@zlink-systems/framework 0.10.0

package/dist/runtime/backend/node/node-raw-binding-port.d.ts

@@ -0,0 +1,8 @@
+import { type Context } from '@zlink-systems/zlink';
+import type { ZLinkRawBindingPort, ZLinkRawHostPort } from '../raw-binding-port';
+export type { ZLinkRawBindingPort, ZLinkRawDealerPort, ZLinkRawHostPort, ZLinkRawMonitorPort, ZLinkRawMonitorRecord, ZLinkRawReceivedRecord, ZLinkRawRouterPort, ZLinkRawSocketPort } from '../raw-binding-port';
+export declare class ZLinkNodeRawBindingPort implements ZLinkRawBindingPort {
+    private readonly sharedContext?;
+    constructor(sharedContext?: Context | undefined);
+    createHost(): ZLinkRawHostPort;
+}

package/dist/runtime/backend/node/node-raw-binding-port.js

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkNodeRawBindingPort = void 0;
+const zlink_1 = require("@zlink-systems/zlink");
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
+const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
+class ZLinkNodeRawBindingPort {
+    sharedContext;
+    constructor(sharedContext) {
+        this.sharedContext = sharedContext;
+    }
+    createHost() {
+        return new NodeRawHostPort(this.sharedContext ?? (0, zlink_1.createContext)(), this.sharedContext === undefined);
+    }
+}
+exports.ZLinkNodeRawBindingPort = ZLinkNodeRawBindingPort;
+class NodeRawHostPort {
+    context;
+    ownsContext;
+    resources = [];
+    state = 'open';
+    constructor(context, ownsContext) {
+        this.context = context;
+        this.ownsContext = ownsContext;
+    }
+    createRouter() {
+        this.requireOpen();
+        return this.own(new NodeRawRouterPort((0, zlink_1.createRouterSocket)(this.context)));
+    }
+    createDealer() {
+        this.requireOpen();
+        return this.own(new NodeRawDealerPort((0, zlink_1.createDealerSocket)(this.context)));
+    }
+    shutdown() {
+        if (this.state !== 'open')
+            return;
+        this.state = 'stopping';
+        if (this.ownsContext)
+            this.context.shutdown();
+    }
+    close() {
+        if (this.state === 'closed')
+            return;
+        this.state = 'stopping';
+        const failures = [];
+        for (const resource of this.resources.splice(0).reverse()) {
+            try {
+                resource.close();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        if (this.ownsContext) {
+            try {
+                this.context.close();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        this.state = 'closed';
+        if (failures.length > 0) {
+            throw new AggregateError(failures, 'Raw binding host cleanup failed.');
+        }
+    }
+    own(resource) {
+        this.resources.push(resource);
+        return resource;
+    }
+    requireOpen() {
+        if (this.state !== 'open') {
+            throw new Error('Raw binding host no longer accepts new resources.');
+        }
+    }
+}
+class NodeRawSocketPort {
+    socket;
+    endpoints = new Set();
+    monitors = new Set();
+    readablePoller = (0, zlink_1.createPoller)();
+    readableEvents = (0, zlink_1.createPollEvents)(1);
+    closed = false;
+    constructor(socket) {
+        this.socket = socket;
+        this.readablePoller.add(socket, [zlink_1.PollEventFlag.PollIn], 0);
+    }
+    bind(endpoint) {
+        this.requireOpen();
+        this.socket.bind(endpoint);
+        this.endpoints.add(`bind\0${endpoint}`);
+    }
+    unbind(endpoint) {
+        this.requireOpen();
+        this.socket.unbind(endpoint);
+        this.endpoints.delete(`bind\0${endpoint}`);
+    }
+    connect(endpoint) {
+        this.requireOpen();
+        connectable(this.socket).connect(endpoint);
+        this.endpoints.add(`connect\0${endpoint}`);
+    }
+    disconnect(endpoint) {
+        this.requireOpen();
+        connectable(this.socket).disconnect(endpoint);
+        this.endpoints.delete(`connect\0${endpoint}`);
+    }
+    setReceiveFlowState(state) {
+        this.requireOpen();
+        this.socket.setReceiveFlowState(state === 'paused' ? zlink_1.ReceiveFlowState.PAUSED : zlink_1.ReceiveFlowState.RUNNING);
+    }
+    monitor() {
+        this.requireOpen();
+        const nativeMonitor = this.socket.monitorOpen();
+        const port = new NodeRawMonitorPort(nativeMonitor, () => this.monitors.delete(port));
+        this.monitors.add(port);
+        return port;
+    }
+    close() {
+        if (this.closed)
+            return;
+        const failures = [];
+        for (const monitor of [...this.monitors].reverse()) {
+            try {
+                monitor.close();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        for (const value of [...this.endpoints].reverse()) {
+            const separator = value.indexOf('\0');
+            const kind = value.slice(0, separator);
+            const endpoint = value.slice(separator + 1);
+            try {
+                if (kind === 'bind')
+                    this.socket.unbind(endpoint);
+                else
+                    connectable(this.socket).disconnect(endpoint);
+            }
+            catch (error) {
+                if ((0, node_socket_backend_adapter_1.isEndpointCloseIgnorableError)(error))
+                    continue;
+                failures.push(error);
+            }
+        }
+        this.endpoints.clear();
+        try {
+            this.readablePoller.remove(this.socket);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            this.readableEvents.close();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            this.readablePoller.close();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            this.socket.close();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        this.closed = true;
+        if (failures.length > 0) {
+            console.error('Raw socket cleanup causes:', failures);
+            throw new AggregateError(failures, 'Raw socket cleanup failed.');
+        }
+    }
+    requireOpen() {
+        if (this.closed)
+            throw new Error('Raw socket is closed.');
+    }
+    receiveRecord(dontWait) {
+        const timeoutMs = dontWait ? 0 : -1;
+        try {
+            if (this.readablePoller.wait(this.readableEvents, timeoutMs) <= 0
+                || !this.readableEvents.hasEvent(0, zlink_1.PollEventFlag.PollIn)) {
+                return undefined;
+            }
+        }
+        catch (error) {
+            if ((0, node_backend_adapter_support_1.isPollerInterruptedError)(error))
+                return undefined;
+            throw error;
+        }
+        return receiveRecord(this.socket, true);
+    }
+}
+class NodeRawRouterPort extends NodeRawSocketPort {
+    nextIncomingRequestSequence = 1n;
+    disconnectRid(routingId) {
+        this.requireOpen();
+        this.socket.disconnectRid(bindingRoutingId(routingId));
+    }
+    constructor(socket) {
+        super(socket);
+        socket.options.handover = true;
+        socket.options.mandatory = true;
+        socket.options.probe = true;
+    }
+    localEndpoint() {
+        this.requireOpen();
+        return this.socket.options.lastEndpoint;
+    }
+    setRoutingId(routingId) {
+        this.requireOpen();
+        this.socket.setRoutingId(bindingRoutingId(routingId));
+    }
+    connectToRoutingId(routingId, endpoint) {
+        this.requireOpen();
+        this.socket.options.setConnectRoutingId(bindingRoutingId(routingId));
+        this.connect(endpoint);
+    }
+    async send(targetRid, parts) {
+        this.requireOpen();
+        await appendSendParts(this.socket.send(bindingRoutingId(targetRid)), parts).submit();
+    }
+    async request(targetRid, parts, timeoutMs) {
+        this.requireOpen();
+        try {
+            const replies = await appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
+                .timeout(timeoutMs)
+                .submit();
+            return copyAndClose(replies);
+        }
+        catch (error) {
+            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error);
+        }
+    }
+    receive(dontWait = false) {
+        this.requireOpen();
+        return receiveRecord(this.socket, dontWait, () => {
+            const current = this.nextIncomingRequestSequence;
+            this.nextIncomingRequestSequence = current === BigInt(Number.MAX_SAFE_INTEGER)
+                ? 1n
+                : current + 1n;
+            return current;
+        }, (targetRid, replyToken, parts) => {
+            appendReplyParts(this.socket.reply(bindingRoutingId(targetRid), replyToken), parts).submit();
+        });
+    }
+}
+class NodeRawDealerPort extends NodeRawSocketPort {
+    constructor(socket) {
+        super(socket);
+    }
+    setRoutingId(routingId) {
+        this.requireOpen();
+        this.socket.setRoutingId(bindingRoutingId(routingId));
+    }
+    async send(parts) {
+        this.requireOpen();
+        await appendSendParts(this.socket.send(), parts).submit();
+    }
+    async request(parts, timeoutMs) {
+        this.requireOpen();
+        const replies = await appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit();
+        return copyAndClose(replies);
+    }
+    receive(dontWait = false) {
+        this.requireOpen();
+        return this.receiveRecord(dontWait);
+    }
+}
+class NodeRawMonitorPort {
+    monitor;
+    release;
+    closed = false;
+    constructor(monitor, release) {
+        this.monitor = monitor;
+        this.release = release;
+    }
+    statusReady() {
+        if (this.closed)
+            throw new Error('Raw monitor is closed.');
+        return this.monitor.status().isReady();
+    }
+    drain(handler) {
+        if (this.closed)
+            throw new Error('Raw monitor is closed.');
+        let count = 0;
+        for (;;) {
+            const event = this.monitor.recv(zlink_1.RecvFlags.DontWait);
+            if (event === null)
+                return count;
+            handler(copyMonitorEvent(event));
+            count += 1;
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.release();
+        this.monitor.close();
+    }
+}
+function appendSendParts(operation, parts) {
+    requireParts(parts);
+    let next = operation.message(parts[0]);
+    for (let index = 1; index < parts.length; index += 1) {
+        next = next.message(parts[index]);
+    }
+    return next;
+}
+function appendRequestParts(operation, parts) {
+    requireParts(parts);
+    let next = operation.message(parts[0]);
+    for (let index = 1; index < parts.length; index += 1) {
+        next = next.message(parts[index]);
+    }
+    return next;
+}
+function appendReplyParts(operation, parts) {
+    requireParts(parts);
+    let next = operation.message(parts[0]);
+    for (let index = 1; index < parts.length; index += 1) {
+        next = next.message(parts[index]);
+    }
+    return next;
+}
+function requireParts(parts) {
+    if (parts.length === 0)
+        throw new TypeError('Raw multipart operation requires at least one part.');
+    return parts;
+}
+function receiveRecord(socket, dontWait, nextRequestSequence, reply) {
+    const received = new zlink_1.Received();
+    if (!socket.recv(received, dontWait ? zlink_1.RecvFlags.DontWait : zlink_1.RecvFlags.None)) {
+        received.close();
+        return undefined;
+    }
+    let closed = false;
+    try {
+        const sourceRid = received.routingId?.toString() ?? '';
+        const sourceRoute = received.routingId?.toBytes() ?? Buffer.alloc(0);
+        const requestSeq = received.replyToken === null ? undefined : nextRequestSequence?.();
+        const replyToken = received.replyToken;
+        const receivedReply = replyToken === null
+            ? undefined
+            : reply === undefined
+                ? received.reply()
+                : (parts) => reply(sourceRoute, replyToken, parts);
+        return {
+            sourceRid,
+            sourceRoute,
+            ...(requestSeq === undefined ? {} : { requestSeq }),
+            ...(receivedReply === undefined
+                ? {}
+                : {
+                    reply: (parts) => {
+                        if (typeof receivedReply === 'function') {
+                            receivedReply(parts);
+                            return;
+                        }
+                        appendReplyParts(receivedReply, parts).submit();
+                    }
+                }),
+            parts: received.parts.map(part => part.toBytes()),
+            close: () => {
+                if (closed)
+                    return;
+                closed = true;
+                received.close();
+            }
+        };
+    }
+    catch (error) {
+        received.close();
+        throw error;
+    }
+}
+function copyAndClose(messages) {
+    try {
+        return messages.map(message => message.toBytes());
+    }
+    finally {
+        for (const message of messages)
+            message.close();
+    }
+}
+function bindingRoutingId(routingId) {
+    return zlink_1.RoutingId.from(routingId);
+}
+function connectable(socket) {
+    if (!('connect' in socket) || !('disconnect' in socket)) {
+        throw new TypeError('Raw socket is not connectable.');
+    }
+    return socket;
+}
+function copyMonitorEvent(event) {
+    return {
+        event: event.event,
+        value: event.value,
+        ...(event.routingId === null ? {} : { routingId: event.routingId.toString() }),
+        localAddress: event.localAddr,
+        remoteAddress: event.remoteAddr,
+        connectionId: event.connectionId,
+        transportLane: event.transportLane,
+        flags: event.flags
+    };
+}

package/dist/runtime/backend/node/node-raw-mesh-backend.d.ts

@@ -0,0 +1,266 @@
+import { SubmitResult, type RequestResult as RequestResultValue, type SubmitResult as SubmitResultValue } from '@zlink-systems/zlink';
+import { type ZLinkBackendMessageLike as MessageLike } from '../runtime-values';
+import type { MeshOperationId, MeshPeerEntry, MeshPublisher, ReadyBatch, ReadyRecord, ReceiveBatch, ServiceSpot, StreamSessionService } from '../../foundation/service-runtime-contracts';
+import { type RawServiceRequestResult } from '../../foundation/raw-service-mesh-runtime';
+import { type ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
+import { type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
+import type { ServiceActorRef, ServiceSpotState } from '../../foundation/service-stateful-registry';
+import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceActivationTarget, ServiceInstanceRouteFence, ServiceSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
+import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation/service-instance-activation-recovery-codec';
+import type { ServiceNodeDescriptor } from '../../foundation/service-topology-registry';
+import type { RoutingId } from '../../../contracts';
+import type { ZLinkBackendActorRef, ZLinkBackendActorSessionSendFence, ZLinkBackendObjectPlacement, ZLinkBackendMeshNode } from '../contracts';
+import type { ZLinkRawBindingPort } from '../raw-binding-port';
+import type { ApplicationJobQueuePort } from '../../application-jobs/contracts';
+/**
+ * M6A MeshNode backend. Stateful Spot/Actor entry points stay explicit until
+ * their owning M6B runtime is connected; topology and node/channel dispatch do
+ * not depend on those entry points.
+ */
+export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
+    private readonly meshName;
+    private readonly bindingPort;
+    private readonly applicationJobQueue?;
+    private readonly applicationJobReceiveFlowFailureSink?;
+    private readonly peerAdmissionSealed?;
+    readonly nativeInstance: this;
+    private readonly channels;
+    private readonly peerIntents;
+    private readonly completions;
+    private completionHead;
+    private completionCount;
+    private readonly routingId;
+    private readonly lifecycleGeneration;
+    private bindEndpoint?;
+    private advertiseHost?;
+    private runtime?;
+    private stateful?;
+    private readyHandler?;
+    private pollTimer?;
+    private nextPeerIntent;
+    private closed;
+    private objectRole;
+    private placementWeight;
+    private activeCapacityLimit;
+    private pendingCapacityLimit;
+    private objectCapabilities;
+    private maintenanceWave?;
+    private mailboxRecordDropped?;
+    private protocolError?;
+    private messageFollowHandler?;
+    private readonly peerDisconnectedHandlers;
+    private readonly receiveBatchBudget;
+    private observedPumpSourceRoutingId?;
+    private observedPumpByteCount;
+    private readonly observePump;
+    private takePumpObservation;
+    constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined);
+    configureObjectPlacement(options: {
+        readonly role: ServiceNodeDescriptor['objectRole'];
+        readonly placementWeight: number;
+        readonly activeCapacityLimit: number;
+        readonly pendingCapacityLimit: number;
+        readonly objectCapabilities: readonly string[];
+        readonly maintenanceWave?: string;
+    }): void;
+    setMailboxRecordDroppedHandler(handler: (record: {
+        readonly kind: 'spot_multicast' | 'actor_control' | 'actor_binding';
+        readonly owner: string;
+    }) => void): void;
+    setProtocolErrorHandler(handler: (record: {
+        readonly sourceNodeRid: string;
+        readonly request: boolean;
+        readonly replied: boolean;
+        readonly command?: number;
+    }) => void): void;
+    onPeerDisconnected(handler: (endpoint: string) => void): void;
+    selectObjectPlacement(stableType: string): ZLinkBackendObjectPlacement;
+    instanceSpotPlacementTypes(): readonly string[];
+    sendToMissingInstanceSpot(target: ServiceInstanceActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
+    requestToMissingInstanceSpot(target: ServiceInstanceActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    setRoutingId(routingId: unknown): void;
+    setBind(endpoint: string): void;
+    setAdvertiseHost(host: string): void;
+    start(): void;
+    setMessageFollowHandler(handler: (record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord) => void): void;
+    sendMessageFollowNotification(targetNodeRid: string, record: Omit<import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord, 'kind'>): Promise<boolean>;
+    shutdown(_timeoutMs: number): RequestResultValue;
+    publishDraining(): Promise<void>;
+    close(): void;
+    addChannelName(name: string): void;
+    setChannelWeight(name: string, weight: number): Promise<void>;
+    setPlacementWeight(weight: number): Promise<void>;
+    connectPeer(options: {
+        readonly endpoint: string;
+        readonly expectedRid?: unknown;
+        readonly expectedSecurityIdentity?: string;
+        readonly expectedLifecycleGeneration?: bigint;
+    }): Promise<bigint>;
+    expectPeer(peer: {
+        readonly nodeRoutingId: string;
+        readonly endpoint: string;
+        readonly securityIdentity?: string;
+        readonly lifecycleGeneration: bigint;
+    }): void;
+    removePeerConnection(intentId: bigint): void;
+    disconnectPeer(peerRid: unknown, lifecycleGeneration: bigint): void;
+    replaceDiscoveredNotRequiredPeers(peers: readonly {
+        readonly nodeRoutingId: string;
+        readonly lifecycleGeneration: bigint;
+        readonly descriptorRevision: bigint;
+        readonly endpoint: string;
+    }[]): void;
+    isObjectClientNodeDirectTarget(targetRid: unknown): boolean;
+    isPeerRouteReady(targetRid: unknown, lifecycleGeneration?: bigint): boolean;
+    sendToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    sendInfrastructureControl(targetRid: unknown, record: Uint8Array | readonly Uint8Array[]): Promise<SubmitResultValue>;
+    sendInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[]): Promise<SubmitResultValue>;
+    requestInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[], options?: {
+        readonly timeoutMs?: number;
+    }): Promise<readonly Uint8Array[]>;
+    requestToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[], options?: {
+        readonly timeoutMs?: number;
+    }): MeshOperationId;
+    sendToChannel(channelName: string, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    requestToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
+        readonly timeoutMs?: number;
+    }): MeshOperationId;
+    status(): {
+        state: number;
+        routingId: RoutingId;
+        meshName: string;
+        localEndpoint: string;
+        lifecycleGeneration: bigint;
+        descriptorRevision: bigint;
+        channelCount: number;
+        configuredPeerCount: number;
+        admittedPeerCount: number;
+        drainingPeerCount: number;
+        pendingApplicationMessages: bigint;
+        pendingInfrastructureMessages: bigint;
+        pendingBytes: bigint;
+        lastError: number;
+        lastChangedMs: bigint;
+    };
+    peers(): MeshPeerEntry[];
+    peerChannels(peerRid: unknown, lifecycleGeneration: bigint): {
+        names: string[];
+        weights: number[];
+    };
+    createPublisher(): MeshPublisher;
+    setReadyHandler(handler: (readyDomains: number) => number): void;
+    createReadyBatch(capacity: number): ReadyBatch;
+    createReceiveBatch(messageCapacity: number, partCapacity: number): ReceiveBatch;
+    drainReady(domains: number, batch: ReadyBatch): {
+        readonly ok: boolean;
+        readonly hasResidue: boolean;
+        readonly records: readonly ReadyRecord[];
+    };
+    createSpot(): ServiceSpot;
+    entrySpot(): ServiceSpot;
+    getOrCreateSpot(routingId: unknown): {
+        readonly spot: ServiceSpot;
+        readonly created: boolean;
+    };
+    instanceSpotApplicationTarget(spotId: string): {
+        readonly stableType: string;
+        readonly objectGeneration: bigint;
+    } | undefined;
+    waitForInstanceApplicationQuiescence(spotId: string, signal?: AbortSignal): Promise<void>;
+    restoreUserSpotAuthority(spotId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpot;
+    restoreSpotAuthority(spotId: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpot;
+    createActor(actorId: string): ZLinkBackendActorRef;
+    restoreActorAuthority(actorId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint, spotId: string, spotGeneration: bigint, membershipEpoch: bigint): ZLinkBackendActorRef;
+    discardRelocatedActor(actor: ZLinkBackendActorRef): void;
+    restoreActorSessionBinding(actor: ZLinkBackendActorRef, sessionNodeRid: unknown, sessionRid: unknown, bindingGeneration: bigint): void;
+    registerInstanceIntent(instanceType: string, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): void;
+    registerAsyncInstanceActivationAuthority(authority: ServiceAsyncInstanceActivationAuthority): void;
+    registerInstanceApplicationLifecycle(lifecycle: ServiceInstanceApplicationLifecycle): void;
+    registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
+    requestUserSpotCreate(targetNodeRid: string, request: Omit<ServiceUserSpotCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    requestUserSpotClose(targetNodeRid: string, request: Omit<ServiceUserSpotCloseRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    recoverInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;
+    recoverPendingInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, pending: ServicePendingInstanceActivation, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;
+    completeRecoveredInstanceActivation(target: ServiceInstanceActivationTarget, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<ServiceInstanceRouteFence | undefined>;
+    forgetInstanceIntent(spotId: string, objectGeneration: bigint, authorityOwnerGeneration: bigint, storeVersion?: string): void;
+    rememberSpotRoute(route: ServiceDirectSpotRouteFence, expectedCurrentRoute?: ServiceDirectSpotRouteFence | null): void;
+    entrySpotRouteFence(targetNodeRid: string, targetSpotId: string): ServiceDirectSpotRouteFence;
+    sealSpotMessageFollowIngress(source: ServiceDirectSpotRouteFence): ServiceSpotMessageFollowSeal | undefined;
+    abortSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal): boolean;
+    commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
+    forgetSpotRoute(spot: ServiceSpotRouteFence['spot'], authorityOwnerGeneration: bigint, storeVersion?: string): void;
+    sendToInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
+    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    actorLookup(actorId: string): {
+        actor: ServiceActorRef;
+        spotId: string;
+        spotGeneration: bigint;
+        membershipEpoch: bigint;
+    };
+    lookupRemoteActor(targetNodeRid: unknown, actorId: string, timeoutMs?: number): MeshOperationId;
+    destroyActor(actor: ZLinkBackendActorRef, timeoutMs?: number): MeshOperationId;
+    joinActorSpot(actor: ZLinkBackendActorRef, targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, request: ServiceApplicationPayload, timeoutMs?: number): MeshOperationId;
+    joinActorSpotCanonical(actor: ZLinkBackendActorRef, targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, request: ServiceApplicationPayload, actorFence: {
+        readonly targetNodeGeneration: bigint;
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+    }, local: {
+        readonly phase: 'admission';
+        readonly transferId: string;
+    }, timeoutMs?: number): MeshOperationId;
+    joinActorEntrySpot(actor: ZLinkBackendActorRef, targetNodeRid: unknown, request: ServiceApplicationPayload, timeoutMs?: number): MeshOperationId;
+    joinActorEntrySpotCanonical(actor: ZLinkBackendActorRef, targetNodeRid: unknown, request: ServiceApplicationPayload, actorFence: {
+        readonly targetNodeGeneration: bigint;
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+    }, local: {
+        readonly phase: 'admission';
+        readonly transferId: string;
+    }, timeoutMs?: number): MeshOperationId;
+    sendToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
+        readonly timeoutMs?: number;
+    }): MeshOperationId;
+    actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    actorRequestToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
+        readonly timeoutMs?: number;
+    }): MeshOperationId;
+    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], _flags?: number, actorFence?: ZLinkBackendActorSessionSendFence): Promise<SubmitResultValue>;
+    closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
+    leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
+    createStreamSessionService(stream: unknown): StreamSessionService;
+    sendFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    requestFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs: number): MeshOperationId;
+    closeSpot(state: ServiceSpotState): boolean;
+    publishFromSpot(state: ServiceSpotState, channelName: string, topic: string, parts: MessageLike | readonly MessageLike[]): Promise<void>;
+    setSpotSubscription(state: ServiceSpotState, channelName: string, topicFilter: string): void;
+    unsetSpotSubscription(state: ServiceSpotState, channelName: string, topicFilter: string): void;
+    clearSpotSubscriptions(state: ServiceSpotState): void;
+    private createDescriptor;
+    private resolveAdvertisedEndpoint;
+    private schedulePoll;
+    private poll;
+    private notifyReady;
+    private observeCompletion;
+    private observeStateful;
+    private enqueueImmediateFailure;
+    private enqueueCompletion;
+    private drainCompletions;
+    private takeCompletion;
+    private clearCompletions;
+    private drainMailbox;
+    private requireRuntime;
+    private requireApplicationJobQueue;
+    private requireStateful;
+    private peerGeneration;
+    private requireNotStarted;
+}
+/**
+ * Classifies a generic node/channel request rejection into a completion
+ * terminal. Spec 32-framework-error-model:91-92 — a reply that could not be
+ * decoded (ServiceWireProtocolError from the reply parser) is a protocol
+ * failure, not connection loss; only genuine transport rejections collapse to
+ * NotConnected.
+ */
+export declare function genericOperationFailure(error: unknown): RawServiceRequestResult;