@zlink-systems/framework 0.10.0

package/dist/runtime/backend/node/node-raw-mesh-backend.js

@@ -0,0 +1,1707 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkNodeRawMeshBackend = void 0;
+exports.genericOperationFailure = genericOperationFailure;
+const node_crypto_1 = require("node:crypto");
+const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
+const contracts_1 = require("../../../contracts");
+const framework_errors_internal_1 = require("../../framework-errors-internal");
+const zlink_1 = require("@zlink-systems/zlink");
+const runtime_values_1 = require("../runtime-values");
+const service_runtime_contracts_1 = require("../../foundation/service-runtime-contracts");
+const operation_registry_1 = require("../../foundation/operation-registry");
+const raw_service_mesh_runtime_1 = require("../../foundation/raw-service-mesh-runtime");
+const service_wire_m6a_codec_1 = require("../../foundation/service-wire-m6a-codec");
+const service_wire_constants_generated_1 = require("../../foundation/service-wire-constants.generated");
+const service_stateful_runtime_1 = require("../../foundation/service-stateful-runtime");
+const service_session_binding_ingress_port_1 = require("../../foundation/service-session-binding-ingress-port");
+const service_metadata_codec_1 = require("../../foundation/service-metadata-codec");
+const EndpointNotation_1 = require("../../../contracts/Configuration/EndpointNotation");
+const ConfigurationException_1 = require("../../../contracts/Configuration/ConfigurationException");
+const MULTIPART_PACKET_NAME = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME;
+const MULTIPART_CONTENT_TYPE = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE;
+const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
+const MAX_DRAIN_RECORDS = 64;
+// A timer is only a no-data backoff.  Once the binding has reported readable
+// work, continue from the next event-loop turn so a full socket does not wait
+// for an arbitrary timer cadence between batches.
+const MESH_BACKEND_IDLE_POLL_INTERVAL_MS = 1;
+const MESH_RECEIVE_BATCH_BYTE_LIMIT = 4 * 1024 * 1024;
+const MESH_RECEIVE_BATCH_TIME_LIMIT_MS = 2;
+/**
+ * Conservative Actor Join admission cap for relocation state chunks (spec 15
+ * §4.2): a stable lower bound safe on any deployment, never lowered on
+ * recompute. Matches the source's own conservative chunk floor.
+ */
+const ACTOR_JOIN_ADVERTISED_RECEIVE_CHUNK_LIMIT_BYTES = 32 * 1024;
+class ZLinkMeshReceiveBatchBudget {
+    peerMessages = new Map();
+    peerBytes = new Map();
+    startedAtMs = 0;
+    reset(nowMs) {
+        this.peerMessages.clear();
+        this.peerBytes.clear();
+        this.startedAtMs = nowMs;
+    }
+    record(peer, byteCount, nowMs) {
+        const messages = (this.peerMessages.get(peer) ?? 0) + 1;
+        const bytes = (this.peerBytes.get(peer) ?? 0) + byteCount;
+        this.peerMessages.set(peer, messages);
+        this.peerBytes.set(peer, bytes);
+        return messages >= MAX_DRAIN_RECORDS
+            || bytes >= MESH_RECEIVE_BATCH_BYTE_LIMIT
+            || nowMs - this.startedAtMs >= MESH_RECEIVE_BATCH_TIME_LIMIT_MS;
+    }
+}
+/**
+ * M6A MeshNode backend. Stateful Spot/Actor entry points stay explicit until
+ * their owning M6B runtime is connected; topology and node/channel dispatch do
+ * not depend on those entry points.
+ */
+class ZLinkNodeRawMeshBackend {
+    meshName;
+    bindingPort;
+    applicationJobQueue;
+    applicationJobReceiveFlowFailureSink;
+    peerAdmissionSealed;
+    nativeInstance = this;
+    channels = new Map();
+    peerIntents = new Map();
+    completions = [];
+    completionHead = 0;
+    completionCount = 0;
+    routingId;
+    lifecycleGeneration;
+    bindEndpoint;
+    advertiseHost;
+    runtime;
+    stateful;
+    readyHandler;
+    pollTimer;
+    nextPeerIntent = 1n;
+    closed = false;
+    objectRole = 'none';
+    placementWeight = 100;
+    activeCapacityLimit = 10_000;
+    pendingCapacityLimit = 128;
+    objectCapabilities = [];
+    maintenanceWave;
+    mailboxRecordDropped;
+    protocolError;
+    messageFollowHandler;
+    peerDisconnectedHandlers = new Set();
+    receiveBatchBudget = new ZLinkMeshReceiveBatchBudget();
+    observedPumpSourceRoutingId;
+    observedPumpByteCount = 0;
+    observePump = (sourceRoutingId, byteCount) => {
+        this.observedPumpSourceRoutingId = sourceRoutingId;
+        this.observedPumpByteCount = byteCount;
+    };
+    takePumpObservation() {
+        const sourceRoutingId = this.observedPumpSourceRoutingId;
+        if (sourceRoutingId === undefined)
+            return undefined;
+        return { sourceRoutingId, byteCount: this.observedPumpByteCount };
+    }
+    constructor(meshName, routingId, bindingPort, applicationJobQueue, applicationJobReceiveFlowFailureSink, peerAdmissionSealed) {
+        this.meshName = meshName;
+        this.bindingPort = bindingPort;
+        this.applicationJobQueue = applicationJobQueue;
+        this.applicationJobReceiveFlowFailureSink = applicationJobReceiveFlowFailureSink;
+        this.peerAdmissionSealed = peerAdmissionSealed;
+        if (meshName.length === 0)
+            throw new TypeError('MeshName must be non-empty.');
+        if (routingId === undefined || routingId.length === 0) {
+            throw new TypeError('M6A raw MeshNode requires a routing id.');
+        }
+        this.routingId = routingId;
+        this.lifecycleGeneration = createLifecycleGeneration();
+    }
+    configureObjectPlacement(options) {
+        this.requireNotStarted();
+        this.objectRole = options.role;
+        this.placementWeight = requirePublicWeight(options.placementWeight, 'placementWeight');
+        this.activeCapacityLimit = requirePositivePlacementValue(options.activeCapacityLimit, 'activeCapacityLimit');
+        this.pendingCapacityLimit = requirePositivePlacementValue(options.pendingCapacityLimit, 'pendingCapacityLimit');
+        this.objectCapabilities = [...new Set(options.objectCapabilities)].sort();
+        this.maintenanceWave = options.maintenanceWave;
+    }
+    setMailboxRecordDroppedHandler(handler) {
+        this.mailboxRecordDropped = handler;
+        this.stateful?.setMailboxDropHandler(handler);
+    }
+    setProtocolErrorHandler(handler) {
+        this.protocolError = handler;
+    }
+    onPeerDisconnected(handler) {
+        this.peerDisconnectedHandlers.add(handler);
+    }
+    selectObjectPlacement(stableType) {
+        const runtime = this.requireRuntime();
+        const localNodeRid = runtime.topology.localDescriptor().nodeRoutingId;
+        const status = runtime.topology.objectPlacementStatus(stableType, candidate => candidate.nodeRoutingId === localNodeRid
+            || runtime.isPeerRouteReady(candidate.nodeRoutingId));
+        if (status !== 'available')
+            return { kind: status };
+        const descriptor = runtime.topology.selectObjectPlacement(stableType, candidate => candidate.nodeRoutingId === localNodeRid
+            || runtime.isPeerRouteReady(candidate.nodeRoutingId));
+        return descriptor === undefined
+            ? { kind: 'unavailable' }
+            : {
+                kind: 'selected',
+                target: {
+                    targetNodeRid: descriptor.nodeRoutingId,
+                    targetNodeGeneration: descriptor.lifecycleGeneration,
+                    descriptorVersion: descriptor.descriptorRevision.toString()
+                }
+            };
+    }
+    instanceSpotPlacementTypes() {
+        return this.requireRuntime().topology.instanceSpotPlacementTypes();
+    }
+    async sendToMissingInstanceSpot(target, parts, deadlineUnixMs, sourceSpotId, metadata) {
+        const result = await this.requireStateful().sendToMissingInstanceSpotFrame(target, encodeMultipartApplicationFrame(parts), deadlineUnixMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata));
+        return result;
+    }
+    requestToMissingInstanceSpot(target, parts, deadlineUnixMs, sourceSpotId, metadata) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToMissingInstanceSpotFrame(target, encodeMultipartApplicationFrame(parts), deadlineUnixMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata)));
+    }
+    setRoutingId(routingId) {
+        if (String(routingId) !== this.routingId) {
+            throw new Error('MeshNode routing id is immutable after construction.');
+        }
+    }
+    setBind(endpoint) {
+        this.requireNotStarted();
+        if (endpoint.length === 0)
+            throw new TypeError('MeshNode bind endpoint must be non-empty.');
+        this.bindEndpoint = endpoint;
+    }
+    setAdvertiseHost(host) {
+        this.requireNotStarted();
+        if (host.length === 0)
+            throw new TypeError('MeshNode advertise host must be non-empty.');
+        this.advertiseHost = host;
+    }
+    start() {
+        if (this.runtime !== undefined)
+            return;
+        if (this.closed)
+            throw new Error('MeshNode is closed.');
+        if (this.bindEndpoint === undefined)
+            throw new Error('MeshNode bind endpoint is not configured.');
+        const descriptor = this.createDescriptor();
+        const runtime = new raw_service_mesh_runtime_1.RawServiceMeshRuntime({
+            descriptor,
+            resolveAdvertisedEndpoint: boundEndpoint => this.resolveAdvertisedEndpoint(boundEndpoint),
+            bindingPort: this.bindingPort,
+            applicationJobQueue: this.requireApplicationJobQueue(),
+            peerAdmissionSealed: this.peerAdmissionSealed,
+            onReceiveFlowConfigFailure: this.applicationJobReceiveFlowFailureSink,
+            onMailboxReady: (domain) => this.readyHandler?.(domain === 'application' ? service_runtime_contracts_1.ReadyDomain.Application : service_runtime_contracts_1.ReadyDomain.Infrastructure),
+            onProtocolError: (record) => this.protocolError?.({
+                sourceNodeRid: record.sourceRoutingId,
+                request: record.request,
+                replied: record.replied,
+                ...(record.command === undefined ? {} : { command: record.command })
+            }),
+            onPeerNotRequired: (nodeRoutingId, endpoint) => {
+                for (const [intent, peer] of this.peerIntents) {
+                    if ((peer.nodeRoutingId === undefined
+                        || peer.nodeRoutingId === nodeRoutingId)
+                        && peer.endpoint === endpoint) {
+                        this.peerIntents.delete(intent);
+                    }
+                }
+            },
+            onPeerDisconnected: (nodeRoutingId, endpoint) => {
+                for (const [intentId, peer] of this.peerIntents) {
+                    if (peer.endpoint === endpoint
+                        && (peer.nodeRoutingId === undefined || peer.nodeRoutingId === nodeRoutingId)) {
+                        this.peerIntents.delete(intentId);
+                    }
+                }
+                for (const handler of this.peerDisconnectedHandlers)
+                    handler(endpoint);
+            }
+        });
+        runtime.start();
+        this.stateful = new service_stateful_runtime_1.ServiceStatefulRuntime(runtime, descriptor.nodeRoutingId, descriptor.lifecycleGeneration);
+        if (this.mailboxRecordDropped !== undefined) {
+            this.stateful.setMailboxDropHandler(this.mailboxRecordDropped);
+        }
+        this.stateful.setMessageFollowHandler((record) => this.messageFollowHandler?.(record));
+        this.runtime = runtime;
+        this.schedulePoll();
+    }
+    setMessageFollowHandler(handler) {
+        this.messageFollowHandler = handler;
+    }
+    async sendMessageFollowNotification(targetNodeRid, record) {
+        return await this.requireStateful().sendMessageFollowNotification(targetNodeRid, record);
+    }
+    shutdown(_timeoutMs) {
+        this.close();
+        return zlink_1.RequestResult.Ok;
+    }
+    async publishDraining() {
+        for (const name of this.channels.keys())
+            this.channels.set(name, 0);
+        await this.requireRuntime().updateLocalDescriptor({ state: 'draining' });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.pollTimer !== undefined)
+            clearTimeout(this.pollTimer);
+        this.pollTimer = undefined;
+        this.stateful?.close();
+        this.stateful = undefined;
+        this.runtime?.close();
+        this.runtime = undefined;
+        this.clearCompletions();
+    }
+    addChannelName(name) {
+        this.requireNotStarted();
+        if (name.length === 0)
+            throw new TypeError('ChannelName must be non-empty.');
+        this.channels.set(name, this.channels.get(name) ?? 100);
+    }
+    async setChannelWeight(name, weight) {
+        if (!this.channels.has(name))
+            throw new Error(`Channel '${name}' is not registered.`);
+        const validated = requirePublicWeight(weight, 'Channel weight');
+        if (this.channels.get(name) === validated)
+            return;
+        this.channels.set(name, validated);
+        if (this.runtime !== undefined) {
+            await this.runtime.updateLocalDescriptor({
+                channelName: name,
+                channelWeight: validated
+            });
+        }
+    }
+    async setPlacementWeight(weight) {
+        const validated = requirePublicWeight(weight, 'Placement weight');
+        if (this.placementWeight === validated)
+            return;
+        this.placementWeight = validated;
+        if (this.runtime !== undefined) {
+            await this.runtime.updateLocalDescriptor({ placementWeight: validated });
+        }
+    }
+    async connectPeer(options) {
+        const runtime = this.requireRuntime();
+        const nodeRoutingId = options.expectedRid === undefined
+            ? undefined
+            : String(options.expectedRid);
+        if (nodeRoutingId === undefined) {
+            runtime.connectPeerEndpoint(options.endpoint);
+        }
+        else {
+            runtime.connectPeerByRoutingId(options.endpoint, nodeRoutingId, options.expectedSecurityIdentity
+                ?? runtime.topology.localDescriptor().securityIdentity, options.expectedLifecycleGeneration);
+        }
+        const intent = this.nextPeerIntent++;
+        this.peerIntents.set(intent, {
+            endpoint: options.endpoint,
+            ...(nodeRoutingId === undefined ? {} : {
+                nodeRoutingId,
+                lifecycleGeneration: options.expectedLifecycleGeneration
+            })
+        });
+        if (nodeRoutingId !== undefined)
+            await runtime.announcePeer(nodeRoutingId);
+        return intent;
+    }
+    expectPeer(peer) {
+        this.requireRuntime().expectPeerByRoutingId(peer.endpoint, peer.nodeRoutingId, peer.securityIdentity, peer.lifecycleGeneration);
+    }
+    removePeerConnection(intentId) {
+        const intent = this.peerIntents.get(intentId);
+        if (intent === undefined)
+            return;
+        this.peerIntents.delete(intentId);
+        if (intent.nodeRoutingId === undefined) {
+            this.runtime?.disconnectPeerEndpoint(intent.endpoint);
+        }
+        else {
+            this.runtime?.disconnectPeer(intent.endpoint, intent.nodeRoutingId, intent.lifecycleGeneration);
+        }
+    }
+    disconnectPeer(peerRid, lifecycleGeneration) {
+        const nodeRoutingId = String(peerRid);
+        const admitted = this.runtime?.topology.peer(nodeRoutingId);
+        if (admitted !== undefined
+            && admitted.descriptor.lifecycleGeneration !== lifecycleGeneration) {
+            return;
+        }
+        const admittedEndpoint = admitted?.descriptor.advertisedEndpoint;
+        const found = [...this.peerIntents.entries()]
+            .find(([, intent]) => (intent.nodeRoutingId === nodeRoutingId
+            && (intent.lifecycleGeneration === undefined
+                || intent.lifecycleGeneration === lifecycleGeneration))
+            || (intent.nodeRoutingId === undefined
+                && admittedEndpoint !== undefined
+                && intent.endpoint === admittedEndpoint));
+        if (found === undefined) {
+            if (admitted !== undefined) {
+                this.runtime?.disconnectPeer(admitted.descriptor.advertisedEndpoint, nodeRoutingId, lifecycleGeneration);
+            }
+            return;
+        }
+        this.removePeerConnection(found[0]);
+    }
+    replaceDiscoveredNotRequiredPeers(peers) {
+        const local = this.requireRuntime().topology.localDescriptor();
+        this.requireRuntime().replaceDiscoveredNotRequired(peers.map(peer => ({
+            ...local,
+            nodeRoutingId: peer.nodeRoutingId,
+            lifecycleGeneration: peer.lifecycleGeneration,
+            descriptorRevision: peer.descriptorRevision,
+            advertisedEndpoint: peer.endpoint,
+            channels: [],
+            objectRole: 'client'
+        })));
+    }
+    isObjectClientNodeDirectTarget(targetRid) {
+        return this.requireRuntime().isObjectClientNodeDirectTarget(String(targetRid));
+    }
+    isPeerRouteReady(targetRid, lifecycleGeneration) {
+        return this.requireRuntime().isPeerRouteReady(String(targetRid), lifecycleGeneration);
+    }
+    async sendToNode(targetRid, parts) {
+        return await this.requireRuntime().sendToNode(String(targetRid), encodeMultipart(parts)) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
+    }
+    async sendInfrastructureControl(targetRid, record) {
+        return await this.requireRuntime().sendService(String(targetRid), (Array.isArray(record) ? record : [record]).map(value => Buffer.from(value))) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
+    }
+    async sendInfrastructureControlFrames(targetRid, frames) {
+        return await this.requireRuntime().sendService(String(targetRid), frames.map(frame => Buffer.from(frame))) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
+    }
+    async requestInfrastructureControlFrames(targetRid, frames, options) {
+        return await this.requireRuntime().requestService(String(targetRid), frames.map(frame => Buffer.from(frame)), options?.timeoutMs ?? 30_000);
+    }
+    requestToNode(targetRid, parts, options) {
+        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipart(parts), options?.timeoutMs ?? 30_000);
+        return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.NodeRequest, pending.promise);
+    }
+    async sendToChannel(channelName, parts) {
+        return await this.requireRuntime().sendToChannel(channelName, encodeMultipart(parts)) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
+    }
+    requestToChannel(channelName, parts, options) {
+        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipart(parts), options?.timeoutMs ?? 30_000);
+        if (pending === undefined) {
+            return this.enqueueImmediateFailure(service_runtime_contracts_1.OperationKind.ChannelRequest, zlink_1.RequestResult.NotFound);
+        }
+        return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.ChannelRequest, pending.promise);
+    }
+    status() {
+        const descriptor = this.runtime?.topology.localDescriptor() ?? this.createDescriptor();
+        const peers = this.runtime?.topology.peers() ?? [];
+        return {
+            state: stateCode(descriptor.state),
+            routingId: descriptor.nodeRoutingId,
+            meshName: descriptor.meshName,
+            localEndpoint: descriptor.advertisedEndpoint,
+            lifecycleGeneration: descriptor.lifecycleGeneration,
+            descriptorRevision: descriptor.descriptorRevision,
+            channelCount: descriptor.channels.length,
+            configuredPeerCount: this.peerIntents.size,
+            admittedPeerCount: peers.length,
+            drainingPeerCount: peers.filter(peer => peer.descriptor.state === 'draining').length,
+            pendingApplicationMessages: BigInt(this.runtime?.mailbox.pendingMessages('application') ?? 0),
+            pendingInfrastructureMessages: BigInt((this.runtime?.mailbox.pendingMessages('infrastructure') ?? 0) + this.completionCount),
+            pendingBytes: BigInt((this.runtime?.mailbox.pendingBytes('application') ?? 0)
+                + (this.runtime?.mailbox.pendingBytes('infrastructure') ?? 0)),
+            lastError: 0,
+            lastChangedMs: BigInt(Math.trunc(performance.now()))
+        };
+    }
+    peers() {
+        const intents = [...this.peerIntents.entries()].map(([id, intent]) => ({
+            id,
+            ...intent
+        }));
+        const findIntent = (nodeRoutingId, endpoint) => intents.find(intent => intent.nodeRoutingId === nodeRoutingId
+            || (intent.nodeRoutingId === undefined
+                && intent.endpoint === endpoint));
+        const admitted = (this.runtime?.topology.peers() ?? []).map(peer => ({
+            connectionIntentId: findIntent(peer.descriptor.nodeRoutingId, peer.descriptor.advertisedEndpoint)?.id ?? 0n,
+            source: 1,
+            state: this.runtime?.isPeerRouteReady(peer.descriptor.nodeRoutingId) === false
+                ? 1
+                : peerStateCode(peer.descriptor.state),
+            routingId: peer.descriptor.nodeRoutingId,
+            lifecycleGeneration: peer.descriptor.lifecycleGeneration,
+            descriptorRevision: peer.descriptor.descriptorRevision,
+            endpoint: peer.descriptor.advertisedEndpoint,
+            channelCount: peer.descriptor.channels.length,
+            lastError: 0,
+            lastChangedMs: BigInt(Math.trunc(performance.now()))
+        }));
+        const notRequired = (this.runtime?.topology.notRequiredPeers() ?? []).map(descriptor => ({
+            connectionIntentId: findIntent(descriptor.nodeRoutingId, descriptor.advertisedEndpoint)?.id ?? 0n,
+            source: 1,
+            state: 6,
+            routingId: descriptor.nodeRoutingId,
+            lifecycleGeneration: descriptor.lifecycleGeneration,
+            descriptorRevision: descriptor.descriptorRevision,
+            endpoint: descriptor.advertisedEndpoint,
+            channelCount: 0,
+            lastError: 0,
+            lastChangedMs: BigInt(Math.trunc(performance.now()))
+        }));
+        const projected = new Set([
+            ...admitted.map(peer => peer.connectionIntentId),
+            ...notRequired.map(peer => peer.connectionIntentId)
+        ]);
+        const disconnected = intents
+            .filter(intent => intent.nodeRoutingId !== undefined
+            && !projected.has(intent.id))
+            .map(intent => {
+            const descriptor = this.runtime?.topology.knownDescriptor(intent.nodeRoutingId);
+            return {
+                connectionIntentId: intent.id,
+                source: 1,
+                // A new manual intent is Connecting until its first descriptor is
+                // observed. A previously admitted required peer is NotConnected.
+                state: descriptor === undefined ? 1 : 0,
+                routingId: intent.nodeRoutingId,
+                lifecycleGeneration: descriptor?.lifecycleGeneration ?? 0n,
+                descriptorRevision: descriptor?.descriptorRevision ?? 0n,
+                endpoint: descriptor?.advertisedEndpoint ?? intent.endpoint,
+                channelCount: descriptor?.channels.length ?? 0,
+                lastError: 0,
+                lastChangedMs: BigInt(Math.trunc(performance.now()))
+            };
+        });
+        return [...admitted, ...notRequired, ...disconnected]
+            .sort((left, right) => String(left.routingId).localeCompare(String(right.routingId)));
+    }
+    peerChannels(peerRid, lifecycleGeneration) {
+        const descriptor = this.runtime?.topology.knownDescriptor(String(peerRid));
+        if (descriptor === undefined || descriptor.lifecycleGeneration !== lifecycleGeneration) {
+            return { names: [], weights: [] };
+        }
+        return {
+            names: descriptor.channels.map(channel => channel.name),
+            weights: descriptor.channels.map(channel => channel.weight)
+        };
+    }
+    createPublisher() {
+        let publisherClosed = false;
+        const publish = async (channelName, topic, parts) => {
+            if (publisherClosed)
+                throw new Error('Mesh publisher is closed.');
+            await this.requireStateful().publishLogicalMulticast(channelName, topic, encodeMultipart(parts));
+        };
+        return {
+            publish,
+            publishAsync: async (channelName, topic, parts, _options, signal) => {
+                signal?.throwIfAborted();
+                await publish(channelName, topic, parts);
+            },
+            close: () => {
+                publisherClosed = true;
+            }
+        };
+    }
+    setReadyHandler(handler) {
+        this.readyHandler = handler;
+        this.notifyReady();
+    }
+    createReadyBatch(capacity) {
+        return new RawReadyBatch(capacity);
+    }
+    createReceiveBatch(messageCapacity, partCapacity) {
+        return new RawReceiveBatch(messageCapacity, partCapacity);
+    }
+    drainReady(domains, batch) {
+        const target = requireRawReadyBatch(batch);
+        if ((domains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
+            this.drainCompletions(target);
+            this.drainMailbox('infrastructure', target);
+        }
+        if ((domains & service_runtime_contracts_1.ReadyDomain.Application) !== 0) {
+            this.drainMailbox('application', target);
+        }
+        const runtime = this.runtime;
+        const infrastructureResidue = (domains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0
+            && (this.completionCount > 0
+                || (runtime?.mailbox.pendingMessages('infrastructure') ?? 0) > 0);
+        const applicationResidue = (domains & service_runtime_contracts_1.ReadyDomain.Application) !== 0
+            && (runtime?.mailbox.pendingMessages('application') ?? 0) > 0;
+        return {
+            ok: true,
+            // Residue is scoped to the requested lane. The pump drains lanes in
+            // separate turns and must not wait on another lane before returning.
+            hasResidue: infrastructureResidue || applicationResidue,
+            records: target.records
+        };
+    }
+    createSpot() {
+        return new RawServiceSpot(this, this.requireStateful().createSpot());
+    }
+    entrySpot() {
+        return new RawServiceSpot(this, this.requireStateful().entrySpot());
+    }
+    getOrCreateSpot(routingId) {
+        const stateful = this.requireStateful();
+        const rid = String(routingId);
+        const existing = stateful.registry.spot(rid);
+        const state = existing ?? stateful.createSpot(rid);
+        return { spot: new RawServiceSpot(this, state), created: existing === undefined };
+    }
+    instanceSpotApplicationTarget(spotId) {
+        return this.requireStateful().instanceSpotApplicationTarget(spotId);
+    }
+    waitForInstanceApplicationQuiescence(spotId, signal) {
+        return this.requireStateful().waitForInstanceApplicationQuiescence(spotId, signal);
+    }
+    restoreUserSpotAuthority(spotId, stableType, generation, authorityOwnerGeneration) {
+        return new RawServiceSpot(this, this.requireStateful().restoreUserSpotAuthority(spotId, stableType, generation, authorityOwnerGeneration));
+    }
+    restoreSpotAuthority(spotId, objectKind, stableType, generation, authorityOwnerGeneration) {
+        return new RawServiceSpot(this, this.requireStateful().restoreSpotAuthority(spotId, objectKind, stableType, generation, authorityOwnerGeneration));
+    }
+    createActor(actorId) {
+        return this.requireStateful().createActor(actorId).ref;
+    }
+    restoreActorAuthority(actorId, stableType, generation, authorityOwnerGeneration, spotId, spotGeneration, membershipEpoch) {
+        return this.requireStateful().restoreActorAuthority(actorId, stableType, generation, authorityOwnerGeneration, spotId, spotGeneration, membershipEpoch).ref;
+    }
+    discardRelocatedActor(actor) {
+        this.requireStateful().discardRelocatedActor({
+            nodeRid: String(actor.nodeRid),
+            actorId: actor.actorId,
+            generation: actor.generation
+        });
+    }
+    restoreActorSessionBinding(actor, sessionNodeRid, sessionRid, bindingGeneration) {
+        this.requireStateful().restoreActorSessionBinding({
+            nodeRid: String(actor.nodeRid),
+            actorId: actor.actorId,
+            generation: actor.generation
+        }, String(sessionNodeRid), String(sessionRid), bindingGeneration);
+    }
+    registerInstanceIntent(instanceType, route, expectedCurrentRoute) {
+        this.requireStateful().registerInstanceIntent(instanceType, route, expectedCurrentRoute);
+    }
+    registerAsyncInstanceActivationAuthority(authority) {
+        this.requireStateful().registerAsyncInstanceActivationAuthority(authority);
+    }
+    registerInstanceApplicationLifecycle(lifecycle) {
+        this.requireStateful().registerInstanceApplicationLifecycle(lifecycle);
+    }
+    registerUserSpotOperationHandler(handler) {
+        this.requireStateful().registerUserSpotOperationHandler(handler);
+    }
+    requestUserSpotCreate(targetNodeRid, request, timeoutMs) {
+        return this.requireStateful().requestUserSpotCreate(targetNodeRid, request, timeoutMs);
+    }
+    requestUserSpotClose(targetNodeRid, request, timeoutMs) {
+        return this.requireStateful().requestUserSpotClose(targetNodeRid, request, timeoutMs);
+    }
+    requestActorCreate(targetNodeRid, request, timeoutMs) {
+        return this.requireStateful().requestActorCreate(targetNodeRid, request, timeoutMs);
+    }
+    recoverInstanceActivation(envelope, route, expectedCurrentRoute) {
+        return this.requireStateful().recoverInstanceActivation(envelope, route, expectedCurrentRoute);
+    }
+    recoverPendingInstanceActivation(envelope, pending, expectedCurrentRoute) {
+        return this.requireStateful().recoverPendingInstanceActivation(envelope, pending, expectedCurrentRoute);
+    }
+    completeRecoveredInstanceActivation(target, route, expectedCurrentRoute) {
+        return this.requireStateful().completeRecoveredInstanceActivation(target, route, expectedCurrentRoute);
+    }
+    forgetInstanceIntent(spotId, objectGeneration, authorityOwnerGeneration, storeVersion) {
+        this.requireStateful().forgetInstanceIntent(spotId, objectGeneration, authorityOwnerGeneration, storeVersion);
+    }
+    rememberSpotRoute(route, expectedCurrentRoute) {
+        this.requireStateful().rememberSpotRoute(route, expectedCurrentRoute);
+    }
+    entrySpotRouteFence(targetNodeRid, targetSpotId) {
+        const generation = this.peerGeneration(targetNodeRid);
+        return {
+            spot: { spotId: targetSpotId, generation },
+            targetNodeRid,
+            targetNodeGeneration: generation,
+            authorityOwnerGeneration: generation,
+            ownerLeaseGeneration: generation,
+            storeVersion: entrySpotFenceVersion(generation)
+        };
+    }
+    sealSpotMessageFollowIngress(source) {
+        return this.requireStateful().sealSpotMessageFollowIngress(source);
+    }
+    abortSpotMessageFollowIngress(seal) {
+        return this.requireStateful().abortSpotMessageFollowIngress(seal);
+    }
+    commitSpotMessageFollowIngress(seal, target, durationMs) {
+        return this.requireStateful().commitSpotMessageFollowIngress(seal, target, durationMs);
+    }
+    forgetSpotRoute(spot, authorityOwnerGeneration, storeVersion) {
+        this.requireStateful().forgetSpotRoute(spot, authorityOwnerGeneration, storeVersion);
+    }
+    async sendToInstanceSpot(route, parts, sourceSpotId, metadata) {
+        const result = await this.requireStateful().sendToInstanceSpot(route, encodeMultipart(parts), sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata));
+        return result;
+    }
+    requestInstanceSpot(route, parts, timeoutMs = 30_000, sourceSpotId, metadata) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToInstanceSpot(route, encodeMultipart(parts), timeoutMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata)));
+    }
+    actorLookup(actorId) {
+        const actor = this.requireStateful().actor(actorId);
+        if (actor === undefined) {
+            throw Object.assign(new Error(`Actor '${actorId}' was not found.`), { nativeErrno: 2 });
+        }
+        return {
+            actor: actor.ref,
+            spotId: actor.spot.spotId,
+            spotGeneration: actor.spot.generation,
+            membershipEpoch: actor.membershipEpoch
+        };
+    }
+    lookupRemoteActor(targetNodeRid, actorId, timeoutMs = 30_000) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorLookup, this.requireStateful().lookupRemoteActor(String(targetNodeRid), actorId, timeoutMs));
+    }
+    destroyActor(actor, timeoutMs = 30_000) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorDestroy, this.requireStateful().destroyActor(actor, timeoutMs));
+    }
+    joinActorSpot(actor, targetNodeRid, targetSpotId, targetSpotGeneration, request, timeoutMs = 30_000) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActor(actor, String(targetNodeRid), { spotId: String(targetSpotId), generation: targetSpotGeneration }, targetSpotGeneration, request, timeoutMs));
+    }
+    joinActorSpotCanonical(actor, targetNodeRid, targetSpotId, targetSpotGeneration, request, actorFence, local, timeoutMs = 30_000) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActorCanonical(actor, String(targetNodeRid), { spotId: String(targetSpotId), generation: targetSpotGeneration }, targetSpotGeneration, request, actorFence, local, timeoutMs));
+    }
+    joinActorEntrySpot(actor, targetNodeRid, request, timeoutMs = 30_000) {
+        const target = String(targetNodeRid);
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActorEntrySpot(actor, target, request, timeoutMs));
+    }
+    joinActorEntrySpotCanonical(actor, targetNodeRid, request, actorFence, local, timeoutMs = 30_000) {
+        const target = String(targetNodeRid);
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorJoin, this.requireStateful().joinActorEntrySpotCanonical(actor, target, request, actorFence, local, timeoutMs));
+    }
+    async sendToActor(actor, parts) {
+        return this.requireStateful().sendToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts));
+    }
+    requestToActor(actor, parts, options) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts), options?.timeoutMs ?? 30_000));
+    }
+    async actorSendToActor(source, target, parts) {
+        return await this.requireStateful().sendToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), source);
+    }
+    actorRequestToActor(source, target, parts, options) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), options?.timeoutMs ?? 30_000, source));
+    }
+    async sendActorBoundSession(actor, expectedBindingGeneration, parts, _flags, actorFence) {
+        return await this.requireStateful().sendBoundSession(actor, expectedBindingGeneration, encodeMultipart(parts), actorFence);
+    }
+    closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs = 30_000) {
+        const binding = this.requireStateful().registry.binding(actor);
+        if (binding === undefined) {
+            return this.enqueueImmediateFailure(service_runtime_contracts_1.OperationKind.StreamUnbind, zlink_1.RequestResult.NotFound);
+        }
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.StreamUnbind, this.requireStateful().unbindSession(binding.sessionRid, actor, expectedBindingGeneration, timeoutMs));
+    }
+    leaveActor(actor, expectedMembershipEpoch, timeoutMs = 30_000) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorLeave, this.requireStateful().leaveActor(actor, expectedMembershipEpoch, timeoutMs));
+    }
+    createStreamSessionService(stream) {
+        return new RawStreamSessionService(this.requireStateful(), stream, (kind, pending) => this.observeStateful(kind, pending));
+    }
+    async sendFromSpot(source, target, parts) {
+        return await this.requireStateful().sendToSpot(source.ref.spotId, target, encodeMultipart(parts));
+    }
+    requestFromSpot(source, target, parts, timeoutMs) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.SpotRequest, this.requireStateful().requestToSpot(source.ref.spotId, target, encodeMultipart(parts), timeoutMs));
+    }
+    closeSpot(state) {
+        return this.requireStateful().registry.closeSpot(state.ref);
+    }
+    async publishFromSpot(state, channelName, topic, parts) {
+        await this.requireStateful().publishLogicalMulticast(channelName, topic, encodeMultipart(parts), state.ref.spotId);
+    }
+    setSpotSubscription(state, channelName, topicFilter) {
+        this.requireStateful().setSubscription(state, channelName, topicFilter);
+    }
+    unsetSpotSubscription(state, channelName, topicFilter) {
+        this.requireStateful().unsetSubscription(state, channelName, topicFilter);
+    }
+    clearSpotSubscriptions(state) {
+        this.requireStateful().clearSubscriptions(state.ref.spotId);
+    }
+    createDescriptor() {
+        const channels = [...this.channels]
+            .map(([name, weight]) => ({ name, weight }))
+            .sort((left, right) => left.name.localeCompare(right.name));
+        return {
+            meshName: this.meshName,
+            nodeRoutingId: this.routingId,
+            lifecycleGeneration: this.lifecycleGeneration,
+            descriptorRevision: 1n,
+            advertisedEndpoint: this.bindEndpoint ?? 'inproc://not-started',
+            channels,
+            state: 'preparing',
+            // Plaintext RouteMesh peers use the shared default admission identity.
+            securityIdentity: 'default',
+            applicationVersion: 0n,
+            ...(this.maintenanceWave === undefined ? {} : { maintenanceWave: this.maintenanceWave }),
+            protocolCapabilities: [
+                service_wire_constants_generated_1.SERVICE_WIRE_REQUIRED_CAPABILITY,
+                ...this.objectCapabilities
+            ].sort(),
+            objectRole: this.objectRole,
+            placementWeight: this.placementWeight,
+            activeCapacityLimit: this.activeCapacityLimit,
+            pendingCapacityLimit: this.pendingCapacityLimit,
+            activeCapacityUsed: 0,
+            pendingCapacityUsed: 0
+        };
+    }
+    resolveAdvertisedEndpoint(boundEndpoint) {
+        const result = (0, EndpointNotation_1.buildAdvertisedEndpoint)(boundEndpoint, this.advertiseHost, 'tcp');
+        if (result === undefined) {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`RouteMesh advertise host requires a TCP endpoint, received '${boundEndpoint}'.`);
+        }
+        return result;
+    }
+    schedulePoll(delayMs = MESH_BACKEND_IDLE_POLL_INTERVAL_MS) {
+        if (this.closed || this.pollTimer !== undefined)
+            return;
+        this.pollTimer = setTimeout(async () => {
+            this.pollTimer = undefined;
+            try {
+                const received = await this.poll();
+                // A zero-delay timer yields to I/O and other ready work first without
+                // inserting the idle polling interval between readable batches.
+                delayMs = received ? 0 : MESH_BACKEND_IDLE_POLL_INTERVAL_MS;
+            }
+            finally {
+                if (!this.closed)
+                    this.schedulePoll(delayMs);
+            }
+        }, delayMs);
+    }
+    async poll() {
+        const runtime = this.runtime;
+        if (runtime === undefined)
+            return false;
+        let received = false;
+        await runtime.drainMonitorEvents();
+        this.receiveBatchBudget.reset(performance.now());
+        for (;;) {
+            this.observedPumpSourceRoutingId = undefined;
+            const result = await runtime.pumpOne(performance.now(), this.observePump);
+            if (result === 'noData')
+                break;
+            received = true;
+            if (result === 'application')
+                this.readyHandler?.(service_runtime_contracts_1.ReadyDomain.Application);
+            const observation = this.takePumpObservation();
+            // Core ROUTER advances its fair-queue cursor after each complete
+            // multipart message, so the next poll resumes from the following pipe.
+            if (observation !== undefined
+                && this.receiveBatchBudget.record(observation.sourceRoutingId, observation.byteCount, performance.now()))
+                break;
+        }
+        await runtime.announceExpectedPeers();
+        await runtime.tickLiveness();
+        this.notifyReady();
+        return received;
+    }
+    notifyReady() {
+        const runtime = this.runtime;
+        let domains = service_runtime_contracts_1.ReadyDomain.None;
+        if (this.completionCount > 0 || (runtime?.mailbox.pendingMessages('infrastructure') ?? 0) > 0) {
+            domains |= service_runtime_contracts_1.ReadyDomain.Infrastructure;
+        }
+        if ((runtime?.mailbox.pendingMessages('application') ?? 0) > 0) {
+            domains |= service_runtime_contracts_1.ReadyDomain.Application;
+        }
+        if (domains !== service_runtime_contracts_1.ReadyDomain.None)
+            this.readyHandler?.(domains);
+    }
+    observeCompletion(low, operationKind, promise) {
+        const id = { high: 1n, low };
+        void promise.then(result => this.enqueueCompletion(id, operationKind, result), error => this.enqueueCompletion(id, operationKind, genericOperationFailure(error)));
+        return id;
+    }
+    observeStateful(operationKind, pending) {
+        const id = { high: 2n, low: pending.id };
+        void pending.promise.then(result => this.enqueueCompletion(id, operationKind, result), error => this.enqueueCompletion(id, operationKind, statefulOperationFailure(error)));
+        return id;
+    }
+    enqueueImmediateFailure(operationKind, terminalResult) {
+        const low = this.nextPeerIntent++;
+        const id = { high: 1n, low };
+        this.enqueueCompletion(id, operationKind, { terminalResult, failureCode: 0 });
+        return id;
+    }
+    enqueueCompletion(operationId, operationKind, result) {
+        if (this.closed)
+            return;
+        this.completions.push({ operationId, operationKind, result });
+        this.completionCount += 1;
+        this.readyHandler?.(service_runtime_contracts_1.ReadyDomain.Infrastructure);
+    }
+    drainCompletions(batch) {
+        while (!batch.full && this.completionCount > 0) {
+            const completion = this.takeCompletion();
+            if (completion === undefined)
+                continue;
+            batch.push({
+                ownerKind: service_runtime_contracts_1.ReadyOwnerKind.Node,
+                domain: service_runtime_contracts_1.ReadyDomain.Infrastructure,
+                spotId: null,
+                actor: null,
+                terminalCompletion: true
+            }, new CompletionClaim(completion));
+        }
+    }
+    takeCompletion() {
+        const completion = this.completions[this.completionHead];
+        if (completion === undefined)
+            return undefined;
+        this.completions[this.completionHead] = undefined;
+        this.completionHead += 1;
+        this.completionCount -= 1;
+        if (this.completionCount === 0) {
+            this.clearCompletions();
+        }
+        else if (this.completionHead >= 1024
+            && this.completionHead * 2 >= this.completions.length) {
+            this.completions.splice(0, this.completionHead);
+            this.completionHead = 0;
+        }
+        return completion;
+    }
+    clearCompletions() {
+        this.completions.length = 0;
+        this.completionHead = 0;
+        this.completionCount = 0;
+    }
+    drainMailbox(domain, batch) {
+        const runtime = this.runtime;
+        if (runtime === undefined)
+            return;
+        while (!batch.full) {
+            const claim = runtime.mailbox.tryClaim(domain, MAX_DRAIN_RECORDS, Number.MAX_SAFE_INTEGER);
+            if (claim === undefined)
+                break;
+            const owner = readyOwner(claim.owner, this.routingId, this.stateful, domain);
+            batch.push(owner, new MailboxClaim(runtime, claim, () => {
+                // A receive batch may intentionally consume fewer records than the
+                // mailbox claim. Releasing the claim re-queues the remainder, so
+                // expose that newly ready work to the dispatch pump.
+                if (runtime.mailbox.pendingMessages(domain) > 0) {
+                    this.readyHandler?.(domain === 'infrastructure' ? service_runtime_contracts_1.ReadyDomain.Infrastructure : service_runtime_contracts_1.ReadyDomain.Application);
+                }
+            }));
+        }
+    }
+    requireRuntime() {
+        if (this.runtime === undefined)
+            throw new Error('MeshNode is not started.');
+        return this.runtime;
+    }
+    requireApplicationJobQueue() {
+        if (this.applicationJobQueue === undefined) {
+            throw new Error('Raw MeshNode requires the host Application Job Queue.');
+        }
+        return this.applicationJobQueue;
+    }
+    requireStateful() {
+        if (this.stateful === undefined)
+            throw new Error('Stateful MeshNode is not started.');
+        return this.stateful;
+    }
+    peerGeneration(nodeRid) {
+        if (nodeRid === this.routingId) {
+            return this.requireRuntime().topology.localDescriptor().lifecycleGeneration;
+        }
+        return this.requireRuntime().topology.peer(nodeRid)?.descriptor.lifecycleGeneration ?? 1n;
+    }
+    requireNotStarted() {
+        if (this.runtime !== undefined)
+            throw new Error('MeshNode is already started.');
+        if (this.closed)
+            throw new Error('MeshNode is closed.');
+    }
+}
+exports.ZLinkNodeRawMeshBackend = ZLinkNodeRawMeshBackend;
+class RawServiceSpot {
+    backend;
+    state;
+    routingId;
+    lifecycleGeneration;
+    subscriptions = new Set();
+    closed = false;
+    constructor(backend, state) {
+        this.backend = backend;
+        this.state = state;
+        this.routingId = state.ref.spotId;
+        this.lifecycleGeneration = state.ref.generation;
+    }
+    status() {
+        return {
+            routingId: this.routingId,
+            lifecycleGeneration: this.lifecycleGeneration
+        };
+    }
+    async sendToChannel(channelName, parts, options) {
+        this.requireOpen();
+        void options;
+        return this.backend.sendToChannel(channelName, parts);
+    }
+    requestToChannel(channelName, parts, options) {
+        this.requireOpen();
+        return this.backend.requestToChannel(channelName, parts, options);
+    }
+    async sendToSpot(targetNodeRid, targetSpotId, targetSpotGeneration, parts, options) {
+        this.requireOpen();
+        const routeFence = requireDirectSpotRouteFence(options?.routeFence, String(targetNodeRid), String(targetSpotId), targetSpotGeneration, options?.entrySpot === true
+            ? this.backend.entrySpotRouteFence(String(targetNodeRid), String(targetSpotId))
+            : undefined);
+        return this.backend.sendFromSpot(this.state, routeFence, parts);
+    }
+    requestToSpot(targetNodeRid, targetSpotId, targetSpotGeneration, parts, options) {
+        this.requireOpen();
+        const routeFence = requireDirectSpotRouteFence(options?.routeFence, String(targetNodeRid), String(targetSpotId), targetSpotGeneration, options?.entrySpot === true
+            ? this.backend.entrySpotRouteFence(String(targetNodeRid), String(targetSpotId))
+            : undefined);
+        return this.backend.requestFromSpot(this.state, routeFence, parts, options?.timeoutMs ?? 30_000);
+    }
+    async publish(channelName, topic, parts, options) {
+        this.requireOpen();
+        void options;
+        await this.backend.publishFromSpot(this.state, channelName, topic, parts);
+    }
+    setSubscription(channelName, topicFilter, kind = 0) {
+        this.requireOpen();
+        if (kind !== 0)
+            throw new RangeError('Only the default logical multicast subscription kind is supported.');
+        this.backend.setSpotSubscription(this.state, channelName, topicFilter);
+        this.subscriptions.add(`${channelName}\0${topicFilter}\0${kind}`);
+    }
+    unsetSubscription(channelName, topicFilter, kind = 0) {
+        this.requireOpen();
+        if (kind !== 0)
+            throw new RangeError('Only the default logical multicast subscription kind is supported.');
+        this.backend.unsetSpotSubscription(this.state, channelName, topicFilter);
+        this.subscriptions.delete(`${channelName}\0${topicFilter}\0${kind}`);
+    }
+    close() {
+        if (this.closed)
+            return;
+        if (this.state.kind !== 'entry' && !this.backend.closeSpot(this.state)) {
+            throw new Error(`Spot '${this.routingId}' still has Actor members.`);
+        }
+        this.backend.clearSpotSubscriptions(this.state);
+        this.closed = true;
+        this.subscriptions.clear();
+    }
+    async dispose() {
+        this.close();
+    }
+    requireOpen() {
+        if (this.closed)
+            throw new Error(`Spot '${this.routingId}' is closed.`);
+    }
+}
+function requireDirectSpotRouteFence(route, targetNodeRid, targetSpotId, targetSpotGeneration, entryRoute) {
+    if (route === undefined && entryRoute !== undefined) {
+        return entryRoute;
+    }
+    if (route === undefined
+        || route.targetNodeRid !== targetNodeRid
+        || route.spot.spotId !== targetSpotId
+        || route.spot.generation !== targetSpotGeneration) {
+        throw new TypeError('Direct Spot submission requires the exact resolved authority fence.');
+    }
+    return route;
+}
+function entrySpotFenceVersion(generation) {
+    return `entry:${generation}`;
+}
+class RawStreamSessionService {
+    stateful;
+    stream;
+    observe;
+    state = 1;
+    closed = false;
+    sessionTargets = new Map();
+    constructor(stateful, stream, observe) {
+        this.stateful = stateful;
+        this.stream = stream;
+        this.observe = observe;
+    }
+    start() {
+        if (this.closed)
+            throw new Error('STREAM session service is closed.');
+        this.state = 2;
+    }
+    shutdown(_timeoutMs) {
+        this.close();
+        return zlink_1.RequestResult.Ok;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.state = 5;
+        this.sessionTargets.clear();
+    }
+    status() {
+        const bindings = this.stateful.allSessionBindings();
+        return {
+            state: this.state,
+            lifecycleGeneration: 1n,
+            sessionCount: BigInt(new Set(bindings.map(value => value.sessionRid)).size),
+            bindingCount: BigInt(bindings.length),
+            pendingMessageCount: 0n,
+            pendingByteCount: 0n,
+            lastError: 0
+        };
+    }
+    lookupActor(targetNodeRid, actorId, timeoutMs = 30_000) {
+        this.requireStarted();
+        return this.observe(service_runtime_contracts_1.OperationKind.ActorLookup, this.stateful.lookupRemoteActor(String(targetNodeRid), actorId, timeoutMs));
+    }
+    bindActor(sessionRid, actor, timeoutMs = 30_000, onBindingReplaced, actorAuthority) {
+        this.requireStarted();
+        const sessionKey = String(sessionRid);
+        this.sessionTargets.set(sessionKey, sessionRid);
+        return this.observe(service_runtime_contracts_1.OperationKind.StreamBind, this.stateful.bindSession(sessionKey, actor, timeoutMs, (targetSessionRid, payloadFrame) => this.deliver(targetSessionRid, payloadFrame), onBindingReplaced, (0, service_session_binding_ingress_port_1.serviceSessionBindingIngressPortIfRegistered)(this), actorAuthority));
+    }
+    unbindActor(sessionRid, actor, expectedBindingGeneration, timeoutMs = 30_000) {
+        this.requireStarted();
+        return this.observe(service_runtime_contracts_1.OperationKind.StreamUnbind, this.stateful.unbindSession(String(sessionRid), actor, expectedBindingGeneration, timeoutMs));
+    }
+    bindings(sessionRid) {
+        return this.stateful.sessionBindings(String(sessionRid));
+    }
+    async sendToActor(sessionRid, actor, parts) {
+        this.requireStarted();
+        return await this.stateful.sendSessionToActor(String(sessionRid), actor, encodeMultipart(parts));
+    }
+    async deliver(sessionRid, payload) {
+        const target = this.sessionTargets.get(sessionRid);
+        if (target === undefined)
+            return false;
+        const operation = this.stream.send(target);
+        const parts = decodeMultipartBuffers((0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload).payload);
+        if (parts.length === 0)
+            return false;
+        let submit = operation.message(parts[0]);
+        for (let index = 1; index < parts.length; index++) {
+            submit = submit.message(parts[index]);
+        }
+        try {
+            await submit.submit();
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof zlink_1.SubmitError))
+                throw error;
+            switch (error.result) {
+                case zlink_1.SubmitResult.NotConnected:
+                case zlink_1.SubmitResult.NotFound:
+                case zlink_1.SubmitResult.Terminated:
+                    // Let the socket monitor drive the existing STREAM close/unbind
+                    // lifecycle instead of maintaining a second session-close state.
+                    (0, node_socket_backend_adapter_1.disconnectStreamPeer)(this.stream, target);
+                    throw new runtime_values_1.ZLinkBackendResultError('submit', error.result, error.nativeErrno, { cause: error });
+                case zlink_1.SubmitResult.Backpressured:
+                case zlink_1.SubmitResult.NotAdmitted:
+                    throw new runtime_values_1.ZLinkBackendResultError('submit', error.result, error.nativeErrno, { cause: error });
+                default:
+                    throw error;
+            }
+        }
+    }
+    requireStarted() {
+        if (this.state !== 2 || this.closed) {
+            throw new Error('STREAM session service is not started.');
+        }
+    }
+}
+class RawReadyBatch {
+    capacity;
+    records = [];
+    claims = [];
+    constructor(capacity) {
+        this.capacity = capacity;
+        if (!Number.isInteger(capacity) || capacity < 1)
+            throw new RangeError('Ready capacity must be positive.');
+    }
+    get full() {
+        return this.records.length >= this.capacity;
+    }
+    push(record, claim) {
+        if (this.full)
+            throw new Error('Ready batch is full.');
+        this.records.push(record);
+        this.claims.push(claim);
+    }
+    takeClaim(index) {
+        if (index < 0 || index >= this.claims.length) {
+            throw new RangeError('Ready claim index is invalid.');
+        }
+        return this.claims[index];
+    }
+    reset() {
+        this.records.length = 0;
+        this.claims.length = 0;
+    }
+    close() {
+        this.reset();
+    }
+}
+class RawReceiveBatch {
+    messageCapacity;
+    partCapacity;
+    constructor(messageCapacity, partCapacity) {
+        this.messageCapacity = messageCapacity;
+        this.partCapacity = partCapacity;
+        if ([messageCapacity, partCapacity].some(value => !Number.isInteger(value) || value < 1)) {
+            throw new RangeError('Receive batch capacities must be positive.');
+        }
+    }
+    reset() { }
+    close() { }
+}
+class MailboxClaim {
+    runtime;
+    claim;
+    onRelease;
+    consumed = false;
+    released = false;
+    remaining = [];
+    constructor(runtime, claim, onRelease) {
+        this.runtime = runtime;
+        this.claim = claim;
+        this.onRelease = onRelease;
+    }
+    recvBatch(batch) {
+        if (this.consumed)
+            return { ok: false, records: [] };
+        this.consumed = true;
+        const capacity = batch;
+        const records = [];
+        let parts = 0;
+        for (let index = 0; index < this.claim.records.length; index += 1) {
+            const record = this.claim.records[index];
+            let decoded;
+            try {
+                decoded = decodeMultipartRecord(this.runtime, record);
+            }
+            catch (error) {
+                record.applicationJob?.close();
+                if (error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError) {
+                    this.runtime.mailbox.releaseClaimedPayload(record);
+                    continue;
+                }
+                this.runtime.mailbox.releaseClaimedPayload(record);
+                this.remaining = this.claim.records.slice(index + 1);
+                throw error;
+            }
+            const nextParts = decoded.parts.length;
+            if (records.length >= capacity.messageCapacity
+                || parts + nextParts > capacity.partCapacity) {
+                for (const part of decoded.parts)
+                    part.close();
+                this.remaining = this.claim.records.slice(index);
+                break;
+            }
+            parts += nextParts;
+            records.push(decoded);
+            this.runtime.mailbox.releaseClaimedPayload(record);
+        }
+        return { ok: records.length > 0, records };
+    }
+    release() {
+        if (this.released)
+            return;
+        this.released = true;
+        this.runtime.mailbox.release(this.claim, this.remaining);
+        this.onRelease?.();
+    }
+}
+class CompletionClaim {
+    completion;
+    consumed = false;
+    constructor(completion) {
+        this.completion = completion;
+    }
+    recvBatch() {
+        if (this.consumed)
+            return { ok: false, records: [] };
+        this.consumed = true;
+        const payload = this.completion.result.payload;
+        return {
+            ok: true,
+            records: [{
+                    kind: service_runtime_contracts_1.ReceiveKind.Completion,
+                    domain: service_runtime_contracts_1.ReadyDomain.Infrastructure,
+                    sourceNodeRid: null,
+                    sourceSpotId: null,
+                    sourceBindingGeneration: 0n,
+                    sourceActor: null,
+                    operationId: this.completion.operationId,
+                    operationKind: this.completion.operationKind,
+                    channelName: null,
+                    topic: null,
+                    applicationMetadata: null,
+                    kindData: 'kindData' in this.completion.result
+                        ? this.completion.result.kindData ?? null
+                        : null,
+                    terminalResult: this.completion.result.terminalResult,
+                    failureErrno: this.completion.result.failureCode,
+                    parts: payload === undefined
+                        ? []
+                        : payload.contentType === MULTIPART_CONTENT_TYPE
+                            ? decodeMultipart(payload.payload)
+                            : [zlink_1.Message.from(payload.payload)],
+                    reply: () => zlink_1.SubmitResult.InvalidState,
+                    replyActorJoin: () => zlink_1.SubmitResult.NotSupported
+                }]
+        };
+    }
+    release() { }
+}
+function decodeMultipartRecord(runtime, record) {
+    const stateful = (0, service_stateful_runtime_1.statefulMailboxData)(record);
+    if (stateful !== undefined) {
+        return decodeStatefulRecord(record, stateful);
+    }
+    // RawServiceMeshRuntime admits the frozen relocation/session controls as
+    // bare service-wire frames on the infrastructure mailbox.  They are
+    // node-owned infrastructure work, not an M6A application envelope, so do
+    // not try to read `parts[1]` as an application payload frame here.  The
+    // host's relocation dispatcher decodes the canonical frame directly from
+    // `parts[0]` and any trailing frames (e.g. a Prepare's bound-session
+    // journal sideband, spec 28 §4.4) as its own node-internal ZLNI frames.
+    // Application dispatch (Channel*/NodeSend/NodeRequest 16-19 envelopes)
+    // always arrives on the application mailbox domain, so gating on
+    // `record.domain` here — rather than solely on part count — keeps a
+    // multi-frame infrastructure control (Prepare + sideband) from being
+    // misread as a 2-frame application envelope and dropped as invalid_frame.
+    if (record.parts.length === 1 || record.domain === 'infrastructure') {
+        const request = record.requestSequence !== undefined
+            && record.sourceRoutingId !== undefined;
+        return {
+            kind: request ? service_runtime_contracts_1.ReceiveKind.NodeRequest : service_runtime_contracts_1.ReceiveKind.NodeSend,
+            domain: readyDomain(record.domain),
+            sourceNodeRid: record.sourceRoutingId ?? null,
+            sourceSpotId: null,
+            sourceBindingGeneration: 0n,
+            sourceActor: null,
+            operationId: { high: 0n, low: record.requestSequence ?? 0n },
+            operationKind: request ? service_runtime_contracts_1.OperationKind.NodeRequest : 0,
+            channelName: null,
+            topic: null,
+            applicationMetadata: null,
+            packetName: undefined,
+            contentType: undefined,
+            kindData: null,
+            terminalResult: 0,
+            failureErrno: 0,
+            ...receiveIngressLifecycle(record),
+            parts: record.parts.map(part => zlink_1.Message.from(part)),
+            reply(parts) {
+                if (!request)
+                    return zlink_1.SubmitResult.InvalidState;
+                const values = Array.isArray(parts) ? parts : [parts];
+                if (values.length === 0)
+                    return zlink_1.SubmitResult.InvalidState;
+                runtime.replyService({
+                    sourceRoutingId: record.sourceRoutingId,
+                    ...(record.sourceRoute === undefined ? {} : { sourceRoute: record.sourceRoute }),
+                    requestSequence: record.requestSequence,
+                    ...(record.reply === undefined ? {} : { reply: record.reply })
+                }, values.map(value => Buffer.from(messageBytesView(value))));
+                return zlink_1.SubmitResult.Ok;
+            },
+            replyActorJoin: () => zlink_1.SubmitResult.NotSupported
+        };
+    }
+    const header = record.parts[0];
+    const command = header[3];
+    const payloadFrame = record.parts[1];
+    const application = decodeApplicationEnvelope(payloadFrame);
+    const channelName = record.owner.startsWith('channel:') ? record.owner.slice('channel:'.length) : null;
+    const operationId = record.correlation === undefined
+        ? { high: 0n, low: 0n }
+        : { high: 1n, low: record.correlation };
+    const kind = command === 16
+        ? service_runtime_contracts_1.ReceiveKind.NodeSend
+        : command === 17
+            ? service_runtime_contracts_1.ReceiveKind.NodeRequest
+            : command === 18
+                ? service_runtime_contracts_1.ReceiveKind.ChannelSend
+                : service_runtime_contracts_1.ReceiveKind.ChannelRequest;
+    const operationKind = kind === service_runtime_contracts_1.ReceiveKind.NodeRequest
+        ? service_runtime_contracts_1.OperationKind.NodeRequest
+        : kind === service_runtime_contracts_1.ReceiveKind.ChannelRequest
+            ? service_runtime_contracts_1.OperationKind.ChannelRequest
+            : 0;
+    const ingressLifecycle = receiveIngressLifecycle(record);
+    return {
+        kind,
+        domain: readyDomain(record.domain),
+        sourceNodeRid: record.sourceRoutingId ?? null,
+        sourceSpotId: null,
+        sourceBindingGeneration: 0n,
+        sourceActor: null,
+        operationId,
+        operationKind,
+        channelName,
+        topic: null,
+        applicationMetadata: null,
+        packetName: application.packetName,
+        contentType: application.contentType,
+        kindData: null,
+        terminalResult: 0,
+        failureErrno: 0,
+        ...ingressLifecycle,
+        parts: decodeMultipart(application.payload),
+        reply(parts) {
+            if (record.correlation === undefined)
+                return zlink_1.SubmitResult.InvalidState;
+            runtime.reply(record, encodeMultipart(parts));
+            return zlink_1.SubmitResult.Ok;
+        },
+        replyActorJoin: () => zlink_1.SubmitResult.NotSupported
+    };
+}
+function decodeStatefulRecord(record, stateful) {
+    const payloadFrame = record.parts.length < 2 ? undefined : record.parts[1];
+    const canonicalActorJoin = stateful.kindData?.kind === 'actorControl'
+        && stateful.kindData.canonicalActorJoin !== undefined;
+    const canonicalActorJoinPayload = stateful.operationKind === service_runtime_contracts_1.OperationKind.ActorJoin
+        && stateful.canonicalApplicationPayload !== undefined;
+    const application = canonicalActorJoinPayload
+        ? stateful.canonicalApplicationPayload
+        : (payloadFrame === undefined ? undefined : decodeApplicationEnvelope(payloadFrame));
+    const operationId = record.correlation === undefined
+        ? { high: 0n, low: 0n }
+        : { high: 2n, low: record.correlation };
+    const ingressLifecycle = receiveIngressLifecycle(record);
+    return {
+        kind: stateful.receiveKind,
+        domain: readyDomain(record.domain),
+        sourceNodeRid: record.sourceRoutingId ?? null,
+        sourceSpotId: stateful.sourceSpotId ?? null,
+        sourceBindingGeneration: stateful.sourceBindingGeneration ?? 0n,
+        sourceActor: stateful.sourceActor ?? null,
+        operationId,
+        operationKind: stateful.operationKind,
+        channelName: stateful.channelName ?? null,
+        topic: stateful.topic ?? null,
+        applicationMetadata: stateful.applicationMetadata ?? null,
+        ...(application === undefined
+            ? {}
+            : {
+                packetName: application.packetName,
+                contentType: application.contentType
+            }),
+        kindData: stateful.kindData ?? null,
+        terminalResult: 0,
+        failureErrno: 0,
+        ...ingressLifecycle,
+        parts: application === undefined
+            ? []
+            : canonicalActorJoinPayload
+                ? [zlink_1.Message.from(application.payload)]
+                : decodeMultipart(application.payload),
+        ...(stateful.isPending === undefined ? {} : { isPending: stateful.isPending }),
+        ...(stateful.deadlineUnixMs === undefined ? {} : { deadlineUnixMs: stateful.deadlineUnixMs }),
+        ...(stateful.messageFollowOrigin === undefined
+            ? {}
+            : { messageFollowOrigin: stateful.messageFollowOrigin }),
+        ...(stateful.onTerminalCompletion === undefined
+            ? {}
+            : { onTerminalCompletion: stateful.onTerminalCompletion }),
+        reply(parts) {
+            if (stateful.reply === undefined)
+                return zlink_1.SubmitResult.InvalidState;
+            return stateful.reply(zlink_1.RequestResult.Ok, 0, encodeMultipart(parts)) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.InvalidState;
+        },
+        replyActorJoin(joinResult, parts, _flags, _replyContentType) {
+            if (stateful.reply === undefined || stateful.targetSpot === undefined) {
+                return zlink_1.SubmitResult.InvalidState;
+            }
+            const membershipEpoch = stateful.kindData?.kind === 'actorControl'
+                ? stateful.kindData.currentMembershipEpoch
+                : undefined;
+            if (joinResult === 0 && membershipEpoch === undefined) {
+                return zlink_1.SubmitResult.InvalidState;
+            }
+            const replyParts = Array.isArray(parts) ? parts : [parts];
+            if (canonicalActorJoin && replyParts.length > 1) {
+                return zlink_1.SubmitResult.InvalidState;
+            }
+            const replyPayload = replyParts.length === 0
+                ? undefined
+                : encodeMultipart(replyParts);
+            const accepted = stateful.reply(zlink_1.RequestResult.Ok, 0, replyPayload, {
+                kind: 'actorJoin',
+                joinResult: joinResult === 0 ? 0 : 1,
+                spot: stateful.targetSpot,
+                ...(membershipEpoch === undefined ? {} : { membershipEpoch }),
+                // Spec 15 §4.2: the accepted admission reply carries the target's
+                // valid receive chunk cap for this join's relocation state chunks —
+                // a conservative, recompute-stable bound (never lowered).
+                ...(joinResult === 0
+                    ? { receiveChunkLimitBytes: ACTOR_JOIN_ADVERTISED_RECEIVE_CHUNK_LIMIT_BYTES }
+                    : {})
+            });
+            return accepted ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.InvalidState;
+        },
+        replyFailure(terminalResult, failureCode) {
+            if (stateful.reply === undefined)
+                return zlink_1.SubmitResult.InvalidState;
+            return stateful.reply(terminalResult, failureCode)
+                ? zlink_1.SubmitResult.Ok
+                : zlink_1.SubmitResult.InvalidState;
+        }
+    };
+}
+function receiveIngressLifecycle(record) {
+    const applicationJob = record.applicationJob;
+    return applicationJob === undefined
+        ? {}
+        : {
+            applicationJobPermit: applicationJob,
+            releaseRetainedIngress: () => applicationJob.close()
+        };
+}
+function readyOwner(owner, nodeRid, stateful, domain) {
+    if (owner.startsWith('spot:')) {
+        return {
+            ownerKind: service_runtime_contracts_1.ReadyOwnerKind.Spot,
+            domain: readyDomain(domain),
+            ordinaryIngressPreAdmitted: domain === 'application',
+            spotId: owner.slice('spot:'.length),
+            actor: null
+        };
+    }
+    if (owner.startsWith('actor:')) {
+        const separator = owner.indexOf('\0', 'actor:'.length);
+        const actorId = separator < 0
+            ? owner.slice('actor:'.length)
+            : owner.slice('actor:'.length, separator);
+        const generation = separator < 0 ? 0n : BigInt(owner.slice(separator + 1));
+        const current = stateful?.actor(actorId);
+        return {
+            ownerKind: service_runtime_contracts_1.ReadyOwnerKind.Actor,
+            domain: readyDomain(domain),
+            ordinaryIngressPreAdmitted: domain === 'application',
+            spotId: current?.spot.spotId ?? null,
+            actor: current?.ref ?? {
+                nodeRid,
+                actorId,
+                generation
+            }
+        };
+    }
+    return {
+        ownerKind: service_runtime_contracts_1.ReadyOwnerKind.Node,
+        domain: readyDomain(domain),
+        ordinaryIngressPreAdmitted: domain === 'application',
+        spotId: null,
+        actor: null
+    };
+}
+function readyDomain(domain) {
+    return domain === 'infrastructure'
+        ? service_runtime_contracts_1.ReadyDomain.Infrastructure
+        : service_runtime_contracts_1.ReadyDomain.Application;
+}
+/**
+ * Classifies a generic node/channel request rejection into a completion
+ * terminal. Spec 32-framework-error-model:91-92 — a reply that could not be
+ * decoded (ServiceWireProtocolError from the reply parser) is a protocol
+ * failure, not connection loss; only genuine transport rejections collapse to
+ * NotConnected.
+ */
+function genericOperationFailure(error) {
+    //  requestProtocolError(16): the schema terminal-failure-integrity rule
+    //  forbids a typed terminal (104) with failure none, so the synthesized
+    //  decode-failure pair is 104+16; genuine transport loss stays 109+0.
+    return error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError
+        ? { terminalResult: zlink_1.RequestResult.ProtocolError, failureCode: 16 }
+        : { terminalResult: zlink_1.RequestResult.NotConnected, failureCode: 0 };
+}
+function statefulOperationFailure(error) {
+    if (error instanceof contracts_1.ZLinkFrameworkException) {
+        return (0, framework_errors_internal_1.internalFrameworkWireReply)(error);
+    }
+    if (error instanceof operation_registry_1.OperationTimeoutError) {
+        return { terminalResult: zlink_1.RequestResult.TimedOut, failureCode: 0 };
+    }
+    if ((0, runtime_values_1.isZLinkBackendResultError)(error)) {
+        return {
+            terminalResult: error.result,
+            failureCode: error.nativeErrno ?? 0
+        };
+    }
+    if (error instanceof operation_registry_1.OperationCancelledError) {
+        return { terminalResult: zlink_1.RequestResult.NotConnected, failureCode: 0 };
+    }
+    return { terminalResult: zlink_1.RequestResult.InternalError, failureCode: 17 };
+}
+function encodeMultipart(parts) {
+    const values = Array.isArray(parts) ? parts : [parts];
+    if (values.length === 0)
+        throw new TypeError('Multipart payload must contain at least one part.');
+    //  messageBytesView aliases the caller's buffer; the parts are consumed
+    //  synchronously by the copy loop below and never retained.
+    const bytes = values.map(messageBytesView);
+    let size = 4;
+    for (const part of bytes)
+        size += 4 + part.byteLength;
+    const payload = Buffer.alloc(size);
+    payload.writeUInt32BE(bytes.length, 0);
+    let offset = 4;
+    for (const part of bytes) {
+        payload.writeUInt32BE(part.byteLength, offset);
+        offset += 4;
+        payload.set(part, offset);
+        offset += part.byteLength;
+    }
+    return {
+        packetName: MULTIPART_PACKET_NAME,
+        contentType: MULTIPART_CONTENT_TYPE,
+        payload
+    };
+}
+function encodeMultipartApplicationFrame(parts) {
+    const values = Array.isArray(parts) ? parts : [parts];
+    if (values.length === 0)
+        throw new TypeError('Multipart payload must contain at least one part.');
+    return (0, service_wire_m6a_codec_1.encodeMultipartApplicationPayload)(values.map(messageBytesView), MULTIPART_PACKET_NAME, MULTIPART_CONTENT_TYPE);
+}
+function decodeApplicationEnvelope(frame) {
+    const bytes = Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength);
+    if (bytes.length < 11 || bytes[0] !== 1) {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid application envelope.');
+    }
+    const bodyLength = bytes.readUInt32BE(1);
+    if (bodyLength !== bytes.length - 5) {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid application envelope length.');
+    }
+    let offset = 5;
+    const packetLength = bytes[offset++];
+    if (packetLength === 0 || bytes.length - offset < packetLength + 1) {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid application envelope packet name.');
+    }
+    let packetName;
+    try {
+        packetName = FATAL_UTF8.decode(bytes.subarray(offset, offset + packetLength));
+    }
+    catch {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid application envelope packet name.');
+    }
+    offset += packetLength;
+    const contentLength = bytes[offset++];
+    if (contentLength === 0 || bytes.length - offset < contentLength + 4) {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid application envelope content type.');
+    }
+    let contentType;
+    try {
+        contentType = FATAL_UTF8.decode(bytes.subarray(offset, offset + contentLength));
+    }
+    catch {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid application envelope content type.');
+    }
+    offset += contentLength;
+    const payloadLength = bytes.readUInt32BE(offset);
+    offset += 4;
+    if (packetName !== MULTIPART_PACKET_NAME
+        || contentType !== MULTIPART_CONTENT_TYPE
+        || payloadLength !== bytes.length - offset) {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Unexpected M6A application payload.');
+    }
+    return { packetName, contentType, payload: bytes.subarray(offset) };
+}
+function decodeMultipart(payload) {
+    const buffers = decodeMultipartBuffers(payload);
+    return buffers.map(part => zlink_1.Message.from(part));
+}
+function decodeMultipartBuffers(payload) {
+    const bytes = Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength);
+    if (bytes.length < 4)
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart payload.');
+    const count = bytes.readUInt32BE(0);
+    if (count === 0 || count > Math.floor((bytes.length - 4) / 4)) {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid multipart part count.');
+    }
+    const result = new Array(count);
+    let offset = 4;
+    for (let index = 0; index < count; index++) {
+        if (bytes.length - offset < 4) {
+            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart part length.');
+        }
+        const length = bytes.readUInt32BE(offset);
+        offset += 4;
+        if (bytes.length - offset < length) {
+            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart part.');
+        }
+        result[index] = bytes.subarray(offset, offset + length);
+        offset += length;
+    }
+    if (offset !== bytes.length) {
+        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Multipart payload has trailing bytes.');
+    }
+    return result;
+}
+function messageBytesView(value) {
+    if (typeof value === 'object' && 'data' in value) {
+        return value.data();
+    }
+    if (typeof value === 'string')
+        return Buffer.from(value);
+    return value;
+}
+function requireRawReadyBatch(batch) {
+    if (!(batch instanceof RawReadyBatch))
+        throw new TypeError('Ready batch belongs to another backend.');
+    return batch;
+}
+function stateCode(state) {
+    return ['preparing', 'serving', 'retiring', 'draining', 'stopped', 'error'].indexOf(state) + 1;
+}
+function peerStateCode(state) {
+    switch (state) {
+        case 'preparing': return 2;
+        case 'serving':
+        case 'retiring': return 3;
+        case 'draining': return 4;
+        case 'stopped':
+        case 'error': return 5;
+    }
+}
+function createLifecycleGeneration() {
+    // Node's public Spot context exposes this lifecycle token as a number. Keep
+    // the opaque equality token within the exact range that surface can carry;
+    // lifecycle ordering is never inferred from its numeric value.
+    const generation = (0, node_crypto_1.randomBytes)(8).readBigUInt64BE()
+        & BigInt(Number.MAX_SAFE_INTEGER);
+    return generation === 0n ? 1n : generation;
+}
+function requirePositivePlacementValue(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > 0x7fff_ffff) {
+        throw new RangeError(`${name} must be an integer in 1..2147483647.`);
+    }
+    return value;
+}
+function requirePublicWeight(value, name) {
+    if (!Number.isInteger(value) || value < 0 || value > 10_000) {
+        throw new RangeError(`${name} must be an integer in 0..10000.`);
+    }
+    return value;
+}