@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/noir/noir_package_config.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+const noirGitDependencySchema = z.object({
+    git: z.string(),
+    tag: z.string(),
+    directory: z.string().optional()
+});
+const noirLocalDependencySchema = z.object({
+    path: z.string()
+});
+const noirPackageConfigSchema = z.object({
+    package: z.object({
+        name: z.string().default(''),
+        type: z.enum([
+            'lib',
+            'contract',
+            'bin'
+        ]).default('bin'),
+        entry: z.string().optional(),
+        description: z.string().optional(),
+        authors: z.array(z.string()).optional(),
+        // eslint-disable-next-line camelcase
+        compiler_version: z.string().optional(),
+        backend: z.string().optional(),
+        license: z.string().optional()
+    }),
+    dependencies: z.record(z.string(), z.union([
+        noirGitDependencySchema,
+        noirLocalDependencySchema
+    ])).default({})
+});
+/**
+ * Checks that an object is a package configuration.
+ * @param config - Config to check
+ */ export function parseNoirPackageConfig(config) {
+    return noirPackageConfigSchema.parse(config);
+}

package/dest/number/index.d.ts

@@ -0,0 +1,3 @@
+/** Bounds the given value between the min and max provided (both inclusive) */
+export declare function boundInclusive(value: number, min: number, max: number): number;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9udW1iZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0VBQStFO0FBQy9FLHdCQUFnQixjQUFjLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQVk5RSJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/number/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAY9E"}

package/dest/number/index.js

@@ -0,0 +1,12 @@
+/** Bounds the given value between the min and max provided (both inclusive) */ export function boundInclusive(value, min, max) {
+    if (min > max) {
+        throw new Error('Minimum bound cannot be greater than maximum bound');
+    }
+    if (value < min) {
+        return min;
+    } else if (value > max) {
+        return max;
+    } else {
+        return value;
+    }
+}

package/dest/profiler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './profiler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm9maWxlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyJ9

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

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

package/dest/profiler/index.js

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

package/dest/profiler/profiler.d.ts

@@ -0,0 +1,8 @@
+declare function reset(): void;
+declare function runAsync<ReturnType>(label: string, fn: () => Promise<ReturnType>): Promise<ReturnType>;
+export declare const profiler: {
+    reset: typeof reset;
+    runAsync: typeof runAsync;
+};
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZmlsZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm9maWxlci9wcm9maWxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE4QkEsaUJBQVMsS0FBSyxJQUFJLElBQUksQ0FFckI7QUF3REQsaUJBQWUsUUFBUSxDQUFDLFVBQVUsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxNQUFNLE9BQU8sQ0FBQyxVQUFVLENBQUMsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBa0NyRztBQUVELGVBQU8sTUFBTSxRQUFROzs7Q0FBc0IsQ0FBQyJ9

package/dest/profiler/profiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiler.d.ts","sourceRoot":"","sources":["../../src/profiler/profiler.ts"],"names":[],"mappings":"AA8BA,iBAAS,KAAK,IAAI,IAAI,CAErB;AAwDD,iBAAe,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAkCrG;AAED,eAAO,MAAM,QAAQ;;;CAAsB,CAAC"}

package/dest/profiler/profiler.js

