@q32/core 0.1.20 → 0.1.22

package/dist/jobs.js

@@ -1,6 +1,157 @@
 import { parseJsonColumn, stringifyJsonColumn } from "./d1.js";
 import { createId } from "./ids.js";
 import { isFutureIso, nowIso } from "./time.js";
+export class JobDeadline {
+    budgetMs;
+    startedAt = Date.now();
+    constructor(budgetMs = 50_000) {
+        this.budgetMs = budgetMs;
+    }
+    shouldYield() {
+        return Date.now() - this.startedAt >= this.budgetMs;
+    }
+}
+export class DurableJobDispatcher {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run(jobId) {
+        const job = await this.options.jobs.claim(jobId);
+        if (!job)
+            return { kind: "done", result: null };
+        const handler = this.options.handlers[job.jobType];
+        if (!handler) {
+            await this.options.jobs.fail(job.jobId, `No handler registered for job type: ${job.jobType}`);
+            throw new Error(`No handler registered for job type: ${job.jobType}`);
+        }
+        const events = new DurableJobEvents(job, this.options.events);
+        await events.info({ eventName: "job.started", status: "started", message: "Job started." });
+        try {
+            if (await this.shouldStop(job.jobId)) {
+                await this.options.jobs.stop(job.jobId);
+                await events.warn({ eventName: "job.stopped", status: "skipped", message: "Job stopped before handler ran." });
+                return { kind: "stopped", result: null };
+            }
+            const output = await handler({
+                job,
+                jobs: this.options.jobs,
+                services: this.options.services,
+                events,
+                shouldStop: () => this.shouldStop(job.jobId),
+            });
+            const normalized = normalizeJobResult(output);
+            if (normalized.kind === "requeue") {
+                await this.options.jobs.requeue(job.jobId, {
+                    payload: normalized.payload,
+                    result: normalized.result ?? null,
+                    availableAt: normalized.availableAt ?? null,
+                });
+                await events.info({ eventName: "job.requeued", status: "started", message: "Job requeued." });
+            }
+            else if (normalized.kind === "stopped") {
+                await this.options.jobs.stop(job.jobId, normalized.result ?? null);
+                await events.warn({ eventName: "job.stopped", status: "skipped", message: "Job stopped." });
+            }
+            else {
+                await this.options.jobs.succeed(job.jobId, normalized.result ?? null);
+                await events.info({ eventName: "job.succeeded", status: "ok", message: "Job succeeded." });
+            }
+            return normalized;
+        }
+        catch (error) {
+            const latest = await this.options.jobs.get(job.jobId);
+            if (latest && latest.attemptCount < latest.maxAttempts) {
+                await this.options.jobs.requeue(job.jobId, {
+                    result: { retryError: errorMessage(error) },
+                    availableAt: this.options.retryDelay?.({ job: latest, error }) ?? null,
+                    lastError: errorMessage(error),
+                });
+                await events.warn({ eventName: "job.retrying", status: "warning", message: "Job failed and will retry.", error });
+                return { kind: "requeue", result: null };
+            }
+            await this.options.jobs.fail(job.jobId, error);
+            await events.error({ eventName: "job.failed", status: "error", message: "Job failed.", error });
+            throw error;
+        }
+    }
+    async shouldStop(jobId) {
+        const latest = await this.options.jobs.get(jobId);
+        return latest?.status === "stopping" || latest?.status === "stopped";
+    }
+}
+export async function runParentJobOrchestration(context, input) {
+    const existing = await context.jobs.listChildren(context.job.jobId);
+    const failureMode = input.failureMode ?? "fail_fast";
+    const queuedSiblingPolicy = input.queuedSiblingPolicy ?? "fail";
+    if (existing.length === 0) {
+        if (input.children.length === 0) {
+            return {
+                kind: "done",
+                result: {
+                    stage: "complete",
+                    failureMode,
+                    queuedSiblingPolicy,
+                    childJobIds: [],
+                    summary: emptyChildrenSummary(context.job.jobId),
+                },
+            };
+        }
+        const children = [];
+        for (const child of input.children) {
+            const queued = await context.jobs.enqueue({
+                ...child,
+                parentJobId: child.parentJobId ?? context.job.jobId,
+            });
+            children.push(queued);
+            await input.onChildQueued?.(queued);
+        }
+        await context.events.info({
+            eventName: "job.children_queued",
+            status: "started",
+            message: "Child jobs queued.",
+            metrics: { queued: input.children.length },
+        });
+        return requeueParent(context.job.payload, children, summarizeJobs(context.job.jobId, children), input);
+    }
+    const summary = await context.jobs.summarizeChildren(context.job.jobId);
+    if (failureMode === "fail_fast" && summary.failed > 0) {
+        const failedReason = (await context.jobs.listChildren(context.job.jobId)).find((child) => child.status === "failed" && child.lastError)
+            ?.lastError ?? `Child job failed for parent ${context.job.jobId}.`;
+        if (queuedSiblingPolicy === "stop") {
+            await context.jobs.markQueuedChildrenTerminal(context.job.jobId, "stopped", failedReason);
+        }
+        else {
+            await context.jobs.markQueuedChildrenTerminal(context.job.jobId, "failed", failedReason);
+        }
+        await context.jobs.requestStopActiveChildren(context.job.jobId);
+        await context.events.warn({
+            eventName: "job.children_failed",
+            status: "warning",
+            message: "One or more child jobs failed.",
+            metrics: summary,
+        });
+        const updated = await context.jobs.summarizeChildren(context.job.jobId);
+        if (!updated.allTerminal) {
+            const children = await context.jobs.listChildren(context.job.jobId);
+            return requeueParent(context.job.payload, children, updated, input);
+        }
+        throw new Error(failedReason);
+    }
+    const children = await context.jobs.listChildren(context.job.jobId);
+    if (!summary.allTerminal)
+        return requeueParent(context.job.payload, children, summary, input);
+    return {
+        kind: "done",
+        result: {
+            stage: "complete",
+            failureMode,
+            queuedSiblingPolicy,
+            childJobIds: children.map((child) => child.jobId),
+            summary,
+        },
+    };
+}
 export class D1JobStore {
     db;
     options;
@@ -14,51 +165,49 @@ export class D1JobStore {
     async enqueue(input) {
         const jobId = createId(this.options.idPrefix ?? "job");
         const now = nowIso();
+        const enqueuePolicy = input.enqueuePolicy ?? "enqueue";
+        if (enqueuePolicy === "dedupe_active" && input.lockKey) {
+            const existing = await this.getActiveForLockKey(input.lockKey);
+            if (existing)
+                return existing;
+        }
         await this.db
             .prepare(`INSERT INTO ${this.tableName} (
-          job_id, job_type, status, payload_json, result_json, lock_key,
+          job_id, job_type, status, org_id, site_id, payload_json, result_json, metadata_json,
+          parent_job_id, lock_key, concurrency_key, concurrency_limit, enqueue_policy,
           attempt_count, max_attempts, available_at, created_at, updated_at
-        ) VALUES (?, ?, 'queued', ?, NULL, ?, 0, ?, ?, ?, ?)`)
-            .bind(jobId, input.jobType, stringifyJsonColumn(input.payload ?? {}), input.lockKey ?? null, Math.max(1, Math.floor(input.maxAttempts ?? 3)), input.availableAt ?? null, now, now)
+        ) VALUES (?, ?, 'queued', ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?)`)
+            .bind(jobId, input.jobType, input.orgId ?? null, input.siteId ?? null, stringifyJsonColumn(input.payload ?? {}), stringifyJsonColumn(input.metadata ?? {}), input.parentJobId ?? null, input.lockKey ?? null, input.concurrencyKey ?? null, normalizeConcurrencyLimit(input.concurrencyLimit), enqueuePolicy, Math.max(1, Math.floor(input.maxAttempts ?? this.options.defaultMaxAttempts ?? 3)), input.availableAt ?? null, now, now)
             .run();
         const job = await this.get(jobId);
         if (!job)
             throw new Error(`Failed to load enqueued job: ${jobId}`);
+        await this.emitStatusEvent(job, "queued", "Job queued.");
         return job;
     }
     async get(jobId) {
         const row = await this.db
-            .prepare(`SELECT
-          job_id AS jobId,
-          job_type AS jobType,
-          status,
-          payload_json AS payloadJson,
-          result_json AS resultJson,
-          lock_key AS lockKey,
-          attempt_count AS attemptCount,
-          max_attempts AS maxAttempts,
-          available_at AS availableAt,
-          started_at AS startedAt,
-          completed_at AS completedAt,
-          last_error AS lastError,
-          created_at AS createdAt,
-          updated_at AS updatedAt
-        FROM ${this.tableName}
-        WHERE job_id = ?
-        LIMIT 1`)
+            .prepare(`${this.selectSql()} WHERE job_id = ? LIMIT 1`)
             .bind(jobId)
             .first();
         return row ? rowToJob(row) : null;
     }
+    async getJob(jobId) {
+        return this.get(jobId);
+    }
+    async enqueueChild(parentJobId, input) {
+        return this.enqueue({ ...input, parentJobId });
+    }
+    async enqueueChildren(parentJobId, inputs) {
+        const children = [];
+        for (const input of inputs)
+            children.push(await this.enqueueChild(parentJobId, input));
+        return children;
+    }
     async listQueued(limit = 25) {
         const now = nowIso();
         const rows = await this.db
-            .prepare(`SELECT
-          job_id AS jobId, job_type AS jobType, status, payload_json AS payloadJson,
-          result_json AS resultJson, lock_key AS lockKey, attempt_count AS attemptCount,
-          max_attempts AS maxAttempts, available_at AS availableAt, started_at AS startedAt,
-          completed_at AS completedAt, last_error AS lastError, created_at AS createdAt, updated_at AS updatedAt
-        FROM ${this.tableName}
+            .prepare(`${this.selectSql()}
         WHERE status = 'queued' AND (available_at IS NULL OR available_at <= ?)
         ORDER BY created_at ASC
         LIMIT ?`)
@@ -66,60 +215,75 @@ export class D1JobStore {
             .all();
         return (rows.results ?? []).map(rowToJob);
     }
+    async getLatestForSite(input) {
+        const row = await this.db
+            .prepare(`${this.selectSql()}
+         WHERE site_id = ?
+           ${input.jobType ? "AND job_type = ?" : ""}
+         ORDER BY created_at DESC
+         LIMIT 1`)
+            .bind(...[input.siteId, ...(input.jobType ? [input.jobType] : [])])
+            .first();
+        return row ? rowToJob(row) : null;
+    }
+    async getActiveForSite(input) {
+        const row = await this.db
+            .prepare(`${this.selectSql()}
+         WHERE site_id = ?
+           AND status IN ('queued', 'running', 'stopping')
+           ${input.jobType ? "AND job_type = ?" : ""}
+         ORDER BY created_at DESC
+         LIMIT 1`)
+            .bind(...[input.siteId, ...(input.jobType ? [input.jobType] : [])])
+            .first();
+        return row ? rowToJob(row) : null;
+    }
+    async getLatestForSiteByPayload(input) {
+        return this.getForSiteByPayload({ ...input, activeOnly: false });
+    }
+    async getActiveForSiteByPayload(input) {
+        return this.getForSiteByPayload({ ...input, activeOnly: true });
+    }
     async claim(jobId) {
         const current = await this.get(jobId);
-        if (!current || current.status === "succeeded" || current.status === "failed")
+        if (!current || isTerminalJobStatus(current.status) || current.status === "stopping")
             return null;
+        if (current.status === "running") {
+            if (!isStaleRunningJob(current, this.options.staleRunningAfterSeconds))
+                return null;
+            await this.markStaleRunningQueued(jobId);
+        }
         if (current.status === "queued" && isFutureIso(current.availableAt))
             return null;
         if (current.attemptCount >= current.maxAttempts) {
             await this.fail(jobId, "Job exhausted all attempts.");
             return null;
         }
+        if (current.concurrencyKey && current.status === "queued") {
+            const limit = current.concurrencyLimit ?? 1;
+            const running = await this.countRunningForConcurrencyKey(current.concurrencyKey);
+            if (running >= limit)
+                return null;
+        }
         const now = nowIso();
         const result = await this.db
             .prepare(`UPDATE ${this.tableName}
          SET status = 'running',
              attempt_count = attempt_count + 1,
-             started_at = COALESCE(started_at, ?),
+             started_at = ?,
              updated_at = ?,
              last_error = NULL
          WHERE job_id = ?
-           AND status IN ('queued', 'running')
+           AND status = 'queued'
            AND (available_at IS NULL OR available_at <= ?)`)
             .bind(now, now, jobId, now)
             .run();
         if (!Number(result.meta.changes ?? 0))
             return null;
-        return this.get(jobId);
-    }
-    async succeed(jobId, result = null) {
-        const now = nowIso();
-        await this.db
-            .prepare(`UPDATE ${this.tableName}
-         SET status = 'succeeded', result_json = ?, completed_at = ?, updated_at = ?
-         WHERE job_id = ?`)
-            .bind(stringifyJsonColumn(result), now, now, jobId)
-            .run();
-    }
-    async requeue(jobId, result = null, availableAt = null) {
-        const now = nowIso();
-        await this.db
-            .prepare(`UPDATE ${this.tableName}
-         SET status = 'queued', result_json = ?, available_at = ?, updated_at = ?
-         WHERE job_id = ?`)
-            .bind(stringifyJsonColumn(result), availableAt, now, jobId)
-            .run();
-    }
-    async fail(jobId, error) {
-        const now = nowIso();
-        const message = error instanceof Error ? error.message : String(error);
-        await this.db
-            .prepare(`UPDATE ${this.tableName}
-         SET status = 'failed', last_error = ?, completed_at = ?, updated_at = ?
-         WHERE job_id = ?`)
-            .bind(message, now, now, jobId)
-            .run();
+        const job = await this.get(jobId);
+        if (job)
+            await this.emitStatusEvent(job, "running", "Job started.");
+        return job;
     }
     async run(jobId, handler) {
         const job = await this.claim(jobId);
@@ -129,7 +293,14 @@ export class D1JobStore {
             const output = await handler(job);
             const normalized = normalizeJobResult(output);
             if (normalized.kind === "requeue") {
-                await this.requeue(jobId, normalized.result ?? null, normalized.availableAt ?? null);
+                await this.requeue(jobId, {
+                    payload: normalized.payload,
+                    result: normalized.result ?? null,
+                    availableAt: normalized.availableAt ?? null,
+                });
+            }
+            else if (normalized.kind === "stopped") {
+                await this.stop(jobId, normalized.result ?? null);
             }
             else {
                 await this.succeed(jobId, normalized.result ?? null);
@@ -139,13 +310,699 @@ export class D1JobStore {
         catch (error) {
             const latest = await this.get(jobId);
             if (latest && latest.attemptCount < latest.maxAttempts) {
-                await this.requeue(jobId, { retryError: error instanceof Error ? error.message : String(error) });
+                await this.requeue(jobId, { result: { retryError: errorMessage(error) }, lastError: errorMessage(error) });
                 return { kind: "requeue", result: null };
             }
             await this.fail(jobId, error);
             throw error;
         }
     }
+    async succeed(jobId, result = null) {
+        await this.complete(jobId, "succeeded", result, null);
+    }
+    async stop(jobId, result = null) {
+        await this.complete(jobId, "stopped", result, null);
+    }
+    async requeue(jobId, inputOrResult = {}, legacyAvailableAt) {
+        const input = isRequeueInput(inputOrResult)
+            ? inputOrResult
+            : { result: inputOrResult, availableAt: legacyAvailableAt ?? null };
+        const now = nowIso();
+        const payloadSql = input.payload === undefined ? "" : "payload_json = ?,";
+        const bindings = input.payload === undefined ? [] : [stringifyJsonColumn(input.payload)];
+        await this.db
+            .prepare(`UPDATE ${this.tableName}
+         SET status = 'queued',
+             ${payloadSql}
+             result_json = ?,
+             available_at = ?,
+             last_error = ?,
+             updated_at = ?
+         WHERE job_id = ?`)
+            .bind(...bindings, stringifyJsonColumn(input.result ?? null), input.availableAt ?? null, input.lastError ?? null, now, jobId)
+            .run();
+        const job = await this.get(jobId);
+        if (job) {
+            await this.emitStatusEvent(job, "queued", "Job requeued.", {
+                availableAt: input.availableAt ?? null,
+                ...(input.lastError ? { lastError: input.lastError } : {}),
+            });
+        }
+    }
+    async fail(jobId, error) {
+        await this.complete(jobId, "failed", null, errorMessage(error));
+    }
+    async requestStop(jobId) {
+        const now = nowIso();
+        const queuedStopStatus = this.options.queuedStopStatus ?? "stopped";
+        await this.db
+            .prepare(`UPDATE ${this.tableName}
+         SET status = CASE WHEN status = 'queued' THEN ? ELSE 'stopping' END,
+             completed_at = CASE WHEN status = 'queued' AND ? = 'stopped' THEN ? ELSE completed_at END,
+             updated_at = ?
+         WHERE job_id = ? AND status IN ('queued', 'running')`)
+            .bind(queuedStopStatus, queuedStopStatus, now, now, jobId)
+            .run();
+        const job = await this.get(jobId);
+        if (job)
+            await this.emitStatusEvent(job, job.status, "Job stop requested.");
+    }
+    async listChildren(parentJobId) {
+        const rows = await this.db
+            .prepare(`${this.selectSql()} WHERE parent_job_id = ? ORDER BY created_at ASC`)
+            .bind(parentJobId)
+            .all();
+        return (rows.results ?? []).map(rowToJob);
+    }
+    async getJobTree(jobId) {
+        const root = await this.get(jobId);
+        if (!root)
+            return null;
+        const rows = await this.db
+            .prepare(`WITH RECURSIVE tree(job_id, depth) AS (
+           SELECT job_id, 0 FROM ${this.tableName} WHERE job_id = ?
+           UNION ALL
+           SELECT jobs.job_id, tree.depth + 1
+           FROM ${this.tableName} jobs
+           JOIN tree ON jobs.parent_job_id = tree.job_id
+         )
+         SELECT
+           jobs.job_id AS jobId,
+           jobs.job_type AS jobType,
+           jobs.status,
+           jobs.org_id AS orgId,
+           jobs.site_id AS siteId,
+           jobs.payload_json AS payloadJson,
+           jobs.result_json AS resultJson,
+           jobs.metadata_json AS metadataJson,
+           jobs.parent_job_id AS parentJobId,
+           jobs.lock_key AS lockKey,
+           jobs.concurrency_key AS concurrencyKey,
+           jobs.concurrency_limit AS concurrencyLimit,
+           jobs.enqueue_policy AS enqueuePolicy,
+           jobs.attempt_count AS attemptCount,
+           jobs.max_attempts AS maxAttempts,
+           jobs.available_at AS availableAt,
+           jobs.started_at AS startedAt,
+           jobs.completed_at AS completedAt,
+           jobs.last_error AS lastError,
+           jobs.created_at AS createdAt,
+           jobs.updated_at AS updatedAt,
+           tree.depth AS depth
+         FROM ${this.tableName} jobs
+         JOIN tree ON jobs.job_id = tree.job_id
+         WHERE jobs.job_id <> ?
+         ORDER BY tree.depth ASC, jobs.created_at ASC`)
+            .bind(jobId, jobId)
+            .all();
+        const children = (rows.results ?? []).map((row) => ({ ...rowToJob(row), depth: Number(row.depth) }));
+        const allJobs = [root, ...children];
+        return {
+            root,
+            children,
+            summary: summarizeJobs(root.jobId, children),
+            rollupStatus: rollupJobTreeStatus(allJobs),
+            rowStates: [
+                jobEntityState(root, 0),
+                ...children.map((child) => jobEntityState(child, child.depth)),
+            ],
+            activityEvents: await this.listJobActivityEvents(allJobs.map((job) => job.jobId)),
+            latestError: latestJobError(allJobs),
+        };
+    }
+    async summarizeChildren(parentJobId) {
+        return summarizeJobs(parentJobId, await this.listChildren(parentJobId));
+    }
+    async markQueuedChildrenTerminal(parentJobId, status, error) {
+        const now = nowIso();
+        const result = await this.db
+            .prepare(`UPDATE ${this.tableName}
+         SET status = ?, last_error = ?, completed_at = ?, updated_at = ?
+         WHERE parent_job_id = ? AND status = 'queued'`)
+            .bind(status, status === "failed" && error ? errorMessage(error) : null, now, now, parentJobId)
+            .run();
+        const changed = Number(result.meta.changes ?? 0);
+        if (changed > 0 && this.options.onStatusEvent) {
+            for (const child of await this.listChildren(parentJobId)) {
+                if (child.status === status) {
+                    await this.emitStatusEvent(child, status, status === "failed" ? errorMessage(error ?? "Child job failed.") : "Job stopped.", error ? { reason: errorMessage(error) } : null);
+                }
+            }
+        }
+        return changed;
+    }
+    async requestStopActiveChildren(parentJobId) {
+        const now = nowIso();
+        const statuses = this.options.requestStopQueuedChildren ? "'queued', 'running'" : "'running'";
+        const result = await this.db
+            .prepare(`UPDATE ${this.tableName}
+         SET status = 'stopping', updated_at = ?
+         WHERE parent_job_id = ? AND status IN (${statuses})`)
+            .bind(now, parentJobId)
+            .run();
+        const changed = Number(result.meta.changes ?? 0);
+        if (changed > 0 && this.options.onStatusEvent) {
+            for (const child of await this.listChildren(parentJobId)) {
+                if (child.status === "stopping")
+                    await this.emitStatusEvent(child, "stopping", "Job stop requested.");
+            }
+        }
+        return changed;
+    }
+    async failQueuedChildren(input) {
+        return this.markQueuedChildrenTerminal(input.parentJobId, "failed", input.reason ?? "Child job failed.");
+    }
+    async stopQueuedChildren(input) {
+        return this.markQueuedChildrenTerminal(input.parentJobId, "stopped", input.reason ?? "Child job stopped.");
+    }
+    async getActiveForLockKey(lockKey) {
+        const row = await this.db
+            .prepare(`${this.selectSql()} WHERE lock_key = ? AND status IN ('queued', 'running', 'stopping') ORDER BY created_at ASC LIMIT 1`)
+            .bind(lockKey)
+            .first();
+        return row ? rowToJob(row) : null;
+    }
+    async countRunningForConcurrencyKey(concurrencyKey) {
+        const row = await this.db
+            .prepare(`SELECT COUNT(*) AS count
+         FROM ${this.tableName}
+         WHERE concurrency_key = ? AND status IN ('running', 'stopping')`)
+            .bind(concurrencyKey)
+            .first();
+        return Number(row?.count ?? 0);
+    }
+    async getForSiteByPayload(input) {
+        const row = await this.db
+            .prepare(`${this.selectSql()}
+         WHERE site_id = ?
+           ${input.jobType ? "AND job_type = ?" : ""}
+           ${input.activeOnly ? "AND status IN ('queued', 'running', 'stopping')" : ""}
+           AND json_extract(payload_json, ?) = ?
+         ORDER BY created_at DESC
+         LIMIT 1`)
+            .bind(...[
+            input.siteId,
+            ...(input.jobType ? [input.jobType] : []),
+            `$.${input.key}`,
+            input.value,
+        ])
+            .first();
+        return row ? rowToJob(row) : null;
+    }
+    async listJobActivityEvents(jobIds) {
+        if (jobIds.length === 0)
+            return [];
+        const placeholders = jobIds.map(() => "?").join(", ");
+        try {
+            const rows = await this.db
+                .prepare(`SELECT
+             ops_event_id AS opsEventId,
+             job_id AS jobId,
+             level,
+             event_type AS eventType,
+             message,
+             metadata_json AS metadataJson,
+             created_at AS createdAt
+           FROM ${this.options.opsEventsTableName ?? "ops_events"}
+           WHERE job_id IN (${placeholders})
+           ORDER BY created_at ASC
+           LIMIT 200`)
+                .bind(...jobIds)
+                .all();
+            return (rows.results ?? []).map(rowToActivityEvent);
+        }
+        catch {
+            return [];
+        }
+    }
+    async complete(jobId, status, result, lastError) {
+        const now = nowIso();
+        await this.db
+            .prepare(`UPDATE ${this.tableName}
+         SET status = ?, result_json = ?, last_error = ?, completed_at = ?, updated_at = ?
+         WHERE job_id = ?`)
+            .bind(status, stringifyJsonColumn(result), lastError, now, now, jobId)
+            .run();
+        const job = await this.get(jobId);
+        if (job) {
+            await this.emitStatusEvent(job, status, status === "succeeded" ? "Job succeeded." : status === "stopped" ? "Job stopped." : (lastError ?? "Job failed."));
+        }
+    }
+    async markStaleRunningQueued(jobId) {
+        const now = nowIso();
+        await this.db
+            .prepare(`UPDATE ${this.tableName}
+         SET status = 'queued',
+             available_at = ?,
+             last_error = ?,
+             updated_at = ?
+         WHERE job_id = ? AND status = 'running'`)
+            .bind(now, "Job reclaimed after stale running lease.", now, jobId)
+            .run();
+        const job = await this.get(jobId);
+        if (job) {
+            await this.emitStatusEvent(job, "queued", "Stale running job requeued.", {
+                previousStatus: "running",
+            });
+        }
+    }
+    async emitStatusEvent(job, status, message, metadata, error) {
+        await this.options.onStatusEvent?.({ job, status, message, metadata: metadata ?? null, error });
+    }
+    selectSql() {
+        return `SELECT
+      job_id AS jobId,
+      job_type AS jobType,
+      status,
+      org_id AS orgId,
+      site_id AS siteId,
+      payload_json AS payloadJson,
+      result_json AS resultJson,
+      metadata_json AS metadataJson,
+      parent_job_id AS parentJobId,
+      lock_key AS lockKey,
+      concurrency_key AS concurrencyKey,
+      concurrency_limit AS concurrencyLimit,
+      enqueue_policy AS enqueuePolicy,
+      attempt_count AS attemptCount,
+      max_attempts AS maxAttempts,
+      available_at AS availableAt,
+      started_at AS startedAt,
+      completed_at AS completedAt,
+      last_error AS lastError,
+      created_at AS createdAt,
+      updated_at AS updatedAt
+    FROM ${this.tableName}`;
+    }
+}
+const DEFAULT_POSTGRES_JOB_COLUMNS = {
+    jobId: "job_id",
+    orgId: "org_id",
+    siteId: "site_id",
+    queueName: "queue_name",
+    jobType: "job_type",
+    status: "status",
+    payloadJson: "payload_json",
+    resultJson: "result_json",
+    metadataJson: "metadata_json",
+    parentJobId: "parent_job_id",
+    lockKey: "lock_key",
+    concurrencyKey: "concurrency_key",
+    concurrencyLimit: "concurrency_limit",
+    enqueuePolicy: "enqueue_policy",
+    attemptCount: "attempt_count",
+    maxAttempts: "max_attempts",
+    availableAt: "available_at",
+    startedAt: "started_at",
+    completedAt: "completed_at",
+    lastError: "last_error",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+};
+export class PostgresJobStore {
+    sql;
+    options;
+    tableName;
+    columns;
+    constructor(sql, options = {}) {
+        this.sql = sql;
+        this.options = options;
+        this.tableName = quotePgIdent(options.tableName ?? "jobs");
+        this.columns = { ...DEFAULT_POSTGRES_JOB_COLUMNS, ...(options.columns ?? {}) };
+    }
+    async enqueue(input) {
+        if (input.enqueuePolicy === "dedupe_active" && input.lockKey) {
+            const existing = await this.getActiveForLockKey(input.lockKey);
+            if (existing)
+                return existing;
+        }
+        const jobId = createId(this.options.idPrefix ?? "job");
+        const queueName = stringValue(input.metadata?.queueName) ?? queueNameFromPayload(input.payload) ?? this.options.queueName ?? null;
+        const insertColumnKeys = [
+            "jobId",
+            "orgId",
+            "siteId",
+            "queueName",
+            "jobType",
+            "status",
+            "payloadJson",
+            "resultJson",
+            "metadataJson",
+            "parentJobId",
+            "lockKey",
+            "concurrencyKey",
+            "concurrencyLimit",
+            "enqueuePolicy",
+            "maxAttempts",
+            "availableAt",
+        ];
+        const insertColumns = insertColumnKeys.filter((key) => this.columns[key] !== null);
+        const insertValues = {
+            jobId,
+            orgId: input.orgId ?? null,
+            siteId: input.siteId ?? null,
+            queueName,
+            jobType: input.jobType,
+            status: this.toDbStatus("queued"),
+            payloadJson: jsonParam(input.payload ?? {}),
+            resultJson: jsonParam(this.options.initialResult ?? null),
+            metadataJson: jsonParam(input.metadata ?? {}),
+            parentJobId: input.parentJobId ?? null,
+            lockKey: input.lockKey ?? null,
+            concurrencyKey: input.concurrencyKey ?? null,
+            concurrencyLimit: normalizeConcurrencyLimit(input.concurrencyLimit),
+            enqueuePolicy: input.enqueuePolicy ?? "enqueue",
+            attemptCount: 0,
+            maxAttempts: Math.max(1, Math.floor(input.maxAttempts ?? this.options.defaultMaxAttempts ?? 3)),
+            availableAt: input.availableAt ?? null,
+            startedAt: null,
+            completedAt: null,
+            lastError: null,
+            createdAt: null,
+            updatedAt: null,
+        };
+        const values = insertColumns.map((key) => insertValues[key]);
+        await this.sql.unsafe(`INSERT INTO ${this.tableName} (
+        ${insertColumns.map((key) => this.col(key)).join(", ")}
+      ) VALUES (${insertColumns.map((key, index) => this.insertPlaceholder(key, index + 1)).join(", ")})`, values);
+        const job = await this.get(jobId);
+        if (!job)
+            throw new Error(`Failed to load enqueued job: ${jobId}`);
+        return job;
+    }
+    async get(jobId) {
+        const rows = await this.sql.unsafe(`${this.selectSql()} WHERE ${this.col("jobId")} = $1 LIMIT 1`, [jobId]);
+        return rows[0] ? this.rowToJob(rows[0]) : null;
+    }
+    async claim(jobId) {
+        const queueClause = this.options.queueName ? `AND ${this.col("queueName")} = $2` : "";
+        const values = this.options.queueName ? [jobId, this.options.queueName] : [jobId];
+        const rows = await this.sql.unsafe(`UPDATE ${this.tableName}
+       SET ${this.col("status")} = '${this.toDbStatus("running")}',
+           ${this.col("attemptCount")} = ${this.col("attemptCount")} + 1,
+           ${this.setSql("startedAt", "now(),")}
+           ${this.col("updatedAt")} = now(),
+           ${this.setSql("lastError", "NULL")}
+       WHERE ${this.col("jobId")} = $1
+         ${queueClause}
+         AND ${this.col("status")} = '${this.toDbStatus("queued")}'
+         AND ${this.col("availableAt")} <= now()
+         AND (
+           ${this.nullableColSql("concurrencyKey", "NULL")} IS NULL
+           OR (
+             SELECT COUNT(*)
+             FROM ${this.tableName} active
+             WHERE active.${this.colRaw("concurrencyKey")} = ${this.tableName}.${this.colRaw("concurrencyKey")}
+               AND active.${this.colRaw("status")} IN ('${this.toDbStatus("running")}', '${this.toDbStatus("stopping")}')
+               AND active.${this.colRaw("jobId")} <> ${this.tableName}.${this.colRaw("jobId")}
+           ) < COALESCE(${this.nullableColSql("concurrencyLimit", "1")}, 1)
+         )
+       RETURNING ${this.returningSql()}`, values);
+        return rows[0] ? this.rowToJob(rows[0]) : null;
+    }
+    async succeed(jobId, result = null) {
+        await this.complete(jobId, "succeeded", result, null);
+    }
+    async requeue(jobId, input = {}) {
+        const payloadSet = input.payload === undefined ? "" : `${this.col("payloadJson")} = $5::jsonb,`;
+        const values = [
+            jsonParam(input.result ?? null),
+            input.availableAt ?? null,
+            input.lastError ?? null,
+            jobId,
+            ...(input.payload === undefined ? [] : [jsonParam(input.payload)]),
+        ];
+        await this.sql.unsafe(`UPDATE ${this.tableName}
+       SET ${this.col("status")} = '${this.toDbStatus("queued")}',
+           ${payloadSet}
+           ${this.col("resultJson")} = $1::jsonb,
+           ${this.col("availableAt")} = COALESCE($2::timestamptz, now()),
+           ${this.setSql("lastError", "$3,")}
+           ${this.col("updatedAt")} = now()
+       WHERE ${this.col("jobId")} = $4`, values);
+    }
+    async fail(jobId, error) {
+        await this.complete(jobId, "failed", null, errorMessage(error));
+    }
+    async stop(jobId, result = null) {
+        await this.complete(jobId, "stopped", result, null);
+    }
+    async requestStop(jobId) {
+        await this.sql.unsafe(`UPDATE ${this.tableName}
+       SET ${this.col("status")} = CASE
+             WHEN ${this.col("status")} = '${this.toDbStatus("queued")}' THEN '${this.toDbStatus("stopped")}'
+             ELSE '${this.toDbStatus("stopping")}'
+           END,
+           ${this.setSql("completedAt", `CASE
+             WHEN ${this.col("status")} = '${this.toDbStatus("queued")}' THEN now()
+             ELSE ${this.col("completedAt")}
+           END,`)}
+           ${this.col("updatedAt")} = now()
+       WHERE ${this.col("jobId")} = $1
+         AND ${this.col("status")} IN ('${this.toDbStatus("queued")}', '${this.toDbStatus("running")}')`, [jobId]);
+    }
+    async listChildren(parentJobId) {
+        const rows = await this.sql.unsafe(`${this.selectSql()} WHERE ${this.col("parentJobId")} = $1 ORDER BY ${this.col("createdAt")} ASC`, [parentJobId]);
+        return rows.map((row) => this.rowToJob(row));
+    }
+    async summarizeChildren(parentJobId) {
+        return summarizeJobs(parentJobId, await this.listChildren(parentJobId));
+    }
+    async markQueuedChildrenTerminal(parentJobId, status, error) {
+        const rows = await this.sql.unsafe(`WITH updated AS (
+         UPDATE ${this.tableName}
+         SET ${this.col("status")} = $1,
+             ${this.setSql("lastError", "$2,")}
+             ${this.setSql("completedAt", "now(),")}
+             ${this.col("updatedAt")} = now()
+         WHERE ${this.col("parentJobId")} = $3
+           AND ${this.col("status")} = '${this.toDbStatus("queued")}'
+         RETURNING ${this.col("jobId")}
+       )
+       SELECT COUNT(*)::int AS changed FROM updated`, [this.toDbStatus(status), status === "failed" && error ? errorMessage(error) : null, parentJobId]);
+        return Number(rows[0]?.changed ?? 0);
+    }
+    async requestStopActiveChildren(parentJobId) {
+        const rows = await this.sql.unsafe(`WITH updated AS (
+         UPDATE ${this.tableName}
+         SET ${this.col("status")} = '${this.toDbStatus("stopping")}',
+             ${this.col("updatedAt")} = now()
+         WHERE ${this.col("parentJobId")} = $1
+           AND ${this.col("status")} = '${this.toDbStatus("running")}'
+         RETURNING ${this.col("jobId")}
+       )
+       SELECT COUNT(*)::int AS changed FROM updated`, [parentJobId]);
+        return Number(rows[0]?.changed ?? 0);
+    }
+    async getActiveForLockKey(lockKey) {
+        const rows = await this.sql.unsafe(`${this.selectSql()}
+       WHERE ${this.col("lockKey")} = $1
+         AND ${this.col("status")} IN ('${this.toDbStatus("queued")}', '${this.toDbStatus("running")}', '${this.toDbStatus("stopping")}')
+       ORDER BY ${this.col("createdAt")} DESC
+       LIMIT 1`, [lockKey]);
+        return rows[0] ? this.rowToJob(rows[0]) : null;
+    }
+    async complete(jobId, status, result, lastError) {
+        await this.sql.unsafe(`UPDATE ${this.tableName}
+       SET ${this.col("status")} = $1,
+           ${this.col("resultJson")} = $2::jsonb,
+           ${this.setSql("lastError", "$3,")}
+           ${this.setSql("completedAt", "now(),")}
+           ${this.col("updatedAt")} = now()
+       WHERE ${this.col("jobId")} = $4`, [this.toDbStatus(status), jsonParam(result), lastError, jobId]);
+    }
+    selectSql() {
+        return `SELECT ${this.returningSql()} FROM ${this.tableName}`;
+    }
+    returningSql() {
+        return [
+            ["jobId", "jobId"],
+            ["jobType", "jobType"],
+            ["status", "status"],
+            ["orgId", "orgId"],
+            ["siteId", "siteId"],
+            ["payloadJson", "payloadJson"],
+            ["resultJson", "resultJson"],
+            ["metadataJson", "metadataJson"],
+            ["parentJobId", "parentJobId"],
+            ["lockKey", "lockKey"],
+            ["concurrencyKey", "concurrencyKey"],
+            ["concurrencyLimit", "concurrencyLimit"],
+            ["enqueuePolicy", "enqueuePolicy"],
+            ["attemptCount", "attemptCount"],
+            ["maxAttempts", "maxAttempts"],
+            ["availableAt", "availableAt"],
+            ["startedAt", "startedAt"],
+            ["completedAt", "completedAt"],
+            ["lastError", "lastError"],
+            ["createdAt", "createdAt"],
+            ["updatedAt", "updatedAt"],
+        ]
+            .map(([key, alias]) => `${this.selectExpr(key)} AS "${alias}"`)
+            .join(", ");
+    }
+    rowToJob(row) {
+        return rowToJob({
+            ...row,
+            status: this.fromDbStatus(String(row.status)),
+            payloadJson: jsonText(row.payloadJson) ?? "{}",
+            resultJson: jsonText(row.resultJson),
+            metadataJson: jsonText(row.metadataJson),
+            availableAt: dateText(row.availableAt),
+            startedAt: dateText(row.startedAt),
+            completedAt: dateText(row.completedAt),
+            createdAt: dateText(row.createdAt) ?? "",
+            updatedAt: dateText(row.updatedAt) ?? "",
+        });
+    }
+    toDbStatus(status) {
+        return this.options.statusMap?.[status] ?? status;
+    }
+    fromDbStatus(status) {
+        return this.options.reverseStatusMap?.[status] ?? status;
+    }
+    col(key) {
+        const column = this.columns[key];
+        if (!column)
+            throw new Error(`Postgres job column is not configured: ${String(key)}`);
+        return quotePgIdent(column);
+    }
+    colRaw(key) {
+        const column = this.columns[key];
+        if (!column)
+            throw new Error(`Postgres job column is not configured: ${String(key)}`);
+        return column;
+    }
+    insertPlaceholder(key, index) {
+        if (key === "payloadJson" || key === "resultJson" || key === "metadataJson")
+            return `$${index}::jsonb`;
+        if (key === "availableAt" || key === "startedAt" || key === "completedAt")
+            return `COALESCE($${index}::timestamptz, now())`;
+        return `$${index}`;
+    }
+    nullableColSql(key, fallback) {
+        return this.columns[key] ? this.col(key) : fallback;
+    }
+    selectExpr(key) {
+        if (this.columns[key])
+            return this.col(key);
+        if (key === "metadataJson")
+            return `'{}'::jsonb`;
+        if (key === "resultJson")
+            return `'null'::jsonb`;
+        if (key === "enqueuePolicy")
+            return `'enqueue'`;
+        if (key === "concurrencyLimit" || key === "attemptCount" || key === "maxAttempts")
+            return "0";
+        return "NULL";
+    }
+    setSql(key, assignment) {
+        return this.columns[key] ? `${this.col(key)} = ${assignment}` : "";
+    }
+}
+export class PipelineManager {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    getNextStep(step) {
+        const index = this.options.steps.indexOf(step);
+        if (index === -1)
+            throw new Error(`Unknown pipeline step: ${step}`);
+        return this.options.steps[index + 1] ?? null;
+    }
+    async run(job) {
+        if (job.pipeline !== this.options.pipeline)
+            throw new Error(`Unexpected pipeline: ${job.pipeline}`);
+        const stepIndex = this.options.steps.indexOf(job.step);
+        if (stepIndex === -1)
+            throw new Error(`Unknown pipeline step: ${job.step}`);
+        const defaultNextStep = this.options.steps[stepIndex + 1] ?? null;
+        const result = await this.options.handlers[job.step]({
+            job,
+            stepIndex,
+            isFinalStep: defaultNextStep === null,
+        });
+        const nextState = result?.state ?? job.state;
+        const explicitNextStep = result?.nextStep;
+        const nextStep = explicitNextStep === undefined
+            ? defaultNextStep
+            : explicitNextStep === null
+                ? null
+                : explicitNextStep.step;
+        const enqueuedState = explicitNextStep && explicitNextStep !== null ? (explicitNextStep.state ?? nextState) : nextState;
+        if (nextStep) {
+            const continuationId = this.options.makeContinuationId?.();
+            const nextJob = {
+                pipeline: job.pipeline,
+                runId: job.runId,
+                step: nextStep,
+                ...(continuationId ? { continuationId } : {}),
+                state: enqueuedState,
+            };
+            if (result?.nextStepDelaySeconds === undefined)
+                await this.options.enqueue(nextJob);
+            else
+                await this.options.enqueue(nextJob, { delaySeconds: result.nextStepDelaySeconds });
+        }
+        const completion = result?.completion ??
+            (nextStep === null && defaultNextStep === null
+                ? {
+                    status: "completed",
+                    targetsTotal: 0,
+                    targetsSucceeded: 0,
+                    targetsFailed: 0,
+                    message: `${job.pipeline} pipeline completed`,
+                }
+                : null);
+        return { nextStep, state: enqueuedState, completion };
+    }
+}
+export function createJobPublisher(options) {
+    return {
+        async put(message, sendOptions = {}) {
+            if (options.inline) {
+                if (!options.handleInline)
+                    throw new Error("Inline job publisher requires handleInline.");
+                await options.onQueued?.(message, { ...sendOptions, mode: "inline" });
+                await options.handleInline(message);
+                return;
+            }
+            if (!options.queue)
+                throw new Error("Job queue is not configured.");
+            await options.onQueued?.(message, { ...sendOptions, mode: "queue" });
+            await options.queue.send(message, sendOptions);
+        },
+    };
+}
+export async function enqueueJobOperation(jobs, input) {
+    const keys = jobOperationKeys(input);
+    return jobs.enqueue({
+        jobType: input.jobType,
+        orgId: input.orgId ?? null,
+        siteId: input.siteId ?? null,
+        parentJobId: input.parentJobId ?? null,
+        payload: jobOperationPayload(input),
+        lockKey: keys.lockKey,
+        concurrencyKey: keys.concurrencyKey,
+        concurrencyLimit: keys.concurrencyLimit,
+        enqueuePolicy: input.dedupeActive === false ? "enqueue" : "dedupe_active",
+        maxAttempts: input.maxAttempts ?? undefined,
+        availableAt: input.availableAt ?? null,
+    });
+}
+export function jobOperationKeys(input) {
+    const scope = keyPart(input.siteId ? `site:${input.siteId}` : "global");
+    const operation = keyPart(input.operationKey);
+    const entityKey = input.entity ? jobOperationEntityKey(input.entity) : null;
+    const concurrencyScope = keyPart(input.concurrencyScope ?? input.operationKey);
+    return {
+        lockKey: input.dedupeActive === false
+            ? null
+            : ["jobop", scope, operation, entityKey ? keyPart(entityKey) : "root"].join(":"),
+        concurrencyKey: ["jobop", scope, concurrencyScope].join(":"),
+        concurrencyLimit: normalizeOperationConcurrencyLimit(input.concurrencyLimit),
+    };
 }
 export const D1_JOBS_SCHEMA = `
 CREATE TABLE IF NOT EXISTS jobs (
@@ -154,7 +1011,14 @@ CREATE TABLE IF NOT EXISTS jobs (
   status TEXT NOT NULL,
   payload_json TEXT NOT NULL DEFAULT '{}',
   result_json TEXT,
+  org_id TEXT,
+  site_id TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  parent_job_id TEXT,
   lock_key TEXT,
+  concurrency_key TEXT,
+  concurrency_limit INTEGER,
+  enqueue_policy TEXT NOT NULL DEFAULT 'enqueue',
   attempt_count INTEGER NOT NULL DEFAULT 0,
   max_attempts INTEGER NOT NULL DEFAULT 3,
   available_at TEXT,
@@ -166,8 +1030,13 @@ CREATE TABLE IF NOT EXISTS jobs (
 );
 CREATE INDEX IF NOT EXISTS jobs_status_available_idx ON jobs(status, available_at, created_at);
 CREATE INDEX IF NOT EXISTS jobs_type_status_idx ON jobs(job_type, status, created_at);
+CREATE INDEX IF NOT EXISTS jobs_org_status_idx ON jobs(org_id, status, created_at);
+CREATE INDEX IF NOT EXISTS jobs_site_status_idx ON jobs(site_id, status, created_at);
+CREATE INDEX IF NOT EXISTS jobs_parent_status_idx ON jobs(parent_job_id, status, created_at);
+CREATE INDEX IF NOT EXISTS jobs_concurrency_active_idx ON jobs(concurrency_key, status)
+  WHERE concurrency_key IS NOT NULL AND status IN ('running', 'stopping');
 CREATE UNIQUE INDEX IF NOT EXISTS jobs_active_lock_key_idx ON jobs(lock_key)
-  WHERE lock_key IS NOT NULL AND status IN ('queued', 'running');
+  WHERE lock_key IS NOT NULL AND status IN ('queued', 'running', 'stopping');
 `;
 function rowToJob(row) {
     return {
@@ -176,7 +1045,14 @@ function rowToJob(row) {
         status: row.status,
         payload: parseJsonColumn(row.payloadJson, {}),
         result: parseJsonColumn(row.resultJson, null),
+        orgId: row.orgId ?? null,
+        siteId: row.siteId ?? null,
+        parentJobId: row.parentJobId ?? null,
         lockKey: row.lockKey,
+        concurrencyKey: row.concurrencyKey ?? null,
+        concurrencyLimit: row.concurrencyLimit === undefined || row.concurrencyLimit === null ? null : Number(row.concurrencyLimit),
+        enqueuePolicy: row.enqueuePolicy ?? "enqueue",
+        metadata: parseJsonColumn(row.metadataJson, {}),
         attemptCount: Number(row.attemptCount),
         maxAttempts: Number(row.maxAttempts),
         availableAt: row.availableAt,
@@ -192,4 +1068,200 @@ function normalizeJobResult(output) {
         return output;
     return { kind: "done", result: (output ?? null) };
 }
+function quotePgIdent(value) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value))
+        throw new Error(`Invalid Postgres identifier: ${value}`);
+    return `"${value}"`;
+}
+function jsonText(value) {
+    if (value === null || value === undefined)
+        return null;
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function jsonParam(value) {
+    return JSON.stringify(value ?? null);
+}
+function queueNameFromPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return stringValue(value.queueName);
+}
+function dateText(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (typeof value === "string")
+        return value;
+    return String(value);
+}
+function rowToActivityEvent(row) {
+    const level = row.level === "warn" || row.level === "error" ? row.level : "info";
+    return {
+        opsEventId: row.opsEventId,
+        jobId: row.jobId,
+        level,
+        eventType: row.eventType,
+        message: row.message,
+        metadata: parseJsonColumn(row.metadataJson, null),
+        createdAt: row.createdAt,
+    };
+}
+function summarizeJobs(parentJobId, jobs) {
+    const summary = {
+        parentJobId,
+        total: jobs.length,
+        queued: 0,
+        running: 0,
+        stopping: 0,
+        succeeded: 0,
+        failed: 0,
+        stopped: 0,
+        active: 0,
+        terminal: 0,
+        allTerminal: jobs.length > 0,
+    };
+    for (const job of jobs) {
+        summary[job.status] += 1;
+        if (isTerminalJobStatus(job.status))
+            summary.terminal += 1;
+        else
+            summary.active += 1;
+    }
+    summary.allTerminal = summary.total > 0 && summary.terminal === summary.total;
+    return summary;
+}
+function rollupJobTreeStatus(jobs) {
+    if (jobs.some((job) => job.status === "failed"))
+        return "failed";
+    if (jobs.some((job) => job.status === "stopped"))
+        return "stopped";
+    if (jobs.some((job) => job.status === "running" || job.status === "stopping"))
+        return "running";
+    if (jobs.some((job) => job.status === "queued"))
+        return "queued";
+    return "succeeded";
+}
+function latestJobError(jobs) {
+    return ([...jobs]
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+        .find((job) => job.lastError && job.lastError.trim().length > 0)?.lastError ?? null);
+}
+function jobEntityState(job, depth) {
+    const payload = isRecord(job.payload) ? job.payload : {};
+    const entityType = stringValue(payload.entityType);
+    const entityId = stringValue(payload.entityId);
+    const entityKey = stringValue(payload.entityKey) ?? (entityType && entityId ? `${entityType}:${entityId}` : job.jobId);
+    return {
+        jobId: job.jobId,
+        jobType: job.jobType,
+        status: job.status,
+        entityKey,
+        entityType,
+        entityId,
+        label: stringValue(payload.entityLabel),
+        lastError: job.lastError,
+        result: job.result,
+        depth,
+    };
+}
+function emptyChildrenSummary(parentJobId) {
+    return summarizeJobs(parentJobId, []);
+}
+function requeueParent(payload, children, summary, input) {
+    const pollSeconds = Math.max(1, Math.floor(input.pollSeconds ?? 10));
+    const now = input.now?.() ?? new Date();
+    return {
+        kind: "requeue",
+        payload,
+        result: {
+            stage: "waiting_children",
+            failureMode: input.failureMode ?? "fail_fast",
+            queuedSiblingPolicy: input.queuedSiblingPolicy ?? "fail",
+            childJobIds: children.map((child) => child.jobId),
+            summary,
+        },
+        availableAt: new Date(now.getTime() + pollSeconds * 1000).toISOString(),
+    };
+}
+function isTerminalJobStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "stopped";
+}
+function normalizeConcurrencyLimit(value) {
+    if (value === null || value === undefined)
+        return null;
+    return Math.max(1, Math.floor(value));
+}
+function jobOperationPayload(input) {
+    return {
+        ...(input.payload ?? {}),
+        operationKey: input.operationKey,
+        ...(input.entity
+            ? {
+                entityType: input.entity.entityType,
+                entityId: input.entity.entityId,
+                entityKey: jobOperationEntityKey(input.entity),
+                ...(input.entity.entityLabel ? { entityLabel: input.entity.entityLabel } : {}),
+            }
+            : {}),
+    };
+}
+function jobOperationEntityKey(entity) {
+    return entity.entityKey?.trim() || `${entity.entityType}:${entity.entityId}`;
+}
+function keyPart(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9:_-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function normalizeOperationConcurrencyLimit(value) {
+    if (!Number.isFinite(value) || !value)
+        return 1;
+    return Math.max(1, Math.floor(value));
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function isRequeueInput(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        ("payload" in value || "result" in value || "availableAt" in value || "lastError" in value));
+}
+function isStaleRunningJob(job, staleRunningAfterSeconds) {
+    if (!staleRunningAfterSeconds || staleRunningAfterSeconds <= 0 || !job.startedAt)
+        return false;
+    const startedAt = Date.parse(job.startedAt);
+    if (!Number.isFinite(startedAt))
+        return false;
+    return Date.now() - startedAt >= staleRunningAfterSeconds * 1000;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class DurableJobEvents {
+    job;
+    sink;
+    constructor(job, sink) {
+        this.job = job;
+        this.sink = sink;
+    }
+    async info(input) {
+        await this.emit({ ...input, severity: "info" });
+    }
+    async warn(input) {
+        await this.emit({ ...input, severity: "warn" });
+    }
+    async error(input) {
+        await this.emit({ ...input, severity: "error" });
+    }
+    async emit(input) {
+        await this.sink?.(this.job, input);
+    }
+}
 //# sourceMappingURL=jobs.js.map