@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/foundation/service-stateful-wire-codec.ts

@@ -3,6 +3,7 @@ import { decodeBoundSessionCloseCommand } from '../protocol/service_wire_codec.g
 import { UINT64_MAX, ZlinkStreamContentType } from '@zlink-systems/stream-wire';
 import { RELOCATION_STATE_CHUNK_DATA_MAX_BYTES } from '../../contracts/Configuration/InternalDefaults';
 import { isCanonicalWireReplyTerminal } from '../framework-errors-internal';
+import { RequestResult } from '../backend/runtime-values';
 import {
   decodeActorRequestCommand,
   decodeActorSendCommand,
@@ -1153,6 +1154,10 @@ export type ServiceStatefulReplyTail =
       readonly bindingGeneration: bigint;
       readonly authorityOwnerGeneration: bigint;
     }
+  | {
+      readonly kind: 'streamBindRejected';
+      readonly rejectionMessage: string;
+    }
   | {
       readonly kind: 'userSpotCreate';
       readonly createResult: 'existing' | 'created' | 'rejected';
@@ -2149,6 +2154,11 @@ export function decodeStatefulReply(
         ...(actor === undefined ? {} : { actor })
       };
     }
+  } else if (operationKind === 'streamBind' && terminalResult === RequestResult.Rejected) {
+    tail = {
+      kind: 'streamBindRejected',
+      rejectionMessage: reader.text16('rejectionMessage')
+    };
   }
   reader.end();
   return {
@@ -2222,6 +2232,8 @@ function encodeReplyTail(tail: ServiceStatefulReplyTail): Buffer {
     }
     case 'streamBind':
       return concat(u64(tail.bindingGeneration), u64(tail.authorityOwnerGeneration));
+    case 'streamBindRejected':
+      return concat(text16(tail.rejectionMessage, 'rejectionMessage'));
     case 'userSpotCreate':
       return concat(
         Buffer.of((['existing', 'created', 'rejected'] as const).indexOf(tail.createResult) + 1),
@@ -2404,6 +2416,12 @@ function text8(value: string, name: string): Buffer {
   return sized8(value, name);
 }
 
+function text16(value: string, name: string): Buffer {
+  const bytes = encodeCanonicalServiceWireText(value, name, 0xffff, outOfRange);
+  if (bytes.byteLength === 0) fail(`${name} must not be empty.`);
+  return concat(u16(bytes.byteLength), bytes);
+}
+
 function optionalRid(value: string | undefined): Buffer {
   return value === undefined ? Buffer.of(0) : rid(value, 'sourceSpotId');
 }

package/src/runtime/foundation/service-topology-registry.ts

@@ -214,6 +214,18 @@ export class ServiceTopologyRegistry {
     return this.peersByRid.get(nodeRoutingId);
   }
 
+  hasRemoteAdmit(nodeRoutingId: string, connectionId?: string | bigint): boolean {
+    const admission = this.routeAdmission(nodeRoutingId);
+    return (
+      admission?.remoteAdmitReceived === true &&
+      (connectionId === undefined || admission.connectionId === connectionId)
+    );
+  }
+
+  readyPeer(nodeRoutingId: string): AdmittedServicePeer | undefined {
+    return this.hasRemoteAdmit(nodeRoutingId) ? this.admittedPeer(nodeRoutingId) : undefined;
+  }
+
   peers(): readonly AdmittedServicePeer[] {
     return this.peersCore();
   }
@@ -331,7 +343,8 @@ export class ServiceTopologyRegistry {
       (value) => value.peer.descriptor.nodeRoutingId,
       (left, right) =>
         compareOrdinal(left.peer.descriptor.nodeRoutingId, right.peer.descriptor.nodeRoutingId),
-      (value) => isReady(value.peer)
+      (value) =>
+        this.readyPeer(value.peer.descriptor.nodeRoutingId) !== undefined && isReady(value.peer)
     )?.peer;
   }
 
@@ -357,7 +370,7 @@ export class ServiceTopologyRegistry {
       (peer) => peer.descriptor.nodeRoutingId,
       (left, right) =>
         compareOrdinal(left.descriptor.nodeRoutingId, right.descriptor.nodeRoutingId),
-      isReady
+      (peer) => this.readyPeer(peer.descriptor.nodeRoutingId) !== undefined && isReady(peer)
     );
   }
 
@@ -423,7 +436,12 @@ export class ServiceTopologyRegistry {
         descriptor.pendingCapacityUsed < descriptor.pendingCapacityLimit
     );
     if (withCapacity.length === 0) return { status: 'capacity', eligible: [] };
-    const weighted = withCapacity.filter((descriptor) => descriptor.placementWeight > 0);
+    const weighted = withCapacity.filter(
+      (descriptor) =>
+        descriptor.placementWeight > 0 &&
+        (descriptor.nodeRoutingId === this.local.nodeRoutingId ||
+          this.readyPeer(descriptor.nodeRoutingId) !== undefined)
+    );
     return { status: weighted.some(isReady) ? 'available' : 'unavailable', eligible: weighted };
   }
 

package/src/runtime/foundation/service-wire-constants.generated.ts

@@ -131,3 +131,13 @@ export const isValidServiceWireTerminalFailure = (
   }
   return ServiceWireExactTerminalByFailureCode[failureCode as keyof typeof ServiceWireExactTerminalByFailureCode] === terminal;
 };
+export function recoverRequestCorrelation(bytes: Uint8Array): bigint | undefined {
+  if (bytes.length < 13
+      || bytes[0] !== 90 || bytes[1] !== 77
+      || bytes[2] !== 1
+      || ![17, 19, 22, 25, 26, 27, 28, 38, 47, 48, 49, 54].includes(bytes[3]!)) return undefined;
+  let correlation = 0n;
+  for (let index = 5; index < 13; ++index)
+    correlation = (correlation << 8n) | BigInt(bytes[index]!);
+  return correlation === 0n ? undefined : correlation;
+}