@@ -0,0 +1,97 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
+const als = new AsyncLocalStorage();
+const roots = [];
+function reset() {
+    roots.length = 0;
+}
+// Strip out circular references (parent) and unused fields (start) for JSON serialization
+function serializeSpans(spans) {
+    return spans.map((span)=>({
+            label: span.label,
+            dur: span.dur,
+            count: span.count,
+            children: serializeSpans(span.children)
+        }));
+}
+let i = 0;
+function save() {
+    if (roots.length === 0) {
+        return;
+    }
+    // Find max single execution time across all spans (dur/count since dur is accumulated)
+    const findMaxSingleDuration = (spans)=>{
+        let max = 0;
+        for (const span of spans){
+            const singleDur = span.dur / span.count;
+            max = Math.max(max, singleDur);
+            if (span.children.length > 0) {
+                max = Math.max(max, findMaxSingleDuration(span.children));
+            }
+        }
+        return max;
+    };
+    const profileData = {
+        spans: serializeSpans(roots),
+        timestamp: new Date().toISOString(),
+        totalTime: findMaxSingleDuration(roots)
+    };
+    const profilePath = path.join(process.cwd(), `profile-${i++}.json`);
+    process.stdout.write(`Writing profile data to ${profilePath}\n`);
+    fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
+}
+// Hook into Jest to save after each test
+if (typeof afterEach === 'function') {
+    afterEach(()=>{
+        save();
+        reset();
+    });
+}
+// Also save on process exit for non-Jest environments
+process.on('exit', ()=>{
+    save();
+});
+// Wrapper for async functions to maintain context properly
+async function runAsync(label, fn) {
+    const parent = als.getStore();
+    // Check if we already have a span with this label in the current context
+    let existingSpan;
+    if (parent) {
+        existingSpan = parent.children.find((c)=>c.label === label);
+    } else {
+        existingSpan = roots.find((r)=>r.label === label);
+    }
+    let span;
+    if (existingSpan) {
+        // Reuse existing span and increment count
+        span = existingSpan;
+        span.count++;
+    } else {
+        // Create new span
+        span = {
+            label,
+            start: performance.now(),
+            dur: 0,
+            count: 1,
+            children: [],
+            parent
+        };
+        if (parent) {
+            parent.children.push(span);
+        } else {
+            roots.push(span);
+        }
+    }
+    const startTime = performance.now();
+    const result = await als.run(span, fn);
+    const elapsed = performance.now() - startTime;
+    // Add to total duration (for averaging)
+    span.dur += elapsed;
+    return result;
+}
+export const profiler = {
+    reset,
+    runAsync
+};

package/dest/promise/index.d.ts

@@ -0,0 +1,3 @@
+export * from './running-promise.js';
+export * from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm9taXNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxZQUFZLENBQUMifQ==

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

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

@@ -0,0 +1,2 @@
+export * from './running-promise.js';
+export * from './utils.js';

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

