@zlink-systems/http-client 0.10.0

package/dist/runtime/browser-runtime.js

@@ -0,0 +1,123 @@
+"use strict";
+/* SPDX-License-Identifier: Apache-2.0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientRuntime = void 0;
+const framework_1 = require("@zlink-systems/framework");
+const redirect_policy_1 = require("./redirect-policy");
+const retry_policy_1 = require("./retry-policy");
+/** Browser transport for the same public client surface used by the Node runtime. */
+class HttpClientRuntime {
+    options;
+    retryPolicy;
+    constructor(options) {
+        this.options = options;
+        rejectUnsupportedTransportOptions(options);
+        this.retryPolicy = new retry_policy_1.RetryPolicy(options);
+    }
+    async executeAsync(spec) {
+        return await this.retryPolicy.execute(spec, (request, signal) => this.perform(request, signal));
+    }
+    async close() { }
+    async perform(spec, signal) {
+        const baseUri = new URL(this.options.baseUrl);
+        const origin = baseUri.origin;
+        let current = new URL(origin + (0, redirect_policy_1.makeTarget)(baseUri.pathname, spec.target));
+        let method = spec.method;
+        let body = spec.body;
+        let bodyProvider = spec.bodyProvider;
+        let redirectsLeft = this.options.followRedirects;
+        for (;;) {
+            const headers = this.buildHeaders(spec, current.origin === origin, body !== undefined || bodyProvider !== undefined);
+            const response = await fetch(current, {
+                method,
+                headers,
+                body: body ?? bodyStream(bodyProvider),
+                credentials: this.options.cookies ? 'include' : 'same-origin',
+                redirect: 'manual',
+                signal,
+            });
+            const location = response.headers.get('location');
+            if (this.options.followRedirects > 0 && (0, redirect_policy_1.isRedirectStatus)(response.status) && location !== null) {
+                if (redirectsLeft === 0) {
+                    await response.body?.cancel();
+                    throw requestError('HTTP request exceeded the redirect limit');
+                }
+                redirectsLeft--;
+                ({ method, body } = (0, redirect_policy_1.rewriteForRedirect)(response.status, method, body));
+                bodyProvider = undefined;
+                await response.body?.cancel();
+                current = (0, redirect_policy_1.resolveLocation)(current, location);
+                continue;
+            }
+            const headersResult = collectHeaders(response.headers);
+            if (spec.sink !== undefined) {
+                await streamResponse(response, spec.sink, this.options.maxResponseBodySize);
+                return { status: response.status, headers: headersResult, body: '' };
+            }
+            const text = await response.text();
+            if (new TextEncoder().encode(text).length > this.options.maxResponseBodySize) {
+                throw requestError('HTTP response exceeded the maximum body size');
+            }
+            return { status: response.status, headers: headersResult, body: text };
+        }
+    }
+    buildHeaders(spec, keepAuthorization, hasBody) {
+        const headers = { accept: 'application/json' };
+        applyHeaders(headers, this.options.headers, keepAuthorization);
+        applyHeaders(headers, spec.headers, keepAuthorization);
+        if (!hasBody)
+            delete headers['content-type'];
+        return headers;
+    }
+}
+exports.HttpClientRuntime = HttpClientRuntime;
+function rejectUnsupportedTransportOptions(options) {
+    if (options.trustCertificateFile !== undefined || options.clientCertificate !== undefined || options.proxy !== undefined) {
+        throw new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.ProtocolError, 'Browser HTTP clients cannot configure certificate files or a transport proxy.');
+    }
+}
+function bodyStream(provider) {
+    if (provider === undefined)
+        return undefined;
+    return new ReadableStream({
+        pull(controller) {
+            const chunk = provider();
+            if (chunk === null)
+                controller.close();
+            else
+                controller.enqueue(chunk);
+        },
+    });
+}
+async function streamResponse(response, sink, maximumSize) {
+    if (response.body === null)
+        return;
+    const reader = response.body.getReader();
+    let total = 0;
+    for (;;) {
+        const result = await reader.read();
+        if (result.done)
+            return;
+        total += result.value.length;
+        if (total > maximumSize) {
+            await reader.cancel();
+            throw requestError('HTTP response exceeded the maximum body size');
+        }
+        sink(result.value);
+    }
+}
+function collectHeaders(headers) {
+    const result = {};
+    headers.forEach((value, name) => { result[name.toLowerCase()] = value; });
+    return result;
+}
+function applyHeaders(target, source, keepAuthorization) {
+    for (const [name, value] of Object.entries(source)) {
+        const lower = name.toLowerCase();
+        if (keepAuthorization || lower !== 'authorization')
+            target[lower] = value;
+    }
+}
+function requestError(message) {
+    return new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.Unavailable, message);
+}

