velocious 1.0.569 → 1.0.571

package/build/src/http-server/client/response-compression.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Runs parse accept encoding.
+ * @param {string} headerValue - Accept-Encoding header value.
+ * @returns {Map<string, number>} - Lowercased coding to q-value (0-1).
+ */
+export function parseAcceptEncoding(headerValue: string): Map<string, number>;
+/**
+ * Negotiates the content coding for a response from the Accept-Encoding header.
+ * Identity participates in the same quality comparison as the supported codings:
+ * a higher-q identity selects identity, and equal-q ties break in server order
+ * br, gzip, identity. Identity defaults to acceptable unless explicitly refused
+ * with `identity;q=0` or a `*;q=0` wildcard without a more specific identity
+ * entry, and an explicit coding entry beats the wildcard.
+ * @param {string | null | undefined} acceptEncoding - Accept-Encoding header value.
+ * @returns {{encoding: "br" | "gzip" | "identity", identityAcceptable: boolean} | {notAcceptable: true}} - Negotiated coding, or that no acceptable representation exists.
+ */
+export function negotiateContentEncoding(acceptEncoding: string | null | undefined): {
+    encoding: "br" | "gzip" | "identity";
+    identityAcceptable: boolean;
+} | {
+    notAcceptable: true;
+};
+/**
+ * Runs is compressible content type.
+ * @param {string} contentType - Content-Type header value.
+ * @returns {boolean} - Whether the media type is on the compressible allowlist.
+ */
+export function isCompressibleContentType(contentType: string): boolean;
+/**
+ * Merges Accept-Encoding into the response Vary header case-insensitively and
+ * without duplicates. An existing `Vary: *` already covers every request header
+ * and is preserved as-is.
+ * @param {import("./response.js").default} response - Response instance.
+ * @returns {void} - No return value.
+ */
+export function addAcceptEncodingToVary(response: import("./response.js").default): void;
+/**
+ * Negotiates and applies compression to a buffered response body immediately before
+ * framing. Only string/Uint8Array responses reach this point; sendFile responses and
+ * bodyless statuses are excluded by the caller. Transformation is skipped for
+ * Cache-Control no-transform, non-allowlisted or pre-compressed media types,
+ * server-sent events, partial (206) responses, requests with a Range header,
+ * credentialed requests (Authorization/Cookie headers), responses carrying
+ * credentials or validators (Set-Cookie/ETag/Digest/Content-Digest/Content-Range
+ * headers), and per-response opt-outs; a skipped
+ * transformation is still sent as identity when the client accepts identity, and
+ * answered "not-acceptable" when it does not. Responses that already carry an
+ * application-supplied Content-Encoding are passed through unchanged and never
+ * negotiate. When the client forbids every representation (identity and all
+ * supported codings), the outcome is "not-acceptable".
+ * @param {object} args - Options object.
+ * @param {Buffer} args.bodyBuffer - Buffered response body bytes (UTF-8 encoded for string bodies).
+ * @param {import("../../configuration-types.js").NormalizedHttpCompressionConfiguration} args.compression - Normalized compression configuration.
+ * @param {import("./request.js").default | import("./websocket-request.js").default} args.request - Request object.
+ * @param {import("./response.js").default} args.response - Response instance.
+ * @returns {Promise<{outcome: "identity"} | {outcome: "compressed", body: Buffer} | {outcome: "not-acceptable"}>} - Compression outcome.
+ */
+export function applyResponseCompression({ bodyBuffer, compression, request, response }: {
+    bodyBuffer: Buffer;
+    compression: import("../../configuration-types.js").NormalizedHttpCompressionConfiguration;
+    request: import("./request.js").default | import("./websocket-request.js").default;
+    response: import("./response.js").default;
+}): Promise<{
+    outcome: "identity";
+} | {
+    outcome: "compressed";
+    body: Buffer;
+} | {
+    outcome: "not-acceptable";
+}>;
+//# sourceMappingURL=response-compression.d.ts.map

package/build/src/http-server/client/response-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-compression.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/response-compression.js"],"names":[],"mappings":"AA4BA;;;;GAIG;AACH,iDAHW,MAAM,GACJ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA8B/B;AAED;;;;;;;;;GASG;AACH,yDAHW,MAAM,GAAG,IAAI,GAAG,SAAS,GACvB;IAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,UAAU,CAAC;IAAC,kBAAkB,EAAE,OAAO,CAAA;CAAC,GAAG;IAAC,aAAa,EAAE,IAAI,CAAA;CAAC,CAyBvG;AAED;;;;GAIG;AACH,uDAHW,MAAM,GACJ,OAAO,CAcnB;AAED;;;;;;GAMG;AACH,kDAHW,OAAO,eAAe,EAAE,OAAO,GAC7B,IAAI,CAmBhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,yFANG;IAAqB,UAAU,EAAvB,MAAM;IAC8E,WAAW,EAA/F,OAAO,8BAA8B,EAAE,sCAAsC;IACG,OAAO,EAAvF,OAAO,cAAc,EAAE,OAAO,GAAG,OAAO,wBAAwB,EAAE,OAAO;IACnC,QAAQ,EAA9C,OAAO,eAAe,EAAE,OAAO;CACvC,GAAU,OAAO,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,GAAG;IAAC,OAAO,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG;IAAC,OAAO,EAAE,gBAAgB,CAAA;CAAC,CAAC,CA6DhH"}

package/build/src/http-server/client/response-compression.js

