@syncular/core 0.0.6-96 → 0.1.1

package/dist/snapshot-chunks.js

@@ -1,89 +1,682 @@
 /**
  * @syncular/core - Snapshot chunk encoding helpers
  */
-export const SYNC_SNAPSHOT_CHUNK_ENCODING = 'json-row-frame-v1';
+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';
-const SNAPSHOT_ROW_FRAME_MAGIC = new Uint8Array([0x53, 0x52, 0x46, 0x31]); // "SRF1"
-const FRAME_LENGTH_BYTES = 4;
+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;
 }
-/**
- * Encode rows as framed JSON bytes without the format header.
- */
-export function encodeSnapshotRowFrames(rows) {
-    const encoder = new TextEncoder();
-    const payloads = [];
-    let totalByteLength = 0;
-    for (const row of rows) {
-        const payload = encoder.encode(normalizeRowJson(row));
-        if (payload.length > MAX_FRAME_BYTE_LENGTH) {
-            throw new Error(`Snapshot row payload exceeds ${MAX_FRAME_BYTE_LENGTH} bytes`);
-        }
-        payloads.push(payload);
-        totalByteLength += FRAME_LENGTH_BYTES + payload.length;
-    }
-    const encoded = new Uint8Array(totalByteLength);
-    const view = new DataView(encoded.buffer, encoded.byteOffset, encoded.length);
-    let offset = 0;
-    for (const payload of payloads) {
-        view.setUint32(offset, payload.length, false);
-        offset += FRAME_LENGTH_BYTES;
-        encoded.set(payload, offset);
-        offset += payload.length;
-    }
-    return encoded;
+function utf8ByteLength(value) {
+    return snapshotTextEncoder.encode(value).length;
 }
-/**
- * Encode rows as framed JSON bytes with a format header.
- *
- * Format:
- * - 4-byte magic header ("SRF1")
- * - repeated frames of:
- *   - 4-byte big-endian payload byte length
- *   - UTF-8 JSON payload
- */
-export function encodeSnapshotRows(rows) {
-    const framedRows = encodeSnapshotRowFrames(rows);
-    const totalByteLength = SNAPSHOT_ROW_FRAME_MAGIC.length + framedRows.length;
-    const encoded = new Uint8Array(totalByteLength);
-    encoded.set(SNAPSHOT_ROW_FRAME_MAGIC, 0);
-    encoded.set(framedRows, SNAPSHOT_ROW_FRAME_MAGIC.length);
-    return encoded;
+function appendStringField(parts, name, value) {
+    parts.push(`${name}:s:${utf8ByteLength(value)}:${value}`);
 }
-/**
- * Decode framed JSON bytes into rows.
- */
-export function decodeSnapshotRows(bytes) {
-    if (bytes.length < SNAPSHOT_ROW_FRAME_MAGIC.length) {
-        throw new Error('Snapshot chunk payload is too small');
+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);
     }
-    for (let index = 0; index < SNAPSHOT_ROW_FRAME_MAGIC.length; index += 1) {
-        const expected = SNAPSHOT_ROW_FRAME_MAGIC[index];
-        const actual = bytes[index];
-        if (actual !== expected) {
-            throw new Error('Unexpected snapshot chunk format');
+    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 decoder = new TextDecoder();
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
-    let offset = SNAPSHOT_ROW_FRAME_MAGIC.length;
-    while (offset < bytes.length) {
-        if (offset + FRAME_LENGTH_BYTES > bytes.length) {
-            throw new Error('Snapshot chunk payload ended mid-frame header');
-        }
-        const payloadLength = view.getUint32(offset, false);
-        offset += FRAME_LENGTH_BYTES;
-        if (offset + payloadLength > bytes.length) {
-            throw new Error('Snapshot chunk payload ended mid-frame body');
-        }
-        const payload = bytes.subarray(offset, offset + payloadLength);
-        offset += payloadLength;
-        rows.push(JSON.parse(decoder.decode(payload)));
-    }
-    return 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