@zlink-systems/framework 0.11.0 → 0.12.0

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperationRegistry = exports.OperationCapacityExceededError = exports.OperationCancelledError = exports.OperationTimeoutError = void 0;
+exports.OperationRegistry = exports.OperationCancelledError = exports.OperationTimeoutError = void 0;
 class OperationTimeoutError extends Error {
     operationId;
     constructor(operationId) {
@@ -19,15 +19,6 @@ class OperationCancelledError extends Error {
     }
 }
 exports.OperationCancelledError = OperationCancelledError;
-class OperationCapacityExceededError extends Error {
-    maxPendingOperations;
-    constructor(maxPendingOperations) {
-        super(`Operation capacity ${maxPendingOperations} is exhausted.`);
-        this.maxPendingOperations = maxPendingOperations;
-        this.name = 'OperationCapacityExceededError';
-    }
-}
-exports.OperationCapacityExceededError = OperationCapacityExceededError;
 const systemClock = {
     setTimeout(callback, delayMs) {
         // A request promise is live work.  Raw RouteMesh polling deliberately
@@ -42,28 +33,19 @@ const systemClock = {
 /** Owns request completion so reply, timeout, cancellation, and shutdown race safely. */
 class OperationRegistry {
     clock;
-    maxPendingOperations;
-    static DEFAULT_MAX_PENDING_OPERATIONS = 4_096;
     entries = new Map();
     nextId = 1n;
     generation = 1n;
     closed = false;
-    constructor(clock = systemClock, maxPendingOperations = OperationRegistry.DEFAULT_MAX_PENDING_OPERATIONS) {
+    constructor(clock = systemClock) {
         this.clock = clock;
-        this.maxPendingOperations = maxPendingOperations;
-        if (!Number.isSafeInteger(maxPendingOperations) || maxPendingOperations <= 0) {
-            throw new RangeError('maxPendingOperations must be a positive safe integer.');
-        }
     }
-    reserve(timeoutMs, timeoutOwner = 'registry') {
+    register(timeoutMs, timeoutOwner = 'registry') {
         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.');
         }
-        if (this.entries.size >= this.maxPendingOperations) {
-            throw new OperationCapacityExceededError(this.maxPendingOperations);
-        }
         const id = this.nextId++;
         const generation = this.generation;
         let resolve;

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

@@ -3,7 +3,7 @@ import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
 import { ApplicationIngressRecordOwner } from '../application-jobs/application-ingress-record-owner';
 import { type PendingOperation } from './operation-registry';
 import { ServiceLivenessRegistry, type ServiceLivenessTick } from './service-liveness-registry';
-import { ServiceMailbox, type ServiceMailboxLimits, type ServiceMailboxRecord } from './service-mailbox';
+import { ServiceMailbox, type ServiceMailboxRecord } from './service-mailbox';
 import { ServiceTopologyRegistry, type ServiceNodeDescriptor } from './service-topology-registry';
 import { type ServiceApplicationPayload } from './service-wire-m6a-codec';
 export type RawServicePumpResult = 'noData' | 'infrastructure' | 'application' | 'dropped' | 'protocolError';
@@ -13,6 +13,8 @@ export interface RawServiceRequestResult {
     readonly failureCode: number;
     readonly payload?: ServiceApplicationPayload;
 }
+/** An M6A application frame already owned by the Framework runtime. */
+type ServiceApplicationPayloadInput = ServiceApplicationPayload | Buffer;
 export interface RawServiceIngressRecord {
     readonly command: number;
     readonly flags: number;
@@ -28,7 +30,6 @@ export type RawServiceIngressHandler = (record: RawServiceIngressRecord) => RawS
 export interface RawServiceMeshRuntimeOptions {
     readonly descriptor: ServiceNodeDescriptor;
     readonly resolveAdvertisedEndpoint?: (boundEndpoint: string) => string;
-    readonly mailbox?: Partial<ServiceMailboxLimits>;
     readonly probeIntervalMs?: number;
     readonly peerTimeoutMs?: number;
     readonly bindingPort: ZLinkRawBindingPort;
@@ -105,18 +106,22 @@ export declare class RawServiceMeshRuntime {
     }): Promise<void>;
     replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void;
     isObjectClientNodeDirectTarget(nodeRoutingId: string): boolean;
-    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayload): Promise<boolean>;
-    sendToChannel(channelName: string, payload: ServiceApplicationPayload): Promise<boolean>;
-    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayload, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
-    requestToChannel(channelName: string, payload: ServiceApplicationPayload, timeoutMs: number): PendingOperation<RawServiceRequestResult> | undefined;
+    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): Promise<boolean>;
+    sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<boolean>;
+    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult> | undefined;
     private isLocalOrReadyPeer;
     setServiceIngress(handler: RawServiceIngressHandler): 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[]>;
     replyService(record: Pick<RawServiceIngressRecord, 'sourceRoutingId' | 'sourceRoute' | 'requestSequence' | 'reply'>, parts: readonly Uint8Array[]): void;
-    reply(request: ServiceMailboxRecord, payload: ServiceApplicationPayload, terminalResult?: number, failureCode?: number): void;
+    reply(request: ServiceMailboxRecord, payload: ServiceApplicationPayloadInput, terminalResult?: number, failureCode?: number): void;
     pumpOne(nowMs?: number, observe?: RawServicePumpObserver): Promise<RawServicePumpResult>;
+    setReadableHandler(handler: () => void): void;
+    /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
+    pumpBatch(receiveReady?: boolean): Promise<boolean>;
+    private receiveOne;
     private pullMonitorEvents;
     private reportProtocolError;
     private replyGenericProtocolError;
@@ -125,6 +130,12 @@ export declare class RawServiceMeshRuntime {
     drainMonitorEvents(nowMs?: number): Promise<number>;
     close(): void;
     private requestToTarget;
+    /**
+     * The generic node/channel backend may supply its single owned M6A frame
+     * directly. All other callers keep the typed application-payload boundary.
+     */
+    private applicationFrame;
+    private applicationPayload;
     private admitPeer;
     private currentConnectionCandidate;
     private createConnectionCandidate;
@@ -141,3 +152,4 @@ export declare class RawServiceMeshRuntime {
     private requireStarted;
     private send;
 }
+export {};

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

@@ -66,7 +66,7 @@ class RawServiceMeshRuntime {
     constructor(options) {
         this.descriptor = options.descriptor;
         this.topology = new service_topology_registry_1.ServiceTopologyRegistry(options.descriptor);
-        this.mailbox = new service_mailbox_1.ServiceMailbox(undefined, options.onMailboxReady);
+        this.mailbox = new service_mailbox_1.ServiceMailbox(options.onMailboxReady);
         this.liveness = new service_liveness_registry_1.ServiceLivenessRegistry(options.probeIntervalMs, options.peerTimeoutMs);
         this.bindingPort = options.bindingPort;
         if (options.applicationJobQueue === undefined) {
@@ -302,12 +302,13 @@ class RawServiceMeshRuntime {
         return descriptor?.objectRole === 'client';
     }
     async sendToNode(targetNodeRoutingId, payload) {
-        return this.send(targetNodeRoutingId, [(0, service_wire_m6a_codec_1.encodeNodeSendHeader)(), (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)]);
+        return this.send(targetNodeRoutingId, [(0, service_wire_m6a_codec_1.encodeNodeSendHeader)(), this.applicationFrame(payload)]);
     }
     async sendToChannel(channelName, payload) {
         const selected = this.topology.selectChannel(channelName, peer => this.isLocalOrReadyPeer(peer.descriptor.nodeRoutingId));
         if (selected === undefined)
             return false;
+        const applicationFrame = this.applicationFrame(payload);
         if (selected.descriptor.nodeRoutingId === this.descriptor.nodeRoutingId) {
             const applicationJobOwner = await this.reserveLocalIngress();
             try {
@@ -315,7 +316,7 @@ class RawServiceMeshRuntime {
                 const accepted = this.mailbox.tryEnqueue({
                     owner: `channel:${channelName}`,
                     domain: 'application',
-                    parts: [(0, service_wire_m6a_codec_1.encodeChannelSendHeader)(channelName), (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)],
+                    parts: [(0, service_wire_m6a_codec_1.encodeChannelSendHeader)(channelName), applicationFrame],
                     sourceRoutingId: this.descriptor.nodeRoutingId,
                     applicationJob
                 });
@@ -329,7 +330,7 @@ class RawServiceMeshRuntime {
         }
         return this.send(selected.descriptor.nodeRoutingId, [
             (0, service_wire_m6a_codec_1.encodeChannelSendHeader)(channelName),
-            (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)
+            applicationFrame
         ]);
     }
     requestToNode(targetNodeRoutingId, payload, timeoutMs) {
@@ -375,7 +376,7 @@ class RawServiceMeshRuntime {
     }
     reply(request, payload, terminalResult = 0, failureCode = 0) {
         if (request.localReply !== undefined) {
-            request.localReply(terminalResult, failureCode, terminalResult === 0 ? payload : undefined);
+            request.localReply(terminalResult, failureCode, terminalResult === 0 ? this.applicationPayload(payload) : undefined);
             return;
         }
         if (request.reply === undefined || request.correlation === undefined) {
@@ -383,12 +384,43 @@ class RawServiceMeshRuntime {
         }
         request.reply([
             (0, service_wire_m6a_codec_1.encodeReplyHeader)(request.correlation, terminalResult, failureCode),
-            ...(terminalResult === 0 ? [(0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)] : [])
+            ...(terminalResult === 0 ? [this.applicationFrame(payload)] : [])
         ]);
     }
     async pumpOne(nowMs = performance.now(), observe) {
-        const router = this.requireStarted();
         this.pullMonitorEvents();
+        return this.receiveOne(nowMs, observe);
+    }
+    setReadableHandler(handler) {
+        this.requireStarted().setReadableHandler(handler);
+    }
+    /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
+    async pumpBatch(receiveReady = true) {
+        await this.drainMonitorEvents();
+        const startedAtMs = performance.now();
+        let messages = 0;
+        let bytes = 0;
+        const observe = (_source, byteCount) => { bytes += byteCount; };
+        while (receiveReady && messages < 64 && !this.closed) {
+            const result = await this.receiveOne(performance.now(), observe);
+            if (result === 'noData') {
+                receiveReady = false;
+                break;
+            }
+            messages += 1;
+            // Core owns the per-peer fair-queue cursor. The Framework limit bounds
+            // the entire round, so changing peers does not renew its byte/count budget.
+            if (bytes >= 4 * 1024 * 1024 || performance.now() - startedAtMs >= 2)
+                break;
+        }
+        if (!this.closed) {
+            await this.announceExpectedPeers();
+            await this.tickLiveness();
+        }
+        return receiveReady && messages > 0;
+    }
+    async receiveOne(nowMs, observe) {
+        const router = this.requireStarted();
         let permit;
         try {
             permit = await this.applicationJobQueue.acquire(this.applicationJobStop.signal);
@@ -398,6 +430,10 @@ class RawServiceMeshRuntime {
                 return 'noData';
             throw error;
         }
+        if (this.closed) {
+            permit.releaseAfterInternalProcessing();
+            return 'noData';
+        }
         let received;
         try {
             received = router.receive(true);
@@ -825,8 +861,8 @@ class RawServiceMeshRuntime {
         const header = channelName === undefined
             ? (0, service_wire_m6a_codec_1.encodeNodeRequestHeader)(correlation)
             : (0, service_wire_m6a_codec_1.encodeChannelRequestHeader)(correlation, channelName);
-        const encodedPayload = (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload);
-        const pending = this.operations.reserve(timeoutMs);
+        const encodedPayload = this.applicationFrame(payload);
+        const pending = this.operations.register(timeoutMs);
         let selectedTargetNodeRoutingId = targetNodeRoutingId;
         if (selectedTargetNodeRoutingId !== this.descriptor.nodeRoutingId
             && !this.isPeerRouteReady(selectedTargetNodeRoutingId)) {
@@ -945,7 +981,7 @@ class RawServiceMeshRuntime {
                     failureCode: reply.failureCode
                 };
                 this.operations.complete(pending.id, reply.terminalResult === 0
-                    ? { ...result, payload: (0, service_wire_m6a_codec_1.decodeApplicationPayload)(replyParts[1]) }
+                    ? { ...result, payload: (0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(replyParts[1]) }
                     : result);
             }
             catch (error) {
@@ -956,6 +992,16 @@ class RawServiceMeshRuntime {
         });
         return pending;
     }
+    /**
+     * The generic node/channel backend may supply its single owned M6A frame
+     * directly. All other callers keep the typed application-payload boundary.
+     */
+    applicationFrame(payload) {
+        return Buffer.isBuffer(payload) ? payload : (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload);
+    }
+    applicationPayload(payload) {
+        return Buffer.isBuffer(payload) ? (0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload) : payload;
+    }
     admitPeer(descriptor, connection, nowMs, expected) {
         const previous = this.topology.peer(descriptor.nodeRoutingId);
         if (previous !== undefined

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

@@ -29,12 +29,6 @@ export interface ServiceMailboxRelocationSeal {
     readonly serial: bigint;
     readonly captured: readonly ServiceMailboxRecord[];
 }
-export interface ServiceMailboxLimits {
-    readonly applicationMessages: number;
-    readonly applicationBytes: number;
-    readonly infrastructureMessages: number;
-    readonly infrastructureBytes: number;
-}
 /** Level-triggered queues with one active application claim per owner. */
 export declare class ServiceMailbox {
     private readonly onReady?;
@@ -45,7 +39,7 @@ export declare class ServiceMailbox {
     private nextClaimSerial;
     private nextRelocationSerial;
     private closed;
-    constructor(_legacyLimits?: ServiceMailboxLimits, onReady?: ((domain: ServiceMailboxDomain) => void) | undefined);
+    constructor(onReady?: ((domain: ServiceMailboxDomain) => void) | undefined);
     releaseClaimedPayload(record: ServiceMailboxRecord): void;
     tryEnqueue(record: ServiceMailboxRecord): boolean;
     tryClaim(domain: ServiceMailboxDomain, messageBudget: number, byteBudget: number): ServiceMailboxClaim | undefined;

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

@@ -11,7 +11,7 @@ class ServiceMailbox {
     nextClaimSerial = 1n;
     nextRelocationSerial = 1n;
     closed = false;
-    constructor(_legacyLimits, onReady) {
+    constructor(onReady) {
         this.onReady = onReady;
         // Host ApplicationJobQueue permits own ordinary-record admission. The
         // Framework-owned payload lifetime does not retain Core HWM credit. A
@@ -56,8 +56,8 @@ class ServiceMailbox {
         if (!queue.claimed && !target.indexed.has(record.owner)) {
             target.indexed.add(record.owner);
             target.ready.push(record.owner);
+            this.onReady?.(record.domain);
         }
-        this.onReady?.(record.domain);
         return true;
     }
     tryClaim(domain, messageBudget, byteBudget) {
@@ -112,6 +112,7 @@ class ServiceMailbox {
         else if (!target.indexed.has(claim.owner)) {
             target.indexed.add(claim.owner);
             target.ready.push(claim.owner);
+            this.onReady?.(claim.domain);
         }
         return true;
     }

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

@@ -224,7 +224,8 @@ export interface ReadyBatch {
     close(): void;
 }
 export interface ReceiveBatch {
-    reset(): void;
+    /** Reuses the batch, limiting this receive to the admitted record count. */
+    reset(messageCapacity?: number): void;
     close(): void;
 }
 export interface MeshNodeStatus {

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

@@ -132,7 +132,7 @@ export declare class ServiceStatefulRegistry {
 export declare class ServiceTerminalOperationRegistry<T> {
     private readonly operations;
     constructor(operations?: OperationRegistry<T>);
-    reserve(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
+    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
     reply(id: bigint, value: T): boolean;
     fail(id: bigint, error: unknown): boolean;
     cancel(id: bigint): boolean;

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

@@ -427,8 +427,8 @@ class ServiceTerminalOperationRegistry {
     constructor(operations = new operation_registry_1.OperationRegistry()) {
         this.operations = operations;
     }
-    reserve(timeoutMs, timeoutOwner = 'registry') {
-        return this.operations.reserve(timeoutMs, timeoutOwner);
+    register(timeoutMs, timeoutOwner = 'registry') {
+        return this.operations.register(timeoutMs, timeoutOwner);
     }
     reply(id, value) {
         return this.operations.complete(id, value);

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

@@ -650,7 +650,7 @@ class ServiceStatefulRuntime {
         return this.submitOneWay(target.targetNodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)]);
     }
     requestToSpot(sourceSpotId, requested, payload, timeoutMs) {
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         const target = this.acceptSpotAuthority(requested);
         if (target === undefined) {
             this.operations.reply(pending.id, {
@@ -676,7 +676,7 @@ class ServiceStatefulRuntime {
         return this.submitOneWay(target.nodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)]);
     }
     requestToActor(target, _targetNodeGeneration, _authorityOwnerGeneration, payload, timeoutMs, sourceActor, boundSession) {
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         const route = this.tryActorFence(target);
         if (route === undefined) {
             this.operations.reply(pending.id, {
@@ -711,7 +711,7 @@ class ServiceStatefulRuntime {
         ], metadataFrame));
     }
     requestToInstanceSpot(route, payload, timeoutMs, sourceSpotId, metadataFrame) {
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         this.submitRequest(pending, route.targetNodeRid, instanceOperationParts([
             (0, service_stateful_wire_codec_1.encodeInstanceSpotHeader)(route, this.nodeGeneration, this.nodeRid, sourceSpotId, 'request', { high: 2n, low: pending.id }, pending.id, metadataFrame !== undefined),
             (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)
@@ -725,7 +725,7 @@ class ServiceStatefulRuntime {
     }
     requestToMissingInstanceSpotFrame(target, payloadFrame, deadlineUnixMs, sourceSpotId, metadataFrame) {
         const timeoutMs = remainingDeadlineMs(deadlineUnixMs);
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         this.submitRequest(pending, target.targetNodeRid, instanceOperationParts([
             (0, service_stateful_wire_codec_1.encodeInstanceSpotActivationHeader)(target, this.nodeGeneration, this.nodeRid, sourceSpotId, 'request', { high: this.nodeGeneration, low: pending.id }, deadlineUnixMs, pending.id, metadataFrame !== undefined),
             payloadFrame
@@ -733,12 +733,12 @@ class ServiceStatefulRuntime {
         return pending;
     }
     lookupRemoteActor(targetNodeRid, actorId, timeoutMs) {
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         this.submitRequest(pending, targetNodeRid, [(0, service_stateful_wire_codec_1.encodeActorLookupHeader)(pending.id, actorId)], timeoutMs, 'actorLookup');
         return pending;
     }
     destroyActor(actor, timeoutMs) {
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         const local = actor.nodeRid === this.nodeRid;
         if (local) {
             queueMicrotask(() => {
@@ -758,7 +758,7 @@ class ServiceStatefulRuntime {
     }
     joinActor(actor, targetNodeRid, targetSpot, targetSpotGeneration, payload, timeoutMs) {
         const deadlineMs = performance.now() + timeoutMs;
-        const pending = this.operations.reserve(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
+        const pending = this.operations.register(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
         const target = this.trySpotFence(targetNodeRid, {
             ...targetSpot,
             generation: targetSpotGeneration
@@ -768,7 +768,7 @@ class ServiceStatefulRuntime {
     }
     joinActorCanonical(actor, targetNodeRid, targetSpot, targetSpotGeneration, request, actorFence, local, timeoutMs) {
         const deadlineMs = performance.now() + timeoutMs;
-        const pending = this.operations.reserve(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
+        const pending = this.operations.register(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
         const target = this.trySpotFence(targetNodeRid, {
             ...targetSpot,
             generation: targetSpotGeneration
@@ -778,18 +778,18 @@ class ServiceStatefulRuntime {
     }
     joinActorEntrySpot(actor, targetNodeRid, payload, timeoutMs) {
         const deadlineMs = performance.now() + timeoutMs;
-        const pending = this.operations.reserve(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
+        const pending = this.operations.register(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
         this.submitActorJoin(pending, actor, targetNodeRid, this.tryEntrySpotFence(targetNodeRid), payload, deadlineMs);
         return pending;
     }
     joinActorEntrySpotCanonical(actor, targetNodeRid, request, actorFence, local, timeoutMs) {
         const deadlineMs = performance.now() + timeoutMs;
-        const pending = this.operations.reserve(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
+        const pending = this.operations.register(timeoutMs, targetNodeRid === this.nodeRid ? 'registry' : 'sender');
         this.submitActorJoin(pending, actor, targetNodeRid, this.tryEntrySpotFence(targetNodeRid), request, deadlineMs, { request, actorFence, local });
         return pending;
     }
     leaveActor(actor, expectedMembershipEpoch, timeoutMs) {
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         queueMicrotask(() => {
             try {
                 const transition = this.registry.leaveActor(actor, expectedMembershipEpoch);
@@ -816,7 +816,7 @@ class ServiceStatefulRuntime {
     }
     bindSession(sessionRid, actor, timeoutMs, deliver, onBindingReplaced, bindingIngress, actorAuthority) {
         const deadlineMs = performance.now() + timeoutMs;
-        const pending = this.operations.reserve(timeoutMs, 'sender');
+        const pending = this.operations.register(timeoutMs, 'sender');
         const generation = this.nextSessionSequence++;
         const localBinding = {
             actor,
@@ -931,7 +931,7 @@ class ServiceStatefulRuntime {
         };
     }
     unbindSession(sessionRid, actor, expectedBindingGeneration, timeoutMs) {
-        const pending = this.operations.reserve(timeoutMs);
+        const pending = this.operations.register(timeoutMs);
         const delivery = this.sessionDeliveries.get(actorKey(actor));
         if (delivery === undefined
             || delivery.binding.sessionRid !== sessionRid
@@ -1559,7 +1559,7 @@ class ServiceStatefulRuntime {
             }
             return;
         }
-        const pending = this.operations.reserve(remainingMs);
+        const pending = this.operations.register(remainingMs);
         this.submitRequest(pending, route.targetNodeRid, instanceOperationParts([
             (0, service_stateful_wire_codec_1.encodeInstanceSpotActivationHeader)(redirectedTarget, this.nodeGeneration, this.nodeRid, record.sourceSpotId, 'request', record.operation, record.deadlineUnixMs, pending.id, metadataFrame !== undefined),
             payloadFrame

package/dist/runtime/framework-errors-internal.d.ts

@@ -54,8 +54,8 @@ export declare function internalFrameworkErrorKind(error: ZLinkFrameworkExceptio
  * terminal is classified identically across languages instead of collapsing to
  * Unavailable. Spec 32-framework-error-model:81-92 (request-terminal
  * classification); a deadline yields DeadlineExceeded, a lost route Unavailable.
- * Backpressure on the REQUEST path is CapacityExceeded (distinct from the
- * one-way submit path, which is DeadlineExceeded).
+ * Backpressure waits in Core until the operation deadline, so request and
+ * one-way terminals both surface DeadlineExceeded when that wait expires.
  */
 export declare function requestResultToPublicErrorKind(result: number): ZLinkFrameworkErrorKind;
 /**
@@ -65,8 +65,8 @@ export declare function requestResultToPublicErrorKind(result: number): ZLinkFra
  * coarse terminal; when absent (0) or unrecognised, the coarse terminal
  * classifies. Remote another-node queue/operation-table saturation
  * (Conflict/Busy) is Unavailable — a resource this runtime does not own — while
- * only the placement admission terminal Backpressured(113) is CapacityExceeded,
- * a target-owned admission decision rather than a queue. Shared by the lifecycle
+ * placement admission terminal Backpressured(113) is Unavailable because no
+ * node can host the Spot. Shared by the lifecycle
  * completion paths (Actor join, User Spot create/close) so they classify
  * identically to the request path instead of collapsing to a single kind.
  */

package/dist/runtime/framework-errors-internal.js

@@ -78,7 +78,7 @@ const INTERNAL_TO_PUBLIC = Object.freeze({
     [ZLinkFrameworkInternalErrorKind.RequestRejected]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.Rejected,
     [ZLinkFrameworkInternalErrorKind.RequestProtocolError]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.ProtocolError,
     [ZLinkFrameworkInternalErrorKind.RequestFailed]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.InternalFailure,
-    [ZLinkFrameworkInternalErrorKind.WorkerQueueFull]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.CapacityExceeded,
+    [ZLinkFrameworkInternalErrorKind.WorkerQueueFull]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.Unavailable,
     [ZLinkFrameworkInternalErrorKind.WorkerTimedOut]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.DeadlineExceeded,
     [ZLinkFrameworkInternalErrorKind.WorkerFailed]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.InternalFailure,
     [ZLinkFrameworkInternalErrorKind.ActorLocationStale]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.Unavailable,
@@ -91,7 +91,7 @@ const INTERNAL_TO_PUBLIC = Object.freeze({
     [ZLinkFrameworkInternalErrorKind.ActorGenerationStale]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.InvalidOperation,
     [ZLinkFrameworkInternalErrorKind.ActorMoving]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.Unavailable,
     [ZLinkFrameworkInternalErrorKind.DeadlineExceeded]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.DeadlineExceeded,
-    [ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.CapacityExceeded,
+    [ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.Unavailable,
     [ZLinkFrameworkInternalErrorKind.RoutingIdConflict]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.AlreadyExists,
     [ZLinkFrameworkInternalErrorKind.SpotGenerationStale]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.InvalidOperation,
     [ZLinkFrameworkInternalErrorKind.SpotMoving]: ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.Unavailable,
@@ -152,8 +152,7 @@ const INTERNAL_KIND_BY_WIRE_FAILURE_CODE = new Map([
     ...Object.entries(exports.ZLINK_FRAMEWORK_INTERNAL_ERROR_KIND_VALUES)
         .map(([kind, code]) => [code + 1, kind]),
     //  Spec 32-framework-error-model:99-103 — a workerQueueFull(18) received in a
-    //  remote reply is the target's queue state (Unavailable), not the source-owned
-    //  CapacityExceeded that the wire-value-minus-one derivation would give.
+    //  remote reply is the target's queue state and maps to Unavailable.
     [18, ZLinkFrameworkInternalErrorKind.RouteNotConnected]
 ]);
 const WIRE_TERMINAL_RESULT_BY_FAILURE_CODE = new Map([
@@ -179,8 +178,8 @@ function internalFrameworkErrorKind(error) {
  * terminal is classified identically across languages instead of collapsing to
  * Unavailable. Spec 32-framework-error-model:81-92 (request-terminal
  * classification); a deadline yields DeadlineExceeded, a lost route Unavailable.
- * Backpressure on the REQUEST path is CapacityExceeded (distinct from the
- * one-way submit path, which is DeadlineExceeded).
+ * Backpressure waits in Core until the operation deadline, so request and
+ * one-way terminals both surface DeadlineExceeded when that wait expires.
  */
 function requestResultToPublicErrorKind(result) {
     switch (result) {
@@ -195,8 +194,7 @@ function requestResultToPublicErrorKind(result) {
         case runtime_values_1.RequestResult.Rejected:
             return ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.Rejected;
         case runtime_values_1.RequestResult.Backpressured:
-            //  Source-owned send/completion reservation exhausted (spec 32:93-98).
-            return ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.CapacityExceeded;
+            return ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.DeadlineExceeded;
         case runtime_values_1.RequestResult.Conflict:
         case runtime_values_1.RequestResult.Busy:
         case runtime_values_1.RequestResult.NotConnected:
@@ -219,8 +217,8 @@ function requestResultToPublicErrorKind(result) {
  * coarse terminal; when absent (0) or unrecognised, the coarse terminal
  * classifies. Remote another-node queue/operation-table saturation
  * (Conflict/Busy) is Unavailable — a resource this runtime does not own — while
- * only the placement admission terminal Backpressured(113) is CapacityExceeded,
- * a target-owned admission decision rather than a queue. Shared by the lifecycle
+ * placement admission terminal Backpressured(113) is Unavailable because no
+ * node can host the Spot. Shared by the lifecycle
  * completion paths (Actor join, User Spot create/close) so they classify
  * identically to the request path instead of collapsing to a single kind.
  */

package/dist/runtime/host/actor-placement-coordinator.js

@@ -82,7 +82,7 @@ class ZLinkActorPlacementCoordinator {
                     //  ownership-aware translator instead of collapsing every non-OK
                     //  remote create to InternalFailure (spec 32-framework-error-model:
                     //  83-118, 99-108). Backpressured(113) still surfaces as target
-                    //  placement capacity -> CapacityExceeded through the shared path.
+                    //  placement capacity -> Unavailable through the shared path.
                     throw (0, framework_errors_internal_1.wireReplyFailureException)(remote.terminalResult, remote.failureCode, `Remote Actor '${actorId}' creation failed with result ${remote.terminalResult}, `
                         + `failure code ${remote.failureCode}, and tail ${remote.tail?.kind ?? 'none'}.`);
                 }

package/dist/runtime/host/index.js

@@ -161,7 +161,7 @@ class ZLinkFrameworkRuntimeHost {
             return sendTimeoutMsForSpotMesh(routeChannelId);
         };
         const defaultSpotSendTimeoutMs = Math.max(LEGACY_MESH_SEND_TIMEOUT_MS, ...[...options.registration.spotNodes.values()].map(node => node.router?.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS), ...[...options.registration.routeChannelOptions.values()].map(route => route.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS));
-        this.routeTransport = new channels_1.ZLinkRuntimeRouteTransport(() => this.channelRuntime, (routerChannelId) => this.meshRouters.canUseRouterChannel(routerChannelId), () => this.spotNodeRuntime, { serializers: options.registration.messageSerializers }, (meshName, targetNodeRid) => this.meshRouters.classifyManualNodeTarget(meshName, targetNodeRid), (meshName, sourceNodeRid, parts) => this.submitLocalMeshRoute(meshName, sourceNodeRid, parts), this.metrics);
+        this.routeTransport = new channels_1.ZLinkRuntimeRouteTransport(() => this.channelRuntime, (routerChannelId) => this.meshRouters.canUseRouterChannel(routerChannelId), () => this.spotNodeRuntime, { serializers: options.registration.messageSerializers }, (meshName, targetNodeRid) => this.meshRouters.classifyManualNodeTarget(meshName, targetNodeRid), (meshName, sourceNodeRid, parts) => this.submitLocalMeshRoute(meshName, sourceNodeRid, parts), this.metrics, () => this.flowCreationEnabled());
         this.spotAddressTransport = new spot_address_transport_1.ZLinkHostSpotAddressTransport({
             resolver: () => this.createLocationSpotRouteResolver(),
             routed: this.routeTransport,

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

@@ -3464,10 +3464,6 @@ function relocationFailedFailureCode(error, objectKind) {
             return service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestRejected;
         case contracts_1.ZLinkFrameworkErrorKind.ProtocolError:
             return service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestProtocolError;
-        //  No dedicated "capacity exceeded" wire code exists; a full queue is
-        //  the closest capacity-shaped signal.
-        case contracts_1.ZLinkFrameworkErrorKind.CapacityExceeded:
-            return service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.workerQueueFull;
         //  No dedicated "deadline exceeded" wire code exists; a worker timeout
         //  is the closest timeout-shaped signal.
         case contracts_1.ZLinkFrameworkErrorKind.DeadlineExceeded:

package/dist/runtime/host/spot-address-transport.js

@@ -417,7 +417,7 @@ function missingInstanceRequestFailure(result, nativeErrno) {
                     ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown
                     : result === runtime_values_1.RequestResult.Backpressured
                         //  Spec 32-framework-error-model:104-108 — the bounded admission
-                        //  terminal is target placement capacity: CapacityExceeded.
+                        //  terminal is target placement capacity: Unavailable.
                         ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted
                         : result === runtime_values_1.RequestResult.NotConnected
                             ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected

package/dist/runtime/host/user-spot-creation-coordinator.js

@@ -712,7 +712,7 @@ function remoteUserSpotFailure(terminalResult, failureCode, message) {
     //  Remote operation-table saturation Busy(108)+None is Unavailable,
     //  InvalidState(111)+None is InvalidOperation, every fine code follows the
     //  shared table, and only placement admission Backpressured(113) stays
-    //  CapacityExceeded.
+    //  Unavailable.
     return (0, framework_errors_internal_1.wireReplyFailureException)(terminalResult, failureCode, `${message} terminalResult=${terminalResult}, failureCode=${failureCode}.`);
 }
 function createDeadline(timeoutMs, parent) {

package/dist/runtime/spots/spot-node-runtime-manager.d.ts

@@ -59,8 +59,6 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private readonly entryActivations;
     private readonly entryActivationStarts;
     private readonly publishers;
-    private readonly activePublishes;
-    private readonly publishSlotWaiters;
     private disposed;
     private readonly autoConnectLoops;
     private readonly publishedMeshNodeDescriptors;
@@ -123,15 +121,5 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private executePublish;
     tryPublish(meshName: string, channelName: string, topic: string, packetName: string | undefined, event: Message, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     private publishWithFlags;
-    private acquirePublishSlot;
-    private publishTimedOut;
-    private releasePublishSlot;
-    private settlePublishSlotWaiter;
-    private rejectPublishSlotWaiter;
-    private removePublishSlotWaiter;
-    private cleanupPublishSlotWaiter;
-    private rejectPublishSlotWaiters;
-    private takePublishSlotWaiter;
-    private compactPublishSlotWaiters;
 }
 export declare function createFrameworkEntrySpotId(prefix: string): string;