@@ -0,0 +1,197 @@
+// @ts-check
+import zlib from "node:zlib";
+import { promisify } from "node:util";
+const brotliCompressAsync = promisify(zlib.brotliCompress);
+const gzipAsync = promisify(zlib.gzip);
+/**
+ * Exact media types (beyond the text/*, *+json, and *+xml families) that are worth compressing.
+ * Everything else — unknown binary types and commonly pre-compressed media such as images,
+ * video, and archives — is left untouched by the conservative allowlist.
+ * @type {Set<string>} */
+const COMPRESSIBLE_EXACT_MEDIA_TYPES = new Set([
+    "application/ecmascript",
+    "application/javascript",
+    "application/json",
+    "application/x-javascript",
+    "application/xml",
+    "image/svg+xml"
+]);
+/**
+ * RFC 9110 §12.4.2 qvalue grammar: `0` or `1` with at most three fractional
+ * digits, and only zeros after `1`.
+ * @type {RegExp} */
+const QVALUE_PATTERN = /^(?:0(?:\.\d{1,3})?|1(?:\.0{1,3})?)$/u;
+/**
+ * Runs parse accept encoding.
+ * @param {string} headerValue - Accept-Encoding header value.
+ * @returns {Map<string, number>} - Lowercased coding to q-value (0-1).
+ */
+export function parseAcceptEncoding(headerValue) {
+    /** @type {Map<string, number>} */
+    const codings = new Map();
+    for (const part of headerValue.split(",")) {
+        const [codingToken, ...parameters] = part.split(";");
+        const coding = codingToken?.trim().toLowerCase();
+        if (!coding)
+            continue;
+        let q = 1;
+        for (const parameter of parameters) {
+            const [name, value] = parameter.split("=");
+            if (name?.trim().toLowerCase() != "q")
+                continue;
+            const qvalue = value?.trim() || "";
+            // A malformed q-value (e.g. `.5`, `01`, `1.001`, more than three fractional
+            // digits, or empty) is treated as "not acceptable" (q=0), per RFC 9110 §12.4.2.
+            q = QVALUE_PATTERN.test(qvalue) ? Number(qvalue) : 0;
+        }
+        codings.set(coding, q);
+    }
+    return codings;
+}
+/**
+ * Negotiates the content coding for a response from the Accept-Encoding header.
+ * Identity participates in the same quality comparison as the supported codings:
+ * a higher-q identity selects identity, and equal-q ties break in server order
+ * br, gzip, identity. Identity defaults to acceptable unless explicitly refused
+ * with `identity;q=0` or a `*;q=0` wildcard without a more specific identity
+ * entry, and an explicit coding entry beats the wildcard.
+ * @param {string | null | undefined} acceptEncoding - Accept-Encoding header value.
+ * @returns {{encoding: "br" | "gzip" | "identity", identityAcceptable: boolean} | {notAcceptable: true}} - Negotiated coding, or that no acceptable representation exists.
+ */
+export function negotiateContentEncoding(acceptEncoding) {
+    if (acceptEncoding === undefined || acceptEncoding === null || acceptEncoding.trim() === "") {
+        return { encoding: "identity", identityAcceptable: true };
+    }
+    const codings = parseAcceptEncoding(acceptEncoding);
+    const wildcardQ = codings.get("*");
+    const identityQ = codings.get("identity") ?? wildcardQ ?? 1;
+    // Declared in server preference order; the stable sort keeps this order for ties.
+    /** @type {Array<{coding: "br" | "gzip" | "identity", q: number}>} */
+    const candidates = [
+        { coding: "br", q: codings.get("br") ?? wildcardQ ?? 0 },
+        { coding: "gzip", q: codings.get("gzip") ?? wildcardQ ?? 0 },
+        { coding: "identity", q: identityQ }
+    ];
+    const selected = candidates
+        .filter((candidate) => candidate.q > 0)
+        .sort((a, b) => b.q - a.q)[0];
+    if (!selected)
+        return { notAcceptable: true };
+    return { encoding: selected.coding, identityAcceptable: identityQ > 0 };
+}
+/**
+ * Runs is compressible content type.
+ * @param {string} contentType - Content-Type header value.
+ * @returns {boolean} - Whether the media type is on the compressible allowlist.
+ */
+export function isCompressibleContentType(contentType) {
+    const mediaType = contentType.split(";")[0]?.trim().toLowerCase();
+    if (!mediaType)
+        return false;
+    // Server-sent events are long-lived streams; buffering them for compression
+    // would break delivery, so they are excluded before the textual allowlist.
+    if (mediaType == "text/event-stream")
+        return false;
+    if (mediaType.startsWith("text/"))
+        return true;
+    if (mediaType.endsWith("+json") || mediaType.endsWith("+xml"))
+        return true;
+    return COMPRESSIBLE_EXACT_MEDIA_TYPES.has(mediaType);
+}
+/**
+ * Merges Accept-Encoding into the response Vary header case-insensitively and
+ * without duplicates. An existing `Vary: *` already covers every request header
+ * and is preserved as-is.
+ * @param {import("./response.js").default} response - Response instance.
+ * @returns {void} - No return value.
+ */
+export function addAcceptEncodingToVary(response) {
+    for (const headerKey in response.headers) {
+        if (headerKey.toLowerCase() != "vary")
+            continue;
+        const values = response.headers[headerKey];
+        const tokens = values.flatMap((value) => value.split(",").map((token) => token.trim().toLowerCase()));
+        if (tokens.includes("*") || tokens.includes("accept-encoding"))
+            return;
+        if (values.length > 0) {
+            values[0] = `${values[0]}, Accept-Encoding`;
+        }
+        return;
+    }
+    response.setHeader("Vary", "Accept-Encoding");
+}
+/**
+ * Negotiates and applies compression to a buffered response body immediately before
+ * framing. Only string/Uint8Array responses reach this point; sendFile responses and
+ * bodyless statuses are excluded by the caller. Transformation is skipped for
+ * Cache-Control no-transform, non-allowlisted or pre-compressed media types,
+ * server-sent events, partial (206) responses, requests with a Range header,
+ * credentialed requests (Authorization/Cookie headers), responses carrying
+ * credentials or validators (Set-Cookie/ETag/Digest/Content-Digest/Content-Range
+ * headers), and per-response opt-outs; a skipped
+ * transformation is still sent as identity when the client accepts identity, and
+ * answered "not-acceptable" when it does not. Responses that already carry an
+ * application-supplied Content-Encoding are passed through unchanged and never
+ * negotiate. When the client forbids every representation (identity and all
+ * supported codings), the outcome is "not-acceptable".
+ * @param {object} args - Options object.
+ * @param {Buffer} args.bodyBuffer - Buffered response body bytes (UTF-8 encoded for string bodies).
+ * @param {import("../../configuration-types.js").NormalizedHttpCompressionConfiguration} args.compression - Normalized compression configuration.
+ * @param {import("./request.js").default | import("./websocket-request.js").default} args.request - Request object.
+ * @param {import("./response.js").default} args.response - Response instance.
+ * @returns {Promise<{outcome: "identity"} | {outcome: "compressed", body: Buffer} | {outcome: "not-acceptable"}>} - Compression outcome.
+ */
+export async function applyResponseCompression({ bodyBuffer, compression, request, response }) {
+    if (!compression.enabled)
+        return { outcome: "identity" };
+    // Application-supplied encodings stay application-owned: they are passed through
+    // unchanged and never take part in negotiation failure handling.
+    if (response.getHeader("Content-Encoding").length > 0)
+        return { outcome: "identity" };
+    const negotiated = negotiateContentEncoding(request.header("accept-encoding"));
+    if ("notAcceptable" in negotiated)
+        return { outcome: "not-acceptable" };
+    const cacheControlTokens = response.getHeader("Cache-Control")
+        .flatMap((value) => value.split(","))
+        .map((token) => token.trim().toLowerCase());
+    const contentType = response.getHeader("Content-Type")[0];
+    // Automatic security exclusions: credentialed requests (Authorization/Cookie) and
+    // responses carrying credentials (Set-Cookie) or representation validators
+    // (ETag/Digest/Content-Digest) are never transformed — compression could leak
+    // secret-bearing content through a compression oracle, and validators stay
+    // application-owned rather than being recomputed for encoded variants.
+    const transformable = !response.isCompressionDisabled() &&
+        response.getStatusCode() !== 206 &&
+        !request.header("range") &&
+        !request.header("authorization") &&
+        !request.header("cookie") &&
+        response.getHeader("Content-Range").length === 0 &&
+        response.getHeader("Set-Cookie").length === 0 &&
+        response.getHeader("ETag").length === 0 &&
+        response.getHeader("Digest").length === 0 &&
+        response.getHeader("Content-Digest").length === 0 &&
+        !cacheControlTokens.includes("no-transform") &&
+        contentType !== undefined &&
+        isCompressibleContentType(contentType);
+    if (!transformable) {
+        // A skipped transformation may still go out as identity when the client accepts
+        // identity; when identity is forbidden, no acceptable representation can be sent.
+        return negotiated.identityAcceptable ? { outcome: "identity" } : { outcome: "not-acceptable" };
+    }
+    // The representation now depends on the request's Accept-Encoding, even when this
+    // particular response ends up identity (missing header, higher-q identity, below threshold).
+    addAcceptEncodingToVary(response);
+    if (negotiated.encoding == "identity")
+        return { outcome: "identity" };
+    // Below the threshold the smaller identity representation is sent instead — but only
+    // when identity is acceptable; a client that forbids identity must never be forced
+    // onto an unacceptable representation by the size check.
+    if (bodyBuffer.length < compression.threshold && negotiated.identityAcceptable)
+        return { outcome: "identity" };
+    const body = negotiated.encoding == "br"
+        ? await brotliCompressAsync(bodyBuffer, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: compression.brotliQuality } })
+        : await gzipAsync(bodyBuffer, { level: compression.gzipLevel });
+    response.setHeader("Content-Encoding", negotiated.encoding);
+    return { body, outcome: "compressed" };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response-compression.js","sourceRoot":"","sources":["../../../../src/http-server/client/response-compression.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAA;AAEnC,MAAM,mBAAmB,GAAG,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;AAC1D,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAEtC;;;;yBAIyB;AACzB,MAAM,8BAA8B,GAAG,IAAI,GAAG,CAAC;IAC7C,wBAAwB;IACxB,wBAAwB;IACxB,kBAAkB;IAClB,0BAA0B;IAC1B,iBAAiB;IACjB,eAAe;CAChB,CAAC,CAAA;AAEF;;;oBAGoB;AACpB,MAAM,cAAc,GAAG,uCAAuC,CAAA;AAE9D;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,WAAW;IAC7C,kCAAkC;IAClC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;IAEzB,KAAK,MAAM,IAAI,IAAI,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1C,MAAM,CAAC,WAAW,EAAE,GAAG,UAAU,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACpD,MAAM,MAAM,GAAG,WAAW,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;QAEhD,IAAI,CAAC,MAAM;YAAE,SAAQ;QAErB,IAAI,CAAC,GAAG,CAAC,CAAA;QAET,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YAE1C,IAAI,IAAI,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,GAAG;gBAAE,SAAQ;YAE/C,MAAM,MAAM,GAAG,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;YAElC,4EAA4E;YAC5E,gFAAgF;YAChF,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QACtD,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IACxB,CAAC;IAED,OAAO,OAAO,CAAA;AAChB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,cAAc;IACrD,IAAI,cAAc,KAAK,SAAS,IAAI,cAAc,KAAK,IAAI,IAAI,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC5F,OAAO,EAAC,QAAQ,EAAE,UAAU,EAAE,kBAAkB,EAAE,IAAI,EAAC,CAAA;IACzD,CAAC;IAED,MAAM,OAAO,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAA;IACnD,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAClC,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,SAAS,IAAI,CAAC,CAAA;IAE3D,kFAAkF;IAClF,qEAAqE;IACrE,MAAM,UAAU,GAAG;QACjB,EAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,SAAS,IAAI,CAAC,EAAC;QACtD,EAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,SAAS,IAAI,CAAC,EAAC;QAC1D,EAAC,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,SAAS,EAAC;KACnC,CAAA;IACD,MAAM,QAAQ,GAAG,UAAU;SACxB,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC;SACtC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAE/B,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAC,aAAa,EAAE,IAAI,EAAC,CAAA;IAE3C,OAAO,EAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,kBAAkB,EAAE,SAAS,GAAG,CAAC,EAAC,CAAA;AACvE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,WAAW;IACnD,MAAM,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;IAEjE,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAA;IAE5B,4EAA4E;IAC5E,2EAA2E;IAC3E,IAAI,SAAS,IAAI,mBAAmB;QAAE,OAAO,KAAK,CAAA;IAClD,IAAI,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAA;IAC9C,IAAI,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAA;IAE1E,OAAO,8BAA8B,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;AACtD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAAQ;IAC9C,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QACzC,IAAI,SAAS,CAAC,WAAW,EAAE,IAAI,MAAM;YAAE,SAAQ;QAE/C,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;QAC1C,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,CAAA;QAErG,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC;YAAE,OAAM;QAEtE,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,mBAAmB,CAAA;QAC7C,CAAC;QAED,OAAM;IACR,CAAC;IAED,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,EAAC,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAC;IACzF,IAAI,CAAC,WAAW,CAAC,OAAO;QAAE,OAAO,EAAC,OAAO,EAAE,UAAU,EAAC,CAAA;IAEtD,iFAAiF;IACjF,iEAAiE;IACjE,IAAI,QAAQ,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAC,OAAO,EAAE,UAAU,EAAC,CAAA;IAEnF,MAAM,UAAU,GAAG,wBAAwB,CAAC,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAE9E,IAAI,eAAe,IAAI,UAAU;QAAE,OAAO,EAAC,OAAO,EAAE,gBAAgB,EAAC,CAAA;IAErE,MAAM,kBAAkB,GAAG,QAAQ,CAAC,SAAS,CAAC,eAAe,CAAC;SAC3D,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;SACpC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAA;IAC7C,MAAM,WAAW,GAAG,QAAQ,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;IAEzD,kFAAkF;IAClF,2EAA2E;IAC3E,8EAA8E;IAC9E,2EAA2E;IAC3E,uEAAuE;IACvE,MAAM,aAAa,GAAG,CAAC,QAAQ,CAAC,qBAAqB,EAAE;QACrD,QAAQ,CAAC,aAAa,EAAE,KAAK,GAAG;QAChC,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;QACxB,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC;QAChC,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;QACzB,QAAQ,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,MAAM,KAAK,CAAC;QAChD,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,MAAM,KAAK,CAAC;QAC7C,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;QACvC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,CAAC;QACzC,QAAQ,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,MAAM,KAAK,CAAC;QACjD,CAAC,kBAAkB,CAAC,QAAQ,CAAC,cAAc,CAAC;QAC5C,WAAW,KAAK,SAAS;QACzB,yBAAyB,CAAC,WAAW,CAAC,CAAA;IAExC,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,gFAAgF;QAChF,kFAAkF;QAClF,OAAO,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,UAAU,EAAC,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,gBAAgB,EAAC,CAAA;IAC5F,CAAC;IAED,kFAAkF;IAClF,6FAA6F;IAC7F,uBAAuB,CAAC,QAAQ,CAAC,CAAA;IAEjC,IAAI,UAAU,CAAC,QAAQ,IAAI,UAAU;QAAE,OAAO,EAAC,OAAO,EAAE,UAAU,EAAC,CAAA;IAEnE,qFAAqF;IACrF,mFAAmF;IACnF,yDAAyD;IACzD,IAAI,UAAU,CAAC,MAAM,GAAG,WAAW,CAAC,SAAS,IAAI,UAAU,CAAC,kBAAkB;QAAE,OAAO,EAAC,OAAO,EAAE,UAAU,EAAC,CAAA;IAE5G,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,IAAI,IAAI;QACtC,CAAC,CAAC,MAAM,mBAAmB,CAAC,UAAU,EAAE,EAAC,MAAM,EAAE,EAAC,CAAC,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,EAAE,WAAW,CAAC,aAAa,EAAC,EAAC,CAAC;QACrH,CAAC,CAAC,MAAM,SAAS,CAAC,UAAU,EAAE,EAAC,KAAK,EAAE,WAAW,CAAC,SAAS,EAAC,CAAC,CAAA;IAE/D,QAAQ,CAAC,SAAS,CAAC,kBAAkB,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAA;IAE3D,OAAO,EAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAC,CAAA;AACtC,CAAC","sourcesContent":["// @ts-check\n\nimport zlib from \"node:zlib\"\nimport {promisify} from \"node:util\"\n\nconst brotliCompressAsync = promisify(zlib.brotliCompress)\nconst gzipAsync = promisify(zlib.gzip)\n\n/**\n * Exact media types (beyond the text/*, *+json, and *+xml families) that are worth compressing.\n * Everything else — unknown binary types and commonly pre-compressed media such as images,\n * video, and archives — is left untouched by the conservative allowlist.\n * @type {Set<string>} */\nconst COMPRESSIBLE_EXACT_MEDIA_TYPES = new Set([\n  \"application/ecmascript\",\n  \"application/javascript\",\n  \"application/json\",\n  \"application/x-javascript\",\n  \"application/xml\",\n  \"image/svg+xml\"\n])\n\n/**\n * RFC 9110 §12.4.2 qvalue grammar: `0` or `1` with at most three fractional\n * digits, and only zeros after `1`.\n * @type {RegExp} */\nconst QVALUE_PATTERN = /^(?:0(?:\\.\\d{1,3})?|1(?:\\.0{1,3})?)$/u\n\n/**\n * Runs parse accept encoding.\n * @param {string} headerValue - Accept-Encoding header value.\n * @returns {Map<string, number>} - Lowercased coding to q-value (0-1).\n */\nexport function parseAcceptEncoding(headerValue) {\n  /** @type {Map<string, number>} */\n  const codings = new Map()\n\n  for (const part of headerValue.split(\",\")) {\n    const [codingToken, ...parameters] = part.split(\";\")\n    const coding = codingToken?.trim().toLowerCase()\n\n    if (!coding) continue\n\n    let q = 1\n\n    for (const parameter of parameters) {\n      const [name, value] = parameter.split(\"=\")\n\n      if (name?.trim().toLowerCase() != \"q\") continue\n\n      const qvalue = value?.trim() || \"\"\n\n      // A malformed q-value (e.g. `.5`, `01`, `1.001`, more than three fractional\n      // digits, or empty) is treated as \"not acceptable\" (q=0), per RFC 9110 §12.4.2.\n      q = QVALUE_PATTERN.test(qvalue) ? Number(qvalue) : 0\n    }\n\n    codings.set(coding, q)\n  }\n\n  return codings\n}\n\n/**\n * Negotiates the content coding for a response from the Accept-Encoding header.\n * Identity participates in the same quality comparison as the supported codings:\n * a higher-q identity selects identity, and equal-q ties break in server order\n * br, gzip, identity. Identity defaults to acceptable unless explicitly refused\n * with `identity;q=0` or a `*;q=0` wildcard without a more specific identity\n * entry, and an explicit coding entry beats the wildcard.\n * @param {string | null | undefined} acceptEncoding - Accept-Encoding header value.\n * @returns {{encoding: \"br\" | \"gzip\" | \"identity\", identityAcceptable: boolean} | {notAcceptable: true}} - Negotiated coding, or that no acceptable representation exists.\n */\nexport function negotiateContentEncoding(acceptEncoding) {\n  if (acceptEncoding === undefined || acceptEncoding === null || acceptEncoding.trim() === \"\") {\n    return {encoding: \"identity\", identityAcceptable: true}\n  }\n\n  const codings = parseAcceptEncoding(acceptEncoding)\n  const wildcardQ = codings.get(\"*\")\n  const identityQ = codings.get(\"identity\") ?? wildcardQ ?? 1\n\n  // Declared in server preference order; the stable sort keeps this order for ties.\n  /** @type {Array<{coding: \"br\" | \"gzip\" | \"identity\", q: number}>} */\n  const candidates = [\n    {coding: \"br\", q: codings.get(\"br\") ?? wildcardQ ?? 0},\n    {coding: \"gzip\", q: codings.get(\"gzip\") ?? wildcardQ ?? 0},\n    {coding: \"identity\", q: identityQ}\n  ]\n  const selected = candidates\n    .filter((candidate) => candidate.q > 0)\n    .sort((a, b) => b.q - a.q)[0]\n\n  if (!selected) return {notAcceptable: true}\n\n  return {encoding: selected.coding, identityAcceptable: identityQ > 0}\n}\n\n/**\n * Runs is compressible content type.\n * @param {string} contentType - Content-Type header value.\n * @returns {boolean} - Whether the media type is on the compressible allowlist.\n */\nexport function isCompressibleContentType(contentType) {\n  const mediaType = contentType.split(\";\")[0]?.trim().toLowerCase()\n\n  if (!mediaType) return false\n\n  // Server-sent events are long-lived streams; buffering them for compression\n  // would break delivery, so they are excluded before the textual allowlist.\n  if (mediaType == \"text/event-stream\") return false\n  if (mediaType.startsWith(\"text/\")) return true\n  if (mediaType.endsWith(\"+json\") || mediaType.endsWith(\"+xml\")) return true\n\n  return COMPRESSIBLE_EXACT_MEDIA_TYPES.has(mediaType)\n}\n\n/**\n * Merges Accept-Encoding into the response Vary header case-insensitively and\n * without duplicates. An existing `Vary: *` already covers every request header\n * and is preserved as-is.\n * @param {import(\"./response.js\").default} response - Response instance.\n * @returns {void} - No return value.\n */\nexport function addAcceptEncodingToVary(response) {\n  for (const headerKey in response.headers) {\n    if (headerKey.toLowerCase() != \"vary\") continue\n\n    const values = response.headers[headerKey]\n    const tokens = values.flatMap((value) => value.split(\",\").map((token) => token.trim().toLowerCase()))\n\n    if (tokens.includes(\"*\") || tokens.includes(\"accept-encoding\")) return\n\n    if (values.length > 0) {\n      values[0] = `${values[0]}, Accept-Encoding`\n    }\n\n    return\n  }\n\n  response.setHeader(\"Vary\", \"Accept-Encoding\")\n}\n\n/**\n * Negotiates and applies compression to a buffered response body immediately before\n * framing. Only string/Uint8Array responses reach this point; sendFile responses and\n * bodyless statuses are excluded by the caller. Transformation is skipped for\n * Cache-Control no-transform, non-allowlisted or pre-compressed media types,\n * server-sent events, partial (206) responses, requests with a Range header,\n * credentialed requests (Authorization/Cookie headers), responses carrying\n * credentials or validators (Set-Cookie/ETag/Digest/Content-Digest/Content-Range\n * headers), and per-response opt-outs; a skipped\n * transformation is still sent as identity when the client accepts identity, and\n * answered \"not-acceptable\" when it does not. Responses that already carry an\n * application-supplied Content-Encoding are passed through unchanged and never\n * negotiate. When the client forbids every representation (identity and all\n * supported codings), the outcome is \"not-acceptable\".\n * @param {object} args - Options object.\n * @param {Buffer} args.bodyBuffer - Buffered response body bytes (UTF-8 encoded for string bodies).\n * @param {import(\"../../configuration-types.js\").NormalizedHttpCompressionConfiguration} args.compression - Normalized compression configuration.\n * @param {import(\"./request.js\").default | import(\"./websocket-request.js\").default} args.request - Request object.\n * @param {import(\"./response.js\").default} args.response - Response instance.\n * @returns {Promise<{outcome: \"identity\"} | {outcome: \"compressed\", body: Buffer} | {outcome: \"not-acceptable\"}>} - Compression outcome.\n */\nexport async function applyResponseCompression({bodyBuffer, compression, request, response}) {\n  if (!compression.enabled) return {outcome: \"identity\"}\n\n  // Application-supplied encodings stay application-owned: they are passed through\n  // unchanged and never take part in negotiation failure handling.\n  if (response.getHeader(\"Content-Encoding\").length > 0) return {outcome: \"identity\"}\n\n  const negotiated = negotiateContentEncoding(request.header(\"accept-encoding\"))\n\n  if (\"notAcceptable\" in negotiated) return {outcome: \"not-acceptable\"}\n\n  const cacheControlTokens = response.getHeader(\"Cache-Control\")\n    .flatMap((value) => value.split(\",\"))\n    .map((token) => token.trim().toLowerCase())\n  const contentType = response.getHeader(\"Content-Type\")[0]\n\n  // Automatic security exclusions: credentialed requests (Authorization/Cookie) and\n  // responses carrying credentials (Set-Cookie) or representation validators\n  // (ETag/Digest/Content-Digest) are never transformed — compression could leak\n  // secret-bearing content through a compression oracle, and validators stay\n  // application-owned rather than being recomputed for encoded variants.\n  const transformable = !response.isCompressionDisabled() &&\n    response.getStatusCode() !== 206 &&\n    !request.header(\"range\") &&\n    !request.header(\"authorization\") &&\n    !request.header(\"cookie\") &&\n    response.getHeader(\"Content-Range\").length === 0 &&\n    response.getHeader(\"Set-Cookie\").length === 0 &&\n    response.getHeader(\"ETag\").length === 0 &&\n    response.getHeader(\"Digest\").length === 0 &&\n    response.getHeader(\"Content-Digest\").length === 0 &&\n    !cacheControlTokens.includes(\"no-transform\") &&\n    contentType !== undefined &&\n    isCompressibleContentType(contentType)\n\n  if (!transformable) {\n    // A skipped transformation may still go out as identity when the client accepts\n    // identity; when identity is forbidden, no acceptable representation can be sent.\n    return negotiated.identityAcceptable ? {outcome: \"identity\"} : {outcome: \"not-acceptable\"}\n  }\n\n  // The representation now depends on the request's Accept-Encoding, even when this\n  // particular response ends up identity (missing header, higher-q identity, below threshold).\n  addAcceptEncodingToVary(response)\n\n  if (negotiated.encoding == \"identity\") return {outcome: \"identity\"}\n\n  // Below the threshold the smaller identity representation is sent instead — but only\n  // when identity is acceptable; a client that forbids identity must never be forced\n  // onto an unacceptable representation by the size check.\n  if (bodyBuffer.length < compression.threshold && negotiated.identityAcceptable) return {outcome: \"identity\"}\n\n  const body = negotiated.encoding == \"br\"\n    ? await brotliCompressAsync(bodyBuffer, {params: {[zlib.constants.BROTLI_PARAM_QUALITY]: compression.brotliQuality}})\n    : await gzipAsync(bodyBuffer, {level: compression.gzipLevel})\n\n  response.setHeader(\"Content-Encoding\", negotiated.encoding)\n\n  return {body, outcome: \"compressed\"}\n}\n"]}

