@aztec/foundation 0.0.0-test.0

package/dest/json-rpc/server/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/server/telemetry.ts"],"names":[],"mappings":""}

package/dest/json-rpc/test/index.d.ts

@@ -0,0 +1,2 @@
+export { createJsonRpcTestSetup, type JsonRpcTestContext } from './integration.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/json-rpc/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}

package/dest/json-rpc/test/index.js

@@ -0,0 +1 @@
+export { createJsonRpcTestSetup } from './integration.js';

package/dest/json-rpc/test/integration.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import type http from 'http';
+import type { ApiSchemaFor } from '../../schemas/api.js';
+import { type SafeJsonRpcClientOptions } from '../client/safe_json_rpc_client.js';
+import { type SafeJsonRpcServer, type SafeJsonRpcServerOptions } from '../server/safe_json_rpc_server.js';
+export type JsonRpcTestContext<T extends object> = {
+    server: SafeJsonRpcServer;
+    client: T;
+    httpServer: http.Server & {
+        port: number;
+    };
+    url: string;
+};
+export declare function createJsonRpcTestSetup<T extends object>(handler: T, schema: ApiSchemaFor<T>, serverOptions?: Partial<SafeJsonRpcServerOptions>, clientOptions?: SafeJsonRpcClientOptions): Promise<JsonRpcTestContext<T>>;
+//# sourceMappingURL=integration.d.ts.map

package/dest/json-rpc/test/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/test/integration.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAAE,KAAK,wBAAwB,EAA2B,MAAM,mCAAmC,CAAC;AAC3G,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAG9B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,MAAM,IAAI;IACjD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,CAAC,CAAC;IACV,UAAU,EAAE,IAAI,CAAC,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,wBAAsB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EAC3D,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,aAAa,GAAE,OAAO,CAAC,wBAAwB,CAAM,EACrD,aAAa,GAAE,wBAA6B,GAC3C,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAUhC"}

package/dest/json-rpc/test/integration.js

@@ -0,0 +1,21 @@
+import { makeFetch } from '../client/fetch.js';
+import { createSafeJsonRpcClient } from '../client/safe_json_rpc_client.js';
+import { createSafeJsonRpcServer, startHttpRpcServer } from '../server/safe_json_rpc_server.js';
+export async function createJsonRpcTestSetup(handler, schema, serverOptions = {}, clientOptions = {}) {
+    const server = createSafeJsonRpcServer(handler, schema, serverOptions);
+    const httpServer = await startHttpRpcServer(server, {
+        host: '127.0.0.1'
+    });
+    const noRetryFetch = makeFetch([], true);
+    const url = `http://127.0.0.1:${httpServer.port}`;
+    const client = createSafeJsonRpcClient(url, schema, {
+        fetch: noRetryFetch,
+        ...clientOptions
+    });
+    return {
+        server,
+        client,
+        httpServer,
+        url
+    };
+}

package/dest/log/console.d.ts

@@ -0,0 +1,11 @@
+import type { LogFn } from './log_fn.js';
+/**
+ * Creates a Logger function with an optional prefix for log messages.
+ * If a prefix is provided, the created logger will prepend it to each log message.
+ * If no prefix is provided, the default console.log will be returned.
+ *
+ * @param prefix - The optional string to prepend to each log message.
+ * @returns A Logger function that accepts any number of arguments and logs them with the specified prefix.
+ */
+export declare function createConsoleLogger(prefix?: string): LogFn;
+//# sourceMappingURL=console.d.ts.map

package/dest/log/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/log/console.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAuBzC;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAM1D"}

package/dest/log/console.js

