@gmickel/gno 2.7.1 → 2.8.1

package/src/store/sqlite/workspace-link-resolver.ts

@@ -0,0 +1,742 @@
+/**
+ * Workspace-wide wiki link resolution (Obsidian semantics) for plain
+ * `[[Target]]` links whose source document belongs to a link workspace.
+ *
+ * One ranking function serves both candidate strategies: a SQL basename
+ * prefilter for small target sets and a bulk load of every workspace member
+ * for large ones. Both feed identical rows into the same in-memory index, so
+ * results never depend on the strategy or on insertion order.
+ *
+ * Document-side case folding mirrors SQLite `lower()` (ASCII only), the
+ * documented caveat shared with collection-scoped resolution.
+ *
+ * @module src/store/sqlite/workspace-link-resolver
+ */
+
+import type { Database } from "bun:sqlite";
+
+// node:path/posix: POSIX path algebra for workspace-relative paths; no Bun equivalent.
+import { posix as pathPosix } from "node:path";
+
+import type {
+  CollectionWorkspaceMembership,
+  LinkWorkspaceSource,
+} from "../../core/link-workspace";
+
+import { placeDocument } from "../../core/link-workspace";
+import { stripWikiMdExt } from "../../core/links";
+
+/** Why a workspace link resolved to its target. */
+export type WorkspaceResolutionReason =
+  /** Exact path relative to the workspace root. */
+  | "workspace-path"
+  /** Exact path relative to the source's own collection root. */
+  | "collection-path"
+  /** The only file (or path suffix) with that name in the workspace. */
+  | "exact-name"
+  /** Won over other same-named files by folder or depth tie-break. */
+  | "tie-break"
+  /** No file matched; frontmatter title inside the source collection. */
+  | "title";
+
+export interface WorkspaceCandidate {
+  id: number;
+  docid: string;
+  collection: string;
+  /** Workspace-relative path (NFC, original case). */
+  path: string;
+}
+
+export interface WorkspaceLinkSource {
+  collection: string;
+  relPath: string;
+}
+
+export interface WorkspaceTargetResolution {
+  target: WorkspaceCandidate;
+  reason: WorkspaceResolutionReason;
+  /** False when candidates stay tied: audit-only, never a graph edge. */
+  traversable: boolean;
+  /** Distinct equally ranked candidates (length > 1 only when tied). */
+  tied: WorkspaceCandidate[];
+  /** Legacy-compatible rank for title fallback confidence (1-4), else null. */
+  titleRank: number | null;
+}
+
+interface CatalogDoc extends WorkspaceCandidate {
+  wsKey: string;
+  /** Workspace-relative path, ASCII-lowered like SQLite lower(). */
+  wsNorm: string;
+  wsFolderNorm: string;
+  depth: number;
+  /** Collection-relative path, ASCII-lowered. */
+  relNorm: string;
+  baseNorm: string;
+  titleNorm: string | null;
+}
+
+interface CatalogRow {
+  id: number;
+  docid: string;
+  collection: string;
+  rel_path: string;
+  title_norm: string | null;
+}
+
+const RELATIVE_TARGET = /^\.\.?\//;
+
+/** SQLite `lower()` folds ASCII letters only; mirror it exactly. */
+const asciiLower = (value: string): string =>
+  value.replace(/[A-Z]+/g, (match) => match.toLowerCase());
+
+const lastSegment = (value: string): string =>
+  value.slice(value.lastIndexOf("/") + 1);
+
+const folderOf = (value: string): string =>
+  value.includes("/") ? value.slice(0, value.lastIndexOf("/")) : "";
+
+const compareCodeUnits = (left: string, right: string): number =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+/** Read every collection's stored link workspace membership. */
+export const loadLinkWorkspaceMemberships = (
+  db: Database
+): Map<string, CollectionWorkspaceMembership> => {
+  const rows = db
+    .query<
+      {
+        name: string;
+        real_path: string | null;
+        workspace_root: string | null;
+        workspace_source: LinkWorkspaceSource | null;
+        workspace_nested: string | null;
+      },
+      []
+    >(
+      "SELECT name, real_path, workspace_root, workspace_source, workspace_nested FROM collections"
+    )
+    .all();
+  const memberships = new Map<string, CollectionWorkspaceMembership>();
+  for (const row of rows) {
+    let nested: string[] = [];
+    if (row.workspace_nested) {
+      try {
+        const parsed: unknown = JSON.parse(row.workspace_nested);
+        if (Array.isArray(parsed)) {
+          nested = parsed.filter(
+            (value): value is string => typeof value === "string"
+          );
+        }
+      } catch {
+        nested = [];
+      }
+    }
+    memberships.set(row.name, {
+      collection: row.name,
+      realPath: row.real_path,
+      root: row.workspace_root,
+      source: row.workspace_source ?? "none",
+      nested,
+    });
+  }
+  return memberships;
+};
+
+/** Workspace identity of a source document, or null for legacy resolution. */
+export const workspaceKeyForDocument = (
+  memberships: ReadonlyMap<string, CollectionWorkspaceMembership>,
+  collection: string,
+  relPath: string
+): string | null => placeDocument(memberships.get(collection), relPath).key;
+
+/** Collections that can hold documents of the given workspace. */
+export const workspaceMemberCollections = (
+  memberships: ReadonlyMap<string, CollectionWorkspaceMembership>,
+  wsKeys: ReadonlySet<string>
+): string[] => {
+  const members: string[] = [];
+  for (const membership of memberships.values()) {
+    const placement = placeDocument(membership, "x");
+    const nestedKeys = membership.nested.map(
+      (prefix) => placeDocument(membership, `${prefix}/x`).key
+    );
+    if (
+      (placement.key !== null && wsKeys.has(placement.key)) ||
+      nestedKeys.some((key) => key !== null && wsKeys.has(key))
+    ) {
+      members.push(membership.collection);
+    }
+  }
+  return members.sort();
+};
+
+/**
+ * Normalize a lowercased wiki target for workspace matching. `./` and `../`
+ * resolve against the source folder; `..` never escapes the workspace root.
+ * Returns null for an escaping target.
+ */
+export const normalizeWorkspaceTarget = (
+  targetRefNorm: string,
+  sourceFolderNorm: string
+): string | null => {
+  let value = targetRefNorm.trim().replace(/^\/+/, "");
+  if (value.startsWith("./") || value.startsWith("../")) {
+    value = sourceFolderNorm ? `${sourceFolderNorm}/${value}` : value;
+  }
+  if (value.includes("/") || value === "..") {
+    value = pathPosix.normalize(value).replace(/\/+$/, "");
+  }
+  if (value === ".." || value.startsWith("../") || value === ".") return null;
+  return value;
+};
+
+/** Keys a document's lowered basename must equal for a target's last segment. */
+const basenameKeys = (normalizedTarget: string): string[] => {
+  const base = stripWikiMdExt(lastSegment(normalizedTarget));
+  return [base, `${base}.md`];
+};
+
+/** Legacy title lookup values (ranks 1-4 of the collection-scoped resolver). */
+const titleLookups = (targetRefNorm: string): Array<[number, string[]]> => {
+  const baseRef = stripWikiMdExt(targetRefNorm);
+  const baseRefMd = `${baseRef}.md`;
+  const suffixes = (value: string): string[] => {
+    const output = [value];
+    let separator = value.indexOf("/");
+    while (separator >= 0) {
+      const suffix = value.slice(separator + 1);
+      if (suffix) output.push(suffix);
+      separator = value.indexOf("/", separator + 1);
+    }
+    return output;
+  };
+  return [
+    [1, [baseRef]],
+    [2, [baseRefMd]],
+    [3, suffixes(baseRef)],
+    [
+      4,
+      suffixes(baseRefMd)
+        .filter((value) => value.endsWith(".md"))
+        .map((value) => value.slice(0, -3)),
+    ],
+  ];
+};
+
+class WorkspaceCatalog {
+  private readonly byBase = new Map<string, CatalogDoc[]>();
+  private readonly byTitle = new Map<string, CatalogDoc[]>();
+
+  constructor(
+    private readonly memberships: ReadonlyMap<
+      string,
+      CollectionWorkspaceMembership
+    >
+  ) {}
+
+  add(row: CatalogRow): void {
+    const placement = placeDocument(
+      this.memberships.get(row.collection),
+      row.rel_path
+    );
+    if (placement.key === null) return;
+    const wsNorm = asciiLower(placement.path);
+    const doc: CatalogDoc = {
+      id: row.id,
+      docid: row.docid,
+      collection: row.collection,
+      path: placement.path,
+      wsKey: placement.key,
+      wsNorm,
+      wsFolderNorm: folderOf(wsNorm),
+      depth: wsNorm.split("/").length,
+      relNorm: asciiLower(row.rel_path.normalize("NFC")),
+      baseNorm: lastSegment(wsNorm),
+      titleNorm: row.title_norm,
+    };
+    const baseKey = `${doc.wsKey}\0${doc.baseNorm}`;
+    const bases = this.byBase.get(baseKey) ?? [];
+    bases.push(doc);
+    this.byBase.set(baseKey, bases);
+    if (doc.titleNorm !== null) {
+      const titleKey = `${doc.collection}\0${doc.titleNorm}`;
+      const titles = this.byTitle.get(titleKey) ?? [];
+      titles.push(doc);
+      this.byTitle.set(titleKey, titles);
+    }
+  }
+
+  byBasename(wsKey: string, keys: readonly string[]): CatalogDoc[] {
+    const lists = keys
+      .map((key) => this.byBase.get(`${wsKey}\0${key}`))
+      .filter((list): list is CatalogDoc[] => list !== undefined);
+    if (lists.length <= 1) return lists[0] ?? [];
+    const found = new Map<number, CatalogDoc>();
+    for (const list of lists) {
+      for (const doc of list) found.set(doc.id, doc);
+    }
+    return [...found.values()];
+  }
+
+  byTitleIn(
+    collection: string,
+    wsKey: string,
+    keys: readonly string[]
+  ): CatalogDoc[] {
+    const found = new Map<number, CatalogDoc>();
+    for (const key of keys) {
+      for (const doc of this.byTitle.get(`${collection}\0${key}`) ?? []) {
+        if (doc.wsKey === wsKey) found.set(doc.id, doc);
+      }
+    }
+    return [...found.values()];
+  }
+}
+
+/** A normalized wiki target, ready to be matched against workspace paths. */
+interface WorkspaceTargetShape {
+  normalized: string;
+  base: string;
+  exact: Set<string>;
+  relative: boolean;
+  hasPath: boolean;
+}
+
+const workspaceTargetShape = (
+  targetRefNorm: string,
+  sourceWsFolderNorm: string
+): WorkspaceTargetShape | null => {
+  const normalized = normalizeWorkspaceTarget(
+    targetRefNorm,
+    sourceWsFolderNorm
+  );
+  if (normalized === null || normalized.length === 0) return null;
+  const base = stripWikiMdExt(normalized);
+  // A relative target stays a path even when it normalizes to a root name.
+  const relative = RELATIVE_TARGET.test(targetRefNorm.trim());
+  return {
+    normalized,
+    base,
+    exact: new Set([base, `${base}.md`]),
+    relative,
+    hasPath: relative || normalized.includes("/"),
+  };
+};
+
+/**
+ * Match class of one same-basename file for a target, or null when it does
+ * not match: 0 exact workspace path, 1 exact path relative to the source's
+ * collection, 2 same folder as the source, 3 any other name or path-suffix
+ * match. Exact path classes apply to path targets only; a plain name ranks
+ * by folder and depth like any other same-named file. A relative target is
+ * already a full workspace path: only the exact workspace path matches.
+ */
+const workspaceMatchClass = (
+  shape: WorkspaceTargetShape,
+  file: {
+    wsNorm: string;
+    wsFolderNorm: string;
+    /** Path relative to the source's collection root, when it is in it. */
+    sourceCollectionRelNorm: string | null;
+    sourceWsFolderNorm: string;
+  }
+): number | null => {
+  if (shape.hasPath && shape.exact.has(file.wsNorm)) return 0;
+  if (shape.relative) return null;
+  if (
+    shape.hasPath &&
+    file.sourceCollectionRelNorm !== null &&
+    shape.exact.has(file.sourceCollectionRelNorm)
+  ) {
+    return 1;
+  }
+  if (
+    !shape.hasPath ||
+    file.wsNorm.endsWith(`/${shape.base}`) ||
+    file.wsNorm.endsWith(`/${shape.base}.md`)
+  ) {
+    return file.wsFolderNorm === file.sourceWsFolderNorm ? 2 : 3;
+  }
+  return null;
+};
+
+interface RankedCandidate {
+  doc: CatalogDoc;
+  klass: number;
+}
+
+/**
+ * Collapse rows of one physical source (the same workspace path indexed by
+ * overlapping collections). Source identity is the exact, case-preserving
+ * workspace path: `Note.md` and `note.md` on a case-sensitive filesystem
+ * are two files and stay two candidates (a tie), never one. The
+ * representative keeps the best class, then the source's own collection,
+ * then the lexicographically first collection.
+ */
+const distinctSources = (
+  ranked: RankedCandidate[],
+  sourceCollection: string
+): RankedCandidate[] => {
+  const preference = (left: RankedCandidate, right: RankedCandidate): number =>
+    left.klass - right.klass ||
+    Number(left.doc.collection !== sourceCollection) -
+      Number(right.doc.collection !== sourceCollection) ||
+    compareCodeUnits(left.doc.collection, right.doc.collection);
+  const bySource = new Map<string, RankedCandidate>();
+  for (const candidate of ranked) {
+    const key = `${candidate.doc.wsKey}\0${candidate.doc.path}`;
+    const existing = bySource.get(key);
+    if (!existing || preference(candidate, existing) < 0) {
+      bySource.set(key, candidate);
+    }
+  }
+  return [...bySource.values()];
+};
+
+const toCandidate = (doc: CatalogDoc): WorkspaceCandidate => ({
+  id: doc.id,
+  docid: doc.docid,
+  collection: doc.collection,
+  path: doc.path,
+});
+
+/**
+ * Rank one plain wiki target inside its source's workspace. Ranking tuple:
+ * workspace-path exact, collection-path exact, same-folder name, other name
+ * or path-suffix match; then fewest path segments; candidates still equal
+ * are tied (listed in canonical path order, no edge).
+ */
+const rankTarget = (
+  catalog: WorkspaceCatalog,
+  wsKey: string,
+  source: { collection: string; wsFolderNorm: string },
+  targetRefNorm: string
+): WorkspaceTargetResolution | null => {
+  const shape = workspaceTargetShape(targetRefNorm, source.wsFolderNorm);
+  if (shape === null) return null;
+  const matches: RankedCandidate[] = [];
+  for (const doc of catalog.byBasename(wsKey, basenameKeys(shape.normalized))) {
+    const klass = workspaceMatchClass(shape, {
+      wsNorm: doc.wsNorm,
+      wsFolderNorm: doc.wsFolderNorm,
+      sourceCollectionRelNorm:
+        doc.collection === source.collection ? doc.relNorm : null,
+      sourceWsFolderNorm: source.wsFolderNorm,
+    });
+    if (klass !== null) matches.push({ doc, klass });
+  }
+  const distinct = distinctSources(matches, source.collection);
+  if (distinct.length > 0) {
+    distinct.sort(
+      (left, right) =>
+        left.klass - right.klass ||
+        left.doc.depth - right.doc.depth ||
+        compareCodeUnits(left.doc.wsNorm, right.doc.wsNorm) ||
+        compareCodeUnits(left.doc.path, right.doc.path)
+    );
+    const best = distinct[0]!;
+    const tied = distinct.filter(
+      (candidate) =>
+        candidate.klass === best.klass && candidate.doc.depth === best.doc.depth
+    );
+    const traversable = tied.length === 1;
+    const reason: WorkspaceResolutionReason =
+      best.klass === 0
+        ? "workspace-path"
+        : best.klass === 1
+          ? "collection-path"
+          : distinct.length === 1
+            ? "exact-name"
+            : "tie-break";
+    return {
+      target: toCandidate(best.doc),
+      reason,
+      traversable,
+      tied: traversable ? [] : tied.map(({ doc }) => toCandidate(doc)),
+      titleRank: null,
+    };
+  }
+  // Fallback: frontmatter title inside the source collection only; relative
+  // targets are paths and never fall back to titles.
+  if (shape.relative) return null;
+  for (const [rank, keys] of titleLookups(targetRefNorm)) {
+    const docs = catalog
+      .byTitleIn(source.collection, wsKey, keys)
+      .sort(
+        (left, right) =>
+          left.depth - right.depth ||
+          compareCodeUnits(left.wsNorm, right.wsNorm)
+      );
+    if (docs.length === 0) continue;
+    return {
+      target: toCandidate(docs[0]!),
+      reason: "title",
+      traversable: docs.length === 1,
+      tied: docs.length === 1 ? [] : docs.map(toCandidate),
+      titleRank: rank,
+    };
+  }
+  return null;
+};
+
+/** Membership map from collection rows (as returned by getCollections). */
+export const membershipsFromCollectionRows = (
+  rows: ReadonlyArray<{
+    name: string;
+    realPath?: string | null;
+    workspaceRoot?: string | null;
+    workspaceSource?: LinkWorkspaceSource;
+    workspaceNested?: string[];
+  }>
+): Map<string, CollectionWorkspaceMembership> =>
+  new Map(
+    rows.map((row) => [
+      row.name,
+      {
+        collection: row.name,
+        realPath: row.realPath ?? null,
+        root: row.workspaceRoot ?? null,
+        source: row.workspaceSource ?? "none",
+        nested: row.workspaceNested ?? [],
+      },
+    ])
+  );
+
+/**
+ * Same ranking over an in-memory document list (graph projection). Returns
+ * `undefined` when the source is not in a link workspace (caller keeps its
+ * collection-scoped contract), `null` when nothing matched.
+ */
+export const createInMemoryWorkspaceResolver = (
+  memberships: ReadonlyMap<string, CollectionWorkspaceMembership>,
+  documents: ReadonlyArray<{
+    id: number;
+    docid: string;
+    collection: string;
+    relPath: string;
+    title: string | null;
+  }>
+): ((
+  source: WorkspaceLinkSource,
+  targetRefNorm: string
+) => WorkspaceTargetResolution | null | undefined) => {
+  const anyWorkspace = [...memberships.values()].some(
+    (membership) =>
+      membership.realPath !== null &&
+      membership.source !== "disabled" &&
+      membership.source !== "unavailable" &&
+      (membership.root !== null || membership.nested.length > 0)
+  );
+  if (!anyWorkspace) return () => undefined;
+  const catalog = new WorkspaceCatalog(memberships);
+  for (const document of documents) {
+    catalog.add({
+      id: document.id,
+      docid: document.docid,
+      collection: document.collection,
+      rel_path: document.relPath,
+      // Mirrors SQLite lower(trim(title)) used by the SQL candidate paths.
+      title_norm:
+        typeof document.title === "string"
+          ? asciiLower(document.title.trim())
+          : null,
+    });
+  }
+  return (source, targetRefNorm) => {
+    const placement = placeDocument(
+      memberships.get(source.collection),
+      source.relPath
+    );
+    if (placement.key === null) return undefined;
+    return rankTarget(
+      catalog,
+      placement.key,
+      {
+        collection: source.collection,
+        wsFolderNorm: folderOf(asciiLower(placement.path)),
+      },
+      targetRefNorm
+    );
+  };
+};
+
+/**
+ * Existence matcher over workspace files that are not indexed documents
+ * (attachments, notes in unindexed or excluded folders). A target matches a
+ * file under the same rules as an indexed note: basename with `.md` optional
+ * (so a non-Markdown target needs its extension), exact or suffix path for
+ * path targets, exact workspace path for `./` and `../` targets. The path
+ * relative to the source's collection needs no separate check here: that
+ * file's workspace path equals the target or ends with `/target`. File names
+ * fold case fully, as Obsidian matches link targets case-insensitively.
+ */
+export const createWorkspaceFileMatcher = (
+  workspacePaths: Iterable<string>
+): ((targetRefNorm: string, sourceWsPath: string) => boolean) => {
+  const byBase = new Map<string, Array<{ wsNorm: string; folder: string }>>();
+  for (const path of workspacePaths) {
+    const wsNorm = path.normalize("NFC").toLowerCase();
+    const base = lastSegment(wsNorm);
+    const files = byBase.get(base) ?? [];
+    files.push({ wsNorm, folder: folderOf(wsNorm) });
+    byBase.set(base, files);
+  }
+  return (targetRefNorm, sourceWsPath) => {
+    const sourceWsFolderNorm = folderOf(
+      sourceWsPath.normalize("NFC").toLowerCase()
+    );
+    const shape = workspaceTargetShape(targetRefNorm, sourceWsFolderNorm);
+    if (shape === null) return false;
+    return basenameKeys(shape.normalized).some((key) =>
+      (byBase.get(key) ?? []).some(
+        (file) =>
+          workspaceMatchClass(shape, {
+            wsNorm: file.wsNorm,
+            wsFolderNorm: file.folder,
+            sourceCollectionRelNorm: null,
+            sourceWsFolderNorm,
+          }) !== null
+      )
+    );
+  };
+};
+
+export interface WorkspaceTargetInput {
+  targetRefNorm: string;
+  source: WorkspaceLinkSource;
+  wsKey: string;
+}
+
+const MAX_SQL_PARAMS = 900;
+const CATALOG_COLUMNS =
+  "id, docid, collection, rel_path, lower(trim(title)) AS title_norm";
+/** SQLite basename of rel_path (text after the last '/'). */
+const BASENAME_SQL =
+  "substr(rel_path, length(rtrim(rel_path, replace(rel_path, '/', ''))) + 1)";
+
+const chunk = <T>(items: readonly T[], size: number): T[][] => {
+  const chunks: T[][] = [];
+  for (let offset = 0; offset < items.length; offset += size) {
+    chunks.push(items.slice(offset, offset + size));
+  }
+  return chunks;
+};
+
+const loadRows = (
+  db: Database,
+  collections: readonly string[],
+  filter: { sql: string; values: string[] } | null
+): CatalogRow[] => {
+  if (collections.length === 0) return [];
+  const rows: CatalogRow[] = [];
+  const collectionPlaceholders = collections.map(() => "?").join(",");
+  const valueChunks = filter
+    ? chunk(filter.values, Math.max(1, MAX_SQL_PARAMS - collections.length))
+    : [[]];
+  for (const values of valueChunks) {
+    if (filter && values.length === 0) continue;
+    rows.push(
+      ...db
+        .query<CatalogRow, string[]>(
+          `SELECT ${CATALOG_COLUMNS} FROM documents
+           WHERE active = 1 AND collection IN (${collectionPlaceholders})
+           ${filter ? `AND ${filter.sql} IN (${values.map(() => "?").join(",")})` : ""}
+           ORDER BY id`
+        )
+        .all(...collections, ...values)
+    );
+  }
+  return rows;
+};
+
+/** Both Unicode forms so a NFD file name still reaches the NFC ranking. */
+const withUnicodeForms = (values: Iterable<string>): string[] => {
+  const output = new Set<string>();
+  for (const value of values) {
+    output.add(value);
+    output.add(value.normalize("NFD"));
+  }
+  return [...output].sort();
+};
+
+/**
+ * Resolve workspace targets. `bulk` loads every document of the involved
+ * workspaces once; otherwise a SQL basename/title prefilter fetches only
+ * potential candidates. Both paths rank identical rows identically.
+ */
+export const resolveWorkspaceTargets = (
+  db: Database,
+  memberships: ReadonlyMap<string, CollectionWorkspaceMembership>,
+  targets: readonly WorkspaceTargetInput[],
+  options: { bulk: boolean }
+): Array<WorkspaceTargetResolution | null> => {
+  if (targets.length === 0) return [];
+  const wsKeys = new Set(targets.map((target) => target.wsKey));
+  const collections = workspaceMemberCollections(memberships, wsKeys);
+  const catalog = new WorkspaceCatalog(memberships);
+  const seen = new Set<number>();
+  const addRows = (rows: CatalogRow[]) => {
+    for (const row of rows) {
+      if (seen.has(row.id)) continue;
+      seen.add(row.id);
+      catalog.add(row);
+    }
+  };
+  if (options.bulk) {
+    addRows(loadRows(db, collections, null));
+  } else {
+    const bases = new Set<string>();
+    const titles = new Set<string>();
+    for (const target of targets) {
+      const normalized = normalizeWorkspaceTarget(target.targetRefNorm, "");
+      const raw = target.targetRefNorm.trim();
+      for (const value of [normalized, raw]) {
+        if (!value) continue;
+        for (const key of basenameKeys(value)) bases.add(key);
+      }
+      for (const [, keys] of titleLookups(target.targetRefNorm)) {
+        for (const key of keys) titles.add(key);
+      }
+    }
+    addRows(
+      loadRows(db, collections, {
+        sql: `lower(${BASENAME_SQL})`,
+        values: withUnicodeForms(bases),
+      })
+    );
+    addRows(
+      loadRows(db, collections, {
+        sql: "lower(trim(title))",
+        values: [...titles].sort(),
+      })
+    );
+  }
+  const cache = new Map<string, WorkspaceTargetResolution | null>();
+  const folders = new Map<string, string>();
+  return targets.map((target) => {
+    const sourceKey = `${target.source.collection}\0${target.source.relPath}`;
+    let wsFolderNorm = folders.get(sourceKey);
+    if (wsFolderNorm === undefined) {
+      wsFolderNorm = folderOf(
+        asciiLower(
+          placeDocument(
+            memberships.get(target.source.collection),
+            target.source.relPath
+          ).path
+        )
+      );
+      folders.set(sourceKey, wsFolderNorm);
+    }
+    // Resolution depends on workspace, source collection and folder only.
+    const cacheKey = `${target.wsKey}\0${target.source.collection}\0${wsFolderNorm}\0${target.targetRefNorm}`;
+    if (cache.has(cacheKey)) return cache.get(cacheKey) ?? null;
+    const result = rankTarget(
+      catalog,
+      target.wsKey,
+      { collection: target.source.collection, wsFolderNorm },
+      target.targetRefNorm
+    );
+    cache.set(cacheKey, result);
+    return result;
+  });
+};