bunqueue 2.8.59 → 2.9.0

package/dist/infrastructure/persistence/postgres/recovery.js

@@ -0,0 +1,178 @@
+import { calculateBackoff, MAX_TIMELINE_ENTRIES } from '../../../domain/types/job';
+import { createDlqEntry, getDlqRetryState, recordJobFailureAttempt, } from '../../../domain/types/dlq';
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent } from './context';
+import { applyPostgresFlowFailure, clearPostgresParentFlowFailures, lockPostgresFlowParents, } from './flowFailures';
+import { getPostgresQueuePolicies } from './policies';
+import { enforcePostgresDlqLimit } from './dlqLifecycle';
+import { discardPostgresProtectedCronLease } from './leaseRelease';
+import { lockPostgresDependencyCompletions } from './dependencyPromotion';
+import { partitionPostgresDestructionCandidates } from './dependencyDestruction';
+async function retryExpiredLease(tx, ctx, input) {
+    const { job, now, reason, error } = input;
+    recordJobFailureAttempt(job, reason, error, now);
+    job.runAt = now + calculateBackoff(job);
+    job.startedAt = null;
+    const state = job.runAt > now ? 'delayed' : job.priority > 0 ? 'prioritized' : 'waiting';
+    if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+        job.timeline.push({ state, timestamp: now, attempt: job.attempts + 1 });
+    }
+    await tx `
+    UPDATE bunqueue_jobs
+    SET payload = ${encodePostgresValue(job)}, state = ${state}, attempts = ${job.attempts},
+        run_at = ${job.runAt}, started_at = NULL, lease_owner = NULL, lease_token = NULL,
+        lease_broker_id = NULL, lease_broker_session_id = NULL,
+        lease_until = NULL, error = NULL, failure_reason = NULL,
+        dlq_entry = NULL,
+        dlq_retry_state = ${encodePostgresValue(getDlqRetryState(job))},
+        version = version + 1
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(job.id)}
+  `;
+    await recordPostgresEvent(tx, ctx, {
+        queue: job.queue,
+        type: reason === "stalled" /* FailureReason.Stalled */ ? 'stalled' : 'failed',
+        jobId: job.id,
+        occurredAt: now,
+        job,
+        state,
+        error,
+        dlqEntry: null,
+        dlqRetryState: getDlqRetryState(job),
+    });
+}
+async function failExpiredLease(tx, ctx, input) {
+    const { job, now, reason, error } = input;
+    job.completedAt = now;
+    const { dlq } = await getPostgresQueuePolicies(tx, ctx, job.queue);
+    const entry = createDlqEntry(job, reason, error, dlq, now);
+    const { protectedIds } = job.removeOnFail
+        ? await partitionPostgresDestructionCandidates(tx, ctx, [job.id], [job.id])
+        : { protectedIds: [] };
+    const removed = job.removeOnFail && protectedIds.length === 0;
+    if (removed) {
+        await tx `
+      DELETE FROM bunqueue_job_logs
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(job.id)}
+    `;
+        await tx `
+      DELETE FROM bunqueue_dependencies
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(job.id)}
+    `;
+        await tx `
+      DELETE FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(job.id)}
+    `;
+    }
+    else {
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(job)}, state = 'failed', attempts = ${job.attempts},
+          completed_at = ${now}, lease_owner = NULL, lease_token = NULL, lease_until = NULL,
+          lease_broker_id = NULL, lease_broker_session_id = NULL,
+          error = ${error}, failure_reason = ${reason},
+          dlq_entry = ${encodePostgresValue(entry)}, dlq_retry_state = NULL,
+          version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(job.id)}
+    `;
+    }
+    await recordPostgresEvent(tx, ctx, {
+        queue: job.queue,
+        type: 'failed',
+        jobId: job.id,
+        occurredAt: now,
+        job,
+        state: 'failed',
+        error,
+        removed,
+        dlqEntry: removed ? null : entry,
+        dlqRetryState: null,
+    });
+    return removed ? null : dlq.maxEntries;
+}
+/** Reclaim expired active leases. Row locks make the sweep safe across many brokers. */
+export async function recoverExpiredPostgresLeases(ctx, limit = 100) {
+    const result = await ctx.sql.begin(async (tx) => {
+        const now = await databaseNow(tx);
+        const initialCandidates = await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace}
+        AND state = 'active'
+        AND lease_until <= ${now}
+      ORDER BY lease_until, id
+      LIMIT ${Math.max(1, limit)}
+    `;
+        if (initialCandidates.length === 0) {
+            return { count: 0, dlqLimits: new Map() };
+        }
+        await lockPostgresDependencyCompletions(tx, ctx, initialCandidates.map(({ id }) => id));
+        const candidates = await tx `
+      SELECT id, parent_id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace}
+        AND id = ANY(${tx.array(initialCandidates.map(({ id }) => id), 'TEXT')})
+        AND state = 'active'
+        AND lease_until <= ${now}
+      ORDER BY lease_until, id
+    `;
+        const parentIds = [
+            ...new Set(candidates.flatMap((row) => (row.parent_id ? [row.parent_id] : []))),
+        ].sort();
+        await lockPostgresFlowParents(tx, ctx, parentIds.map((id) => id));
+        if (candidates.length === 0) {
+            return { count: 0, dlqLimits: new Map() };
+        }
+        const rows = await tx `
+      SELECT * FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace}
+        AND id = ANY(${tx.array(candidates.map((row) => row.id), 'TEXT')})
+        AND state = 'active'
+        AND lease_until <= ${now}
+      ORDER BY lease_until, id
+      LIMIT ${Math.max(1, limit)}
+      FOR UPDATE SKIP LOCKED
+    `;
+        const dlqLimits = new Map();
+        for (const row of rows) {
+            if (await discardPostgresProtectedCronLease(tx, ctx, row, now))
+                continue;
+            const job = decodePostgresJob(row).job;
+            const timedOut = job.timeout !== null && job.startedAt !== null && job.startedAt + job.timeout <= now;
+            const { stall } = await getPostgresQueuePolicies(tx, ctx, job.queue);
+            job.attempts++;
+            if (!timedOut)
+                job.stallCount++;
+            const attemptsExhausted = job.attempts >= job.maxAttempts;
+            const reason = timedOut
+                ? "timeout" /* FailureReason.Timeout */
+                : attemptsExhausted
+                    ? "max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */
+                    : "stalled" /* FailureReason.Stalled */;
+            const error = timedOut ? 'Job processing timed out' : 'PostgreSQL lease expired';
+            if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+                job.timeline.push({
+                    state: 'failed',
+                    timestamp: now,
+                    error,
+                    attempt: job.attempts,
+                });
+            }
+            const failure = { job, now, reason, error };
+            const stallsExhausted = !timedOut && stall.maxStalls > 0 && job.stallCount >= stall.maxStalls;
+            if (!attemptsExhausted && !stallsExhausted)
+                await retryExpiredLease(tx, ctx, failure);
+            else {
+                const maxEntries = await failExpiredLease(tx, ctx, failure);
+                await clearPostgresParentFlowFailures(tx, ctx, job.id);
+                const request = await applyPostgresFlowFailure(tx, ctx, job, error, now);
+                if (maxEntries !== null)
+                    dlqLimits.set(job.queue, maxEntries);
+                if (request)
+                    dlqLimits.set(request.queue, request.maxEntries);
+            }
+        }
+        return { count: rows.length, dlqLimits };
+    });
+    for (const [queue, maxEntries] of [...result.dlqLimits].sort(([left], [right]) => left.localeCompare(right))) {
+        await enforcePostgresDlqLimit(ctx, queue, maxEntries);
+    }
+    return result.count;
+}

