alinea 1.7.0 → 2.0.0-preview.1

package/dist/core/db/EntryTransaction.js

@@ -1,17 +1,22 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/db/EntryTransaction.ts
 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, getWorkspace } from "alinea/core/Internal";
+import { getRoot } from "alinea/core/Internal";
+import { ListRow } from "alinea/core/ListRow";
 import { Type } from "alinea/core/Type";
-import { pathSuffix } from "alinea/core/util/EntryFilenames";
+import { ListEditor } from "alinea/core/field/ListField";
+import { MediaLocation } from "alinea/core/media/MediaLocation";
+import { entryUrl, pathSuffix } from "alinea/core/util/EntryFilenames";
 import {
   generateKeyBetween,
-  generateNKeysBetween
+  generateNKeysBetween,
+  isValidOrderKey
 } from "alinea/core/util/FractionalIndexing";
-import { entries, fromEntries, keys } from "alinea/core/util/Objects";
+import { entries, fromEntries, isRecord, keys } from "alinea/core/util/Objects";
 import * as paths from "alinea/core/util/Paths";
 import { slugify } from "alinea/core/util/Slugs";
 import { unreachable } from "alinea/core/util/Types";
@@ -20,6 +25,8 @@ import { ShaMismatchError } from "../source/ShaMismatchError.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 = [];
@@ -28,6 +35,7 @@ var EntryTransaction = class {
   #tx;
   #fileChanges = [];
   #policy;
+  #urlClaims;
   constructor(config, index, source, from, policy = Policy.ALLOW_ALL) {
     if (index.sha !== from.sha) throw new ShaMismatchError(index.sha, from.sha);
     this.#config = config;
@@ -129,8 +137,9 @@ var EntryTransaction = class {
       const prevLocation = prev.data.location;
       if (prevLocation !== data.location)
         this.removeFile({
-          location: paths.join(
-            getWorkspace(this.#config.workspaces[prev.workspace]).mediaDir,
+          location: MediaLocation.storagePath(
+            this.#config,
+            prev.workspace,
             prev.data.location
           )
         });
@@ -171,7 +180,24 @@ var EntryTransaction = class {
         const shared = Type.sharedData(typeInstance, from.data);
         data = { ...shared, ...data };
       }
-      this.#persistSharedFields(id, locale, type, data);
+    }
+    if (status === "published") {
+      const urlCandidate = {
+        id,
+        type,
+        path,
+        parentId,
+        workspace,
+        root,
+        locale,
+        data
+      };
+      data = this.#dataWithPreviousUrlAlias(
+        urlCandidate,
+        this.#publishedEntry(id, locale)
+      );
+      if (locale !== null) this.#persistSharedFields(id, locale, type, data);
+      this.#assertUniqueUrls({ ...urlCandidate, data });
     }
     const seeds = existing?.get(locale);
     const seeded = fromSeed ?? seeds?.seeded ?? null;
@@ -220,21 +246,7 @@ var EntryTransaction = class {
         return [key, value ?? null];
       })
     );
-    const data = { ...entry.data, ...fieldUpdates };
-    if (locale !== null && status === "published") {
-      this.#persistSharedFields(id, locale, entry.type, data);
-    }
-    const record = createRecord(
-      {
-        id,
-        type: entry.type,
-        index: entry.index,
-        path: entry.path,
-        seeded: entry.seeded,
-        data
-      },
-      status
-    );
+    let data = { ...entry.data, ...fieldUpdates };
     const desiredPath = slugify(
       data.path ?? entry.data.path ?? entry.path
     );
@@ -253,9 +265,33 @@ var EntryTransaction = class {
     if (entry.status === "published") {
       this.#policy.assert(Permission.Publish, entry);
       if (filePath !== entry.filePath) this.#rename(id, locale, path);
-    } else {
-      if (path !== entry.path) record.path = path;
+      const urlCandidate = {
+        id,
+        type: entry.type,
+        path,
+        parentId: entry.parentId,
+        root: entry.root,
+        workspace: entry.workspace,
+        locale,
+        data
+      };
+      data = this.#dataWithPreviousUrlAlias(urlCandidate, entry);
+      if (locale !== null)
+        this.#persistSharedFields(id, locale, entry.type, data);
+      this.#assertUniqueUrls({ ...urlCandidate, data });
     }
+    const record = createRecord(
+      {
+        id,
+        type: entry.type,
+        index: entry.index,
+        path: entry.path,
+        seeded: entry.seeded,
+        data
+      },
+      status
+    );
+    if (entry.status !== "published" && path !== entry.path) record.path = path;
     const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
     this.#tx.add(filePath, contents);
     this.#messages.push(this.#reportOp("update", entry.title));
@@ -271,6 +307,96 @@ var EntryTransaction = class {
     if (suffix !== void 0) return `${target.path}-${suffix}`;
     return target.path;
   }
+  #assertUniqueUrls(candidate) {
+    const claims = this.#getUrlClaims();
+    const urls = this.#candidateUrls(candidate);
+    for (const url of urls) {
+      const key = this.#urlClaimKey(candidate.workspace, candidate.root, url);
+      const existing = claims.get(key);
+      if (existing && existing.id !== candidate.id) {
+        throw new EntryUrlConflictError({
+          url,
+          entryId: existing.id,
+          workspace: candidate.workspace,
+          root: candidate.root
+        });
+      }
+    }
+    for (const [key, claim] of claims) {
+      if (claim.id === candidate.id) claims.delete(key);
+    }
+    for (const url of urls) {
+      claims.set(this.#urlClaimKey(candidate.workspace, candidate.root, url), {
+        id: candidate.id,
+        url
+      });
+    }
+  }
+  #candidateUrls(candidate) {
+    return [this.#resolvedUrl(candidate), ...aliasUrlsFromData(candidate.data)];
+  }
+  #resolvedUrl(candidate) {
+    const type = this.#config.schema[candidate.type];
+    assert(type, `Type not found: ${candidate.type}`);
+    if (candidate.url !== void 0) return candidate.url;
+    return entryUrl(type, {
+      config: this.#config,
+      path: candidate.path,
+      parentPaths: candidate.parentPaths ?? this.#parentPaths(candidate.parentId, candidate.locale),
+      locale: candidate.locale,
+      status: "published",
+      workspace: candidate.workspace,
+      root: candidate.root,
+      data: candidate.data
+    });
+  }
+  #dataWithPreviousUrlAlias(candidate, previousEntry) {
+    if (!previousEntry) return candidate.data;
+    const previousUrl = this.#resolvedUrl(previousEntry);
+    const currentUrl = this.#resolvedUrl(candidate);
+    if (previousUrl === currentUrl) return candidate.data;
+    const type = this.#config.schema[candidate.type];
+    assert(type, `Type not found: ${candidate.type}`);
+    return dataWithUrlAlias(type, candidate.data, previousUrl, currentUrl);
+  }
+  #publishedEntry(id, locale) {
+    return this.#index.findFirst((entry) => {
+      return entry.id === id && entry.locale === locale && entry.status === "published";
+    });
+  }
+  #parentPaths(parentId, locale) {
+    const result = Array();
+    let current = parentId ? this.#index.byId(parentId) : void 0;
+    while (current) {
+      const language = current.get(locale);
+      assert(language, `Missing parent language node`);
+      result.unshift(language.main.path);
+      current = current.parent ?? void 0;
+    }
+    return result;
+  }
+  #getUrlClaims() {
+    if (this.#urlClaims) return this.#urlClaims;
+    const claims = /* @__PURE__ */ new Map();
+    for (const entry of this.#index.findMany((entry2) => {
+      return entry2.status === "published";
+    })) {
+      for (const url of [
+        this.#resolvedUrl(entry),
+        ...aliasUrlsFromData(entry.data)
+      ]) {
+        claims.set(this.#urlClaimKey(entry.workspace, entry.root, url), {
+          id: entry.id,
+          url
+        });
+      }
+    }
+    this.#urlClaims = claims;
+    return claims;
+  }
+  #urlClaimKey(workspace, root, url) {
+    return `${workspace}\0${root}\0${url}`;
+  }
   #persistSharedFields(id, locale, type, data) {
     const index = this.#index;
     const typeInstance = this.#config.schema[type];
