npm - @rocicorp/zero - Versions diffs - 1.12.0-canary.0 → 1.12.0-canary.10 - Mend

@rocicorp/zero 1.12.0-canary.0 → 1.12.0-canary.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1387) hide show

package/out/replicache/src/btree/write.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"write.js","names":["#lock","#modified","#addToModified"],"sources":["../../../../../replicache/src/btree/write.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport {type Chunk, type CreateChunk, toRefs} from '../dag/chunk.ts';\nimport type {Write} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport {\n DataNodeImpl,\n type Entry,\n InternalNodeImpl,\n createNewInternalEntryForNode,\n emptyDataNode,\n isDataNodeImpl,\n newNodeImpl,\n partition,\n toChunkData,\n} from './node.ts';\nimport {BTreeRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class BTreeWrite extends BTreeRead {\n /*\n This rw lock is used to ensure we do not mutate the btree in parallel. It\n * would be a problem if we didn't have the lock in cases like this:\n \n ```ts\n * const p1 = tree.put('a', 0);\n * const p2 = tree.put('b', 1);\n * await p1;\n * await p2;\n * ```\n \n because both `p1` and `p2` would start from the old root hash but a put\n * changes the root hash so the two concurrent puts would lead to only one of\n * them actually working, and it is not deterministic which one would finish\n * last.\n /\n readonly #lock = new Lock();\n readonly #modified: Map<Hash, DataNodeImpl \| InternalNodeImpl> = new Map();\n\n declare protected _dagRead: Write;\n\n readonly minSize: number;\n readonly maxSize: number;\n\n constructor(\n dagWrite: Write,\n formatVersion: FormatVersion,\n root: Hash = emptyHash,\n minSize = 8 1024,\n maxSize = 16 * 1024,\n getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n chunkHeaderSize?: number,\n ) {\n super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);\n\n this.minSize = minSize;\n this.maxSize = maxSize;\n }\n\n #addToModified(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.set(node.hash, node);\n this._cache.set(node.hash, node);\n }\n\n updateNode(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.delete(node.hash);\n node.hash = newRandomHash();\n this.#addToModified(node);\n }\n\n newInternalNodeImpl(\n entries: Array<Entry<Hash>>,\n level: number,\n ): InternalNodeImpl {\n const n = new InternalNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n newDataNodeImpl(entries: Entry<FrozenJSONValue>[]): DataNodeImpl {\n const n = new DataNodeImpl(entries, newRandomHash(), true);\n this.#addToModified(n);\n return n;\n }\n\n newNodeImpl(entries: Entry<FrozenJSONValue>[], level: number): DataNodeImpl;\n newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl {\n const n = newNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n put(key: string, value: FrozenJSONValue): Promise<void> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const entrySize = this.getEntrySize(key, value);\n const rootNode = await oldRootNode.set(key, value, entrySize, this);\n\n // We do the rebalancing in the parent so we need to do it here as well.\n if (rootNode.getChildNodeSize(this) > this.maxSize) {\n const headerSize = this.chunkHeaderSize;\n const {level} = rootNode;\n const entries = partition(\n rootNode.entries,\n value => value[2],\n this.minSize - headerSize,\n this.maxSize - headerSize,\n entries => {\n const node = this.newNodeImpl(entries, level);\n return createNewInternalEntryForNode(node, this.getEntrySize);\n },\n );\n const newRoot = this.newInternalNodeImpl(entries, level + 1);\n this.rootHash = newRoot.hash;\n return;\n }\n\n this.rootHash = rootNode.hash;\n });\n }\n\n /*\n Inserts multiple key-value pairs into the BTree efficiently.\n * The entries array must be sorted by key.\n * @param entries - Array of [key, value] tuples, must be sorted by key\n * @returns Promise that resolves when all entries are inserted\n */\n putMany(\n entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n ): Promise<void> {\n return this.#lock.withLock(async () => {\n if (entries.length === 0) {\n return;\n }\n\n // Validate sortedness and convert to sized entries in one pass\n const sizedEntries: Entry<FrozenJSONValue>[] = entries.map(\n ([k, v], i) => {\n if (i > 0) {\n assert(\n entries[i - 1][0] < k,\n `putMany entries must be sorted and unique`,\n );\n }\n return [k, v, this.getEntrySize(k, v)];\n },\n );\n\n // Compute content size constraints\n const headerSize = this.chunkHeaderSize;\n const contentMin = this.minSize - headerSize;\n const contentMax = this.maxSize - headerSize;\n\n // Fast path: if tree is empty, use bulk loading algorithm\n if (this.rootHash === emptyHash) {\n // Build leaf nodes\n const leafPartitions = partition(\n sizedEntries,\n e => e[2],\n contentMin,\n contentMax,\n entries => entries,\n );\n\n if (leafPartitions.length === 0) {\n return;\n }\n\n if (leafPartitions.length === 1) {\n const leaf = this.newDataNodeImpl(leafPartitions[0]);\n this.rootHash = leaf.hash;\n return;\n }\n\n // Build tree bottom-up - reuse array to avoid allocations\n let currentLevel: Array<DataNodeImpl \| InternalNodeImpl \| Entry<Hash>> =\n leafPartitions.map(entries => this.newDataNodeImpl(entries));\n let level = 0;\n\n while (currentLevel.length > 1) {\n level++;\n\n // Create entries pointing to current level nodes - reuse array\n const parentEntriesLength = currentLevel.length;\n for (let i = 0; i < parentEntriesLength; i++) {\n currentLevel[i] = createNewInternalEntryForNode(\n currentLevel[i] as DataNodeImpl \| InternalNodeImpl,\n this.getEntrySize,\n );\n }\n\n // Partition parent entries\n const parentPartitions = partition(\n currentLevel as Entry<Hash>[],\n e => e[2],\n contentMin,\n contentMax,\n entries => entries,\n );\n\n // Create internal nodes\n currentLevel = parentPartitions.map(entries =>\n this.newInternalNodeImpl(entries, level),\n );\n }\n\n this.rootHash = (\n currentLevel[0] as DataNodeImpl \| InternalNodeImpl\n ).hash;\n return;\n }\n\n // Slow path: merge with existing tree\n const oldRootNode = await this.getNode(this.rootHash);\n const rootNode = await oldRootNode.putMany(sizedEntries, this);\n\n // We do the rebalancing in the parent so we need to do it here as well.\n if (rootNode.getChildNodeSize(this) > this.maxSize) {\n const {level} = rootNode;\n const entries: Entry<Hash>[] = partition(\n rootNode.entries,\n e => e[2],\n contentMin,\n contentMax,\n partitionEntries => {\n const node = this.newNodeImpl(partitionEntries, level);\n return createNewInternalEntryForNode(node, this.getEntrySize);\n },\n );\n const newRoot = this.newInternalNodeImpl(entries, level + 1);\n this.rootHash = newRoot.hash;\n return;\n }\n\n this.rootHash = rootNode.hash;\n });\n }\n\n del(key: string): Promise<boolean> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const newRootNode = await oldRootNode.del(key, this);\n\n // No need to rebalance here since if root gets too small there is nothing\n // we can do about that.\n const found = this.rootHash !== newRootNode.hash;\n if (found) {\n // Flatten one layer.\n if (newRootNode.level > 0 && newRootNode.entries.length === 1) {\n this.rootHash = (newRootNode as InternalNodeImpl).entries[0][1];\n } else {\n this.rootHash = newRootNode.hash;\n }\n }\n\n return found;\n });\n }\n\n clear(): Promise<void> {\n return this.#lock.withLock(() => {\n this.#modified.clear();\n this.rootHash = emptyHash;\n });\n }\n\n flush(): Promise<Hash> {\n return this.#lock.withLock(async () => {\n const dagWrite = this._dagRead;\n\n if (this.rootHash === emptyHash) {\n // Write a chunk for the empty tree.\n const chunk = dagWrite.createChunk(emptyDataNode, []);\n await dagWrite.putChunk(chunk as Chunk<ReadonlyJSONValue>);\n return chunk.hash;\n }\n\n const newChunks: Chunk[] = [];\n const newRoot = gatherNewChunks(\n this.rootHash,\n newChunks,\n dagWrite.createChunk,\n this.#modified,\n this._formatVersion,\n );\n await Promise.all(newChunks.map(chunk => dagWrite.putChunk(chunk)));\n this.#modified.clear();\n this.rootHash = newRoot;\n return newRoot;\n });\n }\n}\n\nfunction gatherNewChunks(\n hash: Hash,\n newChunks: Chunk[],\n createChunk: CreateChunk,\n modified: Map<Hash, DataNodeImpl \| InternalNodeImpl>,\n formatVersion: FormatVersion,\n): Hash {\n const node = modified.get(hash);\n if (node === undefined) {\n // Not modified, use the original.\n return hash;\n }\n\n if (isDataNodeImpl(node)) {\n const chunk = createChunk(toChunkData(node, formatVersion), []);\n newChunks.push(chunk);\n return chunk.hash;\n }\n\n // The BTree cannot have duplicate keys so the child entry hashes are unique.\n // No need fot a set to dedupe here.\n const refs: Hash[] = [];\n const {entries} = node;\n for (let i = 0; i < entries.length; i++) {\n const entry = entries[i];\n const childHash = entry[1];\n const newChildHash = gatherNewChunks(\n childHash,\n newChunks,\n createChunk,\n modified,\n formatVersion,\n );\n if (newChildHash !== childHash) {\n // MUTATES the entries!\n // Hashes do not change the size of the entry because all hashes have the same length\n entries[i] = [entry[0], newChildHash, entry[2]];\n }\n refs.push(newChildHash);\n }\n const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));\n newChunks.push(chunk);\n return chunk.hash;\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"write.js","names":[],"sources":["../../../../../replicache/src/btree/write.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport {type Chunk, type CreateChunk, toRefs} from '../dag/chunk.ts';\nimport type {Write} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport {\n DataNodeImpl,\n type Entry,\n InternalNodeImpl,\n createNewInternalEntryForNode,\n emptyDataNode,\n isDataNodeImpl,\n newNodeImpl,\n partition,\n toChunkData,\n} from './node.ts';\nimport {BTreeRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class BTreeWrite extends BTreeRead {\n /*\n This rw lock is used to ensure we do not mutate the btree in parallel. It\n * would be a problem if we didn't have the lock in cases like this:\n \n ```ts\n * const p1 = tree.put('a', 0);\n * const p2 = tree.put('b', 1);\n * await p1;\n * await p2;\n * ```\n \n because both `p1` and `p2` would start from the old root hash but a put\n * changes the root hash so the two concurrent puts would lead to only one of\n * them actually working, and it is not deterministic which one would finish\n * last.\n /\n readonly #lock = new Lock();\n readonly #modified: Map<Hash, DataNodeImpl \| InternalNodeImpl> = new Map();\n\n declare protected _dagRead: Write;\n\n readonly minSize: number;\n readonly maxSize: number;\n\n constructor(\n dagWrite: Write,\n formatVersion: FormatVersion,\n root: Hash = emptyHash,\n minSize = 8 1024,\n maxSize = 16 * 1024,\n getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n chunkHeaderSize?: number,\n ) {\n super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);\n\n this.minSize = minSize;\n this.maxSize = maxSize;\n }\n\n #addToModified(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.set(node.hash, node);\n this._cache.set(node.hash, node);\n }\n\n updateNode(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.delete(node.hash);\n node.hash = newRandomHash();\n this.#addToModified(node);\n }\n\n newInternalNodeImpl(\n entries: Array<Entry<Hash>>,\n level: number,\n ): InternalNodeImpl {\n const n = new InternalNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n newDataNodeImpl(entries: Entry<FrozenJSONValue>[]): DataNodeImpl {\n const n = new DataNodeImpl(entries, newRandomHash(), true);\n this.#addToModified(n);\n return n;\n }\n\n newNodeImpl(entries: Entry<FrozenJSONValue>[], level: number): DataNodeImpl;\n newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl {\n const n = newNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n put(key: string, value: FrozenJSONValue): Promise<void> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const entrySize = this.getEntrySize(key, value);\n const rootNode = await oldRootNode.set(key, value, entrySize, this);\n\n // We do the rebalancing in the parent so we need to do it here as well.\n if (rootNode.getChildNodeSize(this) > this.maxSize) {\n const headerSize = this.chunkHeaderSize;\n const {level} = rootNode;\n const entries = partition(\n rootNode.entries,\n value => value[2],\n this.minSize - headerSize,\n this.maxSize - headerSize,\n entries => {\n const node = this.newNodeImpl(entries, level);\n return createNewInternalEntryForNode(node, this.getEntrySize);\n },\n );\n const newRoot = this.newInternalNodeImpl(entries, level + 1);\n this.rootHash = newRoot.hash;\n return;\n }\n\n this.rootHash = rootNode.hash;\n });\n }\n\n /*\n Inserts multiple key-value pairs into the BTree efficiently.\n * The entries array must be sorted by key.\n * @param entries - Array of [key, value] tuples, must be sorted by key\n * @returns Promise that resolves when all entries are inserted\n */\n putMany(\n entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n ): Promise<void> {\n return this.#lock.withLock(async () => {\n if (entries.length === 0) {\n return;\n }\n\n // Validate sortedness and convert to sized entries in one pass\n const sizedEntries: Entry<FrozenJSONValue>[] = entries.map(\n ([k, v], i) => {\n if (i > 0) {\n assert(\n entries[i - 1][0] < k,\n `putMany entries must be sorted and unique`,\n );\n }\n return [k, v, this.getEntrySize(k, v)];\n },\n );\n\n // Compute content size constraints\n const headerSize = this.chunkHeaderSize;\n const contentMin = this.minSize - headerSize;\n const contentMax = this.maxSize - headerSize;\n\n // Fast path: if tree is empty, use bulk loading algorithm\n if (this.rootHash === emptyHash) {\n // Build leaf nodes\n const leafPartitions = partition(\n sizedEntries,\n e => e[2],\n contentMin,\n contentMax,\n entries => entries,\n );\n\n if (leafPartitions.length === 0) {\n return;\n }\n\n if (leafPartitions.length === 1) {\n const leaf = this.newDataNodeImpl(leafPartitions[0]);\n this.rootHash = leaf.hash;\n return;\n }\n\n // Build tree bottom-up - reuse array to avoid allocations\n let currentLevel: Array<DataNodeImpl \| InternalNodeImpl \| Entry<Hash>> =\n leafPartitions.map(entries => this.newDataNodeImpl(entries));\n let level = 0;\n\n while (currentLevel.length > 1) {\n level++;\n\n // Create entries pointing to current level nodes - reuse array\n const parentEntriesLength = currentLevel.length;\n for (let i = 0; i < parentEntriesLength; i++) {\n currentLevel[i] = createNewInternalEntryForNode(\n currentLevel[i] as DataNodeImpl \| InternalNodeImpl,\n this.getEntrySize,\n );\n }\n\n // Partition parent entries\n const parentPartitions = partition(\n currentLevel as Entry<Hash>[],\n e => e[2],\n contentMin,\n contentMax,\n entries => entries,\n );\n\n // Create internal nodes\n currentLevel = parentPartitions.map(entries =>\n this.newInternalNodeImpl(entries, level),\n );\n }\n\n this.rootHash = (\n currentLevel[0] as DataNodeImpl \| InternalNodeImpl\n ).hash;\n return;\n }\n\n // Slow path: merge with existing tree\n const oldRootNode = await this.getNode(this.rootHash);\n const rootNode = await oldRootNode.putMany(sizedEntries, this);\n\n // We do the rebalancing in the parent so we need to do it here as well.\n if (rootNode.getChildNodeSize(this) > this.maxSize) {\n const {level} = rootNode;\n const entries: Entry<Hash>[] = partition(\n rootNode.entries,\n e => e[2],\n contentMin,\n contentMax,\n partitionEntries => {\n const node = this.newNodeImpl(partitionEntries, level);\n return createNewInternalEntryForNode(node, this.getEntrySize);\n },\n );\n const newRoot = this.newInternalNodeImpl(entries, level + 1);\n this.rootHash = newRoot.hash;\n return;\n }\n\n this.rootHash = rootNode.hash;\n });\n }\n\n del(key: string): Promise<boolean> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const newRootNode = await oldRootNode.del(key, this);\n\n // No need to rebalance here since if root gets too small there is nothing\n // we can do about that.\n const found = this.rootHash !== newRootNode.hash;\n if (found) {\n // Flatten one layer.\n if (newRootNode.level > 0 && newRootNode.entries.length === 1) {\n this.rootHash = (newRootNode as InternalNodeImpl).entries[0][1];\n } else {\n this.rootHash = newRootNode.hash;\n }\n }\n\n return found;\n });\n }\n\n clear(): Promise<void> {\n return this.#lock.withLock(() => {\n this.#modified.clear();\n this.rootHash = emptyHash;\n });\n }\n\n flush(): Promise<Hash> {\n return this.#lock.withLock(async () => {\n const dagWrite = this._dagRead;\n\n if (this.rootHash === emptyHash) {\n // Write a chunk for the empty tree.\n const chunk = dagWrite.createChunk(emptyDataNode, []);\n await dagWrite.putChunk(chunk as Chunk<ReadonlyJSONValue>);\n return chunk.hash;\n }\n\n const newChunks: Chunk[] = [];\n const newRoot = gatherNewChunks(\n this.rootHash,\n newChunks,\n dagWrite.createChunk,\n this.#modified,\n this._formatVersion,\n );\n await Promise.all(newChunks.map(chunk => dagWrite.putChunk(chunk)));\n this.#modified.clear();\n this.rootHash = newRoot;\n return newRoot;\n });\n }\n}\n\nfunction gatherNewChunks(\n hash: Hash,\n newChunks: Chunk[],\n createChunk: CreateChunk,\n modified: Map<Hash, DataNodeImpl \| InternalNodeImpl>,\n formatVersion: FormatVersion,\n): Hash {\n const node = modified.get(hash);\n if (node === undefined) {\n // Not modified, use the original.\n return hash;\n }\n\n if (isDataNodeImpl(node)) {\n const chunk = createChunk(toChunkData(node, formatVersion), []);\n newChunks.push(chunk);\n return chunk.hash;\n }\n\n // The BTree cannot have duplicate keys so the child entry hashes are unique.\n // No need fot a set to dedupe here.\n const refs: Hash[] = [];\n const {entries} = node;\n for (let i = 0; i < entries.length; i++) {\n const entry = entries[i];\n const childHash = entry[1];\n const newChildHash = gatherNewChunks(\n childHash,\n newChunks,\n createChunk,\n modified,\n formatVersion,\n );\n if (newChildHash !== childHash) {\n // MUTATES the entries!\n // Hashes do not change the size of the entry because all hashes have the same length\n entries[i] = [entry[0], newChildHash, entry[2]];\n }\n refs.push(newChildHash);\n }\n const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));\n newChunks.push(chunk);\n return chunk.hash;\n}\n"],"mappings":"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"}

package/out/replicache/src/config.js CHANGED Viewed

@@ -1,2 +1 @@
-import "../../shared/src/config.js";
-export {};
+export { isProd as skipBTreeNodeAsserts, isProd as skipCommitDataAsserts, isProd as skipFreeze, isProd as skipFrozenAsserts, isProd as skipGCAsserts } from "../../shared/src/config.js";

package/out/replicache/src/connection-loop.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"connection-loop.d.ts","sourceRoot":"","sources":["../../../../replicache/src/connection-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;~~AAEjD~~,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,sCAAsC,CAAC;~~AAGpF~~,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,YAAY,QAAS,CAAC;AAInC,MAAM,WAAW,sBAAsB;IACrC,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IAEtB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAc;;IA0DzB,YACE,EAAE,EAAE,UAAU,EACd,QAAQ,EAAE,sBAAsB,EAChC,iBAAiB,CAAC,EAAE,yBAAyB,EAM9C;IAED,KAAK,IAAI,IAAI,CAMZ;IAED;;;;OAIG;IACG,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,GAAG;QAAC,KAAK,EAAE,OAAO,CAAA;KAAC,CAAC,CAiB9D;IAEK,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CA8HzB;CAiBF"}
1	+ {"version":3,"file":"connection-loop.d.ts","sourceRoot":"","sources":["../../../../replicache/src/connection-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,sCAAsC,CAAC;AAIpF,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,YAAY,QAAS,CAAC;AAInC,MAAM,WAAW,sBAAsB;IACrC,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IAEtB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAc;;IA0DzB,YACE,EAAE,EAAE,UAAU,EACd,QAAQ,EAAE,sBAAsB,EAChC,iBAAiB,CAAC,EAAE,yBAAyB,EAM9C;IAED,KAAK,IAAI,IAAI,CAMZ;IAED;;;;OAIG;IACG,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,GAAG;QAAC,KAAK,EAAE,OAAO,CAAA;KAAC,CAAC,CAiB9D;IAEK,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CA8HzB;CAiBF"}

package/out/replicache/src/connection-loop.js CHANGED Viewed

@@ -1,5 +1,5 @@
+import { resolver } from "../../shared/src/resolver.js";
 import { sleep } from "../../shared/src/sleep.js";
-import { resolver } from "@rocicorp/resolver";
 //#region ../replicache/src/connection-loop.ts
 var MAX_DELAY_MS = 6e4;
 var ConnectionLoop = class {

package/out/replicache/src/connection-loop.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"connection-loop.js","names":["#delegate","#lc","#visibilityWatcher","#closed","#abortSignal","#sendCounter","#sendResolver","#skipSleepsResolver","#pendingResolver","#waitUntilAvailableConnection","#connectionAvailable","#waitingConnectionResolve"],"sources":["../../../../replicache/src/connection-loop.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport type {DocumentVisibilityWatcher} from '../../shared/src/document-visible.ts';\nimport {sleep} from '../../shared/src/sleep.ts';\n\nexport const DEBOUNCE_DELAY_MS = 10;\n\nexport const MIN_DELAY_MS = 30;\nexport const MAX_DELAY_MS = 60_000;\n\ntype SendRecord = {duration: number; ok: boolean};\n\nexport interface ConnectionLoopDelegate {\n invokeSend(): Promise<boolean>;\n debounceDelay: number;\n // If null, no watchdog timer is used.\n watchdogTimer: number \| null;\n maxConnections: number;\n maxDelayMs: number;\n minDelayMs: number;\n}\n\nexport class ConnectionLoop {\n // ConnectionLoop runs a loop sending network requests (either pushes or\n // pulls) to the server. Our goal, generally, is to send requests as fast as\n // we can, but to adjust in case of slowness, network errors, etc. We will\n // send requests in parallel if the server supports it. We also debounce\n // pushes since they frequently happen in series very near to one another\n // (e.g., during drag'n drops).\n //\n // The loop flows through the following states forever, until it is closed:\n //\n // Pending: Wait for event or watchdog\n // \|\n // v\n // Debounce: Wait for more events (we debounce pushes)\n // \|\n // v\n // Wait for available connection (we limit number of parallel requests\n // allowed)\n // \|\n // v\n // Wait to send (if requests are taking too long, we will slow down)\n // \|\n // v\n // Send (asynchronously, wrt the loop)\n // \|\n // v\n // Back to the pending!\n\n // Controls whether the next iteration of the loop will wait at the pending\n // state.\n #pendingResolver = resolver<void>();\n\n /*\n This resolver is used to allow us to skip sleeps when we do send(true)\n /\n #skipSleepsResolver = resolver<void>();\n\n /\n Resolver for the next send. Never rejects. Returns an error instead since\n * this resolver is used in cases where they might not be someone waiting,\n * and we don't want an unhandled promise rejection in that case.\n /\n #sendResolver = resolver<undefined \| {error: unknown}>();\n\n readonly #delegate: ConnectionLoopDelegate;\n #closed = false;\n #abortSignal = new AbortController();\n\n /\n Number of pending send calls.\n \n We keep track of this because if close happens while we are waiting for the\n * send to resolve we should reject the send promise.\n /\n #sendCounter = 0;\n readonly #lc: LogContext;\n readonly #visibilityWatcher: DocumentVisibilityWatcher \| undefined;\n\n constructor(\n lc: LogContext,\n delegate: ConnectionLoopDelegate,\n visibilityWatcher?: DocumentVisibilityWatcher,\n ) {\n this.#lc = lc;\n this.#delegate = delegate;\n this.#visibilityWatcher = visibilityWatcher;\n void this.run();\n }\n\n close(): void {\n this.#closed = true;\n this.#abortSignal.abort();\n if (this.#sendCounter > 0) {\n this.#sendResolver.resolve({error: closeError()});\n }\n }\n\n /\n \n * @returns Returns undefined if ok, otherwise it return the error that caused\n * the send to fail.\n /\n async send(now: boolean): Promise<undefined \| {error: unknown}> {\n if (this.#closed) {\n return {error: closeError()};\n }\n this.#sendCounter++;\n this.#lc.debug?.('send', now);\n if (now) {\n this.#skipSleepsResolver.resolve();\n } else {\n await this.#visibilityWatcher?.waitForVisible();\n }\n\n this.#pendingResolver.resolve();\n\n const result = await this.#sendResolver.promise;\n this.#sendCounter--;\n return result;\n }\n\n async run(): Promise<void> {\n const sendRecords: SendRecord[] = [];\n\n let recoverResolver = resolver();\n let lastSendTime;\n\n // The number of active connections.\n let counter = 0;\n const delegate = this.#delegate;\n const lc = this.#lc;\n let delay = 0;\n\n lc.debug?.('Starting connection loop');\n\n const sleepMaybeSkip: typeof sleep = ms =>\n Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);\n\n while (!this.#closed) {\n lc.debug?.(\n didLastSendRequestFail(sendRecords)\n ? 'Last request failed. Trying again'\n : 'Waiting for a send',\n );\n\n // Wait until send is called or until the watchdog timer fires.\n const races = [this.#pendingResolver.promise];\n const t = delegate.watchdogTimer;\n if (t !== null) {\n // Wait for the watchdog timer to fire or the abort signal to be triggered.\n races.push(sleep(t, this.#abortSignal.signal).catch(() => {}));\n }\n await Promise.race(races);\n if (this.#closed) break;\n\n lc.debug?.('Waiting for debounce');\n await sleepMaybeSkip(delegate.debounceDelay);\n if (this.#closed) break;\n lc.debug?.('debounced');\n\n // This resolver is used to wait for incoming push calls.\n this.#pendingResolver = resolver();\n\n if (counter >= delegate.maxConnections) {\n lc.debug?.('Too many request in flight. Waiting until one finishes...');\n await this.#waitUntilAvailableConnection();\n if (this.#closed) break;\n lc.debug?.('...finished');\n }\n\n // We need to delay the next request even if there are no active requests\n // in case of error.\n if (counter > 0 \|\| didLastSendRequestFail(sendRecords)) {\n delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);\n lc.debug?.(\n didLastSendRequestFail(sendRecords)\n ? 'Last connection errored. Sleeping for'\n : 'More than one outstanding connection (' +\n counter +\n '). Sleeping for',\n delay,\n 'ms',\n );\n } else {\n // We set this to 0 here in case minDelayMs is mutated to a lower value\n // than the old delay so that we still get minDelayMs. This can happen\n // if we get an error during a run where minDelayMs is larger than the\n // current value of minDelayMs.\n delay = 0;\n }\n\n const clampedDelay = Math.min(\n delegate.maxDelayMs,\n Math.max(delegate.minDelayMs, delay),\n );\n if (lastSendTime !== undefined) {\n const timeSinceLastSend = Date.now() - lastSendTime;\n if (clampedDelay > timeSinceLastSend) {\n await Promise.race([\n sleepMaybeSkip(clampedDelay - timeSinceLastSend),\n recoverResolver.promise,\n ]);\n if (this.#closed) break;\n }\n }\n\n counter++;\n void (async () => {\n const start = Date.now();\n let ok: boolean;\n let error: unknown;\n try {\n lastSendTime = start;\n lc.debug?.('Sending request');\n this.#skipSleepsResolver = resolver();\n ok = await delegate.invokeSend();\n lc.debug?.('Send returned', ok);\n } catch (e) {\n lc.debug?.('Send failed', e);\n error = e;\n ok = false;\n }\n if (this.#closed) {\n lc.debug?.('Closed after invokeSend');\n return;\n }\n lc.debug?.('Request done', {duration: Date.now() - start, ok});\n sendRecords.push({duration: Date.now() - start, ok});\n if (recovered(sendRecords)) {\n recoverResolver.resolve();\n recoverResolver = resolver();\n }\n counter--;\n this.#connectionAvailable();\n const sendResolver = this.#sendResolver;\n this.#sendResolver = resolver();\n if (error) {\n sendResolver.resolve({error});\n } else {\n sendResolver.resolve(undefined);\n }\n if (!ok) {\n // Keep trying\n this.#pendingResolver.resolve();\n }\n })();\n }\n }\n\n #waitingConnectionResolve: (() => void) \| undefined = undefined;\n\n #connectionAvailable() {\n if (this.#waitingConnectionResolve) {\n const resolve = this.#waitingConnectionResolve;\n this.#waitingConnectionResolve = undefined;\n resolve();\n }\n }\n\n #waitUntilAvailableConnection() {\n const {promise, resolve} = resolver();\n this.#waitingConnectionResolve = resolve;\n return promise;\n }\n}\n\n// Number of connections to remember when computing the new delay.\nconst CONNECTION_MEMORY_COUNT = 9;\n\nfunction closeError() {\n return new Error('Closed');\n}\n\n// Computes a new delay based on the previous requests. We use the median of the\n// previous successful request divided by `maxConnections`. When we get errors\n// we do exponential backoff. As soon as we recover from an error we reset back\n// to delegate.minDelayMs.\nfunction computeDelayAndUpdateDurations(\n delay: number,\n delegate: ConnectionLoopDelegate,\n sendRecords: SendRecord[],\n): number {\n const {length} = sendRecords;\n if (length === 0) {\n return delay;\n }\n\n // oxlint-disable-next-line typescript/no-non-null-assertion\n const {ok} = sendRecords.at(-1)!;\n const {maxConnections, minDelayMs} = delegate;\n\n if (!ok) {\n return delay === 0 ? minDelayMs : delay 2;\n }\n\n if (length > 1) {\n // length > 1\n const previous: SendRecord = sendRecords[sendRecords.length - 2];\n\n // Prune\n while (sendRecords.length > CONNECTION_MEMORY_COUNT) {\n sendRecords.shift();\n }\n\n if (ok && !previous.ok) {\n // Recovered\n return minDelayMs;\n }\n }\n\n const med = median(\n sendRecords.filter(({ok}) => ok).map(({duration}) => duration),\n );\n\n return (med / maxConnections) \| 0;\n}\n\nfunction median(values: number[]) {\n values.sort();\n const {length} = values;\n const half = length >> 1;\n if (length % 2 === 1) {\n return values[half];\n }\n return (values[half - 1] + values[half]) / 2;\n}\n\nfunction didLastSendRequestFail(sendRecords: SendRecord[]) {\n // oxlint-disable-next-line typescript/no-non-null-assertion\n return sendRecords.length > 0 && !sendRecords.at(-1)!.ok;\n}\n\nfunction recovered(sendRecords: SendRecord[]) {\n return (\n sendRecords.length > 1 &&\n !sendRecords[sendRecords.length - 2].ok &&\n // oxlint-disable-next-line typescript/no-non-null-assertion\n sendRecords.at(-1)!.ok\n );\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"connection-loop.js","names":[],"sources":["../../../../replicache/src/connection-loop.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {DocumentVisibilityWatcher} from '../../shared/src/document-visible.ts';\nimport {resolver} from '../../shared/src/resolver.ts';\nimport {sleep} from '../../shared/src/sleep.ts';\n\nexport const DEBOUNCE_DELAY_MS = 10;\n\nexport const MIN_DELAY_MS = 30;\nexport const MAX_DELAY_MS = 60_000;\n\ntype SendRecord = {duration: number; ok: boolean};\n\nexport interface ConnectionLoopDelegate {\n invokeSend(): Promise<boolean>;\n debounceDelay: number;\n // If null, no watchdog timer is used.\n watchdogTimer: number \| null;\n maxConnections: number;\n maxDelayMs: number;\n minDelayMs: number;\n}\n\nexport class ConnectionLoop {\n // ConnectionLoop runs a loop sending network requests (either pushes or\n // pulls) to the server. Our goal, generally, is to send requests as fast as\n // we can, but to adjust in case of slowness, network errors, etc. We will\n // send requests in parallel if the server supports it. We also debounce\n // pushes since they frequently happen in series very near to one another\n // (e.g., during drag'n drops).\n //\n // The loop flows through the following states forever, until it is closed:\n //\n // Pending: Wait for event or watchdog\n // \|\n // v\n // Debounce: Wait for more events (we debounce pushes)\n // \|\n // v\n // Wait for available connection (we limit number of parallel requests\n // allowed)\n // \|\n // v\n // Wait to send (if requests are taking too long, we will slow down)\n // \|\n // v\n // Send (asynchronously, wrt the loop)\n // \|\n // v\n // Back to the pending!\n\n // Controls whether the next iteration of the loop will wait at the pending\n // state.\n #pendingResolver = resolver<void>();\n\n /*\n This resolver is used to allow us to skip sleeps when we do send(true)\n /\n #skipSleepsResolver = resolver<void>();\n\n /\n Resolver for the next send. Never rejects. Returns an error instead since\n * this resolver is used in cases where they might not be someone waiting,\n * and we don't want an unhandled promise rejection in that case.\n /\n #sendResolver = resolver<undefined \| {error: unknown}>();\n\n readonly #delegate: ConnectionLoopDelegate;\n #closed = false;\n #abortSignal = new AbortController();\n\n /\n Number of pending send calls.\n \n We keep track of this because if close happens while we are waiting for the\n * send to resolve we should reject the send promise.\n /\n #sendCounter = 0;\n readonly #lc: LogContext;\n readonly #visibilityWatcher: DocumentVisibilityWatcher \| undefined;\n\n constructor(\n lc: LogContext,\n delegate: ConnectionLoopDelegate,\n visibilityWatcher?: DocumentVisibilityWatcher,\n ) {\n this.#lc = lc;\n this.#delegate = delegate;\n this.#visibilityWatcher = visibilityWatcher;\n void this.run();\n }\n\n close(): void {\n this.#closed = true;\n this.#abortSignal.abort();\n if (this.#sendCounter > 0) {\n this.#sendResolver.resolve({error: closeError()});\n }\n }\n\n /\n \n * @returns Returns undefined if ok, otherwise it return the error that caused\n * the send to fail.\n /\n async send(now: boolean): Promise<undefined \| {error: unknown}> {\n if (this.#closed) {\n return {error: closeError()};\n }\n this.#sendCounter++;\n this.#lc.debug?.('send', now);\n if (now) {\n this.#skipSleepsResolver.resolve();\n } else {\n await this.#visibilityWatcher?.waitForVisible();\n }\n\n this.#pendingResolver.resolve();\n\n const result = await this.#sendResolver.promise;\n this.#sendCounter--;\n return result;\n }\n\n async run(): Promise<void> {\n const sendRecords: SendRecord[] = [];\n\n let recoverResolver = resolver();\n let lastSendTime;\n\n // The number of active connections.\n let counter = 0;\n const delegate = this.#delegate;\n const lc = this.#lc;\n let delay = 0;\n\n lc.debug?.('Starting connection loop');\n\n const sleepMaybeSkip: typeof sleep = ms =>\n Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);\n\n while (!this.#closed) {\n lc.debug?.(\n didLastSendRequestFail(sendRecords)\n ? 'Last request failed. Trying again'\n : 'Waiting for a send',\n );\n\n // Wait until send is called or until the watchdog timer fires.\n const races = [this.#pendingResolver.promise];\n const t = delegate.watchdogTimer;\n if (t !== null) {\n // Wait for the watchdog timer to fire or the abort signal to be triggered.\n races.push(sleep(t, this.#abortSignal.signal).catch(() => {}));\n }\n await Promise.race(races);\n if (this.#closed) break;\n\n lc.debug?.('Waiting for debounce');\n await sleepMaybeSkip(delegate.debounceDelay);\n if (this.#closed) break;\n lc.debug?.('debounced');\n\n // This resolver is used to wait for incoming push calls.\n this.#pendingResolver = resolver();\n\n if (counter >= delegate.maxConnections) {\n lc.debug?.('Too many request in flight. Waiting until one finishes...');\n await this.#waitUntilAvailableConnection();\n if (this.#closed) break;\n lc.debug?.('...finished');\n }\n\n // We need to delay the next request even if there are no active requests\n // in case of error.\n if (counter > 0 \|\| didLastSendRequestFail(sendRecords)) {\n delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);\n lc.debug?.(\n didLastSendRequestFail(sendRecords)\n ? 'Last connection errored. Sleeping for'\n : 'More than one outstanding connection (' +\n counter +\n '). Sleeping for',\n delay,\n 'ms',\n );\n } else {\n // We set this to 0 here in case minDelayMs is mutated to a lower value\n // than the old delay so that we still get minDelayMs. This can happen\n // if we get an error during a run where minDelayMs is larger than the\n // current value of minDelayMs.\n delay = 0;\n }\n\n const clampedDelay = Math.min(\n delegate.maxDelayMs,\n Math.max(delegate.minDelayMs, delay),\n );\n if (lastSendTime !== undefined) {\n const timeSinceLastSend = Date.now() - lastSendTime;\n if (clampedDelay > timeSinceLastSend) {\n await Promise.race([\n sleepMaybeSkip(clampedDelay - timeSinceLastSend),\n recoverResolver.promise,\n ]);\n if (this.#closed) break;\n }\n }\n\n counter++;\n void (async () => {\n const start = Date.now();\n let ok: boolean;\n let error: unknown;\n try {\n lastSendTime = start;\n lc.debug?.('Sending request');\n this.#skipSleepsResolver = resolver();\n ok = await delegate.invokeSend();\n lc.debug?.('Send returned', ok);\n } catch (e) {\n lc.debug?.('Send failed', e);\n error = e;\n ok = false;\n }\n if (this.#closed) {\n lc.debug?.('Closed after invokeSend');\n return;\n }\n lc.debug?.('Request done', {duration: Date.now() - start, ok});\n sendRecords.push({duration: Date.now() - start, ok});\n if (recovered(sendRecords)) {\n recoverResolver.resolve();\n recoverResolver = resolver();\n }\n counter--;\n this.#connectionAvailable();\n const sendResolver = this.#sendResolver;\n this.#sendResolver = resolver();\n if (error) {\n sendResolver.resolve({error});\n } else {\n sendResolver.resolve(undefined);\n }\n if (!ok) {\n // Keep trying\n this.#pendingResolver.resolve();\n }\n })();\n }\n }\n\n #waitingConnectionResolve: (() => void) \| undefined = undefined;\n\n #connectionAvailable() {\n if (this.#waitingConnectionResolve) {\n const resolve = this.#waitingConnectionResolve;\n this.#waitingConnectionResolve = undefined;\n resolve();\n }\n }\n\n #waitUntilAvailableConnection() {\n const {promise, resolve} = resolver();\n this.#waitingConnectionResolve = resolve;\n return promise;\n }\n}\n\n// Number of connections to remember when computing the new delay.\nconst CONNECTION_MEMORY_COUNT = 9;\n\nfunction closeError() {\n return new Error('Closed');\n}\n\n// Computes a new delay based on the previous requests. We use the median of the\n// previous successful request divided by `maxConnections`. When we get errors\n// we do exponential backoff. As soon as we recover from an error we reset back\n// to delegate.minDelayMs.\nfunction computeDelayAndUpdateDurations(\n delay: number,\n delegate: ConnectionLoopDelegate,\n sendRecords: SendRecord[],\n): number {\n const {length} = sendRecords;\n if (length === 0) {\n return delay;\n }\n\n // oxlint-disable-next-line typescript/no-non-null-assertion\n const {ok} = sendRecords.at(-1)!;\n const {maxConnections, minDelayMs} = delegate;\n\n if (!ok) {\n return delay === 0 ? minDelayMs : delay 2;\n }\n\n if (length > 1) {\n // length > 1\n const previous: SendRecord = sendRecords[sendRecords.length - 2];\n\n // Prune\n while (sendRecords.length > CONNECTION_MEMORY_COUNT) {\n sendRecords.shift();\n }\n\n if (ok && !previous.ok) {\n // Recovered\n return minDelayMs;\n }\n }\n\n const med = median(\n sendRecords.filter(({ok}) => ok).map(({duration}) => duration),\n );\n\n return (med / maxConnections) \| 0;\n}\n\nfunction median(values: number[]) {\n values.sort();\n const {length} = values;\n const half = length >> 1;\n if (length % 2 === 1) {\n return values[half];\n }\n return (values[half - 1] + values[half]) / 2;\n}\n\nfunction didLastSendRequestFail(sendRecords: SendRecord[]) {\n // oxlint-disable-next-line typescript/no-non-null-assertion\n return sendRecords.length > 0 && !sendRecords.at(-1)!.ok;\n}\n\nfunction recovered(sendRecords: SendRecord[]) {\n return (\n sendRecords.length > 1 &&\n !sendRecords[sendRecords.length - 2].ok &&\n // oxlint-disable-next-line typescript/no-non-null-assertion\n sendRecords.at(-1)!.ok\n );\n}\n"],"mappings":"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"}

package/out/replicache/src/dag/chunk.js CHANGED Viewed

@@ -48,6 +48,6 @@ function createChunk(data, refs, chunkHasher) {
 	return new Chunk(chunkHasher(), data, refs);
 }
 //#endregion
-export { Chunk, assertRefs, createChunk, toRefs };
+export { Chunk, asRefs, assertRefs, createChunk, toRefs };
 //# sourceMappingURL=chunk.js.map

package/out/replicache/src/dag/gc.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"gc.js","names":["~~#newHeads~~"~~,"#oldHeads","#putChunks","#delegate","#refsCounted","#refCountUpdates","#loadedRefCountPromises","#isLazyDelegate","#changeRefCount","#ensureRefCountLoaded","#updateRefsCounts","#updateRefCount"~~],"sources":["../../../../../replicache/src/dag/gc.ts"],"sourcesContent":["import {assert, assertNumber} from '../../../shared/src/asserts.ts';\nimport {getOrInsertComputed} from '../../../shared/src/map.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {skipGCAsserts} from '../config.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.ts';\n\nexport type HeadChange = {\n new: Hash \| undefined;\n old: Hash \| undefined;\n};\n\ntype LoadedRefCountPromises = Map<Hash, Promise<number>>;\n\nexport interface RefCountUpdatesDelegate {\n getRefCount: (hash: Hash) => MaybePromise<number \| undefined>;\n getRefs: (hash: Hash) => MaybePromise<readonly Hash[] \| undefined>;\n /*\n Should be implemented if the store lazily loads refs, returning whether\n * or not the chunks refs have already been counted (i.e. are reflected\n * in `getRefCount`).\n \n If defined then:\n * - `getRefs` should return undefined for refs that have not been loaded,\n * but should never return undefined for hashes in `putChunks`.\n * - it is assumed that chunks in `putChunks` may have been reachable before\n * the write, but may not have been counted. This method is used to\n * determine if they have been counted or not. If they have not been\n * counted, and are reachable with the write applied, the returned\n * ref count updates will include updates for counting them.\n \n If undefined then:\n * - `getRefs` should never return undefined\n * - it is assumed that the refs of any chunks which were reachable before\n * the write are already counted\n /\n areRefsCounted?: (hash: Hash) => boolean;\n}\n\n/\n Computes how ref counts should be updated when a dag write is committed.\n * Does not modify the dag store.\n * @param headChanges Heads that were changed by the dag write.\n * @param putChunks Chunks that were put by the dag write.\n * @param delegate Delegate used for getting ref information from the dag store.\n * @returns Map from chunk Hash to changed ref counts. Chunks with a new ref\n * count of 0 should be deleted. All hashes in `putChunks` will have an entry\n * (which will be zero if the newly put chunk is not reachable from any head).\n */\nexport function computeRefCountUpdates(\n headChanges: Iterable<HeadChange>,\n putChunks: ReadonlySet<Hash>,\n delegate: RefCountUpdatesDelegate,\n): Promise<Map<Hash, number>> {\n return new RefCountUpdates(headChanges, putChunks, delegate).compute();\n}\n\nclass RefCountUpdates {\n readonly #newHeads: Hash[];\n readonly #oldHeads: Hash[];\n readonly #putChunks: ReadonlySet<Hash>;\n readonly #delegate: RefCountUpdatesDelegate;\n readonly #refsCounted: Set<Hash> \| null;\n readonly #refCountUpdates: Map<Hash, number>;\n readonly #loadedRefCountPromises: LoadedRefCountPromises;\n readonly #isLazyDelegate: boolean;\n\n constructor(\n headChanges: Iterable<HeadChange>,\n putChunks: ReadonlySet<Hash>,\n delegate: RefCountUpdatesDelegate,\n ) {\n const newHeads: Hash[] = [];\n const oldHeads: Hash[] = [];\n for (const changedHead of headChanges) {\n if (changedHead.old !== changedHead.new) {\n changedHead.old && oldHeads.push(changedHead.old);\n changedHead.new && newHeads.push(changedHead.new);\n }\n }\n this.#newHeads = newHeads;\n this.#oldHeads = oldHeads;\n this.#putChunks = putChunks;\n this.#delegate = delegate;\n this.#refCountUpdates = new Map();\n // This map is used to ensure we do not load the ref count key more than once.\n // Once it is loaded we only operate on a cache of the ref counts.\n this.#loadedRefCountPromises = new Map();\n this.#isLazyDelegate = delegate.areRefsCounted !== undefined;\n this.#refsCounted = this.#isLazyDelegate ? new Set() : null;\n }\n\n async compute(): Promise<Map<Hash, number>> {\n for (const n of this.#newHeads) {\n await this.#changeRefCount(n, 1);\n }\n\n // Now go through the put chunks to ensure each has an entry in\n // refCountUpdates (zero for new chunks which are not reachable from\n // newHeads).\n await Promise.all(\n Array.from(this.#putChunks.values(), hash =>\n this.#ensureRefCountLoaded(hash),\n ),\n );\n\n if (this.#isLazyDelegate) {\n assert(\n this.#delegate.areRefsCounted,\n 'Expected delegate.areRefsCounted to be defined',\n );\n assert(this.#refsCounted, 'Expected refsCounted to be defined');\n let refCountsUpdated;\n do {\n refCountsUpdated = false;\n for (const hash of this.#putChunks.values()) {\n if (\n !this.#delegate.areRefsCounted(hash) &&\n !this.#refsCounted.has(hash) &&\n this.#refCountUpdates.get(hash) !== 0\n ) {\n await this.#updateRefsCounts(hash, 1);\n refCountsUpdated = true;\n break;\n }\n }\n } while (refCountsUpdated);\n }\n\n for (const o of this.#oldHeads) {\n await this.#changeRefCount(o, -1);\n }\n\n // A negative count means a chunk that is still referenced had no (or too\n // low a) ref count in the store, so the store is already corrupt. Always\n // check this, even in production: writing the negative count would only\n // spread the corruption, and the typed error lets the store owner recover.\n // Written as `!(update >= 0)` so that NaN is rejected as well.\n for (const [hash, update] of this.#refCountUpdates) {\n if (!(update >= 0)) {\n throw new InvalidRefCountError(hash, update);\n }\n }\n\n return this.#refCountUpdates;\n }\n\n async #changeRefCount(hash: Hash, delta: number): Promise<void> {\n // First make sure that we have the ref count in the cache. This is async\n // because it might need to load the ref count from the store (via the delegate).\n //\n // Once we have loaded the ref count all the updates to it are sync to\n // prevent race conditions.\n await this.#ensureRefCountLoaded(hash);\n if (this.#updateRefCount(hash, delta)) {\n await this.#updateRefsCounts(hash, delta);\n }\n }\n\n async #updateRefsCounts(hash: Hash, delta: number) {\n if (hash === emptyHash) {\n return;\n }\n const refs = await this.#delegate.getRefs(hash);\n if (!skipGCAsserts) {\n assert(\n refs \|\| (this.#isLazyDelegate && !this.#putChunks.has(hash)),\n 'refs must be defined',\n );\n }\n\n if (refs !== undefined) {\n this.#refsCounted?.add(hash);\n const ps = refs.map(ref => this.#changeRefCount(ref, delta));\n await Promise.all(ps);\n }\n }\n\n #ensureRefCountLoaded(hash: Hash): Promise<number> {\n // Only get the ref count once.\n return getOrInsertComputed(\n this.#loadedRefCountPromises,\n hash,\n async hash => {\n const value = (await this.#delegate.getRefCount(hash)) \|\| 0;\n this.#refCountUpdates.set(hash, value);\n return value;\n },\n );\n }\n\n #updateRefCount(hash: Hash, delta: number): boolean {\n const oldCount = this.#refCountUpdates.get(hash);\n assertNumber(oldCount);\n this.#refCountUpdates.set(hash, oldCount + delta);\n return (oldCount === 0 && delta === 1) \|\| (oldCount === 1 && delta === -1);\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiDA,SAAgB,uBACd,aACA,WACA,UAC4B;CAC5B,OAAO,IAAI,gBAAgB,aAAa,WAAW,QAAQ,~~EAAE~~,QAAQ;AACvE;AAEA,IAAM,kBAAN,MAAsB;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YACE,aACA,WACA,UACA;EACA,MAAM,WAAmB,CAAC;EAC1B,MAAM,WAAmB,CAAC;EAC1B,KAAK,MAAM,eAAe,aACxB,IAAI,YAAY,QAAQ,YAAY,KAAK;GACvC,YAAY,OAAO,SAAS,KAAK,YAAY,GAAG;GAChD,YAAY,OAAO,SAAS,KAAK,YAAY,GAAG;EAClD;EAEF,~~KAAKA~~,YAAY;EACjB,~~KAAKC~~,YAAY;EACjB,~~KAAKC~~,aAAa;EAClB,~~KAAKC~~,YAAY;EACjB,~~KAAKE~~,mCAAmB,IAAI,IAAI;EAGhC,~~KAAKC~~,0CAA0B,IAAI,IAAI;EACvC,~~KAAKC~~,kBAAkB,SAAS,mBAAmB,KAAA;EACnD,~~KAAKH~~,eAAe,~~KAAKG~~,kCAAkB,IAAI,IAAI,IAAI;CACzD;CAEA,MAAM,UAAsC;EAC1C,KAAK,MAAM,KAAK,~~KAAKP~~,WACnB,MAAM,~~KAAKQ~~,gBAAgB,GAAG,CAAC;EAMjC,MAAM,QAAQ,IACZ,MAAM,KAAK,~~KAAKN~~,WAAW,OAAO,IAAG,SACnC,~~KAAKO~~,sBAAsB,IAAI,CACjC,CACF;EAEA,IAAI,~~KAAKF~~,iBAAiB;GACxB,OACE,~~KAAKJ~~,UAAU,gBACf,gDACF;GACA,OAAO,~~KAAKC~~,cAAc,oCAAoC;GAC9D,IAAI;GACJ,GAAG;IACD,mBAAmB;IACnB,KAAK,MAAM,QAAQ,~~KAAKF~~,WAAW,OAAO,GACxC,IACE,CAAC,~~KAAKC~~,UAAU,eAAe,IAAI,KACnC,CAAC,~~KAAKC~~,aAAa,IAAI,IAAI,KAC3B,~~KAAKC~~,iBAAiB,IAAI,IAAI,MAAM,GACpC;KACA,MAAM,~~KAAKK~~,kBAAkB,MAAM,CAAC;KACpC,mBAAmB;KACnB;IACF;GAEJ,SAAS;EACX;EAEA,KAAK,MAAM,KAAK,~~KAAKT~~,WACnB,MAAM,~~KAAKO~~,gBAAgB,GAAG,EAAE;EAQlC,KAAK,MAAM,CAAC,MAAM,WAAW,~~KAAKH~~,kBAChC,IAAI,EAAE,UAAU,IACd,MAAM,IAAI,qBAAqB,MAAM,MAAM;EAI/C,OAAO,~~KAAKA~~;CACd;CAEA,~~MAAMG~~,gBAAgB,MAAY,OAA8B;EAM9D,MAAM,~~KAAKC~~,sBAAsB,IAAI;EACrC,IAAI,~~KAAKE~~,gBAAgB,MAAM,KAAK,GAClC,MAAM,~~KAAKD~~,kBAAkB,MAAM,KAAK;CAE5C;CAEA,~~MAAMA~~,kBAAkB,MAAY,OAAe;EACjD,IAAI,SAAS,WACX;EAEF,MAAM,OAAO,MAAM,~~KAAKP~~,UAAU,QAAQ,IAAI;EAC9C,IAAI,~~CAAC~~,QACH,OACE,QAAS,~~KAAKI~~,mBAAmB,CAAC,~~KAAKL~~,WAAW,IAAI,IAAI,GAC1D,sBACF;EAGF,IAAI,SAAS,KAAA,GAAW;GACtB,~~KAAKE~~,cAAc,IAAI,IAAI;GAC3B,MAAM,KAAK,KAAK,KAAI,QAAO,~~KAAKI~~,gBAAgB,KAAK,KAAK,CAAC;GAC3D,MAAM,QAAQ,IAAI,EAAE;EACtB;CACF;CAEA,sBAAsB,MAA6B;EAEjD,OAAO,oBACL,~~KAAKF~~,yBACL,MACA,OAAM,SAAQ;GACZ,MAAM,QAAS,MAAM,~~KAAKH~~,UAAU,YAAY,IAAI,KAAM;GAC1D,~~KAAKE~~,iBAAiB,IAAI,MAAM,KAAK;GACrC,OAAO;EACT,CACF;CACF;CAEA,gBAAgB,MAAY,OAAwB;EAClD,MAAM,WAAW,~~KAAKA~~,iBAAiB,IAAI,IAAI;EAC/C,aAAa,QAAQ;EACrB,~~KAAKA~~,iBAAiB,IAAI,MAAM,WAAW,KAAK;EAChD,OAAQ,aAAa,KAAK,UAAU,KAAO,aAAa,KAAK,UAAU;CACzE;AACF"}
1	+ {"version":3,"file":"gc.js","names":["skipGCAsserts"],"sources":["../../../../../replicache/src/dag/gc.ts"],"sourcesContent":["import {assert, assertNumber} from '../../../shared/src/asserts.ts';\nimport {getOrInsertComputed} from '../../../shared/src/map.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {skipGCAsserts} from '../config.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.ts';\n\nexport type HeadChange = {\n new: Hash \| undefined;\n old: Hash \| undefined;\n};\n\ntype LoadedRefCountPromises = Map<Hash, Promise<number>>;\n\nexport interface RefCountUpdatesDelegate {\n getRefCount: (hash: Hash) => MaybePromise<number \| undefined>;\n getRefs: (hash: Hash) => MaybePromise<readonly Hash[] \| undefined>;\n /*\n Should be implemented if the store lazily loads refs, returning whether\n * or not the chunks refs have already been counted (i.e. are reflected\n * in `getRefCount`).\n \n If defined then:\n * - `getRefs` should return undefined for refs that have not been loaded,\n * but should never return undefined for hashes in `putChunks`.\n * - it is assumed that chunks in `putChunks` may have been reachable before\n * the write, but may not have been counted. This method is used to\n * determine if they have been counted or not. If they have not been\n * counted, and are reachable with the write applied, the returned\n * ref count updates will include updates for counting them.\n \n If undefined then:\n * - `getRefs` should never return undefined\n * - it is assumed that the refs of any chunks which were reachable before\n * the write are already counted\n /\n areRefsCounted?: (hash: Hash) => boolean;\n}\n\n/\n Computes how ref counts should be updated when a dag write is committed.\n * Does not modify the dag store.\n * @param headChanges Heads that were changed by the dag write.\n * @param putChunks Chunks that were put by the dag write.\n * @param delegate Delegate used for getting ref information from the dag store.\n * @returns Map from chunk Hash to changed ref counts. Chunks with a new ref\n * count of 0 should be deleted. All hashes in `putChunks` will have an entry\n * (which will be zero if the newly put chunk is not reachable from any head).\n */\nexport function computeRefCountUpdates(\n headChanges: Iterable<HeadChange>,\n putChunks: ReadonlySet<Hash>,\n delegate: RefCountUpdatesDelegate,\n): Promise<Map<Hash, number>> {\n return new RefCountUpdates(headChanges, putChunks, delegate).compute();\n}\n\nclass RefCountUpdates {\n readonly #newHeads: Hash[];\n readonly #oldHeads: Hash[];\n readonly #putChunks: ReadonlySet<Hash>;\n readonly #delegate: RefCountUpdatesDelegate;\n readonly #refsCounted: Set<Hash> \| null;\n readonly #refCountUpdates: Map<Hash, number>;\n readonly #loadedRefCountPromises: LoadedRefCountPromises;\n readonly #isLazyDelegate: boolean;\n\n constructor(\n headChanges: Iterable<HeadChange>,\n putChunks: ReadonlySet<Hash>,\n delegate: RefCountUpdatesDelegate,\n ) {\n const newHeads: Hash[] = [];\n const oldHeads: Hash[] = [];\n for (const changedHead of headChanges) {\n if (changedHead.old !== changedHead.new) {\n changedHead.old && oldHeads.push(changedHead.old);\n changedHead.new && newHeads.push(changedHead.new);\n }\n }\n this.#newHeads = newHeads;\n this.#oldHeads = oldHeads;\n this.#putChunks = putChunks;\n this.#delegate = delegate;\n this.#refCountUpdates = new Map();\n // This map is used to ensure we do not load the ref count key more than once.\n // Once it is loaded we only operate on a cache of the ref counts.\n this.#loadedRefCountPromises = new Map();\n this.#isLazyDelegate = delegate.areRefsCounted !== undefined;\n this.#refsCounted = this.#isLazyDelegate ? new Set() : null;\n }\n\n async compute(): Promise<Map<Hash, number>> {\n for (const n of this.#newHeads) {\n await this.#changeRefCount(n, 1);\n }\n\n // Now go through the put chunks to ensure each has an entry in\n // refCountUpdates (zero for new chunks which are not reachable from\n // newHeads).\n await Promise.all(\n Array.from(this.#putChunks.values(), hash =>\n this.#ensureRefCountLoaded(hash),\n ),\n );\n\n if (this.#isLazyDelegate) {\n assert(\n this.#delegate.areRefsCounted,\n 'Expected delegate.areRefsCounted to be defined',\n );\n assert(this.#refsCounted, 'Expected refsCounted to be defined');\n let refCountsUpdated;\n do {\n refCountsUpdated = false;\n for (const hash of this.#putChunks.values()) {\n if (\n !this.#delegate.areRefsCounted(hash) &&\n !this.#refsCounted.has(hash) &&\n this.#refCountUpdates.get(hash) !== 0\n ) {\n await this.#updateRefsCounts(hash, 1);\n refCountsUpdated = true;\n break;\n }\n }\n } while (refCountsUpdated);\n }\n\n for (const o of this.#oldHeads) {\n await this.#changeRefCount(o, -1);\n }\n\n // A negative count means a chunk that is still referenced had no (or too\n // low a) ref count in the store, so the store is already corrupt. Always\n // check this, even in production: writing the negative count would only\n // spread the corruption, and the typed error lets the store owner recover.\n // Written as `!(update >= 0)` so that NaN is rejected as well.\n for (const [hash, update] of this.#refCountUpdates) {\n if (!(update >= 0)) {\n throw new InvalidRefCountError(hash, update);\n }\n }\n\n return this.#refCountUpdates;\n }\n\n async #changeRefCount(hash: Hash, delta: number): Promise<void> {\n // First make sure that we have the ref count in the cache. This is async\n // because it might need to load the ref count from the store (via the delegate).\n //\n // Once we have loaded the ref count all the updates to it are sync to\n // prevent race conditions.\n await this.#ensureRefCountLoaded(hash);\n if (this.#updateRefCount(hash, delta)) {\n await this.#updateRefsCounts(hash, delta);\n }\n }\n\n async #updateRefsCounts(hash: Hash, delta: number) {\n if (hash === emptyHash) {\n return;\n }\n const refs = await this.#delegate.getRefs(hash);\n if (!skipGCAsserts) {\n assert(\n refs \|\| (this.#isLazyDelegate && !this.#putChunks.has(hash)),\n 'refs must be defined',\n );\n }\n\n if (refs !== undefined) {\n this.#refsCounted?.add(hash);\n const ps = refs.map(ref => this.#changeRefCount(ref, delta));\n await Promise.all(ps);\n }\n }\n\n #ensureRefCountLoaded(hash: Hash): Promise<number> {\n // Only get the ref count once.\n return getOrInsertComputed(\n this.#loadedRefCountPromises,\n hash,\n async hash => {\n const value = (await this.#delegate.getRefCount(hash)) \|\| 0;\n this.#refCountUpdates.set(hash, value);\n return value;\n },\n );\n }\n\n #updateRefCount(hash: Hash, delta: number): boolean {\n const oldCount = this.#refCountUpdates.get(hash);\n assertNumber(oldCount);\n this.#refCountUpdates.set(hash, oldCount + delta);\n return (oldCount === 0 && delta === 1) \|\| (oldCount === 1 && delta === -1);\n }\n}\n"],"mappings":"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"}

package/out/replicache/src/dag/lazy-store.js CHANGED Viewed

@@ -446,12 +446,13 @@ var ChunksCache = class {
 		}
 	}
 	updateForCommit(chunksToPut, refCountUpdates) {
-		for (const [hash, count] of refCountUpdates) if (count === 0) if (!this.#evictsAndDeletesSuspended) this.#deleteEntryByHash(hash);
-		else {
-			this.#refCounts.set(hash, 0);
-			this.#suspendedDeletes.push(hash);
-		}
-		else {
+		for (const [hash, count] of refCountUpdates) if (count === 0) {
+			if (!this.#evictsAndDeletesSuspended) this.#deleteEntryByHash(hash);
+			else {
+				this.#refCounts.set(hash, 0);
+				this.#suspendedDeletes.push(hash);
+			}
+		} else {
 			this.#refCounts.set(hash, count);
 			const chunkAndSize = chunksToPut.get(hash);
 			if (chunkAndSize) {
@@ -484,6 +485,6 @@ var ChunksCache = class {
 	}
 };
 //#endregion
-export { LazyStore };
+export { LazyRead, LazyStore, LazyWrite };
 //# sourceMappingURL=lazy-store.js.map

package/out/replicache/src/dag/lazy-store.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"lazy-store.js","names":["#rwLock","#heads","#sourceStore","#chunkHasher","#assertValidHash","#onStorageFailure","#release","#sourceReadOwnedByCaller","#sourceRead","#getSourceRead","#closed","#refCounts","#refs","#createdChunks","#setHead","#cacheSizeLimit","#getSizeOfChunk","#suspendedDeletes","#cacheChunk","#ensureCacheSizeLimit","#evictsAndDeletesSuspended","#size","#evict","#deleteEntryByHash"],"sources":["../../../../../replicache/src/dag/lazy-store.ts"],"sourcesContent":["import {RWLock} from '@rocicorp/lock';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {getSizeOfValue} from '../../../shared/src/size-of-value.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport type {Hash} from '../hash.ts';\nimport {\n getStorageFailure,\n type StorageFailureError,\n} from '../storage-failure.ts';\nimport type {Chunk} from './chunk.ts';\nimport {type ChunkHasher, type Refs, createChunk} from './chunk.ts';\nimport {\n type HeadChange,\n type RefCountUpdatesDelegate,\n computeRefCountUpdates,\n} from './gc.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\n/*\n Dag Store which lazily loads values from a source store and then caches\n * them in an LRU cache. The memory cache for chunks from the source store\n * size is limited to `sourceCacheSizeLimit` bytes, and values are evicted in an\n * LRU fashion. The purpose of this store is to avoid holding the entire client\n * view (i.e. the source store's content) in each tab's JavaScript heap.\n \n This store's heads are independent from the heads of source store, and are\n * only stored in memory.\n \n Chunks which are created via this store's {@link Write} transaction's\n * {@link createChunk} method are assumed to not be persisted to the source\n * store and thus are cached separately from the source store chunks. These\n * memory-only chunks will not be evicted, and their sizes are not counted\n * towards the source chunk cache size. A memory-only chunk will be deleted if\n * it is no longer reachable from one of this store's heads.\n \n Writes only manipulate the in memory state of this store and do not alter the\n * source store. Thus values must be written to the source store through a\n * separate process (see {@link persist}).\n \n Intended use:\n * 1. source store is the 'perdag', a slower persistent store (i.e.\n * dag.StoreImpl using a kv.IDBStore)\n * 2. this store's 'main' head is initialized to the hash of a chunk containing\n * a commit in the source store\n * 3. reads lazily read chunks from the source store and cache them\n * 3. writes are initially made to this store with memory-only chunks\n * 4. writes are asynchronously persisted to the source store through a separate\n * process (see {@link persist}}. This process gathers memory-only chunks\n * from this store and then writes them to the source store. It then informs\n * this store that these chunks are no longer memory-only by calling\n * {@link chunksPersisted}, which move these chunks\n * to this store's LRU cache of source chunks (making them eligible for\n * eviction).\n \n @param sourceStore Store to lazy load and cache values from.\n * @param sourceCacheSizeLimit Size limit in bytes for cache of chunks loaded\n * from `sourceStore`. This size of a value is determined using\n * `getSizeOfValue`. Keys do not count towards cache size. Memory-only chunks\n * do not count towards cache size.\n * @param getSizeOfValue Function for measuring the size in bytes of a value.\n /\nexport class LazyStore implements Store {\n /\n This lock is used to ensure correct isolation of Reads and Writes.\n * Multiple Reads are allowed in parallel but only a single Write. Reads and\n * Writes see an isolated view of the store (corresponding to the Serializable\n * level of transaction isolation defined in the SQL standard).\n \n To ensure these semantics the read lock must be acquired when a Read is\n * created and held til it is closed, and a Write lock must be acquired when a\n * Write is created and held til it is committed or closed.\n \n Code must have a read or write lock to\n * - read `_heads`\n * - read `_memOnlyChunks`\n * - read `_sourceStore`\n * - read and write `_sourceChunksCache`\n * - read and write `_refCounts`\n * - read and write `_refs`\n * and must have a write lock to\n * - write `_heads`\n * - write `_memOnlyChunks`\n /\n readonly #rwLock = new RWLock();\n readonly #heads = new Map<string, Hash>();\n readonly #sourceStore: Store;\n readonly #chunkHasher: ChunkHasher;\n readonly #assertValidHash: (hash: Hash) => void;\n\n /* The following are protected so testing subclass can access. /\n protected readonly _memOnlyChunks = new Map<Hash, Chunk>();\n protected readonly _sourceChunksCache: ChunksCache;\n /\n Ref counts are maintained so that chunks which are unreachable\n * from this stores heads can be eagerly and deterministically deleted from\n * `this._memOnlyChunks` and `this._sourceChunksCache`.\n \n These ref counts are independent from `this._sourceStore`'s ref counts.\n * These ref counts are based on reachability from `this._heads`.\n * A chunk is deleted from `this._memOnlyChunks` or\n * `this._sourceChunksCache` (which ever it is in) when its ref count becomes\n * zero.\n * These ref counts count the refs in `this._heads` and `this._refs`.\n \n Not all reachable chunk's refs are included in `this._refs`, because this\n * would require loading all chunks reachable in the source store in a\n * non-lazy manner. `this._refs` contains the refs of all currently reachable\n * chunks that were ever in `this._memOnlyChunks` or\n * `this._sourceChunksCache` (even if they have been evicted). A\n * chunk's ref information is lazily discovered and stored in `this._refs` and\n * counted in `this._refCounts`. A chunk's entries in `this._refs` and\n * `this._refCounts` are only deleted when a chunk is deleted due to it\n * becoming unreachable (it is not deleted if the chunk is evicted from the\n * source-store cache).\n \n The major implication of this lazy discovery of source store refs, is that\n * a reachable source store chunk may not be cached when loaded, because it is\n * not known to be reachable because some of the pertinent refs have not been\n * discovered. However, in practice chunks are read by traversing the graph\n * starting from a head, and all pertinent refs are discovered as part of the\n * traversal.\n \n These ref counts can be changed in two ways:\n * 1. A LazyRead has a cache miss and loads a chunk from the source store that\n * is reachable from this._heads. If this chunk's refs are not currently\n * counted, it will not have an entry in `this._refs`. In this case, the\n * chunks refs will be put in `this._refs` and `this._refCounts` will be\n * updated to count them.\n * 2. A LazyWrite commit updates a head (which can result in increasing or\n * decreasing ref count) or puts a reachable chunk (either a `memory-only` or\n * `source` chunk) that references this hash (increasing ref count). The\n * computation of these ref count changes is delegated to the\n * `computeRefCountUpdates` shared with dag.StoreImpl. In order to\n * delegate determining reachability to `computeRefCountUpdates` and defer\n * this determination until commit time, LazyWrite treats cache misses\n * as a 'put' of the lazily-loaded chunk.\n \n A chunk's hash may have an entry in `this._refCounts` without that\n * chunk have ever been in `this._memOnlyChunks` or `this._sourceChunksCache`.\n * This is the case when a head or a reachable chunk that was ever in\n * `this._memOnlyChunks` or `this._sourceChunksCache` references a chunk\n * which is not currently cached (either because it has not been read, or\n * because it has been evicted).\n /\n protected readonly _refCounts = new Map<Hash, number>();\n protected readonly _refs = new Map<Hash, readonly Hash[]>();\n\n readonly #onStorageFailure:\n \| ((failure: StorageFailureError) => void)\n \| undefined;\n\n /\n @param onStorageFailure Called when a read of the source store fails on\n * its storage (a {@link StorageFailureError}). Every read this store makes\n * for a chunk it has not cached goes through here, whichever caller asked\n * for it: a query, a mutation, a poke. The source store's own wrapper\n * reports only the begin, commit and release of a transaction.\n /\n constructor(\n sourceStore: Store,\n sourceCacheSizeLimit: number,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n getSizeOfChunk: (chunk: Chunk) => number = getSizeOfValue,\n onStorageFailure?: ((failure: StorageFailureError) => void) \| undefined,\n ) {\n this._sourceChunksCache = new ChunksCache(\n sourceCacheSizeLimit,\n getSizeOfChunk,\n this._refCounts,\n this._refs,\n );\n this.#sourceStore = sourceStore;\n this.#chunkHasher = chunkHasher;\n this.#assertValidHash = assertValidHash;\n this.#onStorageFailure = onStorageFailure;\n }\n\n async read(sourceRead?: Read): Promise<LazyRead> {\n const release = await this.#rwLock.read();\n return new LazyRead(\n this.#heads,\n this._memOnlyChunks,\n this._sourceChunksCache,\n this.#sourceStore,\n release,\n this.#assertValidHash,\n sourceRead,\n this.#onStorageFailure,\n );\n }\n\n async write(): Promise<LazyWrite> {\n const release = await this.#rwLock.write();\n return new LazyWrite(\n this.#heads,\n this._memOnlyChunks,\n this._sourceChunksCache,\n this.#sourceStore,\n this._refCounts,\n this._refs,\n release,\n this.#chunkHasher,\n this.#assertValidHash,\n this.#onStorageFailure,\n );\n }\n\n close(): Promise<void> {\n return promiseVoid;\n }\n\n /\n Does not acquire any lock on the store.\n /\n isCached(chunkHash: Hash): boolean {\n return (\n this._sourceChunksCache.getWithoutUpdatingLRU(chunkHash) !== undefined\n );\n }\n\n withSuspendedSourceCacheEvictsAndDeletes<T>(\n fn: () => MaybePromise<T>,\n ): Promise<T> {\n return this._sourceChunksCache.withSuspendedEvictsAndDeletes(fn);\n }\n}\n\nexport class LazyRead implements Read {\n protected readonly _heads: Map<string, Hash>;\n protected readonly _memOnlyChunks: Map<Hash, Chunk>;\n protected readonly _sourceChunksCache: ChunksCache;\n protected readonly _sourceStore: Store;\n #sourceRead: Promise<Read> \| undefined = undefined;\n readonly #release: () => void;\n #closed = false;\n readonly assertValidHash: (hash: Hash) => void;\n readonly #sourceReadOwnedByCaller: boolean;\n readonly #onStorageFailure:\n \| ((failure: StorageFailureError) => void)\n \| undefined;\n\n constructor(\n heads: Map<string, Hash>,\n memOnlyChunks: Map<Hash, Chunk>,\n sourceChunksCache: ChunksCache,\n sourceStore: Store,\n release: () => void,\n assertValidHash: (hash: Hash) => void,\n // If the lazyRead is being run in the context of an existing\n // read, or write, from the perdag then we must use _that_\n // transaction's read. Trying to open our own `sourceRead` will\n // cause the outer transaction to auto-commit.\n sourceRead?: Read,\n onStorageFailure?: ((failure: StorageFailureError) => void) \| undefined,\n ) {\n this._heads = heads;\n this._memOnlyChunks = memOnlyChunks;\n this._sourceChunksCache = sourceChunksCache;\n this._sourceStore = sourceStore;\n this.#release = release;\n this.assertValidHash = assertValidHash;\n this.#sourceRead =\n sourceRead !== undefined ? Promise.resolve(sourceRead) : undefined;\n this.#sourceReadOwnedByCaller = sourceRead !== undefined;\n this.#onStorageFailure = onStorageFailure;\n }\n\n /\n Reads `hash` from the source store. A storage failure on the read is\n * reported before it propagates, so the instance hears of it whichever\n * caller made the read.\n /\n protected async _getSourceChunk(hash: Hash): Promise<Chunk \| undefined> {\n try {\n return await (await this.#getSourceRead()).getChunk(hash);\n } catch (e) {\n const failure = getStorageFailure(e);\n if (failure !== undefined) {\n this.#onStorageFailure?.(failure);\n }\n throw e;\n }\n }\n\n isMemOnlyChunkHash(hash: Hash): boolean {\n return this._memOnlyChunks.has(hash);\n }\n\n async hasChunk(hash: Hash): Promise<boolean> {\n return (await this.getChunk(hash)) !== undefined;\n }\n\n async getChunk(hash: Hash): Promise<Chunk \| undefined> {\n const memOnlyChunk = this._memOnlyChunks.get(hash);\n if (memOnlyChunk !== undefined) {\n return memOnlyChunk;\n }\n let chunk = this._sourceChunksCache.get(hash);\n if (chunk === undefined) {\n chunk = await this._getSourceChunk(hash);\n if (chunk !== undefined) {\n this._sourceChunksCache.put(chunk);\n }\n }\n return chunk;\n }\n\n mustGetChunk(hash: Hash): Promise<Chunk> {\n return mustGetChunk(this, hash);\n }\n\n getHead(name: string): Promise<Hash \| undefined> {\n return Promise.resolve(this._heads.get(name));\n }\n\n release(): void {\n if (!this.#closed) {\n this.#release();\n if (!this.#sourceReadOwnedByCaller) {\n this.#sourceRead\n ?.then(read => read.release())\n // If creation of the read failed there is nothing to release.\n // Catch to avoid `Uncaught (in promise)` errors being reported.\n .catch(_ => {});\n }\n this.#closed = true;\n }\n }\n\n get closed(): boolean {\n return this.#closed;\n }\n\n #getSourceRead(): Promise<Read> {\n if (!this.#sourceRead) {\n this.#sourceRead = this._sourceStore.read();\n }\n return this.#sourceRead;\n }\n}\n\nexport class LazyWrite\n extends LazyRead\n implements Write, RefCountUpdatesDelegate\n{\n readonly #refCounts: Map<Hash, number>;\n readonly #refs: Map<Hash, readonly Hash[]>;\n readonly #chunkHasher: ChunkHasher;\n protected readonly _pendingHeadChanges = new Map<string, HeadChange>();\n protected readonly _pendingMemOnlyChunks = new Map<Hash, Chunk>();\n protected readonly _pendingCachedChunks = new Map<\n Hash,\n {chunk: Chunk; size: number}\n >();\n readonly #createdChunks = new Set<Hash>();\n\n constructor(\n heads: Map<string, Hash>,\n memOnlyChunks: Map<Hash, Chunk>,\n sourceChunksCache: ChunksCache,\n sourceStore: Store,\n refCounts: Map<Hash, number>,\n refs: Map<Hash, readonly Hash[]>,\n release: () => void,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n onStorageFailure?: ((failure: StorageFailureError) => void) \| undefined,\n ) {\n super(\n heads,\n memOnlyChunks,\n sourceChunksCache,\n sourceStore,\n release,\n assertValidHash,\n undefined,\n onStorageFailure,\n );\n this.#refCounts = refCounts;\n this.#refs = refs;\n this.#chunkHasher = chunkHasher;\n }\n\n createChunk = <V>(data: V, refs: Refs): Chunk<V> => {\n const chunk = createChunk(data, refs, this.#chunkHasher);\n this.#createdChunks.add(chunk.hash);\n return chunk;\n };\n\n putChunk<V>(c: Chunk<V>, size?: number): Promise<void> {\n const {hash, meta} = c;\n this.assertValidHash(hash);\n if (meta.length > 0) {\n for (const h of meta) {\n this.assertValidHash(h);\n }\n }\n if (this.#createdChunks.has(hash) \|\| this.isMemOnlyChunkHash(hash)) {\n this._pendingMemOnlyChunks.set(hash, c);\n } else {\n this._pendingCachedChunks.set(hash, {chunk: c, size: size ?? -1});\n }\n return promiseVoid;\n }\n\n async setHead(name: string, hash: Hash): Promise<void> {\n await this.#setHead(name, hash);\n }\n\n async removeHead(name: string): Promise<void> {\n await this.#setHead(name, undefined);\n }\n\n async #setHead(name: string, hash: Hash \| undefined): Promise<void> {\n const oldHash = await this.getHead(name);\n const v = this._pendingHeadChanges.get(name);\n if (v === undefined) {\n this._pendingHeadChanges.set(name, {new: hash, old: oldHash});\n } else {\n // Keep old if existing\n v.new = hash;\n }\n }\n\n override isMemOnlyChunkHash(hash: Hash): boolean {\n return (\n this._pendingMemOnlyChunks.has(hash) \|\| super.isMemOnlyChunkHash(hash)\n );\n }\n\n override async getChunk(hash: Hash): Promise<Chunk \| undefined> {\n const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);\n if (pendingMemOnlyChunk !== undefined) {\n return pendingMemOnlyChunk;\n }\n const memOnlyChunk = this._memOnlyChunks.get(hash);\n if (memOnlyChunk !== undefined) {\n return memOnlyChunk;\n }\n // In order to delegate determining reachability to `computeRefCountUpdates`\n // and defer this determination until commit time, treat cache misses\n // as a 'put' of the lazily-loaded chunk.\n const pendingCachedChunk = this._pendingCachedChunks.get(hash);\n if (pendingCachedChunk !== undefined) {\n return pendingCachedChunk.chunk;\n }\n let chunk = this._sourceChunksCache.get(hash);\n if (chunk === undefined) {\n chunk = await this._getSourceChunk(hash);\n if (chunk !== undefined) {\n this._pendingCachedChunks.set(chunk.hash, {chunk, size: -1});\n }\n }\n return chunk;\n }\n\n override getHead(name: string): Promise<Hash \| undefined> {\n const headChange = this._pendingHeadChanges.get(name);\n if (headChange) {\n return Promise.resolve(headChange.new);\n }\n return super.getHead(name);\n }\n\n async commit(): Promise<void> {\n const pendingChunks = new Set(\n joinIterables(\n this._pendingMemOnlyChunks.keys(),\n this._pendingCachedChunks.keys(),\n ),\n );\n const refCountUpdates = await computeRefCountUpdates(\n this._pendingHeadChanges.values(),\n pendingChunks,\n this,\n );\n\n for (const [hash, count] of refCountUpdates) {\n if (this.isMemOnlyChunkHash(hash)) {\n if (count === 0) {\n this.#refCounts.delete(hash);\n this._memOnlyChunks.delete(hash);\n this.#refs.delete(hash);\n } else {\n this.#refCounts.set(hash, count);\n const chunk = this._pendingMemOnlyChunks.get(hash);\n if (chunk) {\n this.#refs.set(hash, chunk.meta);\n this._memOnlyChunks.set(hash, chunk);\n }\n }\n refCountUpdates.delete(hash);\n }\n }\n\n this._sourceChunksCache.updateForCommit(\n this._pendingCachedChunks,\n refCountUpdates,\n );\n\n for (const [name, headChange] of this._pendingHeadChanges) {\n if (headChange.new) {\n this._heads.set(name, headChange.new);\n } else {\n this._heads.delete(name);\n }\n }\n\n this._pendingMemOnlyChunks.clear();\n this._pendingCachedChunks.clear();\n this._pendingHeadChanges.clear();\n this.release();\n }\n\n getRefCount(hash: Hash): number \| undefined {\n return this.#refCounts.get(hash);\n }\n\n getRefs(hash: Hash): readonly Hash[] \| undefined {\n const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);\n if (pendingMemOnlyChunk) {\n return pendingMemOnlyChunk.meta;\n }\n const memOnlyChunk = this._memOnlyChunks.get(hash);\n if (memOnlyChunk) {\n return memOnlyChunk.meta;\n }\n const pendingCachedChunk = this._pendingCachedChunks.get(hash);\n if (pendingCachedChunk !== undefined) {\n return pendingCachedChunk.chunk.meta;\n }\n return this.#refs.get(hash);\n }\n\n areRefsCounted(hash: Hash): boolean {\n return this.#refs.has(hash);\n }\n\n chunksPersisted(chunkHashes: readonly Hash[]): void {\n const chunksToCache = [];\n for (const chunkHash of chunkHashes) {\n const chunk = this._memOnlyChunks.get(chunkHash);\n if (chunk) {\n this._memOnlyChunks.delete(chunkHash);\n chunksToCache.push(chunk);\n }\n }\n this._sourceChunksCache.persisted(chunksToCache);\n }\n}\n\ntype CacheEntry = {\n chunk: Chunk;\n size: number;\n};\n\nclass ChunksCache {\n readonly #cacheSizeLimit: number;\n readonly #getSizeOfChunk: (chunk: Chunk) => number;\n readonly #refCounts: Map<Hash, number>;\n readonly #refs: Map<Hash, readonly Hash[]>;\n #size = 0;\n #evictsAndDeletesSuspended = false;\n readonly #suspendedDeletes: Hash[] = [];\n\n /\n Iteration order is from least to most recently used.\n \n Public so that testing subclass can access.\n */\n readonly cacheEntries = new Map<Hash, CacheEntry>();\n\n constructor(\n cacheSizeLimit: number,\n getSizeOfChunk: (v: Chunk) => number,\n refCounts: Map<Hash, number>,\n refs: Map<Hash, readonly Hash[]>,\n ) {\n this.#cacheSizeLimit = cacheSizeLimit;\n this.#getSizeOfChunk = getSizeOfChunk;\n this.#refCounts = refCounts;\n this.#refs = refs;\n }\n\n get(hash: Hash): Chunk \| undefined {\n const cacheEntry = this.cacheEntries.get(hash);\n if (cacheEntry) {\n // Update order in map for LRU tracking.\n this.cacheEntries.delete(hash);\n this.cacheEntries.set(hash, cacheEntry);\n }\n return cacheEntry?.chunk;\n }\n\n getWithoutUpdatingLRU(hash: Hash): Chunk \| undefined {\n return this.cacheEntries.get(hash)?.chunk;\n }\n\n put(chunk: Chunk): void {\n const {hash} = chunk;\n // If there is an existing cache entry then the cached value must be\n // equivalent. Update order in map for LRU tracking and early return.\n const oldCacheEntry = this.cacheEntries.get(hash);\n if (oldCacheEntry) {\n this.cacheEntries.delete(hash);\n this.cacheEntries.set(hash, oldCacheEntry);\n return;\n }\n\n // Only cache if there is a ref from a head to this chunk\n const refCount = this.#refCounts.get(hash);\n if (refCount === undefined \|\| refCount < 1) {\n return;\n }\n if (!this.#cacheChunk(chunk)) {\n return;\n }\n if (!this.#refs.has(hash)) {\n for (const refHash of chunk.meta) {\n this.#refCounts.set(refHash, (this.#refCounts.get(refHash) \|\| 0) + 1);\n }\n this.#refs.set(hash, chunk.meta);\n }\n\n this.#ensureCacheSizeLimit();\n }\n\n #ensureCacheSizeLimit() {\n if (this.#evictsAndDeletesSuspended) {\n return;\n }\n for (const entry of this.cacheEntries.values()) {\n if (this.#size <= this.#cacheSizeLimit) {\n break;\n }\n this.#evict(entry);\n }\n }\n\n #cacheChunk(chunk: Chunk, size?: number): boolean {\n const chunkSize = size ?? this.#getSizeOfChunk(chunk);\n if (chunkSize > this.#cacheSizeLimit) {\n // This value cannot be cached due to its size exceeding the\n // cache size limit, don't evict other entries to try to make\n // room for it.\n return false;\n }\n this.#size += chunkSize;\n this.cacheEntries.set(chunk.hash, {chunk, size: chunkSize});\n return true;\n }\n\n #evict(cacheEntry: CacheEntry): void {\n const {hash} = cacheEntry.chunk;\n this.#size -= cacheEntry.size;\n this.cacheEntries.delete(hash);\n }\n\n #deleteEntryByHash(hash: Hash): void {\n this.#refCounts.delete(hash);\n this.#refs.delete(hash);\n const cacheEntry = this.cacheEntries.get(hash);\n if (cacheEntry) {\n this.#size -= cacheEntry.size;\n this.cacheEntries.delete(hash);\n }\n }\n\n updateForCommit(\n chunksToPut: Map<Hash, {chunk: Chunk; size: number}>,\n refCountUpdates: Map<Hash, number>,\n ): void {\n for (const [hash, count] of refCountUpdates) {\n if (count === 0) {\n if (!this.#evictsAndDeletesSuspended) {\n this.#deleteEntryByHash(hash);\n } else {\n this.#refCounts.set(hash, 0);\n this.#suspendedDeletes.push(hash);\n }\n } else {\n this.#refCounts.set(hash, count);\n const chunkAndSize = chunksToPut.get(hash);\n if (chunkAndSize) {\n const {chunk, size} = chunkAndSize;\n const oldCacheEntry = this.cacheEntries.get(hash);\n if (oldCacheEntry) {\n // If there is an existing cache entry then the cached value must be\n // equivalent. Update order in map for LRU tracking but avoid\n // recomputing size and creating a new cache entry.\n this.cacheEntries.delete(hash);\n this.cacheEntries.set(hash, oldCacheEntry);\n } else {\n this.#cacheChunk(chunk, size !== -1 ? size : undefined);\n this.#refs.set(hash, chunk.meta);\n }\n }\n }\n }\n this.#ensureCacheSizeLimit();\n }\n\n persisted(chunks: Iterable<Chunk>) {\n for (const chunk of chunks) {\n this.#cacheChunk(chunk);\n }\n this.#ensureCacheSizeLimit();\n }\n\n async withSuspendedEvictsAndDeletes<T>(\n fn: () => MaybePromise<T>,\n ): Promise<T> {\n this.#evictsAndDeletesSuspended = true;\n try {\n return await fn();\n } finally {\n this.#evictsAndDeletesSuspended = false;\n for (const hash of this.#suspendedDeletes) {\n if (this.#refCounts.get(hash) === 0) {\n this.#deleteEntryByHash(hash);\n }\n }\n this.#ensureCacheSizeLimit();\n }\n }\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"lazy-store.js","names":[],"sources":["../../../../../replicache/src/dag/lazy-store.ts"],"sourcesContent":["import {RWLock} from '@rocicorp/lock';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {getSizeOfValue} from '../../../shared/src/size-of-value.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport type {Hash} from '../hash.ts';\nimport {\n getStorageFailure,\n type StorageFailureError,\n} from '../storage-failure.ts';\nimport type {Chunk} from './chunk.ts';\nimport {type ChunkHasher, type Refs, createChunk} from './chunk.ts';\nimport {\n type HeadChange,\n type RefCountUpdatesDelegate,\n computeRefCountUpdates,\n} from './gc.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\n/*\n Dag Store which lazily loads values from a source store and then caches\n * them in an LRU cache. The memory cache for chunks from the source store\n * size is limited to `sourceCacheSizeLimit` bytes, and values are evicted in an\n * LRU fashion. The purpose of this store is to avoid holding the entire client\n * view (i.e. the source store's content) in each tab's JavaScript heap.\n \n This store's heads are independent from the heads of source store, and are\n * only stored in memory.\n \n Chunks which are created via this store's {@link Write} transaction's\n * {@link createChunk} method are assumed to not be persisted to the source\n * store and thus are cached separately from the source store chunks. These\n * memory-only chunks will not be evicted, and their sizes are not counted\n * towards the source chunk cache size. A memory-only chunk will be deleted if\n * it is no longer reachable from one of this store's heads.\n \n Writes only manipulate the in memory state of this store and do not alter the\n * source store. Thus values must be written to the source store through a\n * separate process (see {@link persist}).\n \n Intended use:\n * 1. source store is the 'perdag', a slower persistent store (i.e.\n * dag.StoreImpl using a kv.IDBStore)\n * 2. this store's 'main' head is initialized to the hash of a chunk containing\n * a commit in the source store\n * 3. reads lazily read chunks from the source store and cache them\n * 3. writes are initially made to this store with memory-only chunks\n * 4. writes are asynchronously persisted to the source store through a separate\n * process (see {@link persist}}. This process gathers memory-only chunks\n * from this store and then writes them to the source store. It then informs\n * this store that these chunks are no longer memory-only by calling\n * {@link chunksPersisted}, which move these chunks\n * to this store's LRU cache of source chunks (making them eligible for\n * eviction).\n \n @param sourceStore Store to lazy load and cache values from.\n * @param sourceCacheSizeLimit Size limit in bytes for cache of chunks loaded\n * from `sourceStore`. This size of a value is determined using\n * `getSizeOfValue`. Keys do not count towards cache size. Memory-only chunks\n * do not count towards cache size.\n * @param getSizeOfValue Function for measuring the size in bytes of a value.\n /\nexport class LazyStore implements Store {\n /\n This lock is used to ensure correct isolation of Reads and Writes.\n * Multiple Reads are allowed in parallel but only a single Write. Reads and\n * Writes see an isolated view of the store (corresponding to the Serializable\n * level of transaction isolation defined in the SQL standard).\n \n To ensure these semantics the read lock must be acquired when a Read is\n * created and held til it is closed, and a Write lock must be acquired when a\n * Write is created and held til it is committed or closed.\n \n Code must have a read or write lock to\n * - read `_heads`\n * - read `_memOnlyChunks`\n * - read `_sourceStore`\n * - read and write `_sourceChunksCache`\n * - read and write `_refCounts`\n * - read and write `_refs`\n * and must have a write lock to\n * - write `_heads`\n * - write `_memOnlyChunks`\n /\n readonly #rwLock = new RWLock();\n readonly #heads = new Map<string, Hash>();\n readonly #sourceStore: Store;\n readonly #chunkHasher: ChunkHasher;\n readonly #assertValidHash: (hash: Hash) => void;\n\n /* The following are protected so testing subclass can access. /\n protected readonly _memOnlyChunks = new Map<Hash, Chunk>();\n protected readonly _sourceChunksCache: ChunksCache;\n /\n Ref counts are maintained so that chunks which are unreachable\n * from this stores heads can be eagerly and deterministically deleted from\n * `this._memOnlyChunks` and `this._sourceChunksCache`.\n \n These ref counts are independent from `this._sourceStore`'s ref counts.\n * These ref counts are based on reachability from `this._heads`.\n * A chunk is deleted from `this._memOnlyChunks` or\n * `this._sourceChunksCache` (which ever it is in) when its ref count becomes\n * zero.\n * These ref counts count the refs in `this._heads` and `this._refs`.\n \n Not all reachable chunk's refs are included in `this._refs`, because this\n * would require loading all chunks reachable in the source store in a\n * non-lazy manner. `this._refs` contains the refs of all currently reachable\n * chunks that were ever in `this._memOnlyChunks` or\n * `this._sourceChunksCache` (even if they have been evicted). A\n * chunk's ref information is lazily discovered and stored in `this._refs` and\n * counted in `this._refCounts`. A chunk's entries in `this._refs` and\n * `this._refCounts` are only deleted when a chunk is deleted due to it\n * becoming unreachable (it is not deleted if the chunk is evicted from the\n * source-store cache).\n \n The major implication of this lazy discovery of source store refs, is that\n * a reachable source store chunk may not be cached when loaded, because it is\n * not known to be reachable because some of the pertinent refs have not been\n * discovered. However, in practice chunks are read by traversing the graph\n * starting from a head, and all pertinent refs are discovered as part of the\n * traversal.\n \n These ref counts can be changed in two ways:\n * 1. A LazyRead has a cache miss and loads a chunk from the source store that\n * is reachable from this._heads. If this chunk's refs are not currently\n * counted, it will not have an entry in `this._refs`. In this case, the\n * chunks refs will be put in `this._refs` and `this._refCounts` will be\n * updated to count them.\n * 2. A LazyWrite commit updates a head (which can result in increasing or\n * decreasing ref count) or puts a reachable chunk (either a `memory-only` or\n * `source` chunk) that references this hash (increasing ref count). The\n * computation of these ref count changes is delegated to the\n * `computeRefCountUpdates` shared with dag.StoreImpl. In order to\n * delegate determining reachability to `computeRefCountUpdates` and defer\n * this determination until commit time, LazyWrite treats cache misses\n * as a 'put' of the lazily-loaded chunk.\n \n A chunk's hash may have an entry in `this._refCounts` without that\n * chunk have ever been in `this._memOnlyChunks` or `this._sourceChunksCache`.\n * This is the case when a head or a reachable chunk that was ever in\n * `this._memOnlyChunks` or `this._sourceChunksCache` references a chunk\n * which is not currently cached (either because it has not been read, or\n * because it has been evicted).\n /\n protected readonly _refCounts = new Map<Hash, number>();\n protected readonly _refs = new Map<Hash, readonly Hash[]>();\n\n readonly #onStorageFailure:\n \| ((failure: StorageFailureError) => void)\n \| undefined;\n\n /\n @param onStorageFailure Called when a read of the source store fails on\n * its storage (a {@link StorageFailureError}). Every read this store makes\n * for a chunk it has not cached goes through here, whichever caller asked\n * for it: a query, a mutation, a poke. The source store's own wrapper\n * reports only the begin, commit and release of a transaction.\n /\n constructor(\n sourceStore: Store,\n sourceCacheSizeLimit: number,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n getSizeOfChunk: (chunk: Chunk) => number = getSizeOfValue,\n onStorageFailure?: ((failure: StorageFailureError) => void) \| undefined,\n ) {\n this._sourceChunksCache = new ChunksCache(\n sourceCacheSizeLimit,\n getSizeOfChunk,\n this._refCounts,\n this._refs,\n );\n this.#sourceStore = sourceStore;\n this.#chunkHasher = chunkHasher;\n this.#assertValidHash = assertValidHash;\n this.#onStorageFailure = onStorageFailure;\n }\n\n async read(sourceRead?: Read): Promise<LazyRead> {\n const release = await this.#rwLock.read();\n return new LazyRead(\n this.#heads,\n this._memOnlyChunks,\n this._sourceChunksCache,\n this.#sourceStore,\n release,\n this.#assertValidHash,\n sourceRead,\n this.#onStorageFailure,\n );\n }\n\n async write(): Promise<LazyWrite> {\n const release = await this.#rwLock.write();\n return new LazyWrite(\n this.#heads,\n this._memOnlyChunks,\n this._sourceChunksCache,\n this.#sourceStore,\n this._refCounts,\n this._refs,\n release,\n this.#chunkHasher,\n this.#assertValidHash,\n this.#onStorageFailure,\n );\n }\n\n close(): Promise<void> {\n return promiseVoid;\n }\n\n /\n Does not acquire any lock on the store.\n /\n isCached(chunkHash: Hash): boolean {\n return (\n this._sourceChunksCache.getWithoutUpdatingLRU(chunkHash) !== undefined\n );\n }\n\n withSuspendedSourceCacheEvictsAndDeletes<T>(\n fn: () => MaybePromise<T>,\n ): Promise<T> {\n return this._sourceChunksCache.withSuspendedEvictsAndDeletes(fn);\n }\n}\n\nexport class LazyRead implements Read {\n protected readonly _heads: Map<string, Hash>;\n protected readonly _memOnlyChunks: Map<Hash, Chunk>;\n protected readonly _sourceChunksCache: ChunksCache;\n protected readonly _sourceStore: Store;\n #sourceRead: Promise<Read> \| undefined = undefined;\n readonly #release: () => void;\n #closed = false;\n readonly assertValidHash: (hash: Hash) => void;\n readonly #sourceReadOwnedByCaller: boolean;\n readonly #onStorageFailure:\n \| ((failure: StorageFailureError) => void)\n \| undefined;\n\n constructor(\n heads: Map<string, Hash>,\n memOnlyChunks: Map<Hash, Chunk>,\n sourceChunksCache: ChunksCache,\n sourceStore: Store,\n release: () => void,\n assertValidHash: (hash: Hash) => void,\n // If the lazyRead is being run in the context of an existing\n // read, or write, from the perdag then we must use _that_\n // transaction's read. Trying to open our own `sourceRead` will\n // cause the outer transaction to auto-commit.\n sourceRead?: Read,\n onStorageFailure?: ((failure: StorageFailureError) => void) \| undefined,\n ) {\n this._heads = heads;\n this._memOnlyChunks = memOnlyChunks;\n this._sourceChunksCache = sourceChunksCache;\n this._sourceStore = sourceStore;\n this.#release = release;\n this.assertValidHash = assertValidHash;\n this.#sourceRead =\n sourceRead !== undefined ? Promise.resolve(sourceRead) : undefined;\n this.#sourceReadOwnedByCaller = sourceRead !== undefined;\n this.#onStorageFailure = onStorageFailure;\n }\n\n /\n Reads `hash` from the source store. A storage failure on the read is\n * reported before it propagates, so the instance hears of it whichever\n * caller made the read.\n /\n protected async _getSourceChunk(hash: Hash): Promise<Chunk \| undefined> {\n try {\n return await (await this.#getSourceRead()).getChunk(hash);\n } catch (e) {\n const failure = getStorageFailure(e);\n if (failure !== undefined) {\n this.#onStorageFailure?.(failure);\n }\n throw e;\n }\n }\n\n isMemOnlyChunkHash(hash: Hash): boolean {\n return this._memOnlyChunks.has(hash);\n }\n\n async hasChunk(hash: Hash): Promise<boolean> {\n return (await this.getChunk(hash)) !== undefined;\n }\n\n async getChunk(hash: Hash): Promise<Chunk \| undefined> {\n const memOnlyChunk = this._memOnlyChunks.get(hash);\n if (memOnlyChunk !== undefined) {\n return memOnlyChunk;\n }\n let chunk = this._sourceChunksCache.get(hash);\n if (chunk === undefined) {\n chunk = await this._getSourceChunk(hash);\n if (chunk !== undefined) {\n this._sourceChunksCache.put(chunk);\n }\n }\n return chunk;\n }\n\n mustGetChunk(hash: Hash): Promise<Chunk> {\n return mustGetChunk(this, hash);\n }\n\n getHead(name: string): Promise<Hash \| undefined> {\n return Promise.resolve(this._heads.get(name));\n }\n\n release(): void {\n if (!this.#closed) {\n this.#release();\n if (!this.#sourceReadOwnedByCaller) {\n this.#sourceRead\n ?.then(read => read.release())\n // If creation of the read failed there is nothing to release.\n // Catch to avoid `Uncaught (in promise)` errors being reported.\n .catch(_ => {});\n }\n this.#closed = true;\n }\n }\n\n get closed(): boolean {\n return this.#closed;\n }\n\n #getSourceRead(): Promise<Read> {\n if (!this.#sourceRead) {\n this.#sourceRead = this._sourceStore.read();\n }\n return this.#sourceRead;\n }\n}\n\nexport class LazyWrite\n extends LazyRead\n implements Write, RefCountUpdatesDelegate\n{\n readonly #refCounts: Map<Hash, number>;\n readonly #refs: Map<Hash, readonly Hash[]>;\n readonly #chunkHasher: ChunkHasher;\n protected readonly _pendingHeadChanges = new Map<string, HeadChange>();\n protected readonly _pendingMemOnlyChunks = new Map<Hash, Chunk>();\n protected readonly _pendingCachedChunks = new Map<\n Hash,\n {chunk: Chunk; size: number}\n >();\n readonly #createdChunks = new Set<Hash>();\n\n constructor(\n heads: Map<string, Hash>,\n memOnlyChunks: Map<Hash, Chunk>,\n sourceChunksCache: ChunksCache,\n sourceStore: Store,\n refCounts: Map<Hash, number>,\n refs: Map<Hash, readonly Hash[]>,\n release: () => void,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n onStorageFailure?: ((failure: StorageFailureError) => void) \| undefined,\n ) {\n super(\n heads,\n memOnlyChunks,\n sourceChunksCache,\n sourceStore,\n release,\n assertValidHash,\n undefined,\n onStorageFailure,\n );\n this.#refCounts = refCounts;\n this.#refs = refs;\n this.#chunkHasher = chunkHasher;\n }\n\n createChunk = <V>(data: V, refs: Refs): Chunk<V> => {\n const chunk = createChunk(data, refs, this.#chunkHasher);\n this.#createdChunks.add(chunk.hash);\n return chunk;\n };\n\n putChunk<V>(c: Chunk<V>, size?: number): Promise<void> {\n const {hash, meta} = c;\n this.assertValidHash(hash);\n if (meta.length > 0) {\n for (const h of meta) {\n this.assertValidHash(h);\n }\n }\n if (this.#createdChunks.has(hash) \|\| this.isMemOnlyChunkHash(hash)) {\n this._pendingMemOnlyChunks.set(hash, c);\n } else {\n this._pendingCachedChunks.set(hash, {chunk: c, size: size ?? -1});\n }\n return promiseVoid;\n }\n\n async setHead(name: string, hash: Hash): Promise<void> {\n await this.#setHead(name, hash);\n }\n\n async removeHead(name: string): Promise<void> {\n await this.#setHead(name, undefined);\n }\n\n async #setHead(name: string, hash: Hash \| undefined): Promise<void> {\n const oldHash = await this.getHead(name);\n const v = this._pendingHeadChanges.get(name);\n if (v === undefined) {\n this._pendingHeadChanges.set(name, {new: hash, old: oldHash});\n } else {\n // Keep old if existing\n v.new = hash;\n }\n }\n\n override isMemOnlyChunkHash(hash: Hash): boolean {\n return (\n this._pendingMemOnlyChunks.has(hash) \|\| super.isMemOnlyChunkHash(hash)\n );\n }\n\n override async getChunk(hash: Hash): Promise<Chunk \| undefined> {\n const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);\n if (pendingMemOnlyChunk !== undefined) {\n return pendingMemOnlyChunk;\n }\n const memOnlyChunk = this._memOnlyChunks.get(hash);\n if (memOnlyChunk !== undefined) {\n return memOnlyChunk;\n }\n // In order to delegate determining reachability to `computeRefCountUpdates`\n // and defer this determination until commit time, treat cache misses\n // as a 'put' of the lazily-loaded chunk.\n const pendingCachedChunk = this._pendingCachedChunks.get(hash);\n if (pendingCachedChunk !== undefined) {\n return pendingCachedChunk.chunk;\n }\n let chunk = this._sourceChunksCache.get(hash);\n if (chunk === undefined) {\n chunk = await this._getSourceChunk(hash);\n if (chunk !== undefined) {\n this._pendingCachedChunks.set(chunk.hash, {chunk, size: -1});\n }\n }\n return chunk;\n }\n\n override getHead(name: string): Promise<Hash \| undefined> {\n const headChange = this._pendingHeadChanges.get(name);\n if (headChange) {\n return Promise.resolve(headChange.new);\n }\n return super.getHead(name);\n }\n\n async commit(): Promise<void> {\n const pendingChunks = new Set(\n joinIterables(\n this._pendingMemOnlyChunks.keys(),\n this._pendingCachedChunks.keys(),\n ),\n );\n const refCountUpdates = await computeRefCountUpdates(\n this._pendingHeadChanges.values(),\n pendingChunks,\n this,\n );\n\n for (const [hash, count] of refCountUpdates) {\n if (this.isMemOnlyChunkHash(hash)) {\n if (count === 0) {\n this.#refCounts.delete(hash);\n this._memOnlyChunks.delete(hash);\n this.#refs.delete(hash);\n } else {\n this.#refCounts.set(hash, count);\n const chunk = this._pendingMemOnlyChunks.get(hash);\n if (chunk) {\n this.#refs.set(hash, chunk.meta);\n this._memOnlyChunks.set(hash, chunk);\n }\n }\n refCountUpdates.delete(hash);\n }\n }\n\n this._sourceChunksCache.updateForCommit(\n this._pendingCachedChunks,\n refCountUpdates,\n );\n\n for (const [name, headChange] of this._pendingHeadChanges) {\n if (headChange.new) {\n this._heads.set(name, headChange.new);\n } else {\n this._heads.delete(name);\n }\n }\n\n this._pendingMemOnlyChunks.clear();\n this._pendingCachedChunks.clear();\n this._pendingHeadChanges.clear();\n this.release();\n }\n\n getRefCount(hash: Hash): number \| undefined {\n return this.#refCounts.get(hash);\n }\n\n getRefs(hash: Hash): readonly Hash[] \| undefined {\n const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);\n if (pendingMemOnlyChunk) {\n return pendingMemOnlyChunk.meta;\n }\n const memOnlyChunk = this._memOnlyChunks.get(hash);\n if (memOnlyChunk) {\n return memOnlyChunk.meta;\n }\n const pendingCachedChunk = this._pendingCachedChunks.get(hash);\n if (pendingCachedChunk !== undefined) {\n return pendingCachedChunk.chunk.meta;\n }\n return this.#refs.get(hash);\n }\n\n areRefsCounted(hash: Hash): boolean {\n return this.#refs.has(hash);\n }\n\n chunksPersisted(chunkHashes: readonly Hash[]): void {\n const chunksToCache = [];\n for (const chunkHash of chunkHashes) {\n const chunk = this._memOnlyChunks.get(chunkHash);\n if (chunk) {\n this._memOnlyChunks.delete(chunkHash);\n chunksToCache.push(chunk);\n }\n }\n this._sourceChunksCache.persisted(chunksToCache);\n }\n}\n\ntype CacheEntry = {\n chunk: Chunk;\n size: number;\n};\n\nclass ChunksCache {\n readonly #cacheSizeLimit: number;\n readonly #getSizeOfChunk: (chunk: Chunk) => number;\n readonly #refCounts: Map<Hash, number>;\n readonly #refs: Map<Hash, readonly Hash[]>;\n #size = 0;\n #evictsAndDeletesSuspended = false;\n readonly #suspendedDeletes: Hash[] = [];\n\n /\n Iteration order is from least to most recently used.\n \n Public so that testing subclass can access.\n */\n readonly cacheEntries = new Map<Hash, CacheEntry>();\n\n constructor(\n cacheSizeLimit: number,\n getSizeOfChunk: (v: Chunk) => number,\n refCounts: Map<Hash, number>,\n refs: Map<Hash, readonly Hash[]>,\n ) {\n this.#cacheSizeLimit = cacheSizeLimit;\n this.#getSizeOfChunk = getSizeOfChunk;\n this.#refCounts = refCounts;\n this.#refs = refs;\n }\n\n get(hash: Hash): Chunk \| undefined {\n const cacheEntry = this.cacheEntries.get(hash);\n if (cacheEntry) {\n // Update order in map for LRU tracking.\n this.cacheEntries.delete(hash);\n this.cacheEntries.set(hash, cacheEntry);\n }\n return cacheEntry?.chunk;\n }\n\n getWithoutUpdatingLRU(hash: Hash): Chunk \| undefined {\n return this.cacheEntries.get(hash)?.chunk;\n }\n\n put(chunk: Chunk): void {\n const {hash} = chunk;\n // If there is an existing cache entry then the cached value must be\n // equivalent. Update order in map for LRU tracking and early return.\n const oldCacheEntry = this.cacheEntries.get(hash);\n if (oldCacheEntry) {\n this.cacheEntries.delete(hash);\n this.cacheEntries.set(hash, oldCacheEntry);\n return;\n }\n\n // Only cache if there is a ref from a head to this chunk\n const refCount = this.#refCounts.get(hash);\n if (refCount === undefined \|\| refCount < 1) {\n return;\n }\n if (!this.#cacheChunk(chunk)) {\n return;\n }\n if (!this.#refs.has(hash)) {\n for (const refHash of chunk.meta) {\n this.#refCounts.set(refHash, (this.#refCounts.get(refHash) \|\| 0) + 1);\n }\n this.#refs.set(hash, chunk.meta);\n }\n\n this.#ensureCacheSizeLimit();\n }\n\n #ensureCacheSizeLimit() {\n if (this.#evictsAndDeletesSuspended) {\n return;\n }\n for (const entry of this.cacheEntries.values()) {\n if (this.#size <= this.#cacheSizeLimit) {\n break;\n }\n this.#evict(entry);\n }\n }\n\n #cacheChunk(chunk: Chunk, size?: number): boolean {\n const chunkSize = size ?? this.#getSizeOfChunk(chunk);\n if (chunkSize > this.#cacheSizeLimit) {\n // This value cannot be cached due to its size exceeding the\n // cache size limit, don't evict other entries to try to make\n // room for it.\n return false;\n }\n this.#size += chunkSize;\n this.cacheEntries.set(chunk.hash, {chunk, size: chunkSize});\n return true;\n }\n\n #evict(cacheEntry: CacheEntry): void {\n const {hash} = cacheEntry.chunk;\n this.#size -= cacheEntry.size;\n this.cacheEntries.delete(hash);\n }\n\n #deleteEntryByHash(hash: Hash): void {\n this.#refCounts.delete(hash);\n this.#refs.delete(hash);\n const cacheEntry = this.cacheEntries.get(hash);\n if (cacheEntry) {\n this.#size -= cacheEntry.size;\n this.cacheEntries.delete(hash);\n }\n }\n\n updateForCommit(\n chunksToPut: Map<Hash, {chunk: Chunk; size: number}>,\n refCountUpdates: Map<Hash, number>,\n ): void {\n for (const [hash, count] of refCountUpdates) {\n if (count === 0) {\n if (!this.#evictsAndDeletesSuspended) {\n this.#deleteEntryByHash(hash);\n } else {\n this.#refCounts.set(hash, 0);\n this.#suspendedDeletes.push(hash);\n }\n } else {\n this.#refCounts.set(hash, count);\n const chunkAndSize = chunksToPut.get(hash);\n if (chunkAndSize) {\n const {chunk, size} = chunkAndSize;\n const oldCacheEntry = this.cacheEntries.get(hash);\n if (oldCacheEntry) {\n // If there is an existing cache entry then the cached value must be\n // equivalent. Update order in map for LRU tracking but avoid\n // recomputing size and creating a new cache entry.\n this.cacheEntries.delete(hash);\n this.cacheEntries.set(hash, oldCacheEntry);\n } else {\n this.#cacheChunk(chunk, size !== -1 ? size : undefined);\n this.#refs.set(hash, chunk.meta);\n }\n }\n }\n }\n this.#ensureCacheSizeLimit();\n }\n\n persisted(chunks: Iterable<Chunk>) {\n for (const chunk of chunks) {\n this.#cacheChunk(chunk);\n }\n this.#ensureCacheSizeLimit();\n }\n\n async withSuspendedEvictsAndDeletes<T>(\n fn: () => MaybePromise<T>,\n ): Promise<T> {\n this.#evictsAndDeletesSuspended = true;\n try {\n return await fn();\n } finally {\n this.#evictsAndDeletesSuspended = false;\n for (const hash of this.#suspendedDeletes) {\n if (this.#refCounts.get(hash) === 0) {\n this.#deleteEntryByHash(hash);\n }\n }\n this.#ensureCacheSizeLimit();\n }\n }\n}\n"],"mappings":"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"}

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

@@ -172,6 +172,6 @@ var WriteImpl = class extends ReadImpl {
 	}
 };
 //#endregion
-export { StoreImpl };
+export { ReadImpl, StoreImpl, WriteImpl };
 //# sourceMappingURL=store-impl.js.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"store-impl.js","names":["#kv","#chunkHasher","#assertValidHash","#onInvalidRefCount","#putChunks","#changedHeads","#setHead","#invalidRefCountError","#applyRefCountUpdates","#removeAllRelatedKeys"],"sources":["../../../../../replicache/src/dag/store-impl.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {\n Read as KVRead,\n Store as KVStore,\n Write as KVWrite,\n} from '../kv/store.ts';\nimport {\n Chunk,\n type ChunkHasher,\n type Refs,\n assertRefs,\n createChunk,\n} from './chunk.ts';\nimport {type RefCountUpdatesDelegate, computeRefCountUpdates} from './gc.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.ts';\nimport {chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey} from './key.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\n/*\n Called when a write found an invalid ref count in the store. This is the\n * single place where store corruption is detected, so the owner of the store\n * can start recovery no matter which code path performed the write.\n \n The callback runs after the write transaction has been released, so it is\n * safe for it to close or drop the underlying kv store.\n */\nexport type OnInvalidRefCount = (e: InvalidRefCountError) => void;\n\nexport class StoreImpl implements Store {\n readonly #kv: KVStore;\n readonly #chunkHasher: ChunkHasher;\n readonly #assertValidHash: (hash: Hash) => void;\n readonly #onInvalidRefCount: OnInvalidRefCount \| undefined;\n\n constructor(\n kv: KVStore,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n onInvalidRefCount?: OnInvalidRefCount \| undefined,\n ) {\n this.#kv = kv;\n this.#chunkHasher = chunkHasher;\n this.#assertValidHash = assertValidHash;\n this.#onInvalidRefCount = onInvalidRefCount;\n }\n\n async read(): Promise<Read> {\n return new ReadImpl(await this.#kv.read(), this.#assertValidHash);\n }\n\n async write(): Promise<Write> {\n return new WriteImpl(\n await this.#kv.write(),\n this.#chunkHasher,\n this.#assertValidHash,\n this.#onInvalidRefCount,\n );\n }\n\n close(): Promise<void> {\n return this.#kv.close();\n }\n}\n\nexport class ReadImpl implements Read {\n protected readonly _tx: KVRead;\n readonly assertValidHash: (hash: Hash) => void;\n\n constructor(kv: KVRead, assertValidHash: (hash: Hash) => void) {\n this._tx = kv;\n this.assertValidHash = assertValidHash;\n }\n\n hasChunk(hash: Hash): Promise<boolean> {\n return this._tx.has(chunkDataKey(hash));\n }\n\n async getChunk(hash: Hash): Promise<Chunk \| undefined> {\n const dataPromise = this._tx.get(chunkDataKey(hash));\n const refsPromise = this._tx.get(chunkMetaKey(hash));\n let data: ReadonlyJSONValue \| undefined;\n try {\n data = await dataPromise;\n } catch (e) {\n // The two reads fail together on a storage failure; the second\n // rejection has no one to await it and must not surface as unhandled.\n refsPromise.catch(() => {});\n throw e;\n }\n if (data === undefined) {\n refsPromise.catch(() => {\n // Ignore error since we will return undefined anyway.\n });\n return undefined;\n }\n\n const refsVal = await refsPromise;\n let refs: Refs;\n if (refsVal !== undefined) {\n assertRefs(refsVal);\n refs = refsVal;\n } else {\n refs = [];\n }\n return new Chunk(hash, data, refs);\n }\n\n mustGetChunk(hash: Hash): Promise<Chunk> {\n return mustGetChunk(this, hash);\n }\n\n async getHead(name: string): Promise<Hash \| undefined> {\n const data = await this._tx.get(headKey(name));\n if (data === undefined) {\n return undefined;\n }\n assertHash(data);\n return data;\n }\n\n release(): void {\n this._tx.release();\n }\n\n get closed(): boolean {\n return this._tx.closed;\n }\n}\n\ntype HeadChange = {\n new: Hash \| undefined;\n old: Hash \| undefined;\n};\n\nexport class WriteImpl\n extends ReadImpl\n implements Write, RefCountUpdatesDelegate\n{\n declare protected readonly _tx: KVWrite;\n readonly #chunkHasher: ChunkHasher;\n readonly #onInvalidRefCount: OnInvalidRefCount \| undefined;\n #invalidRefCountError: InvalidRefCountError \| undefined;\n\n readonly #putChunks = new Set<Hash>();\n readonly #changedHeads = new Map<string, HeadChange>();\n\n constructor(\n kvw: KVWrite,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n onInvalidRefCount?: OnInvalidRefCount \| undefined,\n ) {\n super(kvw, assertValidHash);\n this.#chunkHasher = chunkHasher;\n this.#onInvalidRefCount = onInvalidRefCount;\n }\n\n createChunk = <V>(data: V, refs: Refs): Chunk<V> =>\n createChunk(data, refs, this.#chunkHasher);\n\n get kvWrite(): KVWrite {\n return this._tx;\n }\n\n async putChunk(c: Chunk): Promise<void> {\n const {hash, data, meta} = c;\n // We never want to write temp hashes to the underlying store.\n this.assertValidHash(hash);\n const key = chunkDataKey(hash);\n // Commit contains InternalValue and Hash which are opaque types.\n const p1 = this._tx.put(key, data as ReadonlyJSONValue);\n let p2;\n if (meta.length > 0) {\n for (const h of meta) {\n this.assertValidHash(h);\n }\n p2 = this._tx.put(chunkMetaKey(hash), meta);\n }\n this.#putChunks.add(hash);\n await p1;\n await p2;\n }\n\n setHead(name: string, hash: Hash): Promise<void> {\n return this.#setHead(name, hash);\n }\n\n removeHead(name: string): Promise<void> {\n return this.#setHead(name, undefined);\n }\n\n async #setHead(name: string, hash: Hash \| undefined): Promise<void> {\n const oldHash = await this.getHead(name);\n const hk = headKey(name);\n\n let p1: Promise<void>;\n if (hash === undefined) {\n p1 = this._tx.del(hk);\n } else {\n p1 = this._tx.put(hk, hash);\n }\n\n const v = this.#changedHeads.get(name);\n if (v === undefined) {\n this.#changedHeads.set(name, {new: hash, old: oldHash});\n } else {\n // Keep old if existing\n v.new = hash;\n }\n\n await p1;\n }\n\n async commit(): Promise<void> {\n let refCountUpdates: Map<Hash, number>;\n try {\n refCountUpdates = await computeRefCountUpdates(\n this.#changedHeads.values(),\n this.#putChunks,\n this,\n );\n } catch (e) {\n if (e instanceof InvalidRefCountError) {\n // Reported from release() rather than here: the owner may drop the\n // store in response and the kv transaction still needs to roll back.\n this.#invalidRefCountError = e;\n }\n throw e;\n }\n await this.#applyRefCountUpdates(refCountUpdates);\n await this._tx.commit();\n }\n\n async getRefCount(hash: Hash): Promise<number \| undefined> {\n const value = await this._tx.get(chunkRefCountKey(hash));\n if (value === undefined) {\n return undefined;\n }\n if (\n typeof value !== 'number' \|\|\n value < 0 \|\|\n value > 0xffff \|\|\n value !== (value \| 0)\n ) {\n throw new InvalidRefCountError(hash, value);\n }\n return value;\n }\n\n async getRefs(hash: Hash): Promise<readonly Hash[]> {\n const meta = await this._tx.get(chunkMetaKey(hash));\n if (meta === undefined) {\n return [];\n }\n assertRefs(meta);\n return meta;\n }\n\n async #applyRefCountUpdates(refCountCache: Map<Hash, number>): Promise<void> {\n const ps: Promise<void>[] = [];\n for (const [hash, count] of refCountCache) {\n if (count === 0) {\n ps.push(this.#removeAllRelatedKeys(hash));\n } else {\n const refCountKey = chunkRefCountKey(hash);\n ps.push(this._tx.put(refCountKey, count));\n }\n }\n await Promise.all(ps);\n }\n\n async #removeAllRelatedKeys(hash: Hash): Promise<void> {\n await Promise.all([\n this._tx.del(chunkDataKey(hash)),\n this._tx.del(chunkMetaKey(hash)),\n this._tx.del(chunkRefCountKey(hash)),\n ]);\n\n this.#putChunks.delete(hash);\n }\n\n release(): void {\n try {\n this._tx.release();\n } finally {\n // Report even if the kv release threw (for example a failed SQLite\n // ROLLBACK): the store is corrupt either way and the owner must still\n // recover. The release error keeps propagating to the caller.\n if (this.#invalidRefCountError) {\n this.#onInvalidRefCount?.(this.#invalidRefCountError);\n }\n }\n }\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"store-impl.js","names":[],"sources":["../../../../../replicache/src/dag/store-impl.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {\n Read as KVRead,\n Store as KVStore,\n Write as KVWrite,\n} from '../kv/store.ts';\nimport {\n Chunk,\n type ChunkHasher,\n type Refs,\n assertRefs,\n createChunk,\n} from './chunk.ts';\nimport {type RefCountUpdatesDelegate, computeRefCountUpdates} from './gc.ts';\nimport {InvalidRefCountError} from './invalid-ref-count-error.ts';\nimport {chunkDataKey, chunkMetaKey, chunkRefCountKey, headKey} from './key.ts';\nimport {type Read, type Store, type Write, mustGetChunk} from './store.ts';\n\n/*\n Called when a write found an invalid ref count in the store. This is the\n * single place where store corruption is detected, so the owner of the store\n * can start recovery no matter which code path performed the write.\n \n The callback runs after the write transaction has been released, so it is\n * safe for it to close or drop the underlying kv store.\n */\nexport type OnInvalidRefCount = (e: InvalidRefCountError) => void;\n\nexport class StoreImpl implements Store {\n readonly #kv: KVStore;\n readonly #chunkHasher: ChunkHasher;\n readonly #assertValidHash: (hash: Hash) => void;\n readonly #onInvalidRefCount: OnInvalidRefCount \| undefined;\n\n constructor(\n kv: KVStore,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n onInvalidRefCount?: OnInvalidRefCount \| undefined,\n ) {\n this.#kv = kv;\n this.#chunkHasher = chunkHasher;\n this.#assertValidHash = assertValidHash;\n this.#onInvalidRefCount = onInvalidRefCount;\n }\n\n async read(): Promise<Read> {\n return new ReadImpl(await this.#kv.read(), this.#assertValidHash);\n }\n\n async write(): Promise<Write> {\n return new WriteImpl(\n await this.#kv.write(),\n this.#chunkHasher,\n this.#assertValidHash,\n this.#onInvalidRefCount,\n );\n }\n\n close(): Promise<void> {\n return this.#kv.close();\n }\n}\n\nexport class ReadImpl implements Read {\n protected readonly _tx: KVRead;\n readonly assertValidHash: (hash: Hash) => void;\n\n constructor(kv: KVRead, assertValidHash: (hash: Hash) => void) {\n this._tx = kv;\n this.assertValidHash = assertValidHash;\n }\n\n hasChunk(hash: Hash): Promise<boolean> {\n return this._tx.has(chunkDataKey(hash));\n }\n\n async getChunk(hash: Hash): Promise<Chunk \| undefined> {\n const dataPromise = this._tx.get(chunkDataKey(hash));\n const refsPromise = this._tx.get(chunkMetaKey(hash));\n let data: ReadonlyJSONValue \| undefined;\n try {\n data = await dataPromise;\n } catch (e) {\n // The two reads fail together on a storage failure; the second\n // rejection has no one to await it and must not surface as unhandled.\n refsPromise.catch(() => {});\n throw e;\n }\n if (data === undefined) {\n refsPromise.catch(() => {\n // Ignore error since we will return undefined anyway.\n });\n return undefined;\n }\n\n const refsVal = await refsPromise;\n let refs: Refs;\n if (refsVal !== undefined) {\n assertRefs(refsVal);\n refs = refsVal;\n } else {\n refs = [];\n }\n return new Chunk(hash, data, refs);\n }\n\n mustGetChunk(hash: Hash): Promise<Chunk> {\n return mustGetChunk(this, hash);\n }\n\n async getHead(name: string): Promise<Hash \| undefined> {\n const data = await this._tx.get(headKey(name));\n if (data === undefined) {\n return undefined;\n }\n assertHash(data);\n return data;\n }\n\n release(): void {\n this._tx.release();\n }\n\n get closed(): boolean {\n return this._tx.closed;\n }\n}\n\ntype HeadChange = {\n new: Hash \| undefined;\n old: Hash \| undefined;\n};\n\nexport class WriteImpl\n extends ReadImpl\n implements Write, RefCountUpdatesDelegate\n{\n declare protected readonly _tx: KVWrite;\n readonly #chunkHasher: ChunkHasher;\n readonly #onInvalidRefCount: OnInvalidRefCount \| undefined;\n #invalidRefCountError: InvalidRefCountError \| undefined;\n\n readonly #putChunks = new Set<Hash>();\n readonly #changedHeads = new Map<string, HeadChange>();\n\n constructor(\n kvw: KVWrite,\n chunkHasher: ChunkHasher,\n assertValidHash: (hash: Hash) => void,\n onInvalidRefCount?: OnInvalidRefCount \| undefined,\n ) {\n super(kvw, assertValidHash);\n this.#chunkHasher = chunkHasher;\n this.#onInvalidRefCount = onInvalidRefCount;\n }\n\n createChunk = <V>(data: V, refs: Refs): Chunk<V> =>\n createChunk(data, refs, this.#chunkHasher);\n\n get kvWrite(): KVWrite {\n return this._tx;\n }\n\n async putChunk(c: Chunk): Promise<void> {\n const {hash, data, meta} = c;\n // We never want to write temp hashes to the underlying store.\n this.assertValidHash(hash);\n const key = chunkDataKey(hash);\n // Commit contains InternalValue and Hash which are opaque types.\n const p1 = this._tx.put(key, data as ReadonlyJSONValue);\n let p2;\n if (meta.length > 0) {\n for (const h of meta) {\n this.assertValidHash(h);\n }\n p2 = this._tx.put(chunkMetaKey(hash), meta);\n }\n this.#putChunks.add(hash);\n await p1;\n await p2;\n }\n\n setHead(name: string, hash: Hash): Promise<void> {\n return this.#setHead(name, hash);\n }\n\n removeHead(name: string): Promise<void> {\n return this.#setHead(name, undefined);\n }\n\n async #setHead(name: string, hash: Hash \| undefined): Promise<void> {\n const oldHash = await this.getHead(name);\n const hk = headKey(name);\n\n let p1: Promise<void>;\n if (hash === undefined) {\n p1 = this._tx.del(hk);\n } else {\n p1 = this._tx.put(hk, hash);\n }\n\n const v = this.#changedHeads.get(name);\n if (v === undefined) {\n this.#changedHeads.set(name, {new: hash, old: oldHash});\n } else {\n // Keep old if existing\n v.new = hash;\n }\n\n await p1;\n }\n\n async commit(): Promise<void> {\n let refCountUpdates: Map<Hash, number>;\n try {\n refCountUpdates = await computeRefCountUpdates(\n this.#changedHeads.values(),\n this.#putChunks,\n this,\n );\n } catch (e) {\n if (e instanceof InvalidRefCountError) {\n // Reported from release() rather than here: the owner may drop the\n // store in response and the kv transaction still needs to roll back.\n this.#invalidRefCountError = e;\n }\n throw e;\n }\n await this.#applyRefCountUpdates(refCountUpdates);\n await this._tx.commit();\n }\n\n async getRefCount(hash: Hash): Promise<number \| undefined> {\n const value = await this._tx.get(chunkRefCountKey(hash));\n if (value === undefined) {\n return undefined;\n }\n if (\n typeof value !== 'number' \|\|\n value < 0 \|\|\n value > 0xffff \|\|\n value !== (value \| 0)\n ) {\n throw new InvalidRefCountError(hash, value);\n }\n return value;\n }\n\n async getRefs(hash: Hash): Promise<readonly Hash[]> {\n const meta = await this._tx.get(chunkMetaKey(hash));\n if (meta === undefined) {\n return [];\n }\n assertRefs(meta);\n return meta;\n }\n\n async #applyRefCountUpdates(refCountCache: Map<Hash, number>): Promise<void> {\n const ps: Promise<void>[] = [];\n for (const [hash, count] of refCountCache) {\n if (count === 0) {\n ps.push(this.#removeAllRelatedKeys(hash));\n } else {\n const refCountKey = chunkRefCountKey(hash);\n ps.push(this._tx.put(refCountKey, count));\n }\n }\n await Promise.all(ps);\n }\n\n async #removeAllRelatedKeys(hash: Hash): Promise<void> {\n await Promise.all([\n this._tx.del(chunkDataKey(hash)),\n this._tx.del(chunkMetaKey(hash)),\n this._tx.del(chunkRefCountKey(hash)),\n ]);\n\n this.#putChunks.delete(hash);\n }\n\n release(): void {\n try {\n this._tx.release();\n } finally {\n // Report even if the kv release threw (for example a failed SQLite\n // ROLLBACK): the store is corrupt either way and the owner must still\n // recover. The release error keeps propagating to the caller.\n if (this.#invalidRefCountError) {\n this.#onInvalidRefCount?.(this.#invalidRefCountError);\n }\n }\n }\n}\n"],"mappings":"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"}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"visitor.js","names":[~~"#dagRead","#seen"~~],"sources":["../../../../../replicache/src/dag/visitor.ts"],"sourcesContent":["import type {Hash} from '../hash.ts';\nimport type {Chunk} from './chunk.ts';\nimport type {MustGetChunk} from './store.ts';\n\n/*\n A visitor walks the DAG starting at a given root and visits each chunk.\n */\nexport class Visitor {\n #seen: Set<Hash> = new Set();\n #dagRead: MustGetChunk;\n\n constructor(dagRead: MustGetChunk) {\n this.#dagRead = dagRead;\n }\n\n async visit(h: Hash) {\n if (this.#seen.has(h)) {\n return;\n }\n this.#seen.add(h);\n const chunk = await this.#dagRead.mustGetChunk(h);\n await this.visitChunk(chunk);\n }\n\n async visitChunk(chunk: Chunk<unknown>) {\n await Promise.all(chunk.meta.map(ref => this.visit(ref)));\n }\n}\n"],"mappings":";;;;AAOA,IAAa,UAAb,MAAqB;CACnB,wBAAmB,IAAI,IAAI;CAC3B;CAEA,YAAY,SAAuB;EACjC,~~KAAKA~~,WAAW;CAClB;CAEA,MAAM,MAAM,GAAS;EACnB,IAAI,~~KAAKC~~,MAAM,IAAI,CAAC,GAClB;EAEF,~~KAAKA~~,MAAM,IAAI,CAAC;EAChB,MAAM,QAAQ,MAAM,~~KAAKD~~,SAAS,aAAa,CAAC;EAChD,MAAM,KAAK,WAAW,KAAK;CAC7B;CAEA,MAAM,WAAW,OAAuB;EACtC,MAAM,QAAQ,IAAI,MAAM,KAAK,KAAI,QAAO,KAAK,MAAM,GAAG,CAAC,CAAC;CAC1D;AACF"}
1	+ {"version":3,"file":"visitor.js","names":[],"sources":["../../../../../replicache/src/dag/visitor.ts"],"sourcesContent":["import type {Hash} from '../hash.ts';\nimport type {Chunk} from './chunk.ts';\nimport type {MustGetChunk} from './store.ts';\n\n/*\n A visitor walks the DAG starting at a given root and visits each chunk.\n */\nexport class Visitor {\n #seen: Set<Hash> = new Set();\n #dagRead: MustGetChunk;\n\n constructor(dagRead: MustGetChunk) {\n this.#dagRead = dagRead;\n }\n\n async visit(h: Hash) {\n if (this.#seen.has(h)) {\n return;\n }\n this.#seen.add(h);\n const chunk = await this.#dagRead.mustGetChunk(h);\n await this.visitChunk(chunk);\n }\n\n async visitChunk(chunk: Chunk<unknown>) {\n await Promise.all(chunk.meta.map(ref => this.visit(ref)));\n }\n}\n"],"mappings":";;;;AAOA,IAAa,UAAb,MAAqB;CACnB,wBAAmB,IAAI,IAAI;CAC3B;CAEA,YAAY,SAAuB;EACjC,KAAK,WAAW;CAClB;CAEA,MAAM,MAAM,GAAS;EACnB,IAAI,KAAK,MAAM,IAAI,CAAC,GAClB;EAEF,KAAK,MAAM,IAAI,CAAC;EAChB,MAAM,QAAQ,MAAM,KAAK,SAAS,aAAa,CAAC;EAChD,MAAM,KAAK,WAAW,KAAK;CAC7B;CAEA,MAAM,WAAW,OAAuB;EACtC,MAAM,QAAQ,IAAI,MAAM,KAAK,KAAI,QAAO,KAAK,MAAM,GAAG,CAAC,CAAC;CAC1D;AACF"}

package/out/replicache/src/db/commit.d.ts CHANGED Viewed

@@ -100,5 +100,4 @@ export type CommitData<M extends Meta> = FrozenTag<{
     readonly indexes: readonly IndexRecord[];
 }>;
 export declare function makeCommitData<M extends Meta>(meta: M, valueHash: Hash, indexes: readonly IndexRecord[]): CommitData<M>;
-export declare function assertCommitData(v: unknown): asserts v is CommitData<Meta>;
 //# sourceMappingURL=commit.d.ts.map

package/out/replicache/src/db/commit.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/db/commit.ts"],"names":[],"mappings":"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~~;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAU1E~~"}
1	+ {"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/db/commit.ts"],"names":[],"mappings":"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"}

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

@@ -73,8 +73,10 @@ async function localMutationsGreaterThan(commit, mutationIDLimits, dagRead) {
 		if (commitIsLocalDD31(commit)) {
 			const { meta } = commit;
 			const mutationIDLowerLimit = remainingMutationIDLimits.get(meta.clientID);
-			if (mutationIDLowerLimit !== void 0) if (meta.mutationID <= mutationIDLowerLimit) remainingMutationIDLimits.delete(meta.clientID);
-			else commits.push(commit);
+			if (mutationIDLowerLimit !== void 0) {
+				if (meta.mutationID <= mutationIDLowerLimit) remainingMutationIDLimits.delete(meta.clientID);
+				else commits.push(commit);
+			}
 		}
 		const { basisHash } = commit.meta;
 		if (basisHash === null) throw new Error(`Commit ${commit.chunk.hash} has no basis`);
@@ -276,6 +278,6 @@ function validateChunk(chunk) {
 	}
 }
 //#endregion
-export { DEFAULT_HEAD_NAME, assertLocalMetaDD31, assertSnapshotCommitDD31, assertSnapshotMetaDD31, baseSnapshotFromCommit, baseSnapshotFromHash, baseSnapshotFromHead, baseSnapshotHashFromHash, commitFromHash, commitFromHead, commitIsLocalDD31, compareCookiesForSnapshots, getMutationID, getRefs, isLocalMetaDD31, localMutations, localMutationsDD31, localMutationsGreaterThan, newLocalDD31, newSnapshotCommitDataDD31, newSnapshotDD31, snapshotMetaParts, toChunkIndexDefinition };
+export { Commit, DEFAULT_HEAD_NAME, assertLocalMetaDD31, assertSnapshotCommitDD31, assertSnapshotMetaDD31, baseSnapshotFromCommit, baseSnapshotFromHash, baseSnapshotFromHead, baseSnapshotHashFromHash, commitChain, commitFromHash, commitFromHead, commitIsLocal, commitIsLocalDD31, commitIsSnapshot, compareCookiesForSnapshots, fromChunk, getMutationID, getRefs, isLocalMetaDD31, localMutations, localMutationsDD31, localMutationsGreaterThan, makeCommitData, newLocalDD31, newSnapshotCommitDataDD31, newSnapshotDD31, snapshotMetaParts, toChunkIndexDefinition };
 //# sourceMappingURL=commit.js.map