coakka-v2-connector-bun 1.3.1

package/CONSUMING.md

@@ -0,0 +1,34 @@
+# Consuming The Bun Connector
+
+This lane is the Bun-facing package for the CoAkka runtime v2 connector.
+
+Current shape:
+
+- package name: `coakka-v2-connector-bun`
+- public runtime owner alias: `BunRuntimeHost`
+- client alias: `BunRuntimeClient`
+- native runtime ABI: shared `libcoakka_runtime_v2`
+- implementation base: the shared JS runtime connector core compiled at package
+  build time
+
+The first cut intentionally reuses the shared JS runtime connector core because
+Bun 1.3.14 can run the packaged native runtime path. If Bun-specific
+event-loop or package-manager behavior later needs a different binding, this
+lane can replace only the native binding layer without changing runtime core
+semantics.
+
+## Minimal Smoke
+
+```ts
+import {
+  BunRuntimeHost,
+  BunRuntimeClient,
+  DeliveryHint,
+  EndpointFlag,
+  PayloadFormat,
+  PayloadIdentity,
+} from "coakka-v2-connector-bun";
+```
+
+Use `BunRuntimeHost.start(...)` the same way Node samples use
+`RuntimeHost.start(...)` or `ConnectorOrchestrator.start(...)`.

package/LICENSE.md

@@ -0,0 +1,115 @@
+# CoAkka Public Artifact Preview License 1.0
+
+Effective: 2026-07-19
+
+This repository is the public binary artifact surface for CoAkka. It contains
+headers, native libraries, connector packages, Maven artifacts, checksums, and
+artifact metadata. It is not a source-build repository.
+
+Unless a specific release artifact includes different license terms, the
+artifacts in this repository are made available under the following preview
+terms.
+
+This is not an OSI-approved open source license. The separate
+`coakka-samples` repository may use a permissive open source license for sample
+code and documentation; that sample license does not change the terms for the
+artifacts distributed from this repository.
+
+## Definitions
+
+`Artifacts` means the CoAkka binaries, headers, libraries, connector packages,
+Maven artifacts, container-bundle files, checksums, manifests, and release
+metadata distributed from this repository or from an official release page for
+this repository.
+
+`Production` means any environment that serves live end-user traffic, live
+customer data, live operational data, revenue-generating workloads, or
+customer-facing workloads outside development, test, CI, sample execution, or
+proof-of-concept evaluation.
+
+`Official sample images` means container images published by the CoAkka
+project or repository owner, including the current
+`docker.io/gabrielgun1983/*` sample image namespace and any future images
+published under an official CoAkka container namespace, that bundle unmodified
+artifacts solely to run official CoAkka samples.
+
+## Allowed Use
+
+You may download, copy, and use the artifacts from this repository to:
+
+- evaluate CoAkka locally
+- run the official public samples
+- build proof-of-concept integrations
+- run development and test environments for applications that integrate with
+  CoAkka
+- run CI jobs, automated tests, and integration verification for
+  non-production applications or evaluations
+- run company evaluations, proofs of concept, and integration tests,
+  including evaluations inside commercial organizations
+- redistribute unmodified CoAkka artifacts inside local development, test, or
+  sample environments, provided this notice and the included checksums or
+  manifests remain available
+- pull, cache internally, and run official sample images for local development,
+  CI, test, sample execution, proof-of-concept integration, and evaluation
+
+## Reserved Uses
+
+The following uses require a separate written license:
+
+- selling, hosting, or offering CoAkka artifacts as a managed runtime service
+- running CoAkka artifacts in production systems
+- bundling CoAkka artifacts into a product distributed to customers
+- redistributing CoAkka artifacts as part of a paid product, support package,
+  appliance, cloud image, or hosted service
+- offering a product or service that presents modified CoAkka artifacts as
+  official CoAkka artifacts
+- removing or obscuring copyright, license, checksum, or provenance notices
+- reverse engineering artifacts except where that restriction is prohibited by
+  applicable law
+- using the CoAkka name, package names, artifact names, image names, or other
+  project identifiers in a way that implies endorsement of an unofficial fork,
+  hosted service, or product
+
+## Official Samples
+
+Official sample images may bundle unmodified artifacts solely so users can run
+official CoAkka samples without installing the artifacts manually.
+
+This sample-image permission does not grant third parties the right to create,
+publish, sell, host, or distribute derivative images for production, customer
+distribution, hosted services, paid support packages, appliances, or cloud
+marketplace offerings.
+
+## Production Use
+
+These preview terms are intended for developer evaluation, sample execution,
+non-production proof-of-concept work, CI, and integration testing. Production
+use, hosted service use, customer distribution, and paid redistribution require
+explicit release terms or a separate written agreement.
+
+For production, hosted service, customer distribution, paid redistribution, or
+other commercial rights, contact the project through `SUPPORT.md`.
+
+## No Warranty
+
+The artifacts are provided as-is, without warranties or conditions of any kind,
+to the maximum extent permitted by applicable law.
+
+## Limitation Of Liability
+
+To the maximum extent permitted by applicable law, the project contributors and
+artifact publishers are not liable for any direct, indirect, incidental,
+special, consequential, exemplary, or other damages arising from use of the
+artifacts.
+
+## No Patent Or Trademark Grant
+
+These preview terms do not grant patent rights, trademark rights, or rights to
+use the CoAkka name beyond the limited artifact and sample uses allowed above.
+Trademark use is governed by `TRADEMARKS.md`.
+
+## Legal Notice
+
+This file is not legal advice. If your intended use depends on legal
+interpretation of these terms, consult your own counsel or request a separate
+written agreement.

