@zlink-systems/framework 0.10.0

package/dist/runtime/foundation/service-runtime-contracts.d.ts

@@ -0,0 +1,332 @@
+import type { Message } from '../../contracts/Common/Message';
+import type { RequestResult, SubmitResult, ZLinkBackendMessageLike as MessageLike } from '../backend/runtime-values';
+import type { RoutingId } from '../../contracts';
+import type { ApplicationJobPermitPort } from '../application-jobs/contracts';
+import type { ServiceActorRef } from './service-stateful-registry';
+import type { ServiceDirectSpotRouteFence, ServiceRetiredBoundSessionRouteFence } from './service-stateful-wire-codec';
+export interface MeshOperationId {
+    readonly high: bigint;
+    readonly low: bigint;
+}
+export interface ActorTransferId {
+    readonly high: bigint;
+    readonly low: bigint;
+}
+export declare const ReadyDomain: Readonly<{
+    readonly None: 0;
+    readonly Application: 1;
+    readonly Infrastructure: 2;
+    readonly All: 3;
+}>;
+export declare const ReadyOwnerKind: Readonly<{
+    readonly Node: 1;
+    readonly Spot: 2;
+    readonly Actor: 3;
+}>;
+export declare const ReceiveKind: Readonly<{
+    readonly NodeSend: 1;
+    readonly NodeRequest: 2;
+    readonly ChannelSend: 3;
+    readonly ChannelRequest: 4;
+    readonly SpotSend: 5;
+    readonly SpotRequest: 6;
+    readonly SpotMulticast: 7;
+    readonly SpotControl: 8;
+    readonly ActorSend: 9;
+    readonly ActorRequest: 10;
+    readonly Completion: 11;
+    readonly SendReady: 12;
+    readonly TransferControl: 13;
+    readonly InstanceSpotActivation: 14;
+    readonly ActorBinding: 15;
+}>;
+export declare const OperationKind: Readonly<{
+    readonly NodeRequest: 1;
+    readonly ChannelRequest: 2;
+    readonly SpotRequest: 3;
+    readonly ActorRequest: 4;
+    readonly ActorLookup: 5;
+    readonly ActorDestroy: 6;
+    readonly ActorJoin: 7;
+    readonly ActorLeave: 8;
+    readonly StreamBind: 9;
+    readonly StreamUnbind: 10;
+    readonly StreamClose: 11;
+    readonly InstanceSpotRequest: 12;
+    readonly UserSpotCreate: 13;
+    readonly UserSpotClose: 14;
+}>;
+export declare function operationRequiresReply(operationKind: number): boolean;
+export declare const ActorLifecycleKind: Readonly<{
+    readonly Created: 1;
+    readonly Joined: 2;
+    readonly Left: 3;
+    readonly Disconnected: 4;
+    readonly Destroyed: 5;
+}>;
+export declare const ActorTransferRole: Readonly<{
+    readonly Source: 1;
+    readonly Target: 2;
+}>;
+export declare const ActorTransferPhase: Readonly<{
+    readonly Preparing: 1;
+    readonly Fenced: 2;
+    readonly Committed: 3;
+    readonly Activated: 4;
+    readonly Aborted: 5;
+}>;
+export interface ActorLocation {
+    readonly actor: ServiceActorRef;
+    readonly spotId: RoutingId | null;
+    readonly spotGeneration: bigint;
+    readonly membershipEpoch: bigint;
+}
+export interface ActorControlPayload {
+    readonly kind: 'actorControl';
+    readonly lifecycleKind: number;
+    readonly previousActor: ServiceActorRef | null;
+    readonly currentActor: ServiceActorRef | null;
+    readonly previousSpotId: RoutingId | null;
+    readonly currentSpotId: RoutingId | null;
+    readonly previousSpotGeneration: bigint;
+    readonly currentSpotGeneration: bigint;
+    readonly previousMembershipEpoch: bigint;
+    readonly currentMembershipEpoch: bigint;
+    readonly resultCode: number;
+    /**
+     * Command 28 arrived as the canonical service-wire multipart form.  The
+     * raw transport owns decoding; the framework uses this retained fence only
+     * to run the spec 51 Store-backed type admission before dispatch.
+     */
+    readonly canonicalActorJoin?: {
+        readonly handoffId: string;
+        readonly actorNodeRid: string;
+        readonly actorGeneration: bigint;
+        readonly actorNodeGeneration: bigint;
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+    };
+}
+export interface ActorJoinCompletionPayload {
+    readonly kind: 'actorJoinCompletion';
+    readonly joinResult: number;
+    readonly actor: ServiceActorRef | null;
+    readonly location: ActorLocation;
+    /** Target's advertised relocation state chunk cap from the accepted admission reply. 0/undefined = not advertised. */
+    readonly receiveChunkLimitBytes?: number;
+    /** Exact application payload content type retained for canonical recovery. */
+    readonly replyContentType?: string;
+    /** Present only when this operation was emitted as canonical command 28. */
+    readonly canonicalHandoffId?: string;
+}
+export interface ActorLookupCompletionPayload {
+    readonly kind: 'actorLookupCompletion';
+    readonly location: ActorLocation;
+}
+export interface SendReadyPayload {
+    readonly kind: 'sendReady';
+    readonly destinationKind: number;
+    readonly targetNodeRid: RoutingId | null;
+    readonly targetSpotId: RoutingId | null;
+    readonly targetActor: ServiceActorRef | null;
+    readonly channelName: string | null;
+}
+export interface ActorTransferControlPayload {
+    readonly kind: 'transferControl';
+    readonly phase: number;
+    readonly role: number;
+    readonly transferId: ActorTransferId;
+    readonly actor: ServiceActorRef | null;
+    readonly membershipEpoch: bigint;
+    readonly finalSequence: bigint;
+    readonly resultCode: number;
+    readonly failureErrno: number;
+}
+export interface ActorBindingControlPayload {
+    readonly kind: 'actorBinding';
+    readonly transition: 'active' | 'tombstone';
+    readonly actor: ServiceActorRef;
+    readonly actorNodeGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly ownerLeaseGeneration: bigint;
+    readonly bindingGeneration: bigint;
+    readonly sessionNodeRid: RoutingId;
+    readonly sessionRid: RoutingId;
+    readonly sessionOwnerNodeGeneration: bigint;
+    readonly sessionOwnerId: string;
+    readonly sessionOwnerLeaseGeneration: bigint;
+}
+export type ReceiveKindData = ActorControlPayload | ActorJoinCompletionPayload | ActorLookupCompletionPayload | SendReadyPayload | ActorTransferControlPayload | ActorBindingControlPayload;
+export interface ReadyRecord {
+    readonly ownerKind: number;
+    readonly domain: number;
+    readonly spotId: RoutingId | null;
+    readonly actor: ServiceActorRef | null;
+    /** True only for a terminal reply/error completion supply. */
+    readonly terminalCompletion?: boolean;
+    /** Raw ingress already reserved its host permit before the Core receive. */
+    readonly ordinaryIngressPreAdmitted?: boolean;
+}
+export interface ReceiveRequirements {
+    readonly messageCount: number;
+    readonly partCount: number;
+    readonly byteCount: number;
+}
+export interface ZLinkMessageFollowOrigin {
+    readonly sourceNodeRid: RoutingId;
+    readonly originalOperation: MeshOperationId;
+    readonly originalReplyRouteId: bigint;
+}
+export interface ReceiveRecord {
+    readonly kind: number;
+    readonly domain: number;
+    readonly sourceNodeRid: RoutingId | null;
+    readonly sourceSpotId: RoutingId | null;
+    readonly sourceBindingGeneration: bigint;
+    readonly sourceActor: ServiceActorRef | null;
+    readonly operationId: MeshOperationId;
+    readonly operationKind: number;
+    readonly channelName: string | null;
+    readonly topic: string | null;
+    readonly applicationMetadata: Buffer | null;
+    readonly packetName?: string;
+    readonly contentType?: string;
+    readonly kindData: ReceiveKindData | null;
+    readonly terminalResult: number;
+    readonly failureErrno: number;
+    readonly parts: Message[];
+    /** Returns whether the local operation can still accept a lifecycle reply. */
+    readonly isPending?: () => boolean;
+    /** Absolute deadline used by the local lifecycle dispatch fence. */
+    readonly deadlineUnixMs?: bigint;
+    readonly messageFollowOrigin?: ZLinkMessageFollowOrigin;
+    readonly onTerminalCompletion?: () => void | Promise<void>;
+    readonly applicationJobPermit?: ApplicationJobPermitPort;
+    readonly releaseRetainedIngress?: () => void;
+    reply(parts: MessageLike | readonly MessageLike[], flags?: number): SubmitResult;
+    replyActorJoin(joinResult: number, parts: MessageLike | readonly MessageLike[], flags?: number, replyContentType?: string): SubmitResult;
+    /** Emits a typed command-20 terminal for a lifecycle request before admission. */
+    replyFailure?(terminalResult: number, failureCode: number): SubmitResult;
+}
+export interface ClaimReceiveResult {
+    readonly ok: boolean;
+    readonly required?: ReceiveRequirements;
+    readonly records: ReceiveRecord[];
+}
+export interface Claim {
+    recvBatch(batch: ReceiveBatch, flags?: number): ClaimReceiveResult;
+    release(): void;
+}
+export interface ReadyBatch {
+    readonly records: ReadyRecord[];
+    takeClaim(index: number): Claim;
+    reset(): void;
+    close(): void;
+}
+export interface ReceiveBatch {
+    reset(): void;
+    close(): void;
+}
+export interface MeshNodeStatus {
+    readonly state: number;
+    readonly routingId: RoutingId;
+    readonly meshName: string;
+    readonly localEndpoint: string;
+    readonly lifecycleGeneration: bigint;
+    readonly descriptorRevision: bigint;
+    readonly channelCount: number;
+    readonly configuredPeerCount: number;
+    readonly admittedPeerCount: number;
+    readonly drainingPeerCount: number;
+    readonly pendingApplicationMessages: bigint;
+    readonly pendingInfrastructureMessages: bigint;
+    readonly pendingBytes: bigint;
+    readonly lastError: number;
+    readonly lastChangedMs: bigint;
+}
+export interface MeshPeerEntry {
+    readonly connectionIntentId: bigint;
+    readonly source: number;
+    readonly state: number;
+    readonly routingId: RoutingId | null;
+    readonly lifecycleGeneration: bigint;
+    readonly descriptorRevision: bigint;
+    readonly endpoint: string;
+    readonly channelCount: number;
+    readonly lastError: number;
+    readonly lastChangedMs: bigint;
+}
+export interface StreamSessionStatus {
+    readonly state: number;
+    readonly lifecycleGeneration: bigint;
+    readonly sessionCount: bigint;
+    readonly bindingCount: bigint;
+    readonly pendingMessageCount: bigint;
+    readonly pendingByteCount: bigint;
+    readonly lastError: number;
+}
+export interface StreamSessionActorAuthorityFence {
+    readonly targetNodeGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly ownerLeaseGeneration: bigint;
+}
+export interface StreamSessionService {
+    start(): void;
+    shutdown(timeoutMs: number): RequestResult;
+    close(): void;
+    status(): StreamSessionStatus;
+    lookupActor(targetNodeRid: RoutingId, actorId: string, timeoutMs?: number): MeshOperationId;
+    bindActor(sessionRid: RoutingId, actor: ServiceActorRef, timeoutMs?: number, onBindingReplaced?: (actorId: string, retiredSession: ServiceRetiredBoundSessionRouteFence, actor: ServiceActorRef) => void, actorAuthority?: StreamSessionActorAuthorityFence): MeshOperationId;
+    unbindActor(sessionRid: RoutingId, actor: ServiceActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
+    bindings(sessionRid: RoutingId): ReadonlyArray<{
+        readonly sessionRid: RoutingId;
+        readonly actor: ServiceActorRef;
+        readonly bindingGeneration: bigint;
+        readonly membershipEpoch: bigint;
+    }>;
+    sendToActor(sessionRid: RoutingId, actor: ServiceActorRef, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+    }): Promise<SubmitResult>;
+}
+export interface MeshPublisher {
+    publish(channelName: string, topic: string, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+    }): Promise<void>;
+    publishAsync(channelName: string, topic: string, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+    }, signal?: AbortSignal): Promise<void>;
+    close(): void;
+}
+export interface ServiceSpot {
+    readonly routingId: RoutingId | null;
+    status(): {
+        readonly routingId: RoutingId;
+        readonly lifecycleGeneration: bigint;
+    };
+    sendToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+    }): Promise<SubmitResult>;
+    requestToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+        timeoutMs?: number;
+        applicationMetadata?: Buffer;
+    }): MeshOperationId;
+    sendToSpot(targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+        routeFence?: ServiceDirectSpotRouteFence;
+        entrySpot?: boolean;
+    }): Promise<SubmitResult>;
+    requestToSpot(targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+        timeoutMs?: number;
+        applicationMetadata?: Buffer;
+        routeFence?: ServiceDirectSpotRouteFence;
+        entrySpot?: boolean;
+    }): MeshOperationId;
+    publish(channelName: string, topic: string, parts: MessageLike | readonly MessageLike[], options?: {
+        flags?: number;
+    }): Promise<void>;
+    setSubscription(channelName: string, topicFilter: string, kind?: number): void;
+    unsetSubscription(channelName: string, topicFilter: string, kind?: number): void;
+    close(): void;
+}

