@aztec/foundation 0.0.0-test.0

package/dest/log/pino-logger.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Writable } from 'stream';
+import type { LogLevel } from './log-levels.js';
+import type { LogData, LogFn } from './log_fn.js';
+export declare function createLogger(module: string): Logger;
+type LogDataHandler = (data: LogData) => LogData;
+export declare function addLogDataHandler(handler: LogDataHandler): void;
+type LogNameHandler = (module: string) => string;
+export declare function addLogNameHandler(handler: LogNameHandler): void;
+export declare function removeLogNameHandler(handler: LogNameHandler): void;
+/** Creates all loggers within the given callback with the suffix appended to the module name. */
+export declare function withLogNameSuffix<T>(suffix: string, callback: () => Promise<T>): Promise<T>;
+export declare const logLevel: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "verbose" | "silent", logFilters: import("./log-filters.js").LogFilters;
+export declare const levels: {
+    labels: any;
+    values: {
+        verbose: number;
+    };
+};
+export declare const pinoPrettyOpts: {
+    destination: number;
+    sync: boolean;
+    colorize: boolean;
+    ignore: string;
+    messageFormat: string;
+    customLevels: string;
+    customColors: string;
+    minimumLevel: "trace";
+    singleLine: boolean;
+};
+export declare const logger: import("pino").Logger<"verbose", boolean>;
+/**
+ * Overwrites the logging stream with a different destination.
+ * Used by jest/setup.mjs to set up a pretty logger.
+ */
+export declare function overwriteLoggingStream(stream: Writable): void;
+/**
+ * Registers an additional destination to the pino logger.
+ * Use only when working with destinations, not worker transports.
+ */
+export declare function registerLoggingStream(stream: Writable): void;
+/** Log function that accepts an exception object */
+type ErrorLogFn = (msg: string, err?: Error | unknown, data?: LogData) => void;
+/**
+ * Logger that supports multiple severity levels.
+ */
+export type Logger = {
+    [K in LogLevel]: LogFn;
+} & {
+    error: ErrorLogFn;
+} & {
+    level: LogLevel;
+    isLevelEnabled: (level: LogLevel) => boolean;
+    module: string;
+};
+export {};
+//# sourceMappingURL=pino-logger.d.ts.map

package/dest/log/pino-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino-logger.d.ts","sourceRoot":"","sources":["../../src/log/pino-logger.ts"],"names":[],"mappings":";AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAOvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAElD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAgCnD;AAID,KAAK,cAAc,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;AAGjD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAE/D;AAQD,KAAK,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;AAGjD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAE/D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,QAK3D;AAED,iGAAiG;AACjG,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAMjG;AAWD,eAAO,MAAO,QAAQ,kFAAE,UAAU,uCAAoD,CAAC;AAevF,eAAO,MAAM,MAAM;;;;;CAGlB,CAAC;AAMF,eAAO,MAAM,cAAc;;;;;;;;;;CAU1B,CAAC;AAoDF,eAAO,MAAM,MAAM,2CAAe,CAAC;AAanC;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAE7D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAe5D;AAED,oDAAoD;AACpD,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;KAAG,CAAC,IAAI,QAAQ,GAAG,KAAK;CAAE,GAAG;IAA4B,KAAK,EAAE,UAAU,CAAA;CAAE,GAAG;IAClG,KAAK,EAAE,QAAQ,CAAC;IAChB,cAAc,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/dest/log/pino-logger.js

