@pattern-stack/codegen 0.17.0 → 0.17.2

package/CHANGELOG.md

@@ -4,6 +4,110 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.17.2] — 2026-06-04
+
+**Shutdown leak fix** (LISTEN-NOTIFY-2; swe-brain dogfood). With
+`listen_notify: true` (the LISTEN/NOTIFY wake extension shipped in 0.16.0), a
+Nest app that booted and then `app.close()`d — e.g. a boot-check / CI smoke step —
+never exited: at least one `LISTEN codegen_jobs_wake` client survived
+`app.close()`, holding an ESTABLISHED Postgres socket open forever (two swe-brain
+CI runs hung for hours). Backward-compatible; affects only consumers that opted
+into `listen_notify`.
+
+### Fixed
+
+- **`PgNotifyListener.stop()` is race-safe against an in-flight `connect()`**
+  (LISTEN-NOTIFY-2 RC1 — the defect that actually fired). `connect()` checked
+  `this.stopped` only at entry, then `await pool.connect()`, wired handlers,
+  issued `LISTEN`, and assigned `this.client` last. A `stop()` arriving during
+  the checkout await ran `releaseClient()` against a still-null `this.client`
+  (released nothing); the resuming `connect()` then assigned the client and
+  issued `LISTEN` — leaking a checked-out connection with no owner left to
+  release it. With 5–6 listeners (one per jobs pool + the events drainer) all
+  starting at bootstrap and a tight `app.close()`, the race fired on ~1 of 6
+  listeners — exactly the observed signature (one survivor, the rest clean).
+  Now `connect()` re-checks `stopped` after the checkout AND after `LISTEN`,
+  destroying the just-acquired client and bailing before assignment; `stop()`
+  tracks and awaits the in-flight connect promise before its own release, so
+  `app.close()` can't return while a checkout is still mid-flight. Releases use
+  `release(true)` (destroy) so a half-listening socket is never reused.
+- **`JobWorker.onModuleDestroy` stops the wake listener on EVERY destroy path**
+  (LISTEN-NOTIFY-2 RC2 — latent). The listener `stop()` lived only on the first
+  (non-`shuttingDown`) branch, so a SIGTERM-then-Nest double-destroy hit the
+  `if (this.shuttingDown) { …; return; }` early return and skipped it, leaking
+  the listener under the normal SIGTERM shutdown path. Teardown is now an
+  idempotent `stopNotifyListener()` called unconditionally at the top of every
+  destroy. `DrizzleEventBus` already stopped its listener unconditionally; it
+  shared `PgNotifyListener` and so benefits from the RC1 fix directly.
+
+## [0.17.1] — 2026-06-04
+
+**Two dogfood fixes that bit the same swe-brain mutation drain** (ADR-0009
+Amendment B): the jobs orchestrator silently dropped function-form
+concurrency/dedupe keys, and the integration differ unconditionally ignored
+`deletedAt`. Both are honored now; both are backward-compatible.
+
+### Fixed
+
+- **`@JobHandler` function-form `concurrency.key` / `dedupe.key` are honored
+  end-to-end** (JOB-FN-KEY; swe-brain ADR-0009 Amendment B §B3). The typed API
+  (`ConcurrencyPolicy.key`/`DedupePolicy.key`) had ALWAYS required a function,
+  but registration (`upsertJobRows`) stored only `typeof key === 'string' ? key
+  : null` — a function key persisted as a NULL `concurrency_key_template`, so
+  `start()` wrote a NULL `job_run.concurrency_key` and the worker's queue-release
+  gate (which keys off `claimed.concurrencyKey`) never engaged. Observed in
+  swe-brain: three `inbound-sync` runs the handler believed shared one
+  `collisionMode: 'queue'` lane ran fully concurrently, three `integration_runs`
+  racing one message row. Now both backends persist a function key as the
+  `FN_KEY_SENTINEL` marker (non-null, so the collision/dedupe path engages, and
+  hash-stable so the definition-hash gate doesn't churn) and re-resolve the live
+  function from `JOB_HANDLER_REGISTRY` at `start()`. A `FN_KEY_SENTINEL` with no
+  live function throws `JobKeyFunctionUnavailableError` (fail loud, never
+  silently degrade to no-key). Drizzle + memory + BullMQ (which delegates to the
+  Drizzle `start`) all agree.
+
+### Changed
+
+- **`ConcurrencyPolicy.key` / `DedupePolicy.key` widen to
+  `JobKeySelector<TInput> = string | ((input) => string)`.** The string form is
+  documented as a `{{field}}` template (evaluated by `evaluateKeyTemplate`); the
+  function form is the one that previously type-checked but was dropped. Existing
+  function keys now WORK (were silently no-key before); existing string-template
+  keys behave identically. New exports from `@pattern-stack/codegen/runtime/*`
+  jobs: `JobKeySelector`, `FN_KEY_SENTINEL`, `keySelectorToTemplate`,
+  `resolveJobKey`, `JobKeyFunctionUnavailableError`.
+
+### Added
+
+- **`DeepEqualDifferOptions.unignore`** — the inverse of `ignore`, subtracted
+  from the default ignore set after the merge (DIFFER-UNIGNORE; swe-brain
+  ADR-0009 Amendment B §B4). Lets a consumer declare that a normally-metadata
+  column is DOMAIN DATA for their entity. The canonical case: an entity with
+  `softDelete: false` whose `deletedAt` carries a vendor-observed retraction
+  tombstone ON the canonical record (a Slack `message_deleted` → `deletedAt`,
+  ADR-0008 §1). `deletedAt` is in `DEFAULT_IGNORE_FIELDS`, so the tombstone
+  overlay diffed to `'noop'` → the upsert was skipped → `deleted_at` never
+  landed (observed: `integration_run_items` `{operation: noop, changed_fields:
+  {}}` for every delete). `new DeepEqualDiffer({ unignore: ['deletedAt'] })` now
+  makes the field register as a change. `unignore` wins over a field also in
+  `ignore`; un-ignoring a field not in the set is a harmless no-op; per-instance
+  (never mutates `DEFAULT_IGNORE_FIELDS`).
+- **`IntegrationModuleOptions.differ` + `integration.differ.{ignore,unignore}`
+  config threading.** `IntegrationModule.forRoot({ differ: { unignore:
+  [...] } })` threads into the default `DeepEqualDiffer` bound to
+  `INTEGRATION_FIELD_DIFFER`, and the subsystem barrel generator emits that
+  `forRoot` option from `integration.differ.*` in `codegen.config.yaml` (same
+  off-by-default config-threading shape as 0.16.0's `listen_notify`; vendored +
+  package mode both covered). A feature module that binds its own
+  `IFieldDiffer<T>` still overrides entirely.
+
+### Docs
+
+- Differ header comment + `integration` consumer skill (`audit-and-detection.md`,
+  `protocols-and-ports.md`) document the `unignore` knob and the
+  `integration.differ.*` config path; the `integration-config` codegen.config
+  template gains a commented `differ:` block.
+
 ## [0.17.0] — 2026-06-04
 
 **`ActivityPattern` subject scoping is config-driven** (ACTIVITY-SUBJECT-1) —

package/consumer-skills/integration/audit-and-detection.md

@@ -285,15 +285,40 @@ as changes), but the diff output preserves the *raw* values:
   Drizzle while adapters deliver numbers; a numeric and a finite-parseable
   string compare equal (with an empty-string guard against silent 0-equality).
 
