@aztec/foundation 0.74.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/message/index.d.ts

@@ -1,32 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/mutex/index.d.ts

@@ -1,53 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,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/mutex_database.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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/noir/index.d.ts

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

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

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

package/dest/noir/noir_package_config.d.ts

@@ -1,129 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dest/promise/index.d.ts

@@ -1,3 +0,0 @@
-export * from './running-promise.js';
-export * from './utils.js';
-//# sourceMappingURL=index.d.ts.map

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

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

package/dest/promise/running-promise.d.ts

@@ -1,41 +0,0 @@
-/**
- * RunningPromise is a utility class that helps manage the execution of an asynchronous function
- * at a specified polling interval. It allows starting, stopping, and checking the status of the
- * internally managed promise. The class also supports interrupting the polling process when stopped.
- */
-export declare class RunningPromise {
-    private fn;
-    private logger;
-    private pollingIntervalMS;
-    private ignoredErrors;
-    private running;
-    private runningPromise;
-    private interruptibleSleep;
-    private requested;
-    constructor(fn: () => void | Promise<void>, logger?: import("../log/pino-logger.js").Logger, pollingIntervalMS?: number, ignoredErrors?: (new (...args: any[]) => Error)[]);
-    /**
-     * Starts the running promise.
-     */
-    start(): void;
-    /**
-     * Stops the running promise, resolves any pending interruptible sleep,
-     * and waits for the currently executing function to complete.
-     */
-    stop(): Promise<void>;
-    /**
-     * Checks if the running promise is currently active.
-     * @returns True if the promise is running.
-     */
-    isRunning(): boolean;
-    /**
-     * Triggers an immediate run of the function, bypassing the polling interval.
-     * If the function is currently running, it will be allowed to continue and then called again immediately.
-     */
-    trigger(): Promise<void>;
-    /**
-     * Updates the polling interval. The new interval will take effect after the next poll.
-     * @param pollingIntervalMS The polling interval in milliseconds.
-     */
-    setPollingIntervalMS(pollingIntervalMS: number): void;
-}
-//# sourceMappingURL=running-promise.d.ts.map

package/dest/promise/running-promise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"running-promise.d.ts","sourceRoot":"","sources":["../../src/promise/running-promise.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,qBAAa,cAAc;IAOvB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,iBAAiB;IACzB,OAAO,CAAC,aAAa;IATvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,kBAAkB,CAA4B;IACtD,OAAO,CAAC,SAAS,CAAqD;gBAG5D,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC9B,MAAM,yCAAkC,EACxC,iBAAiB,SAAQ,EACzB,aAAa,GAAE,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,KAAK,CAAC,EAAO;IAG/D;;OAEG;IACI,KAAK;IAiCZ;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B;;;OAGG;IACI,SAAS;IAIhB;;;OAGG;IACU,OAAO;IAcpB;;;OAGG;IACH,oBAAoB,CAAC,iBAAiB,EAAE,MAAM;CAG/C"}

package/dest/promise/utils.d.ts

@@ -1,12 +0,0 @@
-export type PromiseWithResolvers<T> = {
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (reason?: any) => void;
-};
-/**
- * A polyfill for the Promise.withResolvers proposed API.
- * @see https://github.com/tc39/proposal-promise-with-resolvers
- * @returns A promise with resolvers.
- */
-export declare function promiseWithResolvers<T>(): PromiseWithResolvers<T>;
-//# sourceMappingURL=utils.d.ts.map

package/dest/promise/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/promise/utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;IACpC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CAChC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,KAAK,oBAAoB,CAAC,CAAC,CAAC,CAiBjE"}

package/dest/queue/base_memory_queue.d.ts

