@zlink-systems/zlink 0.17.3

package/dist/zlink/runtime/messaging/message_materializer.js

@@ -0,0 +1,199 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routedReceivedPrefersManagedBuffer = routedReceivedPrefersManagedBuffer;
+exports.routedReceivedRoutingBytes = routedReceivedRoutingBytes;
+exports.nativeReceivedRoutingId = nativeReceivedRoutingId;
+exports.materializeReceived = materializeReceived;
+exports.materializeReceivedInto = materializeReceivedInto;
+exports.materializeRoutedReceivedInto = materializeRoutedReceivedInto;
+exports.materializeTopicMessage = materializeTopicMessage;
+exports.adoptTopicMessage = adoptTopicMessage;
+const message_1 = require("../../contracts/messaging/message");
+const routing_id_1 = require("../core/routing_id");
+const received_1 = require("../../contracts/messaging/received");
+const message_snapshot_1 = require("./message_snapshot");
+const received_state_1 = require("./received_state");
+const received_operations_1 = require("./received_operations");
+const topic_message_state_1 = require("./topic_message_state");
+function isNativeTopicMessageSinglePart(raw) {
+    return Array.isArray(raw);
+}
+function isNativeReceivedBufferParts(raw) {
+    return Array.isArray(raw);
+}
+const routedReceiveContexts = new WeakMap();
+function routedReceivedPrefersManagedBuffer(target) {
+    const parts = target.parts;
+    // HOT PATH: a reusable Received reveals its stable consumer role. A data
+    // reader should avoid a second addon call on the next receive, while a
+    // relay consumes the native frame and therefore stays on the movable path.
+    return parts.length === 1
+        && parts[0].size() <= 64
+        && (0, message_1.hasObservedManagedReceiveData)(parts[0]);
+}
+function routedReceivedRoutingBytes(target) {
+    return target.routingId === null ? null : (0, routing_id_1.normalizeRoutingId)(target.routingId);
+}
+function envelopeOf(raw) {
+    const candidate = raw;
+    return candidate.data !== undefined
+        || candidate.nativeMessage !== undefined
+        || candidate.parts !== undefined
+        || candidate.routingId !== undefined
+        || candidate.replyToken !== undefined
+        ? candidate
+        : null;
+}
+function nativeReceivedRoutingId(raw) {
+    return envelopeOf(raw)?.routingId ?? null;
+}
+function wrapNativeRoutingId(routingId) {
+    if (!routingId || routingId.length === 0) {
+        return null;
+    }
+    return (0, routing_id_1.routingIdFromOwnedBuffer)(routingId);
+}
+function materializeParts(parts) {
+    if (parts.length === 1) {
+        return [(0, message_snapshot_1.messageFromSnapshot)(parts[0])];
+    }
+    const messages = new Array(parts.length);
+    for (let i = 0; i < parts.length; i += 1) {
+        messages[i] = (0, message_snapshot_1.messageFromSnapshot)(parts[i]);
+    }
+    return messages;
+}
+function materializeReceivedParts(raw) {
+    if (isNativeReceivedBufferParts(raw)) {
+        const messages = new Array(raw.length);
+        for (let i = 0; i < raw.length; i += 1) {
+            messages[i] = (0, message_snapshot_1.messageFromOwnedBuffer)(raw[i]);
+        }
+        return messages;
+    }
+    const envelope = envelopeOf(raw);
+    if (envelope === null) {
+        if (Buffer.isBuffer(raw)) {
+            return [(0, message_snapshot_1.messageFromOwnedBuffer)(raw)];
+        }
+        return [(0, message_snapshot_1.messageFromNativeFrame)(raw)];
+    }
+    if (envelope.data !== undefined) {
+        return envelope.routingId && envelope.routingId.length > 0
+            ? [(0, message_snapshot_1.messageFromOwnedRoutedBuffer)(envelope.data, envelope.routingId, envelope.nativeMessage)]
+            : [(0, message_snapshot_1.messageFromOwnedBuffer)(envelope.data, envelope.nativeMessage)];
+    }
+    if (envelope.nativeMessage !== undefined) {
+        const identity = envelope.routingId && envelope.routingId.length > 0
+            ? envelope.routingId.toString()
+            : undefined;
+        return [(0, message_snapshot_1.messageFromNativeFrame)(envelope.nativeMessage, identity === undefined ? undefined : { 'Routing-Id': identity, Identity: identity }, true)];
+    }
+    return materializeParts(envelope.parts ?? []);
+}
+function materializeTopicParts(raw) {
+    if (isNativeTopicMessageSinglePart(raw)) {
+        return [(0, message_snapshot_1.messageFromOwnedBuffer)(raw[0])];
+    }
+    if (raw.data) {
+        // Hot path: core SUB messages are normally single-part. The native layer
+        // passes the owned payload Buffer directly so public TopicMessage adoption
+        // avoids a per-message native parts array and snapshot object.
+        return [(0, message_snapshot_1.messageFromOwnedBuffer)(raw.data)];
+    }
+    if (raw.nativeMessage !== undefined) {
+        return [(0, message_snapshot_1.messageFromNativeFrame)(raw.nativeMessage)];
+    }
+    return materializeParts(raw.parts ?? []);
+}
+function materializeReceived(raw, send, sendManaged) {
+    const envelope = envelopeOf(raw);
+    return (0, received_state_1.createReceived)(materializeReceivedParts(raw), wrapNativeRoutingId(envelope?.routingId ?? null), null, null, send && sendManaged
+        ? {
+            beginSend() {
+                return (0, received_operations_1.createReceivedSendOperation)((parts) => send(parts), (parts) => sendManaged(parts));
+            }
+        }
+        : null);
+}
+function materializeReceivedInto(target, raw, send, sendManaged) {
+    const envelope = envelopeOf(raw);
+    (0, received_state_1.replaceReceived)(target, materializeReceivedParts(raw), wrapNativeRoutingId(envelope?.routingId ?? null), null, null, send && sendManaged
+        ? {
+            beginSend() {
+                return (0, received_operations_1.createReceivedSendOperation)((parts) => send(parts), (parts) => sendManaged(parts));
+            }
+        }
+        : null);
+}
+function materializeRoutedReceivedInto(target, raw, operations) {
+    const envelope = envelopeOf(raw);
+    if (envelope === null) {
+        throw new Error('routed receive requires a receive envelope');
+    }
+    let context = routedReceiveContexts.get(target);
+    if (!context) {
+        context = {
+            routingId: null,
+            replyToken: null,
+            operations,
+            sendContext: {
+                beginSend() {
+                    const routingId = context.routingId;
+                    const operations = context.operations;
+                    if (routingId == null)
+                        throw new Error('missing routed send target');
+                    return (0, received_operations_1.createReceivedSendOperation)((parts) => operations.send(routingId, parts), (parts) => operations.sendManaged(routingId, parts));
+                }
+            },
+            replyContext: {
+                beginReply() {
+                    const routingId = context.routingId;
+                    const replyToken = context.replyToken;
+                    const operations = context.operations;
+                    if (routingId == null || replyToken == null) {
+                        throw new Error('missing request reply target');
+                    }
+                    return (0, received_operations_1.createReceivedReplyOperation)((parts) => operations.reply(routingId, replyToken, parts));
+                }
+            }
+        };
+        routedReceiveContexts.set(target, context);
+    }
+    context.routingId = envelope.routingId ?? null;
+    context.operations = operations;
+    const rawReplyToken = envelope.replyToken ?? 0n;
+    context.replyToken = rawReplyToken === 0n
+        ? null
+        : (0, received_1.createReplyToken)(operations.replyOwner, rawReplyToken);
+    const routingId = context.routingId === null
+        ? null
+        : target.routingId !== null
+            && (0, routing_id_1.normalizeRoutingId)(target.routingId).equals(context.routingId)
+            ? target.routingId
+            : wrapNativeRoutingId(context.routingId);
+    (0, received_state_1.replaceReceived)(target, materializeReceivedParts(raw), routingId, context.replyToken, context.replyToken ? context.replyContext : null, context.routingId == null ? null : context.sendContext);
+}
+function materializeTopicMessage(raw) {
+    const topic = isNativeTopicMessageSinglePart(raw) ? raw[1] : raw.topic;
+    const routingId = isNativeTopicMessageSinglePart(raw)
+        ? null
+        : wrapNativeRoutingId(raw.routingId ?? null);
+    return (0, topic_message_state_1.createTopicMessage)(topic, materializeTopicParts(raw), routingId);
+}
+function adoptTopicMessage(result, raw) {
+    const topic = isNativeTopicMessageSinglePart(raw) ? raw[1] : raw.topic;
+    const routingId = isNativeTopicMessageSinglePart(raw)
+        ? null
+        : wrapNativeRoutingId(raw.routingId ?? null);
+    const data = isNativeTopicMessageSinglePart(raw)
+        ? raw[0]
+        : raw.data;
+    if (data !== undefined) {
+        (0, topic_message_state_1.replaceTopicMessageOwnedSinglePart)(result, topic, data, routingId);
+    }
+    else {
+        (0, topic_message_state_1.replaceTopicMessage)(result, topic, materializeTopicParts(raw), routingId);
+    }
+}

