@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/database-version/version_manager.d.ts

@@ -0,0 +1,88 @@
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type Logger } from '@aztec-labs/foundation/log';
+import fs from 'fs/promises';
+import { DatabaseVersion } from './database_version.js';
+export type DatabaseVersionManagerFs = Pick<typeof fs, 'readFile' | 'rm' | 'mkdir' | 'rename' | 'open'>;
+export declare const DATABASE_VERSION_FILE_NAME = "db_version";
+export type SchemaVersionMismatchPolicy = 'reset' | 'throw';
+/**
+ * How to react when the version file exists but cannot be read (permissions, IO error, truncation).
+ * `'reset'` (default) treats the store as unversioned and lets the reset path run — safe for stores
+ * where an empty state is legitimate. `'throw'` refuses to open, leaving data untouched — required
+ * for protection stores (e.g. signing protection) that must never be silently wiped by a transient
+ * filesystem error. A genuinely missing file (ENOENT) is a first boot and is never affected by this.
+ */
+export type VersionFileReadFailurePolicy = 'reset' | 'throw';
+export type DatabaseVersionManagerOptions<T> = {
+    schemaVersion: number;
+    rollupAddress: EthAddress;
+    dataDirectory: string;
+    onOpen: (dataDir: string) => Promise<T>;
+    onUpgrade?: (dataDir: string, currentVersion: number, latestVersion: number) => Promise<void>;
+    schemaVersionMismatchPolicy?: SchemaVersionMismatchPolicy;
+    versionFileReadFailurePolicy?: VersionFileReadFailurePolicy;
+    fileSystem?: DatabaseVersionManagerFs;
+    log?: Logger;
+};
+/**
+ * A manager for handling database versioning and migrations.
+ * This class will check the version of data in a directory and either
+ * reset or upgrade based on version compatibility.
+ */
+export declare class DatabaseVersionManager<T> {
+    static readonly VERSION_FILE = "db_version";
+    private readonly versionFile;
+    private readonly currentVersion;
+    private dataDirectory;
+    private onOpen;
+    private onUpgrade?;
+    private schemaVersionMismatchPolicy;
+    private versionFileReadFailurePolicy;
+    private fileSystem;
+    private log;
+    /**
+     * Create a new version manager
+     *
+     * @param schemaVersion - The current version of the application
+     * @param rollupAddress - The rollup contract address
+     * @param dataDirectory - The directory where version information will be stored
+     * @param onOpen - A callback to the open the database at the given location
+     * @param onUpgrade - An optional callback to upgrade the database before opening. If not provided it will reset the
+     *   database. Must be idempotent: since the version marker is written only after a successful open, a crash after
+     *   onUpgrade but before the marker is written re-runs onUpgrade on the next start.
+     * @param schemaVersionMismatchPolicy - Whether schema mismatches should reset data or throw
+     * @param versionFileReadFailurePolicy - Whether an unreadable (non-missing) version file should reset data or throw
+     * @param fileSystem - An interface to access the filesystem
+     * @param log - Optional custom logger
+     * @param options - Configuration options
+     */
+    constructor({ schemaVersion, rollupAddress, dataDirectory, onOpen, onUpgrade, schemaVersionMismatchPolicy, versionFileReadFailurePolicy, fileSystem, log }: DatabaseVersionManagerOptions<T>);
+    static writeVersion(version: DatabaseVersion, dataDir: string, fileSystem?: DatabaseVersionManagerFs): Promise<void>;
+    /**
+     * Checks the stored version against the current version and handles the outcome
+     * by either resetting the data directory or calling an upgrade function
+     *
+     * @param onReset - Function to call when a full reset is needed
+     * @param onUpgrade - Function to call when an upgrade is needed
+     * @returns True if data was reset, false if upgraded or no change needed
+     */
+    open(): Promise<[T, boolean]>;
+    private closeQuietly;
+    /**
+     * Writes the current version to the version file
+     */
+    writeVersion(dir?: string): Promise<void>;
+    /**
+     * Resets the data directory by deleting it and recreating it
+     */
+    resetDataDirectory(): Promise<void>;
+    /**
+     * Get the data directory path
+     */
+    getDataDirectory(): string;
+    /**
+     * Get the current version number
+     */
+    getSchemaVersion(): number;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/database-version/version_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version_manager.d.ts","sourceRoot":"","sources":["../../src/database-version/version_manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG7B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,GAAG,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC;AAExG,eAAO,MAAM,0BAA0B,eAAe,CAAC;AACvD,MAAM,MAAM,2BAA2B,GAAG,OAAO,GAAG,OAAO,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,GAAG,OAAO,CAAC;AAE7D,MAAM,MAAM,6BAA6B,CAAC,CAAC,IAAI;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,UAAU,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACxC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9F,2BAA2B,CAAC,EAAE,2BAA2B,CAAC;IAC1D,4BAA4B,CAAC,EAAE,4BAA4B,CAAC;IAC5D,UAAU,CAAC,EAAE,wBAAwB,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAsB,CAAC,CAAC;IACnC,gBAAuB,YAAY,gBAA8B;IAEjE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAkB;IAEjD,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,SAAS,CAAC,CAAoF;IACtG,OAAO,CAAC,2BAA2B,CAA8B;IACjE,OAAO,CAAC,4BAA4B,CAA+B;IACnE,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,GAAG,CAAS;IAEpB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,EACV,aAAa,EACb,aAAa,EACb,aAAa,EACb,MAAM,EACN,SAAS,EACT,2BAAqC,EACrC,4BAAsC,EACtC,UAAe,EACf,GAAgD,EACjD,EAAE,6BAA6B,CAAC,CAAC,CAAC,EAelC;IAED,OAAa,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAE,wBAA6B,iBA6B7G;IAED;;;;;;;OAOG;IACU,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAqGzC;YAMa,YAAY;IAe1B;;OAEG;IACI,YAAY,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;IAED;;OAEG;IACU,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ/C;IAED;;OAEG;IACI,gBAAgB,IAAI,MAAM,CAEhC;IAED;;OAEG;IACI,gBAAgB,IAAI,MAAM,CAEhC;CACF"}

package/dest/database-version/version_manager.js

@@ -0,0 +1,227 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import fs from 'fs/promises';
+import { join } from 'path';
+import { DatabaseVersion } from './database_version.js';
+export const DATABASE_VERSION_FILE_NAME = 'db_version';
+/**
+ * A manager for handling database versioning and migrations.
+ * This class will check the version of data in a directory and either
+ * reset or upgrade based on version compatibility.
+ */ export class DatabaseVersionManager {
+    static VERSION_FILE = DATABASE_VERSION_FILE_NAME;
+    versionFile;
+    currentVersion;
+    dataDirectory;
+    onOpen;
+    onUpgrade;
+    schemaVersionMismatchPolicy;
+    versionFileReadFailurePolicy;
+    fileSystem;
+    log;
+    /**
+   * Create a new version manager
+   *
+   * @param schemaVersion - The current version of the application
+   * @param rollupAddress - The rollup contract address
+   * @param dataDirectory - The directory where version information will be stored
+   * @param onOpen - A callback to the open the database at the given location
+   * @param onUpgrade - An optional callback to upgrade the database before opening. If not provided it will reset the
+   *   database. Must be idempotent: since the version marker is written only after a successful open, a crash after
+   *   onUpgrade but before the marker is written re-runs onUpgrade on the next start.
+   * @param schemaVersionMismatchPolicy - Whether schema mismatches should reset data or throw
+   * @param versionFileReadFailurePolicy - Whether an unreadable (non-missing) version file should reset data or throw
+   * @param fileSystem - An interface to access the filesystem
+   * @param log - Optional custom logger
+   * @param options - Configuration options
+   */ constructor({ schemaVersion, rollupAddress, dataDirectory, onOpen, onUpgrade, schemaVersionMismatchPolicy = 'reset', versionFileReadFailurePolicy = 'reset', fileSystem = fs, log = createLogger(`foundation:version-manager`) }){
+        if (schemaVersion < 1) {
+            throw new TypeError(`Invalid schema version received: ${schemaVersion}`);
+        }
+        this.versionFile = join(dataDirectory, DatabaseVersionManager.VERSION_FILE);
+        this.currentVersion = new DatabaseVersion(schemaVersion, rollupAddress);
+        this.dataDirectory = dataDirectory;
+        this.onOpen = onOpen;
+        this.onUpgrade = onUpgrade;
+        this.schemaVersionMismatchPolicy = schemaVersionMismatchPolicy;
+        this.versionFileReadFailurePolicy = versionFileReadFailurePolicy;
+        this.fileSystem = fileSystem;
+        this.log = log;
+    }
+    static async writeVersion(version, dataDir, fileSystem = fs) {
+        await fileSystem.mkdir(dataDir, {
+            recursive: true
+        });
+        const finalPath = join(dataDir, DatabaseVersionManager.VERSION_FILE);
+        const tmpPath = `${finalPath}.tmp`;
+        // Atomic durable write: fill a temp file, fsync it, then rename it into place. The marker only
+        // becomes visible under its final name once its bytes are durably on disk, so a crash mid-write
+        // can never leave a "valid" version file sitting over an empty or partially-populated data dir.
+        const handle = await fileSystem.open(tmpPath, 'w');
+        try {
+            await handle.writeFile(version.toBuffer());
+            await handle.sync();
+        } finally{
+            await handle.close();
+        }
+        await fileSystem.rename(tmpPath, finalPath);
+        // Best-effort fsync of the containing directory so the rename itself survives a crash. Not all
+        // filesystems support directory fsync, so a failure here is non-fatal.
+        try {
+            const dirHandle = await fileSystem.open(dataDir, 'r');
+            try {
+                await dirHandle.sync();
+            } finally{
+                await dirHandle.close();
+            }
+        } catch  {
+        // directory fsync is best-effort
+        }
+    }
+    /**
+   * Checks the stored version against the current version and handles the outcome
+   * by either resetting the data directory or calling an upgrade function
+   *
+   * @param onReset - Function to call when a full reset is needed
+   * @param onUpgrade - Function to call when an upgrade is needed
+   * @returns True if data was reset, false if upgraded or no change needed
+   */ async open() {
+        // const storedVersion = await DatabaseVersion.readVersion(this.versionFile);
+        let storedVersion;
+        // a flag to suppress logs about 'resetting the data dir' when starting from an empty state
+        let shouldLogDataReset = true;
+        try {
+            const versionBuf = await this.fileSystem.readFile(this.versionFile);
+            storedVersion = DatabaseVersion.fromBuffer(versionBuf);
+        } catch (err) {
+            if (err && err.code === 'ENOENT') {
+                storedVersion = DatabaseVersion.empty();
+                // only turn off these logs if the data dir didn't exist before
+                shouldLogDataReset = false;
+            } else if (this.versionFileReadFailurePolicy === 'throw') {
+                // The version file exists but could not be read/parsed (permissions, IO error, truncation).
+                // Treating this as "unversioned" would reset the data directory, silently wiping a store that
+                // must fail closed. Refuse to open instead, leaving the data untouched for the operator.
+                const code = err?.code;
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`Failed to read database version file at ${this.versionFile} (${code ?? 'unknown error'}: ${message}). ` + `Refusing to open the database; data was NOT reset. Resolve the underlying filesystem error and retry.`, {
+                    cause: err
+                });
+            } else {
+                this.log.warn(`Failed to read stored version information: ${err}. Defaulting to empty version`);
+                storedVersion = DatabaseVersion.empty();
+            }
+        }
+        const cmp = storedVersion.cmp(this.currentVersion);
+        let needsReset = false;
+        if (typeof cmp === 'number') {
+            // only allow forward upgrades
+            if (cmp === -1 && this.onUpgrade) {
+                this.log.info(`Upgrading from version ${storedVersion.schemaVersion} to ${this.currentVersion.schemaVersion}`);
+                try {
+                    await this.onUpgrade(this.dataDirectory, storedVersion.schemaVersion, this.currentVersion.schemaVersion);
+                } catch (error) {
+                    if (this.schemaVersionMismatchPolicy === 'throw') {
+                        throw new Error(`Failed to upgrade database at ${this.dataDirectory} from schema version ${storedVersion.schemaVersion} to ${this.currentVersion.schemaVersion}`, {
+                            cause: error
+                        });
+                    }
+                    this.log.error(`Failed to upgrade: ${error}. Falling back to reset.`);
+                    needsReset = true;
+                }
+            } else if (cmp !== 0) {
+                if (this.schemaVersionMismatchPolicy === 'throw') {
+                    throw new Error(`Cannot open database at ${this.dataDirectory}: stored schema version ${storedVersion.schemaVersion} is incompatible with expected schema version ${this.currentVersion.schemaVersion}`);
+                }
+                if (shouldLogDataReset) {
+                    this.log.info(`Can't upgrade from version ${storedVersion} to ${this.currentVersion}. Resetting database at ${this.dataDirectory}`);
+                }
+                needsReset = true;
+            }
+        } else {
+            if (shouldLogDataReset) {
+                this.log.warn('Rollup address has changed, resetting data directory', {
+                    versionFile: this.versionFile,
+                    storedVersion,
+                    currentVersion: this.currentVersion
+                });
+            }
+            needsReset = true;
+        }
+        // Handle reset if needed
+        if (needsReset) {
+            await this.resetDataDirectory();
+        }
+        // Open the database first, then record the version marker. Writing the marker only after a
+        // successful open makes it a post-commit record: if the process crashes between the reset and a
+        // durable open, no marker is left behind, so the next startup re-runs the reset instead of
+        // trusting a marker that sits over empty or partially-initialized data.
+        const instance = await this.onOpen(this.dataDirectory);
+        // Only (re)write the marker when it would actually change — first boot, reset, or upgrade. On a
+        // normal boot it already matches, so skipping avoids an unnecessary fsync (and the directory
+        // write permission the temp-file+rename needs) and, more importantly, any window where a
+        // marker-write failure would orphan the database we just opened.
+        if (!storedVersion.equals(this.currentVersion)) {
+            try {
+                await this.writeVersion();
+            } catch (err) {
+                // The database opened but recording the marker failed; close the freshly opened instance so
+                // we do not leak its file handles / locks before propagating the failure.
+                await this.closeQuietly(instance);
+                throw err;
+            }
+        }
+        return [
+            instance,
+            needsReset
+        ];
+    }
+    /**
+   * Best-effort close of a just-opened database instance, used to avoid leaking handles/locks when a
+   * post-open step fails. Swallows close errors so the original failure is the one that propagates.
+   */ async closeQuietly(instance) {
+        const closable = instance;
+        const dispose = closable?.close ?? closable?.[Symbol.asyncDispose];
+        if (typeof dispose !== 'function') {
+            return;
+        }
+        try {
+            await dispose.call(closable);
+        } catch (err) {
+            this.log.warn(`Failed to close database after version-write failure: ${err}`);
+        }
+    }
+    /**
+   * Writes the current version to the version file
+   */ writeVersion(dir) {
+        return DatabaseVersionManager.writeVersion(this.currentVersion, dir ?? this.dataDirectory, this.fileSystem);
+    }
+    /**
+   * Resets the data directory by deleting it and recreating it
+   */ async resetDataDirectory() {
+        try {
+            await this.fileSystem.rm(this.dataDirectory, {
+                recursive: true,
+                force: true,
+                maxRetries: 3
+            });
+            await this.fileSystem.mkdir(this.dataDirectory, {
+                recursive: true
+            });
+        } catch (err) {
+            this.log.error(`Failed to reset data directory: ${err}`);
+            throw new Error(`Failed to reset data directory: ${err}`, {
+                cause: err
+            });
+        }
+    }
+    /**
+   * Get the data directory path
+   */ getDataDirectory() {
+        return this.dataDirectory;
+    }
+    /**
+   * Get the current version number
+   */ getSchemaVersion() {
+        return this.currentVersion.schemaVersion;
+    }
+}

