alinea 1.7.0 → 2.0.0-preview.1

package/dist/core/shape/ListShape.js

@@ -1,225 +1,2 @@
-import {
-  YMap,
-  YMapEvent
-} from "../../chunks/chunk-QUIANN6B.js";
-import "../../chunks/chunk-AJJSW27C.js";
-import "../../chunks/chunk-NZLE2WMY.js";
-
 // src/core/shape/ListShape.ts
-import { createId } from "../Id.js";
-import { generateKeyBetween } from "../util/FractionalIndexing.js";
-import { RecordShape } from "./RecordShape.js";
-import { ScalarShape } from "./ScalarShape.js";
-var ListRow;
-((ListRow2) => {
-  ListRow2.id = "_id";
-  ListRow2.index = "_index";
-  ListRow2.type = "_type";
-})(ListRow || (ListRow = {}));
-function sort(a, b) {
-  if (a[ListRow.index] < b[ListRow.index]) return -1;
-  if (a[ListRow.index] > b[ListRow.index]) return 1;
-  return 0;
-}
-var ListShape = class {
-  constructor(label, shapes, initialValue, postProcess) {
-    this.label = label;
-    this.initialValue = initialValue;
-    this.postProcess = postProcess;
-    this.shapes = Object.fromEntries(
-      Object.entries(shapes).map(([key, type]) => {
-        return [
-          key,
-          new RecordShape(label, {
-            [ListRow.id]: new ScalarShape("Id"),
-            [ListRow.index]: new ScalarShape("Index"),
-            [ListRow.type]: new ScalarShape("Type"),
-            ...type.shapes
-          })
-        ];
-      })
-    );
-  }
-  shapes;
-  create() {
-    return this.initialValue ?? [];
-  }
-  toV1(value) {
-    if (!Array.isArray(value)) return [];
-    return value.map(this.normalizeRow).filter(Boolean);
-  }
-  normalizeRow = (row) => {
-    if (ListRow.type in row) return row;
-    const { id, type, index, ...data } = row;
-    if (!id || !type) return void 0;
-    const shape = this.shapes[type];
-    const updated = shape.toV1(data);
-    return {
-      [ListRow.type]: type,
-      [ListRow.id]: id,
-      [ListRow.index]: index,
-      ...updated
-    };
-  };
-  toY(value) {
-    const map = new YMap();
-    const rows = Array.isArray(value) ? value : [];
-    let currentIndex = null;
-    for (const row of rows) {
-      const type = this.shapes[row[ListRow.type]];
-      if (!type) continue;
-      currentIndex = generateKeyBetween(currentIndex, null);
-      map.set(
-        row[ListRow.id],
-        type.toY({ ...row, [ListRow.index]: currentIndex })
-      );
-    }
-    return map;
-  }
-  fromY(map) {
-    const rows = [];
-    if (!map || typeof map.keys !== "function") return rows;
-    for (const key of map.keys()) {
-      const row = map.get(key);
-      if (!row || typeof row.get !== "function") continue;
-      const type = row.get(ListRow.type);
-      const rowType = this.shapes[type];
-      if (rowType) rows.push(rowType.fromY(row));
-    }
-    rows.sort(sort);
-    return rows;
-  }
-  applyY(value, parent, key) {
-    if (!Array.isArray(value)) return;
-    const current = parent.get(key);
-    if (!current) return void parent.set(key, this.toY(value));
-    const currentKeys = new Set(current.keys());
-    const valueKeys = new Set(value.map((row) => row[ListRow.id]));
-    const removed = [...currentKeys].filter((key2) => !valueKeys.has(key2));
-    const added = [...valueKeys].filter((key2) => !currentKeys.has(key2));
-    const changed = [...valueKeys].filter((key2) => currentKeys.has(key2));
-    for (const id of removed) current.delete(id);
-    for (const id of added) {
-      const row = value.find((row2) => row2[ListRow.id] === id);
-      if (!row) continue;
-      const type = row[ListRow.type];
-      const rowType = this.shapes[type];
-      if (!rowType) continue;
-      current.set(id, rowType.toY(row));
-    }
-    for (const id of changed) {
-      const row = value.find((row2) => row2[ListRow.id] === id);
-      if (!row) continue;
-      const type = row[ListRow.type];
-      const currentRow = current.get(id);
-      if (!currentRow) continue;
-      const currentType = currentRow.get(ListRow.type);
-      if (currentType !== type) {
-        current.delete(id);
-        current.set(id, this.shapes[type].toY(row));
-        continue;
-      }
-      const rowType = this.shapes[type];
-      if (!rowType) continue;
-      rowType.applyY(row, current, id);
-    }
-  }
-  init(parent, key) {
-    if (!parent.has(key)) parent.set(key, this.toY(this.create()));
-  }
-  watch(parent, key) {
-    const map = parent.get(key);
-    return (fun) => {
-      function w(events, transaction) {
-        for (const event of events) {
-          if (event.target === map) fun();
-          if (event instanceof YMapEvent && event.keysChanged.has(ListRow.index))
-            fun();
-        }
-      }
-      map.observeDeep(w);
-      return () => {
-        map.unobserveDeep(w);
-      };
-    };
-  }
-  mutator(parent, key) {
-    const res = {
-      replace: (id, row) => {
-        const record = parent.get(key);
-        const rows = this.fromY(record);
-        const index = rows.findIndex((r) => r[ListRow.id] === id);
-        res.remove(id);
-        res.push(row, index);
-      },
-      push: (row, insertAt) => {
-        const type = row[ListRow.type];
-        const shape = this.shapes[type];
-        const record = parent.get(key);
-        const rows = this.fromY(record);
-        const id = createId();
-        const before = insertAt === void 0 ? rows.length - 1 : insertAt - 1;
-        const after = before + 1;
-        const keyA = rows[before]?.[ListRow.index] || null;
-        const keyB = rows[after]?.[ListRow.index] || null;
-        const item = shape.toY({
-          ...shape.create(),
-          ...row,
-          [ListRow.id]: id,
-          [ListRow.index]: generateKeyBetween(keyA, keyB)
-        });
-        record.set(id, item);
-      },
-      remove(id) {
-        const record = parent.get(key);
-        record.delete(id);
-      },
-      move: (oldIndex, newIndex) => {
-        const record = parent.get(key);
-        const rows = this.fromY(record);
-        const from = rows[oldIndex];
-        const into = rows.filter((row2) => row2[ListRow.id] !== from[ListRow.id]);
-        const prev = into[newIndex - 1];
-        const next = into[newIndex];
-        const a = prev?.[ListRow.index] || null;
-        const b = next?.[ListRow.index] || null;
-        const index = generateKeyBetween(a, b);
-        const row = record.get(from[ListRow.id]);
-        row.set(ListRow.index, index);
-      },
-      read: (id) => {
-        const record = parent.get(key);
-        const rows = this.fromY(record);
-        return rows.find((row) => row._id === id);
-      }
-    };
-    return res;
-  }
-  async applyLinks(value, loader) {
-    const tasks = [];
-    if (!Array.isArray(value)) return;
-    for (const row of value) {
-      const type = row[ListRow.type];
-      const shape = this.shapes[type];
-      if (shape) tasks.push(shape.applyLinks(row, loader));
-    }
-    await Promise.all(tasks);
-    if (this.postProcess) await this.postProcess(value, loader);
-  }
-  searchableText(value) {
-    let res = "";
-    const rows = Array.isArray(value) ? value : [];
-    for (const row of rows) {
-      const id = row[ListRow.id];
-      const type = row[ListRow.type];
-      const shape = this.shapes[type];
-      if (!id || !type || !shape) continue;
-      res += shape.searchableText(row);
-    }
-    return res;
-  }
-};
-export {
-  ListRow,
-  ListShape
-};
+export * from "alinea/core/ListRow";

