@forestrie/merklelog 0.0.1

package/dist/massifs/massif.d.ts

@@ -0,0 +1,86 @@
+import type { MassifStart } from "./massifstart.js";
+/**
+ * Massif - Efficient buffer-based access to massif data
+ *
+ * Provides efficient access to massif start data based on a view of an
+ * in-memory buffer which holds the data. All operations work directly with
+ * the buffer without copying.
+ */
+export declare class Massif {
+    private readonly buffer;
+    /**
+     * Creates a new Massif instance from buffer data
+     * @param data - The massif data as ArrayBuffer, Uint8Array, or Buffer
+     */
+    constructor(data: ArrayBuffer | Uint8Array | Buffer | {
+        buffer: ArrayBuffer;
+        byteOffset: number;
+        byteLength: number;
+    });
+    /**
+     * Returns a MassifStart instance populated by reading directly from the buffer
+     *
+     * Computes firstIndex using massif height and index (calls MMR function)
+     * Computes peakStackLen using massif index (calls MMR function)
+     */
+    getStart(): MassifStart;
+    /**
+     * Returns a buffer view of the corresponding field at zero-based index
+     *
+     * Each field is 32 bytes (LogFormat.ValueBytes). Zero-based indexing, without regard
+     * to peakstack or trieindex structure.
+     *
+     * @param index - Zero-based field index (Number or BigInt)
+     * @param count - Number of consecutive fields to include in the view (defaults to 1)
+     * @returns Uint8Array view of the field(s) (32 bytes per field)
+     */
+    fieldref(index: number | bigint, count?: number): Uint8Array;
+    /**
+     * Reads bytes from the buffer at the specified offset
+     *
+     * Returns a view of the buffer without copying. Efficient for reading
+     * arbitrary byte ranges that may span multiple 32-byte fields.
+     *
+     * @param offset - Byte offset into the buffer
+     * @param length - Number of bytes to read
+     * @returns Uint8Array view of the requested bytes
+     */
+    readBytes(offset: number, length: number): Uint8Array;
+    /**
+     * Reads a big-endian uint64 from the buffer
+     */
+    private readUint64BE;
+    /**
+     * Reads a big-endian uint32 from the buffer
+     */
+    private readUint32BE;
+    /**
+     * Reads a big-endian uint16 from the buffer
+     */
+    private readUint16BE;
+    /**
+     * Reserved field (bytes 0-7)
+     */
+    get reserved(): bigint;
+    /**
+     * Last ID timestamp (bytes 8-15)
+     */
+    get lastID(): bigint;
+    /**
+     * Version (bytes 21-22)
+     */
+    get version(): number;
+    /**
+     * Commitment epoch (bytes 23-26)
+     */
+    get commitmentEpoch(): number;
+    /**
+     * Massif height (byte 27)
+     */
+    get massifHeight(): number;
+    /**
+     * Massif index (bytes 28-31)
+     */
+    get massifIndex(): number;
+}
+//# sourceMappingURL=massif.d.ts.map

package/dist/massifs/massif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"massif.d.ts","sourceRoot":"","sources":["../../src/massifs/massif.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAKpD;;;;;;GAMG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IAEpC;;;OAGG;gBAED,IAAI,EACA,WAAW,GACX,UAAU,GACV,MAAM,GACN;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;IAsBrE;;;;;OAKG;IACH,QAAQ,IAAI,WAAW;IAsBvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,UAAU;IAM/D;;;;;;;;;OASG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU;IAIrD;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;OAEG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;CACF"}

package/dist/massifs/massif.js

@@ -0,0 +1,143 @@
+import { MassifStartFmt } from "./massifstart.js";
+import { LogFormat } from "./logformat.js";
+import { massifFirstLeaf, leafMinusSpurSum } from "../mmr/index.js";
+/**
+ * Massif - Efficient buffer-based access to massif data
+ *
+ * Provides efficient access to massif start data based on a view of an
+ * in-memory buffer which holds the data. All operations work directly with
+ * the buffer without copying.
+ */
+export class Massif {
+    buffer;
+    /**
+     * Creates a new Massif instance from buffer data
+     * @param data - The massif data as ArrayBuffer, Uint8Array, or Buffer
+     */
+    constructor(data) {
+        if (data instanceof ArrayBuffer) {
+            this.buffer = new Uint8Array(data);
+        }
+        else if (data instanceof Uint8Array) {
+            this.buffer = data;
+        }
+        else if ("buffer" in data &&
+            "byteOffset" in data &&
+            "byteLength" in data) {
+            // Node.js Buffer or similar
+            this.buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else {
+            throw new Error("Unsupported buffer type");
+        }
+    }
+    /**
+     * Returns a MassifStart instance populated by reading directly from the buffer
+     *
+     * Computes firstIndex using massif height and index (calls MMR function)
+     * Computes peakStackLen using massif index (calls MMR function)
+     */
+    getStart() {
+        const massifHeight = this.massifHeight;
+        const massifIndex = this.massifIndex;
+        // Compute firstIndex using massif height and index
+        const firstIndex = massifFirstLeaf(massifHeight, massifIndex);
+        // Compute peakStackLen using massif index
+        const peakStackLen = leafMinusSpurSum(BigInt(massifIndex));
+        return {
+            reserved: this.reserved,
+            lastID: this.lastID,
+            version: this.version,
+            commitmentEpoch: this.commitmentEpoch,
+            massifHeight,
+            massifIndex,
+            firstIndex,
+            peakStackLen,
+        };
+    }
+    /**
+     * Returns a buffer view of the corresponding field at zero-based index
+     *
+     * Each field is 32 bytes (LogFormat.ValueBytes). Zero-based indexing, without regard
+     * to peakstack or trieindex structure.
+     *
+     * @param index - Zero-based field index (Number or BigInt)
+     * @param count - Number of consecutive fields to include in the view (defaults to 1)
+     * @returns Uint8Array view of the field(s) (32 bytes per field)
+     */
+    fieldref(index, count = 1) {
+        const idx = typeof index === "bigint" ? Number(index) : index;
+        const offset = idx * LogFormat.ValueBytes;
+        return this.buffer.slice(offset, offset + count * LogFormat.ValueBytes);
+    }
+    /**
+     * Reads bytes from the buffer at the specified offset
+     *
+     * Returns a view of the buffer without copying. Efficient for reading
+     * arbitrary byte ranges that may span multiple 32-byte fields.
+     *
+     * @param offset - Byte offset into the buffer
+     * @param length - Number of bytes to read
+     * @returns Uint8Array view of the requested bytes
+     */
+    readBytes(offset, length) {
+        return this.buffer.slice(offset, offset + length);
+    }
+    /**
+     * Reads a big-endian uint64 from the buffer
+     */
+    readUint64BE(offset) {
+        const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + offset, 8);
+        return view.getBigUint64(0, false); // false = big-endian
+    }
+    /**
+     * Reads a big-endian uint32 from the buffer
+     */
+    readUint32BE(offset) {
+        const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + offset, 4);
+        return view.getUint32(0, false); // false = big-endian
+    }
+    /**
+     * Reads a big-endian uint16 from the buffer
+     */
+    readUint16BE(offset) {
+        const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + offset, 2);
+        return view.getUint16(0, false); // false = big-endian
+    }
+    /**
+     * Reserved field (bytes 0-7)
+     */
+    get reserved() {
+        return this.readUint64BE(0);
+    }
+    /**
+     * Last ID timestamp (bytes 8-15)
+     */
+    get lastID() {
+        return this.readUint64BE(MassifStartFmt.LastIdFirstByte);
+    }
+    /**
+     * Version (bytes 21-22)
+     */
+    get version() {
+        return this.readUint16BE(MassifStartFmt.VersionFirstByte);
+    }
+    /**
+     * Commitment epoch (bytes 23-26)
+     */
+    get commitmentEpoch() {
+        return this.readUint32BE(MassifStartFmt.EpochFirstByte);
+    }
+    /**
+     * Massif height (byte 27)
+     */
+    get massifHeight() {
+        return this.buffer[MassifStartFmt.MassifHeightFirstByte];
+    }
+    /**
+     * Massif index (bytes 28-31)
+     */
+    get massifIndex() {
+        return this.readUint32BE(MassifStartFmt.MassifFirstByte);
+    }
+}

package/dist/massifs/massiffull.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Massif fullness determination functions
+ *
+ * Functions for determining if a massif is full based on its height and log entries.
+ */
+/**
+ * Determine if a massif is full.
+ *
+ * @param massifHeight - Massif height (1-based)
+ * @param logEntries - Number of log entries (nodes) in the massif
+ * @returns True if the massif is full
+ */
+export declare function isMassifFull(massifHeight: number, logEntries: bigint): boolean;
+//# sourceMappingURL=massiffull.d.ts.map

package/dist/massifs/massiffull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"massiffull.d.ts","sourceRoot":"","sources":["../../src/massifs/massiffull.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,OAAO,CAWT"}

