@dudousxd/nestjs-durable 0.22.1 → 0.23.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { StepError, WorkflowRef, SingletonConfig, StateStore, Transport, NamedTransport, ControlPlane, ScheduledWorkflow, RetentionPolicy, QueueConfig, AdmissionBackend, WorkflowEngine, EntityHandler, StepInvocation, WorkflowClass, WorkflowInputOf, StartOptions, RunResult } from '@dudousxd/nestjs-durable-core';
+import { StepError, WorkflowRef, SingletonConfig, WorkflowExecutor, StateStore, Transport, NamedTransport, ControlPlane, ScheduledWorkflow, RetentionPolicy, QueueConfig, AdmissionBackend, WorkflowEngine, EntityHandler, StepInvocation, WorkflowClass, WorkflowInputOf, StartOptions, RunResult } from '@dudousxd/nestjs-durable-core';
 import { RunRedisWorkerOptions, RunningWorker, DurableWorkerRuntime } from '@dudousxd/durable-worker';
-import { DynamicModule, InjectionToken, OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { DynamicModule, InjectionToken, OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown, Provider } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner } from '@nestjs/core';
 
 /**
@@ -268,6 +268,73 @@ declare class DurableWorkerModule {
     private static build;
 }
 
+/**
+ * Opt-in config for an **in-app worker**: the same NestJS process runs the engine AND serves its own
+ * discovered `@Workflow`/`@DurableStep` on one default `group`. The engine registers each `@Workflow`
+ * GROUP-SERVED (its turns are dispatched to `group` over the transport via a {@link RemoteWorkflowExecutor}
+ * instead of run inline), and a co-located {@link DurableWorkerRuntime} consumes `group` and replays the
+ * very same TS bodies. This is the uniform-dispatch "one app, both roles" shape — every turn pays a
+ * transport round-trip even though the worker is the same process. Requires a transport that carries
+ * workflow tasks (BullMQ); an in-process-only transport cannot dispatch a {@link WorkflowExecutor}.
+ */
+interface DurableInAppWorkerOptions {
+    /** The default group this app dispatches its `@Workflow` turns to AND consumes as a worker. */
+    group: string;
+    /** ioredis connection (string or options) for the co-located worker consumer (`runRedisWorker`). */
+    connection: string | Record<string, unknown>;
+    /** Key prefix namespacing the durable queues. Defaults to `durable` (matches the transport). */
+    prefix?: string;
+    /** Stable id for this worker process in heartbeats/control. Defaults to a per-host/pid id. */
+    instanceId?: string;
+}
+/** The resolved {@link DurableInAppWorkerOptions} or `null` when the app didn't opt in. */
+declare const IN_APP_WORKER_OPTIONS: unique symbol;
+/**
+ * The group-served binding the {@link import('./workflow.registrar').WorkflowRegistrar} applies to every
+ * discovered `@Workflow`: `{ group, executor }` when the app opted into an in-app worker, else `null`
+ * (workflows register inline — the unchanged default). The executor is a {@link RemoteWorkflowExecutor}
+ * over the engine's own transport, so a group-served turn is dispatched to `group` and the co-located
+ * worker (below) advances it.
+ */
+declare const IN_APP_WORKER_BINDING: unique symbol;
+/** The co-located worker's {@link DurableWorkerRuntime} (the consumer half). */
+declare const IN_APP_WORKER_RUNTIME: unique symbol;
+/** `runRedisWorker`, injected so tests can substitute a fake (no real Redis). Defaults to the real one. */
+declare const IN_APP_RUN_REDIS_WORKER: unique symbol;
+/** Started {@link RunningWorker} handles for the in-app group(s), closed on shutdown. */
+declare const IN_APP_WORKER_RUNNERS: unique symbol;
+/** The group-served binding shape resolved behind {@link IN_APP_WORKER_BINDING}. */
+interface InAppWorkerBinding {
+    group: string;
+    executor: WorkflowExecutor;
+}
+/**
+ * The consumer half of the in-app worker: on init it registers every discovered `@Workflow`/`@DurableStep`
+ * on a {@link DurableWorkerRuntime} (the SAME bodies the engine registered group-served), and on bootstrap
+ * it starts one `runRedisWorker` consumer on the configured group, closing it on shutdown. A no-op when
+ * the app didn't opt in. Mirrors the thin {@link import('./durable-worker.module').DurableWorkerModule},
+ * but co-located with a full engine.
+ */
+declare class InAppWorkerBootstrap implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly discovery;
+    private readonly metadataScanner;
+    private readonly options;
+    private readonly runtime;
+    private readonly runRedisWorker;
+    private readonly runnersSink;
+    private readonly runners;
+    constructor(discovery: DiscoveryService, metadataScanner: MetadataScanner, options: DurableInAppWorkerOptions | null, runtime: DurableWorkerRuntime, runRedisWorker: RunRedisWorkerFn, runnersSink: RunningWorker[]);
+    onModuleInit(): void;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+}
+/**
+ * The providers that stand up an in-app worker, added to {@link import('./durable.module').DurableModule}.
+ * All are inert when `inAppWorker` is unset (the binding resolves to `null`, the bootstrap no-ops), so a
+ * plain `DurableModule` is byte-for-byte unchanged.
+ */
+declare function inAppWorkerProviders(): Provider[];
+
 /**
  * Retention config for the {@link RetentionPoller}. One or more {@link RetentionPolicy policies}
  * (status sets must be disjoint — validated at boot), swept together on a shared interval.
@@ -411,6 +478,15 @@ interface DurableModuleOptions {
     context?: () => Record<string, unknown> | undefined;
     /** Attempts for each saga compensation when a run fails. Default 1 (no retry). Idempotent undos. */
     compensationRetries?: number;