package/dist/runtime/foundation/service-runtime-contracts.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActorTransferPhase = exports.ActorTransferRole = exports.ActorLifecycleKind = exports.OperationKind = exports.ReceiveKind = exports.ReadyOwnerKind = exports.ReadyDomain = void 0;
+exports.operationRequiresReply = operationRequiresReply;
+exports.ReadyDomain = Object.freeze({
+    None: 0,
+    Application: 1,
+    Infrastructure: 2,
+    All: 3
+});
+exports.ReadyOwnerKind = Object.freeze({ Node: 1, Spot: 2, Actor: 3 });
+exports.ReceiveKind = Object.freeze({
+    NodeSend: 1,
+    NodeRequest: 2,
+    ChannelSend: 3,
+    ChannelRequest: 4,
+    SpotSend: 5,
+    SpotRequest: 6,
+    SpotMulticast: 7,
+    SpotControl: 8,
+    ActorSend: 9,
+    ActorRequest: 10,
+    Completion: 11,
+    SendReady: 12,
+    TransferControl: 13,
+    InstanceSpotActivation: 14,
+    ActorBinding: 15
+});
+exports.OperationKind = Object.freeze({
+    NodeRequest: 1,
+    ChannelRequest: 2,
+    SpotRequest: 3,
+    ActorRequest: 4,
+    ActorLookup: 5,
+    ActorDestroy: 6,
+    ActorJoin: 7,
+    ActorLeave: 8,
+    StreamBind: 9,
+    StreamUnbind: 10,
+    StreamClose: 11,
+    InstanceSpotRequest: 12,
+    UserSpotCreate: 13,
+    UserSpotClose: 14
+});
+function operationRequiresReply(operationKind) {
+    return operationKind === exports.OperationKind.NodeRequest
+        || operationKind === exports.OperationKind.ChannelRequest
+        || operationKind === exports.OperationKind.SpotRequest
+        || operationKind === exports.OperationKind.ActorRequest
+        || operationKind === exports.OperationKind.InstanceSpotRequest;
+}
+exports.ActorLifecycleKind = Object.freeze({
+    Created: 1,
+    Joined: 2,
+    Left: 3,
+    Disconnected: 4,
+    Destroyed: 5
+});
+exports.ActorTransferRole = Object.freeze({ Source: 1, Target: 2 });
+exports.ActorTransferPhase = Object.freeze({
+    Preparing: 1,
+    Fenced: 2,
+    Committed: 3,
+    Activated: 4,
+    Aborted: 5
+});

