@babelqueue/bullmq 1.0.1 → 1.2.0

package/README.md

@@ -39,15 +39,54 @@ new Worker(
 );
 ```
 
-`processor` validates each envelope (`EnvelopeCodec.accepts`) and routes by URN; a
-non-conformant envelope throws (BullMQ retries/fails per its options), and an
-unmapped URN throws unless you pass `onUnknownUrn`.
+`processor` validates each envelope (`EnvelopeCodec.accepts`) and routes by URN. A
+non-conformant envelope is **poison** (ADR-0037 decision 3): it fails with BullMQ's
+`UnrecoverableError` — **no retry**, straight to BullMQ's failed set, which keeps the job data. An
+unmapped URN, an exhausted handler failure and a throwing handler keep BullMQ's own retry and
+failed-set behaviour; an unmapped URN throws unless you pass `onUnknownUrn`.
+
+To also keep poison jobs in a BabelQueue dead-letter queue, pass `deadLetterQueue` (opt-in):
+
+```ts
+const handler = processor(handlers, {
+  deadLetterQueue: true, // a Queue instance, a queue name, or `true` for "<queue>.dlq"
+  onError: (error, job) => console.error("DLQ add failed", job.id, error),
+});
+new Worker("orders", handler, { connection });
+// on shutdown: await handler.close(); // closes a Queue the adapter created (string / true)
+```
+
+The [ADR-0035](https://babelqueue.com) record (`dead_letter.reason: "poison"`: an object body is spliced
+with a `dead_letter` block, anything else wrapped in `raw`) is added to that queue as a job, named like the
+poison job, **before** the job fails. A `Queue` instance is used as given; a name or `true` creates a `Queue`
+on the worker's connection and prefix (one per queue name, so a processor shared by several Workers sends each queue's records to its own `<queue>.dlq`). If adding the record fails, the failure goes to `onError` and the job
+still fails as unrecoverable. The body fed to the record rule is the job data serialised as JSON, and
+BullMQ has already parsed what it stored, so a value `JSON.parse` cannot carry (`1e400`, an integer beyond
+2^53) is lost before the adapter sees it — a property of BullMQ.
 
 > BullMQ stores jobs in its own Redis structures, so this gives the canonical
 > envelope **shape + URN routing + trace propagation** to BullMQ-based Node
 > services. For raw cross-language queues, other SDKs read/write plain broker
 > queues directly.
 
+## OpenTelemetry tracing (ADR-0028)
+
+Cross-hop **span** linkage rides on the out-of-band `HeaderCarrier` from
+[`@babelqueue/core@^1.4.0`](https://www.npmjs.com/package/@babelqueue/core). Pass the carrier produced by
+`@babelqueue/core/otel`'s `publish` to this adapter's `publish({ headers })`; it is carried on
+BullMQ's native `telemetry.metadata` job-options slot (so the envelope — `job.data` — is never touched). On consume, the `processor` surfaces a delivered job's headers to the handler's third argument (and `headersOf(job)` reads them back),
+so the core's `otel` `wrapHandler` starts the consumer span as a true **child** of the producer span.
+
+```ts
+import { trace } from "@opentelemetry/api";
+import { publish as tracedPublish } from "@babelqueue/core/otel";
+import type { HeaderCarrier } from "@babelqueue/core";
+
+const headers: HeaderCarrier = {};
+await tracedPublish(trace.getTracer("orders"), urn, data,
+  () => adapterPublish(urn, data, { headers }), { headers });
+```
+
 ## License
 
 [MIT](../../LICENSE) © Muhammet Şafak · [babelqueue.com](https://babelqueue.com)

package/dist/index.cjs

@@ -20,26 +20,109 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  decodeMetadata: () => decodeMetadata,
+  encodeMetadata: () => encodeMetadata,
+  headersOf: () => headersOf,
   processor: () => processor,
   publish: () => publish
 });
 module.exports = __toCommonJS(index_exports);
 var import_core = require("@babelqueue/core");
+var import_bullmq = require("bullmq");
+
+// src/headers.ts
+function sanitizeHeaders(headers) {
+  const out = {};
+  if (!headers) return out;
+  for (const key of Object.keys(headers)) {
+    const value = headers[key];
+    if (key === "" || value == null || value === "") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function encodeMetadata(headers) {
+  const clean = sanitizeHeaders(headers);
+  return Object.keys(clean).length === 0 ? void 0 : JSON.stringify(clean);
+}
+function decodeMetadata(metadata) {
+  if (!metadata) return {};
+  try {
+    const parsed = JSON.parse(metadata);
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return sanitizeHeaders(parsed);
+  } catch {
+    return {};
+  }
+}
+
+// src/index.ts
+function headersOf(job) {
+  return decodeMetadata(job.opts?.telemetry?.metadata);
+}
 async function publish(queue, urn, data, options = {}) {
   const envelope = import_core.EnvelopeCodec.make(urn, data, {
     queue: queue.name,
     traceId: options.traceId
   });
-  await queue.add(urn, envelope, options.jobsOptions);
+  await queue.add(urn, envelope, withHeaders(options.jobsOptions, options.headers));
   return envelope.meta.id;
 }
+function withHeaders(jobsOptions, headers) {
+  const metadata = encodeMetadata(headers);
+  if (metadata === void 0) return jobsOptions;
+  const telemetry = jobsOptions?.telemetry;
+  if (telemetry?.metadata != null) return jobsOptions;
+  return { ...jobsOptions, telemetry: { ...telemetry, metadata } };
+}
+function workerQueueOptions(job) {
+  const opts = job.queue?.opts;
+  return { connection: opts?.connection, ...opts?.prefix === void 0 ? {} : { prefix: opts.prefix } };
+}
 function processor(handlers, options = {}) {
-  return async (job) => {
+  const created = /* @__PURE__ */ new Map();
+  const resolveDeadLetterQueue = (job) => {
+    const target = options.deadLetterQueue;
+    if (target === void 0) return void 0;
+    if (typeof target === "object") return target;
+    const name = target === true ? `${job.queueName}.dlq` : target;
+    const queueOptions = workerQueueOptions(job);
+    const key = `${queueOptions.prefix ?? ""}\0${name}`;
+    let queue = created.get(key);
+    if (queue === void 0) {
+      queue = new import_bullmq.Queue(name, queueOptions);
+      created.set(key, queue);
+    }
+    return queue;
+  };
+  const deadLetterPoison = async (job, error) => {
+    try {
+      const dlq = resolveDeadLetterQueue(job);
+      if (dlq === void 0) return;
+      const body = JSON.stringify(job.data) ?? "null";
+      const delivered = typeof job.attemptsMade === "number" ? job.attemptsMade : 0;
+      const deadLetter = (0, import_core.annotate)({ attempts: delivered }, "poison", options.queue ?? job.queueName, {
+        attempts: delivered,
+        error: error.message,
+        exception: error.name
+      }).dead_letter;
+      const record = (0, import_core.buildPoisonRecord)(Buffer.from(body, "utf8"), JSON.stringify(deadLetter));
+      await dlq.add(job.name, JSON.parse(record));
+    } catch (writeError) {
+      try {
+        options.onError?.(writeError, job);
+      } catch {
+      }
+    }
+  };
+  const run = async (job) => {
     const envelope = job.data;
     if (!import_core.EnvelopeCodec.accepts(envelope)) {
-      throw new import_core.BabelQueueError(
+      const error = new import_core.BabelQueueError(
         `Rejected a non-conformant BabelQueue envelope on job ${job.id ?? "?"}.`
       );
+      await deadLetterPoison(job, error);
+      throw new import_bullmq.UnrecoverableError(error.message);
     }
     const urn = import_core.EnvelopeCodec.urn(envelope);
     const handler = handlers[urn];
@@ -49,11 +132,21 @@ function processor(handlers, options = {}) {
       }
       throw new import_core.UnknownUrnError(urn);
     }
-    return handler(envelope, job);
+    return handler(envelope, job, headersOf(job));
   };
+  return Object.assign(run, {
+    async close() {
+      const queues = [...created.values()];
+      created.clear();
+      await Promise.all(queues.map((queue) => queue.close()));
+    }
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  decodeMetadata,
+  encodeMetadata,
+  headersOf,
   processor,
   publish
 });

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * BullMQ adapter for BabelQueue.\n *\n * It makes your BullMQ jobs carry the canonical BabelQueue envelope and routes\n * them by URN, so a BullMQ-based Node service speaks the same contract (envelope\n * shape, URN identity, trace propagation) as the PHP/Laravel, Python, Go, Java and\n * .NET SDKs.\n *\n *     import { Queue, Worker } from \"bullmq\";\n *     import { publish, processor } from \"@babelqueue/bullmq\";\n *\n *     const queue = new Queue(\"orders\", { connection });\n *     await publish(queue, \"urn:babel:orders:created\", { order_id: 1042 });\n *\n *     new Worker(\"orders\", processor({\n *       \"urn:babel:orders:created\": async (env) => { ... },\n *     }), { connection });\n */\n\nimport {\n  BabelQueueError,\n  EnvelopeCodec,\n  UnknownUrnError,\n  type Envelope,\n  type IncomingEnvelope,\n} from \"@babelqueue/core\";\nimport type { Job, JobsOptions, Queue } from \"bullmq\";\n\n/** A URN handler. Receives the validated envelope and the raw BullMQ job. */\nexport type BabelHandler = (envelope: Envelope, job: Job) => unknown | Promise<unknown>;\n\n/** A map of URN → handler. */\nexport type BabelHandlers = Record<string, BabelHandler>;\n\n/** Options for {@link publish}. */\nexport interface PublishOptions {\n  /** Reuse an existing trace id (trace continuation). */\n  traceId?: string;\n  /** BullMQ job options (delay, attempts, backoff, …). */\n  jobsOptions?: JobsOptions;\n}\n\n/**\n * Build the canonical envelope for `(urn, data)` and add it as a BullMQ job (the\n * job name is the URN, the job data is the envelope). Returns the message id\n * (`meta.id`).\n */\nexport async function publish(\n  queue: Queue,\n  urn: string,\n  data: Record<string, unknown>,\n  options: PublishOptions = {},\n): Promise<string> {\n  const envelope = EnvelopeCodec.make(urn, data, {\n    queue: queue.name,\n    traceId: options.traceId,\n  });\n  await queue.add(urn, envelope, options.jobsOptions);\n  return envelope.meta.id;\n}\n\n/** Options for {@link processor}. */\nexport interface ProcessorOptions {\n  /** Called instead of throwing when a job's URN has no handler. */\n  onUnknownUrn?: (envelope: IncomingEnvelope, job: Job) => unknown | Promise<unknown>;\n}\n\n/**\n * Build a BullMQ processor that decodes each job's envelope, validates it, and\n * routes it to the handler registered for its URN. A non-conformant envelope\n * throws (so BullMQ retries / fails the job per its options); an unmapped URN\n * throws unless `onUnknownUrn` is given.\n *\n *     new Worker(\"orders\", processor(handlers), { connection });\n */\nexport function processor(\n  handlers: BabelHandlers,\n  options: ProcessorOptions = {},\n): (job: Job) => Promise<unknown> {\n  return async (job: Job): Promise<unknown> => {\n    const envelope = job.data as IncomingEnvelope;\n\n    if (!EnvelopeCodec.accepts(envelope)) {\n      throw new BabelQueueError(\n        `Rejected a non-conformant BabelQueue envelope on job ${job.id ?? \"?\"}.`,\n      );\n    }\n\n    const urn = EnvelopeCodec.urn(envelope);\n    const handler = handlers[urn];\n    if (!handler) {\n      if (options.onUnknownUrn) {\n        return options.onUnknownUrn(envelope, job);\n      }\n      throw new UnknownUrnError(urn);\n    }\n\n    return handler(envelope, job);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBA,kBAMO;AAsBP,eAAsB,QACpB,OACA,KACA,MACA,UAA0B,CAAC,GACV;AACjB,QAAM,WAAW,0BAAc,KAAK,KAAK,MAAM;AAAA,IAC7C,OAAO,MAAM;AAAA,IACb,SAAS,QAAQ;AAAA,EACnB,CAAC;AACD,QAAM,MAAM,IAAI,KAAK,UAAU,QAAQ,WAAW;AAClD,SAAO,SAAS,KAAK;AACvB;AAgBO,SAAS,UACd,UACA,UAA4B,CAAC,GACG;AAChC,SAAO,OAAO,QAA+B;AAC3C,UAAM,WAAW,IAAI;AAErB,QAAI,CAAC,0BAAc,QAAQ,QAAQ,GAAG;AACpC,YAAM,IAAI;AAAA,QACR,wDAAwD,IAAI,MAAM,GAAG;AAAA,MACvE;AAAA,IACF;AAEA,UAAM,MAAM,0BAAc,IAAI,QAAQ;AACtC,UAAM,UAAU,SAAS,GAAG;AAC5B,QAAI,CAAC,SAAS;AACZ,UAAI,QAAQ,cAAc;AACxB,eAAO,QAAQ,aAAa,UAAU,GAAG;AAAA,MAC3C;AACA,YAAM,IAAI,4BAAgB,GAAG;AAAA,IAC/B;AAEA,WAAO,QAAQ,UAAU,GAAG;AAAA,EAC9B;AACF;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/headers.ts"],"sourcesContent":["/**\n * BullMQ adapter for BabelQueue.\n *\n * It makes your BullMQ jobs carry the canonical BabelQueue envelope and routes\n * them by URN, so a BullMQ-based Node service speaks the same contract (envelope\n * shape, URN identity, trace propagation) as the PHP/Laravel, Python, Go, Java and\n * .NET SDKs.\n *\n *     import { Queue, Worker } from \"bullmq\";\n *     import { publish, processor } from \"@babelqueue/bullmq\";\n *\n *     const queue = new Queue(\"orders\", { connection });\n *     await publish(queue, \"urn:babel:orders:created\", { order_id: 1042 });\n *\n *     new Worker(\"orders\", processor({\n *       \"urn:babel:orders:created\": async (env) => { ... },\n *     }), { connection });\n */\n\nimport {\n  BabelQueueError,\n  EnvelopeCodec,\n  UnknownUrnError,\n  annotate,\n  buildPoisonRecord,\n  type Envelope,\n  type HeaderCarrier,\n  type IncomingEnvelope,\n} from \"@babelqueue/core\";\nimport { Queue, UnrecoverableError } from \"bullmq\";\nimport type { Job, JobsOptions, QueueOptions } from \"bullmq\";\n\nimport { decodeMetadata, encodeMetadata } from \"./headers.js\";\n\nexport { decodeMetadata, encodeMetadata } from \"./headers.js\";\n\n/**\n * The out-of-band {@link HeaderCarrier} carried by a job, read from BullMQ's native\n * `telemetry.metadata` slot (`job.opts.telemetry.metadata`). Empty for a job published without\n * headers. Pass it to `@babelqueue/core/otel`'s `wrapHandler` to link the consumer span as a child\n * of the producer span (ADR-0028).\n */\nexport function headersOf(job: Job): HeaderCarrier {\n  return decodeMetadata(job.opts?.telemetry?.metadata);\n}\n\n/**\n * A URN handler. Receives the validated envelope, the raw BullMQ job, and the out-of-band\n * {@link HeaderCarrier} carried in the job's `telemetry.metadata` (empty when there are none).\n */\nexport type BabelHandler = (envelope: Envelope, job: Job, headers: HeaderCarrier) => unknown | Promise<unknown>;\n\n/** A map of URN → handler. */\nexport type BabelHandlers = Record<string, BabelHandler>;\n\n/** Options for {@link publish}. */\nexport interface PublishOptions {\n  /** Reuse an existing trace id (trace continuation). */\n  traceId?: string;\n  /** BullMQ job options (delay, attempts, backoff, …). */\n  jobsOptions?: JobsOptions;\n  /**\n   * Out-of-band transport headers carried in BullMQ's native `telemetry.metadata` slot (ADR-0028) —\n   * e.g. a W3C `traceparent` written by `@babelqueue/core/otel`'s `publish`. The canonical envelope\n   * (`job.data`) stays byte-identical (GR-1); an empty/omitted carrier leaves the job options\n   * unchanged. An explicit `jobsOptions.telemetry.metadata` wins (it is not clobbered).\n   */\n  headers?: HeaderCarrier;\n}\n\n/**\n * Build the canonical envelope for `(urn, data)` and add it as a BullMQ job (the\n * job name is the URN, the job data is the envelope). Returns the message id\n * (`meta.id`).\n *\n * When `options.headers` carries any out-of-band header (e.g. a `traceparent`) it is serialized\n * into the job's `telemetry.metadata` so a consumer can read it back via {@link headersOf} — the\n * envelope itself is never touched.\n */\nexport async function publish(\n  queue: Queue,\n  urn: string,\n  data: Record<string, unknown>,\n  options: PublishOptions = {},\n): Promise<string> {\n  const envelope = EnvelopeCodec.make(urn, data, {\n    queue: queue.name,\n    traceId: options.traceId,\n  });\n  await queue.add(urn, envelope, withHeaders(options.jobsOptions, options.headers));\n  return envelope.meta.id;\n}\n\n/**\n * Merge an out-of-band header carrier into a job's `telemetry.metadata` without clobbering an\n * explicit one the caller already set. Returns the original options unchanged when there is nothing\n * to carry, so a header-less publish stays byte-identical.\n */\nfunction withHeaders(jobsOptions: JobsOptions | undefined, headers: HeaderCarrier | undefined): JobsOptions | undefined {\n  const metadata = encodeMetadata(headers);\n  if (metadata === undefined) return jobsOptions;\n  const telemetry = jobsOptions?.telemetry;\n  if (telemetry?.metadata != null) return jobsOptions; // an explicit metadata wins (merge-not-clobber)\n  return { ...jobsOptions, telemetry: { ...telemetry, metadata } };\n}\n\n/** Options for {@link processor}. */\nexport interface ProcessorOptions {\n  /** Called instead of throwing when a job's URN has no handler. */\n  onUnknownUrn?: (envelope: IncomingEnvelope, job: Job) => unknown | Promise<unknown>;\n  /**\n   * A dead-letter queue for **poison** jobs (ADR-0037 decision 3; opt-in, absent = none): a job whose data does\n   * not decode into a valid envelope. When set, the ADR-0035 record (`reason: \"poison\"`, built with the core's\n   * `buildPoisonRecord`) is **also** added to it as a job before the job fails.\n   *\n   * - a BullMQ `Queue` instance is used as given;\n   * - a `string` is a queue name: the adapter creates a `Queue` with that name on the worker's connection;\n   * - `true` creates a `Queue` named `<queue>.dlq` (`<queue>` = the worker's queue name) on the worker's connection.\n   *\n   * A `Queue` the adapter creates is closed by the `close()` of the returned processor; a `Queue` instance you pass is yours to close.\n   * The job data is JSON that BullMQ has already parsed, so a value `JSON.parse` cannot carry (`1e400`, an integer\n   * beyond 2^53) is lost before the adapter sees it: a property of BullMQ, not of the record rule.\n   */\n  deadLetterQueue?: Queue | string | true;\n  /** The `dead_letter.original_queue` of a poison record. Defaults to the worker's queue name (`job.queueName`). */\n  queue?: string;\n  /** Called when adding the poison record to {@link deadLetterQueue} fails. The job still fails as unrecoverable. */\n  onError?: (error: unknown, job: Job) => void;\n}\n\n/** The worker's `Queue` connection options and prefix, read from the job's queue (BullMQ keeps them on `queue.opts`). */\nfunction workerQueueOptions(job: Job): QueueOptions {\n  const opts = (job as unknown as { queue?: { opts?: Partial<QueueOptions> } }).queue?.opts;\n  return { connection: opts?.connection as QueueOptions[\"connection\"], ...(opts?.prefix === undefined ? {} : { prefix: opts.prefix }) };\n}\n\n/**\n * Build a BullMQ processor that decodes each job's envelope, validates it, and\n * routes it to the handler registered for its URN. A **poison** job (data that is\n * not a valid envelope) fails with BullMQ's `UnrecoverableError` — no retry, straight\n * to the failed set (ADR-0037 decision 3), after the ADR-0035 record was added to the\n * optional `deadLetterQueue`; an unmapped URN throws unless `onUnknownUrn` is given\n * (BullMQ retries / fails the job per its options), as does a throwing handler.\n *\n *     new Worker(\"orders\", processor(handlers), { connection });\n */\nexport function processor(\n  handlers: BabelHandlers,\n  options: ProcessorOptions = {},\n): ((job: Job) => Promise<unknown>) & { close(): Promise<void> } {\n  // One adapter-created Queue per (prefix, name): a processor shared by several Workers must not send queue B's poison\n  // records to queue A's `<queue>.dlq` (ADR-0037 decision 3: `<queue>` is the *worker's* queue name).\n  const created = new Map<string, Queue>();\n\n  const resolveDeadLetterQueue = (job: Job): Queue | undefined => {\n    const target = options.deadLetterQueue;\n    if (target === undefined) return undefined;\n    if (typeof target === \"object\") return target;\n    const name = target === true ? `${job.queueName}.dlq` : target;\n    const queueOptions = workerQueueOptions(job);\n    const key = `${queueOptions.prefix ?? \"\"}\\u0000${name}`;\n    let queue = created.get(key);\n    if (queue === undefined) {\n      queue = new Queue(name, queueOptions);\n      created.set(key, queue);\n    }\n    return queue;\n  };\n\n  /** Add the ADR-0035 record to the DLQ; a failure is reported and never replaces the unrecoverable failure. */\n  const deadLetterPoison = async (job: Job, error: BabelQueueError): Promise<void> => {\n    try {\n      const dlq = resolveDeadLetterQueue(job);\n      if (dlq === undefined) return;\n      // The body is the job data serialised as JSON (BullMQ already parsed what it stored).\n      const body = JSON.stringify(job.data) ?? \"null\";\n      const delivered = typeof job.attemptsMade === \"number\" ? job.attemptsMade : 0; // informational\n      const deadLetter = annotate({ attempts: delivered } as unknown as Envelope, \"poison\", options.queue ?? job.queueName, {\n        attempts: delivered,\n        error: error.message,\n        exception: error.name,\n      }).dead_letter;\n      const record = buildPoisonRecord(Buffer.from(body, \"utf8\"), JSON.stringify(deadLetter));\n      await dlq.add(job.name, JSON.parse(record) as Record<string, unknown>);\n    } catch (writeError) {\n      try {\n        options.onError?.(writeError, job);\n      } catch {\n        // a throwing report must not replace the unrecoverable failure\n      }\n    }\n  };\n\n  const run = async (job: Job): Promise<unknown> => {\n    const envelope = job.data as IncomingEnvelope;\n\n    if (!EnvelopeCodec.accepts(envelope)) {\n      const error = new BabelQueueError(\n        `Rejected a non-conformant BabelQueue envelope on job ${job.id ?? \"?\"}.`,\n      );\n      await deadLetterPoison(job, error);\n      // Never retried: BullMQ moves an UnrecoverableError straight to the failed set, which keeps the job data.\n      throw new UnrecoverableError(error.message);\n    }\n\n    const urn = EnvelopeCodec.urn(envelope);\n    const handler = handlers[urn];\n    if (!handler) {\n      if (options.onUnknownUrn) {\n        return options.onUnknownUrn(envelope, job);\n      }\n      throw new UnknownUrnError(urn);\n    }\n\n    return handler(envelope, job, headersOf(job));\n  };\n\n  // Closes the `Queue` the adapter created for a `string` / `true` deadLetterQueue (a no-op otherwise: a\n  // `Queue` instance you passed is yours to close).\n  return Object.assign(run, {\n    async close(): Promise<void> {\n      const queues = [...created.values()];\n      created.clear();\n      await Promise.all(queues.map((queue) => queue.close()));\n    },\n  });\n}\n","/**\n * Pure, dependency-free helpers for the out-of-band transport-header seam (ADR-0028) — the Node\n * adapter mirror of Go's `sanitizeHeaders` and PHP's `Support\\Headers`. They carry an injected\n * {@link HeaderCarrier} (e.g. a W3C `traceparent`) beside the frozen envelope (GR-1), never inside it.\n *\n * BullMQ has no AMQP-style header table; its native context-propagation slot is\n * `JobsOptions.telemetry.metadata` (a string, stored compactly as `tm` in Redis), so the carrier is\n * serialized to JSON there — leaving `job.data` (the canonical envelope) byte-identical.\n */\n\nimport type { HeaderCarrier } from \"@babelqueue/core\";\n\n/**\n * Copy `headers`, dropping blank keys and blank values. Returns an empty object when nothing\n * survives. A nullish input yields an empty object.\n */\nexport function sanitizeHeaders(headers: HeaderCarrier | null | undefined): HeaderCarrier {\n  const out: HeaderCarrier = {};\n  if (!headers) return out;\n  for (const key of Object.keys(headers)) {\n    const value = headers[key];\n    if (key === \"\" || value == null || value === \"\") continue;\n    out[key] = value;\n  }\n  return out;\n}\n\n/**\n * Serialize a header carrier for BullMQ's `telemetry.metadata` slot, or `undefined` when there is\n * nothing to carry (so a header-less publish leaves `telemetry` unset and the job byte-identical).\n */\nexport function encodeMetadata(headers: HeaderCarrier | null | undefined): string | undefined {\n  const clean = sanitizeHeaders(headers);\n  return Object.keys(clean).length === 0 ? undefined : JSON.stringify(clean);\n}\n\n/**\n * Read a header carrier back from a BullMQ `telemetry.metadata` string. Returns an empty object for\n * a missing or unparseable value, so a job produced without headers (or by a non-babelqueue\n * producer) consumes with no headers and no error.\n */\nexport function decodeMetadata(metadata: string | undefined | null): HeaderCarrier {\n  if (!metadata) return {};\n  try {\n    const parsed = JSON.parse(metadata) as unknown;\n    if (parsed == null || typeof parsed !== \"object\" || Array.isArray(parsed)) return {};\n    return sanitizeHeaders(parsed as HeaderCarrier);\n  } catch {\n    return {};\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBA,kBASO;AACP,oBAA0C;;;ACbnC,SAAS,gBAAgB,SAA0D;AACxF,QAAM,MAAqB,CAAC;AAC5B,MAAI,CAAC,QAAS,QAAO;AACrB,aAAW,OAAO,OAAO,KAAK,OAAO,GAAG;AACtC,UAAM,QAAQ,QAAQ,GAAG;AACzB,QAAI,QAAQ,MAAM,SAAS,QAAQ,UAAU,GAAI;AACjD,QAAI,GAAG,IAAI;AAAA,EACb;AACA,SAAO;AACT;AAMO,SAAS,eAAe,SAA+D;AAC5F,QAAM,QAAQ,gBAAgB,OAAO;AACrC,SAAO,OAAO,KAAK,KAAK,EAAE,WAAW,IAAI,SAAY,KAAK,UAAU,KAAK;AAC3E;AAOO,SAAS,eAAe,UAAoD;AACjF,MAAI,CAAC,SAAU,QAAO,CAAC;AACvB,MAAI;AACF,UAAM,SAAS,KAAK,MAAM,QAAQ;AAClC,QAAI,UAAU,QAAQ,OAAO,WAAW,YAAY,MAAM,QAAQ,MAAM,EAAG,QAAO,CAAC;AACnF,WAAO,gBAAgB,MAAuB;AAAA,EAChD,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;;;ADRO,SAAS,UAAU,KAAyB;AACjD,SAAO,eAAe,IAAI,MAAM,WAAW,QAAQ;AACrD;AAmCA,eAAsB,QACpB,OACA,KACA,MACA,UAA0B,CAAC,GACV;AACjB,QAAM,WAAW,0BAAc,KAAK,KAAK,MAAM;AAAA,IAC7C,OAAO,MAAM;AAAA,IACb,SAAS,QAAQ;AAAA,EACnB,CAAC;AACD,QAAM,MAAM,IAAI,KAAK,UAAU,YAAY,QAAQ,aAAa,QAAQ,OAAO,CAAC;AAChF,SAAO,SAAS,KAAK;AACvB;AAOA,SAAS,YAAY,aAAsC,SAA6D;AACtH,QAAM,WAAW,eAAe,OAAO;AACvC,MAAI,aAAa,OAAW,QAAO;AACnC,QAAM,YAAY,aAAa;AAC/B,MAAI,WAAW,YAAY,KAAM,QAAO;AACxC,SAAO,EAAE,GAAG,aAAa,WAAW,EAAE,GAAG,WAAW,SAAS,EAAE;AACjE;AA2BA,SAAS,mBAAmB,KAAwB;AAClD,QAAM,OAAQ,IAAgE,OAAO;AACrF,SAAO,EAAE,YAAY,MAAM,YAA0C,GAAI,MAAM,WAAW,SAAY,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,EAAG;AACtI;AAYO,SAAS,UACd,UACA,UAA4B,CAAC,GACkC;AAG/D,QAAM,UAAU,oBAAI,IAAmB;AAEvC,QAAM,yBAAyB,CAAC,QAAgC;AAC9D,UAAM,SAAS,QAAQ;AACvB,QAAI,WAAW,OAAW,QAAO;AACjC,QAAI,OAAO,WAAW,SAAU,QAAO;AACvC,UAAM,OAAO,WAAW,OAAO,GAAG,IAAI,SAAS,SAAS;AACxD,UAAM,eAAe,mBAAmB,GAAG;AAC3C,UAAM,MAAM,GAAG,aAAa,UAAU,EAAE,KAAS,IAAI;AACrD,QAAI,QAAQ,QAAQ,IAAI,GAAG;AAC3B,QAAI,UAAU,QAAW;AACvB,cAAQ,IAAI,oBAAM,MAAM,YAAY;AACpC,cAAQ,IAAI,KAAK,KAAK;AAAA,IACxB;AACA,WAAO;AAAA,EACT;AAGA,QAAM,mBAAmB,OAAO,KAAU,UAA0C;AAClF,QAAI;AACF,YAAM,MAAM,uBAAuB,GAAG;AACtC,UAAI,QAAQ,OAAW;AAEvB,YAAM,OAAO,KAAK,UAAU,IAAI,IAAI,KAAK;AACzC,YAAM,YAAY,OAAO,IAAI,iBAAiB,WAAW,IAAI,eAAe;AAC5E,YAAM,iBAAa,sBAAS,EAAE,UAAU,UAAU,GAA0B,UAAU,QAAQ,SAAS,IAAI,WAAW;AAAA,QACpH,UAAU;AAAA,QACV,OAAO,MAAM;AAAA,QACb,WAAW,MAAM;AAAA,MACnB,CAAC,EAAE;AACH,YAAM,aAAS,+BAAkB,OAAO,KAAK,MAAM,MAAM,GAAG,KAAK,UAAU,UAAU,CAAC;AACtF,YAAM,IAAI,IAAI,IAAI,MAAM,KAAK,MAAM,MAAM,CAA4B;AAAA,IACvE,SAAS,YAAY;AACnB,UAAI;AACF,gBAAQ,UAAU,YAAY,GAAG;AAAA,MACnC,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF;AAEA,QAAM,MAAM,OAAO,QAA+B;AAChD,UAAM,WAAW,IAAI;AAErB,QAAI,CAAC,0BAAc,QAAQ,QAAQ,GAAG;AACpC,YAAM,QAAQ,IAAI;AAAA,QAChB,wDAAwD,IAAI,MAAM,GAAG;AAAA,MACvE;AACA,YAAM,iBAAiB,KAAK,KAAK;AAEjC,YAAM,IAAI,iCAAmB,MAAM,OAAO;AAAA,IAC5C;AAEA,UAAM,MAAM,0BAAc,IAAI,QAAQ;AACtC,UAAM,UAAU,SAAS,GAAG;AAC5B,QAAI,CAAC,SAAS;AACZ,UAAI,QAAQ,cAAc;AACxB,eAAO,QAAQ,aAAa,UAAU,GAAG;AAAA,MAC3C;AACA,YAAM,IAAI,4BAAgB,GAAG;AAAA,IAC/B;AAEA,WAAO,QAAQ,UAAU,KAAK,UAAU,GAAG,CAAC;AAAA,EAC9C;AAIA,SAAO,OAAO,OAAO,KAAK;AAAA,IACxB,MAAM,QAAuB;AAC3B,YAAM,SAAS,CAAC,GAAG,QAAQ,OAAO,CAAC;AACnC,cAAQ,MAAM;AACd,YAAM,QAAQ,IAAI,OAAO,IAAI,CAAC,UAAU,MAAM,MAAM,CAAC,CAAC;AAAA,IACxD;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/index.d.cts

@@ -1,5 +1,27 @@
-import { Envelope, IncomingEnvelope } from '@babelqueue/core';
-import { Job, JobsOptions, Queue } from 'bullmq';
+import { HeaderCarrier, Envelope, IncomingEnvelope } from '@babelqueue/core';
+import { Job, Queue, JobsOptions } from 'bullmq';
+
+/**
+ * Pure, dependency-free helpers for the out-of-band transport-header seam (ADR-0028) — the Node
+ * adapter mirror of Go's `sanitizeHeaders` and PHP's `Support\Headers`. They carry an injected
+ * {@link HeaderCarrier} (e.g. a W3C `traceparent`) beside the frozen envelope (GR-1), never inside it.
+ *
+ * BullMQ has no AMQP-style header table; its native context-propagation slot is
+ * `JobsOptions.telemetry.metadata` (a string, stored compactly as `tm` in Redis), so the carrier is
+ * serialized to JSON there — leaving `job.data` (the canonical envelope) byte-identical.
+ */
+
+/**
+ * Serialize a header carrier for BullMQ's `telemetry.metadata` slot, or `undefined` when there is
+ * nothing to carry (so a header-less publish leaves `telemetry` unset and the job byte-identical).
+ */
+declare function encodeMetadata(headers: HeaderCarrier | null | undefined): string | undefined;
+/**
+ * Read a header carrier back from a BullMQ `telemetry.metadata` string. Returns an empty object for
+ * a missing or unparseable value, so a job produced without headers (or by a non-babelqueue
+ * producer) consumes with no headers and no error.
+ */
+declare function decodeMetadata(metadata: string | undefined | null): HeaderCarrier;
 
 /**
  * BullMQ adapter for BabelQueue.
@@ -20,8 +42,18 @@ import { Job, JobsOptions, Queue } from 'bullmq';
  *     }), { connection });
  */
 
-/** A URN handler. Receives the validated envelope and the raw BullMQ job. */
-type BabelHandler = (envelope: Envelope, job: Job) => unknown | Promise<unknown>;
+/**
+ * The out-of-band {@link HeaderCarrier} carried by a job, read from BullMQ's native
+ * `telemetry.metadata` slot (`job.opts.telemetry.metadata`). Empty for a job published without
+ * headers. Pass it to `@babelqueue/core/otel`'s `wrapHandler` to link the consumer span as a child
+ * of the producer span (ADR-0028).
+ */
+declare function headersOf(job: Job): HeaderCarrier;
+/**
+ * A URN handler. Receives the validated envelope, the raw BullMQ job, and the out-of-band
+ * {@link HeaderCarrier} carried in the job's `telemetry.metadata` (empty when there are none).
+ */
+type BabelHandler = (envelope: Envelope, job: Job, headers: HeaderCarrier) => unknown | Promise<unknown>;
 /** A map of URN → handler. */
 type BabelHandlers = Record<string, BabelHandler>;
 /** Options for {@link publish}. */
@@ -30,26 +62,59 @@ interface PublishOptions {
     traceId?: string;
     /** BullMQ job options (delay, attempts, backoff, …). */
     jobsOptions?: JobsOptions;
+    /**
+     * Out-of-band transport headers carried in BullMQ's native `telemetry.metadata` slot (ADR-0028) —
+     * e.g. a W3C `traceparent` written by `@babelqueue/core/otel`'s `publish`. The canonical envelope
+     * (`job.data`) stays byte-identical (GR-1); an empty/omitted carrier leaves the job options
+     * unchanged. An explicit `jobsOptions.telemetry.metadata` wins (it is not clobbered).
+     */
+    headers?: HeaderCarrier;
 }
 /**
  * Build the canonical envelope for `(urn, data)` and add it as a BullMQ job (the
  * job name is the URN, the job data is the envelope). Returns the message id
  * (`meta.id`).
+ *
+ * When `options.headers` carries any out-of-band header (e.g. a `traceparent`) it is serialized
+ * into the job's `telemetry.metadata` so a consumer can read it back via {@link headersOf} — the
+ * envelope itself is never touched.
  */
 declare function publish(queue: Queue, urn: string, data: Record<string, unknown>, options?: PublishOptions): Promise<string>;
 /** Options for {@link processor}. */
 interface ProcessorOptions {
     /** Called instead of throwing when a job's URN has no handler. */
     onUnknownUrn?: (envelope: IncomingEnvelope, job: Job) => unknown | Promise<unknown>;
+    /**
+     * A dead-letter queue for **poison** jobs (ADR-0037 decision 3; opt-in, absent = none): a job whose data does
+     * not decode into a valid envelope. When set, the ADR-0035 record (`reason: "poison"`, built with the core's
+     * `buildPoisonRecord`) is **also** added to it as a job before the job fails.
+     *
+     * - a BullMQ `Queue` instance is used as given;
+     * - a `string` is a queue name: the adapter creates a `Queue` with that name on the worker's connection;
+     * - `true` creates a `Queue` named `<queue>.dlq` (`<queue>` = the worker's queue name) on the worker's connection.
+     *
+     * A `Queue` the adapter creates is closed by the `close()` of the returned processor; a `Queue` instance you pass is yours to close.
+     * The job data is JSON that BullMQ has already parsed, so a value `JSON.parse` cannot carry (`1e400`, an integer
+     * beyond 2^53) is lost before the adapter sees it: a property of BullMQ, not of the record rule.
+     */
+    deadLetterQueue?: Queue | string | true;
+    /** The `dead_letter.original_queue` of a poison record. Defaults to the worker's queue name (`job.queueName`). */
+    queue?: string;
+    /** Called when adding the poison record to {@link deadLetterQueue} fails. The job still fails as unrecoverable. */
+    onError?: (error: unknown, job: Job) => void;
 }
 /**
  * Build a BullMQ processor that decodes each job's envelope, validates it, and
- * routes it to the handler registered for its URN. A non-conformant envelope
- * throws (so BullMQ retries / fails the job per its options); an unmapped URN
- * throws unless `onUnknownUrn` is given.
+ * routes it to the handler registered for its URN. A **poison** job (data that is
+ * not a valid envelope) fails with BullMQ's `UnrecoverableError` — no retry, straight
+ * to the failed set (ADR-0037 decision 3), after the ADR-0035 record was added to the
+ * optional `deadLetterQueue`; an unmapped URN throws unless `onUnknownUrn` is given
+ * (BullMQ retries / fails the job per its options), as does a throwing handler.
  *
  *     new Worker("orders", processor(handlers), { connection });
  */
-declare function processor(handlers: BabelHandlers, options?: ProcessorOptions): (job: Job) => Promise<unknown>;
+declare function processor(handlers: BabelHandlers, options?: ProcessorOptions): ((job: Job) => Promise<unknown>) & {
+    close(): Promise<void>;
+};
 
-export { type BabelHandler, type BabelHandlers, type ProcessorOptions, type PublishOptions, processor, publish };
+export { type BabelHandler, type BabelHandlers, type ProcessorOptions, type PublishOptions, decodeMetadata, encodeMetadata, headersOf, processor, publish };

package/dist/index.d.ts

@@ -1,5 +1,27 @@
-import { Envelope, IncomingEnvelope } from '@babelqueue/core';
-import { Job, JobsOptions, Queue } from 'bullmq';
+import { HeaderCarrier, Envelope, IncomingEnvelope } from '@babelqueue/core';
+import { Job, Queue, JobsOptions } from 'bullmq';
+
+/**
+ * Pure, dependency-free helpers for the out-of-band transport-header seam (ADR-0028) — the Node
+ * adapter mirror of Go's `sanitizeHeaders` and PHP's `Support\Headers`. They carry an injected
+ * {@link HeaderCarrier} (e.g. a W3C `traceparent`) beside the frozen envelope (GR-1), never inside it.
+ *
+ * BullMQ has no AMQP-style header table; its native context-propagation slot is
+ * `JobsOptions.telemetry.metadata` (a string, stored compactly as `tm` in Redis), so the carrier is
+ * serialized to JSON there — leaving `job.data` (the canonical envelope) byte-identical.
+ */
+
+/**
+ * Serialize a header carrier for BullMQ's `telemetry.metadata` slot, or `undefined` when there is
+ * nothing to carry (so a header-less publish leaves `telemetry` unset and the job byte-identical).
+ */
+declare function encodeMetadata(headers: HeaderCarrier | null | undefined): string | undefined;
+/**
+ * Read a header carrier back from a BullMQ `telemetry.metadata` string. Returns an empty object for
+ * a missing or unparseable value, so a job produced without headers (or by a non-babelqueue
+ * producer) consumes with no headers and no error.
+ */
+declare function decodeMetadata(metadata: string | undefined | null): HeaderCarrier;
 
 /**
  * BullMQ adapter for BabelQueue.
@@ -20,8 +42,18 @@ import { Job, JobsOptions, Queue } from 'bullmq';
  *     }), { connection });
  */
 
-/** A URN handler. Receives the validated envelope and the raw BullMQ job. */
-type BabelHandler = (envelope: Envelope, job: Job) => unknown | Promise<unknown>;
+/**
+ * The out-of-band {@link HeaderCarrier} carried by a job, read from BullMQ's native
+ * `telemetry.metadata` slot (`job.opts.telemetry.metadata`). Empty for a job published without
+ * headers. Pass it to `@babelqueue/core/otel`'s `wrapHandler` to link the consumer span as a child
+ * of the producer span (ADR-0028).
+ */
+declare function headersOf(job: Job): HeaderCarrier;
+/**
+ * A URN handler. Receives the validated envelope, the raw BullMQ job, and the out-of-band
+ * {@link HeaderCarrier} carried in the job's `telemetry.metadata` (empty when there are none).
+ */
+type BabelHandler = (envelope: Envelope, job: Job, headers: HeaderCarrier) => unknown | Promise<unknown>;
 /** A map of URN → handler. */
 type BabelHandlers = Record<string, BabelHandler>;
 /** Options for {@link publish}. */
@@ -30,26 +62,59 @@ interface PublishOptions {
     traceId?: string;
     /** BullMQ job options (delay, attempts, backoff, …). */
     jobsOptions?: JobsOptions;
+    /**
+     * Out-of-band transport headers carried in BullMQ's native `telemetry.metadata` slot (ADR-0028) —
+     * e.g. a W3C `traceparent` written by `@babelqueue/core/otel`'s `publish`. The canonical envelope
+     * (`job.data`) stays byte-identical (GR-1); an empty/omitted carrier leaves the job options
+     * unchanged. An explicit `jobsOptions.telemetry.metadata` wins (it is not clobbered).
+     */
+    headers?: HeaderCarrier;
 }
 /**
  * Build the canonical envelope for `(urn, data)` and add it as a BullMQ job (the
  * job name is the URN, the job data is the envelope). Returns the message id
  * (`meta.id`).
+ *
+ * When `options.headers` carries any out-of-band header (e.g. a `traceparent`) it is serialized
+ * into the job's `telemetry.metadata` so a consumer can read it back via {@link headersOf} — the
+ * envelope itself is never touched.
  */
 declare function publish(queue: Queue, urn: string, data: Record<string, unknown>, options?: PublishOptions): Promise<string>;
 /** Options for {@link processor}. */
 interface ProcessorOptions {
     /** Called instead of throwing when a job's URN has no handler. */
     onUnknownUrn?: (envelope: IncomingEnvelope, job: Job) => unknown | Promise<unknown>;
+    /**
+     * A dead-letter queue for **poison** jobs (ADR-0037 decision 3; opt-in, absent = none): a job whose data does
+     * not decode into a valid envelope. When set, the ADR-0035 record (`reason: "poison"`, built with the core's
+     * `buildPoisonRecord`) is **also** added to it as a job before the job fails.
+     *
+     * - a BullMQ `Queue` instance is used as given;
+     * - a `string` is a queue name: the adapter creates a `Queue` with that name on the worker's connection;
+     * - `true` creates a `Queue` named `<queue>.dlq` (`<queue>` = the worker's queue name) on the worker's connection.
+     *
+     * A `Queue` the adapter creates is closed by the `close()` of the returned processor; a `Queue` instance you pass is yours to close.
+     * The job data is JSON that BullMQ has already parsed, so a value `JSON.parse` cannot carry (`1e400`, an integer
+     * beyond 2^53) is lost before the adapter sees it: a property of BullMQ, not of the record rule.
+     */
+    deadLetterQueue?: Queue | string | true;
+    /** The `dead_letter.original_queue` of a poison record. Defaults to the worker's queue name (`job.queueName`). */
+    queue?: string;
+    /** Called when adding the poison record to {@link deadLetterQueue} fails. The job still fails as unrecoverable. */
+    onError?: (error: unknown, job: Job) => void;
 }
 /**
  * Build a BullMQ processor that decodes each job's envelope, validates it, and
- * routes it to the handler registered for its URN. A non-conformant envelope
- * throws (so BullMQ retries / fails the job per its options); an unmapped URN
- * throws unless `onUnknownUrn` is given.
+ * routes it to the handler registered for its URN. A **poison** job (data that is
+ * not a valid envelope) fails with BullMQ's `UnrecoverableError` — no retry, straight
+ * to the failed set (ADR-0037 decision 3), after the ADR-0035 record was added to the
+ * optional `deadLetterQueue`; an unmapped URN throws unless `onUnknownUrn` is given
+ * (BullMQ retries / fails the job per its options), as does a throwing handler.
  *
  *     new Worker("orders", processor(handlers), { connection });
  */
-declare function processor(handlers: BabelHandlers, options?: ProcessorOptions): (job: Job) => Promise<unknown>;
+declare function processor(handlers: BabelHandlers, options?: ProcessorOptions): ((job: Job) => Promise<unknown>) & {
+    close(): Promise<void>;
+};
 
-export { type BabelHandler, type BabelHandlers, type ProcessorOptions, type PublishOptions, processor, publish };
+export { type BabelHandler, type BabelHandlers, type ProcessorOptions, type PublishOptions, decodeMetadata, encodeMetadata, headersOf, processor, publish };

package/dist/index.js

@@ -2,23 +2,105 @@
 import {
   BabelQueueError,
   EnvelopeCodec,
-  UnknownUrnError
+  UnknownUrnError,
+  annotate,
+  buildPoisonRecord
 } from "@babelqueue/core";
+import { Queue, UnrecoverableError } from "bullmq";
+
+// src/headers.ts
+function sanitizeHeaders(headers) {
+  const out = {};
+  if (!headers) return out;
+  for (const key of Object.keys(headers)) {
+    const value = headers[key];
+    if (key === "" || value == null || value === "") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function encodeMetadata(headers) {
+  const clean = sanitizeHeaders(headers);
+  return Object.keys(clean).length === 0 ? void 0 : JSON.stringify(clean);
+}
+function decodeMetadata(metadata) {
+  if (!metadata) return {};
+  try {
+    const parsed = JSON.parse(metadata);
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return sanitizeHeaders(parsed);
+  } catch {
+    return {};
+  }
+}
+
+// src/index.ts
+function headersOf(job) {
+  return decodeMetadata(job.opts?.telemetry?.metadata);
+}
 async function publish(queue, urn, data, options = {}) {
   const envelope = EnvelopeCodec.make(urn, data, {
     queue: queue.name,
     traceId: options.traceId
   });
-  await queue.add(urn, envelope, options.jobsOptions);
+  await queue.add(urn, envelope, withHeaders(options.jobsOptions, options.headers));
   return envelope.meta.id;
 }
+function withHeaders(jobsOptions, headers) {
+  const metadata = encodeMetadata(headers);
+  if (metadata === void 0) return jobsOptions;
+  const telemetry = jobsOptions?.telemetry;
+  if (telemetry?.metadata != null) return jobsOptions;
+  return { ...jobsOptions, telemetry: { ...telemetry, metadata } };
+}
+function workerQueueOptions(job) {
+  const opts = job.queue?.opts;
+  return { connection: opts?.connection, ...opts?.prefix === void 0 ? {} : { prefix: opts.prefix } };
+}
 function processor(handlers, options = {}) {
-  return async (job) => {
+  const created = /* @__PURE__ */ new Map();
+  const resolveDeadLetterQueue = (job) => {
+    const target = options.deadLetterQueue;
+    if (target === void 0) return void 0;
+    if (typeof target === "object") return target;
+    const name = target === true ? `${job.queueName}.dlq` : target;
+    const queueOptions = workerQueueOptions(job);
+    const key = `${queueOptions.prefix ?? ""}\0${name}`;
+    let queue = created.get(key);
+    if (queue === void 0) {
+      queue = new Queue(name, queueOptions);
+      created.set(key, queue);
+    }
+    return queue;
+  };
+  const deadLetterPoison = async (job, error) => {
+    try {
+      const dlq = resolveDeadLetterQueue(job);
+      if (dlq === void 0) return;
+      const body = JSON.stringify(job.data) ?? "null";
+      const delivered = typeof job.attemptsMade === "number" ? job.attemptsMade : 0;
+      const deadLetter = annotate({ attempts: delivered }, "poison", options.queue ?? job.queueName, {
+        attempts: delivered,
+        error: error.message,
+        exception: error.name
+      }).dead_letter;
+      const record = buildPoisonRecord(Buffer.from(body, "utf8"), JSON.stringify(deadLetter));
+      await dlq.add(job.name, JSON.parse(record));
+    } catch (writeError) {
+      try {
+        options.onError?.(writeError, job);
+      } catch {
+      }
+    }
+  };
+  const run = async (job) => {
     const envelope = job.data;
     if (!EnvelopeCodec.accepts(envelope)) {
-      throw new BabelQueueError(
+      const error = new BabelQueueError(
         `Rejected a non-conformant BabelQueue envelope on job ${job.id ?? "?"}.`
       );
+      await deadLetterPoison(job, error);
+      throw new UnrecoverableError(error.message);
     }
     const urn = EnvelopeCodec.urn(envelope);
     const handler = handlers[urn];
@@ -28,10 +110,20 @@ function processor(handlers, options = {}) {
       }
       throw new UnknownUrnError(urn);
     }
-    return handler(envelope, job);
+    return handler(envelope, job, headersOf(job));
   };
+  return Object.assign(run, {
+    async close() {
+      const queues = [...created.values()];
+      created.clear();
+      await Promise.all(queues.map((queue) => queue.close()));
+    }
+  });
 }
 export {
+  decodeMetadata,
+  encodeMetadata,
+  headersOf,
   processor,
   publish
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * BullMQ adapter for BabelQueue.\n *\n * It makes your BullMQ jobs carry the canonical BabelQueue envelope and routes\n * them by URN, so a BullMQ-based Node service speaks the same contract (envelope\n * shape, URN identity, trace propagation) as the PHP/Laravel, Python, Go, Java and\n * .NET SDKs.\n *\n *     import { Queue, Worker } from \"bullmq\";\n *     import { publish, processor } from \"@babelqueue/bullmq\";\n *\n *     const queue = new Queue(\"orders\", { connection });\n *     await publish(queue, \"urn:babel:orders:created\", { order_id: 1042 });\n *\n *     new Worker(\"orders\", processor({\n *       \"urn:babel:orders:created\": async (env) => { ... },\n *     }), { connection });\n */\n\nimport {\n  BabelQueueError,\n  EnvelopeCodec,\n  UnknownUrnError,\n  type Envelope,\n  type IncomingEnvelope,\n} from \"@babelqueue/core\";\nimport type { Job, JobsOptions, Queue } from \"bullmq\";\n\n/** A URN handler. Receives the validated envelope and the raw BullMQ job. */\nexport type BabelHandler = (envelope: Envelope, job: Job) => unknown | Promise<unknown>;\n\n/** A map of URN → handler. */\nexport type BabelHandlers = Record<string, BabelHandler>;\n\n/** Options for {@link publish}. */\nexport interface PublishOptions {\n  /** Reuse an existing trace id (trace continuation). */\n  traceId?: string;\n  /** BullMQ job options (delay, attempts, backoff, …). */\n  jobsOptions?: JobsOptions;\n}\n\n/**\n * Build the canonical envelope for `(urn, data)` and add it as a BullMQ job (the\n * job name is the URN, the job data is the envelope). Returns the message id\n * (`meta.id`).\n */\nexport async function publish(\n  queue: Queue,\n  urn: string,\n  data: Record<string, unknown>,\n  options: PublishOptions = {},\n): Promise<string> {\n  const envelope = EnvelopeCodec.make(urn, data, {\n    queue: queue.name,\n    traceId: options.traceId,\n  });\n  await queue.add(urn, envelope, options.jobsOptions);\n  return envelope.meta.id;\n}\n\n/** Options for {@link processor}. */\nexport interface ProcessorOptions {\n  /** Called instead of throwing when a job's URN has no handler. */\n  onUnknownUrn?: (envelope: IncomingEnvelope, job: Job) => unknown | Promise<unknown>;\n}\n\n/**\n * Build a BullMQ processor that decodes each job's envelope, validates it, and\n * routes it to the handler registered for its URN. A non-conformant envelope\n * throws (so BullMQ retries / fails the job per its options); an unmapped URN\n * throws unless `onUnknownUrn` is given.\n *\n *     new Worker(\"orders\", processor(handlers), { connection });\n */\nexport function processor(\n  handlers: BabelHandlers,\n  options: ProcessorOptions = {},\n): (job: Job) => Promise<unknown> {\n  return async (job: Job): Promise<unknown> => {\n    const envelope = job.data as IncomingEnvelope;\n\n    if (!EnvelopeCodec.accepts(envelope)) {\n      throw new BabelQueueError(\n        `Rejected a non-conformant BabelQueue envelope on job ${job.id ?? \"?\"}.`,\n      );\n    }\n\n    const urn = EnvelopeCodec.urn(envelope);\n    const handler = handlers[urn];\n    if (!handler) {\n      if (options.onUnknownUrn) {\n        return options.onUnknownUrn(envelope, job);\n      }\n      throw new UnknownUrnError(urn);\n    }\n\n    return handler(envelope, job);\n  };\n}\n"],"mappings":";AAmBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AAsBP,eAAsB,QACpB,OACA,KACA,MACA,UAA0B,CAAC,GACV;AACjB,QAAM,WAAW,cAAc,KAAK,KAAK,MAAM;AAAA,IAC7C,OAAO,MAAM;AAAA,IACb,SAAS,QAAQ;AAAA,EACnB,CAAC;AACD,QAAM,MAAM,IAAI,KAAK,UAAU,QAAQ,WAAW;AAClD,SAAO,SAAS,KAAK;AACvB;AAgBO,SAAS,UACd,UACA,UAA4B,CAAC,GACG;AAChC,SAAO,OAAO,QAA+B;AAC3C,UAAM,WAAW,IAAI;AAErB,QAAI,CAAC,cAAc,QAAQ,QAAQ,GAAG;AACpC,YAAM,IAAI;AAAA,QACR,wDAAwD,IAAI,MAAM,GAAG;AAAA,MACvE;AAAA,IACF;AAEA,UAAM,MAAM,cAAc,IAAI,QAAQ;AACtC,UAAM,UAAU,SAAS,GAAG;AAC5B,QAAI,CAAC,SAAS;AACZ,UAAI,QAAQ,cAAc;AACxB,eAAO,QAAQ,aAAa,UAAU,GAAG;AAAA,MAC3C;AACA,YAAM,IAAI,gBAAgB,GAAG;AAAA,IAC/B;AAEA,WAAO,QAAQ,UAAU,GAAG;AAAA,EAC9B;AACF;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/headers.ts"],"sourcesContent":["/**\n * BullMQ adapter for BabelQueue.\n *\n * It makes your BullMQ jobs carry the canonical BabelQueue envelope and routes\n * them by URN, so a BullMQ-based Node service speaks the same contract (envelope\n * shape, URN identity, trace propagation) as the PHP/Laravel, Python, Go, Java and\n * .NET SDKs.\n *\n *     import { Queue, Worker } from \"bullmq\";\n *     import { publish, processor } from \"@babelqueue/bullmq\";\n *\n *     const queue = new Queue(\"orders\", { connection });\n *     await publish(queue, \"urn:babel:orders:created\", { order_id: 1042 });\n *\n *     new Worker(\"orders\", processor({\n *       \"urn:babel:orders:created\": async (env) => { ... },\n *     }), { connection });\n */\n\nimport {\n  BabelQueueError,\n  EnvelopeCodec,\n  UnknownUrnError,\n  annotate,\n  buildPoisonRecord,\n  type Envelope,\n  type HeaderCarrier,\n  type IncomingEnvelope,\n} from \"@babelqueue/core\";\nimport { Queue, UnrecoverableError } from \"bullmq\";\nimport type { Job, JobsOptions, QueueOptions } from \"bullmq\";\n\nimport { decodeMetadata, encodeMetadata } from \"./headers.js\";\n\nexport { decodeMetadata, encodeMetadata } from \"./headers.js\";\n\n/**\n * The out-of-band {@link HeaderCarrier} carried by a job, read from BullMQ's native\n * `telemetry.metadata` slot (`job.opts.telemetry.metadata`). Empty for a job published without\n * headers. Pass it to `@babelqueue/core/otel`'s `wrapHandler` to link the consumer span as a child\n * of the producer span (ADR-0028).\n */\nexport function headersOf(job: Job): HeaderCarrier {\n  return decodeMetadata(job.opts?.telemetry?.metadata);\n}\n\n/**\n * A URN handler. Receives the validated envelope, the raw BullMQ job, and the out-of-band\n * {@link HeaderCarrier} carried in the job's `telemetry.metadata` (empty when there are none).\n */\nexport type BabelHandler = (envelope: Envelope, job: Job, headers: HeaderCarrier) => unknown | Promise<unknown>;\n\n/** A map of URN → handler. */\nexport type BabelHandlers = Record<string, BabelHandler>;\n\n/** Options for {@link publish}. */\nexport interface PublishOptions {\n  /** Reuse an existing trace id (trace continuation). */\n  traceId?: string;\n  /** BullMQ job options (delay, attempts, backoff, …). */\n  jobsOptions?: JobsOptions;\n  /**\n   * Out-of-band transport headers carried in BullMQ's native `telemetry.metadata` slot (ADR-0028) —\n   * e.g. a W3C `traceparent` written by `@babelqueue/core/otel`'s `publish`. The canonical envelope\n   * (`job.data`) stays byte-identical (GR-1); an empty/omitted carrier leaves the job options\n   * unchanged. An explicit `jobsOptions.telemetry.metadata` wins (it is not clobbered).\n   */\n  headers?: HeaderCarrier;\n}\n\n/**\n * Build the canonical envelope for `(urn, data)` and add it as a BullMQ job (the\n * job name is the URN, the job data is the envelope). Returns the message id\n * (`meta.id`).\n *\n * When `options.headers` carries any out-of-band header (e.g. a `traceparent`) it is serialized\n * into the job's `telemetry.metadata` so a consumer can read it back via {@link headersOf} — the\n * envelope itself is never touched.\n */\nexport async function publish(\n  queue: Queue,\n  urn: string,\n  data: Record<string, unknown>,\n  options: PublishOptions = {},\n): Promise<string> {\n  const envelope = EnvelopeCodec.make(urn, data, {\n    queue: queue.name,\n    traceId: options.traceId,\n  });\n  await queue.add(urn, envelope, withHeaders(options.jobsOptions, options.headers));\n  return envelope.meta.id;\n}\n\n/**\n * Merge an out-of-band header carrier into a job's `telemetry.metadata` without clobbering an\n * explicit one the caller already set. Returns the original options unchanged when there is nothing\n * to carry, so a header-less publish stays byte-identical.\n */\nfunction withHeaders(jobsOptions: JobsOptions | undefined, headers: HeaderCarrier | undefined): JobsOptions | undefined {\n  const metadata = encodeMetadata(headers);\n  if (metadata === undefined) return jobsOptions;\n  const telemetry = jobsOptions?.telemetry;\n  if (telemetry?.metadata != null) return jobsOptions; // an explicit metadata wins (merge-not-clobber)\n  return { ...jobsOptions, telemetry: { ...telemetry, metadata } };\n}\n\n/** Options for {@link processor}. */\nexport interface ProcessorOptions {\n  /** Called instead of throwing when a job's URN has no handler. */\n  onUnknownUrn?: (envelope: IncomingEnvelope, job: Job) => unknown | Promise<unknown>;\n  /**\n   * A dead-letter queue for **poison** jobs (ADR-0037 decision 3; opt-in, absent = none): a job whose data does\n   * not decode into a valid envelope. When set, the ADR-0035 record (`reason: \"poison\"`, built with the core's\n   * `buildPoisonRecord`) is **also** added to it as a job before the job fails.\n   *\n   * - a BullMQ `Queue` instance is used as given;\n   * - a `string` is a queue name: the adapter creates a `Queue` with that name on the worker's connection;\n   * - `true` creates a `Queue` named `<queue>.dlq` (`<queue>` = the worker's queue name) on the worker's connection.\n   *\n   * A `Queue` the adapter creates is closed by the `close()` of the returned processor; a `Queue` instance you pass is yours to close.\n   * The job data is JSON that BullMQ has already parsed, so a value `JSON.parse` cannot carry (`1e400`, an integer\n   * beyond 2^53) is lost before the adapter sees it: a property of BullMQ, not of the record rule.\n   */\n  deadLetterQueue?: Queue | string | true;\n  /** The `dead_letter.original_queue` of a poison record. Defaults to the worker's queue name (`job.queueName`). */\n  queue?: string;\n  /** Called when adding the poison record to {@link deadLetterQueue} fails. The job still fails as unrecoverable. */\n  onError?: (error: unknown, job: Job) => void;\n}\n\n/** The worker's `Queue` connection options and prefix, read from the job's queue (BullMQ keeps them on `queue.opts`). */\nfunction workerQueueOptions(job: Job): QueueOptions {\n  const opts = (job as unknown as { queue?: { opts?: Partial<QueueOptions> } }).queue?.opts;\n  return { connection: opts?.connection as QueueOptions[\"connection\"], ...(opts?.prefix === undefined ? {} : { prefix: opts.prefix }) };\n}\n\n/**\n * Build a BullMQ processor that decodes each job's envelope, validates it, and\n * routes it to the handler registered for its URN. A **poison** job (data that is\n * not a valid envelope) fails with BullMQ's `UnrecoverableError` — no retry, straight\n * to the failed set (ADR-0037 decision 3), after the ADR-0035 record was added to the\n * optional `deadLetterQueue`; an unmapped URN throws unless `onUnknownUrn` is given\n * (BullMQ retries / fails the job per its options), as does a throwing handler.\n *\n *     new Worker(\"orders\", processor(handlers), { connection });\n */\nexport function processor(\n  handlers: BabelHandlers,\n  options: ProcessorOptions = {},\n): ((job: Job) => Promise<unknown>) & { close(): Promise<void> } {\n  // One adapter-created Queue per (prefix, name): a processor shared by several Workers must not send queue B's poison\n  // records to queue A's `<queue>.dlq` (ADR-0037 decision 3: `<queue>` is the *worker's* queue name).\n  const created = new Map<string, Queue>();\n\n  const resolveDeadLetterQueue = (job: Job): Queue | undefined => {\n    const target = options.deadLetterQueue;\n    if (target === undefined) return undefined;\n    if (typeof target === \"object\") return target;\n    const name = target === true ? `${job.queueName}.dlq` : target;\n    const queueOptions = workerQueueOptions(job);\n    const key = `${queueOptions.prefix ?? \"\"}\\u0000${name}`;\n    let queue = created.get(key);\n    if (queue === undefined) {\n      queue = new Queue(name, queueOptions);\n      created.set(key, queue);\n    }\n    return queue;\n  };\n\n  /** Add the ADR-0035 record to the DLQ; a failure is reported and never replaces the unrecoverable failure. */\n  const deadLetterPoison = async (job: Job, error: BabelQueueError): Promise<void> => {\n    try {\n      const dlq = resolveDeadLetterQueue(job);\n      if (dlq === undefined) return;\n      // The body is the job data serialised as JSON (BullMQ already parsed what it stored).\n      const body = JSON.stringify(job.data) ?? \"null\";\n      const delivered = typeof job.attemptsMade === \"number\" ? job.attemptsMade : 0; // informational\n      const deadLetter = annotate({ attempts: delivered } as unknown as Envelope, \"poison\", options.queue ?? job.queueName, {\n        attempts: delivered,\n        error: error.message,\n        exception: error.name,\n      }).dead_letter;\n      const record = buildPoisonRecord(Buffer.from(body, \"utf8\"), JSON.stringify(deadLetter));\n      await dlq.add(job.name, JSON.parse(record) as Record<string, unknown>);\n    } catch (writeError) {\n      try {\n        options.onError?.(writeError, job);\n      } catch {\n        // a throwing report must not replace the unrecoverable failure\n      }\n    }\n  };\n\n  const run = async (job: Job): Promise<unknown> => {\n    const envelope = job.data as IncomingEnvelope;\n\n    if (!EnvelopeCodec.accepts(envelope)) {\n      const error = new BabelQueueError(\n        `Rejected a non-conformant BabelQueue envelope on job ${job.id ?? \"?\"}.`,\n      );\n      await deadLetterPoison(job, error);\n      // Never retried: BullMQ moves an UnrecoverableError straight to the failed set, which keeps the job data.\n      throw new UnrecoverableError(error.message);\n    }\n\n    const urn = EnvelopeCodec.urn(envelope);\n    const handler = handlers[urn];\n    if (!handler) {\n      if (options.onUnknownUrn) {\n        return options.onUnknownUrn(envelope, job);\n      }\n      throw new UnknownUrnError(urn);\n    }\n\n    return handler(envelope, job, headersOf(job));\n  };\n\n  // Closes the `Queue` the adapter created for a `string` / `true` deadLetterQueue (a no-op otherwise: a\n  // `Queue` instance you passed is yours to close).\n  return Object.assign(run, {\n    async close(): Promise<void> {\n      const queues = [...created.values()];\n      created.clear();\n      await Promise.all(queues.map((queue) => queue.close()));\n    },\n  });\n}\n","/**\n * Pure, dependency-free helpers for the out-of-band transport-header seam (ADR-0028) — the Node\n * adapter mirror of Go's `sanitizeHeaders` and PHP's `Support\\Headers`. They carry an injected\n * {@link HeaderCarrier} (e.g. a W3C `traceparent`) beside the frozen envelope (GR-1), never inside it.\n *\n * BullMQ has no AMQP-style header table; its native context-propagation slot is\n * `JobsOptions.telemetry.metadata` (a string, stored compactly as `tm` in Redis), so the carrier is\n * serialized to JSON there — leaving `job.data` (the canonical envelope) byte-identical.\n */\n\nimport type { HeaderCarrier } from \"@babelqueue/core\";\n\n/**\n * Copy `headers`, dropping blank keys and blank values. Returns an empty object when nothing\n * survives. A nullish input yields an empty object.\n */\nexport function sanitizeHeaders(headers: HeaderCarrier | null | undefined): HeaderCarrier {\n  const out: HeaderCarrier = {};\n  if (!headers) return out;\n  for (const key of Object.keys(headers)) {\n    const value = headers[key];\n    if (key === \"\" || value == null || value === \"\") continue;\n    out[key] = value;\n  }\n  return out;\n}\n\n/**\n * Serialize a header carrier for BullMQ's `telemetry.metadata` slot, or `undefined` when there is\n * nothing to carry (so a header-less publish leaves `telemetry` unset and the job byte-identical).\n */\nexport function encodeMetadata(headers: HeaderCarrier | null | undefined): string | undefined {\n  const clean = sanitizeHeaders(headers);\n  return Object.keys(clean).length === 0 ? undefined : JSON.stringify(clean);\n}\n\n/**\n * Read a header carrier back from a BullMQ `telemetry.metadata` string. Returns an empty object for\n * a missing or unparseable value, so a job produced without headers (or by a non-babelqueue\n * producer) consumes with no headers and no error.\n */\nexport function decodeMetadata(metadata: string | undefined | null): HeaderCarrier {\n  if (!metadata) return {};\n  try {\n    const parsed = JSON.parse(metadata) as unknown;\n    if (parsed == null || typeof parsed !== \"object\" || Array.isArray(parsed)) return {};\n    return sanitizeHeaders(parsed as HeaderCarrier);\n  } catch {\n    return {};\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@babelqueue/bullmq",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "BullMQ adapter for BabelQueue — canonical-envelope jobs and a URN-routed processor.",
-  "keywords": ["babelqueue", "bullmq", "queue", "polyglot", "redis", "messaging"],
+  "keywords": [
+    "babelqueue",
+    "bullmq",
+    "queue",
+    "polyglot",
+    "redis",
+    "messaging"
+  ],
   "homepage": "https://babelqueue.com",
   "bugs": {
     "url": "https://github.com/BabelQueue/babelqueue-node-adapters/issues"
@@ -13,7 +20,7 @@
     "directory": "packages/bullmq"
   },
   "license": "MIT",
-  "author": "Muhammet Şafak <info@muhammetsafak.com.tr>",
+  "author": "Muhammet Şafak <info@muhammetsafak.com>",
   "type": "module",
   "exports": {
     ".": {
@@ -30,7 +37,9 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "sideEffects": false,
   "engines": {
     "node": ">=18"
@@ -41,7 +50,7 @@
     "test": "node --import tsx --test test/*.test.ts"
   },
   "dependencies": {
-    "@babelqueue/core": "^1.0.0"
+    "@babelqueue/core": "^1.13.0"
   },
   "peerDependencies": {
     "bullmq": "^5.0.0"