package/dist/infrastructure/persistence/postgres/relationships.d.ts

@@ -0,0 +1,9 @@
+import type { TransactionSQL } from 'bun';
+import type { JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+import { type PostgresDlqLimitRequest } from './flowFailures';
+/** Atomically attach an existing child to a linkable parent. */
+export declare function updatePostgresJobParentInTransaction(tx: TransactionSQL, ctx: PostgresContext, childId: JobId, parentId: JobId, dependencyLockHeld?: boolean): Promise<PostgresDlqLimitRequest | null>;
+export declare function updatePostgresJobParent(ctx: PostgresContext, childId: JobId, parentId: JobId): Promise<void>;
+/** Detach a child and promote the parent when no unresolved edge remains. */
+export declare function removePostgresChildDependency(ctx: PostgresContext, childId: JobId): Promise<boolean>;

package/dist/infrastructure/persistence/postgres/relationships.js

@@ -0,0 +1,201 @@
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent } from './context';
+import { enforcePostgresDlqLimit } from './dlqLifecycle';
+import { applyPostgresFlowFailure, lockPostgresFlowParent, } from './flowFailures';
+import { lockPostgresDependencyCompletions } from './dependencyPromotion';
+function recordData(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : {};
+}
+function attachChild(child, parent) {
+    return {
+        ...child,
+        parentId: parent.id,
+        data: { ...recordData(child.data), __parentId: String(parent.id), __parentQueue: parent.queue },
+    };
+}
+function detachChild(child) {
+    const data = recordData(child.data);
+    delete data.__parentId;
+    delete data.__parentQueue;
+    return { ...child, parentId: null, data };
+}
+function withChildren(parent, childrenIds, dependsOn) {
+    const data = recordData(parent.data);
+    if (childrenIds.length > 0)
+        data.__childrenIds = childrenIds.map(String);
+    else
+        delete data.__childrenIds;
+    return { ...parent, childrenIds, dependsOn, data };
+}
+async function lockJobs(tx, ctx, ids) {
+    const values = [...new Set(ids.map(String))].sort();
+    const rows = await tx `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ANY(${tx.array(values, 'TEXT')})
+    ORDER BY id
+    FOR UPDATE
+  `;
+    return new Map(rows.map((row) => [row.id, row]));
+}
+async function hasDependencyCycle(tx, ctx, childId, parentId) {
+    const rows = await tx `
+    WITH RECURSIVE reachable(id) AS (
+      SELECT dependency_id
+      FROM bunqueue_dependencies
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(childId)}
+      UNION
+      SELECT dependency.dependency_id
+      FROM bunqueue_dependencies AS dependency
+      JOIN reachable ON reachable.id = dependency.job_id
+      WHERE dependency.namespace = ${ctx.config.namespace}
+    )
+    SELECT 1 AS found FROM reachable WHERE id = ${String(parentId)} LIMIT 1
+  `;
+    return rows.length > 0;
+}
+async function unresolvedCount(tx, ctx, parentId) {
+    const [row] = await tx `
+    SELECT COUNT(*)::bigint AS count
+    FROM bunqueue_dependencies AS dependency
+    WHERE dependency.namespace = ${ctx.config.namespace}
+      AND dependency.job_id = ${String(parentId)}
+      AND NOT EXISTS (
+        SELECT 1 FROM bunqueue_completions AS completion
+        WHERE completion.namespace = dependency.namespace
+          AND completion.job_id = dependency.dependency_id
+      )
+      AND NOT EXISTS (
+        SELECT 1 FROM bunqueue_jobs AS completed
+        WHERE completed.namespace = dependency.namespace
+          AND completed.id = dependency.dependency_id AND completed.state = 'completed'
+      )
+  `;
+    return Number(row.count);
+}
+function readyState(job, now) {
+    if (job.runAt > now)
+        return 'delayed';
+    return job.priority > 0 ? 'prioritized' : 'waiting';
+}
+/** Atomically attach an existing child to a linkable parent. */
+export async function updatePostgresJobParentInTransaction(tx, ctx, childId, parentId, dependencyLockHeld = false) {
+    if (childId === parentId)
+        throw new Error('A flow job cannot be its own parent');
+    if (!dependencyLockHeld)
+        await lockPostgresDependencyCompletions(tx, ctx, [childId]);
+    await lockPostgresFlowParent(tx, ctx, parentId);
+    const rows = await lockJobs(tx, ctx, [childId, parentId]);
+    const childRow = rows.get(String(childId));
+    const parentRow = rows.get(String(parentId));
+    if (!childRow)
+        throw new Error(`Child job not found: ${String(childId)}`);
+    if (!parentRow)
+        throw new Error(`Parent job not found: ${String(parentId)}`);
+    if (['active', 'completed', 'failed'].includes(parentRow.state)) {
+        throw new Error(`Parent job ${String(parentId)} is not linkable`);
+    }
+    const child = decodePostgresJob(childRow).job;
+    const parent = decodePostgresJob(parentRow).job;
+    if (child.parentId && child.parentId !== parentId) {
+        throw new Error(`Child job ${String(childId)} already belongs to another parent`);
+    }
+    if (await hasDependencyCycle(tx, ctx, childId, parentId)) {
+        throw new Error('Flow dependency cycle detected');
+    }
+    const linkedChild = attachChild(child, parent);
+    const linkedParent = withChildren(parent, [...new Set([...parent.childrenIds, childId])], [...new Set([...parent.dependsOn, childId])]);
+    await tx `
+    INSERT INTO bunqueue_dependencies (namespace, job_id, dependency_id)
+    VALUES (${ctx.config.namespace}, ${String(parentId)}, ${String(childId)})
+    ON CONFLICT DO NOTHING
+  `;
+    const now = await databaseNow(tx);
+    const state = (await unresolvedCount(tx, ctx, parentId)) > 0
+        ? 'waiting-children'
+        : readyState(linkedParent, now);
+    await tx `
+    UPDATE bunqueue_jobs
+    SET payload = ${encodePostgresValue(linkedChild)}, parent_id = ${String(parentId)},
+        version = version + 1
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(childId)}
+  `;
+    await tx `
+    UPDATE bunqueue_jobs
+    SET payload = ${encodePostgresValue(linkedParent)}, state = ${state}, version = version + 1
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(parentId)}
+  `;
+    await recordPostgresEvent(tx, ctx, {
+        queue: parent.queue,
+        type: state === 'waiting-children' ? 'waiting-children' : 'retried',
+        jobId: parentId,
+        occurredAt: now,
+        job: linkedParent,
+        state,
+    });
+    if (childRow.state === 'failed') {
+        return await applyPostgresFlowFailure(tx, ctx, linkedChild, childRow.error ?? undefined, now);
+    }
+    return null;
+}
+export async function updatePostgresJobParent(ctx, childId, parentId) {
+    const request = await ctx.sql.begin((tx) => updatePostgresJobParentInTransaction(tx, ctx, childId, parentId));
+    if (request)
+        await enforcePostgresDlqLimit(ctx, request.queue, request.maxEntries);
+}
+/** Detach a child and promote the parent when no unresolved edge remains. */
+export async function removePostgresChildDependency(ctx, childId) {
+    return await ctx.sql.begin(async (tx) => {
+        await lockPostgresDependencyCompletions(tx, ctx, [childId]);
+        const [relation] = await tx `
+      SELECT parent_id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(childId)}
+    `;
+        if (!relation)
+            throw new Error(`Job not found: ${String(childId)}`);
+        if (!relation.parent_id)
+            throw new Error(`Job ${String(childId)} has no parent`);
+        const parentId = relation.parent_id;
+        await lockPostgresFlowParent(tx, ctx, parentId);
+        const rows = await lockJobs(tx, ctx, [childId, parentId]);
+        const childRow = rows.get(String(childId));
+        const parentRow = rows.get(String(parentId));
+        if (!childRow || !parentRow)
+            return false;
+        const child = decodePostgresJob(childRow).job;
+        const parent = decodePostgresJob(parentRow).job;
+        if (child.parentId !== parentId || !parent.dependsOn.includes(childId))
+            return false;
+        const detachedChild = detachChild(child);
+        const detachedParent = withChildren(parent, parent.childrenIds.filter((id) => id !== childId), parent.dependsOn.filter((id) => id !== childId));
+        await tx `
+      DELETE FROM bunqueue_dependencies
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(parentId)}
+        AND dependency_id = ${String(childId)}
+    `;
+        const now = await databaseNow(tx);
+        const state = (await unresolvedCount(tx, ctx, parentId)) > 0
+            ? 'waiting-children'
+            : readyState(detachedParent, now);
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(detachedChild)}, parent_id = NULL, version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(childId)}
+    `;
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(detachedParent)}, state = ${state}, version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(parentId)}
+    `;
+        await recordPostgresEvent(tx, ctx, {
+            queue: parent.queue,
+            type: state === 'waiting-children' ? 'waiting-children' : 'retried',
+            jobId: parentId,
+            occurredAt: now,
+            job: detachedParent,
+            state,
+        });
+        return true;
+    });
+}