package/dest/delayed_public_mutable/delayed_public_mutable_values.d.ts

@@ -0,0 +1,20 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+export declare const DELAYED_PUBLIC_MUTABLE_VALUES_LEN: number;
+export declare class DelayedPublicMutableValues {
+    svc: ScheduledValueChange;
+    sdc: ScheduledDelayChange;
+    constructor(svc: ScheduledValueChange, sdc: ScheduledDelayChange);
+    static fromFields(fields: Fr[] | FieldReader): DelayedPublicMutableValues;
+    toFields(): Fr[];
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): DelayedPublicMutableValues;
+    static empty(valueSize: number): DelayedPublicMutableValues;
+    static readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>): Promise<DelayedPublicMutableValues>;
+    isEmpty(): boolean;
+    writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>): Promise<void[]>;
+    hash(): Promise<Fr>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXllZF9wdWJsaWNfbXV0YWJsZV92YWx1ZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kZWxheWVkX3B1YmxpY19tdXRhYmxlL2RlbGF5ZWRfcHVibGljX211dGFibGVfdmFsdWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBcUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUVoRyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNuRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVuRSxlQUFPLE1BQU0saUNBQWlDLFFBQTZCLENBQUM7QUFFNUUscUJBQWEsMEJBQTBCO0lBRTVCLEdBQUcsRUFBRSxvQkFBb0I7SUFDekIsR0FBRyxFQUFFLG9CQUFvQjtJQUZsQyxZQUNTLEdBQUcsRUFBRSxvQkFBb0IsRUFDekIsR0FBRyxFQUFFLG9CQUFvQixFQUM5QjtJQUVKLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLFdBQVcsOEJBeUIzQztJQUVELFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FXZjtJQUVELFFBQVEsSUFBSSxNQUFNLENBRWpCO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksRUFBRSxTQUFTLEVBQUUsTUFBTSxHQUFHLDBCQUEwQixDQUc5RjtJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLE1BQU0sOEJBRTdCO0lBRUQsT0FBYSxZQUFZLENBQUMsd0JBQXdCLEVBQUUsRUFBRSxFQUFFLFdBQVcsRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLEtBQUssT0FBTyxDQUFDLEVBQUUsQ0FBQyx1Q0FLcEc7SUFFRCxPQUFPLElBQUksT0FBTyxDQUVqQjtJQUVELFdBQVcsQ0FBQyx3QkFBd0IsRUFBRSxFQUFFLEVBQUUsWUFBWSxFQUFFLENBQUMsV0FBVyxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLE9BQU8sQ0FBQyxJQUFJLENBQUMsbUJBTXBHO0lBRUssSUFBSSxJQUFJLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FJeEI7Q0FDRiJ9

