coakka-v2-connector-node 1.3.1

package/dist/runtime-client.js

@@ -0,0 +1,922 @@
+import { closeSync, readSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { BusinessStatus, DeliveryHint, MessageKind, PayloadFormat, PayloadIdentity, RequestTerminalEventKind, RouteStrategy, requireValidConnectorConfig, requireValidRuntimeOverloadPolicy, } from "./models.js";
+import { decodeDeadletter, decodeEnvelope, encodeControlEnvelope, encodeEnvelope, encodeRouteSnapshotPayload, } from "./protobuf.js";
+import { COAKKA_ABI_VERSION, HOST_HANDLES_ENABLE_MONITOR, HOST_HANDLES_SEPARATE_DELIVERED_REQUEST_LANE, NativeRuntimeBindings, } from "./runtime-ffi.js";
+export class DeadletterError extends Error {
+    deadletter;
+    constructor(deadletter) {
+        super(`deadletter reason=${deadletter.reason} detail=${deadletter.detail}`);
+        this.deadletter = deadletter;
+    }
+}
+class BufferedAsyncStream {
+    bufferCapacity;
+    onClose;
+    queue = [];
+    waiters = [];
+    closed = false;
+    constructor(bufferCapacity, onClose) {
+        this.bufferCapacity = bufferCapacity;
+        this.onClose = onClose;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    async next() {
+        if (this.queue.length > 0) {
+            return { value: this.queue.shift(), done: false };
+        }
+        if (this.closed) {
+            return { value: undefined, done: true };
+        }
+        return await new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    async return() {
+        this.close();
+        return { value: undefined, done: true };
+    }
+    push(event) {
+        if (this.closed) {
+            return false;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter != null) {
+            waiter({ value: event, done: false });
+            return true;
+        }
+        if (this.queue.length >= this.bufferCapacity) {
+            return false;
+        }
+        this.queue.push(event);
+        return true;
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.onClose();
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter?.({ value: undefined, done: true });
+        }
+        this.queue.length = 0;
+    }
+}
+class FrameReader {
+    fd;
+    onFrame;
+    onError;
+    buffer = Buffer.alloc(0);
+    closed = false;
+    timer = null;
+    constructor(fd, onFrame, onError) {
+        this.fd = fd;
+        this.onFrame = onFrame;
+        this.onError = onError;
+        this.schedulePoll();
+    }
+    close() {
+        this.closed = true;
+        if (this.timer != null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    handleChunk(chunk) {
+        this.buffer = this.buffer.length === 0 ? Buffer.from(chunk) : Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 8) {
+            const payloadLength = Number(this.buffer.readBigUInt64LE(0));
+            if (!Number.isSafeInteger(payloadLength)) {
+                this.onError(new Error(`frame length too large=${payloadLength}`));
+                return;
+            }
+            if (this.buffer.length < 8 + payloadLength) {
+                return;
+            }
+            const frame = Buffer.from(this.buffer.subarray(8, 8 + payloadLength));
+            this.buffer = this.buffer.subarray(8 + payloadLength);
+            this.onFrame(frame);
+        }
+    }
+    schedulePoll() {
+        this.timer = setTimeout(() => this.poll(), 5);
+    }
+    poll() {
+        if (this.closed) {
+            return;
+        }
+        try {
+            while (!this.closed) {
+                const chunk = Buffer.alloc(64 * 1024);
+                const bytesRead = readSync(this.fd, chunk, 0, chunk.length, null);
+                if (bytesRead === 0) {
+                    break;
+                }
+                this.handleChunk(chunk.subarray(0, bytesRead));
+                if (bytesRead < chunk.length) {
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            if (isRetryableReadError(error)) {
+                // ignore EAGAIN/EWOULDBLOCK on nonblocking runtime pipes
+            }
+            else if (!this.closed) {
+                this.onError(asError(error));
+            }
+        }
+        finally {
+            if (!this.closed) {
+                this.schedulePoll();
+            }
+        }
+    }
+}
+class SignalReader {
+    fd;
+    onError;
+    buffer = Buffer.alloc(0);
+    queue = [];
+    waiters = new Set();
+    closed = false;
+    timer = null;
+    constructor(fd, onError) {
+        this.fd = fd;
+        this.onError = onError;
+        this.schedulePoll();
+    }
+    async next(timeoutMs) {
+        if (this.queue.length > 0) {
+            return this.queue.shift() ?? null;
+        }
+        return await new Promise((resolve) => {
+            const waiter = (value) => {
+                clearTimeout(timer);
+                this.waiters.delete(waiter);
+                resolve(value);
+            };
+            const timer = setTimeout(() => {
+                this.waiters.delete(waiter);
+                resolve(null);
+            }, timeoutMs);
+            this.waiters.add(waiter);
+        });
+    }
+    close() {
+        this.closed = true;
+        if (this.timer != null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        for (const waiter of this.waiters) {
+            waiter(null);
+        }
+        this.waiters.clear();
+    }
+    handleChunk(chunk) {
+        this.buffer = this.buffer.length === 0 ? Buffer.from(chunk) : Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 8) {
+            const signalCount = Number(this.buffer.readBigUInt64LE(0));
+            this.buffer = this.buffer.subarray(8);
+            const waiter = this.waiters.values().next().value;
+            if (waiter != null) {
+                waiter(signalCount);
+            }
+            else {
+                this.queue.push(signalCount);
+            }
+        }
+    }
+    schedulePoll() {
+        this.timer = setTimeout(() => this.poll(), 5);
+    }
+    poll() {
+        if (this.closed) {
+            return;
+        }
+        try {
+            while (!this.closed) {
+                const chunk = Buffer.alloc(8);
+                const bytesRead = readSync(this.fd, chunk, 0, chunk.length, null);
+                if (bytesRead === 0) {
+                    break;
+                }
+                this.handleChunk(chunk.subarray(0, bytesRead));
+                if (bytesRead < chunk.length) {
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            if (isRetryableReadError(error)) {
+                // ignore EAGAIN/EWOULDBLOCK on nonblocking monitor pipes
+            }
+            else if (!this.closed) {
+                this.onError(asError(error));
+            }
+        }
+        finally {
+            if (!this.closed) {
+                this.schedulePoll();
+            }
+        }
+    }
+}
+export class NodeRuntimeClient {
+    config;
+    bindings;
+    runtime;
+    hostHandles;
+    pending = new Map();
+    trackedRequestsByMessageId = new Map();
+    trackedRequestMessageIdsByCorrelationId = new Map();
+    requestHandlers = new Map();
+    terminalEventSubscribers = new Map();
+    deadletterSubscribers = new Map();
+    requestReader;
+    responseReader;
+    deadletterReader;
+    monitorReader;
+    separateDeliveredRequestLane;
+    deliveredRequests = 0;
+    matchedResponses = 0;
+    matchedDeadletters = 0;
+    lateResponses = 0;
+    unhandledDeadletters = 0;
+    nextTerminalSubscriberId = 1;
+    nextDeadletterSubscriberId = 1;
+    terminalEventDropCount = 0;
+    deadletterObservationDropCount = 0;
+    closed = false;
+    constructor(runtimeLibPath, config) {
+        this.config = requireValidConnectorConfig(config);
+        this.bindings = new NativeRuntimeBindings(runtimeLibPath);
+        if (this.bindings.getAbiVersion() !== COAKKA_ABI_VERSION) {
+            throw new Error(`unexpected ABI version: ${this.bindings.getAbiVersion()}`);
+        }
+        this.runtime = this.bindings.createRuntime({
+            systemName: this.config.systemName,
+            nodeId: this.config.nodeId,
+            strictNoDrop: this.config.strictNoDrop ?? true,
+            queueCapacity: this.config.queueCapacity ?? 128,
+        });
+        this.hostHandles = this.bindings.getHostHandles(this.runtime, this.hostHandleFlags());
+        this.bindings.applyControlEnvelope(this.runtime, this.buildControlEnvelopeBytes());
+        this.bindings.startRuntime(this.runtime);
+        const deliveredRequestFd = this.hostHandles.deliveredRequestReadFd;
+        const responseFd = this.hostHandles.responseReadFd;
+        this.separateDeliveredRequestLane =
+            deliveredRequestFd >= 0 && deliveredRequestFd !== responseFd;
+        const requestReadFd = deliveredRequestFd >= 0 ? deliveredRequestFd : responseFd;
+        this.requestReader = new FrameReader(requestReadFd, (frame) => this.onRequestFrame(frame), (error) => this.onReaderError("request", error));
+        this.responseReader = this.separateDeliveredRequestLane
+            ? new FrameReader(responseFd, (frame) => this.onResponseFrame(frame), (error) => this.onReaderError("response", error))
+            : null;
+        this.deadletterReader = new FrameReader(this.hostHandles.deadletterReadFd, (frame) => this.onDeadletterFrame(frame), (error) => this.onReaderError("deadletter", error));
+        this.monitorReader = this.hostHandles.monitorReadFd >= 0
+            ? new SignalReader(this.hostHandles.monitorReadFd, (error) => this.onReaderError("monitor", error))
+            : null;
+    }
+    static nextMessageId(source) {
+        return `${source}-${randomUUID()}`;
+    }
+    static makeTypedRequest(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}, messageId = NodeRuntimeClient.nextMessageId(source), oneWay = false) {
+        const identity = payloadIdentity.requireTyped("typed request");
+        return {
+            message_id: messageId,
+            correlation_id: oneWay ? "" : messageId,
+            source,
+            target,
+            reply_to: oneWay ? "" : `${source}/replies`,
+            kind: MessageKind.REQUEST,
+            one_way: oneWay,
+            timeout_ms: timeoutMs,
+            payload,
+            headers: {
+                method: "POST",
+                operation,
+                ...headers,
+            },
+            status: BusinessStatus.OK,
+            error_code: "",
+            error_message: "",
+            delivery_hint: deliveryHint,
+            message_type: identity.messageType,
+            payload_schema_version: identity.payloadSchemaVersion,
+            payload_format: identity.payloadFormat,
+        };
+    }
+    static makeJsonRequest(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}, messageId = NodeRuntimeClient.nextMessageId(source), oneWay = false) {
+        return NodeRuntimeClient.makeTypedRequest(source, target, Buffer.from(JSON.stringify(payload)), payloadIdentity, timeoutMs, operation, deliveryHint, headers, messageId, oneWay);
+    }
+    static makeTypedReply(request, source, payload, payloadIdentity) {
+        const identity = payloadIdentity.requireTyped("typed reply");
+        const correlationId = request.correlation_id !== "" ? request.correlation_id : request.message_id;
+        return {
+            message_id: `${request.message_id}.reply.${source}`,
+            correlation_id: correlationId,
+            source,
+            target: request.source,
+            reply_to: "",
+            kind: MessageKind.RESPONSE,
+            one_way: false,
+            timeout_ms: request.timeout_ms,
+            payload,
+            headers: {},
+            status: BusinessStatus.OK,
+            error_code: "",
+            error_message: "",
+            delivery_hint: DeliveryHint.ROUTER_DEFAULT,
+            message_type: identity.messageType,
+            payload_schema_version: identity.payloadSchemaVersion,
+            payload_format: identity.payloadFormat,
+        };
+    }
+    static makeJsonReply(request, source, payload, payloadIdentity) {
+        return NodeRuntimeClient.makeTypedReply(request, source, Buffer.from(JSON.stringify(payload)), payloadIdentity);
+    }
+    static makeReplyFromRequestIdentity(request, source, payload) {
+        NodeRuntimeClient.requireTypedPayloadIdentity(request, "request");
+        return NodeRuntimeClient.makeTypedReply(request, source, payload, new PayloadIdentity(request.message_type, request.payload_schema_version, request.payload_format));
+    }
+    static makeJsonReplyFromRequestIdentity(request, source, payload) {
+        return NodeRuntimeClient.makeReplyFromRequestIdentity(request, source, Buffer.from(JSON.stringify(payload)));
+    }
+    static makeRawReply(request, source, payload) {
+        const correlationId = request.correlation_id !== "" ? request.correlation_id : request.message_id;
+        return {
+            message_id: `${request.message_id}.reply.${source}`,
+            correlation_id: correlationId,
+            source,
+            target: request.source,
+            reply_to: "",
+            kind: MessageKind.RESPONSE,
+            one_way: false,
+            timeout_ms: request.timeout_ms,
+            payload,
+            headers: {},
+            status: BusinessStatus.OK,
+            error_code: "",
+            error_message: "",
+            delivery_hint: DeliveryHint.ROUTER_DEFAULT,
+            message_type: "",
+            payload_schema_version: 0,
+            payload_format: PayloadFormat.UNSPECIFIED,
+        };
+    }
+    static makeRawRequest(messageId, source, target, replyTo, payload, timeoutMs = 1_000, deliveryHint = DeliveryHint.ROUTER_DEFAULT) {
+        return {
+            message_id: messageId,
+            correlation_id: messageId,
+            source,
+            target,
+            reply_to: replyTo,
+            kind: MessageKind.REQUEST,
+            one_way: false,
+            timeout_ms: timeoutMs,
+            payload,
+            headers: {},
+            status: BusinessStatus.OK,
+            error_code: "",
+            error_message: "",
+            delivery_hint: deliveryHint,
+            message_type: "",
+            payload_schema_version: 0,
+            payload_format: PayloadFormat.UNSPECIFIED,
+        };
+    }
+    static makeRawOneWay(messageId, source, target, payload, timeoutMs = 1_000, deliveryHint = DeliveryHint.ROUTER_DEFAULT) {
+        return {
+            ...NodeRuntimeClient.makeRawRequest(messageId, source, target, "", payload, timeoutMs, deliveryHint),
+            correlation_id: "",
+            reply_to: "",
+            one_way: true,
+        };
+    }
+    static requireTypedPayloadIdentity(envelope, what) {
+        new PayloadIdentity(envelope.message_type, envelope.payload_schema_version, envelope.payload_format).requireTyped(what);
+    }
+    async askTyped(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        const envelope = NodeRuntimeClient.makeTypedRequest(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint, headers, NodeRuntimeClient.nextMessageId(source), false);
+        return await this.submitPendingRequest(envelope, timeoutMs, (normalized) => this.submitTypedEnvelope(normalized));
+    }
+    async askJson(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        const response = await this.askTyped(source, target, Buffer.from(JSON.stringify(payload)), payloadIdentity, timeoutMs, operation, deliveryHint, headers);
+        return JSON.parse(Buffer.from(response.payload).toString("utf8"));
+    }
+    async askRaw(request, timeoutMs) {
+        if (request.kind !== MessageKind.REQUEST) {
+            throw new Error("askRaw requires MESSAGE_KIND_REQUEST");
+        }
+        if (request.one_way) {
+            throw new Error("askRaw requires oneWay=false");
+        }
+        if (request.message_id === "") {
+            throw new Error("askRaw requires messageId");
+        }
+        const normalized = {
+            ...request,
+            correlation_id: request.correlation_id !== "" ? request.correlation_id : request.message_id,
+        };
+        const effectiveTimeoutMs = timeoutMs ?? (normalized.timeout_ms > 0 ? normalized.timeout_ms : 1_000);
+        return await this.submitPendingRequest(normalized, effectiveTimeoutMs, (tracked) => this.submitRawEnvelope(tracked));
+    }
+    submitRequestTyped(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        const envelope = NodeRuntimeClient.makeTypedRequest(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint, headers, NodeRuntimeClient.nextMessageId(source), false);
+        return this.submitTrackedRequest(envelope, (normalized) => this.submitTypedEnvelope(normalized));
+    }
+    submitRequestJson(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        return this.submitRequestTyped(source, target, Buffer.from(JSON.stringify(payload)), payloadIdentity, timeoutMs, operation, deliveryHint, headers);
+    }
+    submitRequestRaw(request) {
+        return this.submitTrackedRequest(request, (normalized) => this.submitRawEnvelope(normalized));
+    }
+    sendOneWayTyped(source, target, payload, payloadIdentity, deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        const envelope = NodeRuntimeClient.makeTypedRequest(source, target, payload, payloadIdentity, 0, "one_way", deliveryHint, headers, NodeRuntimeClient.nextMessageId(source), true);
+        this.submitTypedEnvelope(envelope);
+    }
+    sendOneWayJson(source, target, payload, payloadIdentity, deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        this.sendOneWayTyped(source, target, Buffer.from(JSON.stringify(payload)), payloadIdentity, deliveryHint, headers);
+    }
+    submitRawEnvelope(envelope) {
+        this.bindings.submitEnvelope(this.runtime, encodeEnvelope(envelope));
+    }
+    submitTypedEnvelope(envelope) {
+        NodeRuntimeClient.requireTypedPayloadIdentity(envelope, "submitTypedEnvelope");
+        this.submitRawEnvelope(envelope);
+    }
+    submitEnvelope(envelope) {
+        this.submitRawEnvelope(envelope);
+    }
+    applyControlEnvelopeBytes(bytes) {
+        this.bindings.applyControlEnvelope(this.runtime, bytes);
+    }
+    applySnapshot(generation, routes, sourceConnector = this.config.systemName, seq = 1, overloadPolicy = this.config.overloadPolicy) {
+        const bytes = this.buildControlEnvelopeBytes(generation, routes, sourceConnector, seq, overloadPolicy);
+        this.applyControlEnvelopeBytes(bytes);
+    }
+    registerHandler(target, handler, typedReplies = true) {
+        if (this.requestHandlers.has(target)) {
+            throw new Error(`handler already registered for target=${target}`);
+        }
+        this.requestHandlers.set(target, { handler, typedReplies });
+    }
+    registerRawHandler(target, handler) {
+        this.registerHandler(target, handler, false);
+    }
+    terminalEvents(options = {}) {
+        const bufferCapacity = options.bufferCapacity ?? 16;
+        if (bufferCapacity < 1) {
+            throw new Error("terminalEvents requires bufferCapacity >= 1");
+        }
+        const subscriberId = this.nextTerminalSubscriberId++;
+        const stream = new BufferedAsyncStream(bufferCapacity, () => {
+            const active = this.terminalEventSubscribers.get(subscriberId);
+            if (active === stream) {
+                this.terminalEventSubscribers.delete(subscriberId);
+            }
+            if (options.signal != null) {
+                options.signal.removeEventListener("abort", closeStream);
+            }
+        });
+        const closeStream = () => {
+            stream.close();
+        };
+        this.terminalEventSubscribers.set(subscriberId, stream);
+        if (options.signal?.aborted) {
+            stream.close();
+            return stream;
+        }
+        options.signal?.addEventListener("abort", closeStream, { once: true });
+        return stream;
+    }
+    deadletters(options = {}) {
+        const bufferCapacity = options.bufferCapacity ?? 128;
+        if (bufferCapacity < 1) {
+            throw new Error("deadletters requires bufferCapacity >= 1");
+        }
+        const subscriberId = this.nextDeadletterSubscriberId++;
+        const stream = new BufferedAsyncStream(bufferCapacity, () => {
+            const active = this.deadletterSubscribers.get(subscriberId);
+            if (active === stream) {
+                this.deadletterSubscribers.delete(subscriberId);
+            }
+            if (options.signal != null) {
+                options.signal.removeEventListener("abort", closeStream);
+            }
+        });
+        const closeStream = () => {
+            stream.close();
+        };
+        this.deadletterSubscribers.set(subscriberId, stream);
+        if (options.signal?.aborted) {
+            stream.close();
+            return stream;
+        }
+        options.signal?.addEventListener("abort", closeStream, { once: true });
+        return stream;
+    }
+    snapshotStats() {
+        return {
+            pendingRequests: this.pending.size,
+            deliveredRequests: this.deliveredRequests,
+            matchedResponses: this.matchedResponses,
+            matchedDeadletters: this.matchedDeadletters,
+            lateResponses: this.lateResponses,
+            unhandledDeadletters: this.unhandledDeadletters,
+            terminalEventDropCount: this.terminalEventDropCount,
+            deadletterObservationDropCount: this.deadletterObservationDropCount,
+        };
+    }
+    healthSnapshot() {
+        return this.bindings.getHealth(this.runtime);
+    }
+    statsSnapshot() {
+        return this.bindings.getStats(this.runtime);
+    }
+    runtimeInfoSnapshot() {
+        return this.bindings.readRuntimeInfo();
+    }
+    runtimeConfigSnapshot() {
+        return this.bindings.getConfig(this.runtime);
+    }
+    monitorIsEnabled() {
+        return this.monitorReader != null;
+    }
+    monitorSnapshot(signalCount = 0) {
+        return {
+            signalCount,
+            health: this.healthSnapshot(),
+            stats: this.statsSnapshot(),
+        };
+    }
+    async awaitNextMonitor(timeoutMs = 1_000) {
+        if (this.monitorReader == null) {
+            throw new Error("runtime monitor is not enabled");
+        }
+        const signalCount = await this.monitorReader.next(timeoutMs);
+        return signalCount == null ? null : this.monitorSnapshot(signalCount);
+    }
+    async awaitAppliedGenerationAtLeast(generation, timeoutMs = 1_000) {
+        const deadline = Date.now() + timeoutMs;
+        const current = this.monitorSnapshot();
+        if (current.health.appliedGeneration >= generation) {
+            return current;
+        }
+        while (Date.now() < deadline) {
+            const remainingMs = Math.max(1, deadline - Date.now());
+            const snapshot = await this.awaitNextMonitor(remainingMs);
+            if (snapshot == null) {
+                return null;
+            }
+            if (snapshot.health.appliedGeneration >= generation) {
+                return snapshot;
+            }
+        }
+        return null;
+    }
+    runtimeSnapshot() {
+        return {
+            runtimeInfo: this.runtimeInfoSnapshot(),
+            runtimeConfig: this.runtimeConfigSnapshot(),
+            connector: {
+                ...this.snapshotStats(),
+                separateDeliveredRequestLane: this.separateDeliveredRequestLane,
+                systemName: this.config.systemName,
+                nodeId: this.config.nodeId,
+            },
+            health: this.healthSnapshot(),
+            stats: this.statsSnapshot(),
+        };
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error("runtime client closed"));
+        }
+        this.pending.clear();
+        this.trackedRequestsByMessageId.clear();
+        this.trackedRequestMessageIdsByCorrelationId.clear();
+        for (const stream of this.terminalEventSubscribers.values()) {
+            stream.close();
+        }
+        this.terminalEventSubscribers.clear();
+        for (const stream of this.deadletterSubscribers.values()) {
+            stream.close();
+        }
+        this.deadletterSubscribers.clear();
+        this.requestReader.close();
+        this.responseReader?.close();
+        this.deadletterReader.close();
+        this.monitorReader?.close();
+        try {
+            this.bindings.stopRuntime(this.runtime);
+        }
+        finally {
+            this.bindings.destroyRuntime(this.runtime);
+            for (const fd of [
+                this.hostHandles.responseReadFd,
+                this.hostHandles.deadletterReadFd,
+                this.hostHandles.requestWriteFd,
+                this.hostHandles.controlWriteFd,
+                this.hostHandles.monitorReadFd,
+                this.hostHandles.deliveredRequestReadFd,
+            ]) {
+                safeCloseFd(fd);
+            }
+        }
+    }
+    hostHandleFlags() {
+        let flags = 0;
+        if (this.config.enableMonitor ?? true) {
+            flags |= HOST_HANDLES_ENABLE_MONITOR;
+        }
+        if (this.config.separateDeliveredRequestLane ?? true) {
+            flags |= HOST_HANDLES_SEPARATE_DELIVERED_REQUEST_LANE;
+        }
+        return flags;
+    }
+    buildControlEnvelopeBytes(generation = this.config.generation ?? 1, routes = this.config.routes, sourceConnector = this.config.systemName, seq = 1, overloadPolicy = this.config.overloadPolicy) {
+        if (overloadPolicy != null) {
+            requireValidRuntimeOverloadPolicy(overloadPolicy);
+        }
+        const snapshotPayload = encodeRouteSnapshotPayload({
+            generation,
+            overload_policy: overloadPolicy == null ? undefined : {
+                ingress_mode: overloadPolicy.ingressMode ?? 0,
+                local_delivery_mode: overloadPolicy.localDeliveryMode ?? 0,
+                remote_outbound_mode: overloadPolicy.remoteOutboundMode ?? 0,
+                remote_outbound_reply_reserve_slots: overloadPolicy.remoteOutboundReplyReserveSlots ?? 0,
+            },
+            routes: routes.map((route) => ({
+                target: route.target,
+                strategy: route.strategy ?? RouteStrategy.SINGLE_OWNER,
+                route_key_hint: route.routeKeyHint ?? "",
+                flags: route.flags ?? 0,
+                endpoints: route.endpoints.map((endpoint) => ({
+                    host: endpoint.host,
+                    port: endpoint.port,
+                    weight: endpoint.weight ?? 1,
+                    flags: endpoint.flags ?? 0,
+                })),
+            })),
+        });
+        const envelope = {
+            seq,
+            generation,
+            kind: 1,
+            payload_format: 2,
+            payload_type: 1,
+            schema_version: 1,
+            payload: snapshotPayload,
+            metadata: {
+                source_connector: sourceConnector,
+            },
+        };
+        return encodeControlEnvelope(envelope);
+    }
+    async submitPendingRequest(request, timeoutMs, submit) {
+        const trackedRequest = this.trackRequest(request, "request");
+        return await new Promise((resolve, reject) => {
+            if (this.pending.has(trackedRequest.messageId)) {
+                this.forgetTrackedRequest(trackedRequest.messageId);
+                reject(new Error(`duplicate pending messageId=${trackedRequest.messageId}`));
+                return;
+            }
+            const timeout = setTimeout(() => {
+                this.pending.delete(trackedRequest.messageId);
+                this.forgetTrackedRequest(trackedRequest.messageId);
+                reject(new Error(`timed out waiting for ${trackedRequest.messageId}`));
+            }, timeoutMs);
+            this.pending.set(trackedRequest.messageId, { resolve, reject, timeout });
+            try {
+                submit(trackedRequest.request);
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                this.pending.delete(trackedRequest.messageId);
+                this.forgetTrackedRequest(trackedRequest.messageId);
+                reject(error);
+            }
+        });
+    }
+    submitTrackedRequest(request, submit) {
+        const trackedRequest = this.trackRequest(request, "submitRequest");
+        try {
+            submit(trackedRequest.request);
+            return {
+                messageId: trackedRequest.messageId,
+                correlationId: trackedRequest.correlationId,
+            };
+        }
+        catch (error) {
+            this.forgetTrackedRequest(trackedRequest.messageId);
+            throw error;
+        }
+    }
+    onRequestFrame(frame) {
+        const envelope = decodeEnvelope(frame);
+        if (this.separateDeliveredRequestLane) {
+            if (envelope.kind !== MessageKind.REQUEST) {
+                throw new Error(`unexpected envelope kind=${envelope.kind} on delivered-request lane`);
+            }
+            this.dispatchRequest(envelope);
+            return;
+        }
+        if (envelope.kind === MessageKind.REQUEST) {
+            this.dispatchRequest(envelope);
+        }
+        else if (envelope.kind === MessageKind.RESPONSE) {
+            this.dispatchResponse(envelope);
+        }
+        else {
+            throw new Error(`unexpected envelope kind=${envelope.kind}`);
+        }
+    }
+    onResponseFrame(frame) {
+        const envelope = decodeEnvelope(frame);
+        if (envelope.kind === MessageKind.RESPONSE) {
+            this.dispatchResponse(envelope);
+        }
+        else if (envelope.kind === MessageKind.REQUEST) {
+            throw new Error("unexpected request on response-only lane");
+        }
+        else {
+            throw new Error(`unexpected envelope kind=${envelope.kind}`);
+        }
+    }
+    onDeadletterFrame(frame) {
+        this.dispatchDeadletter(decodeDeadletter(frame));
+    }
+    dispatchRequest(request) {
+        this.deliveredRequests += 1;
+        const registered = this.requestHandlers.get(request.target);
+        if (registered == null) {
+            return;
+        }
+        void Promise.resolve(registered.handler(request))
+            .then((reply) => {
+            if (!request.one_way && reply != null) {
+                if (registered.typedReplies) {
+                    this.submitTypedEnvelope(reply);
+                }
+                else {
+                    this.submitRawEnvelope(reply);
+                }
+            }
+        })
+            .catch((error) => {
+            console.error(`[coakka-node] request handler failed target=${request.target}`, error);
+        });
+    }
+    dispatchResponse(response) {
+        const trackedRequest = this.forgetTrackedRequestByCorrelationId(response.correlation_id);
+        if (trackedRequest == null) {
+            this.lateResponses += 1;
+            return;
+        }
+        this.publishTerminalEvent({
+            kind: RequestTerminalEventKind.RESPONSE,
+            requestMessageId: trackedRequest.messageId,
+            correlationId: trackedRequest.correlationId,
+            envelope: response,
+        });
+        const pending = this.pending.get(trackedRequest.messageId);
+        if (pending != null) {
+            clearTimeout(pending.timeout);
+            this.pending.delete(trackedRequest.messageId);
+            pending.resolve(response);
+        }
+        this.matchedResponses += 1;
+    }
+    dispatchDeadletter(deadletter) {
+        const trackedRequest = this.forgetTrackedRequest(deadletter.original_envelope.message_id);
+        this.publishDeadletterObservation(deadletter, trackedRequest);
+        if (trackedRequest == null) {
+            this.unhandledDeadletters += 1;
+            return;
+        }
+        this.publishTerminalEvent({
+            kind: RequestTerminalEventKind.DEADLETTER,
+            requestMessageId: trackedRequest.messageId,
+            correlationId: trackedRequest.correlationId,
+            deadletter,
+        });
+        const pending = this.pending.get(trackedRequest.messageId);
+        if (pending != null) {
+            clearTimeout(pending.timeout);
+            this.pending.delete(trackedRequest.messageId);
+            pending.reject(new DeadletterError(deadletter));
+        }
+        this.matchedDeadletters += 1;
+    }
+    publishDeadletterObservation(deadletter, trackedRequest) {
+        const observed = {
+            deadletter,
+            requestMessageId: trackedRequest?.messageId ?? (deadletter.original_envelope.message_id || null),
+            correlationId: trackedRequest?.correlationId ?? (deadletter.original_envelope.correlation_id || null),
+            matchedPendingRequest: trackedRequest != null,
+        };
+        for (const [subscriberId, stream] of this.deadletterSubscribers) {
+            if (stream.push(observed)) {
+                continue;
+            }
+            this.deadletterObservationDropCount += 1;
+            if (this.closed) {
+                this.deadletterSubscribers.delete(subscriberId);
+            }
+        }
+    }
+    onReaderError(lane, error) {
+        if (!this.closed) {
+            console.error(`[coakka-node] ${lane} reader failed`, error);
+        }
+    }
+    trackRequest(request, caller) {
+        if (request.kind !== MessageKind.REQUEST) {
+            throw new Error(`${caller} requires MESSAGE_KIND_REQUEST`);
+        }
+        if (request.one_way) {
+            throw new Error(`${caller} requires oneWay=false`);
+        }
+        if (request.message_id === "") {
+            throw new Error(`${caller} requires messageId`);
+        }
+        const normalized = {
+            ...request,
+            correlation_id: request.correlation_id !== "" ? request.correlation_id : request.message_id,
+        };
+        if (this.trackedRequestsByMessageId.has(normalized.message_id)) {
+            throw new Error(`duplicate tracked messageId=${normalized.message_id}`);
+        }
+        if (this.trackedRequestMessageIdsByCorrelationId.has(normalized.correlation_id)) {
+            throw new Error(`duplicate tracked correlationId=${normalized.correlation_id}`);
+        }
+        this.trackedRequestsByMessageId.set(normalized.message_id, {
+            messageId: normalized.message_id,
+            correlationId: normalized.correlation_id,
+        });
+        this.trackedRequestMessageIdsByCorrelationId.set(normalized.correlation_id, normalized.message_id);
+        return {
+            request: normalized,
+            messageId: normalized.message_id,
+            correlationId: normalized.correlation_id,
+        };
+    }
+    forgetTrackedRequest(messageId) {
+        const trackedRequest = this.trackedRequestsByMessageId.get(messageId) ?? null;
+        if (trackedRequest == null) {
+            return null;
+        }
+        this.trackedRequestsByMessageId.delete(messageId);
+        this.trackedRequestMessageIdsByCorrelationId.delete(trackedRequest.correlationId);
+        return trackedRequest;
+    }
+    forgetTrackedRequestByCorrelationId(correlationId) {
+        const messageId = this.trackedRequestMessageIdsByCorrelationId.get(correlationId);
+        if (messageId == null) {
+            return null;
+        }
+        this.trackedRequestMessageIdsByCorrelationId.delete(correlationId);
+        const trackedRequest = this.trackedRequestsByMessageId.get(messageId) ?? null;
+        if (trackedRequest != null) {
+            this.trackedRequestsByMessageId.delete(messageId);
+        }
+        return trackedRequest;
+    }
+    publishTerminalEvent(event) {
+        for (const stream of this.terminalEventSubscribers.values()) {
+            if (!stream.push(event)) {
+                this.terminalEventDropCount += 1;
+            }
+        }
+    }
+}
+function safeCloseFd(fd) {
+    if (fd >= 0) {
+        try {
+            closeSync(fd);
+        }
+        catch {
+            // ignore close races during shutdown
+        }
+    }
+}
+function isRetryableReadError(error) {
+    return (typeof error === "object" &&
+        error != null &&
+        "code" in error &&
+        (error.code === "EAGAIN" || error.code === "EWOULDBLOCK" || error.code === "EINTR"));
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}