@kronos-ts/axon-server 0.3.1 → 0.4.0

package/src/axon-server.ts

@@ -1,55 +1,29 @@
 /**
- * Axon Server backend for kronos.
+ * The Axon Server command and query buses.
  *
- * `axonServer(config)` is an async factory: it connects eagerly, hands back
- * the four components it provides (eventStore, snapshotStore, commandBus,
- * queryBus), and gives you a `start`/`close` pair. There is no lifecycle
- * framework — the ordering that used to be encoded as `onStart("connect")` /
- * `onStart("processors")` / `onStop("connect")` is now three lines you write
- * in your composition root:
+ * Axon Server is a SMART HUB: outbound dispatch always goes to the server, and
+ * the server decides which node handles it — there is no client-side
+ * prefer-local fork here, which is the whole difference from the dumb-pipe
+ * broker in `@kronos-ts/rabbitmq`.
  *
- * ```ts
- * const axon = await axonServer({
- *   componentName: "university-service",
- *   serializer,
- *   unitOfWorkFactory,
- * })
- * const app = kronos({
- *   components: { ...inMemoryComponents({ serializer, unitOfWorkFactory }), ...axon.components },
- *   modules,
- * })
- * await axon.start()   // readiness barrier: the server can route to our handlers
- * // …
- * await app.stop(); await axon.close()
- * ```
- *
- * Connecting before the app is built is what removes the lazy proxies and
- * subscribe-buffering wrappers the container version needed: by the time
- * `kronos` subscribes a handler, the gRPC streams are already live.
- *
- * REMOTE ADMINISTRATION IS NOT IN HERE. Processor instructions (pause / start /
- * release / split / merge) and processor status reporting are the platform
- * CONTROL PLANE — they are neither persistence nor transport, and lived here
- * only because they share this gRPC connection. They are now an opt-in second
- * object built on the platform stream this backend exposes:
+ * Both buses are plain functions over the shared connection and YOUR local bus:
  *
  * ```ts
- * const control = await axonServerControlPlane(axon.platform, app.processors.values())
+ * const commandBus = interceptingCommandBus(
+ *   axonServerCommandBus(axon, simpleCommandBus(unitOfWork)), lineage)
+ * const queryBus = interceptingQueryBus(
+ *   axonServerQueryBus(axon, simpleQueryBus(unitOfWork)), lineage)
  * ```
  *
- * `start()` therefore takes NO arguments and does exactly one thing: the
- * data-path readiness barrier. See `control-plane.ts`.
- *
  * Axon-specific protocol invariants are preserved byte-for-byte:
  *
  *   - CLIENT_SUPPORTS_STREAMING capability advertised on every dispatched
  *     query via `defaultQueryInstructions(...)`;
  *   - AxonIQ-Context + AxonIQ-Access-Token gRPC metadata headers built by
- *     `createAxonMetadata(...)` and attached to every outbound stream/RPC;
+ *     `contextView(...)` and attached to every outbound stream/RPC;
  *   - permits-AFTER-subscriptions stream ordering preserved on the initial
  *     handshake AND on reconnect (see `ensureStreamStarted` /
- *     `reestablishStreamBody`);
- *   - shutdown ordering: busLatches → platform.stop → connection.close.
+ *     `reestablishStreamBody`).
  */
 import {
   qualifiedNameToString,
@@ -57,9 +31,8 @@ import {
   generateIdentifier,
   type Serializer,
   withRetry,
-  healthCheck,
   type ResilienceConfig,
-} from "@kronos-ts/common"
+} from "@kronos-ts/core"
 import type {
   CommandBus,
   CommandMessage,
@@ -67,36 +40,32 @@ import type {
   QueryMessage,
   SubscriptionFilter,
   SubscriptionQueryResult,
-  UoWRunner,
+  UnitOfWork,
+  Unstamped,
   UpdateHandler,
-} from "@kronos-ts/messaging"
+} from "@kronos-ts/core"
 import {
   applySubscriptionFilter,
-  correlationDataDispatchInterceptor,
-  interceptingCommandBus,
-  interceptingQueryBus,
+  stamped,
   updateHandler,
   runAfterCommitOrImmediately,
-} from "@kronos-ts/messaging"
-import { Metadata } from "nice-grpc"
-import type { AxonServerConnectionConfig } from "./connection.js"
-import { connectToAxonServer, type AxonServerConnection } from "./connection.js"
-import { axonServerEventStore } from "./axon-server-event-store.js"
-import { axonServerSnapshotStore } from "./axon-server-snapshot-store.js"
+} from "@kronos-ts/core"
+import type { AxonServerBusSource } from "./connection.js"
+import { contextView } from "./context-view.js"
 import { metadataToProto, metadataFromProto } from "./metadata-conversion.js"
 import { outboundStream } from "./outbound-stream.js"
 import { mapErrorCode, AxonServerErrorCode } from "./errors.js"
-import { shutdownLatch, type ShutdownLatch } from "./shutdown-latch.js"
-import {
-  platformConnection,
-  type PlatformConnection,
-  type PlatformServiceOptions,
-} from "./platform-service.js"
 
 /** Default flow control settings — aligned with Java's 5000 permits. */
 const DEFAULT_PERMITS = 5000n
 const DEFAULT_THRESHOLD = 2500n
 
+/** Default query dispatch timeout — aligned with Java's one hour. */
+const DEFAULT_QUERY_TIMEOUT_MS = 3_600_000
+
+/** Default command handler load factor — aligned with Java's 100. */
+const DEFAULT_LOAD_FACTOR = 100
+
 /**
  * Flow control configuration for a bus channel.
  */
@@ -120,10 +89,57 @@ export interface ProcessingInstructions {
   timeoutMs?: number
 }
 
