@farm.js/jobs 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,1016 @@
+import { defineIntegration, defineIntegrationAPI, integrationRoute, } from "@farm.js/core";
+import { api } from "@farm.js/core/client";
+import { integrationConfig } from "@farm.js/integration-utils";
+const TRIGGER_CAPABILITIES = {
+    delay: true,
+    schedule: true,
+    debounce: true,
+    tags: true,
+    cancel: true,
+    batchTrigger: true,
+    queue: true,
+    retry: true,
+    ttl: true,
+    concurrencyKey: true,
+    idempotencyKey: true,
+};
+const INNGEST_CAPABILITIES = {
+    delay: false,
+    schedule: false,
+    debounce: false,
+    tags: false,
+    cancel: false,
+    batchTrigger: true,
+    queue: false,
+    retry: false,
+    ttl: false,
+    concurrencyKey: false,
+    idempotencyKey: true,
+};
+class JobsRuntimeError extends Error {
+    status;
+    data;
+    constructor(message, status = 500, data) {
+        super(message);
+        this.name = "JobsRuntimeError";
+        this.status = status;
+        this.data = data;
+    }
+}
+export function task(input) {
+    return {
+        kind: "farm-jobs-task",
+        ...input,
+    };
+}
+export function defineTasks(tasks) {
+    return tasks;
+}
+export function trigger(config) {
+    return {
+        kind: "trigger",
+        config,
+    };
+}
+export function inngest(config) {
+    return {
+        kind: "inngest",
+        config,
+    };
+}
+function normalizeBasePath(input) {
+    const value = (input || "/api/jobs").trim() || "/api/jobs";
+    const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
+    const normalized = withLeadingSlash.replace(/\/+$/g, "");
+    return normalized || "/api/jobs";
+}
+function joinPath(...parts) {
+    const [head, ...tail] = parts.filter(Boolean);
+    if (!head) {
+        return "/";
+    }
+    const base = head.replace(/\/+$/g, "");
+    const suffix = tail
+        .map((part) => part.replace(/^\/+|\/+$/g, ""))
+        .filter(Boolean)
+        .join("/");
+    return suffix ? `${base}/${suffix}` : base;
+}
+function toKebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[_\s]+/g, "-")
+        .replace(/[^a-zA-Z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+}
+function readJsonBody(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "object") {
+        return value;
+    }
+    return undefined;
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function stripReservedKeys(value, keys) {
+    const clone = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (!keys.includes(key)) {
+            clone[key] = entry;
+        }
+    }
+    return clone;
+}
+function isLegacyTriggerBody(value) {
+    const keys = Object.keys(value);
+    return ((hasOwn(value, "input") || hasOwn(value, "options")) &&
+        keys.every((key) => key === "input" || key === "options"));
+}
+function isLegacyScheduleBody(value) {
+    const keys = Object.keys(value);
+    return ((hasOwn(value, "input") ||
+        hasOwn(value, "options") ||
+        hasOwn(value, "at") ||
+        hasOwn(value, "after")) &&
+        keys.every((key) => key === "input" || key === "options" || key === "at" || key === "after"));
+}
+function readInlinePayload(value, reservedKeys) {
+    const payload = stripReservedKeys(value, reservedKeys);
+    return Object.keys(payload).length > 0 ? payload : undefined;
+}
+async function parseRequestBody(request) {
+    try {
+        const body = await request.json();
+        return readJsonBody(body);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeQueue(queue) {
+    if (!queue) {
+        return undefined;
+    }
+    return typeof queue === "string" ? { name: queue } : queue;
+}
+function evaluateComputedValue(input, payload) {
+    if (typeof input === "function") {
+        return input(payload);
+    }
+    return input;
+}
+function dedupeTags(values) {
+    return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+function resolveRetryAttempts(retry) {
+    if (retry === false) {
+        return 1;
+    }
+    return retry?.attempts;
+}
+function normalizeDelayValue(value, fieldName) {
+    if (value == null) {
+        return undefined;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            throw new JobsRuntimeError(`${fieldName} must not be empty.`, 400);
+        }
+        return trimmed;
+    }
+    throw new JobsRuntimeError(`${fieldName} must be a string, number, or Date.`, 400);
+}
+function resolveDebounceOptions(input) {
+    if (!input) {
+        return undefined;
+    }
+    const key = input.key.trim();
+    if (!key) {
+        throw new JobsRuntimeError("debounce.key is required.", 400);
+    }
+    const delay = normalizeDelayValue(input.delay, "debounce.delay");
+    if (delay == null) {
+        throw new JobsRuntimeError("debounce.delay is required.", 400);
+    }
+    return {
+        key,
+        delay,
+    };
+}
+function resolveLaunchOptions(task, payload, options) {
+    const defaults = task.definition.defaults;
+    const resolvedTags = dedupeTags([...(defaults?.tags || []), ...(options?.tags || [])]);
+    return {
+        queue: normalizeQueue(defaults?.queue),
+        retryAttempts: resolveRetryAttempts(defaults?.retry),
+        ttl: defaults?.ttl,
+        concurrencyKey: evaluateComputedValue(defaults?.concurrencyKey, payload),
+        idempotencyKey: options?.idempotencyKey ||
+            evaluateComputedValue(defaults?.idempotencyKey, payload),
+        tags: resolvedTags.length > 0 ? resolvedTags : undefined,
+        delay: normalizeDelayValue(options?.delay, "delay"),
+        debounce: resolveDebounceOptions(options?.debounce),
+    };
+}
+function resolveScheduleLaunchOptions(task, payload, body) {
+    const hasAt = body.at != null;
+    const hasAfter = body.after != null;
+    if (hasAt === hasAfter) {
+        throw new JobsRuntimeError("Schedule requests must include exactly one of at or after.", 400);
+    }
+    const scheduledFor = hasAt
+        ? normalizeDelayValue(body.at, "at")
+        : normalizeDelayValue(body.after, "after");
+    if (scheduledFor == null) {
+        throw new JobsRuntimeError("Schedule requests must include exactly one of at or after.", 400);
+    }
+    return {
+        scheduledFor,
+        launch: resolveLaunchOptions(task, payload, {
+            delay: scheduledFor,
+            debounce: body.options?.debounce,
+            idempotencyKey: body.options?.idempotencyKey,
+            tags: body.options?.tags,
+        }),
+    };
+}
+function buildTriggerProviderOptions(options) {
+    const providerOptions = {};
+    if (options.idempotencyKey) {
+        providerOptions.idempotencyKey = options.idempotencyKey;
+    }
+    if (options.concurrencyKey) {
+        providerOptions.concurrencyKey = options.concurrencyKey;
+    }
+    if (options.queue) {
+        providerOptions.queue = options.queue;
+    }
+    if (options.retryAttempts != null) {
+        providerOptions.maxAttempts = options.retryAttempts;
+    }
+    if (options.ttl != null) {
+        providerOptions.ttl = options.ttl;
+    }
+    if (options.tags?.length) {
+        providerOptions.tags = options.tags;
+    }
+    if (options.delay != null) {
+        providerOptions.delay = options.delay;
+    }
+    if (options.debounce) {
+        providerOptions.debounce = options.debounce;
+    }
+    return providerOptions;
+}
+function createMetadata(task, runtime) {
+    const queue = normalizeQueue(task.definition.defaults?.queue) || null;
+    return {
+        key: task.key,
+        id: task.id,
+        remoteId: task.remoteId,
+        description: task.definition.description || null,
+        schedule: task.definition.schedule || null,
+        runtime: runtime.kind,
+        configured: runtime.isConfigured(),
+        capabilities: runtime.capabilities,
+        paths: {
+            trigger: joinPath(task.metadata.paths.trigger),
+            schedule: joinPath(task.metadata.paths.schedule),
+            batchTrigger: joinPath(task.metadata.paths.batchTrigger),
+            status: joinPath(task.metadata.paths.status),
+            cancel: joinPath(task.metadata.paths.cancel),
+        },
+        defaults: {
+            queue,
+            retryAttempts: resolveRetryAttempts(task.definition.defaults?.retry) ?? null,
+            ttl: task.definition.defaults?.ttl ?? null,
+            tags: [...(task.definition.defaults?.tags || [])],
+            hasConcurrencyKey: !!task.definition.defaults?.concurrencyKey,
+            hasIdempotencyKey: !!task.definition.defaults?.idempotencyKey,
+        },
+    };
+}
+function normalizeStatus(status) {
+    const value = (status || "").trim().toUpperCase();
+    switch (value) {
+        case "PENDING_VERSION":
+        case "QUEUED":
+        case "DEQUEUED":
+            return "queued";
+        case "DELAYED":
+            return "delayed";
+        case "EXECUTING":
+        case "RUNNING":
+            return "running";
+        case "WAITING":
+            return "waiting";
+        case "COMPLETED":
+            return "completed";
+        case "FAILED":
+        case "TIMED_OUT":
+        case "CRASHED":
+        case "SYSTEM_FAILURE":
+            return "failed";
+        case "CANCELED":
+        case "CANCELLED":
+            return "canceled";
+        case "EXPIRED":
+            return "expired";
+        default:
+            return "unknown";
+    }
+}
+async function parseJsonResponse(response) {
+    const text = await response.text();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function requestJSON(url, init) {
+    const response = await fetch(url, init);
+    const data = await parseJsonResponse(response);
+    if (!response.ok) {
+        const message = typeof data === "string"
+            ? data
+            : typeof data === "object" && data
+                ? String(data.error ||
+                    data.message ||
+                    response.statusText ||
+                    "Jobs provider request failed.")
+                : response.statusText || "Jobs provider request failed.";
+        throw new JobsRuntimeError(message, response.status, data);
+    }
+    return data;
+}
+function createTriggerRuntime(config) {
+    function resolve() {
+        return {
+            projectRef: config.projectRef ?? process.env.TRIGGER_PROJECT_REF ?? "",
+            apiKey: config.apiKey ?? process.env.TRIGGER_SECRET_KEY ?? "",
+            webhookSecret: config.webhookSecret ?? process.env.TRIGGER_WEBHOOK_SECRET ?? "",
+            apiBaseUrl: (config.apiBaseUrl ?? "https://api.trigger.dev").replace(/\/+$/g, ""),
+        };
+    }
+    return {
+        kind: "trigger",
+        capabilities: TRIGGER_CAPABILITIES,
+        isConfigured() {
+            return resolve().apiKey.length > 0;
+        },
+        resolveRemoteId(taskId) {
+            return taskId;
+        },
+        validateTask() { },
+        async trigger(task, input, options) {
+            const resolved = resolve();
+            if (!resolved.apiKey) {
+                throw new JobsRuntimeError("Trigger runtime requires TRIGGER_SECRET_KEY or trigger.apiKey.", 500);
+            }
+            const payload = {};
+            if (input !== undefined) {
+                payload.payload = input;
+            }
+            payload.context = {
+                source: "farmjs/jobs",
+                task: task.key,
+                projectRef: resolved.projectRef || undefined,
+            };
+            const providerOptions = buildTriggerProviderOptions(options);
+            if (Object.keys(providerOptions).length > 0) {
+                payload.options = providerOptions;
+            }
+            const data = await requestJSON(`${resolved.apiBaseUrl}/api/v1/tasks/${encodeURIComponent(task.remoteId)}/trigger`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${resolved.apiKey}`,
+                    "content-type": "application/json",
+                    accept: "application/json",
+                },
+                body: JSON.stringify(payload),
+            });
+            const handleId = typeof data === "object" && data ? String(data.id || "") : "";
+            if (!handleId) {
+                throw new JobsRuntimeError("Trigger runtime did not return a run id.", 502, data);
+            }
+            return {
+                handleId,
+                queuedAt: new Date().toISOString(),
+            };
+        },
+        async batchTrigger(task, items) {
+            const resolved = resolve();
+            if (!resolved.apiKey) {
+                throw new JobsRuntimeError("Trigger runtime requires TRIGGER_SECRET_KEY or trigger.apiKey.", 500);
+            }
+            const body = {
+                items: items.map((item) => {
+                    const entry = {
+                        options: buildTriggerProviderOptions(item.options),
+                    };
+                    if (item.input !== undefined) {
+                        entry.payload = item.input;
+                    }
+                    if (Object.keys(entry.options).length === 0) {
+                        delete entry.options;
+                    }
+                    return entry;
+                }),
+            };
+            const data = await requestJSON(`${resolved.apiBaseUrl}/api/v1/tasks/${encodeURIComponent(task.remoteId)}/batch`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${resolved.apiKey}`,
+                    "content-type": "application/json",
+                    accept: "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            const runs = typeof data === "object" && data && Array.isArray(data.runs)
+                ? data.runs
+                : [];
+            const queuedAt = new Date().toISOString();
+            const normalizedRuns = runs
+                .map((run, index) => ({
+                index,
+                handleId: typeof run === "string" ? run : "",
+                queuedAt,
+            }))
+                .filter((run) => run.handleId);
+            if (normalizedRuns.length === 0) {
+                throw new JobsRuntimeError("Trigger runtime did not return any batch run ids.", 502, data);
+            }
+            return {
+                batchId: typeof data === "object" &&
+                    data &&
+                    typeof data.batchId === "string"
+                    ? (data.batchId ?? null)
+                    : null,
+                runs: normalizedRuns,
+            };
+        },
+        async status(task, handleId) {
+            const resolved = resolve();
+            if (!resolved.apiKey) {
+                throw new JobsRuntimeError("Trigger runtime requires TRIGGER_SECRET_KEY or trigger.apiKey.", 500);
+            }
+            const data = await requestJSON(`${resolved.apiBaseUrl}/api/v3/runs/${encodeURIComponent(handleId)}`, {
+                method: "GET",
+                headers: {
+                    authorization: `Bearer ${resolved.apiKey}`,
+                    accept: "application/json",
+                },
+            });
+            const run = typeof data === "object" && data ? data : {};
+            return {
+                handleId,
+                providerRunId: typeof run.id === "string" ? run.id : handleId,
+                status: normalizeStatus(typeof run.status === "string" ? run.status : null),
+                providerStatus: typeof run.status === "string" ? run.status : null,
+                queuedAt: typeof run.createdAt === "string" ? run.createdAt : null,
+                startedAt: typeof run.startedAt === "string" ? run.startedAt : null,
+                finishedAt: typeof run.finishedAt === "string" ? run.finishedAt : null,
+                output: run.output ?? null,
+                error: run.error ?? null,
+                tags: Array.isArray(run.tags)
+                    ? run.tags.filter((value) => typeof value === "string")
+                    : [],
+                raw: data,
+            };
+        },
+        async cancel(task, handleId) {
+            const resolved = resolve();
+            if (!resolved.apiKey) {
+                throw new JobsRuntimeError("Trigger runtime requires TRIGGER_SECRET_KEY or trigger.apiKey.", 500);
+            }
+            await requestJSON(`${resolved.apiBaseUrl}/api/v2/runs/${encodeURIComponent(handleId)}/cancel`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${resolved.apiKey}`,
+                    accept: "application/json",
+                },
+            });
+            return {
+                handleId,
+                task: task.key,
+                runtime: "trigger",
+                canceled: true,
+            };
+        },
+    };
+}
+function createInngestRuntime(config) {
+    function resolve() {
+        return {
+            appId: config.appId ?? process.env.INNGEST_APP_ID ?? "",
+            eventKey: config.eventKey ?? process.env.INNGEST_EVENT_KEY ?? "",
+            signingKey: config.signingKey ?? process.env.INNGEST_SIGNING_KEY ?? "",
+            eventBaseUrl: (config.eventBaseUrl ?? "https://inn.gs").replace(/\/+$/g, ""),
+            apiBaseUrl: (config.apiBaseUrl ?? "https://api.inngest.com").replace(/\/+$/g, ""),
+            eventNamePrefix: config.eventNamePrefix ?? "farm",
+        };
+    }
+    return {
+        kind: "inngest",
+        capabilities: INNGEST_CAPABILITIES,
+        isConfigured() {
+            const resolved = resolve();
+            return resolved.eventKey.length > 0 && resolved.signingKey.length > 0;
+        },
+        resolveRemoteId(taskId) {
+            const resolved = resolve();
+            return `${resolved.eventNamePrefix}/${taskId}`;
+        },
+        validateTask(task) {
+            const defaults = task.definition.defaults;
+            if (defaults?.queue ||
+                defaults?.retry !== undefined ||
+                defaults?.ttl !== undefined ||
+                defaults?.concurrencyKey ||
+                (defaults?.tags && defaults.tags.length > 0)) {
+                throw new JobsRuntimeError(`Task "${task.key}" uses Trigger-style launch defaults that are not supported by the Inngest runtime.`, 400);
+            }
+        },
+        async trigger(task, input, options) {
+            const resolved = resolve();
+            if (!resolved.eventKey) {
+                throw new JobsRuntimeError("Inngest runtime requires INNGEST_EVENT_KEY or inngest.eventKey.", 500);
+            }
+            if (options.delay != null || (options.tags && options.tags.length > 0) || options.debounce) {
+                throw new JobsRuntimeError("Inngest runtime does not support delay, debounce, or tags through this integration yet.", 400);
+            }
+            const body = {
+                name: task.remoteId,
+                data: input ?? {},
+            };
+            if (options.idempotencyKey) {
+                body.id = options.idempotencyKey;
+            }
+            const data = await requestJSON(`${resolved.eventBaseUrl}/e/${encodeURIComponent(resolved.eventKey)}`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    accept: "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            const ids = typeof data === "object" && data && Array.isArray(data.ids)
+                ? data.ids
+                : [];
+            const handleId = typeof ids[0] === "string" ? ids[0] : "";
+            if (!handleId) {
+                throw new JobsRuntimeError("Inngest runtime did not return an event id.", 502, data);
+            }
+            return {
+                handleId,
+                queuedAt: new Date().toISOString(),
+            };
+        },
+        async batchTrigger(task, items) {
+            const resolved = resolve();
+            if (!resolved.eventKey) {
+                throw new JobsRuntimeError("Inngest runtime requires INNGEST_EVENT_KEY or inngest.eventKey.", 500);
+            }
+            const body = items.map((item) => {
+                if (item.options.delay != null ||
+                    (item.options.tags && item.options.tags.length > 0) ||
+                    item.options.debounce) {
+                    throw new JobsRuntimeError("Inngest runtime does not support delay, debounce, or tags through this integration yet.", 400);
+                }
+                const event = {
+                    name: task.remoteId,
+                    data: item.input ?? {},
+                };
+                if (item.options.idempotencyKey) {
+                    event.id = item.options.idempotencyKey;
+                }
+                return event;
+            });
+            const data = await requestJSON(`${resolved.eventBaseUrl}/e/${encodeURIComponent(resolved.eventKey)}`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    accept: "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            const ids = typeof data === "object" && data && Array.isArray(data.ids)
+                ? data.ids
+                : [];
+            const queuedAt = new Date().toISOString();
+            const normalizedRuns = ids
+                .map((id, index) => ({
+                index,
+                handleId: typeof id === "string" ? id : "",
+                queuedAt,
+            }))
+                .filter((run) => run.handleId);
+            if (normalizedRuns.length === 0) {
+                throw new JobsRuntimeError("Inngest runtime did not return any event ids.", 502, data);
+            }
+            return {
+                batchId: null,
+                runs: normalizedRuns,
+            };
+        },
+        async status(task, handleId) {
+            const resolved = resolve();
+            if (!resolved.signingKey) {
+                throw new JobsRuntimeError("Inngest runtime requires INNGEST_SIGNING_KEY or inngest.signingKey.", 500);
+            }
+            const data = await requestJSON(`${resolved.apiBaseUrl}/v1/events/${encodeURIComponent(handleId)}/runs`, {
+                method: "GET",
+                headers: {
+                    authorization: `Bearer ${resolved.signingKey}`,
+                    accept: "application/json",
+                },
+            });
+            const records = typeof data === "object" && data && Array.isArray(data.data)
+                ? data.data
+                : [];
+            const run = records.find((entry) => typeof entry === "object" && entry !== null);
+            if (!run) {
+                return {
+                    handleId,
+                    providerRunId: null,
+                    status: "queued",
+                    providerStatus: "EVENT_ACCEPTED",
+                    queuedAt: null,
+                    startedAt: null,
+                    finishedAt: null,
+                    output: null,
+                    error: null,
+                    tags: [],
+                    raw: data,
+                };
+            }
+            return {
+                handleId,
+                providerRunId: typeof run.run_id === "string" ? run.run_id : null,
+                status: normalizeStatus(typeof run.status === "string" ? run.status : null),
+                providerStatus: typeof run.status === "string" ? run.status : null,
+                queuedAt: typeof run.run_started_at === "string" ? run.run_started_at : null,
+                startedAt: typeof run.run_started_at === "string" ? run.run_started_at : null,
+                finishedAt: typeof run.ended_at === "string" ? run.ended_at : null,
+                output: run.output ?? null,
+                error: run.error ?? null,
+                tags: [],
+                raw: data,
+            };
+        },
+        async cancel(task, handleId) {
+            throw new JobsRuntimeError(`Task "${task.key}" is using the Inngest runtime, which does not expose cancel support through this integration yet.`, 501);
+        },
+    };
+}
+function resolveRuntimeDefinition(input) {
+    if ("runtime" in input && input.runtime) {
+        return input.runtime;
+    }
+    if ("trigger" in input) {
+        return trigger(input.trigger);
+    }
+    return inngest(input.inngest);
+}
+function createRuntime(runtime) {
+    if (runtime.kind === "trigger") {
+        return createTriggerRuntime(runtime.config);
+    }
+    return createInngestRuntime(runtime.config);
+}
+function resolveJobsIntegrationConfig(runtime) {
+    if (runtime.kind === "trigger") {
+        const resolved = {
+            kind: "trigger",
+            projectRef: runtime.config.projectRef ?? process.env.TRIGGER_PROJECT_REF ?? "",
+            apiKey: runtime.config.apiKey ?? process.env.TRIGGER_SECRET_KEY ?? "",
+            webhookSecret: runtime.config.webhookSecret ?? process.env.TRIGGER_WEBHOOK_SECRET ?? "",
+            apiBaseUrl: (runtime.config.apiBaseUrl ?? "https://api.trigger.dev").replace(/\/+$/g, ""),
+        };
+        return integrationConfig({
+            label: "Trigger jobs runtime",
+            env: {
+                projectRef: "TRIGGER_PROJECT_REF",
+                apiKey: "TRIGGER_SECRET_KEY",
+                webhookSecret: "TRIGGER_WEBHOOK_SECRET",
+            },
+            input: resolved,
+        });
+    }
+    const resolved = {
+        kind: "inngest",
+        appId: runtime.config.appId ?? process.env.INNGEST_APP_ID ?? "",
+        eventKey: runtime.config.eventKey ?? process.env.INNGEST_EVENT_KEY ?? "",
+        signingKey: runtime.config.signingKey ?? process.env.INNGEST_SIGNING_KEY ?? "",
+        eventBaseUrl: (runtime.config.eventBaseUrl ?? "https://inn.gs").replace(/\/+$/g, ""),
+        apiBaseUrl: (runtime.config.apiBaseUrl ?? "https://api.inngest.com").replace(/\/+$/g, ""),
+        eventNamePrefix: runtime.config.eventNamePrefix ?? "farm",
+    };
+    return integrationConfig({
+        label: "Inngest jobs runtime",
+        env: {
+            appId: "INNGEST_APP_ID",
+            eventKey: "INNGEST_EVENT_KEY",
+            signingKey: "INNGEST_SIGNING_KEY",
+        },
+        input: resolved,
+    });
+}
+function createJobsApi(tasks, tasksPath) {
+    const definition = {
+        tasks: {
+            list: api.get(tasksPath, {
+                responseFormat: "json",
+            }),
+        },
+    };
+    for (const task of tasks) {
+        definition[task.key] = {
+            trigger: api.post(task.metadata.paths.trigger, {
+                responseFormat: "json",
+            }),
+            schedule: api.post(task.metadata.paths.schedule, {
+                responseFormat: "json",
+            }),
+            batchTrigger: api.post(task.metadata.paths.batchTrigger, {
+                responseFormat: "json",
+            }),
+            status: api.get(task.metadata.paths.status, {
+                responseFormat: "json",
+            }),
+            cancel: api.post(task.metadata.paths.cancel, {
+                responseFormat: "json",
+            }),
+        };
+    }
+    return defineIntegrationAPI(definition);
+}
+function normalizeTasks(tasks, basePath, runtime) {
+    const taskList = [];
+    const seenIds = new Set();
+    const seenSegments = new Set();
+    for (const [key, definition] of Object.entries(tasks)) {
+        if (key === "tasks") {
+            throw new Error('Jobs integration reserves the "tasks" key for metadata APIs.');
+        }
+        if (!definition || definition.kind !== "farm-jobs-task") {
+            throw new Error(`Jobs integration entry "${key}" must be created with task(...).`);
+        }
+        const pathSegment = toKebabCase(key);
+        if (!pathSegment) {
+            throw new Error(`Jobs integration entry "${key}" could not be converted into a route path.`);
+        }
+        if (seenSegments.has(pathSegment)) {
+            throw new Error(`Jobs integration path "${pathSegment}" is duplicated.`);
+        }
+        seenSegments.add(pathSegment);
+        const id = definition.id?.trim() || pathSegment;
+        if (seenIds.has(id)) {
+            throw new Error(`Jobs integration id "${id}" is duplicated.`);
+        }
+        seenIds.add(id);
+        const metadata = {
+            key,
+            id,
+            remoteId: runtime.resolveRemoteId(id),
+            description: definition.description || null,
+            schedule: definition.schedule || null,
+            runtime: runtime.kind,
+            configured: runtime.isConfigured(),
+            capabilities: runtime.capabilities,
+            paths: {
+                trigger: joinPath(basePath, pathSegment, "trigger"),
+                schedule: joinPath(basePath, pathSegment, "schedule"),
+                batchTrigger: joinPath(basePath, pathSegment, "batch-trigger"),
+                status: joinPath(basePath, pathSegment, "status"),
+                cancel: joinPath(basePath, pathSegment, "cancel"),
+            },
+            defaults: {
+                queue: normalizeQueue(definition.defaults?.queue) || null,
+                retryAttempts: resolveRetryAttempts(definition.defaults?.retry) ?? null,
+                ttl: definition.defaults?.ttl ?? null,
+                tags: [...(definition.defaults?.tags || [])],
+                hasConcurrencyKey: !!definition.defaults?.concurrencyKey,
+                hasIdempotencyKey: !!definition.defaults?.idempotencyKey,
+            },
+        };
+        const task = {
+            key,
+            id,
+            pathSegment,
+            remoteId: runtime.resolveRemoteId(id),
+            definition,
+            metadata,
+        };
+        runtime.validateTask(task);
+        taskList.push({
+            ...task,
+            metadata: createMetadata(task, runtime),
+        });
+    }
+    return taskList;
+}
+function errorResponse(error) {
+    if (error instanceof JobsRuntimeError) {
+        return Response.json({
+            error: error.message,
+            details: error.data ?? null,
+        }, {
+            status: error.status,
+        });
+    }
+    return Response.json({
+        error: error instanceof Error ? error.message : "Jobs integration request failed.",
+    }, {
+        status: 500,
+    });
+}
+function normalizeTriggerInput(body) {
+    const value = body || {};
+    if (isLegacyTriggerBody(value)) {
+        return {
+            input: value.input,
+            options: value.options,
+        };
+    }
+    return {
+        input: readInlinePayload(value, ["$options"]),
+        options: value.$options,
+    };
+}
+function normalizeScheduleInput(body) {
+    const value = body || {};
+    if (isLegacyScheduleBody(value)) {
+        return {
+            input: value.input,
+            at: value.at,
+            after: value.after,
+            options: value.options,
+        };
+    }
+    const schedule = value.$schedule && typeof value.$schedule === "object"
+        ? value.$schedule
+        : undefined;
+    return {
+        input: readInlinePayload(value, ["$schedule"]),
+        at: schedule?.at,
+        after: schedule?.after,
+        options: schedule,
+    };
+}
+function normalizeBatchTriggerInput(body) {
+    return (body || {});
+}
+function normalizeBatchTriggerItem(item) {
+    return normalizeTriggerInput(item && typeof item === "object" ? item : undefined);
+}
+function normalizeCancelInput(body) {
+    return (body || {});
+}
+export function jobs(input) {
+    const basePath = normalizeBasePath(input.basePath);
+    const tasksPath = joinPath(basePath, "tasks");
+    const runtimeDefinition = resolveRuntimeDefinition(input);
+    const runtime = createRuntime(runtimeDefinition);
+    const normalizedTasks = normalizeTasks(input.tasks, basePath, runtime);
+    return defineIntegration({
+        category: "automation",
+        type: "jobs",
+        instance: {
+            runtime: runtime.kind,
+            configured: runtime.isConfigured(),
+            tasks: normalizedTasks.map((task) => task.metadata),
+        },
+        config: resolveJobsIntegrationConfig(runtimeDefinition),
+        api: createJobsApi(normalizedTasks, tasksPath),
+        log: input.log,
+        routes: [
+            integrationRoute.get(tasksPath, {
+                responseFormat: "json",
+                handler() {
+                    return Response.json(normalizedTasks.map((task) => task.metadata));
+                },
+            }),
+            ...normalizedTasks.flatMap((task) => [
+                integrationRoute.post(task.metadata.paths.trigger, {
+                    responseFormat: "json",
+                    async handler(request) {
+                        try {
+                            const body = normalizeTriggerInput(await parseRequestBody(request));
+                            const launch = resolveLaunchOptions(task, body.input, body.options);
+                            const triggered = await runtime.trigger(task, body.input, launch);
+                            return Response.json({
+                                handleId: triggered.handleId,
+                                task: task.key,
+                                runtime: runtime.kind,
+                                queuedAt: triggered.queuedAt,
+                                providerTaskId: task.remoteId,
+                            });
+                        }
+                        catch (error) {
+                            return errorResponse(error);
+                        }
+                    },
+                }),
+                integrationRoute.post(task.metadata.paths.batchTrigger, {
+                    responseFormat: "json",
+                    async handler(request) {
+                        try {
+                            const body = normalizeBatchTriggerInput(await parseRequestBody(request));
+                            const items = Array.isArray(body.items) ? body.items : [];
+                            if (items.length === 0) {
+                                return Response.json({
+                                    error: "items must contain at least one trigger payload.",
+                                }, {
+                                    status: 400,
+                                });
+                            }
+                            const batchItems = items.map((item) => {
+                                const normalizedItem = normalizeBatchTriggerItem(item);
+                                return {
+                                    input: normalizedItem?.input,
+                                    options: resolveLaunchOptions(task, normalizedItem?.input, normalizedItem?.options),
+                                };
+                            });
+                            const triggered = await runtime.batchTrigger(task, batchItems);
+                            return Response.json({
+                                batchId: triggered.batchId,
+                                task: task.key,
+                                runtime: runtime.kind,
+                                providerTaskId: task.remoteId,
+                                runs: triggered.runs,
+                            });
+                        }
+                        catch (error) {
+                            return errorResponse(error);
+                        }
+                    },
+                }),
+                integrationRoute.post(task.metadata.paths.schedule, {
+                    responseFormat: "json",
+                    async handler(request) {
+                        try {
+                            const body = normalizeScheduleInput(await parseRequestBody(request));
+                            const { scheduledFor, launch } = resolveScheduleLaunchOptions(task, body.input, body);
+                            const triggered = await runtime.trigger(task, body.input, launch);
+                            return Response.json({
+                                handleId: triggered.handleId,
+                                task: task.key,
+                                runtime: runtime.kind,
+                                queuedAt: triggered.queuedAt,
+                                providerTaskId: task.remoteId,
+                                scheduledFor,
+                            });
+                        }
+                        catch (error) {
+                            return errorResponse(error);
+                        }
+                    },
+                }),
+                integrationRoute.get(task.metadata.paths.status, {
+                    responseFormat: "json",
+                    async handler(request) {
+                        try {
+                            const handleId = new URL(request.url).searchParams.get("handleId") || "";
+                            if (!handleId) {
+                                return Response.json({
+                                    error: "handleId is required.",
+                                }, {
+                                    status: 400,
+                                });
+                            }
+                            const status = await runtime.status(task, handleId);
+                            return Response.json({
+                                ...status,
+                                output: status.output ?? null,
+                                task: task.key,
+                                runtime: runtime.kind,
+                            });
+                        }
+                        catch (error) {
+                            return errorResponse(error);
+                        }
+                    },
+                }),
+                integrationRoute.post(task.metadata.paths.cancel, {
+                    responseFormat: "json",
+                    async handler(request) {
+                        try {
+                            const body = normalizeCancelInput(await parseRequestBody(request));
+                            const handleId = typeof body.handleId === "string" ? body.handleId : "";
+                            if (!handleId) {
+                                return Response.json({
+                                    error: "handleId is required.",
+                                }, {
+                                    status: 400,
+                                });
+                            }
+                            const canceled = await runtime.cancel(task, handleId);
+                            return Response.json(canceled);
+                        }
+                        catch (error) {
+                            return errorResponse(error);
+                        }
+                    },
+                }),
+            ]),
+        ],
+    });
+}