@zlink-systems/framework 0.25.0 → 0.26.0

package/dist/runtime/execution/serial-execution-queue.js

@@ -13,6 +13,7 @@ class ZLinkSerialExecutionQueue {
     executeRecord;
     application;
     lifecycle;
+    activeLifecycle;
     ownerTimeBudget;
     lifecycleBurstLimit;
     nextAcceptedSequence = 1n;
@@ -71,16 +72,15 @@ class ZLinkSerialExecutionQueue {
     submitPreAdmitted(operation, options = {}, context) {
         return this.admit(operation, options, context);
     }
-    snapshot() {
-        return {
-            applicationMessages: this.application.records.length,
-            applicationBytes: 0,
-            lifecycleMessages: this.lifecycle.records.length,
-            lifecycleBytes: 0
-        };
+    /** Holds lifecycle FIFO through an operation result while its application turns can run. */
+    submitLifecycleOperation(operation) {
+        return this.admit(operation, { lane: 'lifecycle' }, undefined, undefined, true);
     }
     get hasPendingWork() {
-        return (this.draining || this.application.records.length > 0 || this.lifecycle.records.length > 0);
+        return (this.draining ||
+            this.activeLifecycle !== undefined ||
+            this.application.records.length > 0 ||
+            this.lifecycle.records.length > 0);
     }
     whenIdle() {
         if (!this.hasPendingWork)
@@ -89,10 +89,14 @@ class ZLinkSerialExecutionQueue {
     }
     /** Stops new submissions while allowing the accepted FIFO to finish. */
     close() {
-        this.closed = true;
+        this.closeAdmission();
         return this.whenIdle();
     }
-    admit(operation, options, context, preparation) {
+    /** Stops admission within the lifecycle operation that owns this queue's close. */
+    closeAdmission() {
+        this.closed = true;
+    }
+    admit(operation, options, context, preparation, operationEnvelope = false) {
         if (this.closed)
             throw new Error('The serial execution queue is closed.');
         const lane = options.lane ?? 'application';
@@ -109,6 +113,15 @@ class ZLinkSerialExecutionQueue {
             if (released)
                 return;
             released = true;
+            if (this.activeLifecycle === record) {
+                this.activeLifecycle = undefined;
+                if (this.application.records.length > 0 || this.lifecycle.records.length > 0) {
+                    this.scheduleDrain();
+                }
+                else if (!this.draining) {
+                    this.resolveIdleWaiters();
+                }
+            }
         };
         const resolve = (value) => {
             if (settled)
@@ -126,6 +139,7 @@ class ZLinkSerialExecutionQueue {
             acceptedSequence: 0n,
             lane,
             operation,
+            operationEnvelope,
             context,
             preparation,
             preparationState: preparation === undefined ? 'ready' : 'idle',
@@ -197,7 +211,24 @@ class ZLinkSerialExecutionQueue {
                 }
                 this.claimStartedAt ??= performance.now();
                 try {
-                    await this.executeRecord(record);
+                    if (record.operationEnvelope) {
+                        try {
+                            const outcome = record.operation();
+                            void Promise.resolve(outcome).then((value) => {
+                                record.resolve(value);
+                                record.release();
+                            }, (error) => {
+                                record.reject(error);
+                                record.release();
+                            });
+                        }
+                        catch (error) {
+                            record.fail(error);
+                        }
+                    }
+                    else {
+                        await this.executeRecord(record);
+                    }
                 }
                 catch (error) {
                     record.fail(error);
@@ -215,11 +246,12 @@ class ZLinkSerialExecutionQueue {
             this.draining = false;
             this.claimStartedAt = undefined;
             if (!waitingForPreparation &&
-                (this.application.records.length > 0 || this.lifecycle.records.length > 0)) {
+                (this.application.records.length > 0 ||
+                    (this.activeLifecycle === undefined && this.lifecycle.records.length > 0))) {
                 this.scheduleDrain();
             }
             else {
-                if (this.application.records.length === 0 && this.lifecycle.records.length === 0) {
+                if (!this.hasPendingWork) {
                     this.resolveIdleWaiters();
                 }
             }
@@ -227,7 +259,7 @@ class ZLinkSerialExecutionQueue {
     }
     selectNext() {
         const applicationReady = this.application.records.length > 0;
-        const lifecycleReady = this.lifecycle.records.length > 0;
+        const lifecycleReady = this.activeLifecycle === undefined && this.lifecycle.records.length > 0;
         if (!applicationReady && !lifecycleReady)
             return undefined;
         if (!applicationReady) {
@@ -253,7 +285,9 @@ class ZLinkSerialExecutionQueue {
         if (this.application.records.length > 0 && this.lifecycleStreak >= this.lifecycleBurstLimit) {
             this.lifecycleDebt = true;
         }
-        return this.lifecycle.records.shift();
+        const record = this.lifecycle.records.shift();
+        this.activeLifecycle = record;
+        return record;
     }
     takeApplication() {
         this.lifecycleStreak = 0;

package/dist/runtime/foundation/listener-records.d.ts

@@ -0,0 +1,11 @@
+import type { ZLinkListenerKind } from '../../contracts/RouteMesh/RuntimeTopology';
+/**
+ * Bound listener records of one runtime generation (spec 04 §3.1). A listener writes its
+ * record when it finishes binding. The listener status query reads only this object.
+ */
+export declare class ZLinkListenerRecords {
+    private readonly endpoints;
+    record(kind: ZLinkListenerKind, name: string, endpoint: string): void;
+    clear(): void;
+    endpoint(kind: ZLinkListenerKind, name: string): string | undefined;
+}

package/dist/runtime/foundation/listener-records.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkListenerRecords = void 0;
+/**
+ * Bound listener records of one runtime generation (spec 04 §3.1). A listener writes its
+ * record when it finishes binding. The listener status query reads only this object.
+ */
+class ZLinkListenerRecords {
+    endpoints = new Map();
+    record(kind, name, endpoint) {
+        this.endpoints.set(`${kind}:${name}`, endpoint);
+    }
+    clear() {
+        this.endpoints.clear();
+    }
+    endpoint(kind, name) {
+        return this.endpoints.get(`${kind}:${name}`);
+    }
+}
+exports.ZLinkListenerRecords = ZLinkListenerRecords;

package/dist/runtime/foundation/raw-service-mesh-runtime.d.ts

@@ -59,17 +59,11 @@ export declare class RawServiceMeshRuntime {
     private readonly expectedPeers;
     private readonly endpointOnlyPeers;
     private readonly peerConnectionIntentRemoved;
-    private readonly connectionCandidates;
-    private readonly unresolvedConnectionCandidates;
-    private readonly connectionIds;
     /**
-     * The monitor drain updates this fence before the event reaches the
-     * normal runtime handler. `null` means that the last observed pair is no
-     * longer usable by the application route.
+     * The last observed Core selected route of each RID (Core ROUTER §10.1):
+     * RID -> route generation. Only `observeSelectedRoutes` replaces it.
      */
-    private readonly monitorConnectionStates;
-    private monitorEvents;
-    private monitorDrainBuffer;
+    private selectedRoutes;
     private readonly bindingPort;
     private readonly applicationJobQueue;
     private readonly peerAdmissionSealed?;
@@ -82,7 +76,6 @@ export declare class RawServiceMeshRuntime {
     private descriptor;
     private host?;
     private router?;
-    private monitor?;
     private nextCorrelation;
     private serviceIngress?;
     private closed;
@@ -124,12 +117,17 @@ export declare class RawServiceMeshRuntime {
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
     pumpBatch(receiveReady?: boolean): Promise<boolean>;
     private receiveOne;
-    private pullMonitorEvents;
     private reportProtocolError;
     private replyGenericProtocolError;
     private processReceived;
     tickLiveness(nowMs?: number): Promise<ServiceLivenessTick>;
-    drainMonitorEvents(nowMs?: number): Promise<number>;
+    /**
+     * The socket's one route observer (Core ROUTER §10.1). It replaces the
+     * observation with Core's selected-route snapshot, ends the admission of
+     * every RID whose observed route disappeared or was replaced, and starts the
+     * handshake of every newly selected route. Returns the number of changes.
+     */
+    observeSelectedRoutes(): Promise<number>;
     close(): void;
     private requestToTarget;
     /**
@@ -139,18 +137,9 @@ export declare class RawServiceMeshRuntime {
     private applicationFrame;
     private applicationPayload;
     private admitPeer;
-    private currentConnectionCandidate;
-    private createConnectionCandidate;
-    private createUnresolvedConnectionCandidate;
-    private promoteUnresolvedConnectionCandidate;
-    private removeConnectionCandidate;
-    private isDiscoveredLifecycleReplacement;
-    private expectedPeerRoutingId;
-    private acceptsExpectedMonitorEndpoint;
     private retireNotRequiredExpectedPeer;
     private selectBilateralConnection;
     private removePeer;
-    private observeMonitorEvent;
     private requireStarted;
     private send;
 }