@tstdl/base 0.93.127 → 0.93.129

package/authentication/tests/authentication.client-error-handling.test.js

@@ -70,6 +70,12 @@ describe('AuthenticationClientService Error Handling & Stuck States', () => {
     afterEach(async () => {
         await service.dispose();
     });
+    function setupServiceWithToken(iatOffset = -10, expOffset = 5) {
+        const now = Math.floor(Date.now() / 1000);
+        const initialToken = { iat: now + iatOffset, exp: now + expOffset, jti: 'initial' };
+        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
+        service = injector.resolve(AuthenticationClientService);
+    }
     test('Corrupt Storage: should handle invalid JSON in storage gracefully', async () => {
         // initialize with corrupt token
         globalThis.localStorage.setItem('AuthenticationService:token', '{ invalid-json');
@@ -77,84 +83,35 @@ describe('AuthenticationClientService Error Handling & Stuck States', () => {
         expect(service.token()).toBeUndefined();
         expect(mockLogger.warn).toHaveBeenCalled(); // Should warn about parse error
     });
-    test('Unrecoverable Errors: should logout on InvalidTokenError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new InvalidTokenError());
+    test.each([
+        ['InvalidTokenError', new InvalidTokenError()],
+        ['NotFoundError', new NotFoundError('Session not found')],
+        ['ForbiddenError', new ForbiddenError()],
+        ['UnauthorizedError', new UnauthorizedError()],
+        ['NotSupportedError', new NotSupportedError()],
+        ['BadRequestError', new BadRequestError()],
+    ])('Unrecoverable Errors: should logout on %s during refresh', async (_, error) => {
+        setupServiceWithToken();
+        mockApiClient.refresh.mockRejectedValue(error);
         // Wait for loop to pick up refresh
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on NotFoundError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new NotFoundError('Session not found'));
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on ForbiddenError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new ForbiddenError());
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on UnauthorizedError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new UnauthorizedError());
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on NotSupportedError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new NotSupportedError());
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on BadRequestError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new BadRequestError());
-        await timeout(100);
+        await timeout(20);
         expect(mockApiClient.endSession).toHaveBeenCalled();
         expect(service.token()).toBeUndefined();
     });
     test('Recoverable Errors: should NOT logout on generic Error during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
+        setupServiceWithToken();
         mockApiClient.refresh.mockRejectedValue(new Error('Network failure'));
-        await timeout(100);
+        await timeout(20);
         // Should NOT have called endSession (logout)
         expect(mockApiClient.endSession).not.toHaveBeenCalled();
         // Token should still be present (retry logic handles it)
         expect(service.token()).toBeDefined();
+        // Trigger immediate retry to finish test quickly
+        service.requestRefresh();
+        await timeout(20);
     });
     test('Logout Failure: should clear local token even if server logout fails', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 1000, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
+        setupServiceWithToken(-1000, 1000);
         mockApiClient.endSession.mockRejectedValue(new Error('Network error during logout'));
         await service.logout();
         expect(mockApiClient.endSession).toHaveBeenCalled();

package/authentication/tests/authentication.client-service-refresh.test.js

@@ -65,59 +65,59 @@ describe('AuthenticationClientService Refresh Loop Reproduction', () => {
     test('Zombie Timer: loop should wake up immediately when token changes', async () => {
         // 1. Mock a long expiration
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 3600, jti: 'initial' };
+        const initialToken = { iat: now - 3600, exp: now + 3600, jti: 'initial' };
         // Set in storage so initialize() (called by resolve) loads it
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         service = injector.resolve(AuthenticationClientService);
         // Wait for loop to enter the race condition (wait phase)
-        await timeout(100);
+        await timeout(20);
         // 2. Change token
-        const newToken = { exp: now + 3600, jti: 'new' };
+        const newToken = { iat: now - 1800, exp: now + 3600, jti: 'new' };
         mockApiClient.refresh.mockResolvedValue(newToken);
         service.requestRefresh(); // This should trigger immediate wake up
         // Wait for loop to process
-        await timeout(100);
+        await timeout(20);
         expect(mockApiClient.refresh).toHaveBeenCalled();
     });
     test('Forced Refresh Loss: forceRefreshToken should not be cleared on failure', async () => {
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 3600, jti: 'initial' };
+        const initialToken = { iat: now - 3600, exp: now + 3600, jti: 'initial' };
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         service = injector.resolve(AuthenticationClientService);
-        await timeout(100);
+        await timeout(20);
         // 1. Mock refresh failure
         mockApiClient.refresh.mockRejectedValue(new Error('Network Error'));
         service.requestRefresh();
         // Wait for loop to attempt refresh and fail
-        await timeout(200);
+        await timeout(50);
         expect(mockApiClient.refresh).toHaveBeenCalled();
         expect(service.forceRefreshToken.isSet).toBe(true); // Should STILL be set
     });
     test('Lock Contention Backoff: should wait 5 seconds and not busy-loop', async () => {
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' }; // Expiring soon
+        const initialToken = { iat: now - 3600, exp: now + 5, jti: 'initial' }; // Expiring soon
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         // 1. Mock lock already held
         mockLock.tryUse.mockResolvedValue(undefined); // lockAcquired = false
         const startTime = Date.now();
         service = injector.resolve(AuthenticationClientService);
-        // We expect it to try once, fail to get lock, and then wait 5 seconds.
-        await timeout(300);
+        // We expect it to try once, fail to get lock, and then wait some time.
+        await timeout(50);
         expect(mockLock.tryUse).toHaveBeenCalledTimes(1);
         // Check if it's still waiting (not finished loop)
         const duration = Date.now() - startTime;
-        expect(duration).toBeLessThan(1000);
+        expect(duration).toBeLessThan(500);
     });
     test('Busy Loop: should not busy loop when forceRefreshToken is set and lock is held', async () => {
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 3600, jti: 'initial' };
+        const initialToken = { iat: now - 3600, exp: now + 3600, jti: 'initial' };
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         // Mock lock already held
         mockLock.tryUse.mockResolvedValue(undefined);
         service = injector.resolve(AuthenticationClientService);
-        await timeout(100);
+        await timeout(20);
         service.requestRefresh(); // Set the flag
-        await timeout(300);
+        await timeout(50);
         // If it busy loops, this will be much higher than 1.
         expect(mockLock.tryUse.mock.calls.length).toBeLessThan(5);
     });