package/dist/runtime/compression.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrapper-controlled response decompression mirroring the C++ `compression.cpp`: gzip and deflate
+ * are decoded, the decoded size is bounded by the configured body limit (enforced by zlib's
+ * `maxOutputLength` so a malicious response cannot allocate past the limit before the check), and the
+ * caller removes the `Content-Encoding` header afterwards. undici's `request` does not auto-decompress,
+ * so streaming downloads are never transparently decoded. A malformed body raises `payloadDecodeFailed`;
+ * exceeding the limit raises `requestFailed`. Decoding runs on zlib's async worker pool — the
+ * synchronous variants would block the event loop for the whole decode of a large body.
+ */
+export declare function gunzip(input: Buffer, maxBytes: number): Promise<Buffer>;
+export declare function inflateDeflate(input: Buffer, maxBytes: number): Promise<Buffer>;

package/dist/runtime/compression.js

@@ -0,0 +1,42 @@
+"use strict";
+/* SPDX-License-Identifier: Apache-2.0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gunzip = gunzip;
+exports.inflateDeflate = inflateDeflate;
+const node_zlib_1 = require("node:zlib");
+const node_util_1 = require("node:util");
+const framework_1 = require("@zlink-systems/framework");
+const gunzipAsync = (0, node_util_1.promisify)(node_zlib_1.gunzip);
+const inflateAsync = (0, node_util_1.promisify)(node_zlib_1.inflate);
+const inflateRawAsync = (0, node_util_1.promisify)(node_zlib_1.inflateRaw);
+/**
+ * Wrapper-controlled response decompression mirroring the C++ `compression.cpp`: gzip and deflate
+ * are decoded, the decoded size is bounded by the configured body limit (enforced by zlib's
+ * `maxOutputLength` so a malicious response cannot allocate past the limit before the check), and the
+ * caller removes the `Content-Encoding` header afterwards. undici's `request` does not auto-decompress,
+ * so streaming downloads are never transparently decoded. A malformed body raises `payloadDecodeFailed`;
+ * exceeding the limit raises `requestFailed`. Decoding runs on zlib's async worker pool — the
+ * synchronous variants would block the event loop for the whole decode of a large body.
+ */
+function gunzip(input, maxBytes) {
+    return decode(() => gunzipAsync(input, { maxOutputLength: maxBytes, chunkSize: 1 << 20 }));
+}
+function inflateDeflate(input, maxBytes) {
+    // Detect a zlib-wrapped stream (CMF/FLG: method deflate, header a multiple of 31) vs raw deflate.
+    const zlibWrapped = input.length >= 2 && (input[0] & 0x0f) === 8 && (((input[0] << 8) | input[1]) % 31) === 0;
+    return decode(() => zlibWrapped
+        ? inflateAsync(input, { maxOutputLength: maxBytes, chunkSize: 1 << 20 })
+        : inflateRawAsync(input, { maxOutputLength: maxBytes, chunkSize: 1 << 20 }));
+}
+async function decode(run) {
+    try {
+        return await run();
+    }
+    catch (cause) {
+        // zlib rejects with a RangeError (ERR_BUFFER_TOO_LARGE) when output exceeds maxOutputLength.
+        if (cause instanceof RangeError) {
+            throw new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.Unavailable, 'HTTP response compressed body exceeds maxResponseBodySize');
+        }
+        throw new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.ProtocolError, 'HTTP response compressed body is malformed', cause);
+    }
+}

package/dist/runtime/cookie-jar.d.ts

@@ -0,0 +1,5 @@
+export declare class CookieJar {
+    private readonly cookies;
+    store(host: string, setCookieHeader: string): void;
+    headerFor(host: string, path: string, secure: boolean): string;
+}

package/dist/runtime/cookie-jar.js

@@ -0,0 +1,84 @@
+"use strict";
+/* SPDX-License-Identifier: Apache-2.0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieJar = void 0;
+const MAX_COOKIES_PER_HOST = 128;
+class CookieJar {
+    cookies = [];
+    store(host, setCookieHeader) {
+        const segments = setCookieHeader.split(';');
+        const pair = (segments.shift() ?? '').trim();
+        const equals = pair.indexOf('=');
+        if (equals < 0) {
+            return;
+        }
+        const name = pair.slice(0, equals).trim();
+        const value = pair.slice(equals + 1).trim();
+        if (name.length === 0) {
+            return;
+        }
+        let path = '/';
+        let secure = false;
+        let expired = false;
+        for (const raw of segments) {
+            const attribute = raw.trim();
+            const attrEquals = attribute.indexOf('=');
+            const attrName = (attrEquals < 0 ? attribute : attribute.slice(0, attrEquals)).trim();
+            const attrValue = attrEquals < 0 ? '' : attribute.slice(attrEquals + 1).trim();
+            if (attrName.toLowerCase() === 'path' && attrValue.length > 0) {
+                path = attrValue;
+            }
+            else if (attrName.toLowerCase() === 'secure') {
+                secure = true;
+            }
+            else if (attrName.toLowerCase() === 'max-age') {
+                const maxAge = Number.parseInt(attrValue, 10);
+                if (!Number.isNaN(maxAge)) {
+                    expired = maxAge <= 0;
+                }
+            }
+        }
+        for (let i = this.cookies.length - 1; i >= 0; i--) {
+            const existing = this.cookies[i];
+            if (existing.host === host && existing.name === name && existing.path === path) {
+                this.cookies.splice(i, 1);
+            }
+        }
+        if (expired) {
+            return;
+        }
+        this.cookies.push({ host, name, value, path, secure });
+        let countForHost = this.cookies.filter((stored) => stored.host === host).length;
+        while (countForHost > MAX_COOKIES_PER_HOST) {
+            const oldest = this.cookies.findIndex((stored) => stored.host === host);
+            if (oldest < 0) {
+                break;
+            }
+            this.cookies.splice(oldest, 1);
+            countForHost--;
+        }
+    }
+    headerFor(host, path, secure) {
+        const parts = [];
+        for (const cookie of this.cookies) {
+            if (cookie.host !== host || (cookie.secure && !secure) || !pathMatches(path, cookie.path)) {
+                continue;
+            }
+            parts.push(`${cookie.name}=${cookie.value}`);
+        }
+        return parts.join('; ');
+    }
+}
+exports.CookieJar = CookieJar;
+function pathMatches(requestPath, cookiePath) {
+    if (cookiePath.length === 0 || cookiePath === '/') {
+        return true;
+    }
+    if (requestPath === cookiePath) {
+        return true;
+    }
+    if (!requestPath.startsWith(cookiePath)) {
+        return false;
+    }
+    return cookiePath.endsWith('/') || requestPath[cookiePath.length] === '/';
+}

package/dist/runtime/options.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Immutable snapshot of the client configuration produced by the builder. Mirrors the C++
+ * `http_client_options_t`. Transport gaps (cookie jar, redirect loop, compression, retry) are
+ * implemented by the wrapper; only matching semantics are delegated to undici.
+ */
+export interface HttpClientOptions {
+    readonly baseUrl: string;
+    readonly timeoutMs: number;
+    readonly maxResponseBodySize: number;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly trustCertificateFile?: string;
+    readonly clientCertificate?: {
+        readonly certificatePath: string;
+        readonly keyPath: string;
+    };
+    readonly followRedirects: number;
+    readonly retryAttempts: number;
+    readonly cookies: boolean;
+    readonly proxy?: string;
+    readonly proxyAuthorization?: string;
+    readonly compression: boolean;
+}

package/dist/runtime/options.js

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

package/dist/runtime/redirect-policy.d.ts

@@ -0,0 +1,13 @@
+import type { ZLinkHttpMethod } from '../types';
+export declare function isRedirectStatus(status: number): boolean;
+/** Combines the base URL path prefix with the request target. */
+export declare function makeTarget(prefix: string, path: string): string;
+/**
+ * Applies the method/body rewrite for a followed redirect: 303, and 301/302 on POST, become a
+ * bodyless GET; all other redirects preserve the method and body.
+ */
+export declare function rewriteForRedirect(status: number, method: ZLinkHttpMethod, body: string | undefined): {
+    method: ZLinkHttpMethod;
+    body: string | undefined;
+};
+export declare function resolveLocation(current: URL, location: string): URL;

package/dist/runtime/redirect-policy.js

@@ -0,0 +1,53 @@
+"use strict";
+/* SPDX-License-Identifier: Apache-2.0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRedirectStatus = isRedirectStatus;
+exports.makeTarget = makeTarget;
+exports.rewriteForRedirect = rewriteForRedirect;
+exports.resolveLocation = resolveLocation;
+const framework_1 = require("@zlink-systems/framework");
+/**
+ * Stateless redirect and target-URL rules for the wrapper-owned redirect loop. Isolates the redirect
+ * contract (allowed statuses, location resolution, method rewrite) from the request flow.
+ */
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+function isRedirectStatus(status) {
+    return REDIRECT_STATUSES.has(status);
+}
+/** Combines the base URL path prefix with the request target. */
+function makeTarget(prefix, path) {
+    if (prefix.length === 0 || prefix === '/') {
+        return path;
+    }
+    return prefix.endsWith('/') ? prefix.slice(0, -1) + path : prefix + path;
+}
+/**
+ * Applies the method/body rewrite for a followed redirect: 303, and 301/302 on POST, become a
+ * bodyless GET; all other redirects preserve the method and body.
+ */
+function rewriteForRedirect(status, method, body) {
+    if (status === 303 || ((status === 301 || status === 302) && method === 'POST')) {
+        return { method: 'GET', body: undefined };
+    }
+    return { method, body };
+}
+function resolveLocation(current, location) {
+    try {
+        if (location.startsWith('http://') || location.startsWith('https://')) {
+            return new URL(location);
+        }
+        if (location.startsWith('//')) {
+            // Protocol-relative location: inherit the current scheme (current.protocol includes the ':').
+            return new URL(current.protocol + location);
+        }
+        if (location.startsWith('/')) {
+            return new URL(current.origin + location);
+        }
+    }
+    catch {
+        // A malformed Location is a redirect-protocol error, not a transport failure: throw a
+        // non-retriable framework exception so retry does not resend the original request.
+        throw new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.Unavailable, `HTTP redirect location is malformed: ${location}`);
+    }
+    throw new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.Unavailable, `HTTP redirect location is not supported: ${location}`);
+}

package/dist/runtime/request-performer.d.ts

@@ -0,0 +1,35 @@
+import { type Dispatcher } from 'undici';
+import type { BodyChunkProvider, DownloadSink, ZLinkHttpMethod } from '../types';
+import type { HttpClientOptions } from './options';
+import { CookieJar } from './cookie-jar';
+export interface HttpRequestSpec {
+    readonly method: ZLinkHttpMethod;
+    readonly target: string;
+    readonly body?: string;
+    readonly bodyProvider?: BodyChunkProvider;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly timeoutMs?: number;
+    readonly sink?: DownloadSink;
+}
+export interface RawResult {
+    readonly status: number;
+    readonly headers: Record<string, string>;
+    readonly body: string;
+}
+/**
+ * Performs a single logical request, driving the wrapper-owned redirect loop, cookie jar
+ * integration, and same-origin `Authorization` scrubbing. Redirect/URL rules live in
+ * `redirect-policy` and response decoding in {@link ResponseBodyReader}. Mirrors the C++
+ * `request_performer.cpp`. undici does not auto-redirect, auto-decompress, or keep cookies, so these
+ * semantics match the ZLink contract.
+ */
+export declare class RequestPerformer {
+    private readonly options;
+    private readonly cookieJar;
+    private readonly dispatcher;
+    private readonly bodyReader;
+    constructor(options: HttpClientOptions, cookieJar: CookieJar, dispatcher: Dispatcher | undefined);
+    perform(spec: HttpRequestSpec, signal: AbortSignal): Promise<RawResult>;
+    private buildHeaders;
+    private buildBody;
+}

package/dist/runtime/request-performer.js

@@ -0,0 +1,158 @@
+"use strict";
+/* SPDX-License-Identifier: Apache-2.0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestPerformer = void 0;
+const node_stream_1 = require("node:stream");
+const undici_1 = require("undici");
+const framework_1 = require("@zlink-systems/framework");
+const redirect_policy_1 = require("./redirect-policy");
+const response_body_reader_1 = require("./response-body-reader");
+const version_1 = require("./version");
+/**
+ * Performs a single logical request, driving the wrapper-owned redirect loop, cookie jar
+ * integration, and same-origin `Authorization` scrubbing. Redirect/URL rules live in
+ * `redirect-policy` and response decoding in {@link ResponseBodyReader}. Mirrors the C++
+ * `request_performer.cpp`. undici does not auto-redirect, auto-decompress, or keep cookies, so these
+ * semantics match the ZLink contract.
+ */
+class RequestPerformer {
+    options;
+    cookieJar;
+    dispatcher;
+    bodyReader;
+    constructor(options, cookieJar, dispatcher) {
+        this.options = options;
+        this.cookieJar = cookieJar;
+        this.dispatcher = dispatcher;
+        this.bodyReader = new response_body_reader_1.ResponseBodyReader(options);
+    }
+    async perform(spec, signal) {
+        const baseUri = new URL(this.options.baseUrl);
+        const origin = baseUri.origin;
+        let current = new URL(origin + (0, redirect_policy_1.makeTarget)(baseUri.pathname, spec.target));
+        let method = spec.method;
+        let body = spec.body;
+        // A streamed body provider cannot be rewound, so it is dropped once a redirect is followed.
+        let bodyProvider = spec.bodyProvider;
+        let redirectsLeft = this.options.followRedirects;
+        for (;;) {
+            const keepAuthorization = current.origin === origin;
+            const hasBody = body !== undefined || bodyProvider !== undefined;
+            const headers = this.buildHeaders(spec, current, keepAuthorization, hasBody);
+            const response = await (0, undici_1.request)(current.href, {
+                method,
+                headers,
+                body: this.buildBody(body, bodyProvider),
+                dispatcher: this.dispatcher,
+                maxRedirections: 0,
+                signal,
+            });
+            const status = response.statusCode;
+            if (this.options.cookies) {
+                const setCookie = response.headers['set-cookie'];
+                const values = Array.isArray(setCookie) ? setCookie : setCookie === undefined ? [] : [setCookie];
+                for (const value of values) {
+                    this.cookieJar.store(current.hostname, value);
+                }
+            }
+            const location = headerValue(response.headers, 'location');
+            if (this.options.followRedirects > 0 && (0, redirect_policy_1.isRedirectStatus)(status) && location !== undefined && location.length > 0) {
+                if (redirectsLeft === 0) {
+                    await drain(response.body);
+                    throw requestError('HTTP request exceeded the redirect limit');
+                }
+                redirectsLeft--;
+                ({ method, body } = (0, redirect_policy_1.rewriteForRedirect)(status, method, body));
+                bodyProvider = undefined; // consumed; never replay a non-rewindable stream on a redirect
+                await drain(response.body);
+                current = (0, redirect_policy_1.resolveLocation)(current, location);
+                continue;
+            }
+            const collectedHeaders = response_body_reader_1.ResponseBodyReader.collectHeaders(response.headers);
+            if (spec.sink !== undefined) {
+                await this.bodyReader.streamToSink(response.body, spec.sink);
+                return { status, headers: collectedHeaders, body: '' };
+            }
+            let bytes = await this.bodyReader.readBuffered(response.body);
+            let finalHeaders = collectedHeaders;
+            if (this.options.compression) {
+                const result = await this.bodyReader.decompress(bytes, finalHeaders);
+                bytes = result.body;
+                finalHeaders = result.headers;
+            }
+            // Decode lazily: the UTF-8 conversion of a large body is a main-thread cost that
+            // callers who never read the text body (binary consumers) should not pay.
+            let text;
+            return {
+                status,
+                headers: finalHeaders,
+                get body() {
+                    text ??= bytes.toString('utf8');
+                    return text;
+                },
+            };
+        }
+    }
+    buildHeaders(spec, target, keepAuthorization, hasBody) {
+        const headers = {
+            'user-agent': version_1.httpClientUserAgent,
+            accept: 'application/json',
+        };
+        if (this.options.compression) {
+            headers['accept-encoding'] = 'gzip, deflate';
+        }
+        // Proxy authentication is carried by the ProxyAgent dispatcher (see runtime.ts), not a header,
+        // so it is not leaked to the target over a CONNECT tunnel.
+        applyHeaders(headers, this.options.headers, keepAuthorization);
+        applyHeaders(headers, spec.headers, keepAuthorization);
+        if (!hasBody) {
+            // A body source dropped by a redirect must not leave stale content-type metadata behind.
+            delete headers['content-type'];
+        }
+        if (this.options.cookies) {
+            const cookieHeader = this.cookieJar.headerFor(target.hostname, target.pathname, target.protocol === 'https:');
+            if (cookieHeader.length > 0) {
+                headers['cookie'] = cookieHeader;
+            }
+        }
+        return headers;
+    }
+    buildBody(body, bodyProvider) {
+        if (bodyProvider !== undefined) {
+            const provider = bodyProvider;
+            return node_stream_1.Readable.from((function* () {
+                for (let chunk = provider(); chunk !== null; chunk = provider()) {
+                    if (chunk.length > 0) {
+                        yield chunk;
+                    }
+                }
+            })());
+        }
+        return body;
+    }
+}
+exports.RequestPerformer = RequestPerformer;
+function applyHeaders(target, headers, keepAuthorization) {
+    for (const [name, value] of Object.entries(headers)) {
+        const lower = name.toLowerCase();
+        if (!keepAuthorization && lower === 'authorization') {
+            continue;
+        }
+        target[lower] = value;
+    }
+}
+function headerValue(headers, name) {
+    const value = headers[name];
+    if (value === undefined) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value[0] : value;
+}
+async function drain(stream) {
+    for await (const _chunk of stream) {
+        // discard
+    }
+}
+function requestError(message) {
+    return new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.Unavailable, message);
+}

package/dist/runtime/response-body-reader.d.ts

@@ -0,0 +1,19 @@
+import type { Readable } from 'node:stream';
+import type { DownloadSink } from '../types';
+import type { HttpClientOptions } from './options';
+/**
+ * Reads and decodes undici response bodies for the wrapper: buffered read with the configured size
+ * limit, streaming delivery to a sink, header collection, and wrapper-controlled gzip/deflate
+ * decompression. Separated from the request/redirect flow so response decoding is independent.
+ */
+export declare class ResponseBodyReader {
+    private readonly options;
+    constructor(options: HttpClientOptions);
+    streamToSink(stream: Readable, sink: DownloadSink): Promise<void>;
+    readBuffered(stream: Readable): Promise<Buffer>;
+    decompress(bytes: Buffer, headers: Record<string, string>): Promise<{
+        body: Buffer;
+        headers: Record<string, string>;
+    }>;
+    static collectHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string>;
+}

package/dist/runtime/response-body-reader.js

@@ -0,0 +1,89 @@
+"use strict";
+/* SPDX-License-Identifier: Apache-2.0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseBodyReader = void 0;
+const framework_1 = require("@zlink-systems/framework");
+const compression_1 = require("./compression");
+/**
+ * Reads and decodes undici response bodies for the wrapper: buffered read with the configured size
+ * limit, streaming delivery to a sink, header collection, and wrapper-controlled gzip/deflate
+ * decompression. Separated from the request/redirect flow so response decoding is independent.
+ */
+class ResponseBodyReader {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async streamToSink(stream, sink) {
+        let total = 0;
+        for await (const chunk of stream) {
+            const buffer = chunk;
+            total += buffer.length;
+            if (total > this.options.maxResponseBodySize) {
+                throw exceededBodySize();
+            }
+            sink(new Uint8Array(buffer));
+        }
+    }
+    async readBuffered(stream) {
+        const chunks = [];
+        let total = 0;
+        for await (const chunk of stream) {
+            const buffer = chunk;
+            total += buffer.length;
+            if (total > this.options.maxResponseBodySize) {
+                throw exceededBodySize();
+            }
+            chunks.push(buffer);
+        }
+        return Buffer.concat(chunks);
+    }
+    async decompress(bytes, headers) {
+        const encoding = Object.prototype.hasOwnProperty.call(headers, 'content-encoding')
+            ? headers['content-encoding']
+            : undefined;
+        // An empty body (HEAD / 204 / 304) carries no payload to decode even with Content-Encoding.
+        if (encoding === undefined || bytes.length === 0) {
+            return { body: bytes, headers };
+        }
+        if (encoding.toLowerCase() === 'gzip') {
+            return {
+                body: await (0, compression_1.gunzip)(bytes, this.options.maxResponseBodySize),
+                headers: stripEncodingHeaders(headers),
+            };
+        }
+        if (encoding.toLowerCase() === 'deflate') {
+            return {
+                body: await (0, compression_1.inflateDeflate)(bytes, this.options.maxResponseBodySize),
+                headers: stripEncodingHeaders(headers),
+            };
+        }
+        return { body: bytes, headers };
+    }
+    static collectHeaders(headers) {
+        const result = {};
+        for (const [name, value] of Object.entries(headers)) {
+            if (value === undefined) {
+                continue;
+            }
+            result[name.toLowerCase()] = Array.isArray(value) ? value.join(', ') : value;
+        }
+        return result;
+    }
+}
+exports.ResponseBodyReader = ResponseBodyReader;
+// After decoding, drop Content-Encoding and the now-stale Content-Length (it described the
+// compressed body, not the decoded one).
+function stripEncodingHeaders(headers) {
+    const copy = {};
+    for (const [key, value] of Object.entries(headers)) {
+        const lower = key.toLowerCase();
+        if (lower !== 'content-encoding' && lower !== 'content-length') {
+            copy[key] = value;
+        }
+    }
+    return copy;
+}
+function exceededBodySize() {
+    return new framework_1.ZLinkFrameworkException(framework_1.ZLinkFrameworkErrorKind.Unavailable, 'HTTP response exceeded the maximum body size');
+}