@zlink-systems/framework 0.25.0 → 0.27.0

package/dist/runtime/actors/post-commit-actor-location.d.ts

@@ -1,19 +0,0 @@
-import type { RoutingId } from '../../contracts';
-import type { ZLinkLocationLifecycle } from '../locations';
-export interface ZLinkPostCommitActorLocationOptions {
-    readonly lifecycle: ZLinkLocationLifecycle;
-    readonly reportError?: (error: unknown) => void;
-    readonly signal?: AbortSignal;
-}
-export declare class ZLinkPostCommitActorLocation {
-    private readonly options;
-    private readonly lane;
-    private readonly queues;
-    private readonly tasks;
-    constructor(options: ZLinkPostCommitActorLocationOptions);
-    joinedEventually(actorType: string, actorId: string, meshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): void;
-    leftEventually(actorType: string, actorId: string, entrySpotId: RoutingId, entrySpotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): void;
-    private enqueue;
-    private run;
-    private completeCore;
-}

package/dist/runtime/actors/post-commit-actor-location.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkPostCommitActorLocation = void 0;
-const state_lane_1 = require("../execution/state-lane");
-const actor_retry_delay_1 = require("./actor-retry-delay");
-class ZLinkPostCommitActorLocation {
-    options;
-    lane = new state_lane_1.ZLinkStateLane();
-    queues = new Map();
-    tasks = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    joinedEventually(actorType, actorId, meshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration) {
-        this.enqueue(actorId, () => this.options.lifecycle.notifyActorJoinedSpot(actorType, actorId, meshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration));
-    }
-    leftEventually(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration) {
-        this.enqueue(actorId, () => this.options.lifecycle.notifyActorLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration));
-    }
-    enqueue(actorId, operation) {
-        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;
-        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);
-    }
-    async run(actorId) {
-        const retryDelay = new actor_retry_delay_1.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;
-                }
-            }
-        }
-    }
-    completeCore(queue) {
-        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;
-        }
-    }
-}
-exports.ZLinkPostCommitActorLocation = ZLinkPostCommitActorLocation;

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

@@ -1,26 +0,0 @@
-import type { ZLinkActor, ZLinkMessage, ZLinkMessageSerializer, ZLinkSpotActorJoinResult } from '../../contracts';
-import type { ZLinkBackendActorJoinRequest, ZLinkBackendSpot } from '../backend/contracts';
-import type { ZLinkDispatchErrorReporter } from '../channels';
-import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-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 declare class ZLinkSpotNativeActorJoinAdmission {
-    private readonly options;
-    constructor(options: ZLinkSpotNativeActorJoinAdmissionOptions);
-    admit(request: ZLinkBackendActorJoinRequest): Promise<void>;
-    private decodeNativeActorJoinRequest;
-    private reportHandlerException;
-}
-export {};

package/dist/runtime/spots/spot-native-actor-join-admission.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkSpotNativeActorJoinAdmission = void 0;
-const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
-const runtime_message_1 = require("../backend/runtime-message");
-const payload_codec_1 = require("../messaging/payload-codec");
-const spot_remote_codec_1 = require("./spot-remote-codec");
-class ZLinkSpotNativeActorJoinAdmission {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async admit(request) {
-        const actorId = request.info.targetActor.actorId;
-        let accepted = false;
-        let acceptedActor;
-        let reply;
-        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 = (0, payload_codec_1.wrapFrameworkPayloadMessage)(joinRequest, this.options.messageSerializers);
-                const response = 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
-                        : (0, payload_codec_1.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);
-            }
-        }
-    }
-    decodeNativeActorJoinRequest(message) {
-        try {
-            const payload = JSON.parse(message.data().toString());
-            if (payload.packetName !== spot_remote_codec_1.REMOTE_ACTOR_JOIN_PACKET ||
-                typeof payload.actorType !== 'string' ||
-                typeof payload.request !== 'string') {
-                return undefined;
-            }
-            return {
-                actorType: payload.actorType,
-                actorCreateRequest: typeof payload.actorCreateRequest === 'string'
-                    ? runtime_message_1.ZLinkBufferMessage.from(Buffer.from(payload.actorCreateRequest, 'base64'))
-                    : undefined,
-                request: runtime_message_1.ZLinkBufferMessage.from(Buffer.from(payload.request, 'base64'))
-            };
-        }
-        catch {
-            return undefined;
-        }
-    }
-    reportHandlerException(actorId, error) {
-        this.options.dispatchErrors?.report({
-            surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotActor,
-            messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend,
-            reason: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerException,
-            action: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop,
-            actorId,
-            error
-        });
-    }
-}
-exports.ZLinkSpotNativeActorJoinAdmission = ZLinkSpotNativeActorJoinAdmission;