@voltro/plugin-queue 0.53.0

package/dist/index.d.ts

@@ -0,0 +1,284 @@
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Schema } from 'effect';
+import { VoltroPlugin } from '@voltro/protocol';
+
+/** The provider the running `queuePlugin` connected — for the outbox handler
+ *  and the cdc sink, which are constructed in app files where the plugin
+ *  instance is not in scope. */
+export declare const activeQueueProvider: () => QueueProvider;
+
+declare interface CdcSinkRecord {
+    readonly table: string;
+    readonly op: 'insert' | 'update' | 'delete';
+    readonly key: string;
+    readonly data: Record<string, unknown> | null;
+    readonly deliveryKey: string;
+}
+
+/**
+ * Declare one queue consumer. One per `*.consumer.ts` file, exported —
+ * loading the module registers it; the queue plugin starts it.
+ */
+export declare const defineQueueConsumer: <A>(definition: QueueConsumerDefinition<A>) => QueueConsumerDefinition<A>;
+
+export declare const kafkaProvider: (config: KafkaProviderConfig) => QueueProvider;
+
+export declare interface KafkaProviderConfig {
+    readonly brokers: ReadonlyArray<string>;
+    readonly clientId?: string;
+    readonly ssl?: boolean;
+    readonly sasl?: {
+        readonly mechanism: 'plain' | 'scram-sha-256' | 'scram-sha-512';
+        readonly username: string;
+        readonly password: string;
+    };
+    /** Partitions consumed in parallel per consumer (default 3). Within one
+     *  partition processing is ALWAYS serial — see the header. */
+    readonly partitionsConsumedConcurrently?: number;
+}
+
+/**
+ * A `CdcSink` producing each record to `topic`: message key = the source
+ * row's id (so one row's changes stay in one partition, ordered), value =
+ * the record JSON, `x-voltro-delivery-key` header = cdc-out's at-least-once
+ * dedupe handle (a consumer that upserts on it collapses retries).
+ */
+export declare const kafkaSink: (options: KafkaSinkOptions) => {
+    readonly name: string;
+    readonly deliver: (batch: ReadonlyArray<CdcSinkRecord>) => Promise<void>;
+    readonly outboundHost?: string;
+};
+
+declare interface KafkaSinkOptions {
+    readonly topic: string;
+    /** Explicit provider — defaults to the running queuePlugin's. */
+    readonly provider?: QueueProvider;
+}
+
+export declare interface QueueConsumeHandle {
+    /** Settles after the consumer left the group and in-flight work stopped. */
+    readonly stop: () => Promise<void>;
+}
+
+export declare interface QueueConsumeOptions {
+    readonly topic: string;
+    readonly groupId: string;
+    readonly fromBeginning?: boolean;
+    /**
+     * Called once per message, SERIALLY PER PARTITION — parallelism exists only
+     * ACROSS partitions. The provider commits the message's offset after this
+     * resolves; a rejection stops the batch without committing, so the message
+     * redelivers (at-least-once). Ordering + commit semantics both depend on
+     * this seriality; concurrency inside a partition would destroy both.
+     */
+    readonly onMessage: (message: QueueIncomingMessage, ctx: {
+        /** Keep the group session alive during a long handler. */
+        readonly heartbeat: () => Promise<void>;
+        /** `true` when the partition was revoked mid-batch (a rebalance): the
+         *  remaining messages belong to their NEW owner — stop without treating
+         *  it as a handler failure. */
+        readonly isStale: () => boolean;
+    }) => Promise<void>;
+}
+
+export declare interface QueueConsumerContext {
+    readonly topic: string;
+    readonly partition: number;
+    readonly offset: string;
+    readonly key: string | null;
+    readonly headers: Readonly<Record<string, string>>;
+    /** Delivery attempt within THIS process, 1-based. Redelivery after a crash
+     *  starts at 1 again — the at-least-once contract. */
+    readonly attempt: number;
+    /** W3C `traceparent` from the message headers, when the producer sent one —
+     *  pass it on for cross-system trace continuity. */
+    readonly traceparent?: string;
+    /** The app's data store — what a consumer writes its results through.
+     *  Reads and writes are NOT wrapped in a transaction by the framework
+     *  (the documented HTTP-handler boundary); a handler needing atomicity
+     *  opens `store.transactional` itself, and MUST be idempotent either way
+     *  (at-least-once delivery). Throws if the plugin has no bound store yet
+     *  (a message arriving before boot finished — the retry absorbs it). */
+    readonly store: DataStore;
+}
+
+export declare interface QueueConsumerDefinition<A = unknown> {
+    /** The topic to consume. */
+    readonly topic: string;
+    /** Consumer group id. Default: `<appName>.<topic>` at runtime — every
+     *  replica of one app shares the group (Kafka coordinates the partitions;
+     *  no advisory lock needed, unlike schedules). */
+    readonly groupId?: string;
+    /** Decode of the message VALUE (JSON-parsed first). A message that fails
+     *  to parse or decode goes STRAIGHT to the dead-letter topic with the
+     *  reason — never into the retry loop (a decode failure is deterministic;
+     *  retrying it is an infinite loop with extra steps). */
+    readonly schema: Schema.Schema<A, any, never>;
+    /**
+     * The handler. Runs SERIALLY PER PARTITION; its offset commits only after
+     * it resolves. It MUST be idempotent: delivery is at-least-once, and a
+     * crash between "handled" and "committed" redelivers.
+     *
+     * NOT wrapped in a store transaction by the framework (same documented
+     * boundary as HTTP route handlers): a handler doing multiple writes that
+     * must be atomic opens its own `store.transactional`.
+     */
+    readonly handler: (message: A, ctx: QueueConsumerContext) => Promise<void>;
+    /** In-process retry attempts before dead-lettering (default 3). Backoff
+     *  BLOCKS the partition on purpose — ordering is the contract. */
+    readonly maxAttempts?: number;
+    /** Dead-letter topic (default `<topic>.dlq`). */
+    readonly dlqTopic?: string;
+    /** Read the topic from the beginning on first group join (default false). */
+    readonly fromBeginning?: boolean;
+}
+
+export declare interface QueueConsumersHandle {
+    readonly stop: () => Promise<void>;
+}
+
+/** One message as the transport hands it to the framework. */
+export declare interface QueueIncomingMessage {
+    readonly topic: string;
+    readonly partition: number;
+    readonly offset: string;
+    readonly key: string | null;
+    /** Raw value bytes as a UTF-8 string (Kafka values are bytes; the framework
+     *  layer owns JSON parsing + Schema decoding). */
+    readonly value: string | null;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly timestamp: string;
+}
+
+/** Per-process counters, keyed by topic — the inspect endpoint reads them. */
+export declare const queueMetrics: () => QueueMetricsSlot;
+
+declare interface QueueMetricsSlot {
+    consumed: Record<string, number>;
+    dlq: Record<string, number>;
+    retried: Record<string, number>;
+    lastError: Record<string, string>;
+    produced: Record<string, number>;
+}
+
+/**
+ * The `*.outbox.ts` handler that makes producing TRANSACTIONAL: a mutation
+ * calls `ctx.outbox.enqueue('queue.produce', { topic, messages })` inside its
+ * transaction — the intent commits or rolls back WITH the domain write, and
+ * the outbox runner delivers it (batched `produce`, at-least-once, retried,
+ * dead-lettered) after commit. One durability path: the existing outbox, not
+ * a second one.
+ *
+ *   // src/queue.outbox.ts
+ *   import { queueOutboxHandler } from '@voltro/plugin-queue'
+ *   export default queueOutboxHandler()
+ */
+export declare const queueOutboxHandler: () => {
+    readonly effect: "queue.produce";
+    readonly handler: (ctx: {
+        readonly payload: Record<string, unknown>;
+    }) => Promise<void>;
+    readonly maxAttempts: number;
+};
+
+/** One message to produce. */
+export declare interface QueueOutgoingMessage {
+    readonly key?: string;
+    readonly value: string;
+    readonly headers?: Readonly<Record<string, string>>;
+}
+
+/**
+ * Queue interop against an existing Kafka. Consumers come from
+ * `*.consumer.ts` files (`defineQueueConsumer`) — discovered by both boot
+ * paths, started at activation, stopped at deactivation (the runner hands
+ * its teardown over at construction; a consumer that outlives
+ * `store.close()` is the rolling-deploy leak).
+ *
+ * Replica coordination is Kafka's own: every replica joins the same consumer
+ * GROUP and the broker assigns partitions — no advisory lock, unlike
+ * schedules (which coordinate through the claim table because there is no
+ * broker to do it).
+ */
+export declare const queuePlugin: (config: QueuePluginConfig) => VoltroPlugin;
+
+export declare interface QueuePluginConfig extends KafkaProviderConfig {
+    /** Instance alias (default `queue`). */
+    readonly name?: string;
+    /** Consumer-group prefix — defaults to the app name at activation. */
+    readonly groupPrefix?: string;
+    /** Injectable for tests. */
+    readonly retryBaseMs?: number;
+}
+
+/**
+ * A queue transport. `kafkaProvider` is the shipped implementation; the
+ * methods are exactly what the framework layer (consumer runner, outbox
+ * bridge, cdc sink) needs — connect, produce (batched), consume, and a
+ * DLQ publish that is just `produce` to the dead-letter topic.
+ */
+export declare interface QueueProvider {
+    readonly name: string;
+    /** Hosts the provider talks to — surfaced as network permissions. */
+    readonly hosts: ReadonlyArray<string>;
+    readonly connect: () => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    /** Produce a BATCH to one topic (one transport round-trip — the outbox
+     *  drain and the cdc sink both deliver batches). */
+    readonly produce: (topic: string, messages: ReadonlyArray<QueueOutgoingMessage>) => Promise<void>;
+    readonly consume: (options: QueueConsumeOptions) => Promise<QueueConsumeHandle>;
+    /** Create topics that don't exist yet (no-op for existing ones). NOT called
+     *  implicitly — an adopter's Kafka is foreign infrastructure, and whether a
+     *  client may create topics is their policy. Tests and bootstrap scripts
+     *  call it explicitly. */
+    readonly ensureTopics: (topics: ReadonlyArray<string>) => Promise<void>;
+}
+
+export declare interface QueueRunnerLogger {
+    info: (message: string, fields?: Record<string, unknown>) => void;
+    warn: (message: string, fields?: Record<string, unknown>) => void;
+    error: (message: string, fields?: Record<string, unknown>) => void;
+}
+
+/** `yield* QueueService` in a handler to produce directly. */
+export declare class QueueService extends QueueService_base {
+}
+
+declare const QueueService_base: Context.TagClass<QueueService, "@voltro/plugin-queue/QueueService", QueueServiceApi>;
+
+export declare interface QueueServiceApi {
+    /** Produce a batch to a topic (one transport round-trip). NOT transactional
+     *  with the surrounding mutation — for atomic produce-with-write, enqueue
+     *  through the outbox (`queueOutboxHandler`). */
+    readonly produce: (topic: string, messages: ReadonlyArray<QueueOutgoingMessage>) => Promise<void>;
+}
+
+/** All registered consumers — read by the plugin's activation. */
+export declare const registeredQueueConsumers: () => ReadonlyArray<QueueConsumerDefinition>;
+
+/** Test seam. */
+export declare const resetQueueConsumersForTest: () => void;
+
+/**
+ * Start one provider consumer per registered definition. Returns the handle
+ * whose `stop()` leaves every group — the plugin takes this at CONSTRUCTION
+ * and registers it for shutdown (the `startOutboxRunner` onShutdown pattern:
+ * a runner that outlives `store.close()` is the rolling-deploy leak).
+ */
+export declare const startQueueConsumers: (args: StartQueueConsumersArgs) => Promise<QueueConsumersHandle>;
+
+export declare interface StartQueueConsumersArgs {
+    readonly provider: QueueProvider;
+    readonly consumers: ReadonlyArray<QueueConsumerDefinition<any>>;
+    readonly appName: string;
+    readonly log: QueueRunnerLogger;
+    /** The bound store, read LAZILY per message — binding may complete after
+     *  the consumers started. */
+    readonly store: () => DataStore | null;
+    /** Base backoff (ms) between handler retries; attempt N waits base·2^(N-1).
+     *  Injectable so tests don't wait wall-clock seconds. */
+    readonly retryBaseMs?: number;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,303 @@
+import { Context as e, Effect as t, Layer as n, Schema as r } from "effect";
+import { definePlugin as i } from "@voltro/protocol";
+import { Kafka as a, logLevel as o } from "kafkajs";
+//#region src/consumer.ts
+var s = Symbol.for("@voltro/plugin-queue:consumers"), c = () => {
+	let e = globalThis;
+	return e[s] ??= /* @__PURE__ */ new Map();
+}, l = (e) => {
+	if (e.topic.trim() === "") throw Error("defineQueueConsumer: `topic` must be a non-empty name");
+	if (e.maxAttempts !== void 0 && e.maxAttempts < 1) throw Error(`defineQueueConsumer("${e.topic}"): maxAttempts must be >= 1`);
+	let t = `${e.topic}|${e.groupId ?? ""}`, n = c().get(t);
+	if (n !== void 0 && n !== e) throw Error(`defineQueueConsumer: topic '${e.topic}'${e.groupId ? ` group '${e.groupId}'` : ""} is declared twice — two consumers in one group on one topic would split its partitions unpredictably. Use a distinct groupId for an independent consumer.`);
+	return c().set(t, e), e;
+}, u = () => [...c().values()], d = () => {
+	c().clear();
+}, f = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e ?? {})) r != null && (t[n] = Buffer.isBuffer(r) ? r.toString("utf8") : String(r));
+	return t;
+}, p = (e) => {
+	let t = new a({
+		clientId: e.clientId ?? "voltro",
+		brokers: [...e.brokers],
+		logLevel: o.ERROR,
+		...e.ssl === void 0 ? {} : { ssl: e.ssl },
+		...e.sasl === void 0 ? {} : { sasl: e.sasl }
+	}), n = null, r = /* @__PURE__ */ new Set();
+	return {
+		name: "kafka",
+		hosts: e.brokers.map((e) => e.split("/").pop() ?? e),
+		connect: async () => {
+			n === null && (n = t.producer({ allowAutoTopicCreation: !0 }), await n.connect());
+		},
+		disconnect: async () => {
+			let e = n;
+			n = null, await Promise.all([...r].map((e) => e.disconnect().catch(() => {}))), r.clear(), e !== null && await e.disconnect().catch(() => {});
+		},
+		produce: async (e, t) => {
+			if (n === null) throw Error("kafkaProvider: produce before connect()");
+			await n.send({
+				topic: e,
+				messages: t.map((e) => ({
+					...e.key === void 0 ? {} : { key: e.key },
+					value: e.value,
+					...e.headers === void 0 ? {} : { headers: { ...e.headers } }
+				}))
+			});
+		},
+		ensureTopics: async (e) => {
+			let n = t.admin();
+			await n.connect();
+			try {
+				await n.createTopics({
+					topics: e.map((e) => ({
+						topic: e,
+						numPartitions: 1
+					})),
+					waitForLeaders: !0
+				});
+			} finally {
+				await n.disconnect();
+			}
+		},
+		consume: async (n) => {
+			let i = t.consumer({ groupId: n.groupId });
+			return r.add(i), await i.connect(), await i.subscribe({
+				topic: n.topic,
+				fromBeginning: n.fromBeginning ?? !1
+			}), await i.run({
+				eachBatchAutoResolve: !1,
+				partitionsConsumedConcurrently: e.partitionsConsumedConcurrently ?? 3,
+				eachBatch: async ({ batch: e, resolveOffset: t, commitOffsetsIfNecessary: r, heartbeat: i, isRunning: a, isStale: o }) => {
+					for (let s of e.messages) {
+						if (!a() || o()) return;
+						let c = {
+							topic: e.topic,
+							partition: e.partition,
+							offset: s.offset,
+							key: s.key === null ? null : s.key.toString("utf8"),
+							value: s.value === null ? null : s.value.toString("utf8"),
+							headers: f(s.headers),
+							timestamp: s.timestamp
+						};
+						await n.onMessage(c, {
+							heartbeat: i,
+							isStale: o
+						}), t(s.offset), await r();
+					}
+				}
+			}), { stop: async () => {
+				r.delete(i), await i.disconnect().catch(() => {});
+			} };
+		}
+	};
+}, m = Symbol.for("@voltro/plugin-queue:metrics"), h = () => {
+	let e = globalThis;
+	return e[m] ??= {
+		consumed: {},
+		dlq: {},
+		retried: {},
+		lastError: {},
+		produced: {}
+	};
+}, g = (e, t) => {
+	e[t] = (e[t] ?? 0) + 1;
+}, _ = (e) => new Promise((t) => setTimeout(t, e)), v = async (e) => {
+	let { provider: t, log: n } = e, i = h(), a = { current: !1 }, o = /* @__PURE__ */ new Set(), s = async (a) => {
+		let o = a.groupId ?? `${e.appName}.${a.topic}`, s = a.dlqTopic ?? `${a.topic}.dlq`, c = a.maxAttempts ?? 3, l = r.decodeUnknownEither(a.schema), u = async (e, r, o) => {
+			g(i.dlq, a.topic), i.lastError[a.topic] = `${e}: ${r}`.slice(0, 500), n.warn("queue: dead-lettered", {
+				topic: a.topic,
+				dlqTopic: s,
+				reason: e,
+				partition: o.partition,
+				offset: o.offset
+			}), await t.produce(s, [{
+				...o.key === null ? {} : { key: o.key },
+				value: o.value ?? "",
+				headers: {
+					...o.headers,
+					"x-voltro-dlq-reason": e,
+					"x-voltro-dlq-detail": r.slice(0, 500),
+					"x-voltro-dlq-source-topic": o.topic,
+					"x-voltro-dlq-source-partition": String(o.partition),
+					"x-voltro-dlq-source-offset": o.offset
+				}
+			}]);
+		}, d = await t.consume({
+			topic: a.topic,
+			groupId: o,
+			...a.fromBeginning === void 0 ? {} : { fromBeginning: a.fromBeginning },
+			onMessage: async (t, r) => {
+				let o;
+				try {
+					o = t.value === null ? null : JSON.parse(t.value);
+				} catch (e) {
+					await u("decode-failed", `invalid JSON: ${e instanceof Error ? e.message : String(e)}`, t);
+					return;
+				}
+				let s = l(o);
+				if (s._tag === "Left") {
+					await u("decode-failed", String(s.left), t);
+					return;
+				}
+				for (let o = 1; o <= c; o++) {
+					if (r.isStale()) return;
+					try {
+						await a.handler(s.right, {
+							topic: t.topic,
+							partition: t.partition,
+							offset: t.offset,
+							key: t.key,
+							headers: t.headers,
+							attempt: o,
+							...t.headers.traceparent === void 0 ? {} : { traceparent: t.headers.traceparent },
+							get store() {
+								let t = e.store();
+								if (t === null) throw Error("queue: store not bound yet — the retry loop absorbs a message arriving before boot finished");
+								return t;
+							}
+						}), g(i.consumed, a.topic);
+						return;
+					} catch (s) {
+						let l = s instanceof Error ? s.message : String(s);
+						if (o >= c) {
+							await u("handler-failed", l, t);
+							return;
+						}
+						g(i.retried, a.topic), n.warn("queue: handler failed, retrying", {
+							topic: a.topic,
+							attempt: o,
+							maxAttempts: c,
+							detail: l
+						}), await r.heartbeat().catch(() => {}), await _((e.retryBaseMs ?? 1e3) * 2 ** (o - 1));
+					}
+				}
+			}
+		});
+		return n.info("queue: consumer started", {
+			topic: a.topic,
+			groupId: o,
+			dlqTopic: s
+		}), d;
+	}, c = e.consumers.map((e) => {
+		let t = { handle: null }, r = () => {
+			s(e).then((e) => {
+				if (a.current) {
+					e.stop();
+					return;
+				}
+				t.handle = e;
+			}).catch((t) => {
+				if (a.current) return;
+				n.warn("queue: consumer start failed — retrying in 5s", {
+					topic: e.topic,
+					detail: t instanceof Error ? t.message : String(t)
+				});
+				let i = setTimeout(() => {
+					o.delete(i), r();
+				}, 5e3);
+				o.add(i);
+			});
+		};
+		return r(), t;
+	});
+	return { stop: async () => {
+		a.current = !0;
+		for (let e of o) clearTimeout(e);
+		o.clear(), await Promise.all(c.map((e) => e.handle?.stop() ?? Promise.resolve()));
+	} };
+}, y = (e) => {
+	let t = () => e.provider ?? C();
+	return {
+		name: `kafka(${e.topic})`,
+		...e.provider !== void 0 && e.provider.hosts[0] !== void 0 ? { outboundHost: e.provider.hosts[0] } : {},
+		deliver: async (n) => {
+			await t().produce(e.topic, n.map((e) => ({
+				key: e.key,
+				value: JSON.stringify({
+					table: e.table,
+					op: e.op,
+					key: e.key,
+					data: e.data
+				}),
+				headers: { "x-voltro-delivery-key": e.deliveryKey }
+			})));
+		}
+	};
+}, b = class extends e.Tag("@voltro/plugin-queue/QueueService")() {}, x = Symbol.for("@voltro/plugin-queue:active-provider"), S = () => {
+	let e = globalThis;
+	return e[x] ??= { current: null };
+}, C = () => {
+	let e = S().current;
+	if (e === null) throw Error("[voltro] no active queue provider — is queuePlugin({...}) in this app's plugins? The outbox handler and kafkaSink need the plugin's connected provider.");
+	return e;
+}, w = () => ({
+	effect: "queue.produce",
+	maxAttempts: 8,
+	handler: async ({ payload: e }) => {
+		let t = e.topic, n = e.messages;
+		if (typeof t != "string" || !Array.isArray(n)) throw Error("queue.produce payload must be { topic: string, messages: QueueOutgoingMessage[] }");
+		await C().produce(t, n);
+		let r = h();
+		r.produced[t] = (r.produced[t] ?? 0) + n.length;
+	}
+}), T = (e) => {
+	let r = e.name ?? "queue", a = p(e), o = ["inspect:read", ...a.hosts.map((e) => `network:outbound:${e}`)], s = null, c = { current: null };
+	return i({
+		name: r,
+		baseName: "queue",
+		description: "Queue interop — consume and produce against an existing Kafka: Schema-decoded consumers (at-least-once, serial per partition, retry + dead-letter), batched producing via a handler service or transactionally through the outbox, and a kafkaSink for plugin-cdc-out.",
+		permissions: o,
+		services: n.succeed(b, { produce: (e, t) => a.produce(e, t) }),
+		bindDataStore: (e) => {
+			c.current = e;
+		},
+		onActivate: (n) => t.tryPromise(async () => {
+			await a.connect(), S().current = a;
+			let t = u();
+			s = await v({
+				provider: a,
+				consumers: t,
+				appName: e.groupPrefix ?? n.app.name,
+				log: n.logger,
+				store: () => c.current,
+				...e.retryBaseMs === void 0 ? {} : { retryBaseMs: e.retryBaseMs }
+			}), n.logger.info("queue: connected", {
+				brokers: a.hosts,
+				consumers: t.length
+			});
+		}),
+		onDeactivate: () => t.tryPromise(async () => {
+			await s?.stop(), s = null, S().current === a && (S().current = null), await a.disconnect();
+		}),
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/consumers",
+			description: "Registered consumers + per-topic consumed/retried/dead-lettered/produced counters (this replica).",
+			handler: () => t.sync(() => {
+				let e = h();
+				return {
+					kind: "json",
+					data: {
+						connected: S().current !== null,
+						brokers: a.hosts,
+						consumers: u().map((t) => ({
+							topic: t.topic,
+							groupId: t.groupId ?? null,
+							dlqTopic: t.dlqTopic ?? `${t.topic}.dlq`,
+							maxAttempts: t.maxAttempts ?? 3,
+							consumed: e.consumed[t.topic] ?? 0,
+							retried: e.retried[t.topic] ?? 0,
+							deadLettered: e.dlq[t.topic] ?? 0,
+							lastError: e.lastError[t.topic] ?? null
+						})),
+						produced: e.produced
+					}
+				};
+			})
+		}]
+	});
+};
+//#endregion
+export { b as QueueService, C as activeQueueProvider, l as defineQueueConsumer, p as kafkaProvider, y as kafkaSink, h as queueMetrics, w as queueOutboxHandler, T as queuePlugin, u as registeredQueueConsumers, d as resetQueueConsumersForTest, v as startQueueConsumers };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@voltro/plugin-queue",
+  "version": "0.53.0",
+  "description": "Queue interop — consume and produce against an existing Kafka: Schema-decoded consumers via defineQueueConsumer (*.consumer.ts; at-least-once, serial per partition, retry + dead-letter), batched producing via QueueService or transactionally through the outbox (queueOutboxHandler), and a kafkaSink for plugin-cdc-out.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/protocol": "0.53.0",
+    "kafkajs": "^2.2.4",
+    "@voltro/database": "0.53.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.22.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}