@zlink-systems/framework 0.25.0 → 0.27.0

package/src/runtime/actors/post-commit-actor-location.ts

@@ -1,121 +0,0 @@
-import type { RoutingId } from '../../contracts';
-import { ZLinkStateLane } from '../execution/state-lane';
-import type { ZLinkLocationLifecycle } from '../locations';
-import { ZLinkActorRetryDelay } from './actor-retry-delay';
-
-export interface ZLinkPostCommitActorLocationOptions {
-  readonly lifecycle: ZLinkLocationLifecycle;
-  readonly reportError?: (error: unknown) => void;
-  readonly signal?: AbortSignal;
-}
-
-interface ActorOperationQueue {
-  readonly operations: Array<(() => Promise<void>) | undefined>;
-  head: number;
-  count: number;
-}
-
-export class ZLinkPostCommitActorLocation {
-  private readonly lane = new ZLinkStateLane();
-  private readonly queues = new Map<string, ActorOperationQueue>();
-  private readonly tasks = new Map<string, Promise<void>>();
-
-  constructor(private readonly options: ZLinkPostCommitActorLocationOptions) {}
-
-  joinedEventually(
-    actorType: string,
-    actorId: string,
-    meshName: string,
-    spotId: RoutingId,
-    spotGeneration: bigint,
-    membershipEpoch: bigint,
-    ownerNodeGeneration: bigint
-  ): void {
-    this.enqueue(actorId, () =>
-      this.options.lifecycle.notifyActorJoinedSpot(
-        actorType,
-        actorId,
-        meshName,
-        spotId,
-        spotGeneration,
-        membershipEpoch,
-        ownerNodeGeneration
-      )
-    );
-  }
-
-  leftEventually(
-    actorType: string,
-    actorId: string,
-    entrySpotId: RoutingId,
-    entrySpotGeneration: bigint,
-    membershipEpoch: bigint,
-    ownerNodeGeneration: bigint
-  ): void {
-    this.enqueue(actorId, () =>
-      this.options.lifecycle.notifyActorLeftSpot(
-        actorType,
-        actorId,
-        entrySpotId,
-        entrySpotGeneration,
-        membershipEpoch,
-        ownerNodeGeneration
-      )
-    );
-  }
-
-  private enqueue(actorId: string, operation: () => Promise<void>): void {
-    const queue = this.queues.get(actorId) ?? { operations: [], head: 0, count: 0 };
-    queue.operations.push(operation);
-    queue.count += 1;
-    this.queues.set(actorId, queue);
-    if (this.tasks.has(actorId)) {
-      return;
-    }
-    let task!: Promise<void>;
-    task = this.run(actorId).finally(
-      async () =>
-        await this.lane.run(() => {
-          if (this.tasks.get(actorId) === task) {
-            this.tasks.delete(actorId);
-          }
-        })
-    );
-    this.tasks.set(actorId, task);
-  }
-
-  private async run(actorId: string): Promise<void> {
-    const retryDelay = new ZLinkActorRetryDelay();
-    while (this.options.signal?.aborted !== true) {
-      const queue = this.queues.get(actorId);
-      const operation = queue?.operations[queue.head];
-      if (queue === undefined || operation === undefined) {
-        this.queues.delete(actorId);
-        return;
-      }
-      try {
-        await operation();
-        await this.lane.run(() => this.completeCore(queue));
-        retryDelay.reset();
-      } catch (error) {
-        this.options.reportError?.(error);
-        if (!(await retryDelay.wait(this.options.signal))) {
-          return;
-        }
-      }
-    }
-  }
-
-  private completeCore(queue: ActorOperationQueue): void {
-    queue.operations[queue.head] = undefined;
-    queue.head += 1;
-    queue.count -= 1;
-    if (queue.count === 0) {
-      queue.operations.length = 0;
-      queue.head = 0;
-    } else if (queue.head >= 1024 && queue.head * 2 >= queue.operations.length) {
-      queue.operations.splice(0, queue.head);
-      queue.head = 0;
-    }
-  }
-}

package/src/runtime/spots/spot-native-actor-join-admission.ts

@@ -1,155 +0,0 @@
-import type {
-  ZLinkActor,
-  ZLinkMessage,
-  ZLinkMessageSerializer,
-  ZLinkSpotActorJoinResult
-} from '../../contracts';
-import {
-  ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
-  ZLinkRuntimeDispatchErrorReason as ZLinkDispatchErrorReason,
-  ZLinkDispatchErrorSurface,
-  ZLinkDispatchMessageKind
-} from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import type { Message } from '../../contracts/Common/Message';
-import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import type { ZLinkBackendActorJoinRequest, ZLinkBackendSpot } from '../backend/contracts';
-import type { ZLinkDispatchErrorReporter } from '../channels';
-import {
-  encodeFrameworkPayloadMessage,
-  wrapFrameworkPayloadMessage
-} from '../messaging/payload-codec';
-import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-import { REMOTE_ACTOR_JOIN_PACKET } from './spot-remote-codec';
-
-interface ZLinkNativeActorJoinAdmissionTarget {
-  onActorJoin?(actorId: string, request: ZLinkMessage): Promise<ZLinkSpotActorJoinResult>;
-  onJoinedActor?(actor: ZLinkActor): Promise<void>;
-}
-
-interface ZLinkSpotNativeActorJoinAdmissionOptions {
-  readonly nativeSpot: ZLinkBackendSpot;
-  readonly serial: ZLinkSpotSerialTurnExecutor;
-  readonly resolveActor: (actorId: string) => ZLinkActor | undefined;
-  readonly getTarget: () => ZLinkNativeActorJoinAdmissionTarget;
-  readonly defaultAccept: boolean;
-  readonly commitAcceptedActor?: (actor: ZLinkActor) => Promise<void>;
-  readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
-  readonly dispatchErrors?: ZLinkDispatchErrorReporter;
-}
-
-export class ZLinkSpotNativeActorJoinAdmission {
-  constructor(private readonly options: ZLinkSpotNativeActorJoinAdmissionOptions) {}
-
-  async admit(request: ZLinkBackendActorJoinRequest): Promise<void> {
-    const actorId = request.info.targetActor.actorId;
-    let accepted = false;
-    let acceptedActor: ZLinkActor | undefined;
-    let reply: Message | undefined;
-    const decoded = this.decodeNativeActorJoinRequest(request.message);
-    try {
-      if (decoded !== undefined) {
-        throw new Error('Remote actor join requires the two-phase routed transfer protocol.');
-      }
-      const actor = this.options.resolveActor(actorId);
-      if (actor !== undefined) {
-        const target = this.options.getTarget();
-        const joinRequest = request.message;
-        const joinPayload = wrapFrameworkPayloadMessage(
-          joinRequest,
-          this.options.messageSerializers
-        );
-        const response: ZLinkSpotActorJoinResult = await this.options.serial.execute(async () =>
-          this.options.defaultAccept || target.onActorJoin === undefined
-            ? { accepted: this.options.defaultAccept }
-            : target.onActorJoin(actorId, joinPayload)
-        );
-        accepted = response.accepted;
-        reply =
-          response.reply === undefined
-            ? undefined
-            : encodeFrameworkPayloadMessage(response.reply, this.options.messageSerializers);
-        if (accepted) {
-          acceptedActor = actor;
-        }
-      }
-    } catch (error) {
-      this.reportHandlerException(actorId, error);
-      accepted = false;
-      reply?.close();
-      reply = undefined;
-    }
-    const operation = this.options.nativeSpot.replyActorJoin(request, accepted ? 0 : 1);
-    let submitted = false;
-    try {
-      if (reply !== undefined) {
-        operation.message(reply);
-      }
-      operation.submit();
-      submitted = true;
-    } finally {
-      if (!submitted) {
-        reply?.close();
-      }
-      decoded?.request.close();
-      decoded?.actorCreateRequest?.close();
-    }
-    if (acceptedActor !== undefined) {
-      try {
-        // The native reply commits the actor's return to the Entry Spot. Publish
-        // the immutable membership callback only after that commit so observers
-        // never see an accepted membership before Core does.
-        await this.options.commitAcceptedActor?.(acceptedActor);
-      } catch (error) {
-        this.reportHandlerException(actorId, error);
-      }
-    }
-  }
-
-  private decodeNativeActorJoinRequest(message: Message):
-    | {
-        readonly actorType: string;
-        readonly actorCreateRequest?: Message;
-        readonly request: Message;
-      }
-    | undefined {
-    try {
-      const payload = JSON.parse(message.data().toString()) as {
-        readonly packetName?: unknown;
-        readonly actorType?: unknown;
-        readonly actorNodeRid?: unknown;
-        readonly actorNodeRidHex?: unknown;
-        readonly actorGeneration?: unknown;
-        readonly actorCreateRequest?: unknown;
-        readonly request?: unknown;
-      };
-      if (
-        payload.packetName !== REMOTE_ACTOR_JOIN_PACKET ||
-        typeof payload.actorType !== 'string' ||
-        typeof payload.request !== 'string'
-      ) {
-        return undefined;
-      }
-      return {
-        actorType: payload.actorType,
-        actorCreateRequest:
-          typeof payload.actorCreateRequest === 'string'
-            ? RuntimeMessage.from(Buffer.from(payload.actorCreateRequest, 'base64'))
-            : undefined,
-        request: RuntimeMessage.from(Buffer.from(payload.request, 'base64'))
-      };
-    } catch {
-      return undefined;
-    }
-  }
-
-  private reportHandlerException(actorId: string, error: unknown): void {
-    this.options.dispatchErrors?.report({
-      surface: ZLinkDispatchErrorSurface.SpotActor,
-      messageKind: ZLinkDispatchMessageKind.ActorSend,
-      reason: ZLinkDispatchErrorReason.HandlerException,
-      action: ZLinkDispatchErrorAction.Drop,
-      actorId,
-      error
-    });
-  }
-}