@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/foundation/request-runtime.d.ts

@@ -0,0 +1,17 @@
+import { OperationRegistry, type OperationHandle, type OperationObserver, type PendingOperation } from './operation-registry';
+import { type ZLinkRequestResult } from '../messaging/request-result';
+/** Owns the request entries and deadline visits of one runtime instance. */
+export declare class RequestRuntime {
+    readonly registry: OperationRegistry<unknown, unknown>;
+    private timer?;
+    private dueMs;
+    begin<T>(timeoutMs: number | undefined, signal?: AbortSignal, existing?: PendingOperation<unknown>, absoluteDeadlineMs?: number): PendingOperation<T>;
+    run<T>(pending: PendingOperation<unknown>, start: (receiver: OperationObserver<unknown, unknown>) => void, decode: (raw: unknown) => T, mapFailure: (error: unknown) => unknown, destination?: OperationObserver<unknown, unknown>): Promise<T>;
+    request<T>(timeoutMs: number | undefined, signal: AbortSignal | undefined, work: (pending: PendingOperation<unknown>) => Promise<T>, existing?: PendingOperation<unknown>, discardLateResult?: (value: T) => void): Promise<T>;
+    prepare<T>(timeoutMs: number | undefined, signal: AbortSignal | undefined, start: (pending: PendingOperation<unknown>, receiver: OperationObserver<unknown, unknown>) => void, decode: (raw: unknown) => T, mapFailure: (error: unknown) => unknown, existing?: PendingOperation<unknown>, destination?: OperationObserver<unknown, unknown>): ZLinkRequestResult<T>;
+    observe<T, R = T>(timeoutMs: number, submit: (entry: OperationHandle<T>, receiver: OperationObserver<T, unknown>) => void, onReply: (value: T) => R, onFailed: (error: unknown) => R): Promise<R>;
+    operations<T, Context = unknown>(): OperationRegistry<T, Context>;
+    close(reason?: unknown): void;
+    private schedule;
+    private readonly visit;
+}