@@ -1,65 +0,0 @@
-export declare abstract class BaseMemoryQueue<T> {
-    private log;
-    private waiting;
-    private flushing;
-    constructor(log?: import("../log/pino-logger.js").Logger);
-    protected abstract get items(): {
-        length: number;
-        get(): T | undefined;
-        put(item: T): void;
-        clear: () => void;
-    };
-    /**
-     * Returns the current number of items in the queue.
-     * The length represents the size of the queue at the time of invocation and may change as new items are added or consumed.
-     *
-     * @returns The number of items in the queue.
-     */
-    length(): number;
-    /**
-     * Returns next item within the queue, or undefined if the queue is empty. Does not block.
-     * @returns The next item in the queue.
-     */
-    getImmediate(): T | undefined;
-    /**
-     * Returns next item within the queue, or blocks until an item has been put into the queue.
-     *
-     * If given a timeout, the promise will reject if no item is received after `timeoutSec` seconds.
-     * If the timeout is undefined (default), this call will block until an item is available or the queue is closed.
-     * If the timeout is 0 and there are no items available then the queue will immediately reject with a TimeoutError.
-     *
-     * If the queue is flushing, `null` is returned.
-     * @param timeoutSec - The timeout in seconds.
-     * @returns A result promise.
-     */
-    get(timeoutSec?: number): Promise<T | null>;
-    /**
-     * Put an item onto back of the queue.
-     * @param item - The item to enqueue.
-     * @returns A boolean indicating whether the item was successfully added to the queue.
-     */
-    put(item: T): boolean;
-    /**
-     * Once ended, no further items are added to queue. Consumers will consume remaining items within the queue.
-     * The queue is not reusable after calling `end()`.
-     * Any consumers waiting for an item receive null.
-     */
-    end(): void;
-    /**
-     * Once cancelled, all items are discarded from the queue, and no further items are added to the queue.
-     * The queue is not reusable after calling `cancel()`.
-     * Any consumers waiting for an item receive null.
-     */
-    cancel(): void;
-    /**
-     * Process items from the queue using a provided handler function.
-     * The function iterates over items in the queue, invoking the handler for each item until the queue is empty and flushing.
-     * If the handler throws an error, it will be caught and logged as 'Queue handler exception:', but the iteration will continue.
-     * The process function returns a promise that resolves when there are no more items in the queue and the queue is flushing.
-     *
-     * @param handler - A function that takes an item of type T and returns a Promise<void> after processing the item.
-     * @returns A Promise<void> that resolves when the queue is finished processing.
-     */
-    process(handler: (item: T) => Promise<void>): Promise<void>;
-}
-//# sourceMappingURL=base_memory_queue.d.ts.map

package/dest/queue/base_memory_queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base_memory_queue.d.ts","sourceRoot":"","sources":["../../src/queue/base_memory_queue.ts"],"names":[],"mappings":"AAGA,8BAAsB,eAAe,CAAC,CAAC;IAIzB,OAAO,CAAC,GAAG;IAHvB,OAAO,CAAC,OAAO,CAAoC;IACnD,OAAO,CAAC,QAAQ,CAAS;gBAEL,GAAG,yCAAyC;IAEhE,SAAS,CAAC,QAAQ,KAAK,KAAK,IAAI;QAC9B,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;QACrB,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QACnB,KAAK,EAAE,MAAM,IAAI,CAAC;KACnB,CAAC;IAEF;;;;;OAKG;IACI,MAAM;IAIb;;;OAGG;IACI,YAAY,IAAI,CAAC,GAAG,SAAS;IAIpC;;;;;;;;;;OAUG;IACI,GAAG,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IA+BlD;;;;OAIG;IACI,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO;IAa5B;;;;OAIG;IACI,GAAG;IAKV;;;;OAIG;IACI,MAAM;IAMb;;;;;;;;OAQG;IACU,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC;CAazD"}

package/dest/queue/bounded_serial_queue.d.ts

@@ -1,56 +0,0 @@
-/**
- * Leverages the unbounded SerialQueue and Semaphore to create a SerialQueue that will block when putting an item
- * if the queue size = maxQueueSize.
- */
-export declare class BoundedSerialQueue {
-    private log;
-    private readonly queue;
-    private semaphore;
-    constructor(maxQueueSize: number, log?: import("../log/pino-logger.js").Logger);
-    /**
-     * Initializes the underlying SerialQueue instance, allowing items to be processed from the queue.
-     * The start method should be called before using the BoundedSerialQueue to ensure proper functionality.
-     */
-    start(): void;
-    /**
-     * Returns the current number of items in the queue.
-     * This is useful for monitoring the size of BoundedSerialQueue and understanding its utilization.
-     *
-     * @returns The length of the queue as an integer value.
-     */
-    length(): number;
-    /**
-     * Cancels the current operation in the SerialQueue, if any, and clears the queue.
-     * Any pending tasks in the queue will not be executed, and the queue will be emptied.
-     * This method is useful for cleaning up resources and stopping ongoing processes when they are no longer needed.
-     * @returns A promise, resolved once cancelled.
-     */
-    cancel(): Promise<void>;
-    /**
-     * Ends the queue processing gracefully, preventing new items from being added.
-     * The currently executing item, if any, will complete and remaining queued items
-     * will be processed in order. Once all items have been processed, the queue becomes
-     * permanently unusable.
-     *
-     * @returns A promise that resolves when all items in the queue have been processed.
-     */
-    end(): Promise<void>;
-    /**
-     * The caller will block until fn is successfully enqueued.
-     * The fn itself is execute asynchronously and its result discarded.
-     * TODO(AD) do we need this if we have exec()?
-     * @param fn - The function to call once unblocked.
-     */
-    put(fn: () => Promise<void>): Promise<void>;
-    /**
-     * The caller will block until fn is successfully executed, and it's result returned.
-     * @param fn - The function.
-     * @returns A promise that resolves with the result once executed.
-     */
-    exec<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Awaiting this ensures the queue is empty before resuming.
-     */
-    syncPoint(): Promise<void>;
-}
-//# sourceMappingURL=bounded_serial_queue.d.ts.map