@@ -0,0 +1,53 @@
+import { type Logger } from '../log/pino-logger.js';
+declare const EXIT: unique symbol;
+export type ErrorHandler = (err: unknown) => typeof EXIT | void | Promise<typeof EXIT | void>;
+export declare function makeLoggingErrorHandler(logger: Logger, ...ignoredErrors: (new (...args: any[]) => Error)[]): ErrorHandler;
+/**
+ * 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 handleError;
+    private running;
+    private runningPromise;
+    private interruptibleSleep;
+    private requested;
+    static readonly EXIT: typeof EXIT;
+    constructor(fn: () => void | Promise<void>, logger?: Logger, pollingIntervalMS?: number, handleError?: ErrorHandler);
+    /**
+     * Starts the running promise.
+     */
+    start(): this;
+    /**
+     * 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.
+     *
+     * Resolves only after a complete run of the function that *started after* this call: a run already in flight is
+     * allowed to finish first, and the function is then called again. Concurrent callers coalesce onto a single such
+     * run. Rejects if the loop stops (via `stop()` or an error handler requesting exit) before that run happens.
+     *
+     * Calling this from inside the function itself and awaiting the result deadlocks, since the awaited run cannot
+     * start until the current one returns. That usage is not supported.
+     */
+    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;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmluZy1wcm9taXNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvbWlzZS9ydW5uaW5nLXByb21pc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBSWxFLFFBQUEsTUFBTSxJQUFJLGVBQW9DLENBQUM7QUFFL0MsTUFBTSxNQUFNLFlBQVksR0FBRyxDQUFDLEdBQUcsRUFBRSxPQUFPLEtBQUssT0FBTyxJQUFJLEdBQUcsSUFBSSxHQUFHLE9BQU8sQ0FBQyxPQUFPLElBQUksR0FBRyxJQUFJLENBQUMsQ0FBQztBQUU5Rix3QkFBZ0IsdUJBQXVCLENBQ3JDLE1BQU0sRUFBRSxNQUFNLEVBQ2QsR0FBRyxhQUFhLEVBQUUsQ0FBQyxLQUFLLEdBQUcsSUFBSSxFQUFFLEdBQUcsRUFBRSxLQUFLLEtBQUssQ0FBQyxFQUFFLEdBQ2xELFlBQVksQ0FNZDtBQUVEOzs7O0dBSUc7QUFDSCxxQkFBYSxjQUFjO0lBU3ZCLE9BQU8sQ0FBQyxFQUFFO0lBQ1YsT0FBTyxDQUFDLE1BQU07SUFDZCxPQUFPLENBQUMsaUJBQWlCO0lBQ3pCLE9BQU8sQ0FBQyxXQUFXO0lBWHJCLE9BQU8sQ0FBQyxPQUFPLENBQVM7SUFDeEIsT0FBTyxDQUFDLGNBQWMsQ0FBcUI7SUFDM0MsT0FBTyxDQUFDLGtCQUFrQixDQUE0QjtJQUN0RCxPQUFPLENBQUMsU0FBUyxDQUFxRDtJQUV0RSxnQkFBdUIsSUFBSSxFQUFFLE9BQU8sSUFBSSxDQUFRO0lBRWhELFlBQ1UsRUFBRSxFQUFFLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFDOUIsTUFBTSxTQUFrQyxFQUN4QyxpQkFBaUIsU0FBUSxFQUN6QixXQUFXLEdBQUUsWUFBOEMsRUFDakU7SUFFSjs7T0FFRztJQUNJLEtBQUssU0F3Q1g7SUFFRDs7O09BR0c7SUFDRyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQU8xQjtJQUVEOzs7T0FHRztJQUNJLFNBQVMsWUFFZjtJQUVEOzs7Ozs7Ozs7T0FTRztJQUNVLE9BQU8sSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBWXBDO0lBRUQ7OztPQUdHO0lBQ0gsb0JBQW9CLENBQUMsaUJBQWlCLEVBQUUsTUFBTSxRQUU3QztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"running-promise.d.ts","sourceRoot":"","sources":["../../src/promise/running-promise.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,QAAA,MAAM,IAAI,eAAoC,CAAC;AAE/C,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,IAAI,GAAG,IAAI,CAAC,CAAC;AAE9F,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,GAAG,aAAa,EAAE,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,KAAK,CAAC,EAAE,GAClD,YAAY,CAMd;AAED;;;;GAIG;AACH,qBAAa,cAAc;IASvB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,iBAAiB;IACzB,OAAO,CAAC,WAAW;IAXrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,kBAAkB,CAA4B;IACtD,OAAO,CAAC,SAAS,CAAqD;IAEtE,gBAAuB,IAAI,EAAE,OAAO,IAAI,CAAQ;IAEhD,YACU,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC9B,MAAM,SAAkC,EACxC,iBAAiB,SAAQ,EACzB,WAAW,GAAE,YAA8C,EACjE;IAEJ;;OAEG;IACI,KAAK,SAwCX;IAED;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAO1B;IAED;;;OAGG;IACI,SAAS,YAEf;IAED;;;;;;;;;OASG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAYpC;IAED;;;OAGG;IACH,oBAAoB,CAAC,iBAAiB,EAAE,MAAM,QAE7C;CACF"}

package/dest/promise/running-promise.js