-**Augment the ignore list per entity** (values merge with the defaults; you
-cannot remove defaults):
+**Augment the ignore list** (`ignore` values merge with the defaults):
 
 ```ts
 { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer({ ignore: ['integration_version'] }) }
 ```
 
-Bind it as `useValue: new DeepEqualDiffer(...)`, not `useClass` — the
-constructor's optional options object confuses Nest's metadata reflection.
+**Un-ignore a default** (`unignore` — the inverse knob). A normally-metadata
+column can be *domain data* for a given entity. The canonical case: an entity
+with `softDelete: false` whose `deletedAt` carries a vendor-observed retraction
+tombstone *on the canonical record* (e.g. a Slack `message_deleted` maps to
+`deletedAt`). Because `deletedAt` is in the default ignore list, the tombstone
+overlay diffs to `'noop'`, the upsert is skipped, and `deleted_at` never lands.
+`unignore` removes it from the ignore set so it registers as a field change:
+
+```ts
+{ provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer({ unignore: ['deletedAt'] }) }
+```
+
+`unignore` is subtracted after `ignore` is merged, so it wins on a field listed
+in both. Un-ignoring a field that isn't in the (merged) set is a harmless no-op.
+
+**Set it once for the whole app via config** instead of binding per feature
+module — `integration.differ.{ignore,unignore}` in `codegen.config.yaml` threads
+into the default differ that `IntegrationModule.forRoot` provides:
+
+```yaml
+integration:
+  backend: drizzle
+  differ:
+    unignore: [deletedAt]   # this entity's deletedAt is domain data
+```
+
+Bind a per-module differ as `useValue: new DeepEqualDiffer(...)`, not `useClass`
+— the constructor's optional options object confuses Nest's metadata reflection.
 
 **`providerChangedFields` is advisory.** When a CDC provider tells you which
 columns changed, set it on the `Change<T>` and the differ skips deep-equal over

package/dist/{chunk-GJDEPTPY.js → chunk-235ZMMJR.js}

@@ -1,9 +1,13 @@
 import {
   JobWorker
-} from "./chunk-OITTYGJS.js";
+} from "./chunk-VDL5CJ5C.js";
 import {
   JobsDomainModule
-} from "./chunk-3MAZ4TQH.js";
+} from "./chunk-AZLUWG5S.js";
+import {
+  BootValidationError,
+  ReservedPoolViolationError
+} from "./chunk-T4BIIU5E.js";
 import {
   BULLMQ_CONNECTION,
   BULLMQ_RESOLVED_CONFIG,
@@ -14,13 +18,9 @@ import {
   allPoolNames,
   loadPoolConfig
 } from "./chunk-RHVN6NA7.js";
-import {
-  BootValidationError,
-  ReservedPoolViolationError
-} from "./chunk-T4BIIU5E.js";
 import {
   HandlerRegistry
-} from "./chunk-CO6LUM72.js";
+} from "./chunk-7P5ODGLA.js";
 import {
   JOB_ORCHESTRATOR,
   JOB_RUN_SERVICE,
@@ -290,4 +290,4 @@ export {
   JobWorkerOrchestrator,
   JobWorkerModule
 };
-//# sourceMappingURL=chunk-GJDEPTPY.js.map
+//# sourceMappingURL=chunk-235ZMMJR.js.map

package/dist/{chunk-DTXH24LR.js → chunk-65MO75WM.js}

@@ -1,22 +1,22 @@
 import {
   BRIDGE_DELIVERY_JOB_TYPE
-} from "./chunk-NXNVTXKG.js";
+} from "./chunk-R6F6KFIL.js";
 import {
   bridgeDelivery
 } from "./chunk-2TVVBC53.js";
-import {
-  JOBS_LISTEN_NOTIFY
-} from "./chunk-ZPL74UQN.js";
-import {
-  jobRuns
-} from "./chunk-OKXZ63IA.js";
 import {
   JOBS_WAKE_CHANNEL,
   pgNotify
-} from "./chunk-MYQIQ27N.js";
+} from "./chunk-Q6LRJ4VI.js";
+import {
+  JOBS_LISTEN_NOTIFY
+} from "./chunk-ZPL74UQN.js";
 import {
   BRIDGE_REGISTRY
 } from "./chunk-4LH67P4U.js";
