@zlink-systems/framework 0.18.1 → 0.20.0

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -137,6 +137,7 @@ class ZLinkSpotNodeRuntimeManager {
             const node = meshAdapter.createMeshNode(this.options.context, {
                 meshName: spotNodeName,
                 routingId,
+                receiveTimeoutMs: spotNode.router?.receiveTimeoutMs,
                 applicationJobQueue: this.applicationJobQueue,
                 applicationJobReceiveFlowFailureSink: this.options.applicationJobReceiveFlowFailureSink,
                 peerAdmissionSealed: () => this.options.peerAdmissionSealed?.(spotNodeName) ?? false
@@ -399,8 +400,7 @@ class ZLinkSpotNodeRuntimeManager {
         await this.publishMeshNodeState(state, signal, meshName);
     }
     entrySpotId(meshName, registration) {
-        if (effectiveObjectRole(registration) !== contracts_1.ZLinkObjectRole.Server
-            || registration.entrySpotType === undefined) {
+        if (effectiveObjectRole(registration) !== contracts_1.ZLinkObjectRole.Server) {
             return undefined;
         }
         let entrySpotId = this.entrySpotIds.get(meshName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.18.1",
+  "version": "0.20.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.18.1",
+    "@zlink-systems/stream-wire": "0.20.0",
     "@zlink-systems/zlink": "1.2.1"
   }
 }

package/src/contracts/Configuration/Builders.ts

@@ -103,8 +103,6 @@ export interface ZLinkMeshChannelServerBuilder {
 export interface ZLinkMeshNodeSocketConfig {
   sendHighWaterMark: number;
   receiveHighWaterMark: number;
-  mailboxMessageBudget: number;
-  mailboxByteBudget: number;
   receiveTimeoutMs?: number;
   sendTimeoutMs?: number;
 }

package/src/contracts/Configuration/Configs.ts

@@ -7,6 +7,7 @@ export interface ZLinkSocketConfig {
   weight?: number;
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
+  receiveTimeoutMs?: number;
   sendTimeoutMs?: number;
 }
 

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -198,8 +198,6 @@ export interface ZLinkClientCapabilityOptions {
   readonly manualConnections?: readonly string[];
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
-  readonly mailboxMessageBudget?: number;
-  readonly mailboxByteBudget?: number;
   readonly sendTimeoutMs?: number;
   readonly maxMessageSize?: number;
 }
@@ -434,6 +432,7 @@ export interface ZLinkSpotRouterCapabilityOptions {
   readonly routingId?: string;
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
+  readonly receiveTimeoutMs?: number;
   readonly sendTimeoutMs?: number;
 }
 

package/src/contracts/Locations/Authority.ts

@@ -154,12 +154,9 @@ export interface ZLinkCreationOperationIdentity {
   readonly operationId: ZLinkCreationOperationId;
 }
 
-export type ZLinkCreationTerminalState = 'created' | 'rejected' | 'failed';
-
 export interface ZLinkCreationTerminalPublication {
   readonly operation: ZLinkCreationOperationIdentity;
   readonly terminalEnvelope: Uint8Array;
-  readonly terminalEnvelopeSha256: Uint8Array;
   /**
    * The original operation deadline. Providers retain the terminal for five
    * minutes after this absolute instant.
@@ -168,19 +165,15 @@ export interface ZLinkCreationTerminalPublication {
 }
 
 export interface ZLinkCreationTerminalRecord {
-  readonly state: ZLinkCreationTerminalState;
   readonly operation: ZLinkCreationOperationIdentity;
-  readonly reservationId: string;
-  readonly objectKind: ZLinkPlacementObjectKind;
   readonly terminalEnvelope: Uint8Array;
-  readonly terminalEnvelopeSha256: Uint8Array;
   readonly expiresAt: Date;
   readonly storeNow: Date;
 }
 
 export type ZLinkCreationTerminalReadResult =
   | { readonly kind: 'missing'; readonly storeNow: Date }
-  | { readonly kind: 'found'; readonly record: ZLinkCreationTerminalRecord };
+  | { readonly kind: 'found'; readonly terminalEnvelope: Uint8Array };
 
 export interface ZLinkObjectReserveRequest {
   readonly key: ZLinkObjectCreationKey;

package/src/runtime/actors/actor-authority-publication.ts

@@ -1,4 +1,4 @@
-import { createHash, randomBytes } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import type {
   ActorRef
 } from '../../contracts';
@@ -6,6 +6,7 @@ import { ZLinkSpotKind } from '../../contracts';
 import type { ZLinkLocationOwnerToken } from '../../contracts/Locations';
 import type { ZLinkAuthoritySnapshot } from '../locations/internal-location-contracts';
 import type { ZLinkObjectCreationStore } from '../locations/internal-store-contracts';
+import { randomOperationId } from '../locations/creation-operation-id';
 import {
   actorRelocationAuthorityApplicationPayload,
   decodeActorAuthorityPayload,
@@ -18,6 +19,7 @@ import {
   replaceServiceRelocationAuthorityApplicationPayload,
   serviceRelocationAuthorityApplicationPayload
 } from '../foundation/service-relocation-runtime';
+import { encodeCreationOperationTerminalV1 } from '../protocol/service_wire_codec.generated';
 
 const CREATION_OPERATION_TIMEOUT_MS = 30_000;
 
@@ -74,12 +76,20 @@ export async function publishInitialActorAuthority(
   }
 
   try {
-    const terminalEnvelope = Buffer.from(JSON.stringify({
-      status: 'created',
-      actorId: identity.actor.actorId,
-      actorGeneration: identity.actor.objectGeneration.toString()
-    }), 'utf8');
-    const operationBytes = randomBytes(16);
+    const terminalEnvelope = Buffer.from(encodeCreationOperationTerminalV1({
+      terminalResult: 'ok',
+      failureCode: 'none',
+      hasCreation: 'true',
+      creation: {
+        createResult: 'created',
+        actor: {
+          actorId: identity.actor.actorId,
+          objectGeneration: identity.actor.objectGeneration
+        }
+      },
+      hasApplicationPayload: 'false'
+    }, { runtimePredicates: {} }));
+    const operationId = randomOperationId();
     const completed = await store.completeCreation({
       key: { kind: 'actor', globalId: identity.actor.actorId },
       reservationId: reserved.reservationId,
@@ -92,13 +102,9 @@ export async function publishInitialActorAuthority(
           operation: {
             sourceNodeRid: identity.actor.nodeRid,
             sourceNodeGeneration: identity.ownerNodeGeneration,
-            operationId: {
-              high: operationBytes.readBigUInt64BE(0),
-              low: operationBytes.readBigUInt64BE(8)
-            }
+            operationId
           },
           terminalEnvelope,
-          terminalEnvelopeSha256: createHash('sha256').update(terminalEnvelope).digest(),
           operationDeadline: new Date(Date.now() + CREATION_OPERATION_TIMEOUT_MS)
         }
       }
@@ -111,16 +117,13 @@ export async function publishInitialActorAuthority(
     requireActorAuthority(completed.ready, identity);
     return completed.ready;
   } catch (error) {
-    try {
-      await store.abort({
-        key: { kind: 'actor', globalId: identity.actor.actorId },
-        reservationId: reserved.reservationId,
-        expectedStoreVersion: reserved.creating.storeVersion.value,
-        target
-      }, signal);
-    } catch {
-      // A completed creation cannot be aborted; the validated authority remains.
-    }
+    const aborted = await store.abort({
+      key: { kind: 'actor', globalId: identity.actor.actorId },
+      reservationId: reserved.reservationId,
+      expectedStoreVersion: reserved.creating.storeVersion.value,
+      target
+    }, signal);
+    if (aborted.kind === 'stale') throw error;
     throw error;
   }
 }

package/src/runtime/actors/actor-creation.ts

@@ -3,6 +3,7 @@ import type {
   RoutingId,
   Type,
   ZLinkActor,
+  ZLinkActorCreateResponse,
   ZLinkActorFactory,
 } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
@@ -53,10 +54,17 @@ export class ZLinkActorCreationCoordinator {
           this.options.actorDestroyedCleanup?.(actorId);
           state.clearAfterDestroy();
         },
-        () => this.createActorAfterClaim(actorId, actorType, state, createRequest, true, signal)
+        () => this.createActorAfterClaim(
+          actorId,
+          actorType,
+          state,
+          createRequest,
+          true,
+          signal
+        )
       );
       if (activation.activated !== undefined) {
-        if (activation.activated.status === 'rejected') {
+        if (activation.activated.status !== 'created') {
           await lifecycle.releaseActor(actorType, actorId);
           return activation.activated;
         }
@@ -77,7 +85,14 @@ export class ZLinkActorCreationCoordinator {
       );
     }
 
-    return await this.createActorAfterClaim(actorId, actorType, state, createRequest, claimLocation, signal);
+    return await this.createActorAfterClaim(
+      actorId,
+      actorType,
+      state,
+      createRequest,
+      claimLocation,
+      signal
+    );
   }
 
   async materializeTransferredActor(
@@ -122,27 +137,41 @@ export class ZLinkActorCreationCoordinator {
       this.options.actorMeshNameProvider
     ));
     const nativeActorNode = this.options.nativeActorNode ?? this.options.nativeActorNodeProvider?.();
+    let actor: ZLinkActor;
+    try {
+      actor = await factory.create(context, signal);
+    } catch (error) {
+      await this.discardStagingActor(state, nativeActorNode);
+      return { status: 'failed', error };
+    }
+    let meshName: string;
+    let nodeRid: RoutingId | undefined;
     try {
-      const actor = await factory.create(context, signal);
       if (actor.context !== context || actor.context.actorId !== context.actorId) {
         throw new ZLinkConfigurationException(
           `Actor factory '${actorType}' must return an Actor bound to the exact supplied context.`
         );
       }
-      const meshName = state.meshName ?? '';
+      meshName = state.meshName ?? '';
       if (meshName.length === 0 && state.nativeActorRef === undefined) {
         throw new ZLinkConfigurationException(
           `Actor '${actorId}' has no RouteMesh identity.`
         );
       }
-      let nodeRid: RoutingId | undefined;
       if (nativeActorNode !== undefined) {
         const actorRef = state.ensureNativeActorRef(nativeActorNode, createRequest.nativeRequest);
         nodeRid = toFrameworkRoutingId(actorRef.nodeRid);
       } else {
         nodeRid = this.options.actorCreatedNodeRidProvider?.();
       }
-      const response = nodeRid === undefined
+    } catch (error) {
+      await this.discardStagingActor(state, nativeActorNode);
+      throw error;
+    }
+
+    let response: ZLinkActorCreateResponse;
+    try {
+      response = nodeRid === undefined
         ? { accepted: true }
         : await this.options.actorCreatedNotifier?.(
           nodeRid,
@@ -150,11 +179,16 @@ export class ZLinkActorCreationCoordinator {
           createRequest.callbackRequest,
           signal
         ) ?? { accepted: true };
-      if (!response.accepted) {
-        await this.discardStagingActor(state, nativeActorNode);
-        return { status: 'rejected', reply: response.reply };
-      }
+    } catch (error) {
+      await this.discardStagingActor(state, nativeActorNode);
+      return { status: 'failed', error };
+    }
+    if (!response.accepted) {
+      await this.discardStagingActor(state, nativeActorNode);
+      return { status: 'rejected', reply: response.reply };
+    }
 
+    try {
       state.bindActor(actor, context);
       if (nativeActorNode !== undefined) {
         const actorRef = state.nativeActorRef!;

package/src/runtime/actors/actor-runtime-state.ts

@@ -257,6 +257,10 @@ export type ZLinkActorCreationAttemptResult =
   | {
       readonly status: 'rejected';
       readonly reply?: unknown;
+    }
+  | {
+      readonly status: 'failed';
+      readonly error: unknown;
     };
 
 export class ZLinkActorRuntimeState {

package/src/runtime/actors/index.ts

@@ -379,6 +379,9 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
         ? { status: 'rejected' }
         : { status: 'rejected', reply: result.reply };
     }
+    if (result.status === 'failed') {
+      throw actorApplicationFailure(actorId, result.error);
+    }
     return result.reply === undefined
       ? { status: result.status, actor: result.actorRef }
       : { status: result.status, actor: result.actorRef, reply: result.reply };
@@ -720,12 +723,19 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       const operation = state.getOrStartCreation(
         actorType,
         failIfExists,
-        () => this.creation.createActor(actorId, actorType, state, createRequest, claimLocation, signal)
+        () => this.creation.createActor(
+          actorId,
+          actorType,
+          state,
+          createRequest,
+          claimLocation,
+          signal
+        )
       );
       if (operation.created) {
         void operation.task.then(
           (result) => {
-            if (result.status === 'rejected') {
+            if (result.status !== 'created') {
               this.discardFailedState(actorId, state, operation.task);
             }
           },
@@ -745,7 +755,9 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
           };
         }
         if (operation.created) {
-          return { status: 'rejected', reply: result.reply };
+          return result.status === 'failed'
+            ? { status: 'failed', error: result.error }
+            : { status: 'rejected', reply: result.reply };
         }
       } catch (error) {
         if (operation.created) {
@@ -936,16 +948,32 @@ export type ZLinkActorLocalCreateResult =
   | {
       readonly status: 'rejected';
       readonly reply?: unknown;
+    }
+  | {
+      readonly status: 'failed';
+      readonly error: unknown;
     };
 
 function requireCreatedActor(result: ZLinkActorLocalCreateResult, actorId: string): ZLinkActor {
-  if (result.status !== 'rejected') return result.actor;
+  if (result.status === 'existing' || result.status === 'created') return result.actor;
+  if (result.status === 'failed') {
+    throw actorApplicationFailure(actorId, result.error);
+  }
   throw createInternalFrameworkException(
     ZLinkFrameworkInternalErrorKind.ActorCreateRejected,
     `Actor '${actorId}' create request was rejected.`
   );
 }
 
+function actorApplicationFailure(actorId: string, error: unknown): ZLinkFrameworkException {
+  return createInternalFrameworkException(
+    ZLinkFrameworkInternalErrorKind.ActorCreateFailed,
+    `Actor '${actorId}' creation failed: ${error instanceof Error ? error.message : String(error)}`,
+    false,
+    error
+  );
+}
+
 async function waitForCreationRetry(signal?: AbortSignal): Promise<void> {
   throwIfAborted(signal);
   await new Promise<void>((resolve, reject) => {

package/src/runtime/admission.ts

@@ -2,7 +2,10 @@ import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException  } fr
 export class ZLinkRuntimeAdmissionGate {
   private readonly meshes = new Map<string, ZLinkMeshAdmissionState>();
 
+  constructor(private readonly ownerAdmissionOpen: () => boolean = () => true) {}
+
   get acceptsNewWork(): boolean {
+    if (!this.ownerAdmissionOpen()) return false;
     for (const state of this.meshes.values()) {
       if (state.sealed) return false;
     }
@@ -23,7 +26,7 @@ export class ZLinkRuntimeAdmissionGate {
   }
 
   accepts(meshName: string): boolean {
-    return !this.requireState(meshName).sealed;
+    return this.ownerAdmissionOpen() && !this.requireState(meshName).sealed;
   }
 
   pending(meshName: string): number {
@@ -48,7 +51,7 @@ export class ZLinkRuntimeAdmissionGate {
 
   claim(meshName: string, operation: string): ZLinkApplicationWorkClaim {
     const state = this.requireState(meshName);
-    if (!state.sealed) {
+    if (this.ownerAdmissionOpen() && !state.sealed) {
       state.active += 1;
       let closed = false;
       return {
@@ -65,7 +68,7 @@ export class ZLinkRuntimeAdmissionGate {
     }
     throw createInternalFrameworkException(
       state.sealedReason,
-      `${operation} was rejected because the framework is draining.`
+      `${operation} was rejected because framework admission is closed.`
     );
   }
 
@@ -113,7 +116,7 @@ export class ZLinkRuntimeAdmissionGate {
       meshName === undefined
         ? this.firstSealedReason()
         : this.requireState(meshName).sealedReason,
-      `${operation} was rejected because the framework is draining.`
+      `${operation} was rejected because framework admission is closed.`
     );
   }
 
@@ -130,7 +133,7 @@ export class ZLinkRuntimeAdmissionGate {
       reason === ZLinkFrameworkInternalErrorKind.RuntimeShutdown
         ? ZLinkFrameworkInternalErrorKind.RuntimeShutdown
         : ZLinkFrameworkInternalErrorKind.ActorCreateRejected,
-      `Actor '${actorId}' create request was rejected because the framework is draining.`
+      `Actor '${actorId}' create request was rejected because framework admission is closed.`
     );
   }
 

package/src/runtime/backend/contracts/index.ts

@@ -157,7 +157,7 @@ export interface ZLinkBackendMeshNode {
   ): Promise<ServiceUserSpotOperationResult>;
   requestActorCreate(
     targetNodeRid: string,
-    request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>,
+    request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>,
     timeoutMs: number
   ): Promise<ServiceUserSpotOperationResult>;
   connectPeer(options: {
@@ -503,6 +503,7 @@ export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket
   peerWeight: number;
   sendHighWaterMark: number;
   receiveHighWaterMark: number;
+  receiveTimeoutMs: number;
   sendTimeoutMs: number;
   maxMessageSize: number;
   send(message: Message | readonly Message[]): Promise<void>;
@@ -536,6 +537,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
   peerWeight: number;
   sendHighWaterMark: number;
   receiveHighWaterMark: number;
+  receiveTimeoutMs: number;
   sendTimeoutMs: number;
   maxMessageSize: number;
   setRoutingId(routingId: RoutingId): void;
@@ -740,6 +742,7 @@ export interface ZLinkMeshBackendAdapter {
     options: {
       readonly meshName: string;
       readonly routingId?: RoutingId;
+      readonly receiveTimeoutMs?: number;
       readonly trustProfile?: string;
       readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;
       readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void;

package/src/runtime/backend/node/node-mesh-backend-adapter.ts

@@ -13,6 +13,7 @@ export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
     options: {
       readonly meshName: string;
       readonly routingId?: string;
+      readonly receiveTimeoutMs?: number;
       readonly trustProfile?: string;
       readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;
       readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void;
@@ -29,7 +30,7 @@ export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
     return new ZLinkNodeRawMeshBackend(
       options.meshName,
       options.routingId,
-      new ZLinkNodeRawBindingPort(bindingContext),
+      new ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs),
       options.applicationJobQueue,
       options.applicationJobReceiveFlowFailureSink,
       options.peerAdmissionSealed

package/src/runtime/backend/node/node-raw-binding-port.ts

@@ -47,12 +47,16 @@ export type {
 } from '../raw-binding-port';
 
 export class ZLinkNodeRawBindingPort implements ZLinkRawBindingPort {
-  constructor(private readonly sharedContext?: Context) {}
+  constructor(
+    private readonly sharedContext?: Context,
+    private readonly routerReceiveTimeoutMs?: number
+  ) {}
 
   createHost(): ZLinkRawHostPort {
     return new NodeRawHostPort(
       this.sharedContext ?? createContext(),
-      this.sharedContext === undefined
+      this.sharedContext === undefined,
+      this.routerReceiveTimeoutMs
     );
   }
 }
@@ -63,12 +67,16 @@ class NodeRawHostPort implements ZLinkRawHostPort {
 
   constructor(
     private readonly context: Context,
-    private readonly ownsContext: boolean
+    private readonly ownsContext: boolean,
+    private readonly routerReceiveTimeoutMs?: number
   ) {}
 
   createRouter(): ZLinkRawRouterPort {
     this.requireOpen();
-    return this.own(new NodeRawRouterPort(createRouterSocket(this.context)));
+    return this.own(new NodeRawRouterPort(
+      createRouterSocket(this.context),
+      this.routerReceiveTimeoutMs
+    ));
   }
 
   createDealer(): ZLinkRawDealerPort {
@@ -230,11 +238,14 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
     }).disconnectRid(bindingRoutingId(routingId));
   }
 
-  constructor(socket: RouterSocket) {
+  constructor(socket: RouterSocket, receiveTimeoutMs?: number) {
     super(socket);
     socket.options.handover = true;
     socket.options.mandatory = true;
     socket.options.probe = true;
+    if (receiveTimeoutMs !== undefined) {
+      socket.options.recvTimeout = receiveTimeoutMs;
+    }
   }
 
   localEndpoint(): string {

package/src/runtime/backend/node/node-raw-mesh-backend.ts

@@ -1008,7 +1008,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
 
   requestActorCreate(
     targetNodeRid: string,
-    request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>,
+    request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>,
     timeoutMs: number
   ): Promise<ServiceUserSpotOperationResult> {
     return this.requireStateful().requestActorCreate(targetNodeRid, request, timeoutMs);

package/src/runtime/backend/node/node-socket-backend-adapter.ts

@@ -32,6 +32,7 @@ export function wrapSocket<T extends { close(): void }>(
       peerWeight?: number;
       sendHwm?: number;
       recvHwm?: number;
+      recvTimeout?: number;
       sendTimeout?: number;
       noDrop?: boolean;
       maxMsgSize?: bigint;
@@ -129,6 +130,12 @@ export function wrapSocket<T extends { close(): void }>(
     set receiveHighWaterMark(value: number) {
       requireSocketOptions(socket).recvHwm = value;
     },
+    get receiveTimeoutMs(): number {
+      return socket.options?.recvTimeout ?? 0;
+    },
+    set receiveTimeoutMs(value: number) {
+      requireSocketOptions(socket).recvTimeout = value;
+    },
     get sendTimeoutMs(): number {
       return socket.options?.sendTimeout ?? 0;
     },

package/src/runtime/channels/channel-socket-options.ts

@@ -53,6 +53,15 @@ class ZLinkLiveSocketConfig implements ZLinkSocketConfig {
     this.socket.receiveHighWaterMark = value;
   }
 
+  get receiveTimeoutMs(): number {
+    return this.socket.receiveTimeoutMs;
+  }
+
+  set receiveTimeoutMs(value: number) {
+    requireValidSendTimeoutMs('receiveTimeoutMs', value);
+    this.socket.receiveTimeoutMs = value;
+  }
+
   get sendTimeoutMs(): number {
     return this.socket.sendTimeoutMs;
   }

package/src/runtime/channels/channel-socket-registry.ts

@@ -1854,6 +1854,7 @@ function applySocketConfig(
   config: {
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
+    readonly receiveTimeoutMs?: number;
     readonly sendTimeoutMs?: number;
     readonly maxMessageSize?: number;
   }
@@ -1864,6 +1865,9 @@ function applySocketConfig(
   if (config.receiveHighWaterMark !== undefined) {
     socket.receiveHighWaterMark = config.receiveHighWaterMark;
   }
+  if (config.receiveTimeoutMs !== undefined) {
+    socket.receiveTimeoutMs = config.receiveTimeoutMs;
+  }
   if (config.sendTimeoutMs !== undefined) {
     socket.sendTimeoutMs = config.sendTimeoutMs;
   }

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

@@ -750,14 +750,10 @@ export class ServiceStatefulRuntime {
 
   requestActorCreate(
     targetNodeRid: string,
-    request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>,
+    request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>,
     timeoutMs: number
   ): Promise<ServiceUserSpotOperationResult> {
     const correlation = this.nextUserSpotOperation++;
-    const operation = {
-      high: this.nodeGeneration,
-      low: correlation
-    };
     return this.requestUserSpotOperation(
       targetNodeRid,
       encodeActorCreateHeader({
@@ -765,7 +761,7 @@ export class ServiceStatefulRuntime {
         sourceNodeRid: this.nodeRid,
         sourceNodeGeneration: this.nodeGeneration,
         correlation,
-        operation
+        operation: request.operation
       }),
       correlation,
       'actorCreate',