package/dist/zlink/runtime/messaging/message_parts_state.d.ts

@@ -0,0 +1,4 @@
+import type { Message } from '../../contracts/messaging/message';
+export declare function freezeMessageParts(parts: readonly Message[]): Message[];
+export declare function freezeOwnedMessageParts(parts: Message[]): Message[];
+export declare function closeMessageParts(parts: readonly Message[] | undefined): void;

package/dist/zlink/runtime/messaging/message_parts_state.js

@@ -0,0 +1,20 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freezeMessageParts = freezeMessageParts;
+exports.freezeOwnedMessageParts = freezeOwnedMessageParts;
+exports.closeMessageParts = closeMessageParts;
+function freezeMessageParts(parts) {
+    return Object.freeze(parts.slice());
+}
+function freezeOwnedMessageParts(parts) {
+    return Object.freeze(parts);
+}
+function closeMessageParts(parts) {
+    if (!parts) {
+        return;
+    }
+    for (const part of parts) {
+        part.close();
+    }
+}

package/dist/zlink/runtime/messaging/message_snapshot.d.ts

@@ -0,0 +1,13 @@
+import { Message } from '../../contracts/messaging/message';
+export interface MessageSnapshot {
+    data?: Buffer;
+    nativeMessage?: unknown;
+    refCount?: number;
+    properties?: Readonly<Record<string, string>>;
+    metadata?: Readonly<Map<number, Buffer>>;
+}
+export declare function messageFromSnapshot(snapshot: MessageSnapshot): Message;
+export declare function messageFromOwnedBuffer(data: Buffer, nativeMessage?: unknown): Message;
+export declare function messageFromNativeFrame(nativeMessage: unknown, properties?: Readonly<Record<string, string>>, nativeReadOnly?: boolean): Message;
+export declare function messageFromOwnedRoutedBuffer(data: Buffer, routingId: Buffer, nativeMessage?: unknown): Message;
+export declare function messageToSnapshot(message: Message): MessageSnapshot;

