@travetto/web 7.1.4 → 8.0.0-alpha.0

package/README.md

@@ -88,7 +88,7 @@ export class WebResponse<B = unknown> extends BaseWebMessage<B, WebResponseConte
 }
 ```
 
-These objects do not represent the underlying sockets provided by various http servers, but in fact are simple wrappers that track the flow through the call stack of the various [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15)s and the [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14) handler.  One of the biggest departures here, is that the response is not an entity that is passed around from call-site to call-site, but is is solely a return-value.  This doesn't mean the return value has to be static and pre-allocated, on the contrary streams are still supported.  The difference here is that the streams/asynchronous values will be consumed until the response is sent back to the user. The [CompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/compress.ts#L44) is a good reference for transforming a [WebResponse](https://github.com/travetto/travetto/tree/main/module/web/src/types/response.ts#L3) that can either be a stream or a fixed value.
+These objects do not represent the underlying sockets provided by various http servers, but in fact are simple wrappers that track the flow through the call stack of the various [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15)s and the [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14) handler.  One of the biggest departures here, is that the response is not an entity that is passed around from call-site to call-site, but is is solely a return-value.  This doesn't mean the return value has to be static and pre-allocated, on the contrary streams are still supported.  The difference here is that the streams/asynchronous values will be consumed until the response is sent back to the user. The [CompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/compress.ts#L51) is a good reference for transforming a [WebResponse](https://github.com/travetto/travetto/tree/main/module/web/src/types/response.ts#L3) that can either be a stream or a fixed value.
 
 ## Defining a Controller
 To start, we must define a [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L12), which is only allowed on classes. Controllers can be configured with:
@@ -145,7 +145,7 @@ class SimpleController {
   @Get('/')
   async simpleGet() {
     let data: Data | undefined;
-    //
+    // Do work
     return data;
   }
 }
@@ -378,8 +378,8 @@ Out of the box, the web framework comes with a few interceptors, and more are co
    1. global - Intended to run outside of the request flow - [AsyncContextInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/context.ts#L13)
    1. terminal - Handles once request and response are finished building - [LoggingInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/logging.ts#L28), [RespondInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/respond.ts#L12)
    1. pre-request - Prepares the request for running - [TrustProxyInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/trust-proxy.ts#L23)
-   1. request - Handles inbound request, validation, and body preparation - [DecompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/decompress.ts#L53), [AcceptInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/accept.ts#L33), [BodyInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/body.ts#L57), [CookieInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cookie.ts#L60) 
-   1. response - Prepares outbound response - [CompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/compress.ts#L44), [CorsInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cors.ts#L51), [EtagInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/etag.ts#L43), [CacheControlInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cache-control.ts#L23) 
+   1. request - Handles inbound request, validation, and body preparation - [DecompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/decompress.ts#L51), [AcceptInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/accept.ts#L33), [BodyInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/body.ts#L57), [CookieInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cookie.ts#L61) 
+   1. response - Prepares outbound response - [CompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/compress.ts#L51), [CorsInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cors.ts#L51), [EtagInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/etag.ts#L41), [CacheControlInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cache-control.ts#L23) 
    1. application - Lives outside of the general request/response behavior, [Web Auth](https://github.com/travetto/travetto/tree/main/module/auth-web#readme "Web authentication integration support for the Travetto framework") uses this for login and logout flows.
 
 ### Packaged Interceptors
@@ -445,7 +445,7 @@ export class AcceptConfig {
 ```
 
 #### DecompressInterceptor