package/src/runtime/foundation/service-wire-m6a-codec.ts

@@ -1,4 +1,5 @@
 import { UINT32_MAX, UINT64_MAX } from '@zlink-systems/stream-wire';
+import { allocatePayloadBytes } from '../../contracts/Common/payload-slab';
 import { normalizeEndpoint } from '../../contracts/Configuration/EndpointNotation';
 import {
   validateDescriptor,
@@ -185,10 +186,23 @@ export function decodeReplyHeader(frame: Uint8Array): ServiceReplyHeader {
 }
 
 export function encodeApplicationPayload(payload: ServiceApplicationPayload): Buffer {
+  return encodeApplicationPayloadWith(payload, allocatePayloadBytes);
+}
+
+/** Encodes a retained internal application frame with its own backing store. */
+export function encodeOwnedApplicationPayload(payload: ServiceApplicationPayload): Buffer {
+  return encodeApplicationPayloadWith(payload, allocateOwnedPayloadBytes);
+}
+
+function encodeApplicationPayloadWith(
+  payload: ServiceApplicationPayload,
+  allocate: (length: number) => Buffer
+): Buffer {
   const result = allocateApplicationPayload(
     payload.packetName,
     payload.contentType,
-    payload.payload.byteLength
+    payload.payload.byteLength,
+    allocate
   );
   result.set(payload.payload, result.byteLength - payload.payload.byteLength);
   return result;
@@ -200,35 +214,68 @@ export function encodeApplicationPayload(payload: ServiceApplicationPayload): Bu
  * the single ownership copy needed for the outbound frame.
  */
 export function encodeMultipartApplicationPayload(
-  parts: readonly Uint8Array[],
+  parts: readonly (Uint8Array | string)[],
   packetName: string,
   contentType: string
 ): Buffer {
+  const multipartLength = multipartPayloadLength(parts);
+  const result = allocateApplicationPayload(
+    packetName,
+    contentType,
+    multipartLength,
+    allocatePayloadBytes
+  );
+  writeMultipartPayload(result, result.byteLength - multipartLength, parts);
+  return result;
+}
+
+/** Encodes bare multipart bytes with the same writer as application frames. */
+export function encodeMultipartPayload(parts: readonly (Uint8Array | string)[]): Buffer {
+  const result = Buffer.alloc(multipartPayloadLength(parts));
+  writeMultipartPayload(result, 0, parts);
+  return result;
+}
+
+function multipartPartLength(part: Uint8Array | string): number {
+  return typeof part === 'string' ? Buffer.byteLength(part, 'utf8') : part.byteLength;
+}
+
+function multipartPayloadLength(parts: readonly (Uint8Array | string)[]): number {
   if (parts.length === 0) fail('Multipart payload must contain at least one part.');
   if (parts.length > MAX_U32) fail('Multipart part count exceeds u32.');
-  let multipartLength = 4;
-  for (const part of parts) {
-    if (part.byteLength > MAX_U32) fail('Multipart part exceeds u32.');
-    multipartLength += 4 + part.byteLength;
-    if (multipartLength > MAX_U32) fail('Multipart payload exceeds u32.');
-  }
-  const result = allocateApplicationPayload(packetName, contentType, multipartLength);
-  let offset = result.byteLength - multipartLength;
+  let length = 4;
+  for (let index = 0; index < parts.length; index += 1) {
+    const partLength = multipartPartLength(parts[index]!);
+    if (partLength > MAX_U32) fail('Multipart part exceeds u32.');
+    length += 4 + partLength;
+    if (length > MAX_U32) fail('Multipart payload exceeds u32.');
+  }
+  return length;
+}
+
+function writeMultipartPayload(
+  result: Buffer,
+  offset: number,
+  parts: readonly (Uint8Array | string)[]
+): void {
   result.writeUInt32BE(parts.length, offset);
   offset += 4;
-  for (const part of parts) {
-    result.writeUInt32BE(part.byteLength, offset);
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index]!;
+    const length = multipartPartLength(part);
+    result.writeUInt32BE(length, offset);
     offset += 4;
-    result.set(part, offset);
-    offset += part.byteLength;
+    if (typeof part === 'string') result.write(part, offset, length, 'utf8');
+    else result.set(part, offset);
+    offset += length;
   }
-  return result;
 }
 
 function allocateApplicationPayload(
   packetName: string,
   contentType: string,
-  payloadLength: number
+  payloadLength: number,
+  allocate: (length: number) => Buffer
 ): Buffer {
   const packetNameLength = canonicalServiceWireTextLength(
     packetName,
@@ -248,7 +295,8 @@ function allocateApplicationPayload(
   const prefixLength = 1 + APPLICATION_PAYLOAD_LENGTH_FIELD_BYTES;
   const bodyLength = frameLength - prefixLength;
   if (bodyLength > MAX_U32) fail('Application payload body exceeds u32.');
-  const result = Buffer.alloc(frameLength);
+  // Both callers write every payload byte after these header fields.
+  const result = allocate(frameLength);
   result[0] = APPLICATION_PAYLOAD_VERSION;
   result.writeUInt32BE(bodyLength, 1);
   let offset = writeText8(result, prefixLength, packetName, packetNameLength);
@@ -257,6 +305,10 @@ function allocateApplicationPayload(
   return result;
 }
 
+function allocateOwnedPayloadBytes(length: number): Buffer {
+  return Buffer.allocUnsafeSlow(length);
+}
+
 export function decodeApplicationPayload(frame: Uint8Array): ServiceApplicationPayload {
   const decoded = decodeApplicationPayloadView(frame);
   return {