@dudousxd/nestjs-durable 0.0.0-beta-20260701163515

package/dist/index.js

@@ -0,0 +1,1286 @@
+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 Step(name) {
+  return (_target, _propertyKey, descriptor) => {
+    const meta = {
+      name
+    };
+    Reflect.defineMetadata(DURABLE_STEP_METADATA, meta, descriptor.value);
+    return descriptor;
+  };
+}
+__name(Step, "Step");
+var DurableStep = Step;
+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-worker.module.ts
+import { DurableWorkerRuntime, runRedisWorker as defaultRunRedisWorker } from "@dudousxd/durable-worker";
+import { tenantGroup } from "@dudousxd/nestjs-durable-core";
+import { Inject, Injectable, Module } from "@nestjs/common";
+import { DiscoveryModule, DiscoveryService, MetadataScanner } from "@nestjs/core";
+
+// src/discovery-helpers.ts
+function scanWorkflows(discovery, register) {
+  for (const wrapper of discovery.getProviders()) {
+    const { instance } = wrapper;
+    if (!instance || typeof instance !== "object") 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`);
+    }
+    register(meta, workflow);
+  }
+}
+__name(scanWorkflows, "scanWorkflows");
+function scanSteps(discovery, scanner, register) {
+  for (const wrapper of discovery.getProviders()) {
+    const { instance } = wrapper;
+    if (!instance || typeof instance !== "object") continue;
+    const prototype = Object.getPrototypeOf(instance);
+    for (const methodName of scanner.getAllMethodNames(prototype)) {
+      const method = instance[methodName];
+      if (typeof method !== "function") continue;
+      const meta = getDurableStepMeta(method);
+      if (!meta) continue;
+      const handler = /* @__PURE__ */ __name((input, log) => method.call(instance, input, log), "handler");
+      register(meta, handler);
+    }
+  }
+}
+__name(scanSteps, "scanSteps");
+
+// src/durable-worker.module.ts
+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");
+var DURABLE_WORKER_OPTIONS = Symbol("nestjs-durable:worker-options");
+var RUN_REDIS_WORKER = Symbol("nestjs-durable:run-redis-worker");
+var DURABLE_WORKER_RUNNERS = Symbol("nestjs-durable:worker-runners");
+var ThinWorkflowRegistrar = class {
+  static {
+    __name(this, "ThinWorkflowRegistrar");
+  }
+  discovery;
+  runtime;
+  constructor(discovery, runtime) {
+    this.discovery = discovery;
+    this.runtime = runtime;
+  }
+  onModuleInit() {
+    scanWorkflows(this.discovery, (meta, instance) => this.runtime.registerWorkflow(meta.name, (ctx, input) => instance.run(ctx, input)));
+  }
+};
+ThinWorkflowRegistrar = _ts_decorate([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+    typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime
+  ])
+], ThinWorkflowRegistrar);
+var ThinStepRegistrar = class {
+  static {
+    __name(this, "ThinStepRegistrar");
+  }
+  discovery;
+  metadataScanner;
+  runtime;
+  constructor(discovery, metadataScanner, runtime) {
+    this.discovery = discovery;
+    this.metadataScanner = metadataScanner;
+    this.runtime = runtime;
+  }
+  onModuleInit() {
+    scanSteps(this.discovery, this.metadataScanner, (meta, handler) => this.runtime.registerStep(meta.name, handler));
+  }
+};
+ThinStepRegistrar = _ts_decorate([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+    typeof MetadataScanner === "undefined" ? Object : MetadataScanner,
+    typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime
+  ])
+], ThinStepRegistrar);
+var ThinWorkerBootstrap = class {
+  static {
+    __name(this, "ThinWorkerBootstrap");
+  }
+  runtime;
+  options;
+  runRedisWorker;
+  runnersSink;
+  runners = [];
+  constructor(runtime, options, runRedisWorker, runnersSink) {
+    this.runtime = runtime;
+    this.options = options;
+    this.runRedisWorker = runRedisWorker;
+    this.runnersSink = runnersSink;
+  }
+  async onApplicationBootstrap() {
+    for (const group of this.options.groups) {
+      const handle = await this.runRedisWorker({
+        runtime: this.runtime,
+        group: tenantGroup(group, this.options.tenant),
+        connection: this.options.connection,
+        ...this.options.prefix !== void 0 ? {
+          prefix: this.options.prefix
+        } : {},
+        ...this.options.instanceId !== void 0 ? {
+          instanceId: this.options.instanceId
+        } : {},
+        ...(this.options.concurrencyByGroup?.[group] ?? this.options.concurrency) !== void 0 ? {
+          concurrency: this.options.concurrencyByGroup?.[group] ?? this.options.concurrency
+        } : {}
+      });
+      this.runners.push(handle);
+      this.runnersSink.push(handle);
+    }
+  }
+  async onApplicationShutdown() {
+    await Promise.allSettled(this.runners.map((h) => h.close()));
+  }
+};
+ThinWorkerBootstrap = _ts_decorate([
+  Injectable(),
+  _ts_param(1, Inject(DURABLE_WORKER_OPTIONS)),
+  _ts_param(2, Inject(RUN_REDIS_WORKER)),
+  _ts_param(3, Inject(DURABLE_WORKER_RUNNERS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime,
+    typeof DurableWorkerModuleOptions === "undefined" ? Object : DurableWorkerModuleOptions,
+    typeof RunRedisWorkerFn === "undefined" ? Object : RunRedisWorkerFn,
+    Array
+  ])
+], ThinWorkerBootstrap);
+var DurableWorkerModule = class _DurableWorkerModule {
+  static {
+    __name(this, "DurableWorkerModule");
+  }
+  static forRoot(options) {
+    return _DurableWorkerModule.build({
+      provide: DURABLE_WORKER_OPTIONS,
+      useValue: options
+    });
+  }
+  static forRootAsync(options) {
+    return _DurableWorkerModule.build({
+      provide: DURABLE_WORKER_OPTIONS,
+      useFactory: options.useFactory,
+      inject: options.inject ?? []
+    });
+  }
+  static build(optionsProvider) {
+    return {
+      module: _DurableWorkerModule,
+      imports: [
+        DiscoveryModule
+      ],
+      providers: [
+        optionsProvider,
+        {
+          provide: DurableWorkerRuntime,
+          useFactory: /* @__PURE__ */ __name(() => new DurableWorkerRuntime(), "useFactory")
+        },
+        {
+          provide: RUN_REDIS_WORKER,
+          useValue: defaultRunRedisWorker
+        },
+        {
+          provide: DURABLE_WORKER_RUNNERS,
+          useValue: []
+        },
+        ThinWorkflowRegistrar,
+        ThinStepRegistrar,
+        ThinWorkerBootstrap
+      ],
+      exports: [
+        DurableWorkerRuntime
+      ]
+    };
+  }
+};
+DurableWorkerModule = _ts_decorate([
+  Module({})
+], DurableWorkerModule);
+
+// src/durable.module.ts
+import { DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL6, STATE_STORE, STATE_STORE_CANONICAL as STATE_STORE_CANONICAL3, TRANSPORT, TRANSPORT_CANONICAL as TRANSPORT_CANONICAL3, WorkflowEngine as WorkflowEngine5 } from "@dudousxd/nestjs-durable-core";
+import { Module as Module2 } from "@nestjs/common";
+import { DiscoveryModule as DiscoveryModule2, ModuleRef } from "@nestjs/core";
+
+// src/durable-step.registrar.ts
+import { DURABLE_OPTIONS_CANONICAL, TRANSPORT_CANONICAL } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject2, Injectable as Injectable2 } from "@nestjs/common";
+import { DiscoveryService as DiscoveryService2, MetadataScanner as MetadataScanner2 } from "@nestjs/core";
+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");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_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;
+    scanSteps(this.discovery, this.metadataScanner, (meta, handler) => transport.handle(meta.name, handler));
+  }
+};
+DurableStepRegistrar = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(2, Inject2(TRANSPORT_CANONICAL)),
+  _ts_param2(3, Inject2(DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof DiscoveryService2 === "undefined" ? Object : DiscoveryService2,
+    typeof MetadataScanner2 === "undefined" ? Object : MetadataScanner2,
+    Object,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
+  ])
+], DurableStepRegistrar);
+
+// src/entity.ts
+import { WorkflowEngine } from "@dudousxd/nestjs-durable-core";
+import { Injectable as Injectable3 } from "@nestjs/common";
+import "reflect-metadata";
+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");
+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_decorate3([
+  Injectable3(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof WorkflowEngine === "undefined" ? Object : WorkflowEngine
+  ])
+], EntityService);
+
+// src/in-app-worker.ts
+import { DurableWorkerRuntime as DurableWorkerRuntime2, runRedisWorker as defaultRunRedisWorker2 } from "@dudousxd/durable-worker";
+import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL2, RemoteWorkflowExecutor, TRANSPORT_CANONICAL as TRANSPORT_CANONICAL2 } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject3, Injectable as Injectable4 } from "@nestjs/common";
+import { DiscoveryService as DiscoveryService3, MetadataScanner as MetadataScanner3 } from "@nestjs/core";
+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 IN_APP_WORKER_OPTIONS = Symbol("nestjs-durable:in-app-worker-options");
+var IN_APP_WORKER_BINDING = Symbol("nestjs-durable:in-app-worker-binding");
+var IN_APP_WORKER_RUNTIME = Symbol("nestjs-durable:in-app-worker-runtime");
+var IN_APP_RUN_REDIS_WORKER = Symbol("nestjs-durable:in-app-run-redis-worker");
+var IN_APP_WORKER_RUNNERS = Symbol("nestjs-durable:in-app-worker-runners");
+function inAppWorkerBinding(transport, options) {
+  if (!options) return null;
+  if (!transport?.dispatchWorkflowTask || !transport.onDecision) {
+    throw new Error("inAppWorker requires a transport that carries workflow tasks (dispatchWorkflowTask + onDecision), e.g. BullMQTransport. An in-process transport cannot serve a group-served workflow.");
+  }
+  return {
+    group: options.group,
+    executor: new RemoteWorkflowExecutor(transport, options.group)
+  };
+}
+__name(inAppWorkerBinding, "inAppWorkerBinding");
+var InAppWorkerBootstrap = class {
+  static {
+    __name(this, "InAppWorkerBootstrap");
+  }
+  discovery;
+  metadataScanner;
+  options;
+  runtime;
+  runRedisWorker;
+  runnersSink;
+  runners = [];
+  constructor(discovery, metadataScanner, options, runtime, runRedisWorker, runnersSink) {
+    this.discovery = discovery;
+    this.metadataScanner = metadataScanner;
+    this.options = options;
+    this.runtime = runtime;
+    this.runRedisWorker = runRedisWorker;
+    this.runnersSink = runnersSink;
+  }
+  onModuleInit() {
+    if (!this.options) return;
+    scanWorkflows(this.discovery, (meta, instance) => this.runtime.registerWorkflow(meta.name, (ctx, input) => instance.run(ctx, input)));
+    scanSteps(this.discovery, this.metadataScanner, (meta, handler) => this.runtime.registerStep(meta.name, handler));
+  }
+  async onApplicationBootstrap() {
+    if (!this.options) return;
+    const handle = await this.runRedisWorker({
+      runtime: this.runtime,
+      group: this.options.group,
+      connection: this.options.connection,
+      ...this.options.prefix !== void 0 ? {
+        prefix: this.options.prefix
+      } : {},
+      ...this.options.instanceId !== void 0 ? {
+        instanceId: this.options.instanceId
+      } : {},
+      ...this.options.concurrency !== void 0 ? {
+        concurrency: this.options.concurrency
+      } : {}
+    });
+    this.runners.push(handle);
+    this.runnersSink.push(handle);
+  }
+  async onApplicationShutdown() {
+    await Promise.allSettled(this.runners.map((handle) => handle.close()));
+  }
+};
+InAppWorkerBootstrap = _ts_decorate4([
+  Injectable4(),
+  _ts_param3(2, Inject3(IN_APP_WORKER_OPTIONS)),
+  _ts_param3(3, Inject3(IN_APP_WORKER_RUNTIME)),
+  _ts_param3(4, Inject3(IN_APP_RUN_REDIS_WORKER)),
+  _ts_param3(5, Inject3(IN_APP_WORKER_RUNNERS)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof DiscoveryService3 === "undefined" ? Object : DiscoveryService3,
+    typeof MetadataScanner3 === "undefined" ? Object : MetadataScanner3,
+    Object,
+    typeof DurableWorkerRuntime2 === "undefined" ? Object : DurableWorkerRuntime2,
+    typeof RunRedisWorkerFn === "undefined" ? Object : RunRedisWorkerFn,
+    Array
+  ])
+], InAppWorkerBootstrap);
+function inAppWorkerProviders() {
+  return [
+    {
+      provide: IN_APP_WORKER_BINDING,
+      useFactory: /* @__PURE__ */ __name((transport, options) => inAppWorkerBinding(transport, options.inAppWorker ?? null), "useFactory"),
+      inject: [
+        TRANSPORT_CANONICAL2,
+        DURABLE_OPTIONS_CANONICAL2
+      ]
+    },
+    {
+      provide: IN_APP_WORKER_OPTIONS,
+      useFactory: /* @__PURE__ */ __name((options) => options.inAppWorker ?? null, "useFactory"),
+      inject: [
+        DURABLE_OPTIONS_CANONICAL2
+      ]
+    },
+    {
+      provide: IN_APP_WORKER_RUNTIME,
+      useFactory: /* @__PURE__ */ __name(() => new DurableWorkerRuntime2(), "useFactory")
+    },
+    {
+      provide: IN_APP_RUN_REDIS_WORKER,
+      useValue: defaultRunRedisWorker2
+    },
+    {
+      provide: IN_APP_WORKER_RUNNERS,
+      useValue: []
+    },
+    InAppWorkerBootstrap
+  ];
+}
+__name(inAppWorkerProviders, "inAppWorkerProviders");
+
+// src/retention-poller.ts
+import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL3, STATE_STORE_CANONICAL, TERMINAL_RUN_STATUSES, parseDuration } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject4, 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");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var DEFAULT_SWEEP_INTERVAL_MS = 6e4;
+var DEFAULT_BATCH_SIZE = 1e3;
+var MAX_BATCHES_PER_POLICY = 100;
+function validateRetention(retention) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const policy of retention.policies) {
+    if (policy.statuses.length === 0) {
+      throw new Error("durable retention: each policy must list at least one status");
+    }
+    if (policy.maxAge == null && policy.maxCount == null) {
+      throw new Error("durable retention: each policy must set maxAge and/or maxCount");
+    }
+    if (policy.maxAge != null) parseDuration(policy.maxAge);
+    for (const status of policy.statuses) {
+      if (!TERMINAL_RUN_STATUSES.includes(status)) {
+        throw new Error(`durable retention: status "${status}" is not terminal; only ${TERMINAL_RUN_STATUSES.join(", ")} can be pruned`);
+      }
+      if (seen.has(status)) {
+        throw new Error(`durable retention: status "${status}" appears in more than one policy; status sets must be disjoint`);
+      }
+      seen.add(status);
+    }
+  }
+}
+__name(validateRetention, "validateRetention");
+var RetentionPoller = class {
+  static {
+    __name(this, "RetentionPoller");
+  }
+  store;
+  options;
+  timer;
+  sweeping = false;
+  constructor(store, options) {
+    this.store = store;
+    this.options = options;
+  }
+  async onApplicationBootstrap() {
+    if (this.options.worker === false) return;
+    const retention = this.options.retention;
+    if (!retention || retention.policies.length === 0) return;
+    validateRetention(retention);
+    if (typeof this.store.pruneTerminalRuns !== "function") {
+      console.warn("[nestjs-durable] `retention` is configured but the store adapter does not implement pruneTerminalRuns; retention is disabled.");
+      return;
+    }
+    await this.sweep();
+    const intervalMs = retention.sweepInterval != null ? parseDuration(retention.sweepInterval) : DEFAULT_SWEEP_INTERVAL_MS;
+    if (intervalMs > 0) {
+      this.timer = setInterval(() => void this.sweep(), intervalMs);
+      this.timer.unref?.();
+    }
+  }
+  onModuleDestroy() {
+    if (this.timer) clearInterval(this.timer);
+  }
+  async sweep() {
+    if (this.sweeping) return;
+    const retention = this.options.retention;
+    const prune = this.store.pruneTerminalRuns;
+    if (!retention || typeof prune !== "function") return;
+    this.sweeping = true;
+    try {
+      const batchSize = retention.batchSize ?? DEFAULT_BATCH_SIZE;
+      const now = Date.now();
+      for (const policy of retention.policies) {
+        for (let batch = 0; batch < MAX_BATCHES_PER_POLICY; batch++) {
+          const deleted = await prune.call(this.store, policy, now, batchSize);
+          if (deleted < batchSize) break;
+        }
+      }
+    } finally {
+      this.sweeping = false;
+    }
+  }
+};
+RetentionPoller = _ts_decorate5([
+  Injectable5(),
+  _ts_param4(0, Inject4(STATE_STORE_CANONICAL)),
+  _ts_param4(1, Inject4(DURABLE_OPTIONS_CANONICAL3)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
+  ])
+], RetentionPoller);
+
+// src/timer-poller.ts
+import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL4, WorkflowEngine as WorkflowEngine2, runSchedules } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject5, Injectable as Injectable6 } from "@nestjs/common";
+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 _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_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() {
+    const drive = this.options.drive ?? this.options.worker !== false;
+    if (!drive) 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_decorate6([
+  Injectable6(),
+  _ts_param5(1, Inject5(DURABLE_OPTIONS_CANONICAL4)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("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_CANONICAL as DURABLE_OPTIONS_CANONICAL5, STATE_STORE_CANONICAL as STATE_STORE_CANONICAL2, WorkflowEngine as WorkflowEngine3, parseDuration as parseDuration2, workflowName } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject6, Injectable as Injectable7 } from "@nestjs/common";
+import { DiscoveryService as DiscoveryService4, MetadataScanner as MetadataScanner4 } 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_decorate7(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_decorate7, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var WorkflowRegistrar = class {
+  static {
+    __name(this, "WorkflowRegistrar");
+  }
+  discovery;
+  metadataScanner;
+  engine;
+  store;
+  options;
+  inAppWorker;
+  constructor(discovery, metadataScanner, engine, store, options, inAppWorker) {
+    this.discovery = discovery;
+    this.metadataScanner = metadataScanner;
+    this.engine = engine;
+    this.store = store;
+    this.options = options;
+    this.inAppWorker = inAppWorker;
+  }
+  async onApplicationBootstrap() {
+    const drive = this.options.drive ?? this.options.worker !== false;
+    if (!drive) 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));
+      }
+    }
+    scanWorkflows(this.discovery, (meta, workflow) => {
+      const validateInput = meta.validateInput ?? (meta.inputSchema ? classValidatorInput(meta.inputSchema) : void 0);
+      const eventBatch = meta.debounce ? {
+        mode: "debounce",
+        windowMs: parseDuration2(meta.debounce)
+      } : meta.batch ? {
+        mode: "batch",
+        maxSize: meta.batch.maxSize,
+        windowMs: parseDuration2(meta.batch.within)
+      } : void 0;
+      const workflowCtor = workflow.constructor;
+      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, workflowCtor),
+        eventBatch,
+        // Uniform dispatch (opt-in): when an in-app worker is configured, register the body GROUP-SERVED
+        // so the engine dispatches its turns to the app's own group instead of running it inline; the
+        // co-located worker consumer replays the same body. Absent → the inline fast path (unchanged).
+        ...this.inAppWorker ? {
+          group: this.inAppWorker.group,
+          executor: this.inAppWorker.executor
+        } : {}
+      });
+      const inline = this.findDeadLetterHandler(workflow);
+      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}`,
+        // Route the dead-letter handler to the dead run's OWN tenant so an operator dispatches it to
+        // that tenant's worker group (`target@<tenant>`), not the bare group.
+        {
+          namespace: run.namespace
+        }
+      ).catch(() => void 0);
+    });
+  }
+};
+WorkflowRegistrar = _ts_decorate7([
+  Injectable7(),
+  _ts_param6(3, Inject6(STATE_STORE_CANONICAL2)),
+  _ts_param6(4, Inject6(DURABLE_OPTIONS_CANONICAL5)),
+  _ts_param6(5, Inject6(IN_APP_WORKER_BINDING)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof DiscoveryService4 === "undefined" ? Object : DiscoveryService4,
+    typeof MetadataScanner4 === "undefined" ? Object : MetadataScanner4,
+    typeof WorkflowEngine3 === "undefined" ? Object : WorkflowEngine3,
+    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
+    Object
+  ])
+], WorkflowRegistrar);
+
+// src/workflow.service.ts
+import { randomUUID } from "node:crypto";
+import { WorkflowEngine as WorkflowEngine4 } from "@dudousxd/nestjs-durable-core";
+import { Injectable as Injectable8 } from "@nestjs/common";
+function _ts_decorate8(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_decorate8, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_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_decorate8([
+  Injectable8(),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof WorkflowEngine4 === "undefined" ? Object : WorkflowEngine4
+  ])
+], WorkflowService);
+
+// src/durable.module.ts
+function _ts_decorate9(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_decorate9, "_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");
+function isScopeableStore(store) {
+  return typeof store.withScope === "function";
+}
+__name(isScopeableStore, "isScopeableStore");
+function scopedStore(options) {
+  if (options.scopeReads !== true || options.namespace === void 0) return options.store;
+  if (!isScopeableStore(options.store)) return options.store;
+  return options.store.withScope({
+    namespace: options.namespace
+  });
+}
+__name(scopedStore, "scopedStore");
+var DurableModule = class _DurableModule {
+  static {
+    __name(this, "DurableModule");
+  }
+  static forRoot(options) {
+    return _DurableModule.build({
+      provide: DURABLE_OPTIONS_CANONICAL6,
+      useValue: options
+    });
+  }
+  static forRootAsync(options) {
+    return _DurableModule.build({
+      provide: DURABLE_OPTIONS_CANONICAL6,
+      useFactory: options.useFactory,
+      inject: options.inject ?? []
+    });
+  }
+  static build(optionsProvider) {
+    return {
+      module: _DurableModule,
+      global: true,
+      imports: [
+        DiscoveryModule2
+      ],
+      providers: [
+        optionsProvider,
+        {
+          provide: STATE_STORE_CANONICAL3,
+          useFactory: /* @__PURE__ */ __name((options) => scopedStore(options), "useFactory"),
+          inject: [
+            DURABLE_OPTIONS_CANONICAL6
+          ]
+        },
+        {
+          provide: TRANSPORT_CANONICAL3,
+          useFactory: /* @__PURE__ */ __name((options) => options.transport ?? null, "useFactory"),
+          inject: [
+            DURABLE_OPTIONS_CANONICAL6
+          ]
+        },
+        // Legacy back-compat aliases (deprecated tokens still resolve to the same instances):
+        {
+          provide: STATE_STORE,
+          useExisting: STATE_STORE_CANONICAL3
+        },
+        {
+          provide: TRANSPORT,
+          useExisting: TRANSPORT_CANONICAL3
+        },
+        {
+          provide: DURABLE_OPTIONS,
+          useExisting: DURABLE_OPTIONS_CANONICAL6
+        },
+        {
+          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,
+              admission: opts.admission,
+              maxRecoveryAttempts: opts.maxRecoveryAttempts,
+              remoteAdvanceSilenceMs: opts.remoteAdvanceSilenceMs,
+              instanceId: opts.instanceId,
+              namespace: opts.namespace,
+              remoteByConvention: opts.remoteByConvention,
+              webhookUrl: opts.webhookUrl,
+              traceparent: opts.traceparent,
+              context,
+              rehydrate: rehydrate || void 0,
+              compensationRetries: opts.compensationRetries,
+              // A non-worker, non-driving (plain API/dashboard) instance must not run workflows:
+              // enqueue-only, leaving each `pending` run in the store for a DRIVING instance's poll.
+              // Workers AND driving control planes (`drive:true` — see `DurableControlPlaneModule`)
+              // get the engine's default in-process dispatcher: for a worker that executes the body
+              // locally, and for a driving-only control plane that has no local registration, the
+              // SAME default dispatcher routes it out remotely via `remoteByConvention` instead.
+              runDispatcher: opts.worker === false && opts.drive !== true ? {
+                dispatch: /* @__PURE__ */ __name(() => {
+                }, "dispatch")
+              } : void 0
+            });
+            for (const queue of opts.queues ?? []) engine.registerQueue(queue);
+            return engine;
+          }, "useFactory"),
+          inject: [
+            STATE_STORE_CANONICAL3,
+            TRANSPORT_CANONICAL3,
+            DURABLE_OPTIONS_CANONICAL6,
+            ModuleRef
+          ]
+        },
+        WorkflowService,
+        EntityService,
+        WorkflowRegistrar,
+        DurableStepRegistrar,
+        TimerPoller,
+        RetentionPoller,
+        // In-app worker (uniform dispatch, opt-in): inert when `inAppWorker` is unset — the binding
+        // resolves to null and the bootstrap no-ops, so a plain DurableModule is unchanged.
+        ...inAppWorkerProviders()
+      ],
+      exports: [
+        WorkflowService,
+        EntityService,
+        WorkflowEngine5,
+        STATE_STORE,
+        STATE_STORE_CANONICAL3,
+        TRANSPORT,
+        TRANSPORT_CANONICAL3,
+        DURABLE_OPTIONS_CANONICAL6
+      ]
+    };
+  }
+};
+DurableModule = _ts_decorate9([
+  Module2({})
+], DurableModule);
+var DurableControlPlaneModule = class {
+  static {
+    __name(this, "DurableControlPlaneModule");
+  }
+  static forRoot(options) {
+    return DurableModule.forRoot({
+      ...options,
+      worker: false,
+      drive: true
+    });
+  }
+  static forRootAsync(options) {
+    return DurableModule.forRootAsync({
+      ...options,
+      useFactory: /* @__PURE__ */ __name(async (...args) => ({
+        ...await options.useFactory(...args),
+        worker: false,
+        drive: true
+      }), "useFactory")
+    });
+  }
+};
+DurableControlPlaneModule = _ts_decorate9([
+  Module2({})
+], DurableControlPlaneModule);
+export {
+  CONTEXT_ACCESSOR,
+  DEAD_LETTER_METADATA,
+  DURABLE_STEP_METADATA,
+  DURABLE_WORKER_OPTIONS,
+  DURABLE_WORKER_RUNNERS,
+  DeadLetter,
+  DurableControlPlaneModule,
+  DurableModule,
+  DurableStep,
+  DurableWorkerModule,
+  ENTITY_METADATA,
+  ENTITY_ON_METADATA,
+  Entity,
+  EntityService,
+  IN_APP_RUN_REDIS_WORKER,
+  IN_APP_WORKER_BINDING,
+  IN_APP_WORKER_OPTIONS,
+  IN_APP_WORKER_RUNNERS,
+  IN_APP_WORKER_RUNTIME,
+  InAppWorkerBootstrap,
+  ON_EVENT_METADATA,
+  On,
+  OnEvent,
+  RUN_REDIS_WORKER,
+  STEP_INTERCEPTOR_METADATA,
+  Step,
+  StepInterceptor,
+  ThinStepRegistrar,
+  ThinWorkerBootstrap,
+  ThinWorkflowRegistrar,
+  WORKFLOW_METADATA,
+  Workflow,
+  WorkflowService,
+  entityConfigFor,
+  getDurableStepMeta,
+  getEntityMeta,
+  getOnEvents,
+  getWorkflowMeta,
+  inAppWorkerProviders,
+  isDeadLetterHandler,
+  isStepInterceptor
+};
+//# sourceMappingURL=index.js.map