@zlink-systems/framework 0.10.0

package/dist/runtime/streams/session-local-actors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkSessionLocalActorBindings = void 0;
+class ZLinkSessionLocalActorBindings {
+    actors = new Map();
+    snapshot() {
+        const snapshot = [];
+        for (const entry of this.actors.values()) {
+            snapshot.push(entry.actor);
+        }
+        return snapshot;
+    }
+    find(actorId) {
+        return this.actors.get(actorId)?.actor;
+    }
+    bind(actor, token) {
+        this.actors.set(actor.actorId, { actor, token });
+    }
+    unbind(actorId, token) {
+        const current = this.actors.get(actorId);
+        if (current?.token === token) {
+            this.actors.delete(actorId);
+        }
+    }
+}
+exports.ZLinkSessionLocalActorBindings = ZLinkSessionLocalActorBindings;

package/dist/runtime/streams/session-provider.d.ts

@@ -0,0 +1,4 @@
+import type { Type, ZLinkSession, ZLinkSessionFactory } from '../../contracts';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import type { DefaultZLinkSessionContext } from './session-context';
+export declare function createStreamSessionInstance(type: Type<ZLinkSession> | Type<ZLinkSessionFactory>, resolver: ZLinkProviderResolver | undefined, context: DefaultZLinkSessionContext, handlerTypes?: readonly Type[]): Promise<ZLinkSession>;

package/dist/runtime/streams/session-provider.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamSessionInstance = createStreamSessionInstance;
+async function createStreamSessionInstance(type, resolver, context, handlerTypes = []) {
+    for (const handlerType of handlerTypes) {
+        context.handlers.addHandler(handlerType);
+    }
+    const created = await createProviderInstance(type, resolver, context);
+    if (isSessionFactory(created)) {
+        return await created.create(context);
+    }
+    return created;
+}
+async function createProviderInstance(type, resolver, fallbackArg) {
+    const existing = resolver?.get?.(type);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const created = await resolver?.create?.(type);
+    if (created !== undefined) {
+        return created;
+    }
+    return fallbackArg === undefined
+        ? new type()
+        : new type(fallbackArg);
+}
+function isSessionFactory(value) {
+    return typeof value.create === 'function'
+        && value.context === undefined;
+}

package/dist/runtime/streams/session-requests.d.ts

@@ -0,0 +1,25 @@
+import type { Message } from '../../contracts/Common/Message';
+export declare class ZLinkPendingSessionRequest {
+    private readonly tracker;
+    readonly requestSeq: bigint;
+    private completed;
+    private readonly timeout;
+    private resolvePromise;
+    private rejectPromise;
+    readonly promise: Promise<Message>;
+    constructor(tracker: ZLinkSessionRequestTracker, requestSeq: bigint, timeoutMs: number | undefined);
+    complete(payload: Message): void;
+    fail(error: unknown): void;
+    cancel(): void;
+    dispose(): void;
+    private clearTimeout;
+}
+export declare class ZLinkSessionRequestTracker {
+    private readonly pending;
+    private nextRequestSeq;
+    start(timeoutMs?: number): ZLinkPendingSessionRequest;
+    complete(requestSeq: bigint, payload: Message): boolean;
+    fail(requestSeq: bigint, error: unknown): boolean;
+    remove(requestSeq: bigint): void;
+    private next;
+}

package/dist/runtime/streams/session-requests.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkSessionRequestTracker = exports.ZLinkPendingSessionRequest = void 0;
+const stream_message_utils_1 = require("./stream-message-utils");
+class ZLinkPendingSessionRequest {
+    tracker;
+    requestSeq;
+    completed = false;
+    timeout;
+    resolvePromise;
+    rejectPromise;
+    promise;
+    constructor(tracker, requestSeq, timeoutMs) {
+        this.tracker = tracker;
+        this.requestSeq = requestSeq;
+        this.promise = new Promise((resolve, reject) => {
+            this.resolvePromise = resolve;
+            this.rejectPromise = reject;
+        });
+        if (timeoutMs !== undefined) {
+            this.timeout = setTimeout(() => this.cancel(), timeoutMs);
+        }
+    }
+    complete(payload) {
+        if (this.completed) {
+            return;
+        }
+        this.completed = true;
+        this.clearTimeout();
+        this.resolvePromise((0, stream_message_utils_1.copyMessage)(payload));
+    }
+    fail(error) {
+        if (this.completed) {
+            return;
+        }
+        this.completed = true;
+        this.clearTimeout();
+        this.rejectPromise(error);
+    }
+    cancel() {
+        if (this.completed) {
+            return;
+        }
+        this.completed = true;
+        this.clearTimeout();
+        this.tracker.remove(this.requestSeq);
+        this.rejectPromise(new Error('Client stream request timed out.'));
+    }
+    dispose() {
+        this.clearTimeout();
+        this.tracker.remove(this.requestSeq);
+    }
+    clearTimeout() {
+        if (this.timeout !== undefined) {
+            clearTimeout(this.timeout);
+        }
+    }
+}
+exports.ZLinkPendingSessionRequest = ZLinkPendingSessionRequest;
+class ZLinkSessionRequestTracker {
+    pending = new Map();
+    nextRequestSeq = 0n;
+    start(timeoutMs) {
+        const requestSeq = this.next();
+        const pending = new ZLinkPendingSessionRequest(this, requestSeq, timeoutMs);
+        if (this.pending.has(requestSeq)) {
+            throw new Error('Duplicate stream request sequence.');
+        }
+        this.pending.set(requestSeq, pending);
+        return pending;
+    }
+    complete(requestSeq, payload) {
+        const pending = this.pending.get(requestSeq);
+        if (pending === undefined) {
+            return false;
+        }
+        this.pending.delete(requestSeq);
+        pending.complete(payload);
+        return true;
+    }
+    fail(requestSeq, error) {
+        const pending = this.pending.get(requestSeq);
+        if (pending === undefined) {
+            return false;
+        }
+        this.pending.delete(requestSeq);
+        pending.fail(error);
+        return true;
+    }
+    remove(requestSeq) {
+        this.pending.delete(requestSeq);
+    }
+    next() {
+        do {
+            this.nextRequestSeq = (this.nextRequestSeq + 1n) & 0xffffffffffffffffn;
+        } while (this.nextRequestSeq === 0n);
+        return this.nextRequestSeq;
+    }
+}
+exports.ZLinkSessionRequestTracker = ZLinkSessionRequestTracker;

package/dist/runtime/streams/session-serial-executor.d.ts

@@ -0,0 +1,12 @@
+import { type ZLinkSerialWorkOptions } from '../execution/serial-execution-queue';
+export declare class ZLinkSessionSerialExecutor {
+    private readonly scheduler;
+    private closed;
+    executeApplication(work: () => Promise<void>, options?: Omit<ZLinkSerialWorkOptions, 'lane'>, onRejected?: (error?: unknown) => void): boolean;
+    executeControl(work: () => Promise<void>, options?: Omit<ZLinkSerialWorkOptions, 'lane'>, onRejected?: (error?: unknown) => void): boolean;
+    executeInfrastructure(work: () => Promise<void>, options?: Omit<ZLinkSerialWorkOptions, 'lane'>, onRejected?: (error?: unknown) => void): boolean;
+    executeFinal(work: () => Promise<void>): Promise<void>;
+    private submit;
+    dispose(): Promise<void>;
+    private execute;
+}

package/dist/runtime/streams/session-serial-executor.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkSessionSerialExecutor = void 0;
+const serial_execution_queue_1 = require("../execution/serial-execution-queue");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
+class ZLinkSessionSerialExecutor {
+    scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue(async (record) => this.execute(record), {
+        capacityError: (lane) => (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerQueueFull, `Stream Session ${lane} execution capacity is full.`, true)
+    });
+    closed = false;
+    executeApplication(work, options = {}, onRejected) {
+        return this.submit(work, 'application', options, onRejected);
+    }
+    executeControl(work, options = {}, onRejected) {
+        return this.submit(work, 'lifecycle', options, onRejected);
+    }
+    executeInfrastructure(work, options = {}, onRejected) {
+        return this.submit(work, 'lifecycle', options, onRejected);
+    }
+    executeFinal(work) {
+        if (this.closed) {
+            return Promise.reject((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown, 'Session execution queue is closed.'));
+        }
+        const boundWork = (0, application_job_queue_scope_1.bindApplicationJobPermit)(work);
+        return (0, application_job_queue_scope_1.hasApplicationJobPermit)()
+            ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'lifecycle' })
+            : this.scheduler.submit(boundWork, { lane: 'lifecycle' });
+    }
+    submit(work, lane, options = {}, onRejected) {
+        if (this.closed)
+            return false;
+        const serialOptions = { ...options, lane };
+        const boundWork = (0, application_job_queue_scope_1.bindApplicationJobPermit)(work);
+        const submitted = (0, application_job_queue_scope_1.hasApplicationJobPermit)()
+            ? this.scheduler.submitPreAdmitted(boundWork, serialOptions)
+            : this.scheduler.submit(boundWork, serialOptions);
+        void submitted
+            .catch(error => onRejected?.(error));
+        return true;
+    }
+    async dispose() {
+        this.closed = true;
+        await this.scheduler.whenIdle();
+    }
+    async execute(record) {
+        try {
+            record.resolve(await record.operation());
+        }
+        catch (error) {
+            record.reject(error);
+        }
+        finally {
+            record.release();
+        }
+    }
+}
+exports.ZLinkSessionSerialExecutor = ZLinkSessionSerialExecutor;

