@zlink-systems/framework 0.26.0 → 0.27.0

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

@@ -2,26 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkNodeRawMeshBackend = void 0;
 exports.requestFailureResult = requestFailureResult;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
+const zlink_1 = require("@zlink-systems/zlink");
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:timers/promises");
-const stream_wire_1 = require("@zlink-systems/stream-wire");
-const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
-const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const contracts_1 = require("../../../contracts");
-const framework_errors_internal_1 = require("../../framework-errors-internal");
-const zlink_1 = require("@zlink-systems/zlink");
-const runtime_values_1 = require("../runtime-values");
-const runtime_message_1 = require("../runtime-message");
-const service_runtime_contracts_1 = require("../../foundation/service-runtime-contracts");
+const ConfigurationException_1 = require("../../../contracts/Configuration/ConfigurationException");
+const EndpointNotation_1 = require("../../../contracts/Configuration/EndpointNotation");
+const InternalDefaults_1 = require("../../../contracts/Configuration/InternalDefaults");
+const Registration_1 = require("../../../contracts/Configuration/Registration");
+const RegistrationBuilderPolicy_1 = require("../../../contracts/Configuration/RegistrationBuilderPolicy");
+const admission_1 = require("../../admission");
+const operation_identity_1 = require("../../foundation/operation-identity");
 const operation_registry_1 = require("../../foundation/operation-registry");
 const raw_service_mesh_runtime_1 = require("../../foundation/raw-service-mesh-runtime");
-const service_wire_m6a_codec_1 = require("../../foundation/service-wire-m6a-codec");
-const service_wire_constants_generated_1 = require("../../foundation/service-wire-constants.generated");
-const service_stateful_runtime_1 = require("../../foundation/service-stateful-runtime");
-const service_session_binding_ingress_port_1 = require("../../foundation/service-session-binding-ingress-port");
 const service_metadata_codec_1 = require("../../foundation/service-metadata-codec");
-const EndpointNotation_1 = require("../../../contracts/Configuration/EndpointNotation");
-const ConfigurationException_1 = require("../../../contracts/Configuration/ConfigurationException");
+const service_runtime_contracts_1 = require("../../foundation/service-runtime-contracts");
+const service_session_binding_ingress_port_1 = require("../../foundation/service-session-binding-ingress-port");
+const service_stateful_runtime_1 = require("../../foundation/service-stateful-runtime");
+const service_wire_binary_primitives_1 = require("../../foundation/service-wire-binary-primitives");
+const service_wire_constants_generated_1 = require("../../foundation/service-wire-constants.generated");
+const service_wire_m6a_codec_1 = require("../../foundation/service-wire-m6a-codec");
+const submission_result_1 = require("../../messaging/submission-result");
+const framework_errors_internal_1 = require("../../framework-errors-internal");
+const runtime_message_1 = require("../runtime-message");
+const runtime_values_1 = require("../runtime-values");
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
+const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
+const DEFAULT_NATIVE_ACTIVE_CAPACITY = 10_000;
+const UNSTARTED_DIAGNOSTIC_ENDPOINT = 'inproc://not-started';
 const MULTIPART_PACKET_NAME = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME;
 const MULTIPART_CONTENT_TYPE = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE;
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
@@ -29,6 +38,9 @@ const MAX_DRAIN_RECORDS = 64;
 // Preserve the existing route observation/admission/liveness cadence. Only the binding
 // readable handler admits receive work; this timer never probes the socket.
 const MESH_BACKEND_MAINTENANCE_INTERVAL_MS = 1;
