collabmd 0.1.34 → 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 });
   }
 
   /**
@@ -514,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);
@@ -594,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);
   }
@@ -629,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);
       });
     });
@@ -648,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;
@@ -666,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;
+}

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -108,6 +108,41 @@ function replacePathPrefix(pathValue, oldPrefix, newPrefix) {
   return `${newPrefix}${pathValue.slice(oldPrefix.length)}`;
 }
 
+function collectAncestorDirectoryPaths(pathValue) {
+  const normalizedPath = String(pathValue ?? '').replace(/\\/g, '/').trim();
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments = normalizedPath.split('/').filter(Boolean);
+  const ancestors = [];
+  let currentPath = '';
+  for (let index = 0; index < Math.max(segments.length - 1, 0); index += 1) {
+    currentPath = currentPath ? `${currentPath}/${segments[index]}` : segments[index];
+    ancestors.push(currentPath);
+  }
+
+  return ancestors;
+}
+
+function expandManagedPaths(paths = []) {
+  const expandedPaths = new Set();
+
+  paths.filter(Boolean).forEach((pathValue) => {
+    const normalizedPath = String(pathValue ?? '').replace(/\\/g, '/').trim();
+    if (!normalizedPath) {
+      return;
+    }
+
+    expandedPaths.add(normalizedPath);
+    collectAncestorDirectoryPaths(normalizedPath).forEach((ancestorPath) => {
+      expandedPaths.add(ancestorPath);
+    });
+  });
+
+  return sortWorkspacePaths(Array.from(expandedPaths));
+}
+
 function sortWorkspacePaths(paths = [], direction = 'asc') {
   const factor = direction === 'desc' ? -1 : 1;
   return [...paths].sort((left, right) => {
@@ -833,7 +868,7 @@ export class VaultFileStore {
     }
 
     try {
-      await this.runManagedWrite([filePath], async () => {
+      await this.runManagedWrite(expandManagedPaths([filePath]), async () => {
         await rm(absolute, { force: true });
         await this.sidecarStore.deleteAllForFile(filePath);
       });
@@ -858,7 +893,7 @@ export class VaultFileStore {
     }
 
     try {
-      await this.runManagedWrite([oldPath, newPath], async () => {
+      await this.runManagedWrite(expandManagedPaths([oldPath, newPath]), async () => {
         await mkdir(dirname(absoluteNew), { recursive: true });
         await rename(absoluteOld, absoluteNew);
         await this.sidecarStore.renameAllForFile(oldPath, newPath);
@@ -901,7 +936,7 @@ export class VaultFileStore {
     const nextManagedPaths = managedPaths.map((pathValue) => replacePathPrefix(pathValue, oldPath, newPath));
 
     try {
-      await this.runManagedWrite([oldPath, newPath, ...managedPaths, ...nextManagedPaths], async () => {
+      await this.runManagedWrite(expandManagedPaths([oldPath, newPath, ...managedPaths, ...nextManagedPaths]), async () => {
         await mkdir(dirname(absoluteNew), { recursive: true });
         await rename(absoluteOld, absoluteNew);
         await Promise.all(
@@ -943,7 +978,7 @@ export class VaultFileStore {
         }
       }
 
-      await this.runManagedWrite([dirPath, ...managedPaths], async () => {
+      await this.runManagedWrite(expandManagedPaths([dirPath, ...managedPaths]), async () => {
         if (recursive) {
           await rm(absolute, { force: true, recursive: true });
         } else {