+    /**
+     * Opt into an **in-app worker** (uniform dispatch): the same process runs the engine AND serves its
+     * own discovered `@Workflow`/`@DurableStep` on one default `group`. Each `@Workflow` is registered
+     * GROUP-SERVED — its turns are dispatched to `group` over the transport and replayed by a co-located
+     * worker consumer — instead of run inline. Requires a workflow-task transport (BullMQ). Omit (the
+     * default) to keep every `@Workflow` on the inline fast path with zero dispatch round-trips. See
+     * {@link DurableInAppWorkerOptions}.
+     */
+    inAppWorker?: DurableInAppWorkerOptions;
 }
 interface DurableModuleAsyncOptions {
     useFactory: (...args: never[]) => DurableModuleOptions | Promise<DurableModuleOptions>;
@@ -548,4 +624,4 @@ declare class WorkflowService {
     }): Promise<number>;
 }
 
-export { CONTEXT_ACCESSOR, type ContextAccessor, type ContextStore, DEAD_LETTER_METADATA, DURABLE_STEP_METADATA, DURABLE_WORKER_OPTIONS, DURABLE_WORKER_RUNNERS, DeadLetter, DurableModule, type DurableModuleAsyncOptions, type DurableModuleOptions, type DurableRetentionOptions, DurableStep, type DurableStepInterceptor, type DurableStepMeta, DurableWorkerModule, type DurableWorkerModuleAsyncOptions, type DurableWorkerModuleOptions, ENTITY_METADATA, ENTITY_ON_METADATA, Entity, EntityService, ON_EVENT_METADATA, On, OnEvent, RUN_REDIS_WORKER, type RunRedisWorkerFn, STEP_INTERCEPTOR_METADATA, StepInterceptor, ThinStepRegistrar, ThinWorkerBootstrap, ThinWorkflowRegistrar, type UserRef, WORKFLOW_METADATA, Workflow, type WorkflowMeta, type WorkflowOptions, WorkflowService, entityConfigFor, getDurableStepMeta, getEntityMeta, getOnEvents, getWorkflowMeta, isDeadLetterHandler, isStepInterceptor };
+export { CONTEXT_ACCESSOR, type ContextAccessor, type ContextStore, DEAD_LETTER_METADATA, DURABLE_STEP_METADATA, DURABLE_WORKER_OPTIONS, DURABLE_WORKER_RUNNERS, DeadLetter, type DurableInAppWorkerOptions, DurableModule, type DurableModuleAsyncOptions, type DurableModuleOptions, type DurableRetentionOptions, DurableStep, type DurableStepInterceptor, type DurableStepMeta, DurableWorkerModule, type DurableWorkerModuleAsyncOptions, type DurableWorkerModuleOptions, 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, type InAppWorkerBinding, InAppWorkerBootstrap, ON_EVENT_METADATA, On, OnEvent, RUN_REDIS_WORKER, type RunRedisWorkerFn, STEP_INTERCEPTOR_METADATA, StepInterceptor, ThinStepRegistrar, ThinWorkerBootstrap, ThinWorkflowRegistrar, type UserRef, WORKFLOW_METADATA, Workflow, type WorkflowMeta, type WorkflowOptions, WorkflowService, entityConfigFor, getDurableStepMeta, getEntityMeta, getOnEvents, getWorkflowMeta, inAppWorkerProviders, isDeadLetterHandler, isStepInterceptor };