@@ -0,0 +1,36 @@
+/* eslint-disable no-console */ /**
+ * ConsoleLogger is a utility class that provides customizable console logging functionality.
+ * It allows setting a custom prefix for log messages and an optional custom logger function,
+ * which can be useful for controlling the format of the output or redirecting logs to a different destination.
+ */ class ConsoleLogger {
+    prefix;
+    logger;
+    constructor(prefix, logger = console.log){
+        this.prefix = prefix;
+        this.logger = logger;
+    }
+    /**
+   * Log messages with the specified prefix using the provided logger.
+   * By default, it uses 'console.log' as the logger but can be overridden
+   * during ConsoleLogger instantiation. This method allows for easy
+   * organization and readability of log messages in the console.
+   *
+   * @param args - The data to be logged, any number of arguments can be passed to this function.
+   */ log(...args) {
+        this.logger(`${this.prefix}:`, ...args);
+    }
+}
+/**
+ * Creates a Logger function with an optional prefix for log messages.
+ * If a prefix is provided, the created logger will prepend it to each log message.
+ * If no prefix is provided, the default console.log will be returned.
+ *
+ * @param prefix - The optional string to prepend to each log message.
+ * @returns A Logger function that accepts any number of arguments and logs them with the specified prefix.
+ */ export function createConsoleLogger(prefix) {
+    if (prefix) {
+        const logger = new ConsoleLogger(prefix, console.log);
+        return (...args)=>logger.log(...args);
+    }
+    return console.log;
+}

package/dest/log/debug.d.ts

@@ -0,0 +1,56 @@
+import type { LogFn } from './log_fn.js';
+/**
+ * Return a logger, meant to be silent by default and verbose during debugging.
+ * @param name - The module name of the logger.
+ * @returns A callable log function.
+ */
+export declare function createDebugOnlyLogger(name: string): LogFn;
+/**
+ * Set a function to be called before each log message is handled by the debug logger.
+ * The hook function will receive the logger namespace and any arguments passed to the logger.
+ * This can be useful for adding additional context, filtering logs, or performing side-effects
+ * based on logged messages.
+ *
+ * @param fn - The function to be called before each log message.
+ */
+export declare function setPreDebugLogHook(fn: (...args: any[]) => void): void;
+/**
+ * Set a callback function to be executed after each log is written by the debug logger.
+ * This allows additional behavior or side effects to occur after a log has been written,
+ * such as sending logs to external services, formatting output, or triggering events.
+ *
+ * @param fn - The callback function to be executed after each log. It receives the same arguments as the original log function call.
+ */
+export declare function setPostDebugLogHook(fn: (...args: any[]) => void): void;
+/**
+ * Enable logs for the specified namespace(s) or wildcard pattern(s).
+ * This function activates the logging functionality for the given
+ * namespace(s) or pattern(s), allowing developers to selectively display
+ * debug logs that match the provided string(s).
+ *
+ * @param str - The namespace(s) or wildcard pattern(s) for which logs should be enabled.
+ */
+export declare function enableLogs(str: string): void;
+/**
+ * Check if the logging is enabled for a given namespace.
+ * The input 'str' represents the namespace for which the log status is being checked.
+ * Returns true if the logging is enabled, otherwise false.
+ *
+ * @param str - The namespace string used to determine if logging is enabled.
+ * @returns A boolean indicating whether logging is enabled for the given namespace.
+ */
+export declare function isLogEnabled(str: string): boolean;
+/**
+ * Format a debug string filling in `'{0}'` entries with their
+ * corresponding values from the args array, amd `'{}'` with the whole array.
+ *
+ * @param formatStr - str of form `'this is a string with some entries like {0} and {1}'`
+ * @param args - array of fields to fill in the string format entries with
+ * @returns formatted string
+ */
+interface Printable {
+    toString(): string;
+}
+export declare function applyStringFormatting(formatStr: string, args: Printable[]): string;
+export {};
+//# sourceMappingURL=debug.d.ts.map

package/dest/log/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/log/debug.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAyBzC;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAGzD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,QAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,QAE/D;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,QAErC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,WAEvC;AAED;;;;;;;GAOG;AACH,UAAU,SAAS;IACjB,QAAQ,IAAI,MAAM,CAAC;CACpB;AACD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,CAQlF"}

package/dest/log/debug.js