+/**
+ * Tuning for {@link axonServerCommandBus}. Every field has a working default;
+ * the two arguments that carry meaning — the connection and your local bus —
+ * are positional, and this record is the trailing remainder.
+ */
+export interface AxonServerCommandBusOptions {
+  /** Axon Server context for this bus's stream. Default: the connection's. */
+  context?: string
+  /** Flow control for the command stream. */
+  flowControl?: FlowControlConfig
+  /**
+   * Load factor for this command handler. Signals to Axon Server how much
+   * capacity this node has — higher value = more commands routed here.
+   * Aligned with Java's `commandLoadFactor`. Default: 100.
+   */
+  loadFactor?: number
+  /** Retry policy for stream re-establishment. Default: the connection's. */
+  resilience?: Partial<ResilienceConfig>
+}
+
+/**
+ * Tuning for {@link axonServerQueryBus}. See {@link AxonServerCommandBusOptions}.
+ */
+export interface AxonServerQueryBusOptions {
+  /** Axon Server context for this bus's stream. Default: the connection's. */
+  context?: string
+  /** Flow control for the query stream. */
+  flowControl?: FlowControlConfig
+  /**
+   * When true, queries are first checked against locally subscribed handlers
+   * before being dispatched through Axon Server. Avoids a network round-trip
+   * when the handler is co-located.
+   *
+   * This is NOT the rabbitmq `preferLocal` fork by another name: it is Java's
+   * `shortcutQueriesToLocalHandlers`, it is off by default, and commands have
+   * no equivalent — Axon Server routes those, always.
+   */
+  shortcutQueriesToLocalHandlers?: boolean
+  /**
+   * Default timeout for query dispatch in ms. Default: 3600000 (1 hour).
+   * Aligned with Java's processing instruction timeout.
+   */
+  timeoutMs?: number
+  /** Retry policy for stream re-establishment. Default: the connection's. */
+  resilience?: Partial<ResilienceConfig>
+}
+
 // Processing instruction keys — aligned with proto ProcessingKey enum.
 // CLIENT_SUPPORTS_STREAMING (key=8) is an Axon-Server-specific capability
-// advertisement that MUST survive the migration verbatim — see file-level
-// JSDoc above and `defaultQueryInstructions` below.
+// advertisement that MUST survive verbatim — see file-level JSDoc above and
+// `defaultQueryInstructions` below.
 const INSTRUCTION_KEY = {
   ROUTING_KEY: 0,
   PRIORITY: 1,
@@ -139,10 +155,16 @@ function toProtoProcessingInstructions(instructions?: ProcessingInstructions): a
     result.push({ key: INSTRUCTION_KEY.ROUTING_KEY, value: { textValue: instructions.routingKey } })
   }
   if (instructions.priority !== undefined) {
-    result.push({ key: INSTRUCTION_KEY.PRIORITY, value: { numberValue: BigInt(instructions.priority) } })
+    result.push({
+      key: INSTRUCTION_KEY.PRIORITY,
+      value: { numberValue: BigInt(instructions.priority) },
+    })
   }
   if (instructions.timeoutMs !== undefined) {
-    result.push({ key: INSTRUCTION_KEY.TIMEOUT, value: { numberValue: BigInt(instructions.timeoutMs) } })
+    result.push({
+      key: INSTRUCTION_KEY.TIMEOUT,
+      value: { numberValue: BigInt(instructions.timeoutMs) },
+    })
   }
   return result
 }
@@ -161,233 +183,8 @@ function defaultQueryInstructions(timeoutMs: number): any[] {
   ]
 }
 
-/**
- * Build the gRPC metadata headers required by Axon Server. AxonIQ-Context
- * is mandatory (identifies the tenant/context); AxonIQ-Access-Token is
- * optional auth. Both must be attached to every outbound stream/RPC —
- * preserved verbatim from the legacy enhancer.
- */
-function createAxonMetadata(config: { context: string; token: string }): Metadata {
-  const metadata = new Metadata()
-  metadata.set("AxonIQ-Context", config.context)
-  if (config.token) {
-    metadata.set("AxonIQ-Access-Token", config.token)
-  }
-  return metadata
-}
-
-export interface AxonServerConfig extends AxonServerConnectionConfig {
-  /** Flow control for the command bus channel. */
-  commandFlowControl?: FlowControlConfig
-  /** Flow control for the query bus channel. */
-  queryFlowControl?: FlowControlConfig
-  /** Platform service configuration (heartbeat, etc.). */
-  platformService?: PlatformServiceOptions
-  /**
-   * When true, queries are first checked against locally registered handlers
-   * before being dispatched through Axon Server. Avoids a network round-trip
-   * when the handler is co-located.
-   *
-   * Aligned with Java's `shortcutQueriesToLocalHandlers`.
-   * Default: false.
-   */
-  shortcutQueriesToLocalHandlers?: boolean
-  /**
-   * Load factor for command handler registration.
-   * Signals to Axon Server how much capacity this handler has.
-   * Higher value = handler can take more commands.
-   *
-   * Aligned with Java's `commandLoadFactor`. Default: 100.
-   */
-  commandLoadFactor?: number
-  /**
-   * Default timeout for command dispatch in ms. Default: 300000 (5 min).
-   * Aligned with Java's processing instruction timeout.
-   */
-  commandTimeoutMs?: number
-  /**
-   * Default timeout for query dispatch in ms. Default: 3600000 (1 hour).
-   * Aligned with Java's processing instruction timeout.
-   */
-  queryTimeoutMs?: number
-  /** Per-extension resilience config (D-100 / D-101). */
-  resilience?: Partial<ResilienceConfig>
-  /**
-   * How long `start()` waits for Axon Server's routing tables to register the
-   * subscribe frames sent on the command/query streams. This is the entire
-   * data-path readiness barrier.
-   *
-   * It is a timed wait rather than an observed signal because nothing on the
-   * client can observe it: subscribes travel on the bus streams, and the
-   * platform stream — which is where an ack would arrive — is a different
-   * stream that Axon Server holds open silently after `register`. Default:
-   * 1000, matching the legacy enhancer. Tests against a freshly-booted server
-   * can tighten this once subscriptions are observed to land faster.
-   */
-  busSubscriptionAckDelayMs?: number
-}
-
-/** The components an Axon Server backend provides. Spread into `kronos`. */
-export interface AxonServerComponents {
-  eventStore: ReturnType<typeof axonServerEventStore>
-  snapshotStore: ReturnType<typeof axonServerSnapshotStore>
-  commandBus: CommandBus
-  queryBus: QueryBus
-}
-
-/**
- * A live Axon Server backend: the components it provides plus the two calls
- * that used to be lifecycle stages.
- */
-/** Everything axonServer() needs: its own config plus the framework values it borrows. */
-export type AxonServerOptions = AxonServerConfig & { serializer: Serializer; unitOfWorkFactory: UoWRunner }
-
-export interface AxonServerBackend {
-  readonly components: AxonServerComponents
-  /**
-   * The platform stream. It is built here because the backend owns the gRPC
-   * connection it rides on and the `platformService` tuning that configures it.
-   *
-   * `start()` below brings it up for the DATA path — heartbeats and reconnect
-   * detection — via `platform.armConnectionMonitoring()`. What it deliberately
-   * does NOT do is arm processor status reporting or route instructions: that is
-   * remote administration, and it stays opt-in behind
-   * `axonServerControlPlane(axon.platform, …)`, which registers its handler and
-   * supplier and then calls `platform.start()` on this same live stream.
-   *
-   * An instruction that arrives before a control plane exists is buffered by the
-   * platform connection and drained on the first `onInstruction` registration,
-   * so opening the stream early costs nothing.
-   */
-  readonly platform: PlatformConnection
-  /**
-   * DATA-PATH START. Two things, both data path:
-   *
-   *   1. arm heartbeat-driven reconnect detection on the platform stream, and
-   *   2. wait until Axon Server can route to the handlers subscribed on the bus
-   *      streams.
-   *
-   * Call AFTER `kronos` — the subscribe frames must already be on the wire for
-   * the readiness wait to mean anything.
-   *
-   * Takes no arguments and arms no control-plane state.
-   */
-  start(): Promise<void>
-  /** Drain in-flight bus work, stop the platform stream, close the connection. */
-  close(): Promise<void>
-}
-
-/**
- * Connect to Axon Server and build the components it backs.
- *
- * `serializer` and `unitOfWorkFactory` are arguments rather than slot lookups:
- * the buses serialize payloads with the former and run every inbound command /
- * query in the latter, so they must be the SAME instances the rest of the app
- * uses. Pass the ones you hand to `kronos`.
- */
-export async function axonServer(
-  options: AxonServerOptions,
-): Promise<AxonServerBackend> {
-  const config = options
-  const { serializer, unitOfWorkFactory, resilience } = config
-
-  const connection = await withRetry(async () => connectToAxonServer(config), {
-    event: "initial-connect",
-    ...resilience,
-  })
-
-  // Health-check ping with warn-then-continue (D-100). AxonServerConnection has
-  // no dedicated probe surface today; the gRPC channel itself is created
-  // eagerly in connectToAxonServer so the meaningful probe is a round-trip — we
-  // approximate via a soft no-op promise that satisfies the threshold contract.
-  // Real network failure is surfaced by the first bus call against the channel.
-  await healthCheck(async () => undefined, {
-    thresholdMs: resilience?.healthCheckThresholdMs,
-    log: resilience?.log,
-  })
-
-  // One latch per bus, drained in close() before the transport goes away.
-  const commandLatch = shutdownLatch()
-  const queryLatch = shutdownLatch()
-  const busLatches: ShutdownLatch[] = [commandLatch, queryLatch]
-
-  // The connection is live before anything below is built, so the buses open
-  // their gRPC streams for real and `subscribe()` reaches the wire immediately —
-  // no lazy proxy, no subscription buffering, no readiness promise.
-  const components: AxonServerComponents = {
-    eventStore: axonServerEventStore(connection, serializer),
-    snapshotStore: axonServerSnapshotStore(connection, serializer),
-    commandBus: distributedCommandBus(
-      connection,
-      unitOfWorkFactory,
-      commandLatch,
-      serializer,
-      config.commandFlowControl,
-      config.commandLoadFactor,
-      resilience,
-    ),
-    queryBus: distributedQueryBus(
-      connection,
-      unitOfWorkFactory,
-      queryLatch,
-      serializer,
-      config.queryFlowControl,
-      config.shortcutQueriesToLocalHandlers,
-      config.queryTimeoutMs,
-      resilience,
-    ),
-  }
-
-  // Built here, started by the control plane (or by the caller). Constructing it
-  // eagerly is what lets the control plane be a separate object at all — and it
-  // keeps `platformService` tuning and `stop()` ownership in one place, so the
-  // documented shutdown order below holds whether or not anyone opted in.
-  const platform = platformConnection(connection, config.platformService)
-
-  return {
-    components,
-    platform,
-
-    async start() {
-      // RECONNECT DETECTION IS DATA PATH. The heartbeat on the platform stream
-      // is what notices a dead channel and calls `connection.reconnect()`; both
-      // buses above hook `connection.onReconnect(...)` to rebuild their own
-      // streams. Arming it used to be a side effect of `platform.start()`, which
-      // only `axonServerControlPlane(...)` calls — so a service that never opted
-      // into remote administration had NO reconnect detection at all and would
-      // sit on a dead channel forever. It is armed here, unconditionally,
-      // independent of whether anyone administers this service.
-      //
-      // `armConnectionMonitoring()` opens the stream and starts heartbeats but
-      // arms NO processor status reporting; that stays the control plane's, and
-      // a later `platform.start()` adds it to this same live stream. Both calls
-      // are idempotent, so either order works.
-      await platform.armConnectionMonitoring()
-
-      // The only thing the data path has to wait for: Axon Server's
-      // command/query routing tables registering the subscribe frames sent on
-      // the BUS streams. It cannot be derived from the platform stream, because
-      // subscribes travel on a different stream entirely — and the platform
-      // stream's own `subscriptionsAcked()` latch says nothing about them (it
-      // latches unconditionally once `register` has been flushed; see
-      // platform-service.ts). So this barrier is the settle wait, and it is
-      // deliberately independent of whether the platform stream is up at all.
-      // The legacy enhancer carried the same 1s wait.
-      await new Promise((r) => setTimeout(r, config.busSubscriptionAckDelayMs ?? 1000))
-    },
-
-    async close() {
-      await Promise.all(busLatches.map((l) => l.initiateShutdown()))
-      // Idempotent, and independent of `control.close()` — a backend that was
-      // never administered still stops a platform stream someone else started.
-      platform.stop()
-      connection.close()
-    },
-  }
-}
-
 // ---------------------------------------------------------------------------