+// Spec 08 §4.2 bounds the combined turn. Raw gets one equal share; stateful
+// can use the remaining turn, including time the raw registry did not consume.
+const MESH_BACKEND_RAW_MAINTENANCE_SHARE = 1 / 2;
 /**
  * Conservative Actor Join admission cap for relocation state chunks (spec 15
  * §4.2): a stable lower bound safe on any deployment, never lowered on
@@ -61,29 +73,39 @@ class ZLinkNodeRawMeshBackend {
     readyHandler;
     maintenanceTimer;
     pumping = false;
-    readable = false;
-    onReadable = () => {
-        this.readable = true;
+    readable = 0;
+    onReadable = (receiveReady, routeReady) => {
+        if (receiveReady)
+            this.readable |= 1;
+        if (routeReady)
+            this.readable |= 2;
         if (!this.closed && !this.pumping)
             void this.pump();
     };
     onMaintenance = () => {
         this.maintenanceTimer = undefined;
+        if (this.closed)
+            return;
+        const nowMs = performance.now();
+        const turnDeadlineMs = nowMs + raw_service_mesh_runtime_1.RAW_MESH_RECEIVE_TIME_BUDGET_MS;
+        this.runtime?.expireOperations(nowMs, nowMs + raw_service_mesh_runtime_1.RAW_MESH_RECEIVE_TIME_BUDGET_MS * MESH_BACKEND_RAW_MAINTENANCE_SHARE);
+        this.stateful?.expireOperations(nowMs, turnDeadlineMs);
+        this.scheduleMaintenance();
         void this.pump();
     };
+    onPendingOperationsChanged = () => this.scheduleMaintenance();
     nextPeerIntent = 1n;
     closed = false;
     objectRole = 'none';
-    placementWeight = 100;
-    activeCapacityLimit = 10_000;
-    pendingCapacityLimit = 128;
+    placementWeight = RegistrationBuilderPolicy_1.ZLINK_DEFAULT_PUBLIC_WEIGHT;
+    activeCapacityLimit = DEFAULT_NATIVE_ACTIVE_CAPACITY;
+    pendingCapacityLimit = InternalDefaults_1.DEFAULT_ACTIVATION_CONCURRENCY_LIMIT;
     objectCapabilities = [];
     maintenanceWave;
     mailboxRecordDropped;
     protocolError;
     messageFollowHandler;
     dispatchErrors;
-    spotAdmissionProvider;
     peerDisconnectedHandlers = new Set();
     constructor(meshName, routingId, bindingPort, applicationJobQueue, applicationJobReceiveFlowFailureSink, peerAdmissionSealed) {
         this.meshName = meshName;
@@ -116,10 +138,6 @@ class ZLinkNodeRawMeshBackend {
         this.dispatchErrors = reporter;
         this.stateful?.setDispatchErrorReporter(reporter, this.meshName);
     }
-    setSpotAdmissionProvider(provider) {
-        this.spotAdmissionProvider = provider;
-        this.stateful?.setSpotAdmissionProvider(provider);
-    }
     setProtocolErrorHandler(handler) {
         this.protocolError = handler;
     }
@@ -182,6 +200,7 @@ class ZLinkNodeRawMeshBackend {
             throw new Error('MeshNode bind endpoint is not configured.');
         const descriptor = this.createDescriptor();
         const runtime = new raw_service_mesh_runtime_1.RawServiceMeshRuntime({
+            onPendingOperationsChanged: this.onPendingOperationsChanged,
             descriptor,
             resolveAdvertisedEndpoint: (boundEndpoint) => this.resolveAdvertisedEndpoint(boundEndpoint),
             bindingPort: this.bindingPort,
@@ -215,10 +234,7 @@ class ZLinkNodeRawMeshBackend {
             }
         });
         runtime.start();
-        this.stateful = new service_stateful_runtime_1.ServiceStatefulRuntime(runtime, descriptor.nodeRoutingId, descriptor.lifecycleGeneration);
-        if (this.spotAdmissionProvider !== undefined) {
-            this.stateful.setSpotAdmissionProvider(this.spotAdmissionProvider);
-        }
+        this.stateful = new service_stateful_runtime_1.ServiceStatefulRuntime(runtime, descriptor.nodeRoutingId, descriptor.lifecycleGeneration, this.onPendingOperationsChanged);
         if (this.dispatchErrors !== undefined) {
             this.stateful.setDispatchErrorReporter(this.dispatchErrors, this.meshName);
         }
@@ -254,7 +270,6 @@ class ZLinkNodeRawMeshBackend {
     close() {
         if (this.closed)
             return;
-        this.closed = true;
         if (this.maintenanceTimer !== undefined)
             clearTimeout(this.maintenanceTimer);
         this.maintenanceTimer = undefined;
@@ -263,6 +278,7 @@ class ZLinkNodeRawMeshBackend {
         this.runtime?.close();
         this.runtime = undefined;
         this.clearCompletions();
+        this.closed = true;
     }
     addChannelName(name) {
         this.requireNotStarted();
@@ -312,8 +328,6 @@ class ZLinkNodeRawMeshBackend {
                     lifecycleGeneration: options.expectedLifecycleGeneration
                 })
         });
-        if (nodeRoutingId !== undefined)
-            await runtime.announcePeer(nodeRoutingId);
         return intent;
     }
     expectPeer(peer) {
@@ -386,17 +400,17 @@ class ZLinkNodeRawMeshBackend {
             : zlink_1.SubmitResult.NotConnected;
     }
     async requestInfrastructureControlFrames(targetRid, frames, options) {
-        return await this.requireRuntime().requestService(String(targetRid), frames.map((frame) => Buffer.from(frame)), options?.timeoutMs ?? 30_000);
+        return await this.requireRuntime().requestService(String(targetRid), frames.map((frame) => Buffer.from(frame)), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
     }
     requestToNode(targetRid, parts, options) {
-        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? 30_000);
+        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
         return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.NodeRequest, pending.promise);
     }
     async sendToChannel(channelName, parts) {
         return this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts));
     }
     requestToChannel(channelName, parts, options) {
-        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? 30_000);
+        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
         return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.ChannelRequest, pending.promise);
     }
     status() {
@@ -432,7 +446,7 @@ class ZLinkNodeRawMeshBackend {
             connectionIntentId: findIntent(peer.descriptor.nodeRoutingId, peer.descriptor.advertisedEndpoint)?.id ?? 0n,
             source: 1,
             state: this.runtime?.isPeerRouteReady(peer.descriptor.nodeRoutingId) === false
-                ? 1
+                ? service_runtime_contracts_1.MeshPeerRuntimeState.Connecting
                 : peerStateCode(peer.descriptor.state),
             routingId: peer.descriptor.nodeRoutingId,
             lifecycleGeneration: peer.descriptor.lifecycleGeneration,
@@ -445,7 +459,7 @@ class ZLinkNodeRawMeshBackend {
         const notRequired = (this.runtime?.topology.notRequiredPeers() ?? []).map((descriptor) => ({
             connectionIntentId: findIntent(descriptor.nodeRoutingId, descriptor.advertisedEndpoint)?.id ?? 0n,
             source: 1,
-            state: 6,
+            state: service_runtime_contracts_1.MeshPeerRuntimeState.NotRequired,
             routingId: descriptor.nodeRoutingId,
             lifecycleGeneration: descriptor.lifecycleGeneration,
             descriptorRevision: descriptor.descriptorRevision,
@@ -568,7 +582,9 @@ class ZLinkNodeRawMeshBackend {
         return this.requireStateful().createActor(actorId).ref;
     }
     restoreActorAuthority(actorId, stableType, generation, authorityOwnerGeneration, spotId, spotGeneration, membershipEpoch) {
-        return this.requireStateful().restoreActorAuthority(actorId, stableType, generation, authorityOwnerGeneration, spotId, spotGeneration, membershipEpoch).ref;
+        const stateful = this.requireStateful();
+        const entry = spotId === undefined ? stateful.entrySpot().ref : undefined;
+        return stateful.restoreActorAuthority(actorId, stableType, generation, authorityOwnerGeneration, entry?.spotId ?? spotId, entry?.generation ?? spotGeneration, membershipEpoch).ref;
     }
     discardRelocatedActor(actor) {
         this.requireStateful().discardRelocatedActor({
@@ -646,17 +662,19 @@ class ZLinkNodeRawMeshBackend {
     forgetSpotRoute(spot, authorityOwnerGeneration, storeVersion) {
         this.requireStateful().forgetSpotRoute(spot, authorityOwnerGeneration, storeVersion);
     }
-    async sendToInstanceSpot(route, parts, sourceSpotId, metadata) {
-        const result = await this.requireStateful().sendToInstanceSpot(route, encodeMultipart(parts), sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata));
+    async sendToInstanceSpot(route, parts, sourceSpotId, metadata, instanceIntent = false) {
+        const result = await this.requireStateful().sendToInstanceSpot(route, encodeMultipart(parts), sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), instanceIntent);
         return result;
     }
-    requestInstanceSpot(route, parts, timeoutMs = 30_000, sourceSpotId, metadata) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToInstanceSpot(route, encodeMultipart(parts), timeoutMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata)));
+    requestInstanceSpot(route, parts, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, sourceSpotId, metadata, instanceIntent = false) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToInstanceSpot(route, encodeMultipart(parts), timeoutMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), instanceIntent));
     }
     actorLookup(actorId) {
         const actor = this.requireStateful().actor(actorId);
         if (actor === undefined) {
-            throw Object.assign(new Error(`Actor '${actorId}' was not found.`), { nativeErrno: 2 });
+            const error = new zlink_1.ConfigError(zlink_1.ConfigResult.NotFound);
+            error.message = `Actor '${actorId}' was not found.`;
+            throw error;
         }
         return {
             actor: actor.ref,
@@ -665,23 +683,23 @@ class ZLinkNodeRawMeshBackend {
             membershipEpoch: actor.membershipEpoch
         };
     }
-    lookupRemoteActor(targetNodeRid, actorId, timeoutMs = 30_000) {
+    lookupRemoteActor(targetNodeRid, actorId, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorLookup, this.requireStateful().lookupRemoteActor(String(targetNodeRid), actorId, timeoutMs));
     }
-    destroyActor(actor, timeoutMs = 30_000) {
+    destroyActor(actor, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorDestroy, this.requireStateful().destroyActor(actor, timeoutMs));
     }
-    joinActorSpot(actor, targetNodeRid, targetSpotId, targetSpotGeneration, request, timeoutMs = 30_000) {
+    joinActorSpot(actor, targetNodeRid, targetSpotId, targetSpotGeneration, request, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActor(actor, String(targetNodeRid), { spotId: String(targetSpotId), generation: targetSpotGeneration }, targetSpotGeneration, request, timeoutMs));
     }
-    joinActorSpotCanonical(actor, targetNodeRid, targetSpotId, targetSpotGeneration, request, actorFence, local, timeoutMs = 30_000) {
+    joinActorSpotCanonical(actor, targetNodeRid, targetSpotId, targetSpotGeneration, request, actorFence, local, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActorCanonical(actor, String(targetNodeRid), { spotId: String(targetSpotId), generation: targetSpotGeneration }, targetSpotGeneration, request, actorFence, local, timeoutMs));
     }
-    joinActorEntrySpot(actor, targetNodeRid, request, timeoutMs = 30_000) {
+    joinActorEntrySpot(actor, targetNodeRid, request, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         const target = String(targetNodeRid);
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActorEntrySpot(actor, target, request, timeoutMs));
     }
-    joinActorEntrySpotCanonical(actor, targetNodeRid, request, actorFence, local, timeoutMs = 30_000) {
+    joinActorEntrySpotCanonical(actor, targetNodeRid, request, actorFence, local, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         const target = String(targetNodeRid);
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActorEntrySpotCanonical(actor, target, request, actorFence, local, timeoutMs));
     }
@@ -689,25 +707,25 @@ class ZLinkNodeRawMeshBackend {
         return this.requireStateful().sendToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts));
     }
     requestToActor(actor, parts, options) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts), options?.timeoutMs ?? 30_000));
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS));
     }
     async actorSendToActor(source, target, parts) {
         return (await this.requireStateful().sendToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), source));
     }
     actorRequestToActor(source, target, parts, options) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), options?.timeoutMs ?? 30_000, source));
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, source));
     }
     async sendActorBoundSession(actor, expectedBindingGeneration, parts, _flags) {
         return (await this.requireStateful().sendBoundSession(actor, expectedBindingGeneration, encodeMultipart(parts)));
     }
-    closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs = 30_000) {
+    closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         const binding = this.requireStateful().registry.binding(actor);
         if (binding === undefined) {
             return this.enqueueImmediateFailure(service_runtime_contracts_1.OperationKind.StreamUnbind, zlink_1.RequestResult.NotFound);
         }
         return this.observeStateful(service_runtime_contracts_1.OperationKind.StreamUnbind, this.requireStateful().unbindSession(binding.sessionRid, actor, expectedBindingGeneration, timeoutMs));
     }
-    leaveActor(actor, expectedMembershipEpoch, timeoutMs = 30_000) {
+    leaveActor(actor, expectedMembershipEpoch, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorLeave, this.requireStateful().leaveActor(actor, expectedMembershipEpoch, timeoutMs));
     }
     createStreamSessionService(stream) {
@@ -743,7 +761,7 @@ class ZLinkNodeRawMeshBackend {
             nodeRoutingId: this.routingId,
             lifecycleGeneration: this.lifecycleGeneration,
             descriptorRevision: 1n,
-            advertisedEndpoint: this.bindEndpoint ?? 'inproc://not-started',
+            advertisedEndpoint: this.bindEndpoint ?? UNSTARTED_DIAGNOSTIC_ENDPOINT,
             channels,
             state: 'preparing',
             // Plaintext RouteMesh peers use the shared default admission identity.
@@ -767,29 +785,35 @@ class ZLinkNodeRawMeshBackend {
         return result;
     }
     scheduleMaintenance() {
-        if (this.closed || this.maintenanceTimer !== undefined)
+        if (this.closed)
+            return;
+        this.maintenanceTimer ??= setTimeout(this.onMaintenance, MESH_BACKEND_MAINTENANCE_INTERVAL_MS);
+        const pending = (this.runtime?.pendingOperationCount ?? 0) + (this.stateful?.pendingOperationCount ?? 0) > 0;
+        if (pending === this.maintenanceTimer.hasRef())
             return;
-        this.maintenanceTimer = setTimeout(this.onMaintenance, MESH_BACKEND_MAINTENANCE_INTERVAL_MS);
+        if (pending) {
+            this.maintenanceTimer.ref();
+        }
+        else {
+            this.maintenanceTimer.unref();
+        }
     }
     async pump() {
         if (this.isClosed() || this.pumping)
             return;
         this.pumping = true;
-        if (this.maintenanceTimer !== undefined)
-            clearTimeout(this.maintenanceTimer);
-        this.maintenanceTimer = undefined;
         try {
             do {
-                const receiveReady = this.readable;
-                this.readable = false;
-                const more = await this.requireRuntime().pumpBatch(receiveReady);
+                const ready = this.readable;
+                this.readable = 0;
+                const more = await this.requireRuntime().pumpBatch((ready & 1) !== 0, (ready & 2) !== 0);
                 if (more) {
                     // Yield only after actual progress, retaining readiness across the
                     // existing batch limits until receive reports no data.
-                    this.readable = true;
+                    this.readable |= 1;
                     await (0, promises_1.setImmediate)();
                 }
-            } while (!this.closed && this.readable);
+            } while (!this.closed && this.readable !== 0);
         }
         finally {
             this.pumping = false;
@@ -817,7 +841,7 @@ class ZLinkNodeRawMeshBackend {
         return id;
     }
     observeStateful(operationKind, pending) {
-        const id = { high: 2n, low: pending.id };
+        const id = { high: operation_identity_1.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: pending.id };
         void pending.promise.then((result) => this.enqueueCompletion(id, operationKind, result), (error) => this.enqueueCompletion(id, operationKind, requestFailureResult(error)));
         return id;
     }
@@ -858,7 +882,7 @@ class ZLinkNodeRawMeshBackend {
         if (this.completionCount === 0) {
             this.clearCompletions();
         }
-        else if (this.completionHead >= 1024 && this.completionHead * 2 >= this.completions.length) {
+        else if ((0, admission_1.shouldCompactBackingArray)(this.completionHead, this.completions.length)) {
             this.completions.splice(0, this.completionHead);
             this.completionHead = 0;
         }
@@ -951,7 +975,7 @@ class RawServiceSpot {
         const routeFence = requireDirectSpotRouteFence(options?.routeFence, String(targetNodeRid), String(targetSpotId), targetSpotGeneration, options?.entrySpot === true
             ? this.backend.entrySpotRouteFence(String(targetNodeRid), String(targetSpotId))
             : undefined);
-        return this.backend.requestFromSpot(this.state, routeFence, parts, options?.timeoutMs ?? 30_000);
+        return this.backend.requestFromSpot(this.state, routeFence, parts, options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
     }
     async publish(channelName, topic, parts, options) {
         this.requireOpen();
@@ -1009,7 +1033,7 @@ class RawStreamSessionService {
     stateful;
     stream;
     observe;
-    state = 1;
+    state = service_runtime_contracts_1.StreamSessionRuntimeState.Created;
     closed = false;
     sessionTargets = new Map();
     constructor(stateful, stream, observe) {
@@ -1020,7 +1044,7 @@ class RawStreamSessionService {
     start() {
         if (this.closed)
             throw new Error('STREAM session service is closed.');
-        this.state = 2;
+        this.state = service_runtime_contracts_1.StreamSessionRuntimeState.Started;
     }
     shutdown(_timeoutMs) {
         this.close();
@@ -1030,7 +1054,7 @@ class RawStreamSessionService {
         if (this.closed)
             return;
         this.closed = true;
-        this.state = 5;
+        this.state = service_runtime_contracts_1.StreamSessionRuntimeState.Closed;
         this.sessionTargets.clear();
     }
     status() {
@@ -1045,17 +1069,17 @@ class RawStreamSessionService {
             lastError: 0
         };
     }
-    lookupActor(targetNodeRid, actorId, timeoutMs = 30_000) {
+    lookupActor(targetNodeRid, actorId, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         this.requireStarted();
         return this.observe(service_runtime_contracts_1.OperationKind.ActorLookup, this.stateful.lookupRemoteActor(String(targetNodeRid), actorId, timeoutMs));
     }
-    bindActor(sessionRid, actor, timeoutMs = 30_000, onBindingReplaced, actorAuthority) {
+    bindActor(sessionRid, actor, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, onBindingReplaced, actorAuthority) {
         this.requireStarted();
         const sessionKey = String(sessionRid);
         this.sessionTargets.set(sessionKey, sessionRid);
-        return this.observe(service_runtime_contracts_1.OperationKind.StreamBind, this.stateful.bindSession(sessionKey, actor, timeoutMs, (targetSessionRid, payloadFrame) => this.deliver(targetSessionRid, actor.actorId, payloadFrame), onBindingReplaced, (0, service_session_binding_ingress_port_1.serviceSessionBindingIngressPortIfRegistered)(this), actorAuthority));
+        return this.observe(service_runtime_contracts_1.OperationKind.StreamBind, this.stateful.bindSession(sessionKey, actor, timeoutMs, (targetSessionRid, payloadFrame) => this.deliver(targetSessionRid, actor.actorId, payloadFrame), onBindingReplaced, actorAuthority));
     }
-    unbindActor(sessionRid, actor, expectedBindingGeneration, timeoutMs = 30_000) {
+    unbindActor(sessionRid, actor, expectedBindingGeneration, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS) {
         this.requireStarted();
         return this.observe(service_runtime_contracts_1.OperationKind.StreamUnbind, this.stateful.unbindSession(String(sessionRid), actor, expectedBindingGeneration, timeoutMs));
     }
@@ -1110,7 +1134,7 @@ class RawStreamSessionService {
         }
     }
     requireStarted() {
-        if (this.state !== 2 || this.closed) {
+        if (this.state !== service_runtime_contracts_1.StreamSessionRuntimeState.Started || this.closed) {
             throw new Error('STREAM session service is not started.');
         }
     }
@@ -1335,7 +1359,7 @@ function decodeMultipartRecord(runtime, record) {
         };
     }
     const header = record.parts[0];
-    const command = header[3];
+    const command = header[service_wire_binary_primitives_1.SERVICE_WIRE_COMMAND_OFFSET];
     const payloadFrame = record.parts[1];
     const application = decodeApplicationEnvelope(payloadFrame);
     const channelName = record.owner.startsWith('channel:')
@@ -1344,11 +1368,11 @@ function decodeMultipartRecord(runtime, record) {
     const operationId = record.correlation === undefined
         ? { high: 0n, low: 0n }
         : { high: 1n, low: record.correlation };
-    const kind = command === 16
+    const kind = command === service_wire_constants_generated_1.ServiceWireCommand.nodeSend
         ? service_runtime_contracts_1.ReceiveKind.NodeSend
-        : command === 17
+        : command === service_wire_constants_generated_1.ServiceWireCommand.nodeRequest
             ? service_runtime_contracts_1.ReceiveKind.NodeRequest
-            : command === 18
+            : command === service_wire_constants_generated_1.ServiceWireCommand.channelSend
                 ? service_runtime_contracts_1.ReceiveKind.ChannelSend
                 : service_runtime_contracts_1.ReceiveKind.ChannelRequest;
     const operationKind = kind === service_runtime_contracts_1.ReceiveKind.NodeRequest
@@ -1398,7 +1422,7 @@ function decodeStatefulRecord(record, stateful) {
             : decodeApplicationEnvelope(payloadFrame);
     const operationId = record.correlation === undefined
         ? { high: 0n, low: 0n }
-        : { high: 2n, low: record.correlation };
+        : { high: operation_identity_1.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: record.correlation };
     const ingressLifecycle = receiveIngressLifecycle(record);
     return {
         kind: stateful.receiveKind,
@@ -1429,12 +1453,18 @@ function decodeStatefulRecord(record, stateful) {
                 : decodeMultipart(application.payload),
         ...(stateful.isPending === undefined ? {} : { isPending: stateful.isPending }),
         ...(stateful.deadlineUnixMs === undefined ? {} : { deadlineUnixMs: stateful.deadlineUnixMs }),
+        ...(stateful.activationRecord === undefined
+            ? {}
+            : { activationRecord: stateful.activationRecord }),
         ...(stateful.messageFollowOrigin === undefined
             ? {}
             : { messageFollowOrigin: stateful.messageFollowOrigin }),
         ...(stateful.onTerminalCompletion === undefined
             ? {}
             : { onTerminalCompletion: stateful.onTerminalCompletion }),
+        ...(stateful.onHandlerTurnStarted === undefined
+            ? {}
+            : { onHandlerTurnStarted: stateful.onHandlerTurnStarted }),
         reply(parts) {
             if (stateful.reply === undefined)
                 return zlink_1.SubmitResult.InvalidState;
@@ -1530,7 +1560,7 @@ function readyDomain(domain) {
 /**
  * The one classification of a failed node/channel/stateful request into its
  * completion terminal. A binding REQUEST result is Core's decision and is kept
- * as is; a submit failure retains its Core meaning at the request boundary.
+ * as is; a submit failure is classified from its submission or completion phase.
  * A reply that could not be decoded is a protocol
  * failure (spec 32-framework-error-model:91-92). The failure code is a wire
  * code, so a Core result carries 0.
@@ -1539,14 +1569,19 @@ function requestFailureResult(error) {
     const failure = (0, node_backend_adapter_support_1.translateBindingResultError)(error);
     if ((0, runtime_values_1.isZLinkBackendResultError)(failure)) {
         return {
-            terminalResult: failure.operation === 'request' ? failure.result : submitFailureTerminal(failure.result),
+            terminalResult: failure.operation === 'request'
+                ? failure.result
+                : (0, submission_result_1.submitToRequestResult)(failure.result, failure.phase),
             failureCode: 0
         };
     }
     //  requestProtocolError(16): the schema terminal-failure-integrity rule
     //  forbids a typed terminal (104) with failure none.
     if (failure instanceof service_wire_m6a_codec_1.ServiceWireProtocolError) {
-        return { terminalResult: zlink_1.RequestResult.ProtocolError, failureCode: 16 };
+        return {
+            terminalResult: zlink_1.RequestResult.ProtocolError,
+            failureCode: service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestProtocolError
+        };
     }
     if (failure instanceof contracts_1.ZLinkFrameworkException) {
         return (0, framework_errors_internal_1.internalFrameworkWireReply)(failure);
@@ -1557,31 +1592,10 @@ function requestFailureResult(error) {
     if (failure instanceof operation_registry_1.OperationCancelledError) {
         return { terminalResult: zlink_1.RequestResult.NotConnected, failureCode: 0 };
     }
-    return { terminalResult: zlink_1.RequestResult.InternalError, failureCode: 17 };
-}
-function submitFailureTerminal(result) {
-    switch (result) {
-        case zlink_1.SubmitResult.Backpressured:
-            return zlink_1.RequestResult.Backpressured;
-        case zlink_1.SubmitResult.NotConnected:
-            return zlink_1.RequestResult.NotConnected;
-        case zlink_1.SubmitResult.NotFound:
-            return zlink_1.RequestResult.NotFound;
-        case zlink_1.SubmitResult.NotAdmitted:
-            return zlink_1.RequestResult.Rejected;
-        case zlink_1.SubmitResult.InvalidHandle:
-        case zlink_1.SubmitResult.InvalidArgument:
-        case zlink_1.SubmitResult.ThreadViolation:
-            return zlink_1.RequestResult.InvalidArgument;
-        case zlink_1.SubmitResult.InvalidState:
-            return zlink_1.RequestResult.InvalidState;
-        case zlink_1.SubmitResult.NotSupported:
-            return zlink_1.RequestResult.NotSupported;
-        case zlink_1.SubmitResult.Terminated:
-            return zlink_1.RequestResult.Terminated;
-        default:
-            return zlink_1.RequestResult.InternalError;
-    }
+    return {
+        terminalResult: zlink_1.RequestResult.InternalError,
+        failureCode: service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestFailed
+    };
 }
 function encodeMultipart(parts) {
     const values = Array.isArray(parts) ? parts : [parts];
@@ -1616,7 +1630,8 @@ function encodeMultipartApplicationFrame(parts) {
 }
 function decodeApplicationEnvelope(frame) {
     const bytes = Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength);
-    if (bytes.length < 11 || bytes[0] !== 1) {
+    if (bytes.length < service_wire_m6a_codec_1.APPLICATION_PAYLOAD_MINIMUM_FIELD_BYTES ||
+        bytes[0] !== service_wire_m6a_codec_1.APPLICATION_PAYLOAD_VERSION) {
         throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid application envelope.');
     }
     const bodyLength = bytes.readUInt32BE(1);
@@ -1714,20 +1729,33 @@ function requireRawReadyBatch(batch) {
     return batch;
 }
 function stateCode(state) {
-    return ['preparing', 'serving', 'retiring', 'draining', 'stopped', 'error'].indexOf(state) + 1;
+    switch (state) {
+        case 'preparing':
+            return service_runtime_contracts_1.MeshNodeRuntimeState.Preparing;
+        case 'serving':
+            return service_runtime_contracts_1.MeshNodeRuntimeState.Serving;
+        case 'retiring':
+            return service_runtime_contracts_1.MeshNodeRuntimeState.Retiring;
+        case 'draining':
+            return service_runtime_contracts_1.MeshNodeRuntimeState.Draining;
+        case 'stopped':
+            return service_runtime_contracts_1.MeshNodeRuntimeState.Stopped;
+        case 'error':
+            return service_runtime_contracts_1.MeshNodeRuntimeState.Error;
+    }
 }
 function peerStateCode(state) {
     switch (state) {
         case 'preparing':
-            return 2;
+            return service_runtime_contracts_1.MeshPeerRuntimeState.Preparing;
         case 'serving':
         case 'retiring':
-            return 3;
+            return service_runtime_contracts_1.MeshPeerRuntimeState.Serving;
         case 'draining':
-            return 4;
+            return service_runtime_contracts_1.MeshPeerRuntimeState.Draining;
         case 'stopped':
         case 'error':
-            return 5;
+            return service_runtime_contracts_1.MeshPeerRuntimeState.Closed;
     }
 }
 function createLifecycleGeneration() {
@@ -1738,14 +1766,14 @@ function createLifecycleGeneration() {
     return generation === 0n ? 1n : generation;
 }
 function requirePositivePlacementValue(value, name) {
-    if (!Number.isSafeInteger(value) || value <= 0 || value > 0x7fff_ffff) {
-        throw new RangeError(`${name} must be an integer in 1..2147483647.`);
+    if (!(0, RegistrationBuilderPolicy_1.isValidPositiveCapacity)(value)) {
+        throw new RangeError(`${name} must be an integer in 1..${RegistrationBuilderPolicy_1.ZLINK_MAX_CAPACITY}.`);
     }
     return value;
 }
 function requirePublicWeight(value, name) {
-    if (!Number.isInteger(value) || value < 0 || value > 10_000) {
-        throw new RangeError(`${name} must be an integer in 0..10000.`);
+    if (!(0, RegistrationBuilderPolicy_1.isValidPublicWeight)(value)) {
+        throw new RangeError(`${name} must be an integer in 0..${RegistrationBuilderPolicy_1.ZLINK_MAX_PUBLIC_WEIGHT}.`);
     }
     return value;
 }

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

@@ -4,6 +4,7 @@ exports.wrapSocket = wrapSocket;
 exports.nodeEventLoopPollerOf = nodeEventLoopPollerOf;
 exports.disconnectStreamPeer = disconnectStreamPeer;
 exports.isEndpointCloseIgnorableError = isEndpointCloseIgnorableError;
+const RegistrationBuilderPolicy_1 = require("../../../contracts/Configuration/RegistrationBuilderPolicy");
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const node_event_loop_poller_1 = require("./node-event-loop-poller");
 const eventLoopPollers = new WeakMap();
@@ -68,7 +69,7 @@ function wrapSocket(nativeInstance, pollCompletion) {
             nativeInstance.setRoutingId((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
         },
         get peerWeight() {
-            return socket.options?.peerWeight ?? 100;
+            return socket.options?.peerWeight ?? RegistrationBuilderPolicy_1.ZLINK_DEFAULT_PUBLIC_WEIGHT;
         },
         set peerWeight(value) {
             requireSocketOptions(socket).peerWeight = value;
@@ -243,6 +244,6 @@ function isEndpointCloseIgnorableError(error) {
     return ((0, node_backend_adapter_support_1.isContextTerminatedError)(error) ||
         (error instanceof Error &&
             'code' in error &&
-            (error.code === 604 ||
+            (error.code === node_backend_adapter_support_1.zlink.ConnectResult.InternalError ||
                 error.code === node_backend_adapter_support_1.zlink.ConnectResult.NotFound)));
 }

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

@@ -24,7 +24,7 @@ export interface ZLinkRawMonitorRecord {
     readonly flags?: number;
 }
 export interface ZLinkRawSocketPort {
-    setReadableHandler(handler: () => void): void;
+    setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void;
     bind(endpoint: string): void;
     unbind(endpoint: string): void;
     connect(endpoint: string): void;