package/README.md

@@ -0,0 +1,36 @@
+# CoAkka Runtime Connector For Bun
+
+This is the first Bun lane for the CoAkka runtime v2 connector.
+
+The lane is deliberately thin for the first slice:
+
+- it packages a Bun-named surface: `coakka-v2-connector-bun`
+- it exports `BunRuntimeHost`, `BunConnectorOrchestrator`, and
+  `BunRuntimeClient` aliases
+- it compiles the shared JS runtime connector core during package build
+- it ships the same staged native runtime files inside the Bun package
+
+Runtime semantics still belong to the native runtime and its public C ABI. Bun
+owns host ergonomics, package smoke, and compatibility evidence only.
+
+## Local Commands
+
+```sh
+export BUN_INSTALL="$HOME/.bun"
+export PATH="$BUN_INSTALL/bin:$PATH"
+
+bun run build
+bun run verify
+bash scripts/smoke-packaged-package.sh
+```
+
+The package smoke builds a tarball, installs it into a temporary Bun consumer,
+starts one embedded runtime, registers a local JSON handler, and proves
+request/reply through the native runtime.
+
+## Boundary
+
+This lane currently reuses the shared JS runtime connector core because Bun can
+run the embedded native binding path. If that boundary stops holding, the
+replacement should be a narrow Bun binding shim, not a fork of runtime routing,
+request/reply, deadletter, or lifecycle semantics.

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export { COAKKA_V2_NATIVE_CORE_VERSION, COAKKA_V2_NATIVE_GIT_COMMIT, COAKKA_V2_NATIVE_PACKAGE_VERSION, COAKKA_V2_NODE_VERSION, } from "./packaging.js";
+export { BusinessStatus, DeliveryHint, EndpointFlag, MessageKind, OverloadMode, PayloadFormat, PayloadIdentity, RequestTerminalEventKind, RouteStrategy, localRoute, requireValidConnectorConfig, requireValidRuntimeOverloadPolicy, requireValidRoute, toConnectorConfig, type ConnectorConfig, type ConnectorStartSpec, type EndpointSpec, type MaybePromise, type ObservedDeadletter, type RuntimeOverloadPolicy, type RequestTerminalEvent, type RequestTerminalEventDeadletter, type RequestTerminalEventResponse, type RouteSpec, type SubmittedRequest, } from "./models.js";
+export { ConnectorOrchestrator, RuntimeHost, RuntimeLibraryResolver, } from "./orchestrator.js";
+export { DeadletterError, NodeRuntimeClient, type HandlerFn, type MonitorSnapshot, type RuntimeClientStats, type DeadlettersOptions, type TerminalEventsOptions, } from "./runtime-client.js";
+export type { ControlEnvelope, RouteSnapshotPayload, TransportDeadletter, TransportEnvelope, } from "./wire-codec.js";
+export { COAKKA_ABI_VERSION, COAKKA_OK, HOST_HANDLES_ENABLE_MONITOR, HOST_HANDLES_SEPARATE_DELIVERED_REQUEST_LANE, type HostHandlesSnapshot, type RuntimeConfigSnapshot, type RuntimeHealthSnapshot, type RuntimeInfoSnapshot, type RuntimeStatsSnapshot, } from "./native-runtime.js";