@@ -0,0 +1,207 @@
+import { createColors, isColorSupported } from 'colorette';
+import isNode from 'detect-node';
+import { pino, symbols } from 'pino';
+import { inspect } from 'util';
+import { compactArray } from '../collection/array.js';
+import { parseBooleanEnv } from '../config/index.js';
+import { GoogleCloudLoggerConfig } from './gcloud-logger-config.js';
+import { getLogLevelFromFilters, parseEnv } from './log-filters.js';
+export function createLogger(module) {
+    module = logNameHandlers.reduce((moduleName, handler)=>handler(moduleName), module.replace(/^aztec:/, ''));
+    const pinoLogger = logger.child({
+        module
+    }, {
+        level: getLogLevelFromFilters(logFilters, module)
+    });
+    // We check manually for isLevelEnabled to avoid calling processLogData unnecessarily.
+    // Note that isLevelEnabled is missing from the browser version of pino.
+    const logFn = (level, msg, data)=>isLevelEnabled(pinoLogger, level) && pinoLogger[level](processLogData(data ?? {}), msg);
+    return {
+        silent: ()=>{},
+        // TODO(palla/log): Should we move err to data instead of the text message?
+        /** Log as fatal. Use when an error has brought down the system. */ fatal: (msg, err, data)=>logFn('fatal', formatErr(msg, err), data),
+        /** Log as error. Use for errors in general. */ error: (msg, err, data)=>logFn('error', formatErr(msg, err), data),
+        /** Log as warn. Use for when we stray from the happy path. */ warn: (msg, data)=>logFn('warn', msg, data),
+        /** Log as info. Use for providing an operator with info on what the system is doing. */ info: (msg, data)=>logFn('info', msg, data),
+        /** Log as verbose. Use for when we need additional insight on what a subsystem is doing. */ verbose: (msg, data)=>logFn('verbose', msg, data),
+        /** Log as debug. Use for when we need debugging info to troubleshoot an issue on a specific component. */ debug: (msg, data)=>logFn('debug', msg, data),
+        /** Log as trace. Use for when we want to denial-of-service any recipient of the logs. */ trace: (msg, data)=>logFn('trace', msg, data),
+        level: pinoLogger.level,
+        /** Whether the given level is enabled for this logger. */ isLevelEnabled: (level)=>isLevelEnabled(pinoLogger, level),
+        /** Module name for the logger. */ module
+    };
+}
+const logDataHandlers = [];
+export function addLogDataHandler(handler) {
+    logDataHandlers.push(handler);
+}
+function processLogData(data) {
+    return logDataHandlers.reduce((accum, handler)=>handler(accum), data);
+}
+const logNameHandlers = [];
+export function addLogNameHandler(handler) {
+    logNameHandlers.push(handler);
+}
+export function removeLogNameHandler(handler) {
+    const index = logNameHandlers.indexOf(handler);
+    if (index !== -1) {
+        logNameHandlers.splice(index, 1);
+    }
+}
+/** Creates all loggers within the given callback with the suffix appended to the module name. */ export async function withLogNameSuffix(suffix, callback) {
+    const logNameHandler = (module)=>`${module}:${suffix}`;
+    addLogNameHandler(logNameHandler);
+    const result = await callback();
+    removeLogNameHandler(logNameHandler);
+    return result;
+}
+// Patch isLevelEnabled missing from pino/browser.
+function isLevelEnabled(logger, level) {
+    return typeof logger.isLevelEnabled === 'function' ? logger.isLevelEnabled(level) : logger.levels.values[level] >= logger.levels.values[logger.level];
+}
+// Load log levels from environment variables.
+const defaultLogLevel = process.env.NODE_ENV === 'test' ? 'silent' : 'info';
+export const [logLevel, logFilters] = parseEnv(process.env.LOG_LEVEL, defaultLogLevel);
+// Define custom logging levels for pino.
+const customLevels = {
+    verbose: 25
+};
+// Global pino options, tweaked for google cloud if running there.
+const useGcloudLogging = parseBooleanEnv(process.env['USE_GCLOUD_LOGGING']);
+const pinoOpts = {
+    customLevels,
+    messageKey: 'msg',
+    useOnlyCustomLevels: false,
+    level: logLevel,
+    ...useGcloudLogging ? GoogleCloudLoggerConfig : {}
+};
+export const levels = {
+    labels: {
+        ...pino.levels.labels,
+        ...Object.fromEntries(Object.entries(customLevels).map((e)=>e.reverse()))
+    },
+    values: {
+        ...pino.levels.values,
+        ...customLevels
+    }
+};
+// Transport options for pretty logging to stderr via pino-pretty.
+const colorEnv = process.env['FORCE_COLOR'];
+const useColor = colorEnv === undefined ? isColorSupported : parseBooleanEnv(colorEnv);
+const { bold, reset } = createColors({
+    useColor
+});
+export const pinoPrettyOpts = {
+    destination: 2,
+    sync: true,
+    colorize: useColor,
+    ignore: 'module,pid,hostname,trace_id,span_id,trace_flags,severity',
+    messageFormat: `${bold('{module}')} ${reset('{msg}')}`,
+    customLevels: 'fatal:60,error:50,warn:40,info:30,verbose:25,debug:20,trace:10',
+    customColors: 'fatal:bgRed,error:red,warn:yellow,info:green,verbose:magenta,debug:blue,trace:gray',
+    minimumLevel: 'trace',
+    singleLine: !parseBooleanEnv(process.env['LOG_MULTILINE'])
+};
+const prettyTransport = {
+    target: 'pino-pretty',
+    options: pinoPrettyOpts,
+    level: 'trace'
+};
+// Transport for vanilla stdio logging as JSON.
+const stdioTransport = {
+    target: 'pino/file',
+    options: {
+        destination: 2
+    },
+    level: 'trace'
+};
+// Transport for OpenTelemetry logging. While defining this here is an abstraction leakage since this
+// should live in the telemetry-client, it is necessary to ensure that the logger is initialized with
+// the correct transport. Tweaking transports of a live pino instance is tricky, and creating a new instance
+// would mean that all child loggers created before the telemetry-client is initialized would not have
+// this transport configured. Note that the target is defined as the export in the telemetry-client,
+// since pino will load this transport separately on a worker thread, to minimize disruption to the main loop.
+const otlpEndpoint = process.env['OTEL_EXPORTER_OTLP_LOGS_ENDPOINT'];
+const otlpEnabled = !!otlpEndpoint && !useGcloudLogging;
+const otelOpts = {
+    levels
+};
+const otelTransport = {
+    target: '@aztec/telemetry-client/otel-pino-stream',
+    options: otelOpts,
+    level: 'trace'
+};
+function makeLogger() {
+    if (!isNode) {
+        // We are on the browser.
+        return pino({
+            ...pinoOpts,
+            browser: {
+                asObject: false
+            }
+        });
+    } else if (process.env.JEST_WORKER_ID) {
+        // We are on jest, so we need sync logging and stream to stderr.
+        // We expect jest/setup.mjs to kick in later and replace set up a pretty logger,
+        // but if for some reason it doesn't, at least we're covered with a default logger.
+        return pino(pinoOpts, pino.destination(2));
+    } else {
+        // Regular nodejs with transports on worker thread, using pino-pretty for console logging if LOG_JSON
+        // is not set, and an optional OTLP transport if the OTLP endpoint is set.
+        const targets = compactArray([
+            parseBooleanEnv(process.env.LOG_JSON) ? stdioTransport : prettyTransport,
+            otlpEnabled ? otelTransport : undefined
+        ]);
+        return pino(pinoOpts, pino.transport({
+            targets,
+            levels: levels.values
+        }));
+    }
+}
+export const logger = makeLogger();
+// Log the logger configuration.
+logger.verbose({
+    module: 'logger',
+    ...logFilters.reduce((accum, [module, level])=>({
+            ...accum,
+            [`log.${module}`]: level
+        }), {})
+}, isNode ? `Logger initialized with level ${logLevel}` + (otlpEnabled ? ` with OTLP exporter to ${otlpEndpoint}` : '') : `Browser console logger initialized with level ${logLevel}`);
+/**
+ * Overwrites the logging stream with a different destination.
+ * Used by jest/setup.mjs to set up a pretty logger.
+ */ export function overwriteLoggingStream(stream) {
+    logger[symbols.streamSym] = stream;
+}
+/**
+ * Registers an additional destination to the pino logger.
+ * Use only when working with destinations, not worker transports.
+ */ export function registerLoggingStream(stream) {
+    logger.verbose({
+        module: 'logger'
+    }, `Registering additional logging stream`);
+    const original = logger[symbols.streamSym];
+    const destination = original ? pino.multistream([
+        // Set streams to lowest logging level, and control actual logging from the parent logger
+        // otherwise streams default to info and refuse to log anything below that.
+        {
+            level: 'trace',
+            stream: original
+        },
+        {
+            level: 'trace',
+            stream
+        }
+    ], {
+        levels: levels.values
+    }) : stream;
+    logger[symbols.streamSym] = destination;
+}
+/**
+ * Concatenates a log message and an exception.
+ * @param msg - Log message
+ * @param err - Error to log
+ * @returns A string with both the log message and the error message.
+ */ function formatErr(msg, err) {
+    return err ? `${msg}: ${inspect(err)}` : msg;
+}

