@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/host/actor-packet-relay.ts

@@ -1,3 +1,5 @@
+import type { ZLinkActorSessionAuthorityFence } from '../streams/actor-session-binding-registry';
+import { mapZLinkRequestReply } from '../messaging/request-result';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException,
@@ -41,7 +43,7 @@ import { streamMetadataMap } from '../actors/bound-session-wire';
 import { decodeRoutingId, normalizeRoutingId, routingIdsEqual } from '../routing-id';
 import { encodeSessionDisconnected } from '../actors/session-disconnected-wire';
 import { ZLinkSubmitStatus } from '../messaging/submission-result';
-import type { DefaultZLinkSpotManager, ZLinkSpotNodeRuntimeManager } from '../spots';
+import type { ZLinkSpotNodeRuntimeManager } from '../spots';
 import type { ZLinkDetachedTaskRunner } from '../spots/spot-actor-join-dispatch';
 import type { ZLinkBoundSessionResponseTarget } from '../streams';
 import type {
@@ -70,7 +72,6 @@ export interface ZLinkActorPacketRelayOptions {
   readonly streamBindingRuntime: () => ZLinkBoundSessionResponsePort & ZLinkStreamActorLookupPort;
   readonly meshRouters: MeshRouterResolver;
   readonly actorManager: () => DefaultZLinkActorManager | undefined;
-  readonly spotManager: () => DefaultZLinkSpotManager | undefined;
   readonly spotNodeRuntime: () => ZLinkSpotNodeRuntimeManager | undefined;
   readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
   readonly errorSink: () => { reportRuntimeTaskException(taskName: string, error: unknown): void };
@@ -112,7 +113,8 @@ export class ZLinkActorPacketRelay {
   async notifyBoundActorDisconnected(
     actor: ZLinkSessionActor,
     signal?: AbortSignal,
-    binding?: ServiceStreamSessionBinding
+    binding?: ServiceStreamSessionBinding,
+    authorityFence?: ZLinkActorSessionAuthorityFence
   ): Promise<void> {
     // The Session binding owns this route, including after relocation and detach (§5, §7).
     const actorRefTarget = this.targets.targetForActorRef(actor.ref);
@@ -122,11 +124,18 @@ export class ZLinkActorPacketRelay {
         actorRefTarget,
         signal,
         actor.ref,
-        binding
+        binding,
+        authorityFence
       );
       return;
     }
-    await this.notifyLocalActorDisconnectedById(actor.actorId, signal, binding, actor.ref);
+    await this.notifyLocalActorDisconnectedById(
+      actor.actorId,
+      signal,
+      binding,
+      actor.ref,
+      authorityFence
+    );
   }
 
   clearRemoteActorPacketTarget(actorId: string): void {
@@ -145,33 +154,32 @@ export class ZLinkActorPacketRelay {
     actorId: string,
     signal?: AbortSignal,
     binding?: ServiceStreamSessionBinding,
-    bindingActorRef?: ActorRef
+    bindingActorRef?: ActorRef,
+    authorityFence?: ZLinkActorSessionAuthorityFence
   ): Promise<void> {
     throwIfAborted(signal);
-    const state = this.options.actorManager()?.getState(actorId);
     const frame = this.disconnectedFrame(actorId, binding);
     const header = RuntimeMessage.fromOwned(Buffer.from(frame.header));
     const body = RuntimeMessage.fromOwned(frame.payload);
     try {
-      if (state?.spotId === undefined)
-        await this.requireSpotNodeRuntime().dispatchEntryActorPacket(
-          'local',
-          actorId,
-          [header, body],
-          false,
-          undefined,
-          bindingActorRef
-        );
-      else
-        await this.requireSpotManager().dispatchRoutedActorPacket(
-          'local',
-          state.spotId,
-          actorId,
-          [header, body],
-          false,
-          undefined,
-          bindingActorRef
-        );
+      const context = sessionActorFollowContext(
+        bindingActorRef,
+        authorityFence,
+        [header, body],
+        false
+      );
+      const ref =
+        context === undefined || bindingActorRef === undefined
+          ? bindingActorRef
+          : attachActorMessageFollowContext(bindingActorRef, context);
+      await this.requireSpotNodeRuntime().dispatchEntryActorPacket(
+        'local',
+        actorId,
+        [header, body],
+        false,
+        undefined,
+        ref
+      );
     } finally {
       header.close();
       body.close();
@@ -275,30 +283,18 @@ export class ZLinkActorPacketRelay {
       ) {
         this.requireCurrentRemoteBinding(relay, _routeContext);
       }
-      const state = this.options.actorManager()?.getState(relay.actorId);
       if (
         frameHeader.kind === ZLinkStreamMessageKind.Send ||
         frameHeader.name === ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET
       ) {
-        const dispatch =
-          state?.spotId === undefined
-            ? this.requireSpotNodeRuntime().dispatchEntryActorPacket(
-                'remote',
-                relay.actorId,
-                [header, body],
-                false,
-                remoteBoundSessionTarget,
-                fallbackActorRef
-              )
-            : this.requireSpotManager().dispatchRoutedActorPacket(
-                'remote',
-                state.spotId,
-                relay.actorId,
-                [header, body],
-                false,
-                remoteBoundSessionTarget,
-                fallbackActorRef
-              );
+        const dispatch = this.requireSpotNodeRuntime().dispatchEntryActorPacket(
+          'remote',
+          relay.actorId,
+          [header, body],
+          false,
+          remoteBoundSessionTarget,
+          fallbackActorRef
+        );
         if (frameHeader.name === ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
           await dispatch;
           return {
@@ -344,25 +340,14 @@ export class ZLinkActorPacketRelay {
         frameHeader.requestSeq !== undefined &&
         relay.returnResponse !== true
       ) {
-        const dispatch =
-          state?.spotId === undefined
-            ? this.requireSpotNodeRuntime().dispatchEntryActorPacket(
-                'remote',
-                relay.actorId,
-                [header, body],
-                false,
-                remoteBoundSessionTarget,
-                fallbackActorRef
-              )
-            : this.requireSpotManager().dispatchRoutedActorPacket(
-                'remote',
-                state.spotId,
-                relay.actorId,
-                [header, body],
-                false,
-                remoteBoundSessionTarget,
-                fallbackActorRef
-              );
+        const dispatch = this.requireSpotNodeRuntime().dispatchEntryActorPacket(
+          'remote',
+          relay.actorId,
+          [header, body],
+          false,
+          remoteBoundSessionTarget,
+          fallbackActorRef
+        );
         closeFrameMessages = false;
         const deferredPacketName = frameHeader.name;
         const deferredRequestSeq = frameHeader.requestSeq;
@@ -413,25 +398,14 @@ export class ZLinkActorPacketRelay {
           )
         };
       }
-      const response =
-        state?.spotId === undefined
-          ? await this.requireSpotNodeRuntime().dispatchEntryActorPacket(
-              'remote',
-              relay.actorId,
-              [header, body],
-              relay.returnResponse === true,
-              remoteBoundSessionTarget,
-              fallbackActorRef
-            )
-          : await this.requireSpotManager().dispatchRoutedActorPacket(
-              'remote',
-              state.spotId,
-              relay.actorId,
-              [header, body],
-              relay.returnResponse === true,
-              remoteBoundSessionTarget,
-              fallbackActorRef
-            );
+      const response = await this.requireSpotNodeRuntime().dispatchEntryActorPacket(
+        'remote',
+        relay.actorId,
+        [header, body],
+        relay.returnResponse === true,
+        remoteBoundSessionTarget,
+        fallbackActorRef
+      );
       return {
         ok: true,
         response,
@@ -611,28 +585,15 @@ export class ZLinkActorPacketRelay {
     );
     let request: Record<string, unknown>;
     try {
-      const authority = aggregateRoute?.authorityFence;
-      const messageFollowContext =
-        authority?.ownerId === undefined || authority.ownerNodeGeneration === undefined
-          ? undefined
-          : createInitialActorMessageFollowContext(
-              {
-                meshName: storedActorRef.meshName,
-                actorRef: storedActorRef,
-                actorType: authority.actorType ?? '',
-                ownerNodeGeneration: authority.ownerNodeGeneration,
-                ownerId: authority.ownerId,
-                ownerLeaseGeneration: authority.ownerLeaseGeneration,
-                authorityOwnerGeneration: authority.authorityOwnerGeneration,
-                authorityStoreVersion: authority.authorityStoreVersion ?? ''
-              },
-              [header, payload],
-              returnResponse,
-              undefined,
-              isValidMessageFollowId(frameHeader.correlationId)
-                ? frameHeader.correlationId
-                : createMessageFollowId()
-            );
+      const messageFollowContext = sessionActorFollowContext(
+        storedActorRef,
+        aggregateRoute?.authorityFence,
+        [header, payload],
+        returnResponse,
+        isValidMessageFollowId(frameHeader.correlationId)
+          ? frameHeader.correlationId
+          : createMessageFollowId()
+      );
       request = encodeRemoteActorPacketRelayPayload({
         actorId: actor.actorId,
         routerChannelId: remoteTarget.routerChannelId,
@@ -751,7 +712,8 @@ export class ZLinkActorPacketRelay {
     remoteTarget: ZLinkRemoteBoundSessionTarget | ZLinkRemoteActorPacketTarget,
     signal?: AbortSignal,
     bindingActorRef?: ActorRef,
-    binding?: ServiceStreamSessionBinding
+    binding?: ServiceStreamSessionBinding,
+    authorityFence?: ZLinkActorSessionAuthorityFence
   ): Promise<void> {
     const spotKind: ZLinkSpotKind | undefined =
       'spotKind' in remoteTarget ? (remoteTarget.spotKind as ZLinkSpotKind | undefined) : undefined;
@@ -760,36 +722,55 @@ export class ZLinkActorPacketRelay {
       binding,
       'sessionNodeRid' in remoteTarget ? remoteTarget : undefined
     );
-    const payload = encodeRemoteActorPacketRelayPayload({
-      actorId,
-      routerChannelId: remoteTarget.routerChannelId,
-      bindingActorRef,
-      ...frame
-    });
+    const parts = [
+      RuntimeMessage.fromOwned(Buffer.from(frame.header)),
+      RuntimeMessage.fromOwned(frame.payload)
+    ];
+    let payload: Record<string, unknown>;
+    try {
+      payload = encodeRemoteActorPacketRelayPayload({
+        actorId,
+        routerChannelId: remoteTarget.routerChannelId,
+        bindingActorRef,
+        messageFollowContext: sessionActorFollowContext(
+          bindingActorRef,
+          authorityFence,
+          parts,
+          false
+        ),
+        ...frame
+      });
+    } finally {
+      for (const part of parts) part.close();
+    }
     if ((spotKind ?? ZLinkSpotKind.Entry) === ZLinkSpotKind.Entry) {
-      await this.options.routeTransport.request(
-        remoteTarget.routerChannelId,
-        String(remoteTarget.targetNodeRid),
-        ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        payload,
-        this.options.requestTimeoutMs,
-        signal
+      await mapZLinkRequestReply(
+        this.options.routeTransport.request(
+          remoteTarget.routerChannelId,
+          String(remoteTarget.targetNodeRid),
+          ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
+          payload,
+          this.options.requestTimeoutMs,
+          signal
+        )
       );
       return;
     }
-    await this.options.routeTransport.requestToSpot(
-      {
-        routerChannelId: remoteTarget.routerChannelId,
-        targetNodeRid: remoteTarget.targetNodeRid,
-        spotId: remoteTarget.spotId,
-        spotKind: spotKind ?? ZLinkSpotKind.Entry
-      },
-      payload,
-      {
-        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        timeoutMs: this.options.requestTimeoutMs,
-        signal
-      }
+    await mapZLinkRequestReply(
+      this.options.routeTransport.requestToSpot(
+        {
+          routerChannelId: remoteTarget.routerChannelId,
+          targetNodeRid: remoteTarget.targetNodeRid,
+          spotId: remoteTarget.spotId,
+          spotKind: spotKind ?? ZLinkSpotKind.Entry
+        },
+        payload,
+        {
+          packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
+          timeoutMs: this.options.requestTimeoutMs,
+          signal
+        }
+      )
     );
   }
 
@@ -856,13 +837,15 @@ export class ZLinkActorPacketRelay {
   ): Promise<TReply> {
     if (target.spotKind === ZLinkSpotKind.Entry) {
       try {
-        return await this.options.routeTransport.request<TReply>(
-          target.routerChannelId,
-          String(target.targetNodeRid),
-          ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-          request,
-          this.options.requestTimeoutMs,
-          signal
+        return await mapZLinkRequestReply(
+          this.options.routeTransport.request<TReply>(
+            target.routerChannelId,
+            String(target.targetNodeRid),
+            ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
+            request,
+            this.options.requestTimeoutMs,
+            signal
+          )
         );
       } catch (error) {
         if (!(error instanceof ZLinkConfigurationException)) {
@@ -886,13 +869,10 @@ export class ZLinkActorPacketRelay {
     payload: Message
   ): Promise<boolean> {
     const state = this.options.actorManager()?.getState(actor.actorId);
-    const spotId = state?.spotId as RoutingId | undefined;
-    const hasActiveSpot =
-      spotId !== undefined && this.options.spotManager()?.hasActiveSpot(spotId) === true;
-    if (!hasActiveSpot) {
+    if (state === undefined) {
       return false;
     }
-    const actorRef = state?.nativeActorRef as ActorRef | undefined;
+    const actorRef = state.nativeActorRef as ActorRef | undefined;
     const localNode = this.options.spotNodeRuntime()?.primaryMeshNode;
     const localNodeRid = localNode === undefined ? undefined : String(localNode.status().routingId);
     if (
@@ -916,12 +896,13 @@ export class ZLinkActorPacketRelay {
     try {
       this.options.detachedTaskRunner.runDetached('local actor packet relay', async () => {
         try {
-          const response = await this.requireSpotManager().dispatchRoutedActorPacket(
+          const response = await this.requireSpotNodeRuntime().dispatchEntryActorPacket(
             'local',
-            spotId,
             actor.actorId,
             [header, body],
-            returnResponse
+            returnResponse,
+            undefined,
+            actor.ref
           );
           if (!returnResponse) {
             return;
@@ -1004,14 +985,6 @@ export class ZLinkActorPacketRelay {
     }
     return runtime;
   }
-
-  private requireSpotManager(): DefaultZLinkSpotManager {
-    const manager = this.options.spotManager();
-    if (manager === undefined) {
-      throw new Error('SPOT manager runtime is not started.');
-    }
-    return manager;
-  }
 }
 
 function isValidMessageFollowId(value: string | undefined): value is string {
@@ -1026,3 +999,34 @@ function withDefaultSpotKind(
     ? { ...target, spotKind: ZLinkSpotKind.Entry }
     : (target as ZLinkRemoteActorPacketTarget & { readonly spotKind: ZLinkSpotKind });
 }
+
+function sessionActorFollowContext(
+  actorRef: ActorRef | undefined,
+  authority: ZLinkActorSessionAuthorityFence | undefined,
+  parts: readonly Message[],
+  request: boolean,
+  operationId?: string
+) {
+  if (
+    actorRef === undefined ||
+    authority?.ownerId === undefined ||
+    authority.ownerNodeGeneration === undefined
+  )
+    return undefined;
+  return createInitialActorMessageFollowContext(
+    {
+      meshName: actorRef.meshName,
+      actorRef,
+      actorType: authority.actorType ?? '',
+      ownerNodeGeneration: authority.ownerNodeGeneration,
+      ownerId: authority.ownerId,
+      ownerLeaseGeneration: authority.ownerLeaseGeneration,
+      authorityOwnerGeneration: authority.authorityOwnerGeneration,
+      authorityStoreVersion: authority.authorityStoreVersion ?? ''
+    },
+    parts,
+    request,
+    undefined,
+    operationId
+  );
+}

package/src/runtime/host/actor-placement-coordinator.ts

@@ -82,7 +82,7 @@ export interface ZLinkActorPlacementCoordinatorOptions {
 }
 
 export class ZLinkActorPlacementCoordinator {
-  constructor(private readonly options: ZLinkActorPlacementCoordinatorOptions) {}
+  constructor(readonly options: ZLinkActorPlacementCoordinatorOptions) {}
 
   async create(
     actorId: string,

package/src/runtime/host/actor-runtime-options-factory.ts

@@ -1,3 +1,4 @@
+import type { RequestRuntime } from '../foundation/request-runtime';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkMessage } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { Type } from '../../contracts/Common/CoreTypes';
@@ -34,6 +35,7 @@ import type { ZLinkRemoteActorPacketTarget } from '../actors';
 import type { ZLinkActorJoinRelocation } from '../actors/actor-join-relocation';
 
 export interface ZLinkActorRuntimeOptionsFactoryOptions {
+  readonly requests?: RequestRuntime;
   readonly terminateActorActivation: (
     actor: ZLinkActor,
     terminal: () => Promise<void>
@@ -261,6 +263,7 @@ export class ZLinkActorRuntimeOptionsFactory {
   createActorClientOptions(): ConstructorParameters<typeof DefaultZLinkActorClient>[0] {
     const locationResolver = this.options.createActorLocationResolver();
     return {
+      requests: this.options.requests,
       nodeProvider: this.options.meshNode,
       completionTableProvider: this.options.meshCompletions,
       locationResolver: () => locationResolver,
@@ -283,7 +286,8 @@ export class ZLinkActorRuntimeOptionsFactory {
         returnResponse,
         actor,
         deadlineUnixMs,
-        onAdmitted
+        onAdmitted,
+        requestOperation
       ) =>
         this.actorBelongsToMesh(meshName, actorId) &&
         !this.options.actorHandoff.isProvisional(actorId)
@@ -297,7 +301,8 @@ export class ZLinkActorRuntimeOptionsFactory {
               deadlineUnixMs,
               undefined,
               undefined,
-              onAdmitted
+              onAdmitted,
+              requestOperation
             )
           : undefined,
       sendErrorReporter: this.options.reportPostCommitError

package/src/runtime/host/actor-transfer-runtime.ts

@@ -703,7 +703,7 @@ export class ZLinkActorTransferRuntime {
     );
   }
 
-  private async sealBoundSessionRoute(
+  async sealBoundSessionRoute(
     actor: ZLinkActor,
     state: ZLinkActorRuntimeState,
     signal?: AbortSignal,
@@ -814,7 +814,7 @@ export class ZLinkActorTransferRuntime {
     };
   }
 
-  private async abortBoundSessionRouteSeal(
+  async abortBoundSessionRouteSeal(
     actor: ZLinkActor,
     state: ZLinkActorRuntimeState,
     target: ZLinkRemoteBoundSessionTarget
@@ -1336,7 +1336,7 @@ export class ZLinkActorTransferRuntime {
     return actorManager;
   }
 
-  private async publishBoundSessionOwnership(
+  async publishBoundSessionOwnership(
     actorId: string,
     actorRef: ZLinkBackendActorRef,
     ownershipGeneration: bigint,

package/src/runtime/host/application-job-queue.ts

@@ -1,5 +1,5 @@
-import { SeverityNumber } from '@opentelemetry/api-logs';
-import { telemetryLogger } from '../diagnostics/message-flow';
+import { logs, SeverityNumber } from '@opentelemetry/api-logs';
+import { TELEMETRY_INSTRUMENTATION_NAME } from '../diagnostics/message-flow-record';
 import { MILLISECONDS_PER_SECOND } from '../diagnostics/runtime-metrics';
 import { ZLinkApplicationJobQueueProfile } from '../../contracts/Dispatch';
 import {
@@ -23,6 +23,8 @@ import {
   type ApplicationJobReceiveFlowTarget
 } from '../application-jobs/receive-flow-controller';
 
+const telemetryLogger = logs.getLogger(TELEMETRY_INSTRUMENTATION_NAME);
+
 export type ApplicationJobQueueProfileValue = 'compact' | 'low_latency' | 'balanced' | 'throughput';
 
 export interface ApplicationJobQueueOptions {
@@ -182,6 +184,10 @@ export class ApplicationJobQueuePermit implements ApplicationJobPermitPort {
     this.owner.releasePermit(this);
   }
 
+  releaseUnqueued(): void {
+    if (this.state === 'reserved') this.owner.releasePermit(this);
+  }
+
   takeReleaseState(): 'reserved' | 'queued' | undefined {
     if (this.state === 'released' || this.state === 'idle') return undefined;
     const state = this.state;
@@ -209,10 +215,21 @@ class ApplicationJobReceiveRotation implements ApplicationJobReceiveRotationPort
 
   reserve(): void {
     this.releaseUnused();
-    const count = this.owner.receiveRotationCapacity(this.capacity);
-    if (count === 0) return;
-    this.granted = count;
-    this.owner.reserveReceiveRotation(count);
+    this.granted = this.owner.tryReserveCount(this.capacity) ?? 0;
+  }
+
+  async acquire(signal: AbortSignal): Promise<void> {
+    this.releaseUnused();
+    this.granted = await new Promise<number>((resolve, reject) => {
+      const count = this.owner.acquireCountOrResume(
+        resolve,
+        reject,
+        signal,
+        this.origin,
+        this.capacity
+      );
+      if (count !== undefined) resolve(count);
+    });
   }
 
   take(): ApplicationJobQueuePermit | undefined {
@@ -237,7 +254,8 @@ class ApplicationJobReceiveRotation implements ApplicationJobReceiveRotationPort
 
 interface CapacityWaiter {
   readonly origin: ApplicationJobOrigin;
-  readonly resolve: (permit: ApplicationJobQueuePermit) => void;
+  readonly requested: number;
+  readonly resolve: (count: number) => void;
   readonly reject: (reason: unknown) => void;
   readonly signal?: AbortSignal;
   readonly abort: () => void;
@@ -299,19 +317,15 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
   createReceiveRotation(
     capacity: number,
     origin: ApplicationJobOrigin
-  ): ApplicationJobReceiveRotationPort {
+  ): ApplicationJobReceiveRotation {
     if (!Number.isSafeInteger(capacity) || capacity < 1)
       throw new RangeError('Receive capacity must be positive.');
     return new ApplicationJobReceiveRotation(this, capacity, origin);
   }
 
-  receiveRotationCapacity(capacity: number): number {
-    if (this.waiters.length !== 0) return 0;
-    return Math.min(capacity, this.limitCount - this.permitsInUse());
-  }
-
-  reserveReceiveRotation(count: number): void {
-    this.reserveSupply(count);
+  tryReserveCount(requested: number): number | undefined {
+    if (this.waiters.length !== 0 || this.permitsInUse() === this.limitCount) return undefined;
+    return this.reserveCount(requested);
   }
 
   registerReceiveFlowTarget(
@@ -372,17 +386,34 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
     signal: AbortSignal | undefined,
     origin: ApplicationJobOrigin
   ): ApplicationJobQueuePermit | undefined {
+    const count = this.acquireCountOrResume(
+      () => resume(new ApplicationJobQueuePermit(this, origin)),
+      reject,
+      signal,
+      origin,
+      1
+    );
+    return count === undefined ? undefined : new ApplicationJobQueuePermit(this, origin);
+  }
+
+  acquireCountOrResume(
+    resume: (count: number) => void,
+    reject: (reason: unknown) => void,
+    signal: AbortSignal | undefined,
+    origin: ApplicationJobOrigin,
+    requested: number
+  ): number | undefined {
     if (signal?.aborted === true) {
       reject(abortReason(signal));
       return undefined;
     }
-    if (this.waiters.length === 0 && this.permitsInUse() < this.limitCount) {
-      return this.reserve(origin);
-    }
+    const count = this.tryReserveCount(requested);
+    if (count !== undefined) return count;
 
-    new Promise<ApplicationJobQueuePermit>((resolve, reject) => {
+    new Promise<number>((resolve, reject) => {
       const waiter: CapacityWaiter = {
         origin,
+        requested,
         resolve,
         reject,
         signal,
@@ -511,12 +542,10 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
     if (evaluatePressure) this.evaluatePressure();
   }
 
-  private reserve(
-    origin: ApplicationJobOrigin,
-    evaluatePressure = true
-  ): ApplicationJobQueuePermit {
-    this.reserveSupply(1, evaluatePressure);
-    return new ApplicationJobQueuePermit(this, origin);
+  private reserveCount(requested: number, evaluatePressure = true): number {
+    const count = Math.min(requested, this.limitCount - this.permitsInUse());
+    this.reserveSupply(count, evaluatePressure);
+    return count;
   }
 
   private drainWaiters(): void {
@@ -526,7 +555,7 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
       waiter.active = false;
       waiter.signal?.removeEventListener('abort', waiter.abort);
       this.recordCompletedWait(waiter);
-      waiter.resolve(this.reserve(waiter.origin, false));
+      waiter.resolve(this.reserveCount(waiter.requested, false));
     }
   }
 
@@ -579,7 +608,7 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
     }
   }
 
-  private evaluatePressure(): void {
+  evaluatePressure(): void {
     const next =
       this.pressureStateValue === 'running'
         ? this.permitsInUse() >= this.pauseCount