@db3.ai/app 0.1.0-beta.1 → 0.1.0

package/dist/logging/DevelopmentConsole.js

@@ -0,0 +1,162 @@
+import { StringDecoder } from 'node:string_decoder';
+import { Writable } from 'node:stream';
+import { stripVTControlCharacters } from 'node:util';
+import { PrettyLogFormatter } from './PrettyLogFormatter.js';
+/**
+ * Owns grouped log output and a bounded live pending area in one terminal.
+ * Multi-process launchers must pipe every child's output through this owner;
+ * unrelated processes writing directly to the same TTY cannot be coordinated.
+ */
+export class DevelopmentConsole {
+    #output;
+    #write;
+    #formatter;
+    #interactive;
+    #restore = [];
+    #lines = [];
+    #timer;
+    #closed = false;
+    /**
+     * Creates a console owner without starting an HTTP server or taking stream ownership.
+     * @param options - Destination, terminal capability and stdio coordination.
+     */
+    constructor(options = {}) {
+        this.#output = options.output ?? process.stdout;
+        this.#write = this.#output.write.bind(this.#output);
+        this.#interactive = options.interactive ?? Boolean(this.#output.isTTY && process.env.TERM !== 'dumb');
+        this.#formatter = new PrettyLogFormatter(options.color ?? consoleColor(Boolean(this.#output.isTTY), process.env));
+        if (this.#interactive) {
+            if (options.coordinateStdio !== false && this.#output === process.stdout) {
+                this.#coordinate(process.stdout);
+                this.#coordinate(process.stderr);
+            }
+            this.#timer = setInterval(() => {
+                if (this.#lines.length && !this.#output.writableNeedDrain)
+                    this.#render('');
+            }, 250);
+            this.#timer.unref();
+            const resize = () => { this.#render(''); };
+            this.#output.on('resize', resize);
+            this.#restore.push(() => { this.#output.off('resize', resize); });
+        }
+        const exit = () => { this.close(); };
+        process.once('exit', exit);
+        this.#restore.push(() => { process.off('exit', exit); });
+    }
+    /** Accepts a complete Pino JSON line, retaining ordinary non-log text verbatim. */
+    write(line) {
+        if (this.#closed)
+            return;
+        try {
+            const record = JSON.parse(line);
+            if (record && typeof record === 'object' && typeof record.level === 'number') {
+                this.#render(this.#formatter.format(record));
+                return;
+            }
+        }
+        catch { /* Non-JSON output from tools is ordinary terminal text. */ }
+        this.writeText(line);
+    }
+    /** Writes tool output above pending rows, removing controls that clear terminal history. */
+    writeText(text) {
+        if (this.#closed || !text)
+            return;
+        const safe = stripVTControlCharacters(text).replace(/\r/g, '').replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+        this.#render(safe.endsWith('\n') ? safe : `${safe}\n`);
+    }
+    /**
+     * Creates a separately buffered child stdout/stderr sink, handling split UTF-8
+     * and final unterminated lines. Long non-JSON lines are forwarded in bounded chunks.
+     * @returns A writable input; end it when its child stream closes.
+     */
+    createInput() {
+        const decoder = new StringDecoder('utf8');
+        let pending = '';
+        const consume = (text) => {
+            pending += text;
+            let newline;
+            while ((newline = pending.indexOf('\n')) !== -1) {
+                this.write(pending.slice(0, newline));
+                pending = pending.slice(newline + 1);
+            }
+            if (pending.length > 256 * 1024) {
+                this.writeText(pending);
+                pending = '';
+            }
+        };
+        return new Writable({
+            write: (chunk, _encoding, callback) => { consume(decoder.write(chunk)); callback(); },
+            final: callback => { consume(decoder.end()); if (pending)
+                this.write(pending); callback(); },
+        });
+    }
+    /** Finalizes pending work from an exited child without disturbing other children. */
+    endSource(pid) { this.#render(this.#formatter.finish(pid)); }
+    /** Waits for previously rendered output to reach the caller-owned destination. */
+    async flush() {
+        await new Promise((resolve, reject) => { this.#write('', error => error ? reject(error) : resolve()); });
+    }
+    /** Clears only owned rows, releases timers/listeners and restores patched stdio. */
+    close() {
+        if (this.#closed)
+            return;
+        clearInterval(this.#timer);
+        this.#render(this.#formatter.finish());
+        this.#closed = true;
+        for (const restore of this.#restore.reverse())
+            restore();
+    }
+    /** Replaces only the live footer and appends immutable completed output above it. */
+    #render(text) {
+        if (this.#closed)
+            return;
+        if (!this.#interactive) {
+            if (text)
+                this.#write(text);
+            return;
+        }
+        const columns = Math.max(1, this.#output.columns ?? 80);
+        const occupied = this.#lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(line.length / columns)), 0);
+        const clear = occupied ? `\u001b[${occupied}A\r\u001b[J` : '';
+        const pending = this.#formatter.pending();
+        const maximum = Math.max(1, Math.min(5, (this.#output.rows ?? 24) - 3));
+        const visible = pending.slice(0, maximum);
+        if (pending.length > maximum)
+            visible[maximum - 1] = `[http] … ${pending.length - maximum + 1} more requests waiting`;
+        // ASCII in mutable rows gives exact terminal-cell counts across resizes.
+        this.#lines = columns < 20 ? [] : visible.map(line => line.replace(/→/g, '->').replace(/[^\x20-\x7e]/g, ' ').slice(0, columns - 1));
+        const footer = this.#lines.length ? this.#lines.join('\n') + '\n' : '';
+        if (clear || text || footer)
+            this.#write(clear + text + footer);
+    }
+    /** Serializes same-process writes with redraws while preserving write callbacks. */
+    #coordinate(stream) {
+        const original = stream.write;
+        const write = (chunk, encoding, callback) => {
+            this.writeText(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString(typeof encoding === 'string' ? encoding : 'utf8'));
+            const done = typeof encoding === 'function' ? encoding : callback;
+            return this.#write('', done);
+        };
+        stream.write = write;
+        this.#restore.push(() => { if (stream.write === write)
+            stream.write = original; });
+    }
+}
+/**
+ * Whether the pretty console uses colour. `NO_COLOR` turns it off; a set
+ * `FORCE_COLOR` (other than `0` or `false`) turns it on even without a TTY, as
+ * when a process manager pipes output into its own terminal view; otherwise a
+ * TTY decides.
+ *
+ * @param isTTY - Whether the output stream is a terminal.
+ * @param env - Process environment.
+ * @returns Whether to emit ANSI colours.
+ */
+export function consoleColor(isTTY, env) {
+    if (env.NO_COLOR !== undefined)
+        return false;
+    const force = env.FORCE_COLOR;
+    if (force === '0' || force === 'false')
+        return false;
+    return force !== undefined || isTTY;
+}

package/dist/logging/Log.d.ts

@@ -1,4 +1,5 @@
 import type { ChildLoggerOptions } from 'pino';
+import type { Mail } from '../mail/index.js';
 import type * as logging from './contracts/index.js';
 /**
  * Application logging service exposed as `app().log`.
@@ -15,8 +16,9 @@ export declare class Log implements logging.Logger {
      * Creates the application logger from explicit options or the Pino driver.
      *
      * @param options - Logging level, destinations, context, and driver overrides.
+     * @param mail - Lazy application Mail resolver, required when email is configured.
      */
-    constructor(options?: logging.LoggingOptions);
+    constructor(options?: logging.LoggingOptions, mail?: () => Mail);
     /** Returns the current trace function, respecting runtime level changes. */
     get trace(): logging.Logger['trace'];
     /** Returns the current debug function, respecting runtime level changes. */

package/dist/logging/Log.js

@@ -14,9 +14,12 @@ export class Log {
      * Creates the application logger from explicit options or the Pino driver.
      *
      * @param options - Logging level, destinations, context, and driver overrides.
+     * @param mail - Lazy application Mail resolver, required when email is configured.
      */
-    constructor(options = {}) {
-        this.#driver = options.driver ?? new PinoLoggerDriver(options);
+    constructor(options = {}, mail) {
+        if (options.driver && options.transports !== undefined)
+            throw new Error('Configured logging transports require the default Pino driver.');
+        this.#driver = options.driver ?? new PinoLoggerDriver(options, undefined, mail);
     }
     /** Returns the current trace function, respecting runtime level changes. */
     get trace() { return this.#driver.logger.trace.bind(this.#driver.logger); }

package/dist/logging/PrettyLogFormatter.d.ts

@@ -0,0 +1,16 @@
+/** Groups redacted HTTP lifecycle records while preserving ordinary diagnostic logs. */
+export declare class PrettyLogFormatter {
+    #private;
+    /** Creates a formatter; terminal capability is resolved by the console owner. */
+    constructor(color?: boolean);
+    /**
+     * Accepts one redacted Pino record and returns any completed output.
+     * Request context is bounded to 1,000 entries. Eviction is explicitly reported;
+     * later completions still print even when their earlier context is unavailable.
+     */
+    format(record: Record<string, unknown>, now?: number): string;
+    /** Returns waiting rows without mutating completed output or request order. */
+    pending(now?: number): string[];
+    /** Finalizes requests whose transport ended before a completion record arrived. */
+    finish(sourcePid?: number): string;
+}

package/dist/logging/PrettyLogFormatter.js

@@ -0,0 +1,151 @@
+import { STATUS_CODES } from 'node:http';
+import { highlightQueueMessage } from './highlightQueueMessage.js';
+/** Groups redacted HTTP lifecycle records while preserving ordinary diagnostic logs. */
+export class PrettyLogFormatter {
+    #requests = new Map();
+    #ended = new Set();
+    #color;
+    /** Creates a formatter; terminal capability is resolved by the console owner. */
+    constructor(color = false) { this.#color = color; }
+    /**
+     * Accepts one redacted Pino record and returns any completed output.
+     * Request context is bounded to 1,000 entries. Eviction is explicitly reported;
+     * later completions still print even when their earlier context is unavailable.
+     */
+    format(record, now = Date.now()) {
+        const message = record.msg;
+        const key = requestKey(record);
+        const request = object(record.req);
+        const exchange = object(record.httpExchange);
+        const route = requestRoute(request);
+        if (message === 'incoming request' && record.reqId != null && route) {
+            this.#ended.delete(key);
+            let evicted = '';
+            if (this.#requests.size >= 1000) {
+                const oldest = this.#requests.keys().next().value;
+                const pending = this.#requests.get(oldest);
+                evicted = this.#http(pending.record, pending, 'tracking limit reached; response still pending');
+                this.#requests.delete(oldest);
+            }
+            this.#requests.set(key, { record, route, started: now });
+            return evicted;
+        }
+        if (message === 'request exchange' && exchange && Number(record.level ?? 30) <= 30) {
+            if (record.reqId != null && this.#ended.has(key))
+                return '';
+            const pending = this.#requests.get(key);
+            if (pending) {
+                pending.exchange = exchange;
+                return '';
+            }
+            // A missing arrival (e.g. a filtered log level) must not lose the payload.
+            return this.#http(record, { record, route: requestRoute(object(exchange.request)) || 'Request', started: now, exchange });
+        }
+        if (['request completed', 'request errored', 'request aborted', 'request timed out'].includes(String(message))) {
+            if (record.reqId != null) {
+                if (this.#ended.has(key))
+                    return '';
+                if (this.#ended.size >= 1000)
+                    this.#ended.delete(this.#ended.values().next().value);
+                this.#ended.add(key);
+            }
+            const pending = this.#requests.get(key);
+            this.#requests.delete(key);
+            const outcome = message === 'request completed' ? undefined : message === 'request errored' ? 'failed' : message === 'request aborted' ? 'cancelled' : 'timed out';
+            return this.#http(record, pending ?? { record, route: route || 'Request', started: now }, outcome);
+        }
+        const severity = Number(record.level ?? 30);
+        const category = severity >= 50 ? 'error' : severity >= 40 ? 'warn' : typeof record.component === 'string' ? record.component : severity <= 20 ? 'debug' : 'app';
+        const context = Object.entries(record).filter(([key, value]) => !hiddenFields.has(key) && value != null).slice(0, 8).map(([key, value]) => `${compact(key, 40)}=${compact(value, 100)}`).join('  ');
+        const details = errorDetails(record.err ?? record.error);
+        return `${this.#paint(timestamp(record.time), 90)} ${this.#paint(`[${compact(category, 30)}]`, severity >= 50 ? 31 : severity >= 40 ? 33 : 36)} ${this.#message(compact(record.msg ?? '', 500))}${context ? `  ${this.#paint(context, 90)}` : ''}\n${details ? indent(details) + '\n' : ''}`;
+    }
+    /** Returns waiting rows without mutating completed output or request order. */
+    pending(now = Date.now()) {
+        return [...this.#requests.values()].map(request => {
+            const elapsed = Math.max(0, now - request.started);
+            return `[http] ${request.route}  ${elapsed >= 5000 ? 'slow · ' : ''}waiting · ${(elapsed / 1000).toFixed(1)} s  #${request.record.reqId}`;
+        });
+    }
+    /** Finalizes requests whose transport ended before a completion record arrived. */
+    finish(sourcePid) {
+        let output = '';
+        for (const [key, pending] of this.#requests) {
+            if (sourcePid !== undefined && pending.record.pid !== sourcePid)
+                continue;
+            output += this.#http(pending.record, pending, 'interrupted · process stopped before response');
+            this.#requests.delete(key);
+        }
+        return output;
+    }
+    /** Renders a single immutable HTTP block, including readable payload previews. */
+    #http(record, pending, outcome) {
+        const status = object(record.res)?.statusCode ?? object(pending.exchange?.response)?.statusCode;
+        const statusText = typeof status === 'number' ? `${status} ${STATUS_CODES[status] ?? ''}`.trim() : '';
+        const elapsed = typeof record.responseTime === 'number' && Number.isFinite(record.responseTime) ? ` · ${Math.round(record.responseTime)} ms` : '';
+        const tone = outcome || Number(status) >= 500 ? 31 : Number(status) >= 400 ? 33 : 32;
+        const reference = record.reqId == null ? '' : `  #${compact(record.reqId, 60)}`;
+        const bodies = bodyPreview(object(object(pending.exchange?.request)?.body), '> request') + bodyPreview(object(object(pending.exchange?.response)?.body), '< response');
+        const details = errorDetails(record.err ?? record.error);
+        return `${this.#paint(timestamp(pending.record.time), 90)} ${this.#paint('[http]', 36)} ${compact(pending.route, 240)}  ${this.#paint(outcome ?? (statusText || 'response'), tone)}${elapsed}${this.#paint(reference, 90)}\n${bodies}${details ? indent(details) + '\n' : ''}\n`;
+    }
+    /** Colours structural labels only, never application-controlled terminal escapes. */
+    #paint(text, code) { return this.#color ? `\u001b[${code}m${text}\u001b[0m` : text; }
+    /** Highlights queue states and job labels when colouring. */
+    #message(text) { return this.#color ? highlightQueueMessage(text, (part, code) => this.#paint(part, code)) : text; }
+}
+const hiddenFields = new Set(['level', 'time', 'pid', 'hostname', 'source', 'environment', 'release', 'component', 'msg', 'req', 'res', 'httpExchange', 'responseTime', 'err', 'error']);
+/** Separates processes and sources that independently allocate Fastify request IDs. */
+function requestKey(record) { return JSON.stringify([record.pid, record.source, record.reqId]); }
+/** Narrows optional parsed context without trusting arbitrary application values. */
+function object(value) { return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
+/** Extracts the method and URL without headers or payload duplication. */
+function requestRoute(request) { return typeof request?.method === 'string' && typeof request.url === 'string' ? `${request.method} → ${request.url}` : ''; }
+/** Formats local wall time with a stable fallback for non-Pino input. */
+function timestamp(value) {
+    const date = new Date(typeof value === 'number' || typeof value === 'string' ? value : NaN);
+    return Number.isNaN(date.getTime()) ? '--:--:--' : [date.getHours(), date.getMinutes(), date.getSeconds()].map(part => String(part).padStart(2, '0')).join(':');
+}
+/** Prevents control injection and bounds single-line summaries. */
+function compact(value, limit) {
+    const text = clean(typeof value === 'string' ? value : JSON.stringify(value) ?? String(value)).replace(/\s+/g, ' ');
+    return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+}
+/** Strips terminal controls while retaining readable line breaks. */
+function clean(text) { return text.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '').replace(/[\u0000-\u0009\u000b-\u001f\u007f-\u009f]/g, ''); }
+/** Indents diagnostic text consistently beneath its owning request or message. */
+function indent(text) { return text.split('\n').map(line => `    ${line}`).join('\n'); }
+/** Shows small JSON inline and larger JSON as a bounded, explicitly shortened preview. */
+function bodyPreview(body, label) {
+    if (!body || body.kind === 'empty')
+        return '';
+    let text;
+    if (body.value === undefined)
+        text = String(body.note ?? `${body.kind} body omitted`);
+    else if (body.kind === 'json' && !body.truncated) {
+        const expanded = JSON.stringify(body.value, null, 2);
+        const inline = expanded.replace(/\n\s*/g, ' ');
+        text = inline.length <= 90 ? inline : expanded;
+    }
+    else
+        text = String(body.value);
+    const lines = clean(text).split('\n');
+    const visible = lines.slice(0, 20).map(line => line.length > 160 ? `${line.slice(0, 159)}… [line shortened]` : line);
+    if (lines.length > 20)
+        visible.push(`… ${lines.length - 20} more lines (full captured body in JSON logs/devtools)`);
+    if (body.truncated)
+        visible.push(`… capture truncated (${body.sizeBytes ?? 'unknown'} bytes before limit)`);
+    return `  ${label}\n${indent(visible.join('\n'))}\n`;
+}
+/** Preserves bounded error stacks and nested causes without terminal control sequences. */
+function errorDetails(value, depth = 0) {
+    if (value == null || depth > 4)
+        return '';
+    const error = object(value);
+    if (!error)
+        return compact(value, 2000);
+    const stack = typeof error.stack === 'string' ? clean(error.stack) : compact(`${error.type ?? 'Error'}: ${error.message ?? JSON.stringify(error)}`, 2000);
+    const detail = stack.length > 16000 ? stack.slice(0, 16000) + '\n… stack shortened' : stack;
+    const cause = errorDetails(error.cause, depth + 1);
+    return `${detail}${cause ? `\nCaused by: ${cause}` : ''}`;
+}

package/dist/logging/acquireDevelopmentConsole.d.ts

@@ -0,0 +1,6 @@
+import { DevelopmentConsole } from './DevelopmentConsole.js';
+/** Shares one terminal owner across application loggers in the same process. */
+export declare function acquireDevelopmentConsole(): {
+    console: DevelopmentConsole;
+    release: () => void;
+};

package/dist/logging/acquireDevelopmentConsole.js

@@ -0,0 +1,21 @@
+import { DevelopmentConsole } from './DevelopmentConsole.js';
+let active;
+let leases = 0;
+/** Shares one terminal owner across application loggers in the same process. */
+export function acquireDevelopmentConsole() {
+    active ??= new DevelopmentConsole();
+    leases++;
+    let released = false;
+    return {
+        console: active,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            if (--leases === 0) {
+                active?.close();
+                active = undefined;
+            }
+        },
+    };
+}

package/dist/logging/contracts/DevelopmentConsoleOptions.d.ts

@@ -0,0 +1,16 @@
+import type { Writable } from 'node:stream';
+/** Terminal capabilities for the one renderer that owns a development output stream. */
+export interface DevelopmentConsoleOptions {
+    /** Output destination; defaults to process.stdout. The caller retains stream ownership. */
+    output?: Writable & {
+        isTTY?: boolean;
+        columns?: number;
+        rows?: number;
+    };
+    /** Enable pending-row redraws. Defaults to the output's terminal capability. */
+    interactive?: boolean;
+    /** Enable structural ANSI colours. Defaults to terminal support, respecting NO_COLOR. */
+    color?: boolean;
+    /** Coordinate console.log/warn and direct stdout/stderr writes in this process. Defaults to true for interactive stdout. */
+    coordinateStdio?: boolean;
+}

package/dist/logging/contracts/DevelopmentConsoleOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/logging/contracts/EmailLogOptions.d.ts

@@ -0,0 +1,8 @@
+import type { MailAddress } from '../../mail/index.js';
+/** Sends each error or fatal record to the configured operator through the application's Mail service. */
+export interface EmailLogOptions {
+    /** Explicit operator destination; disabled unless configured. */
+    to: MailAddress | MailAddress[];
+    /** Optional subject prefix identifying the application. Defaults to Application error. */
+    subjectPrefix?: string;
+}

package/dist/logging/contracts/EmailLogOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/logging/contracts/HttpExchangeMonitorOptions.d.ts

@@ -0,0 +1,12 @@
+import type { FastifyRequest } from 'fastify';
+/** Development HTTP payload capture policy, owned by the host application. */
+export interface HttpExchangeMonitorOptions {
+    /** Defaults to NODE_ENV; production and test never capture payloads. */
+    environment?: string;
+    /** Explicitly disables body capture independently of console presentation. */
+    enabled?: boolean;
+    /** Maximum bytes retained per body; defaults to 16 KiB, capped at 64 KiB. */
+    maxBodyBytes?: number;
+    /** Excludes sensitive routes from payload capture. Request summaries remain governed by route logging. */
+    exclude?: (request: FastifyRequest) => boolean;
+}

package/dist/logging/contracts/HttpExchangeMonitorOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/logging/contracts/LogTransportOptions.d.ts

@@ -0,0 +1,19 @@
+import type { EmailLogOptions } from './EmailLogOptions.js';
+import type { LogLevel } from './Logger.js';
+import type { DevtoolsLogOptions } from './LoggingOptions.js';
+/** A configured destination receiving records at its minimum severity or above. */
+export type LogTransportOptions = {
+    type: 'console';
+    level?: LogLevel;
+} | {
+    type: 'file';
+    level?: LogLevel;
+    destination: string;
+} | ({
+    type: 'email';
+    level?: LogLevel;
+} & EmailLogOptions) | {
+    type: 'devtools';
+    level?: LogLevel;
+    options?: DevtoolsLogOptions;
+};

package/dist/logging/contracts/LogTransportOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/logging/contracts/LoggingOptions.d.ts

@@ -1,3 +1,4 @@
+import type { LogTransportOptions } from './LogTransportOptions.js';
 import type { LoggerDriver } from './LoggerDriver.js';
 import type { LogBindings, LogLevel } from './Logger.js';
 /**
@@ -23,6 +24,10 @@ export interface DevtoolsLogOptions {
  * Application logging configuration.
  */
 export interface LoggingOptions {
+    /** Explicit destinations replace default console/file/devtools selection. An empty array disables output. */
+    transports?: LogTransportOptions[];
+    /** Optional JSON log file retained outside the process/container. The operator owns rotation and retention. */
+    file?: string;
     /** Injectable logging driver used by tests or alternate implementations. */
     driver?: LoggerDriver;
     /** Minimum emitted severity. Defaults to info, or silent in tests. */
@@ -37,8 +42,14 @@ export interface LoggingOptions {
     bindings?: LogBindings;
     /** Sensitive field paths removed before records reach any destination. */
     redact?: false | string[];
-    /** Writes newline-delimited JSON to standard output. Defaults to true. */
+    /** Writes logs to standard output. Defaults to true. */
     console?: boolean;
+    /**
+     * Console presentation only; files and devtools always retain structured JSON.
+     * Auto (the default) uses pretty output in development terminals and JSON
+     * elsewhere. Set PLATFORM_LOG_FORMAT to override the default process-wide.
+     */
+    consoleFormat?: 'auto' | 'pretty' | 'json';
     /**
      * Streams logs to Platform devtools.
      *

package/dist/logging/contracts/index.d.ts

@@ -2,3 +2,7 @@ export * from './HttpExchange.js';
 export * from './Logger.js';
 export * from './LoggerDriver.js';
 export * from './LoggingOptions.js';
+export * from './EmailLogOptions.js';
+export * from './DevelopmentConsoleOptions.js';
+export * from './HttpExchangeMonitorOptions.js';
+export * from './LogTransportOptions.js';

package/dist/logging/contracts/index.js

@@ -2,3 +2,7 @@ export * from './HttpExchange.js';
 export * from './Logger.js';
 export * from './LoggerDriver.js';
 export * from './LoggingOptions.js';
+export * from './EmailLogOptions.js';
+export * from './DevelopmentConsoleOptions.js';
+export * from './HttpExchangeMonitorOptions.js';
+export * from './LogTransportOptions.js';

package/dist/logging/drivers/PinoLoggerDriver.d.ts

@@ -1,5 +1,6 @@
 import { type DestinationStream, type Logger as PinoLogger } from 'pino';
 import type * as logging from '../contracts/index.js';
+import type { Mail } from '../../mail/index.js';
 /**
  * Pino-backed logger driver with optional worker-thread devtools delivery.
  */
@@ -11,8 +12,9 @@ export declare class PinoLoggerDriver implements logging.LoggerDriver {
      *
      * @param options - Framework logging configuration.
      * @param destination - Optional direct destination used by focused tests.
+     * @param mail - Application-owned mail service used by the email destination.
      */
-    constructor(options?: logging.LoggingOptions, destination?: DestinationStream);
+    constructor(options?: logging.LoggingOptions, destination?: DestinationStream, mail?: () => Mail);
     /**
      * Waits until Pino has handed accepted records to its destination.
      */