package/dist/massifs/massiffull.js

@@ -0,0 +1,21 @@
+/**
+ * Massif fullness determination functions
+ *
+ * Functions for determining if a massif is full based on its height and log entries.
+ */
+/**
+ * Determine if a massif is full.
+ *
+ * @param massifHeight - Massif height (1-based)
+ * @param logEntries - Number of log entries (nodes) in the massif
+ * @returns True if the massif is full
+ */
+export function isMassifFull(massifHeight, logEntries) {
+    // Convert 1-based height to 0-based height index
+    const heightIndex = massifHeight - 1;
+    // Expected number of leaves for a full massif: f = 2^g = 1 << heightIndex
+    const expectedLeaves = BigInt(1 << heightIndex);
+    // Actual number of leaves: f = (n + 1) / 2
+    const actualLeaves = (logEntries + 1n) >> 1n;
+    return actualLeaves >= expectedLeaves;
+}

package/dist/massifs/massiflogentries.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MassifLogEntries calculation for v2 massif format
+ */
+/**
+ * MassifLogEntries calculates the number of log entries (nodes) in a blob from
+ * the length of the blob in bytes.
+ *
+ * It does this by accounting for the index data and other header data.
+ * If you know the FirstIndex from the massif start header you can get the
+ * overall mmr size by direct addition.
+ *
+ * Note: this function exists so we can compute the mmrSize from just the blob
+ * store metadata: we store the FirstIndex on a blob tag, and the blob
+ * metadata includes ContentLength. This means when we are checking if a root
+ * seal covers the current log head, we don't need to fetch the log massif blob.
+ *
+ * @param dataLen - Total length of the massif blob in bytes
+ * @param massifHeight - One-based massif height
+ * @returns Number of log entries (nodes) in the blob
+ * @throws Error if the data length is too short to contain the required headers
+ */
+export declare function massifLogEntries(dataLen: number, massifHeight: number): bigint;
+//# sourceMappingURL=massiflogentries.d.ts.map

package/dist/massifs/massiflogentries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"massiflogentries.d.ts","sourceRoot":"","sources":["../../src/massifs/massiflogentries.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GACnB,MAAM,CAWR"}

package/dist/massifs/massiflogentries.js

@@ -0,0 +1,31 @@
+/**
+ * MassifLogEntries calculation for v2 massif format
+ */
+import { LogFormat } from "./logformat.js";
+import { peakStackEnd } from "./peakstackend.js";
+/**
+ * MassifLogEntries calculates the number of log entries (nodes) in a blob from
+ * the length of the blob in bytes.
+ *
+ * It does this by accounting for the index data and other header data.
+ * If you know the FirstIndex from the massif start header you can get the
+ * overall mmr size by direct addition.
+ *
+ * Note: this function exists so we can compute the mmrSize from just the blob
+ * store metadata: we store the FirstIndex on a blob tag, and the blob
+ * metadata includes ContentLength. This means when we are checking if a root
+ * seal covers the current log head, we don't need to fetch the log massif blob.
+ *
+ * @param dataLen - Total length of the massif blob in bytes
+ * @param massifHeight - One-based massif height
+ * @returns Number of log entries (nodes) in the blob
+ * @throws Error if the data length is too short to contain the required headers
+ */
+export function massifLogEntries(dataLen, massifHeight) {
+    const stackEnd = peakStackEnd(massifHeight);
+    if (BigInt(dataLen) < stackEnd) {
+        throw new Error(`Massif data length ${dataLen} is too short. Minimum required: ${stackEnd} bytes`);
+    }
+    const mmrByteCount = BigInt(dataLen) - stackEnd;
+    return mmrByteCount / BigInt(LogFormat.ValueBytes);
+}

package/dist/massifs/massifstart.d.ts

@@ -0,0 +1,63 @@
+/**
+ * MassifStart - Header information for a massif blob
+ *
+ * The massif start is a 32-byte field encoding bookkeeping information
+ * required in a blob to allow for efficient correctness checks.
+ */
+export interface MassifStart {
+    /** Reserved field (bytes 0-7) */
+    reserved: bigint;
+    /** Last ID timestamp (bytes 8-15) */
+    lastID: bigint;
+    /** Version (bytes 21-22) */
+    version: number;
+    /** Commitment epoch (bytes 23-26) */
+    commitmentEpoch: number;
+    /** Massif height (byte 27) */
+    massifHeight: number;
+    /** Massif index (bytes 28-31) */
+    massifIndex: number;
+    /** First MMR index in this massif (computed) */
+    firstIndex: bigint;
+    /** Peak stack length (computed) */
+    peakStackLen: bigint;
+}
+/**
+ * MassifStartFmt - Format constants for MassifStart fields
+ *
+ * Byte offsets and sizes for MassifStart fields.
+ * Matching the Go implementation in go-merklelog/massifs/massifstart.go
+ */
+export declare namespace MassifStartFmt {
+    /** Last ID timestamp field - first byte offset */
+    const LastIdFirstByte = 8;
+    /** Last ID timestamp field - size in bytes */
+    const LastIdSize = 8;
+    /** Last ID timestamp field - end byte offset */
+    const LastIdEnd: number;
+    /** Version field - first byte offset */
+    const VersionFirstByte = 21;
+    /** Version field - size in bytes */
+    const VersionSize = 2;
+    /** Version field - end byte offset */
+    const VersionEnd: number;
+    /** Commitment epoch field - first byte offset */
+    const EpochFirstByte: number;
+    /** Commitment epoch field - size in bytes */
+    const EpochSize = 4;
+    /** Commitment epoch field - end byte offset */
+    const EpochEnd: number;
+    /** Massif height field - first byte offset */
+    const MassifHeightFirstByte: number;
+    /** Massif height field - size in bytes */
+    const MassifHeightSize = 1;
+    /** Massif height field - end byte offset */
+    const MassifHeightEnd: number;
+    /** Massif index field - first byte offset */
+    const MassifFirstByte: number;
+    /** Massif index field - size in bytes */
+    const MassifSize = 4;
+    /** Massif index field - end byte offset */
+    const MassifEnd: number;
+}
+//# sourceMappingURL=massifstart.d.ts.map

package/dist/massifs/massifstart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"massifstart.d.ts","sourceRoot":"","sources":["../../src/massifs/massifstart.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,8BAA8B;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,yBAAiB,cAAc,CAAC;IAC9B,kDAAkD;IAC3C,MAAM,eAAe,IAAI,CAAC;IACjC,8CAA8C;IACvC,MAAM,UAAU,IAAI,CAAC;IAC5B,gDAAgD;IACzC,MAAM,SAAS,QAA+B,CAAC;IAEtD,wCAAwC;IACjC,MAAM,gBAAgB,KAAK,CAAC;IACnC,oCAAoC;IAC7B,MAAM,WAAW,IAAI,CAAC;IAC7B,sCAAsC;IAC/B,MAAM,UAAU,QAAiC,CAAC;IAEzD,iDAAiD;IAC1C,MAAM,cAAc,QAAa,CAAC;IACzC,6CAA6C;IACtC,MAAM,SAAS,IAAI,CAAC;IAC3B,+CAA+C;IACxC,MAAM,QAAQ,QAA6B,CAAC;IAEnD,8CAA8C;IACvC,MAAM,qBAAqB,QAAW,CAAC;IAC9C,0CAA0C;IACnC,MAAM,gBAAgB,IAAI,CAAC;IAClC,4CAA4C;IACrC,MAAM,eAAe,QAA2C,CAAC;IAExE,6CAA6C;IACtC,MAAM,eAAe,QAAkB,CAAC;IAC/C,yCAAyC;IAClC,MAAM,UAAU,IAAI,CAAC;IAC5B,2CAA2C;IACpC,MAAM,SAAS,QAA+B,CAAC;CACvD"}

package/dist/massifs/massifstart.js