@@ -303,6 +429,77 @@ var EntryTransaction = class {
       }
     }
   }
+  #moveUrlAliasUpdates(target) {
+    const updates = Array();
+    for (const entry of this.#index.findMany((entry2) => {
+      return entry2.status === "published" && (entry2.id === target.id || entry2.parents.includes(target.id));
+    })) {
+      const parentPaths = this.#movedParentPaths(entry, target);
+      const candidate = {
+        id: entry.id,
+        type: entry.type,
+        path: entry.path,
+        parentId: entry.id === target.id ? target.parentId : entry.parentId,
+        parentPaths,
+        workspace: target.workspace,
+        root: target.root,
+        locale: entry.locale,
+        data: entry.data
+      };
+      const data = this.#dataWithPreviousUrlAlias(candidate, entry);
+      this.#assertUniqueUrls({ ...candidate, data });
+      updates.push({
+        entry,
+        data,
+        filePath: this.#movedFilePath(entry, target)
+      });
+    }
+    return updates;
+  }
+  #movedParentPaths(entry, target) {
+    const moved = this.#index.byId(target.id);
+    assert(moved, `Entry not found: ${target.id}`);
+    const movedLanguage = moved.get(entry.locale);
+    assert(movedLanguage, `Missing moved entry language node`);
+    const newParentPaths = this.#parentPaths(target.parentId, entry.locale);
+    if (entry.id === target.id) return newParentPaths;
+    const currentParentPaths = this.#parentPaths(entry.parentId, entry.locale);
+    const oldPrefix = this.#parentPaths(moved.parentId, entry.locale).concat(
+      movedLanguage.main.path
+    );
+    const newPrefix = newParentPaths.concat(movedLanguage.main.path);
+    assert(
+      startsWithSegments(currentParentPaths, oldPrefix),
+      `Moved child is outside moved entry path`
+    );
+    return newPrefix.concat(currentParentPaths.slice(oldPrefix.length));
+  }
+  #movedFilePath(entry, target) {
+    const moved = this.#index.byId(target.id);
+    assert(moved, `Entry not found: ${target.id}`);
+    const movedLanguage = moved.get(entry.locale);
+    assert(movedLanguage, `Missing moved entry language node`);
+    const parent = target.parentId ? this.#index.findFirst((parentEntry) => {
+      return parentEntry.id === target.parentId && parentEntry.locale === entry.locale;
+    }) : void 0;
+    const parentDir = parent ? parent.childrenDir : Config.filePath(
+      this.#config,
+      target.workspace,
+      target.root,
+      entry.locale
+    );
+    const nextPrefix = paths.join(parentDir, movedLanguage.main.path);
+    if (entry.id === target.id) {
+      return `${nextPrefix}${entry.status === "published" ? "" : `.${entry.status}`}.json`;
+    }
+    const previousPrefix = movedLanguage.main.childrenDir;
+    assert(
+      entry.filePath === previousPrefix || entry.filePath.startsWith(`${previousPrefix}/`),
+      `Moved child file is outside moved entry directory`
+    );
+    const suffix = entry.filePath.slice(previousPrefix.length).replace(/^\//, "");
+    return paths.join(nextPrefix, suffix);
+  }
   publish({ id, locale, status }) {
     const index = this.#index;
     const entry = index.findFirst((entry2) => {
@@ -312,6 +509,7 @@ var EntryTransaction = class {
     this.#policy.assert(Permission.Publish, entry);
     const pathChange = entry.data.path && entry.data.path !== entry.path;
     let path = slugify(entry.data.path ?? entry.path);
+    let data = entry.data;
     path = this.#getAvailablePath({
       id,
       path,
@@ -321,8 +519,23 @@ var EntryTransaction = class {
       locale
     });
     const childrenDir = paths.join(entry.parentDir, path);
+    const urlCandidate = {
+      id,
+      type: entry.type,
+      path,
+      parentId: entry.parentId,
+      root: entry.root,
+      workspace: entry.workspace,
+      locale,
+      data
+    };
+    data = this.#dataWithPreviousUrlAlias(
+      urlCandidate,
+      this.#publishedEntry(id, locale)
+    );
     if (entry.locale !== null)
-      this.#persistSharedFields(id, entry.locale, entry.type, entry.data);
+      this.#persistSharedFields(id, entry.locale, entry.type, data);
+    this.#assertUniqueUrls({ ...urlCandidate, data });
     const versions = index.byId(id)?.get(locale);
     if (versions)
       for (const [_, version] of versions) {
@@ -330,7 +543,7 @@ var EntryTransaction = class {
       }
     this.#checks.push([entry.filePath, entry.fileHash]);
     this.#tx.remove(entry.filePath);
-    const record = createRecord({ ...entry, path }, "published");
+    const record = createRecord({ ...entry, path, data }, "published");
     const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
     if (pathChange) {
       this.#tx.remove(`${entry.parentDir}/${entry.path}.json`);
@@ -373,29 +586,45 @@ var EntryTransaction = class {
     this.#messages.push(this.#reportOp("archive", mainEntry.title));
     return this;
   }
-  move({ id, after, toParent, toRoot }) {
+  move({ id, target, dropPosition, targetType }) {
     const index = this.#index;
+    targetType ??= "entry";
     const entries2 = Array.from(index.findMany((entry) => entry.id === id));
     assert(entries2.length > 0, `Entry not found: ${id}`);
-    const action = toParent || toRoot ? Permission.Move : Permission.Reorder;
+    const targetEntry = targetType === "root" ? void 0 : index.findFirst((entry) => {
+      return entry.id === target;
+    });
+    assert(targetType === "root" || targetEntry, `Target not found: ${target}`);
+    assert(
+      targetType === "entry" || dropPosition === "on",
+      `Cannot move ${dropPosition} root ${target}`
+    );
+    const parentId = targetType === "root" ? null : dropPosition === "on" ? target : targetEntry?.parentId ?? null;
+    const root = targetType === "root" ? target : targetEntry?.root ?? entries2[0].root;
+    const workspace = targetEntry?.workspace ?? entries2[0].workspace;
+    const action = parentId !== entries2[0].parentId || root !== entries2[0].root ? Permission.Move : Permission.Reorder;
     for (const entry of entries2) this.#policy.assert(action, entry);
-    const parentId = toRoot ? null : toParent ?? entries2[0].parentId;
-    const root = toRoot ?? entries2[0].root;
-    const workspace = entries2[0].workspace;
-    if (toRoot) this.#policy.assert(Permission.Move, { workspace, root });
-    const siblings = new Map(
-      Array.from(
-        index.findMany((entry) => {
-          return entry.workspace === workspace && entry.root === root && entry.parentId === parentId && entry.id !== id;
-        })
-      ).map((entry) => [entry.id, entry])
+    if (action === Permission.Move && parentId === null) {
+      this.#policy.assert(Permission.Move, { workspace, root });
+    }
+    const siblingList = Array.from(
+      index.findMany((entry) => {
+        return entry.workspace === workspace && entry.root === root && entry.parentId === parentId && entry.id !== id;
+      })
     );
-    if (after) assert(siblings.has(after), `Sibling not found: ${after}`);
-    const siblingList = Array.from(siblings.values());
-    const previousIndex = after ? siblingList.findIndex((entry) => entry.id === after) : -1;
-    const nextIndex = previousIndex + 1;
-    const previous = siblingList[previousIndex] ?? null;
-    const next = siblingList[nextIndex] ?? null;
+    let insertIndex = siblingList.length;
+    if (targetType !== "root") {
+      const targetIndex = siblingList.findIndex((entry) => entry.id === target);
+      if (dropPosition === "before") {
+        assert(targetIndex >= 0, `Sibling not found: ${target}`);
+        insertIndex = targetIndex;
+      } else if (dropPosition === "after") {
+        assert(targetIndex >= 0, `Sibling not found: ${target}`);
+        insertIndex = targetIndex + 1;
+      }
+    }
+    const previous = siblingList[insertIndex - 1] ?? null;
+    const next = siblingList[insertIndex] ?? null;
     const seen = /* @__PURE__ */ new Set();
     const hasDuplicates = siblingList.some((entry) => {
       const wasSeen = seen.has(entry.index);
@@ -407,7 +636,7 @@ var EntryTransaction = class {
     if (hasDuplicates) {
       const self = index.findFirst((entry) => entry.id === id);
       assert(self, `Entry not found: ${id}`);
-      siblingList.splice(previousIndex + 1, 0, self);
+      siblingList.splice(insertIndex, 0, self);
       for (const sibling of siblingList) {
         this.#policy.assert(Permission.Reorder, sibling);
       }
@@ -436,20 +665,24 @@ var EntryTransaction = class {
           }
         }
       }
-      newIndex = newKeys[previousIndex + 1];
+      newIndex = newKeys[insertIndex];
     } else {
       newIndex = generateKeyBetween(
         previous?.index ?? null,
         next?.index ?? null
       );
     }
+    const moveUrlAliasUpdates = action === Permission.Move ? this.#moveUrlAliasUpdates({ id, parentId, workspace, root }) : [];
+    const moveUrlAliasData = new Map(
+      moveUrlAliasUpdates.map((update) => [update.entry.filePath, update.data])
+    );
     let info;
     for (const entry of entries2) {
       info = entry;
       const parent = parentId ? index.findFirst((e) => {
         return e.id === parentId && e.locale === entry.locale;
       }) : void 0;
-      if (toParent) {
+      if (action === Permission.Move && parentId) {
         assert(!entry.seeded, `Cannot move seeded entry ${entry.filePath}`);
         assert(parent, `Parent not found: ${parentId}`);
         this.#policy.assert(Permission.Move, parent);
@@ -468,6 +701,7 @@ var EntryTransaction = class {
       const parentDir = parent ? parent.childrenDir : Config.filePath(this.#config, workspace, root, entry.locale);
       const childrenDir = paths.join(parentDir, entry.path);
       const filePath = `${childrenDir}${entry.status === "published" ? "" : `.${entry.status}`}.json`;
+      const data = moveUrlAliasData.get(entry.filePath) ?? entry.data;
       const record = createRecord(
         {
           id,
@@ -475,17 +709,35 @@ var EntryTransaction = class {
           index: newIndex,
           path: entry.path,
           seeded: entry.seeded,
-          data: entry.data
+          root,
+          workspace,
+          parentId,
+          data
         },
         entry.status
       );
       const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
-      if (toParent || toRoot) {
+      if (action === Permission.Move) {
         this.#tx.remove(entry.filePath);
         this.#tx.rename(entry.childrenDir, childrenDir);
       }
       this.#tx.add(filePath, contents);
     }
+    for (const update of moveUrlAliasUpdates) {
+      const entry = update.entry;
+      if (entry.id === id || update.data === entry.data) continue;
+      const record = createRecord(
+        {
+          ...entry,
+          root,
+          workspace,
+          data: update.data
+        },
+        entry.status
+      );
+      const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
+      this.#tx.add(update.filePath, contents);
+    }
     this.#messages.push(this.#reportOp("move", info.title));
     return this;
   }
@@ -507,23 +759,24 @@ var EntryTransaction = class {
         this.#tx.remove(entry.childrenDir);
       }
       if (entry.type === "MediaLibrary") {
-        const workspace = this.#config.workspaces[entry.workspace];
-        const mediaDir = getWorkspace(workspace).mediaDir;
         const files = index.findMany((f) => {
           return f.workspace === entry.workspace && f.root === entry.root && f.filePath.startsWith(entry.childrenDir) && f.type === "MediaFile";
         });
         for (const file of files) {
           this.removeFile({
-            location: paths.join(mediaDir, file.data.location)
+            location: MediaLocation.storagePath(
+              this.#config,
+              entry.workspace,
+              file.data.location
+            )
           });
         }
       }
       if (entry.type === "MediaFile") {
-        const workspace = this.#config.workspaces[entry.workspace];
-        const mediaDir = getWorkspace(workspace).mediaDir;
         this.removeFile({
-          location: paths.join(
-            mediaDir,
+          location: MediaLocation.storagePath(
+            this.#config,
+            entry.workspace,
             entry.data.location
           )
         });
@@ -603,6 +856,86 @@ var EntryTransaction = class {
     };
   }
 };
+function aliasUrlsFromData(data) {
+  const result = /* @__PURE__ */ new Set();
+  for (const alias of aliasesFromData(data) ?? []) {
+    const url = aliasUrl(alias);
+    if (url) result.add(url);
+  }
+  return Array.from(result);
+}
+function dataWithUrlAlias(type, data, previousUrl, currentUrl) {
+  const target = typeAliasTarget(type);
+  if (!target) return data;
+  const aliasUrls = aliasUrlsFromData(data);
+  if (aliasUrls.includes(previousUrl)) return data;
+  const nextData = aliasUrls.includes(currentUrl) ? dataWithoutUrlAlias(data, currentUrl) : data;
+  const metadata = isRecord(nextData.metadata) ? nextData.metadata : {};
+  const aliases = target === "metadata" ? Array.isArray(metadata.aliases) ? metadata.aliases : [] : Array.isArray(nextData.aliases) ? nextData.aliases : [];
+  return dataWithAliases(
+    nextData,
+    target,
+    metadata,
+    aliases.concat(createUrlAliasRow(previousUrl, aliases))
+  );
+}
+function dataWithoutUrlAlias(data, url) {
+  let result = data;
+  if (Array.isArray(data.aliases)) {
+    result = {
+      ...result,
+      aliases: data.aliases.filter((alias) => aliasUrl(alias) !== url)
+    };
+  }
+  const metadata = data.metadata;
+  if (isRecord(metadata) && Array.isArray(metadata.aliases)) {
+    result = {
+      ...result,
+      metadata: {
+        ...metadata,
+        aliases: metadata.aliases.filter((alias) => aliasUrl(alias) !== url)
+      }
+    };
+  }
+  return result;
+}
+function dataWithAliases(data, target, metadata, aliases) {
+  if (target === "aliases") return { ...data, aliases };
+  return {
+    ...data,
+    metadata: {
+      ...metadata,
+      aliases
+    }
+  };
+}
+function typeAliasTarget(type) {
+  if (Type.field(type, "aliases")) return "aliases";
+  const metadata = Type.field(type, "metadata");
+  if (!metadata) return void 0;
+  const options = Field.options(metadata);
+  const fields = options.fields;
+  if (!Type.isType(fields)) return void 0;
+  return Type.field(fields, "aliases") ? "metadata" : void 0;
+}
+function createUrlAliasRow(url, aliases) {
+  const orderedAliases = aliases.filter(isOrderedUrlAliasRow);
+  const editor = new ListEditor(orderedAliases);
+  const created = editor.add("alias", { url }).value().at(-1);
+  assert(created);
+  return created;
+}
+function isOrderedUrlAliasRow(value) {
+  if (!isRecord(value)) return false;
+  const id = value[ListRow.id];
+  const index = value[ListRow.index];
+  const type = value[ListRow.type];
+  const url = value.url;
+  return typeof id === "string" && typeof index === "string" && isValidOrderKey(index) && type === "alias" && typeof url === "string";
+}
+function startsWithSegments(value, prefix) {
+  return prefix.every((segment, index) => value[index] === segment);
+}
 export {
   EntryTransaction
 };

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

@@ -0,0 +1,11 @@
+export interface EntryUrlConflictErrorInfo {
+    url: string;
+    entryId: string;
+    workspace: string;
+    root: string;
+}
+export declare class EntryUrlConflictError extends Error {
+    info: EntryUrlConflictErrorInfo;
+    name: string;
+    constructor(info: EntryUrlConflictErrorInfo);
+}

package/dist/core/db/EntryUrlConflictError.js

@@ -0,0 +1,16 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/core/db/EntryUrlConflictError.ts
+var EntryUrlConflictError = class extends Error {
+  constructor(info) {
+    super(
+      `URL "${info.url}" is already defined by entry ${info.entryId}. Remove or change this URL alias before publishing.`
+    );
+    this.info = info;
+  }
+  info;
+  name = "EntryUrlConflictError";
+};
+export {
+  EntryUrlConflictError
+};

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

@@ -6,9 +6,12 @@ export declare class IndexEvent extends Event {
 export type IndexOp = {
     op: 'index';
     sha: string;
+    ids: Array<string>;
 } | {
-    op: 'entry';
-    id: string;
+    op: 'references';
+    scanned: number;
+    total: number;
+    complete: boolean;
 } | {
     op: 'mutate';
     id: string;

package/dist/core/db/IndexEvent.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/db/IndexEvent.ts
 var IndexEvent = class _IndexEvent extends Event {
@@ -6,6 +6,7 @@ var IndexEvent = class _IndexEvent extends Event {
     super(_IndexEvent.type);
     this.data = data;
   }
+  data;
   static type = "index";
 };
 export {

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

@@ -3,7 +3,7 @@ import type { EntryResolver, ResolveContext } from './EntryResolver.js';
 export declare class LinkResolver {
     resolver: EntryResolver;
     private ctx;
-    private locale;
+    locale: string | null;
     constructor(resolver: EntryResolver, ctx: ResolveContext, locale: string | null);
     includedAtBuild(filePath: string): boolean;
     resolveLinks<P extends Projection>(projection: P, entryIds: ReadonlyArray<string>): Promise<Array<InferProjection<P>>>;