package/dist/zlink/runtime/messaging/message_snapshot.js

@@ -0,0 +1,42 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageFromSnapshot = messageFromSnapshot;
+exports.messageFromOwnedBuffer = messageFromOwnedBuffer;
+exports.messageFromNativeFrame = messageFromNativeFrame;
+exports.messageFromOwnedRoutedBuffer = messageFromOwnedRoutedBuffer;
+exports.messageToSnapshot = messageToSnapshot;
+const message_1 = require("../../contracts/messaging/message");
+function messageFromSnapshot(snapshot) {
+    const message = (0, message_1.acquireMessageWrapper)(snapshot.data, snapshot.refCount ?? 1, snapshot.properties, snapshot.nativeMessage, snapshot.metadata);
+    return message;
+}
+function messageFromOwnedBuffer(data, nativeMessage) {
+    return (0, message_1.acquireMessageWrapper)(data, 1, undefined, nativeMessage);
+}
+function messageFromNativeFrame(nativeMessage, properties, nativeReadOnly = false) {
+    return (0, message_1.acquireMessageWrapper)(undefined, 1, properties, nativeMessage, undefined, nativeReadOnly);
+}
+function messageFromOwnedRoutedBuffer(data, routingId, nativeMessage) {
+    const identity = routingId.toString();
+    return messageFromSnapshot({
+        data,
+        properties: {
+            'Routing-Id': identity,
+            Identity: identity
+        },
+        nativeMessage
+    });
+}
+function messageToSnapshot(message) {
+    const state = message;
+    return {
+        ...(state._buffer === undefined ? {} : { data: state._buffer }),
+        refCount: state._refCount,
+        properties: state._properties,
+        metadata: state._metadata,
+        ...((0, message_1.canShareNativeMessage)(message) && state._nativeMessage !== undefined
+            ? { nativeMessage: state._nativeMessage }
+            : {})
+    };
+}

