@rocicorp/zero 0.25.0-canary.1 → 0.25.0-canary.10

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

@@ -0,0 +1,183 @@
+import { assertNumber } from "../../../shared/src/asserts.js";
+import { assertHash } from "../hash.js";
+import { assertRefs, Chunk, createChunk } from "./chunk.js";
+import { computeRefCountUpdates } from "./gc.js";
+import { chunkDataKey, chunkMetaKey, headKey, chunkRefCountKey } from "./key.js";
+import { mustGetChunk } from "./store.js";
+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();
+  }
+}
+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 === void 0) {
+      return void 0;
+    }
+    const refsVal = await this._tx.get(chunkMetaKey(hash));
+    let refs;
+    if (refsVal !== void 0) {
+      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 === void 0) {
+      return void 0;
+    }
+    assertHash(data);
+    return data;
+  }
+  release() {
+    this._tx.release();
+  }
+  get closed() {
+    return this._tx.closed;
+  }
+}
+class WriteImpl extends ReadImpl {
+  #chunkHasher;
+  #putChunks = /* @__PURE__ */ new Set();
+  #changedHeads = /* @__PURE__ */ 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;
+    this.assertValidHash(hash);
+    const key = chunkDataKey(hash);
+    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, void 0);
+  }
+  async #setHead(name, hash) {
+    const oldHash = await this.getHead(name);
+    const hk = headKey(name);
+    let p1;
+    if (hash === void 0) {
+      p1 = this._tx.del(hk);
+    } else {
+      p1 = this._tx.put(hk, hash);
+    }
+    const v = this.#changedHeads.get(name);
+    if (v === void 0) {
+      this.#changedHeads.set(name, { new: hash, old: oldHash });
+    } else {
+      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 === void 0) {
+      return void 0;
+    }
+    assertNumber(value);
+    if (value < 0 || value > 65535 || 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 === void 0) {
+      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();
+  }
+}
+export {
+  ReadImpl,
+  StoreImpl,
+  WriteImpl
+};
+//# sourceMappingURL=store-impl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store-impl.js","sources":["../../../../../replicache/src/dag/store-impl.ts"],"sourcesContent":["import {assertNumber} from '../../../shared/src/asserts.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {\n  Read as KVRead,\n  Store as KVStore,\n  Write as KVWrite,\n} from '../kv/store.ts';\nimport {\n  Chunk,\n  type ChunkHasher,\n  type Refs,\n  assertRefs,\n  createChunk,\n} from './chunk.ts';\nimport {type RefCountUpdatesDelegate, computeRefCountUpdates} from './gc.ts';\nimport {chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey} from './key.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\nexport class StoreImpl implements Store {\n  readonly #kv: KVStore;\n  readonly #chunkHasher: ChunkHasher;\n  readonly #assertValidHash: (hash: Hash) => void;\n\n  constructor(\n    kv: KVStore,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n  ) {\n    this.#kv = kv;\n    this.#chunkHasher = chunkHasher;\n    this.#assertValidHash = assertValidHash;\n  }\n\n  async read(): Promise<Read> {\n    return new ReadImpl(await this.#kv.read(), this.#assertValidHash);\n  }\n\n  async write(): Promise<Write> {\n    return new WriteImpl(\n      await this.#kv.write(),\n      this.#chunkHasher,\n      this.#assertValidHash,\n    );\n  }\n\n  close(): Promise<void> {\n    return this.#kv.close();\n  }\n}\n\nexport class ReadImpl implements Read {\n  protected readonly _tx: KVRead;\n  readonly assertValidHash: (hash: Hash) => void;\n\n  constructor(kv: KVRead, assertValidHash: (hash: Hash) => void) {\n    this._tx = kv;\n    this.assertValidHash = assertValidHash;\n  }\n\n  hasChunk(hash: Hash): Promise<boolean> {\n    return this._tx.has(chunkDataKey(hash));\n  }\n\n  async getChunk(hash: Hash): Promise<Chunk | undefined> {\n    const data = await this._tx.get(chunkDataKey(hash));\n    if (data === undefined) {\n      return undefined;\n    }\n\n    const refsVal = await this._tx.get(chunkMetaKey(hash));\n    let refs: Refs;\n    if (refsVal !== undefined) {\n      assertRefs(refsVal);\n      refs = refsVal;\n    } else {\n      refs = [];\n    }\n    return new Chunk(hash, data, refs);\n  }\n\n  mustGetChunk(hash: Hash): Promise<Chunk> {\n    return mustGetChunk(this, hash);\n  }\n\n  async getHead(name: string): Promise<Hash | undefined> {\n    const data = await this._tx.get(headKey(name));\n    if (data === undefined) {\n      return undefined;\n    }\n    assertHash(data);\n    return data;\n  }\n\n  release(): void {\n    this._tx.release();\n  }\n\n  get closed(): boolean {\n    return this._tx.closed;\n  }\n}\n\ntype HeadChange = {\n  new: Hash | undefined;\n  old: Hash | undefined;\n};\n\nexport class WriteImpl\n  extends ReadImpl\n  implements Write, RefCountUpdatesDelegate\n{\n  declare protected readonly _tx: KVWrite;\n  readonly #chunkHasher: ChunkHasher;\n\n  readonly #putChunks = new Set<Hash>();\n  readonly #changedHeads = new Map<string, HeadChange>();\n\n  constructor(\n    kvw: KVWrite,\n    chunkHasher: ChunkHasher,\n    assertValidHash: (hash: Hash) => void,\n  ) {\n    super(kvw, assertValidHash);\n    this.#chunkHasher = chunkHasher;\n  }\n\n  createChunk = <V>(data: V, refs: Refs): Chunk<V> =>\n    createChunk(data, refs, this.#chunkHasher);\n\n  get kvWrite(): KVWrite {\n    return this._tx;\n  }\n\n  async putChunk(c: Chunk): Promise<void> {\n    const {hash, data, meta} = c;\n    // We never want to write temp hashes to the underlying store.\n    this.assertValidHash(hash);\n    const key = chunkDataKey(hash);\n    // Commit contains InternalValue and Hash which are opaque types.\n    const p1 = this._tx.put(key, data as ReadonlyJSONValue);\n    let p2;\n    if (meta.length > 0) {\n      for (const h of meta) {\n        this.assertValidHash(h);\n      }\n      p2 = this._tx.put(chunkMetaKey(hash), meta);\n    }\n    this.#putChunks.add(hash);\n    await p1;\n    await p2;\n  }\n\n  setHead(name: string, hash: Hash): Promise<void> {\n    return this.#setHead(name, hash);\n  }\n\n  removeHead(name: string): Promise<void> {\n    return this.#setHead(name, undefined);\n  }\n\n  async #setHead(name: string, hash: Hash | undefined): Promise<void> {\n    const oldHash = await this.getHead(name);\n    const hk = headKey(name);\n\n    let p1: Promise<void>;\n    if (hash === undefined) {\n      p1 = this._tx.del(hk);\n    } else {\n      p1 = this._tx.put(hk, hash);\n    }\n\n    const v = this.#changedHeads.get(name);\n    if (v === undefined) {\n      this.#changedHeads.set(name, {new: hash, old: oldHash});\n    } else {\n      // Keep old if existing\n      v.new = hash;\n    }\n\n    await p1;\n  }\n\n  async commit(): Promise<void> {\n    const refCountUpdates = await computeRefCountUpdates(\n      this.#changedHeads.values(),\n      this.#putChunks,\n      this,\n    );\n    await this.#applyRefCountUpdates(refCountUpdates);\n    await this._tx.commit();\n  }\n\n  async getRefCount(hash: Hash): Promise<number | undefined> {\n    const value = await this._tx.get(chunkRefCountKey(hash));\n    if (value === undefined) {\n      return undefined;\n    }\n    assertNumber(value);\n    if (value < 0 || value > 0xffff || value !== (value | 0)) {\n      throw new Error(\n        `Invalid ref count ${value}. We expect the value to be a Uint16`,\n      );\n    }\n    return value;\n  }\n\n  async getRefs(hash: Hash): Promise<readonly Hash[]> {\n    const meta = await this._tx.get(chunkMetaKey(hash));\n    if (meta === undefined) {\n      return [];\n    }\n    assertRefs(meta);\n    return meta;\n  }\n\n  async #applyRefCountUpdates(refCountCache: Map<Hash, number>): Promise<void> {\n    const ps: Promise<void>[] = [];\n    for (const [hash, count] of refCountCache) {\n      if (count === 0) {\n        ps.push(this.#removeAllRelatedKeys(hash));\n      } else {\n        const refCountKey = chunkRefCountKey(hash);\n        ps.push(this._tx.put(refCountKey, count));\n      }\n    }\n    await Promise.all(ps);\n  }\n\n  async #removeAllRelatedKeys(hash: Hash): Promise<void> {\n    await Promise.all([\n      this._tx.del(chunkDataKey(hash)),\n      this._tx.del(chunkMetaKey(hash)),\n      this._tx.del(chunkRefCountKey(hash)),\n    ]);\n\n    this.#putChunks.delete(hash);\n  }\n\n  release(): void {\n    this._tx.release();\n  }\n}\n"],"names":[],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sources":["../../../../../replicache/src/dag/store.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Hash} from '../hash.ts';\nimport type {Release} from '../with-transactions.ts';\nimport type {Chunk, Refs} from './chunk.ts';\n\nexport interface Store {\n  read(): Promise<Read>;\n  write(): Promise<Write>;\n  close(): Promise<void>;\n}\n\ninterface GetChunk {\n  getChunk(hash: Hash): Promise<Chunk | undefined>;\n}\n\nexport interface MustGetChunk {\n  mustGetChunk(hash: Hash): Promise<Chunk>;\n}\n\nexport interface Read extends GetChunk, MustGetChunk, Release {\n  hasChunk(hash: Hash): Promise<boolean>;\n  getHead(name: string): Promise<Hash | undefined>;\n  get closed(): boolean;\n}\n\nexport interface Write extends Read {\n  createChunk<V>(data: V, refs: Refs): Chunk<V>;\n  putChunk<V>(c: Chunk<V>): Promise<void>;\n  setHead(name: string, hash: Hash): Promise<void>;\n  removeHead(name: string): Promise<void>;\n  assertValidHash(hash: Hash): void;\n  commit(): Promise<void>;\n}\n\nexport class ChunkNotFoundError extends Error {\n  name = 'ChunkNotFoundError';\n  readonly hash: Hash;\n  constructor(hash: Hash) {\n    super(`Chunk not found ${hash}`);\n    this.hash = hash;\n  }\n}\n\nexport async function mustGetChunk(\n  store: GetChunk,\n  hash: Hash,\n): Promise<Chunk> {\n  const chunk = await store.getChunk(hash);\n  if (chunk) {\n    return chunk;\n  }\n  throw new ChunkNotFoundError(hash);\n}\n\nexport async function mustGetHeadHash(\n  name: string,\n  store: Read,\n): Promise<Hash> {\n  const hash = await store.getHead(name);\n  assert(hash, `Missing head ${name}`);\n  return hash;\n}\n"],"names":[],"mappings":";AAkCO,MAAM,2BAA2B,MAAM;AAAA,EAC5C,OAAO;AAAA,EACE;AAAA,EACT,YAAY,MAAY;AACtB,UAAM,mBAAmB,IAAI,EAAE;AAC/B,SAAK,OAAO;AAAA,EACd;AACF;AAEA,eAAsB,aACpB,OACA,MACgB;AAChB,QAAM,QAAQ,MAAM,MAAM,SAAS,IAAI;AACvC,MAAI,OAAO;AACT,WAAO;AAAA,EACT;AACA,QAAM,IAAI,mBAAmB,IAAI;AACnC;AAEA,eAAsB,gBACpB,MACA,OACe;AACf,QAAM,OAAO,MAAM,MAAM,QAAQ,IAAI;AACrC,SAAO,MAAM,gBAAgB,IAAI,EAAE;AACnC,SAAO;AACT;"}

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

