@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,11 +1,14 @@
+import type { OperationHandle } from './operation-registry';
+import type { RequestRuntime } from './request-runtime';
+import { inspectRuntime } from '../internal-observation';
 import { ApplicationIngressRecordOwner } from '../application-jobs/application-ingress-record-owner';
 import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
-import type { ZLinkRawBindingPort } from '../backend/raw-binding-port';
+import type { ZLinkRawBindingPort, ZLinkRawReceivedRecord, ZLinkRawRouterPort } from '../backend/raw-binding-port';
 import { SubmitResult } from '../backend/runtime-values';
 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';
+import { ServiceTopologyRegistry, type PeerAdmissionResult, type ServiceNodeDescriptor } from './service-topology-registry';
 import { type ServiceApplicationPayload } from './service-wire-m6a-codec';
 export type RawServicePumpResult = 'noData' | 'infrastructure' | 'application' | 'dropped' | 'protocolError';
 export type RawServicePumpObserver = (sourceRoutingId: string, byteCount: number) => void;
@@ -21,9 +24,7 @@ export type RawServiceRequestObserver = OperationObserver<RawServiceRequestResul
  * terminal reaches the observer. Local and Promise-contract requests carry
  * the Promise.
  */
-export interface RawServiceObservedRequest {
-    readonly id: bigint;
-    readonly promise?: Promise<RawServiceRequestResult>;
+export interface RawServiceObservedRequest extends OperationHandle<RawServiceRequestResult> {
 }
 /** An M6A application frame already owned by the Framework runtime. */
 type ServiceApplicationPayloadInput = ServiceApplicationPayload | Buffer;
@@ -37,12 +38,13 @@ export interface RawServiceIngressRecord {
     readonly sourceNodeGeneration?: bigint;
     readonly sourceRoute?: Uint8Array;
     readonly requestSequence?: bigint;
-    readonly reply?: (parts: readonly Uint8Array[]) => void;
+    readonly reply?: ServiceMailboxRecord['reply'];
     readonly parts: readonly Buffer[];
     readonly applicationJobOwner?: ApplicationIngressRecordOwner;
 }
 export type RawServiceIngressHandler = (record: RawServiceIngressRecord) => RawServicePumpResult | undefined | Promise<RawServicePumpResult | undefined>;
 export interface RawServiceMeshRuntimeOptions {
+    readonly requests?: RequestRuntime;
     readonly onReceiveReady?: () => void;
     readonly infrastructureTaskRunner?: import('../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner;
     readonly onPendingOperationsChanged?: () => void;
@@ -65,16 +67,37 @@ export interface RawServiceMeshRuntimeOptions {
     }) => void;
 }
 export declare const RAW_MESH_RECEIVE_TIME_BUDGET_MS = 2;
+interface ControlSendState {
+    task?: Promise<boolean>;
+    next?: () => boolean | Promise<boolean>;
+    current?: () => boolean;
+    hello?: Uint8Array;
+}
 /**
  * RouteMesh M6A runtime built only on the public raw binding package.
  * It owns protocol, admission, mailbox, request and liveness state.
  */
 export declare class RawServiceMeshRuntime {
+    [inspectRuntime](nodeRoutingId?: string): Readonly<{
+        pendingControlSends: number;
+        selectedRouteGeneration: bigint | undefined;
+        peerRouteObservers: number;
+        peerConnectionIntentObservers: number;
+        expectedPeers: number;
+    }>;
     readonly topology: ServiceTopologyRegistry;
     readonly mailbox: ServiceMailbox;
     readonly liveness: ServiceLivenessRegistry;
+    private readonly requestOwner;
+    private readonly releaseOperations;
     private readonly operations;
-    private readonly expectedPeers;
+    readonly expectedPeers: Map<string, {
+        readonly meshName: string;
+        readonly nodeRoutingId: string;
+        readonly endpoint?: string;
+        readonly securityIdentity?: string;
+        readonly lifecycleGeneration?: bigint;
+    }>;
     private readonly endpointOnlyPeers;
     private readonly peerConnectionIntentRemoved;
     private readonly peerRouteChanged;
@@ -82,7 +105,8 @@ export declare class RawServiceMeshRuntime {
      * The last observed Core selected route of each RID (Core ROUTER §10.1):
      * RID -> route generation. Only `observeSelectedRoutes` replaces it.
      */
-    private selectedRoutes;
+    selectedRoutes: Map<string, bigint>;
+    private connectionAttempts;
     private readonly bindingPort;
     private readonly applicationJobQueue;
     private readonly nodeMailboxOwner;
@@ -91,7 +115,7 @@ export declare class RawServiceMeshRuntime {
     private receiveAcquisition?;
     private receivePermit?;
     private receiveRotation?;
-    private readonly controlSends;
+    readonly controlSends: Map<string, ControlSendState>;
     private infrastructureFailure?;
     private readonly onReceiveReady?;
     private readonly infrastructureTaskRunner?;
@@ -102,7 +126,7 @@ export declare class RawServiceMeshRuntime {
     private readonly resolveAdvertisedEndpoint?;
     private descriptor;
     private host?;
-    private router?;
+    router?: ZLinkRawRouterPort;
     private nextCorrelation;
     private serviceIngress?;
     private serviceIngressAccepts?;
@@ -117,6 +141,7 @@ export declare class RawServiceMeshRuntime {
     disconnectPeerEndpoint(endpoint: string): void;
     observePeerConnectionIntentRemoved(listener: (nodeRoutingId: string) => void): () => void;
     observePeerRoute(nodeRoutingId: string): import('./durable-service-request').PeerRouteObservation;
+    peerLifecycleGeneration(nodeRoutingId: string): bigint | undefined;
     waitForPeerRoute(nodeRoutingId: string, lifecycleGeneration: bigint, deadlineUnixMs: bigint, signal?: AbortSignal): Promise<void>;
     get requestStopSignal(): AbortSignal;
     observePeerRouteChanged(listener: (nodeRoutingId: string) => void): () => void;
@@ -137,16 +162,18 @@ export declare class RawServiceMeshRuntime {
     replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void;
     isObjectClientNodeDirectTarget(nodeRoutingId: string): boolean;
     sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): boolean | Promise<boolean>;
-    sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<SubmitResult>;
+    sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): SubmitResult | Promise<SubmitResult>;
     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;
+    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted: (() => void) | undefined, observer: RawServiceRequestObserver, operationKind: number, requestOperation?: PendingOperation<unknown>): 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;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted: (() => void) | undefined, observer: RawServiceRequestObserver, operationKind: number, requestOperation?: PendingOperation<unknown>): RawServiceObservedRequest;
+    beginInfrastructureRequest(timeoutMs: number, signal?: AbortSignal, absoluteDeadlineMs?: number): PendingOperation<readonly Uint8Array[]>;
     /**
      * 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;
+    private observedRequest;
     /**
      * An observed caller learns the operation id only when the request call
      * returns, so a terminal decided inside that call is delivered after it.
@@ -157,22 +184,30 @@ export declare class RawServiceMeshRuntime {
     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, onAdmitted?: () => void): Promise<readonly Buffer[]>;
-    replyService(record: Pick<RawServiceIngressRecord, 'sourceRoutingId' | 'sourceRoute' | 'requestSequence' | 'reply'>, parts: readonly Uint8Array[]): void;
+    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void, existing?: Pick<PendingOperation<unknown>, 'id' | 'deadlineMs'>, receiver?: undefined, onSubmitted?: () => void): Promise<readonly Buffer[]>;
+    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted: (() => void) | undefined, existing: Pick<PendingOperation<unknown>, 'id' | 'deadlineMs'> | undefined, receiver: import('./operation-registry').OperationObserver<readonly Buffer[], unknown>): void;
+    replyService(record: Pick<RawServiceIngressRecord, 'sourceRoutingId' | 'sourceRoute' | 'requestSequence' | 'reply'>, parts: readonly (Uint8Array | string)[]): void;
     reply(request: ServiceMailboxRecord, payload: ServiceApplicationPayloadInput, terminalResult?: number, failureCode?: number): void;
     pumpOne(nowMs?: number, observe?: RawServicePumpObserver): Promise<RawServicePumpResult>;
-    setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void;
+    setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void): void;
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
-    pumpBatch(receiveReady?: boolean, routeReady?: boolean): Promise<boolean>;
+    pumpBatch(receiveReady?: boolean, routeReady?: boolean, connectReady?: boolean): boolean | Promise<boolean>;
+    private receiveBatchAfterObservations;
+    private receiveBatch;
     private receiveOne;
+    private acquireReceivePermit;
+    private finishPendingReceive;
     private finishReceive;
-    private reportProtocolError;
+    reportProtocolError(received: import('../backend/node/node-raw-binding-port').ZLinkRawReceivedRecord): void;
     private replyGenericProtocolError;
-    private processReceived;
+    processReceived(received: ZLinkRawReceivedRecord, nowMs: number, applicationJobOwner: ApplicationIngressRecordOwner): RawServicePumpResult | Promise<RawServicePumpResult>;
+    private finishPendingProtocolReceive;
+    private finishPendingStatefulReceive;
     private receiveProtocolFailure;
     private processAdmission;
     private processLiveness;
     private processApplicationReceived;
+    private enqueuePendingOrdinaryRecord;
     private enqueueOrdinaryRecord;
     expireOperations(nowMs: number, turnDeadlineMs: number): number;
     get pendingOperationCount(): number;
@@ -183,7 +218,7 @@ export declare class RawServiceMeshRuntime {
      * ADMIT, which keeps the existing announce cadence.
      */
     nextMaintenanceDeadlineMs(nowMs: number): number;
-    private refreshAdmissionPending;
+    private progressPeerAdmission;
     tickLiveness(nowMs?: number): ServiceLivenessTick;
     /**
      * The socket's one route observer (Core ROUTER §10.1). It replaces the
@@ -200,14 +235,18 @@ export declare class RawServiceMeshRuntime {
      */
     private applicationFrame;
     private applicationPayload;
-    private admitPeer;
+    admitPeer(descriptor: ServiceNodeDescriptor, connectionId: string | bigint, nowMs: number, expected?: {
+        readonly endpoint?: string;
+        readonly securityIdentity?: string;
+        readonly lifecycleGeneration?: bigint;
+    }, command?: number, descriptorBytes?: Uint8Array): PeerAdmissionResult;
     private retireNotRequiredExpectedPeer;
     private selectBilateralConnection;
     private removePeer;
     private requireStarted;
-    private sendControl;
+    sendControl(targetNodeRoutingId: string, parts: readonly Uint8Array[]): Promise<boolean>;
     private submitControl;
-    private startControlSend;
+    startControlSend(target: string, command: number, attempt: () => boolean | Promise<boolean>, current?: () => boolean, hello?: Uint8Array): boolean;
     reportInfrastructureFailure(error: unknown): void;
     private observeInfrastructureFailure;
     private send;