@aztec/prover-client 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/dest/orchestrator/chonk-cache.d.ts

@@ -0,0 +1,39 @@
+import type { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { type LoggerBindings } from '@aztec/foundation/log';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { PublicChonkVerifierPublicInputs } from '@aztec/stdlib/rollup';
+/** Result of a chonk-verifier proof, cached by tx hash. */
+export type ChonkVerifierProofResult = PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+/**
+ * Shared cache of `getPublicChonkVerifierProof` results, keyed by tx hash.
+ *
+ * Owned by the prover-node and shared across every epoch / session: a tx remined into
+ * a different block (e.g. after a brief L1 reorg) reuses the already-computed chonk
+ * proof rather than redoing it. Entries are released via `releaseForBlocks` once the
+ * containing block is no longer interesting to the caller (e.g. its epoch's proof
+ * submission window has expired).
+ */
+export declare class ChonkCache {
+    private readonly cache;
+    private readonly pending;
+    private readonly log;
+    private stopped;
+    constructor(bindings?: LoggerBindings);
+    /** Returns the cached promise for `txHash`, or `undefined` if none is registered. */
+    get(txHash: string): Promise<ChonkVerifierProofResult> | undefined;
+    /**
+     * Atomic get-or-compute: returns the cached promise for `txHash`, or runs `factory`
+     * (passing an AbortSignal the cache controls) and caches its result. Concurrent
+     * callers for the same `txHash` share the same promise.
+     *
+     * Rejected promises are evicted so a future caller can retry. The factory's
+     * AbortSignal fires when the cache is stopped.
+     */
+    getOrCompute(txHash: string, factory: (signal: AbortSignal) => Promise<ChonkVerifierProofResult>): Promise<ChonkVerifierProofResult>;
+    /** Drops cache entries for every tx in the supplied blocks. */
+    releaseForBlocks(blocks: L2Block[]): void;
+    /** Aborts every in-flight chonk-verifier job and clears the cache. */
+    stop(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hvbmstY2FjaGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvY2hvbmstY2FjaGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUseUNBQXlDLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNsRixPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDdkYsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRixPQUFPLEtBQUssRUFBRSwrQkFBK0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRTVFLDJEQUEyRDtBQUMzRCxNQUFNLE1BQU0sd0JBQXdCLEdBQUcsNkJBQTZCLENBQ2xFLCtCQUErQixFQUMvQixPQUFPLHlDQUF5QyxDQUNqRCxDQUFDO0FBRUY7Ozs7Ozs7O0dBUUc7QUFDSCxxQkFBYSxVQUFVO0lBQ3JCLE9BQU8sQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUF3RDtJQUM5RSxPQUFPLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBc0M7SUFDOUQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQVM7SUFDN0IsT0FBTyxDQUFDLE9BQU8sQ0FBUztJQUV4QixZQUFZLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFFcEM7SUFFRCxxRkFBcUY7SUFDOUUsR0FBRyxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLHdCQUF3QixDQUFDLEdBQUcsU0FBUyxDQUV4RTtJQUVEOzs7Ozs7O09BT0c7SUFDSSxZQUFZLENBQ2pCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsT0FBTyxFQUFFLENBQUMsTUFBTSxFQUFFLFdBQVcsS0FBSyxPQUFPLENBQUMsd0JBQXdCLENBQUMsR0FDbEUsT0FBTyxDQUFDLHdCQUF3QixDQUFDLENBbUJuQztJQUVELCtEQUErRDtJQUN4RCxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLEdBQUcsSUFBSSxDQWUvQztJQUVELHNFQUFzRTtJQUMvRCxJQUFJLElBQUksSUFBSSxDQVVsQjtDQUNGIn0=

package/dest/orchestrator/chonk-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chonk-cache.d.ts","sourceRoot":"","sources":["../../src/orchestrator/chonk-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AAClF,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAE5E,2DAA2D;AAC3D,MAAM,MAAM,wBAAwB,GAAG,6BAA6B,CAClE,+BAA+B,EAC/B,OAAO,yCAAyC,CACjD,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwD;IAC9E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAC9D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IAExB,YAAY,QAAQ,CAAC,EAAE,cAAc,EAEpC;IAED,qFAAqF;IAC9E,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAExE;IAED;;;;;;;OAOG;IACI,YAAY,CACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,wBAAwB,CAAC,GAClE,OAAO,CAAC,wBAAwB,CAAC,CAmBnC;IAED,+DAA+D;IACxD,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAe/C;IAED,sEAAsE;IAC/D,IAAI,IAAI,IAAI,CAUlB;CACF"}

package/dest/orchestrator/chonk-cache.js

@@ -0,0 +1,80 @@
+import { createLogger } from '@aztec/foundation/log';
+/**
+ * Shared cache of `getPublicChonkVerifierProof` results, keyed by tx hash.
+ *
+ * Owned by the prover-node and shared across every epoch / session: a tx remined into
+ * a different block (e.g. after a brief L1 reorg) reuses the already-computed chonk
+ * proof rather than redoing it. Entries are released via `releaseForBlocks` once the
+ * containing block is no longer interesting to the caller (e.g. its epoch's proof
+ * submission window has expired).
+ */ export class ChonkCache {
+    cache = new Map();
+    pending = new Map();
+    log;
+    stopped = false;
+    constructor(bindings){
+        this.log = createLogger('prover-client:chonk-cache', bindings);
+    }
+    /** Returns the cached promise for `txHash`, or `undefined` if none is registered. */ get(txHash) {
+        return this.cache.get(txHash);
+    }
+    /**
+   * Atomic get-or-compute: returns the cached promise for `txHash`, or runs `factory`
+   * (passing an AbortSignal the cache controls) and caches its result. Concurrent
+   * callers for the same `txHash` share the same promise.
+   *
+   * Rejected promises are evicted so a future caller can retry. The factory's
+   * AbortSignal fires when the cache is stopped.
+   */ getOrCompute(txHash, factory) {
+        if (this.stopped) {
+            return Promise.reject(new Error('ChonkCache is stopped'));
+        }
+        const existing = this.cache.get(txHash);
+        if (existing) {
+            return existing;
+        }
+        const controller = new AbortController();
+        this.pending.set(txHash, controller);
+        this.log.debug(`Enqueueing chonk-verifier circuit`, {
+            txHash
+        });
+        const promise = factory(controller.signal).finally(()=>this.pending.delete(txHash));
+        // Silently observe the rejection branch and evict so a retry is possible.
+        promise.catch((err)=>{
+            this.cache.delete(txHash);
+            this.log.debug(`Chonk-verifier proof failed; evicted from cache`, {
+                txHash,
+                error: `${err}`
+            });
+        });
+        this.cache.set(txHash, promise);
+        return promise;
+    }
+    /** Drops cache entries for every tx in the supplied blocks. */ releaseForBlocks(blocks) {
+        let released = 0;
+        for (const block of blocks){
+            for (const txEffect of block.body.txEffects){
+                if (this.cache.delete(txEffect.txHash.toString())) {
+                    released++;
+                }
+            }
+        }
+        if (released > 0) {
+            this.log.debug(`Released ${released} chonk-verifier cache entries`, {
+                blockCount: blocks.length,
+                releasedCount: released
+            });
+        }
+    }
+    /** Aborts every in-flight chonk-verifier job and clears the cache. */ stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        for (const controller of this.pending.values()){
+            controller.abort();
+        }
+        this.pending.clear();
+        this.cache.clear();
+    }
+}

package/dest/orchestrator/index.d.ts

@@ -1,5 +1,4 @@
-export { ProvingOrchestrator } from './orchestrator.js';
 export { CheckpointSubTreeOrchestrator, type SubTreeResult } from './checkpoint-sub-tree-orchestrator.js';
-export { EpochProvingContext, type ChonkVerifierProofResult } from './epoch-proving-context.js';
+export { ChonkCache, type ChonkVerifierProofResult } from './chonk-cache.js';
 export { TopTreeOrchestrator, TopTreeCancelledError, type CheckpointTopTreeData, type TopTreeResult, } from './top-tree-orchestrator.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEQsT0FBTyxFQUFFLDZCQUE2QixFQUFFLEtBQUssYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDMUcsT0FBTyxFQUFFLG1CQUFtQixFQUFFLEtBQUssd0JBQXdCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNoRyxPQUFPLEVBQ0wsbUJBQW1CLEVBQ25CLHFCQUFxQixFQUNyQixLQUFLLHFCQUFxQixFQUMxQixLQUFLLGFBQWEsR0FDbkIsTUFBTSw0QkFBNEIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDZCQUE2QixFQUFFLEtBQUssYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDMUcsT0FBTyxFQUFFLFVBQVUsRUFBRSxLQUFLLHdCQUF3QixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDN0UsT0FBTyxFQUNMLG1CQUFtQixFQUNuQixxQkFBcUIsRUFDckIsS0FBSyxxQkFBcUIsRUFDMUIsS0FBSyxhQUFhLEdBQ25CLE1BQU0sNEJBQTRCLENBQUMifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,6BAA6B,EAAE,KAAK,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAC1G,OAAO,EAAE,mBAAmB,EAAE,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAChG,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,GACnB,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,KAAK,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAC1G,OAAO,EAAE,UAAU,EAAE,KAAK,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,GACnB,MAAM,4BAA4B,CAAC"}

package/dest/orchestrator/index.js

@@ -1,4 +1,3 @@
-export { ProvingOrchestrator } from './orchestrator.js';
 export { CheckpointSubTreeOrchestrator } from './checkpoint-sub-tree-orchestrator.js';
-export { EpochProvingContext } from './epoch-proving-context.js';
+export { ChonkCache } from './chonk-cache.js';
 export { TopTreeOrchestrator, TopTreeCancelledError } from './top-tree-orchestrator.js';

package/dest/orchestrator/proving-scheduler.d.ts

@@ -1,8 +1,9 @@
 import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
 /**
- * Minimal surface a deferred-proving state must expose. Both `EpochProvingState` /
- * `CheckpointProvingState` / `BlockProvingState` (used by `ProvingOrchestrator`) and
- * `TopTreeProvingState` (used by `TopTreeOrchestrator`) satisfy it.
+ * Minimal surface a deferred-proving state must expose. Both `CheckpointProvingState` /
+ * `BlockProvingState` (used by `CheckpointSubTreeOrchestrator`) and `TopTreeProvingState`
+ * (used by `TopTreeOrchestrator`) satisfy it.
  */
 export interface ProvingStateLike {
     /** Returns false once the state has been cancelled or otherwise invalidated. */
@@ -14,7 +15,16 @@ export interface ProvingStateLike {
  * Common scheduling infrastructure shared by every orchestrator that drives broker
  * proving jobs:
  *
- *   - One `SerialQueue` (`deferredJobQueue`) acting as the enqueue-throttle.
+ *   - A shared `SerialQueue` (`deferredJobQueue`) that serialises the *act of handing a
+ *     job to the broker*, one initiation per event-loop tick. Each queue task kicks off
+ *     `safeJob` (which submits to the broker) without awaiting it, then yields with
+ *     `sleep(0)`; the next task therefore runs on the following macrotask. This does NOT
+ *     cap how many broker jobs are concurrently in flight — the broker's own queue absorbs
+ *     that. What it bounds is the burst rate: a sub-tree that synchronously discovers
+ *     thousands of ready jobs can't flood the broker (and monopolise the event loop) in a
+ *     single tick. The queue is owned by the `ProverClient` and shared across every
+ *     orchestrator (every sub-tree and top-tree across every concurrent epoch session), so
+ *     this pacing is applied once globally rather than once-per-orchestrator.
  *   - A list of `AbortController`s (`pendingProvingJobs`) so a `cancel()` can abort
  *     in-flight broker jobs when needed.
  *   - A `deferredProving<T>(state, request, callback, isCancelled?)` method that wraps
@@ -23,24 +33,24 @@ export interface ProvingStateLike {
  *
  * Subclasses own their own concrete proving state and define `cancelInternal()` for
  * the rest of the cleanup work (closing world-state forks, marking sub-trees
- * cancelled, etc.). `stop()` lives on the base class and follows the standard pattern
- * of grabbing the old queue, calling `cancelInternal()` (which recreates the queue),
- * and awaiting the old queue's drain.
+ * cancelled, etc.). Because the queue is shared, neither `cancel()` nor `stop()` touch
+ * it — they only abort this orchestrator's in-flight broker jobs. Queued-but-unrun jobs
+ * for a cancelled orchestrator no-op via the guards in `deferredProving`.
  */
 export declare abstract class ProvingScheduler {
-    private readonly enqueueConcurrency;
+    private readonly deferredJobQueue;
     protected pendingProvingJobs: AbortController[];
     protected logger: Logger;
-    private deferredJobQueue;
-    constructor(enqueueConcurrency: number, loggerName?: string, bindings?: LoggerBindings);
+    constructor(deferredJobQueue: SerialQueue, loggerName?: string, bindings?: LoggerBindings);
     /** Number of broker jobs currently in flight. */
     getNumPendingProvingJobs(): number;
     /**
-     * Drains the deferred-job queue, recreates it (so the subclass can be reused), and
-     * optionally aborts every in-flight broker job. Aborting is the right choice on
+     * Optionally aborts every in-flight broker job. Aborting is the right choice on
      * reorg-driven cancel (where the in-flight inputs are no longer valid) and the
      * wrong choice on shutdown (where leaving jobs in the broker queue lets a restart
-     * pick them up).
+     * pick them up). The shared queue is not touched — queued-but-unrun jobs belonging
+     * to this orchestrator no-op once their controller is aborted (or once their state
+     * is marked invalid by the subclass).
      */
     protected resetSchedulerState(abortJobs: boolean): void;
     /**
@@ -50,9 +60,8 @@ export declare abstract class ProvingScheduler {
      */
     protected abstract cancelInternal(): void;
     /**
-     * Standard stop: grab the old queue, cancel (which recreates the queue), then
-     * await the old queue's drain so any final job tear-down has unwound before we
-     * return.
+     * Standard stop: cancel this orchestrator's work. The shared queue is owned by the
+     * `ProverClient` and outlives every orchestrator, so it is not drained here.
      */
     stop(): Promise<void>;
     /**
@@ -69,4 +78,4 @@ export declare abstract class ProvingScheduler {
      */
     protected deferredProving<S extends ProvingStateLike, T>(state: S, request: (signal: AbortSignal) => Promise<T>, callback: (result: T) => void | Promise<void>, isCancelled?: () => boolean): void;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmluZy1zY2hlZHVsZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvcHJvdmluZy1zY2hlZHVsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBSXZGOzs7O0dBSUc7QUFDSCxNQUFNLFdBQVcsZ0JBQWdCO0lBQy9CLGdGQUFnRjtJQUNoRixXQUFXLElBQUksT0FBTyxDQUFDO0lBQ3ZCLHFEQUFxRDtJQUNyRCxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxJQUFJLENBQUM7Q0FDOUI7QUFFRDs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILDhCQUFzQixnQkFBZ0I7SUFNbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxrQkFBa0I7SUFMckMsU0FBUyxDQUFDLGtCQUFrQixFQUFFLGVBQWUsRUFBRSxDQUFNO0lBQ3JELFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ3pCLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBYztJQUV0QyxZQUNtQixrQkFBa0IsRUFBRSxNQUFNLEVBQzNDLFVBQVUsU0FBb0MsRUFDOUMsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUsxQjtJQUVELGlEQUFpRDtJQUMxQyx3QkFBd0IsSUFBSSxNQUFNLENBRXhDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsU0FBUyxDQUFDLG1CQUFtQixDQUFDLFNBQVMsRUFBRSxPQUFPLEdBQUcsSUFBSSxDQVN0RDtJQUVEOzs7O09BSUc7SUFDSCxTQUFTLENBQUMsUUFBUSxDQUFDLGNBQWMsSUFBSSxJQUFJLENBQUM7SUFFMUM7Ozs7T0FJRztJQUNVLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBSWpDO0lBRUQ7Ozs7Ozs7Ozs7O09BV0c7SUFDSCxTQUFTLENBQUMsZUFBZSxDQUFDLENBQUMsU0FBUyxnQkFBZ0IsRUFBRSxDQUFDLEVBQ3JELEtBQUssRUFBRSxDQUFDLEVBQ1IsT0FBTyxFQUFFLENBQUMsTUFBTSxFQUFFLFdBQVcsS0FBSyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQzVDLFFBQVEsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLEtBQUssSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFDN0MsV0FBVyxHQUFFLE1BQU0sT0FBcUIsR0FDdkMsSUFBSSxDQStDTjtDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmluZy1zY2hlZHVsZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvcHJvdmluZy1zY2hlZHVsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBQ3ZGLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUd0RDs7OztHQUlHO0FBQ0gsTUFBTSxXQUFXLGdCQUFnQjtJQUMvQixnRkFBZ0Y7SUFDaEYsV0FBVyxJQUFJLE9BQU8sQ0FBQztJQUN2QixxREFBcUQ7SUFDckQsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUFDO0NBQzlCO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F5Qkc7QUFDSCw4QkFBc0IsZ0JBQWdCO0lBS2xDLE9BQU8sQ0FBQyxRQUFRLENBQUMsZ0JBQWdCO0lBSm5DLFNBQVMsQ0FBQyxrQkFBa0IsRUFBRSxlQUFlLEVBQUUsQ0FBTTtJQUNyRCxTQUFTLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQztJQUV6QixZQUNtQixnQkFBZ0IsRUFBRSxXQUFXLEVBQzlDLFVBQVUsU0FBb0MsRUFDOUMsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUcxQjtJQUVELGlEQUFpRDtJQUMxQyx3QkFBd0IsSUFBSSxNQUFNLENBRXhDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILFNBQVMsQ0FBQyxtQkFBbUIsQ0FBQyxTQUFTLEVBQUUsT0FBTyxHQUFHLElBQUksQ0FNdEQ7SUFFRDs7OztPQUlHO0lBQ0gsU0FBUyxDQUFDLFFBQVEsQ0FBQyxjQUFjLElBQUksSUFBSSxDQUFDO0lBRTFDOzs7T0FHRztJQUNJLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRzNCO0lBRUQ7Ozs7Ozs7Ozs7O09BV0c7SUFDSCxTQUFTLENBQUMsZUFBZSxDQUFDLENBQUMsU0FBUyxnQkFBZ0IsRUFBRSxDQUFDLEVBQ3JELEtBQUssRUFBRSxDQUFDLEVBQ1IsT0FBTyxFQUFFLENBQUMsTUFBTSxFQUFFLFdBQVcsS0FBSyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQzVDLFFBQVEsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLEtBQUssSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFDN0MsV0FBVyxHQUFFLE1BQU0sT0FBcUIsR0FDdkMsSUFBSSxDQWlETjtDQUNGIn0=

package/dest/orchestrator/proving-scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proving-scheduler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/proving-scheduler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAIvF;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,WAAW,IAAI,OAAO,CAAC;IACvB,qDAAqD;IACrD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,gBAAgB;IAMlC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IALrC,SAAS,CAAC,kBAAkB,EAAE,eAAe,EAAE,CAAM;IACrD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,gBAAgB,CAAc;IAEtC,YACmB,kBAAkB,EAAE,MAAM,EAC3C,UAAU,SAAoC,EAC9C,QAAQ,CAAC,EAAE,cAAc,EAK1B;IAED,iDAAiD;IAC1C,wBAAwB,IAAI,MAAM,CAExC;IAED;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAStD;IAED;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI,CAAC;IAE1C;;;;OAIG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAIjC;IAED;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,EACrD,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5C,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC7C,WAAW,GAAE,MAAM,OAAqB,GACvC,IAAI,CA+CN;CACF"}
+{"version":3,"file":"proving-scheduler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/proving-scheduler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,WAAW,IAAI,OAAO,CAAC;IACvB,qDAAqD;IACrD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8BAAsB,gBAAgB;IAKlC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAJnC,SAAS,CAAC,kBAAkB,EAAE,eAAe,EAAE,CAAM;IACrD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IAEzB,YACmB,gBAAgB,EAAE,WAAW,EAC9C,UAAU,SAAoC,EAC9C,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED,iDAAiD;IAC1C,wBAAwB,IAAI,MAAM,CAExC;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAMtD;IAED;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI,CAAC;IAE1C;;;OAGG;IACI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAG3B;IAED;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,EACrD,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5C,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC7C,WAAW,GAAE,MAAM,OAAqB,GACvC,IAAI,CAiDN;CACF"}

package/dest/orchestrator/proving-scheduler.js

@@ -1,12 +1,20 @@
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
-import { SerialQueue } from '@aztec/foundation/queue';
 import { sleep } from '@aztec/foundation/sleep';
 /**
  * Common scheduling infrastructure shared by every orchestrator that drives broker
  * proving jobs:
  *
- *   - One `SerialQueue` (`deferredJobQueue`) acting as the enqueue-throttle.
+ *   - A shared `SerialQueue` (`deferredJobQueue`) that serialises the *act of handing a
+ *     job to the broker*, one initiation per event-loop tick. Each queue task kicks off
+ *     `safeJob` (which submits to the broker) without awaiting it, then yields with
+ *     `sleep(0)`; the next task therefore runs on the following macrotask. This does NOT
+ *     cap how many broker jobs are concurrently in flight — the broker's own queue absorbs
+ *     that. What it bounds is the burst rate: a sub-tree that synchronously discovers
+ *     thousands of ready jobs can't flood the broker (and monopolise the event loop) in a
+ *     single tick. The queue is owned by the `ProverClient` and shared across every
+ *     orchestrator (every sub-tree and top-tree across every concurrent epoch session), so
+ *     this pacing is applied once globally rather than once-per-orchestrator.
  *   - A list of `AbortController`s (`pendingProvingJobs`) so a `cancel()` can abort
  *     in-flight broker jobs when needed.
  *   - A `deferredProving<T>(state, request, callback, isCancelled?)` method that wraps
@@ -15,34 +23,29 @@ import { sleep } from '@aztec/foundation/sleep';
  *
  * Subclasses own their own concrete proving state and define `cancelInternal()` for
  * the rest of the cleanup work (closing world-state forks, marking sub-trees
- * cancelled, etc.). `stop()` lives on the base class and follows the standard pattern
- * of grabbing the old queue, calling `cancelInternal()` (which recreates the queue),
- * and awaiting the old queue's drain.
+ * cancelled, etc.). Because the queue is shared, neither `cancel()` nor `stop()` touch
+ * it — they only abort this orchestrator's in-flight broker jobs. Queued-but-unrun jobs
+ * for a cancelled orchestrator no-op via the guards in `deferredProving`.
  */ export class ProvingScheduler {
-    enqueueConcurrency;
+    deferredJobQueue;
     pendingProvingJobs;
     logger;
-    deferredJobQueue;
-    constructor(enqueueConcurrency, loggerName = 'prover-client:proving-scheduler', bindings){
-        this.enqueueConcurrency = enqueueConcurrency;
+    constructor(deferredJobQueue, loggerName = 'prover-client:proving-scheduler', bindings){
+        this.deferredJobQueue = deferredJobQueue;
         this.pendingProvingJobs = [];
         this.logger = createLogger(loggerName, bindings);
-        this.deferredJobQueue = new SerialQueue();
-        this.deferredJobQueue.start(this.enqueueConcurrency);
     }
     /** Number of broker jobs currently in flight. */ getNumPendingProvingJobs() {
         return this.pendingProvingJobs.length;
     }
     /**
-   * Drains the deferred-job queue, recreates it (so the subclass can be reused), and
-   * optionally aborts every in-flight broker job. Aborting is the right choice on
+   * Optionally aborts every in-flight broker job. Aborting is the right choice on
    * reorg-driven cancel (where the in-flight inputs are no longer valid) and the
    * wrong choice on shutdown (where leaving jobs in the broker queue lets a restart
-   * pick them up).
+   * pick them up). The shared queue is not touched — queued-but-unrun jobs belonging
+   * to this orchestrator no-op once their controller is aborted (or once their state
+   * is marked invalid by the subclass).
    */ resetSchedulerState(abortJobs) {
-        void this.deferredJobQueue.cancel();
-        this.deferredJobQueue = new SerialQueue();
-        this.deferredJobQueue.start(this.enqueueConcurrency);
         if (abortJobs) {
             for (const controller of this.pendingProvingJobs){
                 controller.abort();
@@ -50,13 +53,11 @@ import { sleep } from '@aztec/foundation/sleep';
         }
     }
     /**
-   * Standard stop: grab the old queue, cancel (which recreates the queue), then
-   * await the old queue's drain so any final job tear-down has unwound before we
-   * return.
-   */ async stop() {
-        const oldQueue = this.deferredJobQueue;
+   * Standard stop: cancel this orchestrator's work. The shared queue is owned by the
+   * `ProverClient` and outlives every orchestrator, so it is not drained here.
+   */ stop() {
         this.cancelInternal();
-        await oldQueue.cancel();
+        return Promise.resolve();
     }
     /**
    * Submits a broker request. The returned-via-callback result is dropped if the
@@ -108,9 +109,11 @@ import { sleep } from '@aztec/foundation/sleep';
             }
         };
         void this.deferredJobQueue.put(async ()=>{
+            // Kick off the broker submission without awaiting it — awaiting here would serialise all
+            // proving (one job at a time) and kill parallelism. The `sleep(0)` yields the event loop
+            // so the next queued job initiates on the following macrotask, pacing bursts rather than
+            // bounding in-flight broker concurrency (the broker's own queue handles that).
             void safeJob();
-            // Yield to the macrotask queue so Node has a chance to interleave other work
-            // between enqueues.
             await sleep(0);
         });
     }

package/dest/orchestrator/top-tree-orchestrator.d.ts

@@ -4,6 +4,7 @@ import { type ARCHIVE_HEIGHT, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } f
 import type { EpochNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LoggerBindings } from '@aztec/foundation/log';
+import type { SerialQueue } from '@aztec/foundation/queue';
 import type { Tuple } from '@aztec/foundation/serialize';
 import type { EthAddress } from '@aztec/stdlib/block';
 import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
@@ -11,8 +12,7 @@ import type { Proof } from '@aztec/stdlib/proofs';
 import { type BlockRollupPublicInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import { type TelemetryClient } from '@aztec/telemetry-client';
-import { TopTreeProvingScheduler } from './top-tree-proving-scheduler.js';
-import { TopTreeProvingState } from './top-tree-proving-state.js';
+import { ProvingScheduler } from './proving-scheduler.js';
 /** Per-checkpoint data fed into the top tree. */
 export type CheckpointTopTreeData = {
     /**
@@ -52,11 +52,12 @@ export declare class TopTreeCancelledError extends Error {
  * and each checkpoint's root rollup fires the moment its sub-tree's `blockProofs`
  * promise resolves. Later checkpoints can still be block-level proving in parallel.
  */
-export declare class TopTreeOrchestrator extends TopTreeProvingScheduler {
+export declare class TopTreeOrchestrator extends ProvingScheduler {
+    protected readonly prover: ServerCircuitProver;
     private readonly proverId;
     private state;
     private cancelled;
-    constructor(prover: ServerCircuitProver, proverId: EthAddress, enqueueConcurrency: number, _telemetryClient?: TelemetryClient, bindings?: LoggerBindings);
+    constructor(prover: ServerCircuitProver, proverId: EthAddress, deferredJobQueue: SerialQueue, _telemetryClient?: TelemetryClient, bindings?: LoggerBindings);
     getProverId(): EthAddress;
     /**
      * Proves the top tree from per-checkpoint data and pending block-proofs promises.
@@ -75,9 +76,13 @@ export declare class TopTreeOrchestrator extends TopTreeProvingScheduler {
     }): void;
     /** Standard shutdown — preserve the broker queue (`abortJobs: false`). */
     protected cancelInternal(): void;
-    protected onRootRollupComplete(state: TopTreeProvingState): void;
     private enqueueCheckpointRoot;
     private buildCheckpointRootInputs;
+    private enqueueCheckpointMergeRollup;
+    private enqueueEpochPadding;
+    private enqueueRootRollup;
+    private checkAndEnqueueNextCheckpointMergeRollup;
+    private checkAndEnqueueRootRollup;
     private computeOutHashHints;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/orchestrator/top-tree-orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"top-tree-orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,yCAAyC,EAE/C,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAGnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE1G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,KAAK,uBAAuB,EAI5B,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAGnF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,iDAAiD;AACjD,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAClB,6BAA6B,CAAC,uBAAuB,EAAE,OAAO,yCAAyC,CAAC,EAAE,CAC3G,CAAC;IACF,mFAAmF;IACnF,kBAAkB,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;IAC7B,8FAA8F;IAC9F,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,oGAAoG;IACpG,mBAAmB,EAAE,WAAW,CAAC;IACjC,mFAAmF;IACnF,0BAA0B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC,CAAC;CAC9D,CAAC;AAEF,sCAAsC;AACtC,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,EAAE,sBAAsB,CAAC;IACrC,KAAK,EAAE,KAAK,CAAC;IACb,iBAAiB,EAAE,WAAW,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,MAAM,SAA+B,EAGhD;CACF;AAOD;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,SAAQ,uBAAuB;IAM5D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAL3B,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,SAAS,CAAS;IAE1B,YACE,MAAM,EAAE,mBAAmB,EACV,QAAQ,EAAE,UAAU,EACrC,kBAAkB,EAAE,MAAM,EAC1B,gBAAgB,GAAE,eAAsC,EACxD,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEM,WAAW,IAAI,UAAU,CAE/B;IAED;;;;OAIG;IACU,KAAK,CAChB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,EACxD,cAAc,EAAE,qBAAqB,EAAE,GACtC,OAAO,CAAC,aAAa,CAAC,CAqFxB;IAED;;;;;OAKG;IACI,MAAM,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,QAIlD;IAED,4EAA0E;IAC1E,UAAmB,cAAc,IAAI,IAAI,CAExC;IAID,UAAmB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,QAEjE;IAED,OAAO,CAAC,qBAAqB;YAiCf,yBAAyB;YA6BzB,mBAAmB;CAyBlC"}
+{"version":3,"file":"top-tree-orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,yCAAyC,EAE/C,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAGnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE1G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,KAAK,uBAAuB,EAI5B,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAGnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,iDAAiD;AACjD,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAClB,6BAA6B,CAAC,uBAAuB,EAAE,OAAO,yCAAyC,CAAC,EAAE,CAC3G,CAAC;IACF,mFAAmF;IACnF,kBAAkB,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;IAC7B,8FAA8F;IAC9F,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,oGAAoG;IACpG,mBAAmB,EAAE,WAAW,CAAC;IACjC,mFAAmF;IACnF,0BAA0B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC,CAAC;CAC9D,CAAC;AAEF,sCAAsC;AACtC,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,EAAE,sBAAsB,CAAC;IACrC,KAAK,EAAE,KAAK,CAAC;IACb,iBAAiB,EAAE,WAAW,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,MAAM,SAA+B,EAGhD;CACF;AAOD;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,SAAQ,gBAAgB;IAKrD,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,mBAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAL3B,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,SAAS,CAAS;IAE1B,YACqB,MAAM,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,UAAU,EACrC,gBAAgB,EAAE,WAAW,EAC7B,gBAAgB,GAAE,eAAsC,EACxD,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEM,WAAW,IAAI,UAAU,CAE/B;IAED;;;;OAIG;IACU,KAAK,CAChB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,EACxD,cAAc,EAAE,qBAAqB,EAAE,GACtC,OAAO,CAAC,aAAa,CAAC,CAiFxB;IAED;;;;;OAKG;IACI,MAAM,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,QAIlD;IAED,4EAA0E;IAC1E,UAAmB,cAAc,IAAI,IAAI,CAExC;IAID,OAAO,CAAC,qBAAqB;YA2Cf,yBAAyB;IA+BvC,OAAO,CAAC,4BAA4B;IAepC,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,wCAAwC;IAYhD,OAAO,CAAC,yBAAyB;YAOnB,mBAAmB;CAyBlC"}

package/dest/orchestrator/top-tree-orchestrator.js

@@ -10,7 +10,7 @@ import { CheckpointRootRollupHints, CheckpointRootRollupPrivateInputs, Checkpoin
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 import { buildBlobHints, toProofData } from './block-building-helpers.js';
-import { TopTreeProvingScheduler } from './top-tree-proving-scheduler.js';
+import { ProvingScheduler } from './proving-scheduler.js';
 import { TopTreeProvingState } from './top-tree-proving-state.js';
 /**
  * Sentinel thrown by `cancel` so callers can distinguish reorg-driven cancellation from
@@ -29,12 +29,13 @@ import { TopTreeProvingState } from './top-tree-proving-state.js';
  * out-hash and blob-accumulator hint chains immediately from archiver-derivable data,
  * and each checkpoint's root rollup fires the moment its sub-tree's `blockProofs`
  * promise resolves. Later checkpoints can still be block-level proving in parallel.
- */ export class TopTreeOrchestrator extends TopTreeProvingScheduler {
+ */ export class TopTreeOrchestrator extends ProvingScheduler {
+    prover;
     proverId;
     state;
     cancelled;
-    constructor(prover, proverId, enqueueConcurrency, _telemetryClient = getTelemetryClient(), bindings){
-        super(prover, enqueueConcurrency, 'prover-client:top-tree-orchestrator', bindings), this.proverId = proverId, this.cancelled = false;
+    constructor(prover, proverId, deferredJobQueue, _telemetryClient = getTelemetryClient(), bindings){
+        super(deferredJobQueue, 'prover-client:top-tree-orchestrator', bindings), this.prover = prover, this.proverId = proverId, this.cancelled = false;
     }
     getProverId() {
         return this.proverId;
@@ -59,10 +60,9 @@ import { TopTreeProvingState } from './top-tree-proving-state.js';
             throw new TopTreeCancelledError();
         }
         const { promise: completionPromise, resolve, reject } = promiseWithResolvers();
-        // The completion promise is awaited inside the try/catch below. Attach a no-op catch
-        // here as well so any spurious unhandled-rejection detection during cancellation
-        // (where reject() can fire synchronously before the await microtask installs a handler)
-        // is silenced.
+        // The completion promise is awaited below. Attach a no-op catch here as well so any
+        // spurious unhandled-rejection detection during cancellation (where reject() can fire
+        // synchronously before the await microtask installs a handler) is silenced.
         completionPromise.catch(()=>{});
         const startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(finalBlobBatchingChallenges);
         this.state = new TopTreeProvingState(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges, startBlobAccumulator, resolve, (reason)=>reject(this.cancelled ? new TopTreeCancelledError(reason) : new Error(reason)));
@@ -94,16 +94,13 @@ import { TopTreeProvingState } from './top-tree-proving-state.js';
                 this.state?.reject(`Sub-tree for checkpoint ${i} failed: ${err}`);
             });
         }
-        try {
-            await completionPromise;
-            await this.state.finalizeBatchedBlob();
-            return this.state.getEpochProofResult();
-        } catch (err) {
-            if (this.cancelled) {
-                throw new TopTreeCancelledError();
-            }
-            throw err;
-        }
+        // The error type is stamped atomically at rejection time by the rejectionCallback above
+        // (TopTreeCancelledError iff cancel() drove the rejection). Re-deriving it here from the
+        // live `cancelled` flag would mask a genuine failure that lost a race with a late cancel
+        // (A-1035), so let the original error propagate untouched.
+        await completionPromise;
+        await this.state.finalizeBatchedBlob();
+        return this.state.getEpochProofResult();
     }
     /**
    * Cancels in-flight proving. If `abortJobs` is true, each pending broker job is aborted
@@ -121,9 +118,6 @@ import { TopTreeProvingState } from './top-tree-proving-state.js';
         });
     }
     // --- internal: per-checkpoint enqueue path ---
-    onRootRollupComplete(state) {
-        state.resolve();
-    }
     enqueueCheckpointRoot(state, checkpointIndex, blockProofs, cd, outHashHint, startBlobAccumulator) {
         void this.buildCheckpointRootInputs(blockProofs, cd, outHashHint, startBlobAccumulator).then((inputs)=>{
             this.deferredProving(state, (signal)=>{
@@ -140,6 +134,13 @@ import { TopTreeProvingState } from './top-tree-proving-state.js';
                     this.checkAndEnqueueNextCheckpointMergeRollup(state, leafLocation);
                 }
             });
+        }, // Without this, an input-building failure rejects a discarded promise, state.reject() is
+        // never called, and prove() hangs forever on its completion promise (A-1036).
+        (err)=>{
+            if (this.cancelled) {
+                return;
+            }
+            state.reject(`Building checkpoint root inputs for checkpoint ${checkpointIndex} failed: ${err}`);
         });
     }
     async buildCheckpointRootInputs(blockProofs, cd, outHashHint, startBlobAccumulator) {
@@ -161,6 +162,55 @@ import { TopTreeProvingState } from './top-tree-proving-state.js';
             proofDatas[1]
         ], hints);
     }
+    // --- internal: top-tree proof orchestration (formerly TopTreeProvingScheduler) ---
+    enqueueCheckpointMergeRollup(state, location) {
+        if (!state.verifyState() || !state.tryStartProvingCheckpointMerge(location)) {
+            return;
+        }
+        const inputs = state.getCheckpointMergeRollupInputs(location);
+        this.deferredProving(state, (signal)=>this.prover.getCheckpointMergeRollupProof(inputs, signal, state.epochNumber), (result)=>{
+            state.setCheckpointMergeRollupProof(location, result);
+            this.checkAndEnqueueNextCheckpointMergeRollup(state, location);
+        });
+    }
+    enqueueEpochPadding(state) {
+        if (!state.verifyState() || !state.tryStartProvingPaddingCheckpoint()) {
+            return;
+        }
+        const inputs = state.getPaddingCheckpointInputs();
+        this.deferredProving(state, (signal)=>this.prover.getCheckpointPaddingRollupProof(inputs, signal, state.epochNumber), (result)=>{
+            state.setCheckpointPaddingProof(result);
+            this.checkAndEnqueueRootRollup(state);
+        });
+    }
+    enqueueRootRollup(state) {
+        if (!state.verifyState() || !state.tryStartProvingRootRollup()) {
+            return;
+        }
+        const inputs = state.getRootRollupInputs();
+        this.deferredProving(state, (signal)=>this.prover.getRootRollupProof(inputs, signal, state.epochNumber), (result)=>{
+            this.logger.verbose(`Completed root rollup for epoch ${state.epochNumber}`);
+            state.setRootRollupProof(result);
+            state.resolve();
+        });
+    }
+    checkAndEnqueueNextCheckpointMergeRollup(state, currentLocation) {
+        if (!state.isReadyForCheckpointMerge(currentLocation)) {
+            return;
+        }
+        const parentLocation = state.getParentLocation(currentLocation);
+        if (parentLocation.level === 0) {
+            this.checkAndEnqueueRootRollup(state);
+        } else {
+            this.enqueueCheckpointMergeRollup(state, parentLocation);
+        }
+    }
+    checkAndEnqueueRootRollup(state) {
+        if (!state.isReadyForRootRollup()) {
+            return;
+        }
+        this.enqueueRootRollup(state);
+    }
     async computeOutHashHints(checkpointData) {
         const treeCalculator = await MerkleTreeCalculator.create(OUT_HASH_TREE_HEIGHT, undefined, (left, right)=>Promise.resolve(shaMerkleHash(left, right)));
         const computeHint = async (leaves)=>{

package/dest/orchestrator/top-tree-proving-state.d.ts

@@ -58,4 +58,4 @@ export declare class TopTreeProvingState {
     reject(reason: string): void;
     cancel(): void;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/orchestrator/top-tree-proving-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"top-tree-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AACxG,OAAO,KAAK,EAAiC,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AACjH,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,yBAAyB,CAAC;AACrF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,kCAAkC,EAClC,oCAAoC,EACpC,4BAA4B,EAC5B,uBAAuB,EACvB,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAW9B;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;;aAaZ,WAAW,EAAE,WAAW;aACxB,mBAAmB,EAAE,MAAM;aAC3B,2BAA2B,EAAE,2BAA2B;aACxD,oBAAoB,EAAE,sBAAsB;IAC5D,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAjBpC,OAAO,CAAC,gBAAgB,CAEtB;IACF,OAAO,CAAC,sBAAsB,CAEhB;IACd,OAAO,CAAC,eAAe,CAAuF;IAC9G,OAAO,CAAC,kBAAkB,CAAqC;IAC/D,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,SAAS,CAA8B;IAE/C,YACkB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,EACxD,oBAAoB,EAAE,sBAAsB,EAC3C,kBAAkB,EAAE,MAAM,IAAI,EAC9B,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EAM7D;IAIM,4BAA4B,CACjC,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,GACA,gBAAgB,CAElB;IAIM,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,WAM/D;IAEM,6BAA6B,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,WAE1D;IAEM,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,oBAElD;IAEM,8BAA8B,CAAC,aAAa,EAAE,gBAAgB,sCAMpE;IAIM,gCAAgC,YAMtC;IAEM,yBAAyB,CAC9B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,0BAA0B,yCAEhC;IAIM,yBAAyB,YAM/B;IAEM,kBAAkB,CAAC,aAAa,EAAE,6BAA6B,CAAC,sBAAsB,CAAC,QAE7F;IAEM,oBAAoB,YAG1B;IAEM,mBAAmB,4BAQzB;IAID;;;OAGG;IACI,qBAAqB,CAAC,WAAW,EAAE,sBAAsB,QAE/D;IAEY,mBAAmB,kBAK/B;IAEM,mBAAmB,IAAI;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,YAAY,EAAE,sBAAsB,CAAC;QAAC,iBAAiB,EAAE,WAAW,CAAA;KAAE,CAUnH;IAIM,WAAW,YAEjB;IAEM,OAAO,SAMb;IAEM,MAAM,CAAC,MAAM,EAAE,MAAM,QAM3B;IAEM,MAAM,SAEZ;CAQF"}
+{"version":3,"file":"top-tree-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AACxG,OAAO,KAAK,EAAiC,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AACjH,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,yBAAyB,CAAC;AACrF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,kCAAkC,EAClC,oCAAoC,EACpC,4BAA4B,EAC5B,uBAAuB,EACvB,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAW9B;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;;aAYZ,WAAW,EAAE,WAAW;aACxB,mBAAmB,EAAE,MAAM;aAC3B,2BAA2B,EAAE,2BAA2B;aACxD,oBAAoB,EAAE,sBAAsB;IAC5D,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAhBpC,OAAO,CAAC,gBAAgB,CAEtB;IACF,OAAO,CAAC,sBAAsB,CAEhB;IACd,OAAO,CAAC,eAAe,CAAuF;IAC9G,OAAO,CAAC,kBAAkB,CAAqC;IAC/D,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,SAAS,CAA8B;IAC/C,YACkB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,EACxD,oBAAoB,EAAE,sBAAsB,EAC3C,kBAAkB,EAAE,MAAM,IAAI,EAC9B,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EAM7D;IAIM,4BAA4B,CACjC,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,GACA,gBAAgB,CAElB;IAIM,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,WAM/D;IAEM,6BAA6B,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,WAE1D;IAEM,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,oBAElD;IAEM,8BAA8B,CAAC,aAAa,EAAE,gBAAgB,sCAMpE;IAIM,gCAAgC,YAMtC;IAEM,yBAAyB,CAC9B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,0BAA0B,yCAEhC;IAIM,yBAAyB,YAM/B;IAEM,kBAAkB,CAAC,aAAa,EAAE,6BAA6B,CAAC,sBAAsB,CAAC,QAE7F;IAEM,oBAAoB,YAG1B;IAEM,mBAAmB,4BAQzB;IAID;;;OAGG;IACI,qBAAqB,CAAC,WAAW,EAAE,sBAAsB,QAE/D;IAEY,mBAAmB,kBAK/B;IAEM,mBAAmB,IAAI;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,YAAY,EAAE,sBAAsB,CAAC;QAAC,iBAAiB,EAAE,WAAW,CAAA;KAAE,CAUnH;IAIM,WAAW,YAEjB;IAEM,OAAO,SAMb;IAEM,MAAM,CAAC,MAAM,EAAE,MAAM,QAM3B;IAEM,MAAM,SAEZ;CAQF"}

package/dest/orchestrator/tx-proving-state.d.ts

@@ -1,4 +1,4 @@
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
@@ -32,6 +32,6 @@ export declare class TxProvingState {
         inputs: PrivateTxBaseRollupPrivateInputs;
     };
     setPublicChonkVerifierProof(publicChonkVerifierProofAndVk: PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
-    setAvmProof(avmProof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>): void;
+    setAvmProof(avmProof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>): void;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHgtcHJvdmluZy1zdGF0ZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL29yY2hlc3RyYXRvci90eC1wcm92aW5nLXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSx5Q0FBeUMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25ILE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRixPQUFPLEVBQWtDLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RGLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFFcEIsZ0NBQWdDLEVBRWhDLCtCQUErQixFQUMvQiwrQkFBK0IsRUFDaEMsTUFBTSxzQkFBc0IsQ0FBQztBQUU5QixPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQVFwRDs7OztHQUlHO0FBQ0gscUJBQWEsY0FBYzs7YUFRUCxXQUFXLEVBQUUsV0FBVztJQUN4QyxPQUFPLENBQUMsUUFBUSxDQUFDLGVBQWU7YUFDaEIsYUFBYSxFQUFFLEdBQUcsQ0FBQyxZQUFZLEVBQUUsc0JBQXNCLENBQUM7SUFDeEUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRO0lBVjNCLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUcxQjtJQUNGLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBOEQ7SUFFL0UsWUFDa0IsV0FBVyxFQUFFLFdBQVcsRUFDdkIsZUFBZSxFQUFFLGVBQWUsRUFDakMsYUFBYSxFQUFFLEdBQUcsQ0FBQyxZQUFZLEVBQUUsc0JBQXNCLENBQUMsRUFDdkQsUUFBUSxFQUFFLEVBQUUsRUFDM0I7SUFFSixJQUFJLGVBQWUsWUFFbEI7SUFFTSxLQUFLLFlBRVg7SUFFTSxZQUFZLElBQUksZ0JBQWdCLENBRXRDO0lBRU0sbUNBQW1DLG9FQUV6QztJQUVNLDBCQUEwQjs7Ozs7O01BWWhDO0lBRU0sMkJBQTJCLENBQ2hDLDZCQUE2QixFQUFFLDZCQUE2QixDQUMxRCwrQkFBK0IsRUFDL0IsT0FBTyx5Q0FBeUMsQ0FDakQsUUFHRjtJQUVNLFdBQVcsQ0FBQyxRQUFRLEVBQUUsY0FBYyxDQUFDLE9BQU8sb0NBQW9DLENBQUMsUUFFdkY7Q0FvQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHgtcHJvdmluZy1zdGF0ZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL29yY2hlc3RyYXRvci90eC1wcm92aW5nLXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSx5Q0FBeUMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQzVHLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRixPQUFPLEVBQWtDLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RGLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFFcEIsZ0NBQWdDLEVBRWhDLCtCQUErQixFQUMvQiwrQkFBK0IsRUFDaEMsTUFBTSxzQkFBc0IsQ0FBQztBQUU5QixPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQVFwRDs7OztHQUlHO0FBQ0gscUJBQWEsY0FBYzs7YUFRUCxXQUFXLEVBQUUsV0FBVztJQUN4QyxPQUFPLENBQUMsUUFBUSxDQUFDLGVBQWU7YUFDaEIsYUFBYSxFQUFFLEdBQUcsQ0FBQyxZQUFZLEVBQUUsc0JBQXNCLENBQUM7SUFDeEUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRO0lBVjNCLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUcxQjtJQUNGLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBdUQ7SUFFeEUsWUFDa0IsV0FBVyxFQUFFLFdBQVcsRUFDdkIsZUFBZSxFQUFFLGVBQWUsRUFDakMsYUFBYSxFQUFFLEdBQUcsQ0FBQyxZQUFZLEVBQUUsc0JBQXNCLENBQUMsRUFDdkQsUUFBUSxFQUFFLEVBQUUsRUFDM0I7SUFFSixJQUFJLGVBQWUsWUFFbEI7SUFFTSxLQUFLLFlBRVg7SUFFTSxZQUFZLElBQUksZ0JBQWdCLENBRXRDO0lBRU0sbUNBQW1DLG9FQUV6QztJQUVNLDBCQUEwQjs7Ozs7O01BWWhDO0lBRU0sMkJBQTJCLENBQ2hDLDZCQUE2QixFQUFFLDZCQUE2QixDQUMxRCwrQkFBK0IsRUFDL0IsT0FBTyx5Q0FBeUMsQ0FDakQsUUFHRjtJQUVNLFdBQVcsQ0FBQyxRQUFRLEVBQUUsY0FBYyxDQUFDLE9BQU8sNkJBQTZCLENBQUMsUUFFaEY7Q0FvQ0YifQ==