@@ -0,0 +1,122 @@
+import { InterruptError } from '../error/index.js';
+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 {
+    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.handleError = handleError;
+        this.running = false;
+        this.runningPromise = Promise.resolve();
+        this.interruptibleSleep = new InterruptibleSleep();
+        this.requested = undefined;
+    }
+    /**
+   * Starts the running promise.
+   */ start() {
+        if (this.running) {
+            this.logger.warn(`Attempted to start running promise that was already started`);
+            return this;
+        }
+        this.running = true;
+        const poll = async ()=>{
+            while(this.running){
+                const requested = this.requested;
+                this.requested = undefined;
+                try {
+                    await this.fn();
+                } 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.
+                if (requested) {
+                    requested.resolve();
+                }
+                // If no immediate run was requested, sleep for the polling interval.
+                if (this.requested === undefined && this.running) {
+                    await this.interruptibleSleep.sleep(this.pollingIntervalMS);
+                }
+            }
+            // A trigger that arrived after the final pass started will never be served by any pass, so settle it as
+            // failed rather than leaving its caller waiting forever.
+            const unserved = this.requested;
+            this.requested = undefined;
+            unserved?.reject(new InterruptError('RunningPromise stopped before serving trigger'));
+        };
+        this.runningPromise = poll();
+        return this;
+    }
+    /**
+   * Stops the running promise, resolves any pending interruptible sleep,
+   * and waits for the currently executing function to complete.
+   */ async stop() {
+        if (!this.running) {
+            return;
+        }
+        this.running = false;
+        this.interruptibleSleep.interrupt();
+        await this.runningPromise;
+    }
+    /**
+   * 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.
+   *
+   * Resolves only after a complete run of the function that *started after* this call: a run already in flight is
+   * allowed to finish first, and the function is then called again. Concurrent callers coalesce onto a single such
+   * run. Rejects if the loop stops (via `stop()` or an error handler requesting exit) before that run happens.
+   *
+   * Calling this from inside the function itself and awaiting the result deadlocks, since the awaited run cannot
+   * start until the current one returns. That usage is not supported.
+   */ async trigger() {
+        if (!this.running) {
+            return this.fn();
+        }
+        let requested = this.requested;
+        if (!requested) {
+            requested = promiseWithResolvers();
+            this.requested = requested;
+            this.interruptibleSleep.interrupt();
+        }
+        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) {
+        this.pollingIntervalMS = pollingIntervalMS;
+    }
+}

package/dest/promise/utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Like `Promise.all`, but runs every promise to completion before resolving or rejecting.
+ *
+ * `Promise.all` rejects as soon as one input rejects, abandoning the still-running siblings. When those siblings have
+ * side effects, the caller observes the rejection and reacts to the failure while the abandoned work is still
+ * producing effects. This helper instead guarantees that by the time it rejects, no input is still running.
+ *
+ * The signature mirrors `Promise.all`'s declaration in TypeScript's standard library, so call sites type exactly as
+ * they did with `Promise.all` (in particular, heterogeneous tuples keep their per-position types).
+ */
+export declare function allToCompletion<T extends readonly unknown[] | []>(promises: T): Promise<{
+    -readonly [P in keyof T]: Awaited<T[P]>;
+}>;
+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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm9taXNlL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQixlQUFlLENBQUMsQ0FBQyxTQUFTLFNBQVMsT0FBTyxFQUFFLEdBQUcsRUFBRSxFQUNyRSxRQUFRLEVBQUUsQ0FBQyxHQUNWLE9BQU8sQ0FBQztJQUFFLENBQUMsVUFBVSxDQUFDLElBQUksTUFBTSxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztDQUFFLENBQUMsQ0FpQnREO0FBRUQsTUFBTSxNQUFNLG9CQUFvQixDQUFDLENBQUMsSUFBSTtJQUNwQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3BCLE9BQU8sRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDLEtBQUssSUFBSSxDQUFDO0lBQzVCLE1BQU0sRUFBRSxDQUFDLE1BQU0sQ0FBQyxFQUFFLEdBQUcsS0FBSyxJQUFJLENBQUM7Q0FDaEMsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0Isb0JBQW9CLENBQUMsQ0FBQyxLQUFLLG9CQUFvQixDQUFDLENBQUMsQ0FBQyxDQWlCakUifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/promise/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,EACrE,QAAQ,EAAE,CAAC,GACV,OAAO,CAAC;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAiBtD;AAED,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/promise/utils.js

