@zlink-systems/framework 0.30.0 → 0.30.2

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

@@ -84,12 +84,20 @@ class ZLinkSerialExecutionQueue {
     submitLifecycleOperation(operation, context) {
         return this.admit(operation, { lane: 'lifecycle' }, context, undefined, true);
     }
+    get retainsApplicationForLifecycle() {
+        return this.activeLifecycle?.context !== undefined;
+    }
     visitPendingApplication(visitor) {
         for (const record of this.application.records) {
             if (record.mailbox === undefined)
                 visitor(record);
         }
     }
+    get hasPendingDurableApplication() {
+        // Every application record accepted behind durable work inherits durable
+        // ownership, so the tail answers this without scanning the FIFO.
+        return this.application.records.at(-1)?.preparation !== undefined;
+    }
     get hasPendingWork() {
         return (this.consumer?.running === true ||
             this.activeRecord !== undefined ||
@@ -181,6 +189,18 @@ class ZLinkSerialExecutionQueue {
             release();
             throw error;
         }
+        options.onAdmitted?.();
+        options.onWithdrawable?.(() => {
+            const index = target.records.indexOf(record);
+            if (index < 0)
+                return false;
+            target.records.splice(index, 1);
+            record.preparationController?.abort(new Error('Durable record transferred to another handoff.'));
+            record.preparation?.cancel();
+            resolve(undefined);
+            release();
+            return true;
+        });
         this.scheduleDrain();
         return result;
     }
@@ -198,10 +218,10 @@ class ZLinkSerialExecutionQueue {
         if (consumer.scheduled || consumer.running)
             return;
         consumer.scheduled = true;
-        queueMicrotask(() => {
+        (0, state_lane_1.startOutsideStateLane)(() => queueMicrotask(() => {
             consumer.scheduled = false;
             void this.drain();
-        });
+        }));
     }
     /** Notifications carry no payload, admission sequence, result Promise, or host permit. */
     enqueueMailboxTurn(operation) {

package/dist/runtime/execution/state-lane.d.ts

@@ -1,5 +1,7 @@
 type ZLinkStateLaneWork<T> = () => Promise<T> | T;
 export declare function isStructuralGuardEnabled(): boolean;
+/** Detaches lane ownership while preserving the caller's other execution contexts. */
+export declare function startOutsideStateLane<T>(work: () => T): T;
 /**
  * Single-owner execution lane for a component's mutable state.
  *

package/dist/runtime/execution/state-lane.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkStateLane = void 0;
 exports.isStructuralGuardEnabled = isStructuralGuardEnabled;
+exports.startOutsideStateLane = startOutsideStateLane;
 exports.guardStateLaneCompletion = guardStateLaneCompletion;
 exports.trackDiagnosticCompletion = trackDiagnosticCompletion;
 exports.debugPendingWorkNames = debugPendingWorkNames;
@@ -11,6 +12,10 @@ const UNKNOWN_DIAGNOSTIC_CALLER = '<unknown caller>';
 function isStructuralGuardEnabled() {
     return process.env.ZLINK_NODE_STRUCTURAL_GUARD === '1' || process.env.NODE_ENV === 'test';
 }
+/** Detaches lane ownership while preserving the caller's other execution contexts. */
+function startOutsideStateLane(work) {
+    return currentLaneStorage.exit(() => diagnosticTurnStorage === undefined ? work() : diagnosticTurnStorage.exit(work));
+}
 const currentLaneStorage = new node_async_hooks_1.AsyncLocalStorage();
 const diagnosticPending = isStructuralGuardEnabled() ? new Map() : undefined;
 let nextDiagnosticWork = 0;

package/dist/runtime/foundation/actor-join-recovery-codec.js

@@ -56,7 +56,7 @@ function encodeCanonicalActorJoinRecoverySavedWork(input) {
     const request = Buffer.from(input.request);
     const replyContentType = operationId === undefined
         ? null
-        : requireText(input.replyContentType, 'Actor Join reply content type');
+        : (nullableText(input.replyContentType ?? null, 'Actor Join reply content type') ?? null);
     const metadata = encodeMetadataJson({
         Request: {
             ActorId: requireText(input.actorId, 'Actor id'),
@@ -167,7 +167,7 @@ function decodeCanonicalActorJoinRecoverySavedWork(encoded) {
     const operationLow = integer(metadata.OperationIdLow, 'OperationIdLow');
     const hasOperation = operationHigh !== 0n || operationLow !== 0n;
     const replyContentType = nullableText(metadata.ReplyContentType, 'ReplyContentType');
-    if (hasOperation !== (replyContentType !== undefined)) {
+    if (!hasOperation && replyContentType !== undefined) {
         throw new TypeError('Canonical Actor Join recovery reply identity is invalid.');
     }
     const targetNodeRid = base64(metadata.TargetNodeRid, 'TargetNodeRid');

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

@@ -0,0 +1,14 @@
+export interface PeerRouteObservation {
+    readonly generation?: bigint;
+    readonly ready: boolean;
+}
+export interface DurableServiceRequestPort {
+    readonly requestStopSignal?: AbortSignal;
+    observePeerRoute(target: string): PeerRouteObservation;
+    observePeerRouteChanged(listener: (target: string) => void): () => void;
+    observePeerConnectionIntentRemoved(listener: (target: string) => void): () => void;
+    requestService(target: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
+}
+/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
+export declare function requestDurableService(port: DurableServiceRequestPort, target: string, parts: readonly Uint8Array[], deadlineMs: number, operationKind: string, signal?: AbortSignal, onSubmitted?: (signal: AbortSignal) => Promise<void>): Promise<readonly Buffer[]>;
+export declare function durableRequestCanReplay(error: unknown): boolean;

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestDurableService = requestDurableService;
+exports.durableRequestCanReplay = durableRequestCanReplay;
+const abort_1 = require("../abort");
+const runtime_values_1 = require("../backend/runtime-values");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
+async function requestDurableService(port, target, parts, deadlineMs, operationKind, signal, onSubmitted) {
+    let wasAdmitted = false;
+    const stop = new AbortController();
+    const exhausted = (cause) => (0, framework_errors_internal_1.createInternalFrameworkException)(wasAdmitted
+        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded
+        : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} exhausted its end-to-end deadline.`, true, cause);
+    const timer = setTimeout(() => stop.abort(exhausted()), Math.max(0, Math.ceil(deadlineMs - performance.now())));
+    const unobserveIntent = port.observePeerConnectionIntentRemoved((rid) => {
+        if (rid === target)
+            stop.abort((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} target node lifecycle ended.`, true));
+    });
+    const cancellation = AbortSignal.any([
+        stop.signal,
+        ...(signal === undefined ? [] : [signal]),
+        ...(port.requestStopSignal === undefined ? [] : [port.requestStopSignal])
+    ]);
+    try {
+        for (;;) {
+            cancellation.throwIfAborted();
+            const remainingMs = Math.ceil(deadlineMs - performance.now());
+            if (remainingMs <= 0)
+                throw exhausted();
+            let changed;
+            const transition = new Promise((resolve) => {
+                changed = resolve;
+            });
+            let submittedGeneration;
+            const attemptStop = new AbortController();
+            const attemptSignal = AbortSignal.any([cancellation, attemptStop.signal]);
+            const unobserveRoute = port.observePeerRouteChanged((rid) => {
+                if (rid !== target)
+                    return;
+                const route = port.observePeerRoute(target);
+                if (submittedGeneration === undefined
+                    ? route.ready
+                    : route.generation !== undefined && route.generation !== submittedGeneration) {
+                    changed();
+                    attemptStop.abort();
+                }
+            });
+            try {
+                const route = port.observePeerRoute(target);
+                if (!route.ready) {
+                    await (0, abort_1.awaitWithAbort)(transition, cancellation);
+                    continue;
+                }
+                submittedGeneration = route.generation;
+                const reply = port.requestService(target, parts, remainingMs, () => {
+                    wasAdmitted = true;
+                });
+                const request = onSubmitted === undefined
+                    ? reply
+                    : Promise.race([
+                        reply,
+                        Promise.resolve()
+                            .then(() => onSubmitted(attemptSignal))
+                            .then(() => reply)
+                    ]);
+                const result = await (0, abort_1.awaitWithAbort)(Promise.race([request.then((parts) => ({ parts })), transition.then(() => undefined)]), cancellation);
+                if (result !== undefined)
+                    return result.parts;
+            }
+            catch (error) {
+                cancellation.throwIfAborted();
+                if (!durableRequestCanReplay(error))
+                    throw error;
+                if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request')
+                    wasAdmitted = true;
+            }
+            finally {
+                attemptStop.abort();
+                unobserveRoute();
+            }
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        unobserveIntent();
+    }
+}
+function durableRequestCanReplay(error) {
+    if (!(0, runtime_values_1.isZLinkBackendResultError)(error))
+        return false;
+    return error.operation === 'request'
+        ? error.result === runtime_values_1.RequestResult.NotConnected || error.result === runtime_values_1.RequestResult.TimedOut
+        : error.result === runtime_values_1.SubmitResult.NotConnected ||
+            error.result === runtime_values_1.SubmitResult.NotFound ||
+            error.result === runtime_values_1.SubmitResult.NotAdmitted ||
+            error.result === runtime_values_1.SubmitResult.Backpressured;
+}

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

@@ -10,5 +10,6 @@ export type ZLinkOperationIdentityKey = string & {
     readonly [operationKeyBrand]: true;
 };
 export declare function operationIdentityKey(operationId: ZLinkOperationIdentity128): ZLinkOperationIdentityKey;
+export declare function validateOperationIdentity(operationId: ZLinkOperationIdentity128): void;
 export declare function createRandomOperationIdentity(source?: (size: number) => Buffer): ZLinkOperationIdentity128;
 export {};

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

@@ -2,18 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = exports.OPERATION_IDENTITY_BYTES = void 0;
 exports.operationIdentityKey = operationIdentityKey;
+exports.validateOperationIdentity = validateOperationIdentity;
 exports.createRandomOperationIdentity = createRandomOperationIdentity;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
 exports.OPERATION_IDENTITY_BYTES = 16;
 exports.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = 2n;
 function operationIdentityKey(operationId) {
+    validateOperationIdentity(operationId);
+    return `${operationId.high.toString(16)}:${operationId.low.toString(16)}`;
+}
+function validateOperationIdentity(operationId) {
     requireUnsigned64(operationId.high, 'operationId.high');
     requireUnsigned64(operationId.low, 'operationId.low');
     if (operationId.high === 0n && operationId.low === 0n) {
         throw new RangeError('Operation identity must not be all zero.');
     }
-    return `${operationId.high.toString(16)}:${operationId.low.toString(16)}`;
 }
 function createRandomOperationIdentity(source = node_crypto_1.randomBytes) {
     for (;;) {

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

@@ -13,6 +13,15 @@ export interface PendingOperation<T> {
     readonly id: bigint;
     readonly promise: Promise<T>;
 }
+/**
+ * Receives an operation's terminal at the place it is taken from the
+ * registry. One long-lived observer serves every observed operation, so an
+ * observed registration creates no Promise or per-operation callback.
+ */
+export interface OperationObserver<T, Context> {
+    operationCompleted(id: bigint, value: T, context: Context | undefined): void;
+    operationFailed(id: bigint, reason: unknown, context: Context | undefined): void;
+}
 /** Owns request completion so reply, timeout, cancellation, and shutdown race safely. */
 export declare class OperationRegistry<T, Context = unknown> {
     private readonly clock;
@@ -20,16 +29,31 @@ export declare class OperationRegistry<T, Context = unknown> {
     private readonly entries;
     private nextId;
     private deadlineCursor?;
+    /**
+     * A lower bound of the earliest pending deadline. Completed entries only
+     * leave it early; a full expiry pass replaces it with the exact value.
+     */
+    private earliestDeadlineMs;
+    private scanEarliestDeadlineMs;
     private closed;
+    private pendingCount;
     constructor(clock?: OperationClock, onPendingChanged?: (() => void) | undefined);
     register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender', context?: Context): PendingOperation<T>;
-    complete(id: bigint, value: T): boolean;
+    /** Registers an operation whose terminal goes to `observer` instead of a Promise. */
+    registerObserved(timeoutMs: number, observer: OperationObserver<T, Context>, context?: Context): bigint;
+    /** The time the next expiry pass has work, as a lower bound (spec 08 §4.2). */
+    nextDeadlineMs(): number;
+    private notePending;
+    complete(id: bigint, value: T, terminalContextRetentionMs?: number): 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;
+    failAll(reason: unknown): void;
     get size(): number;
     expire(nowMs: number, turnDeadlineMs: number): number;
     private take;
+    private pendingEntry;
+    private retainTerminal;
 }

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

@@ -29,7 +29,14 @@ class OperationRegistry {
     entries = new Map();
     nextId = 1n;
     deadlineCursor;
+    /**
+     * A lower bound of the earliest pending deadline. Completed entries only
+     * leave it early; a full expiry pass replaces it with the exact value.
+     */
+    earliestDeadlineMs = Number.POSITIVE_INFINITY;
+    scanEarliestDeadlineMs = Number.POSITIVE_INFINITY;
     closed = false;
+    pendingCount = 0;
     constructor(clock = systemClock, onPendingChanged) {
         this.clock = clock;
         this.onPendingChanged = onPendingChanged;
@@ -47,36 +54,63 @@ class OperationRegistry {
             resolve = onResolve;
             reject = onReject;
         });
-        const entry = {
-            context,
-            deadlineMs: timeoutOwner === 'registry' ? this.clock.now() + timeoutMs : undefined,
-            resolve,
-            reject
-        };
+        const deadlineMs = timeoutOwner === 'registry' ? this.clock.now() + timeoutMs : undefined;
+        const entry = { context, deadlineMs, resolve, reject };
         this.entries.set(id, entry);
-        if (this.entries.size === 1)
-            this.onPendingChanged?.();
+        this.notePending(deadlineMs);
         return { id, promise };
     }
-    complete(id, value) {
+    /** Registers an operation whose terminal goes to `observer` instead of a Promise. */
+    registerObserved(timeoutMs, observer, context) {
+        if (this.closed)
+            throw new Error('Operation registry is closed.');
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new RangeError('timeoutMs must be a non-negative finite number.');
+        }
+        const id = this.nextId++;
+        const deadlineMs = this.clock.now() + timeoutMs;
+        this.entries.set(id, { context, deadlineMs, observer });
+        this.notePending(deadlineMs);
+        return id;
+    }
+    /** The time the next expiry pass has work, as a lower bound (spec 08 §4.2). */
+    nextDeadlineMs() {
+        return this.earliestDeadlineMs;
+    }
+    notePending(deadlineMs) {
+        this.pendingCount++;
+        const earlier = deadlineMs !== undefined && deadlineMs < this.earliestDeadlineMs;
+        if (earlier)
+            this.earliestDeadlineMs = deadlineMs;
+        if (earlier || this.pendingCount === 1)
+            this.onPendingChanged?.();
+    }
+    complete(id, value, terminalContextRetentionMs = 0) {
         const entry = this.take(id);
         if (entry === undefined)
             return false;
-        entry.resolve(value);
+        if (entry.observer !== undefined)
+            entry.observer.operationCompleted(id, value, entry.context);
+        else
+            entry.resolve(value);
+        this.retainTerminal(id, entry, terminalContextRetentionMs);
         return true;
     }
     fail(id, reason) {
         const entry = this.take(id);
         if (entry === undefined)
             return false;
-        entry.reject(reason);
+        if (entry.observer !== undefined)
+            entry.observer.operationFailed(id, reason, entry.context);
+        else
+            entry.reject(reason);
         return true;
     }
     cancel(id, message) {
         return this.fail(id, new OperationCancelledError(id, message));
     }
     isPending(id) {
-        return this.entries.has(id);
+        return this.pendingEntry(id) !== undefined;
     }
     context(id) {
         return this.entries.get(id)?.context;
@@ -87,36 +121,70 @@ class OperationRegistry {
         this.closed = true;
         for (const id of this.entries.keys())
             this.cancel(id, reason);
+        this.entries.clear();
         this.deadlineCursor = undefined;
     }
+    failAll(reason) {
+        for (const id of this.entries.keys())
+            this.fail(id, reason);
+    }
     get size() {
-        return this.entries.size;
+        return this.pendingCount;
     }
     expire(nowMs, turnDeadlineMs) {
         let expired = 0;
         while (this.clock.now() < turnDeadlineMs) {
-            this.deadlineCursor ??= this.entries.entries();
+            if (this.deadlineCursor === undefined) {
+                this.deadlineCursor = this.entries.entries();
+                this.scanEarliestDeadlineMs = Number.POSITIVE_INFINITY;
+            }
             const current = this.deadlineCursor.next();
             if (current.done === true) {
                 this.deadlineCursor = undefined;
+                // Entries registered during the pass are appended and were scanned.
+                this.earliestDeadlineMs = this.scanEarliestDeadlineMs;
                 break;
             }
             const [id, entry] = current.value;
-            if (entry.deadlineMs !== undefined && entry.deadlineMs <= nowMs) {
-                if (this.fail(id, new OperationTimeoutError(id)))
+            if (entry.deadlineMs === undefined)
+                continue;
+            if (entry.deadlineMs <= nowMs) {
+                if (!this.isPending(id))
+                    this.entries.delete(id);
+                else if (this.fail(id, new OperationTimeoutError(id)))
                     expired++;
             }
+            else if (entry.deadlineMs < this.scanEarliestDeadlineMs) {
+                this.scanEarliestDeadlineMs = entry.deadlineMs;
+            }
         }
         return expired;
     }
     take(id) {
-        const entry = this.entries.get(id);
+        const entry = this.pendingEntry(id);
         if (entry === undefined)
             return undefined;
         this.entries.delete(id);
-        if (this.entries.size === 0)
+        this.pendingCount--;
+        if (this.pendingCount === 0)
             this.onPendingChanged?.();
         return entry;
     }
+    pendingEntry(id) {
+        const entry = this.entries.get(id);
+        return entry !== undefined && (entry.resolve !== undefined || entry.observer !== undefined)
+            ? entry
+            : undefined;
+    }
+    retainTerminal(id, entry, retentionMs) {
+        if (this.closed || entry.context === undefined || retentionMs === 0)
+            return;
+        entry.resolve = undefined;
+        entry.reject = undefined;
+        entry.observer = undefined;
+        entry.deadlineMs = this.clock.now() + retentionMs;
+        this.entries.set(id, entry);
+        this.earliestDeadlineMs = Math.min(this.earliestDeadlineMs, entry.deadlineMs);
+    }
 }
 exports.OperationRegistry = OperationRegistry;

package/dist/runtime/foundation/raw-service-mesh-runtime.d.ts

@@ -2,7 +2,7 @@ import { ApplicationIngressRecordOwner } from '../application-jobs/application-i
 import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
 import type { ZLinkRawBindingPort } from '../backend/raw-binding-port';
 import { SubmitResult } from '../backend/runtime-values';
-import { type PendingOperation } from './operation-registry';
+import { type OperationObserver, type PendingOperation } from './operation-registry';
 import { ServiceLivenessRegistry, type ServiceLivenessTick } from './service-liveness-registry';
 import { ServiceMailbox, type ServiceMailboxRecord } from './service-mailbox';
 import { ServiceTopologyRegistry, type ServiceNodeDescriptor } from './service-topology-registry';
@@ -14,9 +14,23 @@ export interface RawServiceRequestResult {
     readonly failureCode: number;
     readonly payload?: ServiceApplicationPayload;
 }
+/** Receives observed request terminals; the context is the caller's operation kind. */
+export type RawServiceRequestObserver = OperationObserver<RawServiceRequestResult, number>;
+/**
+ * A registered request. An observed remote request has no Promise; its
+ * terminal reaches the observer. Local and Promise-contract requests carry
+ * the Promise.
+ */
+export interface RawServiceObservedRequest {
+    readonly id: bigint;
+    readonly promise?: Promise<RawServiceRequestResult>;
+}
 /** An M6A application frame already owned by the Framework runtime. */
 type ServiceApplicationPayloadInput = ServiceApplicationPayload | Buffer;
 export interface RawServiceIngressRecord {
+    /** Source identity recorded once by the first accepting owner (Location runtime §9.3). */
+    requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
+    readonly onAdmitted?: () => void;
     readonly command: number;
     readonly flags: number;
     readonly sourceRoutingId: string;
@@ -63,6 +77,7 @@ export declare class RawServiceMeshRuntime {
     private readonly expectedPeers;
     private readonly endpointOnlyPeers;
     private readonly peerConnectionIntentRemoved;
+    private readonly peerRouteChanged;
     /**
      * The last observed Core selected route of each RID (Core ROUTER §10.1):
      * RID -> route generation. Only `observeSelectedRoutes` replaces it.
@@ -70,10 +85,12 @@ export declare class RawServiceMeshRuntime {
     private selectedRoutes;
     private readonly bindingPort;
     private readonly applicationJobQueue;
+    private readonly nodeMailboxOwner;
     private readonly peerAdmissionSealed?;
     private readonly applicationJobStop;
     private receiveAcquisition?;
     private receivePermit?;
+    private receiveRotation?;
     private readonly controlSends;
     private infrastructureFailure?;
     private readonly onReceiveReady?;
@@ -88,6 +105,7 @@ export declare class RawServiceMeshRuntime {
     private router?;
     private nextCorrelation;
     private serviceIngress?;
+    private serviceIngressAccepts?;
     private closed;
     constructor(options: RawServiceMeshRuntimeOptions);
     start(): void;
@@ -98,8 +116,15 @@ export declare class RawServiceMeshRuntime {
     disconnectPeer(endpoint: string, nodeRoutingId: string, lifecycleGeneration?: bigint): void;
     disconnectPeerEndpoint(endpoint: string): void;
     observePeerConnectionIntentRemoved(listener: (nodeRoutingId: string) => void): () => void;
+    observePeerRoute(nodeRoutingId: string): import('./durable-service-request').PeerRouteObservation;
+    waitForPeerRoute(nodeRoutingId: string, lifecycleGeneration: bigint, deadlineUnixMs: bigint, signal?: AbortSignal): Promise<void>;
+    get requestStopSignal(): AbortSignal;
+    observePeerRouteChanged(listener: (nodeRoutingId: string) => void): () => void;
+    hasSelectedPeerRoute(nodeRoutingId: string): boolean;
+    private notifyPeerRouteChanged;
     private notifyPeerConnectionIntentRemoved;
-    announcePeer(nodeRoutingId: string): Promise<boolean>;
+    announcePeer(nodeRoutingId: string): boolean;
+    private isPeerAnnouncementCurrent;
     isPeerRouteReady(nodeRoutingId: string, lifecycleGeneration?: bigint): boolean;
     announceExpectedPeers(): Promise<number>;
     updateLocalDescriptor(options: {
@@ -108,17 +133,31 @@ export declare class RawServiceMeshRuntime {
         readonly channelWeight?: number;
         readonly state?: 'draining';
     }): Promise<void>;
+    private publishLocalDescriptor;
     replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void;
     isObjectClientNodeDirectTarget(nodeRoutingId: string): boolean;
-    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): Promise<boolean>;
+    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): boolean | Promise<boolean>;
     sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<SubmitResult>;
-    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
-    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
+    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
+    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted: (() => void) | undefined, observer: RawServiceRequestObserver, operationKind: number): RawServiceObservedRequest;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted: (() => void) | undefined, observer: RawServiceRequestObserver, operationKind: number): RawServiceObservedRequest;
+    /**
+     * One pending entry per request: an observed request reports its terminal
+     * to the caller's observer; any other request keeps the Promise contract.
+     */
+    private registerRequest;
+    /**
+     * An observed caller learns the operation id only when the request call
+     * returns, so a terminal decided inside that call is delivered after it.
+     */
+    private completeRequest;
+    private failRequest;
     private selectChannelTarget;
-    setServiceIngress(handler: RawServiceIngressHandler): void;
+    setServiceIngress(handler: RawServiceIngressHandler, accepts?: (command: number) => boolean): void;
     reserveLocalIngress(signal?: AbortSignal): Promise<ApplicationIngressRecordOwner>;
     sendService(targetNodeRoutingId: string, parts: readonly Uint8Array[]): Promise<boolean>;
-    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]>;
+    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
     replyService(record: Pick<RawServiceIngressRecord, 'sourceRoutingId' | 'sourceRoute' | 'requestSequence' | 'reply'>, parts: readonly Uint8Array[]): void;
     reply(request: ServiceMailboxRecord, payload: ServiceApplicationPayloadInput, terminalResult?: number, failureCode?: number): void;
     pumpOne(nowMs?: number, observe?: RawServicePumpObserver): Promise<RawServicePumpResult>;
@@ -126,11 +165,25 @@ export declare class RawServiceMeshRuntime {
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
     pumpBatch(receiveReady?: boolean, routeReady?: boolean): Promise<boolean>;
     private receiveOne;
+    private finishReceive;
     private reportProtocolError;
     private replyGenericProtocolError;
     private processReceived;
+    private receiveProtocolFailure;
+    private processAdmission;
+    private processLiveness;
+    private processApplicationReceived;
+    private enqueueOrdinaryRecord;
     expireOperations(nowMs: number, turnDeadlineMs: number): number;
     get pendingOperationCount(): number;
+    cancelPendingOperations(reason: unknown): void;
+    /**
+     * The next management deadline of this node (spec 08 §4.2): request expiry,
+     * liveness probe or timeout, or an owned HELLO exchange still awaiting
+     * ADMIT, which keeps the existing announce cadence.
+     */
+    nextMaintenanceDeadlineMs(nowMs: number): number;
+    private refreshAdmissionPending;
     tickLiveness(nowMs?: number): ServiceLivenessTick;
     /**
      * The socket's one route observer (Core ROUTER §10.1). It replaces the
@@ -155,7 +208,7 @@ export declare class RawServiceMeshRuntime {
     private sendControl;
     private submitControl;
     private startControlSend;
-    private reportInfrastructureFailure;
+    reportInfrastructureFailure(error: unknown): void;
     private observeInfrastructureFailure;
     private send;
     private sendFailure;