@zlink-systems/framework 0.31.0 → 0.32.0

package/src/runtime/foundation/service-stateful-registry.ts

@@ -62,6 +62,11 @@ export interface ServiceSessionBinding {
   readonly membershipEpoch: bigint;
 }
 
+interface ServiceSessionBindingEntry {
+  readonly binding: ServiceSessionBinding;
+  lastAcceptedSequence: bigint;
+}
+
 export interface ServiceObjectReservation {
   readonly id: bigint;
   readonly objectKind: 'actor' | 'userSpot' | 'instanceSpot';
@@ -112,7 +117,7 @@ export class ServiceStatefulRegistry {
   >();
   private readonly actors = new Map<string, ServiceActorState>();
   private readonly actorTypes = new Map<string, string>();
-  private readonly bindings = new Map<string, ServiceSessionBinding>();
+  private readonly bindings = new Map<string, ServiceSessionBindingEntry>();
   private readonly reservations = new Map<string, ServiceObjectReservation>();
   private readonly spotGenerations = new Map<string, bigint>();
   private readonly actorGenerations = new Map<string, bigint>();
@@ -408,7 +413,7 @@ export class ServiceStatefulRegistry {
     );
     requireText(binding.sessionOwnerNodeRid, 'sessionOwnerNodeRid');
     requirePositive(binding.bindingGeneration, 'bindingGeneration');
-    const current = this.bindings.get(actorKey(binding.actor));
+    const current = this.bindings.get(actorKey(binding.actor))?.binding;
     if (
       current !== undefined &&
       current.sessionOwnerNodeRid === binding.sessionOwnerNodeRid &&
@@ -423,7 +428,7 @@ export class ServiceStatefulRegistry {
       throw new ServiceStaleGenerationError('binding', binding.actor.actorId);
     }
     const accepted = Object.freeze({ ...binding });
-    this.bindings.set(actorKey(binding.actor), accepted);
+    this.bindings.set(actorKey(binding.actor), { binding: accepted, lastAcceptedSequence: 0n });
     return accepted;
   }
 
@@ -432,10 +437,29 @@ export class ServiceStatefulRegistry {
   }
 
   private bindingCore(actor: ServiceActorRef): ServiceSessionBinding | undefined {
-    const binding = this.bindings.get(actorKey(actor));
+    const binding = this.bindings.get(actorKey(actor))?.binding;
     return binding?.actor.generation === actor.generation ? binding : undefined;
   }
 
+  /** The Actor owner admits each relayed Session sequence once per binding. */
+  acceptBoundSessionSequence(
+    actor: ServiceActorRef,
+    expectedBindingGeneration: bigint,
+    sequence: bigint
+  ): boolean {
+    const entry = this.bindings.get(actorKey(actor));
+    if (
+      entry === undefined ||
+      entry.binding.actor.generation !== actor.generation ||
+      entry.binding.bindingGeneration !== expectedBindingGeneration ||
+      sequence <= entry.lastAcceptedSequence
+    ) {
+      return false;
+    }
+    entry.lastAcceptedSequence = sequence;
+    return true;
+  }
+
   unbindSession(
     actor: ServiceActorRef,
     expectedBindingGeneration: bigint,
@@ -443,8 +467,9 @@ export class ServiceStatefulRegistry {
     expectedSessionOwnerNodeRid?: string
   ): boolean {
     const key = actorKey(actor);
-    const binding = this.bindings.get(key);
-    if (binding === undefined) return false;
+    const entry = this.bindings.get(key);
+    if (entry === undefined) return false;
+    const binding = entry.binding;
     if (
       binding.bindingGeneration !== expectedBindingGeneration ||
       (expectedSessionRid !== undefined &&
@@ -577,16 +602,16 @@ export class ServiceStatefulRegistry {
 
   private updateBindingMembership(actor: ServiceActorState): void {
     const key = actorKey(actor.ref);
-    const binding = this.bindings.get(key);
-    if (binding === undefined) return;
-    this.bindings.set(
-      key,
-      Object.freeze({
-        ...binding,
+    const entry = this.bindings.get(key);
+    if (entry === undefined) return;
+    this.bindings.set(key, {
+      binding: Object.freeze({
+        ...entry.binding,
         actor: actor.ref,
         membershipEpoch: actor.membershipEpoch
-      })
-    );
+      }),
+      lastAcceptedSequence: entry.lastAcceptedSequence
+    });
   }
 }
 

package/src/runtime/foundation/service-stateful-runtime.ts

@@ -123,12 +123,14 @@ import {
   SERVICE_WIRE_MAJOR,
   SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE
 } from './service-wire-constants.generated';
+import { copyPayloadBytes } from '../../contracts/Common/payload-slab';
 import {
   ServiceWireProtocolError,
   decodeApplicationPayload,
   decodeApplicationPayloadView,
   decodeMultipartApplicationParts,
   encodeApplicationPayload,
+  encodeOwnedApplicationPayload,
   type ServiceApplicationPayload
 } from './service-wire-m6a-codec';
 
@@ -167,6 +169,7 @@ interface ServiceSpotMessageFollowState {
 export interface ServiceStatefulResult {
   readonly terminalResult: number;
   readonly failureCode: number;
+  readonly failureMessage?: string;
   readonly payload?: ServiceApplicationPayload;
   readonly kindData?: ReceiveKindData;
   readonly applicationMetadata?: Buffer;
@@ -476,7 +479,7 @@ export class ServiceStatefulRuntime {
 
   readonly registry: ServiceStatefulRegistry;
 
-  private readonly operations: ServiceTerminalOperationRegistry<ServiceStatefulResult, bigint>;
+  readonly operations: ServiceTerminalOperationRegistry<ServiceStatefulResult, bigint>;
   private readonly sessionDeliveries = new Map<string, ServiceSessionDelivery>();
   /**
    * A local Actor owner can replace its own session binding before the
@@ -520,7 +523,7 @@ export class ServiceStatefulRuntime {
   private dispatchErrors?: ZLinkDispatchErrorReporter;
   private sessionOwnerDescriptors?: ServiceSessionOwnerDescriptors;
   private dispatchErrorMeshName?: string;
-  private readonly admittedUserSpotOperations = new Map<
+  readonly admittedUserSpotOperations = new Map<
     string,
     {
       readonly request: string;
@@ -2437,7 +2440,7 @@ export class ServiceStatefulRuntime {
           ? record.parts.length >= 2
             ? record.parts[record.parts.length - 1]
             : undefined
-          : encodeApplicationPayload(canonicalPayload);
+          : encodeOwnedApplicationPayload(canonicalPayload);
       try {
         return await this.handleIngress(
           record,
@@ -2503,7 +2506,7 @@ export class ServiceStatefulRuntime {
     }
   }
 
-  private async handleIngress(
+  async handleIngress(
     ingress: RawServiceIngressRecord,
     record: ServiceStatefulWireRecord,
     payloadFrame: Buffer | undefined,
@@ -2596,6 +2599,62 @@ export class ServiceStatefulRuntime {
           ) {
             throw new ServiceStaleGenerationError('binding', record.target.actor.actorId);
           }
+          if (
+            !this.registry.acceptBoundSessionSequence(
+              record.target.actor,
+              record.boundSession.bindingGeneration,
+              record.boundSession.sequence
+            )
+          ) {
+            const error = new ZLinkFrameworkException(
+              ZLinkFrameworkErrorKind.InvalidOperation,
+              'Bound Session relay sequence does not increase.'
+            );
+            const reporter = this.dispatchErrors;
+            if (record.kind === 'actorRequest') {
+              if (reporter?.captureEnabled() === true) {
+                reporter.report({
+                  surface: ZLinkDispatchErrorSurface.StreamSession,
+                  messageKind: ZLinkDispatchMessageKind.Request,
+                  reason: ZLinkDispatchErrorReason.StaleTarget,
+                  action: ZLinkDispatchErrorAction.ReplyError,
+                  meshName: this.dispatchErrorMeshName,
+                  sourceRid: ingress.sourceRoutingId,
+                  actorId: record.target.actor.actorId,
+                  correlationId: record.correlation?.toString(),
+                  error
+                });
+              }
+              const result = failure(error);
+              this.replyWire(
+                ingress,
+                record.correlation!,
+                result.terminalResult,
+                result.failureCode
+              );
+              return 'infrastructure';
+            }
+            const tracePoint = flowIfEnabled(reporter?.flow, ZLinkMessageFlowOutcome.Dropped);
+            if (tracePoint !== undefined) {
+              tracePoint.trace({
+                outcome: ZLinkMessageFlowOutcome.Dropped,
+                surface: ZLinkDispatchErrorSurface.StreamSession,
+                messageKind: ZLinkDispatchMessageKind.Send,
+                packetName: decodeApplicationPayloadView(payloadFrame!).packetName,
+                ...(this.dispatchErrorMeshName === undefined
+                  ? {}
+                  : { meshName: this.dispatchErrorMeshName }),
+                ...(record.correlation === undefined
+                  ? {}
+                  : { correlationId: record.correlation.toString() }),
+                sourceRid: ingress.sourceRoutingId,
+                actorId: record.target.actor.actorId,
+                streamSessionId: record.boundSession.sessionRid,
+                errorReason: ZLinkDispatchErrorReason.StaleTarget
+              });
+            }
+            return 'application';
+          }
         }
         return this.enqueueApplicationFrame(
           ingress,
@@ -2755,7 +2814,7 @@ export class ServiceStatefulRuntime {
     return !lifecycle.isMaterialized(applicationTarget);
   }
 
-  private enqueueActivatedInstanceSpot(
+  enqueueActivatedInstanceSpot(
     ingress: RawServiceIngressRecord,
     record: Extract<ServiceStatefulWireRecord, { readonly kind: 'instanceSpot' }>,
     payloadFrame: Buffer,
@@ -2836,7 +2895,7 @@ export class ServiceStatefulRuntime {
     return result;
   }
 
-  private async continueMissingInstanceActivation(
+  async continueMissingInstanceActivation(
     ingress: RawServiceIngressRecord,
     record: Extract<
       ServiceStatefulWireRecord,
@@ -2935,7 +2994,7 @@ export class ServiceStatefulRuntime {
    * record only of a message whose handler turn started before it; a message queued
    * behind that Close is not counted, so it cannot hold the Close it follows.
    */
-  private activationTerminalCompletion(
+  activationTerminalCompletion(
     target: ServiceInstanceActivationTarget,
     route: ServiceInstanceRouteFence
   ): {
@@ -2982,7 +3041,7 @@ export class ServiceStatefulRuntime {
     return { onTerminalCompletion, onHandlerTurnStarted };
   }
 
-  private instanceApplicationTerminalCompletion(
+  instanceApplicationTerminalCompletion(
     target: ServiceInstanceApplicationTarget
   ): (() => Promise<void>) | undefined {
     const lifecycle = this.instanceApplicationLifecycle;
@@ -3052,7 +3111,7 @@ export class ServiceStatefulRuntime {
     for (const waiter of waiters) waiter();
   }
 
-  private finishMissingInstanceActivationFailure(
+  finishMissingInstanceActivationFailure(
     ingress: RawServiceIngressRecord,
     record: Extract<
       ServiceStatefulWireRecord,
@@ -3220,7 +3279,7 @@ export class ServiceStatefulRuntime {
     return { intent, route: current };
   }
 
-  private validateInstanceIngress(
+  validateInstanceIngress(
     ingress: RawServiceIngressRecord,
     record: Extract<ServiceStatefulWireRecord, { readonly kind: 'instanceSpot' }>
   ): void {
@@ -3322,7 +3381,7 @@ export class ServiceStatefulRuntime {
       : undefined;
   }
 
-  private activateMissingInstanceAsync(
+  activateMissingInstanceAsync(
     record: Extract<
       ServiceStatefulWireRecord,
       { readonly kind: 'instanceSpot'; readonly activation: 'missing' }
@@ -3393,7 +3452,7 @@ export class ServiceStatefulRuntime {
     return operation;
   }
 
-  private async runMissingInstanceActivation(
+  async runMissingInstanceActivation(
     record: Extract<
       ServiceStatefulWireRecord,
       { readonly kind: 'instanceSpot'; readonly activation: 'missing' }
@@ -3757,7 +3816,7 @@ export class ServiceStatefulRuntime {
             }
           })
     };
-    const applicationFrame = payloadFrame ?? encodeApplicationPayload(emptyPayload());
+    const applicationFrame = payloadFrame ?? encodeOwnedApplicationPayload(emptyPayload());
     return this.enqueueLifecycleFrame(
       ingress,
       `spot:${record.target.spot.spotId}`,
@@ -4259,7 +4318,7 @@ export class ServiceStatefulRuntime {
     );
   }
 
-  private enqueueApplicationFrame(
+  enqueueApplicationFrame(
     ingress: RawServiceIngressRecord,
     owner: string,
     payloadFrame: Buffer,
@@ -4343,7 +4402,7 @@ export class ServiceStatefulRuntime {
         channelName,
         topic,
         sourceSpotId,
-        encodeApplicationPayload(payload),
+        encodeOwnedApplicationPayload(payload),
         sourceNodeRid,
         applicationJobOwner
       );
@@ -4787,6 +4846,7 @@ export class ServiceStatefulRuntime {
   private async submitOneWay(targetNodeRid: string, parts: readonly Buffer[]): Promise<number> {
     this.requireOpen();
     if (targetNodeRid === this.nodeRid) {
+      parts = copyRetainedServiceFrames(parts);
       const applicationJobOwner = await this.raw.reserveLocalIngress();
       if (captureZLinkExecutionTurn() !== undefined) {
         //  The sender is inside a Spot serial turn. Running ingress inline
@@ -4862,6 +4922,7 @@ export class ServiceStatefulRuntime {
     receiver?: import('./operation-registry').OperationObserver<unknown, unknown>
   ): void {
     if (targetNodeRid === this.nodeRid) {
+      parts = copyRetainedServiceFrames(parts);
       const deadlineUnixMs = BigInt(Date.now() + Math.max(0, timeoutMs));
       const capacityStop = new AbortController();
       void pending.promise.then(
@@ -5031,7 +5092,7 @@ export class ServiceStatefulRuntime {
     );
   }
 
-  private async submitLocalRequest(
+  async submitLocalRequest(
     ingress: RawServiceIngressRecord,
     pending: ServiceStatefulPendingOperation,
     operationKind:
@@ -5058,7 +5119,7 @@ export class ServiceStatefulRuntime {
         ? ingress.parts.length < 2
           ? undefined
           : ingress.parts[1]
-        : encodeApplicationPayload({
+        : encodeOwnedApplicationPayload({
             packetName: canonicalActorJoin.payload.packetName,
             contentType: canonicalActorJoin.payload.contentType,
             payload: Buffer.from(canonicalActorJoin.payload.payload)
@@ -5171,7 +5232,7 @@ export class ServiceStatefulRuntime {
       this.enqueueLifecycleFrame(
         ingress,
         `spot:${decoded.target.spot.spotId}`,
-        payloadFrame ?? encodeApplicationPayload(emptyPayload()),
+        payloadFrame ?? encodeOwnedApplicationPayload(emptyPayload()),
         {
           receiveKind: ReceiveKind.SpotControl,
           operationKind: OperationKind.ActorJoin,
@@ -5381,6 +5442,7 @@ export class ServiceStatefulRuntime {
     return {
       terminalResult,
       failureCode,
+      ...(tail?.kind === 'streamBindRejected' ? { failureMessage: tail.rejectionMessage } : {}),
       ...(payload === undefined ? {} : { payload }),
       ...(tail?.kind === 'streamBind'
         ? {
@@ -5394,7 +5456,7 @@ export class ServiceStatefulRuntime {
     };
   }
 
-  private validateActorFence(fence: ServiceActorRouteFence): ServiceActorState {
+  validateActorFence(fence: ServiceActorRouteFence): ServiceActorState {
     if (
       fence.actor.nodeRid !== this.nodeRid ||
       fence.targetNodeGeneration !== this.nodeGeneration
@@ -5408,7 +5470,7 @@ export class ServiceStatefulRuntime {
     return actor;
   }
 
-  private validateActorMessageFence(fence: ServiceActorRouteFence): ServiceActorState {
+  validateActorMessageFence(fence: ServiceActorRouteFence): ServiceActorState {
     if (
       fence.actor.nodeRid !== this.nodeRid ||
       fence.targetNodeGeneration !== this.nodeGeneration
@@ -5439,7 +5501,7 @@ export class ServiceStatefulRuntime {
     return spot;
   }
 
-  private validateDirectSpotFence(fence: ServiceSpotRouteFence): ServiceSpotState {
+  validateDirectSpotFence(fence: ServiceSpotRouteFence): ServiceSpotState {
     if (
       fence.targetNodeRid !== this.nodeRid ||
       fence.targetNodeGeneration !== this.nodeGeneration
@@ -6412,6 +6474,10 @@ function emptyPayload(): ServiceApplicationPayload {
   };
 }
 
+function copyRetainedServiceFrames(parts: readonly Buffer[]): Buffer[] {
+  return parts.map((part) => copyPayloadBytes(part));
+}
+
 /**
  * The generated command-28 decoder is the canonical wire authority.  Keep
  * the stateful mailbox's internal record shape as an adapter only; it must

package/src/runtime/foundation/service-stateful-wire-codec.ts

@@ -3,6 +3,7 @@ import { decodeBoundSessionCloseCommand } from '../protocol/service_wire_codec.g
 import { UINT64_MAX, ZlinkStreamContentType } from '@zlink-systems/stream-wire';
 import { RELOCATION_STATE_CHUNK_DATA_MAX_BYTES } from '../../contracts/Configuration/InternalDefaults';
 import { isCanonicalWireReplyTerminal } from '../framework-errors-internal';
+import { RequestResult } from '../backend/runtime-values';
 import {
   decodeActorRequestCommand,
   decodeActorSendCommand,
@@ -1153,6 +1154,10 @@ export type ServiceStatefulReplyTail =
       readonly bindingGeneration: bigint;
       readonly authorityOwnerGeneration: bigint;
     }
+  | {
+      readonly kind: 'streamBindRejected';
+      readonly rejectionMessage: string;
+    }
   | {
       readonly kind: 'userSpotCreate';
       readonly createResult: 'existing' | 'created' | 'rejected';
@@ -2149,6 +2154,11 @@ export function decodeStatefulReply(
         ...(actor === undefined ? {} : { actor })
       };
     }
+  } else if (operationKind === 'streamBind' && terminalResult === RequestResult.Rejected) {
+    tail = {
+      kind: 'streamBindRejected',
+      rejectionMessage: reader.text16('rejectionMessage')
+    };
   }
   reader.end();
   return {
@@ -2222,6 +2232,8 @@ function encodeReplyTail(tail: ServiceStatefulReplyTail): Buffer {
     }
     case 'streamBind':
       return concat(u64(tail.bindingGeneration), u64(tail.authorityOwnerGeneration));
+    case 'streamBindRejected':
+      return concat(text16(tail.rejectionMessage, 'rejectionMessage'));
     case 'userSpotCreate':
       return concat(
         Buffer.of((['existing', 'created', 'rejected'] as const).indexOf(tail.createResult) + 1),
@@ -2404,6 +2416,12 @@ function text8(value: string, name: string): Buffer {
   return sized8(value, name);
 }
 
+function text16(value: string, name: string): Buffer {
+  const bytes = encodeCanonicalServiceWireText(value, name, 0xffff, outOfRange);
+  if (bytes.byteLength === 0) fail(`${name} must not be empty.`);
+  return concat(u16(bytes.byteLength), bytes);
+}
+
 function optionalRid(value: string | undefined): Buffer {
   return value === undefined ? Buffer.of(0) : rid(value, 'sourceSpotId');
 }

package/src/runtime/foundation/service-wire-constants.generated.ts

@@ -131,3 +131,13 @@ export const isValidServiceWireTerminalFailure = (
   }
   return ServiceWireExactTerminalByFailureCode[failureCode as keyof typeof ServiceWireExactTerminalByFailureCode] === terminal;
 };
+export function recoverRequestCorrelation(bytes: Uint8Array): bigint | undefined {
+  if (bytes.length < 13
+      || bytes[0] !== 90 || bytes[1] !== 77
+      || bytes[2] !== 1
+      || ![17, 19, 22, 25, 26, 27, 28, 38, 47, 48, 49, 54].includes(bytes[3]!)) return undefined;
+  let correlation = 0n;
+  for (let index = 5; index < 13; ++index)
+    correlation = (correlation << 8n) | BigInt(bytes[index]!);
+  return correlation === 0n ? undefined : correlation;
+}

package/src/runtime/foundation/service-wire-m6a-codec.ts

@@ -1,4 +1,5 @@
 import { UINT32_MAX, UINT64_MAX } from '@zlink-systems/stream-wire';
+import { allocatePayloadBytes } from '../../contracts/Common/payload-slab';
 import { normalizeEndpoint } from '../../contracts/Configuration/EndpointNotation';
 import {
   validateDescriptor,
@@ -185,10 +186,23 @@ export function decodeReplyHeader(frame: Uint8Array): ServiceReplyHeader {
 }
 
 export function encodeApplicationPayload(payload: ServiceApplicationPayload): Buffer {
+  return encodeApplicationPayloadWith(payload, allocatePayloadBytes);
+}
+
+/** Encodes a retained internal application frame with its own backing store. */
+export function encodeOwnedApplicationPayload(payload: ServiceApplicationPayload): Buffer {
+  return encodeApplicationPayloadWith(payload, allocateOwnedPayloadBytes);
+}
+
+function encodeApplicationPayloadWith(
+  payload: ServiceApplicationPayload,
+  allocate: (length: number) => Buffer
+): Buffer {
   const result = allocateApplicationPayload(
     payload.packetName,
     payload.contentType,
-    payload.payload.byteLength
+    payload.payload.byteLength,
+    allocate
   );
   result.set(payload.payload, result.byteLength - payload.payload.byteLength);
   return result;
@@ -205,7 +219,12 @@ export function encodeMultipartApplicationPayload(
   contentType: string
 ): Buffer {
   const multipartLength = multipartPayloadLength(parts);
-  const result = allocateApplicationPayload(packetName, contentType, multipartLength);
+  const result = allocateApplicationPayload(
+    packetName,
+    contentType,
+    multipartLength,
+    allocatePayloadBytes
+  );
   writeMultipartPayload(result, result.byteLength - multipartLength, parts);
   return result;
 }
@@ -255,7 +274,8 @@ function writeMultipartPayload(
 function allocateApplicationPayload(
   packetName: string,
   contentType: string,
-  payloadLength: number
+  payloadLength: number,
+  allocate: (length: number) => Buffer
 ): Buffer {
   const packetNameLength = canonicalServiceWireTextLength(
     packetName,
@@ -275,10 +295,8 @@ function allocateApplicationPayload(
   const prefixLength = 1 + APPLICATION_PAYLOAD_LENGTH_FIELD_BYTES;
   const bodyLength = frameLength - prefixLength;
   if (bodyLength > MAX_U32) fail('Application payload body exceeds u32.');
-  // Both callers write every payload byte after these header fields, so the
-  // frame needs no zero fill and a small frame comes from the shared pool
-  // instead of its own backing store.
-  const result = Buffer.allocUnsafe(frameLength);
+  // Both callers write every payload byte after these header fields.
+  const result = allocate(frameLength);
   result[0] = APPLICATION_PAYLOAD_VERSION;
   result.writeUInt32BE(bodyLength, 1);
   let offset = writeText8(result, prefixLength, packetName, packetNameLength);
@@ -287,6 +305,10 @@ function allocateApplicationPayload(
   return result;
 }
 
+function allocateOwnedPayloadBytes(length: number): Buffer {
+  return Buffer.allocUnsafeSlow(length);
+}
+
 export function decodeApplicationPayload(frame: Uint8Array): ServiceApplicationPayload {
   const decoded = decodeApplicationPayloadView(frame);
   return {

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-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

@@ -608,7 +608,7 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
     }
   }
 
-  private evaluatePressure(): void {
+  evaluatePressure(): void {
     const next =
       this.pressureStateValue === 'running'
         ? this.permitsInUse() >= this.pauseCount