alinea 2.0.0-preview.12 → 2.0.0-preview.13

package/dist/components/internal/sortableDrag.js

@@ -0,0 +1,175 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/components/internal/sortableDrag.ts
+var threshold = 4;
+var duration = 200;
+var easing = "cubic-bezier(0.2, 0, 0, 1)";
+var scrollEdge = 48;
+var scrollSpeed = 12;
+var settling = /* @__PURE__ */ new Map();
+function pressSortableItem({
+  event,
+  list,
+  item,
+  items,
+  onDrop
+}) {
+  const startX = event.clientX;
+  const startY = event.clientY;
+  let pointerY = startY;
+  let drag = null;
+  function onMove(event2) {
+    if (event2.pointerId !== pointerId) return;
+    pointerY = event2.clientY;
+    if (!drag) {
+      const distance = Math.hypot(event2.clientX - startX, pointerY - startY);
+      if (distance < threshold) return;
+      drag = startDrag();
+      if (!drag) return finish(false);
+    }
+    drag.update();
+  }
+  function onUp(event2) {
+    if (event2.pointerId === pointerId) finish(true);
+  }
+  function onCancel(event2) {
+    if (event2.pointerId === pointerId) finish(false);
+  }
+  function onKeyDown(event2) {
+    if (event2.key !== "Escape" || !drag) return;
+    event2.preventDefault();
+    event2.stopPropagation();
+    finish(false);
+  }
+  function onBlur() {
+    finish(false);
+  }
+  const pointerId = event.pointerId;
+  window.addEventListener("pointermove", onMove, true);
+  window.addEventListener("pointerup", onUp, true);
+  window.addEventListener("pointercancel", onCancel, true);
+  window.addEventListener("keydown", onKeyDown, true);
+  window.addEventListener("blur", onBlur);
+  function finish(commit) {
+    window.removeEventListener("pointermove", onMove, true);
+    window.removeEventListener("pointerup", onUp, true);
+    window.removeEventListener("pointercancel", onCancel, true);
+    window.removeEventListener("keydown", onKeyDown, true);
+    window.removeEventListener("blur", onBlur);
+    if (!drag) return;
+    drag.end(commit);
+    drag = null;
+    const block = (event2) => {
+      if (!(event2.target instanceof Node) || !list.contains(event2.target))
+        return;
+      event2.preventDefault();
+      event2.stopPropagation();
+    };
+    window.addEventListener("click", block, true);
+    setTimeout(() => window.removeEventListener("click", block, true), 100);
+  }
+  function startDrag() {
+    for (const settle of Array.from(settling.values())) settle();
+    const elements = items();
+    const from = elements.indexOf(item);
+    if (from === -1) return null;
+    const rects = elements.map((element) => element.getBoundingClientRect());
+    const scroller = scrollParent(list);
+    const startScroll = scroller.scrollTop;
+    const others = elements.filter((element) => element !== item);
+    let to = from;
+    let frame = 0;
+    const userSelect = document.body.style.userSelect;
+    document.body.style.userSelect = "none";
+    document.documentElement.dataset.sortableDragging = "";
+    window.getSelection()?.removeAllRanges();
+    list.dataset.dragging = "";
+    item.dataset.dragging = "";
+    for (const other of others)
+      other.style.transition = `transform ${duration}ms ${easing}`;
+    function offset() {
+      const dy = pointerY - startY + scroller.scrollTop - startScroll;
+      const min = rects[0].top - rects[from].top;
+      const max = rects[rects.length - 1].bottom - rects[from].bottom;
+      return Math.min(max, Math.max(min, dy));
+    }
+    function update() {
+      const dy = offset();
+      item.style.transform = `translateY(${dy}px)`;
+      const top = rects[from].top + dy;
+      const bottom = rects[from].bottom + dy;
+      to = from;
+      for (let index = from - 1; index >= 0; index--)
+        if (top < middle(rects[index])) to = index;
+      for (let index = from + 1; index < rects.length; index++)
+        if (bottom > middle(rects[index])) to = index;
+      const size = rects[from].height;
+      elements.forEach((element, index) => {
+        if (element === item) return;
+        const shift = from < to && index > from && index <= to ? -size : to < from && index >= to && index < from ? size : 0;
+        element.style.transform = shift ? `translateY(${shift}px)` : "";
+      });
+    }
+    function autoScroll() {
+      const bounds = scrollBounds(scroller);
+      const step = pointerY < bounds.top + scrollEdge ? -scrollSpeed : pointerY > bounds.bottom - scrollEdge ? scrollSpeed : 0;
+      if (step) {
+        const before = scroller.scrollTop;
+        scroller.scrollTop += step;
+        if (scroller.scrollTop !== before) update();
+      }
+      frame = requestAnimationFrame(autoScroll);
+    }
+    frame = requestAnimationFrame(autoScroll);
+    function end(commit) {
+      cancelAnimationFrame(frame);
+      document.body.style.userSelect = userSelect;
+      delete document.documentElement.dataset.sortableDragging;
+      const moved = commit && to !== from;
+      for (const other of others) {
+        if (moved) other.style.transition = "";
+        other.style.transform = "";
+      }
+      const visualTop = item.getBoundingClientRect().top;
+      item.style.transform = "";
+      if (moved) onDrop(item, elements[to], to > from ? "after" : "before");
+      const distance = visualTop - item.getBoundingClientRect().top;
+      item.style.transition = "none";
+      item.style.transform = `translateY(${distance}px)`;
+      item.getBoundingClientRect();
+      item.style.transition = `transform ${duration}ms ${easing}`;
+      item.style.transform = "";
+      delete list.dataset.dragging;
+      const timeout = setTimeout(settle, duration);
+      function settle() {
+        clearTimeout(timeout);
+        settling.delete(item);
+        item.style.transition = "";
+        for (const other of others) other.style.transition = "";
+        delete item.dataset.dragging;
+      }
+      settling.set(item, settle);
+    }
+    return { update, end };
+  }
+}
+function middle(rect) {
+  return rect.top + rect.height / 2;
+}
+function scrollParent(element) {
+  for (let parent = element.parentElement; parent; parent = parent.parentElement) {
+    const { overflowY } = getComputedStyle(parent);
+    if ((overflowY === "auto" || overflowY === "scroll") && parent.scrollHeight > parent.clientHeight)
+      return parent;
+  }
+  return document.scrollingElement ?? document.documentElement;
+}
+function scrollBounds(scroller) {
+  if (scroller === document.scrollingElement)
+    return { top: 0, bottom: window.innerHeight };
+  const rect = scroller.getBoundingClientRect();
+  return { top: rect.top, bottom: rect.bottom };
+}
+export {
+  pressSortableItem
+};

