@rest-vir/run-service 0.18.1 → 0.19.1

package/dist/handle-request/endpoint-handler.d.ts

@@ -65,6 +65,15 @@ export type EndpointHandlerParams = {
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
 export type EndpointHandler = (params: Readonly<EndpointHandlerParams>) => MaybePromise<HandledOutput>;
+/**
+ * Handle the output of a handler without sending the response. Similar to
+ * {@link handleHandlerOutput} but this one does not send the response.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/run-service
+ * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
+ */
+export declare function handleHandlerOutputWithoutSending(result: Readonly<HandledOutput>, response: ServerResponse): undefined | HandledOutput;
 /**
  * Handle the output of a handler. Setting headers, sending the response, etc.
  *
@@ -72,4 +81,4 @@ export type EndpointHandler = (params: Readonly<EndpointHandlerParams>) => Maybe
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export declare function handleHandlerResult(result: Readonly<HandledOutput>, response: ServerResponse): undefined | FastifyReply;
+export declare function handleHandlerOutput(result: Readonly<HandledOutput>, response: ServerResponse): undefined | FastifyReply;

package/dist/handle-request/endpoint-handler.js

@@ -1,5 +1,26 @@
 /* node:coverage disable: this file is just types */
 import { setResponseHeaders } from '../util/headers.js';
+/**
+ * Handle the output of a handler without sending the response. Similar to
+ * {@link handleHandlerOutput} but this one does not send the response.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/run-service
+ * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
+ */
+export function handleHandlerOutputWithoutSending(result, response) {
+    if (result?.headers) {
+        setResponseHeaders(response, result.headers);
+    }
+    if (result?.statusCode) {
+        response.statusCode = result.statusCode;
+        return {
+            body: result.body,
+            statusCode: result.statusCode,
+        };
+    }
+    return undefined;
+}
 /**
  * Handle the output of a handler. Setting headers, sending the response, etc.
  *
@@ -7,7 +28,7 @@ import { setResponseHeaders } from '../util/headers.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export function handleHandlerResult(result, response) {
+export function handleHandlerOutput(result, response) {
     if (result?.headers) {
         setResponseHeaders(response, result.headers);
     }

package/dist/handle-request/handle-route.d.ts

@@ -1,4 +1,5 @@
-import { type ImplementedEndpoint, type ImplementedWebSocket, type RunningServerInfo, type ServerRequest, type ServerResponse } from '@rest-vir/implement-service';
+import { type SelectFrom } from '@augment-vir/common';
+import { type GenericServiceImplementation, type ImplementedEndpoint, type ImplementedWebSocket, type PostHook, type RunningServerInfo, type ServerRequest, type ServerResponse } from '@rest-vir/implement-service';
 import { type WebSocket as WsWebSocket } from 'ws';
 import { type HandleRouteOptions } from './endpoint-handler.js';
 /**
@@ -8,8 +9,20 @@ import { type HandleRouteOptions } from './endpoint-handler.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export declare function handleRoute(
-/** Endpoint requests won't have a `WebSocket`. */
-webSocket: WsWebSocket | undefined, request: ServerRequest, 
-/** `WebSocket` requests won't have a response. */
-response: ServerResponse | undefined, route: Readonly<ImplementedEndpoint | ImplementedWebSocket>, attachId: string, server: Readonly<RunningServerInfo>, options?: Readonly<Pick<HandleRouteOptions, 'throwErrorsForExternalHandling'>>): Promise<void>;
+export declare function handleRoute({ webSocket, request, response, route, attachId, server, options, postHook, service, }: {
+    /** Endpoint requests won't have a `WebSocket`. */ webSocket: WsWebSocket | undefined;
+    request: ServerRequest /** `WebSocket` requests won't have a response. */;
+    response: ServerResponse | undefined;
+    route: Readonly<ImplementedEndpoint | ImplementedWebSocket>;
+    attachId: string;
+    server: Readonly<RunningServerInfo>;
+    options: Readonly<Pick<HandleRouteOptions, 'throwErrorsForExternalHandling'>>;
+    postHook: PostHook | undefined;
+    service: Readonly<SelectFrom<GenericServiceImplementation, {
+        webSockets: true;
+        endpoints: true;
+        serviceName: true;
+        serviceOrigin: true;
+        requiredClientOrigin: true;
+    }>>;
+}): Promise<void>;

package/dist/handle-request/handle-route.js

@@ -2,9 +2,10 @@ import { assert, check } from '@augment-vir/assert';
 import { ensureError, HttpStatus } from '@augment-vir/common';
 import { RestVirHandlerError, } from '@rest-vir/implement-service';
 import cluster from 'node:cluster';