@@ -0,0 +1,40 @@
+/**
+ * Like `Promise.all`, but runs every promise to completion before resolving or rejecting.
+ *
+ * `Promise.all` rejects as soon as one input rejects, abandoning the still-running siblings. When those siblings have
+ * side effects, the caller observes the rejection and reacts to the failure while the abandoned work is still
+ * producing effects. This helper instead guarantees that by the time it rejects, no input is still running.
+ *
+ * The signature mirrors `Promise.all`'s declaration in TypeScript's standard library, so call sites type exactly as
+ * they did with `Promise.all` (in particular, heterogeneous tuples keep their per-position types).
+ */ export async function allToCompletion(promises) {
+    const results = await Promise.allSettled(promises);
+    const failures = results.filter((result)=>result.status === 'rejected');
+    if (failures.length === 1) {
+        // Rethrow a lone failure as-is so error identity is preserved for callers that inspect error types.
+        throw failures[0].reason;
+    } else if (failures.length > 1) {
+        throw new AggregateError(failures.map((failure)=>failure.reason), `${failures.length} of ${results.length} concurrent operations failed: ${failures.map((failure)=>failure.reason instanceof Error ? failure.reason.message : String(failure.reason)).join(' | ')}`);
+    }
+    return results.map((result)=>result.value);
+}
+/**
+ * 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() {
+    // 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)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+}

package/dest/queue/base_memory_queue.d.ts

@@ -0,0 +1,65 @@
+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> | void): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZV9tZW1vcnlfcXVldWUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWV1ZS9iYXNlX21lbW9yeV9xdWV1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSw4QkFBc0IsZUFBZSxDQUFDLENBQUM7SUFJekIsT0FBTyxDQUFDLEdBQUc7SUFIdkIsT0FBTyxDQUFDLE9BQU8sQ0FBb0M7SUFDbkQsT0FBTyxDQUFDLFFBQVEsQ0FBUztJQUV6QixZQUFvQixHQUFHLHlDQUF5QyxFQUFJO0lBRXBFLFNBQVMsQ0FBQyxRQUFRLEtBQUssS0FBSyxJQUFJO1FBQzlCLE1BQU0sRUFBRSxNQUFNLENBQUM7UUFDZixHQUFHLElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FBQztRQUNyQixHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsR0FBRyxJQUFJLENBQUM7UUFDbkIsS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0tBQ25CLENBQUM7SUFFRjs7Ozs7T0FLRztJQUNJLE1BQU0sV0FFWjtJQUVEOzs7T0FHRztJQUNJLFlBQVksSUFBSSxDQUFDLEdBQUcsU0FBUyxDQUVuQztJQUVEOzs7Ozs7Ozs7O09BVUc7SUFDSSxHQUFHLENBQUMsVUFBVSxDQUFDLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBNkJqRDtJQUVEOzs7O09BSUc7SUFDSSxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsR0FBRyxPQUFPLENBVzNCO0lBRUQ7Ozs7T0FJRztJQUNJLEdBQUcsU0FHVDtJQUVEOzs7O09BSUc7SUFDSSxNQUFNLFNBSVo7SUFFRDs7Ozs7Ozs7T0FRRztJQUNVLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLGlCQVk5RDtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"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;IAEzB,YAAoB,GAAG,yCAAyC,EAAI;IAEpE,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,WAEZ;IAED;;;OAGG;IACI,YAAY,IAAI,CAAC,GAAG,SAAS,CAEnC;IAED;;;;;;;;;;OAUG;IACI,GAAG,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CA6BjD;IAED;;;;OAIG;IACI,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAW3B;IAED;;;;OAIG;IACI,GAAG,SAGT;IAED;;;;OAIG;IACI,MAAM,SAIZ;IAED;;;;;;;;OAQG;IACU,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,iBAY9D;CACF"}

package/dest/queue/base_memory_queue.js

@@ -0,0 +1,116 @@
+import { TimeoutError } from '../error/index.js';
+import { createLogger } from '../log/index.js';
+export class BaseMemoryQueue {
+    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() {
+        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() {
+        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) {
+        if (this.items.length) {
+            return Promise.resolve(this.items.get());
+        }
+        if (this.items.length === 0 && this.flushing) {
+            return Promise.resolve(null);
+        }
+        // if the caller doesn't want to wait for an item to be available
+        // immediately reject with a Timeout error
+        if (timeoutSec === 0) {
+            return Promise.reject(new TimeoutError('Timeout getting item from queue.'));
+        }
+        return new Promise((resolve, reject)=>{
+            this.waiting.push(resolve);
+            if (timeoutSec) {
+                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.');
+                        reject(err);
+                    }
+                }, timeoutSec * 1000);
+            }
+        });
+    }
+    /**
+   * 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) {
+            this.waiting.shift()(item);
+            return true;
+        } 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() {
+        this.flushing = true;
+        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() {
+        this.flushing = true;
+        this.items.clear();
+        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) {
+        try {
+            while(true){
+                const item = await this.get();
+                if (item === null) {
+                    break;
+                }
+                await handler(item);
+            }
+        } catch (err) {
+            this.log.error('Queue handler exception', err);
+        }
+    }
+}