package/build/src/http-server/client/response.d.ts

@@ -23,6 +23,10 @@ export default class VelociousHttpServerClientResponse {
      * Headers.
      * @type {Record<string, string[]>} */
     headers: Record<string, string[]>;
+    /**
+     * Whether compression has been disabled for this specific response.
+     * @type {boolean} */
+    compressionDisabled: boolean;
     configuration: import("../../configuration.js").default;
     _requestTimeoutMs: number | undefined;
     _requestTimeoutMsChangeHandler: ((timeoutSeconds: number | undefined) => void) | undefined;
@@ -40,6 +44,29 @@ export default class VelociousHttpServerClientResponse {
      * @returns {void} - No return value.
      */
     setHeader(key: string, value: string): void;
+    /**
+     * Returns every value set for a header, matched case-insensitively.
+     * @param {string} key - Header name.
+     * @returns {string[]} - Header values in insertion order.
+     */
+    getHeader(key: string): string[];
+    /**
+     * Removes every value set for a header, matched case-insensitively.
+     * @param {string} key - Header name.
+     * @returns {void} - No return value.
+     */
+    removeHeader(key: string): void;
+    /**
+     * Disables HTTP response compression for this specific response, even when the
+     * server is configured to compress buffered responses.
+     * @returns {void} - No return value.
+     */
+    disableCompression(): void;
+    /**
+     * Runs is compression disabled.
+     * @returns {boolean} - Whether compression has been disabled for this response.
+     */
+    isCompressionDisabled(): boolean;
     /**
      * Runs get body.
      * @returns {string | Uint8Array | null} - The body.

package/build/src/http-server/client/response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/response.js"],"names":[],"mappings":"AA+EA;IAqBE;;;;OAIG;IACH,+BAFG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;KAClD,EAKA;IA7BD;;4CAEwC;IACxC,MADU,MAAM,GAAG,UAAU,GAAG,IAAI,CACzB;IAEX;;+BAE2B;IAC3B,UADU,MAAM,GAAG,IAAI,CACR;IAEf;;oFAEgF;IAChF,gBADU,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CACvD;IAErB;;0CAEsC;IACtC,SADU,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CACtB;IAQV,wDAAkC;IAClC,sCAAkC;IAClC,kDAwJ0B,MAAM,GAAG,SAAS,KAAK,IAAI,cAxJN;IAGjD;;;;;OAKG;IACH,eAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;OAKG;IACH,eAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,WAFa,MAAM,GAAG,UAAU,GAAG,IAAI,CAQtC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GAAG,UAAU,GACjB,IAAI,CAMhB;IAED;;;OAGG;IACH,eAFa,MAAM,GAAG,IAAI,CAIzB;IAED;;;OAGG;IACH,qBAFa,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAI9E;IAED;;;;;OAKG;IACH,kBAJW,MAAM,eACN,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,GAChE,IAAI,CAMhB;IAED;;;;OAIG;IACH,oBAHW,KAAK,GACH,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,kBAHW,MAAM,GAAG,MAAM,GACb,IAAI,CAYhB;IAFC,+BAA+B;IAC/B,kCAAoE;IAGtE;;;OAGG;IACH,uBAFa,MAAM,GAAG,SAAS,CAI9B;IAED;;;;OAIG;IACH,oCAHW,MAAM,GAAG,SAAS,GAAG,IAAI,GACvB,IAAI,CAYhB;IAED;;;;OAIG;IACH,0CAHW,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,GAC1C,IAAI,CAIhB;CACF"}
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/response.js"],"names":[],"mappings":"AA+EA;IA0BE;;;;OAIG;IACH,+BAFG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;KAClD,EAKA;IAlCD;;4CAEwC;IACxC,MADU,MAAM,GAAG,UAAU,GAAG,IAAI,CACzB;IAEX;;+BAE2B;IAC3B,UADU,MAAM,GAAG,IAAI,CACR;IAEf;;oFAEgF;IAChF,gBADU,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CACvD;IAErB;;0CAEsC;IACtC,SADU,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CACtB;IAEZ;;yBAEqB;IACrB,qBADU,OAAO,CACU;IAQzB,wDAAkC;IAClC,sCAAkC;IAClC,kDA4M0B,MAAM,GAAG,SAAS,KAAK,IAAI,cA5MN;IAGjD;;;;;OAKG;IACH,eAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;OAKG;IACH,eAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,MAAM,EAAE,CAepB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CAUhB;IAED;;;;OAIG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,yBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,WAFa,MAAM,GAAG,UAAU,GAAG,IAAI,CAQtC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GAAG,UAAU,GACjB,IAAI,CAMhB;IAED;;;OAGG;IACH,eAFa,MAAM,GAAG,IAAI,CAIzB;IAED;;;OAGG;IACH,qBAFa,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAI9E;IAED;;;;;OAKG;IACH,kBAJW,MAAM,eACN,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,GAChE,IAAI,CAMhB;IAED;;;;OAIG;IACH,oBAHW,KAAK,GACH,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,kBAHW,MAAM,GAAG,MAAM,GACb,IAAI,CAYhB;IAFC,+BAA+B;IAC/B,kCAAoE;IAGtE;;;OAGG;IACH,uBAFa,MAAM,GAAG,SAAS,CAI9B;IAED;;;;OAIG;IACH,oCAHW,MAAM,GAAG,SAAS,GAAG,IAAI,GACvB,IAAI,CAYhB;IAED;;;;OAIG;IACH,0CAHW,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,GAC1C,IAAI,CAIhB;CACF"}

package/build/src/http-server/client/response.js

@@ -91,6 +91,10 @@ export default class VelociousHttpServerClientResponse {
      * Headers.
      * @type {Record<string, string[]>} */
     headers = {};
+    /**
+     * Whether compression has been disabled for this specific response.
+     * @type {boolean} */
+    compressionDisabled = false;
     /**
      * Runs constructor.
      * @param {object} args - Options object.
@@ -122,6 +126,50 @@ export default class VelociousHttpServerClientResponse {
     setHeader(key, value) {
         this.headers[key] = [value];
     }
+    /**
+     * Returns every value set for a header, matched case-insensitively.
+     * @param {string} key - Header name.
+     * @returns {string[]} - Header values in insertion order.
+     */
+    getHeader(key) {
+        const lowerCaseKey = key.toLowerCase();
+        /** @type {string[]} */
+        const values = [];
+        for (const headerKey in this.headers) {
+            if (headerKey.toLowerCase() == lowerCaseKey) {
+                values.push(...this.headers[headerKey]);
+            }
+        }
+        return values;
+    }
+    /**
+     * Removes every value set for a header, matched case-insensitively.
+     * @param {string} key - Header name.
+     * @returns {void} - No return value.
+     */
+    removeHeader(key) {
+        const lowerCaseKey = key.toLowerCase();
+        for (const headerKey in this.headers) {
+            if (headerKey.toLowerCase() == lowerCaseKey) {
+                delete this.headers[headerKey];
+            }
+        }
+    }
+    /**
+     * Disables HTTP response compression for this specific response, even when the
+     * server is configured to compress buffered responses.
+     * @returns {void} - No return value.
+     */
+    disableCompression() {
+        this.compressionDisabled = true;
+    }
+    /**
+     * Runs is compression disabled.
+     * @returns {boolean} - Whether compression has been disabled for this response.
+     */
+    isCompressionDisabled() {
+        return this.compressionDisabled;
+    }
     /**
      * Runs get body.
      * @returns {string | Uint8Array | null} - The body.
@@ -240,4 +288,4 @@ export default class VelociousHttpServerClientResponse {
         this._requestTimeoutMsChangeHandler = handler;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../../../src/http-server/client/response.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Named status aliases.\n * @type {Record<string, number>} */\nconst NAMED_STATUS_ALIASES = {\n  \"success\": 200,\n  \"not-found\": 404,\n  \"internal-server-error\": 500\n}\n\n/**\n * Standard status messages.\n * @type {Record<number, string>} */\nconst STANDARD_STATUS_MESSAGES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal server error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}\n\nexport default class VelociousHttpServerClientResponse {\n  /**\n   * Body.\n   * @type {string | Uint8Array | null} */\n  body = null\n\n  /**\n   * File path.\n   * @type {string | null} */\n  filePath = null\n\n  /**\n   * File response completion callback.\n   * @type {((result: \"completed\" | \"aborted\") => void | Promise<void>) | null} */\n  fileOnFinished = null\n\n  /**\n   * Headers.\n   * @type {Record<string, string[]>} */\n  headers = {}\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   */\n  constructor({configuration}) {\n    this.configuration = configuration\n    this._requestTimeoutMs = undefined\n    this._requestTimeoutMsChangeHandler = undefined\n  }\n\n  /**\n   * Runs add header.\n   * @param {string} key - Key.\n   * @param {string} value - Value to use.\n   * @returns {void} - No return value.\n   */\n  addHeader(key, value) {\n    if (!(key in this.headers)) {\n      this.headers[key] = []\n    }\n\n    this.headers[key].push(value)\n  }\n\n  /**\n   * Runs set header.\n   * @param {string} key - Key.\n   * @param {string} value - Value to use.\n   * @returns {void} - No return value.\n   */\n  setHeader(key, value) {\n    this.headers[key] = [value]\n  }\n\n  /**\n   * Runs get body.\n   * @returns {string | Uint8Array | null} - The body.\n   */\n  getBody() {\n    if (this.body !== undefined) {\n      return this.body\n    }\n\n    throw new Error(\"No body has been set\")\n  }\n\n  /**\n   * Runs get status code.\n   * @returns {number} - The status code.\n   */\n  getStatusCode() {\n    return this.statusCode || 200\n  }\n\n  /**\n   * Runs get status message.\n   * @returns {string} - The status message.\n   */\n  getStatusMessage() {\n    return this.statusMessage || \"OK\"\n  }\n\n  /**\n   * Runs set body.\n   * @param {string | Uint8Array} value - Value to use.\n   * @returns {void} - No return value.\n   */\n  setBody(value) {\n    this.filePath = null\n    this.fileOnFinished = null\n    this.body = value\n  }\n\n  /**\n   * Runs get file path.\n   * @returns {string | null} - File path.\n   */\n  getFilePath() {\n    return this.filePath\n  }\n\n  /**\n   * Gets the file response completion callback.\n   * @returns {((result: \"completed\" | \"aborted\") => void | Promise<void>) | null} - File response completion callback.\n   */\n  getFileOnFinished() {\n    return this.fileOnFinished\n  }\n\n  /**\n   * Runs set file path.\n   * @param {string} path - File path.\n   * @param {((result: \"completed\" | \"aborted\") => void | Promise<void>) | null} [onFinished] - Completion callback.\n   * @returns {void} - No return value.\n   */\n  setFilePath(path, onFinished = null) {\n    this.filePath = path\n    this.fileOnFinished = onFinished\n    this.body = null\n  }\n\n  /**\n   * Runs set error body.\n   * @param {Error} error - Error instance.\n   * @returns {void} - No return value.\n   */\n  setErrorBody(error) {\n    this.setHeader(\"Content-Type\", \"text/plain; charset=UTF-8\")\n    this.setBody(`${error.message}\\n\\n${error.stack}`)\n  }\n\n  /**\n   * Accepts a numeric HTTP status code (e.g. `422`) or one of the\n   * named aliases (`\"success\"`, `\"not-found\"`, `\"internal-server-error\"`).\n   * Numeric inputs in the standard 1xx-5xx range resolve their own\n   * status messages from the IANA registry; aliases keep the\n   * back-compatible code mapping.\n   * @param {number | string} status - Status.\n   * @returns {void} - No return value.\n   */\n  setStatus(status) {\n    const aliasCode = NAMED_STATUS_ALIASES[String(status)]\n    const numericStatus = aliasCode ?? Number(status)\n\n    if (!Number.isInteger(numericStatus) || numericStatus < 100 || numericStatus > 599) {\n      throw new Error(`Unhandled status: ${status}`)\n    }\n\n    this.statusCode = numericStatus\n    this.statusMessage = STANDARD_STATUS_MESSAGES[numericStatus] || \"OK\"\n  }\n\n  /**\n   * Runs get request timeout ms.\n   * @returns {number | undefined} - Request timeout in seconds.\n   */\n  getRequestTimeoutMs() {\n    return this._requestTimeoutMs\n  }\n\n  /**\n   * Runs set request timeout ms.\n   * @param {number | undefined | null} timeoutSeconds - Timeout in seconds.\n   * @returns {void} - No return value.\n   */\n  setRequestTimeoutMs(timeoutSeconds) {\n    if (typeof timeoutSeconds === \"number\" && Number.isFinite(timeoutSeconds)) {\n      this._requestTimeoutMs = timeoutSeconds\n    } else {\n      this._requestTimeoutMs = undefined\n    }\n\n    if (this._requestTimeoutMsChangeHandler) {\n      this._requestTimeoutMsChangeHandler(this._requestTimeoutMs)\n    }\n  }\n\n  /**\n   * Runs set request timeout ms change handler.\n   * @param {(timeoutSeconds: number | undefined) => void} handler - Change handler.\n   * @returns {void} - No return value.\n   */\n  setRequestTimeoutMsChangeHandler(handler) {\n    this._requestTimeoutMsChangeHandler = handler\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../../../src/http-server/client/response.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Named status aliases.\n * @type {Record<string, number>} */\nconst NAMED_STATUS_ALIASES = {\n  \"success\": 200,\n  \"not-found\": 404,\n  \"internal-server-error\": 500\n}\n\n/**\n * Standard status messages.\n * @type {Record<number, string>} */\nconst STANDARD_STATUS_MESSAGES = {\n  100: \"Continue\",\n  101: \"Switching Protocols\",\n  102: \"Processing\",\n  103: \"Early Hints\",\n  200: \"OK\",\n  201: \"Created\",\n  202: \"Accepted\",\n  203: \"Non-Authoritative Information\",\n  204: \"No Content\",\n  205: \"Reset Content\",\n  206: \"Partial Content\",\n  207: \"Multi-Status\",\n  208: \"Already Reported\",\n  226: \"IM Used\",\n  300: \"Multiple Choices\",\n  301: \"Moved Permanently\",\n  302: \"Found\",\n  303: \"See Other\",\n  304: \"Not Modified\",\n  305: \"Use Proxy\",\n  307: \"Temporary Redirect\",\n  308: \"Permanent Redirect\",\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Payload Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Entity\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal server error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n}\n\nexport default class VelociousHttpServerClientResponse {\n  /**\n   * Body.\n   * @type {string | Uint8Array | null} */\n  body = null\n\n  /**\n   * File path.\n   * @type {string | null} */\n  filePath = null\n\n  /**\n   * File response completion callback.\n   * @type {((result: \"completed\" | \"aborted\") => void | Promise<void>) | null} */\n  fileOnFinished = null\n\n  /**\n   * Headers.\n   * @type {Record<string, string[]>} */\n  headers = {}\n\n  /**\n   * Whether compression has been disabled for this specific response.\n   * @type {boolean} */\n  compressionDisabled = false\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   */\n  constructor({configuration}) {\n    this.configuration = configuration\n    this._requestTimeoutMs = undefined\n    this._requestTimeoutMsChangeHandler = undefined\n  }\n\n  /**\n   * Runs add header.\n   * @param {string} key - Key.\n   * @param {string} value - Value to use.\n   * @returns {void} - No return value.\n   */\n  addHeader(key, value) {\n    if (!(key in this.headers)) {\n      this.headers[key] = []\n    }\n\n    this.headers[key].push(value)\n  }\n\n  /**\n   * Runs set header.\n   * @param {string} key - Key.\n   * @param {string} value - Value to use.\n   * @returns {void} - No return value.\n   */\n  setHeader(key, value) {\n    this.headers[key] = [value]\n  }\n\n  /**\n   * Returns every value set for a header, matched case-insensitively.\n   * @param {string} key - Header name.\n   * @returns {string[]} - Header values in insertion order.\n   */\n  getHeader(key) {\n    const lowerCaseKey = key.toLowerCase()\n\n    /** @type {string[]} */\n    const values = []\n\n    for (const headerKey in this.headers) {\n      if (headerKey.toLowerCase() == lowerCaseKey) {\n        values.push(...this.headers[headerKey])\n      }\n    }\n\n    return values\n  }\n\n  /**\n   * Removes every value set for a header, matched case-insensitively.\n   * @param {string} key - Header name.\n   * @returns {void} - No return value.\n   */\n  removeHeader(key) {\n    const lowerCaseKey = key.toLowerCase()\n\n    for (const headerKey in this.headers) {\n      if (headerKey.toLowerCase() == lowerCaseKey) {\n        delete this.headers[headerKey]\n      }\n    }\n  }\n\n  /**\n   * Disables HTTP response compression for this specific response, even when the\n   * server is configured to compress buffered responses.\n   * @returns {void} - No return value.\n   */\n  disableCompression() {\n    this.compressionDisabled = true\n  }\n\n  /**\n   * Runs is compression disabled.\n   * @returns {boolean} - Whether compression has been disabled for this response.\n   */\n  isCompressionDisabled() {\n    return this.compressionDisabled\n  }\n\n  /**\n   * Runs get body.\n   * @returns {string | Uint8Array | null} - The body.\n   */\n  getBody() {\n    if (this.body !== undefined) {\n      return this.body\n    }\n\n    throw new Error(\"No body has been set\")\n  }\n\n  /**\n   * Runs get status code.\n   * @returns {number} - The status code.\n   */\n  getStatusCode() {\n    return this.statusCode || 200\n  }\n\n  /**\n   * Runs get status message.\n   * @returns {string} - The status message.\n   */\n  getStatusMessage() {\n    return this.statusMessage || \"OK\"\n  }\n\n  /**\n   * Runs set body.\n   * @param {string | Uint8Array} value - Value to use.\n   * @returns {void} - No return value.\n   */\n  setBody(value) {\n    this.filePath = null\n    this.fileOnFinished = null\n    this.body = value\n  }\n\n  /**\n   * Runs get file path.\n   * @returns {string | null} - File path.\n   */\n  getFilePath() {\n    return this.filePath\n  }\n\n  /**\n   * Gets the file response completion callback.\n   * @returns {((result: \"completed\" | \"aborted\") => void | Promise<void>) | null} - File response completion callback.\n   */\n  getFileOnFinished() {\n    return this.fileOnFinished\n  }\n\n  /**\n   * Runs set file path.\n   * @param {string} path - File path.\n   * @param {((result: \"completed\" | \"aborted\") => void | Promise<void>) | null} [onFinished] - Completion callback.\n   * @returns {void} - No return value.\n   */\n  setFilePath(path, onFinished = null) {\n    this.filePath = path\n    this.fileOnFinished = onFinished\n    this.body = null\n  }\n\n  /**\n   * Runs set error body.\n   * @param {Error} error - Error instance.\n   * @returns {void} - No return value.\n   */\n  setErrorBody(error) {\n    this.setHeader(\"Content-Type\", \"text/plain; charset=UTF-8\")\n    this.setBody(`${error.message}\\n\\n${error.stack}`)\n  }\n\n  /**\n   * Accepts a numeric HTTP status code (e.g. `422`) or one of the\n   * named aliases (`\"success\"`, `\"not-found\"`, `\"internal-server-error\"`).\n   * Numeric inputs in the standard 1xx-5xx range resolve their own\n   * status messages from the IANA registry; aliases keep the\n   * back-compatible code mapping.\n   * @param {number | string} status - Status.\n   * @returns {void} - No return value.\n   */\n  setStatus(status) {\n    const aliasCode = NAMED_STATUS_ALIASES[String(status)]\n    const numericStatus = aliasCode ?? Number(status)\n\n    if (!Number.isInteger(numericStatus) || numericStatus < 100 || numericStatus > 599) {\n      throw new Error(`Unhandled status: ${status}`)\n    }\n\n    this.statusCode = numericStatus\n    this.statusMessage = STANDARD_STATUS_MESSAGES[numericStatus] || \"OK\"\n  }\n\n  /**\n   * Runs get request timeout ms.\n   * @returns {number | undefined} - Request timeout in seconds.\n   */\n  getRequestTimeoutMs() {\n    return this._requestTimeoutMs\n  }\n\n  /**\n   * Runs set request timeout ms.\n   * @param {number | undefined | null} timeoutSeconds - Timeout in seconds.\n   * @returns {void} - No return value.\n   */\n  setRequestTimeoutMs(timeoutSeconds) {\n    if (typeof timeoutSeconds === \"number\" && Number.isFinite(timeoutSeconds)) {\n      this._requestTimeoutMs = timeoutSeconds\n    } else {\n      this._requestTimeoutMs = undefined\n    }\n\n    if (this._requestTimeoutMsChangeHandler) {\n      this._requestTimeoutMsChangeHandler(this._requestTimeoutMs)\n    }\n  }\n\n  /**\n   * Runs set request timeout ms change handler.\n   * @param {(timeoutSeconds: number | undefined) => void} handler - Change handler.\n   * @returns {void} - No return value.\n   */\n  setRequestTimeoutMsChangeHandler(handler) {\n    this._requestTimeoutMsChangeHandler = handler\n  }\n}\n"]}

package/build/src/http-server/websocket-events-host.d.ts

@@ -7,13 +7,21 @@ export class VelociousHttpServerWebsocketEventsHost {
      * Broadcast handlers grouped by the configuration that owns them.
      * @type {Map<import("../configuration.js").default, Set<import("./worker-handler/index.js").default>>} */
     broadcastHandlersByConfiguration: Map<import("../configuration.js").default, Set<import("./worker-handler/index.js").default>>;
-    publishQueue: Promise<void>;
     /**
-     * Returns a promise that resolves when all pending publish/broadcast
-     * operations have completed (including event-log persistence). Useful
-     * when a request handler needs to guarantee its broadcast is persisted
-     * before responding — without this, the HTTP response can return before
-     * the async event-log write finishes.
+     * Ordered publish tails keyed by channel. Each channel persists and
+     * dispatches behind its own tail so a slow channel cannot head-of-line
+     * block unrelated channels. A rejected tail stays in the map so the
+     * channel remains poisoned and observable.
+     * @type {Map<string, Promise<void>>} */
+    publishQueuesByChannel: Map<string, Promise<void>>;
+    /**
+     * Returns a promise that settles when every channel tail pending at call
+     * time has settled (including event-log persistence). Useful when a
+     * request handler needs to guarantee its broadcast is persisted before
+     * responding — without this, the HTTP response can return before the
+     * async event-log write finishes. This is a snapshot barrier: work
+     * enqueued after the snapshot is not awaited, and the first rejection in
+     * snapshot order is rethrown after every snapshotted tail has settled.
      * @returns {Promise<void>}
      */
     awaitPendingBroadcasts(): Promise<void>;
@@ -48,13 +56,22 @@ export class VelociousHttpServerWebsocketEventsHost {
         configuration: import("../configuration.js").default;
     }): void;
     /**
-     * Runs queue publish.
-     * @param {() => Promise<void>} callback - Publish work to run in order.
-     * @param {string} errorMessage - Message logged when publish work fails.
-     * @param {import("../configuration.js").default} [originatingConfiguration] - Configuration whose context owns the work.
+     * Queues publish work behind the channel's own ordered tail so only work
+     * for the same channel serializes — a slow or failed channel never
+     * head-of-line blocks unrelated channels.
+     * @param {object} args - Options object.
+     * @param {() => Promise<void>} args.callback - Publish work to run in channel order.
+     * @param {string} args.channel - Channel whose ordered tail the work chains onto.
+     * @param {string} args.errorMessage - Message logged when publish work fails.
+     * @param {import("../configuration.js").default} [args.originatingConfiguration] - Configuration whose context owns the work.
      * @returns {void}
      */
-    _queuePublish(callback: () => Promise<void>, errorMessage: string, originatingConfiguration?: import("../configuration.js").default): void;
+    _queuePublish({ callback, channel, errorMessage, originatingConfiguration }: {
+        callback: () => Promise<void>;
+        channel: string;
+        errorMessage: string;
+        originatingConfiguration?: import("../configuration.js").default | undefined;
+    }): void;
     /**
      * Runs persist v2 event if needed.
      * @param {object} args - Options.

package/build/src/http-server/websocket-events-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-events-host.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-events-host.js"],"names":[],"mappings":"AAIA;IAEI;;kEAE8D;IAC9D,UADU,GAAG,CAAC,OAAO,2BAA2B,EAAE,OAAO,CAAC,CACjC;IACzB;;8GAE0G;IAC1G,kCADU,GAAG,CAAC,OAAO,qBAAqB,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,2BAA2B,EAAE,OAAO,CAAC,CAAC,CACrD;IACjD,4BAAqC;IAGvC;;;;;;;OAOG;IACH,0BAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,kBAHW,OAAO,2BAA2B,EAAE,OAAO,GACzC,MAAM,IAAI,CAqBtB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,GAAG,MAAM,eACf,OAAC,GACC,IAAI,CAqBhB;IAED;;;;;;;;;;OAUG;IACH,+DANG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;QAC2C,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,IAAI,CA0BhB;IAED;;;;;;OAMG;IACH,wBALW,MAAM,OAAO,CAAC,IAAI,CAAC,gBACnB,MAAM,6BACN,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAkBhB;IAED;;;;;;;OAOG;IACH,0DALG;QAAgB,IAAI,EAAZ,OAAC;QACY,OAAO,EAApB,MAAM;QACsC,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;OAMG;IACH,4CAJG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;KACT,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;;OAOG;IACH,kEALG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;QAC4C,aAAa;KAClE,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAmB3D;CACF;;AAED,0EAAwE"}
+{"version":3,"file":"websocket-events-host.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-events-host.js"],"names":[],"mappings":"AAIA;IAEI;;kEAE8D;IAC9D,UADU,GAAG,CAAC,OAAO,2BAA2B,EAAE,OAAO,CAAC,CACjC;IACzB;;8GAE0G;IAC1G,kCADU,GAAG,CAAC,OAAO,qBAAqB,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,2BAA2B,EAAE,OAAO,CAAC,CAAC,CACrD;IACjD;;;;;4CAKwC;IACxC,wBADU,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CACG;IAGzC;;;;;;;;;OASG;IACH,0BAFa,OAAO,CAAC,IAAI,CAAC,CASzB;IAED;;;;OAIG;IACH,kBAHW,OAAO,2BAA2B,EAAE,OAAO,GACzC,MAAM,IAAI,CAqBtB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,GAAG,MAAM,eACf,OAAC,GACC,IAAI,CAyBhB;IAED;;;;;;;;;;OAUG;IACH,+DANG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;QAC2C,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,IAAI,CAgChB;IAED;;;;;;;;;;OAUG;IACH,6EANG;QAAkC,QAAQ,EAAlC,MAAM,OAAO,CAAC,IAAI,CAAC;QACN,OAAO,EAApB,MAAM;QACO,YAAY,EAAzB,MAAM;QACuC,wBAAwB;KAC7E,GAAU,IAAI,CAkChB;IAED;;;;;;;OAOG;IACH,0DALG;QAAgB,IAAI,EAAZ,OAAC;QACY,OAAO,EAApB,MAAM;QACsC,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;OAMG;IACH,4CAJG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;KACT,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;;OAOG;IACH,kEALG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;QAC4C,aAAa;KAClE,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAmB3D;CACF;;AAED,0EAAwE"}