-import { handleHandlerResult } from './endpoint-handler.js';
+import { handleHandlerOutput, handleHandlerOutputWithoutSending, } from './endpoint-handler.js';
 import { handleEndpointRequest } from './handle-endpoint.js';
 import { handleWebSocketRequest } from './handle-web-socket.js';
+import { runPostHook } from './run-post-hook.js';
 /**
  * Handles a WebSocket or Endpoint request.
  *
@@ -12,11 +13,7 @@ import { handleWebSocketRequest } from './handle-web-socket.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export async function handleRoute(
-/** Endpoint requests won't have a `WebSocket`. */
-webSocket, request, 
-/** `WebSocket` requests won't have a response. */
-response, route, attachId, server, options = {}) {
+export async function handleRoute({ webSocket, request, response, route, attachId, server, options = {}, postHook, service, }) {
     try {
         const workerPid = cluster.isPrimary ? '' : process.pid;
         const webSocketMarker = route.isWebSocket ? '(ws)' : '';
@@ -36,9 +33,28 @@ response, route, attachId, server, options = {}) {
                 attachId,
                 server,
             });
-            const sentResponse = handleHandlerResult(result, response);
-            if (sentResponse) {
-                return sentResponse;
+            const endpointResult = handleHandlerOutputWithoutSending(result, response);
+            const postHookResult = (postHook &&
+                endpointResult?.statusCode &&
+                (await runPostHook({
+                    attachId,
+                    originalBody: endpointResult.body,
+                    originalStatus: endpointResult.statusCode,
+                    postHook,
+                    request,
+                    response,
+                    server,
+                    service,
+                }))) ||
+                endpointResult;
+            if (postHookResult) {
+                if (postHookResult.body == undefined) {
+                    postHookResult.headers = {
+                        ...postHookResult.headers,
+                        'content-type': undefined,
+                    };
+                }
+                return handleHandlerOutput(postHookResult, response);
             }
         }
         else if (route.isWebSocket) {

package/dist/handle-request/pre-handler.d.ts

@@ -1,6 +1,6 @@
 import { type SelectFrom } from '@augment-vir/common';
 import { type GenericServiceImplementation, type RunningServerInfo, type ServerRequest, type ServerResponse } from '@rest-vir/implement-service';
-import { type FastifyReply } from 'fastify';
+import { type HandledOutput } from './endpoint-handler.js';
 /**
  * Handles a request before it gets to the actual route handlers.
  *
@@ -8,12 +8,18 @@ import { type FastifyReply } from 'fastify';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export declare function preHandler(request: ServerRequest, response: ServerResponse, service: Readonly<SelectFrom<GenericServiceImplementation, {
-    webSockets: true;
-    endpoints: true;
-    serviceName: true;
-    createContext: true;
-    serviceOrigin: true;
-    requiredClientOrigin: true;
-    logger: true;
-}>>, server: Readonly<RunningServerInfo>, attachId: string): Promise<FastifyReply | undefined>;
+export declare function preHandler({ request, response, service, server, attachId, }: {
+    request: ServerRequest;
+    response: ServerResponse;
+    service: Readonly<SelectFrom<GenericServiceImplementation, {
+        webSockets: true;
+        endpoints: true;
+        serviceName: true;
+        createContext: true;
+        serviceOrigin: true;
+        requiredClientOrigin: true;
+        logger: true;
+    }>>;
+    server: Readonly<RunningServerInfo>;
+    attachId: string;
+}): Promise<Readonly<HandledOutput>>;

package/dist/handle-request/pre-handler.js

@@ -3,7 +3,7 @@ import { ensureErrorAndPrependMessage, extractErrorMessage, HttpStatus, stringif
 import { isFormDataShape, matchUrlToService, restVirServiceNameHeader, } from '@rest-vir/define-service';
 import { HttpMethod, RestVirHandlerError, } from '@rest-vir/implement-service';
 import { assertValidShape, isValidShape } from 'object-shape-tester';
-import { handleHandlerResult } from './endpoint-handler.js';
+import { handleHandlerOutputWithoutSending } from './endpoint-handler.js';
 import { handleCors } from './handle-cors.js';
 import { handleRequestMethod } from './handle-request-method.js';
 import { handleSearchParams } from './handle-search-params.js';
@@ -14,7 +14,7 @@ import { handleSearchParams } from './handle-search-params.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export async function preHandler(request, response, service, server, attachId) {
+export async function preHandler({ request, response, service, server, attachId, }) {
     response.header(restVirServiceNameHeader, service.serviceName);
     const pathMatch = matchUrlToService(service, request.originalUrl);
     if (!pathMatch) {
@@ -41,15 +41,16 @@ export async function preHandler(request, response, service, server, attachId) {
         : undefined;
     if (protocolShapeError) {
         service.logger.error(new RestVirHandlerError(route, extractErrorMessage(ensureErrorAndPrependMessage(protocolShapeError, `WebSocket protocols rejected (${stringify(protocols)}):`))));
-        response.statusCode = HttpStatus.BadRequest;
-        response.send('Invalid protocols.');
-        return undefined;
+        return {
+            statusCode: HttpStatus.BadRequest,
+            body: 'Invalid protocol.',
+        };
     }
-    const subHandlerResponse = handleHandlerResult(await handleCors({
+    const subHandlerResponse = handleHandlerOutputWithoutSending(await handleCors({
         request,
         route,
     }), response) ||
-        handleHandlerResult(handleRequestMethod({
+        handleHandlerOutputWithoutSending(handleRequestMethod({
             request,
             route,
         }), response);
@@ -59,15 +60,17 @@ export async function preHandler(request, response, service, server, attachId) {
     const requestData = wrapInTry(() => extractRequestData(request.body, request.headers, route));
     if (requestData instanceof Error) {
         service.logger.error(new RestVirHandlerError(route, `Rejected request body from '${request.originalUrl}': ${stringify(requestData)}`));
-        response.statusCode = HttpStatus.BadRequest;
-        response.send('Invalid body.');
-        return undefined;
+        return {
+            statusCode: HttpStatus.BadRequest,
+            body: 'Invalid body.',
+        };
     }
     const searchParams = handleSearchParams({ request, route });
     if (!('data' in searchParams)) {
-        return handleHandlerResult(searchParams, response);
+        return handleHandlerOutputWithoutSending(searchParams, response);
     }
     const contextParams = {
+        pathParams: request.params,
         method: assertWrap.isEnumValue(request.method.toUpperCase(), HttpMethod),
         request,
         requestData,
@@ -81,23 +84,23 @@ export async function preHandler(request, response, service, server, attachId) {
     };
     try {
         const contextOutput = await service.createContext?.(contextParams);
-        if (contextOutput?.reject) {
-            service.logger.error(new RestVirHandlerError(route, `Context creation rejected: '${request.originalUrl}'`));
-            return handleHandlerResult({
-                body: contextOutput.reject.responseErrorMessage,
-                statusCode: contextOutput.reject.statusCode,
-                headers: contextOutput.reject.headers,
-            }, response);
-        }
         if (!request.restVirContext) {
             request.restVirContext = {};
         }
         request.restVirContext[attachId] = {
-            context: contextOutput?.context,
+            context: contextOutput?.reject ? undefined : contextOutput?.context,
             requestData,
             protocols,
             searchParams: searchParams.data,
         };
+        if (contextOutput?.reject) {
+            service.logger.error(new RestVirHandlerError(route, `Context creation rejected: '${request.originalUrl}'`));
+            return handleHandlerOutputWithoutSending({
+                body: contextOutput.reject.responseErrorMessage,
+                statusCode: contextOutput.reject.statusCode,
+                headers: contextOutput.reject.headers,
+            }, response);
+        }
         return undefined;
     }
     catch (error) {

package/dist/handle-request/run-post-hook.d.ts

@@ -0,0 +1,17 @@
+import { type HttpStatus, type SelectFrom } from '@augment-vir/common';
+import { type GenericServiceImplementation, type PostHook, type RunningServerInfo } from '@rest-vir/implement-service';
+import { type EndpointHandlerParams, type HandledOutput } from './endpoint-handler.js';
+export declare function runPostHook(this: void, { request, response, attachId, server, postHook, service, originalBody, originalStatus, }: Readonly<Omit<EndpointHandlerParams, 'route'> & {
+    attachId: string;
+    server: Readonly<RunningServerInfo>;
+    postHook: PostHook;
+    originalBody: unknown;
+    originalStatus: HttpStatus;
+    service: Readonly<SelectFrom<GenericServiceImplementation, {
+        webSockets: true;
+        endpoints: true;
+        serviceName: true;
+        serviceOrigin: true;
+        requiredClientOrigin: true;
+    }>>;
+}>): Promise<HandledOutput>;

package/dist/handle-request/run-post-hook.js

@@ -0,0 +1,59 @@
+import { assert, assertWrap } from '@augment-vir/assert';
+import { matchUrlToService } from '@rest-vir/define-service';
+import { HttpMethod, } from '@rest-vir/implement-service';
+export async function runPostHook({ request, response, attachId, server, postHook, service, originalBody, originalStatus, }) {
+    const restVirContext = request.restVirContext?.[attachId];
+    assert.isDefined(restVirContext, 'restVirContext is not defined');
+    const context = restVirContext.context;
+    const requestData = restVirContext.requestData;
+    const searchParams = restVirContext.searchParams;
+    const pathMatch = matchUrlToService(service, request.originalUrl);
+    /* node:coverage ignore next 10 */
+    if (!pathMatch) {
+        return undefined;
+    }
+    const endpointDefinition = pathMatch.endpointPath
+        ? service.endpoints[pathMatch.endpointPath]
+        : undefined;
+    const webSocketDefinition = request.ws && pathMatch.webSocketPath
+        ? service.webSockets[pathMatch.webSocketPath]
+        : undefined;
+    const postHookParams = {
+        pathParams: request.params,
+        method: assertWrap.isEnumValue(request.method.toUpperCase(), HttpMethod),
+        request,
+        requestData,
+        requestHeaders: request.headers,
+        response,
+        service,
+        endpointDefinition,
+        webSocketDefinition,
+        context,
+        searchParams,
+        server,
+        originalResponseData: originalBody,
+        originalStatus,
+    };
+    const result = await postHook(postHookParams);
+    if (result) {
+        return {
+            body: 'responseErrorMessage' in result
+                ? result.responseErrorMessage
+                : 'responseData' in result
+                    ? result.responseData
+                    : originalBody,
+            statusCode: 'statusCode' in result ? result.statusCode : originalStatus,
+            headers: {
+                ...result.headers,
+                ...(result.dataType
+                    ? {
+                        'content-type': result.dataType,
+                    }
+                    : {}),
+            },
+        };
+    }
+    else {
+        return undefined;
+    }
+}

package/dist/start-service/attach-service.d.ts

@@ -42,6 +42,7 @@ export declare function attachService(server: Readonly<FastifyInstance>, service
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>, options?: Readonly<HandleRouteOptions>): Promise<void>;
 /**
  * Merge the running Fastify server's port with the given service's origin port (if it has a port).

package/dist/start-service/attach-service.js

@@ -1,10 +1,12 @@
-import { check } from '@augment-vir/assert';
+import { assert, check } from '@augment-vir/assert';
 import { ensureError, extractErrorMessage, getEnumValues, getObjectTypedKeys, HttpMethod, HttpStatus, randomString, } from '@augment-vir/common';
 import fastifyWs from '@fastify/websocket';
 import { RestVirHandlerError, } from '@rest-vir/implement-service';
 import { buildUrl, parseUrl } from 'url-vir';
+import { handleHandlerOutput } from '../handle-request/endpoint-handler.js';
 import { handleRoute } from '../handle-request/handle-route.js';
 import { preHandler } from '../handle-request/pre-handler.js';
+import { runPostHook } from '../handle-request/run-post-hook.js';
 const endpointFastifyMethods = getEnumValues(HttpMethod).filter((value) => {
     return (
     /** Fastify doesn't support the CONNECT method. */
@@ -51,18 +53,45 @@ export async function attachService(server, service, options = {}) {
                 },
             });
         }