package/cancellation/token.d.ts

@@ -46,6 +46,7 @@ export type ConnectConfig = {
  * (emits when set).
  */
 export declare class CancellationSignal implements PromiseLike<void>, Subscribable<void> {
+    #private;
     protected readonly _stateSubject: BehaviorSubject<boolean>;
     /**
      * Observable which emits the current state (true for set, false for unset)
@@ -91,6 +92,11 @@ export declare class CancellationSignal implements PromiseLike<void>, Subscribab
      * @internal
      */
     constructor(stateSubject: BehaviorSubject<boolean>);
+    /**
+     * Returns a standard `AbortSignal` that is aborted when this token is set.
+     * Useful for interoperability with APIs like `fetch`.
+     */
+    get abortSignal(): AbortSignal;
     /**
      * Returns a standard `AbortSignal` that is aborted when this token is set.
      * Useful for interoperability with APIs like `fetch`.

package/cancellation/token.js

@@ -15,6 +15,7 @@ import { isBoolean } from '../utils/type-guards.js';
  */
 export class CancellationSignal {
     _stateSubject;
+    #abortSignal;
     /**
      * Observable which emits the current state (true for set, false for unset)
      * and any subsequent state changes.
@@ -74,6 +75,13 @@ export class CancellationSignal {
     constructor(stateSubject) {
         this._stateSubject = stateSubject;
     }
+    /**
+     * Returns a standard `AbortSignal` that is aborted when this token is set.
+     * Useful for interoperability with APIs like `fetch`.
+     */
+    get abortSignal() {
+        return (this.#abortSignal ??= this.asAbortSignal());
+    }
     /**
      * Returns a standard `AbortSignal` that is aborted when this token is set.
      * Useful for interoperability with APIs like `fetch`.

package/document-management/server/services/document-file.service.js

@@ -6,7 +6,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import sharp, {} from 'sharp';
 import { match } from 'ts-pattern';
-import { injectGenkit } from '../../../ai/genkit/index.js';
 import { ForbiddenError } from '../../../errors/forbidden.error.js';
 import { NotImplementedError } from '../../../errors/not-implemented.error.js';
 import { getMimeType, getMimeTypeExtensions, mimeTypes } from '../../../file/index.js';
@@ -20,14 +19,15 @@ import { digest } from '../../../utils/cryptography.js';
 import { currentTimestamp } from '../../../utils/date-time.js';
 import { getRandomString } from '../../../utils/random.js';
 import { readableStreamFromPromise, readBinaryStream } from '../../../utils/stream/index.js';
-import { isNotReadableStream, isNotUint8Array, isUint8Array } from '../../../utils/type-guards.js';
+import { isNotReadableStream, isNotUint8Array, isString, isUint8Array } from '../../../utils/type-guards.js';
 import { millisecondsPerMinute } from '../../../utils/units.js';
 import { Document } from '../../models/index.js';
 import { DocumentManagementConfiguration } from '../module.js';
+import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentFileService = class DocumentFileService extends Transactional {
     #configuration = inject(DocumentManagementConfiguration);
-    #genkit = injectGenkit();
+    #documentManagementAncillaryService = inject(DocumentManagementAncillaryService);
     #fileObjectStorage = inject(ObjectStorage, this.#configuration.fileObjectStorageModule);
     #filePreviewObjectStorage = inject(ObjectStorage, this.#configuration.filePreviewObjectStorageModule);
     #fileUploadObjectStorage = inject(ObjectStorage, { module: this.#configuration.fileUploadObjectStorageModule /* , configuration: { lifecycle: { expiration: { after: 5 * secondsPerMinute } } } */ });
@@ -86,7 +86,10 @@ let DocumentFileService = class DocumentFileService extends Transactional {
         return this.#fileObjectStorage.getContentStream(objectKey);
     }
     async getContentUrl(document, download = false) {
-        return await this.getDocumentFileContentObjectUrl(document, document.title ?? document.id, download);
+        const resolvedFilename = await this.#documentManagementAncillaryService.getDocumentFilename(document);
+        const fileExtension = getMimeTypeExtensions(document.mimeType)[0] ?? 'bin';
+        const filename = isString(resolvedFilename) ? `${resolvedFilename}.${fileExtension}` : resolvedFilename.fullname;
+        return await this.getDocumentFileContentObjectUrl(document, filename, download);
     }
     /** Gets the underlying object storage object for the document file */
     async getObject(document) {
@@ -132,14 +135,12 @@ let DocumentFileService = class DocumentFileService extends Transactional {
             await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, contentType: 'image/webp' });
         }
     }