+import {
+  jobRuns
+} from "./chunk-OKXZ63IA.js";
 import {
   __decorateClass,
   __decorateParam
@@ -151,4 +151,4 @@ BridgeOutboxDrainHook = __decorateClass([
 export {
   BridgeOutboxDrainHook
 };
-//# sourceMappingURL=chunk-DTXH24LR.js.map
+//# sourceMappingURL=chunk-65MO75WM.js.map

package/dist/{chunk-5RT7JGKT.js → chunk-7OVCARTQ.js}

@@ -4,14 +4,14 @@ import {
 import {
   JOB_ORCHESTRATOR
 } from "./chunk-ZPL74UQN.js";
+import {
+  EVENT_BUS
+} from "./chunk-H5NH7KPE.js";
 import {
   BRIDGE_DELIVERY_REPO,
   BRIDGE_MULTI_TENANT,
   BRIDGE_REGISTRY
 } from "./chunk-4LH67P4U.js";
-import {
-  EVENT_BUS
-} from "./chunk-H5NH7KPE.js";
 import {
   DRIZZLE
 } from "./chunk-U64T4YZE.js";
@@ -106,4 +106,4 @@ EventFlowService = __decorateClass([
 export {
   EventFlowService
 };
-//# sourceMappingURL=chunk-5RT7JGKT.js.map
+//# sourceMappingURL=chunk-7OVCARTQ.js.map

package/dist/{chunk-CO6LUM72.js → chunk-7P5ODGLA.js}

@@ -47,6 +47,34 @@ var HandlerRegistry;
   }
   HandlerRegistry2.get = get;
 })(HandlerRegistry || (HandlerRegistry = {}));
+var FN_KEY_SENTINEL = "<fn>";
+function keySelectorToTemplate(key) {
+  if (typeof key === "string") return key;
+  if (typeof key === "function") return FN_KEY_SENTINEL;
+  return null;
+}
+function resolveJobKey(kind, type, template, payload, evaluateTemplate) {
+  if (template == null) return null;
+  if (template !== FN_KEY_SENTINEL) return evaluateTemplate(template, payload);
+  const meta = JOB_HANDLER_REGISTRY.get(type)?.meta;
+  const key = meta?.[kind]?.key;
+  if (typeof key !== "function") {
+    throw new JobKeyFunctionUnavailableError(type, kind);
+  }
+  return key(payload);
+}
+var JobKeyFunctionUnavailableError = class extends Error {
+  constructor(jobType, kind) {
+    super(
+      `[jobs] ${kind} key for job '${jobType}' was persisted as a function sentinel ('${FN_KEY_SENTINEL}') but no live function is registered for it. The @JobHandler must be imported before start() so its meta is in JOB_HANDLER_REGISTRY.`
+    );
+    this.jobType = jobType;
+    this.kind = kind;
+    this.name = "JobKeyFunctionUnavailableError";
+  }
+  jobType;
+  kind;
+};
 
 export {
   ParentClosePolicy,
@@ -54,6 +82,10 @@ export {
   JOB_HANDLER_REGISTRY,
   JOB_HANDLER_METADATA_KEY,
   JobHandler,
-  HandlerRegistry
+  HandlerRegistry,
+  FN_KEY_SENTINEL,
+  keySelectorToTemplate,
+  resolveJobKey,
+  JobKeyFunctionUnavailableError
 };
-//# sourceMappingURL=chunk-CO6LUM72.js.map
+//# sourceMappingURL=chunk-7P5ODGLA.js.map

package/dist/chunk-7P5ODGLA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-handler.base.ts"],"sourcesContent":["/**\n * Handler base class, JobContext, @JobHandler decorator, and policy types\n * for the job orchestration domain (ADR-022, JOB-2).\n *\n * User-authored jobs subclass `JobHandlerBase<TInput, TOutput>` and decorate\n * the class with `@JobHandler<TInput>('job_type', meta)`. The decorator\n *   1. stores metadata via `Reflect.defineMetadata` so Nest's reflector can\n *      pick it up at module boot, and\n *   2. populates `JOB_HANDLER_REGISTRY` — a module-singleton map consumed by\n *      `JobWorkerModule` (JOB-5) to materialise `job` rows and resolve\n *      handler classes during claim/execute.\n *\n * No runtime orchestration lives here; this file is a pure type + decorator\n * surface so downstream PRs (JOB-3..JOB-5) can implement against a stable\n * shape.\n */\n// TODO(logging-subsystem): swap to ILogger once ADR-028 lands\nimport type { Logger } from '@nestjs/common';\nimport { tokenKey } from '../token-key';\nimport type { EventOfType, EventTypeName } from '../events/event-registry';\nimport type { JobRun } from './job-orchestrator.protocol';\n\n// ─── ParentClosePolicy ──────────────────────────────────────────────────────\n\n/**\n * What happens to running child runs when a parent enters a terminal state.\n * Stored on the child at spawn; changes to the parent after spawn do NOT\n * retroactively rewrite children.\n */\nexport enum ParentClosePolicy {\n  Terminate = 'terminate',\n  Cancel = 'cancel',\n  Abandon = 'abandon',\n}\n\n// ─── Policy types ───────────────────────────────────────────────────────────\n\nexport interface RetryPolicy {\n  attempts: number;\n  backoff: 'fixed' | 'exponential';\n  baseMs: number;\n  nonRetryableErrors?: string[];\n}\n\n/**\n * Concurrency lane key (JOB-FN-KEY, 0.16.2).\n *\n * Two authoring forms, both honored end-to-end (the typed function form was\n * previously dropped to `null` at registration — see `upsertJobRows` — so\n * `collisionMode` silently never engaged):\n *\n *   - **`string`** — a `{{field}}` template evaluated against the start\n *     payload by `evaluateKeyTemplate` (single-key substitution, no dotted\n *     paths). Persisted verbatim to `job.concurrency_key_template`.\n *   - **`(input) => string`** — an arbitrary function of the input. Persisted\n *     as the `FN_KEY_SENTINEL` marker so the definition-hash gate stays stable\n *     and the collision path engages; `start()` re-resolves the live function\n *     from `JOB_HANDLER_REGISTRY` and evaluates it against the payload.\n *\n * Both forms produce a per-lane key; same key + in-flight incumbent ⇒\n * `collisionMode` ('queue' | 'reject' | 'replace') decides.\n */\nexport type JobKeySelector<TInput> = string | ((input: TInput) => string);\n\nexport interface ConcurrencyPolicy<TInput> {\n  key: JobKeySelector<TInput>;\n  collisionMode: 'queue' | 'reject' | 'replace';\n}\n\nexport interface DedupePolicy<TInput> {\n  key: JobKeySelector<TInput>;\n  windowMs: number;\n}\n\n/**\n * Declarative scope reference. `TScope` is parameterised so JOB-7 can narrow\n * `entity` to the generated `ScopeEntityType` union at the call site without\n * modifying this file (OQ-1 resolution, 2026-04-20).\n */\nexport interface ScopeRef<TInput, TScope extends string = string> {\n  entity: TScope;\n  from: (input: TInput) => string;\n}\n\n/**\n * Bridge trigger authoring shape (BRIDGE-6 follow-up — BRIDGE-6 shipped the\n * generator + runtime for `@JobHandler({ triggers })` but never added the\n * authoring field to this type; the generator's tests scan source as strings,\n * so a real decorator was never compiled and the gap went uncaught).\n *\n * Declared on `@JobHandler({ triggers })`; the codegen bridge-registry\n * generator (`src/cli/shared/bridge-registry-generator.ts`) scans these from\n * source and emits `bridge/generated/registry.ts`, validating each `event`\n * against the generated `eventRegistry` at `gen-all`. The distributed union\n * narrows `map`/`when` per `event`, so callbacks are typed against the event\n * payload (ADR-023, \"typed against PayloadOfType<T>\").\n *\n * Typed against events' generated types — the same `import type` coupling the\n * bridge already has (erased at runtime). `jobs` must NOT import `bridge`, so\n * the post-gen `BridgeTriggerEntry` is deliberately not referenced here;\n * `triggerId`/`jobType` are computed by the generator, not authored.\n */\nexport type JobTrigger<TInput> = {\n  [T in EventTypeName]: {\n    /** Event type that fires this trigger. Validated against `eventRegistry`. */\n    event: T;\n    /** Maps the event to the job input. Inlined verbatim into the registry. */\n    map: (event: EventOfType<T>) => TInput;\n    /** Optional guard; `false` → wrapper records `status='skipped'`. */\n    when?: (event: EventOfType<T>) => boolean;\n  };\n}[EventTypeName];\n\nexport interface JobHandlerMeta<TInput> {\n  pool?: string;\n  scope?: ScopeRef<TInput>;\n  retry?: RetryPolicy;\n  concurrency?: ConcurrencyPolicy<TInput>;\n  dedupe?: DedupePolicy<TInput>;\n  timeoutMs?: number;\n  replayFrom?: 'scratch' | 'last_step' | 'last_checkpoint';\n  /**\n   * Bridge triggers (ADR-023 Tier 3). Codegen scans these into `bridgeRegistry`;\n   * the framework `BridgeDeliveryHandler` starts this job per matched event.\n   * Absent for jobs started directly or via `IEventFlow.publishAndStart`.\n   */\n  triggers?: readonly JobTrigger<TInput>[];\n}\n\n// ─── Runtime option shapes ──────────────────────────────────────────────────\n\nexport interface StepOptions {\n  retry?: RetryPolicy;\n  timeoutMs?: number;\n}\n\nexport interface SpawnChildOptions {\n  closePolicy?: ParentClosePolicy;\n  runAt?: Date;\n  priority?: number;\n  tags?: Record<string, string>;\n}\n\n// ─── JobContext ─────────────────────────────────────────────────────────────\n\nexport interface JobContext<TInput> {\n  readonly input: TInput;\n  readonly run: JobRun;\n  step<TOutput>(\n    stepId: string,\n    fn: () => Promise<TOutput>,\n    opts?: StepOptions,\n  ): Promise<TOutput>;\n  spawnChild(type: string, input: unknown, opts?: SpawnChildOptions): Promise<JobRun>;\n  readonly logger: Logger;\n  // NOT in Phase 1 — deferred to ADR-025:\n  //   waitFor(kind, token, opts)\n  //   signal(token, payload)\n  //   sleep(ms)\n}\n\n// ─── JobHandlerBase ─────────────────────────────────────────────────────────\n\nexport abstract class JobHandlerBase<TInput, TOutput = unknown> {\n  abstract run(ctx: JobContext<TInput>): Promise<TOutput>;\n}\n\n// ─── Registry + decorator ───────────────────────────────────────────────────\n\n/**\n * Module-singleton map keyed by job type. Populated by the `@JobHandler`\n * decorator at class definition time; consumed by `JobWorkerModule` (JOB-5)\n * to upsert `job` rows and resolve handler classes during claim/execute.\n */\nexport const JOB_HANDLER_REGISTRY = new Map<\n  string,\n  {\n    type: string;\n    meta: JobHandlerMeta<unknown>;\n    handlerClass: new (...args: unknown[]) => JobHandlerBase<unknown>;\n  }\n>();\n\n// ADR-037: namespaced `Symbol.for(...)` (via `tokenKey()`) so the reflection-metadata\n// key matches by value across import boundaries (the @JobHandler decorator and the\n// reader may resolve different runtime copies). Distinct from the DI tokens but\n// subject to the same dual-package identity hazard.\nexport const JOB_HANDLER_METADATA_KEY = Symbol.for(tokenKey('jobs', 'handler-metadata'));\n\n/**\n * Class decorator that registers a handler with the job type, the full\n * metadata shape, and the target class constructor.\n *\n * Duplicate-type behaviour (OQ-3, resolved 2026-04-18):\n *   - `NODE_ENV === 'production'` → throw; silent overwrite in prod is a\n *     correctness bug.\n *   - `NODE_ENV === 'test'`       → silent overwrite (tests intentionally\n *     re-register handlers).\n *   - otherwise (dev)             → `console.warn` + overwrite. `console`\n *     is used intentionally instead of the Nest `Logger` — decorators run\n *     at module-load time before any Nest container exists.\n */\nexport function JobHandler<TInput>(\n  type: string,\n  meta: JobHandlerMeta<TInput>,\n): ClassDecorator {\n  return (target) => {\n    if (JOB_HANDLER_REGISTRY.has(type)) {\n      const env = process.env.NODE_ENV;\n      if (env === 'production') {\n        throw new Error(\n          `[JobHandler] Duplicate registration for job type '${type}'. ` +\n            `Each @JobHandler must declare a unique type.`,\n        );\n      }\n      if (env !== 'test') {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[JobHandler] Duplicate registration for job type '${type}'. ` +\n            `Overwriting previous handler — this is almost certainly a bug.`,\n        );\n      }\n    }\n\n    Reflect.defineMetadata(JOB_HANDLER_METADATA_KEY, { type, meta }, target);\n    JOB_HANDLER_REGISTRY.set(type, {\n      type,\n      meta: meta as JobHandlerMeta<unknown>,\n      handlerClass: target as unknown as new (\n        ...args: unknown[]\n      ) => JobHandlerBase<unknown>,\n    });\n  };\n}\n\n// ─── HandlerRegistry — read helpers consumed by JobWorkerModule (JOB-5) ─────\n\n/**\n * Single entry shape returned by `HandlerRegistry.getAll()` / `.get()` and\n * exposed to `JobWorkerModule.onModuleInit` for boot-time upserts.\n *\n * Structurally compatible with `IJobOrchestrator.upsertJobRows`'s\n * `JobUpsertEntry` so the worker module can pass entries through verbatim\n * without re-mapping.\n */\nexport interface HandlerRegistryEntry {\n  type: string;\n  meta: JobHandlerMeta<unknown>;\n  handlerClass: new (...args: unknown[]) => JobHandlerBase<unknown>;\n}\n\n/**\n * Read facade over `JOB_HANDLER_REGISTRY`. The decorator's write path is\n * unchanged; this namespace exists so consumers (the worker module, tests)\n * don't import the raw `Map` and accidentally mutate it.\n */\nexport namespace HandlerRegistry {\n  /** All registered entries in insertion order. */\n  export function getAll(): HandlerRegistryEntry[] {\n    return Array.from(JOB_HANDLER_REGISTRY.values());\n  }\n\n  /** Lookup by job type, or `undefined` if no `@JobHandler` is registered. */\n  export function get(type: string): HandlerRegistryEntry | undefined {\n    return JOB_HANDLER_REGISTRY.get(type);\n  }\n}\n\n// ─── Key resolution (JOB-FN-KEY, 0.16.2) ────────────────────────────────────\n\n/**\n * Sentinel persisted to `job.concurrency_key_template` / `dedupe_key_template`\n * when the authored `key` is a function rather than a `{{field}}` template.\n *\n * Why a sentinel (not `null`): the collision/dedupe paths in both backends gate\n * on `definition.concurrencyKeyTemplate != null`. A function key persisted as\n * `null` (the pre-0.16.2 bug) left those columns empty, so `collisionMode` /\n * the dedupe window never engaged — the job ran with NO key. A stable sentinel\n * keeps the column non-null (path engages) AND keeps the definition-hash gate\n * (`upsertJobRows`' `IS DISTINCT FROM` clause) stable across boots, since the\n * function identity itself can't be hashed. `start()` detects the sentinel and\n * re-resolves the live function from `JOB_HANDLER_REGISTRY`.\n *\n * Chosen as an angle-bracketed token so it can never collide with a real\n * `{{field}}` template (which never contains a literal `<`).\n */\nexport const FN_KEY_SENTINEL = '<fn>';\n\n/**\n * Registration-time projection: collapse an authored `JobKeySelector` to the\n * string stored in the `job` definition row. A string template is stored\n * verbatim; a function is stored as `FN_KEY_SENTINEL`; absence stays `null`.\n */\nexport function keySelectorToTemplate(\n  key: JobKeySelector<unknown> | undefined,\n): string | null {\n  if (typeof key === 'string') return key;\n  if (typeof key === 'function') return FN_KEY_SENTINEL;\n  return null;\n}\n\n/** Which meta policy a key belongs to — selects the live fn at `start()`. */\nexport type KeyKind = 'concurrency' | 'dedupe';\n\n/**\n * `start()`-time resolution shared by every backend. Turns the persisted\n * template column into the concrete per-run key for the given payload.\n *\n *   - `template == null` → `null` (no key; caller skips the collision/dedupe path).\n *   - `template === FN_KEY_SENTINEL` → look the live `@JobHandler` meta up in\n *     `JOB_HANDLER_REGISTRY`, pull `meta[kind].key`, and invoke it against the\n *     payload. The registry is the runtime source of truth (the worker already\n *     resolves handler classes the same way), so the function survives the DB\n *     round-trip even though it can't be persisted.\n *   - otherwise → a `{{field}}` template, evaluated via the injected\n *     `evaluateTemplate` (each backend passes its own copy to avoid a runtime\n *     import cycle).\n *\n * Throws `JobKeyFunctionUnavailableError` if the sentinel is present but no\n * live function can be found (e.g. the registry was reset, or a function key\n * was persisted by a newer build and read by an older one). Failing loud beats\n * silently degrading to no-key — the exact regression this fix exists to kill.\n */\nexport function resolveJobKey(\n  kind: KeyKind,\n  type: string,\n  template: string | null,\n  payload: Record<string, unknown>,\n  evaluateTemplate: (template: string, payload: Record<string, unknown>) => string,\n): string | null {\n  if (template == null) return null;\n  if (template !== FN_KEY_SENTINEL) return evaluateTemplate(template, payload);\n\n  const meta = JOB_HANDLER_REGISTRY.get(type)?.meta;\n  const key = (meta?.[kind] as { key?: unknown } | undefined)?.key;\n  if (typeof key !== 'function') {\n    throw new JobKeyFunctionUnavailableError(type, kind);\n  }\n  return (key as (input: unknown) => string)(payload);\n}\n\n/**\n * Raised when a `${FN_KEY_SENTINEL}` template is read but the live function\n * key is missing from `JOB_HANDLER_REGISTRY`. Kept here (not in `jobs-errors`)\n * so `job-handler.base` stays import-cycle-free.\n */\nexport class JobKeyFunctionUnavailableError extends Error {\n  constructor(\n    readonly jobType: string,\n    readonly kind: KeyKind,\n  ) {\n    super(\n      `[jobs] ${kind} key for job '${jobType}' was persisted as a function ` +\n        `sentinel ('${FN_KEY_SENTINEL}') but no live function is registered ` +\n        `for it. The @JobHandler must be imported before start() so its meta ` +\n        `is in JOB_HANDLER_REGISTRY.`,\n    );\n    this.name = 'JobKeyFunctionUnavailableError';\n  }\n}\n"],"mappings":";;;;;AA6BO,IAAK,oBAAL,kBAAKA,uBAAL;AACL,EAAAA,mBAAA,eAAY;AACZ,EAAAA,mBAAA,YAAS;AACT,EAAAA,mBAAA,aAAU;AAHA,SAAAA;AAAA,GAAA;AAsIL,IAAe,iBAAf,MAAyD;AAEhE;AASO,IAAM,uBAAuB,oBAAI,IAOtC;AAMK,IAAM,2BAA2B,OAAO,IAAI,SAAS,QAAQ,kBAAkB,CAAC;AAehF,SAAS,WACd,MACA,MACgB;AAChB,SAAO,CAAC,WAAW;AACjB,QAAI,qBAAqB,IAAI,IAAI,GAAG;AAClC,YAAM,MAAM,QAAQ,IAAI;AACxB,UAAI,QAAQ,cAAc;AACxB,cAAM,IAAI;AAAA,UACR,qDAAqD,IAAI;AAAA,QAE3D;AAAA,MACF;AACA,UAAI,QAAQ,QAAQ;AAElB,gBAAQ;AAAA,UACN,qDAAqD,IAAI;AAAA,QAE3D;AAAA,MACF;AAAA,IACF;AAEA,YAAQ,eAAe,0BAA0B,EAAE,MAAM,KAAK,GAAG,MAAM;AACvE,yBAAqB,IAAI,MAAM;AAAA,MAC7B;AAAA,MACA;AAAA,MACA,cAAc;AAAA,IAGhB,CAAC;AAAA,EACH;AACF;AAuBO,IAAU;AAAA,CAAV,CAAUC,qBAAV;AAEE,WAAS,SAAiC;AAC/C,WAAO,MAAM,KAAK,qBAAqB,OAAO,CAAC;AAAA,EACjD;AAFO,EAAAA,iBAAS;AAKT,WAAS,IAAI,MAAgD;AAClE,WAAO,qBAAqB,IAAI,IAAI;AAAA,EACtC;AAFO,EAAAA,iBAAS;AAAA,GAPD;AA8BV,IAAM,kBAAkB;AAOxB,SAAS,sBACd,KACe;AACf,MAAI,OAAO,QAAQ,SAAU,QAAO;AACpC,MAAI,OAAO,QAAQ,WAAY,QAAO;AACtC,SAAO;AACT;AAwBO,SAAS,cACd,MACA,MACA,UACA,SACA,kBACe;AACf,MAAI,YAAY,KAAM,QAAO;AAC7B,MAAI,aAAa,gBAAiB,QAAO,iBAAiB,UAAU,OAAO;AAE3E,QAAM,OAAO,qBAAqB,IAAI,IAAI,GAAG;AAC7C,QAAM,MAAO,OAAO,IAAI,GAAqC;AAC7D,MAAI,OAAO,QAAQ,YAAY;AAC7B,UAAM,IAAI,+BAA+B,MAAM,IAAI;AAAA,EACrD;AACA,SAAQ,IAAmC,OAAO;AACpD;AAOO,IAAM,iCAAN,cAA6C,MAAM;AAAA,EACxD,YACW,SACA,MACT;AACA;AAAA,MACE,UAAU,IAAI,iBAAiB,OAAO,4CACtB,eAAe;AAAA,IAGjC;AARS;AACA;AAQT,SAAK,OAAO;AAAA,EACd;AAAA,EAVW;AAAA,EACA;AAUb;","names":["ParentClosePolicy","HandlerRegistry"]}

package/dist/{chunk-P3AYBRP6.js → chunk-ATVGYF3D.js}

@@ -1,18 +1,18 @@
 import {
   DrizzleIntegrationRunRecorder
-} from "./chunk-SR7F3TJY.js";
+} from "./chunk-YK5JEVLX.js";
 import {
   MemoryRunRecorder
 } from "./chunk-EO2QPOKH.js";
 import {
   PostgresCursorStore
-} from "./chunk-DCCZB4UC.js";
+} from "./chunk-XWBK3XJK.js";
 import {
   MemoryCursorStore
 } from "./chunk-AHV4GDYM.js";
 import {
   DeepEqualDiffer
-} from "./chunk-36U5UGIO.js";
+} from "./chunk-JEINYUJH.js";
 import {
   INTEGRATION_CURSOR_STORE,
   INTEGRATION_FIELD_DIFFER,
@@ -34,7 +34,13 @@ var IntegrationModule = class {
       { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
       // Default differ — consumers can override by binding a different
       // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.
-      { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
+      // DIFFER-UNIGNORE: `options.differ` (ignore/unignore) is threaded here so
+      // a consumer can declare a default-ignored column (e.g. `deletedAt`) as
+      // domain data for their entities without binding a bespoke differ.
+      {
+        provide: INTEGRATION_FIELD_DIFFER,
+        useValue: new DeepEqualDiffer(options.differ ?? {})
+      }
     ];
     const backendProviders = options.backend === "memory" ? [
       // Wired as singletons via `useValue` so tests can pull
@@ -78,4 +84,4 @@ IntegrationModule = __decorateClass([
 export {
   IntegrationModule
 };
-//# sourceMappingURL=chunk-P3AYBRP6.js.map
+//# sourceMappingURL=chunk-ATVGYF3D.js.map

package/dist/chunk-ATVGYF3D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/integration.module.ts"],"sourcesContent":["/**\n * IntegrationModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory\n * wiring the integration subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).\n *\n * ## What this module provides\n *\n *   - `INTEGRATION_CURSOR_STORE`    — Drizzle or Memory cursor store\n *   - `INTEGRATION_RUN_RECORDER`    — Drizzle or Memory run recorder\n *   - `INTEGRATION_FIELD_DIFFER`    — default `DeepEqualDiffer`\n *   - `INTEGRATION_MULTI_TENANT`    — resolved boolean flag (defaults to false)\n *   - `INTEGRATION_MODULE_OPTIONS`  — the options object itself, for backends\n *     that need to inspect config at construction time\n *\n * ## What this module does NOT provide\n *\n *   - `INTEGRATION_CHANGE_SOURCE` — per-provider per-entity; consumer binds in\n *     their feature module (e.g. `OpportunityIntegrationModule` provides a\n *     `SalesforceOpportunityChangeSource`). Loopback suppression — when\n *     needed — is composed into the primitive's middleware chain via\n *     `createLoopbackMiddleware(store)` (#226-5 / ADR-033); the\n *     orchestrator no longer accepts a fingerprint store directly.\n *   - `INTEGRATION_SINK` — per canonical entity; consumer binds in their feature\n *     module.\n *   - `ExecuteIntegrationUseCase` — registered by the feature module alongside\n *     its source + sink bindings. Providing the orchestrator here would\n *     force Nest to resolve INTEGRATION_CHANGE_SOURCE + INTEGRATION_SINK at module\n *     compile time, which fails when the feature module hasn't been\n *     imported yet. Consumers register `ExecuteIntegrationUseCase` in the same\n *     `providers` array as their source + sink so resolution is local\n *     to where all three are bound.\n *\n * Same shape as `EventsModule.forRoot` — the module wires the bus; you\n * bring your own handlers. Here: the module wires the substrate; you\n * bring your own source + sink.\n *\n * ## Usage\n *\n * ```ts\n * // AppModule — single source of truth for backend + multi-tenancy.\n * @Module({\n *   imports: [IntegrationModule.forRoot({ backend: 'drizzle' })],\n * })\n * export class AppModule {}\n *\n * // Per-entity feature module — binds source + sink, gets the\n * // orchestrator for free.\n * @Module({\n *   providers: [\n *     { provide: INTEGRATION_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },\n *     { provide: INTEGRATION_SINK,          useClass: OpportunityIntegrationSink },\n *     ExecuteIntegrationUseCase,\n *   ],\n * })\n * export class OpportunityIntegrationModule {\n *   constructor(\n *     private readonly execute: ExecuteIntegrationUseCase<CanonicalOpportunity>,\n *   ) {}\n * }\n * ```\n *\n * `global: true` means feature modules do not need to re-import\n * `IntegrationModule` — the substrate tokens are available project-wide.\n */\nimport { Module, type DynamicModule, type Provider } from '@nestjs/common';\nimport {\n  INTEGRATION_CURSOR_STORE,\n  INTEGRATION_FIELD_DIFFER,\n  INTEGRATION_MODULE_OPTIONS,\n  INTEGRATION_MULTI_TENANT,\n  INTEGRATION_RUN_RECORDER,\n} from './integration.tokens';\nimport { MemoryCursorStore } from './integration-cursor-store.memory-backend';\nimport { MemoryRunRecorder } from './integration-run-recorder.memory-backend';\nimport { PostgresCursorStore } from './integration-cursor-store.drizzle-backend';\nimport { DrizzleIntegrationRunRecorder } from './integration-run-recorder.drizzle-backend';\nimport { DeepEqualDiffer, type DeepEqualDifferOptions } from './deep-equal.differ';\n\nexport interface IntegrationModuleOptions {\n  /**\n   * Backend selection. `drizzle` wires the Postgres cursor store +\n   * run-log recorder; `memory` wires in-memory doubles suitable for\n   * tests + local dev.\n   */\n  backend: 'drizzle' | 'memory';\n\n  /**\n   * Multi-tenancy opt-in (SYNC-6).\n   *\n   * When `true`, every call to the orchestrator + both Drizzle backends\n   * must supply a non-null `tenantId`; missing values throw\n   * `MissingTenantIdError`. Defense-in-depth: the orchestrator rejects\n   * at entry (no dangling `status=running` rows) AND the Drizzle\n   * backends reject at their write boundary (belt-and-braces for any\n   * path that bypasses the orchestrator). Both sites use the shared\n   * `assertTenantId` helper so error messages match.\n   *\n   * Memory backends accept `tenantId` unconditionally — their state is\n   * process-local; cross-tenant isolation there is not meaningful.\n   *\n   * Defaults to `false`.\n   */\n  multiTenant?: boolean;\n\n  /**\n   * Default-differ configuration (DIFFER-UNIGNORE, 0.17.1). Threaded into the\n   * `DeepEqualDiffer` bound to `INTEGRATION_FIELD_DIFFER`. Omit for the\n   * historical behaviour (the default ignore list, unchanged).\n   *\n   * Mirrors `DeepEqualDifferOptions`:\n   *   - `ignore`   — extra field names to ignore (merged with the defaults).\n   *   - `unignore` — default-ignored field names to RE-include as domain data\n   *     (e.g. `['deletedAt']` for an entity whose `deletedAt` is a\n   *     vendor-observed retraction tombstone, not row metadata — swe-brain\n   *     ADR-0008 §1). Subtracted after the merge, so it wins.\n   *\n   * A feature module that binds its own `IFieldDiffer<T>` to\n   * `INTEGRATION_FIELD_DIFFER` overrides this entirely (per-entity escape hatch\n   * unchanged).\n   */\n  differ?: DeepEqualDifferOptions;\n}\n\n@Module({})\nexport class IntegrationModule {\n  static forRoot(options: IntegrationModuleOptions): DynamicModule {\n    const multiTenant = options.multiTenant ?? false;\n\n    const sharedProviders: Provider[] = [\n      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },\n      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },\n      // Default differ — consumers can override by binding a different\n      // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.\n      // DIFFER-UNIGNORE: `options.differ` (ignore/unignore) is threaded here so\n      // a consumer can declare a default-ignored column (e.g. `deletedAt`) as\n      // domain data for their entities without binding a bespoke differ.\n      {\n        provide: INTEGRATION_FIELD_DIFFER,\n        useValue: new DeepEqualDiffer(options.differ ?? {}),\n      },\n    ];\n\n    const backendProviders: Provider[] =\n      options.backend === 'memory'\n        ? [\n            // Wired as singletons via `useValue` so tests can pull\n            // them out via `moduleRef.get(MemoryCursorStore)` for\n            // direct assertions. Matches JOB-4 / MemoryJobStore shape.\n            { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },\n            {\n              provide: INTEGRATION_CURSOR_STORE,\n              useExisting: MemoryCursorStore,\n            },\n            { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },\n            {\n              provide: INTEGRATION_RUN_RECORDER,\n              useExisting: MemoryRunRecorder,\n            },\n          ]\n        : [\n            // Drizzle backends — injected with DRIZZLE (provided by the\n            // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag\n            // we bound above.\n            { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },\n            { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder },\n          ];\n\n    return {\n      module: IntegrationModule,\n      global: true,\n      providers: [...sharedProviders, ...backendProviders],\n      exports: [\n        INTEGRATION_MODULE_OPTIONS,\n        INTEGRATION_MULTI_TENANT,\n        INTEGRATION_FIELD_DIFFER,\n        INTEGRATION_CURSOR_STORE,\n        INTEGRATION_RUN_RECORDER,\n      ],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAS,cAAiD;AA4DnD,IAAM,oBAAN,MAAwB;AAAA,EAC7B,OAAO,QAAQ,SAAkD;AAC/D,UAAM,cAAc,QAAQ,eAAe;AAE3C,UAAM,kBAA8B;AAAA,MAClC,EAAE,SAAS,4BAA4B,UAAU,QAAQ;AAAA,MACzD,EAAE,SAAS,0BAA0B,UAAU,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAM3D;AAAA,QACE,SAAS;AAAA,QACT,UAAU,IAAI,gBAAgB,QAAQ,UAAU,CAAC,CAAC;AAAA,MACpD;AAAA,IACF;AAEA,UAAM,mBACJ,QAAQ,YAAY,WAChB;AAAA;AAAA;AAAA;AAAA,MAIE,EAAE,SAAS,mBAAmB,UAAU,IAAI,kBAAkB,EAAE;AAAA,MAChE;AAAA,QACE,SAAS;AAAA,QACT,aAAa;AAAA,MACf;AAAA,MACA,EAAE,SAAS,mBAAmB,UAAU,IAAI,kBAAkB,EAAE;AAAA,MAChE;AAAA,QACE,SAAS;AAAA,QACT,aAAa;AAAA,MACf;AAAA,IACF,IACA;AAAA;AAAA;AAAA;AAAA,MAIE,EAAE,SAAS,0BAA0B,UAAU,oBAAoB;AAAA,MACnE,EAAE,SAAS,0BAA0B,UAAU,8BAA8B;AAAA,IAC/E;AAEN,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,WAAW,CAAC,GAAG,iBAAiB,GAAG,gBAAgB;AAAA,MACnD,SAAS;AAAA,QACP;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAxDa,oBAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,GACG;","names":[]}

package/dist/{chunk-3MAZ4TQH.js → chunk-AZLUWG5S.js}

@@ -1,15 +1,18 @@
-import {
-  MemoryJobOrchestrator
-} from "./chunk-BULPAAD3.js";
 import {
   DrizzleJobRunService
-} from "./chunk-3VEVGL74.js";
+} from "./chunk-VNBC3VXM.js";
 import {
   MemoryJobRunService
-} from "./chunk-CDLWYZVQ.js";
+} from "./chunk-BHZP6LOV.js";
 import {
   DrizzleJobStepService
 } from "./chunk-DV4RV2DC.js";
+import {
+  DrizzleJobOrchestrator
+} from "./chunk-E6PLM6QG.js";
+import {
+  MemoryJobOrchestrator
+} from "./chunk-VQOAATIG.js";
 import {
   MemoryJobStepService
 } from "./chunk-PNZSGAB2.js";
@@ -21,9 +24,6 @@ import {
   BULLMQ_RESOLVED_CONFIG,
   resolveBullMqConfig
 } from "./chunk-I6MVCB5A.js";
-import {
-  DrizzleJobOrchestrator
-} from "./chunk-OTR44OH6.js";
 import {
   JOBS_LISTEN_NOTIFY,
   JOBS_MULTI_TENANT,
@@ -114,4 +114,4 @@ JobsDomainModule = __decorateClass([
 export {
   JobsDomainModule
 };
-//# sourceMappingURL=chunk-3MAZ4TQH.js.map
+//# sourceMappingURL=chunk-AZLUWG5S.js.map

package/dist/{chunk-UTNWFHJF.js → chunk-B34G6PHD.js}

@@ -1,22 +1,22 @@
+import {
+  clampEventLimit,
+  decodeEventCursor,
+  encodeEventCursor
+} from "./chunk-UQ5EHOH2.js";
 import {
   EVENTS_WAKE_CHANNEL,
   PgNotifyListener,
   pgNotify
-} from "./chunk-MYQIQ27N.js";
+} from "./chunk-Q6LRJ4VI.js";
+import {
+  EVENTS_MODULE_OPTIONS
+} from "./chunk-H5NH7KPE.js";
 import {
   BRIDGE_OUTBOX_DRAIN_HOOK
 } from "./chunk-4LH67P4U.js";
 import {
   domainEvents
 } from "./chunk-OFRRBC7M.js";
-import {
-  clampEventLimit,
-  decodeEventCursor,
-  encodeEventCursor
-} from "./chunk-UQ5EHOH2.js";
-import {
-  EVENTS_MODULE_OPTIONS
-} from "./chunk-H5NH7KPE.js";
 import {
   DRIZZLE
 } from "./chunk-U64T4YZE.js";
@@ -393,4 +393,4 @@ DrizzleEventBus = __decorateClass([
 export {
   DrizzleEventBus
 };
-//# sourceMappingURL=chunk-UTNWFHJF.js.map
+//# sourceMappingURL=chunk-B34G6PHD.js.map

package/dist/{chunk-CDLWYZVQ.js → chunk-BHZP6LOV.js}

@@ -1,15 +1,15 @@
-import {
-  clampLimit,
-  decodeKeysetCursor,
-  encodeKeysetCursor,
-  toJobRunSummary
-} from "./chunk-L3LZWWSX.js";
 import {
   MemoryJobStore
 } from "./chunk-SNQ3TOWP.js";
 import {
   MissingTenantIdError
 } from "./chunk-T4BIIU5E.js";
+import {
+  clampLimit,
+  decodeKeysetCursor,
+  encodeKeysetCursor,
+  toJobRunSummary
+} from "./chunk-L3LZWWSX.js";
 import {
   JOBS_MULTI_TENANT,
   JOB_ORCHESTRATOR
@@ -209,4 +209,4 @@ function compareBy(a, b, order) {
 export {
   MemoryJobRunService
 };
-//# sourceMappingURL=chunk-CDLWYZVQ.js.map
+//# sourceMappingURL=chunk-BHZP6LOV.js.map

package/dist/{chunk-W2UIDI3R.js → chunk-CLWBNXKF.js}

@@ -1,12 +1,12 @@
 import {
   JOB_RUN_SERVICE
 } from "./chunk-ZPL74UQN.js";
-import {
-  BRIDGE_DELIVERY_REPO
-} from "./chunk-4LH67P4U.js";
 import {
   EVENT_READ_PORT
 } from "./chunk-H5NH7KPE.js";
+import {
+  BRIDGE_DELIVERY_REPO
+} from "./chunk-4LH67P4U.js";
 import {
   INTEGRATION_CURSOR_STORE,
   INTEGRATION_RUN_RECORDER
@@ -181,4 +181,4 @@ ObservabilityService = __decorateClass([
 export {
   ObservabilityService
 };
-//# sourceMappingURL=chunk-W2UIDI3R.js.map
+//# sourceMappingURL=chunk-CLWBNXKF.js.map

package/dist/{chunk-OTR44OH6.js → chunk-E6PLM6QG.js}

@@ -5,6 +5,14 @@ import {
   JobTypeNotFoundError,
   MissingTenantIdError
 } from "./chunk-T4BIIU5E.js";
+import {
+  JOBS_WAKE_CHANNEL,
+  pgNotify
+} from "./chunk-Q6LRJ4VI.js";
+import {
+  keySelectorToTemplate,
+  resolveJobKey
+} from "./chunk-7P5ODGLA.js";
 import {
   JOBS_LISTEN_NOTIFY,
   JOBS_MULTI_TENANT
@@ -14,10 +22,6 @@ import {
   jobSteps,
   jobs
 } from "./chunk-OKXZ63IA.js";
-import {
-  JOBS_WAKE_CHANNEL,
-  pgNotify
-} from "./chunk-MYQIQ27N.js";
 import {
   DRIZZLE
 } from "./chunk-U64T4YZE.js";
@@ -81,7 +85,13 @@ var DrizzleJobOrchestrator = class {
     if (!def) throw new JobTypeNotFoundError(type);
     const definition = def;
     if (definition.dedupeKeyTemplate && definition.dedupeWindowMs) {
-      const dedupeKey2 = evaluateKeyTemplate(definition.dedupeKeyTemplate, payload);
+      const dedupeKey2 = resolveJobKey(
+        "dedupe",
+        type,
+        definition.dedupeKeyTemplate,
+        payload,
+        evaluateKeyTemplate
+      );
       const windowStart = new Date(Date.now() - definition.dedupeWindowMs);
       const existing = await client.select().from(jobRuns).where(
         and(
@@ -98,9 +108,12 @@ var DrizzleJobOrchestrator = class {
     }
     let concurrencyKey = null;
     if (definition.concurrencyKeyTemplate) {
-      concurrencyKey = evaluateKeyTemplate(
+      concurrencyKey = resolveJobKey(
+        "concurrency",
+        type,
         definition.concurrencyKeyTemplate,
-        payload
+        payload,
+        evaluateKeyTemplate
       );
       const inFlight = await client.select().from(jobRuns).where(
         and(
@@ -136,7 +149,13 @@ var DrizzleJobOrchestrator = class {
       }
       rootRunId = parent.rootRunId;
     }
-    const dedupeKey = definition.dedupeKeyTemplate ? evaluateKeyTemplate(definition.dedupeKeyTemplate, payload) : null;
+    const dedupeKey = resolveJobKey(
+      "dedupe",
+      type,
+      definition.dedupeKeyTemplate,
+      payload,
+      evaluateKeyTemplate
+    );
     const [inserted] = await client.insert(jobRuns).values({
       id: newId,
       jobType: type,
@@ -293,11 +312,13 @@ var DrizzleJobOrchestrator = class {
         backoff: "fixed",
         baseMs: 0
       };
-      const concurrencyKeyTemplate = meta.concurrency?.key;
-      const concurrencyKeyTemplateStr = typeof concurrencyKeyTemplate === "string" ? concurrencyKeyTemplate : null;
+      const concurrencyKeyTemplateStr = keySelectorToTemplate(
+        meta.concurrency?.key
+      );
       const collisionMode = meta.concurrency?.collisionMode ?? "queue";
-      const dedupeKeyTemplate = meta.dedupe?.key;
-      const dedupeKeyTemplateStr = typeof dedupeKeyTemplate === "string" ? dedupeKeyTemplate : null;
+      const dedupeKeyTemplateStr = keySelectorToTemplate(
+        meta.dedupe?.key
+      );
       const dedupeWindowMs = meta.dedupe?.windowMs ?? null;
       const timeoutMs = meta.timeoutMs ?? null;
       const replayFrom = meta.replayFrom ?? "last_checkpoint";
@@ -372,4 +393,4 @@ export {
   evaluateKeyTemplate,
   DrizzleJobOrchestrator
 };
-//# sourceMappingURL=chunk-OTR44OH6.js.map
+//# sourceMappingURL=chunk-E6PLM6QG.js.map