+        const postHook = service.postHook;
         server.addHook('preValidation', async (request, response) => {
             try {
-                return await preHandler(request, response, service, extractRunningServerInfo(service, server), attachId);
+                const preHandlerResult = await preHandler({
+                    request,
+                    response,
+                    service,
+                    server: extractRunningServerInfo(service, server),
+                    attachId,
+                });
+                if (preHandlerResult?.statusCode && postHook) {
+                    const postHookResult = await runPostHook({
+                        attachId,
+                        originalBody: preHandlerResult.body,
+                        originalStatus: preHandlerResult.statusCode,
+                        postHook,
+                        request,
+                        response,
+                        server: extractRunningServerInfo(service, server),
+                        service,
+                    });
+                    if (postHookResult) {
+                        return handleHandlerOutput(postHookResult, response);
+                    }
+                }
+                return handleHandlerOutput(preHandlerResult, response);
             }
             catch (error) {
                 service.logger.error(ensureError(error));
                 if (options.throwErrorsForExternalHandling) {
                     throw error;
+                    /* node:coverage ignore next 5 */
+                }
+                else if (response.sent) {
+                    assert.never("Error encountered but response was already sent so there's nothing we can do about it.");
                 }
-                else if (!response.sent) {
+                else {
                     response.statusCode = HttpStatus.InternalServerError;
-                    response.send();
+                    return response.send();
                 }
             }
         });
@@ -78,17 +107,47 @@ export async function attachService(server, service, options = {}) {
                     method: endpointFastifyMethods,
                     url: path,
                     handler(request, response) {
-                        return handleRoute(undefined, request, response, endpoint, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket: undefined,
+                            request,
+                            response,
+                            route: endpoint,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
                 server.route({
                     method: HttpMethod.Get,
                     url: path,
                     handler(request, response) {
-                        return handleRoute(undefined, request, response, endpoint, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket: undefined,
+                            request,
+                            response,
+                            route: endpoint,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                     wsHandler(webSocket, request) {
-                        return handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket,
+                            request,
+                            response: undefined,
+                            route: webSocketDefinition,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
             }
@@ -100,7 +159,17 @@ export async function attachService(server, service, options = {}) {
                     ],
                     url: path,
                     handler(request, response) {
-                        return handleRoute(undefined, request, response, endpoint, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket: undefined,
+                            request,
+                            response,
+                            route: endpoint,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
             }
@@ -112,7 +181,17 @@ export async function attachService(server, service, options = {}) {
                         return response.status(HttpStatus.NotFound).send();
                     },
                     wsHandler(webSocket, request) {
-                        return handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket,
+                            request,
+                            response: undefined,
+                            route: webSocketDefinition,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
             }

package/dist/start-service/start-service.d.ts

@@ -69,4 +69,5 @@ export declare function startService(service: Readonly<SelectFrom<GenericService
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>, userOptions?: Readonly<StartServiceUserOptions>, fastifyPlugins?: Readonly<FastifyPlugins>): Promise<StartServiceOutput>;

package/dist/test/test-service.d.ts

@@ -284,6 +284,7 @@ export declare function testService<const Service extends Readonly<SelectFrom<Ge
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>>(service: Readonly<Service>, testServiceOptions?: Readonly<Omit<PartialWithUndefined<StartServiceUserOptions>, 'workerCount' | 'preventWorkerRespawn' | ''>>): Promise<{
     /** Kill the server being tested. This should always be called after your tests are finished. */
     kill(this: void): Promise<void>;
@@ -313,6 +314,7 @@ export declare function testExistingServer<const Service extends Readonly<Select
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>>(server: Readonly<FastifyInstance>, service: Readonly<Service>, options?: Readonly<HandleRouteOptions & Omit<PartialWithUndefined<StartServiceOptions>, 'workerCount' | 'preventWorkerRespawn'>>): Promise<{
     /** Send a request to the service. */
     fetchEndpoint: FetchTestService<Service>;
@@ -353,6 +355,7 @@ export declare function describeService<const Service extends Readonly<SelectFro
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>>({ service, options, }: {
     /** The service to startup and send requests to. */
     service: Readonly<Service>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rest-vir/run-service",
-    "version": "0.18.1",
+    "version": "0.19.1",
     "description": "Run a service defined by @rest-vir/define-service and implemented by @rest-vir/implement-service.",
     "keywords": [
         "rest",
@@ -39,25 +39,25 @@
         "test:update": "npm test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.16.0",
-        "@augment-vir/common": "^31.16.0",
-        "@augment-vir/node": "^31.16.0",
+        "@augment-vir/assert": "^31.19.1",
+        "@augment-vir/common": "^31.19.1",
+        "@augment-vir/node": "^31.19.1",
         "@fastify/websocket": "^11.0.2",
-        "@rest-vir/define-service": "^0.18.1",
-        "@rest-vir/implement-service": "^0.18.1",
+        "@rest-vir/define-service": "^0.19.1",
+        "@rest-vir/implement-service": "^0.19.1",
         "cluster-vir": "^0.1.0",
         "date-vir": "^7.3.1",
-        "fastify": "^5.3.2",
+        "fastify": "^5.3.3",
         "light-my-request": "^6.6.0",
         "portfinder": "^1.0.37",
-        "type-fest": "^4.40.1",
+        "type-fest": "^4.41.0",
         "url-vir": "^2.1.3"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.16.0",
+        "@augment-vir/test": "^31.19.1",
         "@fastify/multipart": "^9.0.3",
         "@types/connect": "^3.4.38",
-        "@types/node": "^22.15.3",
+        "@types/node": "^22.15.18",
         "@types/ws": "^8.18.1",
         "c8": "^10.1.3",
         "istanbul-smart-text-reporter": "^1.1.5",