package/dist/runtime/streams/stream-binding-runtime-ports.d.ts

@@ -0,0 +1,62 @@
+import type { ActorRef, ZLinkSessionActor } from '../../contracts';
+import type { ZLinkBackendActorSessionNode } from '../backend';
+import type { ZLinkSubmitResult } from '../messaging/submission-result';
+import type { DefaultZLinkSessionActor } from './session-context';
+import type { ZLinkBoundSessionResponseTarget } from './bound-session-response-target';
+export interface ZLinkStreamActorLookupPort {
+    find(actorId: string): Promise<DefaultZLinkSessionActor | undefined>;
+    authorityFence(actorId: string): Promise<{
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+    } | undefined>;
+    sessionRouteFence(actorId: string): Promise<{
+        readonly actor: ActorRef;
+        readonly sessionRid: ActorRef['nodeRid'];
+        readonly bindingGeneration: bigint;
+    } | undefined>;
+}
+export interface ZLinkStreamActorLifecyclePort {
+    rebindActor(actorRef: ActorRef, signal?: AbortSignal): Promise<void>;
+    refreshActor(actorRef: ActorRef, signal?: AbortSignal): Promise<void>;
+    commitActorRoute(actorRef: ActorRef, signal?: AbortSignal, options?: ZLinkActorRouteCommitOptions): Promise<void>;
+    abortActorRouteSeal(actorId: string, sealId: string): Promise<boolean>;
+    validateActorRouteSeal(actorId: string, sealId: string): Promise<boolean>;
+    unbindActor(actorId: string): Promise<void>;
+}
+export interface ZLinkActorRouteCommitOptions {
+    /**
+     * Relocation already carries the binding identity to the target actor. The
+     * follow-up confirmation can use a one-way route submission because a
+     * request/ACK would create a nested route request while the Session
+     * ownership command is being dispatched.
+     */
+    readonly confirmRemoteSessionBinding?: boolean | 'send';
+    /**
+     * Command 44 keeps ingress sealed while the native route is prepared, then
+     * publishes the new route and releases this exact seal in one owner turn.
+     */
+    readonly releaseSeal?: {
+        readonly sealId: string;
+    };
+}
+export interface ZLinkBoundSessionResponsePort {
+    captureBoundSessionResponseTarget(actor: ZLinkSessionActor): Promise<ZLinkBoundSessionResponseTarget | undefined>;
+    sendLocalBoundSessionResponse(actorId: string, packetName: string, requestSeq: bigint, message: unknown, metadata: ReadonlyMap<string, string>, compressPayload: boolean): Promise<boolean>;
+    sendLocalBoundSessionError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>): Promise<boolean>;
+}
+export interface ZLinkRemoteBoundSessionPort extends ZLinkStreamActorLifecyclePort {
+    disconnectBoundSession(actorId: string, signal?: AbortSignal): Promise<void>;
+    sendLocalBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>): Promise<boolean>;
+    sendLocalBoundSessionResponse(actorId: string, packetName: string, requestSeq: bigint, message: unknown, metadata: ReadonlyMap<string, string>, compressPayload: boolean): Promise<boolean>;
+    sendLocalBoundSessionError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>): Promise<boolean>;
+    sendNativeBoundSessionResponse(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, packetName: string, requestSeq: bigint, message: unknown, metadata: ReadonlyMap<string, string>, compressPayload: boolean, signal?: AbortSignal): Promise<void>;
+    sendNativeBoundSessionError(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<void>;
+}
+export interface ZLinkNativeFallbackBoundSessionPort {
+    disconnectNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, signal?: AbortSignal): Promise<void>;
+    disconnectBoundSession(actorId: string, signal?: AbortSignal): Promise<void>;
+    sendLocalBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>): Promise<boolean>;
+    submitLocalBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+    sendNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+    sendBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+}

