@vibesdotdev/integrations-kafka 0.0.0-stage → 1.0.0-rc.1

package/dist/workers/adapter/provider.js

@@ -0,0 +1,654 @@
+/**
+ * Kafka Provider
+ *
+ * Kafka-based provider for distributed job processing.
+ * Uses existing Kafka infrastructure with worker topics.
+ */
+import { BaseQueueAdapter, assertJobMutationGuard, assertJobWriteGuard, assertExecutionClaim, assertJobReadmission, executionClaimFromRecord, jobMutationStamp, snapshotJob, stampRetryPolicy, withRetryAvailability, isDueAt } from '@vibesdotdev/workers/core/queue-adapter';
+import { CapabilityError, CaughtFailureSchema, valueFreeFailure } from '@vibesdotdev/kernel';
+import { JobDataEqualsSchema, JobStatusSchema, JobExecutionRecordSchema, JobExecutionClaimSchema, JobWriteGuardSchema, JobRetryOptionsSchema, JobMutationStampSchema } from '@vibesdotdev/workers/core/schemas';
+import { CancellationSchema, parseCancellation } from '@vibesdotdev/workers/schemas';
+import { JsonObjectSchema } from '@vibesdotdev/kernel/schemas/json';
+import * as z from 'zod/v4';
+/**
+ * Payload and metadata are separate physical columns. A row whose metadata
+ * column is absent is not decoded by guessing: an application-owned migration
+ * splits historical combined rows and preserves their payloads, and until then
+ * the adapter refuses rather than inventing metadata.
+ */
+function storedJobData(row) {
+    const parsed = JsonObjectSchema.safeParse(row.metadata);
+    if (!parsed.success) {
+        throw new CapabilityError('Stored job metadata is invalid.', 'INTERNAL', {
+            reason: 'job-metadata-record-invalid', retryable: false, cause: parsed.error
+        });
+    }
+    return { cleanData: row.data, metadata: parsed.data };
+}
+function inputJobMetadata(value) {
+    const parsed = JsonObjectSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new CapabilityError('Job metadata is invalid.', 'INVALID_INPUT', {
+            reason: 'job-metadata-invalid', retryable: false, cause: parsed.error
+        });
+    }
+    return parsed.data;
+}
+function storedCancellation(value) {
+    if (value == null)
+        return undefined;
+    const parsed = CancellationSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new CapabilityError('Stored job cancellation provenance is invalid.', 'INTERNAL', {
+            reason: 'job-cancellation-record-invalid', retryable: false, cause: parsed.error
+        });
+    }
+    return parsed.data;
+}
+/** A JSON `null` payload is written as the SQL JSON literal so the NOT NULL column keeps it. */
+function storedPayloadData(value, sql) {
+    return value === null ? sql `'null'` : value;
+}
+function mergeJobMetadata(row, metadata, sql) {
+    const stored = storedJobData(row);
+    return { data: storedPayloadData(stored.cleanData, sql), metadata: inputJobMetadata({ ...stored.metadata, ...metadata }) };
+}
+/**
+ * Page size when a dequeue scans pending rows for the first due job. The scan
+ * pages until a due row is claimed or the pending set is exhausted, so a head
+ * of delayed rows can never starve due jobs behind it.
+ */
+const CLAIM_WINDOW = 20;
+const WORKER_JOB_EVENT_TYPES = [
+    'job.queued',
+    'job.created',
+    'job.started',
+    'job.progress',
+    'job.completed',
+    'job.failed',
+    'job.retrying',
+    'job.cancelled',
+    'tool.event'
+];
+/** The fields that make a bus message a worker job event; anything else on the bus is not one. */
+const WorkerJobEventIdentitySchema = z.object({
+    type: z.enum(WORKER_JOB_EVENT_TYPES),
+    jobId: z.string(),
+    jobType: z.string(),
+    workerId: z.string(),
+    timestamp: z.string()
+});
+/**
+ * A worker job event as the bus delivers it. A present stamp must be valid;
+ * malformed optional detail is dropped rather than refusing the event.
+ */
+const WorkerJobEventSchema = WorkerJobEventIdentitySchema.extend({
+    stamp: JobMutationStampSchema.optional(),
+    payload: z.unknown().optional(),
+    progress: z.union([z.number(), JsonObjectSchema]).optional().catch(undefined),
+    error: z.string().optional().catch(undefined),
+    result: z.unknown().optional(),
+    envelope: z.unknown().optional(),
+    metadata: JsonObjectSchema.optional().catch(undefined)
+});
+/** The bus is untyped transport input: a non-event is skipped, an event with an invalid stamp refuses. */
+function toWorkerJobEvent(message) {
+    if (!WorkerJobEventIdentitySchema.safeParse(message).success)
+        return null;
+    return WorkerJobEventSchema.parse(message);
+}
+/** `broadcastEvent` publishes its named event and data inside the payload. */
+const BroadcastPayloadSchema = z.object({ event: z.string(), data: z.unknown().optional() });
+const FailedPayloadSchema = z.object({ error: z.string() });
+function toJobEvent(message) {
+    const broadcast = BroadcastPayloadSchema.safeParse(message.payload);
+    if (broadcast.success) {
+        return {
+            jobId: message.jobId,
+            event: broadcast.data.event,
+            data: broadcast.data.data,
+            timestamp: new Date(message.timestamp),
+            stamp: message.stamp ?? null
+        };
+    }
+    if (message.type === 'job.completed') {
+        return {
+            jobId: message.jobId,
+            event: 'done',
+            data: message.payload,
+            timestamp: new Date(message.timestamp),
+            stamp: message.stamp ?? null
+        };
+    }
+    if (message.type === 'job.failed') {
+        const failed = FailedPayloadSchema.safeParse(message.payload);
+        const error = (failed.success ? failed.data.error : message.error) ?? 'Job failed';
+        return {
+            jobId: message.jobId,
+            event: 'error',
+            data: { error },
+            timestamp: new Date(message.timestamp),
+            stamp: message.stamp ?? null
+        };
+    }
+    if (message.type === 'job.cancelled') {
+        return {
+            jobId: message.jobId,
+            event: 'cancelled',
+            data: message.payload,
+            timestamp: new Date(message.timestamp),
+            stamp: message.stamp ?? null
+        };
+    }
+    if (message.type === 'job.progress') {
+        return {
+            jobId: message.jobId,
+            event: 'progress',
+            data: message.payload,
+            timestamp: new Date(message.timestamp),
+            stamp: message.stamp ?? null
+        };
+    }
+    return {
+        jobId: message.jobId,
+        event: message.type === 'job.queued' ? 'queued' : 'started',
+        data: message.payload,
+        timestamp: new Date(message.timestamp),
+        stamp: message.stamp ?? null
+    };
+}
+export class KafkaAdapter extends BaseQueueAdapter {
+    db;
+    providerJobs;
+    ops;
+    eventHandlers = new Map();
+    unsubscribeEvents;
+    eventBridgeConnected = false;
+    eventBridgeSetup;
+    eventBridgeCleanup;
+    eventBridgeClosing = false;
+    eventBridge;
+    diagnostics;
+    // The host's declared dialect. 'postgres' claims under a transactional
+    // `FOR UPDATE SKIP LOCKED`; 'sqlite' (Cloudflare D1 / libsql) claims by an
+    // atomic compare-and-set, because those hosts serialize writes and have no
+    // row-lock syntax. The adapter never guesses it.
+    dialect;
+    constructor(db, queueName, options) {
+        super(queueName);
+        this.db = db;
+        this.providerJobs = options.providerJobs;
+        this.ops = options.ops;
+        this.dialect = options.dialect;
+        this.eventBridge = options.eventBridge;
+        this.diagnostics = options.diagnostics;
+    }
+    async connect() {
+        await this.ensureEventBridge();
+    }
+    disconnect() {
+        if (this.eventBridgeCleanup)
+            return this.eventBridgeCleanup;
+        this.eventBridgeClosing = true;
+        this.eventHandlers.clear();
+        const setup = this.eventBridgeSetup;
+        const cleanupOperation = (async () => {
+            const setupResults = setup ? await Promise.allSettled([setup]) : [];
+            this.eventBridgeConnected = false;
+            const unsubscribe = this.unsubscribeEvents;
+            this.unsubscribeEvents = undefined;
+            const unsubscribeResults = unsubscribe
+                ? await Promise.allSettled([Promise.resolve().then(unsubscribe)])
+                : [];
+            const failures = [];
+            if (setupResults[0]?.status === 'rejected')
+                failures.push(setupResults[0].reason);
+            if (unsubscribeResults[0]?.status === 'rejected')
+                failures.push(unsubscribeResults[0].reason);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1) {
+                throw new AggregateError(failures, 'Kafka event bridge cleanup failed.', {
+                    cause: failures[0]
+                });
+            }
+        })();
+        let cleanup;
+        cleanup = cleanupOperation.finally(() => {
+            if (this.eventBridgeCleanup === cleanup)
+                this.eventBridgeCleanup = undefined;
+        });
+        this.eventBridgeCleanup = cleanup;
+        return cleanup;
+    }
+    rowFence(row) {
+        const { eq, and, sql } = this.ops;
+        const nullable = (column, value) => value == null ? sql `${column} IS NULL` : eq(column, value);
+        return and(eq(this.providerJobs.id, row.id), eq(this.providerJobs.queueName, this.queueName), eq(this.providerJobs.provider, 'kafka'), eq(this.providerJobs.status, row.status), nullable(this.providerJobs.generation, row.generation), nullable(this.providerJobs.revision, row.revision), nullable(this.providerJobs.executionState, row.executionState), nullable(this.providerJobs.claimToken, row.claimToken), nullable(this.providerJobs.claimAttempt, row.claimAttempt), nullable(this.providerJobs.claimOwner, row.claimOwner));
+    }
+    async readRow(jobId) {
+        const { eq, and } = this.ops;
+        const [row] = await this.db.select().from(this.providerJobs).where(and(eq(this.providerJobs.id, jobId), eq(this.providerJobs.queueName, this.queueName), eq(this.providerJobs.provider, 'kafka'))).limit(1);
+        return row ?? null;
+    }
+    async requireRow(jobId) {
+        const row = await this.readRow(jobId);
+        if (!row)
+            throw new CapabilityError('Job not found in this queue.', 'NOT_FOUND', { reason: 'job-not-found' });
+        return row;
+    }
+    async writeRow(row, patch, db = this.db) {
+        const [admitted] = await db.update(this.providerJobs).set(patch).where(this.rowFence(row)).returning();
+        return admitted ?? null;
+    }
+    /** `updateJob` never admits a cancellation; `cancelJob` is the only provenance owner. */
+    rejectProvenancelessCancellation(jobId) {
+        throw new CapabilityError('Cancel the job through cancelJob, which requires cancellation provenance.', 'INVALID_INPUT', {
+            reason: 'cancel-provenance-required', retryable: false, details: { jobId }
+        });
+    }
+    /** A row already cancelled holds its admitted provenance; a historical row keeps none. */
+    assertAlreadyCancelled(job) {
+        if (job.status === 'cancelled')
+            return;
+        this.rejectProvenancelessCancellation(job.id);
+    }
+    revisionConflict() {
+        throw new CapabilityError('The intended job mutation could not be admitted.', 'CONFLICT', {
+            reason: 'job-revision-conflict', retryable: false
+        });
+    }
+    /** A bounded native revision retry; assert always holds the caller's original intent. */
+    async mutate(jobId, assert, patch) {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const row = await this.requireRow(jobId);
+            const job = this.toJob(row);
+            assert(job, row);
+            const admitted = await this.writeRow(row, patch(row, job));
+            if (admitted)
+                return admitted;
+        }
+        return this.revisionConflict();
+    }
+    toJob(row) {
+        const parsed = JobExecutionRecordSchema.safeParse(row);
+        if (!parsed.success) {
+            throw new CapabilityError('Stored job ownership is invalid.', 'INTERNAL', {
+                reason: 'job-execution-record-invalid', retryable: false, cause: parsed.error
+            });
+        }
+        const facts = parsed.data;
+        const { cleanData, metadata } = storedJobData(row);
+        const cancellation = storedCancellation(row.cancellation);
+        // SAFETY: TJob and TResult are this queue's declared payload and result; the row holds the
+        // JSON its own enqueue and updateJob wrote, so the stored value is that type's JSON form.
+        const data = cleanData, result = row.result;
+        const job = {
+            id: row.id, data, status: JobStatusSchema.parse(row.status),
+            progress: row.progress ?? undefined,
+            result, error: row.error ?? undefined,
+            attemptsMade: row.attemptsMade ?? 0, createdAt: row.createdAt,
+            startedAt: row.startedAt ?? undefined, completedAt: row.completedAt ?? undefined,
+            generation: facts.generation ?? 0, revision: facts.revision ?? 0,
+            executionClaim: executionClaimFromRecord(facts),
+            retiredAt: facts.retiredAt == null ? undefined : (facts.retiredAt instanceof Date ? facts.retiredAt : new Date(facts.retiredAt)),
+            metadata
+        };
+        if (cancellation)
+            job.cancellation = cancellation;
+        return snapshotJob(job);
+    }
+    async publish(type, jobId, payload, stamp) {
+        try {
+            await this.eventBridge.sendJobEvent({
+                type, jobId, jobType: this.queueName, workerId: this.queueName,
+                timestamp: new Date().toISOString(), payload, stamp
+            });
+        }
+        catch (error) {
+            this.diagnostics.error('Kafka post-admission event delivery failed', {
+                scope: 'workers-kafka:queue', plugin: 'worker-adapter.kafka',
+                error: CaughtFailureSchema.parse(error)
+            });
+        }
+    }
+    async enqueue(data, options) {
+        await this.eventBridge.prepare();
+        const jobId = options?.jobId || this.generateJobId();
+        const metadata = { ...options?.metadata };
+        stampRetryPolicy(metadata, options);
+        const now = new Date();
+        const delay = options?.delay ?? 0;
+        const jobMetadata = inputJobMetadata(delay > 0
+            ? withRetryAvailability(metadata, Math.ceil(delay), now.getTime()) : metadata);
+        const { eq } = this.ops;
+        const [existing] = await this.db.select().from(this.providerJobs)
+            .where(eq(this.providerJobs.id, jobId)).limit(1);
+        if (existing && (existing.queueName !== this.queueName || existing.provider !== 'kafka')) {
+            throw new CapabilityError('This job id is held by another queue or provider.', 'CONFLICT', {
+                reason: 'job-key-held-by-another-queue', retryable: false
+            });
+        }
+        if (existing && existing.status !== 'failed')
+            return jobId;
+        const intended = existing && this.toJob(existing);
+        if (intended)
+            assertJobReadmission(intended, intended.generation);
+        const row = {
+            id: jobId, queueName: this.queueName, provider: 'kafka', data: storedPayloadData(data, this.ops.sql), metadata: jobMetadata,
+            cancellation: null,
+            status: 'pending', attemptsMade: 0, maxAttempts: options?.attempts ?? 3,
+            priority: options?.priority ?? 0, createdAt: now, startedAt: null, completedAt: null,
+            progress: null, result: null, error: null,
+            generation: (intended?.generation ?? 0) + 1, revision: (intended?.revision ?? -1) + 1,
+            executionState: 'none', claimToken: null, claimAttempt: null, claimOwner: null,
+            claimHeartbeatAt: null, retiredAt: null
+        };
+        const admitted = existing ? await this.writeRow(existing, row) : (await this.db.insert(this.providerJobs).values(row)
+            .onConflictDoNothing({ target: this.providerJobs.id }).returning())[0];
+        if (admitted) {
+            await this.publish('job.queued', jobId, {
+                queueName: this.queueName, data, priority: row.priority,
+                attempts: row.maxAttempts, delay: options?.delay, metadata
+            }, jobMutationStamp(this.toJob(admitted)));
+        }
+        else if (!await this.readRow(jobId)) {
+            throw new CapabilityError('This job id is held by another queue or provider.', 'CONFLICT', {
+                reason: 'job-key-held-by-another-queue', retryable: false
+            });
+        }
+        return jobId;
+    }
+    /** Both backing dialects use the same native admission fence; PostgreSQL also locks candidate rows. */
+    async dequeueNative(db, options) {
+        const { eq, and, asc, desc } = this.ops;
+        const now = Date.now();
+        for (let offset = 0;; offset += CLAIM_WINDOW) {
+            let query = db.select().from(this.providerJobs).where(and(eq(this.providerJobs.queueName, this.queueName), eq(this.providerJobs.provider, 'kafka'), eq(this.providerJobs.status, 'pending'))).orderBy(desc(this.providerJobs.priority), asc(this.providerJobs.createdAt))
+                .limit(CLAIM_WINDOW).offset(offset);
+            if (this.dialect === 'postgres')
+                query = query.for('update', { skipLocked: true });
+            const candidates = await query;
+            for (const candidate of candidates) {
+                const job = this.toJob(candidate);
+                if (job.executionClaim.state !== 'none' || !isDueAt(job.metadata, now))
+                    continue;
+                const jobType = job.metadata?.type;
+                if (options?.jobTypes?.length && !options.jobTypes.some(type => type === jobType))
+                    continue;
+                const identity = this.createExecutionClaim(job, options);
+                const patch = {
+                    status: 'processing', startedAt: new Date(), revision: job.revision + 1,
+                    executionState: 'held', claimToken: identity.token, claimAttempt: identity.attempt,
+                    claimOwner: identity.owner, claimHeartbeatAt: new Date().toISOString(), retiredAt: null
+                };
+                if (options?.claimMetadata)
+                    Object.assign(patch, mergeJobMetadata(candidate, options.claimMetadata, this.ops.sql));
+                const admitted = await this.writeRow(candidate, patch, db);
+                if (admitted)
+                    return admitted;
+            }
+            if (candidates.length < CLAIM_WINDOW)
+                return null;
+        }
+    }
+    async dequeue(options) {
+        await this.eventBridge.prepare();
+        const row = this.dialect === 'postgres'
+            ? await this.db.transaction(tx => this.dequeueNative(tx, options))
+            : await this.dequeueNative(this.db, options);
+        if (!row)
+            return null;
+        const job = this.toJob(row);
+        await this.publish('job.started', row.id, {}, jobMutationStamp(job));
+        return job;
+    }
+    async getJob(jobId) {
+        const row = await this.readRow(jobId);
+        return row ? this.toJob(row) : null;
+    }
+    async updateJob(jobId, update, guard) {
+        const intended = JobWriteGuardSchema.parse(guard);
+        const input = { ...update, metadata: update.metadata && { ...update.metadata } };
+        // A newly admitted cancellation has one owner: cancelJob, which requires and
+        // persists Workers provenance. updateJob may hold a cancelled row's other
+        // fields, but never move a live row into `cancelled` without provenance.
+        if (input.status === 'cancelled')
+            this.rejectProvenancelessCancellation(jobId);
+        await this.eventBridge.prepare();
+        const admitted = await this.mutate(jobId, job => {
+            assertJobMutationGuard(job, intended);
+            if (input.status === 'cancelled')
+                this.assertAlreadyCancelled(job);
+        }, (row, job) => {
+            const patch = { revision: job.revision + 1 };
+            if (input.status !== undefined) {
+                patch.status = JobStatusSchema.parse(input.status);
+                const terminal = input.status === 'completed' || input.status === 'failed' || input.status === 'cancelled';
+                patch.completedAt = terminal ? new Date() : null;
+                patch.retiredAt = terminal && job.executionClaim.state === 'none' ? new Date() : null;
+            }
+            if (input.progress !== undefined)
+                patch.progress = input.progress;
+            if (input.result !== undefined)
+                patch.result = input.result;
+            if (input.error !== undefined)
+                patch.error = input.error;
+            if (input.metadata !== undefined)
+                Object.assign(patch, mergeJobMetadata(row, input.metadata, this.ops.sql));
+            return patch;
+        });
+        const stamp = jobMutationStamp(this.toJob(admitted));
+        if (input.progress !== undefined)
+            await this.publish('job.progress', jobId, { progress: input.progress }, stamp);
+        if (input.status === 'completed')
+            await this.publish('job.completed', jobId, { result: input.result }, stamp);
+        if (input.status === 'failed')
+            await this.publish('job.failed', jobId, { error: input.error }, stamp);
+        return stamp;
+    }
+    async renewExecution(jobId, claim) {
+        const intended = JobExecutionClaimSchema.parse(claim);
+        await this.mutate(jobId, job => { assertExecutionClaim(job, intended); }, () => ({
+            claimHeartbeatAt: new Date().toISOString()
+        }));
+    }
+    async releaseExecution(jobId, claim) {
+        const intended = JobExecutionClaimSchema.parse(claim);
+        await this.mutate(jobId, job => { assertExecutionClaim(job, intended); }, (_row, job) => ({
+            executionState: 'none', claimToken: null, claimAttempt: null, claimOwner: null, claimHeartbeatAt: null,
+            retiredAt: job.status === 'completed' || job.status === 'failed' || job.status === 'cancelled' ? new Date() : null
+        }));
+    }
+    async cancelJob(jobId, cancellation) {
+        const provenance = parseCancellation(cancellation);
+        await this.eventBridge.prepare();
+        const row = await this.readRow(jobId);
+        if (!row || (row.status !== 'pending' && row.status !== 'processing'))
+            return false;
+        // Administrative cancellation retains the original native admission, including UNKNOWN ownership.
+        const intended = Object.freeze({ ...row });
+        const admitted = await this.mutate(jobId, (_job, current) => {
+            if (current.generation !== intended.generation || current.status !== intended.status ||
+                current.executionState !== intended.executionState || current.claimToken !== intended.claimToken ||
+                current.claimAttempt !== intended.claimAttempt || current.claimOwner !== intended.claimOwner) {
+                throw new CapabilityError('The intended cancellation admission or phase is no longer current.', 'CONFLICT', {
+                    reason: 'job-write-stale', retryable: false
+                });
+            }
+        }, (_row, job) => ({
+            status: 'cancelled', cancellation: provenance, completedAt: new Date(), revision: job.revision + 1,
+            retiredAt: job.executionClaim.state === 'none' ? new Date() : null
+        }));
+        const cancelled = this.toJob(admitted);
+        const stamp = jobMutationStamp(cancelled);
+        // The admitted record and its stamp travel on both paths: local subscribers
+        // and every other adapter reading the same bus.
+        const payload = { reason: provenance.reason, cancellation: provenance, queueName: this.queueName };
+        this.emitEvent({ jobId, event: 'cancelled', timestamp: new Date(), data: payload, stamp });
+        await this.publish('job.cancelled', jobId, payload, stamp);
+        return true;
+    }
+    async retryJob(jobId, options) {
+        const intended = JobRetryOptionsSchema.parse(options);
+        await this.mutate(jobId, job => assertJobReadmission(job, intended.expectedGeneration), (row, job) => {
+            const { cleanData, metadata } = storedJobData(row);
+            const delay = intended.delay ?? 0;
+            return {
+                data: storedPayloadData(cleanData, this.ops.sql), metadata: inputJobMetadata(withRetryAvailability(metadata, delay > 0 ? Math.ceil(delay) : 0)),
+                status: 'pending', cancellation: null, attemptsMade: job.attemptsMade + 1,
+                generation: job.generation + 1, revision: job.revision + 1,
+                startedAt: null, completedAt: null, retiredAt: null, progress: null, result: null, error: null
+            };
+        });
+        return jobId;
+    }
+    async getStatus(jobId) {
+        return this.toJob(await this.requireRow(jobId)).status;
+    }
+    async listJobs(state, options) {
+        const { eq, and, desc } = this.ops;
+        const conditions = [eq(this.providerJobs.queueName, this.queueName), eq(this.providerJobs.provider, 'kafka')];
+        if (state)
+            conditions.push(eq(this.providerJobs.status, state));
+        if (options?.dataEquals)
+            conditions.push(...this.dataEquals(JobDataEqualsSchema.parse(options.dataEquals)));
+        const rows = await this.db.select().from(this.providerJobs).where(and(...conditions))
+            .orderBy(desc(this.providerJobs.createdAt), desc(this.providerJobs.id))
+            .limit(options?.limit ?? 100).offset(options?.offset ?? 0);
+        return rows.map(row => this.toJob(row));
+    }
+    /** One condition per field: the stored data's top-level field is a JSON string equal to the value. */
+    dataEquals(fields) {
+        const { sql } = this.ops;
+        const data = this.providerJobs.data;
+        return Object.entries(fields).map(([field, value]) => this.dialect === 'postgres'
+            ? sql `(${data})::jsonb -> ${field} = to_jsonb(${value}::text)`
+            : sql `json_type(${data}, ${`$.${field}`}) = 'text' AND json_extract(${data}, ${`$.${field}`}) = ${value}`);
+    }
+    async getMetrics() {
+        const { eq, and, sql } = this.ops;
+        const counts = await this.db
+            .select({
+            status: this.providerJobs.status,
+            count: sql `count(*)`
+        })
+            .from(this.providerJobs)
+            .where(and(eq(this.providerJobs.queueName, this.queueName), eq(this.providerJobs.provider, 'kafka')))
+            .groupBy(this.providerJobs.status);
+        const metrics = { waiting: 0, active: 0, completed: 0, failed: 0 };
+        for (const { status, count } of counts) {
+            if (status === 'pending')
+                metrics.waiting = Number(count);
+            if (status === 'processing')
+                metrics.active = Number(count);
+            if (status === 'completed')
+                metrics.completed = Number(count);
+            if (status === 'failed')
+                metrics.failed = Number(count);
+        }
+        return metrics;
+    }
+    subscribeToEvents(jobId, handler) {
+        const target = jobId === '*' ? '*' : jobId;
+        if (!this.eventHandlers.has(target)) {
+            this.eventHandlers.set(target, new Set());
+        }
+        this.eventHandlers.get(target).add(handler);
+        return () => {
+            const handlers = this.eventHandlers.get(target);
+            if (!handlers)
+                return;
+            handlers.delete(handler);
+            if (handlers.size === 0)
+                this.eventHandlers.delete(target);
+        };
+    }
+    async broadcastEvent(jobId, event, guard, data) {
+        const intended = JobWriteGuardSchema.parse(guard);
+        await this.eventBridge.prepare();
+        const admitted = await this.mutate(jobId, job => assertJobWriteGuard(job, intended), (_row, job) => ({
+            revision: job.revision + 1
+        }));
+        const stamp = jobMutationStamp(this.toJob(admitted));
+        this.emitEvent({ jobId, event, data, timestamp: new Date(), stamp });
+        await this.publish('job.started', jobId, { event, data, queueName: this.queueName }, stamp);
+    }
+    async ensureEventBridge() {
+        const cleanup = this.eventBridgeCleanup;
+        if (cleanup) {
+            await cleanup;
+            return this.ensureEventBridge();
+        }
+        if (this.eventBridgeConnected)
+            return;
+        if (this.eventBridgeSetup)
+            return this.eventBridgeSetup;
+        this.eventBridgeClosing = false;
+        let remover;
+        const setupOperation = Promise.resolve().then(async () => {
+            remover = this.eventBridge.onMessage('worker.jobs', (message) => {
+                if (this.eventBridgeClosing)
+                    return;
+                const workerEvent = toWorkerJobEvent(message);
+                if (!workerEvent)
+                    return;
+                if (workerEvent.workerId !== this.queueName && workerEvent.type !== 'job.queued')
+                    return;
+                this.emitEvent(toJobEvent(workerEvent));
+            });
+            this.unsubscribeEvents = remover;
+            await this.eventBridge.prepare();
+            if (!this.eventBridgeClosing)
+                this.eventBridgeConnected = true;
+        });
+        let setup;
+        setup = setupOperation.then(() => undefined, async (error) => {
+            this.eventBridgeConnected = false;
+            if (this.unsubscribeEvents === remover)
+                this.unsubscribeEvents = undefined;
+            const failure = valueFreeFailure(CaughtFailureSchema.parse(error));
+            this.diagnostics.error('Kafka event bridge setup failed', {
+                scope: 'workers-kafka:queue', plugin: 'worker-adapter.kafka', error: failure
+            });
+            if (!remover)
+                throw error;
+            try {
+                await Promise.resolve().then(remover);
+            }
+            catch (cleanupFailure) {
+                const cleanupFailureSummary = valueFreeFailure(CaughtFailureSchema.parse(cleanupFailure));
+                this.diagnostics.error('Kafka event bridge setup cleanup failed', {
+                    scope: 'workers-kafka:queue', plugin: 'worker-adapter.kafka', error: cleanupFailureSummary
+                });
+                throw new AggregateError([error, cleanupFailure], 'Kafka event bridge setup and cleanup failed.', {
+                    cause: error
+                });
+            }
+            throw error;
+        }).finally(() => {
+            if (this.eventBridgeSetup === setup)
+                this.eventBridgeSetup = undefined;
+        });
+        this.eventBridgeSetup = setup;
+        return setup;
+    }
+    emitEvent(event) {
+        const handlers = [...(this.eventHandlers.get(event.jobId) ?? []), ...(this.eventHandlers.get('*') ?? [])];
+        for (const handler of handlers)
+            this.notifyEventHandler(handler, event);
+    }
+    /** A failing subscriber is reported; the committed admission and its sibling subscribers stand. */
+    notifyEventHandler(handler, event) {
+        try {
+            handler(event);
+        }
+        catch (error) {
+            this.diagnostics.error('Kafka post-admission subscriber delivery failed', {
+                scope: 'workers-kafka:queue', plugin: 'worker-adapter.kafka',
+                error: CaughtFailureSchema.parse(error)
+            });
+        }
+    }
+}
+//# sourceMappingURL=provider.js.map