@tstdl/base 0.93.126 → 0.93.128

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/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/graph.js

@@ -1,5 +1,6 @@
 import { toArray } from '../utils/array/array.js';
 import { isArray, isDefined, isFunction } from '../utils/type-guards.js';
+import { typeOf } from '../utils/type-of.js';
 import { Injector } from './injector.js';
 import { afterResolve } from './interfaces.js';
 import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
@@ -185,8 +186,8 @@ export function getDependencyGraph(injector, options = {}) {
                     label += ' (multi)';
                 }
                 if (isDefined(node.argument)) {
-                    const s = JSON.stringify(node.argument);
-                    label += `\narg: ${s.length > 20 ? `${s.substring(0, 17)}...` : s}`;
+                    const s = isFunction(node.argument) ? typeOf(node.argument) : JSON.stringify(node.argument) ?? 'Could not stringify argument';
+                    label += `\narg: ${(s.length > 20) ? `${s.slice(0, 17)}...` : s}`;
                 }
                 if (node.isCached) {
                     label += '\n(cached)';
@@ -281,6 +282,7 @@ export function renderDependencyGraphToDot(graph, options = {}) {
         return tokenToId.get(token);
     };
     const lines = ['strict digraph G {'];
+    // --- Graph Global Attributes ---
     if (bgcolor) {
         lines.push(`  bgcolor=${JSON.stringify(bgcolor)};`);
     }
@@ -293,6 +295,7 @@ export function renderDependencyGraphToDot(graph, options = {}) {
     lines.push(`  node [shape=box, fontname=${JSON.stringify(fontname)}, style=filled, fillcolor="#f9f9f9", fontsize=${fontsize}];`);
     lines.push(`  edge [fontname=${JSON.stringify(fontname)}, fontsize=${fontsize - 1}];`);
     lines.push(`  rankdir=${rankdir}; compound=true;`);
+    // --- 1. Render Edges ---
     for (const edge of graph.edges) {
         const color = edge.isCycle ? '#e74c3c' : edge.color;
         const penwidth = edge.isCycle ? 2.0 : edge.penwidth;
@@ -304,18 +307,30 @@ export function renderDependencyGraphToDot(graph, options = {}) {
         ].filter(Boolean).join(', ');
         lines.push(`  ${getTokenId(edge.from)} -> ${getTokenId(edge.to)} [${attributes}];`);
     }
+    // --- Helper: Render Node Definition ---
     const renderNode = (node) => {
         const metadata = node.metadata;
         const lifecycle = metadata.lifecycle;
         const first = lifecycle.split('|')[0];
-        const colors = { singleton: '#d1e7dd', injector: '#fff3cd', resolution: '#cfe2ff', transient: '#f8d7da' };
-        const shapes = { singleton: 'doubleoctagon', injector: 'component', resolution: 'ellipse', transient: 'box' };
+        const colors = {
+            singleton: '#d1e7dd',
+            injector: '#fff3cd',
+            resolution: '#cfe2ff',
+            transient: '#f8d7da',
+        };
+        const shapes = {
+            singleton: 'doubleoctagon',
+            injector: 'component',
+            resolution: 'ellipse',
+            transient: 'box',
+        };
         const name = node.name + (metadata.hasAfterResolve ? ' *' : '');
         const label = showMetadata ? `${name}\n[${lifecycle}, ${metadata.type}]` : name;
         const fillcolor = colors[first] ?? '#f9f9f9';
         const shape = shapes[first] ?? 'box';
         return `    ${getTokenId(node.token)} [label=${JSON.stringify(label)}, fillcolor=${JSON.stringify(fillcolor)}, shape=${JSON.stringify(shape)}];`;
     };
+    // --- 2. Render Injector Clusters and Nodes ---
     const injectors = groupByInjector ? Array.from(graph.injectorNames.keys()) : [0];
     for (const injectorId of injectors) {
         if (groupByInjector) {
@@ -330,11 +345,14 @@ export function renderDependencyGraphToDot(graph, options = {}) {
                 if (!graph.nodes.has(owner)) {
                     continue;
                 }
-                const subNodes = Array.from(tokens).filter((token) => graph.nodes.has(token) && (!groupByInjector || graph.nodes.get(token).injectorId == injectorId)).map((token) => graph.nodes.get(token));
+                const subNodes = Array.from(tokens)
+                    .filter((token) => graph.nodes.has(token) && (!groupByInjector || graph.nodes.get(token).injectorId == injectorId))
+                    .map((token) => graph.nodes.get(token));
                 if (subNodes.length == 0) {
                     continue;
                 }
-                lines.push(`    subgraph cluster_${injectorId}_${getTokenId(owner)} { label = ${JSON.stringify(`Dynamic Resolutions of ${graph.nodes.get(owner).name}`)}; style = dashed; color = "#9b59b6"; fontname = ${JSON.stringify(fontname)}; fontsize = ${fontsize};`);
+                const ownerName = graph.nodes.get(owner).name;
+                lines.push(`    subgraph cluster_${injectorId}_${getTokenId(owner)} { label = ${JSON.stringify(`Dynamic Resolutions of ${ownerName}`)}; style = dashed; color = "#9b59b6"; fontname = ${JSON.stringify(fontname)}; fontsize = ${fontsize};`);
                 for (const node of subNodes) {
                     lines.push(renderNode(node));
                     inDynamic.add(node.token);
@@ -351,6 +369,7 @@ export function renderDependencyGraphToDot(graph, options = {}) {
             lines.push('  }');
         }
     }
+    // --- 3. Render Legend ---
     if (showLegend) {
         const legendFontSize = fontsize - 1;
         lines.push(`  subgraph cluster_legend { label = "Legend"; style = solid; color = gray; fontname = ${JSON.stringify(`${fontname}-Bold`)}; fontsize = ${fontsize + 1};`);
@@ -404,7 +423,9 @@ export function renderDependencyGraphToDot(graph, options = {}) {
         lines.push('    l_circular_from -> l_cached_from -> l_optional_from -> l_cross_from [style=invis];');
         lines.push('    l_circular_to -> l_cached_to -> l_optional_to -> l_cross_to [style=invis];');
         lines.push('    l_alias_from -> l_forward_from -> l_dynamic_from -> l_spacer_from [style=invis];');
+        lines.push('  }');
     }
+    lines.push('}');
     return lines.join('\n');
 }
 /**

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
     }
   ]