@dudousxd/nestjs-durable 0.26.0 → 0.27.0

package/dist/index.js

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/decorators.ts
-import { WORKFLOW_NAME_KEY } from "@dudousxd/nestjs-durable-core";
+import { DURABLE_STEP_CONFIG, DURABLE_STEP_NAME, WORKFLOW_NAME_KEY } from "@dudousxd/nestjs-durable-core";
 import "reflect-metadata";
 var WORKFLOW_METADATA = Symbol("nestjs-durable:workflow");
 function Workflow(options) {
@@ -39,12 +39,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[DURABLE_STEP_NAME] = derivedName;
+    const config = stepConfigFrom(options);
+    if (config !== void 0) {
+      descriptor.value[DURABLE_STEP_CONFIG] = config;
+    }
     return descriptor;
   };
 }
@@ -88,10 +112,106 @@ function getOnEvents(meta, target) {
 }
 __name(getOnEvents, "getOnEvents");
 
+// src/durable-start-client.ts
+import { startRun } from "@dudousxd/durable-worker";
+import { workflowName } from "@dudousxd/nestjs-durable-core";
+import { Injectable } from "@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 = workflowName(workflow);
+    await 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([
+  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
 import { DurableWorkerRuntime, runRedisWorker as defaultRunRedisWorker } from "@dudousxd/durable-worker";
-import { Inject, Injectable, Module } from "@nestjs/common";
-import { DiscoveryModule, DiscoveryService, MetadataScanner } from "@nestjs/core";
+import { DURABLE_OPTIONS_CANONICAL } from "@dudousxd/nestjs-durable-core";
+import { Inject, Injectable as Injectable2 } from "@nestjs/common";
+import { DiscoveryService, MetadataScanner } from "@nestjs/core";
 
 // src/discovery-helpers.ts
 function scanWorkflows(discovery, register) {
@@ -118,7 +238,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);
     }
   }
