@aztec/foundation 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/promise/running-promise.js

@@ -1,40 +1,58 @@
 import { createLogger } from '../log/pino-logger.js';
 import { InterruptibleSleep } from '../sleep/index.js';
 import { promiseWithResolvers } from './utils.js';
+const EXIT = Symbol.for('RunningPromise.EXIT');
+export function makeLoggingErrorHandler(logger, ...ignoredErrors) {
+    return (err)=>{
+        if (err instanceof Error && !ignoredErrors.some((ErrorType)=>err instanceof ErrorType)) {
+            logger.error('Error in running promise', err);
+        }
+    };
+}
 /**
  * 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 class RunningPromise {
-    constructor(fn, logger = createLogger('running-promise'), pollingIntervalMS = 10000, ignoredErrors = []) {
+ */ export class RunningPromise {
+    fn;
+    logger;
+    pollingIntervalMS;
+    handleError;
+    running;
+    runningPromise;
+    interruptibleSleep;
+    requested;
+    static EXIT = EXIT;
+    constructor(fn, logger = createLogger('running-promise'), pollingIntervalMS = 10000, handleError = makeLoggingErrorHandler(logger)){
         this.fn = fn;
         this.logger = logger;
         this.pollingIntervalMS = pollingIntervalMS;
-        this.ignoredErrors = ignoredErrors;
+        this.handleError = handleError;
         this.running = false;
         this.runningPromise = Promise.resolve();
         this.interruptibleSleep = new InterruptibleSleep();
         this.requested = undefined;
     }
     /**
-     * Starts the running promise.
-     */
-    start() {
+   * Starts the running promise.
+   */ start() {
         if (this.running) {
             this.logger.warn(`Attempted to start running promise that was already started`);
             return;
         }
         this.running = true;
-        const poll = async () => {
-            while (this.running) {
+        const poll = async ()=>{
+            while(this.running){
                 const hasRequested = this.requested !== undefined;
                 try {
                     await this.fn();
-                }
-                catch (err) {
-                    if (err instanceof Error && !this.ignoredErrors.some(ErrorType => err instanceof ErrorType)) {
-                        this.logger.error('Error in running promise', err);
+                } catch (err) {
+                    const code = await this.handleError(err);
+                    if (code === RunningPromise.EXIT) {
+                        this.logger.warn('Error handler has requested to exit', {
+                            err
+                        });
+                        this.running = false;
                     }
                 }
                 // If an immediate run had been requested *before* the function started running, resolve the request.
@@ -43,7 +61,7 @@ export class RunningPromise {
                     this.requested = undefined;
                 }
                 // If no immediate run was requested, sleep for the polling interval.
-                if (this.requested === undefined) {
+                if (this.requested === undefined && this.running) {
                     await this.interruptibleSleep.sleep(this.pollingIntervalMS);
                 }
             }
@@ -51,10 +69,9 @@ export class RunningPromise {
         this.runningPromise = poll();
     }
     /**
-     * Stops the running promise, resolves any pending interruptible sleep,
-     * and waits for the currently executing function to complete.
-     */
-    async stop() {
+   * Stops the running promise, resolves any pending interruptible sleep,
+   * and waits for the currently executing function to complete.
+   */ async stop() {
         if (!this.running) {
             this.logger.warn(`Running promise was not started`);
             return;
@@ -64,17 +81,15 @@ export class RunningPromise {
         await this.runningPromise;
     }
     /**
-     * Checks if the running promise is currently active.
-     * @returns True if the promise is running.
-     */
-    isRunning() {
+   * Checks if the running promise is currently active.
+   * @returns True if the promise is running.
+   */ isRunning() {
         return this.running;
     }
     /**
-     * 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.
-     */
-    async trigger() {
+   * 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.
+   */ async trigger() {
         if (!this.running) {
             return this.fn();
         }
@@ -87,11 +102,9 @@ export class RunningPromise {
         await requested.promise;
     }
     /**
-     * Updates the polling interval. The new interval will take effect after the next poll.
-     * @param pollingIntervalMS The polling interval in milliseconds.
-     */
-    setPollingIntervalMS(pollingIntervalMS) {
+   * Updates the polling interval. The new interval will take effect after the next poll.
+   * @param pollingIntervalMS The polling interval in milliseconds.
+   */ setPollingIntervalMS(pollingIntervalMS) {
         this.pollingIntervalMS = pollingIntervalMS;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmluZy1wcm9taXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb21pc2UvcnVubmluZy1wcm9taXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNyRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEVBQTZCLG9CQUFvQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTdFOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sY0FBYztJQU16QixZQUNVLEVBQThCLEVBQzlCLFNBQVMsWUFBWSxDQUFDLGlCQUFpQixDQUFDLEVBQ3hDLG9CQUFvQixLQUFLLEVBQ3pCLGdCQUFtRCxFQUFFO1FBSHJELE9BQUUsR0FBRixFQUFFLENBQTRCO1FBQzlCLFdBQU0sR0FBTixNQUFNLENBQWtDO1FBQ3hDLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBUTtRQUN6QixrQkFBYSxHQUFiLGFBQWEsQ0FBd0M7UUFUdkQsWUFBTyxHQUFHLEtBQUssQ0FBQztRQUNoQixtQkFBYyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNuQyx1QkFBa0IsR0FBRyxJQUFJLGtCQUFrQixFQUFFLENBQUM7UUFDOUMsY0FBUyxHQUEyQyxTQUFTLENBQUM7SUFPbkUsQ0FBQztJQUVKOztPQUVHO0lBQ0ksS0FBSztRQUNWLElBQUksSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLDZEQUE2RCxDQUFDLENBQUM7WUFDaEYsT0FBTztRQUNULENBQUM7UUFDRCxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztRQUVwQixNQUFNLElBQUksR0FBRyxLQUFLLElBQUksRUFBRTtZQUN0QixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztnQkFDcEIsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFNBQVMsS0FBSyxTQUFTLENBQUM7Z0JBQ2xELElBQUksQ0FBQztvQkFDSCxNQUFNLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQztnQkFDbEIsQ0FBQztnQkFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO29CQUNiLElBQUksR0FBRyxZQUFZLEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsR0FBRyxZQUFZLFNBQVMsQ0FBQyxFQUFFLENBQUM7d0JBQzVGLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLDBCQUEwQixFQUFFLEdBQUcsQ0FBQyxDQUFDO29CQUNyRCxDQUFDO2dCQUNILENBQUM7Z0JBRUQscUdBQXFHO2dCQUNyRyxJQUFJLFlBQVksRUFBRSxDQUFDO29CQUNqQixJQUFJLENBQUMsU0FBVSxDQUFDLE9BQU8sRUFBRSxDQUFDO29CQUMxQixJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztnQkFDN0IsQ0FBQztnQkFFRCxxRUFBcUU7Z0JBQ3JFLElBQUksSUFBSSxDQUFDLFNBQVMsS0FBSyxTQUFTLEVBQUUsQ0FBQztvQkFDakMsTUFBTSxJQUFJLENBQUMsa0JBQWtCLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO2dCQUM5RCxDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUMsQ0FBQztRQUNGLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVEOzs7T0FHRztJQUNILEtBQUssQ0FBQyxJQUFJO1FBQ1IsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNsQixJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO1lBQ3BELE9BQU87UUFDVCxDQUFDO1FBQ0QsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDckIsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFNBQVMsRUFBRSxDQUFDO1FBQ3BDLE1BQU0sSUFBSSxDQUFDLGNBQWMsQ0FBQztJQUM1QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksU0FBUztRQUNkLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksS0FBSyxDQUFDLE9BQU87UUFDbEIsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNsQixPQUFPLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQztRQUNuQixDQUFDO1FBRUQsSUFBSSxTQUFTLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUMvQixJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7WUFDZixTQUFTLEdBQUcsb0JBQW9CLEVBQVEsQ0FBQztZQUN6QyxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztZQUMzQixJQUFJLENBQUMsa0JBQWtCLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDdEMsQ0FBQztRQUNELE1BQU0sU0FBVSxDQUFDLE9BQU8sQ0FBQztJQUMzQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsb0JBQW9CLENBQUMsaUJBQXlCO1FBQzVDLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxpQkFBaUIsQ0FBQztJQUM3QyxDQUFDO0NBQ0YifQ==

package/dest/promise/utils.js

@@ -2,21 +2,19 @@
  * A polyfill for the Promise.withResolvers proposed API.
  * @see https://github.com/tc39/proposal-promise-with-resolvers
  * @returns A promise with resolvers.
- */
-export function promiseWithResolvers() {
+ */ export function promiseWithResolvers() {
     // use ! operator to avoid TS error
     let resolve;
     let reject;
     // the ES spec guarantees that the promise executor is called synchronously
     // so the resolve and reject functions will be defined
-    const promise = new Promise((res, rej) => {
+    const promise = new Promise((res, rej)=>{
         resolve = res;
         reject = rej;
     });
     return {
         promise,
         resolve,
-        reject,
+        reject
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvbWlzZS91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQjtJQUNsQyxtQ0FBbUM7SUFDbkMsSUFBSSxPQUE0QixDQUFDO0lBQ2pDLElBQUksTUFBK0IsQ0FBQztJQUVwQywyRUFBMkU7SUFDM0Usc0RBQXNEO0lBQ3RELE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxFQUFFO1FBQzFDLE9BQU8sR0FBRyxHQUFHLENBQUM7UUFDZCxNQUFNLEdBQUcsR0FBRyxDQUFDO0lBQ2YsQ0FBQyxDQUFDLENBQUM7SUFFSCxPQUFPO1FBQ0wsT0FBTztRQUNQLE9BQU87UUFDUCxNQUFNO0tBQ1AsQ0FBQztBQUNKLENBQUMifQ==

package/dest/queue/base_memory_queue.js

@@ -1,39 +1,39 @@
 import { TimeoutError } from '../error/index.js';
 import { createLogger } from '../log/index.js';
 export class BaseMemoryQueue {
-    constructor(log = createLogger('foundation:memory_fifo')) {
+    log;
+    waiting;
+    flushing;
+    constructor(log = createLogger('foundation:memory_fifo')){
         this.log = log;
         this.waiting = [];
         this.flushing = false;
     }
     /**
-     * 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() {
+   * 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() {
         return this.items.length;
     }
     /**
-     * Returns next item within the queue, or undefined if the queue is empty. Does not block.
-     * @returns The next item in the queue.
-     */
-    getImmediate() {
+   * Returns next item within the queue, or undefined if the queue is empty. Does not block.
+   * @returns The next item in the queue.
+   */ getImmediate() {
         return this.items.get();
     }
     /**
-     * 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) {
+   * 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) {
         if (this.items.length) {
             return Promise.resolve(this.items.get());
         }
@@ -45,11 +45,11 @@ export class BaseMemoryQueue {
         if (timeoutSec === 0) {
             return Promise.reject(new TimeoutError('Timeout getting item from queue.'));
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject)=>{
             this.waiting.push(resolve);
             if (timeoutSec) {
-                setTimeout(() => {
-                    const index = this.waiting.findIndex(r => r === resolve);
+                setTimeout(()=>{
+                    const index = this.waiting.findIndex((r)=>r === resolve);
                     if (index > -1) {
                         this.waiting.splice(index, 1);
                         const err = new TimeoutError('Timeout getting item from queue.');
@@ -60,65 +60,57 @@ export class BaseMemoryQueue {
         });
     }
     /**
-     * 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) {
+   * 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) {
         if (this.flushing) {
             this.log.warn('Discarding item because queue is flushing');
             return false;
-        }
-        else if (this.waiting.length) {
+        } else if (this.waiting.length) {
             this.waiting.shift()(item);
             return true;
-        }
-        else {
+        } else {
             this.items.put(item);
             return true;
         }
     }
     /**
-     * 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() {
+   * 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() {
         this.flushing = true;
-        this.waiting.forEach(resolve => resolve(null));
+        this.waiting.forEach((resolve)=>resolve(null));
     }
     /**
-     * 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() {
+   * 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() {
         this.flushing = true;
         this.items.clear();
-        this.waiting.forEach(resolve => resolve(null));
+        this.waiting.forEach((resolve)=>resolve(null));
     }
     /**
-     * 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.
-     */
-    async process(handler) {
+   * 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.
+   */ async process(handler) {
         try {
-            while (true) {
+            while(true){
                 const item = await this.get();
                 if (item === null) {
                     break;
                 }
                 await handler(item);
             }
-        }
-        catch (err) {
+        } catch (err) {
             this.log.error('Queue handler exception', err);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZV9tZW1vcnlfcXVldWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvYmFzZV9tZW1vcnlfcXVldWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxNQUFNLE9BQWdCLGVBQWU7SUFJbkMsWUFBb0IsTUFBTSxZQUFZLENBQUMsd0JBQXdCLENBQUM7UUFBNUMsUUFBRyxHQUFILEdBQUcsQ0FBeUM7UUFIeEQsWUFBTyxHQUFpQyxFQUFFLENBQUM7UUFDM0MsYUFBUSxHQUFHLEtBQUssQ0FBQztJQUUwQyxDQUFDO0lBU3BFOzs7OztPQUtHO0lBQ0ksTUFBTTtRQUNYLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUM7SUFDM0IsQ0FBQztJQUVEOzs7T0FHRztJQUNJLFlBQVk7UUFDakIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQzFCLENBQUM7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0ksR0FBRyxDQUFDLFVBQW1CO1FBQzVCLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUN0QixPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUcsQ0FBQyxDQUFDO1FBQzVDLENBQUM7UUFFRCxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDN0MsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQy9CLENBQUM7UUFFRCxpRUFBaUU7UUFDakUsMENBQTBDO1FBQzFDLElBQUksVUFBVSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3JCLE9BQU8sT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLFlBQVksQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDLENBQUM7UUFDOUUsQ0FBQztRQUVELE9BQU8sSUFBSSxPQUFPLENBQVcsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7WUFDL0MsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7WUFFM0IsSUFBSSxVQUFVLEVBQUUsQ0FBQztnQkFDZixVQUFVLENBQUMsR0FBRyxFQUFFO29CQUNkLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxLQUFLLE9BQU8sQ0FBQyxDQUFDO29CQUN6RCxJQUFJLEtBQUssR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDO3dCQUNmLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQzt3QkFDOUIsTUFBTSxHQUFHLEdBQUcsSUFBSSxZQUFZLENBQUMsa0NBQWtDLENBQUMsQ0FBQzt3QkFDakUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO29CQUNkLENBQUM7Z0JBQ0gsQ0FBQyxFQUFFLFVBQVUsR0FBRyxJQUFJLENBQUMsQ0FBQztZQUN4QixDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEdBQUcsQ0FBQyxJQUFPO1FBQ2hCLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ2xCLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLDJDQUEyQyxDQUFDLENBQUM7WUFDM0QsT0FBTyxLQUFLLENBQUM7UUFDZixDQUFDO2FBQU0sSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQy9CLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDNUIsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO2FBQU0sQ0FBQztZQUNOLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3JCLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztJQUNILENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksR0FBRztRQUNSLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDakQsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxNQUFNO1FBQ1gsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUM7UUFDckIsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNuQixJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFFRDs7Ozs7Ozs7T0FRRztJQUNJLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBbUM7UUFDdEQsSUFBSSxDQUFDO1lBQ0gsT0FBTyxJQUFJLEVBQUUsQ0FBQztnQkFDWixNQUFNLElBQUksR0FBRyxNQUFNLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztnQkFDOUIsSUFBSSxJQUFJLEtBQUssSUFBSSxFQUFFLENBQUM7b0JBQ2xCLE1BQU07Z0JBQ1IsQ0FBQztnQkFDRCxNQUFNLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUN0QixDQUFDO1FBQ0gsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyx5QkFBeUIsRUFBRSxHQUFHLENBQUMsQ0FBQztRQUNqRCxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dest/queue/batch_queue.js

@@ -15,54 +15,60 @@ import { FifoMemoryQueue } from './fifo_memory_queue.js';
  * This ensures that batches don't grow too big and that they are flushed at a minimum rate of 1 batch every interval.
  *
  * The consumer side of this queue will process batches as quickly as possible.
- */
-export class BatchQueue {
-    constructor(processBatch, maxBatchSize, maxBatchDuration, log = createLogger('foundation:batch_queue')) {
+ */ export class BatchQueue {
+    processBatch;
+    maxBatchSize;
+    maxBatchDuration;
+    log;
+    container;
+    currentBatch;
+    runningPromise;
+    constructor(processBatch, maxBatchSize, maxBatchDuration, log = createLogger('foundation:batch_queue')){
         this.processBatch = processBatch;
         this.maxBatchSize = maxBatchSize;
         this.maxBatchDuration = maxBatchDuration;
         this.log = log;
         this.container = new FifoMemoryQueue();
-        /**
-         * Immediately flushes the current batch, starting a new one
-         */
-        this.flushCurrentBatch = () => {
+        this.flushCurrentBatch = ()=>{
             if (this.currentBatch) {
-                this.log.trace('Flushing batch', { size: this.currentBatch.items.length, key: this.currentBatch.key });
+                this.log.trace('Flushing batch', {
+                    size: this.currentBatch.items.length,
+                    key: this.currentBatch.key
+                });
                 clearTimeout(this.currentBatch.enqueueTimeout);
                 this.container.put(this.currentBatch);
                 this.currentBatch = undefined;
             }
         };
-        this.execProcessor = async (batch) => {
+        this.execProcessor = async (batch)=>{
             try {
                 await this.processBatch(batch.items, batch.key);
                 batch.deferred.resolve();
-            }
-            catch (err) {
+            } catch (err) {
                 batch.deferred.reject(err);
             }
         };
     }
     /**
-     * Put an item in the queue. It will be routed based on the given key
-     * @param item - The item to add
-     * @param key - The group key for this item
-     * @returns A promise that resolves or rejects when the batch this item is part of is processed
-     */
-    put(item, key) {
+   * Put an item in the queue. It will be routed based on the given key
+   * @param item - The item to add
+   * @param key - The group key for this item
+   * @returns A promise that resolves or rejects when the batch this item is part of is processed
+   */ put(item, key) {
         if (!this.runningPromise) {
             return Promise.reject(new Error('BatchQueue is not started'));
         }
         let currentBatch = this.currentBatch;
         if (!currentBatch || currentBatch.key !== key || currentBatch.items.length >= this.maxBatchSize) {
             this.flushCurrentBatch();
-            this.log.trace('Creating new batch', { key });
+            this.log.trace('Creating new batch', {
+                key
+            });
             currentBatch = {
                 items: [],
                 key,
                 deferred: promiseWithResolvers(),
-                enqueueTimeout: setTimeout(this.flushCurrentBatch, this.maxBatchDuration),
+                enqueueTimeout: setTimeout(this.flushCurrentBatch, this.maxBatchDuration)
             };
             this.currentBatch = currentBatch;
         }
@@ -73,19 +79,20 @@ export class BatchQueue {
         return currentBatch.deferred.promise;
     }
     /**
-     * Starts the queue.
-     */
-    start() {
+   * Immediately flushes the current batch, starting a new one
+   */ flushCurrentBatch;
+    /**
+   * Starts the queue.
+   */ start() {
         if (this.runningPromise) {
             return;
         }
         this.runningPromise = this.container.process(this.execProcessor);
     }
     /**
-     * Stops the queue. Any items in the queue will continue to be processed but new items won't be accepted anymore
-     * @returns A promise that resolves when the queue is drained completely
-     */
-    stop() {
+   * Stops the queue. Any items in the queue will continue to be processed but new items won't be accepted anymore
+   * @returns A promise that resolves when the queue is drained completely
+   */ stop() {
         const runningPromise = this.runningPromise;
         this.runningPromise = undefined;
         if (!runningPromise) {
@@ -94,5 +101,5 @@ export class BatchQueue {
         this.container.end();
         return runningPromise;
     }
+    execProcessor;
 }
-//# sourceMappingURL=data:application/json;base64,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

package/dest/queue/bounded_serial_queue.js

@@ -4,91 +4,81 @@ import { SerialQueue } from './serial_queue.js';
 /**
  * Leverages the unbounded SerialQueue and Semaphore to create a SerialQueue that will block when putting an item
  * if the queue size = maxQueueSize.
- */
-export class BoundedSerialQueue {
-    constructor(maxQueueSize, log = createLogger('foundation:bounded_serial_queue')) {
+ */ export class BoundedSerialQueue {
+    log;
+    queue;
+    semaphore;
+    constructor(maxQueueSize, log = createLogger('foundation:bounded_serial_queue')){
         this.log = log;
         this.queue = new SerialQueue();
         this.semaphore = new Semaphore(maxQueueSize);
     }
     /**
-     * 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() {
+   * 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() {
         this.queue.start();
     }
     /**
-     * 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() {
+   * 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() {
         return this.queue.length();
     }
     /**
-     * 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() {
+   * 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() {
         return this.queue.cancel();
     }
     /**
-     * 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() {
+   * 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() {
         return this.queue.end();
     }
     /**
-     * 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.
-     */
-    async put(fn) {
+   * 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.
+   */ async put(fn) {
         await this.semaphore.acquire();
-        this.queue
-            .put(async () => {
+        this.queue.put(async ()=>{
             try {
                 await fn();
-            }
-            finally {
+            } finally{
                 this.semaphore.release();
             }
-        })
-            .catch(err => {
+        }).catch((err)=>{
             this.log.error('BoundedSerialQueue handler exception:', err);
         });
     }
     /**
-     * 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.
-     */
-    async exec(fn) {
+   * 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.
+   */ async exec(fn) {
         await this.semaphore.acquire();
-        return this.queue.put(async () => {
+        return this.queue.put(async ()=>{
             try {
                 return await fn();
-            }
-            finally {
+            } finally{
                 this.semaphore.release();
             }
         });
     }
     /**
-     * Awaiting this ensures the queue is empty before resuming.
-     */
-    async syncPoint() {
+   * Awaiting this ensures the queue is empty before resuming.
+   */ async syncPoint() {
         await this.queue.syncPoint();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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

package/dest/queue/fifo_memory_queue.d.ts

@@ -1,4 +1,4 @@
-import { type Logger } from '../log/index.js';
+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.

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

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

@@ -3,20 +3,17 @@ 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 class FifoMemoryQueue extends BaseMemoryQueue {
-    constructor(log) {
+ */ export class FifoMemoryQueue extends BaseMemoryQueue {
+    container = new FifoQueue();
+    constructor(log){
         super(log);
-        this.container = new FifoQueue();
     }
     get items() {
         return this.container;
     }
 }
 class FifoQueue {
-    constructor() {
-        this.items = [];
-    }
+    items = [];
     put(item) {
         this.items.push(item);
     }
@@ -30,4 +27,3 @@ class FifoQueue {
         this.items = [];
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlmb19tZW1vcnlfcXVldWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvZmlmb19tZW1vcnlfcXVldWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXpEOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sZUFBbUIsU0FBUSxlQUFrQjtJQUd4RCxZQUFZLEdBQVk7UUFDdEIsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBSEwsY0FBUyxHQUFHLElBQUksU0FBUyxFQUFLLENBQUM7SUFJdkMsQ0FBQztJQUVELElBQXVCLEtBQUs7UUFDMUIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7Q0FDRjtBQUVELE1BQU0sU0FBUztJQUFmO1FBQ1UsVUFBSyxHQUFRLEVBQUUsQ0FBQztJQWlCMUIsQ0FBQztJQWZRLEdBQUcsQ0FBQyxJQUFPO1FBQ2hCLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3hCLENBQUM7SUFFTSxHQUFHO1FBQ1IsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFFRCxJQUFXLE1BQU07UUFDZixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDO0lBQzNCLENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUM7SUFDbEIsQ0FBQztDQUNGIn0=

package/dest/queue/index.js

@@ -4,4 +4,3 @@ export * from './serial_queue.js';
 export * from './bounded_serial_queue.js';
 export * from './semaphore.js';
 export * from './batch_queue.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUMifQ==