@zlink-systems/framework 0.29.0 → 0.30.0

package/src/runtime/locations/location-store-repository.ts

@@ -1,4 +1,10 @@
-import { ServiceRelocationAuthorityPayloadCodec } from '../foundation/service-relocation-runtime';
+import {
+  ServiceRelocationAuthorityPayloadCodec,
+  serviceRelocationAuthorityApplicationPayload
+} from '../foundation/service-relocation-runtime';
+import { decodeServiceReadySpotAuthority } from '../foundation/service-authority-payload-codec';
+import { decodeActorAuthorityPayload } from '../actors/actor-authority-payload-codec';
+import { ZLinkSpotKind } from '../../contracts';
 import { UINT64_MAX } from '@zlink-systems/stream-wire';
 import { createHash, randomUUID } from 'node:crypto';
 import { zlinkRuntimeDefaultLocationOptions } from '../../contracts/Locations/Options';
@@ -76,6 +82,7 @@ import {
   type ZLinkObjectCommitResult,
   type ZLinkObjectCreationCompleteRequest,
   type ZLinkObjectCreationCompleteResult,
+  type ZLinkEndedOwnerReleaseIntent,
   type ZLinkObjectReserveRequest,
   type ZLinkObjectReserveResult,
   type ZLinkOwnerLeaseClaimResult,
@@ -429,10 +436,39 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
                 payload: Buffer.from(mutation.payload)
               }
             };