package/dist/zlink/runtime/messaging/received_operations.d.ts

@@ -0,0 +1,5 @@
+import type { BufferLike } from '../../contracts/core/buffer_like';
+import { Message } from '../../contracts/messaging/message';
+import type { ReplyOperation, SendOperation } from '../../contracts/messaging/operations';
+export declare function createReceivedSendOperation(invoke: (parts: readonly Message[]) => void, invokeAsync: (parts: readonly Message[]) => Promise<void>): SendOperation;
+export declare function createReceivedReplyOperation(invoke: (parts: readonly (Message | BufferLike)[]) => void): ReplyOperation;

package/dist/zlink/runtime/messaging/received_operations.js

@@ -0,0 +1,46 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReceivedSendOperation = createReceivedSendOperation;
+exports.createReceivedReplyOperation = createReceivedReplyOperation;
+const message_1 = require("../../contracts/messaging/message");
+const send_operation_base_1 = require("./send_operation_base");
+class RuntimeReceivedSendOperation extends send_operation_base_1.PartOperationBase {
+    _invoke;
+    _invokeAsync;
+    constructor(_invoke, _invokeAsync) {
+        super((message) => message instanceof message_1.Message ? message : message_1.Message.from(message));
+        this._invoke = _invoke;
+        this._invokeAsync = _invokeAsync;
+    }
+    submit() {
+        return this._invokeAsync(this.consumeParts());
+    }
+    submit_sync() {
+        const parts = this.consumeParts();
+        this._invoke(parts);
+        for (const part of parts)
+            (0, message_1.consumeSubmittedMessage)(part);
+    }
+}
+class RuntimeReceivedReplyOperation extends send_operation_base_1.PartOperationBase {
+    _invoke;
+    constructor(invoke) {
+        super((message) => message);
+        this._invoke = invoke;
+    }
+    submit() {
+        const parts = this.consumeParts();
+        this._invoke(parts);
+        for (const part of parts) {
+            if (part instanceof message_1.Message)
+                (0, message_1.consumeSubmittedMessage)(part);
+        }
+    }
+}
+function createReceivedSendOperation(invoke, invokeAsync) {
+    return new RuntimeReceivedSendOperation(invoke, invokeAsync);
+}
+function createReceivedReplyOperation(invoke) {
+    return new RuntimeReceivedReplyOperation(invoke);
+}

package/dist/zlink/runtime/messaging/received_state.d.ts

@@ -0,0 +1,13 @@
+import { Received } from '../../contracts/messaging/received';
+import { Message } from '../../contracts/messaging/message';
+import type { ReplyOperation, SendOperation } from '../../contracts/messaging/operations';
+import type { ReplyToken } from '../../contracts/messaging/received';
+import { RoutingId } from '../../contracts/core/routing_id';
+export interface ReplyContext {
+    beginReply(): ReplyOperation;
+}
+export interface SendContext {
+    beginSend(): SendOperation;
+}
+export declare function createReceived(parts: readonly Message[], routingId?: RoutingId | null, replyToken?: ReplyToken | null, replyContext?: ReplyContext | null, sendContext?: SendContext | null): Received;
+export declare function replaceReceived(target: Received, parts: Message[], routingId?: RoutingId | null, replyToken?: ReplyToken | null, replyContext?: ReplyContext | null, sendContext?: SendContext | null): void;

