@zlink-systems/framework 0.26.0 → 0.28.0

package/dist/runtime/backend/node/node-event-loop-poller.js

@@ -37,19 +37,18 @@ class ZLinkNodeEventLoopPoller {
     dispose() {
         if (this.disposed)
             return;
-        this.disposed = true;
-        this.events.close();
         this.poller.close();
+        this.events.close();
+        this.disposed = true;
     }
     onReady = () => {
         if (this.disposed)
             return;
         const ready = this.poller.wait(this.events, 0);
-        if (ready === 0 ||
-            this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn) ||
-            this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute)) {
-            this.readableHandler();
-        }
+        const receiveReady = ready === 0 || this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn);
+        const routeReady = ready > 0 && this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute);
+        if (receiveReady || routeReady)
+            this.readableHandler(receiveReady, routeReady);
     };
 }
 exports.ZLinkNodeEventLoopPoller = ZLinkNodeEventLoopPoller;

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

@@ -30,6 +30,7 @@ function wrapMonitorSocket(nativeInstance) {
 function toBackendMonitorEvent(event) {
     return {
         nativeEvent: event.event,
+        readyEdge: (event.flags & node_backend_adapter_support_1.zlink.MonitorEventFlag.ConnectionReadyEdge) !== 0,
         routingId: event.routingId ?? undefined,
         localAddr: event.localAddr,
         remoteAddr: event.remoteAddr,

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

@@ -48,15 +48,16 @@ class NodeRawHostPort {
             return;
         this.state = 'stopping';
         const failures = [];
-        for (const resource of this.resources.splice(0).reverse()) {
+        for (const resource of [...this.resources].reverse()) {
             try {
                 resource.close();
+                this.resources.splice(this.resources.indexOf(resource), 1);
             }
             catch (error) {
                 failures.push(error);
             }
         }
-        if (this.ownsContext) {
+        if (this.ownsContext && failures.length === 0) {
             try {
                 this.context.close();
             }
@@ -64,10 +65,10 @@ class NodeRawHostPort {
                 failures.push(error);
             }
         }
-        this.state = 'closed';
         if (failures.length > 0) {
             throw new AggregateError(failures, 'Raw binding host cleanup failed.');
         }
+        this.state = 'closed';
     }
     own(resource) {
         this.resources.push(resource);
@@ -158,18 +159,17 @@ class NodeRawSocketPort {
                 failures.push(error);
             }
         }
+        if (failures.length > 0) {
+            throw new AggregateError(failures, 'Raw socket cleanup failed.');
+        }
         this.endpoints.clear();
         try {
             this.socket.close();
         }
         catch (error) {
-            failures.push(error);
+            throw new AggregateError([error], 'Raw socket cleanup failed.');
         }
         this.closed = true;
-        if (failures.length > 0) {
-            console.error('Raw socket cleanup causes:', failures);
-            throw new AggregateError(failures, 'Raw socket cleanup failed.');
-        }
     }
     requireOpen() {
         if (this.closed)
@@ -204,23 +204,29 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         this.socket.options.setConnectRoutingId(bindingRoutingId(routingId));
         this.connect(endpoint);
     }
-    async send(targetRid, parts) {
+    send(targetRid, parts) {
         this.requireOpen();
-        const submission = appendSendParts(this.socket.send(bindingRoutingId(targetRid)), parts).submit();
-        if (submission.result === zlink_1.SubmitResult.Backpressured) {
-            await submission.admitted;
-        }
+        requireParts(parts);
+        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(bindingRoutingId(targetRid)), parts);
     }
     async request(targetRid, parts, timeoutMs) {
         this.requireOpen();
+        const deadlineMs = performance.now() + timeoutMs;
+        let submission;
         try {
-            const replies = await appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
+            submission = appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
                 .timeout(timeoutMs)
-                .submit().reply;
+                .submit();
+        }
+        catch (error) {
+            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
+        }
+        try {
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs);
             return copyAndClose(replies);
         }
         catch (error) {
-            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error);
+            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
         }
     }
     routesSnapshot() {
@@ -250,19 +256,28 @@ class NodeRawDealerPort extends NodeRawSocketPort {
         this.requireOpen();
         this.socket.setRoutingId(bindingRoutingId(routingId));
     }
-    async send(parts) {
+    send(parts) {
         this.requireOpen();
-        const submission = appendSendParts(this.socket.send(), parts).submit();
-        if (submission.result === zlink_1.SubmitResult.Backpressured) {
-            await submission.admitted;
-        }
+        requireParts(parts);
+        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(), parts);
     }
     async request(parts, timeoutMs) {
         this.requireOpen();
-        const replies = await appendRequestParts(this.socket.request(), parts)
-            .timeout(timeoutMs)
-            .submit().reply;
-        return copyAndClose(replies);
+        const deadlineMs = performance.now() + timeoutMs;
+        let submission;
+        try {
+            submission = appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit();
+        }
+        catch (error) {
+            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
+        }
+        try {
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs);
+            return copyAndClose(replies);
+        }
+        catch (error) {
+            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
+        }
     }
     receive(dontWait = false) {
         this.requireOpen();
@@ -297,18 +312,10 @@ class NodeRawMonitorPort {
     close() {
         if (this.closed)
             return;
+        this.monitor.close();
         this.closed = true;
         this.release();
-        this.monitor.close();
-    }
-}
-function appendSendParts(operation, parts) {
-    requireParts(parts);
-    let next = operation.message(parts[0]);
-    for (let index = 1; index < parts.length; index += 1) {
-        next = next.message(parts[index]);
     }
-    return next;
 }
 function appendRequestParts(operation, parts) {
     requireParts(parts);

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

@@ -1,18 +1,18 @@
 import { SubmitResult, type RequestResult as RequestResultValue, type SubmitResult as SubmitResultValue } from '@zlink-systems/zlink';
-import { type ZLinkBackendMessageLike as MessageLike } from '../runtime-values';
+import { type RoutingId } from '../../../contracts';
+import type { ApplicationJobQueuePort } from '../../application-jobs/contracts';
 import type { ZLinkDispatchErrorReporter } from '../../channels/dispatch-error-reporter';
-import type { MeshOperationId, MeshPeerEntry, MeshPublisher, ReadyBatch, ReadyRecord, ReceiveBatch, ServiceSpot, StreamSessionService } from '../../foundation/service-runtime-contracts';
 import { type RawServiceRequestResult } from '../../foundation/raw-service-mesh-runtime';
-import { type ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
-import { ServiceStatefulRuntime, type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
+import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation/service-instance-activation-recovery-codec';
+import { type MeshOperationId, type MeshPeerEntry, type MeshPublisher, type ReadyBatch, type ReadyRecord, type ReceiveBatch, type ServiceSpot, type StreamSessionService, MeshNodeRuntimeState } from '../../foundation/service-runtime-contracts';
 import type { ServiceActorRef, ServiceSpotState } from '../../foundation/service-stateful-registry';
+import { type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
 import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceActivationTarget, ServiceInstanceRouteFence, ServiceSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
-import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation/service-instance-activation-recovery-codec';
 import type { ServiceNodeDescriptor } from '../../foundation/service-topology-registry';
-import type { RoutingId } from '../../../contracts';
-import type { ZLinkBackendActorRef, ZLinkBackendObjectPlacement, ZLinkBackendMeshNode } from '../contracts';
+import { type ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
+import type { ZLinkBackendActorRef, ZLinkBackendMeshNode, ZLinkBackendObjectPlacement } from '../contracts';
 import type { ZLinkRawBindingPort } from '../raw-binding-port';
-import type { ApplicationJobQueuePort } from '../../application-jobs/contracts';
+import { type ZLinkBackendMessageLike as MessageLike } from '../runtime-values';
 /**
  * M6A MeshNode backend. Stateful Spot/Actor entry points stay explicit until
  * their owning M6B runtime is connected; topology and node/channel dispatch do
@@ -42,6 +42,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private readable;
     private readonly onReadable;
     private readonly onMaintenance;
+    private readonly onPendingOperationsChanged;
     private nextPeerIntent;
     private closed;
     private objectRole;
@@ -54,7 +55,6 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private protocolError?;
     private messageFollowHandler?;
     private dispatchErrors?;
-    private spotAdmissionProvider?;
     private readonly peerDisconnectedHandlers;
     constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined);
     configureObjectPlacement(options: {
@@ -70,7 +70,6 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly owner: string;
     }) => void): void;
     setDispatchErrorReporter(reporter: ZLinkDispatchErrorReporter): void;
-    setSpotAdmissionProvider(provider: Parameters<ServiceStatefulRuntime['setSpotAdmissionProvider']>[0]): void;
     setProtocolErrorHandler(handler: (record: {
         readonly sourceNodeRid: string;
         readonly request: boolean;
@@ -130,7 +129,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly timeoutMs?: number;
     }): MeshOperationId;
     status(): {
-        state: number;
+        state: MeshNodeRuntimeState;
         routingId: RoutingId;
         meshName: string;
         localEndpoint: string;
@@ -174,7 +173,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     restoreUserSpotAuthority(spotId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpot;
     restoreSpotAuthority(spotId: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpot;
     createActor(actorId: string): ZLinkBackendActorRef;
-    restoreActorAuthority(actorId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint, spotId: string, spotGeneration: bigint, membershipEpoch: bigint): ZLinkBackendActorRef;
+    restoreActorAuthority(actorId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint, spotId: string | undefined, spotGeneration: bigint, membershipEpoch: bigint): ZLinkBackendActorRef;
     discardRelocatedActor(actor: ZLinkBackendActorRef): void;
     restoreActorSessionBinding(actor: ZLinkBackendActorRef, sessionNodeRid: unknown, sessionRid: unknown, bindingGeneration: bigint): void;
     registerInstanceIntent(instanceType: string, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): void;
@@ -195,8 +194,8 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     abortSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal): boolean;
     commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
     forgetSpotRoute(spot: ServiceSpotRouteFence['spot'], authorityOwnerGeneration: bigint, storeVersion?: string): void;
-    sendToInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
-    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    sendToInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): Promise<SubmitResult>;
+    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): MeshOperationId;
     actorLookup(actorId: string): {
         actor: ServiceActorRef;
         spotId: string;
@@ -265,7 +264,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
 /**
  * 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.