@@ -0,0 +1,75 @@
+import debug from 'debug';
+let preLogHook;
+let postLogHook;
+/**
+ * Process and handle the logging of messages through custom hooks and the given logger.
+ * This function checks if the logger's namespace is enabled, executes any preLogHook functions, logs the message using the provided logger, and then executes any postLogHook functions.
+ *
+ * @param logger - The debug logger instance to be used for logging.
+ * @param args - The arguments to be passed to the logger and any hook functions.
+ */ function theFunctionThroughWhichAllLogsPass(logger, ...args) {
+    if (!debug.enabled(logger.namespace)) {
+        return;
+    }
+    if (preLogHook) {
+        preLogHook(logger.namespace, ...args);
+    }
+    logger(...args);
+    if (postLogHook) {
+        postLogHook(logger.namespace, ...args);
+    }
+}
+/**
+ * Return a logger, meant to be silent by default and verbose during debugging.
+ * @param name - The module name of the logger.
+ * @returns A callable log function.
+ */ export function createDebugOnlyLogger(name) {
+    const logger = debug(name);
+    return (...args)=>theFunctionThroughWhichAllLogsPass(logger, ...args);
+}
+/**
+ * Set a function to be called before each log message is handled by the debug logger.
+ * The hook function will receive the logger namespace and any arguments passed to the logger.
+ * This can be useful for adding additional context, filtering logs, or performing side-effects
+ * based on logged messages.
+ *
+ * @param fn - The function to be called before each log message.
+ */ export function setPreDebugLogHook(fn) {
+    preLogHook = fn;
+}
+/**
+ * Set a callback function to be executed after each log is written by the debug logger.
+ * This allows additional behavior or side effects to occur after a log has been written,
+ * such as sending logs to external services, formatting output, or triggering events.
+ *
+ * @param fn - The callback function to be executed after each log. It receives the same arguments as the original log function call.
+ */ export function setPostDebugLogHook(fn) {
+    postLogHook = fn;
+}
+/**
+ * Enable logs for the specified namespace(s) or wildcard pattern(s).
+ * This function activates the logging functionality for the given
+ * namespace(s) or pattern(s), allowing developers to selectively display
+ * debug logs that match the provided string(s).
+ *
+ * @param str - The namespace(s) or wildcard pattern(s) for which logs should be enabled.
+ */ export function enableLogs(str) {
+    debug.enable(str);
+}
+/**
+ * Check if the logging is enabled for a given namespace.
+ * The input 'str' represents the namespace for which the log status is being checked.
+ * Returns true if the logging is enabled, otherwise false.
+ *
+ * @param str - The namespace string used to determine if logging is enabled.
+ * @returns A boolean indicating whether logging is enabled for the given namespace.
+ */ export function isLogEnabled(str) {
+    return debug.enabled(str);
+}
+export function applyStringFormatting(formatStr, args) {
+    return formatStr.replace(/{(\d+)}/g, (match, index)=>{
+        return typeof args[index] === 'undefined' ? match : args[index].toString();
+    }).replace(/{}/g, (_match, _index)=>{
+        return args.toString();
+    });
+}

package/dest/log/gcloud-logger-config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pino configuration for google cloud observability. Tweaks message and timestamp,
+ * adds trace context attributes, and injects severity level.
+ * Adapted from https://cloud.google.com/trace/docs/setup/nodejs-ot#config-structured-logging.
+ */
+export declare const GoogleCloudLoggerConfig: {
+    messageKey: string;
+    timestamp(): string;
+    formatters: {
+        log(object: Record<string, unknown>): Record<string, unknown>;
+        level(label: string, level: number): object;
+    };
+};
+//# sourceMappingURL=gcloud-logger-config.d.ts.map

package/dest/log/gcloud-logger-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcloud-logger-config.d.ts","sourceRoot":"","sources":["../../src/log/gcloud-logger-config.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;iBAGrB,MAAM;;oBAIL,OAAO,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,MAAM,EAAE,OAAO,CAAC;qBAgBhD,MAAM,SAAS,MAAM,GAAG,MAAM;;CA+BjB,CAAC"}

package/dest/log/gcloud-logger-config.js

