alinea 2.0.0-preview.1 → 2.0.0-preview.2

package/dist/core/db/EntryIndex.js

@@ -1840,7 +1840,7 @@ import { IndexEvent } from "./IndexEvent.js";
 function combineConditions(a, b) {
   return {
     search: a.search ?? b.search,
-    nodes: a.nodes ?? b.nodes,
+    nodes: combineNodes(a.nodes, b.nodes),
     node(node) {
       return (a.node ? a.node(node) : true) && (b.node ? b.node(node) : true);
     },
@@ -1852,6 +1852,14 @@ function combineConditions(a, b) {
     }
   };
 }
+function combineNodes(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return matchingNodes(b, new Set(a));
+}
+function* matchingNodes(nodes, included) {
+  for (const node of nodes) if (included.has(node)) yield node;
+}
 var EntryLanguage = class extends Map {
   locale;
   parentDir;
@@ -2082,7 +2090,16 @@ var EntryGraph = class _EntryGraph {
   #filesById = /* @__PURE__ */ new Map();
   #byId = /* @__PURE__ */ new Map();
   #byDir = /* @__PURE__ */ new Map();
-  #childrenByParentId = /* @__PURE__ */ new Map();
+  #nodesBy = {
+    parentId: /* @__PURE__ */ new Map(),
+    url: /* @__PURE__ */ new Map(),
+    workspace: /* @__PURE__ */ new Map(),
+    root: /* @__PURE__ */ new Map(),
+    type: /* @__PURE__ */ new Map(),
+    workspaceRoot: /* @__PURE__ */ new Map(),
+    workspaceRootType: /* @__PURE__ */ new Map()
+  };
+  #nodeOrder = /* @__PURE__ */ new Map();
   nodes;
   #singleWorkspace;
   #search;
@@ -2106,16 +2123,92 @@ var EntryGraph = class _EntryGraph {
       this.#byDir.set(dir, version.id);
     }
     this.nodes = [...this.#filesById.keys()].map((file) => this.#mkNode(file)).sort((a, b) => compareStrings(a.index, b.index));
-    for (const node of this.nodes) {
-      if (!node.parentId) continue;
-      const children = this.#childrenByParentId.get(node.parentId) ?? [];
-      children.push(node);
-      this.#childrenByParentId.set(node.parentId, children);
+    for (const [order, node] of this.nodes.entries()) {
+      this.#nodeOrder.set(node, order);
+      this.#indexNode(node);
     }
   }
   byId(id) {
     return this.#byId.get(id);
   }
+  candidateNodes(query) {
+    const candidates = [];
+    const { ids, parentIds, urls, workspaces, roots, types } = query;
+    if (ids) {
+      const nodes = ids.flatMap((id) => this.byId(id) ?? []);
+      return this.#ordered(nodes).filter((node) => this.#matches(node, query));
+    }
+    if (parentIds)
+      candidates.push(this.#fromIndex(this.#nodesBy.parentId, parentIds));
+    if (urls) candidates.push(this.#fromIndex(this.#nodesBy.url, urls));
+    if (workspaces && roots && types) {
+      const keys2 = workspaces.flatMap(
+        (workspace) => roots.flatMap(
+          (root) => types.map((type) => indexKey(workspace, root, type))
+        )
+      );
+      candidates.push(this.#fromIndex(this.#nodesBy.workspaceRootType, keys2));
+    } else if (workspaces && roots) {
+      const keys2 = workspaces.flatMap(
+        (workspace) => roots.map((root) => indexKey(workspace, root))
+      );
+      candidates.push(this.#fromIndex(this.#nodesBy.workspaceRoot, keys2));
+    } else {
+      if (workspaces)
+        candidates.push(this.#fromIndex(this.#nodesBy.workspace, workspaces));
+      if (roots) candidates.push(this.#fromIndex(this.#nodesBy.root, roots));
+      if (types) candidates.push(this.#fromIndex(this.#nodesBy.type, types));
+    }
+    if (candidates.length === 0) return void 0;
+    candidates.sort((a, b) => a.length - b.length);
+    const [smallest, ...rest] = candidates;
+    const intersection = rest.reduce(
+      (result, nodes) => result.intersection(new Set(nodes)),
+      new Set(smallest)
+    );
+    return Array.from(intersection);
+  }
+  #matches(node, query) {
+    const { parentIds, urls, workspaces, roots, types } = query;
+    if (parentIds && !parentIds.includes(node.parentId)) return false;
+    if (workspaces && !workspaces.includes(node.workspace)) return false;
+    if (roots && !roots.includes(node.root)) return false;
+    if (types && !types.includes(node.type)) return false;
+    if (urls) {
+      const matchesUrl = Array.from(node.values()).some(
+        (language) => urls.includes(language.url)
+      );
+      if (!matchesUrl) return false;
+    }
+    return true;
+  }
+  #indexNode(node) {
+    addToIndex(this.#nodesBy.parentId, node.parentId, node);
+    addToIndex(this.#nodesBy.workspace, node.workspace, node);
+    addToIndex(this.#nodesBy.root, node.root, node);
+    addToIndex(this.#nodesBy.type, node.type, node);
+    addToIndex(
+      this.#nodesBy.workspaceRoot,
+      indexKey(node.workspace, node.root),
+      node
+    );
+    addToIndex(
+      this.#nodesBy.workspaceRootType,
+      indexKey(node.workspace, node.root, node.type),
+      node
+    );
+    const urls = new Set(Array.from(node.values(), (language) => language.url));
+    for (const url of urls) addToIndex(this.#nodesBy.url, url, node);
+  }
+  #fromIndex(index, keys2) {
+    if (keys2.length === 1) return [...index.get(keys2[0]) ?? []];
+    return this.#ordered(keys2.flatMap((key) => index.get(key) ?? []));
+  }
+  #ordered(nodes) {
+    return Array.from(new Set(nodes)).sort(
+      (a, b) => this.#nodeOrder.get(a) - this.#nodeOrder.get(b)
+    );
+  }
   get config() {
     return this.#config;
   }
@@ -2267,13 +2360,21 @@ var EntryGraph = class _EntryGraph {
       this,
       type,
       parent,
-      () => this.#childrenByParentId.get(id) ?? [],
+      () => this.#nodesBy.parentId.get(id) ?? [],
       collection
     );
     this.#byId.set(id, node);
     return node;
   }
 };
+function addToIndex(index, key, node) {
+  const nodes = index.get(key) ?? [];
+  nodes.push(node);
+  index.set(key, nodes);
+}
+function indexKey(...parts) {
+  return JSON.stringify(parts);
+}
 var VersionParser = class extends Map {
   parse(sha, blob) {
     if (super.has(sha)) return super.get(sha);
@@ -2335,7 +2436,7 @@ function changedParentIds(previous, next) {
   }
   return parents;
 }
-var EntryIndex = class extends EventTarget {
+var EntryIndex = class _EntryIndex extends EventTarget {
   tree = ReadonlyTree.EMPTY;
   initialSync;
   graph;
@@ -2352,6 +2453,13 @@ var EntryIndex = class extends EventTarget {
     this.graph = new EntryGraph(config, /* @__PURE__ */ new Map(), this.#seeds);
     this.#singleWorkspace = Config.multipleWorkspaces(config) ? void 0 : keys(config.workspaces)[0];
   }
+  clone() {
+    const clone = new _EntryIndex(this.#config);
+    clone.tree = this.tree;
+    clone.initialSync = this.initialSync;
+    clone.graph = this.graph;
+    return clone;
+  }
   get sha() {
     return this.tree.sha;
   }

package/dist/core/db/EntryResolver.js

@@ -42,6 +42,7 @@ var EntryResolver = class {
   config;
   index;
   #scope;
+  #previewGraphs = /* @__PURE__ */ new WeakMap();
   call(ctx, entry, internal) {
     switch (internal.method) {
       case "snippet": {
@@ -149,9 +150,12 @@ var EntryResolver = class {
       }
       case "children": {
         const depth = query?.depth ?? 1;
+        const self = ctx.graph.byId(entry.id);
         return {
-          entry: (e) => e.filePath.startsWith(entry.childrenDir),
-          node: (node) => node.level > entry.level && node.level <= entry.level + depth
+          nodes: ctx.graph.candidateNodes({
+            ids: descendantIds(self, depth)
+          }),
+          language: (language) => language.locale === entry.locale
         };
       }
       case "parents": {
@@ -221,8 +225,7 @@ var EntryResolver = class {
       if (name.startsWith("_")) return entryFieldValue(entry, name.slice(1));
       return entry.data[name];
     });
-    const multipleIds = typeof query.id === "object" && query.id !== null && query.id.in;
-    const ids = Array.isArray(multipleIds) ? multipleIds : typeof query.id === "string" ? [query.id] : void 0;
+    const ids = equalityValues(query.id);
     return {
       ids,
       condition(entry) {
@@ -248,7 +251,7 @@ var EntryResolver = class {
     const { ids, condition } = this.condition(ctx, edge);
     const filter = {
       search: Array.isArray(search) ? search.join(" ") : search,
-      node: (node) => ids ? ids.includes(node.id) : true,
+      nodes: preFilter?.nodes ? void 0 : this.#candidateNodes(ctx.graph, query, ids),
       entry: condition
     };
     let entries2 = Array.from(
@@ -269,17 +272,33 @@ var EntryResolver = class {
       const orders = Array.isArray(orderBy) ? orderBy : [orderBy];
       entries2.sort((a, b) => {
         for (const order of orders) {
-          const expr = order.asc ?? order.desc;
+          const ascending = order.asc !== void 0;
+          const descending = order.desc !== void 0;
+          assert(
+            ascending !== descending,
+            "orderBy must specify exactly one direction"
+          );
+          const expr = ascending ? order.asc : order.desc;
           const valueA = this.expr(ctx, a, expr);
           const valueB = this.expr(ctx, b, expr);
+          const nullishA = valueA === null || valueA === void 0;
+          const nullishB = valueB === null || valueB === void 0;
+          if (nullishA || nullishB) {
+            if (nullishA !== nullishB) return nullishA ? 1 : -1;
+            continue;
+          }
           const strings = typeof valueA === "string" && typeof valueB === "string";
           const numbers = typeof valueA === "number" && typeof valueB === "number";
+          const booleans = typeof valueA === "boolean" && typeof valueB === "boolean";
           if (strings) {
             const compare = order.caseSensitive ? compareStrings(valueA, valueB) : valueA.localeCompare(valueB, void 0, { numeric: true });
-            if (compare !== 0) return order.asc ? compare : -compare;
+            if (compare !== 0) return ascending ? compare : -compare;
           } else if (numbers) {
             if (valueA !== valueB)
-              return order.asc ? valueA - valueB : valueB - valueA;
+              return ascending ? valueA - valueB : valueB - valueA;
+          } else if (booleans && valueA !== valueB) {
+            const compare = Number(valueA) - Number(valueB);
+            return ascending ? compare : -compare;
           }
         }
         return 0;
@@ -334,6 +353,31 @@ var EntryResolver = class {
       getProcessed
     };
   }
+  #candidateNodes(graph, query, ids) {
+    const location = Array.isArray(query.location) ? query.location : query.location && this.#scope.locationOf(query.location);
+    const indexedLocation = location && location.length >= 1 && location.length <= 3 ? location : void 0;
+    const workspaceQuery = isRecord(query.workspace) && hasWorkspace(query.workspace) ? this.#scope.nameOf(query.workspace) : query.workspace;
+    const rootQuery = isRecord(query.root) && hasRoot(query.root) ? this.#scope.nameOf(query.root) : query.root;
+    const workspaces = intersectValues(
+      equalityValues(workspaceQuery),
+      indexedLocation?.[0] ? [indexedLocation[0]] : void 0
+    );
+    const roots = intersectValues(
+      equalityValues(rootQuery),
+      indexedLocation?.[1] ? [indexedLocation[1]] : void 0
+    );
+    const types = query.type ? (Array.isArray(query.type) ? query.type : [query.type]).map(
+      (type) => this.#scope.nameOf(type)
+    ) : void 0;
+    return graph.candidateNodes({
+      ids,
+      parentIds: equalityValues(query.parentId),
+      urls: equalityValues(query.url),
+      workspaces,
+      roots,
+      types
+    });
+  }
   async postField(ctx, interim, field) {
     return Field.queryValue(field, interim, ctx.linkResolver);
   }
@@ -374,27 +418,7 @@ var EntryResolver = class {
     return interim;
   }
   async resolve(query) {
-    const { preview } = query;
-    const previewEntry = preview && "entry" in preview ? preview.entry : void 0;
-    let graph = this.index.graph;
-    if (previewEntry)
-      graph = graph.withChanges({
-        fromSha: this.index.tree.sha,
-        changes: [
-          {
-            op: "add",
-            path: previewEntry.filePath,
-            sha: previewEntry.fileHash,
-            contents: new TextEncoder().encode(
-              JSON.stringify(
-                createRecord(previewEntry, previewEntry.status),
-                null,
-                2
-              )
-            )
-          }
-        ]
-      });
+    const graph = this.#graphFor(query.preview);
     const ctx = {
       status: query.status ?? "published",
       locale: query.locale,
@@ -403,6 +427,32 @@ var EntryResolver = class {
     };
     return this.query(ctx, query).getProcessed();
   }
+  #graphFor(preview) {
+    const baseGraph = this.index.graph;
+    if (!preview || !("entry" in preview)) return baseGraph;
+    const cached = this.#previewGraphs.get(preview);
+    if (cached?.baseGraph === baseGraph) return cached.previewGraph;
+    const previewEntry = preview.entry;
+    const previewGraph = baseGraph.withChanges({
+      fromSha: this.index.tree.sha,
+      changes: [
+        {
+          op: "add",
+          path: previewEntry.filePath,
+          sha: previewEntry.fileHash,
+          contents: new TextEncoder().encode(
+            JSON.stringify(
+              createRecord(previewEntry, previewEntry.status),
+              null,
+              2
+            )
+          )
+        }
+      ]
+    });
+    this.#previewGraphs.set(preview, { baseGraph, previewGraph });
+    return previewGraph;
+  }
 };
 function statusChecker(status) {
   switch (status) {
@@ -420,6 +470,31 @@ function statusChecker(status) {
       return (entry) => true;
   }
 }
+function descendantIds(node, depth) {
+  if (!node || depth <= 0) return [];
+  const result = [];
+  let level = [node];
+  for (let currentDepth = 1; currentDepth <= depth; currentDepth++) {
+    level = level.flatMap((parent) => Array.from(parent.children()));
+    if (level.length === 0) break;
+    for (const child of level) result.push(child.id);
+  }
+  return result;
+}
+function equalityValues(condition) {
+  if (condition === void 0) return void 0;
+  if (typeof condition !== "object" || condition === null)
+    return [condition];
+  const operations = condition;
+  if (operations.is !== void 0) return [operations.is];
+  if (Array.isArray(operations.in)) return operations.in;
+  return void 0;
+}
+function intersectValues(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return Array.from(new Set(a).intersection(new Set(b)));
+}
 function entryChecker(scope, query) {
   const root = isRecord(query.root) && hasRoot(query.root) ? scope.nameOf(query.root) : query.root;
   const workspace = isRecord(query.workspace) && hasWorkspace(query.workspace) ? scope.nameOf(query.workspace) : query.workspace;

package/dist/core/db/EntryTransaction.d.ts

@@ -20,12 +20,11 @@ export declare class EntryTransaction {
     removeFile(mutation: Op<RemoveFileMutation>): this;
     uploadFile(mutation: Op<UploadFileMutation>): this;
     description(): string;
-    apply(mutations: Array<Mutation>): void;
+    apply(mutations: ReadonlyArray<Mutation>): Promise<void>;
     toRequest(): Promise<{
         fromSha: string;
         intoSha: string;
         description: string;
-        checks: [path: string, sha: string][];
         changes: CommitChange[];
     }>;
 }

package/dist/core/db/EntryTransaction.js

@@ -4,7 +4,6 @@ import "../../chunks/chunk-CQ52GEHY.js";
 import { Config } from "alinea/core/Config";
 import { createRecord } from "alinea/core/EntryRecord";
 import { Field } from "alinea/core/Field";
-import { createId } from "alinea/core/Id";
 import { getRoot } from "alinea/core/Internal";
 import { ListRow } from "alinea/core/ListRow";
 import { Type } from "alinea/core/Type";
@@ -22,13 +21,13 @@ import { slugify } from "alinea/core/util/Slugs";
 import { unreachable } from "alinea/core/util/Types";
 import { Permission, Policy } from "../Role.js";
 import { ShaMismatchError } from "../source/ShaMismatchError.js";
+import { OverlaySource } from "../source/OverlaySource.js";
 import { SourceTransaction } from "../source/Source.js";
 import { assert } from "../util/Assert.js";
 import { commitChanges } from "./CommitRequest.js";
 import { aliasesFromData, aliasUrl } from "./EntryAliases.js";
 import { EntryUrlConflictError } from "./EntryUrlConflictError.js";
 var EntryTransaction = class {
-  #checks = [];
   #messages = [];
   #config;
   #index;
@@ -36,12 +35,16 @@ var EntryTransaction = class {
   #fileChanges = [];
   #policy;
   #urlClaims;
+  #workingSource;
+  #workingTree;
   constructor(config, index, source, from, policy = Policy.ALLOW_ALL) {
     if (index.sha !== from.sha) throw new ShaMismatchError(index.sha, from.sha);
     this.#config = config;
-    this.#index = index;
+    this.#index = index.clone();
     this.#tx = new SourceTransaction(source, from);
     this.#policy = policy;
+    this.#workingSource = new OverlaySource(source, from);
+    this.#workingTree = from;
   }
   get empty() {
     return this.#messages.length === 0;
@@ -54,11 +57,12 @@ var EntryTransaction = class {
     workspace,
     fromSeed,
     parentId = null,
-    id = createId(),
+    id,
     insertOrder = "last",
     status = "published",
     overwrite = false
   }) {
+    assert(id, "Create mutation is missing an id");
     const config = this.#config;
     const index = this.#index;
     const existing = index.byId(id);
@@ -103,7 +107,6 @@ var EntryTransaction = class {
         return entry.id === parentId && entry.locale === locale && entry.main;
       });
       assert(parent, `Parent not found: ${parentId}`);
-      this.#checks.push([parent.filePath, parent.fileHash]);
       this.#policy.assert(Permission.Create, parent);
     }
     const siblings = Array.from(
@@ -259,7 +262,6 @@ var EntryTransaction = class {
       workspace: entry.workspace,
       locale
     });
-    this.#checks.push([entry.filePath, entry.fileHash]);
     const childrenDir = paths.join(entry.parentDir, path);
     const filePath = `${childrenDir}${entry.status === "published" ? "" : `.${entry.status}`}.json`;
     if (entry.status === "published") {
@@ -407,7 +409,6 @@ var EntryTransaction = class {
         return entry.id === id && entry.locale !== locale;
       });
       for (const translation of translations) {
-        this.#checks.push([translation.filePath, translation.fileHash]);
         const record = createRecord(
           {
             id,
@@ -541,7 +542,6 @@ var EntryTransaction = class {
       for (const [_, version] of versions) {
         this.#tx.remove(version.filePath);
       }
-    this.#checks.push([entry.filePath, entry.fileHash]);
     this.#tx.remove(entry.filePath);
     const record = createRecord({ ...entry, path, data }, "published");
     const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
@@ -563,7 +563,6 @@ var EntryTransaction = class {
       if (version === mainEntry) continue;
       this.#tx.remove(version.filePath);
     }
-    this.#checks.push([mainEntry.filePath, mainEntry.fileHash]);
     this.#tx.rename(mainEntry.filePath, `${mainEntry.childrenDir}.draft.json`);
     this.#messages.push(this.#reportOp("unpublish", mainEntry.title));
     return this;
@@ -578,7 +577,6 @@ var EntryTransaction = class {
       if (version === mainEntry) continue;
       this.#tx.remove(version.filePath);
     }
-    this.#checks.push([mainEntry.filePath, mainEntry.fileHash]);
     this.#tx.rename(
       mainEntry.filePath,
       `${mainEntry.childrenDir}.archived.json`
@@ -753,7 +751,6 @@ var EntryTransaction = class {
       if (entry.status === "published")
         assert(!entry.seeded, `Cannot remove seeded entry ${entry.filePath}`);
       info = entry;
-      this.#checks.push([entry.filePath, entry.fileHash]);
       this.#tx.remove(entry.filePath);
       if (entry.status !== "draft") {
         this.#tx.remove(entry.childrenDir);
@@ -810,7 +807,7 @@ var EntryTransaction = class {
   #reportOp(op, title) {
     return `(${op}) ${title}`;
   }
-  apply(mutations) {
+  async apply(mutations) {
     for (const mutation of mutations) {
       switch (mutation.op) {
         case "create":
@@ -843,15 +840,30 @@ var EntryTransaction = class {
         default:
           unreachable(mutation);
       }
+      await this.#flush();
     }
   }
+  async #flush() {
+    const { from, into, changes } = await this.#tx.compile(this.#workingTree);
+    const batch = {
+      fromSha: from.sha,
+      changes
+    };
+    if (batch.changes.length > 0) {
+      await Promise.all([
+        this.#workingSource.applyChanges(batch),
+        this.#index.indexChanges(batch, into)
+      ]);
+    }
+    this.#workingTree = into;
+    this.#urlClaims = void 0;
+  }
   async toRequest() {
     const { from, into, changes } = await this.#tx.compile();
     return {
       fromSha: from.sha,
       intoSha: into.sha,
       description: this.description(),
-      checks: this.#checks,
       changes: this.#fileChanges.concat(commitChanges(changes))
     };
   }

package/dist/core/db/LocalDB.d.ts

@@ -15,7 +15,7 @@ export declare class LocalDB extends WriteableGraph {
     config: Config;
     index: EntryIndex;
     source: Source;
-    constructor(config: Config, source?: Source);
+    constructor(config: Config, source?: Source, index?: EntryIndex);
     resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
     referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
     get sha(): string;
@@ -26,11 +26,10 @@ export declare class LocalDB extends WriteableGraph {
     sync(): Promise<string>;
     syncWith(remote: SyncApi): Promise<string>;
     logEntries(): Promise<void>;
-    request(mutations: Array<Mutation>, policy?: Policy): Promise<{
+    request(mutations: ReadonlyArray<Mutation>, policy?: Policy): Promise<{
         fromSha: string;
         intoSha: string;
         description: string;
-        checks: [path: string, sha: string][];
         changes: import("./CommitRequest.js").CommitChange[];
     }>;
     mutate(mutations: Array<Mutation>): Promise<{

package/dist/core/db/LocalDB.js

@@ -4,6 +4,7 @@ import {
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/db/LocalDB.ts
+import { trace } from "alinea/core/Trace";
 import { Entry } from "../Entry.js";
 import { MemorySource } from "../source/MemorySource.js";
 import { diff } from "../source/Source.js";
@@ -14,10 +15,9 @@ import { EntryTransaction } from "./EntryTransaction.js";
 import { WriteableGraph } from "./WriteableGraph.js";
 var limit = pLimit(1);
 var LocalDB = class extends WriteableGraph {
-  constructor(config, source = new MemorySource()) {
+  constructor(config, source = new MemorySource(), index = new EntryIndex(config)) {
     super();
     this.config = config;
-    const index = new EntryIndex(config);
     const resolver = new EntryResolver(config, index);
     this.#resolver = resolver;
     this.index = index;
@@ -28,7 +28,8 @@ var LocalDB = class extends WriteableGraph {
   source;
   #resolver;
   resolve(query) {
-    return this.#resolver.resolve(query);
+    const span = trace(this.config, "alinea.local_db.resolve");
+    return span(() => this.#resolver.resolve(query));
   }
   referencesTo(query) {
     return this.index.referencesTo(query);
@@ -49,23 +50,27 @@ var LocalDB = class extends WriteableGraph {
     return this.source.getBlobs(shas, options);
   }
   async sync() {
-    return this.index.sync(this.source);
+    const span = trace(this.config, "alinea.local_db.sync");
+    return span(() => this.index.sync(this.source));
   }
   syncWith(remote) {
-    return limit(async () => {
-      const batch = await diff(this.source, remote);
-      const canIndexChanges = this.index.sha === batch.fromSha;
-      if (batch.changes.length > 0)
-        await Promise.all([
-          this.source.applyChanges(batch),
-          canIndexChanges ? this.index.indexChanges(batch) : void 0
-        ]);
-      if (canIndexChanges) {
-        await this.index.seed(this.source);
-        return this.index.sha;
-      }
-      return this.sync();
-    });
+    const span = trace(this.config, "alinea.local_db.sync_with");
+    return span(
+      () => limit(async () => {
+        const batch = await diff(this.source, remote);
+        const canIndexChanges = this.index.sha === batch.fromSha;
+        if (batch.changes.length > 0)
+          await Promise.all([
+            this.source.applyChanges(batch),
+            canIndexChanges ? this.index.indexChanges(batch) : void 0
+          ]);
+        if (canIndexChanges) {
+          await this.index.seed(this.source);
+          return this.index.sha;
+        }
+        return this.sync();
+      })
+    );
   }
   async logEntries() {
     const entries = await this.find({
@@ -99,7 +104,7 @@ var LocalDB = class extends WriteableGraph {
       from,
       policy
     );
-    tx.apply(mutations);
+    await tx.apply(mutations);
     return tx.toRequest();
   }
   async mutate(mutations) {