package/dist/zlink/runtime/messaging/received_state.js

@@ -0,0 +1,29 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReceived = createReceived;
+exports.replaceReceived = replaceReceived;
+const received_1 = require("../../contracts/messaging/received");
+const message_parts_state_1 = require("./message_parts_state");
+function createReceived(parts, routingId = null, replyToken = null, replyContext = null, sendContext = null) {
+    const received = new received_1.Received();
+    replaceReceived(received, (0, message_parts_state_1.freezeMessageParts)(parts), routingId, replyToken, replyContext, sendContext);
+    return received;
+}
+function replaceReceived(target, parts, routingId = null, replyToken = null, replyContext = null, sendContext = null) {
+    const state = target;
+    // Caller-provided receive storage is reused in perf and long-running
+    // consumers. Release the previous payload before adopting the replacement
+    // so native-backed external Buffers do not wait for GC to drop RSS.
+    if (state.parts !== parts) {
+        try {
+            (0, message_parts_state_1.closeMessageParts)(state.parts);
+        }
+        finally { }
+    }
+    state.parts = Object.isFrozen(parts) ? parts : (0, message_parts_state_1.freezeOwnedMessageParts)(parts);
+    state.routingId = routingId;
+    state.replyToken = replyToken;
+    state._replyContext = replyContext;
+    state._sendContext = sendContext;
+}

package/dist/zlink/runtime/messaging/request_executor.d.ts

@@ -0,0 +1,2 @@
+import { Message } from '../../contracts';
+export declare function messagesFromNativeBuffers(buffers: readonly Buffer[] | null | undefined): Message[];

package/dist/zlink/runtime/messaging/request_executor.js

@@ -0,0 +1,8 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messagesFromNativeBuffers = messagesFromNativeBuffers;
+const message_snapshot_1 = require("./message_snapshot");
+function messagesFromNativeBuffers(buffers) {
+    return (buffers ?? []).map((buffer) => (0, message_snapshot_1.messageFromSnapshot)({ data: buffer ?? Buffer.alloc(0) }));
+}

package/dist/zlink/runtime/messaging/send_operation_base.d.ts

@@ -0,0 +1,13 @@
+export type OperationPayloadValue<T> = T | readonly T[];
+export declare class PartOperationBase<TInput, TStored = TInput> {
+    private readonly _normalize;
+    private _single;
+    private _hasSingle;
+    private _parts;
+    private _submitted;
+    constructor(normalize?: (value: TInput) => TStored);
+    message(message: TInput): this;
+    protected ensureOpen(): void;
+    protected consumePayload(): OperationPayloadValue<TStored>;
+    protected consumeParts(): readonly TStored[];
+}

package/dist/zlink/runtime/messaging/send_operation_base.js

@@ -0,0 +1,52 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartOperationBase = void 0;
+function identity(value) {
+    return value;
+}
+class PartOperationBase {
+    _normalize;
+    _single;
+    _hasSingle = false;
+    _parts = null;
+    _submitted = false;
+    constructor(normalize = identity) {
+        this._normalize = normalize;
+    }
+    message(message) {
+        this.ensureOpen();
+        const normalized = this._normalize(message);
+        if (this._parts) {
+            this._parts.push(normalized);
+        }
+        else if (this._hasSingle) {
+            this._parts = [this._single, normalized];
+            this._hasSingle = false;
+            this._single = undefined;
+        }
+        else {
+            this._single = normalized;
+            this._hasSingle = true;
+        }
+        return this;
+    }
+    ensureOpen() {
+        if (this._submitted) {
+            throw new TypeError('operation has already been submitted');
+        }
+    }
+    consumePayload() {
+        this.ensureOpen();
+        if (!this._parts && !this._hasSingle) {
+            throw new TypeError('operation requires at least one message');
+        }
+        this._submitted = true;
+        return this._parts ?? this._single;
+    }
+    consumeParts() {
+        const value = this.consumePayload();
+        return Array.isArray(value) ? value : [value];
+    }
+}
+exports.PartOperationBase = PartOperationBase;

package/dist/zlink/runtime/messaging/subscription_event_state.d.ts

