@zlink-systems/framework 0.10.0

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkPostCommitActorBinder = void 0;
+const state_lane_1 = require("../execution/state-lane");
+const actor_retry_delay_1 = require("./actor-retry-delay");
+class ZLinkPostCommitActorBinder {
+    options;
+    lane = new state_lane_1.ZLinkStateLane();
+    desiredRefs = new Map();
+    tasks = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    bindEventually(actorRef) {
+        void this.bind(actorRef);
+    }
+    bind(actorRef) {
+        this.desiredRefs.set(actorRef.actorId, actorRef);
+        const existing = this.tasks.get(actorRef.actorId);
+        if (existing !== undefined)
+            return existing;
+        let task;
+        task = this.run(actorRef.actorId)
+            .finally(async () => await this.lane.run(() => {
+            if (this.tasks.get(actorRef.actorId) === task) {
+                this.tasks.delete(actorRef.actorId);
+            }
+        }));
+        this.tasks.set(actorRef.actorId, task);
+        return task;
+    }
+    async run(actorId) {
+        const retryDelay = new actor_retry_delay_1.ZLinkActorRetryDelay();
+        for (;;) {
+            const signal = this.signal();
+            if (signal?.aborted === true)
+                return;
+            const actorRef = this.desiredRefs.get(actorId);
+            if (actorRef === undefined) {
+                return;
+            }
+            try {
+                await this.options.bind(actorRef, true);
+                if (await this.lane.run(() => this.completeBindCore(actorId, actorRef))) {
+                    return;
+                }
+                retryDelay.reset();
+            }
+            catch (error) {
+                this.options.reportError?.(error);
+                if (!await retryDelay.wait(signal))
+                    return;
+            }
+        }
+    }
+    signal() {
+        return typeof this.options.signal === 'function'
+            ? this.options.signal()
+            : this.options.signal;
+    }
+    completeBindCore(actorId, actorRef) {
+        if (this.desiredRefs.get(actorId) !== actorRef)
+            return false;
+        this.desiredRefs.delete(actorId);
+        return true;
+    }
+}
+exports.ZLinkPostCommitActorBinder = ZLinkPostCommitActorBinder;

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,72 @@
+"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/actors/spot-actor-dispatch.d.ts