package/dest/queue/bounded_serial_queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bounded_serial_queue.d.ts","sourceRoot":"","sources":["../../src/queue/bounded_serial_queue.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,qBAAa,kBAAkB;IAIK,OAAO,CAAC,GAAG;IAH7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,SAAS,CAAY;gBAEjB,YAAY,EAAE,MAAM,EAAU,GAAG,yCAAkD;IAI/F;;;OAGG;IACI,KAAK;IAIZ;;;;;OAKG;IACI,MAAM;IAIb;;;;;OAKG;IACI,MAAM;IAIb;;;;;;;OAOG;IACI,GAAG;IAIV;;;;;OAKG;IACU,GAAG,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAexD;;;;OAIG;IACU,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAWtD;;OAEG;IACU,SAAS;CAGvB"}

package/dest/queue/fifo_memory_queue.d.ts

@@ -1,21 +0,0 @@
-import { type Logger } from '../log/index.js';
-import { BaseMemoryQueue } from './base_memory_queue.js';
-/**
- * A simple fifo queue. It can grow unbounded. It can have multiple producers and consumers.
- * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
- * the item being pushed is simply discarded.
- */
-export declare class FifoMemoryQueue<T> extends BaseMemoryQueue<T> {
-    private container;
-    constructor(log?: Logger);
-    protected get items(): FifoQueue<T>;
-}
-declare class FifoQueue<T> {
-    private items;
-    put(item: T): void;
-    get(): T | undefined;
-    get length(): number;
-    clear(): void;
-}
-export {};
-//# sourceMappingURL=fifo_memory_queue.d.ts.map

package/dest/queue/fifo_memory_queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fifo_memory_queue.d.ts","sourceRoot":"","sources":["../../src/queue/fifo_memory_queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;;;GAIG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;IACxD,OAAO,CAAC,SAAS,CAAsB;gBAE3B,GAAG,CAAC,EAAE,MAAM;IAIxB,cAAuB,KAAK,iBAE3B;CACF;AAED,cAAM,SAAS,CAAC,CAAC;IACf,OAAO,CAAC,KAAK,CAAW;IAEjB,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAIlB,GAAG,IAAI,CAAC,GAAG,SAAS;IAI3B,IAAW,MAAM,IAAI,MAAM,CAE1B;IAEM,KAAK;CAGb"}

package/dest/queue/index.d.ts

@@ -1,6 +0,0 @@
-export * from './fifo_memory_queue.js';
-export * from './priority_memory_queue.js';
-export * from './serial_queue.js';
-export * from './bounded_serial_queue.js';
-export * from './semaphore.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/queue/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC"}

package/dest/queue/priority_memory_queue.d.ts

@@ -1,13 +0,0 @@
-import { BaseMemoryQueue } from './base_memory_queue.js';
-import { PriorityQueue } from './priority_queue.js';
-/**
- * A priority queue. It can grow unbounded. It can have multiple producers and consumers.
- * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
- * the item being pushed is simply discarded.
- */
-export declare class PriorityMemoryQueue<T> extends BaseMemoryQueue<T> {
-    private container;
-    constructor(comparator: (a: T, b: T) => number);
-    protected get items(): PriorityQueue<T>;
-}
-//# sourceMappingURL=priority_memory_queue.d.ts.map

package/dest/queue/priority_memory_queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"priority_memory_queue.d.ts","sourceRoot":"","sources":["../../src/queue/priority_memory_queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,mBAAmB,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,SAAS,CAAmB;gBAExB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAK9C,cAAuB,KAAK,qBAE3B;CACF"}

package/dest/queue/priority_queue.d.ts