@@ -0,0 +1,4 @@
+import { SubscriptionEvent } from '../../contracts/messaging/subscription_event';
+import { RoutingId } from '../../contracts/core/routing_id';
+export declare function createSubscriptionEvent(topic: string, subscribed: boolean, routingId?: RoutingId | null): SubscriptionEvent;
+export declare function replaceSubscriptionEvent(target: SubscriptionEvent, topic: string, subscribed: boolean, routingId?: RoutingId | null): void;

package/dist/zlink/runtime/messaging/subscription_event_state.js

@@ -0,0 +1,17 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubscriptionEvent = createSubscriptionEvent;
+exports.replaceSubscriptionEvent = replaceSubscriptionEvent;
+const subscription_event_1 = require("../../contracts/messaging/subscription_event");
+function createSubscriptionEvent(topic, subscribed, routingId = null) {
+    const event = new subscription_event_1.SubscriptionEvent();
+    replaceSubscriptionEvent(event, topic, subscribed, routingId);
+    return event;
+}
+function replaceSubscriptionEvent(target, topic, subscribed, routingId = null) {
+    const state = target;
+    state.routingId = routingId;
+    state.topic = topic;
+    state.subscribed = subscribed === true;
+}

package/dist/zlink/runtime/messaging/topic_message_state.d.ts

@@ -0,0 +1,11 @@
+import { TopicMessage } from '../../contracts/messaging/topic_message';
+import { Message } from '../../contracts/messaging/message';
+import { RoutingId } from '../../contracts/core/routing_id';
+export declare function createTopicMessage(topic: string, parts: readonly Message[], routingId?: RoutingId | null): TopicMessage;
+export declare function replaceTopicMessage(target: TopicMessage, topic: string, parts: Message[], routingId?: RoutingId | null): void;
+/**
+ * Replace a caller-provided result from the common owned-Buffer receive path.
+ * The previously visible single part becomes the next receive candidate only
+ * after the new payload has been adopted, so no public part is reused early.
+ */
+export declare function replaceTopicMessageOwnedSinglePart(target: TopicMessage, topic: string, data: Buffer, routingId?: RoutingId | null): void;

package/dist/zlink/runtime/messaging/topic_message_state.js

@@ -0,0 +1,75 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTopicMessage = createTopicMessage;
+exports.replaceTopicMessage = replaceTopicMessage;
+exports.replaceTopicMessageOwnedSinglePart = replaceTopicMessageOwnedSinglePart;
+const topic_message_1 = require("../../contracts/messaging/topic_message");
+const message_1 = require("../../contracts/messaging/message");
+const message_parts_state_1 = require("./message_parts_state");
+function createTopicMessage(topic, parts, routingId = null) {
+    const message = new topic_message_1.TopicMessage();
+    replaceTopicMessage(message, topic, (0, message_parts_state_1.freezeMessageParts)(parts), routingId);
+    return message;
+}
+function replaceTopicMessage(target, topic, parts, routingId = null) {
+    const state = target;
+    // Caller-provided receive storage is a hot path. Replacing the envelope
+    // must release the previously owned payload immediately; otherwise reused
+    // TopicMessage instances retain external Buffer storage until GC and PUBSUB
+    // subscriber benchmarks regress in both RSS and throughput.
+    if (state.parts !== parts) {
+        try {
+            (0, message_parts_state_1.closeMessageParts)(state.parts);
+        }
+        finally { }
+    }
+    const candidate = state._reusableSinglePart;
+    if (candidate && !parts.includes(candidate)) {
+        candidate.close();
+    }
+    state._reusableSinglePart = null;
+    state._reusableSinglePartSlots = [];
+    state.parts = Object.isFrozen(parts) ? parts : (0, message_parts_state_1.freezeOwnedMessageParts)(parts);
+    state.routingId = routingId;
+    state.topic = topic;
+}
+/**
+ * Replace a caller-provided result from the common owned-Buffer receive path.
+ * The previously visible single part becomes the next receive candidate only
+ * after the new payload has been adopted, so no public part is reused early.
+ */
+function replaceTopicMessageOwnedSinglePart(target, topic, data, routingId = null) {
+    const state = target;
+    let next = state._reusableSinglePart;
+    if (next === null) {
+        next = (0, message_1.acquireMessageWrapper)(data);
+    }
+    else {
+        (0, message_1.refillMessageWrapper)(next, data);
+    }
+    const previous = state.parts.length === 1 ? state.parts[0] : null;
+    if (state.parts !== undefined) {
+        for (const part of state.parts) {
+            if (part !== next && part !== previous) {
+                part.close();
+            }
+        }
+    }
+    state.parts = frozenSinglePartSlot(state, next);
+    state._reusableSinglePart = previous === next ? null : previous;
+    state.routingId = routingId;
+    state.topic = topic;
+}
+function frozenSinglePartSlot(state, part) {
+    for (const slot of state._reusableSinglePartSlots) {
+        if (slot[0] === part) {
+            return slot;
+        }
+    }
+    const slot = (0, message_parts_state_1.freezeOwnedMessageParts)([part]);
+    if (state._reusableSinglePartSlots.length < 2) {
+        state._reusableSinglePartSlots.push(slot);
+    }
+    return slot;
+}