@@ -0,0 +1,59 @@
+import type { Type, ZLinkActor, ZLinkActorHandlerRegistry, ZLinkSpot, ZLinkSpotActorJoinResult, ZLinkMessageContext } from '../../contracts';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkMessageSerializer } from '../../contracts';
+import type { ZLinkSerialWorkOptions } from '../execution/serial-execution-queue';
+export declare enum ZLinkActorPacketKind {
+    Send = "send",
+    Request = "request"
+}
+export interface ZLinkActorPacketDescriptor {
+    readonly kind: ZLinkActorPacketKind;
+    readonly packetName: string;
+    readonly actorType: Type<ZLinkActor>;
+    readonly handlerType: Type;
+}
+export declare class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRegistry {
+    private readonly packets;
+    addHandler<THandler>(handlerType: Type<THandler>, packetName?: string): this;
+    addPacket(descriptor: ZLinkActorPacketDescriptor): this;
+    resolvePacket(kind: ZLinkActorPacketKind, actor: ZLinkActor, packetName: string): ZLinkActorPacketDescriptor | undefined;
+}
+export interface ZLinkSpotActorDispatcherOptions {
+    readonly registry: ZLinkSpotActorHandlerRegistryRuntime;
+    readonly spot: ZLinkSpot;
+    readonly providerResolver?: ZLinkProviderResolver;
+    readonly serial?: {
+        execute<T>(operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
+    };
+    readonly serialWorkOptions?: ZLinkSerialWorkOptions;
+    readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
+    readonly onAdmitted?: () => void;
+    readonly onHandlerStart?: () => void;
+}
+interface ZLinkSpotActorReplyOptionsSnapshot {
+    readonly metadata: ReadonlyMap<string, string>;
+    readonly compressPayload: boolean;
+}
+export declare class ZLinkSpotActorDispatcher {
+    private readonly options;
+    constructor(options: ZLinkSpotActorDispatcherOptions);
+    dispatchSend<TMessage>(actor: ZLinkActor, packetName: string, message: TMessage, context?: Partial<ZLinkMessageContext>): Promise<void>;
+    dispatchSendDecoded<TMessage>(actor: ZLinkActor, packetName: string, decode: () => TMessage, context?: Partial<ZLinkMessageContext>): Promise<void>;
+    dispatchRequest<TRequest, TReply>(actor: ZLinkActor, packetName: string, request: TRequest, context?: Partial<ZLinkMessageContext>): Promise<TReply>;
+    dispatchRequestDecoded<TRequest, TReply>(actor: ZLinkActor, packetName: string, decode: () => TRequest, context?: Partial<ZLinkMessageContext>): Promise<TReply>;
+    dispatchRequestThen<TRequest, TReply, TResult>(actor: ZLinkActor, packetName: string, request: TRequest, context: Partial<ZLinkMessageContext> | undefined, afterReply: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<TResult> | TResult, beforeReply?: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<void> | void): Promise<TResult>;
+    dispatchRequestThenDecoded<TRequest, TReply, TResult>(actor: ZLinkActor, packetName: string, decode: () => TRequest, context: Partial<ZLinkMessageContext> | undefined, afterReply: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<TResult> | TResult, beforeReply?: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<void> | void): Promise<TResult>;
+    admitActorJoin(actor: ZLinkActor, request: Message, commit: () => Promise<void> | void): Promise<ZLinkSpotActorJoinResult>;
+    evaluateActorJoin(actor: ZLinkActor, request: Message, contentType?: string): Promise<ZLinkSpotActorJoinResult>;
+    commitActorJoin(actor: ZLinkActor, commit: () => Promise<void> | void): Promise<void>;
+    notifyJoinActor(actor: ZLinkActor): Promise<void>;
+    notifyLeaveActor(actor: ZLinkActor): Promise<void>;
+    notifyDisconnectActor(actor: ZLinkActor): Promise<void>;
+    private requirePacket;
+    private ensureActorType;
+    private invokeHandler;
+    private execute;
+    private createContext;
+}
+export {};

package/dist/runtime/actors/spot-actor-dispatch.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkSpotActorDispatcher = exports.ZLinkSpotActorHandlerRegistryRuntime = exports.ZLinkActorPacketKind = void 0;
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const contracts_1 = require("../../contracts");
+const configuration_1 = require("../configuration");
+const Attributes_1 = require("../../contracts/Handlers/Attributes");
+const payload_codec_1 = require("../messaging/payload-codec");
+const actor_lifecycle_snapshot_1 = require("./actor-lifecycle-snapshot");
+const actor_join_deferred_scope_1 = require("./actor-join-deferred-scope");
+const handler_instance_scope_1 = require("../handlers/handler-instance-scope");
+var ZLinkActorPacketKind;
+(function (ZLinkActorPacketKind) {
+    ZLinkActorPacketKind["Send"] = "send";
+    ZLinkActorPacketKind["Request"] = "request";
+})(ZLinkActorPacketKind || (exports.ZLinkActorPacketKind = ZLinkActorPacketKind = {}));
+class ZLinkSpotActorHandlerRegistryRuntime {
+    packets = new Map();
+    addHandler(handlerType, packetName) {
+        const metadata = (0, Attributes_1.readZLinkDecoratorMetadata)(handlerType).find((entry) => entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest');
+        const resolvedPacketName = packetName ?? metadata?.packetName;
+        if (metadata === undefined || resolvedPacketName === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`Actor packet handler '${handlerType.name}' must declare a packet name.`);
+        }
+        return this.addPacket({
+            kind: metadata.kind === 'spotActorSend'
+                ? ZLinkActorPacketKind.Send
+                : ZLinkActorPacketKind.Request,
+            packetName: resolvedPacketName,
+            actorType: Object,
+            handlerType
+        });
+    }
+    addPacket(descriptor) {
+        const key = packetKey(descriptor.kind, descriptor.actorType, descriptor.packetName);
+        if (this.packets.has(key)) {
+            throw new configuration_1.ZLinkConfigurationException(`Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`);
+        }
+        this.packets.set(key, descriptor);
+        return this;
+    }
+    resolvePacket(kind, actor, packetName) {
+        const actorType = actor.constructor;
+        const exact = this.packets.get(packetKey(kind, actorType, packetName));
+        if (exact !== undefined) {
+            return exact;
+        }
+        const wildcard = this.packets.get(packetKey(kind, Object, packetName));
+        if (wildcard !== undefined) {
+            return wildcard;
+        }
+        for (const descriptor of this.packets.values()) {
+            if (descriptor.kind === kind
+                && descriptor.packetName === packetName
+                && actor instanceof descriptor.actorType) {
+                return descriptor;
+            }
+        }
+        return undefined;
+    }
+}
+exports.ZLinkSpotActorHandlerRegistryRuntime = ZLinkSpotActorHandlerRegistryRuntime;
+class ZLinkSpotActorDispatcher {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    dispatchSend(actor, packetName, message, context = {}) {
+        return this.dispatchSendDecoded(actor, packetName, () => message, context);
+    }
+    dispatchSendDecoded(actor, packetName, decode, context = {}) {
+        return this.execute(async () => {
+            const descriptor = this.requirePacket(ZLinkActorPacketKind.Send, actor, packetName);
+            const message = decode();
+            this.options.onHandlerStart?.();
+            await this.invokeHandler(actor, descriptor, (handler) => (0, actor_join_deferred_scope_1.runActorHandlerWithDeferredJoins)(() => handler.handle(this.options.spot, actor, this.createContext(packetName, context), message)));
+        });
+    }
+    dispatchRequest(actor, packetName, request, context = {}) {
+        return this.dispatchRequestThenDecoded(actor, packetName, () => request, context, (reply) => reply);
+    }
+    dispatchRequestDecoded(actor, packetName, decode, context = {}) {
+        return this.dispatchRequestThenDecoded(actor, packetName, decode, context, (reply) => reply);
+    }
+    dispatchRequestThen(actor, packetName, request, context = {}, afterReply, beforeReply) {
+        return this.dispatchRequestThenDecoded(actor, packetName, () => request, context, afterReply, beforeReply);
+    }
+    dispatchRequestThenDecoded(actor, packetName, decode, context = {}, afterReply, beforeReply) {
+        return this.execute(async () => {
+            const descriptor = this.requirePacket(ZLinkActorPacketKind.Request, actor, packetName);
+            const request = decode();
+            this.options.onHandlerStart?.();
+            return await this.invokeHandler(actor, descriptor, (handler) => (0, actor_join_deferred_scope_1.runActorHandlerWithDeferredJoins)(() => handler.handle(this.options.spot, actor, this.createContext(packetName, context), request), (reply) => afterReply(reply, {
+                metadata: new Map(),
+                compressPayload: false
+            }), beforeReply === undefined
+                ? undefined
+                : (reply) => beforeReply(reply, {
+                    metadata: new Map(),
+                    compressPayload: false
+                })));
+        });
+    }
+    admitActorJoin(actor, request, commit) {
+        return this.evaluateActorJoin(actor, request).then(async (result) => {
+            if (result.accepted) {
+                await this.commitActorJoin(actor, commit);
+            }
+            return result;
+        });
+    }
+    evaluateActorJoin(actor, request, contentType = 'application/json') {
+        return this.execute(async () => {
+            const payload = (0, payload_codec_1.wrapFrameworkPayloadMessage)(request, this.options.messageSerializers, contentType);
+            const onActorJoin = this.options.spot.onActorJoin;
+            return onActorJoin === undefined
+                ? { accepted: false }
+                : await onActorJoin.call(this.options.spot, (0, actor_lifecycle_snapshot_1.actorJoinIdentity)(actor), payload);
+        });
+    }
+    commitActorJoin(actor, commit) {
+        return this.execute(async () => {
+            await commit();
+            await this.options.spot.onJoinedActor(actor);
+        });
+    }
+    notifyJoinActor(actor) {
+        return this.execute(() => this.options.spot.onJoinedActor(actor));
+    }
+    notifyLeaveActor(actor) {
+        return this.execute(() => this.options.spot.onLeaveActor(actor));
+    }
+    notifyDisconnectActor(actor) {
+        return this.execute(() => this.options.spot.onDisconnectActor?.(actor));
+    }
+    requirePacket(kind, actor, packetName) {
+        const descriptor = this.options.registry.resolvePacket(kind, actor, packetName);
+        if (descriptor === undefined) {
+            throw actorDispatchHandlerNotFound(`No Spot actor ${kind} handler is registered for '${packetName}'.`);
+        }
+        this.ensureActorType(descriptor, actor);
+        return descriptor;
+    }
+    ensureActorType(descriptor, actor) {
+        if (descriptor.actorType === Object) {
+            return;
+        }
+        if (actor instanceof descriptor.actorType) {
+            return;
+        }
+        throw actorDispatchHandlerNotFound(`Actor handler '${descriptor.handlerType.name}' expects actor '${descriptor.actorType.name}'.`);
+    }
+    async invokeHandler(actor, descriptor, callback) {
+        return await (0, handler_instance_scope_1.runWithLifecycleHandler)(actor, descriptor.handlerType, this.options.providerResolver, (resolved) => callback(resolved));
+    }
+    execute(operation) {
+        const pending = this.options.serial?.execute(operation, this.options.serialWorkOptions)
+            ?? Promise.resolve().then(operation);
+        this.options.onAdmitted?.();
+        return pending;
+    }
+    createContext(packetName, context) {
+        return {
+            meshName: context.meshName,
+            channelName: context.channelName,
+            packetName,
+            contentType: context.contentType,
+            metadata: context.metadata ?? contracts_1.ZLinkMessageMetadataEmpty,
+            correlationId: context.correlationId
+        };
+    }
+}
+exports.ZLinkSpotActorDispatcher = ZLinkSpotActorDispatcher;
+function packetKey(kind, actorType, packetName) {
+    return `${kind}:${actorType.name}:${packetName}`;
+}
+function actorDispatchHandlerNotFound(message) {
+    return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound, message);
+}