package/dest/delayed_public_mutable/delayed_public_mutable_values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed_public_mutable_values.d.ts","sourceRoot":"","sources":["../../src/delayed_public_mutable/delayed_public_mutable_values.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,kCAAkC,CAAC;AAEhG,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,eAAO,MAAM,iCAAiC,QAA6B,CAAC;AAE5E,qBAAa,0BAA0B;IAE5B,GAAG,EAAE,oBAAoB;IACzB,GAAG,EAAE,oBAAoB;IAFlC,YACS,GAAG,EAAE,oBAAoB,EACzB,GAAG,EAAE,oBAAoB,EAC9B;IAEJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,8BAyB3C;IAED,QAAQ,IAAI,EAAE,EAAE,CAWf;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,0BAA0B,CAG9F;IAED,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,8BAE7B;IAED,OAAa,YAAY,CAAC,wBAAwB,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,WAAW,EAAE,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC,uCAKpG;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,WAAW,CAAC,wBAAwB,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC,WAAW,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,mBAMpG;IAEK,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC,CAIxB;CACF"}

package/dest/delayed_public_mutable/delayed_public_mutable_values.js

@@ -0,0 +1,75 @@
+import { UPDATES_VALUE_SIZE } from '@aztec-labs/constants';
+import { poseidon2Hash } from '@aztec-labs/foundation/crypto/poseidon';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+export const DELAYED_PUBLIC_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
+export class DelayedPublicMutableValues {
+    svc;
+    sdc;
+    constructor(svc, sdc){
+        this.svc = svc;
+        this.sdc = sdc;
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        const firstField = reader.readField().toBigInt();
+        // Extract fields for ScheduledValueChange
+        const svcPre = reader.readFieldArray(UPDATES_VALUE_SIZE);
+        const svcPost = reader.readFieldArray(UPDATES_VALUE_SIZE);
+        const svcTimestampOfChange = firstField & 0xffffffffn;
+        const svc = new ScheduledValueChange(svcPre, svcPost, svcTimestampOfChange);
+        // Extract fields for ScheduledDelayChange from first field
+        const sdcTimestampOfChange = firstField >> 32n & 0xffffffffn;
+        const sdcIsPostSome = firstField >> 64n & 1n;
+        const sdcPost = firstField >> 72n & 0xffffffffn;
+        const sdcIsPreSome = firstField >> 104n & 1n;
+        const sdcPre = firstField >> 112n & 0xffffffffn;
+        const sdc = new ScheduledDelayChange(sdcIsPreSome ? sdcPre : undefined, sdcIsPostSome ? sdcPost : undefined, sdcTimestampOfChange);
+        return new this(svc, sdc);
+    }
+    toFields() {
+        // Pack format matches Noir implementation:
+        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]
+        let firstField = this.svc.timestampOfChange;
+        firstField |= this.sdc.timestampOfChange << 32n;
+        firstField |= (this.sdc.post === undefined ? 0n : 1n) << 64n;
+        firstField |= BigInt(this.sdc.post || 0) << 72n;
+        firstField |= (this.sdc.pre === undefined ? 0n : 1n) << 104n;
+        firstField |= BigInt(this.sdc.pre || 0) << 112n;
+        return [
+            new Fr(firstField),
+            ...this.svc.previous,
+            ...this.svc.post
+        ];
+    }
+    toBuffer() {
+        return serializeToBuffer(this.toFields());
+    }
+    static fromBuffer(buffer, valueSize) {
+        const reader = BufferReader.asReader(buffer);
+        return DelayedPublicMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
+    }
+    static empty(valueSize) {
+        return new this(ScheduledValueChange.empty(valueSize), ScheduledDelayChange.empty());
+    }
+    static async readFromTree(delayedPublicMutableSlot, readStorage) {
+        const fieldPromises = Array.from({
+            length: DELAYED_PUBLIC_MUTABLE_VALUES_LEN
+        }).map((_, i)=>readStorage(delayedPublicMutableSlot.add(new Fr(i))));
+        return DelayedPublicMutableValues.fromFields(await Promise.all(fieldPromises));
+    }
+    isEmpty() {
+        return this.svc.isEmpty() && this.sdc.isEmpty();
+    }
+    writeToTree(delayedPublicMutableSlot, storageWrite) {
+        const fieldPromises = this.toFields().map((field, i)=>storageWrite(delayedPublicMutableSlot.add(new Fr(i)), field));
+        return Promise.all(fieldPromises);
+    }
+    async hash() {
+        const fields = this.toFields();
+        const hash = await poseidon2Hash(fields);
+        return hash;
+    }
+}