-    async getDocumentFileContentObjectUrl(document, title, download) {
+    async getDocumentFileContentObjectUrl(document, filename, download) {
         const key = getObjectKey(document.id);
-        const fileExtension = getMimeTypeExtensions(document.mimeType)[0] ?? 'bin';
         const disposition = download ? 'attachment' : 'inline';
-        const filename = `${title}.${fileExtension}`;
         return await this.#fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
-            'Response-Content-Type': document.mimeType,
-            'Response-Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`,
+            'Content-Type': document.mimeType,
+            'Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`,
         });
     }
 };

package/document-management/server/services/document-management-ancillary.service.d.ts

@@ -1,5 +1,9 @@
-import type { DocumentCollection } from '../../models/index.js';
+import type { Document, DocumentCollection } from '../../models/index.js';
 import type { DocumentCollectionMetadata } from '../../service-models/index.js';
+export type DocumentFileNameResult = string | {
+    /** The full name of the document, including extension. */
+    fullname: string;
+};
 export declare abstract class DocumentManagementAncillaryService {
     /**
      * Resolves application-specific metadata for a list of document collections.
@@ -7,4 +11,11 @@ export declare abstract class DocumentManagementAncillaryService {
      * @returns A promise that resolves to an array of DocumentCollectionMetadata, corresponding to the input collections.
      */
     abstract resolveMetadata(tenantId: string, collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
+    /**
+     * Resolve the file name for a document, which will be used when downloading the document file. The file extension is automatically determined based on the document's MIME type, so the returned file name should not include the extension.
+     * @param document The Document entity for which to resolve the file name.
+     * @param title An optional title provided by the api call.
+     * @returns The resolved file name for the document, without the file extension.
+     */
+    getDocumentFilename(document: Document): DocumentFileNameResult | Promise<DocumentFileNameResult>;
 }

package/document-management/server/services/document-management-ancillary.service.js

@@ -1,2 +1,11 @@
 export class DocumentManagementAncillaryService {
+    /**
+     * Resolve the file name for a document, which will be used when downloading the document file. The file extension is automatically determined based on the document's MIME type, so the returned file name should not include the extension.
+     * @param document The Document entity for which to resolve the file name.
+     * @param title An optional title provided by the api call.
+     * @returns The resolved file name for the document, without the file extension.
+     */
+    getDocumentFilename(document) {
+        return document.title ?? document.originalFileName ?? document.id;
+    }
 }

package/file/server/temporary-file.d.ts

@@ -12,7 +12,7 @@ export declare class TemporaryFile implements AsyncDisposable {
     /**
      * Prevents the temporary file from being deleted on disposal.
      */
-    keep(): void;
+    keep(): this;
     read(): Promise<Uint8Array>;
     readText(): Promise<string>;
     readStream(): ReadableStream<Uint8Array>;
@@ -25,5 +25,6 @@ export declare class TemporaryFile implements AsyncDisposable {
     moveTo(path: string, keep?: boolean): Promise<void>;
     delete(): Promise<void>;
     size(): Promise<number>;
+    dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 }

package/file/server/temporary-file.js

@@ -36,6 +36,7 @@ export class TemporaryFile {
      */
     keep() {
         this.#keep = true;
+        return this;
     }
     async read() {
         return await readFile(this.#path);
@@ -69,7 +70,7 @@ export class TemporaryFile {
         const result = await stat(this.#path);
         return result.size;
     }
-    async [Symbol.asyncDispose]() {
+    async dispose() {
         if (this.#keep) {
             return;
         }
@@ -78,4 +79,7 @@ export class TemporaryFile {
         }
         catch { }
     }
+    async [Symbol.asyncDispose]() {
+        await this.dispose();
+    }
 }

package/http/client/adapters/undici.adapter.js

@@ -20,7 +20,6 @@ export class UndiciHttpClientAdapterOptions {
 ;
 let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAdapter {
     options = inject(UndiciHttpClientAdapterOptions, undefined, { optional: true }) ?? {};
-    // eslint-disable-next-line max-lines-per-function, max-statements
     async call(httpClientRequest) {
         let body;
         if (isDefined(httpClientRequest.body?.json)) {
@@ -64,7 +63,6 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
             const httpClientResponse = new HttpClientResponse({
                 request: httpClientRequest,
                 statusCode: response.statusCode,
-                statusMessage: '?',
                 headers: new HttpHeaders(response.headers),
                 body: response.body,
                 closeHandler: () => response.body.destroy(),

package/http/client/http-client-request.d.ts

@@ -34,6 +34,7 @@ export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url
         formData?: HttpFormDataObject | FormData;
     };
     abortSignal?: CancellationSignal;
+    priority?: RequestPriority;
 };
 export type HttpRequestCredentials = 'omit' | 'same-origin' | 'include';
 export type HttpClientRequestObject = HttpClientRequestOptions & {
@@ -95,6 +96,7 @@ export declare class HttpClientRequest implements Disposable {
     credentials: HttpRequestCredentials | undefined;
     authorization: HttpRequestAuthorization | undefined;
     body: HttpRequestBody | undefined;
+    priority: RequestPriority | undefined;
     /**
      * Request timeout in milliseconds
      * @default 30000

package/http/client/http-client-request.js

@@ -61,6 +61,7 @@ export class HttpClientRequest {
     credentials;
     authorization;
     body;
+    priority;
     /**
      * Request timeout in milliseconds
      * @default 30000
@@ -101,6 +102,7 @@ export class HttpClientRequest {
         this.authorization = requestOptions.authorization;
         this.body = normalizeBody(requestOptions.body);
         this.credentials = requestOptions.credentials;
+        this.priority = requestOptions.priority;
         this.timeout = requestOptions.timeout ?? 30000;
         this.throwOnNon200 = requestOptions.throwOnNon200 ?? true;
         this.context = requestOptions.context ?? {};
@@ -122,6 +124,7 @@ export class HttpClientRequest {
         request.authorization = clone(request.authorization, true);
         request.urlParameters = new HttpUrlParameters(request.urlParameters);
         request.body = normalizeBody(request.body);
+        request.priority = this.priority;
         return request;
     }
     asObject() {
@@ -135,6 +138,7 @@ export class HttpClientRequest {
             query: this.query.asObject(),
             authorization: this.authorization,
             body,
+            priority: this.priority,
             timeout: this.timeout,
             throwOnNon200: this.throwOnNon200,
             context: this.context,

package/http/client/http-client-response.d.ts

@@ -9,7 +9,7 @@ export type HttpClientResponseObject = TypedOmit<HttpClientResponse, 'hasBody' |
 export type HttpClientResponseOptions = {
     request: HttpClientRequest;
     statusCode: number;
-    statusMessage: string | null;
+    statusMessage?: string | null;
     headers: HttpHeadersObject | HttpHeaders;
     body: HttpBody | HttpBodySource;
     closeHandler: () => void;

package/http/client/http-client-response.js

@@ -1,6 +1,7 @@
 import { isString } from '../../utils/type-guards.js';
 import { HttpBody } from '../http-body.js';
 import { HttpHeaders } from '../http-headers.js';
+import { getHttpStatusMessage } from '../utils.js';
 export class HttpClientResponse {
     closeHandler;
     request;
@@ -14,7 +15,7 @@ export class HttpClientResponse {
     constructor(options) {
         this.request = options.request;
         this.statusCode = options.statusCode;
-        this.statusMessage = (isString(options.statusMessage) && (options.statusMessage.length > 0)) ? options.statusMessage : null;
+        this.statusMessage = (isString(options.statusMessage) && (options.statusMessage.length > 0)) ? options.statusMessage : getHttpStatusMessage(this.statusCode);
         this.headers = new HttpHeaders(options.headers);
         this.body = (options.body instanceof HttpBody) ? options.body : new HttpBody(options.body, this.headers);
         this.closeHandler = options.closeHandler;
@@ -28,7 +29,7 @@ export class HttpClientResponse {
             statusCode: this.statusCode,
             statusMessage: this.statusMessage,
             headers: this.headers.asObject(),
-            body: this.body
+            body: this.body,
         };
         return obj;
     }

package/http/utils.d.ts

@@ -15,4 +15,10 @@ export declare function readBodyAsTextStream(body: Body, headers: HttpHeaders, o
 export declare function readBodyAsJson(body: Body, headers: HttpHeaders, options?: ReadBodyAsJsonOptions): Promise<UndefinableJson>;
 export declare function readBody(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string | UndefinableJson | Uint8Array>;
 export declare function readBodyAsStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
+/**
+ * Returns the standard HTTP status message for a given status code.
+ * @param statusCode The HTTP status code.
+ * @returns The standard status message, or 'Unknown' if the code is not recognized.
+ */
+export declare function getHttpStatusMessage(statusCode: number): string;
 export {};

package/http/utils.js

@@ -104,3 +104,74 @@ function ensureSize(length, options) {
         throw MaxBytesExceededError.fromBytes(options.maxBytes);
     }
 }
+const httpStatusMessages = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Content Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: 'I\'m a teapot',
+    421: 'Misdirected Request',
+    422: 'Unprocessable Content',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required',
+};
+/**
+ * Returns the standard HTTP status message for a given status code.
+ * @param statusCode The HTTP status code.
+ * @returns The standard status message, or 'Unknown' if the code is not recognized.
+ */
+export function getHttpStatusMessage(statusCode) {
+    return httpStatusMessages[statusCode] ?? `Unknown (${statusCode})`;
+}

package/injector/injector.js

@@ -7,6 +7,7 @@ import { DeferredPromise } from '../promise/deferred-promise.js';
 import { reflectionRegistry } from '../reflection/registry.js';
 import { toArray } from '../utils/array/array.js';
 import { FactoryMap } from '../utils/factory-map.js';
+import { noop } from '../utils/noop.js';
 import { ForwardRef } from '../utils/object/forward-ref.js';
 import { objectEntries } from '../utils/object/object.js';
 import { assert, isArray, isDefined, isFunction, isNotNull, isNotObject, isNull, isPromise, isUndefined } from '../utils/type-guards.js';
@@ -597,6 +598,7 @@ function newInternalResolveContext(injector) {
         forwardRefs: new Set(),
         $done: new DeferredPromise(),
     };
+    void context.$done.catch(noop); // prevent unhandled rejection if no one is awaiting it
     return context;
 }
 function postProcess(context) {

package/mail/drizzle/0000_numerous_the_watchers.sql

@@ -0,0 +1,8 @@
+CREATE TABLE "mail"."log" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"timestamp" timestamp with time zone NOT NULL,
+	"template" text,
+	"data" jsonb NOT NULL,
+	"send_result" jsonb,
+	"errors" text[]
+);

package/mail/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "f8cdba37-11b9-477a-9f5a-5ef4b5026011",
+  "id": "0c48afa4-9ab0-4965-a93e-05a6c1b88e58",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -44,37 +44,6 @@
           "type": "text[]",
           "primaryKey": false,
           "notNull": false
-        },
-        "revision": {
-          "name": "revision",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "revision_timestamp": {
-          "name": "revision_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "create_timestamp": {
-          "name": "create_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "delete_timestamp": {
-          "name": "delete_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "attributes": {
-          "name": "attributes",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "'{}'::jsonb"
         }
       },
       "indexes": {},

package/mail/drizzle/meta/_journal.json

@@ -5,15 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1740059198387,
-      "tag": "0000_previous_malcolm_colcord",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "7",
-      "when": 1761124592125,
-      "tag": "0001_flimsy_bloodscream",
+      "when": 1771240070681,
+      "tag": "0000_numerous_the_watchers",
       "breakpoints": true
     }
   ]