alinea 2.0.0-preview.0 → 2.0.0-preview.2

package/dist/core/field/RichTextField.js

@@ -1774,8 +1774,8 @@ import {
   Field
 } from "../Field.js";
 import { createId } from "../Id.js";
+import { mediaAltText } from "../media/MediaAltField.js";
 import { MediaFile } from "../media/MediaTypes.js";
-import { MediaLocation } from "../media/MediaLocation.js";
 import { Schema } from "../Schema.js";
 import {
   LinkMark,
@@ -1787,14 +1787,9 @@ import { applyUrlSuffix, createUniqueAnchor } from "../util/Anchors.js";
 import { entries } from "../util/Objects.js";
 import { slugify } from "../util/Slugs.js";
 var linkInfoFields = {
-  entryUrl: Entry.url,
-  extension: MediaFile.extension,
   id: Entry.id,
-  location: MediaFile.location,
-  path: Entry.path,
-  root: Entry.root,
   url: Entry.url,
-  workspace: Entry.workspace
+  alt: MediaFile.alt
 };
 var RichTextField = class extends Field {
   constructor(schema, meta) {
@@ -2014,6 +2009,18 @@ function richTextReferences(schema, doc, path, label) {
       linkType
     });
   });
+  iterImageNodes(doc, (node, index) => {
+    if (typeof node._entry !== "string") return;
+    result.push({
+      targetId: node._entry,
+      fieldPath: referenceFieldPath(
+        typeof node._id === "string" ? [...path, node._id] : [...path, String(index)]
+      ),
+      fieldLabel: label,
+      linkId: node._id,
+      linkType: "image"
+    });
+  });
   doc.forEach((row, index) => {
     if (!schema || !Node.isBlock(row)) return;
     const type = schema[row[Node.type]];
@@ -2039,27 +2046,33 @@ async function applyLinkMarks(doc, loader) {
     const entryId = mark[LinkMark.entry];
     if (typeof entryId === "string") links.set(mark, entryId);
   });
-  const linkIds = Array.from(new Set(links.values()));
+  const images = /* @__PURE__ */ new Map();
+  iterImageNodes(doc, (node) => {
+    if (node._link === "image" && typeof node._entry === "string") {
+      delete node.src;
+      delete node.alt;
+      images.set(node, node._entry);
+    }
+  });
+  const linkIds = Array.from(/* @__PURE__ */ new Set([...links.values(), ...images.values()]));
   const entries2 = await loader.resolveLinks(linkInfoFields, linkIds);
   const info = new Map(entries2.map((entry) => [entry.id, entry]));
   for (const [mark, entryId] of links) {
-    const type = mark[LinkMark.link];
     const data = info.get(entryId);
     if (!data) continue;
-    const href = type === "file" ? MediaLocation.publicUrl(loader.resolver.config, {
-      entryUrl: data.entryUrl,
-      extension: data.extension,
-      location: data.location,
-      path: data.path,
-      root: data.root,
-      workspace: data.workspace
-    }) : data.url;
+    const href = data.url;
     mark.href = applyUrlSuffix(
       href,
       mark[LinkMark.suffix],
       mark[LinkMark.anchor]
     );
   }
+  for (const [node, entryId] of images) {
+    const data = info.get(entryId);
+    if (!data) continue;
+    node.src = data.url;
+    node.alt = mediaAltText(data.alt, loader.locale ?? void 0);
+  }
 }
 function richTextSearchableText(schema, value) {
   if (!Array.isArray(value)) return "";
@@ -2089,6 +2102,13 @@ function iterMarks(doc, fn) {
     else if (Node.isElement(row) && row.content) iterMarks(row.content, fn);
   }
 }