@@ -0,0 +1,66 @@
+/* eslint-disable camelcase */ const GOOGLE_CLOUD_TRACE_ID = 'logging.googleapis.com/trace';
+const GOOGLE_CLOUD_SPAN_ID = 'logging.googleapis.com/spanId';
+const GOOGLE_CLOUD_TRACE_SAMPLED = 'logging.googleapis.com/trace_sampled';
+/**
+ * Pino configuration for google cloud observability. Tweaks message and timestamp,
+ * adds trace context attributes, and injects severity level.
+ * Adapted from https://cloud.google.com/trace/docs/setup/nodejs-ot#config-structured-logging.
+ */ export const GoogleCloudLoggerConfig = {
+    messageKey: 'message',
+    // Same as pino.stdTimeFunctions.isoTime but uses "timestamp" key instead of "time"
+    timestamp () {
+        return `,"timestamp":"${new Date(Date.now()).toISOString()}"`;
+    },
+    formatters: {
+        log (object) {
+            // Add trace context attributes following Cloud Logging structured log format described
+            // in https://cloud.google.com/logging/docs/structured-logging#special-payload-fields
+            const { trace_id, span_id, trace_flags, ...rest } = object;
+            if (trace_id && span_id) {
+                return {
+                    [GOOGLE_CLOUD_TRACE_ID]: trace_id,
+                    [GOOGLE_CLOUD_SPAN_ID]: span_id,
+                    [GOOGLE_CLOUD_TRACE_SAMPLED]: trace_flags ? trace_flags === '01' : undefined,
+                    trace_flags,
+                    ...rest
+                };
+            }
+            return object;
+        },
+        level (label, level) {
+            // Inspired by https://github.com/pinojs/pino/issues/726#issuecomment-605814879
+            // Severity labels https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
+            let severity;
+            switch(label){
+                case 'trace':
+                case 'debug':
+                    severity = 'DEBUG';
+                    break;
+                case 'verbose':
+                case 'info':
+                    severity = 'INFO';
+                    break;
+                case 'warn':
+                    severity = 'WARNING';
+                    break;
+                case 'error':
+                    severity = 'ERROR';
+                    break;
+                case 'fatal':
+                    severity = 'CRITICAL';
+                    break;
+                default:
+                    severity = 'DEFAULT';
+                    break;
+            }
+            return {
+                severity,
+                level
+            };
+        }
+    }
+};
+// Define custom logging levels for pino. Duplicate from pino-logger.ts.
+const customLevels = {
+    verbose: 25
+};

package/dest/log/index.d.ts

@@ -0,0 +1,7 @@
+export * from './console.js';
+export * from './debug.js';
+export * from './pino-logger.js';
+export * from './log_history.js';
+export * from './log_fn.js';
+export * from './libp2p_logger.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/log/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/log/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC"}

package/dest/log/index.js

@@ -0,0 +1,6 @@
+export * from './console.js';
+export * from './debug.js';
+export * from './pino-logger.js';
+export * from './log_history.js';
+export * from './log_fn.js';
+export * from './libp2p_logger.js';

package/dest/log/libp2p_logger.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentLogger } from '@libp2p/interface';
+/**
+ * Creates a libp2p compatible logger that wraps our pino logger.
+ * This adapter implements the ComponentLogger interface required by libp2p.
+ */
+export declare function createLibp2pComponentLogger(namespace: string): ComponentLogger;
+//# sourceMappingURL=libp2p_logger.d.ts.map

package/dest/log/libp2p_logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libp2p_logger.d.ts","sourceRoot":"","sources":["../../src/log/libp2p_logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAU,MAAM,mBAAmB,CAAC;AAMjE;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,CAI9E"}

package/dest/log/libp2p_logger.js

@@ -0,0 +1,55 @@
+import { getLogLevelFromFilters } from './log-filters.js';
+import { logFilters, logger } from './pino-logger.js';
+/**
+ * Creates a libp2p compatible logger that wraps our pino logger.
+ * This adapter implements the ComponentLogger interface required by libp2p.
+ */ export function createLibp2pComponentLogger(namespace) {
+    return {
+        forComponent: (component)=>createLibp2pLogger(`${namespace}:${component}`)
+    };
+}
+// Lipp2p libraries use arbitrary string substitutions, so we need to replace them with %s, this is slow so avoid doing it unless trace debugging
+function replaceFormatting(message) {
+    // Message can sometimes not be a string, e.g. an error object, just return it as is
+    if (!message?.replace) {
+        return message;
+    }
+    return message.replace(/(%p|%a)/g, '%s');
+}
+function createLibp2pLogger(component) {
+    // Create a direct pino logger instance for libp2p that supports string interpolation
+    const log = logger.child({
+        module: component
+    }, {
+        level: getLogLevelFromFilters(logFilters, component)
+    });
+    const logIfEnabled = (level, message, ...args)=>{
+        if (!log.isLevelEnabled(level)) {
+            return;
+        }
+        log[level](replaceFormatting(message), ...args);
+    };
+    // Default log level is trace as this is super super noisy
+    const logFn = (message, ...args)=>{
+        logIfEnabled('trace', message, ...args);
+    };
+    return Object.assign(logFn, {
+        enabled: log.isLevelEnabled('debug'),
+        error (message, ...args) {
+            // We write error outputs as debug as they are often expected, e.g. connection errors can happen in happy paths
+            logIfEnabled('debug', message, ...args);
+        },
+        debug (message, ...args) {
+            logIfEnabled('debug', message, ...args);
+        },
+        info (message, ...args) {
+            logIfEnabled('info', message, ...args);
+        },
+        warn (message, ...args) {
+            logIfEnabled('warn', message, ...args);
+        },
+        trace (message, ...args) {
+            logIfEnabled('trace', message, ...args);
+        }
+    });
+}