package/dist/runtime/foundation/request-runtime.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestRuntime = void 0;
+const request_deadline_1 = require("../messaging/request-deadline");
+const contracts_1 = require("../../contracts");
+const operation_registry_1 = require("./operation-registry");
+const abort_1 = require("../abort");
+const request_result_1 = require("../messaging/request-result");
+/** Owns the request entries and deadline visits of one runtime instance. */
+class RequestRuntime {
+    registry = new operation_registry_1.OperationRegistry(undefined, () => this.schedule(), (reason) => (0, request_deadline_1.requestTerminalError)('Request', reason));
+    timer;
+    dueMs = Number.POSITIVE_INFINITY;
+    begin(timeoutMs, signal, existing, absoluteDeadlineMs) {
+        if (existing !== undefined)
+            return existing;
+        const operation = this.registry.register(timeoutMs ?? 0, timeoutMs === undefined ? 'sender' : 'registry', undefined, absoluteDeadlineMs);
+        operation.setSignal(signal);
+        return operation;
+    }
+    run(pending, start, decode, mapFailure, destination) {
+        if (!pending.isPending())
+            return pending.promise;
+        pending.deferCompletion();
+        const receiver = {
+            operationCompleted: (_id, raw) => {
+                try {
+                    const value = decode(raw);
+                    if (destination !== undefined)
+                        destination.operationCompleted(pending.id, value, undefined);
+                    else
+                        pending.complete(value);
+                }
+                catch (error) {
+                    if (destination !== undefined)
+                        destination.operationFailed(pending.id, error, undefined);
+                    else
+                        pending.fail(error);
+                }
+            },
+            operationFailed: (_id, error) => {
+                let failure = error;
+                try {
+                    failure = mapFailure(error);
+                }
+                catch (mapped) {
+                    failure = mapped;
+                }
+                if (destination !== undefined)
+                    destination.operationFailed(pending.id, failure, undefined);
+                else
+                    pending.fail(failure);
+            }
+        };
+        try {
+            start(receiver);
+        }
+        catch (error) {
+            receiver.operationFailed(pending.id, error, undefined);
+        }
+        return pending.promise;
+    }
+    request(timeoutMs, signal, work, existing, discardLateResult) {
+        if (existing !== undefined) {
+            if (!existing.isPending())
+                return existing.promise.then(() => {
+                    throw new operation_registry_1.OperationCancelledError(existing.id, 'Request is already terminal.');
+                });
+            return work(existing);
+        }
+        const pending = this.begin(timeoutMs, signal, existing);
+        return this.run(pending, (receiver) => {
+            void work(pending).then((value) => receiver.operationCompleted(pending.id, value, undefined), (error) => receiver.operationFailed(pending.id, error, undefined));
+        }, (value) => {
+            if (!pending.isPending())
+                discardLateResult?.(value);
+            return value;
+        }, request_result_1.identityRequestReply);
+    }
+    prepare(timeoutMs, signal, start, decode, mapFailure, existing, destination) {
+        if (signal?.aborted === true && destination === undefined)
+            return (0, request_result_1.rejectZLinkRequestReply)(signal.reason ?? (0, abort_1.createAbortError)());
+        const operation = this.begin(timeoutMs, signal, existing);
+        if (signal?.aborted === true && destination !== undefined)
+            destination.operationFailed(operation.id, signal.reason ?? (0, abort_1.createAbortError)(), undefined);
+        const pending = signal?.aborted === true
+            ? operation.promise
+            : this.run(operation, (receiver) => start(operation, receiver), decode, mapFailure, destination);
+        return {
+            pending,
+            decode: (request_result_1.identityRequestReply),
+            mapFailure: request_result_1.identityRequestReply,
+            operation: operation
+        };
+    }
+    observe(timeoutMs, submit, onReply, onFailed) {
+        return new Promise((resolve, reject) => {
+            const observer = {
+                operationCompleted: (_id, value) => {
+                    try {
+                        resolve(onReply(value));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                },
+                operationFailed: (_id, reason) => {
+                    try {
+                        resolve(onFailed((0, request_deadline_1.requestTerminalError)('Request', reason)));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+            };
+            const id = this.registry.registerObserved(timeoutMs, observer);
+            const entry = this.registry.handle(id);
+            try {
+                submit(entry, {
+                    operationCompleted: (_id, value) => {
+                        if (!entry.complete(value))
+                            observer.operationCompleted(id, value, undefined);
+                    },
+                    operationFailed: (_id, error) => entry.fail(error)
+                });
+            }
+            catch (error) {
+                entry.fail(error);
+            }
+        });
+    }
+    operations() {
+        return this.registry;
+    }
+    close(reason = new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ShuttingDown, 'Request runtime closed.')) {
+        this.registry.clear(reason);
+        this.schedule();
+    }
+    schedule() {
+        const next = this.registry.nextDeadlineMs();
+        if (next < this.dueMs) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+            this.dueMs = next;
+            if (Number.isFinite(next))
+                this.timer = setTimeout(this.visit, Math.min(0x7fff_ffff, Math.ceil(next - performance.now())));
+        }
+        if (this.timer !== undefined) {
+            if (this.registry.size === 0)
+                this.timer.unref();
+            else
+                this.timer.ref();
+        }
+    }
+    visit = () => {
+        this.timer = undefined;
+        this.dueMs = Number.POSITIVE_INFINITY;
+        const now = performance.now();
+        this.registry.expire(now, now + 1);
+        this.schedule();
+    };
+}
+exports.RequestRuntime = RequestRuntime;

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

@@ -1,3 +1,4 @@
+import { inspectRuntime } from '../internal-observation';
 export interface ClientServerDescriptor {
     readonly channelName: string;
     readonly serverRoutingId: string;
@@ -23,6 +24,9 @@ export interface SelectedClientServer {
 }
 /** Dedicated discovery state; fanout publishers never reuse RouteMesh peer rows. */
 export declare class ServiceDiscoveryRegistry {
+    [inspectRuntime](): Readonly<{
+        clientServerObservers: number;
+    }>;
     private readonly clientServerChanged;
     onClientServerChanged(listener: (error?: Error) => void): () => void;
     dispose(error: Error): void;

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

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceDiscoveryRegistry = void 0;
+const internal_observation_1 = require("../internal-observation");
 const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
 const service_weighted_selection_1 = require("./service-weighted-selection");
 /** Dedicated discovery state; fanout publishers never reuse RouteMesh peer rows. */
 class ServiceDiscoveryRegistry {
+    [internal_observation_1.inspectRuntime]() {
+        return Object.freeze({
+            clientServerObservers: this.clientServerChanged.size
+        });
+    }
     clientServerChanged = new Set();
     onClientServerChanged(listener) {
         this.clientServerChanged.add(listener);

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

@@ -25,7 +25,7 @@ export declare class ServiceLivenessConnection {
 export declare class ServiceLivenessRegistry {
     private readonly probeIntervalMs;
     private readonly peerTimeoutMs;
-    private readonly peers;
+    readonly peers: Map<string, ServiceLivenessConnection>;
     private nextProbeId;
     /**
      * The earliest probe or timeout among admitted peers. Received traffic only

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

@@ -6,6 +6,7 @@ export interface ServiceMailboxDispatchOwner {
     prepareDispatch(record: ServiceMailboxRecord, signal: AbortSignal): boolean | Promise<boolean>;
 }
 export interface ServiceMailboxRecord {
+    receivedAt?: Date;
     readonly sourcePreparationOwner?: ServiceMailboxDispatchOwner;
     readonly ingress?: RawServiceIngressRecord;
     readonly owner: string;
@@ -15,7 +16,7 @@ export interface ServiceMailboxRecord {
     readonly requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
     readonly sourceRoute?: Uint8Array;
     readonly requestSequence?: bigint;
-    readonly reply?: (parts: readonly Uint8Array[]) => void;
+    readonly reply?: (parts: readonly (Uint8Array | string)[]) => void;
     readonly correlation?: bigint;
     readonly localReply?: (terminalResult: number, failureCode: number, payload?: {
         readonly packetName: string;
@@ -42,6 +43,7 @@ export interface ServiceMailboxRelocationSeal {
 /** Level-triggered queues with one active application claim per owner. */
 export declare class ServiceMailbox {
     private readonly onReady?;
+    private readonly receivedAtClock;
     private readonly application;
     private readonly infrastructure;
     private readonly relocationSeals;
@@ -49,7 +51,7 @@ export declare class ServiceMailbox {
     private nextClaimSerial;
     private nextRelocationSerial;
     private closed;
-    constructor(onReady?: ((domain: ServiceMailboxDomain) => void) | undefined);
+    constructor(onReady?: ((domain: ServiceMailboxDomain) => void) | undefined, receivedAtClock?: () => Date);
     releaseClaimedPayload(record: ServiceMailboxRecord): void;
     tryEnqueue(record: ServiceMailboxRecord): boolean;
     tryClaim(domain: ServiceMailboxDomain, messageBudget: number, byteBudget: number): ServiceMailboxClaim | undefined;

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

@@ -4,6 +4,7 @@ exports.ServiceMailbox = void 0;
 /** Level-triggered queues with one active application claim per owner. */
 class ServiceMailbox {
     onReady;
+    receivedAtClock;
     application;
     infrastructure;
     relocationSeals = new Map();
@@ -11,8 +12,9 @@ class ServiceMailbox {
     nextClaimSerial = 1n;
     nextRelocationSerial = 1n;
     closed = false;
-    constructor(onReady) {
+    constructor(onReady, receivedAtClock = () => new Date()) {
         this.onReady = onReady;
+        this.receivedAtClock = receivedAtClock;
         // Host ApplicationJobQueue permits own ordinary-record admission. The
         // Framework-owned payload lifetime does not retain Core HWM credit. A
         // second mailbox cap would reject already-admitted work before the shared
@@ -32,6 +34,7 @@ class ServiceMailbox {
         const bytes = retainedBytes(record);
         if (this.closed)
             return false;
+        record.receivedAt ??= this.receivedAtClock();
         if (record.domain === 'application') {
             if (this.relocatedOwners.has(record.owner))
                 return false;

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

@@ -16,7 +16,7 @@ export interface ServiceRelocationCaptureUnit {
     seal(signal?: AbortSignal): Promise<ServiceRelocationSealedWork>;
     captureApplicationState(signal?: AbortSignal): Promise<Uint8Array>;
     commitSeal(followAuthorities: ReadonlyMap<string, ZLinkAuthoritySnapshot>): Promise<void> | void;
-    abortSeal(): Promise<void> | void;
+    abortSeal(onCleanupError?: (error: unknown) => void): Promise<void> | void;
     /** Expired-owner terminal: pending requests fail once and dispatch stays closed. */
     discardSeal?(reason: unknown): Promise<void> | void;
 }
@@ -26,7 +26,7 @@ export declare class ServiceCapturedObjectRelocation {
     private terminal;
     constructor(envelope: ServiceRelocationEnvelope, units: readonly ServiceRelocationCaptureUnit[]);
     commitSource(followAuthorities: ReadonlyMap<string, ZLinkAuthoritySnapshot>): Promise<void>;
-    abortSource(): Promise<void>;
+    abortSource(onCleanupError?: (error: unknown) => void): Promise<void>;
     /**
      * The source owner lease ended before the authority settled (spec 28 §4.4):
      * the source neither resumes nor commits. Retained work is dropped and

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

@@ -20,14 +20,14 @@ class ServiceCapturedObjectRelocation {
             await unit.commitSeal(followAuthorities);
         this.terminal = 'committed';
     }
-    async abortSource() {
+    async abortSource(onCleanupError) {
         if (this.terminal === 'aborted')
             return;
         if (this.terminal !== 'open') {
             throw new Error(`A ${this.terminal} relocation source capture cannot be aborted.`);
         }
         try {
-            await abortSourceSeals(this.units);
+            await abortSourceSeals(this.units, onCleanupError);
         }
         finally {
             this.terminal = 'aborted';
@@ -126,18 +126,25 @@ class ServiceRelocationObjectCaptureOwner {
     }
 }
 exports.ServiceRelocationObjectCaptureOwner = ServiceRelocationObjectCaptureOwner;
-async function abortSourceSeals(units) {
+async function abortSourceSeals(units, onCleanupError) {
     const failures = [];
+    const cleanupFailures = [];
     for (const unit of [...units].reverse()) {
         try {
-            await unit.abortSeal();
+            await unit.abortSeal((error) => cleanupFailures.push(error));
         }
         catch (error) {
             failures.push(error);
         }
     }
     if (failures.length !== 0) {
-        throw new AggregateError(failures, 'Relocation source rollback was incomplete.');
+        throw new AggregateError([...failures, ...cleanupFailures], 'Relocation source rollback was incomplete.');
+    }
+    if (cleanupFailures.length !== 0) {
+        const cleanup = new AggregateError(cleanupFailures, 'Relocation source rollback was incomplete.');
+        if (onCleanupError === undefined)
+            throw cleanup;
+        onCleanupError(cleanup);
     }
 }
 /** Restores an exact User Spot aggregate or standalone Actor into hidden objects. */

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

@@ -1,3 +1,4 @@
+import type { PendingOperation } from './operation-registry';
 import type { RoutingId } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ApplicationJobPermitPort } from '../application-jobs/contracts';
@@ -213,6 +214,7 @@ export interface ZLinkMessageFollowOrigin {
     readonly target?: import('./service-stateful-wire-codec').ServiceActorRouteFence;
 }
 export interface ReceiveRecord {
+    readonly receivedAt?: Date;
     /** 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;
@@ -233,6 +235,7 @@ export interface ReceiveRecord {
     readonly kindData: ReceiveKindData | null;
     readonly terminalResult: number;
     readonly failureErrno: number;
+    readonly failureMessage?: string;
     readonly parts: Message[];
     /** Returns whether the local operation can still accept a lifecycle reply. */
     readonly isPending?: () => boolean;
@@ -250,7 +253,7 @@ export interface ReceiveRecord {
     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;
+    replyFailure?(terminalResult: number, failureCode: number, tail?: import('./service-stateful-wire-codec').ServiceStatefulReplyTail): SubmitResult;
 }
 export interface ClaimReceiveResult {
     readonly ok: boolean;
@@ -349,6 +352,7 @@ export interface ServiceSpot {
     requestToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         applicationMetadata?: Buffer;
         onAdmitted?: () => void;
     }): MeshOperationId;
@@ -360,11 +364,12 @@ export interface ServiceSpot {
     requestToSpot(targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         applicationMetadata?: Buffer;
         routeFence?: ServiceDirectSpotRouteFence;
         onAdmitted?: () => void;
         entrySpot?: boolean;
-    }): MeshOperationId;
+    }, completion?: import('../backend/mesh-completion-table').ZLinkMeshCompletionHandler): MeshOperationId;
     publish(channelName: string, topic: string, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
     }): Promise<void>;

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

@@ -119,6 +119,8 @@ export declare class ServiceStatefulRegistry {
     installSessionBinding(binding: ServiceSessionBinding): ServiceSessionBinding;
     binding(actor: ServiceActorRef): ServiceSessionBinding | undefined;
     private bindingCore;
+    /** The Actor owner admits each relayed Session sequence once per binding. */
+    acceptBoundSessionSequence(actor: ServiceActorRef, expectedBindingGeneration: bigint, sequence: bigint): boolean;
     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;
@@ -129,9 +131,11 @@ export declare class ServiceStatefulRegistry {
 }
 export declare const RELOCATION_REPLY_RETENTION_MS: number;
 export declare class ServiceTerminalOperationRegistry<T, Context = unknown> {
+    private readonly release;
     private readonly operations;
-    constructor(operations?: OperationRegistry<T, Context>);
-    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender', context?: Context): PendingOperation<T>;
+    constructor(operations?: OperationRegistry<T, Context>, release?: () => void);
+    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender', context?: Context, absoluteDeadlineMs?: number): PendingOperation<T>;
+    setContext(id: bigint, context: Context): void;
     reply(id: bigint, value: T, terminalContextRetentionMs?: number): boolean;
     fail(id: bigint, error: unknown): boolean;
     cancel(id: bigint): boolean;

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

@@ -246,7 +246,7 @@ class ServiceStatefulRegistry {
         });
         requireText(binding.sessionOwnerNodeRid, 'sessionOwnerNodeRid');
         requirePositive(binding.bindingGeneration, 'bindingGeneration');
-        const current = this.bindings.get(actorKey(binding.actor));
+        const current = this.bindings.get(actorKey(binding.actor))?.binding;
         if (current !== undefined &&
             current.sessionOwnerNodeRid === binding.sessionOwnerNodeRid &&
             current.sessionOwnerNodeGeneration === binding.sessionOwnerNodeGeneration &&
@@ -257,21 +257,34 @@ class ServiceStatefulRegistry {
             throw new ServiceStaleGenerationError('binding', binding.actor.actorId);
         }
         const accepted = Object.freeze({ ...binding });
-        this.bindings.set(actorKey(binding.actor), accepted);
+        this.bindings.set(actorKey(binding.actor), { binding: accepted, lastAcceptedSequence: 0n });
         return accepted;
     }
     binding(actor) {
         return this.bindingCore(actor);
     }
     bindingCore(actor) {
-        const binding = this.bindings.get(actorKey(actor));
+        const binding = this.bindings.get(actorKey(actor))?.binding;
         return binding?.actor.generation === actor.generation ? binding : undefined;
     }
+    /** The Actor owner admits each relayed Session sequence once per binding. */
+    acceptBoundSessionSequence(actor, expectedBindingGeneration, sequence) {
+        const entry = this.bindings.get(actorKey(actor));
+        if (entry === undefined ||
+            entry.binding.actor.generation !== actor.generation ||
+            entry.binding.bindingGeneration !== expectedBindingGeneration ||
+            sequence <= entry.lastAcceptedSequence) {
+            return false;
+        }
+        entry.lastAcceptedSequence = sequence;
+        return true;
+    }
     unbindSession(actor, expectedBindingGeneration, expectedSessionRid, expectedSessionOwnerNodeRid) {
         const key = actorKey(actor);
-        const binding = this.bindings.get(key);
-        if (binding === undefined)
+        const entry = this.bindings.get(key);
+        if (entry === undefined)
             return false;
+        const binding = entry.binding;
         if (binding.bindingGeneration !== expectedBindingGeneration ||
             (expectedSessionRid !== undefined &&
                 !(0, routing_id_1.routingIdsEqual)(binding.sessionRid, expectedSessionRid)) ||
@@ -387,14 +400,17 @@ class ServiceStatefulRegistry {
     }
     updateBindingMembership(actor) {
         const key = actorKey(actor.ref);
-        const binding = this.bindings.get(key);
-        if (binding === undefined)
+        const entry = this.bindings.get(key);
+        if (entry === undefined)
             return;
-        this.bindings.set(key, Object.freeze({
-            ...binding,
-            actor: actor.ref,
-            membershipEpoch: actor.membershipEpoch
-        }));
+        this.bindings.set(key, {
+            binding: Object.freeze({
+                ...entry.binding,
+                actor: actor.ref,
+                membershipEpoch: actor.membershipEpoch
+            }),
+            lastAcceptedSequence: entry.lastAcceptedSequence
+        });
     }
 }
 exports.ServiceStatefulRegistry = ServiceStatefulRegistry;
@@ -418,15 +434,20 @@ function createSpotState(ref, kind, stableType, authorityOwnerGeneration) {
 }
 exports.RELOCATION_REPLY_RETENTION_MS = 24 * 60 * 60 * 1_000;
 class ServiceTerminalOperationRegistry {
+    release;
     operations;
-    constructor(operations = new operation_registry_1.OperationRegistry()) {
+    constructor(operations = new operation_registry_1.OperationRegistry(), release = () => operations.close('Stateful runtime closed.')) {
+        this.release = release;
         this.operations = operations;
     }
-    register(timeoutMs, timeoutOwner = 'registry', context) {
-        return this.operations.register(timeoutMs, timeoutOwner, context);
+    register(timeoutMs, timeoutOwner = 'registry', context, absoluteDeadlineMs) {
+        return this.operations.register(timeoutMs, timeoutOwner, context, absoluteDeadlineMs);
+    }
+    setContext(id, context) {
+        this.operations.setContext(id, context);
     }
     reply(id, value, terminalContextRetentionMs = 0) {
-        return this.operations.complete(id, value, terminalContextRetentionMs);
+        return this.operations.reply(id, value, terminalContextRetentionMs);
     }
     fail(id, error) {
         return this.operations.fail(id, error);
@@ -450,7 +471,7 @@ class ServiceTerminalOperationRegistry {
         return this.operations.expire(nowMs, turnDeadlineMs);
     }
     close() {
-        this.operations.close('Stateful runtime closed.');
+        this.release();
     }
     failAll(reason) {
         this.operations.failAll(reason);