@@ -126,46 +251,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([
-  Injectable(),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+ThinWorkflowRegistrar = _ts_decorate2([
+  Injectable2(),
+  _ts_param(2, Inject(DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
-    typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime
+    typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], ThinWorkflowRegistrar);
 var ThinStepRegistrar = class {
@@ -175,22 +308,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([
-  Injectable(),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+ThinStepRegistrar = _ts_decorate2([
+  Injectable2(),
+  _ts_param(3, Inject(DURABLE_OPTIONS_CANONICAL)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
     typeof MetadataScanner === "undefined" ? Object : MetadataScanner,
-    typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime
+    typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], ThinStepRegistrar);
 var ThinWorkerBootstrap = class {
@@ -209,113 +347,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([
-  Injectable(),
-  _ts_param(1, Inject(DURABLE_WORKER_OPTIONS)),
+ThinWorkerBootstrap = _ts_decorate2([
+  Injectable2(),
+  _ts_param(1, Inject(DURABLE_OPTIONS_CANONICAL)),
   _ts_param(2, Inject(RUN_REDIS_WORKER)),
   _ts_param(3, Inject(DURABLE_WORKER_RUNNERS)),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof DurableWorkerRuntime === "undefined" ? Object : DurableWorkerRuntime,
-    typeof DurableWorkerModuleOptions === "undefined" ? Object : DurableWorkerModuleOptions,
+    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: [
-        DiscoveryModule
-      ],
-      providers: [
-        optionsProvider,
-        {
-          provide: DurableWorkerRuntime,
-          useFactory: /* @__PURE__ */ __name(() => new DurableWorkerRuntime(), "useFactory")
-        },
-        {
-          provide: RUN_REDIS_WORKER,
-          useValue: defaultRunRedisWorker
-        },
-        {
-          provide: DURABLE_WORKER_RUNNERS,
-          useValue: []
-        },
-        ThinWorkflowRegistrar,
-        ThinStepRegistrar,
-        ThinWorkerBootstrap
-      ],
-      exports: [
-        DurableWorkerRuntime
+function thinWorkerProviders() {
+  return [
+    {
+      provide: 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 DurableWorkerRuntime({
+        workflowGroup: options.partition ?? ""
+      }), "useFactory"),
+      inject: [
+        DURABLE_OPTIONS_CANONICAL
       ]
-    };
-  }
-};
-DurableWorkerModule = _ts_decorate([
-  Module({})
-], DurableWorkerModule);
+    },
+    {
+      provide: RUN_REDIS_WORKER,
+      useValue: defaultRunRedisWorker
+    },
+    {
+      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
-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";
+import { DURABLE_OPTIONS, DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL7, STATE_STORE, STATE_STORE_CANONICAL as STATE_STORE_CANONICAL4, TRANSPORT, TRANSPORT_CANONICAL as TRANSPORT_CANONICAL3, WorkflowEngine as WorkflowEngine6 } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject8, Injectable as Injectable12, Module } from "@nestjs/common";
+import { DiscoveryModule, ModuleRef } from "@nestjs/core";
 
 // src/durable-step.registrar.ts
-import { DURABLE_OPTIONS_CANONICAL, TRANSPORT_CANONICAL } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject2, Injectable as Injectable2 } from "@nestjs/common";
+import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL2, TRANSPORT_CANONICAL } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject2, Injectable as Injectable3 } from "@nestjs/common";
 import { DiscoveryService as DiscoveryService2, MetadataScanner as MetadataScanner2 } from "@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);
@@ -341,18 +505,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([
-  Injectable2(),
+DurableStepRegistrar = _ts_decorate3([
+  Injectable3(),
   _ts_param2(2, Inject2(TRANSPORT_CANONICAL)),
-  _ts_param2(3, Inject2(DURABLE_OPTIONS_CANONICAL)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _ts_param2(3, Inject2(DURABLE_OPTIONS_CANONICAL2)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
     typeof DiscoveryService2 === "undefined" ? Object : DiscoveryService2,
     typeof MetadataScanner2 === "undefined" ? Object : MetadataScanner2,
     Object,
@@ -362,19 +526,19 @@ DurableStepRegistrar = _ts_decorate2([
 
 // src/entity.ts
 import { WorkflowEngine } from "@dudousxd/nestjs-durable-core";
-import { Injectable as Injectable3 } from "@nestjs/common";
+import { Injectable as Injectable4 } from "@nestjs/common";
 import "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) {
@@ -431,49 +595,54 @@ var EntityService = class {
     return this.engine.getEntityState(name, key);
   }
 };
-EntityService = _ts_decorate3([
-  Injectable3(),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+EntityService = _ts_decorate4([
+  Injectable4(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     typeof WorkflowEngine === "undefined" ? Object : WorkflowEngine
   ])
 ], EntityService);
 
 // src/in-app-worker.ts
 import { DurableWorkerRuntime as DurableWorkerRuntime2, runRedisWorker as defaultRunRedisWorker2 } from "@dudousxd/durable-worker";
-import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL2, RemoteWorkflowExecutor, TRANSPORT_CANONICAL as TRANSPORT_CANONICAL2 } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject3, Injectable as Injectable4 } from "@nestjs/common";
+import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL3, TRANSPORT_CANONICAL as TRANSPORT_CANONICAL2 } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject3, Injectable as Injectable5 } from "@nestjs/common";
 import { DiscoveryService as DiscoveryService3, MetadataScanner as MetadataScanner3 } from "@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 RemoteWorkflowExecutor(transport, options.group)
+    transport,
+    ...options.partition !== void 0 ? {
+      partition: options.partition
+    } : {}
   };
 }
 __name(inAppWorkerBinding, "inAppWorkerBinding");
@@ -497,24 +666,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);
@@ -524,17 +696,17 @@ var InAppWorkerBootstrap = class {
     await Promise.allSettled(this.runners.map((handle) => handle.close()));
   }
 };
-InAppWorkerBootstrap = _ts_decorate4([
-  Injectable4(),
-  _ts_param3(2, Inject3(IN_APP_WORKER_OPTIONS)),
+InAppWorkerBootstrap = _ts_decorate5([
+  Injectable5(),
+  _ts_param3(2, Inject3(DURABLE_OPTIONS_CANONICAL3)),
   _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", [
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
     typeof DiscoveryService3 === "undefined" ? Object : DiscoveryService3,
     typeof MetadataScanner3 === "undefined" ? Object : MetadataScanner3,
-    Object,
+    typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
     typeof DurableWorkerRuntime2 === "undefined" ? Object : DurableWorkerRuntime2,
     typeof RunRedisWorkerFn === "undefined" ? Object : RunRedisWorkerFn,
     Array
@@ -544,23 +716,28 @@ 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: [
         TRANSPORT_CANONICAL2,
-        DURABLE_OPTIONS_CANONICAL2
+        DURABLE_OPTIONS_CANONICAL3
       ]
     },
     {
-      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 DurableWorkerRuntime2({
+        workflowGroup: options.partition ?? ""
+      }), "useFactory"),
       inject: [
-        DURABLE_OPTIONS_CANONICAL2
+        DURABLE_OPTIONS_CANONICAL3
       ]
     },
-    {
-      provide: IN_APP_WORKER_RUNTIME,
-      useFactory: /* @__PURE__ */ __name(() => new DurableWorkerRuntime2(), "useFactory")
-    },
     {
       provide: IN_APP_RUN_REDIS_WORKER,
       useValue: defaultRunRedisWorker2
@@ -574,20 +751,142 @@ function inAppWorkerProviders() {
 }
 __name(inAppWorkerProviders, "inAppWorkerProviders");
 
+// src/proxy-run-gateway.ts
+import { Injectable as Injectable6 } from "@nestjs/common";
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+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([
+  Injectable6(),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof Transport === "undefined" ? Object : Transport,
+    String,
+    void 0
+  ])
+], ProxyRunGateway);
+
 // 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) {
+import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL4, STATE_STORE_CANONICAL, TERMINAL_RUN_STATUSES, parseDuration } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject4, Injectable as Injectable7 } from "@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);
@@ -631,12 +930,19 @@ 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;
     }
@@ -653,7 +959,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 {
@@ -661,7 +968,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;
         }
       }
@@ -670,37 +977,244 @@ var RetentionPoller = class {
     }
   }
 };
-RetentionPoller = _ts_decorate5([
-  Injectable5(),
+RetentionPoller = _ts_decorate7([
+  Injectable7(),
   _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,
+  _ts_param4(1, Inject4(DURABLE_OPTIONS_CANONICAL4)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    Object,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], RetentionPoller);
 
-// src/timer-poller.ts
-import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL4, WorkflowEngine as WorkflowEngine2, runSchedules } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject5, Injectable as Injectable6 } from "@nestjs/common";
-function _ts_decorate6(decorators, target, key, desc) {
+// 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
+import { STATE_STORE_CANONICAL as STATE_STORE_CANONICAL2, WorkflowEngine as WorkflowEngine2 } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject5, 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_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([
+  Injectable8(),
+  _ts_param5(0, Inject5(STATE_STORE_CANONICAL2)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof WorkflowEngine2 === "undefined" ? Object : WorkflowEngine2
+  ])
+], 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
+import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL5, WorkflowEngine as WorkflowEngine3, runSchedules } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject6, Injectable as Injectable9 } from "@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");
@@ -715,7 +1229,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;
@@ -745,22 +1259,23 @@ var TimerPoller = class {
     }
   }
 };
-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,
+TimerPoller = _ts_decorate9([
+  Injectable9(),
+  _ts_param6(1, Inject6(DURABLE_OPTIONS_CANONICAL5)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof WorkflowEngine3 === "undefined" ? Object : WorkflowEngine3,
     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
-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 { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL6, RemoteWorkflowExecutor, STATE_STORE_CANONICAL as STATE_STORE_CANONICAL3, WorkflowEngine as WorkflowEngine4, parseDuration as parseDuration2, sanitizeQueueToken, tenantGroup, workflowName as workflowName2 } from "@dudousxd/nestjs-durable-core";
+import { Inject as Inject7, Injectable as Injectable10 } from "@nestjs/common";
 import { DiscoveryService as DiscoveryService4, MetadataScanner as MetadataScanner4 } from "@nestjs/core";
 
 // src/input-validation.ts
@@ -803,23 +1318,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");
@@ -839,13 +1354,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,
@@ -854,8 +1371,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()) {
@@ -889,11 +1411,17 @@ 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: tenantGroup(sanitizeQueueToken(meta.name), this.inAppWorker.partition),
+          executor: new RemoteWorkflowExecutor(this.inAppWorker.transport, meta.name, this.inAppWorker.partition)
         } : {}
       });
       const inline = this.findDeadLetterHandler(workflow);
@@ -905,7 +1433,7 @@ var WorkflowRegistrar = class {
         this.engine.register(dlqName, meta.version, inline);
         deadLetterByWorkflow.set(meta.name, dlqName);
       } else if (meta.deadLetterWorkflow) {
-        deadLetterByWorkflow.set(meta.name, workflowName(meta.deadLetterWorkflow));
+        deadLetterByWorkflow.set(meta.name, workflowName2(meta.deadLetterWorkflow));
       }
     });
     this.installDeadLetterRouting(deadLetterByWorkflow);
