@zlink-systems/framework 0.19.0 → 0.20.0

package/dist/contracts/Configuration/Builders.d.ts

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

package/dist/contracts/Configuration/Configs.d.ts

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

package/dist/contracts/Configuration/RegistrationTypes.d.ts

@@ -165,8 +165,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;
 }
@@ -359,6 +357,7 @@ export interface ZLinkSpotRouterCapabilityOptions {
     readonly routingId?: string;
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
+    readonly receiveTimeoutMs?: number;
     readonly sendTimeoutMs?: number;
 }
 export interface ZLinkSpotRouterPeerConnectionOptions {

package/dist/contracts/Locations/Authority.d.ts

@@ -128,11 +128,9 @@ export interface ZLinkCreationOperationIdentity {
     readonly sourceNodeGeneration: bigint;
     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.
@@ -140,12 +138,8 @@ export interface ZLinkCreationTerminalPublication {
     readonly operationDeadline: Date;
 }
 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;
 }
@@ -154,7 +148,7 @@ export type ZLinkCreationTerminalReadResult = {
     readonly storeNow: Date;
 } | {
     readonly kind: 'found';
-    readonly record: ZLinkCreationTerminalRecord;
+    readonly terminalEnvelope: Uint8Array;
 };
 export interface ZLinkObjectReserveRequest {
     readonly key: ZLinkObjectCreationKey;

package/dist/runtime/actors/actor-authority-publication.js

@@ -8,8 +8,10 @@ exports.rewriteActorAuthorityRoute = rewriteActorAuthorityRoute;
 exports.rewriteActorAuthorityOwner = rewriteActorAuthorityOwner;
 exports.isActorAuthorityPayload = isActorAuthorityPayload;
 const node_crypto_1 = require("node:crypto");
+const creation_operation_id_1 = require("../locations/creation-operation-id");
 const actor_authority_payload_codec_1 = require("./actor-authority-payload-codec");
 const service_relocation_runtime_1 = require("../foundation/service-relocation-runtime");
+const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
 const CREATION_OPERATION_TIMEOUT_MS = 30_000;
 /**
  * Publishes the authority record that owns durable Actor lifecycle state.
@@ -45,12 +47,20 @@ async function publishInitialActorAuthority(store, identity, signal) {
         throw new Error(`Actor '${identity.actor.actorId}' authority reservation failed with '${reserved.kind}'.`);
     }
     try {
-        const terminalEnvelope = Buffer.from(JSON.stringify({
-            status: 'created',
-            actorId: identity.actor.actorId,
-            actorGeneration: identity.actor.objectGeneration.toString()
-        }), 'utf8');
-        const operationBytes = (0, node_crypto_1.randomBytes)(16);
+        const terminalEnvelope = Buffer.from((0, service_wire_codec_generated_1.encodeCreationOperationTerminalV1)({
+            terminalResult: 'ok',
+            failureCode: 'none',
+            hasCreation: 'true',
+            creation: {
+                createResult: 'created',
+                actor: {
+                    actorId: identity.actor.actorId,
+                    objectGeneration: identity.actor.objectGeneration
+                }
+            },
+            hasApplicationPayload: 'false'
+        }, { runtimePredicates: {} }));
+        const operationId = (0, creation_operation_id_1.randomOperationId)();
         const completed = await store.completeCreation({
             key: { kind: 'actor', globalId: identity.actor.actorId },
             reservationId: reserved.reservationId,
@@ -63,13 +73,9 @@ async function publishInitialActorAuthority(store, identity, signal) {
                     operation: {
                         sourceNodeRid: identity.actor.nodeRid,
                         sourceNodeGeneration: identity.ownerNodeGeneration,
-                        operationId: {
-                            high: operationBytes.readBigUInt64BE(0),
-                            low: operationBytes.readBigUInt64BE(8)
-                        }
+                        operationId
                     },
                     terminalEnvelope,
-                    terminalEnvelopeSha256: (0, node_crypto_1.createHash)('sha256').update(terminalEnvelope).digest(),
                     operationDeadline: new Date(Date.now() + CREATION_OPERATION_TIMEOUT_MS)
                 }
             }
@@ -81,17 +87,14 @@ async function publishInitialActorAuthority(store, identity, signal) {
         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/dist/runtime/actors/actor-creation.js

@@ -25,7 +25,7 @@ class ZLinkActorCreationCoordinator {
                 state.clearAfterDestroy();
             }, () => 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;
                 }
@@ -61,16 +61,24 @@ class ZLinkActorCreationCoordinator {
         const factory = await this.createFactory(actorType);
         const context = state.ensureContext(() => new actor_context_1.DefaultZLinkActorContext(state, this.options.joinCoordinator, this.options.boundSessionFactory, this.options.messageSerializers, this.options.actorMeshNameProvider));
         const nativeActorNode = this.options.nativeActorNode ?? this.options.nativeActorNodeProvider?.();
+        let actor;
+        try {
+            actor = await factory.create(context, signal);
+        }
+        catch (error) {
+            await this.discardStagingActor(state, nativeActorNode);
+            return { status: 'failed', error };
+        }
+        let meshName;
+        let nodeRid;
         try {
-            const actor = await factory.create(context, signal);
             if (actor.context !== context || actor.context.actorId !== context.actorId) {
                 throw new configuration_1.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 configuration_1.ZLinkConfigurationException(`Actor '${actorId}' has no RouteMesh identity.`);
             }
-            let nodeRid;
             if (nativeActorNode !== undefined) {
                 const actorRef = state.ensureNativeActorRef(nativeActorNode, createRequest.nativeRequest);
                 nodeRid = (0, actor_runtime_state_1.toFrameworkRoutingId)(actorRef.nodeRid);
@@ -78,13 +86,26 @@ class ZLinkActorCreationCoordinator {
             else {
                 nodeRid = this.options.actorCreatedNodeRidProvider?.();
             }
-            const response = nodeRid === undefined
+        }
+        catch (error) {
+            await this.discardStagingActor(state, nativeActorNode);
+            throw error;
+        }
+        let response;
+        try {
+            response = nodeRid === undefined
                 ? { accepted: true }
                 : await this.options.actorCreatedNotifier?.(nodeRid, actor, 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/dist/runtime/actors/actor-runtime-state.d.ts

@@ -72,6 +72,9 @@ export type ZLinkActorCreationAttemptResult = {
 } | {
     readonly status: 'rejected';
     readonly reply?: unknown;
+} | {
+    readonly status: 'failed';
+    readonly error: unknown;
 };
 export declare class ZLinkActorRuntimeState {
     readonly actorId: string;

package/dist/runtime/actors/index.d.ts

@@ -76,4 +76,7 @@ export type ZLinkActorLocalCreateResult = {
 } | {
     readonly status: 'rejected';
     readonly reply?: unknown;
+} | {
+    readonly status: 'failed';
+    readonly error: unknown;
 };

package/dist/runtime/actors/index.js

@@ -235,6 +235,9 @@ class DefaultZLinkActorManager {
                 ? { 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 };
@@ -453,7 +456,7 @@ class DefaultZLinkActorManager {
             const operation = state.getOrStartCreation(actorType, failIfExists, () => 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);
                     }
                 }, () => this.discardFailedState(actorId, state, operation.task));
@@ -470,7 +473,9 @@ class DefaultZLinkActorManager {
                     };
                 }
                 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) {
@@ -610,10 +615,16 @@ class ZLinkActorCreateCallRuntime {
 class ZLinkActorGetOrCreateCallRuntime extends ZLinkActorCreateCallRuntime {
 }
 function requireCreatedActor(result, actorId) {
-    if (result.status !== 'rejected')
+    if (result.status === 'existing' || result.status === 'created')
         return result.actor;
+    if (result.status === 'failed') {
+        throw actorApplicationFailure(actorId, result.error);
+    }
     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorCreateRejected, `Actor '${actorId}' create request was rejected.`);
 }
+function actorApplicationFailure(actorId, error) {
+    return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorCreateFailed, `Actor '${actorId}' creation failed: ${error instanceof Error ? error.message : String(error)}`, false, error);
+}
 async function waitForCreationRetry(signal) {
     (0, abort_1.throwIfAborted)(signal);
     await new Promise((resolve, reject) => {

package/dist/runtime/admission.d.ts

@@ -1,6 +1,8 @@
 import { ZLinkFrameworkInternalErrorKind } from './framework-errors-internal';
 export declare class ZLinkRuntimeAdmissionGate {
+    private readonly ownerAdmissionOpen;
     private readonly meshes;
+    constructor(ownerAdmissionOpen?: () => boolean);
     get acceptsNewWork(): boolean;
     register(meshName: string): void;
     accepts(meshName: string): boolean;

package/dist/runtime/admission.js

@@ -3,8 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRuntimeAdmissionGate = void 0;
 const framework_errors_internal_1 = require("./framework-errors-internal");
 class ZLinkRuntimeAdmissionGate {
+    ownerAdmissionOpen;
     meshes = new Map();
+    constructor(ownerAdmissionOpen = () => true) {
+        this.ownerAdmissionOpen = ownerAdmissionOpen;
+    }
     get acceptsNewWork() {
+        if (!this.ownerAdmissionOpen())
+            return false;
         for (const state of this.meshes.values()) {
             if (state.sealed)
                 return false;
@@ -24,7 +30,7 @@ class ZLinkRuntimeAdmissionGate {
         }
     }
     accepts(meshName) {
-        return !this.requireState(meshName).sealed;
+        return this.ownerAdmissionOpen() && !this.requireState(meshName).sealed;
     }
     pending(meshName) {
         return this.requireState(meshName).active;
@@ -42,7 +48,7 @@ class ZLinkRuntimeAdmissionGate {
     }
     claim(meshName, operation) {
         const state = this.requireState(meshName);
-        if (!state.sealed) {
+        if (this.ownerAdmissionOpen() && !state.sealed) {
             state.active += 1;
             let closed = false;
             return {
@@ -59,7 +65,7 @@ class ZLinkRuntimeAdmissionGate {
                 }
             };
         }
-        throw (0, framework_errors_internal_1.createInternalFrameworkException)(state.sealedReason, `${operation} was rejected because the framework is draining.`);
+        throw (0, framework_errors_internal_1.createInternalFrameworkException)(state.sealedReason, `${operation} was rejected because framework admission is closed.`);
     }
     async run(meshName, operation, work) {
         const claim = this.claim(meshName, operation);
@@ -106,7 +112,7 @@ class ZLinkRuntimeAdmissionGate {
         }
         throw (0, framework_errors_internal_1.createInternalFrameworkException)(meshName === undefined
             ? this.firstSealedReason()
-            : this.requireState(meshName).sealedReason, `${operation} was rejected because the framework is draining.`);
+            : this.requireState(meshName).sealedReason, `${operation} was rejected because framework admission is closed.`);
     }
     requireActorCreate(actorId, meshName) {
         if (meshName === undefined) {
@@ -121,7 +127,7 @@ class ZLinkRuntimeAdmissionGate {
             : this.requireState(meshName).sealedReason;
         throw (0, framework_errors_internal_1.createInternalFrameworkException)(reason === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown
             ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown
-            : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorCreateRejected, `Actor '${actorId}' create request was rejected because the framework is draining.`);
+            : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorCreateRejected, `Actor '${actorId}' create request was rejected because framework admission is closed.`);
     }
     requireState(meshName) {
         const state = this.meshes.get(meshName);

package/dist/runtime/backend/contracts/index.d.ts

@@ -83,7 +83,7 @@ export interface ZLinkBackendMeshNode {
     registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
     requestUserSpotCreate(targetNodeRid: string, request: Omit<ServiceUserSpotCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     requestUserSpotClose(targetNodeRid: string, request: Omit<ServiceUserSpotCloseRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
-    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     connectPeer(options: {
         readonly endpoint: string;
         readonly expectedRid?: unknown;
@@ -311,6 +311,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>;
@@ -337,6 +338,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     peerWeight: number;
     sendHighWaterMark: number;
     receiveHighWaterMark: number;
+    receiveTimeoutMs: number;
     sendTimeoutMs: number;
     maxMessageSize: number;
     setRoutingId(routingId: RoutingId): void;
@@ -466,6 +468,7 @@ export interface ZLinkMeshBackendAdapter {
     createMeshNode(context: ZLinkBackendContext, 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/dist/runtime/backend/node/node-mesh-backend-adapter.d.ts

@@ -3,6 +3,7 @@ export declare class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdap
     createMeshNode(context: ZLinkBackendContext, 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;

package/dist/runtime/backend/node/node-mesh-backend-adapter.js

@@ -12,7 +12,7 @@ class ZLinkNodeMeshBackendAdapter {
         if (!isBindingContext(bindingContext)) {
             throw new TypeError('Node MeshNode creation requires the Node binding Context owned by the host.');
         }
-        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed);
+        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed);
     }
 }
 exports.ZLinkNodeMeshBackendAdapter = ZLinkNodeMeshBackendAdapter;

package/dist/runtime/backend/node/node-raw-binding-port.d.ts

@@ -3,6 +3,7 @@ import type { ZLinkRawBindingPort, ZLinkRawHostPort } from '../raw-binding-port'
 export type { ZLinkRawBindingPort, ZLinkRawDealerPort, ZLinkRawHostPort, ZLinkRawMonitorPort, ZLinkRawMonitorRecord, ZLinkRawReceivedRecord, ZLinkRawRouterPort, ZLinkRawSocketPort } from '../raw-binding-port';
 export declare class ZLinkNodeRawBindingPort implements ZLinkRawBindingPort {
     private readonly sharedContext?;
-    constructor(sharedContext?: Context | undefined);
+    private readonly routerReceiveTimeoutMs?;
+    constructor(sharedContext?: Context | undefined, routerReceiveTimeoutMs?: number | undefined);
     createHost(): ZLinkRawHostPort;
 }

package/dist/runtime/backend/node/node-raw-binding-port.js

@@ -7,26 +7,30 @@ const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const node_event_loop_poller_1 = require("./node-event-loop-poller");
 class ZLinkNodeRawBindingPort {
     sharedContext;
-    constructor(sharedContext) {
+    routerReceiveTimeoutMs;
+    constructor(sharedContext, routerReceiveTimeoutMs) {
         this.sharedContext = sharedContext;
+        this.routerReceiveTimeoutMs = routerReceiveTimeoutMs;
     }
     createHost() {
-        return new NodeRawHostPort(this.sharedContext ?? (0, zlink_1.createContext)(), this.sharedContext === undefined);
+        return new NodeRawHostPort(this.sharedContext ?? (0, zlink_1.createContext)(), this.sharedContext === undefined, this.routerReceiveTimeoutMs);
     }
 }
 exports.ZLinkNodeRawBindingPort = ZLinkNodeRawBindingPort;
 class NodeRawHostPort {
     context;
     ownsContext;
+    routerReceiveTimeoutMs;
     resources = [];
     state = 'open';
-    constructor(context, ownsContext) {
+    constructor(context, ownsContext, routerReceiveTimeoutMs) {
         this.context = context;
         this.ownsContext = ownsContext;
+        this.routerReceiveTimeoutMs = routerReceiveTimeoutMs;
     }
     createRouter() {
         this.requireOpen();
-        return this.own(new NodeRawRouterPort((0, zlink_1.createRouterSocket)(this.context)));
+        return this.own(new NodeRawRouterPort((0, zlink_1.createRouterSocket)(this.context), this.routerReceiveTimeoutMs));
     }
     createDealer() {
         this.requireOpen();
@@ -178,11 +182,14 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         this.requireOpen();
         this.socket.disconnectRid(bindingRoutingId(routingId));
     }
-    constructor(socket) {
+    constructor(socket, receiveTimeoutMs) {
         super(socket);
         socket.options.handover = true;
         socket.options.mandatory = true;
         socket.options.probe = true;
+        if (receiveTimeoutMs !== undefined) {
+            socket.options.recvTimeout = receiveTimeoutMs;
+        }
     }
     localEndpoint() {
         this.requireOpen();

package/dist/runtime/backend/node/node-raw-mesh-backend.d.ts

@@ -178,7 +178,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
     requestUserSpotCreate(targetNodeRid: string, request: Omit<ServiceUserSpotCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     requestUserSpotClose(targetNodeRid: string, request: Omit<ServiceUserSpotCloseRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
-    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     recoverInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;
     recoverPendingInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, pending: ServicePendingInstanceActivation, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;
     completeRecoveredInstanceActivation(target: ServiceInstanceActivationTarget, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<ServiceInstanceRouteFence | undefined>;

package/dist/runtime/backend/node/node-socket-backend-adapter.js

@@ -92,6 +92,12 @@ function wrapSocket(nativeInstance, pollCompletion) {
         set receiveHighWaterMark(value) {
             requireSocketOptions(socket).recvHwm = value;
         },
+        get receiveTimeoutMs() {
+            return socket.options?.recvTimeout ?? 0;
+        },
+        set receiveTimeoutMs(value) {
+            requireSocketOptions(socket).recvTimeout = value;
+        },
         get sendTimeoutMs() {
             return socket.options?.sendTimeout ?? 0;
         },

package/dist/runtime/channels/channel-socket-options.js

@@ -33,6 +33,13 @@ class ZLinkLiveSocketConfig {
         validateHighWaterMark(value, 'receiveHighWaterMark');
         this.socket.receiveHighWaterMark = value;
     }
+    get receiveTimeoutMs() {
+        return this.socket.receiveTimeoutMs;
+    }
+    set receiveTimeoutMs(value) {
+        (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)('receiveTimeoutMs', value);
+        this.socket.receiveTimeoutMs = value;
+    }
     get sendTimeoutMs() {
         return this.socket.sendTimeoutMs;
     }

package/dist/runtime/channels/channel-socket-registry.js

@@ -1446,6 +1446,9 @@ function applySocketConfig(socket, config) {
     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/dist/runtime/foundation/service-stateful-runtime.d.ts

@@ -253,7 +253,7 @@ export declare class ServiceStatefulRuntime {
     registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
     requestUserSpotCreate(targetNodeRid: string, request: Omit<ServiceUserSpotCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     requestUserSpotClose(targetNodeRid: string, request: Omit<ServiceUserSpotCloseRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
-    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     recoverInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;
     private finishRecoveredInstanceActivation;
     recoverPendingInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, pending: ServicePendingInstanceActivation, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;

package/dist/runtime/foundation/service-stateful-runtime.js

@@ -289,16 +289,12 @@ class ServiceStatefulRuntime {
     }
     requestActorCreate(targetNodeRid, request, timeoutMs) {
         const correlation = this.nextUserSpotOperation++;
-        const operation = {
-            high: this.nodeGeneration,
-            low: correlation
-        };
         return this.requestUserSpotOperation(targetNodeRid, (0, service_stateful_wire_codec_1.encodeActorCreateHeader)({
             ...request,
             sourceNodeRid: this.nodeRid,
             sourceNodeGeneration: this.nodeGeneration,
             correlation,
-            operation
+            operation: request.operation
         }), correlation, 'actorCreate', timeoutMs);
     }
     async recoverInstanceActivation(envelope, route, expectedCurrentRoute) {

package/dist/runtime/host/actor-placement-coordinator.d.ts

@@ -10,11 +10,13 @@ export interface ZLinkActorPlacementTarget {
     readonly entrySpotId: string;
     readonly owner: ZLinkLocationOwnerToken;
     readonly isLocal: boolean;
+    readonly sourceNodeRid: RoutingId;
+    readonly sourceNodeGeneration: bigint;
 }
 export interface ZLinkActorPlacementCoordinatorOptions {
     readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
     readonly target: (meshName: string | undefined, stableType: string, signal?: AbortSignal, excludedNodeRids?: ReadonlySet<string>) => Promise<ZLinkActorPlacementTarget | undefined>;
-    readonly remoteCreate: (meshName: string, targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number) => Promise<ServiceUserSpotOperationResult>;
+    readonly remoteCreate: (meshName: string, targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>, timeoutMs: number) => Promise<ServiceUserSpotOperationResult>;
     readonly decodeRemoteReply?: (payload: Uint8Array) => unknown;
 }
 export declare class ZLinkActorPlacementCoordinator {
@@ -22,11 +24,18 @@ export declare class ZLinkActorPlacementCoordinator {
     constructor(options: ZLinkActorPlacementCoordinatorOptions);
     create(actorId: string, stableType: string, createOnly: boolean, meshName: string | undefined, requestPayload: Uint8Array, timeoutMs: number, signal?: AbortSignal): Promise<ZLinkActorCreateResult>;
     handleRemoteCreate(record: ServiceActorCreateRecord, materialize: (requestPayload: Uint8Array, authority: ZLinkAuthoritySnapshot, signal: AbortSignal) => Promise<{
-        readonly result: 'created' | 'rejected';
-        readonly actor?: ActorRef;
+        readonly result: 'created';
+        readonly actor: ActorRef;
         readonly reply?: Uint8Array;
         readonly onPublished?: () => void;
-        readonly entrySpotId?: string;
-        readonly entrySpotGeneration?: bigint;
+        readonly entrySpotId: string;
+        readonly entrySpotGeneration: bigint;
+    } | {
+        readonly result: 'rejected';
+        readonly reply?: Uint8Array;
+        readonly onPublished?: () => void;
+    } | {
+        readonly result: 'failed';
+        readonly error: unknown;
     }>, signal: AbortSignal): Promise<ServiceUserSpotOperationResult>;
 }