@babelqueue/core 1.0.0 → 1.2.0

package/dist/index.d.ts

@@ -1,129 +1,5 @@
-/**
- * A message that can be produced as a polyglot envelope. Implement it on your
- * own classes/objects so {@link EnvelopeCodec.fromMessage} can build the canonical
- * envelope without ever leaking a language-specific class name onto the wire.
- */
-interface PolyglotMessage {
-    /** The stable URN that identifies this message across languages. */
-    getBabelUrn(): string;
-    /** The pure-JSON payload (no class instances). */
-    toPayload(): Record<string, unknown>;
-}
-/**
- * Optionally implemented alongside {@link PolyglotMessage} to continue an existing
- * distributed trace instead of minting a fresh one.
- */
-interface HasTraceId {
-    /** The trace id to reuse, or null/undefined to mint a new one. */
-    getBabelTraceId(): string | null | undefined;
-}
-
-/** The wire envelope schema version this core implements (versioned independently of the package version). */
-declare const SCHEMA_VERSION = 1;
-/** Stamped into `meta.lang` for envelopes produced by this core. */
-declare const SOURCE_LANG = "node";
-/** Immutable per-message metadata. */
-interface Meta {
-    id: string;
-    queue: string;
-    lang: string;
-    schema_version: number;
-    /** Unix milliseconds, UTC. */
-    created_at: number;
-}
-/** The additive block appended to an envelope when a message is dead-lettered. */
-interface DeadLetter {
-    reason: string;
-    error: string | null;
-    exception: string | null;
-    /** Unix milliseconds, UTC. */
-    failed_at: number;
-    original_queue: string;
-    attempts: number;
-    lang: string;
-}
-/**
- * The canonical BabelQueue wire message: a strict, language-neutral JSON shape
- * that every SDK produces and consumes identically. The property order here is
- * significant — it matches the other cores so {@link EnvelopeCodec.encode} is
- * byte-for-byte identical across the insertion-order languages (PHP/Python).
- */
-interface Envelope {
-    /** The message URN (never a class name). */
-    job: string;
-    /** Correlation id, preserved across every hop. */
-    trace_id: string;
-    /** The pure-JSON payload. */
-    data: Record<string, unknown>;
-    meta: Meta;
-    /** Top-level transport retry counter. */
-    attempts: number;
-    /** Present only once the message has been dead-lettered. */
-    dead_letter?: DeadLetter;
-}
-/**
- * A decoded, not-yet-validated envelope. Fields are loosely typed because they
- * come off the wire; `urn` is accepted as an inbound alias for `job`. Narrow it
- * with {@link EnvelopeCodec.accepts} before trusting the contents.
- */
-interface IncomingEnvelope {
-    job?: string;
-    /** Inbound alias for `job`. */
-    urn?: string;
-    trace_id?: string;
-    data?: unknown;
-    meta?: unknown;
-    attempts?: unknown;
-    dead_letter?: unknown;
-}
-/** Options for {@link EnvelopeCodec.make}. */
-interface MakeOptions {
-    /** Logical queue name recorded in `meta.queue` (default `"default"`). */
-    queue?: string;
-    /** Reuse an existing trace id (trace continuation) instead of minting one. */
-    traceId?: string;
-}
-/**
- * Builds, encodes and decodes the canonical envelope — the single Node/TypeScript
- * implementation of the wire format.
- */
-declare const EnvelopeCodec: {
-    readonly SCHEMA_VERSION: 1;
-    readonly SOURCE_LANG: "node";
-    /**
-     * Build the canonical envelope for a `(urn, data)` pair. Mints a fresh trace id
-     * unless `options.traceId` is given, starts `attempts` at 0, and stamps `meta`.
-     * Throws {@link BabelQueueError} when the URN is blank.
-     */
-    readonly make: (urn: string, data: Record<string, unknown>, options?: MakeOptions) => Envelope;
-    /**
-     * Build the envelope from a {@link PolyglotMessage}. If the message also
-     * implements {@link HasTraceId} and returns a non-empty value, that trace id is
-     * reused.
-     */
-    readonly fromMessage: (message: PolyglotMessage & Partial<HasTraceId>, queue?: string) => Envelope;
-    /**
-     * Encode the envelope as compact UTF-8 JSON. `JSON.stringify` already emits the
-     * canonical form — no spaces, and slashes/unicode/HTML left unescaped — matching
-     * the other SDK cores.
-     */
-    readonly encode: (envelope: Envelope) => string;
-    /**
-     * Parse a raw JSON body. Returns `{}` for malformed or non-object input (call
-     * {@link EnvelopeCodec.accepts} before trusting it). Resolves the `urn` inbound
-     * alias into `job`.
-     */
-    readonly decode: (raw: string) => IncomingEnvelope;
-    /** The message URN — canonical `job`, with `urn` accepted as an alias. */
-    readonly urn: (envelope: IncomingEnvelope) => string;
-    /**
-     * Whether a consumer should accept this envelope. Rejects a missing URN, an
-     * unsupported `meta.schema_version`, a non-object `data`, a non-integer
-     * `attempts`, or a blank `trace_id` — the consumer-side counterpart to the
-     * producer JSON Schema. Acts as a type guard that narrows to {@link Envelope}.
-     */
-    readonly accepts: (envelope: IncomingEnvelope) => envelope is Envelope;
-};
+import { E as Envelope } from './idempotency-DDHjGwF7.js';
+export { D as DeadLetter, a as EnvelopeCodec, H as Handler, b as HasTraceId, I as InMemoryStore, c as IncomingEnvelope, M as MakeOptions, d as Meta, P as PolyglotMessage, S as SCHEMA_VERSION, e as SOURCE_LANG, f as Store, W as Wrap } from './idempotency-DDHjGwF7.js';
 
 /** Options for {@link annotate}. */
 interface AnnotateOptions {
@@ -171,5 +47,93 @@ declare class BabelQueueError extends Error {
 declare class UnknownUrnError extends BabelQueueError {
     constructor(urn: string);
 }
+/**
+ * Raised when a message's `data` does not match the JSON Schema registered for its URN
+ * (ADR-0024). The consumer-side {@link schema.wrap} throws it so the adapter redelivers
+ * (and eventually dead-letters) a poison message.
+ */
+declare class InvalidPayloadError extends BabelQueueError {
+    readonly urn: string;
+    readonly violation: string;
+    constructor(urn: string, violation: string);
+}
+
+/**
+ * Optional per-URN payload schema validation (ADR-0024).
+ *
+ * The Node mirror of the Go `schema` package and PHP `BabelQueue\Schema`. A
+ * {@link SchemaProvider} supplies a JSON Schema for a message URN — typically built from a
+ * babelqueue-registry `registry.json` — and the message's `data` is validated against it.
+ * It is opt-in: a URN with no registered schema is never validated.
+ *
+ * ```ts
+ * import { schema } from "@babelqueue/core";
+ *
+ * const provider = schema.MapProvider.fromJson({ "urn:babel:orders:created": ORDERS_JSON });
+ * schema.validate(provider, "urn:babel:orders:created", { order_id: 7 }); // throws on mismatch
+ * const handler = schema.wrap(provider, async (env) => {  ...  });        // consumer safety net
+ * ```
+ *
+ * The core stays dependency-free and I/O-free, so it carries no file-based provider: a Node
+ * app or adapter reads its `registry.json` (with `node:fs`, etc.) and passes the schemas to
+ * {@link MapProvider.fromJson}. The validator is a small subset of JSON Schema (draft-07)
+ * whose verdicts match the Go, PHP and Python validators and babelqueue-registry's `compat`
+ * linter: `type`, `required`, `properties`, `additionalProperties`, `items`, `enum`,
+ * `const`, `minLength`, `minimum`. Unknown keywords are ignored.
+ */
+
+/** A parsed JSON Schema node. */
+type SchemaNode = Record<string, unknown>;
+/** A consume handler: receives a decoded envelope, may be sync or async. */
+type SchemaHandler = (env: Envelope) => void | Promise<void>;
+/**
+ * A source of per-URN `data` schemas, keyed on the message URN. `schemaFor` may be sync or
+ * async so a production provider can be service- or cache-backed; the reference
+ * {@link MapProvider} is synchronous.
+ */
+interface SchemaProvider {
+    schemaFor(urn: string): SchemaNode | undefined | Promise<SchemaNode | undefined>;
+}
+/** In-memory {@link SchemaProvider}, for tests and for embedding schemas in code. */
+declare class MapProvider implements SchemaProvider {
+    private readonly schemas;
+    constructor(schemas: Record<string, SchemaNode>);
+    /** Build a provider from URN -> raw JSON Schema strings, parsing each. */
+    static fromJson(raw: Record<string, string>): MapProvider;
+    schemaFor(urn: string): SchemaNode | undefined;
+}
+/**
+ * The first `data` violation for `(urn, data)`, or null when it is valid or when no schema is
+ * registered for the URN (opt-in). For producer-side branching.
+ */
+declare function check(provider: SchemaProvider, urn: string, data: Record<string, unknown>): Promise<string | null>;
+/**
+ * Validate `(urn, data)` against its registered schema, throwing {@link InvalidPayloadError}
+ * otherwise. The producer-side guard; call it before publishing.
+ */
+declare function validate(provider: SchemaProvider, urn: string, data: Record<string, unknown>): Promise<void>;
+/**
+ * Wrap a consume handler so each message's `data` is validated against its URN's schema
+ * before the handler runs (consumer-side safety net). Invalid data throws
+ * {@link InvalidPayloadError}, so the adapter redelivers (and eventually dead-letters) the
+ * poison message; a URN with no schema runs the handler unchanged. Prefer {@link check}
+ * producer-side to keep invalid data out of the queue entirely.
+ */
+declare function wrap(provider: SchemaProvider, handler: SchemaHandler): SchemaHandler;
+/** The first violation of `value` against a (subset) JSON Schema node, or null. */
+declare function validateSchema(schema: SchemaNode, value: unknown, path?: string): string | null;
+
+type schema_MapProvider = MapProvider;
+declare const schema_MapProvider: typeof MapProvider;
+type schema_SchemaHandler = SchemaHandler;
+type schema_SchemaNode = SchemaNode;
+type schema_SchemaProvider = SchemaProvider;
+declare const schema_check: typeof check;
+declare const schema_validate: typeof validate;
+declare const schema_validateSchema: typeof validateSchema;
+declare const schema_wrap: typeof wrap;
+declare namespace schema {
+  export { schema_MapProvider as MapProvider, type schema_SchemaHandler as SchemaHandler, type schema_SchemaNode as SchemaNode, type schema_SchemaProvider as SchemaProvider, schema_check as check, schema_validate as validate, schema_validateSchema as validateSchema, schema_wrap as wrap };
+}
 
-export { type AnnotateOptions, BabelQueueError, type DeadLetter, type Envelope, EnvelopeCodec, type HasTraceId, type IncomingEnvelope, type MakeOptions, type Meta, type PolyglotMessage, SCHEMA_VERSION, SOURCE_LANG, UnknownUrnError, UnknownUrnStrategy, annotate, deadLetter };
+export { type AnnotateOptions, BabelQueueError, Envelope, InvalidPayloadError, type SchemaNode, type SchemaProvider, UnknownUrnError, UnknownUrnStrategy, annotate, deadLetter, schema };

package/dist/index.js

@@ -1,134 +1,12 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/codec.ts
-import { randomUUID } from "crypto";
-
-// src/errors.ts
-var BabelQueueError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BabelQueueError";
-  }
-};
-var UnknownUrnError = class extends BabelQueueError {
-  constructor(urn) {
-    super(`No handler is mapped for the message URN "${urn}".`);
-    this.name = "UnknownUrnError";
-  }
-};
-
-// src/codec.ts
-var SCHEMA_VERSION = 1;
-var SOURCE_LANG = "node";
-var EnvelopeCodec = {
+import {
+  BabelQueueError,
+  EnvelopeCodec,
+  InvalidPayloadError,
   SCHEMA_VERSION,
   SOURCE_LANG,
-  /**
-   * Build the canonical envelope for a `(urn, data)` pair. Mints a fresh trace id
-   * unless `options.traceId` is given, starts `attempts` at 0, and stamps `meta`.
-   * Throws {@link BabelQueueError} when the URN is blank.
-   */
-  make(urn, data, options = {}) {
-    const resolvedUrn = (urn ?? "").trim();
-    if (resolvedUrn === "") {
-      throw new BabelQueueError(
-        "A polyglot message must expose a stable, non-empty URN so consumers can identify it without any class name."
-      );
-    }
-    const traceId = (options.traceId ?? "").trim() || randomUUID();
-    return {
-      job: resolvedUrn,
-      trace_id: traceId,
-      data: { ...data },
-      meta: {
-        id: randomUUID(),
-        queue: options.queue ?? "default",
-        lang: SOURCE_LANG,
-        schema_version: SCHEMA_VERSION,
-        created_at: Date.now()
-      },
-      attempts: 0
-    };
-  },
-  /**
-   * Build the envelope from a {@link PolyglotMessage}. If the message also
-   * implements {@link HasTraceId} and returns a non-empty value, that trace id is
-   * reused.
-   */
-  fromMessage(message, queue = "default") {
-    const traceId = typeof message.getBabelTraceId === "function" ? message.getBabelTraceId() ?? void 0 : void 0;
-    return EnvelopeCodec.make(message.getBabelUrn(), message.toPayload(), {
-      queue,
-      traceId
-    });
-  },
-  /**
-   * Encode the envelope as compact UTF-8 JSON. `JSON.stringify` already emits the
-   * canonical form — no spaces, and slashes/unicode/HTML left unescaped — matching
-   * the other SDK cores.
-   */
-  encode(envelope) {
-    return JSON.stringify(envelope);
-  },
-  /**
-   * Parse a raw JSON body. Returns `{}` for malformed or non-object input (call
-   * {@link EnvelopeCodec.accepts} before trusting it). Resolves the `urn` inbound
-   * alias into `job`.
-   */
-  decode(raw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return {};
-    }
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return {};
-    }
-    const envelope = parsed;
-    if (!envelope.job && typeof envelope.urn === "string") {
-      envelope.job = envelope.urn;
-    }
-    return envelope;
-  },
-  /** The message URN — canonical `job`, with `urn` accepted as an alias. */
-  urn(envelope) {
-    const value = envelope?.job ?? envelope?.urn ?? "";
-    return typeof value === "string" ? value.trim() : "";
-  },
-  /**
-   * Whether a consumer should accept this envelope. Rejects a missing URN, an
-   * unsupported `meta.schema_version`, a non-object `data`, a non-integer
-   * `attempts`, or a blank `trace_id` — the consumer-side counterpart to the
-   * producer JSON Schema. Acts as a type guard that narrows to {@link Envelope}.
-   */
-  accepts(envelope) {
-    if (EnvelopeCodec.urn(envelope) === "") {
-      return false;
-    }
-    const meta = envelope.meta;
-    if (meta === null || typeof meta !== "object" || meta.schema_version !== SCHEMA_VERSION) {
-      return false;
-    }
-    const data = envelope.data;
-    if (data === null || typeof data !== "object" || Array.isArray(data)) {
-      return false;
-    }
-    const attempts = envelope.attempts;
-    if (typeof attempts !== "number" || !Number.isInteger(attempts)) {
-      return false;
-    }
-    const traceId = envelope.trace_id;
-    if (typeof traceId !== "string" || traceId.trim() === "") {
-      return false;
-    }
-    return true;
-  }
-};
+  UnknownUrnError,
+  __export
+} from "./chunk-7FUZ3LYT.js";
 
 // src/deadLetter.ts
 var deadLetter_exports = {};