package/dist/core/index.js

@@ -0,0 +1,5 @@
+export { COAKKA_V2_NATIVE_CORE_VERSION, COAKKA_V2_NATIVE_GIT_COMMIT, COAKKA_V2_NATIVE_PACKAGE_VERSION, COAKKA_V2_NODE_VERSION, } from "./packaging.js";
+export { BusinessStatus, DeliveryHint, EndpointFlag, MessageKind, OverloadMode, PayloadFormat, PayloadIdentity, RequestTerminalEventKind, RouteStrategy, localRoute, requireValidConnectorConfig, requireValidRuntimeOverloadPolicy, requireValidRoute, toConnectorConfig, } from "./models.js";
+export { ConnectorOrchestrator, RuntimeHost, RuntimeLibraryResolver, } from "./orchestrator.js";
+export { DeadletterError, NodeRuntimeClient, } from "./runtime-client.js";
+export { COAKKA_ABI_VERSION, COAKKA_OK, HOST_HANDLES_ENABLE_MONITOR, HOST_HANDLES_SEPARATE_DELIVERED_REQUEST_LANE, } from "./native-runtime.js";

package/dist/core/models.d.ts

@@ -0,0 +1,119 @@
+export declare enum MessageKind {
+    UNSPECIFIED = 0,
+    REQUEST = 1,
+    RESPONSE = 2,
+    EVENT = 3
+}
+export declare enum BusinessStatus {
+    UNSPECIFIED = 0,
+    OK = 1,
+    ERROR = 2
+}
+export declare enum DeliveryHint {
+    UNSPECIFIED = 0,
+    ROUTER_DEFAULT = 1,
+    PREFER_LOCAL = 2,
+    REQUIRE_LOCAL = 3,
+    REQUIRE_REMOTE = 4
+}
+export declare enum PayloadFormat {
+    UNSPECIFIED = 0,
+    JSON = 1,
+    WIRE_BINARY = 2,
+    THRIFT = 3,
+    MSGPACK = 4,
+    TEXT = 5,
+    PLAIN_TEXT = 5,
+    BINARY = 6
+}
+export declare enum RouteStrategy {
+    UNSPECIFIED = 0,
+    SINGLE_OWNER = 1,
+    WEIGHTED_ROUND_ROBIN = 2,
+    RENDEZVOUS_HASH = 3
+}
+export declare enum EndpointFlag {
+    NONE = 0,
+    LOCAL = 1,
+    UNAVAILABLE = 2
+}
+export declare enum OverloadMode {
+    REJECT = 0,
+    DROP_EXPIRED_FIRST = 1,
+    DROP_ONE_WAY_FIRST = 2
+}
+export interface RuntimeOverloadPolicy {
+    ingressMode?: OverloadMode;
+    localDeliveryMode?: OverloadMode;
+    remoteOutboundMode?: OverloadMode;
+    remoteOutboundReplyReserveSlots?: number;
+}
+export type MaybePromise<T> = T | Promise<T>;
+export declare class PayloadIdentity {
+    readonly messageType: string;
+    readonly payloadSchemaVersion: number;
+    readonly payloadFormat: PayloadFormat;
+    constructor(messageType: string, payloadSchemaVersion?: number, payloadFormat?: PayloadFormat);
+    isTyped(): boolean;
+    requireTyped(what?: string): PayloadIdentity;
+    static text(messageType: string, payloadSchemaVersion?: number): PayloadIdentity;
+}
+export interface EndpointSpec {
+    host: string;
+    port: number;
+    weight?: number;
+    flags?: number;
+}
+export interface RouteSpec {
+    target: string;
+    endpoints: readonly EndpointSpec[];
+    strategy?: RouteStrategy;
+    routeKeyHint?: string;
+    flags?: number;
+}
+export interface ConnectorConfig {
+    systemName: string;
+    nodeId: string;
+    routes: readonly RouteSpec[];
+    strictNoDrop?: boolean;
+    queueCapacity?: number;
+    enableMonitor?: boolean;
+    separateDeliveredRequestLane?: boolean;
+    generation?: number;
+    overloadPolicy?: RuntimeOverloadPolicy;
+}
+export interface ConnectorStartSpec extends ConnectorConfig {
+}
+export interface SubmittedRequest {
+    messageId: string;
+    correlationId: string;
+}
+export declare const RequestTerminalEventKind: {
+    readonly RESPONSE: "response";
+    readonly DEADLETTER: "deadletter";
+};
+export type RequestTerminalEventKind = (typeof RequestTerminalEventKind)[keyof typeof RequestTerminalEventKind];
+export interface RequestTerminalEventResponse {
+    kind: typeof RequestTerminalEventKind.RESPONSE;
+    requestMessageId: string;
+    correlationId: string;
+    envelope: import("./wire-codec.js").TransportEnvelope;
+}
+export interface RequestTerminalEventDeadletter {
+    kind: typeof RequestTerminalEventKind.DEADLETTER;
+    requestMessageId: string;
+    correlationId: string;
+    deadletter: import("./wire-codec.js").TransportDeadletter;
+}
+export type RequestTerminalEvent = RequestTerminalEventResponse | RequestTerminalEventDeadletter;
+export interface ObservedDeadletter {
+    deadletter: import("./wire-codec.js").TransportDeadletter;
+    requestMessageId: string | null;
+    correlationId: string | null;
+    matchedPendingRequest: boolean;
+}
+export declare function requireValidRoute(route: RouteSpec): RouteSpec;
+export declare function localRoute(target: string, port?: number): RouteSpec;
+export declare function requireValidRuntimeOverloadPolicy(policy: RuntimeOverloadPolicy, what?: string): RuntimeOverloadPolicy;
+export declare function requireValidConnectorConfig(config: ConnectorConfig): ConnectorConfig;
+export declare function toConnectorConfig(startSpec: ConnectorStartSpec): ConnectorConfig;

