wip blobstore stuff -- where does the bloom filter live?

src/lib/docstore/blob-filesystem.ts

···
-import {BlobPath} from './blob-schema'
+import {BlobPath, MetaPath} from './blob-schema'
 
 export class BlobFileSystem {
   #root: FileSystemDirectoryHandle
···
     return [await tempdir.getFileHandle(tempname, {create: true}), () => tempdir.removeEntry(tempname)]
   }
 
+  async metaFileHandle(path: MetaPath) {
+    let metadir = await this.#root.getDirectoryHandle('meta', {create: true})
+    for (const dir of path.slice(0, -1)) {
+      metadir = await metadir.getDirectoryHandle(dir, {create: true})
+    }
+
+    return metadir.getFileHandle(path[path.length - 1], {create: true})
+  }
+
+  async metaFile(path: MetaPath) {
+    const handle = await this.metaFileHandle(path)
+    return await handle.getFile()
+  }
+
   async blobDirectory(path: BlobPath, options?: FileSystemGetDirectoryOptions) {
     const dirs = path.slice(0, -1)
 
···
     }
   }
 
-  async blobFile(path: BlobPath, options?: {createFile?: boolean; createDir?: boolean}) {
+  async blobFileHandle(path: BlobPath, options?: {createFile?: boolean; createDir?: boolean}) {
     const dir = await this.blobDirectory(path, {create: options?.createDir})
     return dir.getFileHandle(path[path.length - 1], {create: options?.createFile})
+  }
+
+  async blobFile(path: BlobPath, options?: {createFile?: boolean; createDir?: boolean}) {
+    const handle = await this.blobFileHandle(path, options)
+    return handle.getFile()
   }
 
   async removeBlob(path: BlobPath) {

src/lib/docstore/blob-metadb.ts

···
-import {BaseFilter} from 'bloom-filters'
 import {DBSchema, IDBPDatabase, openDB} from 'idb'
 
 import {ProtocolError} from '#lib/errors'
···
 import {Digest} from './digest-stream'
 
 interface BlobMetaSchema extends DBSchema {
-  dbmeta: {
-    key: 'iblt'
-    value: {
-      id: 'iblt'
-      iblt: Parameters<typeof BaseFilter.fromJSON>[0]
-    }
-  }
   blobmeta: {
     key: BlobMeta['digest']
     value: BlobMeta
···
 }
 
 export class BlobMetaDB {
-  #database: IDBPDatabase<BlobMetaSchema>
-
   static async open(prefix: string): Promise<BlobMetaDB> {
     const dbprefix = prefix.replaceAll('/', '-')
     const dbversion = 1
     const database = await openDB<BlobMetaSchema>(`blobstore-${dbprefix}`, dbversion, {
       upgrade(db) {
-        // make the metastore
-        db.createObjectStore('dbmeta')
-
-        // make the blobstore
         const blobstore = db.createObjectStore('blobmeta', {keyPath: 'digest'})
         blobstore.createIndex('by-refcount', 'refcount', {unique: false})
         blobstore.createIndex('by-bytesize', 'bytesize', {unique: false})
···
 
     return new BlobMetaDB(database)
   }
+
+  #database: IDBPDatabase<BlobMetaSchema>
 
   private constructor(database: IDBPDatabase<BlobMetaSchema>) {
     this.#database = database

src/lib/docstore/blob-schema.ts

···
 
 import {type Digest, digestSchema} from './digest-stream'
 
+export type MetaPath = string[]
 export type BlobPath = string[]
 export function digestToPath(hash: Digest): BlobPath {
   const [_, digest] = hash.split(':')

src/lib/docstore/blob-store.ts

···
 import {Buffer} from 'buffer' // polyfill
-
 import {InvertibleBloomFilter} from 'bloom-filters'
-import {z} from 'zod/mini'
 
 import {sleep} from '#lib/async/sleep.js'
-import {jsonCodec} from '#lib/schema.js'
 
 import {BlobFileSystem} from './blob-filesystem'
 import {BlobMetaDB} from './blob-metadb'
 import {digestToPath, BlobMetaUnmanaged, BlobMeta} from './blob-schema'
-import {type Digest, DigestStream, digestSchema} from './digest-stream'
+import {type Digest, DigestStream} from './digest-stream'
+import { BlobModification, BlobWAL } from './blob-wal'
 
 declare global {
   interface FileSystemFileHandle {
···
 
 export type BlobResult = BlobMeta & {file: File}
 
-export type BlobModification = z.infer<typeof blobModificationSchema>
-
-const blobModificationSchema = z.object({mod: z.enum(['add', 'del']), digest: digestSchema})
-const blobModificationCodec = jsonCodec(z.array(blobModificationSchema))
-
-export class BlobWAL {
-  #key: string
-  #modifications: BlobModification[]
-
-  constructor(prefix: string) {
-    this.#key = `blobmeta-wal-${prefix}`
-    this.#modifications = []
-    this.reload()
-  }
-
-  reload() {
-    const stored = localStorage.getItem(this.#key) || '[]'
-    this.#modifications = z.decode(blobModificationCodec, stored)
-  }
-
-  save() {
-    const update = z.encode(blobModificationCodec, this.#modifications)
-    localStorage.setItem(this.#key, update)
-  }
-
-  pull() {
-    const val = this.#modifications
-    this.#modifications = []
-
-    return val
-  }
-
-  unshift(...mod: BlobModification[]) {
-    this.#modifications.unshift(...mod)
-    this.save()
-  }
-
-  push(...mod: BlobModification[]) {
-    this.#modifications.push(...mod)
-    this.save()
-  }
-
-  clear() {
-    localStorage.removeItem(this.#key)
-    this.#modifications.length = 0
-  }
-}
-
 export class BlobStore {
   static async open(prefix: string): Promise<BlobStore> {
-    const [db, root] = await Promise.all([BlobMetaDB.open(prefix), BlobFileSystem.open(prefix)])
-    const bloom = await this.openIblt(db)
-
-    return new BlobStore(db, root, new BlobWAL(prefix), bloom)
-  }
-
-  static async openIblt(db: BlobMetaDB) {
-    const tx = db.db.transaction('dbmeta', 'readwrite')
-    const store = tx.objectStore('dbmeta')
-
-    let iblt: InvertibleBloomFilter
+    const [db, root] = await Promise.all([
+      BlobMetaDB.open(prefix),
+      BlobFileSystem.open(prefix)
+    ])
 
-    const extant = await store.get('iblt')
-    if (extant) {
-      iblt = InvertibleBloomFilter.fromJSON(extant.iblt) as InvertibleBloomFilter
+    let bloom: InvertibleBloomFilter
+    const bloomFile = await root.metaFile(["iblt.json"])
+    if (bloomFile.size) {
+      const text = await bloomFile.text()
+      const json = JSON.parse(text)
+      bloom = InvertibleBloomFilter.fromJSON(json)
     } else {
-      iblt = new InvertibleBloomFilter(100, 5)
-      await store.put({id: 'iblt', iblt: iblt.saveAsJSON() as JSON})
+      bloom = new InvertibleBloomFilter(200, 5)
     }
 
-    await tx.done
-    return iblt
+    return new BlobStore(db, root, new BlobWAL(prefix), bloom)
   }
 
   #abort = new AbortController()
···
           case 'add':
             this.#iblt.add(hash)
             break
-          case 'del':
+          case 'remove':
             this.#iblt.remove(hash)
             break
         }
···
     // if blob fails, orphan file to be found during vacuum
 
     await this.#db.db.delete('blobmeta', digest)
-    this.#wal.push({mod: 'del', digest})
+    this.#wal.push({mod: 'remove', digest})
 
     await this.#root.removeBlob(path)
   }

src/lib/docstore/blob-wal.ts

···
+import { z } from "zod/mini"
+import { jsonCodec } from "#lib/schema"
+import { digestSchema } from "./digest-stream"
+
+export type BlobModification = z.infer<typeof blobModificationSchema>
+
+const blobModificationSchema = z.object({mod: z.enum(['add', 'remove']), digest: digestSchema})
+const blobModificationCodec = jsonCodec(z.array(blobModificationSchema))
+
+export class BlobWAL {
+  #key: string
+  #modifications: BlobModification[]
+
+  constructor(prefix: string) {
+    this.#key = `blobmeta-wal-${prefix}`
+    this.#modifications = []
+    this.reload()
+  }
+
+  reload() {
+    const stored = localStorage.getItem(this.#key) || '[]'
+    this.#modifications = z.decode(blobModificationCodec, stored)
+  }
+
+  save() {
+    const update = z.encode(blobModificationCodec, this.#modifications)
+    localStorage.setItem(this.#key, update)
+  }
+
+  pull() {
+    const val = this.#modifications
+    this.#modifications = []
+
+    return val
+  }
+
+  unshift(...mod: BlobModification[]) {
+    this.#modifications.unshift(...mod)
+    this.save()
+  }
+
+  push(...mod: BlobModification[]) {
+    this.#modifications.push(...mod)
+    this.save()
+  }
+
+  clear() {
+    localStorage.removeItem(this.#key)
+    this.#modifications.length = 0
+  }
+}