package/dist/core/source/CombinedSource.d.ts

@@ -1,11 +1,11 @@
 import type { ChangesBatch } from './Change.js';
-import type { Source } from './Source.js';
+import type { GetBlobsOptions, Source } from './Source.js';
 import { ReadonlyTree } from './Tree.js';
 export declare class CombinedSource implements Source {
     #private;
     constructor(sources: Record<string, Source>);
     getTree(): Promise<ReadonlyTree>;
     getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
     applyChanges(batch: ChangesBatch): Promise<void>;
 }

package/dist/core/source/CombinedSource.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/CombinedSource.ts
 import { assert } from "../util/Assert.js";
@@ -32,8 +32,11 @@ var CombinedSource = class {
     if (tree.sha === sha) return void 0;
     return tree;
   }
-  async *getBlobs(shas) {
-    if (this.#only) return this.#only.getBlobs(shas);
+  async *getBlobs(shas, options = {}) {
+    if (this.#only) {
+      yield* this.#only.getBlobs(shas, options);
+      return;
+    }
     const tree = await this.getTree();
     const perSource = /* @__PURE__ */ new Map();
     for (const [name, source] of entries(this.#sources)) {
@@ -47,7 +50,7 @@ var CombinedSource = class {
       }
     }
     for (const [source, shas2] of perSource) {
-      yield* source.getBlobs(shas2);
+      yield* source.getBlobs(shas2, options);
     }
   }
   async applyChanges(batch) {

package/dist/core/source/FSSource.d.ts

@@ -1,13 +1,14 @@
 import type { ChangesBatch } from './Change.js';
-import type { Source } from './Source.js';
+import type { GetBlobsOptions, Source } from './Source.js';
 import { ReadonlyTree, WriteableTree } from './Tree.js';
 export declare class FSSource implements Source {
     #private;
     constructor(cwd: string);
     getTree(): Promise<ReadonlyTree>;
-    getFile(current: ReadonlyTree, builder: WriteableTree, file: string): Promise<readonly [string, Buffer<ArrayBufferLike>] | undefined>;
+    getFile(current: ReadonlyTree, builder: WriteableTree, file: string): Promise<readonly [string, Uint8Array<ArrayBufferLike>] | undefined>;
     getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    readBlob(sha: string, file: string, signal?: AbortSignal): Promise<[sha: string, blob: Uint8Array]>;
     applyChanges(batch: ChangesBatch): Promise<void>;
 }
 export declare class CachedFSSource extends FSSource {
@@ -15,6 +16,7 @@ export declare class CachedFSSource extends FSSource {
     constructor(cwd: string);
     refresh: () => Promise<ReadonlyTree>;
     getTree(): Promise<ReadonlyTree>;
-    getFile(current: ReadonlyTree, builder: WriteableTree, file: string): Promise<readonly [string, Buffer<ArrayBufferLike>] | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    applyChanges(batch: ChangesBatch): Promise<void>;
+    getFile(current: ReadonlyTree, builder: WriteableTree, file: string): Promise<readonly [string, Uint8Array<ArrayBufferLike>] | undefined>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
 }

package/dist/core/source/FSSource.js

@@ -1,9 +1,10 @@
 import {
   pLimit
-} from "../../chunks/chunk-C53YJRET.js";
-import "../../chunks/chunk-NZLE2WMY.js";
+} from "../../chunks/chunk-U5Z2VE7Z.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/FSSource.ts
+import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path/posix";
 
@@ -54,10 +55,17 @@ var p_debounce_default = pDebounce;
 
 // src/core/source/FSSource.ts
 import { assert } from "../util/Assert.js";
-import { accumulate } from "../util/Async.js";
-import { hashBlob } from "./GitUtils.js";
+import { mapConcurrent } from "../util/Async.js";
+import { isRecord } from "../util/Objects.js";
 import { ReadonlyTree, WriteableTree } from "./Tree.js";
 var limit = pLimit(1);
+var fileConcurrency = 64;
+var blobReadConcurrency = 32;
+var encoder = new TextEncoder();
+function hashFileBlob(contents) {
+  const header = encoder.encode(`blob ${contents.byteLength}\0`);
+  return createHash("sha1").update(header).update(contents).digest("hex");
+}
 var FSSource = class {
   #current = ReadonlyTree.EMPTY;
   #cwd;
@@ -73,8 +81,12 @@ var FSSource = class {
       const files = await fs.readdir(this.#cwd, {
         recursive: true
       });
-      const tasks = files.map((file) => this.getFile(current, builder, file));
-      await Promise.all(tasks);
+      for await (const result of mapConcurrent(
+        files,
+        (file) => this.getFile(current, builder, file),
+        { concurrency: fileConcurrency }
+      ))
+        void result;
       const tree = await builder.compile(current);
       this.#current = tree;
       return tree;
@@ -87,8 +99,9 @@ var FSSource = class {
     try {
       stat = await fs.stat(fullPath);
       if (!stat.isFile()) return;
-    } catch {
-      return;
+    } catch (error) {
+      if (isRecord(error) && error.code === "ENOENT") return;
+      throw error;
     }
     const previouslyModified = this.#lastModified.get(filePath);
     if (previouslyModified && stat.mtimeMs === previouslyModified) {
@@ -98,26 +111,37 @@ var FSSource = class {
         return;
       }
     }
+    let contents;
     try {
-      const contents = await fs.readFile(fullPath);
-      const sha = await hashBlob(contents);
-      this.#locations.set(sha, filePath);
-      this.#lastModified.set(filePath, stat.mtimeMs);
-      builder.add(filePath, sha);
-      return [sha, contents];
-    } catch {
+      contents = await fs.readFile(fullPath);
+    } catch (error) {
+      if (isRecord(error) && error.code === "ENOENT") return;
+      throw error;
     }
+    const sha = hashFileBlob(contents);
+    this.#locations.set(sha, filePath);
+    this.#lastModified.set(filePath, stat.mtimeMs);
+    builder.add(filePath, sha);
+    return [sha, contents];
   }
   async getTreeIfDifferent(sha) {
     const current = await this.getTree();
     return current.sha === sha ? void 0 : current;
   }
-  async *getBlobs(shas) {
-    for (const sha of shas) {
-      const path2 = this.#locations.get(sha);
-      assert(path2, `Missing path for blob ${sha}`);
-      yield [sha, await fs.readFile(`${this.#cwd}/${path2}`)];
-    }
+  getBlobs(shas, options = {}) {
+    return mapConcurrent(
+      shas,
+      (sha, signal) => {
+        const file = this.#locations.get(sha);
+        assert(file, `Missing path for blob ${sha}`);
+        return this.readBlob(sha, file, signal);
+      },
+      { concurrency: blobReadConcurrency, signal: options.signal }
+    );
+  }
+  async readBlob(sha, file, signal) {
+    const blob = await fs.readFile(`${this.#cwd}/${file}`, { signal });
+    return [sha, blob];
   }
   async applyChanges(batch) {
     return limit(async () => {
@@ -148,29 +172,50 @@ var CachedFSSource = class extends FSSource {
   constructor(cwd) {
     super(cwd);
   }
-  refresh = p_debounce_default(async () => {
-    this.#blobs = /* @__PURE__ */ new Map();
-    return this.#tree = super.getTree();
+  refresh = p_debounce_default(() => {
+    let refresh;
+    refresh = super.getTree().then(
+      (tree) => {
+        const currentShas = new Set(tree.index().values());
+        for (const sha of this.#blobs.keys()) {
+          if (!currentShas.has(sha)) this.#blobs.delete(sha);
+        }
+        return tree;
+      },
+      (error) => {
+        if (this.#tree === refresh) this.#tree = void 0;
+        throw error;
+      }
+    );
+    this.#tree = refresh;
+    return refresh;
   }, 50);
   getTree() {
     if (!this.#tree) return this.refresh();
     return this.#tree;
   }
+  async applyChanges(batch) {
+    await super.applyChanges(batch);
+    this.#tree = void 0;
+  }
   async getFile(current, builder, file) {
     const result = await super.getFile(current, builder, file);
     if (result) this.#blobs?.set(result[0], result[1]);
     return result;
   }
-  async *getBlobs(shas) {
-    const fromLocal = shas.filter((sha) => this.#blobs.has(sha));
-    const localEntries = fromLocal.map(
-      (sha) => [sha, this.#blobs.get(sha)]
-    );
-    const fromRemote = shas.filter((sha) => !this.#blobs.has(sha));
-    const remoteEntries = fromRemote.length > 0 ? await accumulate(super.getBlobs(fromRemote)) : [];
-    const entries = [...localEntries, ...remoteEntries];
-    this.#blobs = new Map(entries);
-    yield* entries;
+  async *getBlobs(shas, options = {}) {
+    const fromRemote = [];
+    for (const sha of shas) {
+      if (options.signal?.aborted)
+        throw options.signal.reason ?? new Error("Blob transfer aborted");
+      const blob = this.#blobs.get(sha);
+      if (blob) yield [sha, blob];
+      else fromRemote.push(sha);
+    }
+    for await (const [sha, blob] of super.getBlobs(fromRemote, options)) {
+      this.#blobs.set(sha, blob);
+      yield [sha, blob];
+    }
   }
 };
 export {

package/dist/core/source/FilePatch.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/FilePatch.ts
 import { assert } from "../util/Assert.js";
@@ -26,7 +26,10 @@ async function applyFilePatch(base, patch) {
   const baseBytes = encoder.encode(base);
   const expectedBaseHash = patch.subarray(0, HASH_BYTES);
   const actualBaseHash = await computeSha1Bytes(baseBytes);
-  assert(bytesEqual(expectedBaseHash, actualBaseHash), "Patch does not match base");
+  assert(
+    bytesEqual(expectedBaseHash, actualBaseHash),
+    "Patch does not match base"
+  );
   const delta = patch.subarray(HASH_BYTES, patch.length - HASH_BYTES);
   const result = applyGitDelta(baseBytes, delta);
   const expectedHash = patch.subarray(patch.length - HASH_BYTES);

package/dist/core/source/GitDelta.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/GitDelta.ts
 import { assert } from "../util/Assert.js";

package/dist/core/source/GitUtils.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/GitUtils.ts
 import { assert } from "../util/Assert.js";

package/dist/core/source/GithubSource.d.ts

@@ -1,5 +1,5 @@
 import type { ChangesBatch } from './Change.js';
-import type { Source } from './Source.js';
+import type { GetBlobsOptions, Source } from './Source.js';
 import { ReadonlyTree } from './Tree.js';
 export interface GithubSourceOptions {
     authToken: string;
@@ -9,6 +9,7 @@ export interface GithubSourceOptions {
     rootDir: string;
     contentDir: string;
 }
+export declare function normalizeGithubSourceOptions<Options extends GithubSourceOptions>(options: Options): Options;
 export declare class GithubSource implements Source {
     #private;
     constructor(options: GithubSourceOptions);
@@ -16,6 +17,6 @@ export declare class GithubSource implements Source {
     getTree(): Promise<ReadonlyTree>;
     shaAt(ref: string): Promise<string>;
     getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
     applyChanges(batch: ChangesBatch): Promise<void>;
 }

package/dist/core/source/GithubSource.js

@@ -1,19 +1,27 @@
 import {
   pLimit
-} from "../../chunks/chunk-C53YJRET.js";
-import "../../chunks/chunk-NZLE2WMY.js";
+} from "../../chunks/chunk-U5Z2VE7Z.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/GithubSource.ts
 import * as paths from "alinea/core/util/Paths";
 import { HttpError } from "../HttpError.js";
 import { assert } from "../util/Assert.js";
 import { ReadonlyTree } from "./Tree.js";
+function normalizeGithubSourceOptions(options) {
+  return {
+    ...options,
+    rootDir: normalizeDirectory(options.rootDir),
+    contentDir: normalizeDirectory(options.contentDir)
+  };
+}
 var GithubSource = class {
   #current = ReadonlyTree.EMPTY;
   #options;
   #limit = pLimit(8);
+  #shaCache = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.#options = options;
+    this.#options = normalizeGithubSourceOptions(options);
   }
   get contentLocation() {
     const { contentDir, rootDir } = this.#options;
@@ -28,17 +36,25 @@ var GithubSource = class {
   async shaAt(ref) {
     const { owner, repo, authToken } = this.#options;
     const parentDir = this.contentLocation.split("/").slice(0, -1).join("/");
-    const parentInfo = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/contents/${parentDir}?ref=${ref}`,
-      { headers: { Authorization: `Bearer ${authToken}` } }
-    );
+    const url = `https://api.github.com/repos/${owner}/${repo}/contents/${parentDir}?ref=${ref}`;
+    const cached = this.#shaCache.get(url);
+    const headers = new Headers({ Authorization: `Bearer ${authToken}` });
+    if (cached) headers.set("If-None-Match", cached.etag);
+    const parentInfo = await fetch(url, { headers });
+    if (parentInfo.status === 304) {
+      assert(cached, "Received 304 without a cached GitHub response");
+      return cached.sha;
+    }
     assert(parentInfo.ok, `Failed to get parent: ${parentInfo.statusText}`);
     const parents = await parentInfo.json();
     assert(Array.isArray(parents));
     const parent = parents.find((entry) => entry.path === this.contentLocation);
-    if (!parent) return ReadonlyTree.EMPTY.sha;
-    assert(typeof parent.sha === "string");
-    return parent.sha;
+    const sha = parent ? parent.sha : ReadonlyTree.EMPTY.sha;
+    assert(typeof sha === "string");
+    const etag = parentInfo.headers.get("etag");
+    if (etag) this.#shaCache.set(url, { etag, sha });
+    else this.#shaCache.delete(url);
+    return sha;
   }
   async getTreeIfDifferent(sha) {
     const { branch, owner, repo, authToken } = this.#options;
@@ -54,13 +70,16 @@ var GithubSource = class {
     const tree = ReadonlyTree.fromFlat(treeData);
     return tree;
   }
-  async *getBlobs(shas) {
+  async *getBlobs(shas, options = {}) {
     const { owner, repo, authToken } = this.#options;
     const responses = shas.map((sha) => {
       const promise = this.#limit(
         () => fetch(
           `https://api.github.com/repos/${owner}/${repo}/git/blobs/${sha}`,
-          { headers: { Authorization: `Bearer ${authToken}` } }
+          {
+            headers: { Authorization: `Bearer ${authToken}` },
+            signal: options.signal
+          }
         )
       );
       return [sha, promise];
@@ -83,6 +102,12 @@ var GithubSource = class {
     throw new Error("Not implemented");
   }
 };
+function normalizeDirectory(directory) {
+  const normalized = paths.normalize(directory);
+  if (normalized === "." || normalized === "/") return "";
+  return normalized.replace(/^\/+|\/+$/g, "");
+}
 export {
-  GithubSource
+  GithubSource,
+  normalizeGithubSourceOptions
 };

package/dist/core/source/IndexedDBSource.d.ts

@@ -1,11 +1,11 @@
 import type { ChangesBatch } from './Change.js';
-import type { Source } from './Source.js';
+import type { GetBlobsOptions, Source } from './Source.js';
 import { ReadonlyTree } from './Tree.js';
 export declare class IndexedDBSource implements Source {
     #private;
     constructor(indexedDB: IDBFactory, name: string);
     getTree(): Promise<ReadonlyTree>;
     getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
     applyChanges(batch: ChangesBatch): Promise<void>;
 }