@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/runtime/foundation/service-wire-m6a-codec.js

@@ -54,8 +54,7 @@ function encodeNodeSendHeader() {
 function encodeNodeRequestHeader(correlation) {
     return withU64(prefix(exports.M6aServiceWireCommand.nodeRequest), correlation, 'correlation');
 }
-function decodeNodeRequestHeader(frame) {
-    const header = decodeHeader(frame);
+function decodeNodeRequestHeader(frame, header = decodeHeader(frame)) {
     if (header.command !== exports.M6aServiceWireCommand.nodeRequest ||
         header.flags !== 0 ||
         frame.byteLength !== 13) {
@@ -66,8 +65,7 @@ function decodeNodeRequestHeader(frame) {
 function encodeChannelSendHeader(channelName) {
     return concat(prefix(exports.M6aServiceWireCommand.channelSend), encodeText8(channelName, 'channelName'));
 }
-function decodeChannelSendHeader(frame) {
-    const header = decodeHeader(frame);
+function decodeChannelSendHeader(frame, header = decodeHeader(frame)) {
     if (header.command !== exports.M6aServiceWireCommand.channelSend || header.flags !== 0) {
         fail('Invalid channelSend header.');
     }
@@ -79,8 +77,7 @@ function decodeChannelSendHeader(frame) {
 function encodeChannelRequestHeader(correlation, channelName) {
     return concat(withU64(prefix(exports.M6aServiceWireCommand.channelRequest), correlation, 'correlation'), encodeText8(channelName, 'channelName'));
 }
-function decodeChannelRequestHeader(frame) {
-    const header = decodeHeader(frame);
+function decodeChannelRequestHeader(frame, header = decodeHeader(frame)) {
     if (header.command !== exports.M6aServiceWireCommand.channelRequest || header.flags !== 0) {
         fail('Invalid channelRequest header.');
     }
@@ -127,22 +124,8 @@ function decodeReplyHeader(frame) {
     return result;
 }
 function encodeApplicationPayload(payload) {
-    const packetName = encodeText8(payload.packetName, 'packetName');
-    const contentType = encodeText8(payload.contentType, 'contentType');
-    if (payload.payload.byteLength > MAX_U32)
-        fail('Application payload exceeds u32.');
-    const bodyLength = packetName.byteLength + contentType.byteLength + 4 + payload.payload.byteLength;
-    if (bodyLength > MAX_U32)
-        fail('Application payload body exceeds u32.');
-    const result = Buffer.alloc(5 + bodyLength);
-    result[0] = exports.APPLICATION_PAYLOAD_VERSION;
-    result.writeUInt32BE(bodyLength, 1);
-    let offset = 5;
-    offset += packetName.copy(result, offset);
-    offset += contentType.copy(result, offset);
-    result.writeUInt32BE(payload.payload.byteLength, offset);
-    offset += 4;
-    Buffer.from(payload.payload.buffer, payload.payload.byteOffset, payload.payload.byteLength).copy(result, offset);
+    const result = allocateApplicationPayload(payload.packetName, payload.contentType, payload.payload.byteLength);
+    result.set(payload.payload, result.byteLength - payload.payload.byteLength);
     return result;
 }
 /**
@@ -155,8 +138,6 @@ function encodeMultipartApplicationPayload(parts, packetName, contentType) {
         fail('Multipart payload must contain at least one part.');
     if (parts.length > MAX_U32)
         fail('Multipart part count exceeds u32.');
-    const packetNameBytes = encodeText8(packetName, 'packetName');
-    const contentTypeBytes = encodeText8(contentType, 'contentType');
     let multipartLength = 4;
     for (const part of parts) {
         if (part.byteLength > MAX_U32)
@@ -165,27 +146,44 @@ function encodeMultipartApplicationPayload(parts, packetName, contentType) {
         if (multipartLength > MAX_U32)
             fail('Multipart payload exceeds u32.');
     }
-    const bodyLength = packetNameBytes.byteLength + contentTypeBytes.byteLength + 4 + multipartLength;
-    if (bodyLength > MAX_U32)
-        fail('Application payload body exceeds u32.');
-    const result = Buffer.alloc(5 + bodyLength);
-    result[0] = exports.APPLICATION_PAYLOAD_VERSION;
-    result.writeUInt32BE(bodyLength, 1);
-    let offset = 5;
-    offset += packetNameBytes.copy(result, offset);
-    offset += contentTypeBytes.copy(result, offset);
-    result.writeUInt32BE(multipartLength, offset);
-    offset += 4;
+    const result = allocateApplicationPayload(packetName, contentType, multipartLength);
+    let offset = result.byteLength - multipartLength;
     result.writeUInt32BE(parts.length, offset);
     offset += 4;
     for (const part of parts) {
         result.writeUInt32BE(part.byteLength, offset);
         offset += 4;
-        Buffer.from(part.buffer, part.byteOffset, part.byteLength).copy(result, offset);
+        result.set(part, offset);
         offset += part.byteLength;
     }
     return result;
 }
+function allocateApplicationPayload(packetName, contentType, payloadLength) {
+    const packetNameBytes = (0, service_wire_binary_primitives_1.encodeCanonicalServiceWireText)(packetName, 'packetName', service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES, fail);
+    const contentTypeBytes = (0, service_wire_binary_primitives_1.encodeCanonicalServiceWireText)(contentType, 'contentType', service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES, fail);
+    if (payloadLength > MAX_U32)
+        fail('Application payload exceeds u32.');
+    const frameLength = exports.APPLICATION_PAYLOAD_MINIMUM_FIELD_BYTES +
+        packetNameBytes.byteLength +
+        contentTypeBytes.byteLength +
+        payloadLength;
+    const prefixLength = 1 + APPLICATION_PAYLOAD_LENGTH_FIELD_BYTES;
+    const bodyLength = frameLength - prefixLength;
+    if (bodyLength > MAX_U32)
+        fail('Application payload body exceeds u32.');
+    const result = Buffer.alloc(frameLength);
+    result[0] = exports.APPLICATION_PAYLOAD_VERSION;
+    result.writeUInt32BE(bodyLength, 1);
+    let offset = prefixLength;
+    result[offset++] = packetNameBytes.byteLength;
+    result.set(packetNameBytes, offset);
+    offset += packetNameBytes.byteLength;
+    result[offset++] = contentTypeBytes.byteLength;
+    result.set(contentTypeBytes, offset);
+    offset += contentTypeBytes.byteLength;
+    result.writeUInt32BE(payloadLength, offset);
+    return result;
+}
 function decodeApplicationPayload(frame) {
     const decoded = decodeApplicationPayloadView(frame);
     return {
@@ -419,7 +417,7 @@ function encodeU64(value) {
     return result;
 }
 function encodeText8(value, field) {
-    const bytes = (0, service_wire_binary_primitives_1.encodeCanonicalServiceWireText)(value, field, 0xff, fail);
+    const bytes = (0, service_wire_binary_primitives_1.encodeCanonicalServiceWireText)(value, field, service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES, fail);
     return concat(Buffer.of(bytes.byteLength), bytes);
 }
 function encodeText16(value, field) {
@@ -430,7 +428,7 @@ function tlv(id, value) {
     return concat(Buffer.of(id), encodeU32(value.byteLength), value);
 }
 function concat(...parts) {
-    return Buffer.concat(parts.map((part) => Buffer.from(part)));
+    return Buffer.concat(parts);
 }
 function readNonZeroU64(bytes, offset, field) {
     const result = bytes.readBigUInt64BE(offset);

package/dist/runtime/handlers/handler-instance-scope.d.ts

@@ -5,9 +5,17 @@ export interface ZLinkHandlerInstanceScope {
     resolve<T>(type: Type<T>): Promise<T>;
     dispose(): Promise<void>;
 }
+interface ZLinkHandlerInstanceScopeFactory {
+    prepare?(type: Type): void | (() => unknown);
+    create(context?: ZLinkMessageContext): ZLinkHandlerInstanceScope;
+}
+export declare function registerHandlerInstanceScopeFactory(providerResolver: ZLinkProviderResolver, factory: ZLinkHandlerInstanceScopeFactory): void;
+export declare function prepareHandlerInstance<T>(providerResolver: ZLinkProviderResolver | undefined, type: Type<T>): (() => T) | undefined;
 export declare function runInHandlerInstanceScope<T>(providerResolver: ZLinkProviderResolver | undefined, context: ZLinkMessageContext | undefined, callback: (scope: ZLinkHandlerInstanceScope) => Promise<T>): Promise<T>;
 export declare function resolveLifecycleHandler<T>(owner: object, type: Type<T>, providerResolver?: ZLinkProviderResolver): Promise<T>;
 export declare function runWithLifecycleHandler<THandler, TResult>(owner: object, type: Type<THandler>, providerResolver: ZLinkProviderResolver | undefined, callback: (handler: THandler) => Promise<TResult>): Promise<TResult>;
 export declare function disposeLifecycleHandlers(owner: object, detachedTaskRunner: ZLinkDetachedTaskRunner): Promise<void>;
 export declare function disposeOwnedInstance(instance: unknown): Promise<void>;
+export declare function handlerInstanceCleanup(instance: unknown): (() => unknown) | undefined;
 export declare function disposeOwnedInstances(instances: readonly unknown[]): Promise<void>;
+export {};

package/dist/runtime/handlers/handler-instance-scope.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHandlerInstanceScopeFactory = registerHandlerInstanceScopeFactory;
+exports.prepareHandlerInstance = prepareHandlerInstance;
 exports.runInHandlerInstanceScope = runInHandlerInstanceScope;
 exports.resolveLifecycleHandler = resolveLifecycleHandler;
 exports.runWithLifecycleHandler = runWithLifecycleHandler;
 exports.disposeLifecycleHandlers = disposeLifecycleHandlers;
 exports.disposeOwnedInstance = disposeOwnedInstance;
+exports.handlerInstanceCleanup = handlerInstanceCleanup;
 exports.disposeOwnedInstances = disposeOwnedInstances;
 const node_async_hooks_1 = require("node:async_hooks");
 const HANDLER_SCOPE_FACTORY = Symbol.for('@zlink-systems/framework.handler-instance-scope-factory');
@@ -13,10 +16,27 @@ const activeLifecycleScope = new node_async_hooks_1.AsyncLocalStorage();
 const detachedLifecycleResource = new node_async_hooks_1.AsyncResource('zlink:handler-instance-scope');
 const dispatchScopes = new WeakMap();
 const lifecycleScopes = new WeakMap();
+function registerHandlerInstanceScopeFactory(providerResolver, factory) {
+    Object.defineProperty(providerResolver, HANDLER_SCOPE_FACTORY, {
+        value: factory,
+        enumerable: false
+    });
+}
+function prepareHandlerInstance(providerResolver, type) {
+    if (providerResolver === undefined)
+        return () => new type();
+    const factory = providerResolver[HANDLER_SCOPE_FACTORY];
+    if (isHandlerInstanceScopeFactory(factory)) {
+        const activate = factory.prepare?.(type);
+        if (activate !== undefined)
+            return activate;
+    }
+    return undefined;
+}
 async function runInHandlerInstanceScope(providerResolver, context, callback) {
     const active = activeHandlerScope.getStore();
     if (active !== undefined) {
-        return callback(active.scope);
+        return callback(active);
     }
     if (context !== undefined) {
         const existing = dispatchScopes.get(context);
@@ -29,7 +49,7 @@ async function runInHandlerInstanceScope(providerResolver, context, callback) {
         dispatchScopes.set(context, scope);
     }
     try {
-        return await activeHandlerScope.run({ scope }, () => callback(scope));
+        return await activeHandlerScope.run(scope, () => callback(scope));
     }
     finally {
         if (context !== undefined && dispatchScopes.get(context) === scope) {
@@ -94,14 +114,15 @@ class DefaultHandlerInstanceScope {
             return existing;
         const activation = createDeferred();
         this.instances.set(type, activation.promise);
-        void this.activate(type, activation);
+        this.activate(type, activation);
         return activation.promise;
     }
     async dispose() {
         if (this.disposed)
             return;
         this.disposed = true;
-        await Promise.allSettled(this.instances.values());
+        if (this.owned.length !== this.instances.size)
+            await Promise.allSettled(this.instances.values());
         try {
             await disposeOwnedInstances(this.owned);
         }
@@ -110,21 +131,37 @@ class DefaultHandlerInstanceScope {
             this.instances.clear();
         }
     }
-    async activate(type, activation) {
-        let instance;
+    activate(type, activation) {
         try {
             const created = this.providerResolver?.create?.(type);
-            instance = created === undefined ? new type() : await created;
+            if (created === undefined) {
+                this.completeActivation(new type(), activation);
+            }
+            else {
+                void this.activatePending(created, activation);
+            }
         }
         catch (error) {
             activation.reject(error);
-            return;
         }
+    }
+    async activatePending(created, activation) {
+        try {
+            this.completeActivation(await created, activation);
+        }
+        catch (error) {
+            activation.reject(error);
+        }
+    }
+    completeActivation(instance, activation) {
         if (!this.disposed) {
             this.owned.push(instance);
             activation.resolve(instance);
             return;
         }
+        void this.disposeLateActivation(instance, activation);
+    }
+    async disposeLateActivation(instance, activation) {
         try {
             await disposeOwnedInstance(instance);
             activation.reject(new Error('Handler instance scope was disposed during activation.'));
@@ -240,18 +277,24 @@ function startOutsideLifecycleInvocation(work) {
     return detachedLifecycleResource.runInAsyncScope(work);
 }
 async function disposeOwnedInstance(instance) {
+    const cleanup = handlerInstanceCleanup(instance);
+    if (cleanup !== undefined)
+        await cleanup.call(instance);
+}
+function handlerInstanceCleanup(instance) {
     if (instance === null || instance === undefined)
         return;
     const value = instance;
     if (typeof value.dispose === 'function') {
-        await value.dispose();
+        return value.dispose;
     }
     else if (typeof value.close === 'function') {
-        await value.close();
+        return value.close;
     }
     else if (typeof value.onModuleDestroy === 'function') {
-        await value.onModuleDestroy();
+        return value.onModuleDestroy;
     }
+    return undefined;
 }
 async function disposeOwnedInstances(instances) {
     const failures = [];

package/dist/runtime/host/actor-runtime-options-factory.js

@@ -149,9 +149,9 @@ class ZLinkActorRuntimeOptionsFactory {
             staleActorRefReporter: (_meshName, actorId) => this.options.actorHandoff.recordStaleFailure(actorId),
             staleActorRefPredicate: (meshName, actor) => this.actorBelongsToMesh(meshName, actor.actorId) &&
                 this.options.actorHandoff.isKnownStale(actor),
-            handoffCapture: (meshName, actorId, parts, returnResponse, actor, deadlineUnixMs) => this.actorBelongsToMesh(meshName, actorId) &&
+            handoffCapture: (meshName, actorId, parts, returnResponse, actor, deadlineUnixMs, onAdmitted) => this.actorBelongsToMesh(meshName, actorId) &&
                 !this.options.actorHandoff.isProvisional(actorId)
-                ? this.options.actorHandoff.capture('local', actorId, parts, returnResponse, undefined, actor, deadlineUnixMs)
+                ? this.options.actorHandoff.capture('local', actorId, parts, returnResponse, undefined, actor, deadlineUnixMs, undefined, undefined, onAdmitted)
                 : undefined,
             sendErrorReporter: this.options.reportPostCommitError
         };

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

@@ -1,4 +1,4 @@
-import type { ApplicationJobOrigin, ApplicationJobPermitPort, ApplicationJobQueuePort } from '../application-jobs/contracts';
+import type { ApplicationJobOrigin, ApplicationJobPermitPort, ApplicationJobReceiveRotationPort, ApplicationJobQueuePort } from '../application-jobs/contracts';
 export type ApplicationJobQueueProfileValue = 'compact' | 'low_latency' | 'balanced' | 'throughput';
 export interface ApplicationJobQueueOptions {
     readonly profile?: ApplicationJobQueueProfileValue;
@@ -40,12 +40,17 @@ export declare function resolveApplicationJobQueueConfiguration(options?: Applic
 export declare class ApplicationJobQueuePermit implements ApplicationJobPermitPort {
     private readonly owner;
     readonly origin: ApplicationJobOrigin;
+    private readonly reusable;
+    detachedForHandlerTurn: boolean;
     private state;
-    constructor(owner: ApplicationJobQueue, origin: ApplicationJobOrigin);
+    constructor(owner: ApplicationJobQueue, origin: ApplicationJobOrigin, reusable?: boolean);
+    reserveStorage(): boolean;
+    releaseStorage(): void;
+    detachForHandlerTurn(): void;
     markApplicationQueued(): void;
     releaseBeforeHandler(): void;
     releaseAfterInternalProcessing(): void;
-    private release;
+    takeReleaseState(): 'reserved' | 'queued' | undefined;
 }
 /**
  * Host-instance owner of the ordinary-ingress queue permit lifecycle.
@@ -59,9 +64,10 @@ export declare class ApplicationJobQueue implements ApplicationJobQueuePort {
     private readonly loggerFailureReporter?;
     private localWaiters;
     private localBacklogLogged;
-    private reservedSupplyPermits;
-    private queuedApplicationJobs;
-    private peakPermitsInUse;
+    private readonly permitCounts;
+    private readonly limitCount;
+    private readonly pauseCount;
+    private readonly resumeCount;
     private capacityWaitCount;
     private capacityWaitDurationSeconds;
     private metricsEpoch;
@@ -79,6 +85,9 @@ export declare class ApplicationJobQueue implements ApplicationJobQueuePort {
     private readonly receiveFlowController;
     constructor(configuration: ApplicationJobQueueConfiguration, nowMs?: () => number, handlerStartGate?: (() => boolean) | undefined, loggerFailureReporter?: ((error: unknown) => void) | undefined);
     shouldHoldPermitBeforeHandler(): boolean;
+    createReceiveRotation(capacity: number, origin: ApplicationJobOrigin): ApplicationJobReceiveRotationPort;
+    receiveRotationCapacity(capacity: number): number;
+    reserveReceiveRotation(count: number): void;
     registerReceiveFlowTarget(identity: object, applyState: (state: ApplicationJobQueuePressureState) => void, failureSink?: (error: unknown) => void): boolean;
     unregisterReceiveFlowTarget(identity: object): void;
     acquire(signal: AbortSignal | undefined, origin: ApplicationJobOrigin): Promise<ApplicationJobQueuePermit>;
@@ -90,9 +99,12 @@ export declare class ApplicationJobQueue implements ApplicationJobQueuePort {
     onPressureStateChange(listener: (state: ApplicationJobQueuePressureState, sequence: bigint) => void): () => void;
     recordFlowStateConfigFailure(): void;
     markQueued(): void;
-    release(state: 'reserved' | 'queued'): void;
+    releasePermit(permit: ApplicationJobQueuePermit): void;
+    releaseUnusedReceiveRotation(grants: readonly (ApplicationJobQueuePermit | undefined)[], consumed: number, granted: number): void;
+    release(state: 'reserved' | 'queued', count?: number): void;
     private limit;
     private permitsInUse;
+    private reserveSupply;
     private reserve;
     private drainWaiters;
     private cancel;

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

@@ -53,10 +53,31 @@ function resolveApplicationJobQueueConfiguration(options = {}, effectiveProcesso
 class ApplicationJobQueuePermit {
     owner;
     origin;
-    state = 'reserved';
-    constructor(owner, origin) {
+    reusable;
+    detachedForHandlerTurn = false;
+    state;
+    constructor(owner, origin, reusable = false) {
         this.owner = owner;
         this.origin = origin;
+        this.reusable = reusable;
+        this.state = reusable ? 'idle' : 'reserved';
+    }
+    reserveStorage() {
+        if (this.state !== 'idle')
+            return false;
+        this.state = 'reserved';
+        this.detachedForHandlerTurn = false;
+        return true;
+    }
+    releaseStorage() {
+        if (!this.reusable || this.state === 'idle')
+            return;
+        if (this.state !== 'released')
+            throw new Error('Reservation storage still owns queue capacity.');
+        this.state = 'idle';
+    }
+    detachForHandlerTurn() {
+        this.detachedForHandlerTurn = true;
     }
     markApplicationQueued() {
         if (this.state !== 'reserved') {
@@ -68,19 +89,75 @@ class ApplicationJobQueuePermit {
     releaseBeforeHandler() {
         if (this.owner.shouldHoldPermitBeforeHandler())
             return;
-        this.release();
+        this.owner.releasePermit(this);
     }
     releaseAfterInternalProcessing() {
-        this.release();
+        this.owner.releasePermit(this);
     }
-    release() {
-        if (this.state === 'released')
-            return;
-        this.owner.release(this.state);
+    takeReleaseState() {
+        if (this.state === 'released' || this.state === 'idle')
+            return undefined;
+        const state = this.state;
         this.state = 'released';
+        return state;
     }
 }
 exports.ApplicationJobQueuePermit = ApplicationJobQueuePermit;
+/** Connection-owned storage; queue accounting remains with the host queue. */
+class ApplicationJobReceiveRotation {
+    owner;
+    capacity;
+    origin;
+    storage = [];
+    grants;
+    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.owner.reserveReceiveRotation(count);
+    }
+    take() {
+        if (this.consumed === this.granted)
+            return undefined;
+        return this.grants[this.consumed++];
+    }
+    releaseUnused() {
+        this.owner.releaseUnusedReceiveRotation(this.grants, this.consumed, this.granted);
+        // Keep the prepared grant slots and reset only the logical count.
+        this.granted = 0;
+        this.consumed = 0;
+    }
+}
 /**
  * Host-instance owner of the ordinary-ingress queue permit lifecycle.
  * It reserves capacity before receive/claim and transfers released capacity
@@ -93,9 +170,11 @@ class ApplicationJobQueue {
     loggerFailureReporter;
     localWaiters = 0;
     localBacklogLogged = false;
-    reservedSupplyPermits = 0n;
-    queuedApplicationJobs = 0n;
-    peakPermitsInUse = 0n;
+    // The contract bounds capacity by INT32_MAX; public snapshots remain bigint.
+    permitCounts = new Uint32Array(3 /* QueuePermitCount.Size */);
+    limitCount;
+    pauseCount;
+    resumeCount;
     capacityWaitCount = 0n;
     capacityWaitDurationSeconds = 0;
     metricsEpoch = 0n;
@@ -116,11 +195,27 @@ class ApplicationJobQueue {
         this.nowMs = nowMs;
         this.handlerStartGate = handlerStartGate;
         this.loggerFailureReporter = loggerFailureReporter;
+        this.limitCount = Number(configuration.effectiveMaxQueuedApplicationJobs);
+        this.pauseCount = Number(configuration.pausePermitCount);
+        this.resumeCount = Number(configuration.resumePermitCount);
         this.receiveFlowController = new receive_flow_controller_1.ApplicationJobReceiveFlowController(this, (state) => state);
     }
     shouldHoldPermitBeforeHandler() {
         return this.handlerStartGate?.() === true;
     }
+    createReceiveRotation(capacity, origin) {
+        if (!Number.isSafeInteger(capacity) || capacity < 1)
+            throw new RangeError('Receive capacity must be positive.');
+        return new ApplicationJobReceiveRotation(this, capacity, origin);
+    }
+    receiveRotationCapacity(capacity) {
+        if (this.waiters.length !== 0)
+            return 0;
+        return Math.min(capacity, this.limitCount - this.permitsInUse());
+    }
+    reserveReceiveRotation(count) {
+        this.reserveSupply(count);
+    }
     registerReceiveFlowTarget(identity, applyState, failureSink) {
         this.unregisterReceiveFlowTarget(identity);
         const target = {
@@ -173,7 +268,7 @@ class ApplicationJobQueue {
             reject(abortReason(signal));
             return undefined;
         }
-        if (this.waiters.length === 0 && this.permitsInUse() < this.limit()) {
+        if (this.waiters.length === 0 && this.permitsInUse() < this.limitCount) {
             return this.reserve(origin);
         }
         new Promise((resolve, reject) => {
@@ -204,10 +299,10 @@ class ApplicationJobQueue {
         const now = this.nowMs();
         return Object.freeze({
             ...this.configuration,
-            reservedSupplyPermits: this.reservedSupplyPermits,
-            queuedApplicationJobs: this.queuedApplicationJobs,
-            permitsInUse,
-            peakPermitsInUse: this.peakPermitsInUse,
+            reservedSupplyPermits: BigInt(this.permitCounts[0 /* QueuePermitCount.Reserved */]),
+            queuedApplicationJobs: BigInt(this.permitCounts[1 /* QueuePermitCount.Queued */]),
+            permitsInUse: BigInt(permitsInUse),
+            peakPermitsInUse: BigInt(this.permitCounts[2 /* QueuePermitCount.Peak */]),
             capacityWaiters: BigInt(this.waiters.length),
             capacityWaitCount: this.capacityWaitCount,
             capacityWaitDurationSeconds: this.capacityWaitDurationSeconds,
@@ -221,7 +316,7 @@ class ApplicationJobQueue {
     }
     resetMetrics() {
         this.metricsEpoch += 1n;
-        this.peakPermitsInUse = this.permitsInUse();
+        this.permitCounts[2 /* QueuePermitCount.Peak */] = this.permitsInUse();
         this.capacityWaitCount = 0n;
         this.capacityWaitDurationSeconds = 0;
         this.runningTransitionCount = 0n;
@@ -248,25 +343,37 @@ class ApplicationJobQueue {
         this.flowStateConfigFailureCount += 1n;
     }
     markQueued() {
-        if (this.reservedSupplyPermits === 0n) {
+        if (this.permitCounts[0 /* QueuePermitCount.Reserved */] === 0) {
             throw new Error('Application job queue has no reserved supply permit.');
         }
-        this.reservedSupplyPermits -= 1n;
-        this.queuedApplicationJobs += 1n;
-    }
-    release(state) {
-        if (state === 'reserved') {
-            if (this.reservedSupplyPermits === 0n) {
-                throw new Error('Application job queue reserved permit accounting underflow.');
-            }
-            this.reservedSupplyPermits -= 1n;
+        this.permitCounts[0 /* QueuePermitCount.Reserved */] =
+            this.permitCounts[0 /* QueuePermitCount.Reserved */] - 1;
+        this.permitCounts[1 /* QueuePermitCount.Queued */] = this.permitCounts[1 /* QueuePermitCount.Queued */] + 1;
+    }
+    releasePermit(permit) {
+        const state = permit.takeReleaseState();
+        if (state !== undefined)
+            this.release(state);
+    }
+    releaseUnusedReceiveRotation(grants, consumed, granted) {
+        const count = granted - consumed;
+        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();
         }
-        else {
-            if (this.queuedApplicationJobs === 0n) {
-                throw new Error('Application job queue queued permit accounting underflow.');
-            }
-            this.queuedApplicationJobs -= 1n;
+        this.release('reserved', count);
+    }
+    release(state, count = 1) {
+        const index = state === 'reserved' ? 0 /* QueuePermitCount.Reserved */ : 1 /* QueuePermitCount.Queued */;
+        const available = this.permitCounts[index];
+        if (available < count) {
+            throw new Error(`Application job queue ${state} permit accounting underflow.`);
         }
+        this.permitCounts[index] = available - count;
         this.drainWaiters();
         this.evaluatePressure();
     }
@@ -274,19 +381,21 @@ class ApplicationJobQueue {
         return this.configuration.effectiveMaxQueuedApplicationJobs;
     }
     permitsInUse() {
-        return this.reservedSupplyPermits + this.queuedApplicationJobs;
+        return (this.permitCounts[0 /* QueuePermitCount.Reserved */] + this.permitCounts[1 /* QueuePermitCount.Queued */]);
     }
-    reserve(origin, evaluatePressure = true) {
-        this.reservedSupplyPermits += 1n;
-        const current = this.permitsInUse();
-        if (current > this.peakPermitsInUse)
-            this.peakPermitsInUse = current;
+    reserveSupply(count, evaluatePressure = true) {
+        this.permitCounts[0 /* QueuePermitCount.Reserved */] =
+            this.permitCounts[0 /* QueuePermitCount.Reserved */] + count;
+        this.permitCounts[2 /* QueuePermitCount.Peak */] = Math.max(this.permitCounts[2 /* QueuePermitCount.Peak */], this.permitsInUse());
         if (evaluatePressure)
             this.evaluatePressure();
+    }
+    reserve(origin, evaluatePressure = true) {
+        this.reserveSupply(1, evaluatePressure);
         return new ApplicationJobQueuePermit(this, origin);
     }
     drainWaiters() {
-        while (this.waiters.length > 0 && this.permitsInUse() < this.limit()) {
+        while (this.waiters.length > 0 && this.permitsInUse() < this.limitCount) {
             const waiter = this.waiters.shift();
             if (!waiter.active)
                 continue;
@@ -348,12 +457,11 @@ class ApplicationJobQueue {
         }
     }
     evaluatePressure() {
-        const permitsInUse = this.permitsInUse();
         const next = this.pressureStateValue === 'running'
-            ? permitsInUse >= this.configuration.pausePermitCount
+            ? this.permitsInUse() >= this.pauseCount
                 ? 'paused'
                 : 'running'
-            : permitsInUse <= this.configuration.resumePermitCount
+            : this.permitsInUse() <= this.resumeCount
                 ? 'running'
                 : 'paused';
         if (next === this.pressureStateValue)

package/dist/runtime/host/entry-actor-runtime.d.ts

@@ -20,6 +20,7 @@ export declare class ZLinkEntryActorRuntimeService implements ZLinkEntryActorRun
     private readonly binder;
     constructor(options: ZLinkEntryActorRuntimeOptions);
     resolveActor(actorId: string): ZLinkActor | undefined;
+    releaseMembers(meshName: string): Promise<void>;
     commitActorTransaction(actor: ZLinkActor, onJoined: () => Promise<void>): Promise<void>;
     destroyActor(node: ZLinkBackendSpotNode, entryNodeRid: ActorRef['nodeRid'], actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     routePacket(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef): Promise<{