alinea 2.0.0-preview.12 → 2.0.0-preview.14

package/dist/.init/content/pages/welcome.json

@@ -1,5 +1,5 @@
 {
-  "_id": "3KPEwd5jxca0cmXOExux5RBSXpo",
+  "_id": "3Kg2pCrguJIYIFElVMkyXOQsdZa",
   "_type": "Page",
   "_index": "a0",
   "_seeded": "welcome.json",

package/dist/.mcp/later/dev.json

@@ -1 +1 @@
-{"url":"http://localhost:1","pid":2819}
+{"url":"http://localhost:1","pid":3063}

package/dist/.mcp/online/dev.json

@@ -1 +1 @@
-{"url":"http://localhost:40589","pid":2819}
+{"url":"http://localhost:34865","pid":3063}

package/dist/adapter/next/cms.js

@@ -8,23 +8,24 @@ import {
   applyPreview as applyPreviewUpdate,
   decodePreviewRequest
 } from "alinea/backend/resolver/ParsePreview";
-import { createThrottledSync } from "alinea/backend/util/Syncable";
+import { dashboardUrl } from "./dashboardUrl.js";
+import { createThrottledSync, syncWait } from "alinea/backend/util/Syncable";
 import { Client } from "alinea/core/Client";
 import { CMS } from "alinea/core/CMS";
-import { Config } from "alinea/core/Config";
 import {
   withDevelopmentKey
 } from "alinea/core/Connection";
 import { outcome } from "alinea/core/Outcome";
 import { getScope } from "alinea/core/Scope";
 import { trace } from "alinea/core/Trace";
+import { within } from "alinea/core/util/Async";
 import { getPreviewPayloadFromCookies } from "alinea/preview/PreviewCookies";
 import { Headers } from "@alinea/iso";
 import { cache } from "react";
 import { requestContext } from "./context.js";
 import { cachedResolve, developmentRevision } from "./devCache.js";
 import { RenderStats, summarizeQuery, timed } from "./renderStats.js";
-import { syncIfStale } from "./syncCheck.js";
+import { contentShaWindow, syncIfStale, tagContentSha } from "./syncCheck.js";
 import { jsx } from "react/jsx-runtime";
 var preValidatedRemote = { validate: false };
 var NextCMS = class extends CMS {
@@ -66,6 +67,10 @@ var NextCMS = class extends CMS {
    * returns a fresh holder, so nothing is recorded there.
    */
   #render = cache(() => ({}));
+  /** Build renders join the content sha tag once, see `tagContentSha`. */
+  #tagContent = cache(
+    () => tagContentSha(contentShaWindow(this.config.syncInterval))
+  );
   /** One content revision per render, see `developmentRevision`. */
   #devRevision = cache(() => developmentRevision());
   #isDraft = cache(async () => {
@@ -95,7 +100,10 @@ var NextCMS = class extends CMS {
         (row) => timed(row, () => this.#syncDb(db, client, void 0))
       );
     try {
-      const sha = await db.syncWith(client, preValidatedRemote);
+      const sha = await within(
+        db.syncWith(client, preValidatedRemote),
+        syncWait
+      );
       this.#syncedAt = Date.now();
       return sha;
     } catch (error) {
@@ -201,12 +209,19 @@ var NextCMS = class extends CMS {
     const answer = () => stats && row ? stats.executed(row, () => db.resolve(request)) : db.resolve(request);
     const syncInterval = request.disableSync ? Number.POSITIVE_INFINITY : request.syncInterval ?? this.config.syncInterval;
     if (hasPreview) return answer();
-    if (!isBuild) {
+    if (isBuild) {
+      await this.#tagContent();
+    } else {
       const tracked = {
         sha: db.sha,
         syncWith: () => this.#syncDb(db, client, stats)
       };
-      const settled = !isDraft && await syncIfStale(tracked, client, syncInterval);
+      const settled = !isDraft && await syncIfStale(
+        tracked,
+        client,
+        syncInterval,
+        contentShaWindow(this.config.syncInterval)
+      );
       if (!settled)
         await this.throttle(() => this.#syncDb(db, client, stats), syncInterval);
     }
@@ -264,16 +279,13 @@ var NextCMS = class extends CMS {
     if (!stats) return null;
     const { default: dynamic } = await import("next/dynamic.js");
     const { isDev, handlerUrl } = await requestContext(this.config);
-    let adminPath = Config.adminPath(this.config);
-    if (!adminPath.startsWith("/")) adminPath = `/${adminPath}`;
-    const dashboardUrl = isDev ? adminPath : new URL(`${adminPath}.html`, handlerUrl).href;
     const NextPreviews = dynamic(() => import("./previews.js"), {
       ssr: false
     });
     return /* @__PURE__ */ jsx(
       NextPreviews,
       {
-        dashboardUrl,
+        dashboardUrl: dashboardUrl(this.config, isDev, handlerUrl),
         widget,
         stats: widget && showStats ? stats.settled() : void 0,
         workspace,

package/dist/adapter/next/context.js

@@ -15,13 +15,10 @@ async function requestContext(config, request) {
       applyAuth: (init) => forwardDevelopmentCredentials(request, apiKey, init)
     };
   }
-  const nodeEnv = process.env.NODE_ENV;
-  const baseUrl = Config.baseUrl(config, nodeEnv);
-  if (!baseUrl) throw new Error(`Missing baseUrl in config for ${nodeEnv}`);
   const localOrigin = process.env.__NEXT_PRIVATE_ORIGIN;
   return {
     isDev: false,
-    handlerUrl: new URL(Config.handlerUrl(config), baseUrl),
+    handlerUrl: Config.serverHandlerUrl(config),
     apiKey,
     publicUrl: localOrigin ? new URL(localOrigin) : void 0
   };

package/dist/adapter/next/dashboardUrl.d.ts

@@ -0,0 +1,6 @@
+import { Config } from 'alinea/core/Config';
+/**
+ * The dashboard as the site serves it: in development the site proxies the
+ * admin path to the dev server, in production it serves the generated file.
+ */
+export declare function dashboardUrl(config: Config, isDev: boolean, handlerUrl: URL | string): string;

package/dist/adapter/next/dashboardUrl.js

@@ -0,0 +1,13 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/adapter/next/dashboardUrl.ts
+import { Config } from "alinea/core/Config";
+function dashboardUrl(config, isDev, handlerUrl) {
+  if (!isDev)
+    return new URL(`/${Config.dashboardFile(config)}`, handlerUrl).href;
+  const adminPath = Config.adminPath(config);
+  return adminPath.startsWith("/") ? adminPath : `/${adminPath}`;
+}
+export {
+  dashboardUrl
+};

package/dist/adapter/next/handler.js

@@ -10,6 +10,7 @@ import {
 import {
   createHandler as createCoreHandler
 } from "alinea/backend/Handler";
+import { committedEntries, removedEntries } from "alinea/backend/CommitEntries";
 import { HandleAction } from "alinea/backend/HandleAction";
 import { JWTPreviews } from "alinea/backend/util/JWTPreviews";
 import { CloudRemote } from "alinea/cloud/CloudRemote";
@@ -79,18 +80,28 @@ function createHandlerWithDatabase(input, openGeneratedDatabase) {
     });
     let sha;
     let user;
+    let before = [];
     try {
       user = await devServer.user();
       if (!user) return failure(401, "Unauthorized");
       const adjusted = await options.beforeCommit?.({ mutations, user });
       if (adjusted) mutations = [...adjusted];
+      if (options.afterCommit)
+        before = await committedEntries(devServer, mutations).catch(() => []);
       ({ sha } = await devServer.mutate(mutations));
     } catch (error) {
       if (error instanceof HttpError) return failure(error.code, error.message);
       throw error;
     }
     try {
-      await afterCommit({ mutations, sha, user });
+      const entries = options.afterCommit ? await committedEntries(devServer, mutations) : [];
+      await afterCommit({
+        mutations,
+        sha,
+        user,
+        entries,
+        removed: removedEntries(before, entries)
+      });
     } catch (error) {
       console.error("Alinea afterCommit hook failed", error);
     }

package/dist/adapter/next/syncCheck.d.ts

@@ -6,13 +6,26 @@ interface SyncableDB {
     syncWith(source: RemoteSource, options?: SyncOptions): Promise<string>;
 }
 export declare const CONTENT_SHA_TAG = "alinea-content-sha";
+/**
+ * How long renders share the latest content sha. Configured through the
+ * config's `syncInterval`, never a query's: all renders share one entry.
+ */
+export declare function contentShaWindow(syncInterval?: number): number;
+/**
+ * Tag a static render with the content sha without looking it up. Renders at
+ * build skip `syncIfStale`, so this is how their pages join the tag that
+ * commits revalidate, and get the same time-based safety net as pages
+ * rendered at runtime.
+ */
+export declare function tagContentSha(revalidate?: number): Promise<void>;
 export declare function revalidateContentSha(): Promise<void>;
 /**
  * Sync the isolate-local db only when it is behind the shared content sha.
  * Returns true when the freshness question is settled here (synced, forced,
  * or explicitly disabled) and the caller can skip its throttled sync.
  * Returns false when the sha could not be determined, so the caller falls
- * back to its existing throttle behavior.
+ * back to its existing throttle behavior. `shaWindow` is how long renders
+ * share the latest sha, see `contentShaWindow`.
  */
-export declare function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, options?: SyncOptions): Promise<boolean>;
+export declare function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, shaWindow?: number, options?: SyncOptions): Promise<boolean>;
 export {};

package/dist/adapter/next/syncCheck.js

@@ -2,22 +2,27 @@ import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/adapter/next/syncCheck.ts
 var CONTENT_SHA_TAG = "alinea-content-sha";
-var SHA_REVALIDATE_SECONDS = 60;
+var SHA_REVALIDATE_SECONDS = 300;
+function contentShaWindow(syncInterval) {
+  if (syncInterval !== void 0 && syncInterval > 0 && Number.isFinite(syncInterval))
+    return syncInterval;
+  return SHA_REVALIDATE_SECONDS;
+}
 var inflight;
-function latestSha(client) {
+function latestSha(client, revalidate) {
   if (inflight) return inflight;
-  inflight = loadLatestSha(client).finally(() => {
+  inflight = loadLatestSha(client, revalidate).finally(() => {
     inflight = void 0;
   });
   return inflight;
 }
-async function loadLatestSha(client) {
+async function loadLatestSha(client, revalidate) {
   try {
     const { unstable_cache } = await import("next/cache.js");
     const getSha = unstable_cache(
       () => client.getSha(),
       ["alinea-content-sha"],
-      { revalidate: SHA_REVALIDATE_SECONDS, tags: [CONTENT_SHA_TAG] }
+      { revalidate, tags: [CONTENT_SHA_TAG] }
     );
     return await getSha();
   } catch {
@@ -28,26 +33,38 @@ async function loadLatestSha(client) {
     }
   }
 }
+async function tagContentSha(revalidate = SHA_REVALIDATE_SECONDS) {
+  try {
+    const { unstable_cache } = await import("next/cache.js");
+    await unstable_cache(async () => true, ["alinea-content-sha-tag"], {
+      revalidate,
+      tags: [CONTENT_SHA_TAG]
+    })();
+  } catch {
+  }
+}
 async function revalidateContentSha() {
   try {
     const { revalidateTag } = await import("next/cache.js");
-    revalidateTag(CONTENT_SHA_TAG, { expire: 0 });
+    revalidateTag(CONTENT_SHA_TAG, "max");
   } catch {
   }
 }
-async function syncIfStale(db, client, syncInterval, options) {
+async function syncIfStale(db, client, syncInterval, shaWindow = SHA_REVALIDATE_SECONDS, options) {
   if (syncInterval === Number.POSITIVE_INFINITY) return true;
   if (syncInterval === 0) {
     await db.syncWith(client, options);
     return true;
   }
-  const expected = await latestSha(client);
+  const expected = await latestSha(client, shaWindow);
   if (!expected) return false;
   if (expected !== await db.sha) await db.syncWith(client, options);
   return true;
 }
 export {
   CONTENT_SHA_TAG,
+  contentShaWindow,
   revalidateContentSha,
-  syncIfStale
+  syncIfStale,
+  tagContentSha
 };

package/dist/backend/CommitEntries.d.ts

@@ -0,0 +1,17 @@
+import type { DashboardEntry } from 'alinea/core/DashboardEntry';
+import type { Mutation } from 'alinea/core/db/Mutation';
+import type { Resolver } from 'alinea/core/Resolver';
+/** An entry that no longer exists after a commit */
+export interface RemovedEntry {
+    id: string;
+    type: string;
+    locale: string | null;
+    /** The url the entry had before the commit */
+    url: string;
+}
+/**
+ * The latest version, in every locale, of the entries that mutations change
+ */
+export declare function committedEntries(resolver: Resolver, mutations: ReadonlyArray<Mutation>): Promise<Array<DashboardEntry>>;
+/** The entries of `before` that are not in `after` */
+export declare function removedEntries(before: Array<DashboardEntry>, after: Array<DashboardEntry>): Array<RemovedEntry>;

package/dist/backend/CommitEntries.js

@@ -0,0 +1,39 @@
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/backend/CommitEntries.ts
+import { Entry } from "alinea/core/Entry";
+var select = {
+  id: Entry.id,
+  type: Entry.type,
+  title: Entry.title,
+  path: Entry.path,
+  url: Entry.url,
+  locale: Entry.locale,
+  status: Entry.status,
+  workspace: Entry.workspace,
+  root: Entry.root,
+  parentId: Entry.parentId,
+  data: Entry.data
+};
+function entryIds(mutations) {
+  const ids = mutations.map((mutation) => "id" in mutation ? mutation.id : "");
+  return [...new Set(ids.filter(Boolean))];
+}
+async function committedEntries(resolver, mutations) {
+  const ids = entryIds(mutations);
+  if (ids.length === 0) return [];
+  return await resolver.resolve({
+    id: { in: ids },
+    status: "preferDraft",
+    select
+  });
+}
+function removedEntries(before, after) {
+  const key = (entry) => `${entry.id}:${entry.locale}`;
+  const remaining = new Set(after.map(key));
+  return before.filter((entry) => !remaining.has(key(entry))).map(({ id, type, locale, url }) => ({ id, type, locale, url }));
+}
+export {
+  committedEntries,
+  removedEntries
+};

package/dist/backend/Handler.d.ts

@@ -1,6 +1,8 @@
 import type { CMS } from 'alinea/core/CMS';
 import type { AuthedContext, RemoteConnection, RequestContext } from 'alinea/core/Connection';
 import type { LocalStore } from 'alinea/core/db/LocalStore';
+import type { DashboardEntry } from 'alinea/core/DashboardEntry';
+import { type RemovedEntry } from './CommitEntries.js';
 import type { Mutation } from 'alinea/core/db/Mutation';
 import type { User } from 'alinea/core/User';
 export interface Handler {
@@ -14,6 +16,13 @@ export interface BeforeCommitContext {
 }
 export interface AfterCommitContext extends BeforeCommitContext {
     sha: string;
+    /**
+     * The entries the mutations changed as they are after the commit: the
+     * latest version in each locale
+     */
+    entries: Array<DashboardEntry>;
+    /** Entries that no longer exist after the commit, with the url they had */
+    removed: Array<RemovedEntry>;
 }
 export interface HandlerHooks {
     beforeCommit?(context: BeforeCommitContext): HookResponse<ReadonlyArray<Mutation>>;

package/dist/backend/Handler.js

@@ -4,7 +4,7 @@ import {
   object,
   optional,
   string
-} from "../chunks/chunk-UPY2RUZF.js";
+} from "../chunks/chunk-TWBREZWC.js";
 import {
   PLazy
 } from "../chunks/chunk-IKINPSS5.js";
@@ -19,6 +19,10 @@ import {
 } from "alinea/core/BlobTransport";
 import { Config } from "alinea/core/Config";
 import { developmentKeyHeader } from "alinea/core/Connection";
+import {
+  committedEntries,
+  removedEntries
+} from "./CommitEntries.js";
 import { Entry } from "alinea/core/Entry";
 import { ErrorCode, HttpError } from "alinea/core/HttpError";
 import { MediaLocation } from "alinea/core/media/MediaLocation";
@@ -27,15 +31,18 @@ import { assertUploadSize } from "alinea/core/media/UploadLimits";
 import { Permission, Policy } from "alinea/core/Role";
 import { getScope } from "alinea/core/Scope";
 import { ShaMismatchError } from "alinea/core/source/ShaMismatchError";
+import { sourceAtTree } from "alinea/core/source/Source";
 import { base64 } from "alinea/core/util/Encoding";
+import { within } from "alinea/core/util/Async";
 import { isRecord } from "alinea/core/util/Objects";
-import { isAbsolute, normalize } from "alinea/core/util/Paths";
+import { fileVersions } from "alinea/core/util/EntryFilenames";
+import { isAbsolute, normalize, relative } from "alinea/core/util/Paths";
 import { InvalidCredentialsError, MissingCredentialsError } from "./Auth.js";
 import { HandleAction } from "./HandleAction.js";
 import { proxyMediaUrl } from "./api/ProxyMedia.js";
 import { applyPreview, decodePreviewRequest } from "./resolver/ParsePreview.js";
 import { compressResponse } from "./router/Router.js";
-import { createThrottledSync } from "./util/Syncable.js";
+import { createThrottledSync, syncWait } from "./util/Syncable.js";
 var PrepareBody = object({
   filename: string,
   size: optional(number)
@@ -53,9 +60,9 @@ function createHandler({
     const local = await db;
     const simulateLatency = process.env.ALINEA_LATENCY;
     if (simulateLatency) await new Promise((resolve) => setTimeout(resolve, 2e3));
-    async function syncForRead(cnx) {
+    async function syncForRead(sync) {
       try {
-        await local.syncWith(cnx);
+        await within(sync, syncWait);
       } catch (error) {
         console.warn(
           `Alinea could not sync with the remote, serving current content: ${error instanceof Error ? error.message : String(error)}`
@@ -64,7 +71,7 @@ function createHandler({
     }
     async function periodicSync(cnx, syncInterval) {
       if (dev) return;
-      return throttle(() => syncForRead(cnx), syncInterval);
+      return syncForRead(throttle(() => local.syncWith(cnx), syncInterval));
     }
     try {
       const previews = new JWTPreviews(context.apiKey);
@@ -258,7 +265,7 @@ function createHandler({
         } else {
           const preview = await decodePreviewRequest(query.preview);
           if ("contentHash" in preview && await local.sha !== preview.contentHash)
-            await syncForRead(cnx);
+            await syncForRead(local.syncWith(cnx));
           query.preview = await applyPreview(local, preview);
         }
         return Response.json(await local.resolve(query) ?? null);
@@ -278,57 +285,92 @@ function createHandler({
           user: user.claims
         });
         if (adjusted) mutations = adjusted;
+        const before = hooks.afterCommit ? await committedEntries(local, mutations) : [];
         const attempt = async (retry = 0) => {
           if (retry > 0) await local.syncWith(cnx);
           const request2 = {
             ...await local.request(mutations, policy),
             user: user.claims
           };
+          let sha2;
           try {
-            let { sha: sha2 } = await cnx.write(request2);
-            if (sha2 === request2.intoSha) {
-              await local.write(request2);
-            } else {
-              sha2 = await local.syncWith(cnx);
-            }
-            return sha2;
+            sha2 = (await cnx.write(request2)).sha;
           } catch (error) {
             const isConflict = error instanceof ShaMismatchError || error instanceof HttpError && error.code === 409 || error instanceof Response && error.status === 409;
             if (isConflict && retry < 3) return attempt(retry + 1);
             throw error;
           }
+          try {
+            if (sha2 === request2.intoSha) await local.write(request2);
+            else sha2 = await local.syncWith(cnx);
+          } catch {
+            sha2 = await local.syncWith(cnx).catch(() => sha2);
+          }
+          return sha2;
         };
         const sha = await attempt();
         try {
-          await hooks.afterCommit?.({ mutations, sha, user: user.claims });
+          if (hooks.afterCommit) {
+            const entries = await committedEntries(local, mutations);
+            await hooks.afterCommit({
+              mutations,
+              sha,
+              user: user.claims,
+              entries,
+              removed: removedEntries(before, entries)
+            });
+          }
         } catch (error) {
           console.error("Alinea afterCommit hook failed", error);
         }
         return Response.json({ sha });
       }
       if (action === HandleAction.History && request.method === "GET") {
-        expectUser();
+        const user = expectUser();
         expectJson();
         const file = string(url.searchParams.get("file"));
         const revisionId = string.nullable(url.searchParams.get("revisionId"));
-        const result = await (revisionId ? cnx.revisionData(file, revisionId) : cnx.revisions(file));
+        const record = revisionId ? await cnx.revisionData(file, revisionId) : void 0;
+        const contentDir = Config.contentDir(cms.config);
+        const owners = () => historyEntries(local, contentDir, file, record);
+        let entries = await owners();
+        if (entries.length === 0) {
+          await syncForRead(local.syncWith(cnx));
+          entries = await owners();
+        }
+        if (entries.length === 0)
+          throw new HttpError(ErrorCode.NotFound, "Entry not found");
+        const policy = await user.policy;
+        for (const entry of entries) policy.assert(Permission.Read, entry);
+        const result = revisionId ? record : await cnx.revisions(file);
         return Response.json(result ?? null);
       }
       if (action === HandleAction.Tree && request.method === "GET") {
         expectJson();
         const sha = string(url.searchParams.get("sha"));
-        await syncForRead(cnx);
+        let source = cnx;
+        try {
+          const remoteTree = await cnx.getTreeIfDifferent(sha);
+          if (!remoteTree) return Response.json(null);
+          source = sourceAtTree(cnx, remoteTree);
+        } catch {
+        }
+        await syncForRead(local.syncWith(source));
         const tree = await local.getTreeIfDifferent(sha);
         return compressResponse(request, Response.json(tree ?? null));
       }
       if (action === HandleAction.Sha && request.method === "GET") {
         expectJson();
-        await syncForRead(cnx);
+        await syncForRead(local.syncWith(cnx));
         return Response.json(await local.sha);
       }
       if (action === HandleAction.Blob && request.method === "POST") {
         const { shas } = object({ shas: array(string) })(await body);
-        const tree = await local.source.getTree();
+        let tree = await local.source.getTree();
+        if (!dev && shas.some((sha) => !tree.hasSha(sha))) {
+          await syncForRead(local.syncWith(cnx));
+          tree = await local.source.getTree();
+        }
         const fromLocal = [];
         const fromRemote = [];
         for (const sha of shas) {
@@ -417,6 +459,28 @@ function createHandler({
     }
   };
 }
+var historyResource = {
+  id: Entry.id,
+  type: Entry.type,
+  workspace: Entry.workspace,
+  root: Entry.root,
+  parents: Entry.parents,
+  locale: Entry.locale
+};
+async function historyEntries(local, contentDir, file, record) {
+  const filePath = relative(contentDir, file);
+  if (filePath.startsWith("../")) return [];
+  const status = "all";
+  const select = historyResource;
+  const atFile = await local.find({
+    filePath: { in: fileVersions(filePath) },
+    status,
+    select
+  });
+  const id = record?._id;
+  if (atFile.length > 0 || typeof id !== "string") return atFile;
+  return local.find({ id, status, select });
+}
 function redirectFile(location, cacheControl) {
   return new Response(null, {
     status: 307,

package/dist/backend/api/BasicAuth.js

@@ -42,7 +42,11 @@ var BasicAuth = class {
     const [scheme, token] = auth.split(" ", 2);
     if (scheme !== "Basic")
       throw new MissingCredentialsError("Invalid authorization scheme");
-    const [username, password] = atob(token).split(":");
+    const credentials = atob(token);
+    const colon = credentials.indexOf(":");
+    if (colon === -1) throw new InvalidCredentialsError("Invalid credentials");
+    const username = credentials.slice(0, colon);
+    const password = credentials.slice(colon + 1);
     const authorized = await this.#verify(username, password);
     if (!authorized) throw new InvalidCredentialsError("Invalid credentials");
     const user = typeof authorized === "boolean" ? {

package/dist/backend/api/BlobStore.d.ts

@@ -0,0 +1,21 @@
+import type { CommitApi, SyncApi } from 'alinea/core/Connection';
+/**
+ * Content blobs kept where every handler instance finds them, such as the
+ * backend database: an instance that is behind reads what another one
+ * fetched or committed, instead of fetching it from the remote again.
+ */
+export interface BlobStore {
+    /** The stored blobs among `shas`. */
+    readBlobs(shas: ReadonlyArray<string>): Promise<Map<string, Uint8Array>>;
+    /** Keep blobs, found again by their sha. */
+    storeBlobs(blobs: ReadonlyArray<[sha: string, blob: Uint8Array]>): Promise<void>;
+}
+export declare function isBlobStore<T extends object>(value: T): value is T & BlobStore;
+/**
+ * Answer from the store what it has, and fetch the rest from the remote,
+ * storing it. The store only saves requests: when it fails, the remote
+ * answers instead.
+ */
+export declare function storedBlobs(store: BlobStore, getBlobs: SyncApi['getBlobs']): SyncApi['getBlobs'];
+/** Commit through the remote, and store the committed content. */
+export declare function storedWrites(store: BlobStore, write: CommitApi['write']): CommitApi['write'];