@zlink-systems/framework 0.27.0 → 0.29.0

package/dist/runtime/channels/source-spot-router.d.ts

@@ -5,6 +5,6 @@ export declare class ZLinkSourceSpotRouter {
     private readonly defaultRequestTimeoutMs;
     constructor(defaultRequestTimeoutMs: number | undefined);
     request<TReply>(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    send(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    send(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     requestRaw(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
 }

package/dist/runtime/channels/source-spot-router.js

@@ -26,14 +26,12 @@ class ZLinkSourceSpotRouter {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async send(sourceSpot, target, packetName, message, signal, metadata, timeoutMs) {
-        (0, abort_1.throwIfAborted)(signal);
+    async send(sourceSpot, target, packetName, message, metadata) {
         const parts = [
             (0, spot_direct_envelope_1.encodeSpotDirectEnvelope)(3 /* ZLinkChannelMessageKind.Command */, target.routerChannelId, packetName, message, metadata)
         ];
         try {
-            void timeoutMs;
-            await (0, abort_1.awaitWithAbort)(sourceSpot.sendToSpot(target.targetNodeRid, target.spotId, parts), signal);
+            await sourceSpot.sendToSpot(target.targetNodeRid, target.spotId, parts);
         }
         finally {
             (0, channel_envelope_1.closeMessages)(parts);

package/dist/runtime/channels/spot-node-route-transport.d.ts

@@ -7,7 +7,7 @@ export declare class ZLinkSpotNodeRouteTransport {
     private readonly registration;
     private readonly targets;
     constructor(registration: ZLinkFrameworkRegistration, targets: ZLinkSpotRouteTargetResolver);
-    send(target: ZLinkSpotRouteTarget, parts: readonly Message[], signal?: AbortSignal): Promise<boolean>;
+    send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<boolean>;
     request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply> | undefined;
     requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]> | undefined;
 }

package/dist/runtime/channels/spot-node-route-transport.js

@@ -11,14 +11,13 @@ class ZLinkSpotNodeRouteTransport {
         this.registration = registration;
         this.targets = targets;
     }
-    async send(target, parts, signal) {
+    async send(target, parts) {
         const router = this.targets.spotNodeRouter(target.routerChannelId);
         if (router === undefined) {
             return false;
         }
         try {
-            (0, abort_1.throwIfAborted)(signal);
-            await (0, abort_1.awaitWithAbort)(router.sendToSpot(target.targetNodeRid, target.spotId, parts), signal);
+            await router.sendToSpot(target.targetNodeRid, target.spotId, parts);
             return true;
         }
         finally {

package/dist/runtime/channels/spot-route-bridge-transport.d.ts

@@ -7,7 +7,7 @@ export declare class ZLinkSpotRouteBridgeTransport {
     private readonly defaultRequestTimeoutMs;
     constructor(bridges: ReadonlyMap<string, ZLinkBackendSpotRouteBridge>, defaultRequestTimeoutMs: number | undefined);
     has(routerChannelId: string): boolean;
-    send(target: ZLinkSpotRouteTarget, parts: readonly Message[], signal?: AbortSignal): Promise<void>;
+    send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<void>;
     request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
     requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
     private requireBridge;

package/dist/runtime/channels/spot-route-bridge-transport.js

@@ -15,10 +15,10 @@ class ZLinkSpotRouteBridgeTransport {
     has(routerChannelId) {
         return this.bridges.has(routerChannelId);
     }
-    async send(target, parts, signal) {
+    async send(target, parts) {
         const bridge = this.requireBridge(target.routerChannelId);
         try {
-            await (0, abort_1.awaitWithAbort)((0, channel_multipart_1.appendParts)(bridge.send(target.routerChannelId, target.targetNodeRid, target.spotId), parts).submit(), signal);
+            await (0, channel_multipart_1.appendParts)(bridge.send(target.routerChannelId, target.targetNodeRid, target.spotId), parts).submit();
         }
         finally {
             (0, channel_envelope_1.closeMessages)(parts);

package/dist/runtime/channels/spot-route-dispatch-strategy.d.ts

@@ -8,8 +8,6 @@ import type { ZLinkChannelSocketRegistry } from './channel-socket-registry';
 export interface ZLinkLocalSpotRouteDispatcher {
     send(spotId: RoutingId, packetName: string | undefined, message: unknown, context: {
         readonly channelName: string;
-        readonly admissionTimeoutMs?: number;
-        readonly signal?: AbortSignal;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<void>;
     request<TReply>(spotId: RoutingId, packetName: string | undefined, request: unknown, context: {
@@ -39,12 +37,12 @@ export declare class ZLinkSpotRouteDispatchStrategy {
     spotRouteNode(routerChannelId: string): ZLinkBackendSpotNode | undefined;
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
-    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     private routeSendToSpotScoped;
     routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     private routeRequestToSpotScoped;
     routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
     routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
 }

package/dist/runtime/channels/spot-route-dispatch-strategy.js

@@ -41,35 +41,34 @@ class ZLinkSpotRouteDispatchStrategy {
     canRoutePacketChannel(routerChannelId) {
         return this.targets.canRoutePacketChannel(routerChannelId);
     }
-    routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
+    routeSendToSpot(spotRouteTarget, packetName, message, metadata) {
         // Call-scoped flow (spec 27 §4): the envelope flow pair lives only for
         // the duration of this outbound call, never in the caller's context.
-        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeSendToSpotScoped(spotRouteTarget, packetName, message, signal, metadata, timeoutMs));
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeSendToSpotScoped(spotRouteTarget, packetName, message, metadata));
     }
-    async routeSendToSpotScoped(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        (0, abort_1.throwIfAborted)(signal);
+    async routeSendToSpotScoped(spotRouteTarget, packetName, message, metadata) {
         const localSpotRouteNode = this.targets.localRouteNode(spotRouteTarget);
         if (localSpotRouteNode !== undefined) {
-            await this.localTransport.send(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, message, signal, metadata, timeoutMs);
+            await this.localTransport.send(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, message, metadata);
             return;
         }
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, spotRouteTarget.routerChannelId, packetName, message, undefined, undefined, (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.options.codecs), undefined, this.options.flowCreationEnabled?.() ?? true, metadata);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId) &&
-            (await this.spotNodeTransport.send(spotRouteTarget, parts, signal))) {
+            (await this.spotNodeTransport.send(spotRouteTarget, parts))) {
             return;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            await this.bridgeTransport.send(spotRouteTarget, parts, signal);
+            await this.bridgeTransport.send(spotRouteTarget, parts);
             return;
         }
         if (this.targets.hasBoundRouteRouter(spotRouteTarget.routerChannelId)) {
-            await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT, signal);
+            await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
             return;
         }
-        if (await this.spotNodeTransport.send(spotRouteTarget, parts, signal)) {
+        if (await this.spotNodeTransport.send(spotRouteTarget, parts)) {
             return;
         }
-        await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT, signal);
+        await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
     }
     routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
         return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata));
@@ -102,8 +101,8 @@ class ZLinkSpotRouteDispatchStrategy {
     routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
         return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
     }
-    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
+        await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
     routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
         return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal);

package/dist/runtime/execution/serial-execution-queue.d.ts

@@ -36,20 +36,23 @@ export interface ZLinkSerialWorkPreparation {
  */
 export declare class ZLinkSerialExecutionQueue {
     private readonly executeRecord;
+    private readonly sharedOwner?;
     private readonly application;
     private readonly lifecycle;
     private activeLifecycle?;
+    private activeRecord?;
+    /** The admitted node itself owns ready membership; no second readiness flag. */
+    private ownerMembership?;
     private readonly ownerTimeBudget;
     private readonly lifecycleBurstLimit;
     private nextAcceptedSequence;
-    private draining;
-    private drainScheduled;
+    private readonly consumer?;
     private lifecycleStreak;
     private lifecycleDebt;
     private claimStartedAt?;
     private closed;
     private readonly idleWaiters;
-    constructor(executeRecord: (record: ZLinkSerialWorkRecord<unknown>) => Promise<void>, options?: ZLinkSerialSchedulerOptions);
+    constructor(executeRecord: (record: ZLinkSerialWorkRecord<unknown>) => Promise<void>, options?: ZLinkSerialSchedulerOptions, sharedOwner?: ZLinkSerialExecutionQueue | undefined);
     submit<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
     submitDetached<T>(operation: () => Promise<T> | T, onError: (error: unknown) => void, options?: ZLinkSerialWorkOptions, context?: unknown): void;
     /**
@@ -73,7 +76,13 @@ export declare class ZLinkSerialExecutionQueue {
     get admissionClosed(): boolean;
     private admit;
     private scheduleDrain;
+    /** Notifications carry no payload, admission sequence, result Promise, or host permit. */
+    private enqueueMailboxTurn;
+    /** Called only by the shared scheduler's consumer, never by a producer. */
+    private consumeMailbox;
+    private finishMailbox;
     private drain;
+    private prepareSelected;
     private selectNext;
     private takeSelected;
     private takeLifecycle;

package/dist/runtime/execution/serial-execution-queue.js

@@ -13,21 +13,25 @@ exports.ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS = Object.freeze({
  */
 class ZLinkSerialExecutionQueue {
     executeRecord;
+    sharedOwner;
     application;
     lifecycle;
     activeLifecycle;
+    activeRecord;
+    /** The admitted node itself owns ready membership; no second readiness flag. */
+    ownerMembership;
     ownerTimeBudget;
     lifecycleBurstLimit;
     nextAcceptedSequence = 1n;
-    draining = false;
-    drainScheduled = false;
+    consumer;
     lifecycleStreak = 0;
     lifecycleDebt = false;
     claimStartedAt;
     closed = false;
     idleWaiters = [];
-    constructor(executeRecord, options = {}) {
+    constructor(executeRecord, options = {}, sharedOwner) {
         this.executeRecord = executeRecord;
+        this.sharedOwner = sharedOwner;
         const configured = { ...exports.ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS, ...options };
         validateNonNegative(configured.ownerTimeBudget, 'ownerTimeBudget');
         validatePositive(configured.lifecycleBurstLimit, 'lifecycleBurstLimit');
@@ -35,6 +39,8 @@ class ZLinkSerialExecutionQueue {
         this.lifecycle = createLane();
         this.ownerTimeBudget = configured.ownerTimeBudget;
         this.lifecycleBurstLimit = configured.lifecycleBurstLimit;
+        if (sharedOwner === undefined)
+            this.consumer = { running: false, scheduled: false };
     }
     submit(operation, options = {}, context) {
         try {
@@ -79,11 +85,14 @@ class ZLinkSerialExecutionQueue {
         return this.admit(operation, { lane: 'lifecycle' }, context, undefined, true);
     }
     visitPendingApplication(visitor) {
-        for (const record of this.application.records)
-            visitor(record);
+        for (const record of this.application.records) {
+            if (record.mailbox === undefined)
+                visitor(record);
+        }
     }
     get hasPendingWork() {
-        return (this.draining ||
+        return (this.consumer?.running === true ||
+            this.activeRecord !== undefined ||
             this.activeLifecycle !== undefined ||
             this.application.records.length > 0 ||
             this.lifecycle.records.length > 0);
@@ -127,7 +136,7 @@ class ZLinkSerialExecutionQueue {
                 if (this.application.records.length > 0 || this.lifecycle.records.length > 0) {
                     this.scheduleDrain();
                 }
-                else if (!this.draining) {
+                else if (this.consumer?.running !== true) {
                     this.resolveIdleWaiters();
                 }
             }
@@ -176,18 +185,90 @@ class ZLinkSerialExecutionQueue {
         return result;
     }
     scheduleDrain() {
-        if (this.drainScheduled || this.draining)
+        if (this.sharedOwner !== undefined) {
+            if (this.activeRecord !== undefined)
+                return;
+            // Ready membership in the existing owner queue is the only notification state.
+            if (this.ownerMembership !== undefined)
+                return;
+            this.enqueueMailboxTurn(() => this.consumeMailbox());
+            return;
+        }
+        const consumer = this.consumer;
+        if (consumer.scheduled || consumer.running)
             return;
-        this.drainScheduled = true;
+        consumer.scheduled = true;
         queueMicrotask(() => {
-            this.drainScheduled = false;
+            consumer.scheduled = false;
             void this.drain();
         });
     }
+    /** Notifications carry no payload, admission sequence, result Promise, or host permit. */
+    enqueueMailboxTurn(operation) {
+        const entry = {
+            acceptedSequence: 0n,
+            lane: 'application',
+            mailbox: this,
+            operation,
+            operationEnvelope: false,
+            preparationState: 'ready',
+            resolve: unexpectedMailboxSettlement,
+            reject: unexpectedMailboxSettlement,
+            release: unexpectedMailboxSettlement,
+            fail: unexpectedMailboxSettlement
+        };
+        const owner = this.sharedOwner;
+        owner.application.records.push(entry);
+        this.ownerMembership = entry;
+        owner.scheduleDrain();
+    }
+    /** Called only by the shared scheduler's consumer, never by a producer. */
+    consumeMailbox() {
+        const selection = this.selectNext();
+        if (selection === undefined) {
+            if (!this.hasPendingWork)
+                this.resolveIdleWaiters();
+            return;
+        }
+        const record = selection.record;
+        if (!this.prepareSelected(selection))
+            return;
+        this.takeSelected(selection);
+        if (record.preparationState === 'failed') {
+            record.preparation?.cancel();
+            record.fail(record.preparationError);
+            this.scheduleDrain();
+            return;
+        }
+        this.activeRecord = record;
+        // The operation can submit Spot turns, including Yield continuations. Its
+        // Actor claim remains held until terminal settlement returns to this gate.
+        let terminal;
+        try {
+            terminal = Promise.resolve(record.operation());
+        }
+        catch (error) {
+            terminal = Promise.reject(error);
+        }
+        void terminal.then((value) => this.finishMailbox(record, () => record.resolve(value)), (error) => this.finishMailbox(record, () => record.reject(error)));
+    }
+    finishMailbox(record, settle) {
+        this.enqueueMailboxTurn(() => {
+            settle();
+            record.release();
+            record.preparation?.cancel();
+            this.activeRecord = undefined;
+            if (this.selectNext() !== undefined)
+                this.scheduleDrain();
+            else if (!this.hasPendingWork)
+                this.resolveIdleWaiters();
+        });
+    }
     async drain() {
-        if (this.draining)
+        const consumer = this.consumer;
+        if (consumer.running)
             return;
-        this.draining = true;
+        consumer.running = true;
         let waitingForPreparation = false;
         try {
             for (;;) {
@@ -195,20 +276,7 @@ class ZLinkSerialExecutionQueue {
                 if (selection === undefined)
                     break;
                 const record = selection.record;
-                if (selection.lane === 'lifecycle') {
-                    const applicationHead = this.application.records[0];
-                    if (this.application.records.length > 0 &&
-                        !this.cancelPreparationForRearbitration(applicationHead)) {
-                        waitingForPreparation = true;
-                        break;
-                    }
-                }
-                if (record.preparationState === 'idle') {
-                    this.startPreparation(record);
-                    waitingForPreparation = true;
-                    break;
-                }
-                if (record.preparationState === 'pending' || record.preparationState === 'canceling') {
+                if (!this.prepareSelected(selection)) {
                     waitingForPreparation = true;
                     break;
                 }
@@ -220,7 +288,10 @@ class ZLinkSerialExecutionQueue {
                 }
                 this.claimStartedAt ??= performance.now();
                 try {
-                    if (record.operationEnvelope) {
+                    if (record.mailbox !== undefined) {
+                        record.operation();
+                    }
+                    else if (record.operationEnvelope) {
                         try {
                             const outcome = record.operation();
                             void Promise.resolve(outcome).then((value) => {
@@ -240,6 +311,8 @@ class ZLinkSerialExecutionQueue {
                     }
                 }
                 catch (error) {
+                    if (record.mailbox !== undefined)
+                        throw error;
                     record.fail(error);
                 }
                 finally {
@@ -252,7 +325,7 @@ class ZLinkSerialExecutionQueue {
             }
         }
         finally {
-            this.draining = false;
+            consumer.running = false;
             this.claimStartedAt = undefined;
             if (!waitingForPreparation && this.selectNext() !== undefined) {
                 this.scheduleDrain();
@@ -264,6 +337,16 @@ class ZLinkSerialExecutionQueue {
             }
         }
     }
+    prepareSelected(selection) {
+        if (selection.lane === 'lifecycle' &&
+            this.application.records.length > 0 &&
+            !this.cancelPreparationForRearbitration(this.application.records[0]))
+            return false;
+        const record = selection.record;
+        if (record.preparationState === 'idle')
+            this.startPreparation(record);
+        return record.preparationState !== 'pending' && record.preparationState !== 'canceling';
+    }
     selectNext() {
         const lifecycleOwner = this.activeLifecycle?.context;
         const applicationRecord = lifecycleOwner === undefined
@@ -291,6 +374,8 @@ class ZLinkSerialExecutionQueue {
         if (record !== selection.record) {
             throw new Error('The selected serial work record changed before owner claim.');
         }
+        if (selection.record.mailbox !== undefined)
+            selection.record.mailbox.ownerMembership = undefined;
         return record;
     }
     takeLifecycle() {
@@ -402,6 +487,9 @@ function createLane() {
         records: []
     };
 }
+function unexpectedMailboxSettlement() {
+    throw new Error('A mailbox notification has no independent terminal result.');
+}
 function validatePositive(value, field) {
     if (!Number.isSafeInteger(value) || value < 1) {
         throw new RangeError(`${field} must be a positive safe integer.`);

package/dist/runtime/foundation/operation-registry.d.ts

@@ -14,7 +14,7 @@ export interface PendingOperation<T> {
     readonly promise: Promise<T>;
 }
 /** Owns request completion so reply, timeout, cancellation, and shutdown race safely. */
-export declare class OperationRegistry<T> {
+export declare class OperationRegistry<T, Context = unknown> {
     private readonly clock;
     private readonly onPendingChanged?;
     private readonly entries;
@@ -22,11 +22,12 @@ export declare class OperationRegistry<T> {
     private deadlineCursor?;
     private closed;
     constructor(clock?: OperationClock, onPendingChanged?: (() => void) | undefined);
-    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
+    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender', context?: Context): PendingOperation<T>;
     complete(id: bigint, value: T): boolean;
     fail(id: bigint, reason: unknown): boolean;
     cancel(id: bigint, message?: string): boolean;
     isPending(id: bigint): boolean;
+    context(id: bigint): Context | undefined;
     close(reason?: string): void;
     get size(): number;
     expire(nowMs: number, turnDeadlineMs: number): number;

package/dist/runtime/foundation/operation-registry.js

@@ -34,7 +34,7 @@ class OperationRegistry {
         this.clock = clock;
         this.onPendingChanged = onPendingChanged;
     }
-    register(timeoutMs, timeoutOwner = 'registry') {
+    register(timeoutMs, timeoutOwner = 'registry', context) {
         if (this.closed)
             throw new Error('Operation registry is closed.');
         if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
@@ -48,6 +48,7 @@ class OperationRegistry {
             reject = onReject;
         });
         const entry = {
+            context,
             deadlineMs: timeoutOwner === 'registry' ? this.clock.now() + timeoutMs : undefined,
             resolve,
             reject
@@ -77,6 +78,9 @@ class OperationRegistry {
     isPending(id) {
         return this.entries.has(id);
     }
+    context(id) {
+        return this.entries.get(id)?.context;
+    }
     close(reason = 'Operation registry closed.') {
         if (this.closed)
             return;

package/dist/runtime/foundation/raw-service-mesh-runtime.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RawServiceMeshRuntime = exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS = void 0;
 const node_os_1 = require("node:os");
 const application_ingress_record_owner_1 = require("../application-jobs/application-ingress-record-owner");
+const submission_result_1 = require("../messaging/submission-result");
 const runtime_values_1 = require("../backend/runtime-values");
 const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
 const operation_registry_1 = require("./operation-registry");
@@ -564,16 +565,16 @@ class RawServiceMeshRuntime {
                 const record = livenessCodec.decodeLivenessRecord(received.parts[0]);
                 if (record.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe) {
                     const ack = this.liveness.acknowledgeProbe(received.sourceRid, peer.connectionId, record.probeId);
-                    const sent = ack !== undefined &&
-                        (await this.send(received.sourceRid, [
-                            livenessCodec.encodeLivenessRecord({
-                                command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck,
-                                probeId: record.probeId
-                            })
-                        ]));
-                    if (!sent) {
+                    if (ack === undefined)
                         return 'protocolError';
-                    }
+                    const sent = await this.send(received.sourceRid, [
+                        livenessCodec.encodeLivenessRecord({
+                            command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck,
+                            probeId: record.probeId
+                        })
+                    ]);
+                    if (!sent)
+                        return 'dropped';
                 }
                 else {
                     this.liveness.acknowledge(received.sourceRid, peer.connectionId, record.probeId, nowMs);
@@ -962,8 +963,13 @@ class RawServiceMeshRuntime {
             await this.requireStarted().send(targetNodeRoutingId, parts);
             return true;
         }
-        catch {
-            return false;
+        catch (error) {
+            if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
+                const terminal = (0, submission_result_1.submitToRequestResult)(error.result, error.phase);
+                if (terminal === runtime_values_1.RequestResult.NotConnected || terminal === runtime_values_1.RequestResult.NotFound)
+                    return false;
+            }
+            throw error;
         }
     }
 }

package/dist/runtime/foundation/service-authority-payload-codec.d.ts

@@ -42,8 +42,6 @@ export interface ServiceUserSpotAuthorityPayload {
     readonly ownerNodeRid: string;
     readonly ownerNodeGeneration: bigint;
 }
-/** Replaces only authority-relocation-state and preserves the canonical owner payload. */
-export declare function replaceServiceAuthorityRelocationState(payload: Uint8Array, relocationState: Uint8Array): Buffer;
 export declare function encodeServiceUserSpotAuthorityPayload(value: ServiceUserSpotAuthorityPayload): Buffer;
 export declare function encodeServiceInstanceAuthorityPayload(value: ServiceInstanceAuthorityPayload): Buffer;
 export declare function decodeServiceReadySpotAuthority(payload: Uint8Array): ServiceReadySpotAuthority | undefined;

package/dist/runtime/foundation/service-authority-payload-codec.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceServiceAuthorityRelocationState = replaceServiceAuthorityRelocationState;
 exports.encodeServiceUserSpotAuthorityPayload = encodeServiceUserSpotAuthorityPayload;
 exports.encodeServiceInstanceAuthorityPayload = encodeServiceInstanceAuthorityPayload;
 exports.decodeServiceReadySpotAuthority = decodeServiceReadySpotAuthority;
@@ -21,48 +20,6 @@ const AUTHORITY_MAGIC = Buffer.from([0x5a, 0x4c, 0x41, 0x55]);
 const AUTHORITY_FORMAT_VERSION = 1;
 const AUTHORITY_FLAGS = 0;
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
-/** Replaces only authority-relocation-state and preserves the canonical owner payload. */
-function replaceServiceAuthorityRelocationState(payload, relocationState) {
-    const bytes = Buffer.from(payload);
-    const reader = new AuthorityReader(bytes);
-    reader.expect(AUTHORITY_MAGIC);
-    if (reader.u8() !== AUTHORITY_FORMAT_VERSION || reader.u16() !== AUTHORITY_FLAGS) {
-        throw new TypeError('Authority payload header is invalid.');
-    }
-    const bodyLength = reader.u32();
-    const body = reader.takeReader(bodyLength);
-    const checksumOffset = reader.offset;
-    const checksum = reader.u32();
-    if (!reader.done || (0, service_relocation_runtime_1.crc32c)(bytes.subarray(0, checksumOffset)) !== checksum) {
-        throw new TypeError('Authority payload checksum is invalid.');
-    }
-    body.u8();
-    body.u8();
-    body.skip(body.u16());
-    body.text8();
-    body.nonZeroU64();
-    body.text8();
-    body.rid();
-    body.nonZeroU64();
-    const relocationOffset = body.offset;
-    body.bool8();
-    body.skip(body.u32());
-    const relocationEnd = body.offset;
-    const currentBody = bytes.subarray(11, 11 + bodyLength);
-    const nextBody = Buffer.concat([
-        currentBody.subarray(0, relocationOffset),
-        Buffer.from(relocationState),
-        currentBody.subarray(relocationEnd)
-    ]);
-    const envelope = Buffer.concat([
-        AUTHORITY_MAGIC,
-        Buffer.of(AUTHORITY_FORMAT_VERSION),
-        u16(AUTHORITY_FLAGS),
-        u32(nextBody.byteLength),
-        nextBody
-    ]);
-    return Buffer.concat([envelope, u32((0, service_relocation_runtime_1.crc32c)(envelope))]);
-}
 function encodeServiceUserSpotAuthorityPayload(value) {
     const spot = conditional(2, concat(rid(value.spotId, 'spotId'), text8(value.stableType, 'stableType'), Buffer.of(1)));
     const object = conditional(2, spot);

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

@@ -129,14 +129,15 @@ export declare class ServiceStatefulRegistry {
     runTurn<T>(owner: string, work: () => T | Promise<T>): Promise<T>;
     private updateBindingMembership;
 }
-export declare class ServiceTerminalOperationRegistry<T> {
+export declare class ServiceTerminalOperationRegistry<T, Context = unknown> {
     private readonly operations;
-    constructor(operations?: OperationRegistry<T>);
-    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
+    constructor(operations?: OperationRegistry<T, Context>);
+    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender', context?: Context): PendingOperation<T>;
     reply(id: bigint, value: T): boolean;
     fail(id: bigint, error: unknown): boolean;
     cancel(id: bigint): boolean;
     isPending(id: bigint): boolean;
+    context(id: bigint): Context | undefined;
     get size(): number;
     expire(nowMs: number, turnDeadlineMs: number): number;
     close(): void;