@dudousxd/nestjs-durable 0.15.0 → 0.16.0

package/dist/index.js

@@ -1,24 +1,747 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/decorators.ts
+import { WORKFLOW_NAME_KEY } from "@dudousxd/nestjs-durable-core";
+import "reflect-metadata";
+var WORKFLOW_METADATA = Symbol("nestjs-durable:workflow");
+function Workflow(options) {
+  return (target) => {
+    const meta = {
+      name: options.name,
+      version: options.version ?? "1",
+      deadLetterWorkflow: options.deadLetterWorkflow,
+      tags: options.tags,
+      singleton: options.singleton,
+      executionTimeout: options.executionTimeout,
+      inputSchema: options.inputSchema,
+      validateInput: options.validateInput,
+      onEvent: options.onEvent,
+      debounce: options.debounce,
+      batch: options.batch
+    };
+    Reflect.defineMetadata(WORKFLOW_METADATA, meta, target);
+    Object.defineProperty(target, WORKFLOW_NAME_KEY, {
+      value: options.name,
+      configurable: true
+    });
+  };
+}
+__name(Workflow, "Workflow");
+function getWorkflowMeta(target) {
+  return Reflect.getMetadata(WORKFLOW_METADATA, target);
+}
+__name(getWorkflowMeta, "getWorkflowMeta");
+var DURABLE_STEP_METADATA = Symbol("nestjs-durable:step-handler");
+function DurableStep(name) {
+  return (_target, _propertyKey, descriptor) => {
+    const meta = {
+      name
+    };
+    Reflect.defineMetadata(DURABLE_STEP_METADATA, meta, descriptor.value);
+    return descriptor;
+  };
+}
+__name(DurableStep, "DurableStep");
+function getDurableStepMeta(method) {
+  return Reflect.getMetadata(DURABLE_STEP_METADATA, method);
+}
+__name(getDurableStepMeta, "getDurableStepMeta");
+var DEAD_LETTER_METADATA = Symbol("nestjs-durable:dead-letter");
+function DeadLetter() {
+  return (_target, _propertyKey, descriptor) => {
+    Reflect.defineMetadata(DEAD_LETTER_METADATA, true, descriptor.value);
+    return descriptor;
+  };
+}
+__name(DeadLetter, "DeadLetter");
+function isDeadLetterHandler(method) {
+  return Reflect.getMetadata(DEAD_LETTER_METADATA, method) === true;
+}
+__name(isDeadLetterHandler, "isDeadLetterHandler");
+var ON_EVENT_METADATA = Symbol("nestjs-durable:on-event");
+function OnEvent(...events) {
+  return (target) => {
+    const existing = Reflect.getMetadata(ON_EVENT_METADATA, target) ?? [];
+    Reflect.defineMetadata(ON_EVENT_METADATA, [
+      ...existing,
+      ...events
+    ], target);
+  };
+}
+__name(OnEvent, "OnEvent");
+function getOnEvents(meta, target) {
+  const fromDecorator = Reflect.getMetadata(ON_EVENT_METADATA, target) ?? [];
+  return [
+    .../* @__PURE__ */ new Set([
+      ...meta.onEvent ?? [],
+      ...fromDecorator
+    ])
+  ];
+}
+__name(getOnEvents, "getOnEvents");
+
+// src/durable.module.ts
+import { DURABLE_OPTIONS as DURABLE_OPTIONS4, STATE_STORE as STATE_STORE2, TRANSPORT as TRANSPORT2, WorkflowEngine as WorkflowEngine5 } from "@dudousxd/nestjs-durable-core";
+import { Module } from "@nestjs/common";
+import { DiscoveryModule, ModuleRef } from "@nestjs/core";
+
+// src/durable-step.registrar.ts
+import { DURABLE_OPTIONS, TRANSPORT } from "@dudousxd/nestjs-durable-core";
+import { Inject, Injectable } from "@nestjs/common";
+import { DiscoveryService, MetadataScanner } from "@nestjs/core";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+function supportsHandle(transport) {
+  return typeof transport?.handle === "function";
+}
+__name(supportsHandle, "supportsHandle");
+var DurableStepRegistrar = class {
+  static {
+    __name(this, "DurableStepRegistrar");
+  }
+  discovery;
+  metadataScanner;
+  transport;
+  options;
+  constructor(discovery, metadataScanner, transport, options) {
+    this.discovery = discovery;
+    this.metadataScanner = metadataScanner;
+    this.transport = transport;
+    this.options = options;
+  }
+  onModuleInit() {
+    if (this.options.worker === false) return;
+    if (!supportsHandle(this.transport)) return;
+    const transport = this.transport;
+    for (const wrapper of this.discovery.getProviders()) {
+      const { instance } = wrapper;
+      if (!instance || typeof instance !== "object") continue;
+      const prototype = Object.getPrototypeOf(instance);
+      for (const methodName of this.metadataScanner.getAllMethodNames(prototype)) {
+        const method = instance[methodName];
+        if (typeof method !== "function") continue;
+        const meta = getDurableStepMeta(method);
+        if (!meta) continue;
+        transport.handle(meta.name, (input, log) => instance[methodName](input, log));
+      }
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  }
+};
+DurableStepRegistrar = _ts_decorate([
+  Injectable(),
+  _ts_param(2, Inject(TRANSPORT)),
+  _ts_param(3, Inject(DURABLE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+    typeof MetadataScanner === "undefined" ? Object : MetadataScanner,
+    Object,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
+  ])
+], DurableStepRegistrar);
+
+// src/entity.ts
+import { WorkflowEngine } from "@dudousxd/nestjs-durable-core";
+import { Injectable as Injectable2 } from "@nestjs/common";
+import "reflect-metadata";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var ENTITY_METADATA = Symbol("nestjs-durable:entity");
+var ENTITY_ON_METADATA = Symbol("nestjs-durable:entity-on");
+function Entity(options) {
+  return (target) => {
+    Reflect.defineMetadata(ENTITY_METADATA, options, target);
+  };
+}
+__name(Entity, "Entity");
+function On(op) {
+  return (target, propertyKey) => {
+    const ctor = target.constructor;
+    const ops = Reflect.getMetadata(ENTITY_ON_METADATA, ctor) ?? /* @__PURE__ */ new Map();
+    ops.set(op, propertyKey);
+    Reflect.defineMetadata(ENTITY_ON_METADATA, ops, ctor);
+  };
+}
+__name(On, "On");
+function getEntityMeta(target) {
+  return Reflect.getMetadata(ENTITY_METADATA, target);
+}
+__name(getEntityMeta, "getEntityMeta");
+function entityConfigFor(ctor) {
+  const ops = Reflect.getMetadata(ENTITY_ON_METADATA, ctor) ?? /* @__PURE__ */ new Map();
+  const Cls = ctor;
+  const handlers = {};
+  for (const [op, method] of ops) {
+    handlers[op] = (state, arg) => {
+      Object.setPrototypeOf(state, Cls.prototype);
+      const fn = state[method];
+      if (typeof fn !== "function") throw new Error(`entity handler "${method}" is not a method`);
+      return fn.call(state, arg);
+    };
+  }
+  return {
+    initialState: /* @__PURE__ */ __name(() => new Cls(), "initialState"),
+    handlers
+  };
+}
+__name(entityConfigFor, "entityConfigFor");
+var EntityService = class {
+  static {
+    __name(this, "EntityService");
+  }
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  /** Send an operation to an entity (fire-and-forget; ordered + exactly-once per key). */
+  signal(name, key, op, arg) {
+    return this.engine.signalEntity(name, key, op, arg);
+  }
+  /** Read an entity's current durable state (or undefined if it has none yet). */
+  getState(name, key) {
+    return this.engine.getEntityState(name, key);
+  }
+};
+EntityService = _ts_decorate2([
+  Injectable2(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof WorkflowEngine === "undefined" ? Object : WorkflowEngine
+  ])
+], EntityService);
+
+// src/timer-poller.ts
+import { DURABLE_OPTIONS as DURABLE_OPTIONS2, WorkflowEngine as WorkflowEngine2, runSchedules } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject2, Injectable as Injectable3 } from "@nestjs/common";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var TimerPoller = class {
+  static {
+    __name(this, "TimerPoller");
+  }
+  engine;
+  options;
+  timer;
+  polling = false;
+  unsubscribeEnqueued;
+  constructor(engine, options) {
+    this.engine = engine;
+    this.options = options;
+  }
+  async onApplicationBootstrap() {
+    if (this.options.worker === false) return;
+    this.unsubscribeEnqueued = this.engine.onEnqueued((runId) => void this.engine.runOne(runId));
+    await this.poll();
+    const intervalMs = this.options.timerPollMs ?? 1e3;
+    if (intervalMs > 0) {
+      this.timer = setInterval(() => void this.poll(), intervalMs);
+      this.timer.unref?.();
+    }
+  }
+  onModuleDestroy() {
+    if (this.timer) clearInterval(this.timer);
+    this.unsubscribeEnqueued?.();
+  }
+  async poll() {
+    if (this.polling) return;
+    this.polling = true;
+    try {
+      await this.engine.runPending();
+      await this.engine.recoverIncomplete();
+      await this.engine.resumeDueTimers();
+      await this.engine.sweepTimeouts();
+      const schedules = this.options.schedules;
+      if (schedules && schedules.length > 0) {
+        await runSchedules(this.engine, schedules, Date.now());
+      }
+    } finally {
+      this.polling = false;
+    }
+  }
+};
+TimerPoller = _ts_decorate3([
+  Injectable3(),
+  _ts_param2(1, Inject2(DURABLE_OPTIONS2)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof WorkflowEngine2 === "undefined" ? Object : WorkflowEngine2,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
+  ])
+], TimerPoller);
+
+// src/tokens.ts
+var CONTEXT_ACCESSOR = Symbol.for("@dudousxd/nestjs-context:accessor");
+
+// src/workflow.registrar.ts
+import { DURABLE_OPTIONS as DURABLE_OPTIONS3, STATE_STORE, WorkflowEngine as WorkflowEngine3, parseDuration, workflowName } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject3, Injectable as Injectable4 } from "@nestjs/common";
+import { DiscoveryService as DiscoveryService2, MetadataScanner as MetadataScanner2 } from "@nestjs/core";
+
+// src/input-validation.ts
+function classValidatorInput(cls) {
+  let cv;
+  let ct;
+  try {
+    cv = __require("class-validator");
+    ct = __require("class-transformer");
+  } catch {
+    throw new Error('@Workflow({ inputSchema }) needs the optional peers "class-validator" and "class-transformer" \u2014 install them, or pass a `validateInput` function instead.');
+  }
+  return async (input) => {
+    const instance = ct.plainToInstance(cls, input);
+    const errors = await cv.validate(instance, {
+      whitelist: true
+    });
+    if (errors.length > 0) {
+      const message = errors.map((e) => Object.values(e.constraints ?? {
+        _: e.property
+      }).join(", ")).join("; ");
+      throw new Error(`invalid input for workflow: ${message}`);
+    }
+  };
+}
+__name(classValidatorInput, "classValidatorInput");
+
+// src/step-interceptor.ts
+import "reflect-metadata";
+var STEP_INTERCEPTOR_METADATA = Symbol("nestjs-durable:step-interceptor");
+function StepInterceptor() {
+  return (target) => {
+    Reflect.defineMetadata(STEP_INTERCEPTOR_METADATA, true, target);
+  };
+}
+__name(StepInterceptor, "StepInterceptor");
+function isStepInterceptor(target) {
+  return Reflect.getMetadata(STEP_INTERCEPTOR_METADATA, target) === true;
+}
+__name(isStepInterceptor, "isStepInterceptor");
+
+// src/workflow.registrar.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var WorkflowRegistrar = class {
+  static {
+    __name(this, "WorkflowRegistrar");
+  }
+  discovery;
+  metadataScanner;
+  engine;
+  store;
+  options;
+  constructor(discovery, metadataScanner, engine, store, options) {
+    this.discovery = discovery;
+    this.metadataScanner = metadataScanner;
+    this.engine = engine;
+    this.store = store;
+    this.options = options;
+  }
+  async onApplicationBootstrap() {
+    if (this.options.worker === false) return;
+    await this.engine.recoverIncomplete();
+  }
+  /** On deploy/shutdown: stop picking up new runs and wait for in-flight ones to settle, then close
+  *  the transport(s) so the broker workers stop consuming and connections are released. Closing
+  *  AFTER the drain keeps the transport alive while in-flight runs dispatch/await their remote steps. */
+  async onApplicationShutdown() {
+    await this.engine.drain(this.options.shutdownTimeoutMs);
+    const transports = [
+      this.options.transport,
+      ...(this.options.transports ?? []).map((t) => t.transport)
+    ];
+    await Promise.allSettled(transports.map((t) => t?.close?.()));
+  }
+  async onModuleInit() {
+    if (this.options.autoSchema !== false) {
+      await this.store.ensureSchema?.();
+    }
+    const deadLetterByWorkflow = /* @__PURE__ */ new Map();
+    for (const wrapper of this.discovery.getProviders()) {
+      const { instance } = wrapper;
+      if (!instance || typeof instance !== "object") continue;
+      if (isStepInterceptor(instance.constructor)) {
+        const interceptor = instance;
+        this.engine.use((invocation, next) => interceptor.intercept(invocation, next));
+      }
+      const entityMeta = getEntityMeta(instance.constructor);
+      if (entityMeta) {
+        this.engine.registerEntity(entityMeta.name, entityConfigFor(instance.constructor));
+        continue;
+      }
+      const meta = getWorkflowMeta(instance.constructor);
+      if (!meta) continue;
+      const workflow = instance;
+      if (typeof workflow.run !== "function") {
+        throw new Error(`@Workflow ${meta.name} must define a run(ctx, input) method`);
+      }
+      const validateInput = meta.validateInput ?? (meta.inputSchema ? classValidatorInput(meta.inputSchema) : void 0);
+      const eventBatch = meta.debounce ? {
+        mode: "debounce",
+        windowMs: parseDuration(meta.debounce)
+      } : meta.batch ? {
+        mode: "batch",
+        maxSize: meta.batch.maxSize,
+        windowMs: parseDuration(meta.batch.within)
+      } : void 0;
+      this.engine.register(meta.name, meta.version, (ctx, input) => workflow.run(ctx, input), {
+        tags: meta.tags,
+        singleton: meta.singleton,
+        executionTimeout: meta.executionTimeout,
+        validateInput,
+        onEvent: getOnEvents(meta, instance.constructor),
+        eventBatch
+      });
+      const inline = this.findDeadLetterHandler(instance);
+      if (inline && meta.deadLetterWorkflow) {
+        throw new Error(`@Workflow ${meta.name} declares both an inline @DeadLetter() method and a deadLetterWorkflow option. Use one: the inline handler, or the reference.`);
+      }
+      if (inline) {
+        const dlqName = `${meta.name}.dlq`;
+        this.engine.register(dlqName, meta.version, inline);
+        deadLetterByWorkflow.set(meta.name, dlqName);
+      } else if (meta.deadLetterWorkflow) {
+        deadLetterByWorkflow.set(meta.name, workflowName(meta.deadLetterWorkflow));
+      }
+    }
+    this.installDeadLetterRouting(deadLetterByWorkflow);
+  }
+  /** Returns the instance's `@DeadLetter()` method bound to the instance, or undefined if none. */
+  findDeadLetterHandler(instance) {
+    const prototype = Object.getPrototypeOf(instance);
+    for (const methodName of this.metadataScanner.getAllMethodNames(prototype)) {
+      const method = instance[methodName];
+      if (typeof method === "function" && isDeadLetterHandler(method)) {
+        return (ctx, input) => method.call(instance, ctx, input);
+      }
+    }
+    return void 0;
+  }
+  /**
+  * Installs a single onDead listener that routes a dead run to its workflow's handler (from the
+  * map) or the module-level `deadLetterWorkflow` default. The handler is started idempotently with
+  * a `dlq:<runId>` id, so re-recovery never double-dispatches.
+  */
+  installDeadLetterRouting(byWorkflow) {
+    const fallback = this.options.deadLetterWorkflow ? workflowName(this.options.deadLetterWorkflow) : void 0;
+    if (byWorkflow.size === 0 && !fallback) return;
+    this.engine.onDead((run) => {
+      const target = byWorkflow.get(run.workflow) ?? fallback;
+      if (!target) return;
+      void this.engine.start(target, {
+        deadRunId: run.id,
+        workflow: run.workflow,
+        input: run.input,
+        error: run.error
+      }, `dlq:${run.id}`).catch(() => void 0);
+    });
+  }
+};
+WorkflowRegistrar = _ts_decorate4([
+  Injectable4(),
+  _ts_param3(3, Inject3(STATE_STORE)),
+  _ts_param3(4, Inject3(DURABLE_OPTIONS3)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof DiscoveryService2 === "undefined" ? Object : DiscoveryService2,
+    typeof MetadataScanner2 === "undefined" ? Object : MetadataScanner2,
+    typeof WorkflowEngine3 === "undefined" ? Object : WorkflowEngine3,
+    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
+  ])
+], WorkflowRegistrar);
+
+// src/workflow.service.ts
+import { randomUUID } from "node:crypto";
+import { WorkflowEngine as WorkflowEngine4 } from "@dudousxd/nestjs-durable-core";
+import { Injectable as Injectable5 } from "@nestjs/common";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var WorkflowService = class {
+  static {
+    __name(this, "WorkflowService");
+  }
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  start(workflow, input, runId = randomUUID(), opts) {
+    return this.engine.start(workflow, input, runId, opts);
+  }
+  resume(runId) {
+    return this.engine.resume(runId);
+  }
+  /**
+  * Resolve once a run settles — terminal (completed/failed/cancelled/dead) or suspended. `start`
+  * only enqueues (a worker runs the body), so pair them when a request needs the outcome:
+  * `const { runId } = await svc.start(...); const result = await svc.waitForRun(runId)`.
+  */
+  waitForRun(runId, opts) {
+    return this.engine.waitForRun(runId, opts);
+  }
+  /** Deliver an external signal (e.g. from a webhook) to the run waiting on `token`. */
+  signal(token, payload) {
+    return this.engine.signal(token, payload);
+  }
+  signalWithStart(workflow, input, runId, signal, opts) {
+    return this.engine.signalWithStart(workflow, input, runId, signal, opts);
+  }
+  /**
+  * Publish a named event. Resumes runs waiting on it via `ctx.waitForEvent(name, { match })` and
+  * starts a fresh run of every workflow subscribed via `@Workflow({ onEvent })` / `@OnEvent` (the
+  * payload becomes its input). Pass `opts.id` to dedupe redeliveries. Returns how many runs it
+  * touched (resumed + started).
+  */
+  publishEvent(name, payload, opts) {
+    return this.engine.publishEvent(name, payload, opts);
+  }
+};
+WorkflowService = _ts_decorate5([
+  Injectable5(),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof WorkflowEngine4 === "undefined" ? Object : WorkflowEngine4
+  ])
+], WorkflowService);
+
+// src/durable.module.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function resolveAccessor(moduleRef) {
+  try {
+    return moduleRef.get(CONTEXT_ACCESSOR, {
+      strict: false
+    });
+  } catch {
+    return void 0;
+  }
+}
+__name(resolveAccessor, "resolveAccessor");
+function carrierFromAccessor(accessor) {
+  const carrier = {};
+  const traceId = accessor.traceId();
+  if (traceId !== void 0) carrier.traceId = traceId;
+  const tenantId = accessor.tenantId();
+  if (tenantId !== void 0) carrier.tenantId = tenantId;
+  const userRef = accessor.userRef();
+  if (userRef !== void 0) carrier.userRef = userRef;
+  return carrier;
+}
+__name(carrierFromAccessor, "carrierFromAccessor");
+function isContextRuntime(x) {
+  return !!x && typeof x.deserialize === "function";
+}
+__name(isContextRuntime, "isContextRuntime");
+async function resolveContextRuntime() {
+  try {
+    const specifier = "@dudousxd/nestjs-context";
+    const mod = await import(specifier);
+    return isContextRuntime(mod.Context) ? mod.Context : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(resolveContextRuntime, "resolveContextRuntime");
+function isControlPlane(x) {
+  return !!x && typeof x.publishControl === "function" && typeof x.onControl === "function";
+}
+__name(isControlPlane, "isControlPlane");
+var DurableModule = class _DurableModule {
+  static {
+    __name(this, "DurableModule");
+  }
+  static forRoot(options) {
+    return _DurableModule.build({
+      provide: DURABLE_OPTIONS4,
+      useValue: options
+    });
+  }
+  static forRootAsync(options) {
+    return _DurableModule.build({
+      provide: DURABLE_OPTIONS4,
+      useFactory: options.useFactory,
+      inject: options.inject ?? []
+    });
+  }
+  static build(optionsProvider) {
+    return {
+      module: _DurableModule,
+      global: true,
+      imports: [
+        DiscoveryModule
+      ],
+      providers: [
+        optionsProvider,
+        {
+          provide: STATE_STORE2,
+          useFactory: /* @__PURE__ */ __name((options) => options.store, "useFactory"),
+          inject: [
+            DURABLE_OPTIONS4
+          ]
+        },
+        {
+          provide: TRANSPORT2,
+          useFactory: /* @__PURE__ */ __name((options) => options.transport ?? null, "useFactory"),
+          inject: [
+            DURABLE_OPTIONS4
+          ]
+        },
+        {
+          provide: WorkflowEngine5,
+          useFactory: /* @__PURE__ */ __name(async (store, transport, opts, moduleRef) => {
+            const primary = transport ?? opts.transports?.[0]?.transport;
+            const accessor = resolveAccessor(moduleRef);
+            const context = opts.context ?? (accessor ? () => carrierFromAccessor(accessor) : void 0);
+            const runtime = accessor ? await resolveContextRuntime() : void 0;
+            const rehydrate = runtime && ((carrier, fn) => carrier && Object.keys(carrier).length > 0 ? runtime.deserialize(carrier, fn) : fn());
+            const engine = new WorkflowEngine5({
+              store,
+              transport: transport ?? void 0,
+              transports: opts.transports,
+              controlPlane: opts.controlPlane ?? (isControlPlane(primary) ? primary : void 0),
+              leaseMs: opts.leaseMs,
+              maxRecoveryAttempts: opts.maxRecoveryAttempts,
+              instanceId: opts.instanceId,
+              webhookUrl: opts.webhookUrl,
+              traceparent: opts.traceparent,
+              context,
+              rehydrate: rehydrate || void 0,
+              compensationRetries: opts.compensationRetries,
+              // A non-worker (API/dashboard) instance must not run workflows: enqueue-only, leaving
+              // each `pending` run in the store for a worker's `runPending` poll. Workers use the
+              // default in-process dispatcher (execute locally).
+              runDispatcher: opts.worker === false ? {
+                dispatch: /* @__PURE__ */ __name(() => {
+                }, "dispatch")
+              } : void 0
+            });
+            for (const queue of opts.queues ?? []) engine.registerQueue(queue);
+            return engine;
+          }, "useFactory"),
+          inject: [
+            STATE_STORE2,
+            TRANSPORT2,
+            DURABLE_OPTIONS4,
+            ModuleRef
+          ]
+        },
+        WorkflowService,
+        EntityService,
+        WorkflowRegistrar,
+        DurableStepRegistrar,
+        TimerPoller
+      ],
+      exports: [
+        WorkflowService,
+        EntityService,
+        WorkflowEngine5,
+        STATE_STORE2,
+        TRANSPORT2
+      ]
+    };
+  }
+};
+DurableModule = _ts_decorate6([
+  Module({})
+], DurableModule);
+export {
+  CONTEXT_ACCESSOR,
+  DEAD_LETTER_METADATA,
+  DURABLE_STEP_METADATA,
+  DeadLetter,
+  DurableModule,
+  DurableStep,
+  ENTITY_METADATA,
+  ENTITY_ON_METADATA,
+  Entity,
+  EntityService,
+  ON_EVENT_METADATA,
+  On,
+  OnEvent,
+  STEP_INTERCEPTOR_METADATA,
+  StepInterceptor,
+  WORKFLOW_METADATA,
+  Workflow,
+  WorkflowService,
+  entityConfigFor,
+  getDurableStepMeta,
+  getEntityMeta,
+  getOnEvents,
+  getWorkflowMeta,
+  isDeadLetterHandler,
+  isStepInterceptor
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./context-accessor"), exports);
-__exportStar(require("./decorators"), exports);
-__exportStar(require("./durable.module"), exports);
-__exportStar(require("./entity"), exports);
-__exportStar(require("./step-interceptor"), exports);
-__exportStar(require("./tokens"), exports);
-__exportStar(require("./workflow.service"), exports);
 //# sourceMappingURL=index.js.map