package/dest/delayed_public_mutable/delayed_public_mutable_values_with_hash.d.ts

@@ -0,0 +1,15 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AztecAddress } from '../aztec-address/index.js';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+export declare class DelayedPublicMutableValuesWithHash {
+    private dpmv;
+    constructor(svc: ScheduledValueChange, sdc: ScheduledDelayChange);
+    toFields(): Promise<Fr[]>;
+    writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>): Promise<void>;
+    static getContractUpdateSlots(contractAddress: AztecAddress): Promise<{
+        delayedPublicMutableSlot: Fr;
+        delayedPublicMutableHashSlot: Fr;
+    }>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXllZF9wdWJsaWNfbXV0YWJsZV92YWx1ZXNfd2l0aF9oYXNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVsYXllZF9wdWJsaWNfbXV0YWJsZS9kZWxheWVkX3B1YmxpY19tdXRhYmxlX3ZhbHVlc193aXRoX2hhc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRzlELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ25FLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRW5FLHFCQUFhLGtDQUFrQztJQUM3QyxPQUFPLENBQUMsSUFBSSxDQUE2QjtJQUV6QyxZQUFZLEdBQUcsRUFBRSxvQkFBb0IsRUFBRSxHQUFHLEVBQUUsb0JBQW9CLEVBRS9EO0lBRUssUUFBUSxJQUFJLE9BQU8sQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUU5QjtJQUVLLFdBQVcsQ0FBQyx3QkFBd0IsRUFBRSxFQUFFLEVBQUUsWUFBWSxFQUFFLENBQUMsV0FBVyxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLE9BQU8sQ0FBQyxJQUFJLENBQUMsaUJBTTFHO0lBRUQsT0FBYSxzQkFBc0IsQ0FBQyxlQUFlLEVBQUUsWUFBWTs7O09BUWhFO0NBQ0YifQ==

