@syncular/core 0.1.3 → 0.2.0

package/dist/snapshot-chunks.js

@@ -1,682 +0,0 @@
-/**
- * @syncular/core - Snapshot chunk encoding helpers
- */
-import { sha256Hex } from './utils/crypto.js';
-export const SYNC_SNAPSHOT_CHUNK_ENCODING_BINARY_TABLE_V1 = 'binary-table-v1';
-export const SYNC_SNAPSHOT_CHUNK_ENCODINGS = [
-    SYNC_SNAPSHOT_CHUNK_ENCODING_BINARY_TABLE_V1,
-];
-export const SYNC_SNAPSHOT_CHUNK_ENCODING = SYNC_SNAPSHOT_CHUNK_ENCODING_BINARY_TABLE_V1;
-export function isSyncSnapshotChunkEncoding(value) {
-    return (typeof value === 'string' &&
-        SYNC_SNAPSHOT_CHUNK_ENCODINGS.includes(value));
-}
-export const SYNC_SNAPSHOT_CHUNK_COMPRESSION = 'gzip';
-export const SYNC_SNAPSHOT_ARTIFACT_COMPRESSION_NONE = 'none';
-export const SYNC_SCOPED_SNAPSHOT_ARTIFACT_MANIFEST_VERSION = 1;
-export const SYNC_SCOPED_SNAPSHOT_ARTIFACT_KIND_SQLITE_V1 = 'sqlite-snapshot-v1';
-const SNAPSHOT_BINARY_TABLE_MAGIC = new Uint8Array([0x53, 0x42, 0x54, 0x31]); // "SBT1"
-const BINARY_TABLE_VERSION = 1;
-const BINARY_TABLE_FLAG_NONE = 0;
-const BINARY_COLUMN_FLAG_NULLABLE = 1;
-const MAX_FRAME_BYTE_LENGTH = 0xffff_ffff;
-const snapshotTextEncoder = new TextEncoder();
-const snapshotTextDecoder = new TextDecoder();
-const BINARY_TYPE_TAGS = {
-    string: 1,
-    integer: 2,
-    float: 3,
-    boolean: 4,
-    json: 5,
-    bytes: 6,
-};
-const BINARY_COLUMN_TYPES_BY_TAG = new Map(Object.entries(BINARY_TYPE_TAGS).map(([type, tag]) => [
-    tag,
-    type,
-]));
-function normalizeRowJson(row) {
-    const serialized = JSON.stringify(row);
-    return serialized === undefined ? 'null' : serialized;
-}
-function utf8ByteLength(value) {
-    return snapshotTextEncoder.encode(value).length;
-}
-function appendStringField(parts, name, value) {
-    parts.push(`${name}:s:${utf8ByteLength(value)}:${value}`);
-}
-function appendNullableStringField(parts, name, value) {
-    if (value === null) {
-        parts.push(`${name}:n`);
-        return;
-    }
-    appendStringField(parts, name, value);
-}
-function appendIntField(parts, name, value) {
-    if (!Number.isSafeInteger(value)) {
-        throw new Error(`Snapshot manifest ${name} must be a safe integer`);
-    }
-    parts.push(`${name}:i:${value}`);
-}
-function appendBoolField(parts, name, value) {
-    parts.push(`${name}:b:${value ? 1 : 0}`);
-}
-export function snapshotScopeDigestFromCacheKey(scopeKey) {
-    const marker = ':scope:';
-    const markerIndex = scopeKey.lastIndexOf(marker);
-    if (markerIndex < 0) {
-        throw new Error('Snapshot scope cache key is missing scope digest');
-    }
-    const digest = scopeKey.slice(markerIndex + marker.length);
-    if (!/^[a-f0-9]{64}$/.test(digest)) {
-        throw new Error('Snapshot scope cache key has invalid scope digest');
-    }
-    return digest;
-}
-export function snapshotManifestDigestPayload(manifest) {
-    const parts = ['syncular.snapshot-manifest.v1'];
-    appendIntField(parts, 'version', manifest.version);
-    appendStringField(parts, 'table', manifest.table);
-    appendIntField(parts, 'asOfCommitSeq', manifest.asOfCommitSeq);
-    appendStringField(parts, 'scopeDigest', manifest.scopeDigest);
-    appendNullableStringField(parts, 'rowCursor', manifest.rowCursor);
-    appendIntField(parts, 'rowLimit', manifest.rowLimit);
-    appendNullableStringField(parts, 'nextRowCursor', manifest.nextRowCursor);
-    appendBoolField(parts, 'isFirstPage', manifest.isFirstPage);
-    appendBoolField(parts, 'isLastPage', manifest.isLastPage);
-    appendIntField(parts, 'chunkCount', manifest.chunks.length);
-    for (const [index, chunk] of manifest.chunks.entries()) {
-        appendIntField(parts, `chunk.${index}.index`, index);
-        appendStringField(parts, `chunk.${index}.id`, chunk.id);
-        appendIntField(parts, `chunk.${index}.byteLength`, chunk.byteLength);
-        appendStringField(parts, `chunk.${index}.sha256`, chunk.sha256);
-        appendStringField(parts, `chunk.${index}.encoding`, chunk.encoding);
-        appendStringField(parts, `chunk.${index}.compression`, chunk.compression);
-    }
-    return `${parts.join('\n')}\n`;
-}
-export async function createSnapshotManifestDigest(manifest) {
-    return sha256Hex(snapshotManifestDigestPayload(manifest));
-}
-export async function createSnapshotManifest(manifest) {
-    return {
-        ...manifest,
-        chunks: [...manifest.chunks],
-        digest: await createSnapshotManifestDigest(manifest),
-    };
-}
-function normalizedFeatureSet(featureSet) {
-    return Array.from(new Set(featureSet)).sort();
-}
-function scopedSnapshotArtifactDigestInput(manifest) {
-    return {
-        ...manifest,
-        featureSet: normalizedFeatureSet(manifest.featureSet),
-    };
-}
-export function scopedSnapshotArtifactDigestPayload(manifest) {
-    const input = scopedSnapshotArtifactDigestInput(manifest);
-    const parts = ['syncular.scoped-snapshot-artifact.v1'];
-    appendIntField(parts, 'version', input.version);
-    appendStringField(parts, 'artifactKind', input.artifactKind);
-    appendStringField(parts, 'partitionId', input.partitionId);
-    appendStringField(parts, 'subscriptionId', input.subscriptionId);
-    appendStringField(parts, 'table', input.table);
-    appendStringField(parts, 'schemaVersion', input.schemaVersion);
-    appendIntField(parts, 'asOfCommitSeq', input.asOfCommitSeq);
-    appendStringField(parts, 'scopeDigest', input.scopeDigest);
-    appendNullableStringField(parts, 'rowCursor', input.rowCursor);
-    appendIntField(parts, 'rowLimit', input.rowLimit);
-    appendIntField(parts, 'rowCount', input.rowCount);
-    appendNullableStringField(parts, 'nextRowCursor', input.nextRowCursor);
-    appendBoolField(parts, 'isFirstPage', input.isFirstPage);
-    appendBoolField(parts, 'isLastPage', input.isLastPage);
-    appendStringField(parts, 'compression', input.compression);
-    appendIntField(parts, 'byteLength', input.byteLength);
-    appendStringField(parts, 'sha256', input.sha256);
-    appendIntField(parts, 'featureCount', input.featureSet.length);
-    for (const [index, feature] of input.featureSet.entries()) {
-        appendIntField(parts, `feature.${index}.index`, index);
-        appendStringField(parts, `feature.${index}.name`, feature);
-    }
-    return `${parts.join('\n')}\n`;
-}
-export async function createScopedSnapshotArtifactDigest(manifest) {
-    return sha256Hex(scopedSnapshotArtifactDigestPayload(manifest));
-}
-export async function createScopedSnapshotArtifactManifest(manifest) {
-    const normalized = scopedSnapshotArtifactDigestInput(manifest);
-    return {
-        ...normalized,
-        featureSet: [...normalized.featureSet],
-        digest: await createScopedSnapshotArtifactDigest(normalized),
-    };
-}
-export function encodeBinarySnapshotTable(table) {
-    const writer = new BinarySnapshotWriter(estimateBinarySnapshotTableSize(table));
-    const valueWriters = table.columns.map(createBinarySnapshotValueWriter);
-    writeBinarySnapshotTableHeader(writer, table.table, table.columns, table.rows.length);
-    const nullBitmapBytes = Math.ceil(table.columns.length / 8);
-    for (const row of table.rows) {
-        const nullBitmapOffset = writer.writeZeroes(nullBitmapBytes);
-        for (let index = 0; index < table.columns.length; index += 1) {
-            const column = table.columns[index];
-            const value = row[column.name];
-            if (value == null) {
-                if (!column.nullable) {
-                    throw new Error(`Binary snapshot column ${column.name} is not nullable`);
-                }
-                const bitmapIndex = nullBitmapOffset + Math.floor(index / 8);
-                writer.patchUint8(bitmapIndex, writer.readUint8(bitmapIndex) | (1 << (index % 8)));
-                continue;
-            }
-            valueWriters[index](writer, value);
-        }
-    }
-    return writer.toUint8Array();
-}
-function createBinarySnapshotValueWriter(column) {
-    const label = `binary snapshot ${column.name}`;
-    switch (column.type) {
-        case 'string':
-            return (writer, value) => {
-                writer.writeString32(binarySnapshotString(value, label), label);
-            };
-        case 'integer':
-            return (writer, value) => {
-                writer.writeInt64(value, label);
-            };
-        case 'float':
-            return (writer, value) => {
-                if (typeof value !== 'number') {
-                    throw new Error(`${label} expected number`);
-                }
-                writer.writeFloat64(value);
-            };
-        case 'boolean':
-            return (writer, value) => {
-                if (typeof value !== 'boolean') {
-                    throw new Error(`${label} expected boolean`);
-                }
-                writer.writeUint8(value ? 1 : 0);
-            };
-        case 'json':
-            return (writer, value) => {
-                writer.writeString32(normalizeRowJson(value), label);
-            };
-        case 'bytes':
-            return (writer, value) => {
-                const bytes = coerceBinaryBytes(value, column.name);
-                writer.writeUint32(bytes.length);
-                writer.writeBytes(bytes);
-            };
-    }
-}
-export class BinarySnapshotTableWriter {
-    columns;
-    writer;
-    nullBitmapBytes;
-    expectedRows;
-    rowsWritten = 0;
-    nullBitmapOffset = null;
-    constructor(table, columns, rowCount, initialCapacity) {
-        this.columns = columns;
-        this.expectedRows = rowCount;
-        this.nullBitmapBytes = Math.ceil(columns.length / 8);
-        this.writer = new BinarySnapshotWriter(initialCapacity ??
-            estimateBinarySnapshotStaticSize(table, columns, rowCount));
-        writeBinarySnapshotTableHeader(this.writer, table, columns, rowCount);
-    }
-    beginRow() {
-        if (this.rowsWritten >= this.expectedRows) {
-            throw new Error('Binary snapshot writer received too many rows');
-        }
-        this.nullBitmapOffset = this.writer.writeZeroes(this.nullBitmapBytes);
-        this.rowsWritten += 1;
-    }
-    writeNull(columnIndex) {
-        const column = this.column(columnIndex);
-        if (!column.nullable) {
-            throw new Error(`Binary snapshot column ${column.name} is not nullable`);
-        }
-        const nullBitmapOffset = this.currentNullBitmapOffset();
-        const bitmapIndex = nullBitmapOffset + Math.floor(columnIndex / 8);
-        this.writer.patchUint8(bitmapIndex, this.writer.readUint8(bitmapIndex) | (1 << (columnIndex % 8)));
-    }
-    writeString(value, label) {
-        this.currentNullBitmapOffset();
-        this.writer.writeString32(binarySnapshotString(value, label), label);
-    }
-    writeInteger(value, label) {
-        this.currentNullBitmapOffset();
-        this.writer.writeInt64(value, label);
-    }
-    writeFloat(value, label) {
-        this.currentNullBitmapOffset();
-        if (typeof value !== 'number') {
-            throw new Error(`${label} expected number`);
-        }
-        this.writer.writeFloat64(value);
-    }
-    writeBoolean(value, label) {
-        this.currentNullBitmapOffset();
-        if (typeof value !== 'boolean') {
-            throw new Error(`${label} expected boolean`);
-        }
-        this.writer.writeUint8(value ? 1 : 0);
-    }
-    writeJson(value, label) {
-        this.currentNullBitmapOffset();
-        this.writer.writeString32(normalizeRowJson(value), label);
-    }
-    writeBytes(value, columnName) {
-        this.currentNullBitmapOffset();
-        const bytes = coerceBinaryBytes(value, columnName);
-        this.writer.writeUint32(bytes.length);
-        this.writer.writeBytes(bytes);
-    }
-    writeValue(columnIndex, value) {
-        const column = this.column(columnIndex);
-        if (value == null) {
-            this.writeNull(columnIndex);
-            return;
-        }
-        this.currentNullBitmapOffset();
-        writeBinarySnapshotValue(this.writer, column, value);
-    }
-    finish() {
-        if (this.rowsWritten !== this.expectedRows) {
-            throw new Error(`Binary snapshot writer expected ${this.expectedRows} rows, received ${this.rowsWritten}`);
-        }
-        return this.writer.toUint8Array();
-    }
-    column(columnIndex) {
-        const column = this.columns[columnIndex];
-        if (!column) {
-            throw new Error(`Binary snapshot column index ${columnIndex} is invalid`);
-        }
-        return column;
-    }
-    currentNullBitmapOffset() {
-        if (this.nullBitmapOffset == null) {
-            throw new Error('Binary snapshot writer has no active row');
-        }
-        return this.nullBitmapOffset;
-    }
-}
-export function decodeBinarySnapshotTable(bytes) {
-    const reader = new BinarySnapshotReader(bytes);
-    reader.expectMagic(SNAPSHOT_BINARY_TABLE_MAGIC, 'binary snapshot table');
-    const version = reader.readUint16('binary snapshot version');
-    if (version !== BINARY_TABLE_VERSION) {
-        throw new Error(`Unsupported binary snapshot version: ${version}`);
-    }
-    const flags = reader.readUint16('binary snapshot flags');
-    if (flags !== BINARY_TABLE_FLAG_NONE) {
-        throw new Error(`Unsupported binary snapshot flags: ${flags}`);
-    }
-    const table = reader.readString16('binary snapshot table name');
-    const columnCount = reader.readUint16('binary snapshot column count');
-    const columns = [];
-    for (let index = 0; index < columnCount; index += 1) {
-        const name = reader.readString16('binary snapshot column name');
-        const typeTag = reader.readUint8('binary snapshot column type');
-        const type = BINARY_COLUMN_TYPES_BY_TAG.get(typeTag);
-        if (!type)
-            throw new Error(`Unsupported binary snapshot type tag: ${typeTag}`);
-        const columnFlags = reader.readUint8('binary snapshot column flags');
-        if (columnFlags & ~BINARY_COLUMN_FLAG_NULLABLE) {
-            throw new Error(`Unsupported binary snapshot column flags: ${columnFlags}`);
-        }
-        columns.push({
-            name,
-            type,
-            ...(columnFlags & BINARY_COLUMN_FLAG_NULLABLE ? { nullable: true } : {}),
-        });
-    }
-    const rowCount = reader.readUint32('binary snapshot row count');
-    const rows = [];
-    const nullBitmapBytes = Math.ceil(columns.length / 8);
-    for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
-        const nullBitmap = reader.readBytes(nullBitmapBytes, 'binary snapshot row null bitmap');
-        const row = {};
-        for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
-            const column = columns[columnIndex];
-            const isNull = (nullBitmap[Math.floor(columnIndex / 8)] &
-                (1 << (columnIndex % 8))) !==
-                0;
-            if (isNull && !column.nullable) {
-                throw new Error(`Binary snapshot column ${column.name} is not nullable`);
-            }
-            row[column.name] = isNull
-                ? null
-                : reader.readValue(column.type, `binary snapshot ${column.name}`);
-        }
-        rows.push(row);
-    }
-    reader.assertDone();
-    return { table, columns, rows };
-}
-function writeBinarySnapshotValue(writer, column, value) {
-    switch (column.type) {
-        case 'string': {
-            if (typeof value !== 'string') {
-                throw new Error(`Binary snapshot column ${column.name} expected string`);
-            }
-            writer.writeString32(value, `binary snapshot ${column.name}`);
-            return;
-        }
-        case 'integer':
-            writer.writeInt64(value, `binary snapshot ${column.name}`);
-            return;
-        case 'float': {
-            if (typeof value !== 'number') {
-                throw new Error(`Binary snapshot column ${column.name} expected number`);
-            }
-            writer.writeFloat64(value);
-            return;
-        }
-        case 'boolean': {
-            if (typeof value !== 'boolean') {
-                throw new Error(`Binary snapshot column ${column.name} expected boolean`);
-            }
-            writer.writeUint8(value ? 1 : 0);
-            return;
-        }
-        case 'json':
-            writer.writeString32(normalizeRowJson(value), `binary snapshot ${column.name}`);
-            return;
-        case 'bytes': {
-            const bytes = coerceBinaryBytes(value, column.name);
-            writer.writeUint32(bytes.length);
-            writer.writeBytes(bytes);
-            return;
-        }
-    }
-}
-function binarySnapshotInt64(value, label) {
-    let bigint;
-    if (typeof value === 'bigint') {
-        bigint = value;
-    }
-    else if (typeof value === 'number' && Number.isSafeInteger(value)) {
-        bigint = BigInt(value);
-    }
-    else if (typeof value === 'string' && /^-?\d+$/.test(value)) {
-        bigint = BigInt(value);
-    }
-    else {
-        throw new Error(`${label} expected a safe integer or bigint`);
-    }
-    return bigint;
-}
-function binarySnapshotString(value, label) {
-    if (typeof value === 'string')
-        return value;
-    if (value instanceof Date)
-        return value.toISOString();
-    throw new Error(`${label} expected string`);
-}
-function coerceBinaryBytes(value, columnName) {
-    if (value instanceof Uint8Array)
-        return value;
-    if (value instanceof ArrayBuffer)
-        return new Uint8Array(value);
-    throw new Error(`Binary snapshot column ${columnName} expected bytes`);
-}
-function assertUint16(value, label) {
-    if (!Number.isInteger(value) || value < 0 || value > 0xffff) {
-        throw new Error(`${label} exceeds uint16 bounds`);
-    }
-}
-function assertUint32(value, label) {
-    if (!Number.isInteger(value) || value < 0 || value > MAX_FRAME_BYTE_LENGTH) {
-        throw new Error(`${label} exceeds uint32 bounds`);
-    }
-}
-function estimateBinarySnapshotTableSize(table) {
-    return estimateBinarySnapshotStaticSize(table.table, table.columns, table.rows.length);
-}
-function estimateBinarySnapshotStaticSize(table, columns, rowCount) {
-    const columnHeaderBytes = columns.reduce((sum, column) => sum + 4 + column.name.length * 4, 0);
-    const rowOverhead = rowCount * Math.max(1, Math.ceil(columns.length / 8));
-    const scalarBytes = rowCount * columns.length * 16;
-    return (SNAPSHOT_BINARY_TABLE_MAGIC.length +
-        10 +
-        table.length * 4 +
-        columnHeaderBytes +
-        rowOverhead +
-        scalarBytes);
-}
-function writeBinarySnapshotTableHeader(writer, table, columns, rowCount) {
-    assertUint16(columns.length, 'binary snapshot column count');
-    assertUint32(rowCount, 'binary snapshot row count');
-    writer.writeBytes(SNAPSHOT_BINARY_TABLE_MAGIC);
-    writer.writeUint16(BINARY_TABLE_VERSION);
-    writer.writeUint16(BINARY_TABLE_FLAG_NONE);
-    writer.writeString16(table, 'binary snapshot table name');
-    writer.writeUint16(columns.length);
-    for (const column of columns) {
-        writer.writeString16(column.name, 'binary snapshot column name');
-        writer.writeUint8(BINARY_TYPE_TAGS[column.type]);
-        writer.writeUint8(column.nullable ? BINARY_COLUMN_FLAG_NULLABLE : 0);
-    }
-    writer.writeUint32(rowCount);
-}
-class BinarySnapshotWriter {
-    bytes;
-    view;
-    offset = 0;
-    constructor(initialCapacity) {
-        this.bytes = new Uint8Array(Math.max(64, initialCapacity));
-        this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.length);
-    }
-    writeUint8(value) {
-        this.ensure(1);
-        this.view.setUint8(this.offset, value);
-        this.offset += 1;
-    }
-    writeUint16(value) {
-        assertUint16(value, 'binary snapshot uint16');
-        this.ensure(2);
-        this.view.setUint16(this.offset, value, true);
-        this.offset += 2;
-    }
-    writeUint32(value) {
-        assertUint32(value, 'binary snapshot uint32');
-        this.ensure(4);
-        this.view.setUint32(this.offset, value, true);
-        this.offset += 4;
-    }
-    writeInt64(value, label) {
-        this.ensure(8);
-        if (typeof value === 'number') {
-            if (!Number.isSafeInteger(value)) {
-                throw new Error(`${label} expected a safe integer or bigint`);
-            }
-            if (value >= 0) {
-                this.view.setUint32(this.offset, value >>> 0, true);
-                this.view.setUint32(this.offset + 4, Math.floor(value / 0x1_0000_0000), true);
-            }
-            else {
-                this.view.setBigInt64(this.offset, BigInt(value), true);
-            }
-        }
-        else {
-            this.view.setBigInt64(this.offset, binarySnapshotInt64(value, label), true);
-        }
-        this.offset += 8;
-    }
-    writeFloat64(value) {
-        this.ensure(8);
-        this.view.setFloat64(this.offset, value, true);
-        this.offset += 8;
-    }
-    writeString16(value, label) {
-        if (this.writeAsciiString16(value, label))
-            return;
-        const bytes = snapshotTextEncoder.encode(value);
-        assertUint16(bytes.length, label);
-        this.writeUint16(bytes.length);
-        this.writeBytes(bytes);
-    }
-    writeString32(value, label) {
-        if (this.writeAsciiString32(value, label))
-            return;
-        const bytes = snapshotTextEncoder.encode(value);
-        assertUint32(bytes.length, label);
-        this.writeUint32(bytes.length);
-        this.writeBytes(bytes);
-    }
-    writeBytes(bytes) {
-        this.ensure(bytes.length);
-        this.bytes.set(bytes, this.offset);
-        this.offset += bytes.length;
-    }
-    writeZeroes(length) {
-        this.ensure(length);
-        const start = this.offset;
-        this.bytes.fill(0, start, start + length);
-        this.offset += length;
-        return start;
-    }
-    readUint8(offset) {
-        return this.view.getUint8(offset);
-    }
-    patchUint8(offset, value) {
-        this.view.setUint8(offset, value);
-    }
-    toUint8Array() {
-        return this.bytes.subarray(0, this.offset);
-    }
-    ensure(length) {
-        const required = this.offset + length;
-        if (required <= this.bytes.length)
-            return;
-        let nextLength = this.bytes.length;
-        while (nextLength < required) {
-            nextLength *= 2;
-        }
-        const next = new Uint8Array(nextLength);
-        next.set(this.bytes, 0);
-        this.bytes = next;
-        this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.length);
-    }
-    writeAsciiString16(value, label) {
-        assertUint16(value.length, label);
-        const start = this.offset;
-        this.writeUint16(value.length);
-        return this.tryWriteAsciiBytes(value, start);
-    }
-    writeAsciiString32(value, label) {
-        assertUint32(value.length, label);
-        const start = this.offset;
-        this.writeUint32(value.length);
-        return this.tryWriteAsciiBytes(value, start);
-    }
-    tryWriteAsciiBytes(value, rollbackOffset) {
-        this.ensure(value.length);
-        for (let index = 0; index < value.length; index += 1) {
-            const code = value.charCodeAt(index);
-            if (code > 0x7f) {
-                this.offset = rollbackOffset;
-                return false;
-            }
-            this.bytes[this.offset + index] = code;
-        }
-        this.offset += value.length;
-        return true;
-    }
-}
-class BinarySnapshotReader {
-    bytes;
-    view;
-    offset = 0;
-    constructor(bytes) {
-        this.bytes = bytes;
-        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
-    }
-    expectMagic(magic, label) {
-        const actual = this.readBytes(magic.length, `${label} magic`);
-        for (let index = 0; index < magic.length; index += 1) {
-            if (actual[index] !== magic[index])
-                throw new Error(`Unexpected ${label} magic`);
-        }
-    }
-    readUint8(label) {
-        this.require(1, label);
-        const value = this.view.getUint8(this.offset);
-        this.offset += 1;
-        return value;
-    }
-    readUint16(label) {
-        this.require(2, label);
-        const value = this.view.getUint16(this.offset, true);
-        this.offset += 2;
-        return value;
-    }
-    readUint32(label) {
-        this.require(4, label);
-        const value = this.view.getUint32(this.offset, true);
-        this.offset += 4;
-        return value;
-    }
-    readString16(label) {
-        const length = this.readUint16(`${label} length`);
-        return snapshotTextDecoder.decode(this.readBytes(length, label));
-    }
-    readString32(label) {
-        const length = this.readUint32(`${label} length`);
-        return snapshotTextDecoder.decode(this.readBytes(length, label));
-    }
-    readBytes(length, label) {
-        this.require(length, label);
-        const value = this.bytes.subarray(this.offset, this.offset + length);
-        this.offset += length;
-        return value;
-    }
-    readValue(type, label) {
-        switch (type) {
-            case 'string':
-                return this.readString32(label);
-            case 'integer': {
-                this.require(8, label);
-                const value = this.view.getBigInt64(this.offset, true);
-                this.offset += 8;
-                const numberValue = Number(value);
-                return Number.isSafeInteger(numberValue) &&
-                    BigInt(numberValue) === value
-                    ? numberValue
-                    : value;
-            }
-            case 'float': {
-                this.require(8, label);
-                const value = this.view.getFloat64(this.offset, true);
-                this.offset += 8;
-                return value;
-            }
-            case 'boolean': {
-                const value = this.readUint8(label);
-                if (value !== 0 && value !== 1)
-                    throw new Error(`${label} expected boolean byte`);
-                return value === 1;
-            }
-            case 'json':
-                return JSON.parse(this.readString32(label));
-            case 'bytes': {
-                const length = this.readUint32(`${label} length`);
-                return this.readBytes(length, label);
-            }
-        }
-    }
-    assertDone() {
-        if (this.offset !== this.bytes.length) {
-            throw new Error('Binary snapshot payload has trailing bytes');
-        }
-    }
-    require(length, label) {
-        if (this.offset + length > this.bytes.length) {
-            throw new Error(`${label} exceeds binary snapshot payload bounds`);
-        }
-    }
-}
-//# sourceMappingURL=snapshot-chunks.js.map