-[DecompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/decompress.ts#L53) handles decompressing the inbound request, if supported.  This relies upon HTTP standards for content encoding, and negotiating the appropriate decompression scheme.
+[DecompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/decompress.ts#L51) handles decompressing the inbound request, if supported.  This relies upon HTTP standards for content encoding, and negotiating the appropriate decompression scheme.
 
 **Code: Decompress Config**
 ```typescript
@@ -462,7 +462,7 @@ export class DecompressConfig {
 ```
 
 #### CookieInterceptor
-[CookieInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cookie.ts#L60) is responsible for processing inbound cookie headers and populating the appropriate data on the request, as well as sending the appropriate response data
+[CookieInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cookie.ts#L61) is responsible for processing inbound cookie headers and populating the appropriate data on the request, as well as sending the appropriate response data
 
 **Code: Cookies Config**
 ```typescript
@@ -532,7 +532,7 @@ export class WebBodyConfig {
 ```
 
 #### CompressInterceptor
-[CompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/compress.ts#L44) by default, will compress all valid outbound responses over a certain size, or for streams will cache every response. This relies on Node's [Buffer](https://nodejs.org/api/zlib.html) support for compression.
+[CompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/compress.ts#L51) by default, will compress all valid outbound responses over a certain size, or for streams will cache every response. This relies on Node's [Buffer](https://nodejs.org/api/zlib.html) support for compression.
 
 **Code: Compress Config**
 ```typescript
@@ -544,7 +544,7 @@ export class CompressConfig {
   /**
    * Raw encoding options
    */
-  raw?: (ZlibOptions & BrotliOptions) | undefined;
+  raw?: (zlib.ZlibOptions & zlib.BrotliOptions) | undefined;
   /**
    * Supported encodings
    */
@@ -553,7 +553,7 @@ export class CompressConfig {
 ```
 
 #### EtagInterceptor
-[EtagInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/etag.ts#L43) by default, will tag all cacheable HTTP responses, when the response value/length is known.  Streams, and other async data sources do not have a pre-defined length, and so are ineligible for etagging.
+[EtagInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/etag.ts#L41) by default, will tag all cacheable HTTP responses, when the response value/length is known.  Streams, and other async data sources do not have a pre-defined length, and so are ineligible for etagging.
 
 **Code: ETag Config**
 ```typescript
@@ -740,16 +740,18 @@ Cookies are a unique element, within the framework, as they sit on the request a
 **Code: CookieJar contract**
 ```typescript
 export class CookieJar {
-  constructor({ keys, ...options }: CookieJarOptions = {});
-  import(cookies: Cookie[]): this;
+  constructor(options: CookieJarOptions = {}, keys?: string[] | KeyGrip);
+  get shouldSign(): boolean;
+  async export(cookie: Cookie, response?: boolean): Promise<string[]>;
+  async import(cookies: Cookie[]): Promise<void>;
   has(name: string, options: CookieGetOptions = {}): boolean;
   get(name: string, options: CookieGetOptions = {}): string | undefined;
   set(cookie: Cookie): void;
   getAll(): Cookie[];
-  importCookieHeader(header: string | null | undefined): this;
-  importSetCookieHeader(headers: string[] | null | undefined): this;
-  exportCookieHeader(): string;
-  exportSetCookieHeader(): string[];
+  importCookieHeader(header: string | null | undefined): Promise<void>;
+  importSetCookieHeader(headers: string[] | null | undefined): Promise<void>;
+  exportCookieHeader(): Promise<string>;
+  exportSetCookieHeader(): Promise<string[]>;
 }
 ```
 

package/__index__.ts

@@ -7,6 +7,7 @@ export * from './src/types/error.ts';
 export * from './src/types/cookie.ts';
 export * from './src/types/interceptor.ts';
 export * from './src/types/headers.ts';
+export * from './src/types/message.ts';
 
 export * from './src/context.ts';
 export * from './src/config.ts';
@@ -43,4 +44,4 @@ export * from './src/util/header.ts';
 export * from './src/util/cookie.ts';
 export * from './src/util/common.ts';
 export * from './src/util/keygrip.ts';
-export * from './src/util/net.ts';
+export * from './src/util/net.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/web",
-  "version": "7.1.4",
+  "version": "8.0.0-alpha.0",
   "type": "module",
   "description": "Declarative support for creating Web Applications",
   "keywords": [
@@ -26,18 +26,18 @@
     "directory": "module/web"
   },
   "dependencies": {
-    "@travetto/config": "^7.1.4",
-    "@travetto/context": "^7.1.4",
-    "@travetto/di": "^7.1.4",
-    "@travetto/registry": "^7.1.4",
-    "@travetto/runtime": "^7.1.4",
-    "@travetto/schema": "^7.1.4",
-    "find-my-way": "^9.4.0"
+    "@travetto/config": "^8.0.0-alpha.0",
+    "@travetto/context": "^8.0.0-alpha.0",
+    "@travetto/di": "^8.0.0-alpha.0",
+    "@travetto/registry": "^8.0.0-alpha.0",
+    "@travetto/runtime": "^8.0.0-alpha.0",
+    "@travetto/schema": "^8.0.0-alpha.0",
+    "find-my-way": "^9.5.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.1.4",
-    "@travetto/test": "^7.1.4",
-    "@travetto/transformer": "^7.1.3"
+    "@travetto/cli": "^8.0.0-alpha.0",
+    "@travetto/test": "^8.0.0-alpha.0",
+    "@travetto/transformer": "^8.0.0-alpha.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/context.ts

@@ -1,6 +1,6 @@
 import { AsyncContextValue, type AsyncContext } from '@travetto/context';
 import { Inject, Injectable } from '@travetto/di';
-import { AppError, castTo, type Class } from '@travetto/runtime';
+import { RuntimeError, castTo, type Class } from '@travetto/runtime';
 
 import { WebRequest } from './types/request.ts';
 
@@ -38,7 +38,7 @@ export class WebAsyncContext {
   getSource<T>(cls: Class<T>): () => T {
     const item = this.#byType.get(cls.Ⲑid);
     if (!item) {
-      throw new AppError('Unknown type for web context');
+      throw new RuntimeError('Unknown type for web context');
     }
     return castTo(item);
   }

package/src/decorator/common.ts

@@ -1,4 +1,4 @@
-import { type Class, type ClassInstance, getClass, type RetainPrimitiveFields, type TimeSpan, TimeUtil } from '@travetto/runtime';
+import { type Class, type ClassInstance, getClass, type RetainIntrinsicFields, type TimeSpan, TimeUtil } from '@travetto/runtime';
 
 import { ControllerRegistryIndex } from '../registry/registry-index.ts';
 import type { EndpointConfig, ControllerConfig, EndpointDecorator, EndpointFunctionDescriptor } from '../registry/types.ts';
@@ -49,7 +49,7 @@ export function CacheControl(input: TimeSpan | number | CacheControlInput, extra
   const { cacheableAge, isPrivate } = input;
   return register({
     responseContext: {
-      ...(cacheableAge !== undefined ? { cacheableAge: TimeUtil.asSeconds(cacheableAge) } : {}),
+      ...(cacheableAge !== undefined ? { cacheableAge: TimeUtil.duration(cacheableAge, 's') } : {}),
       ...isPrivate !== undefined ? { isPrivate } : {}
     }
   });
@@ -74,7 +74,7 @@ export function Accepts(types: [string, ...string[]]): EndpointDecorator {
  */
 export const ConfigureInterceptor = <T extends WebInterceptor>(
   cls: Class<T>,
-  config: Partial<RetainPrimitiveFields<T['config']>>,
+  config: Partial<RetainIntrinsicFields<T['config']>>,
   extra?: Partial<EndpointConfig & ControllerConfig>
 ): EndpointDecorator =>
   ControllerRegistryIndex.createInterceptorConfigDecorator(cls, config, extra);

package/src/interceptor/accept.ts

@@ -61,7 +61,7 @@ export class AcceptInterceptor implements WebInterceptor<AcceptConfig> {
       this.validate(request, config);
       return response = await next();
     } catch (error) {
-      throw response = await WebCommonUtil.catchResponse(error);
+      throw response = WebCommonUtil.catchResponse(error);
     } finally {
       response?.headers.setIfAbsent('Accept', config.types.join(','));
     }

package/src/interceptor/body.ts

@@ -78,7 +78,7 @@ export class BodyInterceptor implements WebInterceptor<WebBodyConfig> {
   async filter({ request, config, next }: WebChainedContext<WebBodyConfig>): Promise<WebResponse> {
     const input = request.body;
 
-    if (!WebBodyUtil.isRaw(input)) {
+    if (!WebBodyUtil.isRawBinary(input)) {
       return next();
     }
 

package/src/interceptor/compress.ts

@@ -1,8 +1,9 @@
-import { buffer } from 'node:stream/consumers';
-import { type BrotliOptions, constants, createBrotliCompress, createDeflate, createGzip, type ZlibOptions } from 'node:zlib';
+import zlib from 'node:zlib';
+import util from 'node:util';
 
 import { Injectable, Inject } from '@travetto/di';
 import { Config } from '@travetto/config';
+import { BinaryUtil } from '@travetto/runtime';
 
 import type { WebInterceptor, WebInterceptorContext } from '../types/interceptor.ts';
 import type { WebInterceptorCategory } from '../types/core.ts';
@@ -13,13 +14,19 @@ import { WebError } from '../types/error.ts';
 import { WebBodyUtil } from '../util/body.ts';
 import { WebHeaderUtil } from '../util/header.ts';
 
-const COMPRESSORS = {
-  gzip: createGzip,
-  deflate: createDeflate,
-  br: createBrotliCompress,
+const STREAM_COMPRESSORS = {
+  gzip: zlib.createGzip,
+  deflate: zlib.createDeflate,
+  br: zlib.createBrotliCompress,
 };
 
-type WebCompressEncoding = keyof typeof COMPRESSORS | 'identity';
+const ARRAY_COMPRESSORS = {
+  gzip: util.promisify(zlib.gzip),
+  deflate: util.promisify(zlib.deflate),
+  br: util.promisify(zlib.brotliCompress),
+};
+
+type WebCompressEncoding = keyof typeof ARRAY_COMPRESSORS | 'identity';
 
 @Config('web.compress')
 export class CompressConfig {
@@ -30,7 +37,7 @@ export class CompressConfig {
   /**
    * Raw encoding options
    */
-  raw?: (ZlibOptions & BrotliOptions) | undefined;
+  raw?: (zlib.ZlibOptions & zlib.BrotliOptions) | undefined;
   /**
    * Supported encodings
    */
@@ -63,38 +70,38 @@ export class CompressInterceptor implements WebInterceptor {
     }
 
     const accepts = request.headers.get('Accept-Encoding');
-    const type = WebHeaderUtil.negotiateHeader(accepts ?? '*', supportedEncodings);
+    const encoding = WebHeaderUtil.negotiateHeader(accepts ?? '*', supportedEncodings);
 
-    if (!type) {
+    if (!encoding) {
       throw WebError.for(`Please accept one of: ${supportedEncodings.join(', ')}. ${accepts} is not supported`, 406);
     }
 
-    if (type === 'identity') {
+    if (encoding === 'identity') {
       return response;
     }
 
     const binaryResponse = new WebResponse({ context: response.context, ...WebBodyUtil.toBinaryMessage(response) });
-    const chunkSize = raw.chunkSize ?? constants.Z_DEFAULT_CHUNK;
-    const len = Buffer.isBuffer(binaryResponse.body) ? binaryResponse.body.byteLength : undefined;
+    const chunkSize = raw.chunkSize ?? zlib.constants.Z_DEFAULT_CHUNK;
+    const len = BinaryUtil.isBinaryArray(binaryResponse.body) ? binaryResponse.body.byteLength : undefined;
 
     if (len !== undefined && len >= 0 && len < chunkSize || !binaryResponse.body) {
       return binaryResponse;
     }
 
-    const options = type === 'br' ? { params: { [constants.BROTLI_PARAM_QUALITY]: 4, ...raw.params }, ...raw } : { ...raw };
-    const stream = COMPRESSORS[type](options);
+    const options = encoding === 'br' ? { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 4, ...raw.params }, ...raw } : { ...raw };
 
     // If we are compressing
-    binaryResponse.headers.set('Content-Encoding', type);
+    binaryResponse.headers.set('Content-Encoding', encoding);
 
-    if (Buffer.isBuffer(binaryResponse.body)) {
-      stream.end(binaryResponse.body);
-      const out = await buffer(stream);
+    if (BinaryUtil.isBinaryArray(binaryResponse.body)) {
+      const compressor = ARRAY_COMPRESSORS[encoding];
+      const out = await compressor(await BinaryUtil.toBuffer(binaryResponse.body), options);
       binaryResponse.body = out;
       binaryResponse.headers.set('Content-Length', `${out.byteLength}`);
     } else {
-      binaryResponse.body.pipe(stream);
-      binaryResponse.body = stream;
+      const compressedStream = STREAM_COMPRESSORS[encoding](options);
+      void BinaryUtil.pipeline(binaryResponse.body, compressedStream);
+      binaryResponse.body = compressedStream;
       binaryResponse.headers.delete('Content-Length');
     }
 

package/src/interceptor/cookie.ts

@@ -10,6 +10,7 @@ import type { WebInterceptorCategory } from '../types/core.ts';
 
 import type { WebConfig } from '../config.ts';
 import type { Cookie, CookieSetOptions } from '../types/cookie.ts';
+import { KeyGrip } from '../util/keygrip.ts';
 import { CookieJar } from '../util/cookie.ts';
 import type { WebAsyncContext } from '../context.ts';
 
@@ -61,6 +62,8 @@ export class CookieInterceptor implements WebInterceptor<CookieConfig> {
 
   #cookieJar = new AsyncContextValue<CookieJar>(this);
 
+  keyGrip: KeyGrip;
+
   category: WebInterceptorCategory = 'request';
 
   @Inject()
@@ -77,13 +80,13 @@ export class CookieInterceptor implements WebInterceptor<CookieConfig> {
 
   postConstruct(): void {
     this.webAsyncContext.registerSource(CookieJar, () => this.#cookieJar.get());
+    this.keyGrip ??= new KeyGrip(this.config.keys ?? []);
   }
 
   finalizeConfig({ config }: WebInterceptorContext<CookieConfig>): CookieConfig {
     const url = new URL(this.webConfig.baseUrl ?? 'x://localhost');
     config.secure ??= url.protocol === 'https:';
     config.domain ??= url.hostname;
-    config.signed ??= !!config.keys?.length;
     return config;
   }
 
@@ -92,11 +95,12 @@ export class CookieInterceptor implements WebInterceptor<CookieConfig> {
   }
 
   async filter({ request, config, next }: WebChainedContext<CookieConfig>): Promise<WebResponse> {
-    const jar = new CookieJar(config).importCookieHeader(request.headers.get('Cookie'));
+    const jar = new CookieJar(config, this.keyGrip);
+    await jar.importCookieHeader(request.headers.get('Cookie'));
     this.#cookieJar.set(jar);
 
     const response = await next();
-    for (const cookie of jar.exportSetCookieHeader()) { response.headers.append('Set-Cookie', cookie); }
+    for (const cookie of await jar.exportSetCookieHeader()) { response.headers.append('Set-Cookie', cookie); }
     return response;
   }
 }

package/src/interceptor/decompress.ts

@@ -1,10 +1,10 @@
-import type { Readable } from 'node:stream';
 import zlib from 'node:zlib';
 import util from 'node:util';
+import { pipeline } from 'node:stream/promises';
 
 import { Injectable, Inject } from '@travetto/di';
 import { Config } from '@travetto/config';
-import { castTo } from '@travetto/runtime';
+import { BinaryUtil, castTo, type BinaryType } from '@travetto/runtime';
 
 import type { WebChainedContext } from '../types/filter.ts';
 import type { WebResponse } from '../types/response.ts';
@@ -18,18 +18,16 @@ import { WebError } from '../types/error.ts';
 const STREAM_DECOMPRESSORS = {
   gzip: zlib.createGunzip,
   deflate: zlib.createInflate,
-  br: zlib.createBrotliDecompress,
-  identity: (): Readable => null!
+  br: zlib.createBrotliDecompress
 };
 
-const BUFFER_DECOMPRESSORS = {
+const ARRAY_DECOMPRESSORS = {
   gzip: util.promisify(zlib.gunzip),
   deflate: util.promisify(zlib.inflate),
-  br: util.promisify(zlib.brotliDecompress),
-  identity: (): Readable => null!
+  br: util.promisify(zlib.brotliDecompress)
 };
 
-type WebDecompressEncoding = keyof typeof BUFFER_DECOMPRESSORS;
+type WebDecompressEncoding = (keyof typeof ARRAY_DECOMPRESSORS) | 'identity';
 
 /**
  * Web body parse configuration
@@ -52,8 +50,8 @@ export class DecompressConfig {
 @Injectable()
 export class DecompressInterceptor implements WebInterceptor<DecompressConfig> {
 
-  static async decompress(headers: WebHeaders, input: Buffer | Readable, config: DecompressConfig): Promise<typeof input> {
-    const encoding: WebDecompressEncoding | 'identity' = castTo(headers.getList('Content-Encoding')?.[0]) ?? 'identity';
+  static async decompress(headers: WebHeaders, input: BinaryType, config: DecompressConfig): Promise<BinaryType> {
+    const encoding: WebDecompressEncoding = castTo(headers.getList('Content-Encoding')?.[0]) ?? 'identity';
 
     if (!config.supportedEncodings.includes(encoding)) {
       throw WebError.for(`Unsupported Content-Encoding: ${encoding}`, 415);
@@ -63,10 +61,14 @@ export class DecompressInterceptor implements WebInterceptor<DecompressConfig> {
       return input;
     }
 
-    if (Buffer.isBuffer(input)) {
-      return BUFFER_DECOMPRESSORS[encoding](input);
+    if (BinaryUtil.isBinaryArray(input)) {
+      return ARRAY_DECOMPRESSORS[encoding](await BinaryUtil.toBinaryArray(input));
+    } else if (BinaryUtil.isBinaryStream(input)) {
+      const output = STREAM_DECOMPRESSORS[encoding]();
+      void pipeline(input, output);
+      return output;
     } else {
-      return input.pipe(STREAM_DECOMPRESSORS[encoding]());
+      throw WebError.for('Unable to decompress body: unsupported type', 400);
     }
   }
 
@@ -81,9 +83,9 @@ export class DecompressInterceptor implements WebInterceptor<DecompressConfig> {
   }
 
   async filter({ request, config, next }: WebChainedContext<DecompressConfig>): Promise<WebResponse> {
-    if (WebBodyUtil.isRaw(request.body)) {
+    if (WebBodyUtil.isRawBinary(request.body)) {
       const updatedBody = await DecompressInterceptor.decompress(request.headers, request.body, config);
-      request.body = WebBodyUtil.markRaw(updatedBody);
+      request.body = WebBodyUtil.markRawBinary(updatedBody);
     }
     return next();
   }

package/src/interceptor/etag.ts

@@ -1,9 +1,7 @@
-import crypto from 'node:crypto';
-
 import { Injectable, Inject } from '@travetto/di';
 import { Config } from '@travetto/config';
 import { Ignore } from '@travetto/schema';
-import { BinaryUtil } from '@travetto/runtime';
+import { BinaryMetadataUtil, BinaryUtil, type BinaryArray } from '@travetto/runtime';
 
 import type { WebChainedContext } from '../types/filter.ts';
 import { WebResponse } from '../types/response.ts';
@@ -48,14 +46,10 @@ export class EtagInterceptor implements WebInterceptor {
   @Inject()
   config: EtagConfig;
 
-  computeTag(body: Buffer): string {
+  computeTag(body: BinaryArray): string {
     return body.byteLength === 0 ?
       '2jmj7l5rSw0yVb/vlWAYkK/YBwk' :
-      crypto
-        .createHash('sha1')
-        .update(body.toString('utf8'), 'utf8')
-        .digest('base64')
-        .substring(0, 27);
+      BinaryMetadataUtil.hash(body, { length: 27, hashAlgorithm: 'sha1', outputEncoding: 'base64' });
   }
 
   addTag(ctx: WebChainedContext<EtagConfig>, response: WebResponse): WebResponse {
@@ -65,7 +59,7 @@ export class EtagInterceptor implements WebInterceptor {
 
     if (
       (statusCode >= 300 && statusCode !== 304) || // Ignore redirects
-      BinaryUtil.isReadableStream(response.body) // Ignore streams (unknown length)
+      BinaryUtil.isBinaryStream(response.body) // Ignore streams (unknown length)
     ) {
       return response;
     }
@@ -73,12 +67,12 @@ export class EtagInterceptor implements WebInterceptor {
     const binaryResponse = new WebResponse({ ...response, ...WebBodyUtil.toBinaryMessage(response) });
 
     const body = binaryResponse.body;
-    if (!Buffer.isBuffer(body)) {
+    if (!BinaryUtil.isBinaryArray(body)) {
       return binaryResponse;
     }
 
     const minSize = ctx.config._minimumSize ??= WebCommonUtil.parseByteSize(ctx.config.minimumSize);
-    if (body.length < minSize) {
+    if (body.byteLength < minSize) {
       return binaryResponse;
     }
 

package/src/registry/registry-adapter.ts

@@ -1,5 +1,5 @@
 import type { RegistryAdapter } from '@travetto/registry';
-import { AppError, asFull, castTo, type Class, type RetainPrimitiveFields, safeAssign } from '@travetto/runtime';
+import { RuntimeError, asFull, castTo, type Class, type RetainIntrinsicFields, safeAssign } from '@travetto/runtime';
 import { WebHeaders } from '@travetto/web';
 import { type SchemaParameterConfig, SchemaRegistryIndex } from '@travetto/schema';
 
@@ -60,7 +60,7 @@ function computeParameterLocation(endpoint: EndpointConfig, param: SchemaParamet
   if (!SchemaRegistryIndex.has(param.type)) {
     if ((param.type === String || param.type === Number) && name && endpoint.path.includes(`:${name}`)) {
       return 'path';
-    } else if (param.type === Blob || param.type === File || param.type === ArrayBuffer || param.type === Uint8Array) {
+    } else if (param.binary) {
       return 'body';
     }
     return 'query';
@@ -100,7 +100,7 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
   registerEndpoint(method: string, ...data: Partial<EndpointConfig>[]): EndpointConfig {
     this.register();
 
-    if (!this.#endpoints.has(method)) {
+    const resolved = this.#endpoints.getOrInsertComputed(method, () => {
       const endpointConfig = asFull<EndpointConfig>({
         path: '/',
         fullPath: '/',
@@ -117,11 +117,11 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
         responseFinalizer: undefined
       });
       this.#config.endpoints.push(endpointConfig);
-      this.#endpoints.set(method, endpointConfig);
-    }
+      return endpointConfig;
+    });
 
-    combineEndpointConfigs(this.#config, this.#endpoints.get(method)!, ...data);
-    return this.#endpoints.get(method)!;
+    combineEndpointConfigs(this.#config, resolved, ...data);
+    return resolved;
   }
 
   registerEndpointParameter(method: string, idx: number, ...config: Partial<EndpointParameterConfig>[]): EndpointParameterConfig {
@@ -156,14 +156,14 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
   getEndpointConfig(method: string): EndpointConfig {
     const endpoint = this.#endpoints.get(method);
     if (!endpoint) {
-      throw new AppError(`Endpoint not registered: ${String(method)} on ${this.#cls.name}`);
+      throw new RuntimeError(`Endpoint not registered: ${String(method)} on ${this.#cls.name}`);
     }
     return endpoint;
   }
 
   registerInterceptorConfig<T extends WebInterceptor>(
     cls: Class<T>,
-    config: Partial<RetainPrimitiveFields<T['config']>>,
+    config: Partial<RetainIntrinsicFields<T['config']>>,
     extra?: Partial<EndpointConfig & ControllerConfig>
   ): ControllerConfig {
     return this.register({ interceptorConfigs: [[cls, castTo(config)]], ...extra });
@@ -172,7 +172,7 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
   registerEndpointInterceptorConfig<T extends WebInterceptor>(
     property: string,
     cls: Class<T>,
-    config: Partial<RetainPrimitiveFields<T['config']>>,
+    config: Partial<RetainIntrinsicFields<T['config']>>,
     extra?: Partial<EndpointConfig>
   ): EndpointConfig {
     return this.registerEndpoint(property, { interceptorConfigs: [[cls, castTo(config)]], ...extra });

package/src/registry/registry-index.ts

@@ -1,5 +1,5 @@
 import { type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { type Class, type ClassInstance, getClass, isClass, type RetainPrimitiveFields } from '@travetto/runtime';
+import { type Class, type ClassInstance, getClass, isClass, type RetainIntrinsicFields } from '@travetto/runtime';
 import { DependencyRegistryIndex } from '@travetto/di';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
@@ -39,7 +39,7 @@ export class ControllerRegistryIndex implements RegistryIndex {
    */
   static createInterceptorConfigDecorator<T extends WebInterceptor>(
     cls: Class<T>,
-    config: Partial<RetainPrimitiveFields<T['config']>>,
+    config: Partial<RetainIntrinsicFields<T['config']>>,
     extra?: Partial<EndpointConfig & ControllerConfig>
   ): EndpointDecorator {
     return (instanceOrCls: Class | ClassInstance, property?: string): void => {

package/src/router/standard.ts

@@ -1,6 +1,6 @@
 import router from 'find-my-way';
 
-import { AppError } from '@travetto/runtime';
+import { RuntimeError } from '@travetto/runtime';
 import { Inject, Injectable } from '@travetto/di';
 
 import type { EndpointConfig } from '../registry/types.ts';
@@ -44,7 +44,7 @@ export class StandardWebRouter extends BaseWebRouter {
     const endpoint = this.#cache.get(handler!);
     if (!endpoint) {
       return new WebResponse({
-        body: new AppError(`Unknown endpoint ${httpMethod} ${request.context.path}`, { category: 'notfound' }),
+        body: new RuntimeError(`Unknown endpoint ${httpMethod} ${request.context.path}`, { category: 'notfound' }),
       });
     }
     Object.assign(request.context, { pathParams: params });

package/src/types/error.ts

@@ -1,9 +1,9 @@
-import { type AnyMap, AppError, type ErrorCategory } from '@travetto/runtime';
+import { type AnyMap, RuntimeError, type ErrorCategory } from '@travetto/runtime';
 
 /**
  * Web Error
  */
-export class WebError extends AppError<{ statusCode?: number }> {
+export class WebError extends RuntimeError<{ statusCode?: number }> {
   static for(message: string, code: number, details?: AnyMap, category: ErrorCategory = 'data'): WebError {
     return new WebError(message, { category, details: { ...details, statusCode: code } });
   }

package/src/types/message.ts

@@ -1,9 +1,6 @@
-import type { Readable } from 'node:stream';
 import { castTo } from '@travetto/runtime';
 import { WebHeaders, type WebHeadersInit } from './headers.ts';
 
-export type WebBinaryBody = Readable | Buffer;
-
 export interface WebMessageInit<B = unknown, C = unknown> {
   context?: C;
   headers?: WebHeadersInit;