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

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

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","names":[],"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"],"mappings":"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"}

package/out/packages/replicache/src/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../../replicache/src/db/index.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {BTreeRead} from '../btree/read.ts';\nimport type {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenJSONObject, FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {IndexRecord} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\n\ntype IndexOperation = Enum<typeof IndexOperation>;\n\nexport class IndexRead<BTree = BTreeRead> {\n  readonly meta: IndexRecord;\n  readonly map: BTree;\n\n  constructor(meta: IndexRecord, map: BTree) {\n    this.meta = meta;\n    this.map = map;\n  }\n}\n\nexport class IndexWrite extends IndexRead<BTreeWrite> {\n  // Note: does not update self.meta.valueHash (doesn't need to at this point as flush\n  // is only called during commit.)\n  flush(): Promise<Hash> {\n    return this.map.flush();\n  }\n\n  clear(): Promise<void> {\n    return this.map.clear();\n  }\n}\n\n// Index or de-index a single primary entry.\nexport async function indexValue(\n  lc: LogContext,\n  index: BTreeWrite,\n  op: IndexOperation,\n  key: string,\n  val: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): Promise<void> {\n  try {\n    for (const entry of getIndexKeys(key, val, jsonPointer, allowEmpty)) {\n      switch (op) {\n        case IndexOperation.Add:\n          await index.put(entry, val);\n          break;\n        case IndexOperation.Remove:\n          await index.del(entry);\n          break;\n      }\n    }\n  } catch (e) {\n    // Right now all the errors that index_value() returns are customers dev\n    // problems: either the value is not json, the pointer is into nowhere, etc.\n    // So we ignore them.\n    lc.info?.('Not indexing value', val, ':', e);\n  }\n}\n\n// Gets the set of index keys for a given primary key and value.\nexport function getIndexKeys(\n  primary: string,\n  value: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): string[] {\n  const target = evaluateJSONPointer(value, jsonPointer);\n  if (target === undefined) {\n    if (allowEmpty) {\n      return [];\n    }\n    throw new Error(`No value at path: ${jsonPointer}`);\n  }\n\n  const values = Array.isArray(target) ? target : [target];\n\n  const indexKeys: string[] = [];\n  for (const value of values) {\n    if (typeof value === 'string') {\n      indexKeys.push(encodeIndexKey([value, primary]));\n    } else {\n      throw new Error('Unsupported target type');\n    }\n  }\n\n  return indexKeys;\n}\n\nexport const KEY_VERSION_0 = '\\u0000';\nexport const KEY_SEPARATOR = '\\u0000';\n\n/**\n * When using indexes the key is a tuple of the secondary key and the primary\n * key.\n */\nexport type IndexKey = readonly [secondary: string, primary: string];\n\n// An index key is encoded to vec of bytes in the following order:\n//   - key version byte(s), followed by\n//   - the secondary key bytes (which for now is a UTF8 encoded string), followed by\n//   - the key separator, a null byte, followed by\n//   - the primary key bytes\n//\n// The null separator byte ensures that if a secondary key A is longer than B then\n// A always sorts after B. Appending the primary key ensures index keys with\n// identical secondary keys sort in primary key order. Secondary keys must not\n// contain a zero (null) byte.\nexport function encodeIndexKey(indexKey: IndexKey): string {\n  const secondary = indexKey[0];\n  const primary = indexKey[1];\n\n  if (secondary.includes('\\u0000')) {\n    throw new Error('Secondary key cannot contain null byte');\n  }\n  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;\n}\n\n// Returns bytes that can be used to scan for the given secondary index value.\n//\n// Consider a scan for start_secondary_key=\"a\" (97). We want to scan with scan\n// key [0, 97]. We could also scan with [0, 97, 0], but then we couldn't use\n// this function for prefix scans, so we lop off the null byte. If we want\n// the scan to be exclusive, we scan with the next greater value, [0, 97, 1]\n// (we disallow zero bytes in secondary keys).\n//\n// Now it gets a little tricky. We also want to be able to scan using the\n// primary key, start_key. When we do this we have to encode the scan key\n// a little differently We essentially have to fix the value of the\n// secondary key so we can vary the start_key. That is, the match on\n// start_secondary_key becomes an exact match.\n//\n// Consider the scan for start_secondary_key=\"a\" and start_key=[2]. We want\n// to scan with [0, 97, 0, 2]. If we want exclusive we want to scan with\n// the next highest value, [0, 97, 0, 2, 0] (zero bytes are allowed in primary\n// keys). So far so good. It is important to notice that we need to\n// be able to distinguish between not wanting use start_key and wanting to\n// use start_key=[]. In the former case we want to scan with the secondary\n// key value, possibly followed by a 1 with no trailing zero byte ([0, 97]\n// or [0, 97, 1]). In the latter case we want to scan by the secondary\n// key value, followed by the zero byte, followed by the primary key value\n// and another zero if it is exclusive ([0, 97, 0] or [0, 97, 0, 0]).\n// This explains why we need the Option around start_key.\nexport function encodeIndexScanKey(\n  secondary: string,\n  primary: string | undefined,\n): string {\n  const k = encodeIndexKey([secondary, primary || '']);\n  if (primary === undefined) {\n    return k.slice(0, k.length - 1);\n  }\n  return k;\n}\n\n// Decodes an IndexKey encoded by encode_index_key.\nexport function decodeIndexKey(encodedIndexKey: string): IndexKey {\n  if (encodedIndexKey[0] !== KEY_VERSION_0) {\n    throw new Error('Invalid version');\n  }\n\n  const versionLen = KEY_VERSION_0.length;\n  const separatorLen = KEY_SEPARATOR.length;\n  const separatorOffset = encodedIndexKey.indexOf(KEY_SEPARATOR, versionLen);\n  if (separatorOffset === -1) {\n    throw new Error('Invalid formatting');\n  }\n\n  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);\n  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);\n  return [secondary, primary];\n}\n\nexport function evaluateJSONPointer(\n  value: FrozenJSONValue,\n  pointer: string,\n): FrozenJSONValue | undefined {\n  function parseIndex(s: string): number | undefined {\n    if (s.startsWith('+') || (s.startsWith('0') && s.length !== 1)) {\n      return undefined;\n    }\n    return parseInt(s, 10);\n  }\n\n  if (pointer === '') {\n    return value;\n  }\n  if (!pointer.startsWith('/')) {\n    throw new Error(`Invalid JSON pointer: ${pointer}`);\n  }\n\n  const tokens = pointer\n    .split('/')\n    .slice(1)\n    .map(x => x.replace(/~1/g, '/').replace(/~0/g, '~'));\n\n  let target = value;\n  for (const token of tokens) {\n    let targetOpt;\n    if (Array.isArray(target)) {\n      const i = parseIndex(token);\n      if (i === undefined) {\n        return undefined;\n      }\n      targetOpt = target[i];\n    } else if (target === null) {\n      return undefined;\n    } else if (typeof target === 'object') {\n      target = target as FrozenJSONObject;\n      targetOpt = target[token];\n    }\n    if (targetOpt === undefined) {\n      return undefined;\n    }\n    target = targetOpt;\n  }\n  return target;\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/db/read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","names":["#dagRead"],"sources":["../../../../../../replicache/src/db/read.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {BTreeRead} from '../btree/read.ts';\nimport type {Read as DagRead} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type Meta,\n  commitFromHash,\n  commitFromHead,\n} from './commit.ts';\nimport {IndexRead} from './index.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Read {\n  readonly #dagRead: DagRead;\n  map: BTreeRead;\n  readonly indexes: Map<string, IndexRead>;\n\n  constructor(\n    dagRead: DagRead,\n    map: BTreeRead,\n    indexes: Map<string, IndexRead>,\n  ) {\n    this.#dagRead = dagRead;\n    this.map = map;\n    this.indexes = indexes;\n  }\n\n  has(key: string): Promise<boolean> {\n    return this.map.has(key);\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    return this.map.get(key);\n  }\n\n  isEmpty(): Promise<boolean> {\n    return this.map.isEmpty();\n  }\n\n  getMapForIndex(indexName: string): BTreeRead {\n    const idx = this.indexes.get(indexName);\n    if (idx === undefined) {\n      throw new Error(`Unknown index name: ${indexName}`);\n    }\n    return idx.map;\n  }\n\n  get closed(): boolean {\n    return this.#dagRead.closed;\n  }\n\n  close(): void {\n    this.#dagRead.release();\n  }\n}\n\nexport function readFromDefaultHead(\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);\n}\n\nexport async function readFromHead(\n  name: string,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHead(name, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nexport async function readFromHash(\n  hash: Hash,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHash(hash, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nfunction readFromCommit(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Read {\n  const indexes = readIndexesForRead(commit, dagRead, formatVersion);\n  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);\n  return new Read(dagRead, map, indexes);\n}\n\nexport function readIndexesForRead(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Map<string, IndexRead> {\n  const m = new Map();\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexRead(\n        index,\n        new BTreeRead(dagRead, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n"],"mappings":";;;;AAiBA,IAAa,OAAb,MAAkB;CAChB;CACA;CACA;CAEA,YACE,SACA,KACA,SACA;EACA,KAAKA,WAAW;EAChB,KAAK,MAAM;EACX,KAAK,UAAU;CACjB;CAEA,IAAI,KAA+B;EACjC,OAAO,KAAK,IAAI,IAAI,GAAG;CACzB;CAEA,IAAI,KAAmD;EACrD,OAAO,KAAK,IAAI,IAAI,GAAG;CACzB;CAEA,UAA4B;EAC1B,OAAO,KAAK,IAAI,QAAQ;CAC1B;CAEA,eAAe,WAA8B;EAC3C,MAAM,MAAM,KAAK,QAAQ,IAAI,SAAS;EACtC,IAAI,QAAQ,KAAA,GACV,MAAM,IAAI,MAAM,uBAAuB,WAAW;EAEpD,OAAO,IAAI;CACb;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA,SAAS;CACvB;CAEA,QAAc;EACZ,KAAKA,SAAS,QAAQ;CACxB;AACF;AAEA,SAAgB,oBACd,SACA,eACe;CACf,OAAO,aAAa,mBAAmB,SAAS,aAAa;AAC/D;AAEA,eAAsB,aACpB,MACA,SACA,eACe;CAEf,OAAO,eAAe,MADD,eAAe,MAAM,OAAO,GACnB,SAAS,aAAa;AACtD;AAEA,eAAsB,aACpB,MACA,SACA,eACe;CAEf,OAAO,eAAe,MADD,eAAe,MAAM,OAAO,GACnB,SAAS,aAAa;AACtD;AAEA,SAAS,eACP,QACA,SACA,eACM;CACN,MAAM,UAAU,mBAAmB,QAAQ,SAAS,aAAa;CAEjE,OAAO,IAAI,KAAK,SAAS,IADT,UAAU,SAAS,eAAe,OAAO,SAChC,GAAK,OAAO;AACvC;AAEA,SAAgB,mBACd,QACA,SACA,eACwB;CACxB,MAAM,oBAAI,IAAI,IAAI;CAClB,KAAK,MAAM,SAAS,OAAO,SACzB,EAAE,IACA,MAAM,WAAW,MACjB,IAAI,UACF,OACA,IAAI,UAAU,SAAS,eAAe,MAAM,SAAS,CACvD,CACF;CAEF,OAAO;AACT"}

package/out/packages/replicache/src/db/rebase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebase.js","names":[],"sources":["../../../../../../replicache/src/db/rebase.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {Write as DagWrite} from '../dag/store.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroTxData} from '../replicache-options.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport {WriteTransactionImpl} from '../transactions.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {\n  type Commit,\n  type LocalMeta,\n  type LocalMetaDD31,\n  type Meta,\n  assertLocalMetaDD31,\n  commitFromHash,\n  isLocalMetaDD31,\n} from './commit.ts';\nimport type {Write} from './write.ts';\nimport {newWriteLocal} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nasync function rebaseMutation(\n  mutation: Commit<LocalMetaDD31>,\n  dagWrite: DagWrite,\n  basisHash: Hash,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Write> {\n  const localMeta = mutation.meta;\n  const name = localMeta.mutatorName;\n  if (isLocalMetaDD31(localMeta)) {\n    assert(\n      localMeta.clientID === mutationClientID,\n      'mutationClientID must match clientID of LocalMeta',\n    );\n  }\n  const maybeMutatorImpl = mutators[name];\n  if (!maybeMutatorImpl) {\n    // Developers must not remove mutator names from code deployed with the\n    // same schemaVersion because Replicache needs to be able to replay\n    // mutations during pull.\n    //\n    // If we detect that this has happened, stub in a no-op mutator so that at\n    // least sync can move forward. Note that the server-side mutation will\n    // still get sent. This doesn't remove the queued local mutation, it just\n    // removes its visible effects.\n    lc.error?.(`Cannot rebase unknown mutator ${name}`);\n  }\n  const mutatorImpl =\n    maybeMutatorImpl ||\n    (async () => {\n      // no op\n    });\n\n  const args = localMeta.mutatorArgsJSON;\n\n  const basisCommit = await commitFromHash(basisHash, dagWrite);\n  const nextMutationID = await basisCommit.getNextMutationID(\n    mutationClientID,\n    dagWrite,\n  );\n  if (nextMutationID !== localMeta.mutationID) {\n    throw new Error(\n      `Inconsistent mutation ID: original: ${localMeta.mutationID}, next: ${nextMutationID} - mutationClientID: ${mutationClientID} mutatorName: ${name}`,\n    );\n  }\n\n  if (formatVersion >= FormatVersion.DD31) {\n    assertLocalMetaDD31(localMeta);\n  }\n\n  const dbWrite = await newWriteLocal(\n    basisHash,\n    name,\n    args,\n    mutation.chunk.hash,\n    dagWrite,\n    localMeta.timestamp,\n    mutationClientID,\n    formatVersion,\n  );\n\n  const tx = new WriteTransactionImpl(\n    mutationClientID,\n    await dbWrite.getMutationID(),\n    'rebase',\n    zeroData,\n    dbWrite,\n    lc,\n  );\n  await mutatorImpl(tx, args);\n  return dbWrite;\n}\n\nexport async function rebaseMutationAndPutCommit(\n  mutation: Commit<LocalMeta>,\n  dagWrite: DagWrite,\n  basis: Hash,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  // TODO(greg): mutationClientID can be retrieved from mutation if LocalMeta\n  // is a LocalMetaDD31.  As part of DD31 cleanup we can remove this arg.\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Commit<Meta>> {\n  const tx = await rebaseMutation(\n    mutation,\n    dagWrite,\n    basis,\n    mutators,\n    lc,\n    mutationClientID,\n    formatVersion,\n    zeroData,\n  );\n  return tx.putCommit();\n}\n\nexport async function rebaseMutationAndCommit(\n  mutation: Commit<LocalMeta>,\n  dagWrite: DagWrite,\n  basis: Hash,\n  headName: string,\n  mutators: MutatorDefs,\n  lc: LogContext,\n  // TODO(greg): mutationClientID can be retrieved from mutation if LocalMeta\n  // is a LocalMetaDD31.  As part of DD31 cleanup we can remove this arg.\n  mutationClientID: ClientID,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Hash> {\n  const dbWrite = await rebaseMutation(\n    mutation,\n    dagWrite,\n    basis,\n    mutators,\n    lc,\n    mutationClientID,\n    formatVersion,\n    zeroData,\n  );\n  return dbWrite.commit(headName);\n}\n"],"mappings":";;;;;AAwBA,eAAe,eACb,UACA,UACA,WACA,UACA,IACA,kBACA,eACA,UACgB;CAChB,MAAM,YAAY,SAAS;CAC3B,MAAM,OAAO,UAAU;CACvB,IAAI,gBAAgB,SAAS,GAC3B,OACE,UAAU,aAAa,kBACvB,mDACF;CAEF,MAAM,mBAAmB,SAAS;CAClC,IAAI,CAAC,kBASH,GAAG,QAAQ,iCAAiC,MAAM;CAEpD,MAAM,cACJ,qBACC,YAAY,CAEb;CAEF,MAAM,OAAO,UAAU;CAGvB,MAAM,iBAAiB,OAAM,MADH,eAAe,WAAW,QAAQ,GACnB,kBACvC,kBACA,QACF;CACA,IAAI,mBAAmB,UAAU,YAC/B,MAAM,IAAI,MACR,uCAAuC,UAAU,WAAW,UAAU,eAAe,uBAAuB,iBAAiB,gBAAgB,MAC/I;CAGF,IAAI,iBAAiB,GACnB,oBAAoB,SAAS;CAG/B,MAAM,UAAU,MAAM,cACpB,WACA,MACA,MACA,SAAS,MAAM,MACf,UACA,UAAU,WACV,kBACA,aACF;CAUA,MAAM,YAAY,IARH,qBACb,kBACA,MAAM,QAAQ,cAAc,GAC5B,UACA,UACA,SACA,EAEgB,GAAI,IAAI;CAC1B,OAAO;AACT;AAEA,eAAsB,2BACpB,UACA,UACA,OACA,UACA,IAGA,kBACA,eACA,UACuB;CAWvB,QAAO,MAVU,eACf,UACA,UACA,OACA,UACA,IACA,kBACA,eACA,QACF,GACU,UAAU;AACtB;AAEA,eAAsB,wBACpB,UACA,UACA,OACA,UACA,UACA,IAGA,kBACA,eACA,UACe;CAWf,QAAO,MAVe,eACpB,UACA,UACA,OACA,UACA,IACA,kBACA,eACA,QACF,GACe,OAAO,QAAQ;AAChC"}

package/out/packages/replicache/src/db/write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.js","names":["#dagWrite","#basis","#meta","#clientID","#formatVersion","#generateDiffs"],"sources":["../../../../../../replicache/src/db/write.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {diff} from '../btree/diff.ts';\nimport type {InternalDiff} from '../btree/node.ts';\nimport {BTreeRead, allEntriesAsDiff} from '../btree/read.ts';\nimport {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenCookie} from '../cookies.ts';\nimport type {Write as DagWrite} from '../dag/store.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport {lazy} from '../lazy.ts';\nimport type {DiffComputationConfig} from '../sync/diff.ts';\nimport {DiffsMap} from '../sync/diff.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  type Meta as CommitMeta,\n  type IndexRecord,\n  type Meta,\n  baseSnapshotHashFromHash,\n  commitFromHash,\n  newLocalDD31 as commitNewLocalDD31,\n  newSnapshotDD31 as commitNewSnapshotDD31,\n  getMutationID,\n} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\nimport type {IndexRead} from './index.ts';\nimport {IndexWrite, indexValue} from './index.ts';\nimport * as MetaType from './meta-type-enum.ts';\nimport {Read, readIndexesForRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Write extends Read {\n  readonly #dagWrite: DagWrite;\n  readonly #basis: Commit<CommitMeta> | undefined;\n  readonly #meta: CommitMeta;\n\n  declare map: BTreeWrite;\n\n  declare readonly indexes: Map<string, IndexWrite>;\n  readonly #clientID: ClientID;\n  readonly #formatVersion: FormatVersion;\n\n  constructor(\n    dagWrite: DagWrite,\n    map: BTreeWrite,\n    basis: Commit<CommitMeta> | undefined,\n    meta: CommitMeta,\n    indexes: Map<string, IndexWrite>,\n    clientID: ClientID,\n    formatVersion: FormatVersion,\n  ) {\n    // TypeScript has trouble\n    super(dagWrite, map, indexes);\n    this.#dagWrite = dagWrite;\n    this.#basis = basis;\n    this.#meta = meta;\n    this.#clientID = clientID;\n    this.#formatVersion = formatVersion;\n\n    // TODO(arv): if (DEBUG) { ...\n    if (basis === undefined) {\n      assert(\n        meta.basisHash === emptyHash,\n        'Expected basisHash to be emptyHash when basis is undefined',\n      );\n    } else {\n      assert(\n        meta.basisHash === basis.chunk.hash,\n        'Expected meta.basisHash to equal basis.chunk.hash',\n      );\n    }\n  }\n\n  /**\n   * The value needs to be frozen since it is kept in memory and used later for\n   * comparison as well as returned in `get`.\n   */\n  async put(\n    lc: LogContext,\n    key: string,\n    value: FrozenJSONValue,\n  ): Promise<void> {\n    const oldVal = lazy(() => this.map.get(key));\n    await updateIndexes(lc, this.indexes, key, oldVal, value);\n\n    await this.map.put(key, value);\n  }\n\n  /**\n   * Inserts or updates multiple entries in a single bulk operation. More\n   * efficient than calling {@link put} in a loop because it uses\n   * {@link BTreeWrite.putMany} to build or merge tree nodes in one pass.\n   *\n   * `entries` must be sorted in ascending key order.\n   */\n  async putMany(\n    lc: LogContext,\n    entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n  ): Promise<void> {\n    if (entries.length === 0) {\n      return;\n    }\n\n    // Update indexes for all entries\n    if (this.indexes.size > 0) {\n      // TODO(arv): Indexes can use the optimizePatch pattern too.\n      for (const [key, value] of entries) {\n        const oldVal = lazy(() => this.map.get(key));\n        await updateIndexes(lc, this.indexes, key, oldVal, value);\n      }\n    }\n\n    // BTreeWrite.putMany handles both empty and non-empty trees optimally\n    await this.map.putMany(entries);\n  }\n\n  getMutationID(): Promise<number> {\n    return getMutationID(this.#clientID, this.#dagWrite, this.#meta);\n  }\n\n  async del(lc: LogContext, key: string): Promise<boolean> {\n    // TODO(arv): This does the binary search twice. We can do better.\n    const oldVal = lazy(() => this.map.get(key));\n    if (oldVal !== undefined) {\n      await updateIndexes(lc, this.indexes, key, oldVal, undefined);\n    }\n    return this.map.del(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.map.clear();\n    const ps = [];\n    for (const idx of this.indexes.values()) {\n      ps.push(idx.clear());\n    }\n    await Promise.all(ps);\n  }\n\n  async putCommit(): Promise<Commit<CommitMeta>> {\n    const valueHash = await this.map.flush();\n    const indexRecords: IndexRecord[] = [];\n\n    for (const index of this.indexes.values()) {\n      const valueHash = await index.flush();\n      const indexRecord: IndexRecord = {\n        definition: index.meta.definition,\n        valueHash,\n      };\n      indexRecords.push(indexRecord);\n    }\n\n    let commit: Commit<Meta>;\n    const meta = this.#meta;\n    switch (meta.type) {\n      case MetaType.LocalDD31: {\n        assert(\n          this.#formatVersion >= FormatVersion.DD31,\n          'Expected formatVersion >= DD31 for LocalDD31 commit',\n        );\n        const {\n          basisHash,\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          timestamp,\n        } = meta;\n        commit = commitNewLocalDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          await baseSnapshotHashFromHash(basisHash, this.#dagWrite),\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          valueHash,\n          indexRecords,\n          timestamp,\n          this.#clientID,\n        );\n        break;\n      }\n\n      case MetaType.SnapshotDD31: {\n        assert(\n          this.#formatVersion > FormatVersion.DD31,\n          'Expected formatVersion > DD31 for SnapshotDD31 commit',\n        );\n        const {basisHash, lastMutationIDs, cookieJSON} = meta;\n        commit = commitNewSnapshotDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          lastMutationIDs,\n          cookieJSON,\n          valueHash,\n          indexRecords,\n        );\n        break;\n      }\n    }\n    await this.#dagWrite.putChunk(commit.chunk);\n    return commit;\n  }\n\n  // Return value is the hash of the new commit.\n  async commit(headName: string): Promise<Hash> {\n    const commit = await this.putCommit();\n    const commitHash = commit.chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return commitHash;\n  }\n\n  async commitWithDiffs(\n    headName: string,\n    diffConfig: DiffComputationConfig,\n  ): Promise<[Hash, DiffsMap]> {\n    const commit = this.putCommit();\n    const diffMap = await this.#generateDiffs(diffConfig);\n    const commitHash = (await commit).chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return [commitHash, diffMap];\n  }\n\n  async #generateDiffs(diffConfig: DiffComputationConfig): Promise<DiffsMap> {\n    const diffsMap = new DiffsMap();\n    if (!diffConfig.shouldComputeDiffs()) {\n      return diffsMap;\n    }\n\n    let valueDiff: InternalDiff = [];\n    if (this.#basis) {\n      const basisMap = new BTreeRead(\n        this.#dagWrite,\n        this.#formatVersion,\n        this.#basis.valueHash,\n      );\n      valueDiff = await diff(basisMap, this.map);\n    }\n    diffsMap.set('', valueDiff);\n    let basisIndexes: Map<string, IndexRead>;\n    if (this.#basis) {\n      basisIndexes = readIndexesForRead(\n        this.#basis,\n        this.#dagWrite,\n        this.#formatVersion,\n      );\n    } else {\n      basisIndexes = new Map();\n    }\n\n    for (const [name, index] of this.indexes) {\n      if (!diffConfig.shouldComputeDiffsForIndex(name)) {\n        continue;\n      }\n      const basisIndex = basisIndexes.get(name);\n      assert(index !== basisIndex, 'Expected index to differ from basisIndex');\n\n      const indexDiffResult = await (basisIndex\n        ? diff(basisIndex.map, index.map)\n        : // No basis. All keys are new.\n          allEntriesAsDiff(index.map, 'add'));\n      diffsMap.set(name, indexDiffResult);\n    }\n\n    // Handle indexes in basisIndex but not in this.indexes. All keys are\n    // deleted.\n    for (const [name, basisIndex] of basisIndexes) {\n      if (\n        !this.indexes.has(name) &&\n        diffConfig.shouldComputeDiffsForIndex(name)\n      ) {\n        const indexDiffResult = await allEntriesAsDiff(basisIndex.map, 'del');\n        diffsMap.set(name, indexDiffResult);\n      }\n    }\n    return diffsMap;\n  }\n\n  close(): void {\n    this.#dagWrite.release();\n  }\n}\n\nexport async function newWriteLocal(\n  basisHash: Hash,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  dagWrite: DagWrite,\n  timestamp: number,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  const mutationID = await basis.getNextMutationID(clientID, dagWrite);\n  const indexes = readIndexesForWrite(basis, dagWrite, formatVersion);\n  assert(\n    formatVersion >= FormatVersion.DD31,\n    'Expected formatVersion >= DD31 for newWriteLocal',\n  );\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n\n    {\n      type: MetaType.LocalDD31,\n      basisHash,\n      baseSnapshotHash: await baseSnapshotHashFromHash(basisHash, dagWrite),\n      mutatorName,\n      mutatorArgsJSON,\n      mutationID,\n      originalHash,\n      timestamp,\n      clientID,\n    },\n    indexes,\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function newWriteSnapshotDD31(\n  basisHash: Hash,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  dagWrite: DagWrite,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n    {basisHash, type: MetaType.SnapshotDD31, lastMutationIDs, cookieJSON},\n    readIndexesForWrite(basis, dagWrite, formatVersion),\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function updateIndexes(\n  lc: LogContext,\n  indexes: Map<string, IndexWrite>,\n  key: string,\n  oldValGetter: () => Promise<FrozenJSONValue | undefined>,\n  newVal: FrozenJSONValue | undefined,\n): Promise<void> {\n  const ps: Promise<void>[] = [];\n  for (const idx of indexes.values()) {\n    const {keyPrefix} = idx.meta.definition;\n    if (!keyPrefix || key.startsWith(keyPrefix)) {\n      const oldVal = await oldValGetter();\n      if (oldVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Remove,\n            key,\n            oldVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n      if (newVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Add,\n            key,\n            newVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n    }\n  }\n  await Promise.all(ps);\n}\n\nexport function readIndexesForWrite(\n  commit: Commit<CommitMeta>,\n  dagWrite: DagWrite,\n  formatVersion: FormatVersion,\n): Map<string, IndexWrite> {\n  const m = new Map();\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexWrite(\n        index,\n        new BTreeWrite(dagWrite, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n\nexport async function createIndexBTree(\n  lc: LogContext,\n  dagWrite: DagWrite,\n  valueMap: BTreeRead,\n  prefix: string,\n  jsonPointer: string,\n  allowEmpty: boolean,\n  formatVersion: FormatVersion,\n): Promise<BTreeWrite> {\n  const indexMap = new BTreeWrite(dagWrite, formatVersion);\n  for await (const entry of valueMap.scan(prefix)) {\n    const key = entry[0];\n    if (!key.startsWith(prefix)) {\n      break;\n    }\n    await indexValue(\n      lc,\n      indexMap,\n      IndexOperation.Add,\n      key,\n      entry[1],\n      jsonPointer,\n      allowEmpty,\n    );\n  }\n  return indexMap;\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/deleted-clients.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleted-clients.js","names":[],"sources":["../../../../../replicache/src/deleted-clients.ts"],"sourcesContent":["import {stringCompare} from '../../shared/src/string-compare.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport type {Read, Write} from './dag/store.ts';\nimport {deepFreeze} from './frozen-json.ts';\nimport {getClients, setClients} from './persist/clients.ts';\nimport {\n  clientGroupIDSchema,\n  clientIDSchema,\n  type ClientGroupID,\n  type ClientID,\n} from './sync/ids.ts';\n\n/**\n * We keep track of deleted clients in the {@linkcode DELETED_CLIENTS_HEAD_NAME}\n * head.\n */\nexport const DELETED_CLIENTS_HEAD_NAME = 'deleted-clients-v2';\n\ntype ClientIDPair = {\n  clientGroupID: ClientGroupID;\n  clientID: ClientID;\n};\n\nexport type DeletedClients = readonly Readonly<ClientIDPair>[];\n\nexport type WritableDeletedClients = ClientIDPair[];\n\nexport const deletedClientsSchema: v.Type<DeletedClients> = v.readonlyArray(\n  v.readonlyObject({\n    clientGroupID: clientGroupIDSchema,\n    clientID: clientIDSchema,\n  }),\n);\n\nfunction compare(a: ClientIDPair, b: ClientIDPair): number {\n  const cg = stringCompare(a.clientGroupID, b.clientGroupID);\n  if (cg !== 0) {\n    return cg;\n  }\n  return stringCompare(a.clientID, b.clientID);\n}\n\nexport function normalizeDeletedClients(\n  deletedClients: DeletedClients,\n): DeletedClients {\n  return deletedClients\n    .toSorted(compare)\n    .filter((item, i, arr) => i === 0 || compare(item, arr[i - 1]) !== 0);\n}\n\nexport function mergeDeletedClients(\n  a: DeletedClients,\n  b: DeletedClients,\n): DeletedClients {\n  const merged: WritableDeletedClients = [];\n  a = normalizeDeletedClients(a);\n  b = normalizeDeletedClients(b);\n  for (let i = 0, j = 0; i < a.length || j < b.length; ) {\n    if (i < a.length && (j >= b.length || compare(a[i], b[j]) < 0)) {\n      merged.push(a[i]);\n      i++;\n    } else if (j < b.length && (i >= a.length || compare(b[j], a[i]) < 0)) {\n      merged.push(b[j]);\n      j++;\n    } else {\n      // equal\n      merged.push(a[i]);\n      i++;\n      j++;\n    }\n  }\n  return merged;\n}\n\nexport function removeFromDeletedClients(\n  old: DeletedClients,\n  toRemove: DeletedClients,\n): DeletedClients {\n  old = normalizeDeletedClients(old);\n  toRemove = normalizeDeletedClients(toRemove);\n  const result: WritableDeletedClients = [];\n  for (let i = 0, j = 0; i < old.length; ) {\n    if (j >= toRemove.length || compare(old[i], toRemove[j]) < 0) {\n      result.push(old[i]);\n      i++;\n    } else if (j < toRemove.length && compare(old[i], toRemove[j]) === 0) {\n      // equal, skip\n      i++;\n      j++;\n    } else {\n      // old[i] > toRemove[j]\n      j++;\n    }\n  }\n  return result;\n}\n\nexport async function setDeletedClients(\n  dagWrite: Write,\n  deletedClients: DeletedClients,\n): Promise<DeletedClients> {\n  // sort and dedupe\n\n  const data = normalizeDeletedClients(deletedClients);\n\n  const chunkData = deepFreeze(data);\n  const chunk = dagWrite.createChunk(chunkData, []);\n  await dagWrite.putChunk(chunk);\n  await dagWrite.setHead(DELETED_CLIENTS_HEAD_NAME, chunk.hash);\n  return data;\n}\n\nexport async function getDeletedClients(\n  dagRead: Read,\n): Promise<DeletedClients> {\n  const hash = await dagRead.getHead(DELETED_CLIENTS_HEAD_NAME);\n  if (hash === undefined) {\n    return [];\n  }\n  const chunk = await dagRead.mustGetChunk(hash);\n\n  const res = v.test(chunk.data, deletedClientsSchema);\n  if (!res.ok) {\n    // If not ok then we ignore this. It might be in the old format but we do\n    // not know the clientGroupID of the old clients.\n    return [];\n  }\n\n  return res.value;\n}\n\n/**\n * Adds deleted clients to the {@linkcode DELETED_CLIENTS_HEAD_NAME} head.\n * @returns the new list of deleted clients (sorted and deduped).\n */\nexport async function addDeletedClients(\n  dagWrite: Write,\n  deletedClientsToAdd: DeletedClients,\n): Promise<DeletedClients> {\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n\n  return setDeletedClients(\n    dagWrite,\n    mergeDeletedClients(oldDeletedClients, deletedClientsToAdd),\n  );\n}\n\nexport async function removeDeletedClients(\n  dagWrite: Write,\n  deletedClientsToRemove: DeletedClients,\n): Promise<DeletedClients> {\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n  return setDeletedClients(\n    dagWrite,\n    removeFromDeletedClients(oldDeletedClients, deletedClientsToRemove),\n  );\n}\n\nexport async function confirmDeletedClients(\n  dagWrite: Write,\n  deletedClientIds: readonly ClientID[],\n  deletedClientGroupIds: readonly ClientGroupID[],\n): Promise<DeletedClients> {\n  const deletedClientIDSet = new Set(deletedClientIds);\n  const deletedClientGroupIDSet = new Set(deletedClientGroupIds);\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n  const clients = new Map(await getClients(dagWrite));\n  for (const clientID of deletedClientIds) {\n    clients.delete(clientID);\n  }\n  for (const clientGroupID of deletedClientGroupIds) {\n    for (const [clientID, client] of clients) {\n      if (client.clientGroupID === clientGroupID) {\n        clients.delete(clientID);\n      }\n    }\n  }\n\n  await setClients(clients, dagWrite);\n\n  return setDeletedClients(\n    dagWrite,\n    oldDeletedClients.filter(\n      ({clientGroupID, clientID}) =>\n        !deletedClientGroupIDSet.has(clientGroupID) &&\n        !deletedClientIDSet.has(clientID),\n    ),\n  );\n}\n"],"mappings":";;;;;;;;;;AAgBA,IAAa,4BAA4B;AAWzC,IAAa,uBAA+C,cAC1D,eAAiB;CACf,eAAe;CACf,UAAU;AACZ,CAAC,CACH;AAEA,SAAS,QAAQ,GAAiB,GAAyB;CACzD,MAAM,KAAK,cAAc,EAAE,eAAe,EAAE,aAAa;CACzD,IAAI,OAAO,GACT,OAAO;CAET,OAAO,cAAc,EAAE,UAAU,EAAE,QAAQ;AAC7C;AAEA,SAAgB,wBACd,gBACgB;CAChB,OAAO,eACJ,SAAS,OAAO,EAChB,QAAQ,MAAM,GAAG,QAAQ,MAAM,KAAK,QAAQ,MAAM,IAAI,IAAI,EAAE,MAAM,CAAC;AACxE;AAEA,SAAgB,oBACd,GACA,GACgB;CAChB,MAAM,SAAiC,CAAC;CACxC,IAAI,wBAAwB,CAAC;CAC7B,IAAI,wBAAwB,CAAC;CAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,EAAE,UAAU,IAAI,EAAE,SAC3C,IAAI,IAAI,EAAE,WAAW,KAAK,EAAE,UAAU,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI;EAC9D,OAAO,KAAK,EAAE,EAAE;EAChB;CACF,OAAO,IAAI,IAAI,EAAE,WAAW,KAAK,EAAE,UAAU,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,IAAI;EACrE,OAAO,KAAK,EAAE,EAAE;EAChB;CACF,OAAO;EAEL,OAAO,KAAK,EAAE,EAAE;EAChB;EACA;CACF;CAEF,OAAO;AACT;AAyBA,eAAsB,kBACpB,UACA,gBACyB;CAGzB,MAAM,OAAO,wBAAwB,cAAc;CAEnD,MAAM,YAAY,WAAW,IAAI;CACjC,MAAM,QAAQ,SAAS,YAAY,WAAW,CAAC,CAAC;CAChD,MAAM,SAAS,SAAS,KAAK;CAC7B,MAAM,SAAS,QAAQ,2BAA2B,MAAM,IAAI;CAC5D,OAAO;AACT;AAEA,eAAsB,kBACpB,SACyB;CACzB,MAAM,OAAO,MAAM,QAAQ,QAAQ,yBAAyB;CAC5D,IAAI,SAAS,KAAA,GACX,OAAO,CAAC;CAIV,MAAM,MAAM,MAAO,MAFC,QAAQ,aAAa,IAAI,GAEpB,MAAM,oBAAoB;CACnD,IAAI,CAAC,IAAI,IAGP,OAAO,CAAC;CAGV,OAAO,IAAI;AACb;;;;;AAMA,eAAsB,kBACpB,UACA,qBACyB;CAGzB,OAAO,kBACL,UACA,oBAAoB,MAJU,kBAAkB,QAAQ,GAIjB,mBAAmB,CAC5D;AACF;AAaA,eAAsB,sBACpB,UACA,kBACA,uBACyB;CACzB,MAAM,qBAAqB,IAAI,IAAI,gBAAgB;CACnD,MAAM,0BAA0B,IAAI,IAAI,qBAAqB;CAC7D,MAAM,oBAAoB,MAAM,kBAAkB,QAAQ;CAC1D,MAAM,UAAU,IAAI,IAAI,MAAM,WAAW,QAAQ,CAAC;CAClD,KAAK,MAAM,YAAY,kBACrB,QAAQ,OAAO,QAAQ;CAEzB,KAAK,MAAM,iBAAiB,uBAC1B,KAAK,MAAM,CAAC,UAAU,WAAW,SAC/B,IAAI,OAAO,kBAAkB,eAC3B,QAAQ,OAAO,QAAQ;CAK7B,MAAM,WAAW,SAAS,QAAQ;CAElC,OAAO,kBACL,UACA,kBAAkB,QACf,EAAC,eAAe,eACf,CAAC,wBAAwB,IAAI,aAAa,KAC1C,CAAC,mBAAmB,IAAI,QAAQ,CACpC,CACF;AACF"}

package/out/packages/replicache/src/error-responses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-responses.js","names":[],"sources":["../../../../../replicache/src/error-responses.ts"],"sourcesContent":["import {assert} from '../../shared/src/asserts.ts';\n\nfunction isError(obj: unknown, type: string): boolean {\n  return (\n    typeof obj === 'object' &&\n    obj !== null &&\n    (obj as {error: unknown}).error === type\n  );\n}\n\ntype ErrorResponse = {error: string};\n\nexport function isErrorResponse(obj: object): obj is ErrorResponse {\n  return typeof (obj as {error: unknown}).error === 'string';\n}\n\n/**\n * In certain scenarios the server can signal that it does not know about the\n * client. For example, the server might have lost all of its state (this might\n * happen during the development of the server).\n */\nexport type ClientStateNotFoundResponse = {\n  error: 'ClientStateNotFound';\n};\n\nexport function isClientStateNotFoundResponse(\n  v: unknown,\n): v is ClientStateNotFoundResponse {\n  return isError(v, 'ClientStateNotFound');\n}\n\n/**\n * The server endpoint may respond with a `VersionNotSupported` error if it does\n * not know how to handle the pull, push or schema version.\n */\nexport type VersionNotSupportedResponse = {\n  error: 'VersionNotSupported';\n  versionType?: 'pull' | 'push' | 'schema' | undefined;\n};\n\nexport function isVersionNotSupportedResponse(\n  v: unknown,\n): v is VersionNotSupportedResponse {\n  if (!isError(v, 'VersionNotSupported')) {\n    return false;\n  }\n\n  const {versionType} = v as Record<string, unknown>;\n  switch (versionType) {\n    case undefined:\n    case 'pull':\n    case 'push':\n    case 'schema':\n      return true;\n  }\n\n  return false;\n}\n\nexport function assertVersionNotSupportedResponse(\n  v: unknown,\n): asserts v is VersionNotSupportedResponse {\n  assert(\n    isVersionNotSupportedResponse(v),\n    'Expected a VersionNotSupportedResponse',\n  );\n}\n"],"mappings":";;AAEA,SAAS,QAAQ,KAAc,MAAuB;CACpD,OACE,OAAO,QAAQ,YACf,QAAQ,QACP,IAAyB,UAAU;AAExC;AAIA,SAAgB,gBAAgB,KAAmC;CACjE,OAAO,OAAQ,IAAyB,UAAU;AACpD;AAWA,SAAgB,8BACd,GACkC;CAClC,OAAO,QAAQ,GAAG,qBAAqB;AACzC;AAWA,SAAgB,8BACd,GACkC;CAClC,IAAI,CAAC,QAAQ,GAAG,qBAAqB,GACnC,OAAO;CAGT,MAAM,EAAC,gBAAe;CACtB,QAAQ,aAAR;EACE,KAAK,KAAA;EACL,KAAK;EACL,KAAK;EACL,KAAK,UACH,OAAO;CACX;CAEA,OAAO;AACT;AAEA,SAAgB,kCACd,GAC0C;CAC1C,OACE,8BAA8B,CAAC,GAC/B,wCACF;AACF"}

package/out/packages/replicache/src/frozen-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frozen-json.js","names":[],"sources":["../../../../../replicache/src/frozen-json.ts"],"sourcesContent":["import {throwInvalidType} from '../../shared/src/asserts.ts';\nimport {skipAssertJSONValue} from '../../shared/src/config.ts';\nimport {hasOwn} from '../../shared/src/has-own.ts';\nimport type {\n  ReadonlyJSONObject,\n  ReadonlyJSONValue,\n} from '../../shared/src/json.ts';\nimport {skipFreeze, skipFrozenAsserts} from './config.ts';\nimport type {Cookie, FrozenCookie} from './cookies.ts';\n\ndeclare const frozenJSONTag: unique symbol;\n\n/**\n * Used to mark a type as having been frozen.\n */\nexport type FrozenTag<T> = T & {readonly [frozenJSONTag]: true};\n\nexport type FrozenJSONValue =\n  | null\n  | string\n  | boolean\n  | number\n  | FrozenJSONArray\n  | FrozenJSONObject;\n\ntype FrozenJSONArray = FrozenTag<ReadonlyArray<FrozenJSONValue>>;\n\nexport type FrozenJSONObject = FrozenTag<{\n  readonly [key: string]: FrozenJSONValue;\n}>;\n\n/**\n * We tag deep frozen objects in debug mode so that we do not have to deep\n * freeze an object more than once.\n */\nconst deepFrozenObjects = new WeakSet<object>();\n\n/**\n * Recursively freezes the passed in value (mutates it) and returns it.\n *\n * This is controlled by `skipFreeze` which is true in release mode.\n */\nexport function deepFreeze(v: Cookie): FrozenCookie;\nexport function deepFreeze(v: ReadonlyJSONValue): FrozenJSONValue;\nexport function deepFreeze(v: ReadonlyJSONValue): FrozenJSONValue {\n  if (skipFreeze) {\n    return v as FrozenJSONValue;\n  }\n\n  deepFreezeInternal(v, []);\n  return v as FrozenJSONValue;\n}\n\nfunction deepFreezeInternal(\n  v: ReadonlyJSONValue | undefined,\n  seen: object[],\n): void {\n  switch (typeof v) {\n    case 'undefined':\n      throw new TypeError('Unexpected value undefined');\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return;\n    case 'object': {\n      if (v === null) {\n        return;\n      }\n\n      if (deepFrozenObjects.has(v)) {\n        return;\n      }\n      deepFrozenObjects.add(v);\n\n      if (seen.includes(v)) {\n        throwInvalidType(v, 'Cyclic JSON object');\n      }\n\n      seen.push(v);\n\n      Object.freeze(v);\n      if (Array.isArray(v)) {\n        deepFreezeArray(v, seen);\n      } else {\n        deepFreezeObject(v as ReadonlyJSONObject, seen);\n      }\n      seen.pop();\n      return;\n    }\n\n    default:\n      throwInvalidType(v, 'JSON value');\n  }\n}\n\nfunction deepFreezeArray(\n  v: ReadonlyArray<ReadonlyJSONValue>,\n  seen: object[],\n): void {\n  for (const item of v) {\n    deepFreezeInternal(item, seen);\n  }\n}\n\nfunction deepFreezeObject(v: ReadonlyJSONObject, seen: object[]): void {\n  for (const k in v) {\n    if (hasOwn(v, k)) {\n      const value = v[k];\n      if (value !== undefined) {\n        deepFreezeInternal(value, seen);\n      }\n    }\n  }\n}\n\nexport function assertFrozenJSONValue(\n  v: unknown,\n): asserts v is FrozenJSONValue {\n  if (skipFrozenAsserts || skipAssertJSONValue) {\n    return;\n  }\n\n  switch (typeof v) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return;\n    case 'object':\n      if (v === null) {\n        return;\n      }\n\n      if (isDeepFrozen(v, [])) {\n        return;\n      }\n  }\n  throwInvalidType(v, 'JSON value');\n}\n\nexport function assertDeepFrozen<V>(v: V): asserts v is Readonly<V> {\n  if (skipFrozenAsserts) {\n    return;\n  }\n\n  if (!isDeepFrozen(v, [])) {\n    throw new Error('Expected frozen object');\n  }\n}\n\n/**\n * Recursive deep frozen check.\n *\n * It adds frozen objects to the {@link deepFrozenObjects} WeakSet so that we do\n * not have to check the same object more than once.\n */\nexport function isDeepFrozen(v: unknown, seen: object[]): boolean {\n  switch (typeof v) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return true;\n    case 'object':\n      if (v === null) {\n        return true;\n      }\n\n      if (deepFrozenObjects.has(v)) {\n        return true;\n      }\n\n      if (!Object.isFrozen(v)) {\n        return false;\n      }\n\n      if (seen.includes(v)) {\n        throwInvalidType(v, 'Cyclic JSON object');\n      }\n\n      seen.push(v);\n\n      if (Array.isArray(v)) {\n        for (const item of v) {\n          if (!isDeepFrozen(item, seen)) {\n            seen.pop();\n            return false;\n          }\n        }\n      } else {\n        for (const k in v) {\n          if (hasOwn(v, k)) {\n            const value = (v as Record<string, unknown>)[k];\n            if (value !== undefined && !isDeepFrozen(value, seen)) {\n              seen.pop();\n              return false;\n            }\n          }\n        }\n      }\n\n      deepFrozenObjects.add(v);\n      seen.pop();\n      return true;\n\n    default:\n      throwInvalidType(v, 'JSON value');\n  }\n}\n\nexport type P = Parameters<typeof deepFreeze>[0];\nexport type R = ReturnType<typeof deepFreeze>;\nexport function deepFreezeAllowUndefined(v: P | undefined): R | undefined {\n  if (v === undefined) {\n    return undefined;\n  }\n  return deepFreeze(v) as R;\n}\n"],"mappings":";;;;;;;;;AAmCA,IAAM,oCAAoB,IAAI,QAAgB;AAS9C,SAAgB,WAAW,GAAuC;CAChE,IAAI,QACF,OAAO;CAGT,mBAAmB,GAAG,CAAC,CAAC;CACxB,OAAO;AACT;AAEA,SAAS,mBACP,GACA,MACM;CACN,QAAQ,OAAO,GAAf;EACE,KAAK,aACH,MAAM,IAAI,UAAU,4BAA4B;EAClD,KAAK;EACL,KAAK;EACL,KAAK,UACH;EACF,KAAK;GACH,IAAI,MAAM,MACR;GAGF,IAAI,kBAAkB,IAAI,CAAC,GACzB;GAEF,kBAAkB,IAAI,CAAC;GAEvB,IAAI,KAAK,SAAS,CAAC,GACjB,iBAAiB,GAAG,oBAAoB;GAG1C,KAAK,KAAK,CAAC;GAEX,OAAO,OAAO,CAAC;GACf,IAAI,MAAM,QAAQ,CAAC,GACjB,gBAAgB,GAAG,IAAI;QAEvB,iBAAiB,GAAyB,IAAI;GAEhD,KAAK,IAAI;GACT;EAGF,SACE,iBAAiB,GAAG,YAAY;CACpC;AACF;AAEA,SAAS,gBACP,GACA,MACM;CACN,KAAK,MAAM,QAAQ,GACjB,mBAAmB,MAAM,IAAI;AAEjC;AAEA,SAAS,iBAAiB,GAAuB,MAAsB;CACrE,KAAK,MAAM,KAAK,GACd,IAAI,OAAO,GAAG,CAAC,GAAG;EAChB,MAAM,QAAQ,EAAE;EAChB,IAAI,UAAU,KAAA,GACZ,mBAAmB,OAAO,IAAI;CAElC;AAEJ;AA0BA,SAAgB,iBAAoB,GAAgC;CAClE,IAAI,QACF;CAGF,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,GACrB,MAAM,IAAI,MAAM,wBAAwB;AAE5C;;;;;;;AAQA,SAAgB,aAAa,GAAY,MAAyB;CAChE,QAAQ,OAAO,GAAf;EACE,KAAK;EACL,KAAK;EACL,KAAK,UACH,OAAO;EACT,KAAK;GACH,IAAI,MAAM,MACR,OAAO;GAGT,IAAI,kBAAkB,IAAI,CAAC,GACzB,OAAO;GAGT,IAAI,CAAC,OAAO,SAAS,CAAC,GACpB,OAAO;GAGT,IAAI,KAAK,SAAS,CAAC,GACjB,iBAAiB,GAAG,oBAAoB;GAG1C,KAAK,KAAK,CAAC;GAEX,IAAI,MAAM,QAAQ,CAAC;SACZ,MAAM,QAAQ,GACjB,IAAI,CAAC,aAAa,MAAM,IAAI,GAAG;KAC7B,KAAK,IAAI;KACT,OAAO;IACT;UAGF,KAAK,MAAM,KAAK,GACd,IAAI,OAAO,GAAG,CAAC,GAAG;IAChB,MAAM,QAAS,EAA8B;IAC7C,IAAI,UAAU,KAAA,KAAa,CAAC,aAAa,OAAO,IAAI,GAAG;KACrD,KAAK,IAAI;KACT,OAAO;IACT;GACF;GAIJ,kBAAkB,IAAI,CAAC;GACvB,KAAK,IAAI;GACT,OAAO;EAET,SACE,iBAAiB,GAAG,YAAY;CACpC;AACF;AAIA,SAAgB,yBAAyB,GAAiC;CACxE,IAAI,MAAM,KAAA,GACR;CAEF,OAAO,WAAW,CAAC;AACrB"}

package/out/packages/replicache/src/get-default-puller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-default-puller.js","names":[],"sources":["../../../../../replicache/src/get-default-puller.ts"],"sourcesContent":["import {\n  assertNumber,\n  assertObject,\n  assertString,\n} from '../../shared/src/asserts.ts';\nimport {callDefaultFetch} from './call-default-fetch.ts';\nimport {assertCookie} from './cookies.ts';\nimport {\n  isClientStateNotFoundResponse,\n  isVersionNotSupportedResponse,\n} from './error-responses.ts';\nimport {assertHTTPRequestInfo} from './http-request-info.ts';\nimport {assertPatchOperations} from './patch-operation.ts';\nimport type {\n  PullResponseV1,\n  Puller,\n  PullerResult,\n  PullerResultV1,\n} from './puller.ts';\nimport type {PullRequest} from './sync/pull.ts';\n\n/**\n * This creates a default puller which uses HTTP POST to send the pull request.\n */\nexport function getDefaultPuller(rep: {pullURL: string; auth: string}): Puller {\n  async function puller(\n    requestBody: PullRequest,\n    requestID: string,\n  ): Promise<PullerResult> {\n    const [response, httpRequestInfo] = await callDefaultFetch(\n      rep.pullURL,\n      rep.auth,\n      requestID,\n      requestBody,\n    );\n    if (!response) {\n      return {httpRequestInfo};\n    }\n\n    return {\n      response: await response.json(),\n      httpRequestInfo,\n    };\n  }\n\n  defaultPullers.add(puller);\n  return puller;\n}\n\nconst defaultPullers = new WeakSet();\n\nexport function isDefaultPuller(puller: Puller): boolean {\n  return defaultPullers.has(puller);\n}\n\nexport function assertPullResponseV1(v: unknown): asserts v is PullResponseV1 {\n  assertObject(v);\n  if (isClientStateNotFoundResponse(v) || isVersionNotSupportedResponse(v)) {\n    return;\n  }\n  if (v.cookie !== undefined) {\n    assertCookie(v.cookie);\n  }\n  assertLastMutationIDChanges(v.lastMutationIDChanges);\n  assertPatchOperations(v.patch);\n}\n\nfunction assertLastMutationIDChanges(\n  lastMutationIDChanges: unknown,\n): asserts lastMutationIDChanges is Record<string, number> {\n  assertObject(lastMutationIDChanges);\n  for (const [key, value] of Object.entries(lastMutationIDChanges)) {\n    assertString(key);\n    assertNumber(value);\n  }\n}\n\nexport function assertPullerResultV1(v: unknown): asserts v is PullerResultV1 {\n  assertObject(v);\n  assertHTTPRequestInfo(v.httpRequestInfo);\n  if (v.response !== undefined) {\n    assertPullResponseV1(v.response);\n  }\n}\n"],"mappings":";;;;;;;;;;AAwBA,SAAgB,iBAAiB,KAA8C;CAC7E,eAAe,OACb,aACA,WACuB;EACvB,MAAM,CAAC,UAAU,mBAAmB,MAAM,iBACxC,IAAI,SACJ,IAAI,MACJ,WACA,WACF;EACA,IAAI,CAAC,UACH,OAAO,EAAC,gBAAe;EAGzB,OAAO;GACL,UAAU,MAAM,SAAS,KAAK;GAC9B;EACF;CACF;CAEA,eAAe,IAAI,MAAM;CACzB,OAAO;AACT;AAEA,IAAM,iCAAiB,IAAI,QAAQ;AAEnC,SAAgB,gBAAgB,QAAyB;CACvD,OAAO,eAAe,IAAI,MAAM;AAClC;AAEA,SAAgB,qBAAqB,GAAyC;CAC5E,aAAa,CAAC;CACd,IAAI,8BAA8B,CAAC,KAAK,8BAA8B,CAAC,GACrE;CAEF,IAAI,EAAE,WAAW,KAAA,GACf,aAAa,EAAE,MAAM;CAEvB,4BAA4B,EAAE,qBAAqB;CACnD,sBAAsB,EAAE,KAAK;AAC/B;AAEA,SAAS,4BACP,uBACyD;CACzD,aAAa,qBAAqB;CAClC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,qBAAqB,GAAG;EAChE,aAAa,GAAG;EAChB,aAAa,KAAK;CACpB;AACF;AAEA,SAAgB,qBAAqB,GAAyC;CAC5E,aAAa,CAAC;CACd,sBAAsB,EAAE,eAAe;CACvC,IAAI,EAAE,aAAa,KAAA,GACjB,qBAAqB,EAAE,QAAQ;AAEnC"}