package/dest/delayed_public_mutable/delayed_public_mutable_values_with_hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed_public_mutable_values_with_hash.d.ts","sourceRoot":"","sources":["../../src/delayed_public_mutable/delayed_public_mutable_values_with_hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,qBAAa,kCAAkC;IAC7C,OAAO,CAAC,IAAI,CAA6B;IAEzC,YAAY,GAAG,EAAE,oBAAoB,EAAE,GAAG,EAAE,oBAAoB,EAE/D;IAEK,QAAQ,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,CAE9B;IAEK,WAAW,CAAC,wBAAwB,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC,WAAW,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,iBAM1G;IAED,OAAa,sBAAsB,CAAC,eAAe,EAAE,YAAY;;;OAQhE;CACF"}

package/dest/delayed_public_mutable/delayed_public_mutable_values_with_hash.js

@@ -0,0 +1,30 @@
+import { UPDATED_CLASS_IDS_SLOT } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { deriveStorageSlotInMap } from '../hash/map_slot.js';
+import { DELAYED_PUBLIC_MUTABLE_VALUES_LEN, DelayedPublicMutableValues } from './delayed_public_mutable_values.js';
+export class DelayedPublicMutableValuesWithHash {
+    dpmv;
+    constructor(svc, sdc){
+        this.dpmv = new DelayedPublicMutableValues(svc, sdc);
+    }
+    async toFields() {
+        return [
+            ...this.dpmv.toFields(),
+            await this.dpmv.hash()
+        ];
+    }
+    async writeToTree(delayedPublicMutableSlot, storageWrite) {
+        const fields = await this.toFields();
+        for(let i = 0; i < fields.length; i++){
+            await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
+        }
+    }
+    static async getContractUpdateSlots(contractAddress) {
+        const delayedPublicMutableSlot = await deriveStorageSlotInMap(new Fr(UPDATED_CLASS_IDS_SLOT), contractAddress);
+        const delayedPublicMutableHashSlot = delayedPublicMutableSlot.add(new Fr(DELAYED_PUBLIC_MUTABLE_VALUES_LEN));
+        return {
+            delayedPublicMutableSlot,
+            delayedPublicMutableHashSlot
+        };
+    }
+}

