@rocicorp/zero 0.2.2024101101 → 0.3.2024102500

package/out/replicache/src/dag/store-impl.js

@@ -0,0 +1,175 @@
+import { assertNumber } from '../../../shared/src/asserts.js';
+import { assertHash } from '../hash.js';
+import { Chunk, assertRefs, createChunk, } from './chunk.js';
+import { computeRefCountUpdates } from './gc.js';
+import { chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey } from './key.js';
+import { mustGetChunk } from './store.js';
+export class StoreImpl {
+    #kv;
+    #chunkHasher;
+    #assertValidHash;
+    constructor(kv, chunkHasher, assertValidHash) {
+        this.#kv = kv;
+        this.#chunkHasher = chunkHasher;
+        this.#assertValidHash = assertValidHash;
+    }
+    async read() {
+        return new ReadImpl(await this.#kv.read(), this.#assertValidHash);
+    }
+    async write() {
+        return new WriteImpl(await this.#kv.write(), this.#chunkHasher, this.#assertValidHash);
+    }
+    close() {
+        return this.#kv.close();
+    }
+}
+export class ReadImpl {
+    _tx;
+    assertValidHash;
+    constructor(kv, assertValidHash) {
+        this._tx = kv;
+        this.assertValidHash = assertValidHash;
+    }
+    hasChunk(hash) {
+        return this._tx.has(chunkDataKey(hash));
+    }
+    async getChunk(hash) {
+        const data = await this._tx.get(chunkDataKey(hash));
+        if (data === undefined) {
+            return undefined;
+        }
+        const refsVal = await this._tx.get(chunkMetaKey(hash));
+        let refs;
+        if (refsVal !== undefined) {
+            assertRefs(refsVal);
+            refs = refsVal;
+        }
+        else {
+            refs = [];
+        }
+        return new Chunk(hash, data, refs);
+    }
+    mustGetChunk(hash) {
+        return mustGetChunk(this, hash);
+    }
+    async getHead(name) {
+        const data = await this._tx.get(headKey(name));
+        if (data === undefined) {
+            return undefined;
+        }
+        assertHash(data);
+        return data;
+    }
+    release() {
+        this._tx.release();
+    }
+    get closed() {
+        return this._tx.closed;
+    }
+}
+export class WriteImpl extends ReadImpl {
+    #chunkHasher;
+    #putChunks = new Set();
+    #changedHeads = new Map();
+    constructor(kvw, chunkHasher, assertValidHash) {
+        super(kvw, assertValidHash);
+        this.#chunkHasher = chunkHasher;
+    }
+    createChunk = (data, refs) => createChunk(data, refs, this.#chunkHasher);
+    get kvWrite() {
+        return this._tx;
+    }
+    async putChunk(c) {
+        const { hash, data, meta } = c;
+        // We never want to write temp hashes to the underlying store.
+        this.assertValidHash(hash);
+        const key = chunkDataKey(hash);
+        // Commit contains InternalValue and Hash which are opaque types.
+        const p1 = this._tx.put(key, data);
+        let p2;
+        if (meta.length > 0) {
+            for (const h of meta) {
+                this.assertValidHash(h);
+            }
+            p2 = this._tx.put(chunkMetaKey(hash), meta);
+        }
+        this.#putChunks.add(hash);
+        await p1;
+        await p2;
+    }
+    setHead(name, hash) {
+        return this.#setHead(name, hash);
+    }
+    removeHead(name) {
+        return this.#setHead(name, undefined);
+    }
+    async #setHead(name, hash) {
+        const oldHash = await this.getHead(name);
+        const hk = headKey(name);
+        let p1;
+        if (hash === undefined) {
+            p1 = this._tx.del(hk);
+        }
+        else {
+            p1 = this._tx.put(hk, hash);
+        }
+        const v = this.#changedHeads.get(name);
+        if (v === undefined) {
+            this.#changedHeads.set(name, { new: hash, old: oldHash });
+        }
+        else {
+            // Keep old if existing
+            v.new = hash;
+        }
+        await p1;
+    }
+    async commit() {
+        const refCountUpdates = await computeRefCountUpdates(this.#changedHeads.values(), this.#putChunks, this);
+        await this.#applyRefCountUpdates(refCountUpdates);
+        await this._tx.commit();
+    }
+    async getRefCount(hash) {
+        const value = await this._tx.get(chunkRefCountKey(hash));
+        if (value === undefined) {
+            return undefined;
+        }
+        assertNumber(value);
+        if (value < 0 || value > 0xffff || value !== (value | 0)) {
+            throw new Error(`Invalid ref count ${value}. We expect the value to be a Uint16`);
+        }
+        return value;
+    }
+    async getRefs(hash) {
+        const meta = await this._tx.get(chunkMetaKey(hash));
+        if (meta === undefined) {
+            return [];
+        }
+        assertRefs(meta);
+        return meta;
+    }
+    async #applyRefCountUpdates(refCountCache) {
+        const ps = [];
+        for (const [hash, count] of refCountCache) {
+            if (count === 0) {
+                ps.push(this.#removeAllRelatedKeys(hash));
+            }
+            else {
+                const refCountKey = chunkRefCountKey(hash);
+                ps.push(this._tx.put(refCountKey, count));
+            }
+        }
+        await Promise.all(ps);
+    }
+    async #removeAllRelatedKeys(hash) {
+        await Promise.all([
+            this._tx.del(chunkDataKey(hash)),
+            this._tx.del(chunkMetaKey(hash)),
+            this._tx.del(chunkRefCountKey(hash)),
+        ]);
+        this.#putChunks.delete(hash);
+    }
+    release() {
+        this._tx.release();
+    }
+}
+//# sourceMappingURL=store-impl.js.map

package/out/replicache/src/dag/store-impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-impl.js","sourceRoot":"","sources":["../../../../../replicache/src/dag/store-impl.ts"],"names":[],"mappings":"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"}

package/out/replicache/src/dag/store.js

@@ -0,0 +1,22 @@
+import { assert } from '../../../shared/src/asserts.js';
+export class ChunkNotFoundError extends Error {
+    name = 'ChunkNotFoundError';
+    hash;
+    constructor(hash) {
+        super(`Chunk not found ${hash}`);
+        this.hash = hash;
+    }
+}
+export async function mustGetChunk(store, hash) {
+    const chunk = await store.getChunk(hash);
+    if (chunk) {
+        return chunk;
+    }
+    throw new ChunkNotFoundError(hash);
+}
+export async function mustGetHeadHash(name, store) {
+    const hash = await store.getHead(name);
+    assert(hash, `Missing head ${name}`);
+    return hash;
+}
+//# sourceMappingURL=store.js.map

package/out/replicache/src/dag/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../../replicache/src/dag/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,gCAAgC,CAAC;AAkCtD,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3C,IAAI,GAAG,oBAAoB,CAAC;IACnB,IAAI,CAAO;IACpB,YAAY,IAAU;QACpB,KAAK,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAED,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,KAAe,EACf,IAAU;IAEV,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,IAAI,kBAAkB,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,IAAY,EACZ,KAAW;IAEX,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,MAAM,CAAC,IAAI,EAAE,gBAAgB,IAAI,EAAE,CAAC,CAAC;IACrC,OAAO,IAAI,CAAC;AACd,CAAC"}

package/out/replicache/src/dag/visitor.js

@@ -0,0 +1,22 @@
+/**
+ * A visitor walks the DAG starting at a given root and visits each chunk.
+ */
+export class Visitor {
+    #seen = new Set();
+    #dagRead;
+    constructor(dagRead) {
+        this.#dagRead = dagRead;
+    }
+    async visit(h) {
+        if (this.#seen.has(h)) {
+            return;
+        }
+        this.#seen.add(h);
+        const chunk = await this.#dagRead.mustGetChunk(h);
+        await this.visitChunk(chunk);
+    }
+    async visitChunk(chunk) {
+        await Promise.all(chunk.meta.map(ref => this.visit(ref)));
+    }
+}
+//# sourceMappingURL=visitor.js.map

package/out/replicache/src/dag/visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.js","sourceRoot":"","sources":["../../../../../replicache/src/dag/visitor.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,OAAO,OAAO;IAClB,KAAK,GAAc,IAAI,GAAG,EAAE,CAAC;IAC7B,QAAQ,CAAe;IAEvB,YAAY,OAAqB;QAC/B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,CAAO;QACjB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAClB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAClD,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,KAAqB;QACpC,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;CACF"}

package/out/replicache/src/db/commit.js

@@ -0,0 +1,443 @@
+import { assert, assertArray, assertBoolean, assertNumber, assertObject, assertString, unreachable, } from '../../../shared/src/asserts.js';
+import { assertJSONValue } from '../../../shared/src/json.js';
+import { skipCommitDataAsserts } from '../config.js';
+import { compareCookies } from '../cookies.js';
+import { toRefs } from '../dag/chunk.js';
+import { mustGetHeadHash } from '../dag/store.js';
+import { assertDeepFrozen, deepFreeze, } from '../frozen-json.js';
+import { assertHash } from '../hash.js';
+import * as MetaType from './meta-type-enum.js';
+export const DEFAULT_HEAD_NAME = 'main';
+export function commitIsLocalSDD(commit) {
+    return isLocalMetaSDD(commit.meta);
+}
+export function commitIsLocalDD31(commit) {
+    return isLocalMetaDD31(commit.meta);
+}
+export function commitIsLocal(commit) {
+    return commitIsLocalDD31(commit) || commitIsLocalSDD(commit);
+}
+function commitIsSnapshotDD31(commit) {
+    return isSnapshotMetaDD31(commit.meta);
+}
+function commitIsSnapshotSDD(commit) {
+    return isSnapshotMetaSDD(commit.meta);
+}
+export function commitIsSnapshot(commit) {
+    return commitIsSnapshotDD31(commit) || commitIsSnapshotSDD(commit);
+}
+export class Commit {
+    chunk;
+    constructor(chunk) {
+        this.chunk = chunk;
+    }
+    get meta() {
+        return this.chunk.data.meta;
+    }
+    get valueHash() {
+        // Already validated!
+        return this.chunk.data.valueHash;
+    }
+    getMutationID(clientID, dagRead) {
+        return getMutationID(clientID, dagRead, this.meta);
+    }
+    async getNextMutationID(clientID, dagRead) {
+        return (await this.getMutationID(clientID, dagRead)) + 1;
+    }
+    get indexes() {
+        // Already validated!
+        return this.chunk.data.indexes;
+    }
+}
+export async function getMutationID(clientID, dagRead, meta) {
+    switch (meta.type) {
+        case MetaType.IndexChangeSDD:
+            return meta.lastMutationID;
+        case MetaType.SnapshotSDD:
+            return meta.lastMutationID;
+        case MetaType.SnapshotDD31:
+            return meta.lastMutationIDs[clientID] ?? 0;
+        case MetaType.LocalSDD:
+            return meta.mutationID;
+        case MetaType.LocalDD31: {
+            if (meta.clientID === clientID) {
+                return meta.mutationID;
+            }
+            const { basisHash } = meta;
+            const basisCommit = await commitFromHash(basisHash, dagRead);
+            return getMutationID(clientID, dagRead, basisCommit.meta);
+        }
+        default:
+            unreachable(meta);
+    }
+}
+/**
+ * Returns the set of local commits from the given `fromCommitHash` back to but not
+ * including its base snapshot. If `fromCommitHash` is a snapshot, the returned vector
+ * will be empty. When, as typical, `fromCommitHash` is the head of the default chain
+ * then the returned commits are the set of pending commits, ie the set of local commits
+ * that have not yet been pushed to the data layer.
+ *
+ * The vector of commits is returned in reverse chain order, that is, starting
+ * with the commit with hash `fromCommitHash` and walking backwards.
+ */
+export async function localMutations(fromCommitHash, dagRead) {
+    const commits = await commitChain(fromCommitHash, dagRead);
+    // Filter does not deal with type narrowing.
+    return commits.filter(c => commitIsLocal(c));
+}
+export async function localMutationsDD31(fromCommitHash, dagRead) {
+    const commits = await commitChain(fromCommitHash, dagRead);
+    // Filter does not deal with type narrowing.
+    return commits.filter(c => commitIsLocalDD31(c));
+}
+export async function localMutationsGreaterThan(commit, mutationIDLimits, dagRead) {
+    const commits = [];
+    const remainingMutationIDLimits = new Map(Object.entries(mutationIDLimits));
+    while (!commitIsSnapshot(commit) && remainingMutationIDLimits.size > 0) {
+        if (commitIsLocalDD31(commit)) {
+            const { meta } = commit;
+            const mutationIDLowerLimit = remainingMutationIDLimits.get(meta.clientID);
+            if (mutationIDLowerLimit !== undefined) {
+                if (meta.mutationID <= mutationIDLowerLimit) {
+                    remainingMutationIDLimits.delete(meta.clientID);
+                }
+                else {
+                    commits.push(commit);
+                }
+            }
+        }
+        const { basisHash } = commit.meta;
+        if (basisHash === null) {
+            throw new Error(`Commit ${commit.chunk.hash} has no basis`);
+        }
+        commit = await commitFromHash(basisHash, dagRead);
+    }
+    return commits;
+}
+export async function baseSnapshotFromHead(name, dagRead) {
+    const hash = await dagRead.getHead(name);
+    assert(hash, `Missing head ${name}`);
+    return baseSnapshotFromHash(hash, dagRead);
+}
+export async function baseSnapshotHashFromHash(hash, dagRead) {
+    return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;
+}
+export async function baseSnapshotFromHash(hash, dagRead) {
+    const commit = await commitFromHash(hash, dagRead);
+    return baseSnapshotFromCommit(commit, dagRead);
+}
+export async function baseSnapshotFromCommit(commit, dagRead) {
+    while (!commitIsSnapshot(commit)) {
+        const { meta } = commit;
+        if (isLocalMetaDD31(meta)) {
+            commit = await commitFromHash(meta.baseSnapshotHash, dagRead);
+        }
+        else {
+            const { basisHash } = meta;
+            if (basisHash === null) {
+                throw new Error(`Commit ${commit.chunk.hash} has no basis`);
+            }
+            commit = await commitFromHash(basisHash, dagRead);
+        }
+    }
+    return commit;
+}
+export function snapshotMetaParts(c, clientID) {
+    const m = c.meta;
+    if (isSnapshotMetaDD31(m)) {
+        const lmid = m.lastMutationIDs[clientID] ?? 0;
+        return [lmid, m.cookieJSON];
+    }
+    return [m.lastMutationID, m.cookieJSON];
+}
+export function compareCookiesForSnapshots(a, b) {
+    return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);
+}
+/**
+ * Returns all commits from the commit with fromCommitHash to its base snapshot,
+ * inclusive of both. Resulting vector is in chain-head-first order (so snapshot
+ * comes last).
+ */
+export async function commitChain(fromCommitHash, dagRead) {
+    let commit = await commitFromHash(fromCommitHash, dagRead);
+    const commits = [];
+    while (!commitIsSnapshot(commit)) {
+        const { meta } = commit;
+        const { basisHash } = meta;
+        if (basisHash === null) {
+            throw new Error(`Commit ${commit.chunk.hash} has no basis`);
+        }
+        commits.push(commit);
+        commit = await commitFromHash(basisHash, dagRead);
+    }
+    commits.push(commit);
+    return commits;
+}
+export async function commitFromHash(hash, dagRead) {
+    const chunk = await dagRead.mustGetChunk(hash);
+    return fromChunk(chunk);
+}
+export async function commitFromHead(name, dagRead) {
+    const hash = await mustGetHeadHash(name, dagRead);
+    return commitFromHash(hash, dagRead);
+}
+function assertIndexChangeMeta(v) {
+    // type already asserted
+    assertNumber(v.lastMutationID);
+    // Note: indexes are already validated for all commit types. Only additional
+    // things to validate are:
+    //   - lastMutationID is equal to the basis
+    //   - valueHash has not been changed
+    // However we don't have a write transaction this deep, so these validated at
+    // commit time.
+}
+export function assertIndexChangeCommit(c) {
+    assertIndexChangeMeta(c.meta);
+}
+function assertLocalMetaSDD(v) {
+    // type already asserted
+    assertNumber(v.mutationID);
+    assertString(v.mutatorName);
+    if (!v.mutatorName) {
+        throw new Error('Missing mutator name');
+    }
+    assertJSONValue(v.mutatorArgsJSON);
+    if (v.originalHash !== null) {
+        assertHash(v.originalHash);
+    }
+    assertNumber(v.timestamp);
+}
+export function assertLocalMetaDD31(v) {
+    // type already asserted
+    assertString(v.clientID);
+    assertLocalMetaSDD(v);
+}
+export function isLocalMetaDD31(meta) {
+    return meta.type === MetaType.LocalDD31;
+}
+function isLocalMetaSDD(meta) {
+    return meta.type === MetaType.LocalSDD;
+}
+export function assertLocalCommitDD31(c) {
+    assertLocalMetaDD31(c.meta);
+}
+export function assertLocalCommitSDD(c) {
+    assertLocalMetaSDD(c.meta);
+}
+function assertSnapshotMetaBase(v) {
+    // type already asserted
+    if (v.basisHash !== null) {
+        assertHash(v.basisHash);
+    }
+    assertJSONValue(v.cookieJSON);
+}
+export function assertSnapshotMetaSDD(v) {
+    assertSnapshotMetaBase(v);
+    assertNumber(v.lastMutationID);
+}
+export function assertSnapshotMetaDD31(v) {
+    assertSnapshotMetaBase(v);
+    assertLastMutationIDs(v.lastMutationIDs);
+}
+function assertLastMutationIDs(v) {
+    assertObject(v);
+    for (const e of Object.values(v)) {
+        assertNumber(e);
+    }
+}
+export function assertSnapshotCommitSDD(c) {
+    assertSnapshotMetaSDD(c.meta);
+}
+export function assertSnapshotCommitDD31(c) {
+    assertSnapshotMetaDD31(c.meta);
+}
+function isSnapshotMetaDD31(meta) {
+    return meta.type === MetaType.SnapshotDD31;
+}
+function isSnapshotMetaSDD(meta) {
+    return meta.type === MetaType.SnapshotSDD;
+}
+function assertMeta(v) {
+    assertObject(v);
+    assertDeepFrozen(v);
+    if (v.basisHash !== null) {
+        assertString(v.basisHash);
+    }
+    assertNumber(v.type);
+    switch (v.type) {
+        case MetaType.IndexChangeSDD:
+            assertIndexChangeMeta(v);
+            break;
+        case MetaType.LocalSDD:
+            assertLocalMetaSDD(v);
+            break;
+        case MetaType.LocalDD31:
+            assertLocalMetaDD31(v);
+            break;
+        case MetaType.SnapshotSDD:
+            assertSnapshotMetaSDD(v);
+            break;
+        case MetaType.SnapshotDD31:
+            assertSnapshotMetaDD31(v);
+            break;
+        default:
+            throw new Error(`Invalid enum value ${v.type}`);
+    }
+}
+export function chunkIndexDefinitionEqualIgnoreName(a, b) {
+    return (a.jsonPointer === b.jsonPointer &&
+        (a.allowEmpty ?? false) === (b.allowEmpty ?? false) &&
+        a.keyPrefix === b.keyPrefix);
+}
+function assertChunkIndexDefinition(v) {
+    assertObject(v);
+    assertDeepFrozen(v);
+    assertString(v.name);
+    assertString(v.keyPrefix);
+    assertString(v.jsonPointer);
+    if (v.allowEmpty !== undefined) {
+        assertBoolean(v.allowEmpty);
+    }
+}
+export function toChunkIndexDefinition(name, indexDefinition) {
+    return {
+        name,
+        keyPrefix: indexDefinition.prefix ?? '',
+        jsonPointer: indexDefinition.jsonPointer,
+        allowEmpty: indexDefinition.allowEmpty ?? false,
+    };
+}
+function assertIndexRecord(v) {
+    assertObject(v);
+    assertDeepFrozen(v);
+    assertChunkIndexDefinition(v.definition);
+    assertString(v.valueHash);
+}
+function assertIndexRecords(v) {
+    assertArray(v);
+    assertDeepFrozen(v);
+    for (const ir of v) {
+        assertIndexRecord(ir);
+    }
+}
+export function newLocalSDD(createChunk, basisHash, mutationID, mutatorName, mutatorArgsJSON, originalHash, valueHash, indexes, timestamp) {
+    const meta = {
+        type: MetaType.LocalSDD,
+        basisHash,
+        mutationID,
+        mutatorName,
+        mutatorArgsJSON,
+        originalHash,
+        timestamp,
+    };
+    return commitFromCommitData(createChunk, makeCommitData(meta, valueHash, indexes));
+}
+export function newLocalDD31(createChunk, basisHash, baseSnapshotHash, mutationID, mutatorName, mutatorArgsJSON, originalHash, valueHash, indexes, timestamp, clientID) {
+    const meta = {
+        type: MetaType.LocalDD31,
+        basisHash,
+        baseSnapshotHash,
+        mutationID,
+        mutatorName,
+        mutatorArgsJSON,
+        originalHash,
+        timestamp,
+        clientID,
+    };
+    return commitFromCommitData(createChunk, makeCommitData(meta, valueHash, indexes));
+}
+export function newSnapshotSDD(createChunk, basisHash, lastMutationID, cookieJSON, valueHash, indexes) {
+    return commitFromCommitData(createChunk, newSnapshotCommitDataSDD(basisHash, lastMutationID, cookieJSON, valueHash, indexes));
+}
+export function newSnapshotDD31(createChunk, basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
+    return commitFromCommitData(createChunk, newSnapshotCommitDataDD31(basisHash, lastMutationIDs, cookieJSON, valueHash, indexes));
+}
+export function newSnapshotCommitDataSDD(basisHash, lastMutationID, cookieJSON, valueHash, indexes) {
+    const meta = {
+        type: MetaType.SnapshotSDD,
+        basisHash,
+        lastMutationID,
+        cookieJSON,
+    };
+    return makeCommitData(meta, valueHash, indexes);
+}
+export function newSnapshotCommitDataDD31(basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
+    const meta = {
+        type: MetaType.SnapshotDD31,
+        basisHash,
+        lastMutationIDs,
+        cookieJSON,
+    };
+    return makeCommitData(meta, valueHash, indexes);
+}
+export function newIndexChange(createChunk, basisHash, lastMutationID, valueHash, indexes) {
+    const meta = {
+        type: MetaType.IndexChangeSDD,
+        basisHash,
+        lastMutationID,
+    };
+    return commitFromCommitData(createChunk, makeCommitData(meta, valueHash, indexes));
+}
+export function fromChunk(chunk) {
+    validateChunk(chunk);
+    return new Commit(chunk);
+}
+function commitFromCommitData(createChunk, data) {
+    return new Commit(createChunk(data, getRefs(data)));
+}
+export function getRefs(data) {
+    const refs = new Set();
+    refs.add(data.valueHash);
+    const { meta } = data;
+    switch (meta.type) {
+        case MetaType.IndexChangeSDD:
+            meta.basisHash && refs.add(meta.basisHash);
+            break;
+        case MetaType.LocalSDD:
+        case MetaType.LocalDD31:
+            meta.basisHash && refs.add(meta.basisHash);
+            // Local has weak originalHash
+            break;
+        case MetaType.SnapshotSDD:
+        case MetaType.SnapshotDD31:
+            // Snapshot has weak basisHash
+            break;
+        default:
+            unreachable(meta);
+    }
+    for (const index of data.indexes) {
+        refs.add(index.valueHash);
+    }
+    return toRefs(refs);
+}
+export function makeCommitData(meta, valueHash, indexes) {
+    return deepFreeze({
+        meta,
+        valueHash,
+        indexes,
+    });
+}
+export function assertCommitData(v) {
+    if (skipCommitDataAsserts) {
+        return;
+    }
+    assertObject(v);
+    assertDeepFrozen(v);
+    assertMeta(v.meta);
+    assertString(v.valueHash);
+    assertIndexRecords(v.indexes);
+}
+function validateChunk(chunk) {
+    const { data } = chunk;
+    assertCommitData(data);
+    const seen = new Set();
+    for (const index of data.indexes) {
+        const { name } = index.definition;
+        if (seen.has(name)) {
+            throw new Error(`Duplicate index ${name}`);
+        }
+        seen.add(name);
+    }
+}
+//# sourceMappingURL=commit.js.map