@@ -0,0 +1,39 @@
+/**
+ * MassifStartFmt - Format constants for MassifStart fields
+ *
+ * Byte offsets and sizes for MassifStart fields.
+ * Matching the Go implementation in go-merklelog/massifs/massifstart.go
+ */
+export var MassifStartFmt;
+(function (MassifStartFmt) {
+    /** Last ID timestamp field - first byte offset */
+    MassifStartFmt.LastIdFirstByte = 8;
+    /** Last ID timestamp field - size in bytes */
+    MassifStartFmt.LastIdSize = 8;
+    /** Last ID timestamp field - end byte offset */
+    MassifStartFmt.LastIdEnd = MassifStartFmt.LastIdFirstByte + MassifStartFmt.LastIdSize;
+    /** Version field - first byte offset */
+    MassifStartFmt.VersionFirstByte = 21;
+    /** Version field - size in bytes */
+    MassifStartFmt.VersionSize = 2;
+    /** Version field - end byte offset */
+    MassifStartFmt.VersionEnd = MassifStartFmt.VersionFirstByte + MassifStartFmt.VersionSize;
+    /** Commitment epoch field - first byte offset */
+    MassifStartFmt.EpochFirstByte = MassifStartFmt.VersionEnd; // 23
+    /** Commitment epoch field - size in bytes */
+    MassifStartFmt.EpochSize = 4;
+    /** Commitment epoch field - end byte offset */
+    MassifStartFmt.EpochEnd = MassifStartFmt.EpochFirstByte + MassifStartFmt.EpochSize;
+    /** Massif height field - first byte offset */
+    MassifStartFmt.MassifHeightFirstByte = MassifStartFmt.EpochEnd; // 27
+    /** Massif height field - size in bytes */
+    MassifStartFmt.MassifHeightSize = 1;
+    /** Massif height field - end byte offset */
+    MassifStartFmt.MassifHeightEnd = MassifStartFmt.MassifHeightFirstByte + MassifStartFmt.MassifHeightSize;
+    /** Massif index field - first byte offset */
+    MassifStartFmt.MassifFirstByte = MassifStartFmt.MassifHeightEnd; // 28
+    /** Massif index field - size in bytes */
+    MassifStartFmt.MassifSize = 4;
+    /** Massif index field - end byte offset */
+    MassifStartFmt.MassifEnd = MassifStartFmt.MassifFirstByte + MassifStartFmt.MassifSize;
+})(MassifStartFmt || (MassifStartFmt = {}));

package/dist/massifs/mmrindex.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MMR index calculation functions for massifs
+ *
+ * Functions for computing MMR indices from massif metadata.
+ */
+/**
+ * Compute the last MMR index in a massif.
+ *
+ * @param massifHeight - Massif height (1-based)
+ * @param massifIndex - Massif index
+ * @param blobSize - Size of the massif blob in bytes
+ * @returns The last MMR index in the massif
+ */
+export declare function computeLastMMRIndex(massifHeight: number, massifIndex: number, blobSize: number): bigint;
+//# sourceMappingURL=mmrindex.d.ts.map

package/dist/massifs/mmrindex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmrindex.d.ts","sourceRoot":"","sources":["../../src/massifs/mmrindex.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,MAAM,CAUR"}

package/dist/massifs/mmrindex.js

@@ -0,0 +1,24 @@
+/**
+ * MMR index calculation functions for massifs
+ *
+ * Functions for computing MMR indices from massif metadata.
+ */
+import { massifLogEntries } from "./massiflogentries.js";
+import { massifFirstLeaf } from "../mmr/index.js";
+/**
+ * Compute the last MMR index in a massif.
+ *
+ * @param massifHeight - Massif height (1-based)
+ * @param massifIndex - Massif index
+ * @param blobSize - Size of the massif blob in bytes
+ * @returns The last MMR index in the massif
+ */
+export function computeLastMMRIndex(massifHeight, massifIndex, blobSize) {
+    // Calculate number of log entries (nodes) in the blob
+    // massifLogEntries expects 1-based height
+    const logEntries = massifLogEntries(blobSize, massifHeight);
+    // Get firstIndex using massifFirstLeaf (also expects 1-based height)
+    const firstIndex = massifFirstLeaf(massifHeight, massifIndex);
+    // Last index = firstIndex + logEntries - 1
+    return firstIndex + logEntries - 1n;
+}

package/dist/massifs/peakstackend.d.ts

@@ -0,0 +1,21 @@
+/**
+ * PeakStackEnd calculation for v2 massif format
+ */
+/**
+ * PeakStackEnd returns the first byte after the massif ancestor peak stack data
+ *
+ * The peak stack is fixed at MaxMmrHeight entries regardless of how many are
+ * actually needed. This makes it possible to trivially compute the node &
+ * leaf counts knowing only the byte size of the massif.
+ *
+ * V2 layout:
+ *   StartHeader (256 bytes)
+ *   IndexHeader (32 bytes) = BloomHeaderV1
+ *   IndexData (bloom bitsets + frontier + leaf table + node store)
+ *   PeakStack (MaxMmrHeight * ValueBytes = 2048 bytes)
+ *
+ * @param massifHeight - One-based massif height
+ * @returns Byte offset of the end of the peak stack
+ */
+export declare function peakStackEnd(massifHeight: number): bigint;
+//# sourceMappingURL=peakstackend.d.ts.map

package/dist/massifs/peakstackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peakstackend.d.ts","sourceRoot":"","sources":["../../src/massifs/peakstackend.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAUzD"}