package/dest/log/log-filters.d.ts

@@ -0,0 +1,7 @@
+import { type LogLevel } from './log-levels.js';
+export type LogFilters = [string, LogLevel][];
+export declare function getLogLevelFromFilters(filters: LogFilters, module: string): LogLevel | undefined;
+export declare function assertLogLevel(level: string): asserts level is LogLevel;
+export declare function parseEnv(env: string | undefined, defaultLevel: LogLevel): [LogLevel, LogFilters];
+export declare function parseFilters(definition: string | undefined): LogFilters;
+//# sourceMappingURL=log-filters.d.ts.map

package/dest/log/log-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-filters.d.ts","sourceRoot":"","sources":["../../src/log/log-filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAa,MAAM,iBAAiB,CAAC;AAE3D,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC;AAE9C,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAehG;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,QAAQ,CAIvE;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,YAAY,EAAE,QAAQ,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAOhG;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CA0BvE"}

package/dest/log/log-filters.js

@@ -0,0 +1,59 @@
+import { LogLevels } from './log-levels.js';
+export function getLogLevelFromFilters(filters, module) {
+    for (const [filterModule, level] of filters){
+        try {
+            const regex = new RegExp(filterModule);
+            if (regex.test(module)) {
+                return level;
+            }
+        } catch  {
+            // If regex is invalid, fall back to startsWith check
+            if (module.startsWith(filterModule)) {
+                return level;
+            }
+        }
+    }
+    return undefined;
+}
+export function assertLogLevel(level) {
+    if (!LogLevels.includes(level)) {
+        throw new Error(`Invalid log level: ${level}`);
+    }
+}
+export function parseEnv(env, defaultLevel) {
+    if (!env) {
+        return [
+            defaultLevel,
+            []
+        ];
+    }
+    const [level] = env.split(';', 1);
+    assertLogLevel(level);
+    return [
+        level,
+        parseFilters(env.slice(level.length + 1))
+    ];
+}
+export function parseFilters(definition) {
+    if (!definition) {
+        return [];
+    }
+    const statements = definition.split(';');
+    const filters = [];
+    for (const statement of statements){
+        const [level] = statement.split(':', 1);
+        const modules = statement.slice(level.length + 1);
+        if (!modules || !level) {
+            throw new Error(`Invalid log filter statement: ${statement}`);
+        }
+        const sanitizedLevel = level.trim().toLowerCase();
+        assertLogLevel(sanitizedLevel);
+        for (const module of modules.split(',')){
+            filters.push([
+                module.trim().toLowerCase().replace(/^aztec:/, ''),
+                sanitizedLevel
+            ]);
+        }
+    }
+    return filters.reverse();
+}

package/dest/log/log-levels.d.ts

@@ -0,0 +1,3 @@
+export declare const LogLevels: readonly ["silent", "fatal", "error", "warn", "info", "verbose", "debug", "trace"];
+export type LogLevel = (typeof LogLevels)[number];
+//# sourceMappingURL=log-levels.d.ts.map

package/dest/log/log-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-levels.d.ts","sourceRoot":"","sources":["../../src/log/log-levels.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,oFAAqF,CAAC;AAE5G,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dest/log/log-levels.js

@@ -0,0 +1,10 @@
+export const LogLevels = [
+    'silent',
+    'fatal',
+    'error',
+    'warn',
+    'info',
+    'verbose',
+    'debug',
+    'trace'
+];

