@travetto/web 7.1.4 → 8.0.0-alpha.0

package/src/util/body.ts

@@ -1,72 +1,74 @@
 import { TextDecoder } from 'node:util';
-import { Readable } from 'node:stream';
 
-import { type Any, BinaryUtil, castTo, hasToJSON, JSONUtil, Util } from '@travetto/runtime';
+import { type BinaryType, BinaryUtil, type BinaryArray, castTo, Util, CodecUtil, hasToJSON, BinaryMetadataUtil, JSONUtil } from '@travetto/runtime';
 
-import type { WebBinaryBody, WebMessage } from '../types/message.ts';
+import type { WebMessage } from '../types/message.ts';
 import { WebHeaders } from '../types/headers.ts';
 import { WebError } from '../types/error.ts';
 
-const WebRawStreamSymbol = Symbol();
+const WebRawBinarySymbol = Symbol();
+
+const NULL_TERMINATOR = BinaryUtil.makeBinaryArray(0);
 
 /**
  * Utility classes for supporting web body operations
  */
 export class WebBodyUtil {
 
+  /** Get Metadata Headers */
+  static getMetadataHeaders(value: BinaryType): [string, string][] {
+    const metadata = BinaryMetadataUtil.read(value);
+    const length = BinaryMetadataUtil.readLength(metadata);
+
+    const result = [
+      ['Content-Type', metadata.contentType],
+      ['Content-Length', length],
+      ['Content-Encoding', metadata.contentEncoding],
+      ['Cache-Control', metadata.cacheControl],
+      ['Content-Language', metadata.contentLanguage],
+      ...(metadata.range ? [['Accept-Ranges', 'bytes']] : []),
+      ...(metadata.range ? [['Content-Range', `bytes ${metadata.range.start}-${metadata.range.end}/${metadata.size}`]] : []),
+      ...(metadata.filename ? [['Content-Disposition', `attachment; filename="${metadata.filename}"`]] : [])
+    ]
+      .map((pair) => [pair[0], pair[1]?.toString()])
+      .filter((pair): pair is [string, string] => pair[1] !== undefined);
+
+    return result;
+  }
+
   /**
    * Generate multipart body
    */
-  static async * buildMultiPartBody(form: FormData, boundary: string): AsyncIterable<string | Buffer> {
-    const nl = '\r\n';
-    for (const [key, value] of form.entries()) {
-      const data = value.slice();
-      const filename = data instanceof File ? data.name : undefined;
-      const size = data instanceof Blob ? data.size : data.length;
-      const type = data instanceof Blob ? data.type : undefined;
-      yield `--${boundary}${nl}`;
-      yield `Content-Disposition: form-data; name="${key}"; filename="${filename ?? key}"${nl}`;
-      yield `Content-Length: ${size}${nl}`;
-      if (type) {
-        yield `Content-Type: ${type}${nl}`;
+  static async * buildMultiPartBody(form: FormData, boundary: string): AsyncIterable<BinaryArray> {
+    const bytes = (value: string = '', suffix = '\r\n'): BinaryArray => CodecUtil.fromUTF8String(`${value}${suffix}`);
+    for (const [key, item] of form.entries()) {
+      yield bytes(`--${boundary}`);
+      const binaryValue = typeof item === 'string' ? CodecUtil.fromUTF8String(item) : item.slice();
+
+      // Headers
+      if (typeof item == 'string') {
+        BinaryMetadataUtil.write(binaryValue, { size: item.length });
       }
-      yield nl;
-      if (data instanceof Blob) {
-        for await (const chunk of data.stream()) {
-          yield chunk;
-        }
-      } else {
-        yield data;
+
+      if (item instanceof File) {
+        yield bytes(`Content-Disposition: form-data; name="${key}"; filename="${item.name || key}"`);
       }
-      yield nl;
-    }
-    yield `--${boundary}--${nl}`;
-  }
 
-  /** Get Blob Headers */
-  static getBlobHeaders(value: Blob): [string, string][] {
-    const meta = BinaryUtil.getBlobMeta(value);
-
-    const toAdd: [string, string | undefined][] = [
-      ['Content-Type', value.type],
-      ['Content-Length', `${value.size}`],
-      ['Content-Encoding', meta?.contentEncoding],
-      ['Cache-Control', meta?.cacheControl],
-      ['Content-Language', meta?.contentLanguage],
-    ];
-
-    if (meta?.range) {
-      toAdd.push(
-        ['Accept-Ranges', 'bytes'],
-        ['Content-Range', `bytes ${meta.range.start}-${meta.range.end}/${meta.size}`],
-      );
-    }
+      for (const [header, value] of WebBodyUtil.getMetadataHeaders(binaryValue)) {
+        if (header.startsWith('Content-') && header !== 'Content-Disposition') {
+          yield bytes(`${header}: ${value}`);
+        }
+      }
 
-    if (value instanceof File && value.name) {
-      toAdd.push(['Content-disposition', `attachment; filename="${value.name}"`]);
+      yield bytes();
+      if (binaryValue instanceof Blob) {
+        yield* BinaryUtil.toBinaryStream(binaryValue);
+      } else {
+        yield binaryValue;
+      }
+      yield bytes();
     }
-
-    return toAdd.filter((pair): pair is [string, string] => !!pair[1]);
+    yield bytes(`--${boundary}--`);
   }
 
   /**
@@ -89,49 +91,35 @@ export class WebBodyUtil {
   /**
    * Convert an existing web message to a binary web message
    */
-  static toBinaryMessage(message: WebMessage): Omit<WebMessage<WebBinaryBody>, 'context'> {
-    const body = message.body;
-    if (Buffer.isBuffer(body) || BinaryUtil.isReadable(body)) {
-      return castTo(message);
-    }
+  static toBinaryMessage(message: WebMessage): Omit<WebMessage<BinaryType>, 'context'> {
+    const { body } = message;
+    const out: Omit<WebMessage<BinaryType>, 'context'> = { headers: new WebHeaders(message.headers), body: null! };
 
-    const out: Omit<WebMessage<WebBinaryBody>, 'context'> = { headers: new WebHeaders(message.headers), body: null! };
-    if (body instanceof Blob) {
-      for (const [key, value] of this.getBlobHeaders(body)) {
+    if (BinaryUtil.isBinaryType(body)) {
+      for (const [key, value] of this.getMetadataHeaders(body)) {
         out.headers.set(key, value);
       }
-      out.body = Readable.fromWeb(body.stream());
+      out.body = body;
     } else if (body instanceof FormData) {
       const boundary = `${'-'.repeat(24)}-multipart-${Util.uuid()}`;
       out.headers.set('Content-Type', `multipart/form-data; boundary=${boundary}`);
-      out.body = Readable.from(this.buildMultiPartBody(body, boundary));
-    } else if (BinaryUtil.isReadableStream(body)) {
-      out.body = Readable.fromWeb(body);
-    } else if (BinaryUtil.isAsyncIterable(body)) {
-      out.body = Readable.from(body);
-    } else if (body === null || body === undefined) {
-      out.body = Buffer.alloc(0);
-    } else if (BinaryUtil.isArrayBuffer(body)) {
-      out.body = Buffer.from(body);
+      out.body = this.buildMultiPartBody(body, boundary);
     } else {
-      let text: string;
+      let text: BinaryArray;
       if (typeof body === 'string') {
-        text = body;
+        text = CodecUtil.fromUTF8String(body);
       } else if (hasToJSON(body)) {
-        text = JSON.stringify(body.toJSON());
+        text = JSONUtil.toBinaryArray(body.toJSON());
       } else if (body instanceof Error) {
-        text = JSON.stringify({ message: body.message });
+        text = JSONUtil.toBinaryArray({ message: body.message });
       } else {
-        text = JSON.stringify(body);
+        text = JSONUtil.toBinaryArray(body);
       }
-      out.body = Buffer.from(text, 'utf-8');
-    }
-
-    if (Buffer.isBuffer(out.body)) {
-      out.headers.set('Content-Length', `${out.body.byteLength}`);
+      out.headers.set('Content-Length', `${text.byteLength}`);
+      out.body = text;
     }
 
-    out.headers.setIfAbsent('Content-Type', this.defaultContentType(message.body));
+    out.headers.setIfAbsent('Content-Type', this.defaultContentType(body));
 
     return castTo(out);
   }
@@ -139,9 +127,9 @@ export class WebBodyUtil {
   /**
    * Set body and mark as unprocessed
    */
-  static markRaw(body: WebBinaryBody | undefined): typeof body {
+  static markRawBinary(body: BinaryType | undefined): typeof body {
     if (body) {
-      Object.defineProperty(body, WebRawStreamSymbol, { value: body });
+      Object.defineProperty(body, WebRawBinarySymbol, { value: body });
     }
     return body;
   }
@@ -149,9 +137,8 @@ export class WebBodyUtil {
   /**
    * Is the input raw
    */
-  static isRaw(body: unknown): body is WebBinaryBody {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return !!body && ((Buffer.isBuffer(body) || BinaryUtil.isReadable(body)) && (body as Any)[WebRawStreamSymbol] === body);
+  static isRawBinary(body: unknown): body is BinaryType {
+    return BinaryUtil.isBinaryType(body) && castTo<{ [WebRawBinarySymbol]: unknown }>(body)[WebRawBinarySymbol] === body;
   }
 
   /**
@@ -160,7 +147,7 @@ export class WebBodyUtil {
   static parseBody(type: string, body: string): unknown {
     switch (type) {
       case 'text': return body;
-      case 'json': return JSONUtil.parseSafe(body);
+      case 'json': return JSONUtil.fromUTF8(body);
       case 'form': return Object.fromEntries(new URLSearchParams(body));
     }
   }
@@ -168,8 +155,8 @@ export class WebBodyUtil {
   /**
    * Read text from an input source
    */
-  static async readText(input: Readable | Buffer, limit: number, encoding?: string): Promise<{ text: string, read: number }> {
-    encoding ??= (Buffer.isBuffer(input) ? undefined : input.readableEncoding) ?? 'utf-8';
+  static async readText(input: BinaryType, limit: number, encoding?: string): Promise<{ text: string, read: number }> {
+    encoding ??= CodecUtil.detectEncoding(input) ?? 'utf-8';
 
     let decoder: TextDecoder;
     try {
@@ -178,26 +165,26 @@ export class WebBodyUtil {
       throw WebError.for('Specified Encoding Not Supported', 415, { encoding });
     }
 
-    if (Buffer.isBuffer(input)) {
+    if (BinaryUtil.isBinaryArray(input)) {
       if (input.byteLength > limit) {
         throw WebError.for('Request Entity Too Large', 413, { received: input.byteLength, limit });
       }
       return { text: decoder.decode(input), read: input.byteLength };
     }
 
-    let received = Buffer.isBuffer(input) ? input.byteOffset : 0;
+    let received = 0;
     const all: string[] = [];
 
     try {
-      for await (const chunk of castTo<AsyncIterable<string | Buffer>>(input.iterator({ destroyOnReturn: false }))) {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8');
-        received += buffer.byteLength;
+      for await (const chunk of BinaryUtil.toBinaryStream(input)) {
+        const bytes = CodecUtil.readUtf8Chunk(chunk);
+        received += bytes.byteLength;
         if (received > limit) {
           throw WebError.for('Request Entity Too Large', 413, { received, limit });
         }
-        all.push(decoder.decode(buffer, { stream: true }));
+        all.push(decoder.decode(bytes, { stream: true }));
       }
-      all.push(decoder.decode(Buffer.alloc(0), { stream: false }));
+      all.push(decoder.decode(NULL_TERMINATOR, { stream: false }));
       return { text: all.join(''), read: received };
     } catch (error) {
       if (error instanceof Error && error.name === 'AbortError') {

package/src/util/common.ts

@@ -1,4 +1,4 @@
-import { AppError, type ErrorCategory, Util } from '@travetto/runtime';
+import { RuntimeError, type ErrorCategory, Util } from '@travetto/runtime';
 
 import { WebResponse } from '../types/response.ts';
 import type { WebRequest } from '../types/request.ts';
@@ -116,8 +116,8 @@ export class WebCommonUtil {
 
     const body = error instanceof Error ? error :
       (!!error && typeof error === 'object' && ('message' in error && typeof error.message === 'string')) ?
-        new AppError(error.message, { details: error }) :
-        new AppError(`${error}`);
+        new RuntimeError(error.message, { details: error }) :
+        new RuntimeError(`${error}`);
 
     const webError: Error & Partial<WebError> = body;
     const statusCode = webError.details?.statusCode ?? ERROR_CATEGORY_STATUS[webError.category!] ?? 500;

package/src/util/cookie.ts

@@ -1,4 +1,4 @@
-import { AppError } from '@travetto/runtime';
+import { RuntimeError } from '@travetto/runtime';
 
 import type { Cookie, CookieGetOptions, CookieSetOptions } from '../types/cookie.ts';
 import { KeyGrip } from './keygrip.ts';
@@ -7,40 +7,43 @@ import { WebHeaderUtil } from './header.ts';
 const pairText = (cookie: Cookie): string => `${cookie.name}=${cookie.value}`;
 const pair = (key: string, value: unknown): string => `${key}=${value}`;
 
-type CookieJarOptions = { keys?: string[] } & CookieSetOptions;
+type CookieJarOptions = CookieSetOptions;
 
 export class CookieJar {
 
-  #grip?: KeyGrip;
+  #grip: KeyGrip;
   #cookies: Record<string, Cookie> = {};
   #setOptions: CookieSetOptions = {};
   #deleteOptions: CookieSetOptions = { maxAge: 0, expires: undefined };
 
-  constructor({ keys, ...options }: CookieJarOptions = {}) {
-    this.#grip = keys?.length ? new KeyGrip(keys) : undefined;
+  constructor(options: CookieJarOptions = {}, keys?: string[] | KeyGrip) {
+    this.#grip = (keys instanceof KeyGrip ? keys : new KeyGrip(keys ?? []));
     this.#setOptions = {
       secure: false,
       path: '/',
-      signed: !!keys?.length,
       ...options,
     };
   }
 
-  #exportCookie(cookie: Cookie, response?: boolean): string[] {
+  get shouldSign(): boolean {
+    return this.#setOptions.signed ?? this.#grip.active;
+  }
+
+  async export(cookie: Cookie, response?: boolean): Promise<string[]> {
     const suffix = response ? WebHeaderUtil.buildCookieSuffix(cookie) : null;
     const payload = pairText(cookie);
     const out = suffix ? [[payload, ...suffix].join(';')] : [payload];
     if (cookie.signed) {
-      const sigPair = pair(`${cookie.name}.sig`, this.#grip!.sign(payload));
+      const sigPair = pair(`${cookie.name}.sig`, await this.#grip.sign(payload));
       out.push(suffix ? [sigPair, ...suffix].join(';') : sigPair);
     }
     return out;
   }
 
-  import(cookies: Cookie[]): this {
+  async import(cookies: Cookie[]): Promise<void> {
     const signatures: Record<string, string> = {};
     for (const cookie of cookies) {
-      if (this.#setOptions.signed && cookie.name.endsWith('.sig')) {
+      if (this.shouldSign && cookie.name.endsWith('.sig')) {
         signatures[cookie.name.replace(/[.]sig$/, '')] = cookie.value!;
       } else {
         this.#cookies[cookie.name] = { signed: false, ...cookie };
@@ -55,19 +58,18 @@ export class CookieJar {
       cookie.signed = true;
 
       const computed = pairText(cookie);
-      const index = this.#grip!.index(computed, value);
+      const result = await this.#grip.isValid(computed, value);
 
-      if (index < 0) {
+      if (result === 'invalid') {
         delete this.#cookies[name];
-      } else if (index >= 1) {
+      } else if (result === 'stale') {
         cookie.response = true;
       }
     }
-    return this;
   }
 
   has(name: string, options: CookieGetOptions = {}): boolean {
-    const needSigned = options.signed ?? this.#setOptions.signed;
+    const needSigned = options.signed ?? this.shouldSign;
     return name in this.#cookies && this.#cookies[name].signed === needSigned;
   }
 
@@ -78,45 +80,52 @@ export class CookieJar {
   }
 
   set(cookie: Cookie): void {
-    const alias = this.#cookies[cookie.name] = {
+    const alias = {
       ...this.#setOptions,
       ...cookie,
       response: true,
       ...(cookie.value === null || cookie.value === undefined) ? this.#deleteOptions : {},
     };
 
+    alias.signed ??= this.shouldSign;
+
     if (!this.#setOptions.secure && alias.secure) {
-      throw new AppError('Cannot send secure cookie over unencrypted connection');
+      throw new RuntimeError('Cannot send secure cookie over unencrypted connection');
     }
 
-    if (alias.signed && !this.#grip) {
-      throw new AppError('Signing keys required for signed cookies');
+    if (alias.signed && !this.#grip.active) {
+      throw new RuntimeError('Signing keys required for signed cookies');
     }
 
     if (alias.maxAge !== undefined && !alias.expires) {
       alias.expires = new Date(Date.now() + alias.maxAge);
     }
+
+    this.#cookies[cookie.name] = alias;
   }
 
   getAll(): Cookie[] {
     return Object.values(this.#cookies);
   }
 
-  importCookieHeader(header: string | null | undefined): this {
+  importCookieHeader(header: string | null | undefined): Promise<void> {
     return this.import(WebHeaderUtil.parseCookieHeader(header ?? ''));
   }
 
-  importSetCookieHeader(headers: string[] | null | undefined): this {
+  importSetCookieHeader(headers: string[] | null | undefined): Promise<void> {
     return this.import(headers?.map(WebHeaderUtil.parseSetCookieHeader) ?? []);
   }
 
-  exportCookieHeader(): string {
-    return this.getAll().flatMap(cookie => this.#exportCookie(cookie)).join('; ');
+  exportCookieHeader(): Promise<string> {
+    return Promise.all(this.getAll()
+      .map(cookie => this.export(cookie)))
+      .then(parts => parts.flat().join('; '));
   }
 
-  exportSetCookieHeader(): string[] {
-    return this.getAll()
+  exportSetCookieHeader(): Promise<string[]> {
+    return Promise.all(this.getAll()
       .filter(cookie => cookie.response)
-      .flatMap(cookie => this.#exportCookie(cookie, true));
+      .map(cookie => this.export(cookie, true)))
+      .then(parts => parts.flat());
   }
 }

package/src/util/keygrip.ts

@@ -1,43 +1,63 @@
-import crypto from 'node:crypto';
-import { AppError, castKey } from '@travetto/runtime';
+import { timingSafeEqual } from 'node:crypto';
 
-const CHAR_MAPPING = { '/': '_', '+': '-', '=': '' };
+import { BinaryUtil, CodecUtil, type BinaryArray } from '@travetto/runtime';
 
-function timeSafeCompare(a: string, b: string): boolean {
-  const key = crypto.randomBytes(32);
-  const ah = crypto.createHmac('sha256', key).update(a).digest();
-  const bh = crypto.createHmac('sha256', key).update(b).digest();
-  return ah.length === bh.length && crypto.timingSafeEqual(ah, bh);
-}
+const CHAR_MAPPING: Record<string, string> = { '/': '_', '+': '-', '=': '' };
 
 export class KeyGrip {
 
+  static async getRandomHmacKey(): Promise<CryptoKey> {
+    const keyBytes = crypto.getRandomValues(new Uint8Array(32));
+    return crypto.subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+  }
+
+  static async hmac(value: string, cryptoKey: CryptoKey): Promise<BinaryArray> {
+    const input = BinaryUtil.binaryArrayToBuffer(CodecUtil.fromUTF8String(value));
+    return BinaryUtil.binaryArrayToUint8Array(await crypto.subtle.sign('HMAC', cryptoKey, input));
+  }
+
   #keys: string[];
-  #algorithm: string;
-  #encoding: crypto.BinaryToTextEncoding;
+  #cryptoKeys = new Map<string, Promise<CryptoKey>>();
 
-  constructor(keys: string[], algorithm = 'sha1', encoding: crypto.BinaryToTextEncoding = 'base64') {
-    if (!keys.length) {
-      throw new AppError('Keys must be defined');
-    }
+  constructor(keys: string[]) {
     this.#keys = keys;
-    this.#algorithm = algorithm;
-    this.#encoding = encoding;
   }
 
-  sign(data: string, key?: string): string {
-    return crypto
-      .createHmac(this.#algorithm, key ?? this.#keys[0])
-      .update(data)
-      .digest(this.#encoding)
-      .replace(/[/+=]/g, ch => CHAR_MAPPING[castKey(ch)]);
+  get active(): boolean {
+    return this.#keys.length > 0;
   }
 
-  verify(data: string, digest: string): boolean {
-    return this.index(data, digest) > -1;
+  async getCryptoKey(key: string): Promise<CryptoKey> {
+    return this.#cryptoKeys.getOrInsertComputed(key, async () => {
+      const keyBytes = BinaryUtil.binaryArrayToBuffer(CodecUtil.fromUTF8String(key));
+      return crypto.subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    });
   }
 
-  index(data: string, digest: string): number {
-    return this.#keys.findIndex(key => timeSafeCompare(digest, this.sign(data, key)));
+  async sign(data: string, key?: string): Promise<string> {
+    const cryptoKey = await this.getCryptoKey(key ?? this.#keys[0]);
+    const signature = await KeyGrip.hmac(data, cryptoKey);
+    return CodecUtil.toBase64String(signature).replace(/[/+=]/g, ch => CHAR_MAPPING[ch]);
+  }
+
+  verify(data: string, digest: string): Promise<boolean> {
+    return this.isValid(data, digest).then(result => result !== 'invalid');
+  }
+
+  async isValid(data: string, digest: string): Promise<'valid' | 'invalid' | 'stale'> {
+    const key = await KeyGrip.getRandomHmacKey();
+    const digestBytes = BinaryUtil.binaryArrayToUint8Array(await KeyGrip.hmac(digest, key));
+
+    for (let i = 0; i < this.#keys.length; i++) {
+      const signedBytes = BinaryUtil.binaryArrayToUint8Array(await KeyGrip.hmac(await this.sign(data, this.#keys[i]), key));
+
+      if (
+        signedBytes.byteLength === digestBytes.byteLength &&
+        timingSafeEqual(digestBytes, signedBytes)
+      ) {
+        return i === 0 ? 'valid' : 'stale';
+      }
+    }
+    return 'invalid';
   }
 }

package/support/test/dispatch-util.ts

@@ -1,7 +1,4 @@
-import { buffer } from 'node:stream/consumers';
-import type { Readable } from 'node:stream';
-
-import { AppError, BinaryUtil, castTo, JSONUtil } from '@travetto/runtime';
+import { BinaryUtil, castTo, type BinaryType, type BinaryArray, CodecUtil, JSONUtil } from '@travetto/runtime';
 import { BindUtil } from '@travetto/schema';
 
 import type { WebResponse } from '../../src/types/response.ts';
@@ -10,21 +7,26 @@ import { DecompressInterceptor } from '../../src/interceptor/decompress.ts';
 import { WebBodyUtil } from '../../src/util/body.ts';
 import { WebCommonUtil } from '../../src/util/common.ts';
 
-const toBuffer = (src: Buffer | Readable) => Buffer.isBuffer(src) ? src : buffer(src);
-
 /**
  * Utilities for supporting custom test dispatchers
  */
 export class WebTestDispatchUtil {
 
-  static async applyRequestBody(request: WebRequest): Promise<WebRequest> {
+  static async applyRequestBody(request: WebRequest, toByteArray: true): Promise<WebRequest<BinaryArray>>;
+  static async applyRequestBody(request: WebRequest, toByteArray?: false): Promise<WebRequest<BinaryType>>;
+  static async applyRequestBody(request: WebRequest, toByteArray: boolean = false): Promise<WebRequest<BinaryType>> {
     if (request.body !== undefined) {
       const sample = WebBodyUtil.toBinaryMessage(request);
       sample.headers.forEach((v, k) => request.headers.set(k, Array.isArray(v) ? v.join(',') : v));
-      request.body = WebBodyUtil.markRaw(await toBuffer(sample.body!));
+      if (toByteArray) {
+        sample.body = sample.body ?
+          await BinaryUtil.toBinaryArray(sample.body) :
+          BinaryUtil.makeBinaryArray(0);
+      }
+      request.body = WebBodyUtil.markRawBinary(sample.body);
     }
     Object.assign(request.context, { httpQuery: BindUtil.flattenPaths(request.context.httpQuery ?? {}) });
-    return request;
+    return castTo(request);
   }
 
   static async finalizeResponseBody(response: WebResponse, decompress?: boolean): Promise<WebResponse> {
@@ -32,32 +34,32 @@ export class WebTestDispatchUtil {
 
     response.context.httpStatusCode = WebCommonUtil.getStatusCode(response);
 
-    if (decompress) {
-      if (Buffer.isBuffer(result) || BinaryUtil.isReadable(result)) {
-        const bufferResult = result = await toBuffer(result);
-        if (bufferResult.length) {
-          try {
-            result = await DecompressInterceptor.decompress(
-              response.headers,
-              bufferResult,
-              { applies: true, supportedEncodings: ['br', 'deflate', 'gzip', 'identity'] }
-            );
-          } catch { }
-        }
+    if (decompress && BinaryUtil.isBinaryType(result)) {
+      const bufferResult = result = await BinaryUtil.toBinaryArray(result);
+      if (bufferResult.byteLength) {
+        try {
+          result = await DecompressInterceptor.decompress(
+            response.headers,
+            bufferResult,
+            { applies: true, supportedEncodings: ['br', 'deflate', 'gzip', 'identity'] }
+          );
+        } catch { }
       }
     }
 
-    const text = Buffer.isBuffer(result) ? result.toString('utf8') : (typeof result === 'string' ? result : undefined);
+    const isJSON = response.headers.get('Content-Type') === 'application/json';
+    const isText = response.headers.get('Content-Type')?.startsWith('text/') ?? false;
 
-    if (text) {
-      switch (response.headers.get('Content-Type')) {
-        case 'application/json': result = JSONUtil.parseSafe(castTo(text)); break;
-        case 'text/plain': result = text; break;
-      }
+    if (BinaryUtil.isBinaryArray(result) && (isJSON || isText)) {
+      result = CodecUtil.toUTF8String(result);
+    }
+
+    if (typeof result === 'string' && isJSON) {
+      result = JSONUtil.fromUTF8(result, { reviver: JSONUtil.TRANSMIT_REVIVER });
     }
 
     if (response.context.httpStatusCode && response.context.httpStatusCode >= 400) {
-      result = WebCommonUtil.catchResponse(AppError.fromJSON(result) ?? result).body;
+      result = WebCommonUtil.catchResponse(result).body;
     }
 
     response.body = result;

package/support/test/suite/base.ts

@@ -54,7 +54,7 @@ export abstract class BaseWebSuite {
 
   @AfterAll()
   async destroySever(): Promise<void> {
-    await this.#cleanup?.();
+    this.#cleanup?.();
     this.#cleanup = undefined;
   }
 

package/support/test/suite/controller.ts

@@ -1,6 +1,4 @@
-import { Readable } from 'node:stream';
-
-import { AppError, castTo } from '@travetto/runtime';
+import { RuntimeError, BinaryUtil, castTo, CodecUtil } from '@travetto/runtime';
 
 import { Controller } from '../../../src/decorator/controller.ts';
 import { Get, Post, Put, Delete, Patch } from '../../../src/decorator/endpoint.ts';
@@ -59,13 +57,13 @@ export class TestController {
   @Get('/stream')
   @SetHeaders({ 'Content-Type': 'text/plain' })
   getStream() {
-    return Readable.from(Buffer.from('hello'));
+    return BinaryUtil.toBinaryStream(CodecUtil.fromUTF8String('hello'));
   }
 
   @Get('/buffer')
   @Produces('text/plain')
   getBuffer() {
-    return Buffer.from('hello');
+    return CodecUtil.fromUTF8String('hello');
   }
 
   @Get('/renderable')
@@ -98,6 +96,6 @@ export class TestController {
 
   @Post('/ip')
   notFound() {
-    throw new AppError('Uh-oh', { category: 'general' });
+    throw new RuntimeError('Uh-oh', { category: 'general' });
   }
 }