package/dist/index.js

@@ -293,7 +293,7 @@ DurableWorkerModule = _ts_decorate([
 ], DurableWorkerModule);
 
 // src/durable.module.ts
-import { DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL5, STATE_STORE, STATE_STORE_CANONICAL as STATE_STORE_CANONICAL3, TRANSPORT, TRANSPORT_CANONICAL as TRANSPORT_CANONICAL2, WorkflowEngine as WorkflowEngine5 } from "@dudousxd/nestjs-durable-core";
+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";
 
@@ -435,9 +435,11 @@ EntityService = _ts_decorate3([
   ])
 ], EntityService);
 
-// src/retention-poller.ts
-import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL2, STATE_STORE_CANONICAL, TERMINAL_RUN_STATUSES, parseDuration } from "@dudousxd/nestjs-durable-core";
+// 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);
@@ -455,6 +457,136 @@ function _ts_param3(paramIndex, decorator) {
   };
 }
 __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.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;
@@ -531,37 +663,37 @@ var RetentionPoller = class {
     }
   }
 };
-RetentionPoller = _ts_decorate4([
-  Injectable4(),
-  _ts_param3(0, Inject3(STATE_STORE_CANONICAL)),
-  _ts_param3(1, Inject3(DURABLE_OPTIONS_CANONICAL2)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+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_CANONICAL3, WorkflowEngine as WorkflowEngine2, runSchedules } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject4, Injectable as Injectable5 } from "@nestjs/common";
-function _ts_decorate5(decorators, target, key, desc) {
+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_decorate5, "_ts_decorate");
-function _ts_metadata5(k, v) {
+__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_metadata5, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
+__name(_ts_param5, "_ts_param");
 var TimerPoller = class {
   static {
     __name(this, "TimerPoller");
@@ -606,11 +738,11 @@ var TimerPoller = class {
     }
   }
 };
-TimerPoller = _ts_decorate5([
-  Injectable5(),
-  _ts_param4(1, Inject4(DURABLE_OPTIONS_CANONICAL3)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+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
   ])
@@ -620,9 +752,9 @@ TimerPoller = _ts_decorate5([
 var CONTEXT_ACCESSOR = Symbol.for("@dudousxd/nestjs-context:accessor");
 
 // src/workflow.registrar.ts
-import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL4, STATE_STORE_CANONICAL as STATE_STORE_CANONICAL2, WorkflowEngine as WorkflowEngine3, parseDuration as parseDuration2, workflowName } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject5, Injectable as Injectable6 } from "@nestjs/common";
-import { DiscoveryService as DiscoveryService3, MetadataScanner as MetadataScanner3 } from "@nestjs/core";
+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) {
@@ -664,23 +796,23 @@ function isStepInterceptor(target) {
 __name(isStepInterceptor, "isStepInterceptor");
 
 // src/workflow.registrar.ts
-function _ts_decorate6(decorators, target, key, desc) {
+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_decorate6, "_ts_decorate");
-function _ts_metadata6(k, v) {
+__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_metadata6, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param5, "_ts_param");
+__name(_ts_param6, "_ts_param");
 var WorkflowRegistrar = class {
   static {
     __name(this, "WorkflowRegistrar");
@@ -690,12 +822,14 @@ var WorkflowRegistrar = class {
   engine;
   store;
   options;
-  constructor(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() {
     if (this.options.worker === false) return;
@@ -746,7 +880,14 @@ var WorkflowRegistrar = class {
         executionTimeout: meta.executionTimeout,
         validateInput,
         onEvent: getOnEvents(meta, workflowCtor),
-        eventBatch
+        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) {
@@ -793,35 +934,37 @@ var WorkflowRegistrar = class {
     });
   }
 };
-WorkflowRegistrar = _ts_decorate6([
-  Injectable6(),
-  _ts_param5(3, Inject5(STATE_STORE_CANONICAL2)),
-  _ts_param5(4, Inject5(DURABLE_OPTIONS_CANONICAL4)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
-    typeof DiscoveryService3 === "undefined" ? Object : DiscoveryService3,
-    typeof MetadataScanner3 === "undefined" ? Object : MetadataScanner3,
+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
+    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 Injectable7 } from "@nestjs/common";
-function _ts_decorate7(decorators, target, key, desc) {
+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_decorate7, "_ts_decorate");
-function _ts_metadata7(k, v) {
+__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_metadata7, "_ts_metadata");
+__name(_ts_metadata8, "_ts_metadata");
 var WorkflowService = class {
   static {
     __name(this, "WorkflowService");
@@ -861,22 +1004,22 @@ var WorkflowService = class {
     return this.engine.publishEvent(name, payload, opts);
   }
 };
-WorkflowService = _ts_decorate7([
-  Injectable7(),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
+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_decorate8(decorators, target, key, desc) {
+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_decorate8, "_ts_decorate");
+__name(_ts_decorate9, "_ts_decorate");
 function resolveAccessor(moduleRef) {
   try {
     return moduleRef.get(CONTEXT_ACCESSOR, {
@@ -922,13 +1065,13 @@ var DurableModule = class _DurableModule {
   }
   static forRoot(options) {
     return _DurableModule.build({
-      provide: DURABLE_OPTIONS_CANONICAL5,
+      provide: DURABLE_OPTIONS_CANONICAL6,
       useValue: options
     });
   }
   static forRootAsync(options) {
     return _DurableModule.build({
-      provide: DURABLE_OPTIONS_CANONICAL5,
+      provide: DURABLE_OPTIONS_CANONICAL6,
       useFactory: options.useFactory,
       inject: options.inject ?? []
     });
@@ -946,14 +1089,14 @@ var DurableModule = class _DurableModule {
           provide: STATE_STORE_CANONICAL3,
           useFactory: /* @__PURE__ */ __name((options) => options.store, "useFactory"),
           inject: [
-            DURABLE_OPTIONS_CANONICAL5
+            DURABLE_OPTIONS_CANONICAL6
           ]
         },
         {
-          provide: TRANSPORT_CANONICAL2,
+          provide: TRANSPORT_CANONICAL3,
           useFactory: /* @__PURE__ */ __name((options) => options.transport ?? null, "useFactory"),
           inject: [
-            DURABLE_OPTIONS_CANONICAL5
+            DURABLE_OPTIONS_CANONICAL6
           ]
         },
         // Legacy back-compat aliases (deprecated tokens still resolve to the same instances):
@@ -963,11 +1106,11 @@ var DurableModule = class _DurableModule {
         },
         {
           provide: TRANSPORT,
-          useExisting: TRANSPORT_CANONICAL2
+          useExisting: TRANSPORT_CANONICAL3
         },
         {
           provide: DURABLE_OPTIONS,
-          useExisting: DURABLE_OPTIONS_CANONICAL5
+          useExisting: DURABLE_OPTIONS_CANONICAL6
         },
         {
           provide: WorkflowEngine5,
@@ -1005,8 +1148,8 @@ var DurableModule = class _DurableModule {
           }, "useFactory"),
           inject: [
             STATE_STORE_CANONICAL3,
-            TRANSPORT_CANONICAL2,
-            DURABLE_OPTIONS_CANONICAL5,
+            TRANSPORT_CANONICAL3,
+            DURABLE_OPTIONS_CANONICAL6,
             ModuleRef
           ]
         },
@@ -1015,7 +1158,10 @@ var DurableModule = class _DurableModule {
         WorkflowRegistrar,
         DurableStepRegistrar,
         TimerPoller,
-        RetentionPoller
+        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,
@@ -1024,13 +1170,13 @@ var DurableModule = class _DurableModule {
         STATE_STORE,
         STATE_STORE_CANONICAL3,
         TRANSPORT,
-        TRANSPORT_CANONICAL2,
-        DURABLE_OPTIONS_CANONICAL5
+        TRANSPORT_CANONICAL3,
+        DURABLE_OPTIONS_CANONICAL6
       ]
     };
   }
 };
-DurableModule = _ts_decorate8([
+DurableModule = _ts_decorate9([
   Module2({})
 ], DurableModule);
 export {
@@ -1047,6 +1193,12 @@ export {
   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,
@@ -1064,6 +1216,7 @@ export {
   getEntityMeta,
   getOnEvents,
   getWorkflowMeta,
+  inAppWorkerProviders,
   isDeadLetterHandler,
   isStepInterceptor
 };