+function iterImageNodes(doc, fn) {
+  doc.forEach((node, index) => {
+    if (!Node.isElement(node)) return;
+    if (node._type === "image") fn(node, index);
+    if (node.content) iterImageNodes(node.content, fn);
+  });
+}
 function iterNodes(doc, fn, path = []) {
   doc.forEach((row, index) => {
     const rowPath = [...path, String(index)];
@@ -2107,8 +2127,12 @@ var RichTextEditor = class {
     this.doc.push({ _id: createId(), _type: type, ...block });
     return this;
   }
-  addHtml(html) {
-    this.doc.push(...parseHTML(html.trim()));
+  addHtml(html, options) {
+    this.doc.push(...parseHTML(html.trim(), options));
+    return this;
+  }
+  async addHtmlAsync(html, options) {
+    this.doc.push(...await parseHTMLAsync(html.trim(), options));
     return this;
   }
   value() {
@@ -2170,51 +2194,94 @@ function mapMark(name, attributes) {
       return { _type: "link", ...attributes };
   }
 }
-function parseHTML(html) {
-  const doc = [];
-  if (typeof html !== "string") return doc;
-  const parents = [
-    { tag: void 0, doc }
-  ];
-  const markStack = [];
+async function parseHTMLAsync(html, options = {}) {
+  const state = createParseHTMLState();
+  if (typeof html !== "string") return state.doc;
+  for (const token of tokenizeHTML(html)) {
+    if (token.type === "text") {
+      processText(state, token.text);
+    } else if (token.type === "closeTag") {
+      processCloseTag(state, token.name);
+    } else {
+      const tagHandler = options.tags?.[token.name];
+      const markHandler = options.marks?.[token.name];
+      const node = tagHandler ? await tagHandler(token.attributes) : mapNode(token.name, token.attributes);
+      const mark = markHandler ? await markHandler(token.attributes) : mapMark(token.name, token.attributes);
+      processOpenTag(state, token.name, node, mark);
+    }
+  }
+  concatTextNodes(state.doc);
+  return state.doc;
+}
+function parseHTML(html, options = {}) {
+  const state = createParseHTMLState();
+  if (typeof html !== "string") return state.doc;
+  for (const token of tokenizeHTML(html)) {
+    if (token.type === "text") {
+      processText(state, token.text);
+    } else if (token.type === "closeTag") {
+      processCloseTag(state, token.name);
+    } else {
+      const tagHandler = options.tags?.[token.name];
+      const markHandler = options.marks?.[token.name];
+      const node = tagHandler ? tagHandler(token.attributes) : mapNode(token.name, token.attributes);
+      const mark = markHandler ? markHandler(token.attributes) : mapMark(token.name, token.attributes);
+      processOpenTag(state, token.name, node, mark);
+    }
+  }
+  concatTextNodes(state.doc);
+  return state.doc;
+}
+function tokenizeHTML(html) {
+  const tokens = [];
   const parser = new Parser({
     onopentag(name, attributes) {
-      const node = mapNode(name, attributes);
-      const mark = mapMark(name, attributes);
-      const parent = parents.at(-1);
-      if (node) {
-        parent?.doc?.push(node);
-        parents.push({ tag: name, doc: node?.content });
-      } else if (mark) {
-        const target = parent?.doc;
-        if (!target) return;
-        markStack.push({
-          tag: name,
-          mark,
-          doc: target,
-          start: target.length
-        });
-      }
+      tokens.push({ type: "openTag", name, attributes });
     },
     ontext(text) {
-      const parent = parents.at(-1);
-      if (parent?.doc === doc && text.trim().length === 0) return;
-      parent?.doc?.push({ _type: "text", text });
+      tokens.push({ type: "text", text });
     },
     onclosetag(name) {
-      const parent = parents.at(-1);
-      if (parent?.tag === name) parents.pop();
-      const match = findMark(name, markStack);
-      if (match < 0) return;
-      const { mark, doc: doc2, start } = markStack[match];
-      for (let i = start; i < doc2.length; i++) applyMark(doc2[i], mark);
-      markStack.splice(match);
+      tokens.push({ type: "closeTag", name });
     }
   });
   parser.write(html);
   parser.end();
-  concatTextNodes(doc);
-  return doc;
+  return tokens;
+}
+function createParseHTMLState() {
+  const doc = [];
+  return { doc, parents: [{ doc }], markStack: [] };
+}
+function processOpenTag(state, name, node, mark) {
+  const parent = state.parents.at(-1);
+  if (node) {
+    parent?.doc?.push(node);
+    state.parents.push({ tag: name, doc: node.content });
+  } else if (mark) {
+    const target = parent?.doc;
+    if (!target) return;
+    state.markStack.push({
+      tag: name,
+      mark,
+      doc: target,
+      start: target.length
+    });
+  }
+}
+function processText(state, text) {
+  const parent = state.parents.at(-1);
+  if (parent?.doc === state.doc && text.trim().length === 0) return;
+  parent?.doc?.push({ _type: "text", text });
+}
+function processCloseTag(state, name) {
+  const parent = state.parents.at(-1);
+  if (parent?.tag === name) state.parents.pop();
+  const match = findMark(name, state.markStack);
+  if (match < 0) return;
+  const { mark, doc, start } = state.markStack[match];
+  for (let i = start; i < doc.length; i++) applyMark(doc[i], mark);
+  state.markStack.splice(match);
 }
 function findMark(tag, marks) {
   for (let i = marks.length - 1; i >= 0; i--) {
@@ -2223,7 +2290,7 @@ function findMark(tag, marks) {
   return -1;
 }
 function applyMark(node, mark) {
-  if (node._type === "text") {
+  if (Node.isText(node)) {
     const marks = node.marks || (node.marks = []);
     if (!marks.some((current) => sameMark(current, mark))) marks.unshift(mark);
     return;
@@ -2269,5 +2336,6 @@ function concatTextNodes(doc) {
 export {
   RichTextEditor,
   RichTextField,
-  parseHTML
+  parseHTML,
+  parseHTMLAsync
 };

package/dist/core/media/MediaAltField.d.ts

@@ -7,3 +7,4 @@ export interface MediaAltOptions extends Omit<TextOptions, 'initialValue' | 'val
 export declare class MediaAltField extends ScalarField<MediaAltValue, MediaAltOptions> {
 }
 export declare function mediaAlt(label: string, options?: WithoutLabel<MediaAltOptions>): MediaAltField;
+export declare function mediaAltText(value: MediaAltValue, locale?: string): string;

package/dist/core/media/MediaAltField.js

@@ -3,6 +3,7 @@ import "../../chunks/chunk-CQ52GEHY.js";
 // src/core/media/MediaAltField.ts
 import { ScalarField } from "alinea/core/field/ScalarField";
 import { viewKeys } from "alinea/dashboard/ViewKeys";
+import { isRecord } from "../util/Objects.js";
 var MediaAltField = class extends ScalarField {
 };
 function mediaAlt(label, options = {}) {
@@ -11,7 +12,14 @@ function mediaAlt(label, options = {}) {
     view: viewKeys.MediaAltInput
   });
 }
+function mediaAltText(value, locale) {
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) return "";
+  if (locale && typeof value[locale] === "string") return value[locale];
+  return Object.values(value).find((value2) => typeof value2 === "string") ?? "";
+}
 export {
   MediaAltField,
-  mediaAlt
+  mediaAlt,
+  mediaAltText
 };

package/dist/core/media/MediaLocation.d.ts

@@ -16,10 +16,13 @@ export interface MediaUrlResolver {
     (meta: MediaUrlMeta): string;
 }
 export interface MediaPublicUrlMeta extends Omit<MediaUrlMeta, 'parentPaths'> {
-    entryUrl: string;
+    /** @deprecated Pass parentPaths directly when available. */
+    entryUrl?: string;
+    parentPaths?: Array<string>;
 }
 export interface MediaEntryUrlMeta {
-    entryUrl: string;
+    defaultUrl: string;
+    parentPaths: Array<string>;
     path: string;
     workspace: string;
     root: string;

package/dist/core/media/MediaLocation.js

@@ -24,29 +24,28 @@ var MediaLocation;
   }
   MediaLocation2.entryLocation = entryLocation;
   function publicUrl(config, meta) {
-    const { entryUrl: entryUrl2, ...media } = meta;
-    const { location, workspace } = media;
+    const { entryUrl: entryUrl2, parentPaths, ...media } = meta;
+    const { location, workspace } = meta;
     const { mediaUrl } = Workspace.data(config.workspaces[workspace]);
     if (!mediaUrl) return location;
     if (typeof mediaUrl === "function") {
-      const segments = entryUrl2.split("/").filter(Boolean);
       return mediaUrl({
         ...media,
-        parentPaths: segments.slice(0, -1)
+        parentPaths: parentPaths ?? entryUrl2?.split("/").filter(Boolean).slice(0, -1) ?? []
       });
     }
     return joinPaths(mediaUrl, location);
   }
   MediaLocation2.publicUrl = publicUrl;
   function entryUrl(config, meta) {
-    const { data, entryUrl: entryUrl2, path, root, workspace } = meta;
+    const { data, defaultUrl, parentPaths, path, root, workspace } = meta;
     const { extension, location } = data;
     if (typeof extension !== "string" || typeof location !== "string")
-      return entryUrl2;
+      return defaultUrl;
     return publicUrl(config, {
-      entryUrl: entryUrl2,
       extension,
       location,
+      parentPaths,
       path,
       root,
       workspace

package/dist/core/media/MediaTypes.js

@@ -9,6 +9,7 @@ import { path } from "alinea/field/path/PathField";
 import { text } from "alinea/field/text/TextField";
 import { type } from "../Type.js";
 import { mediaAlt } from "./MediaAltField.js";
+import { MediaLocation } from "./MediaLocation.js";
 var MediaLibrary = type("Media directory", {
   icon: IcRoundPermMedia,
   contains: ["MediaLibrary", "MediaFile"],
@@ -20,6 +21,16 @@ var MediaLibrary = type("Media directory", {
 });
 var MediaFile = type("Media file", {
   hidden: true,
+  entryUrl({ config, data, defaultUrl, parentPaths, path: path2, root, workspace }) {
+    return MediaLocation.entryUrl(config, {
+      data,
+      defaultUrl,
+      parentPaths,
+      path: path2,
+      root,
+      workspace
+    });
+  },
   fields: {
     title: text("Title"),
     path: path("Path"),

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

@@ -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,5 +1,5 @@
 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;
@@ -7,7 +7,8 @@ export declare class FSSource implements Source {
     getTree(): Promise<ReadonlyTree>;
     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 {
@@ -17,5 +18,5 @@ export declare class CachedFSSource extends FSSource {
     getTree(): Promise<ReadonlyTree>;
     applyChanges(batch: ChangesBatch): Promise<void>;
     getFile(current: ReadonlyTree, builder: WriteableTree, file: string): Promise<readonly [string, Uint8Array<ArrayBufferLike>] | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
 }

package/dist/core/source/FSSource.js

@@ -4,6 +4,7 @@ import {
 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,12 +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 { mapConcurrent } from "../util/Async.js";
 import { isRecord } from "../util/Objects.js";
-import { hashBlob } from "./GitUtils.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;
@@ -75,11 +81,12 @@ var FSSource = class {
       const files = await fs.readdir(this.#cwd, {
         recursive: true
       });
-      const fileLimit = pLimit(fileConcurrency);
-      const tasks = files.map(
-        (file) => fileLimit(() => 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;
@@ -111,7 +118,7 @@ var FSSource = class {
       if (isRecord(error) && error.code === "ENOENT") return;
       throw error;
     }
-    const sha = await hashBlob(contents);
+    const sha = hashFileBlob(contents);
     this.#locations.set(sha, filePath);
     this.#lastModified.set(filePath, stat.mtimeMs);
     builder.add(filePath, sha);
@@ -121,12 +128,20 @@ var FSSource = class {
     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 () => {
@@ -157,9 +172,23 @@ 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();
@@ -174,16 +203,19 @@ var CachedFSSource = class extends FSSource {
     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/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;
@@ -17,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

@@ -19,6 +19,7 @@ var GithubSource = class {
   #current = ReadonlyTree.EMPTY;
   #options;
   #limit = pLimit(8);
+  #shaCache = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#options = normalizeGithubSourceOptions(options);
   }
@@ -35,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;
@@ -61,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];

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>;
 }