@@ -927,31 +1455,40 @@ var WorkflowRegistrar = class {
   * a `dlq:<runId>` id, so re-recovery never double-dispatches.
   */
   installDeadLetterRouting(byWorkflow) {
-    const fallback = this.options.deadLetterWorkflow ? workflowName(this.options.deadLetterWorkflow) : void 0;
+    const fallback = this.options.deadLetterWorkflow ? workflowName2(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([
-  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", [
+WorkflowRegistrar = _ts_decorate10([
+  Injectable10(),
+  _ts_param7(3, Inject7(STATE_STORE_CANONICAL3)),
+  _ts_param7(4, Inject7(DURABLE_OPTIONS_CANONICAL6)),
+  _ts_param7(5, Inject7(IN_APP_WORKER_BINDING)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof DiscoveryService4 === "undefined" ? Object : DiscoveryService4,
     typeof MetadataScanner4 === "undefined" ? Object : MetadataScanner4,
-    typeof WorkflowEngine3 === "undefined" ? Object : WorkflowEngine3,
-    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof WorkflowEngine4 === "undefined" ? Object : WorkflowEngine4,
+    Object,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
     Object
   ])
@@ -959,19 +1496,19 @@ WorkflowRegistrar = _ts_decorate7([
 
 // src/workflow.service.ts
 import { randomUUID } from "node:crypto";
-import { WorkflowEngine as WorkflowEngine4 } from "@dudousxd/nestjs-durable-core";
-import { Injectable as Injectable8 } from "@nestjs/common";
-function _ts_decorate8(decorators, target, key, desc) {
+import { WorkflowEngine as WorkflowEngine5 } from "@dudousxd/nestjs-durable-core";
+import { Injectable as Injectable11 } from "@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");
@@ -1011,22 +1548,32 @@ var WorkflowService = class {
     return this.engine.publishEvent(name, payload, opts);
   }
 };
-WorkflowService = _ts_decorate8([
-  Injectable8(),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
-    typeof WorkflowEngine4 === "undefined" ? Object : WorkflowEngine4
+WorkflowService = _ts_decorate11([
+  Injectable11(),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof WorkflowEngine5 === "undefined" ? Object : WorkflowEngine5
   ])
 ], 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, {
@@ -1066,20 +1613,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([
+  Injectable12(),
+  _ts_param8(1, Inject8(TRANSPORT_CANONICAL3)),
+  _ts_param8(2, Inject8(RUN_GATEWAY)),
+  _ts_param8(3, Inject8(STATE_STORE_CANONICAL4)),
+  _ts_param8(4, Inject8(DURABLE_OPTIONS_CANONICAL7)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof WorkflowEngine6 === "undefined" ? Object : WorkflowEngine6,
+    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: DURABLE_OPTIONS_CANONICAL6,
+      provide: DURABLE_OPTIONS_CANONICAL7,
       useValue: options
     });
   }
   static forRootAsync(options) {
     return _DurableModule.build({
-      provide: DURABLE_OPTIONS_CANONICAL6,
-      useFactory: options.useFactory,
+      provide: DURABLE_OPTIONS_CANONICAL7,
+      useFactory: /* @__PURE__ */ __name(async (...args) => {
+        const resolved = await options.useFactory(...args);
+        assertValidRole(resolved);
+        return resolved;
+      }, "useFactory"),
       inject: options.inject ?? []
     });
   }
@@ -1088,28 +1718,28 @@ var DurableModule = class _DurableModule {
       module: _DurableModule,
       global: true,
       imports: [
-        DiscoveryModule2
+        DiscoveryModule
       ],
       providers: [
         optionsProvider,
         {
-          provide: STATE_STORE_CANONICAL3,
-          useFactory: /* @__PURE__ */ __name((options) => options.store, "useFactory"),
+          provide: STATE_STORE_CANONICAL4,
+          useFactory: /* @__PURE__ */ __name((options) => options.store !== void 0 ? scopedStore(options.store, options) : null, "useFactory"),
           inject: [
-            DURABLE_OPTIONS_CANONICAL6
+            DURABLE_OPTIONS_CANONICAL7
           ]
         },
         {
           provide: TRANSPORT_CANONICAL3,
           useFactory: /* @__PURE__ */ __name((options) => options.transport ?? null, "useFactory"),
           inject: [
-            DURABLE_OPTIONS_CANONICAL6
+            DURABLE_OPTIONS_CANONICAL7
           ]
         },
         // Legacy back-compat aliases (deprecated tokens still resolve to the same instances):
         {
           provide: STATE_STORE,
-          useExisting: STATE_STORE_CANONICAL3
+          useExisting: STATE_STORE_CANONICAL4
         },
         {
           provide: TRANSPORT,
@@ -1117,47 +1747,59 @@ var DurableModule = class _DurableModule {
         },
         {
           provide: DURABLE_OPTIONS,
-          useExisting: DURABLE_OPTIONS_CANONICAL6
+          useExisting: DURABLE_OPTIONS_CANONICAL7
         },
         {
-          provide: WorkflowEngine5,
-          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: WorkflowEngine6,
+          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 WorkflowEngine5({
+            const engine = new WorkflowEngine6({
               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: [
-            STATE_STORE_CANONICAL3,
+            DURABLE_OPTIONS_CANONICAL7,
+            STATE_STORE_CANONICAL4,
             TRANSPORT_CANONICAL3,
-            DURABLE_OPTIONS_CANONICAL6,
             ModuleRef
           ]
         },
@@ -1167,53 +1809,81 @@ 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: [
+            DURABLE_OPTIONS_CANONICAL7,
+            STATE_STORE_CANONICAL4,
+            WorkflowEngine6
+          ]
+        },
+        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,
-        WorkflowEngine5,
+        WorkflowEngine6,
         STATE_STORE,
-        STATE_STORE_CANONICAL3,
+        STATE_STORE_CANONICAL4,
         TRANSPORT,
         TRANSPORT_CANONICAL3,
-        DURABLE_OPTIONS_CANONICAL6
+        DURABLE_OPTIONS_CANONICAL7,
+        RUN_GATEWAY
       ]
     };
   }
 };
-DurableModule = _ts_decorate9([
-  Module2({})
+DurableModule = _ts_decorate12([
+  Module({})
 ], DurableModule);
 export {
   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,
   OnEvent,
+  ProxyRunGateway,
+  RUN_GATEWAY,
   RUN_REDIS_WORKER,
+  RunRequestResponder,
   STEP_INTERCEPTOR_METADATA,
   Step,
   StepInterceptor,
+  StoreRunGateway,
+  TenantEventRepublisher,
   ThinStepRegistrar,
   ThinWorkerBootstrap,
   ThinWorkflowRegistrar,
@@ -1227,6 +1897,10 @@ export {
   getWorkflowMeta,
   inAppWorkerProviders,
   isDeadLetterHandler,
-  isStepInterceptor
+  isDrivingOperator,
+  isOperatorRole,
+  isStepInterceptor,
+  thinWorkerProviders,
+  unavailableRunGateway
 };
 //# sourceMappingURL=index.js.map