@@ -0,0 +1,22 @@
+class Visitor {
+  #seen = /* @__PURE__ */ 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)));
+  }
+}
+export {
+  Visitor
+};
+//# sourceMappingURL=visitor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.js","sources":["../../../../../replicache/src/dag/visitor.ts"],"sourcesContent":["import type {Hash} from '../hash.ts';\nimport type {Chunk} from './chunk.ts';\nimport type {MustGetChunk} from './store.ts';\n\n/**\n * A visitor walks the DAG starting at a given root and visits each chunk.\n */\nexport class Visitor {\n  #seen: Set<Hash> = new Set();\n  #dagRead: MustGetChunk;\n\n  constructor(dagRead: MustGetChunk) {\n    this.#dagRead = dagRead;\n  }\n\n  async visit(h: Hash) {\n    if (this.#seen.has(h)) {\n      return;\n    }\n    this.#seen.add(h);\n    const chunk = await this.#dagRead.mustGetChunk(h);\n    await this.visitChunk(chunk);\n  }\n\n  async visitChunk(chunk: Chunk<unknown>) {\n    await Promise.all(chunk.meta.map(ref => this.visit(ref)));\n  }\n}\n"],"names":[],"mappings":"AAOO,MAAM,QAAQ;AAAA,EACnB,4BAAuB,IAAA;AAAA,EACvB;AAAA,EAEA,YAAY,SAAuB;AACjC,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,MAAM,MAAM,GAAS;AACnB,QAAI,KAAK,MAAM,IAAI,CAAC,GAAG;AACrB;AAAA,IACF;AACA,SAAK,MAAM,IAAI,CAAC;AAChB,UAAM,QAAQ,MAAM,KAAK,SAAS,aAAa,CAAC;AAChD,UAAM,KAAK,WAAW,KAAK;AAAA,EAC7B;AAAA,EAEA,MAAM,WAAW,OAAuB;AACtC,UAAM,QAAQ,IAAI,MAAM,KAAK,IAAI,SAAO,KAAK,MAAM,GAAG,CAAC,CAAC;AAAA,EAC1D;AACF;"}

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