package/dest/log/log_fn.d.ts

@@ -0,0 +1,7 @@
+/** Structured log data to include with the message. */
+export type LogData = Record<string, string | number | bigint | boolean | {
+    toString(): string;
+} | undefined>;
+/** A callable logger instance. */
+export type LogFn = (msg: string, data?: unknown) => void;
+//# sourceMappingURL=log_fn.d.ts.map

package/dest/log/log_fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log_fn.d.ts","sourceRoot":"","sources":["../../src/log/log_fn.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAAC;AAE9G,kCAAkC;AAClC,MAAM,MAAM,KAAK,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC"}

package/dest/log/log_fn.js

@@ -0,0 +1 @@
+/** Structured log data to include with the message. */ /** A callable logger instance. */ export { };

package/dest/log/log_history.d.ts

@@ -0,0 +1,31 @@
+/**
+ * LogHistory is a utility class that provides the ability to store and manage debug logs.
+ * It can be enabled to record logs along with their timestamps, retrieve a specified number
+ * of recent logs, or clear stored logs based on a given count. This can be useful for debugging
+ * purposes, monitoring application activities, and maintaining log history.
+ */
+export declare class LogHistory {
+    private logs;
+    /**
+     * Enables the logging of debug messages with timestamps.
+     * Hooks into the pre-debug log and stores each log entry along with its timestamp in the logs array.
+     */
+    enable(): void;
+    /**
+     * Retrieves a specified number of logs from the end of the log history or all logs if no argument is provided.
+     * The logs are ordered chronologically, with the oldest logs at the beginning of the array.
+     *
+     * @param last - Optional number representing the amount of recent logs to return. Defaults to 0, which returns all logs.
+     * @returns An array of log arrays, each containing a timestamp and log arguments.
+     */
+    getLogs(last?: number): any[][];
+    /**
+     * Clear a specified number of logs from the beginning of the logs array.
+     * If no count is provided, it will clear all logs.
+     *
+     * @param count - The number of logs to be removed (default: total logs length).
+     */
+    clear(count?: number): void;
+}
+export declare const logHistory: LogHistory;
+//# sourceMappingURL=log_history.d.ts.map

package/dest/log/log_history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log_history.d.ts","sourceRoot":"","sources":["../../src/log/log_history.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAe;IAE3B;;;OAGG;IACI,MAAM;IAMb;;;;;;OAMG;IACI,OAAO,CAAC,IAAI,SAAI;IAIvB;;;;;OAKG;IACI,KAAK,CAAC,KAAK,SAAmB;CAGtC;AAED,eAAO,MAAM,UAAU,YAAmB,CAAC"}

package/dest/log/log_history.js

@@ -0,0 +1,38 @@
+import { setPreDebugLogHook } from './debug.js';
+/**
+ * LogHistory is a utility class that provides the ability to store and manage debug logs.
+ * It can be enabled to record logs along with their timestamps, retrieve a specified number
+ * of recent logs, or clear stored logs based on a given count. This can be useful for debugging
+ * purposes, monitoring application activities, and maintaining log history.
+ */ export class LogHistory {
+    logs = [];
+    /**
+   * Enables the logging of debug messages with timestamps.
+   * Hooks into the pre-debug log and stores each log entry along with its timestamp in the logs array.
+   */ enable() {
+        setPreDebugLogHook((...args)=>{
+            this.logs.push([
+                new Date().toISOString(),
+                ...args
+            ]);
+        });
+    }
+    /**
+   * Retrieves a specified number of logs from the end of the log history or all logs if no argument is provided.
+   * The logs are ordered chronologically, with the oldest logs at the beginning of the array.
+   *
+   * @param last - Optional number representing the amount of recent logs to return. Defaults to 0, which returns all logs.
+   * @returns An array of log arrays, each containing a timestamp and log arguments.
+   */ getLogs(last = 0) {
+        return last ? this.logs.slice(-last) : this.logs;
+    }
+    /**
+   * Clear a specified number of logs from the beginning of the logs array.
+   * If no count is provided, it will clear all logs.
+   *
+   * @param count - The number of logs to be removed (default: total logs length).
+   */ clear(count = this.logs.length) {
+        this.logs = this.logs.slice(count);
+    }
+}
+export const logHistory = new LogHistory();