package/dest/message/index.d.ts

@@ -0,0 +1,32 @@
+export type MessageHeaderInit = {
+    /** The message ID. Optional, if not set defaults to 0 */
+    messageId?: number;
+    /** Identifies the original request. Optional */
+    requestId?: number;
+};
+export declare class MessageHeader {
+    /** An number to identify this message */
+    readonly messageId: number;
+    /** If this message is a response to a request, the messageId of the request */
+    readonly requestId: number;
+    constructor({ messageId, requestId }: MessageHeaderInit);
+    static fromMessagePack(data: object): MessageHeader;
+}
+interface TypedMessageLike {
+    msgType: number;
+    header: {
+        messageId?: number;
+        requestId?: number;
+    };
+    value: any;
+}
+export declare class TypedMessage<T, B> {
+    readonly msgType: T;
+    readonly header: MessageHeader;
+    readonly value: B;
+    constructor(msgType: T, header: MessageHeader, value: B);
+    static fromMessagePack<T, B>(data: TypedMessageLike): TypedMessage<T, B>;
+    static isTypedMessageLike(obj: any): obj is TypedMessageLike;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/message/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,qBAAa,aAAa;IACxB,yCAAyC;IACzC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,+EAA+E;IAC/E,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEtB,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,iBAAiB;IAKvD,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa;CAGpD;AAED,UAAU,gBAAgB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC;CACZ;AAED,qBAAa,YAAY,CAAC,CAAC,EAAE,CAAC;aACO,OAAO,EAAE,CAAC;aAAkB,MAAM,EAAE,aAAa;aAAkB,KAAK,EAAE,CAAC;gBAA3E,OAAO,EAAE,CAAC,EAAkB,MAAM,EAAE,aAAa,EAAkB,KAAK,EAAE,CAAC;IAE9G,MAAM,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;IAIxE,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,gBAAgB;CAG7D"}

package/dest/message/index.js

@@ -0,0 +1,27 @@
+export class MessageHeader {
+    /** An number to identify this message */ messageId;
+    /** If this message is a response to a request, the messageId of the request */ requestId;
+    constructor({ messageId, requestId }){
+        this.messageId = messageId ?? 0;
+        this.requestId = requestId ?? 0;
+    }
+    static fromMessagePack(data) {
+        return new MessageHeader(data);
+    }
+}
+export class TypedMessage {
+    msgType;
+    header;
+    value;
+    constructor(msgType, header, value){
+        this.msgType = msgType;
+        this.header = header;
+        this.value = value;
+    }
+    static fromMessagePack(data) {
+        return new TypedMessage(data['msgType'], MessageHeader.fromMessagePack(data['header']), data['value']);
+    }
+    static isTypedMessageLike(obj) {
+        return typeof obj === 'object' && obj !== null && 'msgType' in obj && 'header' in obj && 'value' in obj;
+    }
+}

package/dest/mutex/index.d.ts

@@ -0,0 +1,53 @@
+import type { MutexDatabase } from './mutex_database.js';
+export * from './mutex_database.js';
+/**
+ * Mutex class provides a mutual exclusion mechanism for critical sections of code using a named lock.
+ * The lock is acquired and released via the `lock` and `unlock` methods. Locks can be optionally pinged
+ * to keep them alive when they are held for longer durations, avoiding unintended release due to timeouts.
+ *
+ * The underlying lock state is managed in a MutexDatabase instance which can be shared across multiple Mutex instances.
+ * This allows for synchronization between different parts of an application or even across different instances of an application.
+ *
+ * @example
+ * const mutex = new Mutex(mutexDatabase, 'myLock');
+ * await mutex.lock();
+ * // Critical section here
+ * await mutex.unlock();
+ */
+export declare class Mutex {
+    private readonly db;
+    private readonly name;
+    private readonly timeout;
+    private readonly tryLockInterval;
+    private readonly pingInterval;
+    private id;
+    private pingTimeout;
+    constructor(db: MutexDatabase, name: string, timeout?: number, tryLockInterval?: number, pingInterval?: number);
+    /**
+     * Acquire a lock on the mutex. If 'untilAcquired' is true, the method will keep trying to acquire the lock until it
+     * successfully acquires it. If 'untilAcquired' is false, the method will try to acquire the lock once and return
+     * immediately with a boolean indicating if the lock has been acquired or not.
+     *
+     * @param untilAcquired - Optional parameter, set to true by default. If true, the method will keep trying to acquire the lock until success. If false, the method will try only once and return a boolean value.
+     * @returns A Promise that resolves to true if the lock has been acquired, or false when 'untilAcquired' is false and the lock could not be immediately acquired.
+     */
+    lock(untilAcquired?: boolean): Promise<boolean>;
+    /**
+     * Unlocks the mutex, allowing other instances to acquire the lock.
+     * This method also clears the internal ping timeout and increments the internal ID
+     * to ensure stale pings do not extend the lock after it has been released.
+     *
+     * @returns A promise that resolves once the lock has been released in the database.
+     */
+    unlock(): Promise<void>;
+    /**
+     * Periodically extends the lock's lifetime by updating the database record with a new expiration time.
+     * This method is called recursively using setTimeout. If the id passed to the ping method does not match
+     * the current lock instance's id, it means the lock has been released or acquired by another instance
+     * and the ping should not proceed further.
+     *
+     * @param id - The id of the current lock instance.
+     */
+    private ping;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutex/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,cAAc,qBAAqB,CAAC;AAEpC;;;;;;;;;;;;;GAaG;AACH,qBAAa,KAAK;IAKd,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAR/B,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,WAAW,CAAkB;gBAGlB,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,SAAO,EACd,eAAe,SAAO,EACtB,YAAY,SAAO;IAGtC;;;;;;;OAOG;IACU,IAAI,CAAC,aAAa,UAAO;IAetC;;;;;;OAMG;IACU,MAAM;IAMnB;;;;;;;OAOG;IACH,OAAO,CAAC,IAAI;CASb"}

package/dest/mutex/index.js

@@ -0,0 +1,78 @@
+export * from './mutex_database.js';
+/**
+ * Mutex class provides a mutual exclusion mechanism for critical sections of code using a named lock.
+ * The lock is acquired and released via the `lock` and `unlock` methods. Locks can be optionally pinged
+ * to keep them alive when they are held for longer durations, avoiding unintended release due to timeouts.
+ *
+ * The underlying lock state is managed in a MutexDatabase instance which can be shared across multiple Mutex instances.
+ * This allows for synchronization between different parts of an application or even across different instances of an application.
+ *
+ * @example
+ * const mutex = new Mutex(mutexDatabase, 'myLock');
+ * await mutex.lock();
+ * // Critical section here
+ * await mutex.unlock();
+ */ export class Mutex {
+    db;
+    name;
+    timeout;
+    tryLockInterval;
+    pingInterval;
+    id;
+    pingTimeout;
+    constructor(db, name, timeout = 5000, tryLockInterval = 2000, pingInterval = 2000){
+        this.db = db;
+        this.name = name;
+        this.timeout = timeout;
+        this.tryLockInterval = tryLockInterval;
+        this.pingInterval = pingInterval;
+        this.id = 0;
+    }
+    /**
+   * Acquire a lock on the mutex. If 'untilAcquired' is true, the method will keep trying to acquire the lock until it
+   * successfully acquires it. If 'untilAcquired' is false, the method will try to acquire the lock once and return
+   * immediately with a boolean indicating if the lock has been acquired or not.
+   *
+   * @param untilAcquired - Optional parameter, set to true by default. If true, the method will keep trying to acquire the lock until success. If false, the method will try only once and return a boolean value.
+   * @returns A Promise that resolves to true if the lock has been acquired, or false when 'untilAcquired' is false and the lock could not be immediately acquired.
+   */ async lock(untilAcquired = true) {
+        while(true){
+            if (await this.db.acquireLock(this.name, this.timeout)) {
+                const id = this.id;
+                this.pingTimeout = setTimeout(()=>this.ping(id), this.pingInterval);
+                return true;
+            }
+            if (!untilAcquired) {
+                return false;
+            }
+            await new Promise((resolve)=>setTimeout(resolve, this.tryLockInterval));
+        }
+    }
+    /**
+   * Unlocks the mutex, allowing other instances to acquire the lock.
+   * This method also clears the internal ping timeout and increments the internal ID
+   * to ensure stale pings do not extend the lock after it has been released.
+   *
+   * @returns A promise that resolves once the lock has been released in the database.
+   */ async unlock() {
+        clearTimeout(this.pingTimeout);
+        this.id++;
+        await this.db.releaseLock(this.name);
+    }
+    /**
+   * Periodically extends the lock's lifetime by updating the database record with a new expiration time.
+   * This method is called recursively using setTimeout. If the id passed to the ping method does not match
+   * the current lock instance's id, it means the lock has been released or acquired by another instance
+   * and the ping should not proceed further.
+   *
+   * @param id - The id of the current lock instance.
+   */ ping(id) {
+        if (id !== this.id) {
+            return;
+        }
+        void (async ()=>{
+            await this.db.extendLock(this.name, this.timeout);
+            this.pingTimeout = setTimeout(()=>this.ping(id), this.pingInterval);
+        })();
+    }
+}

package/dest/mutex/mutex_database.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents a mutual exclusion (mutex) database interface.
+ * Provides functionality for acquiring, extending, and releasing locks on resources to ensure exclusive access and prevent conflicts in concurrent applications.
+ */
+export interface MutexDatabase {
+    acquireLock(name: string, timeout: number): Promise<boolean>;
+    extendLock(name: string, timeout: number): Promise<void>;
+    releaseLock(name: string): Promise<void>;
+}
+//# sourceMappingURL=mutex_database.d.ts.map

package/dest/mutex/mutex_database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutex_database.d.ts","sourceRoot":"","sources":["../../src/mutex/mutex_database.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAE5B,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7D,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C"}

package/dest/mutex/mutex_database.js

@@ -0,0 +1,4 @@
+/**
+ * Represents a mutual exclusion (mutex) database interface.
+ * Provides functionality for acquiring, extending, and releasing locks on resources to ensure exclusive access and prevent conflicts in concurrent applications.
+ */ export { };

package/dest/noir/index.d.ts

@@ -0,0 +1,2 @@
+export * from './noir_package_config.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/noir/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/dest/noir/index.js

@@ -0,0 +1 @@
+export * from './noir_package_config.js';

package/dest/noir/noir_package_config.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+declare const noirGitDependencySchema: z.ZodObject<{
+    git: z.ZodString;
+    tag: z.ZodString;
+    directory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    git: string;
+    tag: string;
+    directory?: string | undefined;
+}, {
+    git: string;
+    tag: string;
+    directory?: string | undefined;
+}>;
+declare const noirLocalDependencySchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+declare const noirPackageConfigSchema: z.ZodObject<{
+    package: z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        type: z.ZodDefault<z.ZodEnum<["lib", "contract", "bin"]>>;
+        entry: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        authors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        compiler_version: z.ZodOptional<z.ZodString>;
+        backend: z.ZodOptional<z.ZodString>;
+        license: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "lib" | "contract" | "bin";
+        description?: string | undefined;
+        entry?: string | undefined;
+        authors?: string[] | undefined;
+        compiler_version?: string | undefined;
+        backend?: string | undefined;
+        license?: string | undefined;
+    }, {
+        description?: string | undefined;
+        name?: string | undefined;
+        type?: "lib" | "contract" | "bin" | undefined;
+        entry?: string | undefined;
+        authors?: string[] | undefined;
+        compiler_version?: string | undefined;
+        backend?: string | undefined;
+        license?: string | undefined;
+    }>;
+    dependencies: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        git: z.ZodString;
+        tag: z.ZodString;
+        directory: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        git: string;
+        tag: string;
+        directory?: string | undefined;
+    }, {
+        git: string;
+        tag: string;
+        directory?: string | undefined;
+    }>, z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>]>>>;
+}, "strip", z.ZodTypeAny, {
+    package: {
+        name: string;
+        type: "lib" | "contract" | "bin";
+        description?: string | undefined;
+        entry?: string | undefined;
+        authors?: string[] | undefined;
+        compiler_version?: string | undefined;
+        backend?: string | undefined;
+        license?: string | undefined;
+    };
+    dependencies: Record<string, {
+        git: string;
+        tag: string;
+        directory?: string | undefined;
+    } | {
+        path: string;
+    }>;
+}, {
+    package: {
+        description?: string | undefined;
+        name?: string | undefined;
+        type?: "lib" | "contract" | "bin" | undefined;
+        entry?: string | undefined;
+        authors?: string[] | undefined;
+        compiler_version?: string | undefined;
+        backend?: string | undefined;
+        license?: string | undefined;
+    };
+    dependencies?: Record<string, {
+        git: string;
+        tag: string;
+        directory?: string | undefined;
+    } | {
+        path: string;
+    }> | undefined;
+}>;
+/**
+ * Noir package configuration.
+ */
+export type NoirPackageConfig = z.infer<typeof noirPackageConfigSchema>;
+/**
+ * A remote package dependency.
+ */
+export type NoirGitDependencyConfig = z.infer<typeof noirGitDependencySchema>;
+/**
+ * A local package dependency.
+ */
+export type NoirLocalDependencyConfig = z.infer<typeof noirLocalDependencySchema>;
+/**
+ * A package dependency.
+ */
+export type NoirDependencyConfig = NoirGitDependencyConfig | NoirLocalDependencyConfig;
+/**
+ * Checks that an object is a package configuration.
+ * @param config - Config to check
+ */
+export declare function parseNoirPackageConfig(config: any): NoirPackageConfig;
+export {};
+//# sourceMappingURL=noir_package_config.d.ts.map

package/dest/noir/noir_package_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noir_package_config.d.ts","sourceRoot":"","sources":["../../src/noir/noir_package_config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,uBAAuB;;;;;;;;;;;;EAI3B,CAAC;AAEH,QAAA,MAAM,yBAAyB;;;;;;EAE7B,CAAC;AAEH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa3B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,GAAG,yBAAyB,CAAC;AAEvF;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,GAAG,GAAG,iBAAiB,CAErE"}