+      const actor =
+        mutation.kind !== 'delete' && record.snapshot.allocation.objectKind === 'actor'
+          ? decodeActorAuthorityPayload(
+              serviceRelocationAuthorityApplicationPayload(mutation.payload)
+            )
+          : undefined;
+      const previousActor =
+        actor === undefined
+          ? undefined
+          : decodeActorAuthorityPayload(
+              serviceRelocationAuthorityApplicationPayload(record.snapshot.payload)
+            );
+      const membershipConditions =
+        actor?.currentSpotKind === ZLinkSpotKind.User &&
+        (previousActor?.currentSpotKind !== ZLinkSpotKind.User ||
+          previousActor.currentSpotId !== actor.currentSpotId ||
+          previousActor.currentSpotGeneration !== actor.currentSpotGeneration)
+          ? await this.userSpotMembershipConditions(
+              actor.currentSpotId,
+              actor.currentSpotGeneration,
+              signal,
+              {
+                ownerId: record.snapshot.ownerId,
+                leaseGeneration: record.snapshot.ownerLeaseGeneration
+              }
+            )
+          : [];
+      if (membershipConditions === undefined) return { kind: 'conflict', current: snapshot };
       const result = await this.provider.write(
         {
           conditions: [
             { kind: 'version', key: rowKey, expected: current.value.version },
+            ...membershipConditions,
             ...(mutation.kind === 'restore'
               ? []
               : [
@@ -945,7 +981,7 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
         ) {
           throw new Error('Aggregate participant staging checksum does not match inventory.');
         }
-        authorityRows.push({ key: rowKeyForParticipant, current, record, entry });
+        authorityRows.push({ key: rowKeyForParticipant, current, record, entry, payload });
       }
 
       const targetDescriptorKey = meshKey(
@@ -1024,12 +1060,52 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
           bytes: encodeJson(capacity)
         });
       }
+      const membershipConditions: ZLinkStoreCondition[] = [];
+      for (const row of authorityRows) {
+        if (row.record.snapshot.allocation.objectKind !== 'actor') continue;
+        const actor = decodeActorAuthorityPayload(
+          serviceRelocationAuthorityApplicationPayload(row.payload)
+        );
+        if (actor?.currentSpotKind !== ZLinkSpotKind.User) continue;
+        const spotKey = encodeAuthorityKey('user_spot', actor.currentSpotId);
+        const participantSpot = authorityRows.find(
+          (candidate) => candidate.entry.authorityKey === spotKey.value
+        );
+        if (participantSpot !== undefined) {
+          if (
+            participantSpot.record.snapshot.allocation.objectKind !== 'user_spot' ||
+            participantSpot.record.snapshot.objectGeneration !== actor.currentSpotGeneration
+          )
+            return { kind: 'stale' };
+          continue;
+        }
+        if (
+          membershipConditions.some(
+            (condition) => condition.key.value === authorityKey(spotKey.value).value
+          )
+        )
+          continue;
+        const conditions = await this.userSpotMembershipConditions(
+          actor.currentSpotId,
+          actor.currentSpotGeneration,
+          signal,
+          aggregate.targetOwner
+        );
+        if (conditions === undefined) return { kind: 'stale' };
+        membershipConditions.push(
+          ...conditions.filter(
+            (condition) =>
+              !membershipConditions.some((existing) => existing.key.value === condition.key.value)
+          )
+        );
+      }
       const published = await this.provider.write(
         {
           conditions: [
             { kind: 'version', key: rowKey, expected: aggregateRead.value.version },
             versionCondition(targetDescriptorKey, descriptorRead),
             leaseValueCondition(targetLeaseKey, aggregate.targetOwner),
+            ...membershipConditions,
             ...[...capacityReads.entries()].map(([value, read]) => ({
               kind: 'version' as const,
               key: capacityKeys.get(value)!,
@@ -1128,21 +1204,33 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
   override async releaseEndedReservation(
     key: ZLinkAuthorityKey,
     expectedStoreVersion: string,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    request?: ZLinkEndedOwnerReleaseIntent
   ): Promise<boolean> {
+    return (
+      (await this.tryReleaseEndedReservation(key, expectedStoreVersion, signal, request)) ===
+      'reclaimed'
+    );
+  }
+
+  private async tryReleaseEndedReservation(
+    key: ZLinkAuthorityKey,
+    expectedStoreVersion: string,
+    signal?: AbortSignal,
+    request?: ZLinkEndedOwnerReleaseIntent
+  ): Promise<'notReclaimable' | 'conflict' | 'reclaimed'> {
     const rowKey = authorityKey(key.value);
     const current = await this.provider.read(rowKey, signal);
     if (current.kind === 'missing' || current.value.version.value !== expectedStoreVersion)
-      return false;
+      return 'conflict';
     const record = decodeAuthorityRecord(current.value.bytes);
     const snapshot = record.snapshot;
     if (
-      snapshot.allocation.state !== 'reserved' ||
-      snapshot.pendingCreation === undefined ||
-      record.aggregate !== undefined ||
-      hasRelocationAuthority(snapshot.payload)
+      snapshot.allocation.state === 'active'
+        ? request === undefined
+        : snapshot.pendingCreation === undefined
     )
-      return false;
+      return 'notReclaimable';
     const leaseKey = ownerKey(snapshot.ownerId);
     const descriptorKey = meshKey(
       snapshot.allocation.descriptor.meshName,
@@ -1159,27 +1247,111 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     ]);
     if (lease.kind === 'found' && lease.value.expiresAt === undefined)
       throw new Error('Location Store owner lease record is invalid.');
-    if (
-      sameLiveOwner(lease, snapshot) &&
+    const ownerLive = sameLiveOwner(lease, snapshot);
+    if (snapshot.allocation.state === 'active') {
+      if (ownerLive) return 'notReclaimable';
+      let unavailable = record.aggregate !== undefined || hasRelocationAuthority(snapshot.payload);
+      if (snapshot.allocation.objectKind !== 'actor') {
+        const spot = decodeServiceReadySpotAuthority(snapshot.payload);
+        unavailable ||=
+          spot === undefined ||
+          spot.kind !== request?.key.kind ||
+          spot.stableType !== request.intent.stableType ||
+          spot.spotId !== request.key.globalId ||
+          spot.activationRecovery !== undefined;
+        if (spot?.kind === 'user_spot') {
+          // The snapshot starts only after the old owner's lease was found invalid.
+          for (const prefix of [`${PREFIX}actor:`, `${AUTHORITY_PREIMAGE_PREFIX}actor\0`]) {
+            membershipSnapshot: for (;;) {
+              let snapshotHasMember = false;
+              let cursor: ZLinkStoreScanCursor | undefined;
+              do {
+                const page = await this.provider.scan(
+                  { prefix, cursor, limit: ZLINK_PROVIDER_MAX_PAGE_SIZE },
+                  signal
+                );
+                if (page.kind === 'expired') continue membershipSnapshot;
+                for (const item of page.value.items) {
+                  if (prefix === `${PREFIX}actor:`) {
+                    const actor = normalizeActor(
+                      decodeJson<DescriptorRecord<ZLinkActorLocation>>(item.value.bytes).descriptor
+                    );
+                    snapshotHasMember ||=
+                      actor.spotKind === ZLinkSpotKind.User &&
+                      String(actor.spotId) === spot.spotId &&
+                      actor.spotGeneration === snapshot.objectGeneration;
+                  } else {
+                    const authority = decodeAuthorityRecord(item.value.bytes).snapshot;
+                    if (authority.allocation.objectKind !== 'actor') continue;
+                    const actor = decodeActorAuthorityPayload(
+                      serviceRelocationAuthorityApplicationPayload(authority.payload)
+                    );
+                    snapshotHasMember ||=
+                      actor?.currentSpotKind === ZLinkSpotKind.User &&
+                      actor.currentSpotId === spot.spotId &&
+                      actor.currentSpotGeneration === snapshot.objectGeneration;
+                  }
+                }
+                cursor = page.value.nextCursor;
+              } while (cursor !== undefined);
+              unavailable ||= snapshotHasMember;
+              break;
+            }
+          }
+        }
+      }
+      if (unavailable || request?.actorRelocationPolicy !== 'disabled')
+        throw new ZLinkFrameworkException(
+          ZLinkFrameworkErrorKind.Unavailable,
+          'Object owner lease is unavailable.'
+        );
+    } else if (
+      ownerLive &&
       descriptor.kind === 'found' &&
       reviveMeshDescriptor(
         decodeCanonicalDescriptorRecord<ZLinkMeshNodeDescriptor>(descriptor.value.bytes).descriptor
       ).lifecycleGeneration === snapshot.allocation.descriptorLifecycleGeneration
     )
-      return false;
+      return 'notReclaimable';
+    if (
+      snapshot.allocation.state !== 'active' &&
+      (record.aggregate !== undefined || hasRelocationAuthority(snapshot.payload))
+    )
+      return 'notReclaimable';
     const mutations: ZLinkStoreWriteRequest['mutations'][number][] = [
       { kind: 'delete', key: rowKey }
     ];
     if (capacity.kind === 'found') {
       const stored = decodeJson<CapacityRecord>(capacity.value.bytes);
-      mutations.push({
-        kind: 'put',
-        key: capacityRowKey,
-        bytes: encodeJson({
-          active: stored.active,
-          pending: subtractCapacity(stored.pending, snapshot.allocation.capacity)
-        } satisfies CapacityRecord)
-      });
+      try {
+        mutations.push({
+          kind: 'put',
+          key: capacityRowKey,
+          bytes: encodeJson({
+            active:
+              snapshot.allocation.state === 'active'
+                ? subtractCapacity(stored.active, snapshot.allocation.capacity)
+                : stored.active,
+            pending:
+              snapshot.allocation.state === 'reserved'
+                ? subtractCapacity(stored.pending, snapshot.allocation.capacity)
+                : stored.pending
+          } satisfies CapacityRecord)
+        });
+      } catch (error) {
+        if (
+          !(error instanceof ZLinkFrameworkException) ||
+          error.kind !== ZLinkFrameworkErrorKind.DataLost
+        )
+          throw error;
+        const observed = await this.provider.read(rowKey, signal);
+        if (
+          observed.kind === 'missing' ||
+          observed.value.version.value !== current.value.version.value
+        )
+          return 'conflict';
+        throw error;
+      }
     }
     const result = await this.provider.write(
       {
@@ -1193,7 +1365,7 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
       },
       signal
     );
-    return result.kind === 'applied';
+    return result.kind === 'applied' ? 'reclaimed' : 'conflict';
   }
 
   override async reserve(
@@ -1203,6 +1375,7 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
   ): Promise<ZLinkObjectReserveResult> {
     const encodedAuthorityKey = encodeAuthorityKey(request.key.kind, request.key.globalId);
     const reservationId = randomUUID();
+    let reclaimVersion: string | undefined;
     for (;;) {
       throwIfOperationExpired(signal, deadlineUnixMs);
       const rowKey = authorityKey(encodedAuthorityKey.value);
@@ -1223,19 +1396,23 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
         ) {
           return { kind: 'typeMismatch', current: snapshot };
         }
-        if (snapshot.allocation.state === 'active') {
-          return { kind: 'alreadyExists', current: snapshot };
-        }
-        if (
-          !(await this.releaseEndedReservation(
-            encodedAuthorityKey,
-            current.value.version.value,
-            signal
-          ))
-        )
+        if (reclaimVersion !== undefined && snapshot.storeVersion.value !== reclaimVersion)
           return { kind: 'conflict', current: snapshot };
+        const reclaim = await this.tryReleaseEndedReservation(
+          encodedAuthorityKey,
+          current.value.version.value,
+          signal,
+          request
+        );
+        if (reclaim === 'notReclaimable')
+          return snapshot.allocation.state === 'active'
+            ? { kind: 'alreadyExists', current: snapshot }
+            : { kind: 'conflict', current: snapshot };
+        reclaimVersion = reclaim === 'conflict' ? snapshot.storeVersion.value : undefined;
         continue;
       }
+      if (reclaimVersion !== undefined)
+        return { kind: 'conflict', current: { kind: 'missing', storeNow: current.storeNow } };
       const [descriptorRead, leaseRead] = await Promise.all([
         this.provider.read(descriptorKey, signal),
         this.provider.read(leaseKey, signal)
@@ -1555,6 +1732,22 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
           'Creation terminal expiry must be the live operation deadline plus five minutes.'
         );
       }
+      const actor =
+        request.completion.kind === 'created'
+          ? decodeActorAuthorityPayload(
+              serviceRelocationAuthorityApplicationPayload(request.completion.readyPayload)
+            )
+          : undefined;
+      const membershipConditions =
+        actor?.currentSpotKind === ZLinkSpotKind.User
+          ? await this.userSpotMembershipConditions(
+              actor.currentSpotId,
+              actor.currentSpotGeneration,
+              signal,
+              request.target.owner
+            )
+          : [];
+      if (membershipConditions === undefined) return { kind: 'stale' };
       const mutations =
         request.completion.kind === 'created'
           ? [
@@ -1596,6 +1789,7 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
           conditions: [
             { kind: 'version', key: rowKey, expected: current.value.version },
             { kind: 'missing', key: terminalRowKey },
+            ...membershipConditions,
             versionCondition(descriptorKey, descriptorRead),
             leaseValueCondition(leaseKey, request.target.owner),
             conditionFor(capacityRowKey, capacityRead)
@@ -2027,7 +2221,8 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
       actorKey(location.meshName, location.actorId),
       normalizeActor(location),
       intent,
-      signal
+      signal,
+      location
     );
   }
 
@@ -2569,11 +2764,48 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     };
   }
 
+  private async userSpotMembershipConditions(
+    spotId: string,
+    objectGeneration: bigint,
+    signal?: AbortSignal,
+    conditionedOwner?: ZLinkLocationOwnerToken
+  ): Promise<ZLinkStoreCondition[] | undefined> {
+    const key = authorityKey(encodeAuthorityKey('user_spot', spotId).value);
+    const read = await this.provider.read(key, signal);
+    if (read.kind === 'missing') return undefined;
+    const record = decodeAuthorityRecord(read.value.bytes);
+    const snapshot = record.snapshot;
+    if (
+      record.aggregate !== undefined ||
+      snapshot.allocation.objectKind !== 'user_spot' ||
+      snapshot.allocation.state !== 'active' ||
+      snapshot.objectGeneration !== objectGeneration ||
+      decodeServiceReadySpotAuthority(snapshot.payload)?.kind !== 'user_spot'
+    )
+      return undefined;
+    const leaseKey = ownerKey(snapshot.ownerId);
+    const lease = await this.provider.read(leaseKey, signal);
+    if (!sameLiveOwner(lease, snapshot)) return undefined;
+    return [
+      { kind: 'version', key, expected: read.value.version },
+      ...(conditionedOwner?.ownerId === snapshot.ownerId &&
+      conditionedOwner.leaseGeneration === snapshot.ownerLeaseGeneration
+        ? []
+        : [
+            leaseValueCondition(leaseKey, {
+              ownerId: snapshot.ownerId,
+              leaseGeneration: snapshot.ownerLeaseGeneration
+            })
+          ])
+    ];
+  }
+
   private async updateOwnedLocation<T extends LeaseOwnedLocation>(
     rowKey: ZLinkStoreKey,
     location: T,
     intent: ZLinkLocationWriteIntent,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    membership?: Pick<ZLinkActorLocation, 'spotKind' | 'spotId' | 'spotGeneration'>
   ): Promise<ZLinkLocationWriteResult> {
     const leaseKey = ownerKey(location.ownerId);
     const [lease, current] = await Promise.all([
@@ -2627,6 +2859,24 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
       return rejected(lease.value.storeNow);
     }
 
+    const previousMembership =
+      current.kind === 'found' && membership !== undefined
+        ? decodeJson<DescriptorRecord<ZLinkActorLocation>>(current.value.bytes).descriptor
+        : undefined;
+    const membershipConditions =
+      membership?.spotKind === ZLinkSpotKind.User &&
+      (previousMembership?.spotKind !== ZLinkSpotKind.User ||
+        String(previousMembership.spotId) !== String(membership.spotId) ||
+        BigInt(previousMembership.spotGeneration) !== membership.spotGeneration)
+        ? await this.userSpotMembershipConditions(
+            String(membership.spotId),
+            membership.spotGeneration,
+            signal,
+            { ownerId: location.ownerId, leaseGeneration: locationOwnerGeneration(location) }
+          )
+        : [];
+    if (membershipConditions === undefined) return rejected(lease.value.storeNow);
+
     const result = await this.provider.write(
       {
         conditions: [
@@ -2634,7 +2884,8 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
             ownerId: location.ownerId,
             leaseGeneration: locationOwnerGeneration(location)
           }),
-          rowCondition
+          rowCondition,
+          ...membershipConditions
         ],
         mutations: [
           {
@@ -4040,13 +4291,21 @@ function adjustCapacity(
   if (delta.spotType !== undefined) {
     const key = capacityTypeKey(delta.spotType);
     const next = (spotTypes[key] ?? 0) + direction * delta.spotType.count;
-    if (next < 0) throw new Error('Provider capacity counter underflow.');
+    if (next < 0)
+      throw new ZLinkFrameworkException(
+        ZLinkFrameworkErrorKind.DataLost,
+        'Provider capacity counter underflow.'
+      );
     if (next === 0) delete spotTypes[key];
     else spotTypes[key] = next;
   }
   const actors = usage.actors + direction * delta.actors;
   const spots = usage.spots + direction * delta.spots;
-  if (actors < 0 || spots < 0) throw new Error('Provider capacity counter underflow.');
+  if (actors < 0 || spots < 0)
+    throw new ZLinkFrameworkException(
+      ZLinkFrameworkErrorKind.DataLost,
+      'Provider capacity counter underflow.'
+    );
   return { actors, spots, spotTypes };
 }
 

package/src/runtime/locations/resolvers.ts

@@ -26,7 +26,11 @@ import {
   type ResolvedSpotHandle
 } from '../spots/spot-handle';
 
-import type { ZLinkSpotRouteResolver, ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
+import type {
+  ZLinkSpotRouteResolver,
+  ZLinkSpotRouteTarget,
+  ZLinkInstanceReactivationRoute
+} from '../spots/spot-routing-internal';
 import { encodeAuthorityKey } from './authority-key-codec';
 import { isKnownZLinkLocationAutoConnectType, isKnownZLinkLocationRole } from './canonical-codec';
 import {
@@ -951,7 +955,17 @@ export class ZLinkAuthoritySpotRouteResolver implements ZLinkSpotRouteResolver {
     ) => Promise<ZLinkFrameworkRuntimeState | undefined>
   ) {}
 
-  async resolve(spotId: RoutingId, signal?: AbortSignal): Promise<ZLinkSpotRouteTarget> {
+  resolve(
+    spotId: RoutingId,
+    signal: AbortSignal | undefined,
+    instanceIntent: true
+  ): Promise<ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute>;
+  resolve(spotId: RoutingId, signal?: AbortSignal): Promise<ZLinkSpotRouteTarget>;
+  async resolve(
+    spotId: RoutingId,
+    signal?: AbortSignal,
+    instanceIntent?: true
+  ): Promise<ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute> {
     const key = String(spotId);
     const prepared = await this.lane.run(() => this.beginResolutionCore(key));
     try {
@@ -980,6 +994,15 @@ export class ZLinkAuthoritySpotRouteResolver implements ZLinkSpotRouteResolver {
                   signal
                 );
           if (remainingLeaseMs !== undefined && remainingLeaseMs <= 0) {
+            if (instanceIntent === true && ready?.kind === 'instance_spot') {
+              return {
+                kind: 'coldActivation',
+                spotId,
+                spotKind: ZLinkSpotKind.Instance,
+                meshName: ready.ownerMeshName,
+                stableType: ready.stableType
+              };
+            }
             throw new ZLinkFrameworkException(
               ZLinkFrameworkErrorKind.Unavailable,
               `SPOT '${spotId}' Ready authority owner lease is unavailable.`

package/src/runtime/messaging/submission-result.ts

@@ -18,13 +18,13 @@ export interface ZLinkSubmitResult {
   readonly status: ZLinkSubmitStatus;
 }
 
-/** Projects immediate refusal and pending admission failure from their Core phase. */
+/** Projects typed submit failure; capacity refusal has no admission wait token. */
 export function submitToRequestResult(result: number, phase: 'submit' | 'completion'): number {
   switch (result) {
     case SubmitResult.Ok:
       return RequestResult.Ok;
     case SubmitResult.Backpressured:
-      return phase === 'submit' ? RequestResult.NotConnected : RequestResult.TimedOut;
+      return RequestResult.NotConnected;
     case SubmitResult.NotConnected:
       return RequestResult.NotConnected;
     case SubmitResult.NotFound:

package/src/runtime/spots/formal-remote-actor-admission-registry.ts

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId } from '../../contracts';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors/actor-runtime-state';
 import type { ZLinkDeferredJoinCompletion } from '../actors/deferred-join-completion';
@@ -13,6 +14,7 @@ const ADMISSION_RETENTION_MS = 30_000;
  * how long the underlying buffer stays valid.
  */
 export interface ZLinkParkedActorArrival {
+  readonly origin: ApplicationJobOrigin;
   readonly header: Buffer;
   readonly payload: Buffer;
   readonly returnResponse: boolean;

package/src/runtime/spots/index.ts

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import { dispatchReasonFromError } from '../diagnostics/dispatch-error-details';
 import type {
   ActorRef,
@@ -190,6 +191,7 @@ export interface ZLinkSpotManagerOptions {
     ): Promise<void>;
   };
   readonly dispatchEntryActorPacket?: (
+    origin: ApplicationJobOrigin,
     actorId: string,
     parts: readonly Message[],
     returnResponse?: boolean,
@@ -1532,6 +1534,7 @@ export class DefaultZLinkSpotManager {
   }
 
   dispatchRoutedActorPacket(
+    origin: ApplicationJobOrigin,
     spotId: RoutingId,
     actorId: string,
     parts: readonly Message[],
@@ -1544,6 +1547,7 @@ export class DefaultZLinkSpotManager {
       throw new ZLinkConfigurationException(`Spot '${spotId}' is not active.`);
     }
     return this.dispatchActorPacket(
+      origin,
       activation,
       actorId,
       parts,
@@ -1555,6 +1559,7 @@ export class DefaultZLinkSpotManager {
 
   /** @internal Replays a record already owned by the Actor handoff queue. */
   dispatchRoutedActorPacketDirect(
+    origin: ApplicationJobOrigin,
     spotId: RoutingId,
     actorId: string,
     parts: readonly Message[],
@@ -1567,6 +1572,7 @@ export class DefaultZLinkSpotManager {
       throw new ZLinkConfigurationException(`Spot '${spotId}' is not active.`);
     }
     return this.activationLifecycle.dispatchActorPacketDirect(
+      origin,
       activation,
       actorId,
       parts,
@@ -1965,6 +1971,7 @@ export class DefaultZLinkSpotManager {
   }
 
   async dispatchMeshActor(
+    origin: ApplicationJobOrigin,
     meshName: string,
     owner: ReadyRecord,
     record: ReceiveRecord
@@ -2027,6 +2034,7 @@ export class DefaultZLinkSpotManager {
       }
       const response = targetsEntrySpot
         ? await this.options.dispatchEntryActorPacket?.(
+            origin,
             actor.actorId,
             record.parts,
             request,
@@ -2036,6 +2044,7 @@ export class DefaultZLinkSpotManager {
             record.messageFollowOrigin
           )
         : await this.dispatchMeshActorPacket(
+            origin,
             meshName,
             spotId,
             actor.actorId,
@@ -2693,6 +2702,7 @@ export class DefaultZLinkSpotManager {
                     );
                   }
                   return await this.options.dispatchEntryActorPacket(
+                    'remote',
                     entryActor.context.actorId,
                     parts,
                     returnResponse,
@@ -2922,6 +2932,7 @@ export class DefaultZLinkSpotManager {
               pendingTransfer.handoffBacklog,
               (parts, returnResponse, remoteBoundSessionTarget, _fallbackActorRef) =>
                 this.dispatchActorPacket(
+                  'remote',
                   activation,
                   actor.context.actorId,
                   parts,
@@ -3271,6 +3282,7 @@ export class DefaultZLinkSpotManager {
   }
 
   private async dispatchActorPacket(
+    origin: ApplicationJobOrigin,
     activation: ZLinkSpotActivation,
     actorId: string,
     parts: readonly Message[],
@@ -3281,6 +3293,7 @@ export class DefaultZLinkSpotManager {
     messageFollowOrigin?: ZLinkMessageFollowOrigin
   ): Promise<unknown> {
     return await this.activationLifecycle.dispatchActorPacket(
+      origin,
       activation,
       actorId,
       parts,
@@ -3311,6 +3324,7 @@ export class DefaultZLinkSpotManager {
     for (const arrival of drained) {
       try {
         const response = await this.dispatchActorPacket(
+          arrival.origin,
           activation,
           actor.context.actorId,
           [RuntimeMessage.from(arrival.header), RuntimeMessage.from(arrival.payload)],
@@ -3327,6 +3341,7 @@ export class DefaultZLinkSpotManager {
   }
 
   private async dispatchMeshActorPacket(
+    origin: ApplicationJobOrigin,
     meshName: string,
     spotId: RoutingId,
     actorId: string,
@@ -3343,6 +3358,7 @@ export class DefaultZLinkSpotManager {
       );
     }
     return await this.dispatchActorPacket(
+      origin,
       activation,
       actorId,
       parts,