package/dist/infrastructure/persistence/postgres/removeUnprocessedChildren.d.ts

@@ -0,0 +1,4 @@
+import { type JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+/** Atomically remove only direct, pending children without orphaning live consumers. */
+export declare function removePostgresUnprocessedChildren(ctx: PostgresContext, parentId: JobId): Promise<JobId[]>;

package/dist/infrastructure/persistence/postgres/removeUnprocessedChildren.js

@@ -0,0 +1,241 @@
+import { jobId, MAX_TIMELINE_ENTRIES } from '../../../domain/types/job';
+import { recordPostgresJobEvents } from './batchEvents';
+import { decodePostgresJob, encodePostgresValue, postgresByteaBase64 } from './codec';
+import { databaseNow } from './context';
+import { lockPostgresDependencyCompletions } from './dependencyPromotion';
+import { lockPostgresFlowParent } from './flowFailures';
+const REMOVABLE_STATES = new Set([
+    'waiting',
+    'prioritized',
+    'delayed',
+    'waiting-children',
+]);
+const LIVE_CONSUMER_STATES = [
+    'waiting',
+    'prioritized',
+    'delayed',
+    'waiting-children',
+    'active',
+];
+function recordData(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : {};
+}
+function uniqueIds(ids) {
+    return [...new Set(ids.map(String))].sort();
+}
+function detachChild(job) {
+    const data = recordData(job.data);
+    delete data.__parentId;
+    delete data.__parentQueue;
+    return { ...job, parentId: null, data };
+}
+function updateParent(job, removedIds) {
+    const childrenIds = job.childrenIds.filter((id) => !removedIds.has(String(id)));
+    const dependsOn = job.dependsOn.filter((id) => !removedIds.has(String(id)));
+    const data = recordData(job.data);
+    if (childrenIds.length > 0)
+        data.__childrenIds = childrenIds.map(String);
+    else
+        delete data.__childrenIds;
+    return { ...job, childrenIds, dependsOn, data };
+}
+function readyState(job, now) {
+    if (job.runAt > now)
+        return 'delayed';
+    return job.priority > 0 ? 'prioritized' : 'waiting';
+}
+async function discoverChildren(tx, ctx, parentId) {
+    const [parent] = await tx `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(parentId)}
+  `;
+    if (!parent)
+        return [];
+    const linked = await tx `
+    SELECT id AS child_id
+    FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND parent_id = ${String(parentId)}
+    UNION
+    SELECT dependency_id AS child_id
+    FROM bunqueue_dependencies
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(parentId)}
+  `;
+    return uniqueIds([
+        ...decodePostgresJob(parent).job.childrenIds,
+        ...linked.map((row) => row.child_id),
+    ]);
+}
+async function lockRows(tx, ctx, parentId, candidates) {
+    const consumers = await tx `
+    SELECT DISTINCT consumer.id
+    FROM bunqueue_dependencies AS dependency
+    JOIN bunqueue_jobs AS consumer
+      ON consumer.namespace = dependency.namespace AND consumer.id = dependency.job_id
+    WHERE dependency.namespace = ${ctx.config.namespace}
+      AND dependency.dependency_id = ANY(${tx.array([...candidates], 'TEXT')})
+      AND consumer.state = ANY(${tx.array([...LIVE_CONSUMER_STATES], 'TEXT')})
+    ORDER BY consumer.id
+  `;
+    const ids = uniqueIds([parentId, ...candidates, ...consumers.map((row) => row.id)]);
+    const rows = await tx `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ANY(${tx.array(ids, 'TEXT')})
+    ORDER BY id
+    FOR UPDATE
+  `;
+    return new Map(rows.map((row) => [row.id, row]));
+}
+async function protectedCandidates(tx, ctx, parentId, removable) {
+    if (removable.size === 0)
+        return new Set();
+    const edges = await tx `
+    SELECT dependency.job_id AS consumer_id, dependency.dependency_id
+    FROM bunqueue_dependencies AS dependency
+    JOIN bunqueue_jobs AS consumer
+      ON consumer.namespace = dependency.namespace AND consumer.id = dependency.job_id
+    WHERE dependency.namespace = ${ctx.config.namespace}
+      AND dependency.dependency_id = ANY(${tx.array([...removable], 'TEXT')})
+      AND consumer.state = ANY(${tx.array([...LIVE_CONSUMER_STATES], 'TEXT')})
+    ORDER BY dependency.job_id, dependency.dependency_id
+  `;
+    const protectedIds = new Set();
+    for (const edge of edges) {
+        if (edge.consumer_id !== String(parentId) && !removable.has(edge.consumer_id)) {
+            protectedIds.add(edge.dependency_id);
+        }
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const edge of edges) {
+            if (!protectedIds.has(edge.consumer_id) || protectedIds.has(edge.dependency_id))
+                continue;
+            protectedIds.add(edge.dependency_id);
+            changed = true;
+        }
+    }
+    return protectedIds;
+}
+async function deleteJobs(tx, ctx, ids) {
+    if (ids.length === 0)
+        return;
+    await tx `
+    DELETE FROM bunqueue_dependencies
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${tx.array([...ids], 'TEXT')})
+  `;
+    await tx `
+    DELETE FROM bunqueue_job_logs
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${tx.array([...ids], 'TEXT')})
+  `;
+    await tx `
+    DELETE FROM bunqueue_flow_failures
+    WHERE namespace = ${ctx.config.namespace} AND parent_id = ANY(${tx.array([...ids], 'TEXT')})
+  `;
+    await tx `
+    DELETE FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ANY(${tx.array([...ids], 'TEXT')})
+  `;
+}
+async function detachJobs(tx, ctx, jobs) {
+    if (jobs.length === 0)
+        return;
+    await tx `
+    UPDATE bunqueue_jobs AS child
+    SET payload = decode(batch.payload_base64, 'base64'), parent_id = NULL,
+        version = child.version + 1
+    FROM unnest(
+      ${tx.array(jobs.map((job) => String(job.id)), 'TEXT')},
+      ${tx.array(jobs.map((job) => postgresByteaBase64(encodePostgresValue(job))), 'TEXT')}
+    ) AS batch(id, payload_base64)
+    WHERE child.namespace = ${ctx.config.namespace} AND child.id = batch.id
+  `;
+}
+async function unresolvedParentDependencies(tx, ctx, parentId) {
+    const [row] = await tx `
+    SELECT EXISTS (
+      SELECT 1 FROM bunqueue_dependencies AS dependency
+      WHERE dependency.namespace = ${ctx.config.namespace}
+        AND dependency.job_id = ${String(parentId)}
+        AND NOT EXISTS (
+          SELECT 1 FROM bunqueue_completions AS completion
+          WHERE completion.namespace = dependency.namespace
+            AND completion.job_id = dependency.dependency_id
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM bunqueue_jobs AS completed
+          WHERE completed.namespace = dependency.namespace
+            AND completed.id = dependency.dependency_id AND completed.state = 'completed'
+        )
+    ) AS unresolved
+  `;
+    return row.unresolved;
+}
+/** Atomically remove only direct, pending children without orphaning live consumers. */
+export async function removePostgresUnprocessedChildren(ctx, parentId) {
+    return await ctx.sql.begin(async (tx) => {
+        const candidates = await discoverChildren(tx, ctx, parentId);
+        if (candidates.length === 0)
+            return [];
+        await lockPostgresDependencyCompletions(tx, ctx, candidates.map(jobId));
+        await lockPostgresFlowParent(tx, ctx, parentId);
+        const rows = await lockRows(tx, ctx, parentId, candidates);
+        const parentRow = rows.get(String(parentId));
+        if (!parentRow)
+            return [];
+        const removable = new Set(candidates.filter((id) => {
+            const row = rows.get(id);
+            return row?.parent_id === String(parentId) && REMOVABLE_STATES.has(row.state);
+        }));
+        if (removable.size === 0)
+            return [];
+        const protectedIds = await protectedCandidates(tx, ctx, parentId, removable);
+        const deletedIds = [...removable].filter((id) => !protectedIds.has(id));
+        const detachedRows = [...protectedIds]
+            .map((id) => rows.get(id))
+            .filter((row) => row !== undefined);
+        const deletedRows = deletedIds
+            .map((id) => rows.get(id))
+            .filter((row) => row !== undefined);
+        const detachedJobs = detachedRows.map((row) => detachChild(decodePostgresJob(row).job));
+        const removed = new Set(removable);
+        await tx `
+      DELETE FROM bunqueue_dependencies
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(parentId)}
+        AND dependency_id = ANY(${tx.array([...removed], 'TEXT')})
+    `;
+        await deleteJobs(tx, ctx, deletedIds);
+        await detachJobs(tx, ctx, detachedJobs);
+        const now = await databaseNow(tx);
+        const parent = updateParent(decodePostgresJob(parentRow).job, removed);
+        const promote = parentRow.state === 'waiting-children' &&
+            !(await unresolvedParentDependencies(tx, ctx, parentId));
+        const parentState = promote ? readyState(parent, now) : parentRow.state;
+        if (promote && parent.timeline.at(-1)?.state !== parentState) {
+            if (parent.timeline.length < MAX_TIMELINE_ENTRIES) {
+                parent.timeline.push({ state: parentState, timestamp: now });
+            }
+        }
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(parent)}, state = ${parentState}, version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(parentId)}
+    `;
+        await recordPostgresJobEvents(tx, ctx, [
+            ...deletedRows.map((row) => ({
+                job: decodePostgresJob(row).job,
+                type: 'removed',
+                state: row.state,
+                removed: true,
+            })),
+            ...detachedRows.map((row, index) => ({
+                job: detachedJobs[index],
+                type: 'updated',
+                state: row.state,
+            })),
+            { job: parent, type: promote ? 'retried' : 'updated', state: parentState },
+        ], now);
+        return [...removed].map(jobId);
+    });
+}

package/dist/infrastructure/persistence/postgres/repeatMutations.d.ts

@@ -0,0 +1,5 @@
+import type { TransactionSQL } from 'bun';
+import type { JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+/** Update the pending successor addressed through a completed repeat generation. */
+export declare function updatePostgresRepeatSuccessorData(tx: TransactionSQL, ctx: PostgresContext, originalId: JobId, data: unknown): Promise<boolean>;

package/dist/infrastructure/persistence/postgres/repeatMutations.js

@@ -0,0 +1,37 @@
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent } from './context';
+import { updatedPostgresJobData } from './jobData';
+/** Update the pending successor addressed through a completed repeat generation. */
+export async function updatePostgresRepeatSuccessorData(tx, ctx, originalId, data) {
+    const links = await tx `
+    SELECT successor_id FROM bunqueue_repeat_links
+    WHERE namespace = ${ctx.config.namespace} AND original_id = ${String(originalId)}
+  `;
+    if (!links[0])
+        return false;
+    const rows = await tx `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ${links[0].successor_id}
+    FOR UPDATE
+  `;
+    const row = rows[0];
+    if (!row || ['active', 'completed', 'failed'].includes(row.state))
+        return false;
+    const job = decodePostgresJob(row).job;
+    const updated = { ...job, data: updatedPostgresJobData(job, data) };
+    const now = await databaseNow(tx);
+    await tx `
+    UPDATE bunqueue_jobs
+    SET payload = ${encodePostgresValue(updated)}, version = version + 1
+    WHERE namespace = ${ctx.config.namespace} AND id = ${row.id}
+  `;
+    await recordPostgresEvent(tx, ctx, {
+        queue: job.queue,
+        type: 'updated',
+        jobId: job.id,
+        occurredAt: now,
+        job: updated,
+        state: row.state,
+    });
+    return true;
+}