@@ -1,14 +0,0 @@
-/**
- * Priority queue implementation based on a custom comparator.
- */
-export declare class PriorityQueue<T> {
-    private comparator;
-    private items;
-    constructor(comparator: (a: T, b: T) => number);
-    put(item: T): void;
-    get(): T | undefined;
-    peek(): T | undefined;
-    clear(): void;
-    get length(): number;
-}
-//# sourceMappingURL=priority_queue.d.ts.map

package/dest/queue/priority_queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"priority_queue.d.ts","sourceRoot":"","sources":["../../src/queue/priority_queue.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,aAAa,CAAC,CAAC;IAGd,OAAO,CAAC,UAAU;IAF9B,OAAO,CAAC,KAAK,CAAM;gBAEC,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAI/C,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAQlB,GAAG,IAAI,CAAC,GAAG,SAAS;IAIpB,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB,KAAK;IAIZ,IAAW,MAAM,IAAI,MAAM,CAE1B;CACF"}

package/dest/queue/semaphore.d.ts

@@ -1,23 +0,0 @@
-/**
- * Allows the acquiring of up to `size` tokens before calls to acquire block, waiting for a call to release().
- */
-export declare class Semaphore {
-    private readonly queue;
-    constructor(size: number);
-    /**
-     * Acquires a token from the Semaphore, allowing access to a limited resource.
-     * If no tokens are available, the call will block and wait until a token is released.
-     * Use in conjunction with the release() method to manage access to resources with limited capacity.
-     *
-     * @returns A Promise that resolves when a token is acquired.
-     */
-    acquire(): Promise<void>;
-    /**
-     * Releases a token back into the semaphore, allowing another acquire call to proceed.
-     * If there are any pending calls to acquire(), one of them will be unblocked and allowed to proceed.
-     * This method should only be called by the holder of the acquired token to ensure proper functionality
-     * and avoid unexpected behavior.
-     */
-    release(): void;
-}
-//# sourceMappingURL=semaphore.d.ts.map

package/dest/queue/semaphore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"semaphore.d.ts","sourceRoot":"","sources":["../../src/queue/semaphore.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;gBAE5C,IAAI,EAAE,MAAM;IAIxB;;;;;;OAMG;IACU,OAAO;IAIpB;;;;;OAKG;IACI,OAAO;CAGf"}

package/dest/queue/serial_queue.d.ts

@@ -1,49 +0,0 @@
-/**
- * A more specialized fifo queue that enqueues functions to execute. Enqueued functions are executed in serial.
- */
-export declare class SerialQueue {
-    private readonly queue;
-    private runningPromise;
-    private started;
-    /**
-     * Initializes the execution of enqueued functions in the serial queue.
-     * Functions are executed in the order they were added to the queue, with each function
-     * waiting for the completion of the previous one before starting its execution.
-     * This method should be called once to start processing the queue.
-     */
-    start(): void;
-    /**
-     * Returns the current number of enqueued functions in the serial queue.
-     * This provides a way to check the size of the queue and monitor its progress.
-     *
-     * @returns The length of the serial queue as a number.
-     */
-    length(): number;
-    /**
-     * Cancels the processing of the remaining functions in the serial queue and resolves the running promise.
-     * Any enqueued functions that have not yet been executed will be discarded. The queue can still accept new
-     * functions after cancellation, but the previously enqueued functions will not be re-processed.
-     *
-     * @returns The running promise which resolves when the current executing function (if any) completes.
-     */
-    cancel(): Promise<void>;
-    /**
-     * Signals the SerialQueue that it should finish processing its current task and stop accepting new tasks.
-     * The returned Promise resolves when all enqueued tasks have completed execution.
-     *
-     * @returns A Promise that resolves when the queue is completely emptied and no new tasks are allowed.
-     */
-    end(): Promise<void>;
-    /**
-     * Enqueues fn for execution on the serial queue.
-     * Returns the result of the function after execution.
-     * @param fn - The function to enqueue.
-     * @returns A resolution promise. Rejects if the function does, or if the function could not be enqueued.
-     */
-    put<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Awaiting this ensures the queue is empty before resuming.
-     */
-    syncPoint(): Promise<void>;
-}
-//# sourceMappingURL=serial_queue.d.ts.map

package/dest/queue/serial_queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serial_queue.d.ts","sourceRoot":"","sources":["../../src/queue/serial_queue.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8C;IACpE,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,OAAO,CAAS;IAExB;;;;;OAKG;IACI,KAAK;IAQZ;;;;;OAKG;IACI,MAAM;IAIb;;;;;;OAMG;IACI,MAAM;IAKb;;;;;OAKG;IACI,GAAG;IAKV;;;;;OAKG;IACI,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgB/C;;OAEG;IACU,SAAS;CAGvB"}