package/dist/runtime/actors/transferred-actor-rollback.d.ts

@@ -0,0 +1,16 @@
+import type { ZLinkActor } from '../../contracts';
+import type { ZLinkActorManagerOptions } from './actor-runtime-contracts';
+import type { ZLinkActorRuntimeState } from './actor-runtime-state';
+type ZLinkTransferredActorRollbackOptions = Pick<ZLinkActorManagerOptions, 'actorDestroyedCleanup' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'nativeActorCompletionTableProvider' | 'shutdownSignal' | 'metrics'>;
+export declare class ZLinkTransferredActorRollbackCoordinator {
+    private readonly states;
+    private readonly options;
+    private readonly tasks;
+    constructor(states: Map<string, ZLinkActorRuntimeState>, options: ZLinkTransferredActorRollbackOptions);
+    rollback(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
+    private schedule;
+    private retry;
+    private destroyNativeActor;
+    private complete;
+}
+export {};

package/dist/runtime/actors/transferred-actor-rollback.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkTransferredActorRollbackCoordinator = void 0;
+const backend_1 = require("../backend");
+const runtime_values_1 = require("../backend/runtime-values");
+const actor_retry_delay_1 = require("./actor-retry-delay");
+class ZLinkTransferredActorRollbackCoordinator {
+    states;
+    options;
+    tasks = new Map();
+    constructor(states, options) {
+        this.states = states;
+        this.options = options;
+    }
+    async rollback(actor, signal) {
+        const state = this.states.get(actor.context.actorId);
+        if (state?.actor !== actor) {
+            return;
+        }
+        state.clearJoinedSpot();
+        if (!state.isMoving) {
+            state.beginMove();
+        }
+        const actorRef = state.nativeActorRef;
+        const node = this.options.nativeActorNode ?? this.options.nativeActorNodeProvider?.();
+        try {
+            if (node !== undefined && actorRef !== undefined) {
+                await this.destroyNativeActor(node, actorRef, signal);
+            }
+        }
+        catch (error) {
+            this.schedule(actor, state, node, actorRef);
+            throw error;
+        }
+        this.complete(actor, state);
+    }
+    schedule(actor, state, node, actorRef) {
+        if (this.tasks.has(actor.context.actorId)) {
+            return;
+        }
+        const task = this.retry(actor, state, node, actorRef)
+            .finally(() => this.tasks.delete(actor.context.actorId));
+        this.tasks.set(actor.context.actorId, task);
+    }
+    async retry(actor, state, node, actorRef) {
+        const retryDelay = new actor_retry_delay_1.ZLinkActorRetryDelay();
+        while (this.states.get(actor.context.actorId) === state && this.options.shutdownSignal?.aborted !== true) {
+            if (!await retryDelay.wait(this.options.shutdownSignal))
+                return;
+            try {
+                if (node !== undefined && actorRef !== undefined) {
+                    await this.destroyNativeActor(node, actorRef);
+                }
+                this.complete(actor, state);
+                return;
+            }
+            catch {
+                // The tombstone prevents dispatch while the next retry is pending.
+            }
+        }
+    }
+    async destroyNativeActor(node, actorRef, signal) {
+        const completions = this.options.nativeActorCompletionTableProvider?.();
+        if (completions === undefined) {
+            throw new Error('Actor rollback requires a running MeshNode completion table.');
+        }
+        const completion = await completions.submit(() => node.destroyActor({
+            nodeRid: actorRef.nodeRid,
+            actorId: actorRef.actorId,
+            generation: actorRef.generation
+        }), signal);
+        try {
+            if (completion.terminalResult !== runtime_values_1.RequestResult.Ok) {
+                throw new Error(`Actor rollback destroy failed with '${completion.terminalResult}' (errno ${completion.failureErrno}).`);
+            }
+        }
+        finally {
+            (0, backend_1.closeMeshCompletion)(completion);
+        }
+    }
+    complete(actor, state) {
+        if (this.states.get(actor.context.actorId) !== state) {
+            return;
+        }
+        this.options.actorDestroyedCleanup?.(actor.context.actorId);
+        state.clearAfterDestroy();
+        this.states.delete(actor.context.actorId);
+        this.options.metrics?.change('zlink.actor.count', -1);
+    }
+}
+exports.ZLinkTransferredActorRollbackCoordinator = ZLinkTransferredActorRollbackCoordinator;

package/dist/runtime/admission.d.ts

@@ -0,0 +1,20 @@
+import { ZLinkFrameworkInternalErrorKind } from './framework-errors-internal';
+export declare class ZLinkRuntimeAdmissionGate {
+    private readonly meshes;
+    get acceptsNewWork(): boolean;
+    register(meshName: string): void;
+    accepts(meshName: string): boolean;
+    pending(meshName: string): number;
+    seal(meshName: string, reason?: ZLinkFrameworkInternalErrorKind): void;
+    close(): void;
+    claim(meshName: string, operation: string): ZLinkApplicationWorkClaim;
+    run<T>(meshName: string, operation: string, work: () => Promise<T>): Promise<T>;
+    awaitZero(meshName: string, signal?: AbortSignal): Promise<void>;
+    requireRequest(operation: string, meshName?: string): void;
+    requireActorCreate(actorId: string, meshName?: string): void;
+    private requireState;
+    private firstSealedReason;
+}
+export interface ZLinkApplicationWorkClaim {
+    close(): void;
+}