@aztec-labs/sequencer-client 6.0.0-nightly.20260829

package/dest/sequencer/requests_tracker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tracks fire-and-forget requests so a shutdown path can interrupt any in-flight work and await it to
+ * settle. Each tracked request is a promise plus an optional interrupt callback; the entry removes itself
+ * from the bag once its promise settles, so the tracker only ever holds requests that are still in flight.
+ */
+export declare class RequestsTracker {
+    private readonly requests;
+    private nextId;
+    /** Number of in-flight requests currently tracked. */
+    get size(): number;
+    /**
+     * Tracks a fire-and-forget request. `interrupt`, when provided, is invoked by {@link interruptRequests}
+     * to cancel the in-flight work so its promise settles promptly. The entry auto-removes once `promise`
+     * settles, whether it resolves or rejects.
+     */
+    trackRequest(promise: Promise<unknown>, interrupt?: () => void): void;
+    /** Interrupts every in-flight request that was tracked with an interrupt callback. */
+    interruptRequests(): void;
+    /** Awaits every currently in-flight request to settle. */
+    awaitRequests(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdHNfdHJhY2tlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcXVlbmNlci9yZXF1ZXN0c190cmFja2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7O0dBSUc7QUFDSCxxQkFBYSxlQUFlO0lBQzFCLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFxQztJQUM5RCxPQUFPLENBQUMsTUFBTSxDQUFLO0lBRW5CLHNEQUFzRDtJQUN0RCxJQUFXLElBQUksSUFBSSxNQUFNLENBRXhCO0lBRUQ7Ozs7T0FJRztJQUNJLFlBQVksQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLFNBQVMsQ0FBQyxFQUFFLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FPM0U7SUFFRCxzRkFBc0Y7SUFDL0UsaUJBQWlCLElBQUksSUFBSSxDQUkvQjtJQUVELDBEQUEwRDtJQUM3QyxhQUFhLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUUxQztDQUNGIn0=

package/dest/sequencer/requests_tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests_tracker.d.ts","sourceRoot":"","sources":["../../src/sequencer/requests_tracker.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAC9D,OAAO,CAAC,MAAM,CAAK;IAEnB,sDAAsD;IACtD,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;OAIG;IACI,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAO3E;IAED,sFAAsF;IAC/E,iBAAiB,IAAI,IAAI,CAI/B;IAED,0DAA0D;IAC7C,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1C;CACF"}

package/dest/sequencer/requests_tracker.js

@@ -0,0 +1,33 @@
+/** A tracked request: the awaitable to wait on, plus an optional interrupt to cancel it early. */ /**
+ * Tracks fire-and-forget requests so a shutdown path can interrupt any in-flight work and await it to
+ * settle. Each tracked request is a promise plus an optional interrupt callback; the entry removes itself
+ * from the bag once its promise settles, so the tracker only ever holds requests that are still in flight.
+ */ export class RequestsTracker {
+    requests = new Map();
+    nextId = 0;
+    /** Number of in-flight requests currently tracked. */ get size() {
+        return this.requests.size;
+    }
+    /**
+   * Tracks a fire-and-forget request. `interrupt`, when provided, is invoked by {@link interruptRequests}
+   * to cancel the in-flight work so its promise settles promptly. The entry auto-removes once `promise`
+   * settles, whether it resolves or rejects.
+   */ trackRequest(promise, interrupt) {
+        const id = this.nextId++;
+        const settled = promise.then(()=>this.requests.delete(id), ()=>this.requests.delete(id));
+        this.requests.set(id, {
+            promise: settled,
+            interrupt
+        });
+    }
+    /** Interrupts every in-flight request that was tracked with an interrupt callback. */ interruptRequests() {
+        for (const { interrupt } of this.requests.values()){
+            interrupt?.();
+        }
+    }
+    /** Awaits every currently in-flight request to settle. */ async awaitRequests() {
+        await Promise.all([
+            ...this.requests.values()
+        ].map((request)=>request.promise));
+    }
+}

package/dest/sequencer/sequencer.d.ts

@@ -0,0 +1,326 @@
+import { type EpochCache } from '@aztec-labs/epoch-cache';
+import { type RollupContract } from '@aztec-labs/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type Logger } from '@aztec-labs/foundation/log';
+import { RunningPromise } from '@aztec-labs/foundation/running-promise';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { TypedEventEmitter } from '@aztec-labs/foundation/types';
+import type { P2P } from '@aztec-labs/p2p';
+import type { SlasherClientInterface } from '@aztec-labs/slasher';
+import type { BlockData, L2BlockSink, L2BlockSource, ProposedCheckpointSink, ValidateCheckpointResult } from '@aztec-labs/stdlib/block';
+import { type Checkpoint, type ProposedCheckpointData } from '@aztec-labs/stdlib/checkpoint';
+import type { ChainConfig } from '@aztec-labs/stdlib/config';
+import { type ResolvedSequencerConfig, type SequencerConfig, type WorldStateSynchronizer } from '@aztec-labs/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec-labs/stdlib/messaging';
+import { ProposerTimetable } from '@aztec-labs/stdlib/timetable';
+import { type TelemetryClient, type Tracer } from '@aztec-labs/telemetry-client';
+import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec-labs/validator-client';
+import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
+import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
+import type { InvalidateCheckpointRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import { CheckpointProposalJob } from './checkpoint_proposal_job.js';
+import type { SequencerEvents } from './events.js';
+import { RequestsTracker } from './requests_tracker.js';
+import type { SequencerRollupConstants } from './types.js';
+import { SequencerState } from './utils.js';
+export { SequencerState };
+/** Slot snapshot used to prepare a checkpoint proposal. */
+type SequencerSlotContext = {
+    slot: SlotNumber;
+    targetSlot: SlotNumber;
+    epoch: EpochNumber;
+    targetEpoch: EpochNumber;
+    ts: bigint;
+    nowSeconds: bigint;
+};
+declare const Sequencer_base: new () => TypedEventEmitter<SequencerEvents>;
+/**
+ * Sequencer client
+ * - Checks whether it is elected as proposer for the next slot
+ * - Builds multiple blocks and broadcasts them
+ * - Collects attestations for the checkpoint
+ * - Publishes the checkpoint to L1
+ * - Votes for proposals and slashes on L1
+ */
+export declare class Sequencer extends Sequencer_base {
+    protected publisherFactory: SequencerPublisherFactory;
+    protected validatorClient: ValidatorClient;
+    protected globalsBuilder: GlobalVariableBuilder;
+    protected p2pClient: P2P;
+    protected worldState: WorldStateSynchronizer;
+    protected slasherClient: SlasherClientInterface | undefined;
+    protected l2BlockSource: L2BlockSource & L2BlockSink & ProposedCheckpointSink;
+    protected l1ToL2MessageSource: L1ToL2MessageSource;
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder;
+    protected l1Constants: SequencerRollupConstants;
+    protected dateProvider: DateProvider;
+    protected epochCache: EpochCache;
+    protected rollupContract: RollupContract;
+    protected telemetry: TelemetryClient;
+    protected log: Logger;
+    protected runningPromise?: RunningPromise;
+    private state;
+    private stateSlotNumber;
+    /** Wall-clock time (ms, via the date provider) at which the current state was entered. */
+    private stateEnteredAtMs;
+    private metrics;
+    private checkpointProposalJobMetrics;
+    private readonly stateLog;
+    /** The last slot for which we attempted to perform our fallback duties (votes and/or prune) with degraded block production */
+    private lastSlotForFallbackAction;
+    /** The (checkpoint, slot) of the last invalidation request we successfully simulated, to prevent
+     * re-simulating and re-submitting the same invalidation across the many ticks within a single slot. */
+    private lastInvalidationAttempt;
+    /** The last epoch for which we logged a "no committee" diagnostic, to avoid per-slot log spam. */
+    private lastEpochForNoCommitteeLog;
+    /** The last slot for which we triggered a checkpoint proposal job, to prevent duplicate attempts. */
+    protected lastSlotForCheckpointProposalJob: SlotNumber | undefined;
+    /** Last successful checkpoint proposed */
+    private lastCheckpointProposed;
+    /** The last epoch for which we logged strategy comparison in fisherman mode. */
+    private lastEpochForStrategyComparison;
+    /** The last checkpoint proposal job, tracked so we can await its pending L1 submission during shutdown. */
+    protected lastCheckpointProposalJob: CheckpointProposalJob | undefined;
+    /**
+     * In-flight fire-and-forget requests that {@link stop} interrupts and drains, and {@link pause} awaits
+     * untouched: the checkpoint proposal jobs' backgrounded L1 submissions (each job is handed this shared
+     * tracker) plus the sequencer's own fallback submissions (votes/prune when we cannot build, or
+     * escape-hatch votes). Each fallback send is gated by its wrapper publisher's interruptible target-slot
+     * sleep; the tracked interrupt wakes that sleep so the send short-circuits without publishing. A wrapper
+     * is created for a single send and is never restarted, so once interrupted its sleeper can never publish
+     * a stale-slot tx, even after the pooled publishers are restarted by a later {@link start}.
+     */
+    protected readonly pendingRequests: RequestsTracker;
+    /** Proposer schedule and block sub-slot timetable for the sequencer, rebuilt on every config update. */
+    protected timetable: ProposerTimetable;
+    /** Config for the sequencer */
+    protected config: ResolvedSequencerConfig;
+    private readonly signatureContext;
+    constructor(publisherFactory: SequencerPublisherFactory, validatorClient: ValidatorClient, globalsBuilder: GlobalVariableBuilder, p2pClient: P2P, worldState: WorldStateSynchronizer, slasherClient: SlasherClientInterface | undefined, l2BlockSource: L2BlockSource & L2BlockSink & ProposedCheckpointSink, l1ToL2MessageSource: L1ToL2MessageSource, checkpointsBuilder: FullNodeCheckpointsBuilder, l1Constants: SequencerRollupConstants, dateProvider: DateProvider, epochCache: EpochCache, rollupContract: RollupContract, config: SequencerConfig & Pick<ChainConfig, 'l1ChainId' | 'rollupAddress'>, telemetry?: TelemetryClient, log?: Logger);
+    /**
+     * Updates sequencer config by the defined values and rebuilds the timetable.
+     *
+     * The merged config is validated against a candidate before being committed: {@link buildTimetable} may
+     * reject the candidate (invalid timing geometry, or per-block allocation multipliers below the network
+     * minimums). On rejection we leave `this.config` and `this.timetable` untouched and rethrow, so a bad update
+     * never leaves the sequencer running with a rejected config and a stale timetable.
+     */
+    updateConfig(config: Partial<SequencerConfig>): void;
+    /**
+     * Builds the proposer timetable from the given config and L1 constants via the shared
+     * {@link buildProposerTimetable} helper, so the sequencer derives the same blocks-per-checkpoint as the p2p
+     * layer and `getNodeInfo`. The fast local/e2e profile and budget clamping happen inside
+     * {@link ProposerTimetable}.
+     *
+     * Throws if the timing geometry is invalid or the per-block allocation multipliers are below the network
+     * minimums; callers must treat a throw as a rejected config and not commit it.
+     */
+    private buildTimetable;
+    /**
+     * Checks this node's configured per-block allocation against the network admission limit. A node
+     * advertises and admits txs up to the limit derived from the network-minimum multipliers (see
+     * {@link computeNetworkTxGasLimits}).
+     *
+     * Fails startup (and runtime config updates) only when the configured per-block allocation *multipliers*
+     * (`perBlockAllocationMultiplier` / `perBlockDAAllocationMultiplier`) are below the network minimums: such
+     * a node would accept txs over RPC/gossip that its builder can never pack into a block regardless of block
+     * size. Operators may configure a higher (more generous) multiplier, but not a lower one.
+     *
+     * When the multipliers meet the floor but an absolute per-block gas cap (`maxDABlockGas` / `maxL2BlockGas`)
+     * shrinks the builder's effective grant below the network limit, this is legitimate operator
+     * restrictiveness — the node simply builds smaller blocks and such txs stay in the pool for other
+     * proposers — so we only log a warning rather than failing startup. Restrictive tx-count caps
+     * (`maxTxsPerBlock` / `maxTxsPerCheckpoint`) can likewise make the builder skip admitted txs; they are
+     * intentionally not modeled here for the same reason.
+     */
+    private assertConfigMeetsNetworkTxLimits;
+    /** Initializes the sequencer (precomputes tables). Takes about 3s. */
+    init(): void;
+    /**
+     * Starts (or restarts) the sequencer and moves it to the IDLE state. Idempotent: a start while already
+     * running is a no-op, so it never orphans the previous poll loop. A start while STOPPING throws, since the
+     * in-flight stop would mark the fresh loop's state STOPPED and orphan it — silently doing nothing would
+     * leave the caller believing the sequencer is running when it is on its way to STOPPED. Safe to call after
+     * a previous {@link stop} has resolved; the caller must also restart the publishers (see
+     * {@link SequencerClient.start}) so L1 publishing is re-enabled.
+     */
+    start(): void;
+    /** Triggers an immediate run of the sequencer, bypassing the polling interval. */
+    trigger(): Promise<void> | undefined;
+    /**
+     * Stops the sequencer from building blocks and moves it to STOPPED state, interrupting the in-flight
+     * work() iteration and its pending L1 submissions for a fast shutdown, then draining before returning.
+     * Idempotent: a second call while already stopped or stopping is a no-op. Lifecycle calls are expected
+     * to be serialized by the caller. For a restartable pause that lets in-flight work finish untouched
+     * (e.g. around a test clock warp), use {@link pause} instead.
+     */
+    stop(): Promise<void>;
+    /**
+     * Gracefully pauses block production so the sequencer can later be resumed with {@link start}: halts the
+     * poll loop and waits for the in-flight work() iteration and every pending L1 submission / fallback send
+     * to finish, without interrupting them. No interrupt lands mid-build, so no spurious checkpoint-error is
+     * emitted and no enqueued checkpoint is dropped. Deliberately does not stop inner services (validator/HA
+     * signer, publishers), so the slashing-protection store stays open and the sequencer stays restartable.
+     * Used by tests that pause sequencers around an L1 clock warp. Idempotent.
+     */
+    pause(): Promise<void>;
+    /** Main sequencer loop with a try/catch */
+    protected safeWork(): Promise<void>;
+    /** Returns the current state of the sequencer. */
+    status(): {
+        state: SequencerState;
+    };
+    /**
+     * Main sequencer loop:
+     * - Checks if we are up to date
+     * - If we are and we are the sequencer, collect txs and build blocks
+     * - Build multiple blocks per slot when configured
+     * - Collect attestations for the final block
+     * - Submit checkpoint
+     */
+    protected work(): Promise<Checkpoint | undefined>;
+    /** Returns slot and target slot from a single clock snapshot. */
+    protected getSlotContextInNextL1Slot(): SequencerSlotContext;
+    /**
+     * Prepares the checkpoint proposal by performing all necessary checks and setup.
+     * This is the initial step in the main loop.
+     * @returns CheckpointProposalJob if successful, undefined if we are not yet synced or are not the proposer.
+     */
+    protected prepareCheckpointProposal(slot: SlotNumber, targetSlot: SlotNumber, epoch: EpochNumber, targetEpoch: EpochNumber, ts: bigint, nowSeconds: bigint): Promise<CheckpointProposalJob | undefined>;
+    protected createCheckpointProposalJob(targetSlot: SlotNumber, targetEpoch: EpochNumber, checkpointNumber: CheckpointNumber, syncedToBlockNumber: BlockNumber, checkpointedCheckpointNumber: CheckpointNumber, proposer: EthAddress | undefined, publisher: SequencerPublisher, attestorAddress: EthAddress, invalidateCheckpoint: InvalidateCheckpointRequest | undefined, proposedCheckpointData?: ProposedCheckpointData): CheckpointProposalJob;
+    /**
+     * Returns the current sequencer state.
+     */
+    getState(): SequencerState;
+    /**
+     * Internal helper for setting the sequencer state. Pure: sets the state, emits `state-changed`, and
+     * records metrics. Timing deadlines are queried explicitly at the relevant call sites, not gated here.
+     * @param proposedState - The new state to transition to.
+     * @param slotNumber - The target slot being proposed for, emitted as `targetSlot` on the event payload
+     * and used to anchor `secondsIntoBuildFrame`. Undefined for lifecycle states with no associated slot.
+     * @param force - Whether to force the transition even if the sequencer is stopped.
+     */
+    protected setState(proposedState: SequencerState, slotNumber: SlotNumber | undefined, opts?: {
+        force?: boolean;
+    }): void;
+    /**
+     * Returns whether all dependencies have caught up.
+     * We don't check against the previous block submitted since it may have been reorg'd out.
+     */
+    protected checkSync(args: {
+        ts: bigint;
+        slot: SlotNumber;
+    }): Promise<SequencerSyncCheckResult | undefined>;
+    /**
+     * Checks if we are the proposer for the next slot.
+     * @returns True if we can propose, and the proposer address (undefined if anyone can propose)
+     */
+    protected checkCanPropose(targetSlot: SlotNumber): Promise<[boolean, EthAddress | undefined]>;
+    /**
+     * Tries to vote on slashing actions and governance and to prune when we cannot build and are past the
+     * block-building window. This allows the sequencer to participate in governance/slashing votes even when it
+     * cannot build blocks, and to prune the pending chain so it can recover from bad data that is blocking sync.
+     */
+    protected tryVoteAndPruneWhenCannotBuild(args: {
+        slot: SlotNumber;
+        targetSlot: SlotNumber;
+    }): Promise<void>;
+    private tryEnqueuePruneIfPrunable;
+    /**
+     * Tries to vote on slashing actions and governance proposals when escape hatch is open.
+     * This allows the sequencer to participate in voting without performing checkpoint proposal work.
+     */
+    protected tryVoteWhenEscapeHatchOpen(args: {
+        slot: SlotNumber;
+        targetSlot: SlotNumber;
+        proposer: EthAddress | undefined;
+    }): Promise<void>;
+    /**
+     * Considers invalidating a block if the pending chain is invalid. Depends on how long the invalid block
+     * has been there without being invalidated and whether the sequencer is in the committee or not. We always
+     * have the proposer try to invalidate, but if they fail, the sequencers in the committee are expected to try,
+     * and if they fail, any sequencer will try as well.
+     * @param pendingChainValidationStatus - The archiver's pending-chain validation status, authoritative on its own.
+     * @param currentSlot - The wall-clock slot, used for committee lookup, the per-(checkpoint, slot) dedup guard, and logging.
+     */
+    protected considerInvalidatingCheckpoint(pendingChainValidationStatus: ValidateCheckpointResult, currentSlot: SlotNumber): Promise<void>;
+    private logStrategyComparison;
+    /**
+     * Wall-clock seconds elapsed since the build-frame start of the given target slot
+     * (`now − getBuildFrameStart(targetSlot)`). May be negative if called before the build frame opens.
+     */
+    private getSecondsIntoBuildFrame;
+    get aztecSlotDuration(): number;
+    get maxL2BlockGas(): number | undefined;
+    getSlasherClient(): SlasherClientInterface | undefined;
+    get tracer(): Tracer;
+    getValidatorAddresses(): EthAddress[];
+    /** Updates the publisher factory's node keystore adapter after a keystore reload. */
+    updatePublisherNodeKeyStore(adapter: NodeKeystoreAdapter): void;
+    getConfig(): {
+        sequencerPollingIntervalMS: number;
+        maxTxsPerBlock?: number | undefined;
+        maxTxsPerCheckpoint?: number | undefined;
+        maxBlocksPerCheckpoint: number;
+        minTxsPerBlock: number;
+        minValidTxsPerBlock?: number | undefined;
+        publishTxsWithProposals: boolean;
+        maxL2BlockGas?: number | undefined;
+        maxDABlockGas?: number | undefined;
+        perBlockAllocationMultiplier: number;
+        perBlockDAAllocationMultiplier: number;
+        redistributeCheckpointBudget?: boolean | undefined;
+        coinbase?: EthAddress | undefined;
+        feeRecipient?: import("@aztec-labs/stdlib/aztec-address").AztecAddress | undefined;
+        acvmWorkingDirectory?: string | undefined;
+        acvmBinaryPath?: string | undefined;
+        txPublicSetupAllowListExtend?: import("@aztec-labs/stdlib/config").AllowedElement[] | undefined;
+        governanceProposerPayload?: EthAddress | undefined;
+        governanceProposerForcePayloadVote: boolean;
+        minBlockDuration?: number | undefined;
+        checkpointProposalPrepareTime?: number | undefined;
+        l1PublishingTime: number;
+        fakeProcessingDelayPerTxMs?: number | undefined;
+        fakeThrowAfterProcessingTxCount?: number | undefined;
+        attestationPropagationTime: number;
+        secondsBeforeInvalidatingBlockAsCommitteeMember: number;
+        secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
+        skipCollectingAttestations: boolean;
+        skipInvalidateBlockAsProposer: boolean;
+        skipWaitForValidParentCheckpointOnL1: boolean;
+        broadcastInvalidBlockProposal: boolean;
+        invalidBlockProposalIndexWithinCheckpoint?: number | undefined;
+        broadcastInvalidCheckpointProposalOnly: boolean;
+        injectFakeAttestation: boolean;
+        injectHighSValueAttestation: boolean;
+        injectUnrecoverableSignatureAttestation: boolean;
+        injectYParityAttestation: boolean;
+        fishermanMode: boolean;
+        shuffleAttestationOrdering: boolean;
+        blockDurationMs: number;
+        checkpointProposalSyncGraceSeconds: number;
+        expectedBlockProposalsPerSlot?: number | undefined;
+        buildCheckpointIfEmpty: boolean;
+        skipPushProposedBlocksToArchiver: boolean;
+        minBlocksForCheckpoint?: number | undefined;
+        skipPublishingCheckpointsPercent: number;
+        skipBroadcastProposals?: boolean | undefined;
+        skipBroadcastCheckpointProposal?: boolean | undefined;
+        pauseProposingForSlots?: SlotNumber[] | undefined;
+        minPeersToPropose: number;
+    };
+}
+type SequencerSyncCheckResult = {
+    blockData?: BlockData;
+    checkpointNumber: CheckpointNumber;
+    checkpointedCheckpointNumber: CheckpointNumber;
+    blockNumber: BlockNumber;
+    archive: Fr;
+    hasProposedCheckpoint: boolean;
+    proposedCheckpointData?: ProposedCheckpointData;
+    syncedL2Slot: SlotNumber;
+    pendingChainValidationStatus: ValidateCheckpointResult;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sequencer.d.ts","sourceRoot":"","sources":["../../src/sequencer/sequencer.ts"],"names":[],"mappings":"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"}

package/dest/sequencer/sequencer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencer.d.ts","sourceRoot":"","sources":["../../src/sequencer/sequencer.ts"],"names":[],"mappings":"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"}