package/dist/runtime/streams/stream-binding-runtime-ports.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/streams/stream-frame-factory.d.ts

@@ -0,0 +1,44 @@
+import type { ZLinkStreamCompressionCodec, ZLinkStreamCompressionOptions } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
+import { ZLinkStreamCodec, type ZLinkStreamFrameHeader, ZLinkStreamMessageKind, type ZLinkStreamReplyMessageKind } from './protocol';
+export interface ZLinkStreamFramePayloadCodec {
+    encode(payload: unknown, context?: {
+        readonly messageType?: Function;
+        readonly packetName?: string;
+        readonly direction: 'Request' | 'Response' | 'Error' | 'Send';
+    } | Function): {
+        readonly codec: ZLinkStreamCodec;
+        readonly payload: Uint8Array;
+    };
+}
+export interface ZLinkStreamFrameMessageFactoryOptions {
+    readonly messageFactory?: ZLinkStreamFrameMessageFactorySource;
+    readonly streamPayloadCodec?: ZLinkStreamFramePayloadCodec;
+    readonly streamCompression?: ZLinkStreamCompressionOptions;
+    readonly flowCreationEnabled?: () => boolean;
+}
+export interface ZLinkStreamFrameMessageFactorySource {
+    createTextMessage(payload: string): Message;
+    createBinaryMessage?(payload: Uint8Array): Message;
+}
+export declare class ZLinkStreamFrameMessageFactory {
+    private readonly options;
+    private readonly compressionCodec;
+    constructor(options: ZLinkStreamFrameMessageFactoryOptions);
+    createTextMessage(payload: string): Message;
+    createBinaryMessage(payload: Uint8Array): Message;
+    createJsonFrameMessage(kind: ZLinkStreamMessageKind, packetName: string, metadata: ReadonlyMap<string, string>, compressed: boolean, requestSeq: bigint | undefined, payload: unknown, correlationId?: string): Message;
+    createJsonReplyFrameMessage(requestHeader: ZLinkStreamFrameHeader, kind: ZLinkStreamReplyMessageKind, metadata: ReadonlyMap<string, string>, compressed: boolean, payload: unknown): Message;
+    private createJsonFrameMessageWithHeader;
+    /**
+     * Wraps a freshly encoded, unaliased frame. `createBinaryMessage` must copy
+     * because callers may pass live buffers, but the frames built here are
+     * never retained by the encoder, so the default path skips that copy.
+     */
+    private createOwnedFrameMessage;
+    private encodePayload;
+    private requireMessageFactory;
+}
+export declare const zlinkStreamLz4CompressionCodec: ZLinkStreamCompressionCodec;
+export declare function resolveStreamCompressionCodec(options: ZLinkStreamCompressionOptions | undefined): ZLinkStreamCompressionCodec | undefined;
+export declare function decompressStreamPayload(payload: Uint8Array, codec: ZLinkStreamCompressionCodec | undefined, maxDecompressedSize?: number): Uint8Array;

package/dist/runtime/streams/stream-frame-factory.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zlinkStreamLz4CompressionCodec = exports.ZLinkStreamFrameMessageFactory = void 0;
+exports.resolveStreamCompressionCodec = resolveStreamCompressionCodec;
+exports.decompressStreamPayload = decompressStreamPayload;
+const runtime_message_1 = require("../backend/runtime-message");
+const flow_context_1 = require("../diagnostics/flow-context");
+const framework_json_v1_1 = require("../messaging/framework-json-v1");
+const Attributes_1 = require("../../contracts/Handlers/Attributes");
+const protocol_1 = require("./protocol");
+const DEFAULT_MAX_DECOMPRESSED_STREAM_PAYLOAD_SIZE = 64 * 1024;
+class ZLinkStreamFrameMessageFactory {
+    options;
+    compressionCodec;
+    constructor(options) {
+        this.options = options;
+        this.compressionCodec = resolveStreamCompressionCodec(options.streamCompression);
+    }
+    createTextMessage(payload) {
+        return this.requireMessageFactory().createTextMessage(payload);
+    }
+    createBinaryMessage(payload) {
+        const factory = this.requireMessageFactory();
+        if (factory.createBinaryMessage !== undefined) {
+            return factory.createBinaryMessage(payload);
+        }
+        return factory.createTextMessage((0, protocol_1.utf8Decode)(payload));
+    }
+    createJsonFrameMessage(kind, packetName, metadata, compressed, requestSeq, payload, correlationId) {
+        const flow = (this.options.flowCreationEnabled?.() ?? true)
+            ? (0, flow_context_1.currentOrCreateFlow)('Application')
+            : undefined;
+        return this.createJsonFrameMessageWithHeader(payload, compressed, packetName, streamDirection(kind), (codec, flags) => ({
+            kind,
+            codec,
+            flags,
+            requestSeq,
+            name: kind === protocol_1.ZLinkStreamMessageKind.Response || kind === protocol_1.ZLinkStreamMessageKind.Error
+                ? ''
+                : packetName,
+            metadata,
+            correlationId,
+            flowId: flow?.flowId,
+            flowOrigin: flow?.flowOrigin
+        }));
+    }
+    createJsonReplyFrameMessage(requestHeader, kind, metadata, compressed, payload) {
+        return this.createJsonFrameMessageWithHeader(payload, compressed, requestHeader.name, streamDirection(kind), (codec, flags) => (0, protocol_1.createStreamReplyHeader)(requestHeader, kind, codec, flags, metadata, this.options.flowCreationEnabled?.() ?? true));
+    }
+    createJsonFrameMessageWithHeader(payload, compressed, packetName, direction, createHeader) {
+        const encoded = this.encodePayload(payload, packetName, direction);
+        let body = encoded.payload;
+        if (compressed) {
+            body = compressStreamPayload(body, this.compressionCodec);
+        }
+        const flags = compressed ? protocol_1.ZLinkStreamHeaderFlags.PayloadCompressed : protocol_1.ZLinkStreamHeaderFlags.None;
+        const frame = (0, protocol_1.encodeStreamFrame)(createHeader(encoded.codec, flags), body);
+        return this.createOwnedFrameMessage(frame);
+    }
+    /**
+     * Wraps a freshly encoded, unaliased frame. `createBinaryMessage` must copy
+     * because callers may pass live buffers, but the frames built here are
+     * never retained by the encoder, so the default path skips that copy.
+     */
+    createOwnedFrameMessage(frame) {
+        const factory = this.options.messageFactory;
+        if (factory !== undefined) {
+            return factory.createBinaryMessage !== undefined
+                ? factory.createBinaryMessage(frame)
+                : factory.createTextMessage((0, protocol_1.utf8Decode)(frame));
+        }
+        return runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength));
+    }
+    encodePayload(payload, packetName, direction) {
+        const codec = this.options.streamPayloadCodec;
+        if (codec !== undefined) {
+            if (direction !== 'Error') {
+                return codec.encode(payload, { packetName, direction });
+            }
+        }
+        return {
+            codec: protocol_1.ZLinkStreamCodec.Json,
+            payload: (0, protocol_1.utf8Encode)((0, framework_json_v1_1.stringifyFrameworkJsonV1)(payload, direction === 'Error'
+                ? undefined
+                : (0, Attributes_1.readZLinkPacketJsonContract)(packetName)?.[direction === 'Response' ? 'reply' : 'payload']))
+        };
+    }
+    requireMessageFactory() {
+        return this.options.messageFactory ?? defaultStreamMessageFactory;
+    }
+}
+exports.ZLinkStreamFrameMessageFactory = ZLinkStreamFrameMessageFactory;
+function streamDirection(kind) {
+    switch (kind) {
+        case protocol_1.ZLinkStreamMessageKind.Request: return 'Request';
+        case protocol_1.ZLinkStreamMessageKind.Response: return 'Response';
+        case protocol_1.ZLinkStreamMessageKind.Error: return 'Error';
+        default: return 'Send';
+    }
+}
+exports.zlinkStreamLz4CompressionCodec = {
+    compress(payload) {
+        return (0, protocol_1.lz4Pickle)(payload);
+    },
+    decompress(payload, maxDecompressedSize) {
+        return (0, protocol_1.lz4Unpickle)(payload, maxDecompressedSize);
+    }
+};
+function resolveStreamCompressionCodec(options) {
+    if (options?.disabled === true) {
+        return undefined;
+    }
+    return options?.codec ?? exports.zlinkStreamLz4CompressionCodec;
+}
+function compressStreamPayload(payload, codec) {
+    if (codec === undefined) {
+        throw new Error('Compression codec is not configured.');
+    }
+    try {
+        return codec.compress(payload);
+    }
+    catch (error) {
+        throw new Error(`Compression failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function decompressStreamPayload(payload, codec, maxDecompressedSize = DEFAULT_MAX_DECOMPRESSED_STREAM_PAYLOAD_SIZE) {
+    if (codec === undefined) {
+        throw new Error('Compression codec is not configured.');
+    }
+    let decompressed;
+    try {
+        decompressed = codec.decompress(payload, maxDecompressedSize);
+    }
+    catch (error) {
+        throw new Error(`Decompression failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (decompressed.length > maxDecompressedSize) {
+        throw new Error('Decompressed stream payload exceeds maximum stream payload size.');
+    }
+    return decompressed;
+}
+const defaultStreamMessageFactory = {
+    createTextMessage(payload) {
+        return runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(payload));
+    },
+    createBinaryMessage(payload) {
+        return runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(payload));
+    }
+};

