@zlink-systems/framework 0.30.1 → 0.30.2

package/dist/runtime/host/application-job-queue.d.ts

@@ -40,11 +40,12 @@ export declare function resolveApplicationJobQueueConfiguration(options?: Applic
 export declare class ApplicationJobQueuePermit implements ApplicationJobPermitPort {
     private readonly owner;
     readonly origin: ApplicationJobOrigin;
-    private readonly reusable;
+    private readonly storage?;
     detachedForHandlerTurn: boolean;
     private state;
-    constructor(owner: ApplicationJobQueue, origin: ApplicationJobOrigin, reusable?: boolean);
+    constructor(owner: ApplicationJobQueue, origin: ApplicationJobOrigin, storage?: ApplicationJobReceiveRotation | undefined);
     reserveStorage(): boolean;
+    reacquire(signal: AbortSignal): Promise<ApplicationJobPermitPort>;
     releaseStorage(): void;
     detachForHandlerTurn(): void;
     markApplicationQueued(): void;
@@ -52,6 +53,25 @@ export declare class ApplicationJobQueuePermit implements ApplicationJobPermitPo
     releaseAfterInternalProcessing(): void;
     takeReleaseState(): 'reserved' | 'queued' | undefined;
 }
+/**
+ * Connection-owned storage; queue accounting remains with the host queue.
+ * The rotation budget is a count reserved from the queue. Only a record that
+ * is actually received takes a permit, from the idle storage stack, so a
+ * rotation that receives one record touches one permit.
+ */
+declare class ApplicationJobReceiveRotation implements ApplicationJobReceiveRotationPort {
+    private readonly owner;
+    private readonly capacity;
+    private readonly origin;
+    private readonly idle;
+    private granted;
+    private consumed;
+    constructor(owner: ApplicationJobQueue, capacity: number, origin: ApplicationJobOrigin);
+    reserve(): void;
+    take(): ApplicationJobQueuePermit | undefined;
+    releaseUnused(): void;
+    returnIdle(permit: ApplicationJobQueuePermit): void;
+}
 /**
  * Host-instance owner of the ordinary-ingress queue permit lifecycle.
  * It reserves capacity before receive/claim and transfers released capacity
@@ -100,7 +120,7 @@ export declare class ApplicationJobQueue implements ApplicationJobQueuePort {
     recordFlowStateConfigFailure(): void;
     markQueued(): void;
     releasePermit(permit: ApplicationJobQueuePermit): void;
-    releaseUnusedReceiveRotation(grants: readonly (ApplicationJobQueuePermit | undefined)[], consumed: number, granted: number): void;
+    releaseUnusedReceiveRotation(count: number): void;
     release(state: 'reserved' | 'queued', count?: number): void;
     private limit;
     private permitsInUse;
@@ -116,3 +136,4 @@ export declare class ApplicationJobQueue implements ApplicationJobQueuePort {
     private cumulativePauseDurationAt;
 }
 export declare function nodeEffectiveProcessorCount(explicitExecutorMaximum?: number, runtimeConstrainedLogicalCount?: number, readSystemText?: (path: string) => string | undefined): bigint;
+export {};

package/dist/runtime/host/application-job-queue.js

@@ -53,14 +53,14 @@ function resolveApplicationJobQueueConfiguration(options = {}, effectiveProcesso
 class ApplicationJobQueuePermit {
     owner;
     origin;
-    reusable;
+    storage;
     detachedForHandlerTurn = false;
     state;
-    constructor(owner, origin, reusable = false) {
+    constructor(owner, origin, storage) {
         this.owner = owner;
         this.origin = origin;
-        this.reusable = reusable;
-        this.state = reusable ? 'idle' : 'reserved';
+        this.storage = storage;
+        this.state = storage === undefined ? 'reserved' : 'idle';
     }
     reserveStorage() {
         if (this.state !== 'idle')
@@ -69,12 +69,16 @@ class ApplicationJobQueuePermit {
         this.detachedForHandlerTurn = false;
         return true;
     }
+    reacquire(signal) {
+        return this.owner.acquire(signal, this.origin);
+    }
     releaseStorage() {
-        if (!this.reusable || this.state === 'idle')
+        if (this.storage === undefined || this.state === 'idle')
             return;
         if (this.state !== 'released')
             throw new Error('Reservation storage still owns queue capacity.');
         this.state = 'idle';
+        this.storage.returnIdle(this);
     }
     detachForHandlerTurn() {
         this.detachedForHandlerTurn = true;
@@ -103,60 +107,49 @@ class ApplicationJobQueuePermit {
     }
 }
 exports.ApplicationJobQueuePermit = ApplicationJobQueuePermit;
-/** Connection-owned storage; queue accounting remains with the host queue. */
+/**
+ * Connection-owned storage; queue accounting remains with the host queue.
+ * The rotation budget is a count reserved from the queue. Only a record that
+ * is actually received takes a permit, from the idle storage stack, so a
+ * rotation that receives one record touches one permit.
+ */
 class ApplicationJobReceiveRotation {
     owner;
     capacity;
     origin;
-    storage = [];
-    grants;
+    idle = [];
     granted = 0;
     consumed = 0;
     constructor(owner, capacity, origin) {
         this.owner = owner;
         this.capacity = capacity;
         this.origin = origin;
-        this.grants = new Array(capacity);
-        this.prepareStorage();
-    }
-    prepareStorage() {
-        for (let index = 0; index < this.capacity; index++)
-            this.storage.push(new ApplicationJobQueuePermit(this.owner, this.origin, true));
     }
     reserve() {
         this.releaseUnused();
         const count = this.owner.receiveRotationCapacity(this.capacity);
         if (count === 0)
             return;
-        for (let index = 0; index < this.storage.length; index++) {
-            const permit = this.storage[index];
-            if (permit.reserveStorage())
-                this.grants[this.granted++] = permit;
-            if (this.granted === count)
-                break;
-        }
-        if (this.granted < count) {
-            const start = this.storage.length;
-            this.prepareStorage();
-            for (let index = start; this.granted < count; index++) {
-                const permit = this.storage[index];
-                permit.reserveStorage();
-                this.grants[this.granted++] = permit;
-            }
-        }
+        this.granted = count;
         this.owner.reserveReceiveRotation(count);
     }
     take() {
         if (this.consumed === this.granted)
             return undefined;
-        return this.grants[this.consumed++];
+        this.consumed++;
+        const permit = this.idle.pop() ?? new ApplicationJobQueuePermit(this.owner, this.origin, this);
+        permit.reserveStorage();
+        return permit;
     }
     releaseUnused() {
-        this.owner.releaseUnusedReceiveRotation(this.grants, this.consumed, this.granted);
-        // Keep the prepared grant slots and reset only the logical count.
+        // Unconsumed budget never became a permit; it returns as a count.
+        this.owner.releaseUnusedReceiveRotation(this.granted - this.consumed);
         this.granted = 0;
         this.consumed = 0;
     }
+    returnIdle(permit) {
+        this.idle.push(permit);
+    }
 }
 /**
  * Host-instance owner of the ordinary-ingress queue permit lifecycle.
@@ -355,16 +348,10 @@ class ApplicationJobQueue {
         if (state !== undefined)
             this.release(state);
     }
-    releaseUnusedReceiveRotation(grants, consumed, granted) {
-        const count = granted - consumed;
+    releaseUnusedReceiveRotation(count) {
+        // Unconsumed budget still belongs to this receive round; no record has acquired it.
         if (count === 0)
             return;
-        // Unconsumed grants still belong to this receive round; no record has acquired them.
-        for (let index = consumed; index < granted; index++) {
-            const permit = grants[index];
-            permit.takeReleaseState();
-            permit.releaseStorage();
-        }
         this.release('reserved', count);
     }
     release(state, count = 1) {

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

@@ -91,6 +91,7 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     readonly routeMeshRuntime: ZLinkRouteMeshRuntime;
     readonly clientServerRuntime: ZLinkClientServerRuntime;
     readonly fanoutRuntime: ZLinkFanoutRuntime;
+    private readonly relocationStore?;
     private readonly routeMeshCoordinator;
     constructor(options: ZLinkFrameworkRuntimeHostOptions, internalOptions?: unknown);
     get isStarted(): boolean;
@@ -135,6 +136,9 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private stopCore;
     private installOwnerLeaseRecoveryPublication;
     private resumeOwnerLeaseOwnedWork;
+    private enterServing;
+    private publishOrStayPreparing;
+    private startStatefulAuthority;
     private createStatefulAuthorityRoutes;
     private requiresStatefulAuthorityRuntime;
     private installLocationBackedAuthorities;
@@ -153,7 +157,6 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private publishHostRelocated;
     private publishHostDraining;
     private cleanupOwnerForDrain;
-    private forceStopMesh;
     private registerInstanceApplicationLifecycle;
     setActorManager(actorManager: DefaultZLinkActorManager): void;
     setSpotManager(spotManager: DefaultZLinkSpotManager): void;
@@ -169,6 +172,7 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private dispatchMeshNodePayload;
     private completeFormalSourceLeave;
     private dispatchMeshRecord;
+    private admitMeshDispatch;
     private dispatchMeshActorBinding;
     private submitLocalMeshRoute;
     private dispatchMeshSpotRecord;