package/dist/runtime/foundation/service-session-binding-ingress-port.d.ts

@@ -0,0 +1,23 @@
+export interface ServiceSessionBindingRetainedDelivery {
+    deliver(): Promise<boolean>;
+    fail(error: unknown): void;
+}
+export interface ServiceSessionBindingAdmissionClaim {
+    readonly actorId: string;
+    readonly objectGeneration: bigint;
+    readonly actorNodeRid: string;
+    readonly actorNodeGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly ownerLeaseGeneration: bigint;
+    readonly producerNodeRid: string;
+    readonly producerNodeGeneration: bigint;
+    readonly sessionIdentity: string;
+    readonly bindingGeneration: bigint;
+}
+export type ServiceSessionBindingAdmissionResult = 'passThrough' | 'retained' | 'rejected';
+export interface ServiceSessionBindingIngressPort {
+    retainOutbound(claim: ServiceSessionBindingAdmissionClaim, delivery: ServiceSessionBindingRetainedDelivery): Promise<ServiceSessionBindingAdmissionResult>;
+    clearOutbound(actorId: string, error: unknown): Promise<void>;
+}
+export declare function registerServiceSessionBindingIngressPort(service: object, port: ServiceSessionBindingIngressPort): void;
+export declare function serviceSessionBindingIngressPortIfRegistered(service: object): ServiceSessionBindingIngressPort | undefined;

