@zlink-systems/framework 0.30.0 → 0.30.2

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

@@ -22,14 +22,25 @@ export declare class ServiceLivenessConnection {
     tryGetProbe(nowMs: number, allocateProbeId: () => bigint): bigint | undefined;
     acknowledge(probeId: bigint, nowMs: number): boolean;
 }
-/** Uses monotonic milliseconds and never treats application traffic as a probe ACK. */
 export declare class ServiceLivenessRegistry {
     private readonly probeIntervalMs;
     private readonly peerTimeoutMs;
     private readonly peers;
     private nextProbeId;
+    /**
+     * The earliest probe or timeout among admitted peers. Received traffic only
+     * extends a peer's deadline, so this stays a lower bound between ticks.
+     */
+    private nextDueMs;
+    private admissionActivityMs?;
     constructor(probeIntervalMs?: number, peerTimeoutMs?: number);
     admit(nodeRoutingId: string, connectionId: string | bigint, nowMs: number): ServiceLivenessConnection;
+    /** When the next tick has probe or timeout work (spec 08 §4.2 management deadline). */
+    nextDeadlineMs(): number;
+    /** Pending admission shares the existing liveness management cadence (MeshNode §7.1). */
+    setAdmissionPending(pending: boolean, nowMs: number): void;
+    private nextAdmissionDeadlineMs;
+    tickAdmission(nowMs: number): boolean;
     recordReceived(connection: ServiceLivenessConnection, nowMs: number): void;
     disconnect(nodeRoutingId: string, connectionId: string | bigint): boolean;
     acknowledge(nodeRoutingId: string, connectionId: string | bigint, probeId: bigint, nowMs: number): boolean;

package/dist/runtime/foundation/service-liveness-registry.js

@@ -43,11 +43,21 @@ class ServiceLivenessConnection {
 }
 exports.ServiceLivenessConnection = ServiceLivenessConnection;
 /** Uses monotonic milliseconds and never treats application traffic as a probe ACK. */
+const NO_LIVENESS_WORK = Object.freeze({
+    probes: Object.freeze([]),
+    timedOutNodes: Object.freeze([])
+});
 class ServiceLivenessRegistry {
     probeIntervalMs;
     peerTimeoutMs;
     peers = new Map();
     nextProbeId = 1n;
+    /**
+     * The earliest probe or timeout among admitted peers. Received traffic only
+     * extends a peer's deadline, so this stays a lower bound between ticks.
+     */
+    nextDueMs = Number.POSITIVE_INFINITY;
+    admissionActivityMs;
     constructor(probeIntervalMs = exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS, peerTimeoutMs = exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS) {
         this.probeIntervalMs = probeIntervalMs;
         this.peerTimeoutMs = peerTimeoutMs;
@@ -69,8 +79,31 @@ class ServiceLivenessRegistry {
             return current;
         const admitted = new ServiceLivenessConnection(connectionId, nowMs, this.probeIntervalMs, this.peerTimeoutMs);
         this.peers.set(nodeRoutingId, admitted);
+        this.nextDueMs = Math.min(this.nextDueMs, admitted.nextProbeMs, admitted.deadlineMs);
         return admitted;
     }
+    /** When the next tick has probe or timeout work (spec 08 §4.2 management deadline). */
+    nextDeadlineMs() {
+        return Math.min(this.nextDueMs, this.nextAdmissionDeadlineMs());
+    }
+    /** Pending admission shares the existing liveness management cadence (MeshNode §7.1). */
+    setAdmissionPending(pending, nowMs) {
+        if (pending)
+            this.admissionActivityMs ??= nowMs;
+        else
+            this.admissionActivityMs = undefined;
+    }
+    nextAdmissionDeadlineMs() {
+        return this.admissionActivityMs === undefined
+            ? Number.POSITIVE_INFINITY
+            : this.admissionActivityMs + this.probeIntervalMs;
+    }
+    tickAdmission(nowMs) {
+        if (nowMs < this.nextAdmissionDeadlineMs())
+            return false;
+        this.admissionActivityMs = nowMs;
+        return true;
+    }
     recordReceived(connection, nowMs) {
         connection.recordReceived(nowMs);
     }
@@ -95,8 +128,11 @@ class ServiceLivenessRegistry {
         return { nodeRoutingId, connectionId, probeId };
     }
     tick(nowMs) {
+        if (nowMs < this.nextDeadlineMs())
+            return NO_LIVENESS_WORK;
         const probes = [];
         const timedOutNodes = [];
+        let nextDueMs = Number.POSITIVE_INFINITY;
         for (const [nodeRoutingId, peer] of this.peers) {
             if (peer.isExpired(nowMs)) {
                 timedOutNodes.push(nodeRoutingId);
@@ -106,7 +142,9 @@ class ServiceLivenessRegistry {
             const probeId = peer.tryGetProbe(nowMs, this.allocateProbeId);
             if (probeId !== undefined)
                 probes.push({ nodeRoutingId, connectionId: peer.connectionId, probeId });
+            nextDueMs = Math.min(nextDueMs, peer.nextProbeMs, peer.deadlineMs);
         }
+        this.nextDueMs = nextDueMs;
         timedOutNodes.sort();
         return { probes, timedOutNodes };
     }

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

@@ -1,11 +1,18 @@
 import type { ApplicationJobRecordLease } from '../application-jobs/application-ingress-record-owner';
 import type { ReceiveRecord } from './service-runtime-contracts';
+import type { RawServiceIngressRecord } from './raw-service-mesh-runtime';
 export type ServiceMailboxDomain = 'application' | 'infrastructure';
+export interface ServiceMailboxDispatchOwner {
+    prepareDispatch(record: ServiceMailboxRecord, signal: AbortSignal): boolean | Promise<boolean>;
+}
 export interface ServiceMailboxRecord {
+    readonly sourcePreparationOwner?: ServiceMailboxDispatchOwner;
+    readonly ingress?: RawServiceIngressRecord;
     readonly owner: string;
     readonly domain: ServiceMailboxDomain;
     parts: readonly Uint8Array[];
     readonly sourceRoutingId?: string;
+    readonly requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
     readonly sourceRoute?: Uint8Array;
     readonly requestSequence?: bigint;
     readonly reply?: (parts: readonly Uint8Array[]) => void;

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

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceMaintenanceRuntime = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
 const state_lane_1 = require("../execution/state-lane");
-const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:service-maintenance-runtime');
 /** Owns first-intent-wins maintenance admission and terminal observation. */
 class ServiceMaintenanceRuntime {
     options;
@@ -156,7 +154,7 @@ class ServiceMaintenanceRuntime {
                     continue;
                 admitted = true;
                 let running;
-                running = startOutsideStateLane(() => unit
+                running = (0, state_lane_1.startOutsideStateLane)(() => unit
                     .relocate(signal)
                     .catch((error) => {
                     failures.push(error);
@@ -206,6 +204,3 @@ class ServiceMaintenanceRuntime {
     }
 }
 exports.ServiceMaintenanceRuntime = ServiceMaintenanceRuntime;
-function startOutsideStateLane(work) {
-    return detachedStateLaneResource.runInAsyncScope(work);
-}

package/dist/runtime/foundation/service-relocation-object-owner.d.ts

@@ -3,6 +3,7 @@ import type { ServiceRelocationRestoreOwner, ServiceRelocationStaging } from './
 import type { ServiceRelocationEnvelope, ServiceRelocationMembership, ServiceRelocationParticipant, ServiceRelocationQueuedMessage, ServiceRelocationTimer } from './service-relocation-runtime';
 export interface ServiceRelocationSealedWork {
     readonly boundSessionState: Uint8Array;
+    readonly sessionBinding?: ServiceRelocationParticipant['sessionBinding'];
     readonly queuedMessages: readonly ServiceRelocationQueuedMessage[];
     readonly timers: readonly ServiceRelocationTimer[];
 }
@@ -14,7 +15,7 @@ export interface ServiceRelocationCaptureUnit {
     readonly authorityOwnerGeneration: bigint;
     seal(signal?: AbortSignal): Promise<ServiceRelocationSealedWork>;
     captureApplicationState(signal?: AbortSignal): Promise<Uint8Array>;
-    commitSeal(): Promise<void> | void;
+    commitSeal(followAuthorities: ReadonlyMap<string, ZLinkAuthoritySnapshot>): Promise<void> | void;
     abortSeal(): Promise<void> | void;
     /** Expired-owner terminal: pending requests fail once and dispatch stays closed. */
     discardSeal?(reason: unknown): Promise<void> | void;
@@ -24,7 +25,7 @@ export declare class ServiceCapturedObjectRelocation {
     private readonly units;
     private terminal;
     constructor(envelope: ServiceRelocationEnvelope, units: readonly ServiceRelocationCaptureUnit[]);
-    commitSource(): Promise<void>;
+    commitSource(followAuthorities: ReadonlyMap<string, ZLinkAuthoritySnapshot>): Promise<void>;
     abortSource(): Promise<void>;
     /**
      * The source owner lease ended before the authority settled (spec 28 §4.4):
@@ -52,7 +53,6 @@ export interface ServiceRelocationTargetObjectPort<THidden extends ServiceReloca
     publish(hidden: THidden, authority: ZLinkAuthoritySnapshot, signal?: AbortSignal): Promise<void>;
     restoreBoundSession(hidden: THidden, payload: Uint8Array, signal?: AbortSignal): Promise<void>;
     replayQueuedMessage(hidden: THidden, message: ServiceRelocationQueuedMessage, signal?: AbortSignal): Promise<void>;
-    restoreTimer(hidden: THidden, timer: ServiceRelocationTimer, signal?: AbortSignal): Promise<void>;
     normalize(hidden: THidden, authority: ZLinkAuthoritySnapshot, signal?: AbortSignal): Promise<void>;
     openAdmission(hidden: THidden, signal?: AbortSignal): Promise<void>;
     abort(hidden: THidden): Promise<void> | void;

package/dist/runtime/foundation/service-relocation-object-owner.js

@@ -10,14 +10,14 @@ class ServiceCapturedObjectRelocation {
         this.envelope = envelope;
         this.units = units;
     }
-    async commitSource() {
+    async commitSource(followAuthorities) {
         if (this.terminal === 'committed')
             return;
         if (this.terminal !== 'open') {
             throw new Error(`Relocation source capture was already ${this.terminal}.`);
         }
         for (const unit of this.units)
-            await unit.commitSeal();
+            await unit.commitSeal(followAuthorities);
         this.terminal = 'committed';
     }
     async abortSource() {
@@ -26,18 +26,11 @@ class ServiceCapturedObjectRelocation {
         if (this.terminal !== 'open') {
             throw new Error(`A ${this.terminal} relocation source capture cannot be aborted.`);
         }
-        const failures = [];
-        for (const unit of [...this.units].reverse()) {
-            try {
-                await unit.abortSeal();
-            }
-            catch (error) {
-                failures.push(error);
-            }
+        try {
+            await abortSourceSeals(this.units);
         }
-        this.terminal = 'aborted';
-        if (failures.length !== 0) {
-            throw new AggregateError(failures, 'Relocation source rollback was incomplete.');
+        finally {
+            this.terminal = 'aborted';
         }
     }
     /**
@@ -91,23 +84,29 @@ class ServiceRelocationObjectCaptureOwner {
         try {
             for (const unit of units) {
                 signal?.throwIfAborted();
-                const work = await unit.seal(signal);
-                captured.push({ unit, work });
+                const capture = { unit };
+                captured.push(capture);
+                capture.work = await unit.seal(signal);
             }
-            const participants = await mapConcurrentOrdered(captured, this.maxConcurrentCallbacks, async ({ unit, work }) => ({
-                key: unit.authorityKey,
-                objectKind: unit.objectKind,
-                stableType: unit.stableType,
-                objectGeneration: unit.objectGeneration,
-                authorityOwnerGeneration: unit.authorityOwnerGeneration,
-                applicationState: Buffer.from(await unit.captureApplicationState(signal)),
-                boundSessionState: Buffer.from(work.boundSessionState),
-                queuedMessages: work.queuedMessages.map((message) => ({
-                    sequence: message.sequence,
-                    payload: Buffer.from(message.payload)
-                })),
-                timers: work.timers.map((timer) => ({ ...timer }))
-            }), signal);
+            const participants = await mapConcurrentOrdered(captured, this.maxConcurrentCallbacks, async ({ unit, work: sealedWork }) => {
+                // Application capture starts only after every seal completed.
+                const work = sealedWork;
+                return {
+                    key: unit.authorityKey,
+                    objectKind: unit.objectKind,
+                    stableType: unit.stableType,
+                    objectGeneration: unit.objectGeneration,
+                    authorityOwnerGeneration: unit.authorityOwnerGeneration,
+                    applicationState: Buffer.from(await unit.captureApplicationState(signal)),
+                    boundSessionState: Buffer.from(work.boundSessionState),
+                    ...(work.sessionBinding === undefined ? {} : { sessionBinding: work.sessionBinding }),
+                    queuedMessages: work.queuedMessages.map((message) => ({
+                        sequence: message.sequence,
+                        payload: Buffer.from(message.payload)
+                    })),
+                    timers: work.timers.map((timer) => ({ ...timer }))
+                };
+            }, signal);
             return new ServiceCapturedObjectRelocation({
                 aggregateId,
                 aggregateGeneration,
@@ -116,13 +115,31 @@ class ServiceRelocationObjectCaptureOwner {
             }, units);
         }
         catch (error) {
-            for (const { unit } of captured.reverse())
-                await unit.abortSeal();
+            try {
+                await abortSourceSeals(captured.map(({ unit }) => unit));
+            }
+            catch (rollbackError) {
+                throw new AggregateError([error, rollbackError], 'Relocation capture failed and source rollback was incomplete.');
+            }
             throw error;
         }
     }
 }
 exports.ServiceRelocationObjectCaptureOwner = ServiceRelocationObjectCaptureOwner;
+async function abortSourceSeals(units) {
+    const failures = [];
+    for (const unit of [...units].reverse()) {
+        try {
+            await unit.abortSeal();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length !== 0) {
+        throw new AggregateError(failures, 'Relocation source rollback was incomplete.');
+    }
+}
 /** Restores an exact User Spot aggregate or standalone Actor into hidden objects. */
 class ServiceRelocationObjectRestoreOwner {
     target;
@@ -182,9 +199,6 @@ class ServiceRelocationObjectRestoreOwner {
             for (const message of participant.queuedMessages) {
                 await this.target.replayQueuedMessage(hidden, message, signal);
             }
-            for (const timer of participant.timers) {
-                await this.target.restoreTimer(hidden, timer, signal);
-            }
         }
     }
     /** Appends one post-capture relay to the already restored temporary queue. */

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

@@ -1,4 +1,5 @@
 import type { ZLinkPlacementObjectKind } from '../locations/internal-location-contracts';
+import { type RelocationEnvelopeV1 as GeneratedRelocationEnvelopeV1 } from '../protocol/service_wire_pilot_codec.generated';
 export interface ServiceRelocationParticipant {
     /** Wire-local participant ordinal; identity is projected from Location Store. */
     readonly participantId?: bigint;
@@ -17,6 +18,7 @@ export interface ServiceRelocationParticipant {
     readonly applicationStatePresent?: boolean;
     readonly applicationState: Uint8Array;
     readonly boundSessionState: Uint8Array;
+    readonly sessionBinding?: GeneratedRelocationEnvelopeV1['sessionBindings'][number];
     readonly queuedMessages: readonly ServiceRelocationQueuedMessage[];
     readonly timers: readonly ServiceRelocationTimer[];
 }

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

@@ -480,6 +480,9 @@ function encodeServiceRelocationEnvelope(envelope, applicationVersion) {
             lastCompletedScheduledIndex: nonNegativeBigInt(timer.lastScheduledIndex, 'timer scheduled index'),
             nextScheduledAtUnixMilliseconds: nonNegativeUnixMilliseconds(timer.dueAtUnixMs, 'timer due time')
         })),
+        sessionBindings: participants.flatMap((participant, index) => participant.sessionBinding === undefined
+            ? []
+            : [{ ...participant.sessionBinding, participantId: BigInt(index + 1) }]),
         pendingTimerTicks: pending.map((value) => ({
             participantId: value.participantId,
             order: value.order,
@@ -510,11 +513,20 @@ function decodeServiceRelocationEnvelope(payload, aggregateGeneration) {
     if (aggregateId === undefined)
         throw new TypeError('Invalid relocation identity.');
     positiveBigInt(aggregateGeneration, 'aggregate generation');
+    const bindings = new Map(generated.sessionBindings.map((binding) => [binding.participantId, binding]));
+    for (const id of bindings.keys()) {
+        if (id > BigInt(generated.applicationStates.length))
+            throw new TypeError('Session binding participant is outside its inventory.');
+    }
     const participants = generated.applicationStates.map((state, index) => {
         if (state.participantId !== BigInt(index + 1)) {
             throw new TypeError('Application state participant order is invalid.');
         }
-        return wireParticipant(state.participantId, state.hasState, Buffer.from(state.payload));
+        const binding = bindings.get(state.participantId);
+        return {
+            ...wireParticipant(state.participantId, state.hasState, Buffer.from(state.payload)),
+            ...(binding === undefined ? {} : { sessionBinding: binding })
+        };
     });
     const byId = new Map(participants.map((value) => [value.participantId, value]));
     for (const work of generated.savedWork) {
@@ -524,12 +536,16 @@ function decodeServiceRelocationEnvelope(payload, aggregateGeneration) {
         });
     }
     for (const timer of generated.timerRegistrations) {
+        const dueAtUnixMs = unixMilliseconds(timer.nextScheduledAtUnixMilliseconds);
+        const intervalMs = unixMilliseconds(timer.periodMilliseconds);
         byId.get(timer.participantId).timers.push({
             timerId: timer.name,
             handlerType: timer.handlerType,
-            startedAtUnixMs: 0,
-            dueAtUnixMs: unixMilliseconds(timer.nextScheduledAtUnixMilliseconds),
-            intervalMs: unixMilliseconds(timer.periodMilliseconds),
+            // The wire anchors the nominal schedule by its next due time: the next
+            // nominal tick after the completed ScheduledIndex (Spot timer §1).
+            startedAtUnixMs: dueAtUnixMs - Number(timer.lastCompletedScheduledIndex + 1n) * intervalMs,
+            dueAtUnixMs,
+            intervalMs,
             overrunPolicy: timerPolicyName(timer.overrunPolicy),
             maxCatchUpTicks: unixMilliseconds(timer.maxCatchUpTicks),
             stopOnUnhandledException: timer.stopOnUnhandledException,

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

@@ -205,11 +205,18 @@ export interface ReceiveRequirements {
     readonly byteCount: number;
 }
 export interface ZLinkMessageFollowOrigin {
+    readonly requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
     readonly sourceNodeRid: RoutingId;
     readonly originalOperation: MeshOperationId;
     readonly originalReplyRouteId: bigint;
+    /** The canonical target accepted with the original native Actor frame. */
+    readonly target?: import('./service-stateful-wire-codec').ServiceActorRouteFence;
 }
 export interface ReceiveRecord {
+    /** Resolve record prerequisites in owner order, outside an application handler turn. */
+    readonly prepareDispatch?: (this: ReceiveRecord, signal: AbortSignal) => boolean | Promise<boolean>;
+    readonly statefulMailboxRecord?: import('./service-mailbox').ServiceMailboxRecord;
+    readonly requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
     readonly kind: number;
     readonly domain: number;
     readonly sourceNodeRid: RoutingId | null;
@@ -314,7 +321,7 @@ export interface StreamSessionService {
     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;
+    bindActor(sessionRid: RoutingId, actor: ServiceActorRef, timeoutMs?: number, onBindingReplaced?: (actorId: string, retiredSession: ServiceRetiredBoundSessionRouteFence, actor: ServiceActorRef) => void, actorAuthority?: StreamSessionActorAuthorityFence, close?: () => Promise<void>): MeshOperationId;
     unbindActor(sessionRid: RoutingId, actor: ServiceActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     bindings(sessionRid: RoutingId): ReadonlyArray<ServiceStreamSessionBinding>;
     sendToActor(sessionRid: RoutingId, actor: ServiceActorRef, parts: MessageLike | readonly MessageLike[], options?: {
@@ -343,6 +350,7 @@ export interface ServiceSpot {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     sendToSpot(targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
@@ -354,6 +362,7 @@ export interface ServiceSpot {
         timeoutMs?: number;
         applicationMetadata?: Buffer;
         routeFence?: ServiceDirectSpotRouteFence;
+        onAdmitted?: () => void;
         entrySpot?: boolean;
     }): MeshOperationId;
     publish(channelName: string, topic: string, parts: MessageLike | readonly MessageLike[], options?: {

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

@@ -1,5 +1,6 @@
+import type { RoutingId } from '../../contracts';
 export interface ServiceSessionBindingIngressPort {
-    actorSlot(actorId: string, sessionRid: string): Promise<number | undefined>;
+    actorSlot(actorId: string, sessionRid: RoutingId): Promise<number | undefined>;
 }
 export declare function registerServiceSessionBindingIngressPort(service: object, port: ServiceSessionBindingIngressPort): void;
 export declare function serviceSessionBindingIngressPortIfRegistered(service: object): ServiceSessionBindingIngressPort | undefined;

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

@@ -95,7 +95,6 @@ export declare class ServiceStatefulRegistry {
     private readonly reservationAttempts;
     private readonly turns;
     private nextReservationId;
-    private nextBindingGeneration;
     constructor(nodeRid: string, nodeGeneration: bigint);
     createEntrySpot(spotId?: string): ServiceSpotState;
     private createEntrySpotCore;
@@ -117,8 +116,7 @@ export declare class ServiceStatefulRegistry {
     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;
+    installSessionBinding(binding: ServiceSessionBinding): ServiceSessionBinding;
     binding(actor: ServiceActorRef): ServiceSessionBinding | undefined;
     private bindingCore;
     unbindSession(actor: ServiceActorRef, expectedBindingGeneration: bigint, expectedSessionRid?: string, expectedSessionOwnerNodeRid?: string): boolean;
@@ -129,17 +127,20 @@ export declare class ServiceStatefulRegistry {
     runTurn<T>(owner: string, work: () => T | Promise<T>): Promise<T>;
     private updateBindingMembership;
 }
+export declare const RELOCATION_REPLY_RETENTION_MS: number;
 export declare class ServiceTerminalOperationRegistry<T, Context = unknown> {
     private readonly operations;
     constructor(operations?: OperationRegistry<T, Context>);
     register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender', context?: Context): PendingOperation<T>;
-    reply(id: bigint, value: T): boolean;
+    reply(id: bigint, value: T, terminalContextRetentionMs?: number): boolean;
     fail(id: bigint, error: unknown): boolean;
     cancel(id: bigint): boolean;
     isPending(id: bigint): boolean;
     context(id: bigint): Context | undefined;
     get size(): number;
+    nextDeadlineMs(): number;
     expire(nowMs: number, turnDeadlineMs: number): number;
     close(): void;
+    failAll(reason: unknown): void;
 }
 export {};

package/dist/runtime/foundation/service-stateful-registry.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceTerminalOperationRegistry = exports.ServiceStatefulRegistry = exports.ServiceStaleGenerationError = void 0;
+exports.ServiceTerminalOperationRegistry = exports.RELOCATION_REPLY_RETENTION_MS = exports.ServiceStatefulRegistry = exports.ServiceStaleGenerationError = void 0;
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
+const routing_id_1 = require("../routing-id");
+const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
 const operation_registry_1 = require("./operation-registry");
 class ServiceStaleGenerationError extends Error {
     objectKind;
@@ -33,7 +35,6 @@ class ServiceStatefulRegistry {
     reservationAttempts = new Map();
     turns = new Map();
     nextReservationId = 1n;
-    nextBindingGeneration = 1n;
     constructor(nodeRid, nodeGeneration) {
         this.nodeRid = nodeRid;
         this.nodeGeneration = nodeGeneration;
@@ -238,37 +239,26 @@ class ServiceStatefulRegistry {
         this.bindings.delete(actorKey(actor));
         return current;
     }
-    bindSession(actor, sessionRid, sessionOwnerNodeRid, sessionOwnerNodeGeneration, sessionOwnerId, sessionOwnerLeaseGeneration) {
-        const current = this.requireActorCore(actor);
-        requireText(sessionRid, 'sessionRid');
-        requireText(sessionOwnerNodeRid, 'sessionOwnerNodeRid');
-        const binding = Object.freeze({
-            actor: Object.freeze({ ...current.ref }),
-            sessionRid,
-            sessionOwnerNodeRid,
-            ...(sessionOwnerNodeGeneration === undefined ? {} : { sessionOwnerNodeGeneration }),
-            ...(sessionOwnerId === undefined ? {} : { sessionOwnerId }),
-            ...(sessionOwnerLeaseGeneration === undefined ? {} : { sessionOwnerLeaseGeneration }),
-            bindingGeneration: this.nextBindingGeneration++,
-            membershipEpoch: current.membershipEpoch
-        });
-        this.bindings.set(actorKey(actor), binding);
-        return binding;
-    }
     installSessionBinding(binding) {
         this.requireActorCore(binding.actor);
+        (0, service_wire_binary_primitives_1.encodeServiceWireRoutingId)(binding.sessionRid, 'sessionRid', CoreTypes_1.ZLINK_MAX_ROUTING_ID_BYTES, (message) => {
+            throw new RangeError(message);
+        });
+        requireText(binding.sessionOwnerNodeRid, 'sessionOwnerNodeRid');
         requirePositive(binding.bindingGeneration, 'bindingGeneration');
         const current = this.bindings.get(actorKey(binding.actor));
         if (current !== undefined &&
             current.sessionOwnerNodeRid === binding.sessionOwnerNodeRid &&
             current.sessionOwnerNodeGeneration === binding.sessionOwnerNodeGeneration &&
-            current.sessionOwnerId === binding.sessionOwnerId &&
-            current.sessionOwnerLeaseGeneration === binding.sessionOwnerLeaseGeneration &&
             current.bindingGeneration >= binding.bindingGeneration) {
+            if (current.bindingGeneration === binding.bindingGeneration &&
+                current.sessionRid === binding.sessionRid)
+                return current;
             throw new ServiceStaleGenerationError('binding', binding.actor.actorId);
         }
-        this.nextBindingGeneration = max(this.nextBindingGeneration, binding.bindingGeneration + 1n);
-        this.bindings.set(actorKey(binding.actor), Object.freeze({ ...binding }));
+        const accepted = Object.freeze({ ...binding });
+        this.bindings.set(actorKey(binding.actor), accepted);
+        return accepted;
     }
     binding(actor) {
         return this.bindingCore(actor);
@@ -283,7 +273,8 @@ class ServiceStatefulRegistry {
         if (binding === undefined)
             return false;
         if (binding.bindingGeneration !== expectedBindingGeneration ||
-            (expectedSessionRid !== undefined && binding.sessionRid !== expectedSessionRid) ||
+            (expectedSessionRid !== undefined &&
+                !(0, routing_id_1.routingIdsEqual)(binding.sessionRid, expectedSessionRid)) ||
             (expectedSessionOwnerNodeRid !== undefined &&
                 binding.sessionOwnerNodeRid !== expectedSessionOwnerNodeRid)) {
             throw new ServiceStaleGenerationError('binding', actor.actorId);
@@ -425,6 +416,7 @@ function createSpotState(ref, kind, stableType, authorityOwnerGeneration) {
             return Object.freeze({ ...base, kind, stableType });
     }
 }
+exports.RELOCATION_REPLY_RETENTION_MS = 24 * 60 * 60 * 1_000;
 class ServiceTerminalOperationRegistry {
     operations;
     constructor(operations = new operation_registry_1.OperationRegistry()) {
@@ -433,8 +425,8 @@ class ServiceTerminalOperationRegistry {
     register(timeoutMs, timeoutOwner = 'registry', context) {
         return this.operations.register(timeoutMs, timeoutOwner, context);
     }
-    reply(id, value) {
-        return this.operations.complete(id, value);
+    reply(id, value, terminalContextRetentionMs = 0) {
+        return this.operations.complete(id, value, terminalContextRetentionMs);
     }
     fail(id, error) {
         return this.operations.fail(id, error);
@@ -451,12 +443,18 @@ class ServiceTerminalOperationRegistry {
     get size() {
         return this.operations.size;
     }
+    nextDeadlineMs() {
+        return this.operations.nextDeadlineMs();
+    }
     expire(nowMs, turnDeadlineMs) {
         return this.operations.expire(nowMs, turnDeadlineMs);
     }
     close() {
         this.operations.close('Stateful runtime closed.');
     }
+    failAll(reason) {
+        this.operations.failAll(reason);
+    }
 }
 exports.ServiceTerminalOperationRegistry = ServiceTerminalOperationRegistry;
 function actorKey(actor) {