package/dist/massifs/peakstackend.js

@@ -0,0 +1,29 @@
+/**
+ * PeakStackEnd calculation for v2 massif format
+ */
+import { LogFormat } from "./logformat.js";
+import { indexDataBytesV2, leafCountForMassifHeight } from "./indexformat.js";
+/**
+ * PeakStackEnd returns the first byte after the massif ancestor peak stack data
+ *
+ * The peak stack is fixed at MaxMmrHeight entries regardless of how many are
+ * actually needed. This makes it possible to trivially compute the node &
+ * leaf counts knowing only the byte size of the massif.
+ *
+ * V2 layout:
+ *   StartHeader (256 bytes)
+ *   IndexHeader (32 bytes) = BloomHeaderV1
+ *   IndexData (bloom bitsets + frontier + leaf table + node store)
+ *   PeakStack (MaxMmrHeight * ValueBytes = 2048 bytes)
+ *
+ * @param massifHeight - One-based massif height
+ * @returns Byte offset of the end of the peak stack
+ */
+export function peakStackEnd(massifHeight) {
+    const fixedHeaderEnd = BigInt(LogFormat.StartHeaderSize);
+    const indexHeaderBytes = BigInt(LogFormat.IndexHeaderBytes);
+    const leafCount = leafCountForMassifHeight(massifHeight);
+    const indexDataBytes = indexDataBytesV2(leafCount);
+    const peakStackSize = BigInt(LogFormat.MaxMmrHeight * LogFormat.ValueBytes);
+    return fixedHeaderEnd + indexHeaderBytes + indexDataBytes + peakStackSize;
+}

package/dist/massifs/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Re-exports for massifs module types and constants
+ *
+ * This file serves as a convenience re-export point for external consumers.
+ * Types and interfaces are organized into individual files to:
+ * 1. Avoid circular dependencies
+ * 2. Avoid monolithic types.ts files
+ * 3. Keep related code (interfaces and their implementations) together
+ */
+export type { MassifStart } from "./massifstart.js";
+export { MassifStartFmt } from "./massifstart.js";
+export { LogFormat } from "./logformat.js";
+export { Urkle, Bloom, IndexV2, leafCountForMassifHeight, leafTableBytes, nodeCountMax, nodeStoreBytes, bloomMBits, bloomBitsetBytes, bloomRegionBytes, indexDataBytesV2, } from "./indexformat.js";
+export { peakStackEnd } from "./peakstackend.js";
+export { massifLogEntries } from "./massiflogentries.js";
+export { urkleLeafTableStartFieldIndex, urkleLeafTableStartByteOffset, createLeafEnumerator, leafComponentByteOffset, leafComponentSize, } from "./urkleindex.js";
+export type { LeafComponent, LeafEnumeratorSpec, LeafEntry, } from "./urkleindex.js";
+export { computeLastMMRIndex } from "./mmrindex.js";
+export { isMassifFull } from "./massiffull.js";
+//# sourceMappingURL=types.d.ts.map

package/dist/massifs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/massifs/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC7B,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,SAAS,GACV,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/massifs/types.js

@@ -0,0 +1,23 @@
+/**
+ * Re-exports for massifs module types and constants
+ *
+ * This file serves as a convenience re-export point for external consumers.
+ * Types and interfaces are organized into individual files to:
+ * 1. Avoid circular dependencies
+ * 2. Avoid monolithic types.ts files
+ * 3. Keep related code (interfaces and their implementations) together
+ */
+export { MassifStartFmt } from "./massifstart.js";
+// Re-export log format constants
+export { LogFormat } from "./logformat.js";
+// Re-export index format constants and functions (v2)
+export { Urkle, Bloom, IndexV2, leafCountForMassifHeight, leafTableBytes, nodeCountMax, nodeStoreBytes, bloomMBits, bloomBitsetBytes, bloomRegionBytes, indexDataBytesV2, } from "./indexformat.js";
+// Re-export peakStackEnd and massifLogEntries
+export { peakStackEnd } from "./peakstackend.js";
+export { massifLogEntries } from "./massiflogentries.js";
+// Re-export urkle index helpers
+export { urkleLeafTableStartFieldIndex, urkleLeafTableStartByteOffset, createLeafEnumerator, leafComponentByteOffset, leafComponentSize, } from "./urkleindex.js";
+// Re-export MMR index functions
+export { computeLastMMRIndex } from "./mmrindex.js";
+// Re-export massif fullness functions
+export { isMassifFull } from "./massiffull.js";