package/dist/zlink/runtime/native/binding.d.ts

@@ -0,0 +1,6 @@
+import type { CoreNativeBinding } from './binding_core';
+import type { ContextNativeBinding } from './binding_context';
+import type { EventingNativeBinding } from './binding_eventing';
+import type { SocketNativeBinding } from './binding_socket';
+export interface NativeBinding extends CoreNativeBinding, ContextNativeBinding, SocketNativeBinding, EventingNativeBinding {
+}

package/dist/zlink/runtime/native/binding.js

@@ -0,0 +1,3 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/zlink/runtime/native/binding_context.d.ts

@@ -0,0 +1,14 @@
+import type { NativeBuffer, NativeHandle } from './binding_types';
+import type { CoreHwmBudgetSnapshot } from '../../contracts/core';
+export type CoreHwmBudgetSnapshotRaw = Omit<CoreHwmBudgetSnapshot, 'budgetPlanningActive' | 'budgetInsufficient' | 'aggregateHwmValid' | 'aggregateOverflow'>;
+export interface ContextNativeBinding {
+    ctxGetOpt: (ctx: NativeHandle, option: number) => number;
+    ctxGetOptData: (ctx: NativeHandle, option: number) => NativeBuffer;
+    ctxGetAutoHwmBudgetSnapshot: (ctx: NativeHandle) => CoreHwmBudgetSnapshotRaw;
+    ctxNew: () => NativeHandle;
+    ctxRecalculateAutoHwm: (ctx: NativeHandle) => void;
+    ctxResetAutoHwmBudgetMetrics: (ctx: NativeHandle) => void;
+    ctxSetOpt: (ctx: NativeHandle, option: number, value: number | NativeBuffer) => void;
+    ctxShutdown: (ctx: NativeHandle) => void;
+    ctxTerm: (ctx: NativeHandle) => void;
+}

package/dist/zlink/runtime/native/binding_context.js

@@ -0,0 +1,3 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/zlink/runtime/native/binding_core.d.ts

@@ -0,0 +1,21 @@
+import type { NativeHandle, NativeVersion, NullableNativeHandle } from './binding_types';
+export interface CoreNativeBinding {
+    errno: () => number;
+    messageAllocate: (size: number) => {
+        data?: Buffer;
+        nativeMessage: unknown;
+    };
+    messageFrameData: (nativeMessage: unknown) => Buffer;
+    messageFrameCopyData: (nativeMessage: unknown) => Buffer;
+    messageFrameSize: (nativeMessage: unknown) => number;
+    messageFrameClose: (nativeMessage: unknown) => void;
+    messageFromBuffer: (data: Buffer) => {
+        data?: Buffer;
+        nativeMessage: unknown;
+    };
+    has: (capability: string) => boolean;
+    proxy: (frontend: NativeHandle, backend: NativeHandle, capture: NullableNativeHandle) => void;
+    sleep: (seconds: number) => void;
+    strerror: (code: number) => string;
+    version: () => NativeVersion;
+}

package/dist/zlink/runtime/native/binding_core.js

@@ -0,0 +1,3 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });