@syncular/core 0.1.2 → 0.2.0

package/dist/sync-packs.js

@@ -1,821 +0,0 @@
-/**
- * Binary sync-pack helpers.
- *
- * `binary-sync-pack-v1` removes the repeated JSON field-name envelope around
- * combined sync responses. Commit/subscription/snapshot protocol metadata is
- * encoded positionally, and incremental row bodies can be grouped into
- * generated binary table payloads when table encoders are available.
- *
- * Wire versions:
- * - v7: positional envelope with refs-only snapshot chunks, per-pack table and
- *   scope dictionaries, and grouped generated binary row payloads for
- *   incremental changes.
- * - v8: variant-tagged push and operation result records.
- * - v9: per-snapshot `bootstrapStateAfter` checkpoints for partial resume.
- * - v10: optional per-commit digest and chain-root verification metadata.
- * - v11: per-snapshot manifest metadata for chunk ordering/integrity.
- * - v12: per-commit partition id and previous chain root for canonical wire
- *   commit verification.
- * - v13: subscription-level integrity roots replace repeated per-commit root
- *   metadata.
- * - v14: snapshots can advertise scoped artifact refs.
- */
-import { decodeBinarySnapshotTable, } from './snapshot-chunks.js';
-export const SYNC_PACK_ENCODING_BINARY_V1 = 'binary-sync-pack-v1';
-export const SYNC_PACK_CONTENT_TYPE = 'application/vnd.syncular.sync-pack.v1';
-const MAGIC = new Uint8Array([0x53, 0x53, 0x50, 0x31]); // "SSP1"
-const VERSION = 14;
-const FLAG_NONE = 0;
-// Row-group framing carries table/schema overhead; small commits are
-// cheaper inline.
-const MIN_BINARY_CHANGE_ROW_GROUP_ROWS = 8;
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-export function isBinarySyncPackContentType(value) {
-    return value?.split(';', 1)[0]?.trim() === SYNC_PACK_CONTENT_TYPE;
-}
-export function encodeBinarySyncPack(response, options = {}) {
-    const writer = new BinarySyncPackWriter();
-    writer.bytes(MAGIC);
-    writer.u16(VERSION);
-    writer.u16(FLAG_NONE);
-    writer.bool(response.ok);
-    writer.optionalI32(response.requiredSchemaVersion);
-    writer.optionalI32(response.latestSchemaVersion);
-    writer.optionalValue(response.push, writePushResponse);
-    writer.optionalValue(response.pull, (nextWriter, pull) => writePullResponse(nextWriter, pull, options));
-    return writer.finish();
-}
-export function decodeBinarySyncPack(bytes) {
-    const reader = new BinarySyncPackReader(bytes);
-    reader.expectMagic(MAGIC, 'binary sync pack');
-    const version = reader.u16('binary sync pack version');
-    if (version !== VERSION) {
-        throw new Error(`Unsupported binary sync pack version: ${version}`);
-    }
-    const flags = reader.u16('binary sync pack flags');
-    if (flags !== FLAG_NONE) {
-        throw new Error(`Unsupported binary sync pack flags: ${flags}`);
-    }
-    const response = {
-        ok: reader.bool('combined response ok'),
-    };
-    const requiredSchemaVersion = reader.optionalI32('required schema version');
-    if (requiredSchemaVersion !== undefined) {
-        response.requiredSchemaVersion = requiredSchemaVersion;
-    }
-    const latestSchemaVersion = reader.optionalI32('latest schema version');
-    if (latestSchemaVersion !== undefined) {
-        response.latestSchemaVersion = latestSchemaVersion;
-    }
-    const push = reader.optionalValue(readPushResponse);
-    if (push)
-        response.push = push;
-    const pull = reader.optionalValue(readPullResponse);
-    if (pull)
-        response.pull = pull;
-    reader.assertDone();
-    return response;
-}
-function writePushResponse(writer, push) {
-    writer.bool(push.ok);
-    writer.array(push.commits, writePushCommitResponse);
-}
-function readPushResponse(reader) {
-    return {
-        ok: reader.bool('push response ok'),
-        commits: reader.array('push commits', readPushCommitResponse),
-    };
-}
-function writePushCommitResponse(writer, commit) {
-    writer.bool(commit.ok);
-    writer.string32(commit.clientCommitId);
-    writer.u8(pushCommitStatusByte(commit.status));
-    writer.optionalI64(commit.commitSeq);
-    writer.array(commit.results, writeOperationResult);
-}
-function readPushCommitResponse(reader) {
-    const commit = {
-        ok: reader.bool('push commit ok'),
-        clientCommitId: reader.string32('push client commit id'),
-        status: readPushCommitStatus(reader),
-        results: [],
-    };
-    const commitSeq = reader.optionalI64('push commit seq');
-    if (commitSeq !== undefined)
-        commit.commitSeq = commitSeq;
-    commit.results = reader.array('push operation results', readOperationResult);
-    return commit;
-}
-function pushCommitStatusByte(status) {
-    switch (status) {
-        case 'applied':
-            return 1;
-        case 'cached':
-            return 2;
-        case 'rejected':
-            return 3;
-    }
-}
-function readPushCommitStatus(reader) {
-    const status = reader.u8('push commit status');
-    switch (status) {
-        case 1:
-            return 'applied';
-        case 2:
-            return 'cached';
-        case 3:
-            return 'rejected';
-        default:
-            throw new Error(`Unsupported push commit status byte: ${status}`);
-    }
-}
-function operationResultStatusByte(status) {
-    switch (status) {
-        case 'applied':
-            return 1;
-        case 'conflict':
-            return 2;
-        case 'error':
-            return 3;
-    }
-}
-function writeOperationResult(writer, result) {
-    writer.i32(result.opIndex);
-    writer.u8(operationResultStatusByte(result.status));
-    switch (result.status) {
-        case 'applied':
-            return;
-        case 'conflict':
-            writer.string32(result.message);
-            writer.optionalString32(result.code);
-            writer.i64(result.server_version);
-            writer.json(result.server_row);
-            return;
-        case 'error':
-            writer.string32(result.error);
-            writer.optionalString32(result.code);
-            writer.optionalBool(result.retriable);
-            return;
-    }
-}
-function readOperationResult(reader) {
-    const opIndex = reader.i32('operation result index');
-    const status = reader.u8('operation result status');
-    switch (status) {
-        case 1:
-            return { opIndex, status: 'applied' };
-        case 2: {
-            const message = reader.string32('operation result conflict message');
-            const code = reader.optionalString32('operation result conflict code');
-            const serverVersion = reader.i64('operation result conflict server version');
-            const serverRow = reader.json('operation result conflict server row');
-            return {
-                opIndex,
-                status: 'conflict',
-                message,
-                ...(code !== undefined ? { code } : {}),
-                server_version: serverVersion,
-                server_row: serverRow,
-            };
-        }
-        case 3: {
-            const error = reader.string32('operation result error message');
-            const code = reader.optionalString32('operation result error code');
-            const retriable = reader.optionalBool('operation result error retriable');
-            return {
-                opIndex,
-                status: 'error',
-                error,
-                ...(code !== undefined ? { code } : {}),
-                ...(retriable !== undefined ? { retriable } : {}),
-            };
-        }
-        default:
-            throw new Error(`Unsupported operation result status byte: ${status}`);
-    }
-}
-function writePullResponse(writer, pull, options) {
-    writer.bool(pull.ok);
-    writer.array(pull.subscriptions, (nextWriter, subscription) => writeSubscriptionResponse(nextWriter, subscription, options));
-}
-function readPullResponse(reader) {
-    return {
-        ok: reader.bool('pull response ok'),
-        subscriptions: reader.array('pull subscriptions', readSubscriptionResponse),
-    };
-}
-function writeSubscriptionResponse(writer, subscription, options) {
-    writer.string32(subscription.id);
-    writer.string16(subscription.status);
-    writer.json(subscription.scopes);
-    writer.bool(subscription.bootstrap);
-    writer.optionalJson(subscription.bootstrapState ?? undefined);
-    writer.i64(subscription.nextCursor);
-    writer.optionalValue(subscription.integrity, writeSubscriptionIntegrity);
-    writer.array(subscription.commits, (nextWriter, commit) => writeCommit(nextWriter, commit, options));
-    writer.optionalArray(subscription.snapshots, writeSnapshot);
-}
-function readSubscriptionResponse(reader) {
-    const subscription = {
-        id: reader.string32('subscription id'),
-        status: reader.string16('subscription status'),
-        scopes: reader.json('subscription scopes'),
-        bootstrap: reader.bool('subscription bootstrap'),
-        nextCursor: 0,
-        commits: [],
-    };
-    const bootstrapState = reader.optionalJson('subscription bootstrap state');
-    subscription.bootstrapState =
-        bootstrapState ?? null;
-    subscription.nextCursor = reader.i64('subscription next cursor');
-    const integrity = reader.optionalValue(readSubscriptionIntegrity);
-    if (integrity)
-        subscription.integrity = integrity;
-    subscription.commits = reader.array('subscription commits', readCommit);
-    const snapshots = reader.optionalArray('subscription snapshots', readSnapshot);
-    if (snapshots)
-        subscription.snapshots = snapshots;
-    return subscription;
-}
-function writeSubscriptionIntegrity(writer, integrity) {
-    writer.string32(integrity.partitionId);
-    writer.string32(integrity.previousChainRoot);
-    writer.string32(integrity.commitChainRoot);
-    writer.i64(integrity.commitSeq);
-}
-function readSubscriptionIntegrity(reader) {
-    return {
-        partitionId: reader.string32('subscription integrity partitionId'),
-        previousChainRoot: reader.string32('subscription integrity previous chain root'),
-        commitChainRoot: reader.string32('subscription integrity chain root'),
-        commitSeq: reader.i64('subscription integrity commit seq'),
-    };
-}
-function writeCommit(writer, commit, options) {
-    writer.i64(commit.commitSeq);
-    writer.string32(commit.createdAt);
-    writer.string32(commit.actorId);
-    writeChanges(writer, commit.changes, options);
-}
-function readCommit(reader) {
-    const commit = {
-        commitSeq: reader.i64('commit seq'),
-        createdAt: reader.string32('commit createdAt'),
-        actorId: reader.string32('commit actorId'),
-        changes: [],
-    };
-    commit.changes = readChangesV8(reader);
-    return commit;
-}
-function writeChanges(writer, changes, options) {
-    const encodedRowCountsByTable = new Map();
-    const tableIndexesByName = new Map();
-    const tableNames = [];
-    const scopeIndexesByKey = new Map();
-    const singleScopeIndexesByName = new Map();
-    const scopeValuesByIndex = [];
-    const tableIndexFor = (table) => {
-        let tableIndex = tableIndexesByName.get(table);
-        if (tableIndex !== undefined)
-            return tableIndex;
-        tableIndex = tableNames.length;
-        tableIndexesByName.set(table, tableIndex);
-        tableNames.push(table);
-        return tableIndex;
-    };
-    const scopeIndexFor = (scopes) => {
-        const entries = Object.entries(scopes);
-        if (entries.length === 1) {
-            const [scopeName, scopeValue] = entries[0];
-            let indexesByValue = singleScopeIndexesByName.get(scopeName);
-            if (!indexesByValue) {
-                indexesByValue = new Map();
-                singleScopeIndexesByName.set(scopeName, indexesByValue);
-            }
-            let scopeIndex = indexesByValue.get(scopeValue);
-            if (scopeIndex !== undefined)
-                return scopeIndex;
-            scopeIndex = scopeValuesByIndex.length;
-            indexesByValue.set(scopeValue, scopeIndex);
-            scopeValuesByIndex.push(scopes);
-            return scopeIndex;
-        }
-        const key = scopeDictionaryKey(entries);
-        let scopeIndex = scopeIndexesByKey.get(key);
-        if (scopeIndex !== undefined)
-            return scopeIndex;
-        scopeIndex = scopeValuesByIndex.length;
-        scopeIndexesByKey.set(key, scopeIndex);
-        scopeValuesByIndex.push(scopes);
-        return scopeIndex;
-    };
-    const tableIndexesByChange = [];
-    const scopeIndexesByChange = [];
-    for (let index = 0; index < changes.length; index += 1) {
-        const change = changes[index];
-        tableIndexesByChange[index] = tableIndexFor(change.table);
-        scopeIndexesByChange[index] = scopeIndexFor(change.scopes);
-        if (change.op === 'delete' || change.row_json == null)
-            continue;
-        if (!options.changeRowEncoders?.[change.table])
-            continue;
-        encodedRowCountsByTable.set(change.table, (encodedRowCountsByTable.get(change.table) ?? 0) + 1);
-    }
-    const rowRefs = new Map();
-    const groups = [];
-    const groupIndexesByTable = new Map();
-    for (let index = 0; index < changes.length; index += 1) {
-        const change = changes[index];
-        if (change.op === 'delete' || change.row_json == null)
-            continue;
-        const encoder = options.changeRowEncoders?.[change.table];
-        if (!encoder)
-            continue;
-        if ((encodedRowCountsByTable.get(change.table) ?? 0) <
-            MIN_BINARY_CHANGE_ROW_GROUP_ROWS) {
-            continue;
-        }
-        let groupIndex = groupIndexesByTable.get(change.table);
-        if (groupIndex === undefined) {
-            groupIndex = groups.length;
-            groupIndexesByTable.set(change.table, groupIndex);
-            groups.push({
-                table: change.table,
-                tableIndex: tableIndexesByChange[index],
-                encoder,
-                rows: [],
-            });
-        }
-        const group = groups[groupIndex];
-        const rowIndex = group.rows.length;
-        group.rows.push(change.row_json);
-        rowRefs.set(index, { groupIndex, rowIndex });
-    }
-    writer.array(tableNames, (nextWriter, table) => nextWriter.string16(table));
-    writer.array(scopeValuesByIndex, (nextWriter, scopes) => nextWriter.stringMap(scopes));
-    writer.u32(changes.length);
-    for (let index = 0; index < changes.length; index += 1) {
-        const change = changes[index];
-        writeChangeMetadataV8(writer, change, tableIndexesByChange[index], scopeIndexesByChange[index], rowRefs.get(index));
-    }
-    writer.u32(groups.length);
-    for (const group of groups) {
-        writer.u16(group.tableIndex);
-        writer.bytes32(group.encoder(group.rows));
-    }
-}
-function writeChangeMetadataV8(writer, change, tableIndex, scopeIndex, rowRef) {
-    writer.u16(tableIndex);
-    writer.string32(change.row_id);
-    writer.u8(change.op === 'upsert' ? 1 : 2);
-    if (change.row_json == null) {
-        writer.u8(0);
-    }
-    else if (rowRef) {
-        writer.u8(2);
-        writer.u32(rowRef.groupIndex);
-        writer.u32(rowRef.rowIndex);
-    }
-    else {
-        writer.u8(1);
-        writer.json(change.row_json);
-    }
-    writer.optionalI64(change.row_version ?? undefined);
-    writer.u32(scopeIndex);
-}
-function readChangesV8(reader) {
-    const tableNames = reader.array('commit change table dictionary', (reader) => reader.string16('commit change table'));
-    const scopeValuesByIndex = reader.array('commit change scope dictionary', (reader) => reader.stringMap('commit change scopes'));
-    const changeCount = reader.u32('commit changes length');
-    const changes = [];
-    const rowRefs = [];
-    for (let index = 0; index < changeCount; index += 1) {
-        const change = readChangeMetadataV8(reader, index, tableNames, scopeValuesByIndex, rowRefs);
-        changes.push(change);
-    }
-    const groupCount = reader.u32('binary change row group count');
-    const groupRows = new Map();
-    for (let groupIndex = 0; groupIndex < groupCount; groupIndex += 1) {
-        const table = tableNameAt(tableNames, reader.u16('binary change row group table index'));
-        const decoded = decodeBinarySnapshotTable(reader.bytes32('binary change row group payload'));
-        if (decoded.table !== table) {
-            throw new Error(`Binary sync pack row group table mismatch: expected ${table}, got ${decoded.table}`);
-        }
-        groupRows.set(groupIndex, decoded.rows);
-    }
-    for (const ref of rowRefs) {
-        const rows = groupRows.get(ref.groupIndex);
-        const row = rows?.[ref.rowIndex];
-        if (!row) {
-            throw new Error(`Binary sync pack change row ref is invalid: group=${ref.groupIndex}, row=${ref.rowIndex}`);
-        }
-        if (changes[ref.changeIndex]?.table !== ref.table) {
-            throw new Error('Binary sync pack row ref table mismatch');
-        }
-        changes[ref.changeIndex].row_json = row;
-    }
-    return changes;
-}
-function readChangeMetadataV8(reader, changeIndex, tableNames, scopeValuesByIndex, rowRefs) {
-    const table = tableNameAt(tableNames, reader.u16('change table index'));
-    const rowId = reader.string32('change row id');
-    const opByte = reader.u8('change op');
-    if (opByte !== 1 && opByte !== 2) {
-        throw new Error(`Unsupported binary sync pack change op byte: ${opByte}`);
-    }
-    let rowJson = null;
-    const rowPayloadKind = reader.u8('change row payload kind');
-    if (rowPayloadKind === 1) {
-        rowJson = reader.json('change row json');
-    }
-    else if (rowPayloadKind === 2) {
-        rowRefs.push({
-            changeIndex,
-            table,
-            groupIndex: reader.u32('change row group index'),
-            rowIndex: reader.u32('change row group row index'),
-        });
-    }
-    else if (rowPayloadKind !== 0) {
-        throw new Error(`Unsupported binary sync pack change row payload kind: ${rowPayloadKind}`);
-    }
-    return {
-        table,
-        row_id: rowId,
-        op: opByte === 1 ? 'upsert' : 'delete',
-        row_json: rowJson,
-        row_version: reader.optionalI64('change row version') ?? null,
-        scopes: scopeValuesAt(scopeValuesByIndex, reader.u32('change scopes index')),
-    };
-}
-function tableNameAt(tableNames, index) {
-    const table = tableNames[index];
-    if (table === undefined) {
-        throw new Error(`Binary sync pack table index is invalid: ${index}`);
-    }
-    return table;
-}
-function scopeValuesAt(scopeValuesByIndex, index) {
-    const scopes = scopeValuesByIndex[index];
-    if (scopes === undefined) {
-        throw new Error(`Binary sync pack scope index is invalid: ${index}`);
-    }
-    return { ...scopes };
-}
-function scopeDictionaryKey(entries) {
-    let count = 0;
-    let body = '';
-    for (const [scopeName, scopeValue] of entries) {
-        count += 1;
-        body += `${scopeName.length}:${scopeName}${scopeValue.length}:${scopeValue}`;
-    }
-    return `${count}|${body}`;
-}
-function writeSnapshot(writer, snapshot) {
-    writer.string16(snapshot.table);
-    writer.array(snapshot.rows, (nextWriter, row) => nextWriter.json(row));
-    writer.optionalArray(snapshot.chunks, writeSnapshotChunkRef);
-    writer.bool(snapshot.isFirstPage);
-    writer.bool(snapshot.isLastPage);
-    writer.optionalJson(snapshot.bootstrapStateAfter ?? undefined);
-    writer.optionalJson(snapshot.manifest ?? undefined);
-    writer.optionalJson(snapshot.artifacts ?? undefined);
-}
-function readSnapshot(reader) {
-    const snapshot = {
-        table: reader.string16('snapshot table'),
-        rows: reader.array('snapshot rows', (nextReader) => nextReader.json('snapshot row')),
-        isFirstPage: false,
-        isLastPage: false,
-    };
-    const chunks = reader.optionalArray('snapshot chunks', readSnapshotChunkRef);
-    if (chunks)
-        snapshot.chunks = chunks;
-    snapshot.isFirstPage = reader.bool('snapshot first page');
-    snapshot.isLastPage = reader.bool('snapshot last page');
-    snapshot.bootstrapStateAfter =
-        reader.optionalJson('snapshot bootstrap state after') ?? null;
-    const manifest = reader.optionalJson('snapshot manifest');
-    if (manifest !== undefined)
-        snapshot.manifest = manifest;
-    const artifacts = reader.optionalJson('snapshot artifacts');
-    if (artifacts !== undefined)
-        snapshot.artifacts = artifacts;
-    return snapshot;
-}
-function writeSnapshotChunkRef(writer, chunk) {
-    writer.string32(chunk.id);
-    writer.i64(chunk.byteLength);
-    writer.string16(chunk.sha256);
-    writer.string16(chunk.encoding);
-    writer.string16(chunk.compression);
-}
-function readSnapshotChunkRef(reader) {
-    return {
-        id: reader.string32('snapshot chunk id'),
-        byteLength: reader.i64('snapshot chunk byte length'),
-        sha256: reader.string16('snapshot chunk sha256'),
-        encoding: reader.string16('snapshot chunk encoding'),
-        compression: reader.string16('snapshot chunk compression'),
-    };
-}
-class BinarySyncPackWriter {
-    bytesOut;
-    view;
-    offset = 0;
-    constructor(initialCapacity = 1024) {
-        this.bytesOut = new Uint8Array(Math.max(64, initialCapacity));
-        this.view = new DataView(this.bytesOut.buffer, this.bytesOut.byteOffset, this.bytesOut.length);
-    }
-    finish() {
-        return this.bytesOut.subarray(0, this.offset);
-    }
-    bytes(value) {
-        this.ensure(value.length);
-        this.bytesOut.set(value, this.offset);
-        this.offset += value.length;
-    }
-    bool(value) {
-        this.u8(value ? 1 : 0);
-    }
-    optionalBool(value) {
-        this.optionalValue(value, (writer, nextValue) => writer.bool(nextValue));
-    }
-    u8(value) {
-        this.ensure(1);
-        this.view.setUint8(this.offset, value);
-        this.offset += 1;
-    }
-    u16(value) {
-        assertUnsigned(value, 0xffff, 'uint16');
-        this.ensure(2);
-        this.view.setUint16(this.offset, value, true);
-        this.offset += 2;
-    }
-    u32(value) {
-        assertUnsigned(value, 0xffff_ffff, 'uint32');
-        this.ensure(4);
-        this.view.setUint32(this.offset, value, true);
-        this.offset += 4;
-    }
-    i32(value) {
-        assertSigned(value, -0x8000_0000, 0x7fff_ffff, 'int32');
-        this.ensure(4);
-        this.view.setInt32(this.offset, value, true);
-        this.offset += 4;
-    }
-    optionalI32(value) {
-        this.optionalValue(value, (writer, nextValue) => writer.i32(nextValue));
-    }
-    i64(value) {
-        if (!Number.isSafeInteger(value)) {
-            throw new Error('int64 value must be a safe integer');
-        }
-        this.ensure(8);
-        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);
-        }
-        this.offset += 8;
-    }
-    optionalI64(value) {
-        this.optionalValue(value ?? undefined, (writer, nextValue) => writer.i64(nextValue));
-    }
-    string16(value) {
-        if (this.writeAsciiString16(value))
-            return;
-        const bytes = textEncoder.encode(value);
-        this.u16(bytes.length);
-        this.bytes(bytes);
-    }
-    string32(value) {
-        if (this.writeAsciiString32(value))
-            return;
-        const bytes = textEncoder.encode(value);
-        this.u32(bytes.length);
-        this.bytes(bytes);
-    }
-    optionalString32(value) {
-        this.optionalValue(value, (writer, nextValue) => writer.string32(nextValue));
-    }
-    bytes32(value) {
-        this.u32(value.length);
-        this.bytes(value);
-    }
-    json(value) {
-        this.string32(JSON.stringify(value) ?? 'null');
-    }
-    stringMap(value) {
-        const entries = Object.entries(value);
-        this.u32(entries.length);
-        for (const [key, nextValue] of entries) {
-            this.string16(key);
-            this.string32(nextValue);
-        }
-    }
-    optionalJson(value) {
-        this.optionalValue(value, (writer, nextValue) => writer.json(nextValue));
-    }
-    array(values, write) {
-        this.u32(values.length);
-        for (const value of values) {
-            write(this, value);
-        }
-    }
-    optionalArray(values, write) {
-        this.optionalValue(values, (writer, nextValues) => writer.array(nextValues, write));
-    }
-    optionalValue(value, write) {
-        if (value === undefined) {
-            this.u8(0);
-            return;
-        }
-        this.u8(1);
-        write(this, value);
-    }
-    ensure(length) {
-        const required = this.offset + length;
-        if (required <= this.bytesOut.length)
-            return;
-        let nextLength = this.bytesOut.length;
-        while (nextLength < required) {
-            nextLength *= 2;
-        }
-        const next = new Uint8Array(nextLength);
-        next.set(this.bytesOut, 0);
-        this.bytesOut = next;
-        this.view = new DataView(this.bytesOut.buffer, this.bytesOut.byteOffset, this.bytesOut.length);
-    }
-    writeAsciiString16(value) {
-        assertUnsigned(value.length, 0xffff, 'uint16');
-        const start = this.offset;
-        this.u16(value.length);
-        return this.tryWriteAsciiBytes(value, start);
-    }
-    writeAsciiString32(value) {
-        assertUnsigned(value.length, 0xffff_ffff, 'uint32');
-        const start = this.offset;
-        this.u32(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.bytesOut[this.offset + index] = code;
-        }
-        this.offset += value.length;
-        return true;
-    }
-}
-class BinarySyncPackReader {
-    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.bytesSlice(magic.length, `${label} magic`);
-        for (let index = 0; index < magic.length; index += 1) {
-            if (actual[index] !== magic[index]) {
-                throw new Error(`Unexpected ${label} magic`);
-            }
-        }
-    }
-    bool(label) {
-        const value = this.u8(label);
-        if (value !== 0 && value !== 1) {
-            throw new Error(`${label} expected boolean byte`);
-        }
-        return value === 1;
-    }
-    optionalBool(label) {
-        return this.optionalValue((reader) => reader.bool(label));
-    }
-    u8(label) {
-        this.require(1, label);
-        const value = this.view.getUint8(this.offset);
-        this.offset += 1;
-        return value;
-    }
-    u16(label) {
-        this.require(2, label);
-        const value = this.view.getUint16(this.offset, true);
-        this.offset += 2;
-        return value;
-    }
-    u32(label) {
-        this.require(4, label);
-        const value = this.view.getUint32(this.offset, true);
-        this.offset += 4;
-        return value;
-    }
-    i32(label) {
-        this.require(4, label);
-        const value = this.view.getInt32(this.offset, true);
-        this.offset += 4;
-        return value;
-    }
-    optionalI32(label) {
-        return this.optionalValue((reader) => reader.i32(label));
-    }
-    i64(label) {
-        this.require(8, label);
-        const value = this.view.getBigInt64(this.offset, true);
-        this.offset += 8;
-        const asNumber = Number(value);
-        if (!Number.isSafeInteger(asNumber) || BigInt(asNumber) !== value) {
-            throw new Error(`${label} exceeds JavaScript safe integer bounds`);
-        }
-        return asNumber;
-    }
-    optionalI64(label) {
-        return this.optionalValue((reader) => reader.i64(label));
-    }
-    string16(label) {
-        const length = this.u16(`${label} length`);
-        return textDecoder.decode(this.bytesSlice(length, label));
-    }
-    string32(label) {
-        const length = this.u32(`${label} length`);
-        return textDecoder.decode(this.bytesSlice(length, label));
-    }
-    optionalString32(label) {
-        return this.optionalValue((reader) => reader.string32(label));
-    }
-    bytes32(label) {
-        const length = this.u32(`${label} length`);
-        return this.bytesSlice(length, label);
-    }
-    json(label) {
-        return JSON.parse(this.string32(label));
-    }
-    stringMap(label) {
-        const length = this.u32(`${label} length`);
-        const out = {};
-        for (let index = 0; index < length; index += 1) {
-            out[this.string16(`${label} key`)] = this.string32(`${label} value`);
-        }
-        return out;
-    }
-    optionalJson(label) {
-        return this.optionalValue((reader) => reader.json(label));
-    }
-    array(label, read) {
-        const length = this.u32(`${label} length`);
-        const values = [];
-        for (let index = 0; index < length; index += 1) {
-            values.push(read(this));
-        }
-        return values;
-    }
-    optionalArray(label, read) {
-        return this.optionalValue((reader) => reader.array(label, read));
-    }
-    optionalValue(read) {
-        const present = this.u8('optional value present');
-        if (present === 0)
-            return undefined;
-        if (present !== 1) {
-            throw new Error(`Optional value marker must be 0 or 1, got ${present}`);
-        }
-        return read(this);
-    }
-    bytesSlice(length, label) {
-        this.require(length, label);
-        const value = this.bytes.subarray(this.offset, this.offset + length);
-        this.offset += length;
-        return value;
-    }
-    assertDone() {
-        if (this.offset !== this.bytes.length) {
-            throw new Error('Binary sync pack has trailing bytes');
-        }
-    }
-    require(length, label) {
-        if (this.offset + length > this.bytes.length) {
-            throw new Error(`${label} exceeds binary sync pack bounds`);
-        }
-    }
-}
-function assertUnsigned(value, max, label) {
-    if (!Number.isInteger(value) || value < 0 || value > max) {
-        throw new Error(`${label} value is out of range`);
-    }
-}
-function assertSigned(value, min, max, label) {
-    if (!Number.isInteger(value) || value < min || value > max) {
-        throw new Error(`${label} value is out of range`);
-    }
-}
-//# sourceMappingURL=sync-packs.js.map