package/dest/delayed_public_mutable/index.d.ts

@@ -0,0 +1,5 @@
+export * from './scheduled_delay_change.js';
+export * from './scheduled_value_change.js';
+export * from './delayed_public_mutable_values.js';
+export * from './delayed_public_mutable_values_with_hash.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kZWxheWVkX3B1YmxpY19tdXRhYmxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsOENBQThDLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/delayed_public_mutable/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC"}

package/dest/delayed_public_mutable/index.js

@@ -0,0 +1,4 @@
+export * from './scheduled_delay_change.js';
+export * from './scheduled_value_change.js';
+export * from './delayed_public_mutable_values.js';
+export * from './delayed_public_mutable_values_with_hash.js';

package/dest/delayed_public_mutable/scheduled_delay_change.d.ts

@@ -0,0 +1,10 @@
+import type { UInt64 } from '../types/shared.js';
+export declare class ScheduledDelayChange {
+    pre: UInt64 | undefined;
+    post: UInt64 | undefined;
+    timestampOfChange: UInt64;
+    constructor(pre: UInt64 | undefined, post: UInt64 | undefined, timestampOfChange: UInt64);
+    static empty(): ScheduledDelayChange;
+    isEmpty(): boolean;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGVkX2RlbGF5X2NoYW5nZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RlbGF5ZWRfcHVibGljX211dGFibGUvc2NoZWR1bGVkX2RlbGF5X2NoYW5nZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVqRCxxQkFBYSxvQkFBb0I7SUFFdEIsR0FBRyxFQUFFLE1BQU0sR0FBRyxTQUFTO0lBQ3ZCLElBQUksRUFBRSxNQUFNLEdBQUcsU0FBUztJQUN4QixpQkFBaUIsRUFBRSxNQUFNO0lBSGxDLFlBQ1MsR0FBRyxFQUFFLE1BQU0sR0FBRyxTQUFTLEVBQ3ZCLElBQUksRUFBRSxNQUFNLEdBQUcsU0FBUyxFQUN4QixpQkFBaUIsRUFBRSxNQUFNLEVBQzlCO0lBRUosTUFBTSxDQUFDLEtBQUsseUJBRVg7SUFFRCxPQUFPLElBQUksT0FBTyxDQUVqQjtDQUNGIn0=

package/dest/delayed_public_mutable/scheduled_delay_change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled_delay_change.d.ts","sourceRoot":"","sources":["../../src/delayed_public_mutable/scheduled_delay_change.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,qBAAa,oBAAoB;IAEtB,GAAG,EAAE,MAAM,GAAG,SAAS;IACvB,IAAI,EAAE,MAAM,GAAG,SAAS;IACxB,iBAAiB,EAAE,MAAM;IAHlC,YACS,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,iBAAiB,EAAE,MAAM,EAC9B;IAEJ,MAAM,CAAC,KAAK,yBAEX;IAED,OAAO,IAAI,OAAO,CAEjB;CACF"}

package/dest/delayed_public_mutable/scheduled_delay_change.js

@@ -0,0 +1,16 @@
+export class ScheduledDelayChange {
+    pre;
+    post;
+    timestampOfChange;
+    constructor(pre, post, timestampOfChange){
+        this.pre = pre;
+        this.post = post;
+        this.timestampOfChange = timestampOfChange;
+    }
+    static empty() {
+        return new this(undefined, undefined, 0n);
+    }
+    isEmpty() {
+        return this.pre === undefined && this.post === undefined && this.timestampOfChange === 0n;
+    }
+}

package/dest/delayed_public_mutable/scheduled_value_change.d.ts

@@ -0,0 +1,12 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { UInt64 } from '../types/shared.js';
+export declare class ScheduledValueChange {
+    previous: Fr[];
+    post: Fr[];
+    timestampOfChange: UInt64;
+    constructor(previous: Fr[], post: Fr[], timestampOfChange: UInt64);
+    static empty(valueSize: number): ScheduledValueChange;
+    isEmpty(): boolean;
+    getCurrentAt(timestamp: UInt64): Fr[];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGVkX3ZhbHVlX2NoYW5nZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RlbGF5ZWRfcHVibGljX211dGFibGUvc2NoZWR1bGVkX3ZhbHVlX2NoYW5nZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFekQsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFakQscUJBQWEsb0JBQW9CO0lBRXRCLFFBQVEsRUFBRSxFQUFFLEVBQUU7SUFDZCxJQUFJLEVBQUUsRUFBRSxFQUFFO0lBQ1YsaUJBQWlCLEVBQUUsTUFBTTtJQUhsQyxZQUNTLFFBQVEsRUFBRSxFQUFFLEVBQUUsRUFDZCxJQUFJLEVBQUUsRUFBRSxFQUFFLEVBQ1YsaUJBQWlCLEVBQUUsTUFBTSxFQUtqQztJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLE1BQU0sd0JBRTdCO0lBRUQsT0FBTyxJQUFJLE9BQU8sQ0FFakI7SUFFRCxZQUFZLENBQUMsU0FBUyxFQUFFLE1BQU0sUUFNN0I7Q0FDRiJ9

package/dest/delayed_public_mutable/scheduled_value_change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled_value_change.d.ts","sourceRoot":"","sources":["../../src/delayed_public_mutable/scheduled_value_change.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,qBAAa,oBAAoB;IAEtB,QAAQ,EAAE,EAAE,EAAE;IACd,IAAI,EAAE,EAAE,EAAE;IACV,iBAAiB,EAAE,MAAM;IAHlC,YACS,QAAQ,EAAE,EAAE,EAAE,EACd,IAAI,EAAE,EAAE,EAAE,EACV,iBAAiB,EAAE,MAAM,EAKjC;IAED,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,wBAE7B;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,YAAY,CAAC,SAAS,EAAE,MAAM,QAM7B;CACF"}

package/dest/delayed_public_mutable/scheduled_value_change.js

@@ -0,0 +1,27 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+export class ScheduledValueChange {
+    previous;
+    post;
+    timestampOfChange;
+    constructor(previous, post, timestampOfChange){
+        this.previous = previous;
+        this.post = post;
+        this.timestampOfChange = timestampOfChange;
+        if (this.previous.length !== this.post.length) {
+            throw new Error('Previous and post must have the same length');
+        }
+    }
+    static empty(valueSize) {
+        return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0n);
+    }
+    isEmpty() {
+        return this.previous.every((v)=>v.isZero()) && this.post.every((v)=>v.isZero()) && this.timestampOfChange === 0n;
+    }
+    getCurrentAt(timestamp) {
+        if (timestamp < this.timestampOfChange) {
+            return this.previous;
+        } else {
+            return this.post;
+        }
+    }
+}

package/dest/deserialization/index.d.ts

@@ -0,0 +1,43 @@
+/** Max transactions per block for deserialization validation */
+export declare const MAX_TXS_PER_BLOCK: number;
+/** Max committee size - theoretical max from bitmap design (256 bytes × 8 bits) */
+export declare const MAX_COMMITTEE_SIZE = 2048;
+/**
+ * Maximum number of L2 blocks in a provable checkpoint. Used for deserialization and when ingesting
+ * checkpoints already accepted by L1.
+ *
+ * This MUST be >= the number of blocks the proving system can carry, or a structurally-valid, provable
+ * checkpoint that L1 accepts would be rejected on ingest (`validateCheckpoint`) and wedge the archiver.
+ * The checkpoint root circuit caps a checkpoint at {@link MAX_BLOCKS_PER_CHECKPOINT} blocks, well under
+ * the looser ceiling the blob-field budget imposes:
+ *
+ *   budget = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB = 6 * 4096 = 24,576 fields
+ *
+ *   per-block minimal blob footprint (every block carries a per-block l1-to-l2 root):
+ *     a block with no txs           = 7 fields   (NUM_BLOCK_END_BLOB_FIELDS)
+ *     a block with one minimal tx   = 7 + 4 = 11 fields
+ *                                     (NUM_BLOCK_END_BLOB_FIELDS + a 4-field minimal tx:
+ *                                      tx start marker + tx hash + fee + 1 mandatory nullifier)
+ *     + 1 checkpoint-end marker      (NUM_CHECKPOINT_END_MARKER_FIELDS)
+ *
+ *   max N:  7 + 11*(N - 1) + 1 <= 24,576  =>  11*(N - 1) <= 24,568  =>  N <= 2,234
+ *
+ * 2234 is kept as the deserialization bound: it is far above the circuit cap, so it never rejects a
+ * provable checkpoint, while still bounding how much a malformed blob payload can allocate. L1 carries
+ * no block count of its own, so an over-cap (and therefore unprovable) checkpoint can only reach it with
+ * a malicious committee supermajority — a terminal network compromise. Invariant checked by the unit
+ * test in deserialization.test.ts.
+ */
+export declare const MAX_CAPACITY_BLOCKS_PER_CHECKPOINT = 2234;
+/**
+ * Max blocks per checkpoint we are willing to build or attest to, and the default block-count limit for
+ * `validateCheckpoint`. This is the protocol cap the checkpoint root circuit enforces: anything above it
+ * is unprovable, so a node must never build or attest to it. Distinct from
+ * {@link MAX_CAPACITY_BLOCKS_PER_CHECKPOINT}, the looser bound used when deserializing untrusted payloads.
+ */
+export declare const MAX_ATTESTABLE_BLOCKS_PER_CHECKPOINT = 72;
+/** Max tx effects per body (based on blob capacity per checkpoint) */
+export declare const MAX_TX_EFFECTS_PER_BODY: number;
+/** Max block hash string length (hex: 0x + 64 chars, with generous headroom) */
+export declare const MAX_BLOCK_HASH_STRING_LENGTH = 128;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kZXNlcmlhbGl6YXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0EsZ0VBQWdFO0FBQ2hFLGVBQU8sTUFBTSxpQkFBaUIsUUFBVSxDQUFDO0FBRXpDLG9GQUFtRjtBQUNuRixlQUFPLE1BQU0sa0JBQWtCLE9BQU8sQ0FBQztBQUV2Qzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXlCRztBQUNILGVBQU8sTUFBTSxrQ0FBa0MsT0FBTyxDQUFDO0FBRXZEOzs7OztHQUtHO0FBQ0gsZUFBTyxNQUFNLG9DQUFvQyxLQUE0QixDQUFDO0FBRTlFLHNFQUFzRTtBQUN0RSxlQUFPLE1BQU0sdUJBQXVCLFFBQXlDLENBQUM7QUFFOUUsZ0ZBQWdGO0FBQ2hGLGVBQU8sTUFBTSw0QkFBNEIsTUFBTSxDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/deserialization/index.ts"],"names":[],"mappings":"AAOA,gEAAgE;AAChE,eAAO,MAAM,iBAAiB,QAAU,CAAC;AAEzC,oFAAmF;AACnF,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,KAA4B,CAAC;AAE9E,sEAAsE;AACtE,eAAO,MAAM,uBAAuB,QAAyC,CAAC;AAE9E,gFAAgF;AAChF,eAAO,MAAM,4BAA4B,MAAM,CAAC"}