-// Shared payload helpers (moved verbatim from legacy enhancer)
+// Shared payload helpers
 // ---------------------------------------------------------------------------
 
 function createPayloadHelpers(serializer: Serializer) {
@@ -395,7 +192,11 @@ function createPayloadHelpers(serializer: Serializer) {
     serializePayload(name: string, payload: unknown, revision: string = "") {
       return serializer.serialize(payload, name, revision)
     },
-    deserializePayload(data: Uint8Array | undefined, type: string = "", revision: string = ""): unknown {
+    deserializePayload(
+      data: Uint8Array | undefined,
+      type: string = "",
+      revision: string = "",
+    ): unknown {
       if (!data || data.length === 0) return undefined
       return serializer.deserialize({ data, type, revision })
     },
@@ -403,79 +204,77 @@ function createPayloadHelpers(serializer: Serializer) {
 }
 
 // ---------------------------------------------------------------------------
-// Distributed Command Bus
-//
-// Bus implementation moved verbatim from the legacy enhancer with TWO
-// behavioural additions per D-97:
-//   1) reestablishStream() body wrapped in withRetry({ event: "reconnect" })
-//   2) inbound-stream backoff replaced by the same withRetry path
-//
-// Axon-specific protocol invariants preserved BYTE-FOR-BYTE:
-//   - AxonIQ-Context + AxonIQ-Access-Token gRPC metadata headers via
-//     createAxonMetadata(connection.config)
-//   - permits-AFTER-subscriptions ordering on reestablishStreamBody (subs
-//     are sent BEFORE grantPermits() in the reconnect path; the initial
-//     handshake matches this — see ensureStreamStarted's grantPermits call
-//     in subscribe()).
+// Axon Server Command Bus
 // ---------------------------------------------------------------------------
 
 /**
- * A command bus backed by Axon Server.
+ * A command bus backed by Axon Server, over YOUR local bus.
  *
- * - **Outbound dispatch**: Always goes through Axon Server via the unary Dispatch RPC.
- *   Axon Server routes the command to the appropriate node (which may be this one).
- * - **Local segment**: Handlers subscribed via `subscribe()` are registered with
- *   Axon Server (so other nodes can route to us) and stored locally. When Axon Server
- *   routes an inbound command to this node, it's executed on the local segment
- *   within a UnitOfWork.
- */
-/**
- * A command bus backed by Axon Server.
+ * - **Outbound dispatch**: ALWAYS through Axon Server, via the unary Dispatch
+ *   RPC. Axon Server routes the command to the appropriate node (which may be
+ *   this one). There is deliberately no client-side prefer-local fork: the hub
+ *   is the router, and short-circuiting it would silently defeat load factors,
+ *   priorities and routing keys.
+ * - **Inbound**: a command the server routes here is dispatched into `local` —
+ *   not into a privately-held handler map. That is what makes the unit-of-work
+ *   policy you chose for `local` (say `postgresUnitOfWork(pg, unitOfWork)`)
+ *   apply to server-routed work exactly as it applies to work this process
+ *   originated. It is also why this function takes no `unitOfWork` argument:
+ *   `local` carries that policy now.
+ * - **subscribe**: registers the handler on `local` AND announces the name to
+ *   Axon Server, so other nodes can route to us.
  *
  * ## Correlation lineage and the interceptor layer
  *
- * The returned bus is wrapped in {@link interceptingCommandBus} carrying
- * {@link correlationDataDispatchInterceptor}, so lineage is stamped onto the
- * outgoing message BEFORE it is serialized onto the wire.
+ * The returned bus stamps no lineage of its own. A host that wants it wraps the
+ * OUTERMOST bus:
+ *
+ * ```ts
+ * interceptingCommandBus(axonServerCommandBus(conn, local), lineage)
+ * ```
+ *
+ * so whatever a host adds runs BEFORE the message is serialized onto the wire.
+ * Lineage itself is usually already on `message.metadata` by then — `ctx.send`
+ * stamps the unit of work's correlation data before any bus sees the message.
  *
  * This is precisely how the Java client does it. AF4's `AxonServerCommandBus`
  * holds its own `DispatchInterceptors` and dispatches as
  * `doDispatch(dispatchInterceptors.intercept(commandMessage), cb)` — one call
- * site, at the top, ahead of any routing; and its `doDispatch` (like this one)
- * always goes to the server, letting Axon Server decide where the command lands.
- * AF5 keeps the property via decorator order:
- * `DISTRIBUTED_COMMAND_BUS_ORDER = InterceptingCommandBus.DECORATION_ORDER - 50`
+ * site, at the top, ahead of any routing. AF5 keeps the property via decorator
+ * order: `DISTRIBUTED_COMMAND_BUS_ORDER = InterceptingCommandBus.DECORATION_ORDER - 50`
  * stacks `InterceptingCommandBus → DistributedCommandBus → SimpleCommandBus`.
  *
- * Before this wrap, an Axon-backed service lost lineage on EVERY command: the
- * only registration of `correlationDataDispatchInterceptor` lives in
- * `@kronos-ts/app`'s in-memory default bus, and `components.commandBus` from
- * this backend replaces it wholesale.
- *
- * No double-application risk: the local segment here is a plain handler map, not
- * a `CommandBus`, so this is the only interceptor in the chain. Inbound commands
- * from the server are invoked through that map directly, which matches AF —
- * `CommandProcessingTask` runs the local segment WITHOUT re-running dispatch
- * interceptors.
+ * If `local` is itself an intercepting bus, a server-routed command sees
+ * `lineage` twice. That is harmless: both of its fields are `??` seeds, so the
+ * second application finds them set and changes nothing.
  */
-export function distributedCommandBus(
-  connection: AxonServerConnection,
-  unitOfWorkRunner: UoWRunner,
-  shutdownLatch: ShutdownLatch,
-  serializer: Serializer,
-  flowControl?: FlowControlConfig,
-  commandLoadFactor?: number,
-  resilience?: Partial<ResilienceConfig>,
+export function axonServerCommandBus(
+  conn: AxonServerBusSource,
+  local: CommandBus,
+  options: AxonServerCommandBusOptions = {},
 ): CommandBus {
-  const metadata = createAxonMetadata(connection.config)
+  const {
+    connection,
+    serializer,
+    metadata: axonMetadata,
+  } = contextView(conn, options.context ?? conn.connection.config.context)
+  const shutdownLatch = conn.shutdown
+  const resilience = options.resilience ?? conn.resilience
+  const metadata = axonMetadata()
   const { serializePayload, deserializePayload } = createPayloadHelpers(serializer)
-  const PERMITS = BigInt(flowControl?.permits ?? Number(DEFAULT_PERMITS))
-  const THRESHOLD = BigInt(flowControl?.refillThreshold ?? Number(DEFAULT_THRESHOLD))
+  const PERMITS = BigInt(options.flowControl?.permits ?? Number(DEFAULT_PERMITS))
+  const THRESHOLD = BigInt(options.flowControl?.refillThreshold ?? Number(DEFAULT_THRESHOLD))
+  const loadFactor = options.loadFactor ?? DEFAULT_LOAD_FACTOR
 
-  // Local segment — handlers that execute on this node
-  const localSegment = new Map<string, (message: CommandMessage) => Promise<unknown>>()
+  /**
+   * The names this node announced to Axon Server. The handlers themselves live
+   * on `local`; this set exists so an inbound command for a name we never
+   * subscribed still answers NO_HANDLER_FOR_COMMAND rather than whatever
+   * `local.dispatch` happens to throw — and so a reconnect can re-announce.
+   */
+  const subscribedNames = new Set<string>()
 
-  // Bidirectional stream for handler registration + inbound command handling
+  // Bidirectional stream for handler subscription + inbound command handling
   let outbound = outboundStream<any>()
   let streamStarted = false
   let permits = 0n
@@ -497,8 +296,21 @@ export function distributedCommandBus(
     permits += PERMITS
   }
 
+  function sendSubscribe(commandName: string) {
+    outbound.send({
+      subscribe: {
+        messageId: generateIdentifier(),
+        command: commandName,
+        componentName: connection.config.componentName,
+        clientId: connection.config.clientId,
+        loadFactor,
+      },
+      instructionId: generateIdentifier(),
+    })
+  }
+
   /**
-   * Re-establish the bidirectional stream and re-subscribe all handlers.
+   * Re-establish the bidirectional stream and re-announce all handlers.
    * Called on stream error or when the connection reconnects.
    *
    * ORDER (preserves Axon-specific invariant): subscriptions are
@@ -512,18 +324,7 @@ export function distributedCommandBus(
     permits = 0n
     ensureStreamStarted()
     // Re-subscribe all handlers FIRST
-    for (const commandName of localSegment.keys()) {
-      outbound.send({
-        subscribe: {
-          messageId: generateIdentifier(),
-          command: commandName,
-          componentName: connection.config.componentName,
-          clientId: connection.config.clientId,
-          loadFactor: commandLoadFactor ?? 100,
-        },
-        instructionId: generateIdentifier(),
-      })
-    }
+    for (const commandName of subscribedNames) sendSubscribe(commandName)
     // Permits AFTER subscriptions (Axon-specific ordering invariant)
     grantPermits()
   }
@@ -540,7 +341,7 @@ export function distributedCommandBus(
   connection.onReconnect(() => {
     if (!shutdownLatch.shuttingDown && streamStarted) {
       reestablishStreamWithRetry().catch((err) => {
-        console.error("Distributed command bus: reconnect retries exhausted", err)
+        console.error("Axon Server command bus: reconnect retries exhausted", err)
       })
     }
   })
@@ -553,13 +354,12 @@ export function distributedCommandBus(
         permits--
         const proto = message.command
         const commandName = proto.name
-        const handler = localSegment.get(commandName)
 
         let resultPayload: unknown
         let errorCode = ""
         let errorMsg = ""
 
-        if (handler) {
+        if (subscribedNames.has(commandName)) {
           try {
             const commandMessage: CommandMessage = {
               kind: "command",
@@ -570,10 +370,12 @@ export function distributedCommandBus(
               timestamp: Number(proto.timestamp),
             }
 
-            // Execute inbound command within its own UnitOfWork (AF5 parity)
-            resultPayload = await unitOfWorkRunner(commandMessage.metadata, () =>
-              handler(commandMessage),
-            )
+            // Through the LOCAL BUS, so the caller's unit-of-work policy runs.
+            // AF parity is preserved: `CommandProcessingTask` runs the local
+            // segment without re-running dispatch interceptors, and a `local`
+            // that happens to carry `lineage` re-applies a pair of `??` seeds
+            // that are already set.
+            resultPayload = await local.dispatch(commandMessage)
           } catch (err) {
             errorCode = AxonServerErrorCode.COMMAND_EXECUTION_ERROR
             errorMsg = err instanceof Error ? err.message : String(err)
@@ -590,11 +392,15 @@ export function distributedCommandBus(
             requestIdentifier: proto.messageIdentifier,
             errorCode,
             errorMessage: errorCode
-              ? { message: errorMsg, location: connection.config.componentName, details: [], errorCode }
-              : undefined,
-            payload: resultPayload !== undefined
-              ? serializePayload("result", resultPayload)
+              ? {
+                  message: errorMsg,
+                  location: connection.config.componentName,
+                  details: [],
+                  errorCode,
+                }
               : undefined,
+            payload:
+              resultPayload !== undefined ? serializePayload("result", resultPayload) : undefined,
             metaData: {},
             processingInstructions: [],
           },
@@ -614,35 +420,47 @@ export function distributedCommandBus(
       if (shutdownLatch.shuttingDown) return
       if (String(err).includes("Connection dropped")) return
 
-      console.error("Distributed command bus: inbound stream error, attempting re-establishment via withRetry", err)
+      console.error(
+        "Axon Server command bus: inbound stream error, attempting re-establishment via withRetry",
+        err,
+      )
       await reestablishStreamWithRetry().catch((retryErr) => {
-        console.error("Distributed command bus: reconnect retries exhausted", retryErr)
+        console.error("Axon Server command bus: reconnect retries exhausted", retryErr)
       })
     }
   }
 
-  const routing: CommandBus = {
-    async dispatch(message: CommandMessage): Promise<unknown> {
+  return {
+    async dispatch(unstamped: Unstamped<CommandMessage>): Promise<unknown> {
+      // A transport is not a task: it has no unit of work, so it has no clock.
+      // A message that reaches the wire still {@link Unstamped} is therefore
+      // stamped from system time here — the envelope crosses a process boundary
+      // and must be fully formed. A locally-shortcut message is handed to
+      // `local` unstamped instead, so the task that handles it supplies the
+      // instant.
+      const message = stamped(unstamped, Date.now)
       const activity = shutdownLatch.registerActivity()
       try {
         const commandName = qualifiedNameToString(message.name)
 
-        const response = await connection.commands.dispatch({
-          messageIdentifier: message.identifier,
-          name: commandName,
-          timestamp: BigInt(message.timestamp),
-          payload: serializePayload(commandName, message.payload),
-          metaData: metadataToProto(message.metadata),
-          processingInstructions: toProtoProcessingInstructions(message.metadata?.processingInstructions as ProcessingInstructions | undefined),
-          clientId: connection.config.clientId,
-          componentName: connection.config.componentName,
-        }, { metadata })
+        const response = await connection.commands.dispatch(
+          {
+            messageIdentifier: message.identifier,
+            name: commandName,
+            timestamp: BigInt(message.timestamp),
+            payload: serializePayload(commandName, message.payload),
+            metaData: metadataToProto(message.metadata),
+            processingInstructions: toProtoProcessingInstructions(
+              message.metadata?.processingInstructions as ProcessingInstructions | undefined,
+            ),
+            clientId: connection.config.clientId,
+            componentName: connection.config.componentName,
+          },
+          { metadata },
+        )
 
         if (response.errorCode && response.errorCode !== "") {
-          throw mapErrorCode(
-            response.errorCode,
-            response.errorMessage?.message ?? "Unknown error",
-          )
+          throw mapErrorCode(response.errorCode, response.errorMessage?.message ?? "Unknown error")
         }
 
         return deserializePayload(response.payload?.data as Uint8Array | undefined)
@@ -651,73 +469,72 @@ export function distributedCommandBus(
       }
     },
 
-    subscribe(commandName: string, handler: (message: CommandMessage) => Promise<unknown>) {
-      localSegment.set(commandName, handler)
+    subscribe(
+      commandName: string,
+      handler: (message: CommandMessage, uow: UnitOfWork) => Promise<unknown>,
+    ) {
+      subscribedNames.add(commandName)
+      local.subscribe(commandName, handler)
 
       ensureStreamStarted()
       // Subscription FIRST
-      outbound.send({
-        subscribe: {
-          messageId: generateIdentifier(),
-          command: commandName,
-          componentName: connection.config.componentName,
-          clientId: connection.config.clientId,
-          loadFactor: commandLoadFactor ?? 100,
-        },
-        instructionId: generateIdentifier(),
-      })
+      sendSubscribe(commandName)
       // Permits AFTER subscription (Axon-specific ordering invariant)
       grantPermits()
     },
   }
-
-  // Interception OUTSIDE routing — see the note on this function.
-  const bus = interceptingCommandBus(routing)
-  bus.registerDispatchInterceptor(correlationDataDispatchInterceptor())
-  return bus
 }
 
 // ---------------------------------------------------------------------------
-// Distributed Query Bus
+// Axon Server Query Bus
 // ---------------------------------------------------------------------------
 
 /**
- * A query bus backed by Axon Server.
+ * A query bus backed by Axon Server, over YOUR local bus.
+ *
+ * Same architecture as {@link axonServerCommandBus}: outbound dispatch goes
+ * through Axon Server, and a query the server routes here runs through `local`,
+ * so your unit-of-work policy applies to server-routed reads too. `subscribe`
+ * registers on `local` and announces the name to the server.
  *
- * Same architecture as the distributed command bus:
- * - **Outbound dispatch**: Always through Axon Server.
- * - **Local segment**: Handlers registered here are stored locally and
- *   registered with Axon Server for inbound routing. Inbound queries
- *   are executed within a UnitOfWork.
+ * The one asymmetry with commands is `shortcutQueriesToLocalHandlers` — Java
+ * has it for queries and not for commands, and so do we. When it is on and this
+ * node subscribed the name, `query()` goes straight to `local` and the caller's
+ * unit of work is passed through, so the local branch nests exactly as the
+ * in-process bus does.
  *
- * Wrapped in {@link interceptingQueryBus} with
- * {@link correlationDataDispatchInterceptor}, matching AF4's
- * `AxonServerQueryBus`, which calls `dispatchInterceptors.intercept(...)` at the
- * top of `query`, `streamingQuery`, `scatterGather` and `subscriptionQuery`.
- * Because the wrap is outside, the `shortcutQueriesToLocalHandlers` branch in
- * `query()` gets identical lineage to the remote branch.
+ * Lineage, if wanted, is `interceptingQueryBus(bus, lineage)` at the host,
+ * matching AF4's `AxonServerQueryBus`, which calls
+ * `dispatchInterceptors.intercept(...)` at the top of `query`, `streamingQuery`,
+ * `scatterGather` and `subscriptionQuery`. Because the wrap is outside, the
+ * shortcut branch gets identical lineage to the remote branch.
  *
  * KNOWN GAP: `subscriptionQuery` / `subscribeToUpdates` build their proto
  * straight from `message.metadata`, and `interceptingQueryBus` (in
- * `@kronos-ts/messaging`) forwards those two calls to the delegate without
- * running the dispatch chain. Closing that needs a messaging-package change.
+ * `@kronos-ts/core`) forwards those two calls to the delegate without
+ * running the dispatch chain. Closing that needs a core change.
  */
-export function distributedQueryBus(
-  connection: AxonServerConnection,
-  unitOfWorkRunner: UoWRunner,
-  shutdownLatch: ShutdownLatch,
-  serializer: Serializer,
-  flowControl?: FlowControlConfig,
-  shortcutQueriesToLocalHandlers?: boolean,
-  queryTimeoutMs?: number,
-  resilience?: Partial<ResilienceConfig>,
+export function axonServerQueryBus(
+  conn: AxonServerBusSource,
+  local: QueryBus,
+  options: AxonServerQueryBusOptions = {},
 ): QueryBus {
-  const metadata = createAxonMetadata(connection.config)
-  const PERMITS = BigInt(flowControl?.permits ?? Number(DEFAULT_PERMITS))
-  const THRESHOLD = BigInt(flowControl?.refillThreshold ?? Number(DEFAULT_THRESHOLD))
+  const {
+    connection,
+    serializer,
+    metadata: axonMetadata,
+  } = contextView(conn, options.context ?? conn.connection.config.context)
+  const shutdownLatch = conn.shutdown
+  const resilience = options.resilience ?? conn.resilience
+  const metadata = axonMetadata()
+  const PERMITS = BigInt(options.flowControl?.permits ?? Number(DEFAULT_PERMITS))
+  const THRESHOLD = BigInt(options.flowControl?.refillThreshold ?? Number(DEFAULT_THRESHOLD))
+  const shortcutQueriesToLocalHandlers = options.shortcutQueriesToLocalHandlers ?? false
+  const queryTimeoutMs = options.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS
   const { serializePayload, deserializePayload } = createPayloadHelpers(serializer)
 
-  const localSegment = new Map<string, (message: QueryMessage) => Promise<unknown>>()
+  /** Query names announced to Axon Server; the handlers live on `local`. */
+  const subscribedNames = new Set<string>()
 
   // Local subscription store — subscription queries opened by THIS instance.
   // Inbound updates from the server are offered into these via the Subscription RPC loop.
@@ -750,8 +567,21 @@ export function distributedQueryBus(
     permits += PERMITS
   }
 
+  function sendSubscribe(queryName: string) {
+    outbound.send({
+      subscribe: {
+        messageId: generateIdentifier(),
+        query: queryName,
+        resultName: "",
+        componentName: connection.config.componentName,
+        clientId: connection.config.clientId,
+      },
+      instructionId: generateIdentifier(),
+    })
+  }
+
   /**
-   * Re-establish the bidirectional stream and re-subscribe all handlers.
+   * Re-establish the bidirectional stream and re-announce all handlers.
    * Called on stream error or when the connection reconnects.
    *
    * ORDER (preserves Axon-specific invariant): subscriptions are
@@ -763,18 +593,7 @@ export function distributedQueryBus(
     streamStarted = false
     permits = 0n
     ensureStreamStarted()
-    for (const queryName of localSegment.keys()) {
-      outbound.send({
-        subscribe: {
-          messageId: generateIdentifier(),
-          query: queryName,
-          resultName: "",
-          componentName: connection.config.componentName,
-          clientId: connection.config.clientId,
-        },
-        instructionId: generateIdentifier(),
-      })
-    }
+    for (const queryName of subscribedNames) sendSubscribe(queryName)
     grantQueryPermits()
   }
 
@@ -790,7 +609,7 @@ export function distributedQueryBus(
   connection.onReconnect(() => {
     if (!shutdownLatch.shuttingDown && streamStarted) {
       reestablishStreamWithRetry().catch((err) => {
-        console.error("Distributed query bus: reconnect retries exhausted", err)
+        console.error("Axon Server query bus: reconnect retries exhausted", err)
       })
     }
   })
@@ -810,12 +629,11 @@ export function distributedQueryBus(
       )
       handlerSubscriptions.set(subId, { queryName, payload })
 
-      const handler = localSegment.get(queryName)
       let resultPayload: unknown
       let errorCode = ""
       let errorMsg = ""
 
-      if (handler) {
+      if (subscribedNames.has(queryName)) {
         try {
           const queryMessage: QueryMessage = {
             kind: "query",
@@ -825,9 +643,7 @@ export function distributedQueryBus(
             metadata: metadataFromProto(proto.metaData ?? {}),
             timestamp: Number(proto.timestamp),
           }
-          resultPayload = await unitOfWorkRunner(queryMessage.metadata, async () => {
-            return handler(queryMessage)
-          })
+          resultPayload = await local.query(queryMessage)
         } catch (err) {
           errorCode = AxonServerErrorCode.QUERY_EXECUTION_ERROR
           errorMsg = err instanceof Error ? err.message : String(err)
@@ -837,9 +653,8 @@ export function distributedQueryBus(
         errorMsg = `No local handler for query "${queryName}"`
       }
 
-      const responseSerialized = resultPayload !== undefined
-        ? serializePayload("result", resultPayload)
-        : undefined
+      const responseSerialized =
+        resultPayload !== undefined ? serializePayload("result", resultPayload) : undefined
 
       outbound.send({
         subscriptionQueryResponse: {
@@ -850,7 +665,12 @@ export function distributedQueryBus(
             requestIdentifier: proto.messageIdentifier,
             errorCode,
             errorMessage: errorCode
-              ? { message: errorMsg, location: connection.config.componentName, details: [], errorCode }
+              ? {
+                  message: errorMsg,
+                  location: connection.config.componentName,
+                  details: [],
+                  errorCode,
+                }
               : undefined,
             payload: responseSerialized,
             metaData: {},
@@ -879,13 +699,12 @@ export function distributedQueryBus(
         permits--
         const proto = message.query
         const queryName = proto.query
-        const handler = localSegment.get(queryName)
 
         let resultPayload: unknown
         let errorCode = ""
         let errorMsg = ""
 
-        if (handler) {
+        if (subscribedNames.has(queryName)) {
           try {
             const queryMessage: QueryMessage = {
               kind: "query",
@@ -896,9 +715,9 @@ export function distributedQueryBus(
               timestamp: Number(proto.timestamp),
             }
 
-            resultPayload = await unitOfWorkRunner(queryMessage.metadata, async () => {
-              return handler(queryMessage)
-            })
+            // Through the LOCAL BUS: no unit of work is handed in, so `local`
+            // opens one under whatever policy the caller gave it.
+            resultPayload = await local.query(queryMessage)
           } catch (err) {
             errorCode = AxonServerErrorCode.QUERY_EXECUTION_ERROR
             errorMsg = err instanceof Error ? err.message : String(err)
@@ -914,11 +733,15 @@ export function distributedQueryBus(
             requestIdentifier: proto.messageIdentifier,
             errorCode,
             errorMessage: errorCode
-              ? { message: errorMsg, location: connection.config.componentName, details: [], errorCode }
-              : undefined,
-            payload: resultPayload !== undefined
-              ? serializePayload("result", resultPayload)
+              ? {
+                  message: errorMsg,
+                  location: connection.config.componentName,
+                  details: [],
+                  errorCode,
+                }
               : undefined,
+            payload:
+              resultPayload !== undefined ? serializePayload("result", resultPayload) : undefined,
             metaData: {},
             processingInstructions: [],
           },
@@ -945,39 +768,52 @@ export function distributedQueryBus(
       if (shutdownLatch.shuttingDown) return
       if (String(err).includes("Connection dropped")) return
 
-      console.error("Distributed query bus: inbound stream error, attempting re-establishment via withRetry", err)
+      console.error(
+        "Axon Server query bus: inbound stream error, attempting re-establishment via withRetry",
+        err,
+      )
       await reestablishStreamWithRetry().catch((retryErr) => {
-        console.error("Distributed query bus: reconnect retries exhausted", retryErr)
+        console.error("Axon Server query bus: reconnect retries exhausted", retryErr)
       })
     }
   }
 
   const routing: QueryBus = {
-    async query(message: QueryMessage): Promise<unknown> {
+    async query(unstamped: Unstamped<QueryMessage>, uow?: UnitOfWork): Promise<unknown> {
       const activity = shutdownLatch.registerActivity()
       try {
-        const queryName = qualifiedNameToString(message.name)
-
-        // Local shortcut — handle locally if handler is co-located
-        if (shortcutQueriesToLocalHandlers) {
-          const localHandler = localSegment.get(queryName)
-          if (localHandler) {
-            return unitOfWorkRunner(message.metadata, async () => {
-              return localHandler(message)
-            })
-          }
+        const queryName = qualifiedNameToString(unstamped.name)
+
+        // Local shortcut — handle locally if a handler is co-located. The
+        // caller's unit of work is passed straight through, so `local` makes the
+        // nest-or-open decision on the HANDLE exactly as it does for an
+        // in-process read: a live unit of work handed in by `ctx.query` is
+        // reused so the consulting read shares the caller's transaction.
+        if (shortcutQueriesToLocalHandlers && subscribedNames.has(queryName)) {
+          return local.query(unstamped, uow)
         }
 
-        const responseStream = connection.queries.query({
-          messageIdentifier: message.identifier,
-          query: queryName,
-          timestamp: BigInt(message.timestamp),
-          payload: serializePayload(queryName, message.payload),
-          metaData: metadataToProto(message.metadata),
-          processingInstructions: defaultQueryInstructions(queryTimeoutMs ?? 3600000),
-          clientId: connection.config.clientId,
-          componentName: connection.config.componentName,
-        }, { metadata })
+      // A transport is not a task: it has no unit of work, so it has no clock.
+      // A message that reaches the wire still {@link Unstamped} is therefore
+      // stamped from system time here — the envelope crosses a process boundary
+      // and must be fully formed. A locally-shortcut message is handed to
+      // `local` unstamped instead, so the task that handles it supplies the
+      // instant.
+        const message = stamped(unstamped, Date.now)
+
+        const responseStream = connection.queries.query(
+          {
+            messageIdentifier: message.identifier,
+            query: queryName,
+            timestamp: BigInt(message.timestamp),
+            payload: serializePayload(queryName, message.payload),
+            metaData: metadataToProto(message.metadata),
+            processingInstructions: defaultQueryInstructions(queryTimeoutMs),
+            clientId: connection.config.clientId,
+            componentName: connection.config.componentName,
+          },
+          { metadata },
+        )
 
         for await (const response of responseStream) {
           if (response.errorCode && response.errorCode !== "") {
@@ -995,25 +831,24 @@ export function distributedQueryBus(
       }
     },
 
-    subscribe(queryName: string, handler: (message: QueryMessage) => Promise<unknown>) {
-      localSegment.set(queryName, handler)
+    subscribe(
+      queryName: string,
+      handler: (message: QueryMessage, uow: UnitOfWork) => Promise<unknown>,
+    ) {
+      subscribedNames.add(queryName)
+      local.subscribe(queryName, handler)
 
       ensureStreamStarted()
-      outbound.send({
-        subscribe: {
-          messageId: generateIdentifier(),
-          query: queryName,
-          resultName: "",
-          componentName: connection.config.componentName,
-          clientId: connection.config.clientId,
-        },
-        instructionId: generateIdentifier(),
-      })
+      sendSubscribe(queryName)
       // Permits AFTER subscription (Axon-specific ordering invariant)
       grantQueryPermits()
     },
 
-    subscriptionQuery(message: QueryMessage, bufferSize?: number): SubscriptionQueryResult {
+    subscriptionQuery(
+      unstamped: Unstamped<QueryMessage>,
+      bufferSize?: number,
+    ): SubscriptionQueryResult {
+      const message = stamped(unstamped, Date.now)
       const queryId = message.identifier
       if (subscriptions.has(queryId)) {
         throw new Error(`Subscription query already registered for identifier "${queryId}"`)
@@ -1037,7 +872,7 @@ export function distributedQueryBus(
             timestamp: BigInt(message.timestamp),
             payload: serializePayload(queryName, message.payload),
             metaData: metadataToProto(message.metadata),
-            processingInstructions: defaultQueryInstructions(queryTimeoutMs ?? 3600000),
+            processingInstructions: defaultQueryInstructions(queryTimeoutMs),
             clientId: connection.config.clientId,
             componentName: connection.config.componentName,
           },
@@ -1054,7 +889,7 @@ export function distributedQueryBus(
             timestamp: BigInt(message.timestamp),
             payload: serializePayload(queryName, message.payload),
             metaData: metadataToProto(message.metadata),
-            processingInstructions: defaultQueryInstructions(queryTimeoutMs ?? 3600000),
+            processingInstructions: defaultQueryInstructions(queryTimeoutMs),
             clientId: connection.config.clientId,
             componentName: connection.config.componentName,
           },
@@ -1078,21 +913,33 @@ export function distributedQueryBus(
               const initial = response.initialResult
               if (!initialSettled) {
                 if (initial.errorCode && initial.errorCode !== "") {
-                  rejectInitial(mapErrorCode(initial.errorCode, initial.errorMessage?.message ?? "Unknown error"))
+                  rejectInitial(
+                    mapErrorCode(
+                      initial.errorCode,
+                      initial.errorMessage?.message ?? "Unknown error",
+                    ),
+                  )
                 } else {
-                  resolveInitial(deserializePayload(initial.payload?.data as Uint8Array | undefined))
+                  resolveInitial(
+                    deserializePayload(initial.payload?.data as Uint8Array | undefined),
+                  )
                 }
                 initialSettled = true
               }
             } else if (response.update) {
-              const update = deserializePayload(response.update.payload?.data as Uint8Array | undefined)
+              const update = deserializePayload(
+                response.update.payload?.data as Uint8Array | undefined,
+              )
               handler.offer(update)
             } else if (response.complete) {
               handler.complete()
               break
             } else if (response.completeExceptionally) {
               handler.completeExceptionally(
-                new Error(response.completeExceptionally.errorMessage?.message ?? "Subscription query failed"),
+                new Error(
+                  response.completeExceptionally.errorMessage?.message ??
+                    "Subscription query failed",
+                ),
               )
               break
             }
@@ -1125,7 +972,11 @@ export function distributedQueryBus(
       }
     },
 
-    subscribeToUpdates(message: QueryMessage, bufferSize?: number): AsyncIterable<unknown> & { close(): void } {
+    subscribeToUpdates(
+      unstamped: Unstamped<QueryMessage>,
+      bufferSize?: number,
+    ): AsyncIterable<unknown> & { close(): void } {
+      const message = stamped(unstamped, Date.now)
       const queryId = message.identifier
       if (subscriptions.has(queryId)) {
         throw new Error(`Subscription query already registered for identifier "${queryId}"`)
@@ -1174,10 +1025,7 @@ export function distributedQueryBus(
       })
     },
 
-    async completeSubscription(
-      queryName: string,
-      filter?: SubscriptionFilter,
-    ): Promise<void> {
+    async completeSubscription(queryName: string, filter?: SubscriptionFilter): Promise<void> {
       runAfterCommitOrImmediately(() => {
         for (const [subId, sub] of handlerSubscriptions) {
           if (sub.queryName !== queryName) continue
@@ -1233,7 +1081,5 @@ export function distributedQueryBus(
     },
   }
 
-  const bus = interceptingQueryBus(routing)
-  bus.registerDispatchInterceptor(correlationDataDispatchInterceptor())
-  return bus
+  return routing
 }