@dudousxd/nestjs-durable 0.26.0 → 0.28.0

package/dist/index.cjs

@@ -24,29 +24,33 @@ __export(index_exports, {
   CONTEXT_ACCESSOR: () => CONTEXT_ACCESSOR,
   DEAD_LETTER_METADATA: () => DEAD_LETTER_METADATA,
   DURABLE_STEP_METADATA: () => DURABLE_STEP_METADATA,
-  DURABLE_WORKER_OPTIONS: () => DURABLE_WORKER_OPTIONS,
   DURABLE_WORKER_RUNNERS: () => DURABLE_WORKER_RUNNERS,
   DeadLetter: () => DeadLetter,
   DurableModule: () => DurableModule,
+  DurableStartClient: () => DurableStartClient,
   DurableStep: () => DurableStep,
-  DurableWorkerModule: () => DurableWorkerModule,
   ENTITY_METADATA: () => ENTITY_METADATA,
   ENTITY_ON_METADATA: () => ENTITY_ON_METADATA,
   Entity: () => Entity,
   EntityService: () => EntityService,
   IN_APP_RUN_REDIS_WORKER: () => IN_APP_RUN_REDIS_WORKER,
   IN_APP_WORKER_BINDING: () => IN_APP_WORKER_BINDING,
-  IN_APP_WORKER_OPTIONS: () => IN_APP_WORKER_OPTIONS,
   IN_APP_WORKER_RUNNERS: () => IN_APP_WORKER_RUNNERS,
   IN_APP_WORKER_RUNTIME: () => IN_APP_WORKER_RUNTIME,
   InAppWorkerBootstrap: () => InAppWorkerBootstrap,
   ON_EVENT_METADATA: () => ON_EVENT_METADATA,
   On: () => On,
+  OnDurableEvent: () => OnDurableEvent,
   OnEvent: () => OnEvent,
+  ProxyRunGateway: () => ProxyRunGateway,
+  RUN_GATEWAY: () => RUN_GATEWAY,
   RUN_REDIS_WORKER: () => RUN_REDIS_WORKER,
+  RunRequestResponder: () => RunRequestResponder,
   STEP_INTERCEPTOR_METADATA: () => STEP_INTERCEPTOR_METADATA,
   Step: () => Step,
   StepInterceptor: () => StepInterceptor,
+  StoreRunGateway: () => StoreRunGateway,
+  TenantEventRepublisher: () => TenantEventRepublisher,
   ThinStepRegistrar: () => ThinStepRegistrar,
   ThinWorkerBootstrap: () => ThinWorkerBootstrap,
   ThinWorkflowRegistrar: () => ThinWorkflowRegistrar,
@@ -60,7 +64,11 @@ __export(index_exports, {
   getWorkflowMeta: () => getWorkflowMeta,
   inAppWorkerProviders: () => inAppWorkerProviders,
   isDeadLetterHandler: () => isDeadLetterHandler,
-  isStepInterceptor: () => isStepInterceptor
+  isDrivingOperator: () => isDrivingOperator,
+  isOperatorRole: () => isOperatorRole,
+  isStepInterceptor: () => isStepInterceptor,
+  thinWorkerProviders: () => thinWorkerProviders,
+  unavailableRunGateway: () => unavailableRunGateway
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -96,12 +104,36 @@ function getWorkflowMeta(target) {
 }
 __name(getWorkflowMeta, "getWorkflowMeta");
 var DURABLE_STEP_METADATA = Symbol("nestjs-durable:step-handler");
-function Step(name) {
-  return (_target, _propertyKey, descriptor) => {
+function stepConfigFrom(options) {
+  const config = {
+    retries: options.retries,
+    backoff: options.backoff,
+    backoffMs: options.backoffMs,
+    backoffMaxMs: options.backoffMaxMs,
+    jitter: options.jitter,
+    timeoutMs: options.timeoutMs
+  };
+  const hasAnyField = Object.values(config).some((value) => value !== void 0);
+  return hasAnyField ? config : void 0;
+}
+__name(stepConfigFrom, "stepConfigFrom");
+function Step(nameOrOptions) {
+  return (target, propertyKey, descriptor) => {
+    const options = typeof nameOrOptions === "string" ? {
+      name: nameOrOptions
+    } : nameOrOptions ?? {};
+    const derivedName = options.name ?? `${target.constructor.name}.${String(propertyKey)}`;
     const meta = {
-      name
+      name: derivedName,
+      input: options.input,
+      output: options.output
     };
     Reflect.defineMetadata(DURABLE_STEP_METADATA, meta, descriptor.value);
+    descriptor.value[import_nestjs_durable_core.DURABLE_STEP_NAME] = derivedName;
+    const config = stepConfigFrom(options);
+    if (config !== void 0) {
+      descriptor.value[import_nestjs_durable_core.DURABLE_STEP_CONFIG] = config;
+    }
     return descriptor;
   };
 }
@@ -124,7 +156,7 @@ function isDeadLetterHandler(method) {
 }
 __name(isDeadLetterHandler, "isDeadLetterHandler");
 var ON_EVENT_METADATA = Symbol("nestjs-durable:on-event");
-function OnEvent(...events) {
+function OnDurableEvent(...events) {
   return (target) => {
     const existing = Reflect.getMetadata(ON_EVENT_METADATA, target) ?? [];
     Reflect.defineMetadata(ON_EVENT_METADATA, [
@@ -133,7 +165,8 @@ function OnEvent(...events) {
     ], target);
   };
 }
-__name(OnEvent, "OnEvent");
+__name(OnDurableEvent, "OnDurableEvent");
+var OnEvent = OnDurableEvent;
 function getOnEvents(meta, target) {
   const fromDecorator = Reflect.getMetadata(ON_EVENT_METADATA, target) ?? [];
   return [
@@ -145,9 +178,105 @@ function getOnEvents(meta, target) {
 }
 __name(getOnEvents, "getOnEvents");
 
-// src/durable-worker.module.ts
+// src/durable-start-client.ts
 var import_durable_worker = require("@dudousxd/durable-worker");
+var import_nestjs_durable_core2 = require("@dudousxd/nestjs-durable-core");
 var import_common = require("@nestjs/common");
+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");
+var DurableStartClient = class {
+  static {
+    __name(this, "DurableStartClient");
+  }
+  options;
+  deps;
+  tenant;
+  constructor(options, deps) {
+    this.options = options;
+    this.deps = deps;
+    this.tenant = options.partition ?? "default";
+  }
+  async start(workflow, input, runId = globalThis.crypto.randomUUID(), opts) {
+    const name = (0, import_nestjs_durable_core2.workflowName)(workflow);
+    await (0, import_durable_worker.startRun)(this.options.connection, {
+      tenant: this.tenant,
+      workflow: name,
+      input,
+      runId,
+      // Option B: DO NOT pass `namespace` — the start-run queue stays the shared
+      // `durable-start-run` the operator consumes; tenant rides only as message data.
+      ...this.options.prefix !== void 0 ? {
+        prefix: this.options.prefix
+      } : {},
+      ...opts?.tags !== void 0 ? {
+        tags: opts.tags
+      } : {},
+      ...opts?.searchAttributes !== void 0 ? {
+        searchAttributes: opts.searchAttributes
+      } : {},
+      ...this.deps !== void 0 ? {
+        deps: this.deps
+      } : {}
+    });
+    return {
+      runId,
+      status: "pending"
+    };
+  }
+  cancel(_runId) {
+    return tenantUnsupported("cancel");
+  }
+  deleteRun(_runId) {
+    return tenantUnsupported("deleteRun");
+  }
+  // — everything below rejects: a tenant worker holds no store/driver, only the start channel. —
+  // The remaining WorkflowEngine surface WorkflowService delegates to (resume/waitForRun/signal/
+  // signalWithStart/publishEvent) all need the store or driver a tenant does not have. A tenant only
+  // ever calls `start`; these exist so a mistaken call fails with a CLEAR, named tenant error instead
+  // of a cryptic `this.engine.X is not a function` — the facade is honest about what it cannot do.
+  // Params mirror the WorkflowEngine surface being faced; every method rejects without reading them.
+  resume(_runId) {
+    return tenantUnsupported("resume");
+  }
+  waitForRun(_runId, _opts) {
+    return tenantUnsupported("waitForRun");
+  }
+  signal(_token, _payload) {
+    return tenantUnsupported("signal");
+  }
+  signalWithStart(_workflow, _input, _runId, _signal, _opts) {
+    return tenantUnsupported("signalWithStart");
+  }
+  publishEvent(_name, _payload, _opts) {
+    return tenantUnsupported("publishEvent");
+  }
+};
+DurableStartClient = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
+    typeof StartRunDeps === "undefined" ? Object : StartRunDeps
+  ])
+], DurableStartClient);
+function tenantUnsupported(method) {
+  return Promise.reject(new Error(`${method}() is not available on a tenant worker (no store). Use the control plane for it.`));
+}
+__name(tenantUnsupported, "tenantUnsupported");
+
+// src/durable-worker.module.ts
+var import_durable_worker2 = require("@dudousxd/durable-worker");
+var import_nestjs_durable_core3 = require("@dudousxd/nestjs-durable-core");
+var import_common2 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
 // src/discovery-helpers.ts
@@ -175,7 +304,12 @@ function scanSteps(discovery, scanner, register) {
       if (typeof method !== "function") continue;
       const meta = getDurableStepMeta(method);
       if (!meta) continue;
-      const handler = /* @__PURE__ */ __name((input, log) => method.call(instance, input, log), "handler");
+      const boundMethod = method;
+      const handler = /* @__PURE__ */ __name(async (input, log) => {
+        const validInput = meta.input ? meta.input.parse(input) : input;
+        const output = await boundMethod.call(instance, validInput, log);
+        return meta.output ? meta.output.parse(output) : output;
+      }, "handler");
       register(meta, handler);
     }
   }
@@ -183,46 +317,54 @@ function scanSteps(discovery, scanner, register) {
 __name(scanSteps, "scanSteps");
 
 // src/durable-worker.module.ts
-function _ts_decorate(decorators, target, key, desc) {
+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_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
+__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_metadata, "_ts_metadata");
+__name(_ts_metadata2, "_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");
+function isPureThinWorker(options) {
+  return options.store === void 0 && options.connection !== void 0;
+}
+__name(isPureThinWorker, "isPureThinWorker");
 var ThinWorkflowRegistrar = class {
   static {
     __name(this, "ThinWorkflowRegistrar");
   }
   discovery;
   runtime;
-  constructor(discovery, runtime) {
+  options;
+  constructor(discovery, runtime, options) {
     this.discovery = discovery;
     this.runtime = runtime;
+    this.options = options;
   }
   onModuleInit() {
+    if (!isPureThinWorker(this.options)) return;
     scanWorkflows(this.discovery, (meta, instance) => this.runtime.registerWorkflow(meta.name, (ctx, input) => instance.run(ctx, input)));
   }
 };
-ThinWorkflowRegistrar = _ts_decorate([
-  (0, import_common.Injectable)(),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+ThinWorkflowRegistrar = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_param(2, (0, import_common2.Inject)(import_nestjs_durable_core3.DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
-    typeof import_durable_worker.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker.DurableWorkerRuntime
+    typeof import_durable_worker2.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker2.DurableWorkerRuntime,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], ThinWorkflowRegistrar);
 var ThinStepRegistrar = class {
@@ -232,22 +374,27 @@ var ThinStepRegistrar = class {
   discovery;
   metadataScanner;
   runtime;
-  constructor(discovery, metadataScanner, runtime) {
+  options;
+  constructor(discovery, metadataScanner, runtime, options) {
     this.discovery = discovery;
     this.metadataScanner = metadataScanner;
     this.runtime = runtime;
+    this.options = options;
   }
   onModuleInit() {
+    if (!isPureThinWorker(this.options)) return;
     scanSteps(this.discovery, this.metadataScanner, (meta, handler) => this.runtime.registerStep(meta.name, handler));
   }
 };
-ThinStepRegistrar = _ts_decorate([
-  (0, import_common.Injectable)(),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+ThinStepRegistrar = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_param(3, (0, import_common2.Inject)(import_nestjs_durable_core3.DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
     typeof import_core.MetadataScanner === "undefined" ? Object : import_core.MetadataScanner,
-    typeof import_durable_worker.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker.DurableWorkerRuntime
+    typeof import_durable_worker2.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker2.DurableWorkerRuntime,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], ThinStepRegistrar);
 var ThinWorkerBootstrap = class {
@@ -266,113 +413,139 @@ var ThinWorkerBootstrap = class {
     this.runnersSink = runnersSink;
   }
   async onApplicationBootstrap() {
-    for (const group of this.options.groups) {
-      const handle = await this.runRedisWorker({
-        runtime: this.runtime,
-        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.concurrencyByGroup?.[group] ?? this.options.concurrency) !== void 0 ? {
-          concurrency: this.options.concurrencyByGroup?.[group] ?? this.options.concurrency
-        } : {}
-      });
-      this.runners.push(handle);
-      this.runnersSink.push(handle);
-    }
+    const options = this.options;
+    if (!isPureThinWorker(options) || options.connection === void 0) return;
+    const handle = await this.runRedisWorker({
+      runtime: this.runtime,
+      connection: options.connection,
+      ...options.partition !== void 0 ? {
+        partition: options.partition
+      } : {},
+      ...options.prefix !== void 0 ? {
+        prefix: options.prefix
+      } : {},
+      ...options.instanceId !== void 0 ? {
+        instanceId: options.instanceId
+      } : {},
+      ...options.concurrency !== void 0 ? {
+        concurrency: options.concurrency
+      } : {}
+    });
+    this.runners.push(handle);
+    this.runnersSink.push(handle);
   }
   async onApplicationShutdown() {
     await Promise.allSettled(this.runners.map((h) => h.close()));
   }
 };
-ThinWorkerBootstrap = _ts_decorate([
-  (0, import_common.Injectable)(),
-  _ts_param(1, (0, import_common.Inject)(DURABLE_WORKER_OPTIONS)),
-  _ts_param(2, (0, import_common.Inject)(RUN_REDIS_WORKER)),
-  _ts_param(3, (0, import_common.Inject)(DURABLE_WORKER_RUNNERS)),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_durable_worker.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker.DurableWorkerRuntime,
-    typeof DurableWorkerModuleOptions === "undefined" ? Object : DurableWorkerModuleOptions,
+ThinWorkerBootstrap = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_param(1, (0, import_common2.Inject)(import_nestjs_durable_core3.DURABLE_OPTIONS_CANONICAL)),
+  _ts_param(2, (0, import_common2.Inject)(RUN_REDIS_WORKER)),
+  _ts_param(3, (0, import_common2.Inject)(DURABLE_WORKER_RUNNERS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof import_durable_worker2.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker2.DurableWorkerRuntime,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
     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: [
-        import_core.DiscoveryModule
-      ],
-      providers: [
-        optionsProvider,
-        {
-          provide: import_durable_worker.DurableWorkerRuntime,
-          useFactory: /* @__PURE__ */ __name(() => new import_durable_worker.DurableWorkerRuntime(), "useFactory")
-        },
-        {
-          provide: RUN_REDIS_WORKER,
-          useValue: import_durable_worker.runRedisWorker
-        },
-        {
-          provide: DURABLE_WORKER_RUNNERS,
-          useValue: []
-        },
-        ThinWorkflowRegistrar,
-        ThinStepRegistrar,
-        ThinWorkerBootstrap
-      ],
-      exports: [
-        import_durable_worker.DurableWorkerRuntime
+function thinWorkerProviders() {
+  return [
+    {
+      provide: import_durable_worker2.DurableWorkerRuntime,
+      // The runtime's `WorkflowWorker` falls back to its own `group` ctor param as the WORKFLOW's
+      // `workflowPartition` for any `ctx.step` call (see `workflow-context.ts`'s `resolveCallGroup`)
+      // — that fallback MUST equal this module's own `partition`, or a dispatched step's decision
+      // carries a mismatched token and the engine dispatches it to a queue nothing here subscribes
+      // to. Explicit `''` (never
+      // `undefined`) so it does NOT fall through to `WorkflowWorker`'s unrelated `'workflows'`
+      // default parameter.
+      useFactory: /* @__PURE__ */ __name((options) => new import_durable_worker2.DurableWorkerRuntime({
+        workflowGroup: options.partition ?? ""
+      }), "useFactory"),
+      inject: [
+        import_nestjs_durable_core3.DURABLE_OPTIONS_CANONICAL
       ]
-    };
-  }
-};
-DurableWorkerModule = _ts_decorate([
-  (0, import_common.Module)({})
-], DurableWorkerModule);
+    },
+    {
+      provide: RUN_REDIS_WORKER,
+      useValue: import_durable_worker2.runRedisWorker
+    },
+    {
+      provide: DURABLE_WORKER_RUNNERS,
+      useValue: []
+    },
+    ThinWorkflowRegistrar,
+    ThinStepRegistrar,
+    ThinWorkerBootstrap
+  ];
+}
+__name(thinWorkerProviders, "thinWorkerProviders");
+function tenantGatewayUnavailable(method) {
+  return Promise.reject(new Error(`RunGateway.${method}() is not available \u2014 pass \`transport\` to use RunGateway.`));
+}
+__name(tenantGatewayUnavailable, "tenantGatewayUnavailable");
+function unavailableRunGateway() {
+  return {
+    getRunDetail(_runId) {
+      return tenantGatewayUnavailable("getRunDetail");
+    },
+    listRuns(_query) {
+      return tenantGatewayUnavailable("listRuns");
+    },
+    cancel(_runId) {
+      return tenantGatewayUnavailable("cancel");
+    },
+    retry(_runId) {
+      return tenantGatewayUnavailable("retry");
+    },
+    continue(_runId) {
+      return tenantGatewayUnavailable("continue");
+    },
+    retryWithInput(_runId, _input) {
+      return tenantGatewayUnavailable("retryWithInput");
+    },
+    subscribe(_runId, _onEvent) {
+      throw new Error("RunGateway.subscribe() is not available \u2014 pass `transport` to use RunGateway.");
+    }
+  };
+}
+__name(unavailableRunGateway, "unavailableRunGateway");
 
 // src/durable.module.ts
-var import_nestjs_durable_core9 = require("@dudousxd/nestjs-durable-core");
-var import_common9 = require("@nestjs/common");
+var import_nestjs_durable_core12 = require("@dudousxd/nestjs-durable-core");
+var import_common12 = require("@nestjs/common");
 var import_core5 = require("@nestjs/core");
 
 // src/durable-step.registrar.ts
-var import_nestjs_durable_core2 = require("@dudousxd/nestjs-durable-core");
-var import_common2 = require("@nestjs/common");
+var import_nestjs_durable_core4 = require("@dudousxd/nestjs-durable-core");
+var import_common3 = require("@nestjs/common");
 var import_core2 = require("@nestjs/core");
-function _ts_decorate2(decorators, target, key, desc) {
+
+// src/role.ts
+function isOperatorRole(options) {
+  return options.store !== void 0;
+}
+__name(isOperatorRole, "isOperatorRole");
+function isDrivingOperator(options) {
+  return isOperatorRole(options) && options.drive !== false;
+}
+__name(isDrivingOperator, "isDrivingOperator");
+
+// src/durable-step.registrar.ts
+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_decorate2, "_ts_decorate");
-function _ts_metadata2(k, v) {
+__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_metadata2, "_ts_metadata");
+__name(_ts_metadata3, "_ts_metadata");
 function _ts_param2(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -398,18 +571,18 @@ var DurableStepRegistrar = class {
     this.options = options;
   }
   onModuleInit() {
-    if (this.options.worker === false) return;
+    if (!isDrivingOperator(this.options)) 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([
-  (0, import_common2.Injectable)(),
-  _ts_param2(2, (0, import_common2.Inject)(import_nestjs_durable_core2.TRANSPORT_CANONICAL)),
-  _ts_param2(3, (0, import_common2.Inject)(import_nestjs_durable_core2.DURABLE_OPTIONS_CANONICAL)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+DurableStepRegistrar = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_param2(2, (0, import_common3.Inject)(import_nestjs_durable_core4.TRANSPORT_CANONICAL)),
+  _ts_param2(3, (0, import_common3.Inject)(import_nestjs_durable_core4.DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
     typeof import_core2.DiscoveryService === "undefined" ? Object : import_core2.DiscoveryService,
     typeof import_core2.MetadataScanner === "undefined" ? Object : import_core2.MetadataScanner,
     Object,
@@ -418,20 +591,20 @@ DurableStepRegistrar = _ts_decorate2([
 ], DurableStepRegistrar);
 
 // src/entity.ts
-var import_nestjs_durable_core3 = require("@dudousxd/nestjs-durable-core");
-var import_common3 = require("@nestjs/common");
+var import_nestjs_durable_core5 = require("@dudousxd/nestjs-durable-core");
+var import_common4 = require("@nestjs/common");
 var import_reflect_metadata2 = require("reflect-metadata");
-function _ts_decorate3(decorators, target, key, desc) {
+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_decorate3, "_ts_decorate");
-function _ts_metadata3(k, v) {
+__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_metadata3, "_ts_metadata");
+__name(_ts_metadata4, "_ts_metadata");
 var ENTITY_METADATA = Symbol("nestjs-durable:entity");
 var ENTITY_ON_METADATA = Symbol("nestjs-durable:entity-on");
 function Entity(options) {
@@ -488,49 +661,54 @@ var EntityService = class {
     return this.engine.getEntityState(name, key);
   }
 };
-EntityService = _ts_decorate3([
-  (0, import_common3.Injectable)(),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
-    typeof import_nestjs_durable_core3.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core3.WorkflowEngine
+EntityService = _ts_decorate4([
+  (0, import_common4.Injectable)(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof import_nestjs_durable_core5.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core5.WorkflowEngine
   ])
 ], EntityService);
 
 // src/in-app-worker.ts
-var import_durable_worker2 = require("@dudousxd/durable-worker");
-var import_nestjs_durable_core4 = require("@dudousxd/nestjs-durable-core");
-var import_common4 = require("@nestjs/common");
+var import_durable_worker3 = require("@dudousxd/durable-worker");
+var import_nestjs_durable_core6 = require("@dudousxd/nestjs-durable-core");
+var import_common5 = require("@nestjs/common");
 var import_core3 = require("@nestjs/core");
-function _ts_decorate4(decorators, target, key, desc) {
+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_decorate4, "_ts_decorate");
-function _ts_metadata4(k, v) {
+__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_metadata4, "_ts_metadata");
+__name(_ts_metadata5, "_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 isCoLocatedWorker(options) {
+  return options.store !== void 0 && options.connection !== void 0;
+}
+__name(isCoLocatedWorker, "isCoLocatedWorker");
 function inAppWorkerBinding(transport, options) {
-  if (!options) return null;
+  if (!isCoLocatedWorker(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.");
+    throw new Error("a co-located worker (store + connection) 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 import_nestjs_durable_core4.RemoteWorkflowExecutor(transport, options.group)
+    transport,
+    ...options.partition !== void 0 ? {
+      partition: options.partition
+    } : {}
   };
 }
 __name(inAppWorkerBinding, "inAppWorkerBinding");
@@ -554,24 +732,27 @@ var InAppWorkerBootstrap = class {
     this.runnersSink = runnersSink;
   }
   onModuleInit() {
-    if (!this.options) return;
+    if (!isCoLocatedWorker(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 options = this.options;
+    if (!isCoLocatedWorker(options) || options.connection === void 0) 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
+      connection: options.connection,
+      ...options.partition !== void 0 ? {
+        partition: options.partition
+      } : {},
+      ...options.prefix !== void 0 ? {
+        prefix: options.prefix
       } : {},
-      ...this.options.instanceId !== void 0 ? {
-        instanceId: this.options.instanceId
+      ...options.instanceId !== void 0 ? {
+        instanceId: options.instanceId
       } : {},
-      ...this.options.concurrency !== void 0 ? {
-        concurrency: this.options.concurrency
+      ...options.concurrency !== void 0 ? {
+        concurrency: options.concurrency
       } : {}
     });
     this.runners.push(handle);
@@ -581,18 +762,18 @@ var InAppWorkerBootstrap = class {
     await Promise.allSettled(this.runners.map((handle) => handle.close()));
   }
 };
-InAppWorkerBootstrap = _ts_decorate4([
-  (0, import_common4.Injectable)(),
-  _ts_param3(2, (0, import_common4.Inject)(IN_APP_WORKER_OPTIONS)),
-  _ts_param3(3, (0, import_common4.Inject)(IN_APP_WORKER_RUNTIME)),
-  _ts_param3(4, (0, import_common4.Inject)(IN_APP_RUN_REDIS_WORKER)),
-  _ts_param3(5, (0, import_common4.Inject)(IN_APP_WORKER_RUNNERS)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+InAppWorkerBootstrap = _ts_decorate5([
+  (0, import_common5.Injectable)(),
+  _ts_param3(2, (0, import_common5.Inject)(import_nestjs_durable_core6.DURABLE_OPTIONS_CANONICAL)),
+  _ts_param3(3, (0, import_common5.Inject)(IN_APP_WORKER_RUNTIME)),
+  _ts_param3(4, (0, import_common5.Inject)(IN_APP_RUN_REDIS_WORKER)),
+  _ts_param3(5, (0, import_common5.Inject)(IN_APP_WORKER_RUNNERS)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
     typeof import_core3.DiscoveryService === "undefined" ? Object : import_core3.DiscoveryService,
     typeof import_core3.MetadataScanner === "undefined" ? Object : import_core3.MetadataScanner,
-    Object,
-    typeof import_durable_worker2.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker2.DurableWorkerRuntime,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
+    typeof import_durable_worker3.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker3.DurableWorkerRuntime,
     typeof RunRedisWorkerFn === "undefined" ? Object : RunRedisWorkerFn,
     Array
   ])
@@ -601,26 +782,31 @@ function inAppWorkerProviders() {
   return [
     {
       provide: IN_APP_WORKER_BINDING,
-      useFactory: /* @__PURE__ */ __name((transport, options) => inAppWorkerBinding(transport, options.inAppWorker ?? null), "useFactory"),
+      useFactory: /* @__PURE__ */ __name((transport, options) => inAppWorkerBinding(transport, options), "useFactory"),
       inject: [
-        import_nestjs_durable_core4.TRANSPORT_CANONICAL,
-        import_nestjs_durable_core4.DURABLE_OPTIONS_CANONICAL
+        import_nestjs_durable_core6.TRANSPORT_CANONICAL,
+        import_nestjs_durable_core6.DURABLE_OPTIONS_CANONICAL
       ]
     },
     {
-      provide: IN_APP_WORKER_OPTIONS,
-      useFactory: /* @__PURE__ */ __name((options) => options.inAppWorker ?? null, "useFactory"),
+      provide: IN_APP_WORKER_RUNTIME,
+      // The runtime's `WorkflowWorker` uses its `group` ctor param as the WORKFLOW's
+      // `workflowPartition` for any `ctx.step` call (see `workflow-context.ts`'s `resolveCallGroup`)
+      // — that fallback MUST equal this app's own `partition`, or a dispatched step's decision
+      // carries a mismatched token and the engine dispatches it to a queue nothing here subscribes
+      // to. Explicit `''` (never
+      // `undefined`) so it does NOT fall through to `WorkflowWorker`'s unrelated `'workflows'`
+      // default parameter.
+      useFactory: /* @__PURE__ */ __name((options) => new import_durable_worker3.DurableWorkerRuntime({
+        workflowGroup: options.partition ?? ""
+      }), "useFactory"),
       inject: [
-        import_nestjs_durable_core4.DURABLE_OPTIONS_CANONICAL
+        import_nestjs_durable_core6.DURABLE_OPTIONS_CANONICAL
       ]
     },
-    {
-      provide: IN_APP_WORKER_RUNTIME,
-      useFactory: /* @__PURE__ */ __name(() => new import_durable_worker2.DurableWorkerRuntime(), "useFactory")
-    },
     {
       provide: IN_APP_RUN_REDIS_WORKER,
-      useValue: import_durable_worker2.runRedisWorker
+      useValue: import_durable_worker3.runRedisWorker
     },
     {
       provide: IN_APP_WORKER_RUNNERS,
@@ -631,20 +817,142 @@ function inAppWorkerProviders() {
 }
 __name(inAppWorkerProviders, "inAppWorkerProviders");
 
+// src/proxy-run-gateway.ts
+var import_common6 = require("@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");
+var ProxyRunGateway = class {
+  static {
+    __name(this, "ProxyRunGateway");
+  }
+  transport;
+  tenant;
+  timeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  constructor(transport, tenant, timeoutMs = 1e4) {
+    this.transport = transport;
+    this.tenant = tenant;
+    this.timeoutMs = timeoutMs;
+    this.transport.onRunReply?.((reply) => this.handleReply(reply));
+  }
+  handleReply(reply) {
+    const pending = this.pending.get(reply.requestId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pending.delete(reply.requestId);
+    if (reply.result.ok) {
+      pending.resolve(reply.result.data);
+    } else {
+      pending.reject(new Error(reply.result.error.message));
+    }
+  }
+  request(body) {
+    return new Promise((resolve, reject) => {
+      const requestId = globalThis.crypto.randomUUID();
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`control plane did not respond to ${body.kind} within ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+      this.pending.set(requestId, {
+        resolve,
+        reject,
+        timer
+      });
+      this.transport.dispatchRunRequest?.({
+        requestId,
+        tenant: this.tenant,
+        body
+      }).catch((error) => {
+        const stillPending = this.pending.get(requestId);
+        if (!stillPending) return;
+        clearTimeout(stillPending.timer);
+        this.pending.delete(requestId);
+        stillPending.reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  }
+  getRunDetail(runId) {
+    return this.request({
+      kind: "getRunDetail",
+      runId
+    });
+  }
+  listRuns(query) {
+    return this.request({
+      kind: "listRuns",
+      query
+    });
+  }
+  cancel(runId, opts) {
+    return this.request(opts === void 0 ? {
+      kind: "cancel",
+      runId
+    } : {
+      kind: "cancel",
+      runId,
+      opts
+    });
+  }
+  retry(runId) {
+    return this.request({
+      kind: "retry",
+      runId
+    });
+  }
+  continue(runId) {
+    return this.request({
+      kind: "continue",
+      runId
+    });
+  }
+  retryWithInput(runId, input) {
+    return this.request({
+      kind: "retryWithInput",
+      runId,
+      input
+    });
+  }
+  subscribe(runId, onEvent) {
+    const unsubscribe = this.transport.onTenantEvent?.(this.tenant, (evt) => {
+      if (evt.event.runId === runId) onEvent(evt.event);
+    });
+    return unsubscribe ?? (() => {
+    });
+  }
+};
+ProxyRunGateway = _ts_decorate6([
+  (0, import_common6.Injectable)(),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof Transport === "undefined" ? Object : Transport,
+    String,
+    void 0
+  ])
+], ProxyRunGateway);
+
 // src/retention-poller.ts
-var import_nestjs_durable_core5 = require("@dudousxd/nestjs-durable-core");
-var import_common5 = require("@nestjs/common");
-function _ts_decorate5(decorators, target, key, desc) {
+var import_nestjs_durable_core7 = require("@dudousxd/nestjs-durable-core");
+var import_common7 = require("@nestjs/common");
+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_decorate5, "_ts_decorate");
-function _ts_metadata5(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_metadata5, "_ts_metadata");
+__name(_ts_metadata7, "_ts_metadata");
 function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -663,10 +971,10 @@ function validateRetention(retention) {
     if (policy.maxAge == null && policy.maxCount == null) {
       throw new Error("durable retention: each policy must set maxAge and/or maxCount");
     }
-    if (policy.maxAge != null) (0, import_nestjs_durable_core5.parseDuration)(policy.maxAge);
+    if (policy.maxAge != null) (0, import_nestjs_durable_core7.parseDuration)(policy.maxAge);
     for (const status of policy.statuses) {
-      if (!import_nestjs_durable_core5.TERMINAL_RUN_STATUSES.includes(status)) {
-        throw new Error(`durable retention: status "${status}" is not terminal; only ${import_nestjs_durable_core5.TERMINAL_RUN_STATUSES.join(", ")} can be pruned`);
+      if (!import_nestjs_durable_core7.TERMINAL_RUN_STATUSES.includes(status)) {
+        throw new Error(`durable retention: status "${status}" is not terminal; only ${import_nestjs_durable_core7.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`);
@@ -688,17 +996,24 @@ var RetentionPoller = class {
     this.store = store;
     this.options = options;
   }
+  /** Non-null once past the `isDrivingOperator` guard (which requires `options.store` to be set). */
+  requireStore() {
+    if (!this.store) {
+      throw new Error("unreachable: STATE_STORE_CANONICAL must resolve a store when options.store is set");
+    }
+    return this.store;
+  }
   async onApplicationBootstrap() {
-    if (this.options.worker === false) return;
+    if (!isDrivingOperator(this.options)) return;
     const retention = this.options.retention;
     if (!retention || retention.policies.length === 0) return;
     validateRetention(retention);
-    if (typeof this.store.pruneTerminalRuns !== "function") {
+    if (typeof this.requireStore().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 ? (0, import_nestjs_durable_core5.parseDuration)(retention.sweepInterval) : DEFAULT_SWEEP_INTERVAL_MS;
+    const intervalMs = retention.sweepInterval != null ? (0, import_nestjs_durable_core7.parseDuration)(retention.sweepInterval) : DEFAULT_SWEEP_INTERVAL_MS;
     if (intervalMs > 0) {
       this.timer = setInterval(() => void this.sweep(), intervalMs);
       this.timer.unref?.();
@@ -710,7 +1025,8 @@ var RetentionPoller = class {
   async sweep() {
     if (this.sweeping) return;
     const retention = this.options.retention;
-    const prune = this.store.pruneTerminalRuns;
+    const store = this.requireStore();
+    const prune = store.pruneTerminalRuns;
     if (!retention || typeof prune !== "function") return;
     this.sweeping = true;
     try {
@@ -718,7 +1034,7 @@ var RetentionPoller = class {
       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);
+          const deleted = await prune.call(store, policy, now, batchSize);
           if (deleted < batchSize) break;
         }
       }
@@ -727,37 +1043,244 @@ var RetentionPoller = class {
     }
   }
 };
-RetentionPoller = _ts_decorate5([
-  (0, import_common5.Injectable)(),
-  _ts_param4(0, (0, import_common5.Inject)(import_nestjs_durable_core5.STATE_STORE_CANONICAL)),
-  _ts_param4(1, (0, import_common5.Inject)(import_nestjs_durable_core5.DURABLE_OPTIONS_CANONICAL)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
-    typeof StateStore === "undefined" ? Object : StateStore,
+RetentionPoller = _ts_decorate7([
+  (0, import_common7.Injectable)(),
+  _ts_param4(0, (0, import_common7.Inject)(import_nestjs_durable_core7.STATE_STORE_CANONICAL)),
+  _ts_param4(1, (0, import_common7.Inject)(import_nestjs_durable_core7.DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    Object,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], RetentionPoller);
 
-// src/timer-poller.ts
-var import_nestjs_durable_core6 = require("@dudousxd/nestjs-durable-core");
-var import_common6 = require("@nestjs/common");
-function _ts_decorate6(decorators, target, key, desc) {
+// src/run-request-responder.ts
+var RunRequestResponder = class {
+  static {
+    __name(this, "RunRequestResponder");
+  }
+  transport;
+  gateway;
+  constructor(transport, gateway) {
+    this.transport = transport;
+    this.gateway = gateway;
+  }
+  /** Register the consumer on the transport. Each request is answered independently; a handler
+  *  failure never throws back into the transport (errors are captured into an error reply). */
+  start() {
+    this.transport.onRunRequest(async (msg) => {
+      const reply = await this.handle(msg);
+      await this.transport.publishRunReply(reply);
+    });
+  }
+  async handle(msg) {
+    const { body } = msg;
+    if (body.kind === "listRuns") {
+      const data = await this.gateway.listRuns({
+        ...body.query,
+        namespace: msg.tenant
+      });
+      return {
+        requestId: msg.requestId,
+        result: {
+          ok: true,
+          data
+        }
+      };
+    }
+    const detail = await this.gateway.getRunDetail(body.runId);
+    if (detail && detail.run.namespace !== msg.tenant) {
+      return {
+        requestId: msg.requestId,
+        result: {
+          ok: false,
+          error: {
+            message: "run belongs to another tenant",
+            code: "cross-tenant"
+          }
+        }
+      };
+    }
+    if (body.kind === "getRunDetail") {
+      return {
+        requestId: msg.requestId,
+        result: {
+          ok: true,
+          data: detail
+        }
+      };
+    }
+    try {
+      const data = await this.callVerb(body);
+      return {
+        requestId: msg.requestId,
+        result: {
+          ok: true,
+          data
+        }
+      };
+    } catch (err) {
+      return {
+        requestId: msg.requestId,
+        result: {
+          ok: false,
+          error: {
+            message: err instanceof Error ? err.message : String(err)
+          }
+        }
+      };
+    }
+  }
+  callVerb(body) {
+    switch (body.kind) {
+      case "cancel":
+        return this.gateway.cancel(body.runId, body.opts);
+      case "retry":
+        return this.gateway.retry(body.runId);
+      case "continue":
+        return this.gateway.continue(body.runId);
+      case "retryWithInput":
+        return this.gateway.retryWithInput(body.runId, body.input);
+    }
+  }
+};
+
+// src/store-run-gateway.ts
+var import_nestjs_durable_core8 = require("@dudousxd/nestjs-durable-core");
+var import_common8 = require("@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_decorate6, "_ts_decorate");
-function _ts_metadata6(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_metadata6, "_ts_metadata");
+__name(_ts_metadata8, "_ts_metadata");
 function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param5, "_ts_param");
+var StoreRunGateway = class {
+  static {
+    __name(this, "StoreRunGateway");
+  }
+  store;
+  engine;
+  constructor(store, engine) {
+    this.store = store;
+    this.engine = engine;
+  }
+  async getRunDetail(runId) {
+    const run = await this.store.getRun(runId);
+    if (!run) return null;
+    const [timeline, children] = await Promise.all([
+      this.store.listCheckpoints(runId),
+      this.engine.getRunChildren(runId)
+    ]);
+    return {
+      run,
+      timeline,
+      children
+    };
+  }
+  listRuns(query) {
+    return this.store.listRuns(query);
+  }
+  cancel(runId, opts) {
+    return this.engine.cancel(runId, opts);
+  }
+  /** Re-enqueue (dispatch model) instead of resuming inline — a worker picks the run up and replays it. */
+  retry(runId) {
+    return this.engine.requeue(runId);
+  }
+  continue(runId) {
+    return this.engine.continue(runId);
+  }
+  retryWithInput(runId, input) {
+    return this.engine.retryWithInput(runId, input);
+  }
+  subscribe(runId, onEvent) {
+    return this.engine.subscribe((event) => {
+      if (event.runId === runId) onEvent(event);
+    });
+  }
+};
+StoreRunGateway = _ts_decorate8([
+  (0, import_common8.Injectable)(),
+  _ts_param5(0, (0, import_common8.Inject)(import_nestjs_durable_core8.STATE_STORE_CANONICAL)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof import_nestjs_durable_core8.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core8.WorkflowEngine
+  ])
+], StoreRunGateway);
+
+// src/tenant-event-republisher.ts
+function isTerminalRunEvent(event) {
+  return event.type === "run.completed" || event.type === "run.failed";
+}
+__name(isTerminalRunEvent, "isTerminalRunEvent");
+var TenantEventRepublisher = class {
+  static {
+    __name(this, "TenantEventRepublisher");
+  }
+  store;
+  publish;
+  runNamespaces = /* @__PURE__ */ new Map();
+  constructor(store, publish) {
+    this.store = store;
+    this.publish = publish;
+  }
+  async handle(event) {
+    const namespace = await this.namespaceFor(event);
+    if (isTerminalRunEvent(event)) this.runNamespaces.delete(event.runId);
+    if (!namespace || namespace === "default") return;
+    await this.publish({
+      tenant: namespace,
+      event
+    }).catch(() => void 0);
+  }
+  async namespaceFor(event) {
+    if (this.runNamespaces.has(event.runId)) {
+      const cached = this.runNamespaces.get(event.runId);
+      return cached === null ? void 0 : cached;
+    }
+    if (event.namespace !== void 0) {
+      this.runNamespaces.set(event.runId, event.namespace === "default" ? null : event.namespace);
+      return event.namespace;
+    }
+    const run = await this.store.getRun(event.runId);
+    const tenantNamespace = run?.namespace !== void 0 && run.namespace !== "default" ? run.namespace : null;
+    this.runNamespaces.set(event.runId, tenantNamespace);
+    return tenantNamespace === null ? void 0 : tenantNamespace;
+  }
+};
+
+// src/timer-poller.ts
+var import_nestjs_durable_core9 = require("@dudousxd/nestjs-durable-core");
+var import_common9 = require("@nestjs/common");
+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 _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
 var TimerPoller = class {
   static {
     __name(this, "TimerPoller");
@@ -772,7 +1295,7 @@ var TimerPoller = class {
     this.options = options;
   }
   async onApplicationBootstrap() {
-    if (this.options.worker === false) return;
+    if (!isDrivingOperator(this.options)) return;
     this.unsubscribeEnqueued = this.engine.onEnqueued((runId) => void this.engine.runOne(runId));
     await this.poll();
     const intervalMs = this.options.timerPollMs ?? 1e3;
@@ -795,29 +1318,30 @@ var TimerPoller = class {
       await this.engine.sweepTimeouts();
       const schedules = this.options.schedules;
       if (schedules && schedules.length > 0) {
-        await (0, import_nestjs_durable_core6.runSchedules)(this.engine, schedules, Date.now());
+        await (0, import_nestjs_durable_core9.runSchedules)(this.engine, schedules, Date.now());
       }
     } finally {
       this.polling = false;
     }
   }
 };
-TimerPoller = _ts_decorate6([
-  (0, import_common6.Injectable)(),
-  _ts_param5(1, (0, import_common6.Inject)(import_nestjs_durable_core6.DURABLE_OPTIONS_CANONICAL)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
-    typeof import_nestjs_durable_core6.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core6.WorkflowEngine,
+TimerPoller = _ts_decorate9([
+  (0, import_common9.Injectable)(),
+  _ts_param6(1, (0, import_common9.Inject)(import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof import_nestjs_durable_core9.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core9.WorkflowEngine,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], TimerPoller);
 
 // src/tokens.ts
 var CONTEXT_ACCESSOR = Symbol.for("@dudousxd/nestjs-context:accessor");
+var RUN_GATEWAY = Symbol.for("nestjs-durable:run-gateway");
 
 // src/workflow.registrar.ts
-var import_nestjs_durable_core7 = require("@dudousxd/nestjs-durable-core");
-var import_common7 = require("@nestjs/common");
+var import_nestjs_durable_core10 = require("@dudousxd/nestjs-durable-core");
+var import_common10 = require("@nestjs/common");
 var import_core4 = require("@nestjs/core");
 
 // src/input-validation.ts
@@ -860,23 +1384,23 @@ function isStepInterceptor(target) {
 __name(isStepInterceptor, "isStepInterceptor");
 
 // src/workflow.registrar.ts
-function _ts_decorate7(decorators, target, key, desc) {
+function _ts_decorate10(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_decorate10, "_ts_decorate");
+function _ts_metadata10(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) {
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param6, "_ts_param");
+__name(_ts_param7, "_ts_param");
 var WorkflowRegistrar = class {
   static {
     __name(this, "WorkflowRegistrar");
@@ -896,13 +1420,15 @@ var WorkflowRegistrar = class {
     this.inAppWorker = inAppWorker;
   }
   async onApplicationBootstrap() {
-    if (this.options.worker === false) return;
+    if (!isDrivingOperator(this.options)) 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. */
+  *  AFTER the drain keeps the transport alive while in-flight runs dispatch/await their remote steps.
+  *  Operator only — a thin worker (no `store`) holds no engine to drain. */
   async onApplicationShutdown() {
+    if (!isOperatorRole(this.options)) return;
     await this.engine.drain(this.options.shutdownTimeoutMs);
     const transports = [
       this.options.transport,
@@ -911,8 +1437,13 @@ var WorkflowRegistrar = class {
     await Promise.allSettled(transports.map((t) => t?.close?.()));
   }
   async onModuleInit() {
+    if (!isOperatorRole(this.options)) return;
+    const store = this.store;
+    if (!store) {
+      throw new Error("unreachable: STATE_STORE_CANONICAL must resolve a store when options.store is set");
+    }
     if (this.options.autoSchema !== false) {
-      await this.store.ensureSchema?.();
+      await store.ensureSchema?.();
     }
     const deadLetterByWorkflow = /* @__PURE__ */ new Map();
     for (const wrapper of this.discovery.getProviders()) {
@@ -931,11 +1462,11 @@ var WorkflowRegistrar = class {
       const validateInput = meta.validateInput ?? (meta.inputSchema ? classValidatorInput(meta.inputSchema) : void 0);
       const eventBatch = meta.debounce ? {
         mode: "debounce",
-        windowMs: (0, import_nestjs_durable_core7.parseDuration)(meta.debounce)
+        windowMs: (0, import_nestjs_durable_core10.parseDuration)(meta.debounce)
       } : meta.batch ? {
         mode: "batch",
         maxSize: meta.batch.maxSize,
-        windowMs: (0, import_nestjs_durable_core7.parseDuration)(meta.batch.within)
+        windowMs: (0, import_nestjs_durable_core10.parseDuration)(meta.batch.within)
       } : void 0;
       const workflowCtor = workflow.constructor;
       this.engine.register(meta.name, meta.version, (ctx, input) => workflow.run(ctx, input), {
@@ -946,13 +1477,23 @@ var WorkflowRegistrar = class {
         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).
+        // so the engine dispatches its turns over the transport instead of running it inline; the
+        // co-located worker consumer (Task 5: one queue PER REGISTERED NAME) replays the same body.
+        // The routing token — and the executor that dispatches under it — MUST be keyed by THIS
+        // workflow's own name (`tenantGroup(sanitizeQueueToken(meta.name), partition)`), not a single
+        // group shared across every discovered `@Workflow`: a fixed shared token would dispatch every
+        // workflow's turns to one queue while the co-located worker subscribes one queue per name,
+        // so a turn dispatched under the wrong token would never be consumed. Absent → the inline fast
+        // path (unchanged).
         ...this.inAppWorker ? {
-          group: this.inAppWorker.group,
-          executor: this.inAppWorker.executor
+          group: (0, import_nestjs_durable_core10.tenantGroup)((0, import_nestjs_durable_core10.sanitizeQueueToken)(meta.name), this.inAppWorker.partition),
+          executor: new import_nestjs_durable_core10.RemoteWorkflowExecutor(this.inAppWorker.transport, meta.name, this.inAppWorker.partition)
         } : {}
       });
+      (0, import_nestjs_durable_core10.bindWorkflowClass)(workflowCtor, {
+        start: /* @__PURE__ */ __name((name, input, runId, opts) => this.engine.start(name, input, runId, opts), "start"),
+        waitForRun: /* @__PURE__ */ __name((runId, opts) => this.engine.waitForRun(runId, opts), "waitForRun")
+      });
       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.`);
@@ -962,7 +1503,7 @@ var WorkflowRegistrar = class {
         this.engine.register(dlqName, meta.version, inline);
         deadLetterByWorkflow.set(meta.name, dlqName);
       } else if (meta.deadLetterWorkflow) {
-        deadLetterByWorkflow.set(meta.name, (0, import_nestjs_durable_core7.workflowName)(meta.deadLetterWorkflow));
+        deadLetterByWorkflow.set(meta.name, (0, import_nestjs_durable_core10.workflowName)(meta.deadLetterWorkflow));
       }
     });
     this.installDeadLetterRouting(deadLetterByWorkflow);
@@ -984,31 +1525,40 @@ var WorkflowRegistrar = class {
   * a `dlq:<runId>` id, so re-recovery never double-dispatches.
   */
   installDeadLetterRouting(byWorkflow) {
-    const fallback = this.options.deadLetterWorkflow ? (0, import_nestjs_durable_core7.workflowName)(this.options.deadLetterWorkflow) : void 0;
+    const fallback = this.options.deadLetterWorkflow ? (0, import_nestjs_durable_core10.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);
+      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([
-  (0, import_common7.Injectable)(),
-  _ts_param6(3, (0, import_common7.Inject)(import_nestjs_durable_core7.STATE_STORE_CANONICAL)),
-  _ts_param6(4, (0, import_common7.Inject)(import_nestjs_durable_core7.DURABLE_OPTIONS_CANONICAL)),
-  _ts_param6(5, (0, import_common7.Inject)(IN_APP_WORKER_BINDING)),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
+WorkflowRegistrar = _ts_decorate10([
+  (0, import_common10.Injectable)(),
+  _ts_param7(3, (0, import_common10.Inject)(import_nestjs_durable_core10.STATE_STORE_CANONICAL)),
+  _ts_param7(4, (0, import_common10.Inject)(import_nestjs_durable_core10.DURABLE_OPTIONS_CANONICAL)),
+  _ts_param7(5, (0, import_common10.Inject)(IN_APP_WORKER_BINDING)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof import_core4.DiscoveryService === "undefined" ? Object : import_core4.DiscoveryService,
     typeof import_core4.MetadataScanner === "undefined" ? Object : import_core4.MetadataScanner,
-    typeof import_nestjs_durable_core7.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core7.WorkflowEngine,
-    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof import_nestjs_durable_core10.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core10.WorkflowEngine,
+    Object,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
     Object
   ])
@@ -1016,19 +1566,19 @@ WorkflowRegistrar = _ts_decorate7([
 
 // src/workflow.service.ts
 var import_node_crypto = require("crypto");
-var import_nestjs_durable_core8 = require("@dudousxd/nestjs-durable-core");
-var import_common8 = require("@nestjs/common");
-function _ts_decorate8(decorators, target, key, desc) {
+var import_nestjs_durable_core11 = require("@dudousxd/nestjs-durable-core");
+var import_common11 = require("@nestjs/common");
+function _ts_decorate11(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) {
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata11(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata8, "_ts_metadata");
+__name(_ts_metadata11, "_ts_metadata");
 var WorkflowService = class {
   static {
     __name(this, "WorkflowService");
@@ -1060,7 +1610,7 @@ var WorkflowService = class {
   }
   /**
   * 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
+  * starts a fresh run of every workflow subscribed via `@Workflow({ onEvent })` / `@OnDurableEvent` (the
   * payload becomes its input). Pass `opts.id` to dedupe redeliveries. Returns how many runs it
   * touched (resumed + started).
   */
@@ -1068,22 +1618,32 @@ var WorkflowService = class {
     return this.engine.publishEvent(name, payload, opts);
   }
 };
-WorkflowService = _ts_decorate8([
-  (0, import_common8.Injectable)(),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
-    typeof import_nestjs_durable_core8.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core8.WorkflowEngine
+WorkflowService = _ts_decorate11([
+  (0, import_common11.Injectable)(),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof import_nestjs_durable_core11.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core11.WorkflowEngine
   ])
 ], WorkflowService);
 
 // src/durable.module.ts
-function _ts_decorate9(decorators, target, key, desc) {
+function _ts_decorate12(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");
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
 function resolveAccessor(moduleRef) {
   try {
     return moduleRef.get(CONTEXT_ACCESSOR, {
@@ -1123,20 +1683,103 @@ 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(store, options) {
+  if (options.scopeReads !== true || options.namespace === void 0) return store;
+  if (!isScopeableStore(store)) return store;
+  return store.withScope({
+    namespace: options.namespace
+  });
+}
+__name(scopedStore, "scopedStore");
+function assertValidRole(options) {
+  const hasStore = options.store !== void 0;
+  const hasConnection = options.connection !== void 0;
+  if (!hasStore && !hasConnection) {
+    throw new Error("a durable module needs either a `store` (operator) or a `connection` (worker)");
+  }
+  if (hasStore && options.transport === void 0) {
+    throw new Error("an operator (`store`) needs a `transport`");
+  }
+}
+__name(assertValidRole, "assertValidRole");
+var RunGatewayBootstrap = class RunGatewayBootstrap2 {
+  static {
+    __name(this, "RunGatewayBootstrap");
+  }
+  engine;
+  transport;
+  gateway;
+  store;
+  options;
+  unsubscribe;
+  constructor(engine, transport, gateway, store, options) {
+    this.engine = engine;
+    this.transport = transport;
+    this.gateway = gateway;
+    this.store = store;
+    this.options = options;
+  }
+  onApplicationBootstrap() {
+    if (!isDrivingOperator(this.options) || !this.transport) return;
+    const store = this.store;
+    if (!store) return;
+    const { onRunRequest, publishRunReply, publishTenantEvent } = this.transport;
+    if (typeof onRunRequest === "function" && typeof publishRunReply === "function") {
+      const runRequestTransport = {
+        onRunRequest: onRunRequest.bind(this.transport),
+        publishRunReply: publishRunReply.bind(this.transport)
+      };
+      new RunRequestResponder(runRequestTransport, this.gateway).start();
+    }
+    if (typeof publishTenantEvent === "function") {
+      const republisher = new TenantEventRepublisher(store, publishTenantEvent.bind(this.transport));
+      this.unsubscribe = this.engine.subscribe((event) => {
+        void republisher.handle(event);
+      });
+    }
+  }
+  onModuleDestroy() {
+    this.unsubscribe?.();
+  }
+};
+RunGatewayBootstrap = _ts_decorate12([
+  (0, import_common12.Injectable)(),
+  _ts_param8(1, (0, import_common12.Inject)(import_nestjs_durable_core12.TRANSPORT_CANONICAL)),
+  _ts_param8(2, (0, import_common12.Inject)(RUN_GATEWAY)),
+  _ts_param8(3, (0, import_common12.Inject)(import_nestjs_durable_core12.STATE_STORE_CANONICAL)),
+  _ts_param8(4, (0, import_common12.Inject)(import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof import_nestjs_durable_core12.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core12.WorkflowEngine,
+    Object,
+    typeof RunGateway === "undefined" ? Object : RunGateway,
+    Object,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
+  ])
+], RunGatewayBootstrap);
 var DurableModule = class _DurableModule {
   static {
     __name(this, "DurableModule");
   }
   static forRoot(options) {
+    assertValidRole(options);
     return _DurableModule.build({
-      provide: import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL,
+      provide: import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL,
       useValue: options
     });
   }
   static forRootAsync(options) {
     return _DurableModule.build({
-      provide: import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL,
-      useFactory: options.useFactory,
+      provide: import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL,
+      useFactory: /* @__PURE__ */ __name(async (...args) => {
+        const resolved = await options.useFactory(...args);
+        assertValidRole(resolved);
+        return resolved;
+      }, "useFactory"),
       inject: options.inject ?? []
     });
   }
@@ -1150,71 +1793,83 @@ var DurableModule = class _DurableModule {
       providers: [
         optionsProvider,
         {
-          provide: import_nestjs_durable_core9.STATE_STORE_CANONICAL,
-          useFactory: /* @__PURE__ */ __name((options) => options.store, "useFactory"),
+          provide: import_nestjs_durable_core12.STATE_STORE_CANONICAL,
+          useFactory: /* @__PURE__ */ __name((options) => options.store !== void 0 ? scopedStore(options.store, options) : null, "useFactory"),
           inject: [
-            import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL
+            import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL
           ]
         },
         {
-          provide: import_nestjs_durable_core9.TRANSPORT_CANONICAL,
+          provide: import_nestjs_durable_core12.TRANSPORT_CANONICAL,
           useFactory: /* @__PURE__ */ __name((options) => options.transport ?? null, "useFactory"),
           inject: [
-            import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL
+            import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL
           ]
         },
         // Legacy back-compat aliases (deprecated tokens still resolve to the same instances):
         {
-          provide: import_nestjs_durable_core9.STATE_STORE,
-          useExisting: import_nestjs_durable_core9.STATE_STORE_CANONICAL
+          provide: import_nestjs_durable_core12.STATE_STORE,
+          useExisting: import_nestjs_durable_core12.STATE_STORE_CANONICAL
         },
         {
-          provide: import_nestjs_durable_core9.TRANSPORT,
-          useExisting: import_nestjs_durable_core9.TRANSPORT_CANONICAL
+          provide: import_nestjs_durable_core12.TRANSPORT,
+          useExisting: import_nestjs_durable_core12.TRANSPORT_CANONICAL
         },
         {
-          provide: import_nestjs_durable_core9.DURABLE_OPTIONS,
-          useExisting: import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL
+          provide: import_nestjs_durable_core12.DURABLE_OPTIONS,
+          useExisting: import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL
         },
         {
-          provide: import_nestjs_durable_core9.WorkflowEngine,
-          useFactory: /* @__PURE__ */ __name(async (store, transport, opts, moduleRef) => {
-            const primary = transport ?? opts.transports?.[0]?.transport;
+          // Shared token, bound EXACTLY once: a real engine for the operator role, or a store-less
+          // `DurableStartClient` facade for a thin worker (no `store`) — either way, `WorkflowService`
+          // and app code call `engine.start(...)` unchanged.
+          provide: import_nestjs_durable_core12.WorkflowEngine,
+          useFactory: /* @__PURE__ */ __name(async (options, store, transport, moduleRef) => {
+            if (options.store === void 0) {
+              return new DurableStartClient(options);
+            }
+            if (!store) {
+              throw new Error("unreachable: STATE_STORE_CANONICAL must resolve a store when options.store is set");
+            }
+            const primary = transport ?? options.transports?.[0]?.transport;
             const accessor = resolveAccessor(moduleRef);
-            const context = opts.context ?? (accessor ? () => carrierFromAccessor(accessor) : void 0);
+            const context = options.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 import_nestjs_durable_core9.WorkflowEngine({
+            const engine = new import_nestjs_durable_core12.WorkflowEngine({
               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,
-              webhookUrl: opts.webhookUrl,
-              traceparent: opts.traceparent,
+              transports: options.transports,
+              controlPlane: options.controlPlane ?? (isControlPlane(primary) ? primary : void 0),
+              leaseMs: options.leaseMs,
+              admission: options.admission,
+              maxRecoveryAttempts: options.maxRecoveryAttempts,
+              remoteAdvanceSilenceMs: options.remoteAdvanceSilenceMs,
+              instanceId: options.instanceId,
+              namespace: options.namespace,
+              webhookUrl: options.webhookUrl,
+              traceparent: options.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 ? {
+              compensationRetries: options.compensationRetries,
+              // A non-driving (dashboard/API) operator must not run workflows: enqueue-only, leaving
+              // each `pending` run in the store for a DRIVING instance's poll. A driving operator gets
+              // the engine's default in-process dispatcher: for a body registered inline, it runs
+              // locally; for one registered GROUP-SERVED (co-located worker) or left unregistered, the
+              // SAME default dispatcher routes it out remotely (group-served executor, or convention
+              // dispatch — always on) instead.
+              runDispatcher: options.drive === false ? {
                 dispatch: /* @__PURE__ */ __name(() => {
                 }, "dispatch")
               } : void 0
             });
-            for (const queue of opts.queues ?? []) engine.registerQueue(queue);
+            for (const queue of options.queues ?? []) engine.registerQueue(queue);
             return engine;
           }, "useFactory"),
           inject: [
-            import_nestjs_durable_core9.STATE_STORE_CANONICAL,
-            import_nestjs_durable_core9.TRANSPORT_CANONICAL,
-            import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL,
+            import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL,
+            import_nestjs_durable_core12.STATE_STORE_CANONICAL,
+            import_nestjs_durable_core12.TRANSPORT_CANONICAL,
             import_core5.ModuleRef
           ]
         },
@@ -1224,54 +1879,83 @@ var DurableModule = class _DurableModule {
         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()
+        // Tenant run gateway: bound EXACTLY once — the store-backed `StoreRunGateway` for an operator,
+        // or (for a thin worker, no `store`) a `ProxyRunGateway` over `transport` when given, else a
+        // gateway whose every method rejects with a clear tenant error.
+        {
+          provide: RUN_GATEWAY,
+          useFactory: /* @__PURE__ */ __name((options, store, engine) => {
+            if (options.store !== void 0) {
+              if (!store) {
+                throw new Error("unreachable: STATE_STORE_CANONICAL must resolve a store when options.store is set");
+              }
+              return new StoreRunGateway(store, engine);
+            }
+            return options.transport ? new ProxyRunGateway(options.transport, options.partition ?? "default", options.runGatewayTimeoutMs) : unavailableRunGateway();
+          }, "useFactory"),
+          inject: [
+            import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL,
+            import_nestjs_durable_core12.STATE_STORE_CANONICAL,
+            import_nestjs_durable_core12.WorkflowEngine
+          ]
+        },
+        RunGatewayBootstrap,
+        // Co-located in-app worker (uniform dispatch): inert unless BOTH `store` and `connection` are
+        // set — see `in-app-worker.ts`.
+        ...inAppWorkerProviders(),
+        // Pure thin-worker consumer: inert unless `connection` is set WITHOUT `store` — see
+        // `durable-worker.module.ts`.
+        ...thinWorkerProviders()
       ],
       exports: [
         WorkflowService,
         EntityService,
-        import_nestjs_durable_core9.WorkflowEngine,
-        import_nestjs_durable_core9.STATE_STORE,
-        import_nestjs_durable_core9.STATE_STORE_CANONICAL,
-        import_nestjs_durable_core9.TRANSPORT,
-        import_nestjs_durable_core9.TRANSPORT_CANONICAL,
-        import_nestjs_durable_core9.DURABLE_OPTIONS_CANONICAL
+        import_nestjs_durable_core12.WorkflowEngine,
+        import_nestjs_durable_core12.STATE_STORE,
+        import_nestjs_durable_core12.STATE_STORE_CANONICAL,
+        import_nestjs_durable_core12.TRANSPORT,
+        import_nestjs_durable_core12.TRANSPORT_CANONICAL,
+        import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL,
+        RUN_GATEWAY
       ]
     };
   }
 };
-DurableModule = _ts_decorate9([
-  (0, import_common9.Module)({})
+DurableModule = _ts_decorate12([
+  (0, import_common12.Module)({})
 ], DurableModule);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CONTEXT_ACCESSOR,
   DEAD_LETTER_METADATA,
   DURABLE_STEP_METADATA,
-  DURABLE_WORKER_OPTIONS,
   DURABLE_WORKER_RUNNERS,
   DeadLetter,
   DurableModule,
+  DurableStartClient,
   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,
+  OnDurableEvent,
   OnEvent,
+  ProxyRunGateway,
+  RUN_GATEWAY,
   RUN_REDIS_WORKER,
+  RunRequestResponder,
   STEP_INTERCEPTOR_METADATA,
   Step,
   StepInterceptor,
+  StoreRunGateway,
+  TenantEventRepublisher,
   ThinStepRegistrar,
   ThinWorkerBootstrap,
   ThinWorkflowRegistrar,
@@ -1285,6 +1969,10 @@ DurableModule = _ts_decorate9([
   getWorkflowMeta,
   inAppWorkerProviders,
   isDeadLetterHandler,
-  isStepInterceptor
+  isDrivingOperator,
+  isOperatorRole,
+  isStepInterceptor,
+  thinWorkerProviders,
+  unavailableRunGateway
 });
 //# sourceMappingURL=index.cjs.map