package/dist/components/internal/useDragDrop.js

@@ -1,9 +1,9 @@
 import {
   $32ef394310635fd5$export$2cfc5be7a55829f6,
   $f9554a667e4f0374$export$62ed72bc21f6b8a6
-} from "../../chunks/chunk-JOF663EG.js";
+} from "../../chunks/chunk-QHHMKJUO.js";
 import "../../chunks/chunk-NUFRM6SI.js";
-import "../../chunks/chunk-RE523BQ7.js";
+import "../../chunks/chunk-HOETF6HN.js";
 import "../../chunks/chunk-RKDPDEF7.js";
 import "../../chunks/chunk-PSSMQKAH.js";
 import "../../chunks/chunk-CQ52GEHY.js";

package/dist/components.d.ts

@@ -42,6 +42,7 @@ export * from './components/RadioGroup.js';
 export * from './components/Resizable.js';
 export * from './components/SearchField.js';
 export * from './components/Select.js';
+export * from './components/Sheet.js';
 export * from './components/Sidebar.js';
 export * from './components/SortableList.js';
 export * from './components/Spinner.js';

package/dist/components.js

@@ -43,6 +43,7 @@ export * from "./components/RadioGroup.js";
 export * from "./components/Resizable.js";
 export * from "./components/SearchField.js";
 export * from "./components/Select.js";
+export * from "./components/Sheet.js";
 export * from "./components/Sidebar.js";
 export * from "./components/SortableList.js";
 export * from "./components/Spinner.js";

package/dist/core/Config.d.ts

@@ -19,7 +19,12 @@ export interface Config {
     preview?: Preview;
     /** Every edit will pass through a draft status before being published */
     enableDrafts?: boolean;
-    /** Fallback interval in seconds for polling content updates (freshness is primarily sha-driven) */
+    /**
+     * Fallback interval in seconds for polling content updates (freshness is
+     * primarily sha-driven). In Next.js it also sets how long renders share the
+     * latest content sha, which bounds how soon edits made outside the handler
+     * show up: five minutes when unset.
+     */
     syncInterval?: number;
     /** Maximum file upload size in bytes */
     maxUploadSize?: number;

package/dist/core/Document.d.ts

@@ -7,4 +7,12 @@ export type Document = {
     path: PathField;
     metadata: MetadataField;
 };
-export declare function document<Fields extends FieldsDefinition = {}>(label: string, { fields, ...config }: TypeConfig<Fields> | ContainerTypeConfig<Fields>): Type<Document & Fields>;
+export type DocumentConfig<Fields, Seo, Details> = (TypeConfig<Fields> | ContainerTypeConfig<Fields>) & {
+    /** Fields shown in the SEO tab, above the previews */
+    seo?: Seo;
+    /** Fields shown in the Details tab, above the created and updated details */
+    details?: Details;
+};
+export declare function document<Fields extends FieldsDefinition = {}, Seo extends FieldsDefinition = {}, Details extends FieldsDefinition = {}>(label: string, { fields, seo, details, ...config }: DocumentConfig<Fields, Seo, Details>): Type<Document & Fields & Seo & Details>;
+/** Whether `type` was created with `Config.document` */
+export declare function isDocument(type: Type): boolean;

package/dist/core/Document.js

@@ -8,24 +8,40 @@ import {
 } from "alinea/dashboard/icons";
 import {
   metadata as createMetadata,
-  metadataDetails
+  metadataDetails,
+  metadataPreviews
 } from "alinea/field/metadata";
 import { path as createPath } from "alinea/field/path";
 import { tab, tabs } from "alinea/field/tabs";
 import { text } from "alinea/field/text";
+import { Section } from "./Section.js";
 import {
   type
 } from "./Type.js";
+import { entries, keys } from "./util/Objects.js";
 var documentMarker = /* @__PURE__ */ Symbol.for("@alinea.Document");
 function documentFields() {
   return {
     title: text("Title", { required: true, width: 0.5 }),
     path: createPath("Path", { required: true, width: 0.5 }),
-    metadata: createMetadata("Metadata", { detailsSection: true })
+    metadata: createMetadata("Metadata", { sections: true })
   };
 }
-function document(label, { fields, ...config }) {
+function document(label, {
+  fields = {},
+  seo = {},
+  details = {},
+  ...config
+}) {
   const { title, path, metadata } = documentFields();
+  const taken = /* @__PURE__ */ new Set([
+    ...keys({ title, path, metadata }),
+    ...fieldNames(fields)
+  ]);
+  for (const name of [...fieldNames(seo), ...fieldNames(details)]) {
+    if (taken.has(name)) throw new Error(`Field "${name}" is defined twice`);
+    taken.add(name);
+  }
   const fieldsWithMeta = tabs(
     tab("Document", {
       icon: IcRoundDescription,
@@ -33,11 +49,11 @@ function document(label, { fields, ...config }) {
     }),
     tab("SEO", {
       icon: IcRoundBolt,
-      fields: { metadata }
+      fields: { metadata, ...seo, ...metadataPreviews() }
     }),
     tab("Details", {
       icon: IcRoundInfo,
-      fields: { ...metadataDetails(metadata) }
+      fields: { ...details, ...metadataDetails(metadata) }
     })
   );
   const result = type(label, {
@@ -46,6 +62,15 @@ function document(label, { fields, ...config }) {
   });
   return Object.assign(result, { [documentMarker]: true });
 }
+function isDocument(type2) {
+  return documentMarker in type2;
+}
+function fieldNames(definition) {
+  return entries(definition).flatMap(
+    ([name, value]) => Section.isSection(value) ? keys(Section.fields(value)) : [name]
+  );
+}
 export {
-  document
+  document,
+  isDocument
 };

package/dist/core/Overview.d.ts

@@ -70,7 +70,7 @@ export type OverviewSortDirection = 'asc' | 'desc';
 export interface OverviewSort {
     /**
      * A key of `overview.sorts`, of `overview.columns`, or a built-in column:
-     * `title`, `type`, `status`, `updated`, `author`
+     * `title`, `type`, `updated`, `author`
      */
     column: string;
     direction: OverviewSortDirection;
@@ -180,8 +180,6 @@ export interface OverviewColumn<Value = any> extends OverviewColumnBase<Value> {
 export interface OverviewBuiltins {
     /** The entry type, shown by default when the children have several types */
     type?: boolean;
-    /** The publication status, shown by default when the statuses differ */
-    status?: boolean;
     /** When the entry was last edited, shown by default when recorded */
     updated?: boolean;
     /** Who last edited the entry, shown by default when recorded */
@@ -192,7 +190,7 @@ export interface OverviewOptions {
     /**
      * Columns shown after the title and the built-in columns, or before the
      * built-in columns with `position: 'start'`. A column keyed `type`,
-     * `status`, `updated` or `author` replaces that built-in column.
+     * `updated` or `author` replaces that built-in column.
      */
     columns?: Record<string, OverviewColumn>;
     /** Show or hide the built-in columns */

package/dist/core/TextDoc.d.ts

@@ -70,6 +70,10 @@ export interface ImageNode extends ElementNode {
 export interface BlockNode {
     _id: string;
     _type: string;
+    /** A label editors give the block, its anchor follows it by default */
+    _label?: string;
+    /** Lets links point to the block, unique within the entry */
+    _anchor?: string;
 }
 export declare namespace BlockNode {
     const id = "_id";

package/dist/core/Validation.d.ts

@@ -53,4 +53,3 @@ export declare function validateType(type: Type, value: unknown, context: FieldV
 /** Validate entry data: required, min, max and validate options */
 export declare function validateEntry(type: Type, data: unknown, options?: ValidateEntryOptions): Array<FieldValidationError>;
 export declare function formatFieldPath(path: FieldPath): string;
-export declare function formatValidationErrors(errors: ReadonlyArray<FieldValidationError>): string;

package/dist/core/Validation.js

@@ -104,15 +104,9 @@ function formatFieldPath(path) {
   }
   return result;
 }
-function formatValidationErrors(errors) {
-  return errors.map(
-    (error) => `- ${formatFieldPath(error.path)} (${error.labels.join(" \u203A ")}): ${error.message}`
-  ).join("\n");
-}
 export {
   fieldError,
   formatFieldPath,
-  formatValidationErrors,
   policyFieldOptions,
   scopeGetter,
   trackedFieldOptions,

package/dist/core/field/RichTextField.js

@@ -1911,8 +1911,11 @@ function normalizeRichTextAnchors(schema, doc, anchors) {
   function normalizeNode(node, insideHeading, activeManualAnchors2) {
     if (Node.isBlock(node)) {
       activeManualAnchors2.clear();
+      const source2 = blockAnchor(node);
+      const unique2 = createUniqueAnchor(source2, anchors);
+      const anchored = source2 !== void 0 && unique2 !== node._anchor ? { ...node, _anchor: unique2 } : node;
       const type = schema?.[node[Node.type]];
-      return type ? Type.normalizeAnchors(type, node, { anchors }) : node;
+      return type ? Type.normalizeAnchors(type, anchored, { anchors }) : anchored;
     }
     if (Node.isText(node)) {
       const marks = node.marks;
@@ -2052,20 +2055,36 @@ function richTextAnchors(schema, doc, context) {
     }
   });
   doc.forEach((row, index) => {
-    if (!schema || !Node.isBlock(row)) return;
-    const type = schema[row[Node.type]];
+    if (!Node.isBlock(row)) return;
+    const segment = row._id ?? String(index);
+    const anchor = blockAnchor(row);
+    if (anchor && !anchors.has(anchor)) {
+      anchors.add(anchor);
+      result.push({
+        id: anchor,
+        label: `#${anchor}`,
+        fieldPath: referenceFieldPath([...path, segment, anchor]),
+        fieldLabel: label
+      });
+    }
+    const type = schema?.[row[Node.type]];
     if (!type) return;
     result.push(
       ...Type.anchors(
         type,
         row,
-        [...path, row._id ?? String(index)],
+        [...path, segment],
         [...labels, Type.label(type)]
       )
     );
   });
   return result;
 }
+function blockAnchor(block) {
+  if (typeof block._anchor === "string") return block._anchor;
+  if (typeof block._label === "string" && block._label)
+    return slugify(block._label);
+}
 function richTextReferences(schema, doc, context) {
   const { path, label, labels } = context;
   const result = [];

package/dist/core/media/MediaTypes.js

@@ -82,7 +82,7 @@ function mediaOverview() {
     MediaLibrary: new Expr({ type: "value", value: 0 })
   });
   return {
-    builtins: { type: false, status: false },
+    builtins: { type: false },
     // Folders first in their manual order, files have none and come after,
     // newest first: entry ids start with their creation time. Indexes are
     // keys that only order as stored.

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

@@ -13,6 +13,10 @@ export declare function normalizeGithubSourceOptions<Options extends GithubSourc
 export declare class GithubSource implements Source {
     #private;
     constructor(options: GithubSourceOptions);
+    /** Request GitHub, counting the request against its budget. */
+    protected githubFetch(input: string, init?: RequestInit): Promise<Response>;
+    /** Run an operation, and log what it spent of GitHub's budgets. */
+    protected spending<T>(operation: string, run: () => Promise<T>): Promise<T>;
     protected get contentLocation(): string;
     getTree(): Promise<ReadonlyTree>;
     shaAt(ref: string): Promise<string>;

package/dist/core/source/GithubSource.js

@@ -8,9 +8,14 @@ import * as paths from "alinea/core/util/Paths";
 import { HttpError } from "../HttpError.js";
 import { assert } from "../util/Assert.js";
 import { isRecord } from "alinea/core/util/Objects";
+import { chunks } from "../util/Arrays.js";
+import { hashBlob } from "./GitUtils.js";
+import { GithubUsage } from "./GithubUsage.js";
 import { Leaf, ReadonlyTree } from "./Tree.js";
 var shaCache = /* @__PURE__ */ new Map();
 var truncatedTrees = /* @__PURE__ */ new Set();
+var blobsPerQuery = 100;
+var smallestBlobQuery = 25;
 function normalizeGithubSourceOptions(options) {
   return {
     ...options,
@@ -22,9 +27,27 @@ var GithubSource = class {
   #current = ReadonlyTree.EMPTY;
   #options;
   #limit = pLimit(8);
+  /** Blob queries in flight, each holding up to a hundred blobs in memory. */
+  #blobQueries = pLimit(2);
+  #usage = new GithubUsage();
   constructor(options) {
     this.#options = normalizeGithubSourceOptions(options);
   }
+  /** Request GitHub, counting the request against its budget. */
+  async githubFetch(input, init) {
+    const response = await fetch(input, init);
+    this.#usage.record(response);
+    return response;
+  }
+  /** Run an operation, and log what it spent of GitHub's budgets. */
+  async spending(operation, run) {
+    const before = this.#usage.count();
+    try {
+      return await run();
+    } finally {
+      this.#usage.log(operation, before);
+    }
+  }
   get contentLocation() {
     const { contentDir, rootDir } = this.#options;
     return paths.join(rootDir, contentDir);
@@ -42,7 +65,7 @@ var GithubSource = class {
     const cached = 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 });
+    const parentInfo = await this.githubFetch(url, { headers });
     if (parentInfo.status === 304) {
       assert(cached, "Received 304 without a cached GitHub response");
       return cached.sha;
@@ -59,10 +82,12 @@ var GithubSource = class {
     else shaCache.delete(url);
     return sha;
   }
-  async getTreeIfDifferent(sha) {
-    const remoteSha = await this.shaAt(this.#options.branch);
-    if (remoteSha === sha) return void 0;
-    return this.#fetchTree(remoteSha, this.contentLocation);
+  getTreeIfDifferent(sha) {
+    return this.spending("sync", async () => {
+      const remoteSha = await this.shaAt(this.#options.branch);
+      if (remoteSha === sha) return void 0;
+      return this.#fetchTree(remoteSha, this.contentLocation);
+    });
   }
   /**
    * GitHub truncates recursive listings above 100k entries or 7 MB, so a
@@ -73,7 +98,7 @@ var GithubSource = class {
     const key = `${owner}/${repo}:${location}`;
     const list = async (query) => {
       const response = await this.#limit(
-        () => fetch(
+        () => this.githubFetch(
           `https://api.github.com/repos/${owner}/${repo}/git/trees/${sha}${query}`,
           { headers: { Authorization: `Bearer ${authToken}` } }
         )
@@ -101,28 +126,105 @@ var GithubSource = class {
     return ReadonlyTree.fromNodes(new Map(nodes), sha);
   }
   async *getBlobs(shas, options = {}) {
+    const before = this.#usage.count();
+    const batches = Array.from(
+      chunks(shas, blobsPerQuery),
+      (batch) => this.#blobQueries(() => this.#queryBlobs(batch, options.signal))
+    );
+    for (const batch of batches) batch.catch(() => {
+    });
+    try {
+      for (const batch of batches) yield* await batch;
+    } finally {
+      this.#usage.log("blobs", before);
+    }
+  }
+  /**
+   * Look blobs up in one GraphQL query, which costs a single point of
+   * GitHub's GraphQL budget however many it holds, where the REST API counts
+   * a request per blob. A query GitHub cannot answer in time, such as one
+   * for many large files, is asked again in halves, down to a small one.
+   */
+  async #queryBlobs(shas, signal) {
+    const blobs = await this.#graphqlBlobs(shas, signal);
+    if (blobs) return blobs;
+    if (shas.length <= smallestBlobQuery)
+      throw new HttpError(502, "Failed to get blobs: GitHub did not answer");
+    const half = Math.ceil(shas.length / 2);
+    return [
+      ...await this.#queryBlobs(shas.slice(0, half), signal),
+      ...await this.#queryBlobs(shas.slice(half), signal)
+    ];
+  }
+  /**
+   * Blobs found by one GraphQL query, or undefined if GitHub could not
+   * answer it, such as when it timed out. Blobs it has no text for, such as
+   * binary or very large files, are fetched one by one.
+   */
+  async #graphqlBlobs(shas, signal) {
     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}` },
-            signal: options.signal
-          }
-        )
-      );
-      return [sha, promise];
+    const params = shas.map((_, i) => `$b${i}: GitObjectID!`).join(", ");
+    const fields = shas.map(
+      (_, i) => `b${i}: object(oid: $b${i}) { ... on Blob { text isBinary isTruncated } }`
+    ).join("\n");
+    const query = `query ($owner: String!, $repo: String!, ${params}) {
+      repository(owner: $owner, name: $repo) {
+        ${fields}
+      }
+    }`;
+    const variables = { owner, repo };
+    for (const [i, sha] of shas.entries()) variables[`b${i}`] = sha;
+    const response = await this.githubFetch("https://api.github.com/graphql", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query, variables }),
+      signal
     });
-    for (const [sha, promise] of responses) {
-      const response = await promise;
-      if (!response.ok) throw await githubError(response, "Failed to get blob");
-      const blobData = await response.json();
-      assert(blobData.encoding === "base64");
-      assert(typeof blobData.content === "string");
-      assert(blobData.size > 0);
-      yield [sha, Uint8Array.from(atob(blobData.content), (c) => c.charCodeAt(0))];
+    if (response.status >= 500) return void 0;
+    if (!response.ok) throw await githubError(response, "Failed to get blobs");
+    const result = await response.json();
+    assert(isRecord(result));
+    const errors = Array.isArray(result.errors) ? result.errors : [];
+    if (errors.length > 0) {
+      const typed = errors.some(
+        (error) => isRecord(error) && typeof error.type === "string"
+      );
+      if (!typed) return void 0;
+      const reasons = errors.map(
+        (error) => isRecord(error) ? String(error.message) : String(error)
+      );
+      throw new Error(`Failed to get blobs: ${reasons.join("; ")}`);
+    }
+    const data = isRecord(result.data) ? result.data : {};
+    const repository = isRecord(data.repository) ? data.repository : {};
+    const encoder = new TextEncoder();
+    const blobs = Array();
+    for (const [i, sha] of shas.entries()) {
+      const blob = repository[`b${i}`];
+      const text = isRecord(blob) && !blob.isBinary && !blob.isTruncated ? blob.text : void 0;
+      const bytes = typeof text === "string" ? encoder.encode(text) : void 0;
+      blobs.push([
+        sha,
+        bytes && await hashBlob(bytes) === sha ? bytes : await this.#fetchBlob(sha, signal)
+      ]);
     }
+    return blobs;
+  }
+  async #fetchBlob(sha, signal) {
+    const { owner, repo, authToken } = this.#options;
+    const response = await this.githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/blobs/${sha}`,
+      { headers: { Authorization: `Bearer ${authToken}` }, signal }
+    );
+    if (!response.ok) throw await githubError(response, "Failed to get blob");
+    const blobData = await response.json();
+    assert(blobData.encoding === "base64");
+    assert(typeof blobData.content === "string");
+    assert(blobData.size > 0);
+    return Uint8Array.from(atob(blobData.content), (c) => c.charCodeAt(0));
   }
   async applyChanges(batch) {
     throw new Error("Not implemented");

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

@@ -0,0 +1,21 @@
+/**
+ * Counts the GitHub requests a source makes against its REST and GraphQL
+ * budgets, and logs what each operation spent and what is left, so the logs
+ * show where a rate limit goes. Answers of 304 are free and not counted.
+ */
+export declare class GithubUsage {
+    #private;
+    rest: number;
+    graphql: number;
+    record(response: Response): void;
+    /** The requests counted so far, to log what an operation adds. */
+    count(): {
+        rest: number;
+        graphql: number;
+    };
+    /** Log what `operation` spent since `before`, if anything. */
+    log(operation: string, before: {
+        rest: number;
+        graphql: number;
+    }): void;
+}