package/out/packages/replicache/src/get-default-pusher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-default-pusher.js","names":[],"sources":["../../../../../replicache/src/get-default-pusher.ts"],"sourcesContent":["import {callDefaultFetch} from './call-default-fetch.ts';\nimport {\n  isClientStateNotFoundResponse,\n  isVersionNotSupportedResponse,\n} from './error-responses.ts';\nimport type {Pusher, PusherResult} from './pusher.ts';\nimport type {PushRequest} from './sync/push.ts';\n\n/**\n * This creates a default pusher which uses HTTP POST to send the push request.\n */\nexport function getDefaultPusher(rep: {pushURL: string; auth: string}): Pusher {\n  async function pusher(\n    requestBody: PushRequest,\n    requestID: string,\n  ): Promise<PusherResult> {\n    const [response, httpRequestInfo] = await callDefaultFetch(\n      rep.pushURL,\n      rep.auth,\n      requestID,\n      requestBody,\n    );\n    if (!response) {\n      return {httpRequestInfo};\n    }\n\n    const rv: PusherResult = {\n      httpRequestInfo,\n    };\n\n    let result;\n    try {\n      result = await response.json();\n    } catch {\n      // Ignore JSON parse errors. It is valid to return a non-JSON response.\n      return rv;\n    }\n\n    if (\n      isClientStateNotFoundResponse(result) ||\n      isVersionNotSupportedResponse(result)\n    ) {\n      rv.response = result;\n    }\n\n    return rv;\n  }\n\n  defaultPushers.add(pusher);\n  return pusher;\n}\n\nconst defaultPushers = new WeakSet();\n\nexport function isDefaultPusher(pusher: Pusher): boolean {\n  return defaultPushers.has(pusher);\n}\n"],"mappings":";;;;;;AAWA,SAAgB,iBAAiB,KAA8C;CAC7E,eAAe,OACb,aACA,WACuB;EACvB,MAAM,CAAC,UAAU,mBAAmB,MAAM,iBACxC,IAAI,SACJ,IAAI,MACJ,WACA,WACF;EACA,IAAI,CAAC,UACH,OAAO,EAAC,gBAAe;EAGzB,MAAM,KAAmB,EACvB,gBACF;EAEA,IAAI;EACJ,IAAI;GACF,SAAS,MAAM,SAAS,KAAK;EAC/B,QAAQ;GAEN,OAAO;EACT;EAEA,IACE,8BAA8B,MAAM,KACpC,8BAA8B,MAAM,GAEpC,GAAG,WAAW;EAGhB,OAAO;CACT;CAEA,eAAe,IAAI,MAAM;CACzB,OAAO;AACT;AAEA,IAAM,iCAAiB,IAAI,QAAQ;AAEnC,SAAgB,gBAAgB,QAAyB;CACvD,OAAO,eAAe,IAAI,MAAM;AAClC"}

package/out/packages/replicache/src/get-kv-store-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-kv-store-provider.js","names":[],"sources":["../../../../../replicache/src/get-kv-store-provider.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {\n  dropIDBStoreWithMemFallback,\n  newIDBStoreWithMemFallback,\n} from './kv/idb-store-with-mem-fallback.ts';\nimport {dropMemStore, MemStore} from './kv/mem-store.ts';\nimport type {StoreProvider} from './kv/store.ts';\n\nexport function getKVStoreProvider(\n  lc: LogContext,\n  kvStore: 'mem' | 'idb' | StoreProvider | undefined,\n): StoreProvider {\n  switch (kvStore) {\n    case 'idb':\n    case undefined:\n      return {\n        create: name => newIDBStoreWithMemFallback(lc, name),\n        drop: dropIDBStoreWithMemFallback,\n      };\n    case 'mem':\n      return {\n        create: name => new MemStore(name),\n        drop: name => dropMemStore(name),\n      };\n    default:\n      return kvStore;\n  }\n}\n"],"mappings":";;;AAQA,SAAgB,mBACd,IACA,SACe;CACf,QAAQ,SAAR;EACE,KAAK;EACL,KAAK,KAAA,GACH,OAAO;GACL,SAAQ,SAAQ,2BAA2B,IAAI,IAAI;GACnD,MAAM;EACR;EACF,KAAK,OACH,OAAO;GACL,SAAQ,SAAQ,IAAI,SAAS,IAAI;GACjC,OAAM,SAAQ,aAAa,IAAI;EACjC;EACF,SACE,OAAO;CACX;AACF"}

package/out/packages/replicache/src/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","names":[],"sources":["../../../../../replicache/src/hash.ts"],"sourcesContent":["import {assert} from '../../shared/src/asserts.ts';\nimport {randomUint64} from '../../shared/src/random-uint64.ts';\nimport * as valita from '../../shared/src/valita.ts';\n\nexport const STRING_LENGTH = 22;\n\n// We use an opaque type so that we can make sure that a hash is always a hash.\n// TypeScript does not have direct support but we can use a trick described\n// here:\n//\n// https://evertpot.com/opaque-ts-types/\n//\n// The basic idea is to declare a type that cannot be created. We then use\n// functions that cast a string to this type.\n//\n\n// By using declare we tell the type system that there is a unique symbol.\n// However, there is no such symbol but the type system does not care.\ndeclare const hashTag: unique symbol;\n\n/**\n * Opaque type representing a hash. The only way to create one is using `parse`\n * or `hashOf` (except for static unsafe cast of course).\n */\nexport type Hash = string & {[hashTag]: true};\n\n// We are no longer using hashes but due to legacy reason we still refer to\n// them as hashes. We use UUID and counters instead.\nconst hashRe = /^[0-9a-v-]+$/;\n\nexport function parse(s: string): Hash {\n  assertHash(s);\n  return s;\n}\n\nconst emptyUUID = '0'.repeat(STRING_LENGTH);\nexport const emptyHash = emptyUUID as unknown as Hash;\n\n/**\n * Creates a function that generates random hashes.\n */\nexport const newRandomHash = makeNewRandomHashFunctionInternal();\n\nconst fakeHashRe = /^[0-9a-v]{0,8}$/;\n\n/**\n * Creates a function that generates UUID hashes for tests.\n */\nexport function makeNewFakeHashFunction(hashPrefix = 'fake'): () => Hash {\n  assert(fakeHashRe.test(hashPrefix), `Invalid hash prefix: ${hashPrefix}`);\n  let i = 0;\n  return () => {\n    const count = String(i++);\n    return (hashPrefix +\n      '0'.repeat(STRING_LENGTH - hashPrefix.length - count.length) +\n      count) as Hash;\n  };\n}\n\nfunction toStringAndSlice(n: number | bigint, len: number): string {\n  return n.toString(32).slice(-len).padStart(len, '0');\n}\n\n/**\n * This creates an ID that looks like `<RANDOM><COUNTER>`. The random part is\n * a random number encoded with base 32 and the length is 12 characters. The\n * is 10 characters long and encoded as base 32. The total length is 22 characters.\n *\n * Do the math: https://devina.io/collision-calculator\n */\nfunction makeNewRandomHashFunctionInternal(): () => Hash {\n  let base = '';\n  let i = 0;\n\n  return () => {\n    if (!base) {\n      // This needs to be lazy because the cloudflare worker environment will\n      // throw an error if crypto.getRandomValues is used statically.  Specifically:\n      // Error: Some functionality, such as asynchronous I/O, timeouts, and\n      // generating random values, can only be performed while handling a\n      // request.\n      base = toStringAndSlice(randomUint64(), 12);\n    }\n    const tail = toStringAndSlice(i++, 10);\n    return (base + tail) as Hash;\n  };\n}\n\n/**\n * Generates a fake hash useful for testing.\n */\nexport function fakeHash(word: string | number): Hash {\n  if (typeof word === 'number') {\n    word = String(word);\n  }\n  return ('fake' + '0'.repeat(STRING_LENGTH - 4 - word.length) + word) as Hash;\n}\n\nexport function isHash(value: unknown): value is Hash {\n  return typeof value === 'string' && hashRe.test(value);\n}\n\nexport function assertHash(value: unknown): asserts value is Hash {\n  valita.assert(value, hashSchema);\n}\n\nexport const hashSchema = valita.string().assert(isHash, 'Invalid hash');\n"],"mappings":";;AA4BA,IAAM,SAAS;AAQf,IAAa,YADK,IAAI,OAAA,EACG;;;;AAKzB,IAAa,gBAAgB,kCAAkC;AAkB/D,SAAS,iBAAiB,GAAoB,KAAqB;CACjE,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,GAAG,EAAE,SAAS,KAAK,GAAG;AACrD;;;;;;;;AASA,SAAS,oCAAgD;CACvD,IAAI,OAAO;CACX,IAAI,IAAI;CAER,aAAa;EACX,IAAI,CAAC,MAMH,OAAO,iBAAiB,aAAa,GAAG,EAAE;EAE5C,MAAM,OAAO,iBAAiB,KAAK,EAAE;EACrC,OAAQ,OAAO;CACjB;AACF;AAYA,SAAgB,OAAO,OAA+B;CACpD,OAAO,OAAO,UAAU,YAAY,OAAO,KAAK,KAAK;AACvD;AAEA,SAAgB,WAAW,OAAuC;CAChE,OAAc,OAAO,UAAU;AACjC;AAEA,IAAa,aAAa,eAAO,OAAO,EAAE,OAAO,QAAQ,cAAc"}

package/out/packages/replicache/src/http-request-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-request-info.js","names":[],"sources":["../../../../../replicache/src/http-request-info.ts"],"sourcesContent":["import {\n  assertNumber,\n  assertObject,\n  assertString,\n} from '../../shared/src/asserts.ts';\n\nexport function assertHTTPRequestInfo(\n  v: unknown,\n): asserts v is HTTPRequestInfo {\n  assertObject(v);\n  assertNumber(v.httpStatusCode);\n  assertString(v.errorMessage);\n}\n\nexport type HTTPRequestInfo = {\n  httpStatusCode: number;\n  errorMessage: string;\n};\n"],"mappings":";;AAMA,SAAgB,sBACd,GAC8B;CAC9B,aAAa,CAAC;CACd,aAAa,EAAE,cAAc;CAC7B,aAAa,EAAE,YAAY;AAC7B"}

package/out/packages/replicache/src/index-defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-defs.js","names":[],"sources":["../../../../../replicache/src/index-defs.ts"],"sourcesContent":["import * as valita from '../../shared/src/valita.ts';\n\n/**\n * The definition of a single index.\n */\nexport type IndexDefinition = {\n  /**\n   * The prefix, if any, to limit the index over. If not provided the values of\n   * all keys are indexed.\n   */\n  readonly prefix?: string | undefined;\n\n  /**\n   * A [JSON Pointer](https://tools.ietf.org/html/rfc6901) pointing at the sub\n   * value inside each value to index over.\n   *\n   * For example, one might index over users' ages like so:\n   * `{prefix: '/user/', jsonPointer: '/age'}`\n   */\n  readonly jsonPointer: string;\n\n  /**\n   * If `true`, indexing empty values will not emit a warning.  Defaults to `false`.\n   */\n  readonly allowEmpty?: boolean | undefined;\n};\n\nexport const indexDefinitionSchema: valita.Type<IndexDefinition> =\n  valita.readonlyObject({\n    prefix: valita.string().optional(),\n    jsonPointer: valita.string(),\n    allowEmpty: valita.boolean().optional(),\n  });\n\n/**\n * An object as a map defining the indexes. The keys are the index names and the\n * values are the index definitions.\n */\nexport type IndexDefinitions = {readonly [name: string]: IndexDefinition};\n\nexport const indexDefinitionsSchema = valita.readonlyRecord(\n  indexDefinitionSchema,\n);\n\nexport function indexDefinitionEqual(\n  a: IndexDefinition,\n  b: IndexDefinition,\n): boolean {\n  return (\n    a.jsonPointer === b.jsonPointer &&\n    (a.allowEmpty ?? false) === (b.allowEmpty ?? false) &&\n    (a.prefix ?? '') === (b.prefix ?? '')\n  );\n}\n\nexport function indexDefinitionsEqual(\n  a: IndexDefinitions,\n  b: IndexDefinitions,\n): boolean {\n  if (Object.keys(a).length !== Object.keys(b).length) {\n    return false;\n  }\n  for (const [aKey, aValue] of Object.entries(a)) {\n    const bValue = b[aKey];\n    if (!bValue || !indexDefinitionEqual(aValue, bValue)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function assertIndexDefinitions(\n  value: unknown,\n): asserts value is IndexDefinitions {\n  valita.assert(value, indexDefinitionsSchema);\n}\n"],"mappings":";AAwCA,IAAa,yBAAyB,eAZpC,eAAsB;CACpB,QAAQ,eAAO,OAAO,EAAE,SAAS;CACjC,aAAa,eAAO,OAAO;CAC3B,YAAY,eAAO,QAAQ,EAAE,SAAS;AACxC,CASA,CACF;AAEA,SAAgB,qBACd,GACA,GACS;CACT,OACE,EAAE,gBAAgB,EAAE,gBACnB,EAAE,cAAc,YAAY,EAAE,cAAc,WAC5C,EAAE,UAAU,SAAS,EAAE,UAAU;AAEtC;AAEA,SAAgB,sBACd,GACA,GACS;CACT,IAAI,OAAO,KAAK,CAAC,EAAE,WAAW,OAAO,KAAK,CAAC,EAAE,QAC3C,OAAO;CAET,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,CAAC,GAAG;EAC9C,MAAM,SAAS,EAAE;EACjB,IAAI,CAAC,UAAU,CAAC,qBAAqB,QAAQ,MAAM,GACjD,OAAO;CAEX;CACA,OAAO;AACT"}

package/out/packages/replicache/src/kv/expo-sqlite/store.js

@@ -0,0 +1,57 @@
+import { SQLiteStore, dropStore } from "../sqlite-store.js";
+import { deleteDatabaseSync, openDatabaseSync } from "expo-sqlite";
+//#region ../replicache/src/kv/expo-sqlite/store.ts
+function dropExpoSQLiteStore(name, opts) {
+	return dropStore(name, (filename) => new ExpoSQLiteDatabase(filename), opts);
+}
+/**
+* Creates a StoreProvider for SQLite-based stores using expo-sqlite.
+* Supports shared connections between multiple store instances with the same name,
+* providing efficient resource utilization and proper transaction isolation.
+*/
+function expoSQLiteStoreProvider(opts) {
+	return {
+		create: (name) => new SQLiteStore(name, (name) => new ExpoSQLiteDatabase(name), opts),
+		drop: (name) => dropExpoSQLiteStore(name, opts)
+	};
+}
+var ExpoSQLitePreparedStatement = class {
+	#statement;
+	constructor(statement) {
+		this.#statement = statement;
+	}
+	async exec(params) {
+		await this.#statement.executeForRawResultAsync(params);
+	}
+	async all(params) {
+		return (await this.#statement.executeForRawResultAsync(params)).getAllAsync();
+	}
+};
+var ExpoSQLiteDatabase = class {
+	#db;
+	#filename;
+	#statements = /* @__PURE__ */ new Set();
+	constructor(filename) {
+		this.#filename = filename;
+		this.#db = openDatabaseSync(filename);
+	}
+	close() {
+		for (const stmt of this.#statements) stmt.finalizeSync();
+		this.#db.closeSync();
+	}
+	destroy() {
+		deleteDatabaseSync(this.#filename);
+	}
+	prepare(sql) {
+		const statement = this.#db.prepareSync(sql);
+		this.#statements.add(statement);
+		return new ExpoSQLitePreparedStatement(statement);
+	}
+	execSync(sql) {
+		this.#db.execSync(sql);
+	}
+};
+//#endregion
+export { expoSQLiteStoreProvider };
+
+//# sourceMappingURL=store.js.map

package/out/packages/replicache/src/kv/expo-sqlite/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["#statement","#db","#filename","#statements"],"sources":["../../../../../../../replicache/src/kv/expo-sqlite/store.ts"],"sourcesContent":["import {\n  deleteDatabaseSync,\n  openDatabaseSync,\n  type SQLiteDatabase as DB,\n  type SQLiteStatement,\n} from 'expo-sqlite';\nimport type {\n  PreparedStatement,\n  SQLiteDatabase,\n  SQLiteStoreOptions,\n} from '../sqlite-store.ts';\nimport {dropStore, SQLiteStore} from '../sqlite-store.ts';\nimport type {StoreProvider} from '../store.ts';\n\nexport type ExpoSQLiteStoreOptions = SQLiteStoreOptions;\n\nexport function dropExpoSQLiteStore(\n  name: string,\n  opts?: ExpoSQLiteStoreOptions,\n): Promise<void> {\n  return dropStore(name, filename => new ExpoSQLiteDatabase(filename), opts);\n}\n\n/**\n * Creates a StoreProvider for SQLite-based stores using expo-sqlite.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n */\nexport function expoSQLiteStoreProvider(\n  opts?: ExpoSQLiteStoreOptions,\n): StoreProvider {\n  return {\n    create: name =>\n      new SQLiteStore(name, name => new ExpoSQLiteDatabase(name), opts),\n    drop: name => dropExpoSQLiteStore(name, opts),\n  };\n}\n\nclass ExpoSQLitePreparedStatement implements PreparedStatement {\n  readonly #statement: SQLiteStatement;\n\n  constructor(statement: SQLiteStatement) {\n    this.#statement = statement;\n  }\n\n  async exec(params: string[]): Promise<void> {\n    await this.#statement.executeForRawResultAsync(params);\n  }\n\n  async all(params: string[]): Promise<unknown[][]> {\n    const result = await this.#statement.executeForRawResultAsync(params);\n    return result.getAllAsync() as Promise<unknown[][]>;\n  }\n}\n\nclass ExpoSQLiteDatabase implements SQLiteDatabase {\n  readonly #db: DB;\n  readonly #filename: string;\n  readonly #statements: Set<SQLiteStatement> = new Set();\n\n  constructor(filename: string) {\n    this.#filename = filename;\n    this.#db = openDatabaseSync(filename);\n  }\n\n  close(): void {\n    for (const stmt of this.#statements) {\n      stmt.finalizeSync();\n    }\n    this.#db.closeSync();\n  }\n\n  destroy(): void {\n    deleteDatabaseSync(this.#filename);\n  }\n\n  prepare(sql: string): PreparedStatement {\n    const statement = this.#db.prepareSync(sql);\n    this.#statements.add(statement);\n    return new ExpoSQLitePreparedStatement(statement);\n  }\n\n  execSync(sql: string): void {\n    this.#db.execSync(sql);\n  }\n}\n"],"mappings":";;;AAgBA,SAAgB,oBACd,MACA,MACe;CACf,OAAO,UAAU,OAAM,aAAY,IAAI,mBAAmB,QAAQ,GAAG,IAAI;AAC3E;;;;;;AAOA,SAAgB,wBACd,MACe;CACf,OAAO;EACL,SAAQ,SACN,IAAI,YAAY,OAAM,SAAQ,IAAI,mBAAmB,IAAI,GAAG,IAAI;EAClE,OAAM,SAAQ,oBAAoB,MAAM,IAAI;CAC9C;AACF;AAEA,IAAM,8BAAN,MAA+D;CAC7D;CAEA,YAAY,WAA4B;EACtC,KAAKA,aAAa;CACpB;CAEA,MAAM,KAAK,QAAiC;EAC1C,MAAM,KAAKA,WAAW,yBAAyB,MAAM;CACvD;CAEA,MAAM,IAAI,QAAwC;EAEhD,QAAO,MADc,KAAKA,WAAW,yBAAyB,MAAM,GACtD,YAAY;CAC5B;AACF;AAEA,IAAM,qBAAN,MAAmD;CACjD;CACA;CACA,8BAA6C,IAAI,IAAI;CAErD,YAAY,UAAkB;EAC5B,KAAKE,YAAY;EACjB,KAAKD,MAAM,iBAAiB,QAAQ;CACtC;CAEA,QAAc;EACZ,KAAK,MAAM,QAAQ,KAAKE,aACtB,KAAK,aAAa;EAEpB,KAAKF,IAAI,UAAU;CACrB;CAEA,UAAgB;EACd,mBAAmB,KAAKC,SAAS;CACnC;CAEA,QAAQ,KAAgC;EACtC,MAAM,YAAY,KAAKD,IAAI,YAAY,GAAG;EAC1C,KAAKE,YAAY,IAAI,SAAS;EAC9B,OAAO,IAAI,4BAA4B,SAAS;CAClD;CAEA,SAAS,KAAmB;EAC1B,KAAKF,IAAI,SAAS,GAAG;CACvB;AACF"}

package/out/packages/replicache/src/kv/idb-store-with-mem-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-store-with-mem-fallback.js","names":["#lc","#name","#store","#withBrainTransplant"],"sources":["../../../../../../replicache/src/kv/idb-store-with-mem-fallback.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {navigator} from '../../../shared/src/navigator.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {IDBStore} from './idb-store.ts';\nimport {MemStore, dropMemStore} from './mem-store.ts';\nimport type {Read, Store, Write} from './store.ts';\n\n/**\n * This store uses an {@link IDBStore} by default. If the {@link IDBStore} fails\n * to open the DB with an exception that matches\n * {@link isFirefoxPrivateBrowsingError} we switch out the implementation to use\n * a {@link MemStore} instead.\n *\n * The reason this is relatively complicated is that when {@link IDBStore} is\n * created, it calls `openDatabase` synchronously, but that returns a `Promise`\n * that will reject in the case of Firefox private browsing. We don't await this\n * promise until we call `read` or `write` so we cannot do the switch until\n * then.\n */\n\nexport class IDBStoreWithMemFallback implements Store {\n  readonly #lc: LogContext;\n  readonly #name: string;\n  #store: Store;\n  constructor(lc: LogContext, name: string) {\n    this.#lc = lc;\n    this.#name = name;\n    this.#store = new IDBStore(name);\n  }\n\n  read(): Promise<Read> {\n    return this.#withBrainTransplant(s => s.read());\n  }\n\n  write(): Promise<Write> {\n    return this.#withBrainTransplant(s => s.write());\n  }\n\n  async #withBrainTransplant<T extends Read>(\n    f: (store: Store) => Promise<T>,\n  ): Promise<T> {\n    try {\n      return await f(this.#store);\n    } catch (e) {\n      if (isFirefoxPrivateBrowsingError(e)) {\n        // It is possible that we end up with multiple pending read/write and\n        // they all reject. Make sure we only replace the implementation once.\n        if (this.#store instanceof IDBStore) {\n          this.#lc.info?.(\n            'Switching to MemStore because of Firefox private browsing error',\n          );\n          this.#store = new MemStore(this.#name);\n        }\n        return f(this.#store);\n      }\n      throw e;\n    }\n  }\n\n  close(): Promise<void> {\n    return this.#store.close();\n  }\n\n  get closed(): boolean {\n    return this.#store.closed;\n  }\n}\n\nfunction isFirefoxPrivateBrowsingError(e: unknown): e is DOMException {\n  return (\n    isFirefox() &&\n    e instanceof DOMException &&\n    e.name === 'InvalidStateError' &&\n    e.message ===\n      'A mutation operation was attempted on a database that did not allow mutations.'\n  );\n}\n\nfunction isFirefox(): boolean {\n  return navigator?.userAgent?.includes('Firefox') ?? false;\n}\n\nexport function newIDBStoreWithMemFallback(\n  lc: LogContext,\n  name: string,\n): Store {\n  if (isFirefox()) {\n    return new IDBStoreWithMemFallback(lc, name);\n  }\n  return new IDBStore(name);\n}\n\nexport function dropIDBStoreWithMemFallback(name: string): Promise<void> {\n  if (!isFirefox()) {\n    return dropIDBStore(name);\n  }\n  try {\n    return dropIDBStore(name);\n  } catch (e) {\n    if (isFirefoxPrivateBrowsingError(e)) {\n      return dropMemStore(name);\n    }\n  }\n  return promiseVoid;\n}\n\nfunction dropIDBStore(name: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const req = indexedDB.deleteDatabase(name);\n    req.onsuccess = () => resolve();\n    req.onerror = () => reject(req.error);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,IAAa,0BAAb,MAAsD;CACpD;CACA;CACA;CACA,YAAY,IAAgB,MAAc;EACxC,KAAKA,MAAM;EACX,KAAKC,QAAQ;EACb,KAAKC,SAAS,IAAI,SAAS,IAAI;CACjC;CAEA,OAAsB;EACpB,OAAO,KAAKC,sBAAqB,MAAK,EAAE,KAAK,CAAC;CAChD;CAEA,QAAwB;EACtB,OAAO,KAAKA,sBAAqB,MAAK,EAAE,MAAM,CAAC;CACjD;CAEA,MAAMA,qBACJ,GACY;EACZ,IAAI;GACF,OAAO,MAAM,EAAE,KAAKD,MAAM;EAC5B,SAAS,GAAG;GACV,IAAI,8BAA8B,CAAC,GAAG;IAGpC,IAAI,KAAKA,kBAAkB,UAAU;KACnC,KAAKF,IAAI,OACP,iEACF;KACA,KAAKE,SAAS,IAAI,SAAS,KAAKD,KAAK;IACvC;IACA,OAAO,EAAE,KAAKC,MAAM;GACtB;GACA,MAAM;EACR;CACF;CAEA,QAAuB;EACrB,OAAO,KAAKA,OAAO,MAAM;CAC3B;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA,OAAO;CACrB;AACF;AAEA,SAAS,8BAA8B,GAA+B;CACpE,OACE,UAAU,KACV,aAAa,gBACb,EAAE,SAAS,uBACX,EAAE,YACA;AAEN;AAEA,SAAS,YAAqB;CAC5B,OAAO,gBAAW,WAAW,SAAS,SAAS,KAAK;AACtD;AAEA,SAAgB,2BACd,IACA,MACO;CACP,IAAI,UAAU,GACZ,OAAO,IAAI,wBAAwB,IAAI,IAAI;CAE7C,OAAO,IAAI,SAAS,IAAI;AAC1B;AAEA,SAAgB,4BAA4B,MAA6B;CACvE,IAAI,CAAC,UAAU,GACb,OAAO,aAAa,IAAI;CAE1B,IAAI;EACF,OAAO,aAAa,IAAI;CAC1B,SAAS,GAAG;EACV,IAAI,8BAA8B,CAAC,GACjC,OAAO,aAAa,IAAI;CAE5B;CACA,OAAO;AACT;AAEA,SAAS,aAAa,MAA6B;CACjD,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,MAAM,UAAU,eAAe,IAAI;EACzC,IAAI,kBAAkB,QAAQ;EAC9B,IAAI,gBAAgB,OAAO,IAAI,KAAK;CACtC,CAAC;AACH"}

package/out/packages/replicache/src/kv/idb-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-store.js","names":["#db","#closed","#withReopen","#idbDeleted","#tx"],"sources":["../../../../../../replicache/src/kv/idb-store.ts"],"sourcesContent":["import {resolver} from '@rocicorp/resolver';\nimport {assertNotNull} from '../../../shared/src/asserts.ts';\nimport {mustGetBrowserGlobal} from '../../../shared/src/browser-env.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {\n  type FrozenJSONValue,\n  deepFreezeAllowUndefined,\n} from '../frozen-json.ts';\nimport type {Read, Store, Write} from './store.ts';\nimport {\n  storeIsClosedRejection,\n  transactionIsClosedRejection,\n} from './throw-if-closed.ts';\nimport {WriteImplBase, deleteSentinel} from './write-impl-base.ts';\n\nconst RELAXED = {durability: 'relaxed'} as const;\nconst OBJECT_STORE = 'chunks';\n\nexport class IDBStore implements Store {\n  #db: Promise<IDBDatabase>;\n  #closed = false;\n  #idbDeleted = false;\n\n  constructor(name: string) {\n    this.#db = openDatabase(name);\n  }\n\n  read(): Promise<Read> {\n    if (this.#closed) {\n      return storeIsClosedRejection();\n    }\n    return this.#withReopen(readImpl);\n  }\n\n  write(): Promise<Write> {\n    if (this.#closed) {\n      return storeIsClosedRejection();\n    }\n    return this.#withReopen(writeImpl);\n  }\n\n  async close(): Promise<void> {\n    if (!this.#idbDeleted) {\n      const db = await this.#db;\n      db.close();\n    }\n    this.#closed = true;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  async #withReopen<R>(fn: (db: IDBDatabase) => R): Promise<R> {\n    // Tries to reopen an IndexedDB, and rejects if the database needs\n    // upgrading (is missing for whatever reason).\n    const reopenExistingDB = async (name: string): Promise<IDBDatabase> => {\n      const {promise, resolve, reject} = resolver<IDBDatabase>();\n      const req = indexedDB.open(name);\n\n      req.onupgradeneeded = () => {\n        const tx = req.transaction;\n        assertNotNull(tx);\n        tx.abort();\n        this.#idbDeleted = true;\n        reject(\n          new IDBNotFoundError(\n            `Expected IndexedDB not found: ${name}. This likely means that the user deleted IndexedDB instances while the app was running. This is non-fatal. The app will continue running in memory until reload.`,\n          ),\n        );\n      };\n\n      req.onsuccess = () => resolve(req.result);\n      req.onerror = () => reject(req.error);\n\n      const db = await promise;\n      db.onversionchange = () => db.close();\n      return db;\n    };\n\n    // We abstract on `readImpl` to work around an issue in Safari. Safari does\n    // not allow any microtask between a transaction is created until it is\n    // first used. We used to use `await read()` here instead of `await\n    // this._db` but then there is a microtask between the creation of the\n    // transaction and the return of this function. By doing `await this._db`\n    // here we only await the db and no await is involved with the transaction.\n    // See https://github.com/jakearchibald/idb-keyval/commit/1af0a00b1a70a678d2f9cf5e74c55a22e57324c5#r55989916\n    const db = await this.#db;\n\n    try {\n      return fn(db);\n    } catch (e: unknown) {\n      if (!this.#closed && e instanceof DOMException) {\n        if (e.name === 'InvalidStateError') {\n          this.#db = reopenExistingDB(db.name);\n          const reopened = await this.#db;\n          return fn(reopened);\n        } else if (e.name === 'NotFoundError') {\n          // This edge-case can happen if the db has been deleted and the\n          // user/developer has DevTools open in certain browsers.\n          // See discussion at https://github.com/rocicorp/replicache-internal/pull/216\n          this.#idbDeleted = true;\n          mustGetBrowserGlobal('indexedDB').deleteDatabase(db.name);\n          throw new IDBNotFoundError(\n            `Expected IndexedDB ${db.name} missing object store. Deleting db. This is non-fatal, the app will continue working in memory until it is reloaded.`,\n          );\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nclass ReadImpl implements Read {\n  readonly #tx: IDBTransaction;\n  #closed = false;\n\n  constructor(tx: IDBTransaction) {\n    this.#tx = tx;\n  }\n\n  has(key: string): Promise<boolean> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    return new Promise((resolve, reject) => {\n      const req = objectStore(this.#tx).count(key);\n      req.onsuccess = () => resolve(req.result > 0);\n      req.onerror = () => reject(req.error);\n    });\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    return new Promise((resolve, reject) => {\n      const req = objectStore(this.#tx).get(key);\n      req.onsuccess = () => resolve(deepFreezeAllowUndefined(req.result));\n      req.onerror = () => reject(req.error);\n    });\n  }\n\n  release(): void {\n    this.#closed = true;\n    // Do nothing. We rely on IDB locking.\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nclass WriteImpl extends WriteImplBase {\n  readonly #tx: IDBTransaction;\n  #closed = false;\n\n  constructor(tx: IDBTransaction) {\n    super(new ReadImpl(tx));\n    this.#tx = tx;\n  }\n\n  commit(): Promise<void> {\n    if (this.#closed) {\n      return transactionIsClosedRejection();\n    }\n    if (this._pending.size === 0) {\n      return promiseVoid;\n    }\n\n    return new Promise((resolve, reject) => {\n      const tx = this.#tx;\n      const store = objectStore(tx);\n      for (const [key, val] of this._pending) {\n        if (val === deleteSentinel) {\n          store.delete(key);\n        } else {\n          store.put(val, key);\n        }\n      }\n      tx.oncomplete = () => resolve();\n      tx.onerror = () => reject(tx.error);\n    });\n  }\n\n  release(): void {\n    // We rely on IDB locking so no need to do anything here.\n    this.#closed = true;\n    super.release();\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nfunction writeImpl(db: IDBDatabase): Write {\n  const tx = db.transaction(OBJECT_STORE, 'readwrite', RELAXED);\n  return new WriteImpl(tx);\n}\n\nfunction readImpl(db: IDBDatabase): Read {\n  const tx = db.transaction(OBJECT_STORE, 'readonly');\n  return new ReadImpl(tx);\n}\n\nfunction objectStore(tx: IDBTransaction): IDBObjectStore {\n  return tx.objectStore(OBJECT_STORE);\n}\n\nfunction openDatabase(name: string): Promise<IDBDatabase> {\n  const idb = mustGetBrowserGlobal('indexedDB');\n  return new Promise((resolve, reject) => {\n    const req = idb.open(name);\n    req.onupgradeneeded = () => {\n      req.result.createObjectStore(OBJECT_STORE);\n    };\n    req.onsuccess = () => {\n      const db = req.result;\n      // Another tab/process wants to modify the db, so release it.\n      db.onversionchange = () => db.close();\n      resolve(db);\n    };\n    req.onerror = () => reject(req.error);\n  });\n}\n\n/**\n * This error is thrown when we detect that the IndexedDB has been removed. This\n * does not normally happen but can happen during development if the user has\n * DevTools open and deletes the IndexedDB from there.\n */\nexport class IDBNotFoundError extends Error {\n  name = 'IDBNotFoundError';\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/kv/mem-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mem-store.js","names":["#map","#rwLock","#closed"],"sources":["../../../../../../replicache/src/kv/mem-store.ts"],"sourcesContent":["import {RWLock} from '@rocicorp/lock';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {ReadImpl} from './read-impl.ts';\nimport type {Read, Store, Write} from './store.ts';\nimport {throwIfStoreClosed} from './throw-if-closed.ts';\nimport {WriteImpl} from './write-impl.ts';\n\ntype StorageMap = Map<string, FrozenJSONValue>;\n\ntype Value = {readonly lock: RWLock; readonly map: StorageMap};\n\nconst stores = new Map<string, Value>();\n\nexport function clearAllNamedMemStoresForTesting(): void {\n  stores.clear();\n}\n\nexport function dropMemStore(name: string): Promise<void> {\n  stores.delete(name);\n  return promiseVoid;\n}\n\nexport function hasMemStore(name: string): boolean {\n  return stores.has(name);\n}\n\n/**\n * A named in-memory Store implementation.\n *\n * Two (or more) named memory stores with the same name will share the same\n * underlying storage. They will also share the same read/write locks, so that\n * only one write transaction can be running at the same time.\n *\n * @experimental This class is experimental and might be removed or changed\n * in the future without following semver versioning. Please be cautious.\n */\nexport class MemStore implements Store {\n  readonly #map: StorageMap;\n  readonly #rwLock: RWLock;\n  #closed = false;\n\n  constructor(name: string) {\n    const entry = stores.get(name);\n    let lock: RWLock;\n    let map: StorageMap;\n    if (entry) {\n      ({lock, map} = entry);\n    } else {\n      lock = new RWLock();\n      map = new Map();\n      stores.set(name, {lock, map});\n    }\n    this.#rwLock = lock;\n    this.#map = map;\n  }\n\n  async read(): Promise<Read> {\n    throwIfStoreClosed(this);\n    const release = await this.#rwLock.read();\n    return new ReadImpl(this.#map, release);\n  }\n\n  async write(): Promise<Write> {\n    throwIfStoreClosed(this);\n    const release = await this.#rwLock.write();\n    return new WriteImpl(this.#map, release);\n  }\n\n  close(): Promise<void> {\n    this.#closed = true;\n    return promiseVoid;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n"],"mappings":";;;;;;AAYA,IAAM,yBAAS,IAAI,IAAmB;AAMtC,SAAgB,aAAa,MAA6B;CACxD,OAAO,OAAO,IAAI;CAClB,OAAO;AACT;;;;;;;;;;;AAgBA,IAAa,WAAb,MAAuC;CACrC;CACA;CACA,UAAU;CAEV,YAAY,MAAc;EACxB,MAAM,QAAQ,OAAO,IAAI,IAAI;EAC7B,IAAI;EACJ,IAAI;EACJ,IAAI,OACF,CAAC,CAAC,MAAM,OAAO;OACV;GACL,OAAO,IAAI,OAAO;GAClB,sBAAM,IAAI,IAAI;GACd,OAAO,IAAI,MAAM;IAAC;IAAM;GAAG,CAAC;EAC9B;EACA,KAAKC,UAAU;EACf,KAAKD,OAAO;CACd;CAEA,MAAM,OAAsB;EAC1B,mBAAmB,IAAI;EACvB,MAAM,UAAU,MAAM,KAAKC,QAAQ,KAAK;EACxC,OAAO,IAAI,SAAS,KAAKD,MAAM,OAAO;CACxC;CAEA,MAAM,QAAwB;EAC5B,mBAAmB,IAAI;EACvB,MAAM,UAAU,MAAM,KAAKC,QAAQ,MAAM;EACzC,OAAO,IAAI,UAAU,KAAKD,MAAM,OAAO;CACzC;CAEA,QAAuB;EACrB,KAAKE,UAAU;EACf,OAAO;CACT;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA;CACd;AACF"}

package/out/packages/replicache/src/kv/op-sqlite/store.js

@@ -0,0 +1,63 @@
+import { SQLiteStore, dropStore } from "../sqlite-store.js";
+import { open } from "./types.js";
+//#region ../replicache/src/kv/op-sqlite/store.ts
+function dropOpSQLiteStore(name, opts) {
+	return dropStore(name, (filename, options) => new OpSQLiteDatabase(filename, options), opts);
+}
+/**
+* Creates a StoreProvider for SQLite-based stores using @op-engineering/op-sqlite.
+* Supports shared connections between multiple store instances with the same name,
+* providing efficient resource utilization and proper transaction isolation.
+* Uses parameterized queries for safety and performance.
+*/
+function opSQLiteStoreProvider(opts) {
+	return {
+		create: (name) => new SQLiteStore(name, (name, options) => new OpSQLiteDatabase(name, options), opts),
+		drop: (name) => dropOpSQLiteStore(name, opts)
+	};
+}
+var OpSQLitePreparedStatement = class {
+	#db;
+	#sql;
+	constructor(db, sql) {
+		this.#db = db;
+		this.#sql = sql;
+	}
+	async exec(params) {
+		await this.#db.executeRaw(this.#sql, params);
+	}
+	all(params) {
+		return this.#db.executeRaw(this.#sql, params);
+	}
+};
+var OpSQLiteDatabase = class {
+	#db;
+	#filename;
+	constructor(filename, opts) {
+		this.#filename = filename;
+		const openOpts = { name: filename };
+		if (opts?.location) openOpts.location = opts.location;
+		if (opts?.encryptionKey) openOpts.encryptionKey = opts.encryptionKey;
+		this.#db = open(openOpts);
+	}
+	close() {
+		this.#db.close();
+	}
+	destroy() {
+		try {
+			const tempDb = open({ name: this.#filename });
+			tempDb.delete();
+			tempDb.close();
+		} catch (_error) {}
+	}
+	prepare(sql) {
+		return new OpSQLitePreparedStatement(this.#db, sql);
+	}
+	execSync(sql) {
+		this.#db.executeRawSync(sql, []);
+	}
+};
+//#endregion
+export { opSQLiteStoreProvider };
+
+//# sourceMappingURL=store.js.map

package/out/packages/replicache/src/kv/op-sqlite/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["#db","#sql","#filename"],"sources":["../../../../../../../replicache/src/kv/op-sqlite/store.ts"],"sourcesContent":["import type {\n  PreparedStatement,\n  SQLiteDatabase,\n  SQLiteStoreOptions,\n} from '../sqlite-store.ts';\nimport {dropStore, SQLiteStore} from '../sqlite-store.ts';\nimport type {StoreProvider} from '../store.ts';\nimport {open, type DB} from './types.ts';\n\nexport type OpSQLiteStoreOptions = SQLiteStoreOptions & {\n  // OpSQLite-specific options\n  location?: 'default' | 'Library' | 'Documents' | 'Temporary';\n  encryptionKey?: string;\n};\n\nfunction dropOpSQLiteStore(\n  name: string,\n  opts?: OpSQLiteStoreOptions,\n): Promise<void> {\n  return dropStore(\n    name,\n    (filename, options) => new OpSQLiteDatabase(filename, options),\n    opts,\n  );\n}\n\n/**\n * Creates a StoreProvider for SQLite-based stores using @op-engineering/op-sqlite.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n * Uses parameterized queries for safety and performance.\n */\nexport function opSQLiteStoreProvider(\n  opts?: OpSQLiteStoreOptions,\n): StoreProvider {\n  return {\n    create: name =>\n      new SQLiteStore(\n        name,\n        (name, options) => new OpSQLiteDatabase(name, options),\n        opts,\n      ),\n    drop: name => dropOpSQLiteStore(name, opts),\n  };\n}\n\nclass OpSQLitePreparedStatement implements PreparedStatement {\n  readonly #db: DB;\n  readonly #sql: string;\n\n  constructor(db: DB, sql: string) {\n    this.#db = db;\n    this.#sql = sql;\n  }\n\n  async exec(params: string[]): Promise<void> {\n    await this.#db.executeRaw(this.#sql, params);\n  }\n\n  all(params: string[]): Promise<unknown[][]> {\n    return this.#db.executeRaw(this.#sql, params);\n  }\n}\n\nclass OpSQLiteDatabase implements SQLiteDatabase {\n  readonly #db: DB;\n  readonly #filename: string;\n\n  constructor(filename: string, opts?: OpSQLiteStoreOptions) {\n    this.#filename = filename;\n    const openOpts: {\n      name: string;\n      location?: string;\n      encryptionKey?: string;\n    } = {name: filename};\n\n    if (opts?.location) {\n      openOpts.location = opts.location;\n    }\n    if (opts?.encryptionKey) {\n      openOpts.encryptionKey = opts.encryptionKey;\n    }\n\n    this.#db = open(openOpts);\n  }\n\n  close(): void {\n    this.#db.close();\n  }\n\n  destroy(): void {\n    // OpSQLite uses delete method on the database instance\n    // We need to create a temporary connection to delete the database\n    try {\n      const tempDb = open({name: this.#filename});\n      tempDb.delete();\n      tempDb.close();\n    } catch (_error) {\n      // Database might not exist, which is fine\n    }\n  }\n\n  prepare(sql: string): PreparedStatement {\n    return new OpSQLitePreparedStatement(this.#db, sql);\n  }\n\n  execSync(sql: string): void {\n    this.#db.executeRawSync(sql, []);\n  }\n}\n"],"mappings":";;;AAeA,SAAS,kBACP,MACA,MACe;CACf,OAAO,UACL,OACC,UAAU,YAAY,IAAI,iBAAiB,UAAU,OAAO,GAC7D,IACF;AACF;;;;;;;AAQA,SAAgB,sBACd,MACe;CACf,OAAO;EACL,SAAQ,SACN,IAAI,YACF,OACC,MAAM,YAAY,IAAI,iBAAiB,MAAM,OAAO,GACrD,IACF;EACF,OAAM,SAAQ,kBAAkB,MAAM,IAAI;CAC5C;AACF;AAEA,IAAM,4BAAN,MAA6D;CAC3D;CACA;CAEA,YAAY,IAAQ,KAAa;EAC/B,KAAKA,MAAM;EACX,KAAKC,OAAO;CACd;CAEA,MAAM,KAAK,QAAiC;EAC1C,MAAM,KAAKD,IAAI,WAAW,KAAKC,MAAM,MAAM;CAC7C;CAEA,IAAI,QAAwC;EAC1C,OAAO,KAAKD,IAAI,WAAW,KAAKC,MAAM,MAAM;CAC9C;AACF;AAEA,IAAM,mBAAN,MAAiD;CAC/C;CACA;CAEA,YAAY,UAAkB,MAA6B;EACzD,KAAKC,YAAY;EACjB,MAAM,WAIF,EAAC,MAAM,SAAQ;EAEnB,IAAI,MAAM,UACR,SAAS,WAAW,KAAK;EAE3B,IAAI,MAAM,eACR,SAAS,gBAAgB,KAAK;EAGhC,KAAKF,MAAM,KAAK,QAAQ;CAC1B;CAEA,QAAc;EACZ,KAAKA,IAAI,MAAM;CACjB;CAEA,UAAgB;EAGd,IAAI;GACF,MAAM,SAAS,KAAK,EAAC,MAAM,KAAKE,UAAS,CAAC;GAC1C,OAAO,OAAO;GACd,OAAO,MAAM;EACf,SAAS,QAAQ,CAEjB;CACF;CAEA,QAAQ,KAAgC;EACtC,OAAO,IAAI,0BAA0B,KAAKF,KAAK,GAAG;CACpD;CAEA,SAAS,KAAmB;EAC1B,KAAKA,IAAI,eAAe,KAAK,CAAC,CAAC;CACjC;AACF"}

package/out/packages/replicache/src/kv/op-sqlite/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../../../replicache/src/kv/op-sqlite/types.ts"],"sourcesContent":["// Type definitions and imports for @op-engineering/op-sqlite\n// This file isolates the module resolution workarounds needed for this package\n\nimport {open as openDB} from '@op-engineering/op-sqlite';\n\n// Minimal type definitions for @op-engineering/op-sqlite\n// These types are used as fallback since imports have module resolution issues\nexport interface DB {\n  close: () => void;\n  delete: (location?: string) => void;\n  executeRaw: (query: string, params?: string[]) => Promise<string[][]>;\n  executeRawSync: (query: string, params?: string[]) => string[][];\n}\n\nexport type OpenFunction = (params: {\n  name: string;\n  location?: string;\n  encryptionKey?: string;\n}) => DB;\n\n// Export the open function with proper typing\nexport const open: OpenFunction = openDB;\n"],"mappings":";;AAqBA,IAAa,SAAqB"}

package/out/packages/replicache/src/kv/read-impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-impl.js","names":["#map","#release","#closed"],"sources":["../../../../../../replicache/src/kv/read-impl.ts"],"sourcesContent":["import type {FrozenJSONValue} from '../frozen-json.ts';\nimport type {Read} from './store.ts';\nimport {maybeTransactionIsClosedRejection} from './throw-if-closed.ts';\n\nexport class ReadImpl implements Read {\n  readonly #map: Map<string, FrozenJSONValue>;\n  readonly #release: () => void;\n  #closed = false;\n\n  constructor(map: Map<string, FrozenJSONValue>, release: () => void) {\n    this.#map = map;\n    this.#release = release;\n  }\n\n  release() {\n    this.#release();\n    this.#closed = true;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  has(key: string): Promise<boolean> {\n    return (\n      maybeTransactionIsClosedRejection(this) ??\n      Promise.resolve(this.#map.has(key))\n    );\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    return (\n      maybeTransactionIsClosedRejection(this) ??\n      Promise.resolve(this.#map.get(key))\n    );\n  }\n}\n"],"mappings":";;AAIA,IAAa,WAAb,MAAsC;CACpC;CACA;CACA,UAAU;CAEV,YAAY,KAAmC,SAAqB;EAClE,KAAKA,OAAO;EACZ,KAAKC,WAAW;CAClB;CAEA,UAAU;EACR,KAAKA,SAAS;EACd,KAAKC,UAAU;CACjB;CAEA,IAAI,SAAkB;EACpB,OAAO,KAAKA;CACd;CAEA,IAAI,KAA+B;EACjC,OACE,kCAAkC,IAAI,KACtC,QAAQ,QAAQ,KAAKF,KAAK,IAAI,GAAG,CAAC;CAEtC;CAEA,IAAI,KAAmD;EACrD,OACE,kCAAkC,IAAI,KACtC,QAAQ,QAAQ,KAAKA,KAAK,IAAI,GAAG,CAAC;CAEtC;AACF"}