package/dist/core/models.js

@@ -0,0 +1,150 @@
+export var MessageKind;
+(function (MessageKind) {
+    MessageKind[MessageKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    MessageKind[MessageKind["REQUEST"] = 1] = "REQUEST";
+    MessageKind[MessageKind["RESPONSE"] = 2] = "RESPONSE";
+    MessageKind[MessageKind["EVENT"] = 3] = "EVENT";
+})(MessageKind || (MessageKind = {}));
+export var BusinessStatus;
+(function (BusinessStatus) {
+    BusinessStatus[BusinessStatus["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    BusinessStatus[BusinessStatus["OK"] = 1] = "OK";
+    BusinessStatus[BusinessStatus["ERROR"] = 2] = "ERROR";
+})(BusinessStatus || (BusinessStatus = {}));
+export var DeliveryHint;
+(function (DeliveryHint) {
+    DeliveryHint[DeliveryHint["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    DeliveryHint[DeliveryHint["ROUTER_DEFAULT"] = 1] = "ROUTER_DEFAULT";
+    DeliveryHint[DeliveryHint["PREFER_LOCAL"] = 2] = "PREFER_LOCAL";
+    DeliveryHint[DeliveryHint["REQUIRE_LOCAL"] = 3] = "REQUIRE_LOCAL";
+    DeliveryHint[DeliveryHint["REQUIRE_REMOTE"] = 4] = "REQUIRE_REMOTE";
+})(DeliveryHint || (DeliveryHint = {}));
+export var PayloadFormat;
+(function (PayloadFormat) {
+    PayloadFormat[PayloadFormat["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    PayloadFormat[PayloadFormat["JSON"] = 1] = "JSON";
+    PayloadFormat[PayloadFormat["WIRE_BINARY"] = 2] = "WIRE_BINARY";
+    PayloadFormat[PayloadFormat["THRIFT"] = 3] = "THRIFT";
+    PayloadFormat[PayloadFormat["MSGPACK"] = 4] = "MSGPACK";
+    PayloadFormat[PayloadFormat["TEXT"] = 5] = "TEXT";
+    PayloadFormat[PayloadFormat["PLAIN_TEXT"] = 5] = "PLAIN_TEXT";
+    PayloadFormat[PayloadFormat["BINARY"] = 6] = "BINARY";
+})(PayloadFormat || (PayloadFormat = {}));
+export var RouteStrategy;
+(function (RouteStrategy) {
+    RouteStrategy[RouteStrategy["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    RouteStrategy[RouteStrategy["SINGLE_OWNER"] = 1] = "SINGLE_OWNER";
+    RouteStrategy[RouteStrategy["WEIGHTED_ROUND_ROBIN"] = 2] = "WEIGHTED_ROUND_ROBIN";
+    RouteStrategy[RouteStrategy["RENDEZVOUS_HASH"] = 3] = "RENDEZVOUS_HASH";
+})(RouteStrategy || (RouteStrategy = {}));
+export var EndpointFlag;
+(function (EndpointFlag) {
+    EndpointFlag[EndpointFlag["NONE"] = 0] = "NONE";
+    EndpointFlag[EndpointFlag["LOCAL"] = 1] = "LOCAL";
+    EndpointFlag[EndpointFlag["UNAVAILABLE"] = 2] = "UNAVAILABLE";
+})(EndpointFlag || (EndpointFlag = {}));
+export var OverloadMode;
+(function (OverloadMode) {
+    OverloadMode[OverloadMode["REJECT"] = 0] = "REJECT";
+    OverloadMode[OverloadMode["DROP_EXPIRED_FIRST"] = 1] = "DROP_EXPIRED_FIRST";
+    OverloadMode[OverloadMode["DROP_ONE_WAY_FIRST"] = 2] = "DROP_ONE_WAY_FIRST";
+})(OverloadMode || (OverloadMode = {}));
+export class PayloadIdentity {
+    messageType;
+    payloadSchemaVersion;
+    payloadFormat;
+    constructor(messageType, payloadSchemaVersion = 1, payloadFormat = PayloadFormat.UNSPECIFIED) {
+        this.messageType = messageType;
+        this.payloadSchemaVersion = payloadSchemaVersion;
+        this.payloadFormat = payloadFormat;
+    }
+    isTyped() {
+        return (this.messageType.trim() !== "" &&
+            this.payloadSchemaVersion >= 1 &&
+            this.payloadFormat !== PayloadFormat.UNSPECIFIED);
+    }
+    requireTyped(what = "payload identity") {
+        if (this.messageType.trim() === "") {
+            throw new Error(`${what} requires messageType`);
+        }
+        if (this.payloadSchemaVersion < 1) {
+            throw new Error(`${what} requires payloadSchemaVersion >= 1`);
+        }
+        if (this.payloadFormat === PayloadFormat.UNSPECIFIED) {
+            throw new Error(`${what} requires declared payloadFormat`);
+        }
+        return this;
+    }
+    static text(messageType, payloadSchemaVersion = 1) {
+        return new PayloadIdentity(messageType, payloadSchemaVersion, PayloadFormat.TEXT);
+    }
+}
+export const RequestTerminalEventKind = {
+    RESPONSE: "response",
+    DEADLETTER: "deadletter",
+};
+export function requireValidRoute(route) {
+    if (route.target.trim() === "") {
+        throw new Error("route requires target");
+    }
+    if (route.endpoints.length === 0) {
+        throw new Error(`route target=${route.target} requires at least one endpoint`);
+    }
+    return route;
+}
+export function localRoute(target, port = 9001) {
+    return {
+        target,
+        endpoints: [{ host: "127.0.0.1", port, flags: EndpointFlag.LOCAL }],
+    };
+}
+export function requireValidRuntimeOverloadPolicy(policy, what = "overloadPolicy") {
+    if ((policy.ingressMode ?? OverloadMode.REJECT) !== OverloadMode.REJECT) {
+        throw new Error(`${what}.ingressMode currently supports only REJECT`);
+    }
+    if ((policy.localDeliveryMode ?? OverloadMode.REJECT) !== OverloadMode.REJECT) {
+        throw new Error(`${what}.localDeliveryMode currently supports only REJECT`);
+    }
+    if ((policy.remoteOutboundReplyReserveSlots ?? 0) < 0) {
+        throw new Error(`${what}.remoteOutboundReplyReserveSlots must be >= 0`);
+    }
+    return policy;
+}
+export function requireValidConnectorConfig(config) {
+    if (config.systemName.trim() === "") {
+        throw new Error("connector config requires systemName");
+    }
+    if (config.nodeId.trim() === "") {
+        throw new Error("connector config requires nodeId");
+    }
+    if ((config.queueCapacity ?? 128) < 1) {
+        throw new Error("connector config requires queueCapacity >= 1");
+    }
+    if ((config.generation ?? 1) < 1) {
+        throw new Error("connector config requires generation >= 1");
+    }
+    if (config.overloadPolicy != null) {
+        requireValidRuntimeOverloadPolicy(config.overloadPolicy, "connector config overloadPolicy");
+    }
+    if (config.routes.length === 0) {
+        throw new Error("connector config requires at least one route");
+    }
+    for (const route of config.routes) {
+        requireValidRoute(route);
+    }
+    return config;
+}
+export function toConnectorConfig(startSpec) {
+    requireValidConnectorConfig(startSpec);
+    return {
+        systemName: startSpec.systemName,
+        nodeId: startSpec.nodeId,
+        routes: startSpec.routes,
+        strictNoDrop: startSpec.strictNoDrop ?? true,
+        queueCapacity: startSpec.queueCapacity ?? 128,
+        enableMonitor: startSpec.enableMonitor ?? true,
+        separateDeliveredRequestLane: startSpec.separateDeliveredRequestLane ?? true,
+        generation: startSpec.generation ?? 1,
+        overloadPolicy: startSpec.overloadPolicy,
+    };
+}

package/dist/core/native-runtime.d.ts

@@ -0,0 +1,105 @@
+export declare const COAKKA_OK = 0;
+export declare const COAKKA_ABI_VERSION = 1;
+export declare const HOST_HANDLES_ENABLE_MONITOR: number;
+export declare const HOST_HANDLES_SEPARATE_DELIVERED_REQUEST_LANE: number;
+export interface RuntimeInfoSnapshot {
+    abiVersion: number;
+    featureFlags: number;
+    runtimeVersion: string;
+    gitCommit: string;
+    southboundBackend: string;
+    allocatorBackend: string;
+    docsHint: string;
+}
+export interface RuntimeConfigSnapshot {
+    systemName: string;
+    nodeId: string;
+    runtimeState: number;
+    snapshotPresent: boolean;
+    appliedGeneration: number;
+    routeCount: number;
+    southboundBindHost: string;
+    southboundBindPort: number;
+    effectiveIngressOverloadMode: number;
+    effectiveLocalDeliveryOverloadMode: number;
+    effectiveRemoteOutboundOverloadMode: number;
+    effectiveRemoteOutboundReplyReserveSlots: number;
+}
+export interface RuntimeHealthSnapshot {
+    runtimeState: number;
+    flags: number;
+    appliedGeneration: number;
+}
+export interface RuntimeStatsSnapshot {
+    appliedGeneration: number;
+    routeCount: number;
+    runtimeState: number;
+    queueRejectedCount: number;
+    routeMissCount: number;
+    deadletterCount: number;
+    deliveryFailedCount: number;
+    controlRejectedCount: number;
+    monitorEventEmittedCount: number;
+    monitorEventDroppedCount: number;
+    monitorEventEmittedLifetimeCount: number;
+    monitorEventDroppedLifetimeCount: number;
+    localWorkQueueCapacity: number;
+    localWorkQueueDepth: number;
+    localWorkQueueHighWatermark: number;
+    deliveredRequestOutboundDirectWriteCount: number;
+    responseOutboundDirectWriteCount: number;
+    deadletterOutboundDirectWriteCount: number;
+    remoteOutboundQueueCapacity: number;
+    remoteOutboundQueueDepth: number;
+    remoteOutboundQueueHighWatermark: number;
+    remoteOutboundQueueRejectedCount: number;
+    remoteOutboundExpiredDropCount: number;
+    remoteOutboundReplyReserveSlots: number;
+    remoteOutboundReplyReservationRejectCount: number;
+    remoteOutboundOneWayDropCount: number;
+}
+export interface HostHandlesSnapshot {
+    flags: number;
+    requestWriteFd: number;
+    responseReadFd: number;
+    deadletterReadFd: number;
+    controlWriteFd: number;
+    monitorReadFd: number;
+    deliveredRequestReadFd: number;
+}
+export interface NativeRuntimeConfig {
+    systemName: string;
+    nodeId: string;
+    strictNoDrop: boolean;
+    queueCapacity: number;
+}
+export declare class NativeRuntimeBindings {
+    readonly runtimeLibPath: string;
+    private readonly lib;
+    private readonly getAbiVersionFn;
+    private readonly getInfoFn;
+    private readonly createRuntimeFn;
+    private readonly destroyRuntimeFn;
+    private readonly getHostHandlesFn;
+    private readonly startRuntimeFn;
+    private readonly stopRuntimeFn;
+    private readonly getHealthFn;
+    private readonly getStatsFn;
+    private readonly getConfigFn;
+    private readonly submitEnvelopeFn;
+    private readonly applyControlEnvelopeFn;
+    constructor(runtimeLibPath: string);
+    getAbiVersion(): number;
+    readRuntimeInfo(): RuntimeInfoSnapshot;
+    createRuntime(config: NativeRuntimeConfig): unknown;
+    destroyRuntime(runtime: unknown): void;
+    getHostHandles(runtime: unknown, flags: number): HostHandlesSnapshot;
+    startRuntime(runtime: unknown): void;
+    stopRuntime(runtime: unknown): void;
+    getHealth(runtime: unknown): RuntimeHealthSnapshot;
+    getStats(runtime: unknown): RuntimeStatsSnapshot;
+    getConfig(runtime: unknown): RuntimeConfigSnapshot;
+    submitEnvelope(runtime: unknown, bytes: Uint8Array): void;
+    applyControlEnvelope(runtime: unknown, bytes: Uint8Array): void;
+    requireOk(rc: number, what: string): void;
+}