collabmd 0.1.33 → 0.1.35

package/src/server/domain/backlink-index.js

@@ -10,11 +10,15 @@
  * incrementally whenever a file is persisted, created, deleted, or renamed.
  */
 
-import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
-import { getVaultFileExtension, isMarkdownFilePath } from '../../domain/file-kind.js';
+import { createWikiTargetIndex } from '../../domain/wiki-link-resolver.js';
+import { isMarkdownFilePath } from '../../domain/file-kind.js';
+import {
+  collectMarkdownReferences,
+  collectReferenceTargetKeysForFilePath,
+  createReferenceTargetAliasMap,
+} from './markdown-reference-extractor.js';
 import { mapWithConcurrency } from '../shared/async-utils.js';
 
-const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
 const BACKLINK_BUILD_CONCURRENCY = 8;
 
 function createDeferred() {
@@ -27,39 +31,6 @@ function createDeferred() {
   return { promise, reject, resolve };
 }
 
-function normalizeWikiTargetKey(target = '') {
-  const normalizedTarget = String(target ?? '').trim();
-  if (!normalizedTarget) {
-    return '';
-  }
-
-  return getVaultFileExtension(normalizedTarget)
-    ? normalizedTarget
-    : `${normalizedTarget}.md`;
-}
-
-function collectWikiTargetKeysForFilePath(filePath = '') {
-  const normalizedPath = String(filePath ?? '').trim();
-  if (!normalizedPath) {
-    return [];
-  }
-
-  const segments = normalizedPath.split('/').filter(Boolean);
-  const keys = [];
-  for (let index = 0; index < segments.length; index += 1) {
-    keys.push(segments.slice(index).join('/'));
-  }
-
-  if (isMarkdownFilePath(normalizedPath)) {
-    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
-    for (let index = 0; index < rawSegments.length; index += 1) {
-      keys.push(rawSegments.slice(index).join('/'));
-    }
-  }
-
-  return [...new Set(keys)];
-}
-
 export class BacklinkIndex {
   constructor({
     rebuildDelayMs = 150,
@@ -225,7 +196,10 @@ export class BacklinkIndex {
    * Incrementally update the index when a file's content changes.
    * Call this after every persist / write.
    */
-  updateFile(filePath, content, { refreshIndex = true } = {}) {
+  updateFile(filePath, content, {
+    refreshIndex = true,
+    targetPathAliases = new Map(),
+  } = {}) {
     // Remove old forward links for this file
     this._removeForwardLinks(filePath);
 
@@ -242,7 +216,7 @@ export class BacklinkIndex {
     }
 
     // Re-index with new content
-    this._indexFile(filePath, content);
+    this._indexFile(filePath, content, { targetPathAliases });
   }
 
   /**
@@ -371,10 +345,23 @@ export class BacklinkIndex {
     previousState = null,
     nextState = null,
   } = {}) {
-    let refreshIndex = false;
     const previousEntries = previousState?.entries ?? new Map();
     const nextEntries = nextState?.entries ?? new Map();
     const changedPaths = Array.from(new Set(workspaceChange.changedPaths ?? []));
+    const { impactedSources, renameMap } = this._computeWorkspaceChangeMeta(workspaceChange, changedPaths, previousEntries, nextEntries);
+
+    let refreshIndex = this._applyDeletedPaths(workspaceChange.deletedPaths);
+    refreshIndex = this._applyRenamedPaths(workspaceChange.renamedPaths, refreshIndex);
+    refreshIndex = await this._applyChangedPaths(changedPaths, previousEntries, nextEntries, refreshIndex);
+
+    if (refreshIndex) {
+      const sourcesToRefresh = this._collectRefreshSources(impactedSources, changedPaths, workspaceChange.renamedPaths, nextEntries);
+      this._refreshWikiTargetIndex();
+      await this._refreshImpactedSources(sourcesToRefresh, { nextEntries, renameMap });
+    }
+  }
+
+  _computeWorkspaceChangeMeta(workspaceChange, changedPaths, previousEntries, nextEntries) {
     const createdPaths = changedPaths.filter((pathValue) => (
       nextEntries.has(pathValue) && !previousEntries.has(pathValue)
     ));
@@ -393,18 +380,28 @@ export class BacklinkIndex {
         .filter((entry) => entry?.oldPath && entry?.newPath)
         .map((entry) => [entry.oldPath, entry.newPath]),
     );
+    return { impactedSources, renameMap };
+  }
 
-    for (const pathValue of workspaceChange.deletedPaths ?? []) {
+  _applyDeletedPaths(deletedPaths) {
+    let refreshIndex = false;
+    for (const pathValue of deletedPaths ?? []) {
       refreshIndex = this.onFileDeleted(pathValue, { refreshIndex: false }) || refreshIndex;
     }
+    return refreshIndex;
+  }
 
-    for (const entry of workspaceChange.renamedPaths ?? []) {
+  _applyRenamedPaths(renamedPaths, refreshIndex) {
+    for (const entry of renamedPaths ?? []) {
       if (!entry?.oldPath || !entry?.newPath) {
         continue;
       }
       refreshIndex = this.onFileRenamed(entry.oldPath, entry.newPath, { refreshIndex: false }) || refreshIndex;
     }
+    return refreshIndex;
+  }
 
+  async _applyChangedPaths(changedPaths, previousEntries, nextEntries, refreshIndex) {
     for (const pathValue of changedPaths) {
       const existsNow = nextEntries.has(pathValue);
       const existedBefore = previousEntries.has(pathValue);
@@ -433,26 +430,22 @@ export class BacklinkIndex {
         refreshIndex = this.onFileCreated(pathValue, content, { refreshIndex: false }) || refreshIndex;
       }
     }
+    return refreshIndex;
+  }
 
-    if (refreshIndex) {
-      const sourcesToRefresh = new Set(impactedSources);
-      changedPaths.forEach((pathValue) => {
-        if (nextEntries.has(pathValue) && isMarkdownFilePath(pathValue)) {
-          sourcesToRefresh.add(pathValue);
-        }
-      });
-      (workspaceChange.renamedPaths ?? []).forEach((entry) => {
-        if (entry?.newPath && isMarkdownFilePath(entry.newPath)) {
-          sourcesToRefresh.add(entry.newPath);
-        }
-      });
-
-      this._refreshWikiTargetIndex();
-      await this._refreshImpactedSources(sourcesToRefresh, {
-        nextEntries,
-        renameMap,
-      });
-    }
+  _collectRefreshSources(impactedSources, changedPaths, renamedPaths, nextEntries) {
+    const sourcesToRefresh = new Set(impactedSources);
+    changedPaths.forEach((pathValue) => {
+      if (nextEntries.has(pathValue) && isMarkdownFilePath(pathValue)) {
+        sourcesToRefresh.add(pathValue);
+      }
+    });
+    (renamedPaths ?? []).forEach((entry) => {
+      if (entry?.newPath && isMarkdownFilePath(entry.newPath)) {
+        sourcesToRefresh.add(entry.newPath);
+      }
+    });
+    return sourcesToRefresh;
   }
 
   /**
@@ -495,38 +488,32 @@ export class BacklinkIndex {
 
   // --- Private methods ---
 
-  _indexFile(filePath, content) {
+  _indexFile(filePath, content, { targetPathAliases = new Map() } = {}) {
     const resolvedTargets = new Set();
     const contextsByTarget = new Map();
     const rawTargetKeys = new Set();
-    const lines = content.split('\n');
-
-    for (const line of lines) {
-      WIKI_LINK_RE.lastIndex = 0;
-      let match;
-      while ((match = WIKI_LINK_RE.exec(line)) !== null) {
-        const target = match[1].trim();
-        if (!target) {
-          continue;
-        }
+    const references = collectMarkdownReferences(content, {
+      sourceFilePath: filePath,
+      targetPathAliases,
+      wikiTargetIndex: this._wikiTargetIndex,
+    });
 
-        const rawTargetKey = normalizeWikiTargetKey(target);
-        if (rawTargetKey) {
-          rawTargetKeys.add(rawTargetKey);
-        }
+    for (const reference of references) {
+      if (reference.rawTargetKey) {
+        rawTargetKeys.add(reference.rawTargetKey);
+      }
 
-        const resolved = this._resolveTarget(target);
-        if (!resolved || resolved === filePath) {
-          continue;
-        }
+      const resolved = reference.resolvedPath;
+      if (!resolved || resolved === filePath) {
+        continue;
+      }
 
-        resolvedTargets.add(resolved);
+      resolvedTargets.add(resolved);
 
-        if (!contextsByTarget.has(resolved)) {
-          contextsByTarget.set(resolved, []);
-        }
-        contextsByTarget.get(resolved).push(line.trim());
+      if (!contextsByTarget.has(resolved)) {
+        contextsByTarget.set(resolved, []);
       }
+      contextsByTarget.get(resolved).push(reference.context);
     }
 
     this.contextsBySource.delete(filePath);
@@ -575,14 +562,6 @@ export class BacklinkIndex {
     this.forward.delete(filePath);
   }
 
-  /**
-   * Resolve a wiki-link target string to a vault file path.
-   * Same logic as the client's resolveWikiTarget.
-   */
-  _resolveTarget(target) {
-    return resolveWikiTargetWithIndex(target, this._wikiTargetIndex);
-  }
-
   _refreshWikiTargetIndex() {
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
   }
@@ -610,7 +589,7 @@ export class BacklinkIndex {
   _collectImpactedSourcesForMembershipChanges(pathValues = []) {
     const affectedTargetKeys = new Set();
     pathValues.forEach((pathValue) => {
-      collectWikiTargetKeysForFilePath(pathValue).forEach((targetKey) => {
+      collectReferenceTargetKeysForFilePath(pathValue).forEach((targetKey) => {
         affectedTargetKeys.add(targetKey);
       });
     });
@@ -629,6 +608,7 @@ export class BacklinkIndex {
     renameMap = new Map(),
   } = {}) {
     const refreshedSources = new Set();
+    const targetPathAliases = createReferenceTargetAliasMap(Array.from(renameMap.entries()));
 
     for (const sourcePath of impactedSources) {
       const livePath = renameMap.get(sourcePath) ?? sourcePath;
@@ -647,7 +627,7 @@ export class BacklinkIndex {
       }
 
       refreshedSources.add(livePath);
-      this.updateFile(livePath, content, { refreshIndex: false });
+      this.updateFile(livePath, content, { refreshIndex: false, targetPathAliases });
     }
   }
 }

package/src/server/domain/bases/base-index-snapshot-store.js

@@ -1,16 +1,19 @@
 import { basename, dirname, extname } from 'node:path';
 
-import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../../domain/wiki-link-resolver.js';
+import { createWikiTargetIndex } from '../../../domain/wiki-link-resolver.js';
 import {
-  getVaultFileExtension,
   isMarkdownFilePath,
   stripVaultFileExtension,
 } from '../../../domain/file-kind.js';
 import { extractYamlFrontmatter } from '../../../domain/yaml-frontmatter.js';
+import {
+  collectMarkdownReferences,
+  collectReferenceTargetKeysForFilePath,
+  createReferenceTargetAliasMap,
+} from '../markdown-reference-extractor.js';
 import { mapWithConcurrency } from '../../shared/async-utils.js';
 import { createLinkValue, dedupeLinkValues } from './base-expression-runtime.js';
 
-const INTERNAL_LINK_RE = /(!)?\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g;
 const INLINE_TAG_RE = /(^|[\s(])#([A-Za-z0-9/_-]+)/g;
 const INDEX_READ_CONCURRENCY = 8;
 
@@ -42,28 +45,35 @@ function compareVaultPaths(left = '', right = '') {
   return String(left).localeCompare(String(right), undefined, { sensitivity: 'base' });
 }
 
-function extractReferences(markdownText = '', wikiTargetIndex) {
+function extractReferences(markdownText = '', {
+  sourceFilePath = '',
+  targetPathAliases = new Map(),
+  wikiTargetIndex,
+} = {}) {
   const links = [];
   const embeds = [];
-  let match;
-  while ((match = INTERNAL_LINK_RE.exec(String(markdownText ?? ''))) !== null) {
-    const isEmbed = Boolean(match[1]);
-    const rawTarget = String(match[2] ?? '').trim();
-    if (!rawTarget) {
-      continue;
-    }
+  const rawTargetKeys = new Set();
+  const references = collectMarkdownReferences(markdownText, {
+    sourceFilePath,
+    targetPathAliases,
+    wikiTargetIndex,
+  });
 
-    const resolvedPath = resolveWikiTargetWithIndex(rawTarget, wikiTargetIndex);
-    const linkValue = createLinkValue(resolvedPath || rawTarget, {
-      exists: Boolean(resolvedPath),
-      rawTarget,
+  references.forEach((reference) => {
+    const linkValue = createLinkValue(reference.resolvedPath || reference.targetPath || reference.rawTarget, {
+      exists: Boolean(reference.resolvedPath),
+      rawTarget: reference.rawTarget,
     });
     links.push(linkValue);
-    if (isEmbed) {
+    if (reference.isEmbed) {
       embeds.push(linkValue);
     }
-  }
-  return { embeds, links };
+    if (reference.rawTargetKey) {
+      rawTargetKeys.add(reference.rawTargetKey);
+    }
+  });
+
+  return { embeds, links, rawTargetKeys };
 }
 
 function isWorkspaceFileEntry(entry = null) {
@@ -81,39 +91,6 @@ function listWorkspaceFilePaths(workspaceState = {}) {
     .sort(compareVaultPaths);
 }
 
-function normalizeWikiTargetKey(target = '') {
-  const normalizedTarget = String(target ?? '').trim();
-  if (!normalizedTarget) {
-    return '';
-  }
-
-  return getVaultFileExtension(normalizedTarget)
-    ? normalizedTarget
-    : `${normalizedTarget}.md`;
-}
-
-function collectWikiTargetKeysForFilePath(filePath = '') {
-  const normalizedPath = String(filePath ?? '').trim();
-  if (!normalizedPath) {
-    return [];
-  }
-
-  const segments = normalizedPath.split('/').filter(Boolean);
-  const keys = [];
-  for (let index = 0; index < segments.length; index += 1) {
-    keys.push(segments.slice(index).join('/'));
-  }
-
-  if (isMarkdownFilePath(normalizedPath)) {
-    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
-    for (let index = 0; index < rawSegments.length; index += 1) {
-      keys.push(rawSegments.slice(index).join('/'));
-    }
-  }
-
-  return [...new Set(keys)];
-}
-
 function createBacklinkEntry(sourcePath = '') {
   return createLinkValue(sourcePath, {
     display: basename(sourcePath),
@@ -160,12 +137,18 @@ export class BaseIndexSnapshotStore {
     return scannedWorkspaceState;
   }
 
-  createSnapshotRow(filePath, workspaceState, wikiTargetIndex, markdownContent = null) {
+  createSnapshotRow(filePath, workspaceState, wikiTargetIndex, markdownContent = null, {
+    targetPathAliases = new Map(),
+  } = {}) {
     const metadata = workspaceState.metadata.get(filePath) ?? null;
     const frontmatter = markdownContent ? extractYamlFrontmatter(markdownContent) : null;
     const noteProperties = isPlainObject(frontmatter?.data) ? frontmatter.data : {};
     const bodyMarkdown = frontmatter?.bodyMarkdown ?? markdownContent ?? '';
-    const references = extractReferences(bodyMarkdown, wikiTargetIndex);
+    const references = extractReferences(bodyMarkdown, {
+      sourceFilePath: filePath,
+      targetPathAliases,
+      wikiTargetIndex,
+    });
     const tags = [...new Set([
       ...normalizeTags(noteProperties.tags),
       ...extractInlineTags(bodyMarkdown),
@@ -193,11 +176,7 @@ export class BaseIndexSnapshotStore {
           .map((link) => link?.path)
           .filter((targetPath) => targetPath && targetPath !== filePath),
       ),
-      rawTargetKeys: new Set(
-        references.links
-          .map((link) => normalizeWikiTargetKey(link?.rawTarget))
-          .filter(Boolean),
-      ),
+      rawTargetKeys: references.rawTargetKeys,
       row: {
         file: fileValue,
         noteProperties,
@@ -373,7 +352,7 @@ export class BaseIndexSnapshotStore {
   collectImpactedSourcesForMembershipChanges(snapshot, pathValues = []) {
     const affectedTargetKeys = new Set();
     pathValues.forEach((pathValue) => {
-      collectWikiTargetKeysForFilePath(pathValue).forEach((targetKey) => {
+      collectReferenceTargetKeysForFilePath(pathValue).forEach((targetKey) => {
         affectedTargetKeys.add(targetKey);
       });
     });
@@ -392,7 +371,9 @@ export class BaseIndexSnapshotStore {
     return impactedPaths;
   }
 
-  async refreshSnapshotRows(snapshot, workspaceState, pathValues = []) {
+  async refreshSnapshotRows(snapshot, workspaceState, pathValues = [], {
+    targetPathAliases = new Map(),
+  } = {}) {
     const filePathsToRefresh = Array.from(new Set(pathValues))
       .filter((pathValue) => {
         const entry = workspaceState?.entries?.get(pathValue);
@@ -403,7 +384,9 @@ export class BaseIndexSnapshotStore {
       const markdownContent = isMarkdownFilePath(filePath)
         ? await this.vaultFileStore.readMarkdownFile(filePath)
         : null;
-      const rowRecord = this.createSnapshotRow(filePath, workspaceState, snapshot.wikiTargetIndex, markdownContent);
+      const rowRecord = this.createSnapshotRow(filePath, workspaceState, snapshot.wikiTargetIndex, markdownContent, {
+        targetPathAliases,
+      });
       this.removeRawTargetSourceContributions(snapshot, filePath);
       snapshot.rowsByPath.set(filePath, rowRecord.row);
       snapshot.forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
@@ -489,6 +472,7 @@ export class BaseIndexSnapshotStore {
     const snapshot = this.indexSnapshot;
     const affectedTargetPaths = new Set();
     const affectedSourcePaths = new Set(markdownPathsToRefresh);
+    const targetPathAliases = createReferenceTargetAliasMap(renamedFileEntries);
     if (membershipChanged) {
       const membershipAffectedPaths = [
         ...deletedFilePaths,
@@ -543,7 +527,7 @@ export class BaseIndexSnapshotStore {
         ...createdFilePaths,
         ...renamedFileEntries.map((entry) => entry.newPath),
         ...affectedSourcePaths,
-      ]);
+      ], { targetPathAliases });
     } else {
       affectedSourcePaths.forEach((pathValue) => {
         this.removeSourceBacklinkContributions(snapshot, pathValue, affectedTargetPaths);

package/src/server/domain/markdown-reference-extractor.js

@@ -0,0 +1,233 @@
+import {
+  getVaultFileExtension,
+  isImageAttachmentFilePath,
+  isMarkdownFilePath,
+} from '../../domain/file-kind.js';
+import { resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
+
+const INTERNAL_LINK_RE = /(!)?\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+const MARKDOWN_IMAGE_OPEN_RE = /!\[[^\]\n]*\]\(/g;
+
+function isAbsoluteOrExternalUrl(source = '') {
+  const normalized = String(source ?? '').trim();
+  return (
+    !normalized
+    || normalized.startsWith('data:')
+    || normalized.startsWith('blob:')
+    || normalized.startsWith('#')
+    || normalized.startsWith('//')
+    || /^[a-zA-Z][a-zA-Z\d+.-]*:/u.test(normalized)
+    || normalized.startsWith('/')
+  );
+}
+
+function normalizePathSegments(pathValue = '') {
+  return String(pathValue ?? '')
+    .replace(/\\/g, '/')
+    .split('/')
+    .filter(Boolean);
+}
+
+function resolveVaultRelativePath(fromFilePath = '', relativePath = '') {
+  const sourceSegments = normalizePathSegments(fromFilePath);
+  const targetSegments = String(relativePath ?? '')
+    .split('/')
+    .map((segment) => {
+      try {
+        return decodeURIComponent(segment);
+      } catch {
+        return segment;
+      }
+    });
+
+  if (targetSegments.length === 0) {
+    return '';
+  }
+
+  sourceSegments.pop();
+  const resolvedSegments = [...sourceSegments];
+
+  for (const rawSegment of targetSegments) {
+    const segment = String(rawSegment ?? '').trim();
+    if (!segment || segment === '.') {
+      continue;
+    }
+
+    if (segment === '..') {
+      if (resolvedSegments.length === 0) {
+        return '';
+      }
+      resolvedSegments.pop();
+      continue;
+    }
+
+    resolvedSegments.push(segment);
+  }
+
+  return resolvedSegments.join('/');
+}
+
+function parseMarkdownImageDestination(sourceText = '') {
+  const text = String(sourceText ?? '');
+  let index = 0;
+  while (/\s/u.test(text[index] ?? '')) {
+    index += 1;
+  }
+
+  if (text[index] === '<') {
+    const endIndex = text.indexOf('>', index + 1);
+    if (endIndex < 0 || text.indexOf(')', endIndex + 1) < 0) {
+      return '';
+    }
+    return text.slice(index + 1, endIndex).trim();
+  }
+
+  const startIndex = index;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === ')' || /\s/u.test(char)) {
+      break;
+    }
+    index += 1;
+  }
+
+  if (startIndex === index || text.indexOf(')', index) < 0) {
+    return '';
+  }
+
+  return text.slice(startIndex, index).trim();
+}
+
+function resolveMarkdownImageTargetPath(sourceFilePath = '', imageSource = '') {
+  const source = String(imageSource ?? '').trim();
+  if (isAbsoluteOrExternalUrl(source)) {
+    return '';
+  }
+
+  const resolvedPath = resolveVaultRelativePath(sourceFilePath, source);
+  return isImageAttachmentFilePath(resolvedPath) ? resolvedPath : '';
+}
+
+function resolveAliasedTargetPath(targetPath = '', wikiTargetIndex = null, targetPathAliases = new Map()) {
+  const candidates = [
+    String(targetPath ?? '').trim(),
+    normalizeReferenceTargetKey(targetPath),
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const aliasedPath = targetPathAliases?.get?.(candidate);
+    if (aliasedPath && wikiTargetIndex?.exactPaths?.has?.(aliasedPath)) {
+      return aliasedPath;
+    }
+  }
+
+  return null;
+}
+
+export function normalizeReferenceTargetKey(target = '') {
+  const normalizedTarget = String(target ?? '').trim();
+  if (!normalizedTarget) {
+    return '';
+  }
+
+  return getVaultFileExtension(normalizedTarget)
+    ? normalizedTarget
+    : `${normalizedTarget}.md`;
+}
+
+export function collectReferenceTargetKeysForFilePath(filePath = '') {
+  const normalizedPath = String(filePath ?? '').trim();
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments = normalizedPath.split('/').filter(Boolean);
+  const keys = [];
+  for (let index = 0; index < segments.length; index += 1) {
+    keys.push(segments.slice(index).join('/'));
+  }
+
+  if (isMarkdownFilePath(normalizedPath)) {
+    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
+    for (let index = 0; index < rawSegments.length; index += 1) {
+      keys.push(rawSegments.slice(index).join('/'));
+    }
+  }
+
+  return [...new Set(keys)];
+}
+
+export function createReferenceTargetAliasMap(renamedEntries = []) {
+  const aliases = new Map();
+
+  renamedEntries.forEach((entry) => {
+    const oldPath = Array.isArray(entry) ? entry[0] : entry?.oldPath;
+    const newPath = Array.isArray(entry) ? entry[1] : entry?.newPath;
+    if (!oldPath || !newPath) {
+      return;
+    }
+
+    aliases.set(oldPath, newPath);
+    collectReferenceTargetKeysForFilePath(oldPath).forEach((targetKey) => {
+      aliases.set(targetKey, newPath);
+    });
+  });
+
+  return aliases;
+}
+
+export function collectMarkdownReferences(markdownText = '', {
+  sourceFilePath = '',
+  targetPathAliases = new Map(),
+  wikiTargetIndex = null,
+} = {}) {
+  const references = [];
+  const lines = String(markdownText ?? '').split('\n');
+
+  for (const line of lines) {
+    const context = line.trim();
+
+    INTERNAL_LINK_RE.lastIndex = 0;
+    let linkMatch;
+    while ((linkMatch = INTERNAL_LINK_RE.exec(line)) !== null) {
+      const rawTarget = String(linkMatch[2] ?? '').trim();
+      if (!rawTarget) {
+        continue;
+      }
+
+      const resolvedPath = resolveWikiTargetWithIndex(rawTarget, wikiTargetIndex)
+        || resolveAliasedTargetPath(rawTarget, wikiTargetIndex, targetPathAliases);
+      references.push({
+        context,
+        isEmbed: Boolean(linkMatch[1]),
+        rawTarget,
+        rawTargetKey: normalizeReferenceTargetKey(rawTarget),
+        resolvedPath,
+        targetPath: resolvedPath || rawTarget,
+      });
+    }
+
+    MARKDOWN_IMAGE_OPEN_RE.lastIndex = 0;
+    while (MARKDOWN_IMAGE_OPEN_RE.exec(line) !== null) {
+      const rawTarget = parseMarkdownImageDestination(line.slice(MARKDOWN_IMAGE_OPEN_RE.lastIndex));
+      const targetPath = resolveMarkdownImageTargetPath(sourceFilePath, rawTarget);
+      if (!targetPath) {
+        continue;
+      }
+
+      const resolvedPath = wikiTargetIndex?.exactPaths?.has?.(targetPath)
+        ? targetPath
+        : resolveAliasedTargetPath(targetPath, wikiTargetIndex, targetPathAliases);
+      references.push({
+        context,
+        isEmbed: true,
+        rawTarget,
+        rawTargetKey: normalizeReferenceTargetKey(targetPath),
+        resolvedPath,
+        targetPath,
+      });
+    }
+  }
+
+  return references;
+}