@@ -0,0 +1,358 @@
+import { assertObject, assertNumber, assertString, unreachable, assertArray, assertBoolean, assert } from "../../../shared/src/asserts.js";
+import { assertJSONValue } from "../../../shared/src/json.js";
+import { isProd } from "../../../shared/src/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 { LocalDD31, SnapshotDD31 } from "./meta-type-enum.js";
+const DEFAULT_HEAD_NAME = "main";
+function commitIsLocalDD31(commit) {
+  return isLocalMetaDD31(commit.meta);
+}
+function commitIsLocal(commit) {
+  return commitIsLocalDD31(commit);
+}
+function commitIsSnapshot(commit) {
+  return isSnapshotMetaDD31(commit.meta);
+}
+class Commit {
+  chunk;
+  constructor(chunk) {
+    this.chunk = chunk;
+  }
+  get meta() {
+    return this.chunk.data.meta;
+  }
+  get valueHash() {
+    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() {
+    return this.chunk.data.indexes;
+  }
+}
+async function getMutationID(clientID, dagRead, meta) {
+  switch (meta.type) {
+    case SnapshotDD31:
+      return meta.lastMutationIDs[clientID] ?? 0;
+    case 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();
+  }
+}
+async function localMutations(fromCommitHash, dagRead) {
+  const commits = await commitChain(fromCommitHash, dagRead);
+  return commits.filter((c) => commitIsLocal(c));
+}
+async function localMutationsDD31(fromCommitHash, dagRead) {
+  const commits = await commitChain(fromCommitHash, dagRead);
+  return commits.filter((c) => commitIsLocalDD31(c));
+}
+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 !== void 0) {
+        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;
+}
+async function baseSnapshotFromHead(name, dagRead) {
+  const hash = await dagRead.getHead(name);
+  assert(hash, `Missing head ${name}`);
+  return baseSnapshotFromHash(hash, dagRead);
+}
+async function baseSnapshotHashFromHash(hash, dagRead) {
+  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;
+}
+async function baseSnapshotFromHash(hash, dagRead) {
+  const commit = await commitFromHash(hash, dagRead);
+  return baseSnapshotFromCommit(commit, dagRead);
+}
+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;
+}
+function snapshotMetaParts(c, clientID) {
+  const m = c.meta;
+  const lmid = m.lastMutationIDs[clientID] ?? 0;
+  return [lmid, m.cookieJSON];
+}
+function compareCookiesForSnapshots(a, b) {
+  return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);
+}
+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;
+}
+async function commitFromHash(hash, dagRead) {
+  const chunk = await dagRead.mustGetChunk(hash);
+  return fromChunk(chunk);
+}
+async function commitFromHead(name, dagRead) {
+  const hash = await mustGetHeadHash(name, dagRead);
+  return commitFromHash(hash, dagRead);
+}
+function assertLocalMetaDD31(v) {
+  assertString(v.clientID);
+  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);
+}
+function isLocalMetaDD31(meta) {
+  return meta.type === LocalDD31;
+}
+function assertSnapshotMetaDD31(v) {
+  if (v.basisHash !== null) {
+    assertHash(v.basisHash);
+  }
+  assertJSONValue(v.cookieJSON);
+  assertLastMutationIDs(v.lastMutationIDs);
+}
+function assertLastMutationIDs(v) {
+  assertObject(v);
+  for (const e of Object.values(v)) {
+    assertNumber(e);
+  }
+}
+function assertSnapshotCommitDD31(c) {
+  assertSnapshotMetaDD31(c.meta);
+}
+function isSnapshotMetaDD31(meta) {
+  return meta.type === SnapshotDD31;
+}
+function assertMeta(v) {
+  assertObject(v);
+  assertDeepFrozen(v);
+  if (v.basisHash !== null) {
+    assertString(v.basisHash);
+  }
+  assertNumber(v.type);
+  switch (v.type) {
+    case LocalDD31:
+      assertLocalMetaDD31(v);
+      break;
+    case SnapshotDD31:
+      assertSnapshotMetaDD31(v);
+      break;
+    default:
+      throw new Error(`Invalid enum value ${v.type}`);
+  }
+}
+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 !== void 0) {
+    assertBoolean(v.allowEmpty);
+  }
+}
+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);
+  }
+}
+function newLocalDD31(createChunk, basisHash, baseSnapshotHash, mutationID, mutatorName, mutatorArgsJSON, originalHash, valueHash, indexes, timestamp, clientID) {
+  const meta = {
+    type: LocalDD31,
+    basisHash,
+    baseSnapshotHash,
+    mutationID,
+    mutatorName,
+    mutatorArgsJSON,
+    originalHash,
+    timestamp,
+    clientID
+  };
+  return commitFromCommitData(
+    createChunk,
+    makeCommitData(meta, valueHash, indexes)
+  );
+}
+function newSnapshotDD31(createChunk, basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
+  return commitFromCommitData(
+    createChunk,
+    newSnapshotCommitDataDD31(
+      basisHash,
+      lastMutationIDs,
+      cookieJSON,
+      valueHash,
+      indexes
+    )
+  );
+}
+function newSnapshotCommitDataDD31(basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
+  const meta = {
+    type: SnapshotDD31,
+    basisHash,
+    lastMutationIDs,
+    cookieJSON
+  };
+  return makeCommitData(meta, valueHash, indexes);
+}
+function fromChunk(chunk) {
+  validateChunk(chunk);
+  return new Commit(chunk);
+}
+function commitFromCommitData(createChunk, data) {
+  return new Commit(createChunk(data, getRefs(data)));
+}
+function getRefs(data) {
+  const refs = /* @__PURE__ */ new Set();
+  refs.add(data.valueHash);
+  const { meta } = data;
+  switch (meta.type) {
+    case LocalDD31:
+      meta.basisHash && refs.add(meta.basisHash);
+      break;
+    case SnapshotDD31:
+      break;
+    default:
+      unreachable();
+  }
+  for (const index of data.indexes) {
+    refs.add(index.valueHash);
+  }
+  return toRefs(refs);
+}
+function makeCommitData(meta, valueHash, indexes) {
+  return deepFreeze({
+    meta,
+    valueHash,
+    indexes
+  });
+}
+function assertCommitData(v) {
+  if (isProd) {
+    return;
+  }
+  assertObject(v);
+  assertDeepFrozen(v);
+  assertMeta(v.meta);
+  assertString(v.valueHash);
+  assertIndexRecords(v.indexes);
+}
+function validateChunk(chunk) {
+  const { data } = chunk;
+  assertCommitData(data);
+  const seen = /* @__PURE__ */ 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);
+  }
+}
+export {
+  Commit,
+  DEFAULT_HEAD_NAME,
+  assertCommitData,
+  assertLocalMetaDD31,
+  assertSnapshotCommitDD31,
+  assertSnapshotMetaDD31,
+  baseSnapshotFromCommit,
+  baseSnapshotFromHash,
+  baseSnapshotFromHead,
+  baseSnapshotHashFromHash,
+  chunkIndexDefinitionEqualIgnoreName,
+  commitChain,
+  commitFromHash,
+  commitFromHead,
+  commitIsLocal,
+  commitIsLocalDD31,
+  commitIsSnapshot,
+  compareCookiesForSnapshots,
+  fromChunk,
+  getMutationID,
+  getRefs,
+  isLocalMetaDD31,
+  localMutations,
+  localMutationsDD31,
+  localMutationsGreaterThan,
+  makeCommitData,
+  newLocalDD31,
+  newSnapshotCommitDataDD31,
+  newSnapshotDD31,
+  snapshotMetaParts,
+  toChunkIndexDefinition
+};
+//# sourceMappingURL=commit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","sources":["../../../../../replicache/src/db/commit.ts"],"sourcesContent":["import {\n  assert,\n  assertArray,\n  assertBoolean,\n  assertNumber,\n  assertObject,\n  assertString,\n  unreachable,\n} from '../../../shared/src/asserts.ts';\nimport {assertJSONValue} from '../../../shared/src/json.ts';\nimport {skipCommitDataAsserts} from '../config.ts';\nimport {type FrozenCookie, compareCookies} from '../cookies.ts';\nimport {type Chunk, type CreateChunk, type Refs, toRefs} from '../dag/chunk.ts';\nimport {type MustGetChunk, type Read, mustGetHeadHash} from '../dag/store.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {IndexDefinition} from '../index-defs.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport * as MetaType from './meta-type-enum.ts';\n\nexport const DEFAULT_HEAD_NAME = 'main';\n\nexport function commitIsLocalDD31(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return isLocalMetaDD31(commit.meta);\n}\n\nexport function commitIsLocal(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return commitIsLocalDD31(commit);\n}\n\nexport function commitIsSnapshot(\n  commit: Commit<Meta>,\n): commit is Commit<SnapshotMetaDD31> {\n  return isSnapshotMetaDD31(commit.meta);\n}\n\nexport class Commit<M extends Meta> {\n  readonly chunk: Chunk<CommitData<M>>;\n\n  constructor(chunk: Chunk<CommitData<M>>) {\n    this.chunk = chunk;\n  }\n\n  get meta(): M {\n    return this.chunk.data.meta;\n  }\n\n  get valueHash(): Hash {\n    // Already validated!\n    return this.chunk.data.valueHash;\n  }\n\n  getMutationID(clientID: ClientID, dagRead: MustGetChunk): Promise<number> {\n    return getMutationID(clientID, dagRead, this.meta);\n  }\n\n  async getNextMutationID(\n    clientID: ClientID,\n    dagRead: MustGetChunk,\n  ): Promise<number> {\n    return (await this.getMutationID(clientID, dagRead)) + 1;\n  }\n\n  get indexes(): readonly IndexRecord[] {\n    // Already validated!\n    return this.chunk.data.indexes;\n  }\n}\n\nexport async function getMutationID(\n  clientID: ClientID,\n  dagRead: MustGetChunk,\n  meta: Meta,\n): Promise<number> {\n  switch (meta.type) {\n    case MetaType.SnapshotDD31:\n      return meta.lastMutationIDs[clientID] ?? 0;\n\n    case MetaType.LocalDD31: {\n      if (meta.clientID === clientID) {\n        return meta.mutationID;\n      }\n      const {basisHash} = meta;\n      const basisCommit = await commitFromHash(basisHash, dagRead);\n      return getMutationID(clientID, dagRead, basisCommit.meta);\n    }\n\n    default:\n      unreachable(meta);\n  }\n}\n\n/**\n * Returns the set of local commits from the given `fromCommitHash` back to but not\n * including its base snapshot. If `fromCommitHash` is a snapshot, the returned vector\n * will be empty. When, as typical, `fromCommitHash` is the head of the default chain\n * then the returned commits are the set of pending commits, ie the set of local commits\n * that have not yet been pushed to the data layer.\n *\n * The vector of commits is returned in reverse chain order, that is, starting\n * with the commit with hash `fromCommitHash` and walking backwards.\n */\nexport async function localMutations(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocal(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsDD31(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocalDD31(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsGreaterThan(\n  commit: Commit<Meta>,\n  mutationIDLimits: Record<ClientID, number>,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits: Commit<LocalMetaDD31>[] = [];\n  const remainingMutationIDLimits = new Map(Object.entries(mutationIDLimits));\n  while (!commitIsSnapshot(commit) && remainingMutationIDLimits.size > 0) {\n    if (commitIsLocalDD31(commit)) {\n      const {meta} = commit;\n      const mutationIDLowerLimit = remainingMutationIDLimits.get(meta.clientID);\n      if (mutationIDLowerLimit !== undefined) {\n        if (meta.mutationID <= mutationIDLowerLimit) {\n          remainingMutationIDLimits.delete(meta.clientID);\n        } else {\n          commits.push(commit as Commit<LocalMetaDD31>);\n        }\n      }\n    }\n    const {basisHash} = commit.meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  return commits;\n}\n\nexport async function baseSnapshotFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const hash = await dagRead.getHead(name);\n  assert(hash, `Missing head ${name}`);\n  return baseSnapshotFromHash(hash, dagRead);\n}\n\nexport async function baseSnapshotHashFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Hash> {\n  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;\n}\n\nexport async function baseSnapshotFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const commit = await commitFromHash(hash, dagRead);\n  return baseSnapshotFromCommit(commit, dagRead);\n}\n\nexport async function baseSnapshotFromCommit(\n  commit: Commit<Meta>,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    if (isLocalMetaDD31(meta)) {\n      commit = await commitFromHash(meta.baseSnapshotHash, dagRead);\n    } else {\n      const {basisHash} = meta;\n      if (basisHash === null) {\n        throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n      }\n      commit = await commitFromHash(basisHash, dagRead);\n    }\n  }\n  return commit;\n}\n\nexport function snapshotMetaParts(\n  c: Commit<SnapshotMetaDD31>,\n  clientID: ClientID,\n): [lastMutationID: number, cookie: FrozenCookie | FrozenJSONValue] {\n  const m = c.meta;\n  const lmid = m.lastMutationIDs[clientID] ?? 0;\n  return [lmid, m.cookieJSON];\n}\n\nexport function compareCookiesForSnapshots(\n  a: Commit<SnapshotMetaDD31>,\n  b: Commit<SnapshotMetaDD31>,\n): number {\n  return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);\n}\n\n/**\n * Returns all commits from the commit with fromCommitHash to its base snapshot,\n * inclusive of both. Resulting vector is in chain-head-first order (so snapshot\n * comes last).\n */\nexport async function commitChain(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<Meta>[]> {\n  let commit = await commitFromHash(fromCommitHash, dagRead);\n  const commits = [];\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    const {basisHash} = meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commits.push(commit);\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  commits.push(commit);\n  return commits;\n}\n\nexport async function commitFromHash(\n  hash: Hash,\n  dagRead: MustGetChunk,\n): Promise<Commit<Meta>> {\n  const chunk = await dagRead.mustGetChunk(hash);\n  return fromChunk(chunk);\n}\n\nexport async function commitFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<Meta>> {\n  const hash = await mustGetHeadHash(name, dagRead);\n  return commitFromHash(hash, dagRead);\n}\n\nexport type LocalMetaDD31 = {\n  readonly type: MetaType.LocalDD31;\n  readonly basisHash: Hash;\n  readonly mutationID: number;\n  readonly mutatorName: string;\n  readonly mutatorArgsJSON: FrozenJSONValue;\n  readonly originalHash: Hash | null;\n  readonly timestamp: number;\n  readonly clientID: ClientID;\n  readonly baseSnapshotHash: Hash;\n};\n\nexport type LocalMeta = LocalMetaDD31;\n\nexport function assertLocalMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is LocalMetaDD31 {\n  // type already asserted\n  assertString(v.clientID);\n  assertNumber(v.mutationID);\n  assertString(v.mutatorName);\n  if (!v.mutatorName) {\n    throw new Error('Missing mutator name');\n  }\n  assertJSONValue(v.mutatorArgsJSON);\n  if (v.originalHash !== null) {\n    assertHash(v.originalHash);\n  }\n  assertNumber(v.timestamp);\n}\n\nexport function isLocalMetaDD31(meta: Meta): meta is LocalMetaDD31 {\n  return meta.type === MetaType.LocalDD31;\n}\n\nexport function assertLocalCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<LocalMetaDD31> {\n  assertLocalMetaDD31(c.meta);\n}\n\nexport type SnapshotMetaDD31 = {\n  readonly type: MetaType.SnapshotDD31;\n  readonly basisHash: Hash | null;\n  readonly lastMutationIDs: Record<ClientID, number>;\n  readonly cookieJSON: FrozenCookie;\n};\n\nexport type SnapshotMeta = SnapshotMetaDD31;\n\nexport function assertSnapshotMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is SnapshotMetaDD31 {\n  // type already asserted\n  if (v.basisHash !== null) {\n    assertHash(v.basisHash);\n  }\n  assertJSONValue(v.cookieJSON);\n  assertLastMutationIDs(v.lastMutationIDs);\n}\n\nfunction assertLastMutationIDs(\n  v: unknown,\n): asserts v is Record<ClientID, number> {\n  assertObject(v);\n  for (const e of Object.values(v)) {\n    assertNumber(e);\n  }\n}\n\nexport type Meta = LocalMetaDD31 | SnapshotMetaDD31;\n\nexport function assertSnapshotCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<SnapshotMetaDD31> {\n  assertSnapshotMetaDD31(c.meta);\n}\n\nfunction isSnapshotMetaDD31(meta: Meta): meta is SnapshotMetaDD31 {\n  return meta.type === MetaType.SnapshotDD31;\n}\n\nfunction assertMeta(v: unknown): asserts v is Meta {\n  assertObject(v);\n  assertDeepFrozen(v);\n  if (v.basisHash !== null) {\n    assertString(v.basisHash);\n  }\n\n  assertNumber(v.type);\n  switch (v.type) {\n    case MetaType.LocalDD31:\n      assertLocalMetaDD31(v);\n      break;\n    case MetaType.SnapshotDD31:\n      assertSnapshotMetaDD31(v);\n      break;\n    default:\n      throw new Error(`Invalid enum value ${v.type}`);\n  }\n}\n\n/**\n * This is the type used for index definitions as defined in the Commit chunk data.\n *\n * Changing this requires a REPLICACHE_FORMAT_VERSION bump.\n */\nexport type ChunkIndexDefinition = {\n  readonly name: string;\n  readonly keyPrefix: string;\n  readonly jsonPointer: string;\n  // Used to not exist\n  readonly allowEmpty?: boolean;\n};\n\nexport function chunkIndexDefinitionEqualIgnoreName(\n  a: ChunkIndexDefinition,\n  b: ChunkIndexDefinition,\n): boolean {\n  return (\n    a.jsonPointer === b.jsonPointer &&\n    (a.allowEmpty ?? false) === (b.allowEmpty ?? false) &&\n    a.keyPrefix === b.keyPrefix\n  );\n}\n\nfunction assertChunkIndexDefinition(\n  v: unknown,\n): asserts v is ChunkIndexDefinition {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertString(v.name);\n  assertString(v.keyPrefix);\n  assertString(v.jsonPointer);\n  if (v.allowEmpty !== undefined) {\n    assertBoolean(v.allowEmpty);\n  }\n}\n\nexport function toChunkIndexDefinition(\n  name: string,\n  indexDefinition: IndexDefinition,\n): Required<ChunkIndexDefinition> {\n  return {\n    name,\n    keyPrefix: indexDefinition.prefix ?? '',\n    jsonPointer: indexDefinition.jsonPointer,\n    allowEmpty: indexDefinition.allowEmpty ?? false,\n  };\n}\n\nexport type IndexRecord = {\n  readonly definition: ChunkIndexDefinition;\n  readonly valueHash: Hash;\n};\n\nfunction assertIndexRecord(v: unknown): asserts v is IndexRecord {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertChunkIndexDefinition(v.definition);\n  assertString(v.valueHash);\n}\n\nfunction assertIndexRecords(v: unknown): asserts v is IndexRecord[] {\n  assertArray(v);\n  assertDeepFrozen(v);\n  for (const ir of v) {\n    assertIndexRecord(ir);\n  }\n}\n\nexport function newLocalDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash,\n  baseSnapshotHash: Hash,\n  mutationID: number,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n  timestamp: number,\n  clientID: ClientID,\n): Commit<LocalMetaDD31> {\n  const meta: LocalMetaDD31 = {\n    type: MetaType.LocalDD31,\n    basisHash,\n    baseSnapshotHash,\n    mutationID,\n    mutatorName,\n    mutatorArgsJSON,\n    originalHash,\n    timestamp,\n    clientID,\n  };\n  return commitFromCommitData(\n    createChunk,\n    makeCommitData(meta, valueHash, indexes),\n  );\n}\n\nexport function newSnapshotDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): Commit<SnapshotMetaDD31> {\n  return commitFromCommitData(\n    createChunk,\n    newSnapshotCommitDataDD31(\n      basisHash,\n      lastMutationIDs,\n      cookieJSON,\n      valueHash,\n      indexes,\n    ),\n  );\n}\n\nexport function newSnapshotCommitDataDD31(\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<SnapshotMetaDD31> {\n  const meta: SnapshotMetaDD31 = {\n    type: MetaType.SnapshotDD31,\n    basisHash,\n    lastMutationIDs,\n    cookieJSON,\n  };\n  return makeCommitData(meta, valueHash, indexes);\n}\n\nexport function fromChunk(chunk: Chunk): Commit<Meta> {\n  validateChunk(chunk);\n  return new Commit(chunk);\n}\n\nfunction commitFromCommitData<M extends Meta>(\n  createChunk: CreateChunk,\n  data: CommitData<M>,\n): Commit<M> {\n  return new Commit(createChunk(data, getRefs(data)));\n}\n\nexport function getRefs(data: CommitData<Meta>): Refs {\n  const refs: Set<Hash> = new Set();\n  refs.add(data.valueHash);\n  const {meta} = data;\n  switch (meta.type) {\n    case MetaType.LocalDD31:\n      meta.basisHash && refs.add(meta.basisHash);\n      // Local has weak originalHash\n      break;\n    case MetaType.SnapshotDD31:\n      // Snapshot has weak basisHash\n      break;\n    default:\n      unreachable(meta);\n  }\n\n  for (const index of data.indexes) {\n    refs.add(index.valueHash);\n  }\n\n  return toRefs(refs);\n}\n\nexport type CommitData<M extends Meta> = FrozenTag<{\n  readonly meta: M;\n  readonly valueHash: Hash;\n  readonly indexes: readonly IndexRecord[];\n}>;\n\nexport function makeCommitData<M extends Meta>(\n  meta: M,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<M> {\n  return deepFreeze({\n    meta,\n    valueHash,\n    indexes,\n  }) as unknown as CommitData<M>;\n}\n\nexport function assertCommitData(v: unknown): asserts v is CommitData<Meta> {\n  if (skipCommitDataAsserts) {\n    return;\n  }\n\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertMeta(v.meta);\n  assertString(v.valueHash);\n  assertIndexRecords(v.indexes);\n}\n\nfunction validateChunk(chunk: Chunk): asserts chunk is Chunk<CommitData<Meta>> {\n  const {data} = chunk;\n  assertCommitData(data);\n\n  const seen = new Set();\n  for (const index of data.indexes) {\n    const {name} = index.definition;\n    if (seen.has(name)) {\n      throw new Error(`Duplicate index ${name}`);\n    }\n    seen.add(name);\n  }\n}\n"],"names":["MetaType.SnapshotDD31","MetaType.LocalDD31","skipCommitDataAsserts"],"mappings":"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"}

package/out/replicache/src/db/index-operation-enum.js

@@ -0,0 +1,7 @@
+const Add = 0;
+const Remove = 1;
+export {
+  Add,
+  Remove
+};
+//# sourceMappingURL=index-operation-enum.js.map

package/out/replicache/src/db/index-operation-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-operation-enum.js","sources":["../../../../../replicache/src/db/index-operation-enum.ts"],"sourcesContent":["export const Add = 0;\nexport const Remove = 1;\n\nexport type Add = typeof Add;\nexport type Remove = typeof Remove;\n"],"names":[],"mappings":"AAAO,MAAM,MAAM;AACZ,MAAM,SAAS;"}