package/dist/runtime/foundation/service-session-binding-ingress-port.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerServiceSessionBindingIngressPort = registerServiceSessionBindingIngressPort;
+exports.serviceSessionBindingIngressPortIfRegistered = serviceSessionBindingIngressPortIfRegistered;
+const ports = new WeakMap();
+function registerServiceSessionBindingIngressPort(service, port) {
+    ports.set(service, port);
+}
+function serviceSessionBindingIngressPortIfRegistered(service) {
+    return ports.get(service);
+}

package/dist/runtime/foundation/service-stateful-registry.d.ts

@@ -0,0 +1,142 @@
+import { OperationRegistry, type PendingOperation } from './operation-registry';
+export type ServiceSpotKind = 'entry' | 'user' | 'instance';
+export interface ServiceSpotRef {
+    readonly spotId: string;
+    readonly generation: bigint;
+}
+export interface ServiceActorRef {
+    readonly nodeRid: string;
+    readonly actorId: string;
+    readonly generation: bigint;
+}
+interface ServiceSpotStateBase {
+    readonly ref: ServiceSpotRef;
+    readonly stableType: string;
+    readonly authorityOwnerGeneration: bigint;
+    readonly state: 'ready' | 'closing';
+}
+export interface ServiceEntrySpotState extends ServiceSpotStateBase {
+    readonly kind: 'entry';
+    readonly stableType: 'entry';
+    readonly state: 'ready';
+}
+export interface ServiceUserSpotState extends ServiceSpotStateBase {
+    readonly kind: 'user';
+}
+export interface ServiceInstanceSpotState extends ServiceSpotStateBase {
+    readonly kind: 'instance';
+}
+export type ServiceSpotState = ServiceEntrySpotState | ServiceUserSpotState | ServiceInstanceSpotState;
+export interface ServiceActorState {
+    readonly ref: ServiceActorRef;
+    readonly authorityOwnerGeneration: bigint;
+    readonly spot: ServiceSpotRef;
+    readonly membershipEpoch: bigint;
+}
+export interface ServiceSessionBinding {
+    readonly actor: ServiceActorRef;
+    readonly sessionRid: string;
+    readonly sessionOwnerNodeRid: string;
+    /** Lifecycle/lease fence of the session owner, when supplied by the owner. */
+    readonly sessionOwnerNodeGeneration?: bigint;
+    readonly sessionOwnerId?: string;
+    readonly sessionOwnerLeaseGeneration?: bigint;
+    readonly bindingGeneration: bigint;
+    readonly membershipEpoch: bigint;
+}
+export interface ServiceObjectReservation {
+    readonly id: bigint;
+    readonly objectKind: 'actor' | 'userSpot' | 'instanceSpot';
+    readonly key: string;
+    readonly stableType: string;
+    readonly generation: bigint;
+    readonly attempt: bigint;
+}
+export type ServiceReservationResult = {
+    readonly kind: 'reserved';
+    readonly reservation: ServiceObjectReservation;
+} | {
+    readonly kind: 'existing';
+    readonly spot?: ServiceSpotState;
+    readonly actor?: ServiceActorState;
+} | {
+    readonly kind: 'typeMismatch';
+} | {
+    readonly kind: 'attemptStale';
+};
+export interface ServiceMembershipTransition {
+    readonly actor: ServiceActorState;
+    readonly previousSpot: ServiceSpotRef;
+    readonly currentSpot: ServiceSpotRef;
+    readonly previousMembershipEpoch: bigint;
+    readonly currentMembershipEpoch: bigint;
+}
+export declare class ServiceStaleGenerationError extends Error {
+    readonly objectKind: 'actor' | 'spot' | 'binding';
+    readonly key: string;
+    constructor(objectKind: 'actor' | 'spot' | 'binding', key: string);
+}
+/**
+ * Owns the stateful identity and fencing rules that used to be split across
+ * Core service tables. Network transport and application materialization stay
+ * outside this module.
+ */
+export declare class ServiceStatefulRegistry {
+    readonly nodeRid: string;
+    readonly nodeGeneration: bigint;
+    private readonly spots;
+    private readonly spotTypes;
+    private readonly actors;
+    private readonly actorTypes;
+    private readonly bindings;
+    private readonly reservations;
+    private readonly spotGenerations;
+    private readonly actorGenerations;
+    private readonly reservationAttempts;
+    private readonly turns;
+    private nextReservationId;
+    private nextBindingGeneration;
+    constructor(nodeRid: string, nodeGeneration: bigint);
+    createEntrySpot(spotId?: string): ServiceSpotState;
+    private createEntrySpotCore;
+    createSpot(spotId: string, kind?: Exclude<ServiceSpotKind, 'entry'>, stableType?: string): ServiceSpotState;
+    private createSpotCore;
+    spot(spotId: string): ServiceSpotState | undefined;
+    restoreSpot(ref: ServiceSpotRef, kind: ServiceSpotKind, stableType: string, authorityOwnerGeneration: bigint): ServiceSpotState;
+    private restoreSpotCore;
+    requireSpot(ref: ServiceSpotRef): ServiceSpotState;
+    private requireSpotCore;
+    closeSpot(ref: ServiceSpotRef): boolean;
+    createActor(actorId: string, stableType?: string, initialSpot?: ServiceSpotRef): ServiceActorState;
+    private createActorCore;
+    restoreActor(actor: ServiceActorRef, stableType: string, spot: ServiceSpotRef, membershipEpoch: bigint, authorityOwnerGeneration?: bigint): ServiceActorState;
+    actor(actorId: string): ServiceActorState | undefined;
+    requireActor(ref: ServiceActorRef): ServiceActorState;
+    private requireActorCore;
+    joinActor(actor: ServiceActorRef, target: ServiceSpotRef): ServiceMembershipTransition;
+    private joinActorCore;
+    leaveActor(actor: ServiceActorRef, expectedMembershipEpoch: bigint): ServiceMembershipTransition;
+    destroyActor(actor: ServiceActorRef): ServiceActorState;
+    bindSession(actor: ServiceActorRef, sessionRid: string, sessionOwnerNodeRid: string, sessionOwnerNodeGeneration?: bigint, sessionOwnerId?: string, sessionOwnerLeaseGeneration?: bigint): ServiceSessionBinding;
+    installSessionBinding(binding: ServiceSessionBinding): void;
+    binding(actor: ServiceActorRef): ServiceSessionBinding | undefined;
+    private bindingCore;
+    unbindSession(actor: ServiceActorRef, expectedBindingGeneration: bigint, expectedSessionRid?: string, expectedSessionOwnerNodeRid?: string): boolean;
+    validateBoundSession(actor: ServiceActorRef, expectedBindingGeneration: bigint): ServiceSessionBinding;
+    reserve(objectKind: ServiceObjectReservation['objectKind'], key: string, stableType: string, attempt: bigint): ServiceReservationResult;
+    commitReservation(reservation: ServiceObjectReservation): ServiceSpotState | ServiceActorState;
+    abortReservation(reservation: ServiceObjectReservation): boolean;
+    runTurn<T>(owner: string, work: () => T | Promise<T>): Promise<T>;
+    private updateBindingMembership;
+}
+export declare class ServiceTerminalOperationRegistry<T> {
+    private readonly operations;
+    constructor(operations?: OperationRegistry<T>);
+    reserve(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
+    reply(id: bigint, value: T): boolean;
+    fail(id: bigint, error: unknown): boolean;
+    cancel(id: bigint): boolean;
+    isPending(id: bigint): boolean;
+    close(): void;
+}
+export {};