@@ -159,14 +37,203 @@ var UnknownUrnStrategy = {
   /** Route to the dead-letter queue. */
   DEAD_LETTER: "dead_letter"
 };
+
+// src/idempotency.ts
+var InMemoryStore = class {
+  entries = /* @__PURE__ */ new Set();
+  seen(messageId) {
+    return this.entries.has(messageId);
+  }
+  remember(messageId) {
+    this.entries.add(messageId);
+  }
+  forget(messageId) {
+    this.entries.delete(messageId);
+  }
+};
+function Wrap(store, handler) {
+  return async (env) => {
+    const id = env.meta.id;
+    if (!id) {
+      await handler(env);
+      return;
+    }
+    if (await store.seen(id)) {
+      return;
+    }
+    await handler(env);
+    await store.remember(id);
+  };
+}
+
+// src/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  MapProvider: () => MapProvider,
+  check: () => check,
+  validate: () => validate,
+  validateSchema: () => validateSchema,
+  wrap: () => wrap
+});
+var MapProvider = class _MapProvider {
+  schemas;
+  constructor(schemas) {
+    this.schemas = new Map(Object.entries(schemas));
+  }
+  /** Build a provider from URN -> raw JSON Schema strings, parsing each. */
+  static fromJson(raw) {
+    const schemas = {};
+    for (const [urn, body] of Object.entries(raw)) {
+      const decoded = JSON.parse(body);
+      if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) {
+        throw new Error(`schema: invalid JSON schema for "${urn}"`);
+      }
+      schemas[urn] = decoded;
+    }
+    return new _MapProvider(schemas);
+  }
+  schemaFor(urn) {
+    return this.schemas.get(urn);
+  }
+};
+async function check(provider, urn, data) {
+  const schemaNode = await provider.schemaFor(urn);
+  if (!schemaNode) {
+    return null;
+  }
+  return validateSchema(schemaNode, data);
+}
+async function validate(provider, urn, data) {
+  const violation2 = await check(provider, urn, data);
+  if (violation2 !== null) {
+    throw new InvalidPayloadError(urn, violation2);
+  }
+}
+function wrap(provider, handler) {
+  return async (env) => {
+    await validate(provider, env.job, env.data);
+    await handler(env);
+  };
+}
+function validateSchema(schema, value, path = "") {
+  if ("const" in schema && !equal(value, schema.const)) {
+    return violation(path, "wrong_const");
+  }
+  const enumValues = schema.enum;
+  if (Array.isArray(enumValues) && !enumValues.some((item) => equal(value, item))) {
+    return violation(path, "not_in_enum");
+  }
+  const type = typeof schema.type === "string" ? schema.type : "";
+  switch (type) {
+    case "object":
+      return checkObject(schema, value, path);
+    case "array":
+      return checkArray(schema, value, path);
+    case "string": {
+      if (typeof value !== "string") {
+        return violation(path, "not_a_string");
+      }
+      const minLength = schema.minLength;
+      if (typeof minLength === "number" && value.length < minLength) {
+        return violation(path, "below_min_length");
+      }
+      return null;
+    }
+    case "integer":
+      if (!isInteger(value)) {
+        return violation(path, "not_an_integer");
+      }
+      return checkMinimum(schema, value, path);
+    case "number":
+      if (typeof value !== "number") {
+        return violation(path, "not_a_number");
+      }
+      return checkMinimum(schema, value, path);
+    case "boolean":
+      return typeof value === "boolean" ? null : violation(path, "not_a_boolean");
+    case "null":
+      return value === null ? null : violation(path, "not_null");
+    default:
+      return null;
+  }
+}
+function checkObject(schema, value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return violation(path, "not_an_object");
+  }
+  const obj = value;
+  const required = schema.required;
+  if (Array.isArray(required)) {
+    for (const key of required) {
+      if (typeof key === "string" && !(key in obj)) {
+        return violation(join(path, key), "missing_required");
+      }
+    }
+  }
+  const properties = typeof schema.properties === "object" && schema.properties !== null ? schema.properties : {};
+  const additionalAllowed = schema.additionalProperties !== false;
+  for (const [name, item] of Object.entries(obj)) {
+    const propSchema = properties[name];
+    if (typeof propSchema === "object" && propSchema !== null) {
+      const found = validateSchema(propSchema, item, join(path, name));
+      if (found !== null) {
+        return found;
+      }
+      continue;
+    }
+    if (!additionalAllowed) {
+      return violation(join(path, name), "additional_not_allowed");
+    }
+  }
+  return null;
+}
+function checkArray(schema, value, path) {
+  if (!Array.isArray(value)) {
+    return violation(path, "not_an_array");
+  }
+  const items = schema.items;
+  if (typeof items !== "object" || items === null) {
+    return null;
+  }
+  for (let i = 0; i < value.length; i++) {
+    const found = validateSchema(items, value[i], `${path}[${i}]`);
+    if (found !== null) {
+      return found;
+    }
+  }
+  return null;
+}
+function checkMinimum(schema, value, path) {
+  const minimum = schema.minimum;
+  if (typeof minimum === "number" && value < minimum) {
+    return violation(path, "below_minimum");
+  }
+  return null;
+}
+function isInteger(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function equal(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function violation(path, reason) {
+  return `${path === "" ? "<root>" : path}: ${reason}`;
+}
+function join(path, key) {
+  return path === "" ? key : `${path}.${key}`;
+}
 export {
   BabelQueueError,
   EnvelopeCodec,
+  InMemoryStore,
+  InvalidPayloadError,
   SCHEMA_VERSION,
   SOURCE_LANG,
   UnknownUrnError,
   UnknownUrnStrategy,
+  Wrap,
   annotate,
-  deadLetter_exports as deadLetter
+  deadLetter_exports as deadLetter,
+  schema_exports as schema
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/codec.ts","../src/errors.ts","../src/deadLetter.ts","../src/routing.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\n\nimport type { HasTraceId, PolyglotMessage } from \"./contracts.js\";\nimport { BabelQueueError } from \"./errors.js\";\n\n/** The wire envelope schema version this core implements (versioned independently of the package version). */\nexport const SCHEMA_VERSION = 1;\n\n/** Stamped into `meta.lang` for envelopes produced by this core. */\nexport const SOURCE_LANG = \"node\";\n\n/** Immutable per-message metadata. */\nexport interface Meta {\n  id: string;\n  queue: string;\n  lang: string;\n  schema_version: number;\n  /** Unix milliseconds, UTC. */\n  created_at: number;\n}\n\n/** The additive block appended to an envelope when a message is dead-lettered. */\nexport interface DeadLetter {\n  reason: string;\n  error: string | null;\n  exception: string | null;\n  /** Unix milliseconds, UTC. */\n  failed_at: number;\n  original_queue: string;\n  attempts: number;\n  lang: string;\n}\n\n/**\n * The canonical BabelQueue wire message: a strict, language-neutral JSON shape\n * that every SDK produces and consumes identically. The property order here is\n * significant — it matches the other cores so {@link EnvelopeCodec.encode} is\n * byte-for-byte identical across the insertion-order languages (PHP/Python).\n */\nexport interface Envelope {\n  /** The message URN (never a class name). */\n  job: string;\n  /** Correlation id, preserved across every hop. */\n  trace_id: string;\n  /** The pure-JSON payload. */\n  data: Record<string, unknown>;\n  meta: Meta;\n  /** Top-level transport retry counter. */\n  attempts: number;\n  /** Present only once the message has been dead-lettered. */\n  dead_letter?: DeadLetter;\n}\n\n/**\n * A decoded, not-yet-validated envelope. Fields are loosely typed because they\n * come off the wire; `urn` is accepted as an inbound alias for `job`. Narrow it\n * with {@link EnvelopeCodec.accepts} before trusting the contents.\n */\nexport interface IncomingEnvelope {\n  job?: string;\n  /** Inbound alias for `job`. */\n  urn?: string;\n  trace_id?: string;\n  data?: unknown;\n  meta?: unknown;\n  attempts?: unknown;\n  dead_letter?: unknown;\n}\n\n/** Options for {@link EnvelopeCodec.make}. */\nexport interface MakeOptions {\n  /** Logical queue name recorded in `meta.queue` (default `\"default\"`). */\n  queue?: string;\n  /** Reuse an existing trace id (trace continuation) instead of minting one. */\n  traceId?: string;\n}\n\n/**\n * Builds, encodes and decodes the canonical envelope — the single Node/TypeScript\n * implementation of the wire format.\n */\nexport const EnvelopeCodec = {\n  SCHEMA_VERSION,\n  SOURCE_LANG,\n\n  /**\n   * Build the canonical envelope for a `(urn, data)` pair. Mints a fresh trace id\n   * unless `options.traceId` is given, starts `attempts` at 0, and stamps `meta`.\n   * Throws {@link BabelQueueError} when the URN is blank.\n   */\n  make(\n    urn: string,\n    data: Record<string, unknown>,\n    options: MakeOptions = {},\n  ): Envelope {\n    const resolvedUrn = (urn ?? \"\").trim();\n    if (resolvedUrn === \"\") {\n      throw new BabelQueueError(\n        \"A polyglot message must expose a stable, non-empty URN so consumers can identify it without any class name.\",\n      );\n    }\n\n    const traceId = (options.traceId ?? \"\").trim() || randomUUID();\n\n    return {\n      job: resolvedUrn,\n      trace_id: traceId,\n      data: { ...data },\n      meta: {\n        id: randomUUID(),\n        queue: options.queue ?? \"default\",\n        lang: SOURCE_LANG,\n        schema_version: SCHEMA_VERSION,\n        created_at: Date.now(),\n      },\n      attempts: 0,\n    };\n  },\n\n  /**\n   * Build the envelope from a {@link PolyglotMessage}. If the message also\n   * implements {@link HasTraceId} and returns a non-empty value, that trace id is\n   * reused.\n   */\n  fromMessage(\n    message: PolyglotMessage & Partial<HasTraceId>,\n    queue = \"default\",\n  ): Envelope {\n    const traceId =\n      typeof message.getBabelTraceId === \"function\"\n        ? (message.getBabelTraceId() ?? undefined)\n        : undefined;\n\n    return EnvelopeCodec.make(message.getBabelUrn(), message.toPayload(), {\n      queue,\n      traceId,\n    });\n  },\n\n  /**\n   * Encode the envelope as compact UTF-8 JSON. `JSON.stringify` already emits the\n   * canonical form — no spaces, and slashes/unicode/HTML left unescaped — matching\n   * the other SDK cores.\n   */\n  encode(envelope: Envelope): string {\n    return JSON.stringify(envelope);\n  },\n\n  /**\n   * Parse a raw JSON body. Returns `{}` for malformed or non-object input (call\n   * {@link EnvelopeCodec.accepts} before trusting it). Resolves the `urn` inbound\n   * alias into `job`.\n   */\n  decode(raw: string): IncomingEnvelope {\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(raw);\n    } catch {\n      return {};\n    }\n    if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) {\n      return {};\n    }\n\n    const envelope = parsed as IncomingEnvelope;\n    if (!envelope.job && typeof envelope.urn === \"string\") {\n      envelope.job = envelope.urn;\n    }\n    return envelope;\n  },\n\n  /** The message URN — canonical `job`, with `urn` accepted as an alias. */\n  urn(envelope: IncomingEnvelope): string {\n    const value = envelope?.job ?? envelope?.urn ?? \"\";\n    return typeof value === \"string\" ? value.trim() : \"\";\n  },\n\n  /**\n   * Whether a consumer should accept this envelope. Rejects a missing URN, an\n   * unsupported `meta.schema_version`, a non-object `data`, a non-integer\n   * `attempts`, or a blank `trace_id` — the consumer-side counterpart to the\n   * producer JSON Schema. Acts as a type guard that narrows to {@link Envelope}.\n   */\n  accepts(envelope: IncomingEnvelope): envelope is Envelope {\n    if (EnvelopeCodec.urn(envelope) === \"\") {\n      return false;\n    }\n\n    const meta = envelope.meta;\n    if (\n      meta === null ||\n      typeof meta !== \"object\" ||\n      (meta as Meta).schema_version !== SCHEMA_VERSION\n    ) {\n      return false;\n    }\n\n    const data = envelope.data;\n    if (data === null || typeof data !== \"object\" || Array.isArray(data)) {\n      return false;\n    }\n\n    const attempts = envelope.attempts;\n    if (typeof attempts !== \"number\" || !Number.isInteger(attempts)) {\n      return false;\n    }\n\n    const traceId = envelope.trace_id;\n    if (typeof traceId !== \"string\" || traceId.trim() === \"\") {\n      return false;\n    }\n\n    return true;\n  },\n} as const;\n","/** Base error for all BabelQueue failures. */\nexport class BabelQueueError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"BabelQueueError\";\n  }\n}\n\n/** Raised when no handler is mapped for a message URN. */\nexport class UnknownUrnError extends BabelQueueError {\n  constructor(urn: string) {\n    super(`No handler is mapped for the message URN \"${urn}\".`);\n    this.name = \"UnknownUrnError\";\n  }\n}\n","import type { DeadLetter, Envelope } from \"./codec.js\";\nimport { SOURCE_LANG } from \"./codec.js\";\n\n/** Options for {@link annotate}. */\nexport interface AnnotateOptions {\n  /** Defaults to the envelope's current `attempts`. */\n  attempts?: number;\n  /** A human-readable error message (JSON `null` when omitted). */\n  error?: string | null;\n  /** The originating error type/class name (JSON `null` when omitted). */\n  exception?: string | null;\n}\n\n/**\n * Return a copy of the envelope with a `dead_letter` block attached, recording\n * why and where it failed. The original envelope is preserved unchanged inside\n * the result, so any-language consumers can still read it.\n */\nexport function annotate(\n  envelope: Envelope,\n  reason: string,\n  originalQueue: string,\n  options: AnnotateOptions = {},\n): Envelope {\n  const deadLetter: DeadLetter = {\n    reason,\n    error: options.error ?? null,\n    exception: options.exception ?? null,\n    failed_at: Date.now(),\n    original_queue: originalQueue,\n    attempts: options.attempts ?? envelope.attempts ?? 0,\n    lang: SOURCE_LANG,\n  };\n\n  return { ...envelope, dead_letter: deadLetter };\n}\n","/**\n * What a consumer does with a message whose URN has no registered handler.\n * Mirrors the constants in every other SDK core.\n */\nexport const UnknownUrnStrategy = {\n  /** Surface an error; let the worker decide. */\n  FAIL: \"fail\",\n  /** Drop the message. */\n  DELETE: \"delete\",\n  /** Requeue for another consumer. */\n  RELEASE: \"release\",\n  /** Route to the dead-letter queue. */\n  DEAD_LETTER: \"dead_letter\",\n} as const;\n\nexport type UnknownUrnStrategy =\n  (typeof UnknownUrnStrategy)[keyof typeof UnknownUrnStrategy];\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/deadLetter.ts","../src/routing.ts","../src/idempotency.ts","../src/schema.ts"],"sourcesContent":["import type { DeadLetter, Envelope } from \"./codec.js\";\nimport { SOURCE_LANG } from \"./codec.js\";\n\n/** Options for {@link annotate}. */\nexport interface AnnotateOptions {\n  /** Defaults to the envelope's current `attempts`. */\n  attempts?: number;\n  /** A human-readable error message (JSON `null` when omitted). */\n  error?: string | null;\n  /** The originating error type/class name (JSON `null` when omitted). */\n  exception?: string | null;\n}\n\n/**\n * Return a copy of the envelope with a `dead_letter` block attached, recording\n * why and where it failed. The original envelope is preserved unchanged inside\n * the result, so any-language consumers can still read it.\n */\nexport function annotate(\n  envelope: Envelope,\n  reason: string,\n  originalQueue: string,\n  options: AnnotateOptions = {},\n): Envelope {\n  const deadLetter: DeadLetter = {\n    reason,\n    error: options.error ?? null,\n    exception: options.exception ?? null,\n    failed_at: Date.now(),\n    original_queue: originalQueue,\n    attempts: options.attempts ?? envelope.attempts ?? 0,\n    lang: SOURCE_LANG,\n  };\n\n  return { ...envelope, dead_letter: deadLetter };\n}\n","/**\n * What a consumer does with a message whose URN has no registered handler.\n * Mirrors the constants in every other SDK core.\n */\nexport const UnknownUrnStrategy = {\n  /** Surface an error; let the worker decide. */\n  FAIL: \"fail\",\n  /** Drop the message. */\n  DELETE: \"delete\",\n  /** Requeue for another consumer. */\n  RELEASE: \"release\",\n  /** Route to the dead-letter queue. */\n  DEAD_LETTER: \"dead_letter\",\n} as const;\n\nexport type UnknownUrnStrategy =\n  (typeof UnknownUrnStrategy)[keyof typeof UnknownUrnStrategy];\n","/**\n * Optional idempotency helper (ADR-0022): dedupe a consume handler on `meta.id`.\n *\n * The Node mirror of the PHP `BabelQueue\\Idempotency` and Go `idempotency` helpers.\n * The core is codec-only (no dispatcher), so this wraps a user-provided handler that\n * an adapter (NestJS, BullMQ, ...) drives:\n *\n * ```ts\n * import { Wrap, InMemoryStore, type Handler } from \"@babelqueue/core\";\n *\n * const store = new InMemoryStore();\n * const handler = Wrap(store, async (env) => {  ...  });\n * ```\n *\n * A previously-seen id returns early (the adapter acks it); a throwing/rejecting\n * handler leaves the id unmarked so a redelivery runs it again; a message with no\n * usable `meta.id` runs unchanged. \"Seen-set\" post-success dedupe — not exactly-once,\n * not in-flight concurrency locking (a transactional mode is a future direction).\n */\nimport type { Envelope } from \"./codec.js\";\n\n/** A consume handler: receives a decoded envelope, may be sync or async. */\nexport type Handler = (env: Envelope) => void | Promise<void>;\n\n/**\n * A pluggable record of message ids already processed, keyed on `meta.id`. Methods may\n * be sync or async so a production store can be Redis- or DB-backed; the reference\n * {@link InMemoryStore} is synchronous.\n */\nexport interface Store {\n  seen(messageId: string): boolean | Promise<boolean>;\n  remember(messageId: string): void | Promise<void>;\n  forget(messageId: string): void | Promise<void>;\n}\n\n/**\n * Process-local {@link Store} backed by a Set. For tests / single-process consumers;\n * not shared across workers and not persistent — use a Redis- or DB-backed store for\n * production fleets.\n */\nexport class InMemoryStore implements Store {\n  private readonly entries = new Set<string>();\n\n  seen(messageId: string): boolean {\n    return this.entries.has(messageId);\n  }\n\n  remember(messageId: string): void {\n    this.entries.add(messageId);\n  }\n\n  forget(messageId: string): void {\n    this.entries.delete(messageId);\n  }\n}\n\n/**\n * Wraps `handler` so a message whose `meta.id` was already processed successfully is\n * skipped. A thrown/rejected handler leaves the id unmarked, so a redelivery runs it\n * again (retry / dead-letter still apply); a message with no usable id runs unchanged.\n */\nexport function Wrap(store: Store, handler: Handler): Handler {\n  return async (env: Envelope): Promise<void> => {\n    const id = env.meta.id;\n\n    // No usable id → cannot dedupe; run the handler unchanged.\n    if (!id) {\n      await handler(env);\n      return;\n    }\n\n    // Already processed on an earlier delivery: return so the adapter acks it.\n    if (await store.seen(id)) {\n      return;\n    }\n\n    // First success wins; a throw here leaves the id unmarked → retry/DLQ apply.\n    await handler(env);\n    await store.remember(id);\n  };\n}\n","/**\n * Optional per-URN payload schema validation (ADR-0024).\n *\n * The Node mirror of the Go `schema` package and PHP `BabelQueue\\Schema`. A\n * {@link SchemaProvider} supplies a JSON Schema for a message URN — typically built from a\n * babelqueue-registry `registry.json` — and the message's `data` is validated against it.\n * It is opt-in: a URN with no registered schema is never validated.\n *\n * ```ts\n * import { schema } from \"@babelqueue/core\";\n *\n * const provider = schema.MapProvider.fromJson({ \"urn:babel:orders:created\": ORDERS_JSON });\n * schema.validate(provider, \"urn:babel:orders:created\", { order_id: 7 }); // throws on mismatch\n * const handler = schema.wrap(provider, async (env) => {  ...  });        // consumer safety net\n * ```\n *\n * The core stays dependency-free and I/O-free, so it carries no file-based provider: a Node\n * app or adapter reads its `registry.json` (with `node:fs`, etc.) and passes the schemas to\n * {@link MapProvider.fromJson}. The validator is a small subset of JSON Schema (draft-07)\n * whose verdicts match the Go, PHP and Python validators and babelqueue-registry's `compat`\n * linter: `type`, `required`, `properties`, `additionalProperties`, `items`, `enum`,\n * `const`, `minLength`, `minimum`. Unknown keywords are ignored.\n */\nimport type { Envelope } from \"./codec.js\";\nimport { InvalidPayloadError } from \"./errors.js\";\n\n/** A parsed JSON Schema node. */\nexport type SchemaNode = Record<string, unknown>;\n\n/** A consume handler: receives a decoded envelope, may be sync or async. */\nexport type SchemaHandler = (env: Envelope) => void | Promise<void>;\n\n/**\n * A source of per-URN `data` schemas, keyed on the message URN. `schemaFor` may be sync or\n * async so a production provider can be service- or cache-backed; the reference\n * {@link MapProvider} is synchronous.\n */\nexport interface SchemaProvider {\n  schemaFor(urn: string): SchemaNode | undefined | Promise<SchemaNode | undefined>;\n}\n\n/** In-memory {@link SchemaProvider}, for tests and for embedding schemas in code. */\nexport class MapProvider implements SchemaProvider {\n  private readonly schemas: Map<string, SchemaNode>;\n\n  constructor(schemas: Record<string, SchemaNode>) {\n    this.schemas = new Map(Object.entries(schemas));\n  }\n\n  /** Build a provider from URN -> raw JSON Schema strings, parsing each. */\n  static fromJson(raw: Record<string, string>): MapProvider {\n    const schemas: Record<string, SchemaNode> = {};\n    for (const [urn, body] of Object.entries(raw)) {\n      const decoded: unknown = JSON.parse(body);\n      if (typeof decoded !== \"object\" || decoded === null || Array.isArray(decoded)) {\n        throw new Error(`schema: invalid JSON schema for \"${urn}\"`);\n      }\n      schemas[urn] = decoded as SchemaNode;\n    }\n    return new MapProvider(schemas);\n  }\n\n  schemaFor(urn: string): SchemaNode | undefined {\n    return this.schemas.get(urn);\n  }\n}\n\n/**\n * The first `data` violation for `(urn, data)`, or null when it is valid or when no schema is\n * registered for the URN (opt-in). For producer-side branching.\n */\nexport async function check(\n  provider: SchemaProvider,\n  urn: string,\n  data: Record<string, unknown>,\n): Promise<string | null> {\n  const schemaNode = await provider.schemaFor(urn);\n  if (!schemaNode) {\n    return null;\n  }\n  return validateSchema(schemaNode, data);\n}\n\n/**\n * Validate `(urn, data)` against its registered schema, throwing {@link InvalidPayloadError}\n * otherwise. The producer-side guard; call it before publishing.\n */\nexport async function validate(\n  provider: SchemaProvider,\n  urn: string,\n  data: Record<string, unknown>,\n): Promise<void> {\n  const violation = await check(provider, urn, data);\n  if (violation !== null) {\n    throw new InvalidPayloadError(urn, violation);\n  }\n}\n\n/**\n * Wrap a consume handler so each message's `data` is validated against its URN's schema\n * before the handler runs (consumer-side safety net). Invalid data throws\n * {@link InvalidPayloadError}, so the adapter redelivers (and eventually dead-letters) the\n * poison message; a URN with no schema runs the handler unchanged. Prefer {@link check}\n * producer-side to keep invalid data out of the queue entirely.\n */\nexport function wrap(provider: SchemaProvider, handler: SchemaHandler): SchemaHandler {\n  return async (env: Envelope): Promise<void> => {\n    await validate(provider, env.job, env.data);\n    await handler(env);\n  };\n}\n\n/** The first violation of `value` against a (subset) JSON Schema node, or null. */\nexport function validateSchema(schema: SchemaNode, value: unknown, path = \"\"): string | null {\n  if (\"const\" in schema && !equal(value, schema.const)) {\n    return violation(path, \"wrong_const\");\n  }\n  const enumValues = schema.enum;\n  if (Array.isArray(enumValues) && !enumValues.some((item) => equal(value, item))) {\n    return violation(path, \"not_in_enum\");\n  }\n\n  const type = typeof schema.type === \"string\" ? schema.type : \"\";\n  switch (type) {\n    case \"object\":\n      return checkObject(schema, value, path);\n    case \"array\":\n      return checkArray(schema, value, path);\n    case \"string\": {\n      if (typeof value !== \"string\") {\n        return violation(path, \"not_a_string\");\n      }\n      const minLength = schema.minLength;\n      if (typeof minLength === \"number\" && value.length < minLength) {\n        return violation(path, \"below_min_length\");\n      }\n      return null;\n    }\n    case \"integer\":\n      if (!isInteger(value)) {\n        return violation(path, \"not_an_integer\");\n      }\n      return checkMinimum(schema, value, path);\n    case \"number\":\n      if (typeof value !== \"number\") {\n        return violation(path, \"not_a_number\");\n      }\n      return checkMinimum(schema, value, path);\n    case \"boolean\":\n      return typeof value === \"boolean\" ? null : violation(path, \"not_a_boolean\");\n    case \"null\":\n      return value === null ? null : violation(path, \"not_null\");\n    default:\n      return null;\n  }\n}\n\nfunction checkObject(schema: SchemaNode, value: unknown, path: string): string | null {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    return violation(path, \"not_an_object\");\n  }\n  const obj = value as Record<string, unknown>;\n\n  const required = schema.required;\n  if (Array.isArray(required)) {\n    for (const key of required) {\n      if (typeof key === \"string\" && !(key in obj)) {\n        return violation(join(path, key), \"missing_required\");\n      }\n    }\n  }\n\n  const properties =\n    typeof schema.properties === \"object\" && schema.properties !== null\n      ? (schema.properties as Record<string, unknown>)\n      : {};\n  const additionalAllowed = schema.additionalProperties !== false;\n\n  for (const [name, item] of Object.entries(obj)) {\n    const propSchema = properties[name];\n    if (typeof propSchema === \"object\" && propSchema !== null) {\n      const found = validateSchema(propSchema as SchemaNode, item, join(path, name));\n      if (found !== null) {\n        return found;\n      }\n      continue;\n    }\n    if (!additionalAllowed) {\n      return violation(join(path, name), \"additional_not_allowed\");\n    }\n  }\n\n  return null;\n}\n\nfunction checkArray(schema: SchemaNode, value: unknown, path: string): string | null {\n  if (!Array.isArray(value)) {\n    return violation(path, \"not_an_array\");\n  }\n  const items = schema.items;\n  if (typeof items !== \"object\" || items === null) {\n    return null;\n  }\n  for (let i = 0; i < value.length; i++) {\n    const found = validateSchema(items as SchemaNode, value[i], `${path}[${i}]`);\n    if (found !== null) {\n      return found;\n    }\n  }\n  return null;\n}\n\nfunction checkMinimum(schema: SchemaNode, value: number, path: string): string | null {\n  const minimum = schema.minimum;\n  if (typeof minimum === \"number\" && value < minimum) {\n    return violation(path, \"below_minimum\");\n  }\n  return null;\n}\n\n// JSON numbers are all `number` in JS; an integer is a whole number (and never a boolean).\nfunction isInteger(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isInteger(value);\n}\n\n// Structural equality for enum/const checks: JSON.stringify distinguishes a string \"1\" from\n// a number 1, matching the strict comparisons in the other SDK validators.\nfunction equal(a: unknown, b: unknown): boolean {\n  return JSON.stringify(a) === JSON.stringify(b);\n}\n\nfunction violation(path: string, reason: string): string {\n  return `${path === \"\" ? \"<root>\" : path}: ${reason}`;\n}\n\nfunction join(path: string, key: string): string {\n  return path === \"\" ? key : `${path}.${key}`;\n}\n"],"mappings":"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","names":["violation"]}