package/dist/runtime/streams/stream-message-utils.d.ts

@@ -0,0 +1,5 @@
+import type { Message } from '../../contracts/Common/Message';
+export declare function copyMessage(message: Message): Message;
+export declare function simpleMessage(bytes: Uint8Array): unknown;
+/** Create the structural Message used by the internal receive assembler. */
+export declare function ownedMessage(bytes: Uint8Array): Message;

package/dist/runtime/streams/stream-message-utils.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyMessage = copyMessage;
+exports.simpleMessage = simpleMessage;
+exports.ownedMessage = ownedMessage;
+const framework_json_v1_1 = require("../messaging/framework-json-v1");
+const protocol_1 = require("./protocol");
+const EMPTY_MESSAGE_BYTES = new Uint8Array(0);
+function copyMessage(message) {
+    const value = message;
+    if (value.copy !== undefined) {
+        return value.copy();
+    }
+    if (value.toBytes !== undefined) {
+        return simpleMessage(value.toBytes());
+    }
+    if (value.data !== undefined) {
+        return simpleMessage(value.data());
+    }
+    if (value.bytes !== undefined) {
+        return simpleMessage(value.bytes);
+    }
+    if (value.getString !== undefined) {
+        return simpleMessage((0, protocol_1.utf8Encode)(value.getString()));
+    }
+    throw new Error('Stream response payload cannot be copied.');
+}
+function simpleMessage(bytes) {
+    return createSimpleMessage(new Uint8Array(bytes), false);
+}
+/** Create the structural Message used by the internal receive assembler. */
+function ownedMessage(bytes) {
+    return createSimpleMessage(bytes, true);
+}
+function createSimpleMessage(initial, releaseOnClose) {
+    return new ZLinkSimpleMessage(initial, releaseOnClose);
+}
+class ZLinkSimpleMessage {
+    current;
+    releaseOnClose;
+    constructor(current, releaseOnClose) {
+        this.current = current;
+        this.releaseOnClose = releaseOnClose;
+    }
+    get bytes() {
+        return this.current;
+    }
+    toBytes() {
+        return new Uint8Array(this.current);
+    }
+    data() {
+        return this.current;
+    }
+    size() {
+        return this.current.byteLength;
+    }
+    isEmpty() {
+        return this.current.byteLength === 0;
+    }
+    copy() {
+        return createSimpleMessage(new Uint8Array(this.current), true);
+    }
+    getString() {
+        return (0, protocol_1.utf8Decode)(this.current);
+    }
+    value() {
+        return (0, framework_json_v1_1.parseFrameworkJsonV1)((0, protocol_1.utf8Decode)(this.current));
+    }
+    close() {
+        if (this.releaseOnClose) {
+            this.current = EMPTY_MESSAGE_BYTES;
+        }
+    }
+}