@zlink-systems/framework 0.30.0 → 0.30.2

package/src/runtime/channels/channel-transports.ts

@@ -12,6 +12,7 @@ import {
 import { ZLinkBufferMessage } from '../backend/runtime-message';
 import {
   RequestResult,
+  ZLINK_BACKEND_SEND_DONT_WAIT,
   isZLinkBackendResultError,
   type ZLinkBackendMessageLike as MessageLike
 } from '../backend/runtime-values';
@@ -61,6 +62,8 @@ import {
   type ZLinkChannelEnvelopeCodecRegistry
 } from './channel-envelope';
 
+const NON_BLOCKING_SEND_OPTIONS = Object.freeze({ flags: ZLINK_BACKEND_SEND_DONT_WAIT });
+
 export interface ZLinkChannelClientTransport {
   send(
     channelName: string,
@@ -74,7 +77,8 @@ export interface ZLinkChannelClientTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply>;
   tryPublish?(
     channelName: string,
@@ -131,7 +135,8 @@ export interface ZLinkRouteClientTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply>;
   submitToChannel(
     meshName: string,
@@ -147,7 +152,8 @@ export interface ZLinkRouteClientTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply>;
   sendToSpot?(
     spotRouteTarget: ZLinkSpotRouteTarget,
@@ -164,6 +170,7 @@ export interface ZLinkRouteClientTransport {
       readonly packetName?: string;
       readonly timeoutMs?: number;
       readonly signal?: AbortSignal;
+      readonly onAdmitted?: () => void;
       readonly metadata?: ReadonlyMap<string, string>;
     }
   ): Promise<TReply>;
@@ -182,7 +189,8 @@ interface ZLinkChannelTransportRuntime {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply>;
   tryPublish(
     channelName: string,
@@ -215,7 +223,8 @@ interface ZLinkChannelTransportRuntime {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply>;
   routeSendToSpot(
     spotRouteTarget: ZLinkSpotRouteTarget,
@@ -236,7 +245,8 @@ interface ZLinkChannelTransportRuntime {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply>;
   routeRequestFromSpotToSpot<TReply>(
     sourceSpot: ZLinkBackendSpot,
@@ -244,20 +254,23 @@ interface ZLinkChannelTransportRuntime {
     packetName: string | undefined,
     request: unknown,
     timeoutMs: number | undefined,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    onAdmitted?: () => void
   ): Promise<TReply>;
   routeRequestRawFromSpotToSpot(
     sourceSpot: ZLinkBackendSpot,
     spotRouteTarget: ZLinkSpotRouteTarget,
     request: Message,
     timeoutMs: number | undefined,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    onAdmitted?: () => void
   ): Promise<readonly Message[]>;
   routeRequestRawToSpot(
     spotRouteTarget: ZLinkSpotRouteTarget,
     request: Message,
     timeoutMs: number | undefined,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    onAdmitted?: () => void
   ): Promise<readonly Message[]>;
 }
 
@@ -269,7 +282,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     private readonly meshRuntime:
       | (() =>
           | {
-              readonly meshNode: (meshName: string) => ZLinkBackendMeshNode | undefined;
+              readonly meshNode?: (meshName: string) => ZLinkBackendMeshNode | undefined;
               readonly meshCompletionTable: (
                 meshName: string
               ) => ZLinkMeshCompletionTable | undefined;
@@ -307,40 +320,44 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     );
   }
 
-  async submit(
+  submit(
     meshName: string,
     targetNodeRid: string,
     packetName: string | undefined,
     message: unknown,
     metadata?: ReadonlyMap<string, string>
-  ): Promise<ZLinkSubmitResult> {
+  ): ZLinkSubmitResult | Promise<ZLinkSubmitResult> {
     // Call-scoped flow (spec 27 §4): the envelope flow pair lives only for
     // the duration of this outbound call, never in the caller's context.
-    return runWithOutboundFlow(this.flowCreationEnabled(), () =>
+    if (!this.flowCreationEnabled())
+      return this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false);
+    return runWithOutboundFlow(true, () =>
       this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false)
     );
   }
 
-  async submitInfrastructure(
+  submitInfrastructure(
     meshName: string,
     targetNodeRid: string,
     packetName: string | undefined,
     message: unknown,
     metadata?: ReadonlyMap<string, string>
-  ): Promise<ZLinkSubmitResult> {
-    return runWithOutboundFlow(this.flowCreationEnabled(), () =>
+  ): ZLinkSubmitResult | Promise<ZLinkSubmitResult> {
+    if (!this.flowCreationEnabled())
+      return this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true);
+    return runWithOutboundFlow(true, () =>
       this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true)
     );
   }
 
-  private async submitNode(
+  private submitNode(
     meshName: string,
     targetNodeRid: string,
     packetName: string | undefined,
     message: unknown,
     metadata: ReadonlyMap<string, string> | undefined,
     allowObjectClientTarget: boolean
-  ): Promise<ZLinkSubmitResult> {
+  ): ZLinkSubmitResult | Promise<ZLinkSubmitResult> {
     const node = this.meshNode(meshName);
     if (node === undefined) {
       return this.requireManager().routeSubmit(
@@ -365,22 +382,33 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       undefined,
       metadata
     );
-    const operation = `MeshNode '${meshName}' send to node '${targetNodeRid}'`;
-    if (this.isSelfNode(node, targetNodeRid)) {
-      return this.submitLocalNode(meshName, String(node.status().routingId), parts);
+    const sourceNodeRid =
+      node.routingId ?? (node.status().routingId as unknown as import('../../contracts').RoutingId);
+    if (routingIdsEqual(sourceNodeRid, targetNodeRid)) {
+      return this.submitLocalNode(meshName, String(sourceNodeRid), parts);
     }
     if (
-      !this.isKnownBackendPeer(node, targetNodeRid) &&
-      this.manualNodeTarget?.(meshName, targetNodeRid) === false
+      this.manualNodeTarget?.(meshName, targetNodeRid) === false &&
+      !this.isKnownBackendPeer(node, targetNodeRid)
     ) {
       return { status: ZLinkSubmitStatus.TargetNotFound };
     }
     try {
-      return mapMeshSubmitResult(
-        await node.sendToNode(toBackendRoutingId(targetNodeRid), parts, { flags: 1 })
+      const submitted = node.sendToNode(
+        toBackendRoutingId(targetNodeRid),
+        parts,
+        NON_BLOCKING_SEND_OPTIONS
       );
+      return submitted instanceof Promise
+        ? submitted.then(mapMeshSubmitResult, (error) => {
+            throw mapMeshSubmissionError(
+              error,
+              `MeshNode '${meshName}' send to node '${targetNodeRid}'`
+            );
+          })
+        : mapMeshSubmitResult(submitted);
     } catch (error) {
-      throw mapMeshSubmissionError(error, operation);
+      throw mapMeshSubmissionError(error, `MeshNode '${meshName}' send to node '${targetNodeRid}'`);
     }
   }
 
@@ -391,9 +419,21 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
-    return runWithOutboundFlow(this.flowCreationEnabled(), () =>
+    if (!this.flowCreationEnabled())
+      return this.requestScoped<TReply>(
+        meshName,
+        targetNodeRid,
+        packetName,
+        request,
+        timeoutMs,
+        signal,
+        metadata,
+        onAdmitted
+      );
+    return runWithOutboundFlow(true, () =>
       this.requestScoped<TReply>(
         meshName,
         targetNodeRid,
@@ -401,7 +441,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
         request,
         timeoutMs,
         signal,
-        metadata
+        metadata,
+        onAdmitted
       )
     );
   }
@@ -413,7 +454,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
     const node = this.meshNode(meshName);
     if (node === undefined) {
@@ -424,7 +466,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
         request,
         timeoutMs,
         signal,
-        metadata
+        metadata,
+        onAdmitted
       );
     }
     const correlationId = newChannelCorrelationId();
@@ -445,16 +488,15 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
         metadata,
         correlationId
       );
-      const completion = await this.submitRequestOperation(
-        meshName,
-        timeoutMs,
-        signal,
-        `MeshNode '${meshName}' request to node '${targetNodeRid}'`,
-        (remainingTimeoutMs) => {
-          const operationId = node.requestToNode(toBackendRoutingId(targetNodeRid), parts, {
-            flags: 1,
-            timeoutMs: remainingTimeoutMs
-          });
+      const requestOptions = { flags: 1, onAdmitted, timeoutMs: requestTimeoutBudget(timeoutMs) };
+      let completion: ZLinkMeshCompletion;
+      try {
+        completion = await this.completionTable(meshName).submit(() => {
+          const operationId = node.requestToNode(
+            toBackendRoutingId(targetNodeRid),
+            parts,
+            requestOptions
+          );
           this.traceNodeRequest(
             ZLinkMessageFlowOutcome.Sent,
             undefined,
@@ -464,8 +506,13 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
             correlationId
           );
           return operationId;
-        }
-      );
+        }, signal);
+      } catch (error) {
+        throw mapMeshSubmissionError(
+          error,
+          `MeshNode '${meshName}' request to node '${targetNodeRid}'`
+        );
+      }
       const reply = this.decodeMeshReply<TReply>(meshName, completion);
       this.traceNodeRequest(
         ZLinkMessageFlowOutcome.ReplyReceived,
@@ -546,7 +593,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     const operation = `MeshNode '${meshName}' send to channel '${channelName}'`;
     try {
       const result = mapMeshSubmitResult(
-        await node.sendToChannel(channelName, parts, { flags: 1 })
+        await node.sendToChannel(channelName, parts, NON_BLOCKING_SEND_OPTIONS)
       );
       if (result.status === ZLinkSubmitStatus.TargetNotFound) {
         this.metrics?.recordChannelSelectionFailure(meshName, channelName, 'no_ready_target');
@@ -564,9 +611,21 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
-    return runWithOutboundFlow(this.flowCreationEnabled(), () =>
+    if (!this.flowCreationEnabled())
+      return this.requestToChannelScoped<TReply>(
+        meshName,
+        channelName,
+        packetName,
+        request,
+        timeoutMs,
+        signal,
+        metadata,
+        onAdmitted
+      );
+    return runWithOutboundFlow(true, () =>
       this.requestToChannelScoped<TReply>(
         meshName,
         channelName,
@@ -574,7 +633,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
         request,
         timeoutMs,
         signal,
-        metadata
+        metadata,
+        onAdmitted
       )
     );
   }
@@ -586,7 +646,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
     throwIfAborted(signal);
     const node = this.requireMeshNode(meshName);
@@ -600,54 +661,34 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     );
     const metric = this.metrics?.startRequest(meshName, 'channel');
     try {
-      const completion = await this.submitRequestOperation(
-        meshName,
-        timeoutMs,
-        signal,
-        `MeshNode '${meshName}' request to channel '${channelName}'`,
-        (remainingTimeoutMs) =>
-          node.requestToChannel(channelName, parts, { flags: 1, timeoutMs: remainingTimeoutMs })
-      );
+      const requestOptions = { flags: 1, timeoutMs: requestTimeoutBudget(timeoutMs), onAdmitted };
+      let completion: ZLinkMeshCompletion;
+      try {
+        completion = await this.completionTable(meshName).submit(
+          () => node.requestToChannel(channelName, parts, requestOptions),
+          signal
+        );
+      } catch (error) {
+        throw mapMeshSubmissionError(
+          error,
+          `MeshNode '${meshName}' request to channel '${channelName}'`
+        );
+      }
       const reply = this.decodeMeshReply<TReply>(meshName, completion);
       metric?.complete('completed');
       return reply;
     } catch (error) {
-      metric?.complete(requestMetricOutcome(error));
-      if (requestMetricOutcome(error) === 'target_not_found') {
+      metric?.complete(requestMetricOutcome(error, signal));
+      if (
+        error instanceof ZLinkFrameworkException &&
+        internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.RequestTargetNotFound
+      ) {
         this.metrics?.recordChannelSelectionFailure(meshName, channelName, 'no_ready_target');
       }
       throw error;
     }
   }
 
-  private async submitRequestOperation(
-    meshName: string,
-    timeoutMs: number | undefined,
-    signal: AbortSignal | undefined,
-    operation: string,
-    attempt: (
-      remainingTimeoutMs: number
-    ) => ReturnType<Parameters<ZLinkMeshCompletionTable['submit']>[0]>
-  ): Promise<ZLinkMeshCompletion> {
-    const effectiveTimeoutMs = Math.max(1, timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
-    const deadlineMs = performance.now() + effectiveTimeoutMs;
-    const remainingTimeoutMs = deadlineMs - performance.now();
-    if (remainingTimeoutMs <= 0) {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
-        `${operation} timed out before submission.`
-      );
-    }
-    try {
-      return await this.completionTable(meshName).submit(
-        () => attempt(Math.max(1, Math.ceil(remainingTimeoutMs))),
-        signal
-      );
-    } catch (error) {
-      throw mapMeshSubmissionError(error, operation);
-    }
-  }
-
   sendToSpot(
     spotRouteTarget: ZLinkSpotRouteTarget,
     message: unknown,
@@ -767,7 +808,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
         request,
         options.timeoutMs,
         options.signal,
-        options.metadata
+        options.metadata,
+        options.onAdmitted
       );
     }
     throwIfAborted(options.signal);
@@ -790,7 +832,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
                 options.timeoutMs,
                 undefined,
                 options.metadata,
-                options.instanceSpot
+                options.instanceSpot,
+                options.onAdmitted
               )
             : node
                 .entrySpot()
@@ -801,6 +844,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
                   encoded,
                   {
                     flags: 1,
+                    onAdmitted: options.onAdmitted,
                     timeoutMs: options.timeoutMs,
                     routeFence: directSpotRouteFence(spotRouteTarget),
                     entrySpot: spotRouteTarget.spotKind === ZLinkSpotKind.Entry
@@ -825,6 +869,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       readonly packetName?: string;
       readonly timeoutMs?: number;
       readonly signal?: AbortSignal;
+      readonly onAdmitted?: () => void;
     }
   ): Promise<TReply> {
     return this.requireManager().routeRequestFromSpotToSpot<TReply>(
@@ -833,7 +878,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       options.packetName,
       request,
       options.timeoutMs,
-      options.signal
+      options.signal,
+      options.onAdmitted
     );
   }
 
@@ -841,21 +887,30 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     sourceSpot: ZLinkBackendSpot,
     spotRouteTarget: ZLinkSpotRouteTarget,
     request: Message,
-    options: { readonly timeoutMs?: number; readonly signal?: AbortSignal }
+    options: {
+      readonly timeoutMs?: number;
+      readonly signal?: AbortSignal;
+      readonly onAdmitted?: () => void;
+    }
   ): Promise<readonly Message[]> {
     return this.requireManager().routeRequestRawFromSpotToSpot(
       sourceSpot,
       spotRouteTarget,
       request,
       options.timeoutMs,
-      options.signal
+      options.signal,
+      options.onAdmitted
     );
   }
 
   requestRawToSpot(
     spotRouteTarget: ZLinkSpotRouteTarget,
     request: Message,
-    options: { readonly timeoutMs?: number; readonly signal?: AbortSignal }
+    options: {
+      readonly timeoutMs?: number;
+      readonly signal?: AbortSignal;
+      readonly onAdmitted?: () => void;
+    }
   ): Promise<readonly Message[]> {
     return runWithOutboundFlow(this.flowCreationEnabled(), () =>
       this.requestRawToSpotScoped(spotRouteTarget, request, options)
@@ -865,7 +920,11 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
   private async requestRawToSpotScoped(
     spotRouteTarget: ZLinkSpotRouteTarget,
     request: Message,
-    options: { readonly timeoutMs?: number; readonly signal?: AbortSignal }
+    options: {
+      readonly timeoutMs?: number;
+      readonly signal?: AbortSignal;
+      readonly onAdmitted?: () => void;
+    }
   ): Promise<readonly Message[]> {
     const meshName = spotRouteTarget.routerChannelId;
     const node = this.meshNode(meshName);
@@ -893,6 +952,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
                 parts,
                 {
                   flags: 1,
+                  onAdmitted: options.onAdmitted,
                   timeoutMs: options.timeoutMs,
                   routeFence: directSpotRouteFence(spotRouteTarget),
                   entrySpot: spotRouteTarget.spotKind === ZLinkSpotKind.Entry
@@ -925,7 +985,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       spotRouteTarget,
       request,
       options.timeoutMs,
-      options.signal
+      options.signal,
+      options.onAdmitted
     );
   }
 
@@ -938,21 +999,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
   }
 
   private meshNode(meshName: string): ZLinkBackendMeshNode | undefined {
-    const runtime = this.meshRuntime?.();
-    return (
-      runtime as unknown as
-        | {
-            meshNode?: (meshName: string) => ZLinkBackendMeshNode | undefined;
-          }
-        | undefined
-    )?.meshNode?.(meshName);
-  }
-
-  private isSelfNode(node: ZLinkBackendMeshNode, targetNodeRid: string): boolean {
-    return routingIdsEqual(
-      node.status().routingId as unknown as import('../../contracts').RoutingId,
-      targetNodeRid
-    );
+    return this.meshRuntime?.()?.meshNode?.(meshName);
   }
 
   private isKnownBackendPeer(node: ZLinkBackendMeshNode, targetNodeRid: string): boolean {
@@ -1101,6 +1148,14 @@ function instanceSpotRouteFence(target: ZLinkSpotRouteTarget): ServiceInstanceRo
   };
 }
 
+/**
+ * The binding request timeout for one submission. The binding owns the
+ * deadline after submit; the completion table slot only waits for it.
+ */
+function requestTimeoutBudget(timeoutMs: number | undefined): number {
+  return Math.max(1, Math.ceil(timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS));
+}
+
 function mapMeshSubmitResult(result: number): ZLinkSubmitResult {
   return classifySubmitResult(result, 'Mesh submission');
 }
@@ -1192,14 +1247,18 @@ export function meshRequestFailure(
   return error;
 }
 
-function requestMetricOutcome(error: unknown): string {
+function requestMetricOutcome(error: unknown, signal?: AbortSignal): string {
   if (error instanceof ZLinkFrameworkException) {
-    if (internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.RequestTargetNotFound)
-      return 'target_not_found';
     if (internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.DeadlineExceeded)
       return 'timed_out';
     if (internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.RuntimeShutdown)
       return 'shutdown';
   }
+  if (
+    signal?.aborted === true &&
+    (error === signal.reason ||
+      (error instanceof Error && (error.cause === signal.reason || error.name === 'AbortError')))
+  )
+    return 'cancelled';
   return 'failed';
 }

package/src/runtime/channels/client-server-location-runtime.ts

@@ -1,3 +1,4 @@
+import { routingIdsEqual } from '../routing-id';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLINK_DEFAULT_PUBLIC_WEIGHT } from '../../contracts/Configuration/RegistrationBuilderPolicy';
 import {
@@ -121,9 +122,9 @@ export class ZLinkClientServerLocationRuntime {
         ownerId: owner.ownerId,
         leaseGeneration: owner.leaseGeneration
       };
-      const result = await this.store.updateClientServer(
-        candidate,
-        ZLinkLocationWriteIntent.Takeover,
+      const result = await this.locationRuntime.writeDescriptor(
+        (writeSignal) =>
+          this.store.updateClientServer(candidate, ZLinkLocationWriteIntent.Takeover, writeSignal),
         signal
       );
       if (result.status !== ZLinkLocationWriteStatus.Stored) {
@@ -152,9 +153,9 @@ export class ZLinkClientServerLocationRuntime {
                 descriptorRevision: current.descriptorRevision + 1n,
                 weight: runtimeWeight
               };
-        const result = await this.store.updateClientServer(
-          candidate,
-          ZLinkLocationWriteIntent.Renew,
+        const result = await this.locationRuntime.writeDescriptor(
+          (writeSignal) =>
+            this.store.updateClientServer(candidate, ZLinkLocationWriteIntent.Renew, writeSignal),
           signal
         );
         if (result.status !== ZLinkLocationWriteStatus.Stored) {
@@ -181,9 +182,9 @@ export class ZLinkClientServerLocationRuntime {
         leaseGeneration: owner.leaseGeneration,
         updatedAt: new Date(0)
       };
-      const result = await this.store.updateClientServer(
-        descriptor,
-        ZLinkLocationWriteIntent.NewClaim,
+      const result = await this.locationRuntime.writeDescriptor(
+        (writeSignal) =>
+          this.store.updateClientServer(descriptor, ZLinkLocationWriteIntent.NewClaim, writeSignal),
         signal
       );
       if (result.status !== ZLinkLocationWriteStatus.Stored) {
@@ -587,7 +588,7 @@ function requireMatchingAdmission(
 ): void {
   if (
     actual.channelName !== expected.channelName ||
-    actual.serverRid !== String(expected.serverRid) ||
+    !routingIdsEqual(actual.serverRid, expected.serverRid) ||
     actual.lifecycleGeneration !== expected.lifecycleGeneration ||
     actual.descriptorRevision !== expected.descriptorRevision ||
     actual.weight !== expected.weight ||

package/src/runtime/channels/dispatch-error-reporter.ts

@@ -21,6 +21,7 @@ export type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port'
 
 type ZLinkRuntimeDispatchFailure = ZLinkDispatchFailure & {
   readonly error?: unknown;
+  readonly severity?: 'warning';
 };
 
 export class ZLinkDispatchErrorReporter {
@@ -37,7 +38,7 @@ export class ZLinkDispatchErrorReporter {
     _providerResolver: unknown,
     errorSink: ZLinkDispatchErrorSink,
     ctx?: ZLinkDiagnosticsContext,
-    private readonly metrics?: ZLinkRuntimeMetrics
+    readonly metrics?: ZLinkRuntimeMetrics
   ) {
     const flowCtx: ZLinkDiagnosticsContext = ctx ?? {
       diagnostics: DEFAULT_ZLINK_DIAGNOSTICS,
@@ -86,7 +87,8 @@ export class ZLinkDispatchErrorReporter {
       errorType: errorInfo.errorType,
       errorMessage: errorInfo.errorMessage,
       errorCauseType: errorInfo.errorCauseType,
-      errorCauseMessage: errorInfo.errorCauseMessage
+      errorCauseMessage: errorInfo.errorCauseMessage,
+      severity: normalized.severity
     });
   }