@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/resource-lock.mjs

@@ -0,0 +1,1014 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { snapshot } from "@mnaoumov/typescript-lib/array";
+import { convertAsyncToSync } from "@mnaoumov/typescript-lib/async";
+import { Beeper } from "@mnaoumov/typescript-lib/beeper";
+import {
+  CallbackDisposable,
+  MultipleDisposeBehavior
+} from "@mnaoumov/typescript-lib/disposable";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { assertNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { ViewType } from "@obsidian-typings/obsidian-public-latest/implementations";
+import {
+  FileManager,
+  MarkdownView,
+  Menu,
+  setIcon,
+  setTooltip,
+  Vault
+} from "obsidian";
+import { ComponentEx } from "./components/component-ex.mjs";
+import { MonkeyAroundComponent } from "./components/monkey-around-component.mjs";
+import { toggleEditorReadOnly } from "./editor.mjs";
+import { getPath } from "./file-system.mjs";
+import { appendCodeBlock } from "./html-element.mjs";
+import { t } from "./i18n/i18n.mjs";
+import { confirm } from "./modals/confirm.mjs";
+import { getObsidianDevUtilsState } from "./obsidian-dev-utils-state.mjs";
+import {
+  isChild,
+  isChildOrSelf
+} from "./vault.mjs";
+const RESOURCE_LOCK_STATE_KEY = "resourceLock";
+const LOCK_ICON_ID = "lock";
+const LOCK_INDICATOR_CSS_CLASS = "obsidian-dev-utils-lock-indicator";
+const LOCK_INDICATOR_FLASH_CSS_CLASS = "obsidian-dev-utils-lock-indicator-flash";
+const STATUS_BAR_ITEM_CSS_CLASS = "status-bar-item";
+const STATUS_BAR_CSS_SELECTOR = ".status-bar";
+const UNLOCK_ICON_ID = "unlock";
+const MIDDLE_MOUSE_BUTTON = 1;
+class ResourceLockEventsComponent extends ComponentEx {
+  app;
+  onChange;
+  onExternalMutation;
+  onFileMenu;
+  onRename;
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.onChange = params.onChange;
+    this.onExternalMutation = params.onExternalMutation;
+    this.onFileMenu = params.onFileMenu;
+    this.onRename = params.onRename;
+  }
+  onload() {
+    super.onload();
+    this.registerEvent(this.app.workspace.on("active-leaf-change", this.onChange));
+    this.registerEvent(this.app.workspace.on("layout-change", this.onChange));
+    this.registerEvent(this.app.workspace.on("file-open", this.onChange));
+    this.registerEvent(this.app.workspace.on("file-menu", this.onFileMenu));
+    this.registerEvent(this.app.vault.on("create", (file) => {
+      this.onExternalMutation(file.path);
+    }));
+    this.registerEvent(this.app.vault.on("delete", (file) => {
+      this.onExternalMutation(file.path);
+    }));
+    this.registerEvent(this.app.vault.on("rename", (file, oldPath) => {
+      this.onRename(oldPath, file.path);
+      this.onExternalMutation(oldPath);
+      this.onExternalMutation(file.path);
+    }));
+    this.registerEvent(this.app.metadataCache.on("deleted", (file) => {
+      this.onExternalMutation(file.path);
+    }));
+  }
+}
+class ResourceLockManager {
+  beeper = new Beeper();
+  // The inner sets are mutable so a rename can re-key the paths of an in-flight bypass scope in place;
+  // the scope's `Disposable` deletes by set identity, so mutating the contents cannot orphan it.
+  bypassPathSets = /* @__PURE__ */ new Set();
+  eventsComponent = null;
+  indicatorsByView = /* @__PURE__ */ new Map();
+  lockEntriesByPath = /* @__PURE__ */ new Map();
+  mutationBlockerComponent = null;
+  statusBarItemEl = null;
+  bypass(app, pathsOrFiles) {
+    const bypassedPaths = new Set(pathsOrFiles.map((pathOrFile) => getPath(app, pathOrFile)));
+    this.bypassPathSets.add(bypassedPaths);
+    return new CallbackDisposable({
+      callback: () => {
+        this.bypassPathSets.delete(bypassedPaths);
+      },
+      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
+    });
+  }
+  /**
+   * Fully unlocks the note at the given path. Resolves the lock covering it — the path itself when
+   * directly locked, otherwise the enclosing `subtree`-locked folder — then aborts every
+   * {@link AbortController} registered on that owner (cancelling the operations that took the locks)
+   * AND removes the owner's lock entries (releasing the lock unconditionally). Unlike
+   * {@link requestUnlock}, which only aborts the exact path's controllers and relies on each operation
+   * releasing its own lock, this resolves ancestor coverage and always releases — so a note held by an
+   * indefinitely-held lock is guaranteed to become editable. A no-op when nothing covers the path.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file of the note to unlock.
+   */
+  forceUnlock(app, pathOrFile) {
+    const ownerPath = this.resolveLockOwnerPath(app, getPath(app, pathOrFile));
+    if (ownerPath === null) {
+      return;
+    }
+    this.abortAndReleaseEntries(app, ownerPath);
+  }
+  isLocked(app, pathOrFile) {
+    return this.isPathLocked(getPath(app, pathOrFile));
+  }
+  /**
+   * Checks whether the given path is locked directly or is covered by a `subtree`-locked ancestor
+   * folder.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if the path is itself locked or lies under a `subtree`-locked folder.
+   */
+  isLockedByAncestor(app, pathOrFile) {
+    return this.resolveLockOwnerPath(app, getPath(app, pathOrFile)) !== null;
+  }
+  /**
+   * Checks whether the given path is covered by a mutation-blocking lock (one taken with
+   * `blocksMutations`) directly or on a `subtree`-locked ancestor folder.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if a mutation of the path is currently blocked.
+   */
+  isMutationBlockedByAncestor(app, pathOrFile) {
+    const path = getPath(app, pathOrFile);
+    const exactEntries = this.lockEntriesByPath.get(path);
+    if (exactEntries?.some((entry) => entry.blocksMutations)) {
+      return true;
+    }
+    for (const [lockedPath, entries] of this.lockEntriesByPath) {
+      if (entries.some((entry) => entry.mode === "subtree" && entry.blocksMutations) && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath })) {
+        return true;
+      }
+    }
+    return false;
+  }
+  lock(params) {
+    const { app } = params;
+    const path = getPath(app, params.pathOrFile);
+    const entry = {
+      abortController: params.abortController ?? null,
+      blocksMutations: params.blocksMutations ?? false,
+      mode: params.mode ?? "file",
+      onUnlockRequested: params.onUnlockRequested ?? null,
+      operationName: params.operationName,
+      path,
+      pluginId: params.pluginId,
+      shouldReleaseOnAbort: params.shouldReleaseOnAbort ?? false
+    };
+    let entries = this.lockEntriesByPath.get(path);
+    if (!entries) {
+      entries = [];
+      this.lockEntriesByPath.set(path, entries);
+    }
+    entries.push(entry);
+    this.ensureSubscribed(app);
+    if (entry.blocksMutations) {
+      this.ensureBlockerInstalled(app);
+    }
+    this.wireReleaseOnAbort(app, entry);
+    this.reconcile(app);
+    return new CallbackDisposable({
+      callback: () => {
+        this.removeEntry(app, entry);
+      },
+      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
+    });
+  }
+  /**
+   * Aborts every {@link AbortController} currently registered for the note at the given path, which
+   * cancels the operations holding the lock. Each operation releases its own lock in its `finally`
+   * when it observes the abort, so this does not unlock the path directly. A no-op when no controller
+   * is registered for the path.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file of the note to request an unlock for.
+   */
+  requestUnlock(app, pathOrFile) {
+    const entries = this.lockEntriesByPath.get(getPath(app, pathOrFile));
+    if (!entries) {
+      return;
+    }
+    for (const entry of entries) {
+      entry.abortController?.abort();
+    }
+  }
+  unlock(app, pathOrFile, pluginId) {
+    const path = getPath(app, pathOrFile);
+    const entries = this.lockEntriesByPath.get(path);
+    if (!entries) {
+      return;
+    }
+    const index = entries.findIndex((entry) => entry.pluginId === pluginId);
+    if (index === -1) {
+      return;
+    }
+    entries.splice(index, 1);
+    if (entries.length === 0) {
+      this.lockEntriesByPath.delete(path);
+    }
+    this.reconcileAndCleanup(app);
+  }
+  unlockAllForPlugin(app, pluginId) {
+    for (const [path, entries] of this.lockEntriesByPath) {
+      const remaining = entries.filter((entry) => entry.pluginId !== pluginId);
+      if (remaining.length === 0) {
+        this.lockEntriesByPath.delete(path);
+      } else if (remaining.length !== entries.length) {
+        this.lockEntriesByPath.set(path, remaining);
+      }
+    }
+    this.reconcileAndCleanup(app);
+  }
+  /**
+   * Aborts every {@link AbortController} on the given (already-resolved) owner path's lock entries —
+   * cancelling the owning operations — and removes those entries, releasing the lock. The entries
+   * snapshot is copied first because an entry's `shouldReleaseOnAbort` abort listener mutates the
+   * array as it fires. Always leaves the owner path with no entries.
+   *
+   * @param app - The Obsidian app instance.
+   * @param ownerPath - The directly-locked owner path whose entries to abort and release.
+   */
+  abortAndReleaseEntries(app, ownerPath) {
+    const entries = this.lockEntriesByPath.get(ownerPath);
+    assertNonNullable(entries);
+    for (const entry of snapshot(entries)) {
+      entry.abortController?.abort();
+    }
+    this.lockEntriesByPath.delete(ownerPath);
+    this.reconcileAndCleanup(app);
+  }
+  addUnlockMenuItem(app, menu, path) {
+    menu.addItem((item) => {
+      item.setTitle(t(($) => $.obsidianDevUtils.resourceLock.unlockMenuItem)).setIcon(UNLOCK_ICON_ID).onClick(convertAsyncToSync(async () => {
+        const isConfirmed = await confirm({
+          app,
+          message: this.unlockConfirmMessage(app, path),
+          title: t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmTitle)
+        });
+        if (isConfirmed) {
+          this.abortAndReleaseEntries(app, path);
+        }
+      }));
+    });
+  }
+  createIndicators(app, view, tooltip) {
+    const getOwnerPath = () => this.resolveViewOwnerPath(app, view);
+    const actionIconEl = view.addAction(LOCK_ICON_ID, tooltip, noop);
+    this.registerUnlockMenu(app, actionIconEl, getOwnerPath);
+    let tabIconEl = null;
+    const tabStatusContainerEl = view.leaf.tabHeaderStatusContainerEl;
+    if (tabStatusContainerEl) {
+      tabIconEl = tabStatusContainerEl.createSpan({ cls: LOCK_INDICATOR_CSS_CLASS });
+      setIcon(tabIconEl, LOCK_ICON_ID);
+      setTooltip(tabIconEl, tooltip);
+      this.registerUnlockMenu(app, tabIconEl, getOwnerPath);
+    }
+    const onTypeAttempt = () => {
+      this.flashIndicators(view);
+      this.beeper.beep();
+    };
+    view.contentEl.addEventListener("beforeinput", onTypeAttempt);
+    return {
+      actionIconEl,
+      disposeTypeListener: () => {
+        view.contentEl.removeEventListener("beforeinput", onTypeAttempt);
+      },
+      tabIconEl
+    };
+  }
+  ensureBlockerInstalled(app) {
+    if (this.mutationBlockerComponent) {
+      return;
+    }
+    this.mutationBlockerComponent = new ResourceLockMutationBlockerComponent({
+      shouldBlockMutation: (path) => this.shouldBlockMutation(app, path)
+    });
+    this.mutationBlockerComponent.load();
+  }
+  ensureSubscribed(app) {
+    if (this.eventsComponent) {
+      return;
+    }
+    this.eventsComponent = new ResourceLockEventsComponent({
+      app,
+      onChange: () => {
+        this.reconcile(app);
+      },
+      onExternalMutation: (path) => {
+        this.handleExternalMutation(app, path);
+      },
+      onFileMenu: (menu, file) => {
+        this.handleFileMenu(app, menu, file);
+      },
+      onRename: (oldPath, newPath) => {
+        this.handleRename(app, oldPath, newPath);
+      }
+    });
+    this.eventsComponent.load();
+  }
+  flashElement(element) {
+    element.removeClass(LOCK_INDICATOR_FLASH_CSS_CLASS);
+    element.getBoundingClientRect();
+    element.addClass(LOCK_INDICATOR_FLASH_CSS_CLASS);
+  }
+  flashIndicators(view) {
+    const indicators = this.indicatorsByView.get(view);
+    for (const element of [indicators?.actionIconEl, indicators?.tabIconEl, this.statusBarItemEl]) {
+      if (element) {
+        this.flashElement(element);
+      }
+    }
+  }
+  /**
+   * Reacts to a vault/metadata event on a path. If the path is mutation-blocked and NOT covered by an
+   * active bypass scope, the change bypassed the blocker patch (sync / filesystem / a raw-adapter
+   * write) — an intruder. Abort the `abortController` of every mutation-blocking lock covering the path
+   * so the owning operation cancels and rolls back. A no-op for the owner's own (bypassed) mutations,
+   * for unblocked paths, and for blocking locks with no `abortController`.
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path the event fired on.
+   */
+  handleExternalMutation(app, path) {
+    if (!this.isMutationBlockedByAncestor(app, path) || this.isBypassed(app, path)) {
+      return;
+    }
+    for (const [lockedPath, entries] of this.lockEntriesByPath) {
+      for (const entry of entries) {
+        if (!entry.blocksMutations || !entry.abortController) {
+          continue;
+        }
+        const doesCoverPath = lockedPath === path || entry.mode === "subtree" && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath });
+        if (doesCoverPath) {
+          entry.abortController.abort();
+        }
+      }
+    }
+  }
+  handleFileMenu(app, menu, file) {
+    const ownerPath = this.resolveLockOwnerPath(app, file.path);
+    if (ownerPath === null) {
+      return;
+    }
+    this.addUnlockMenuItem(app, menu, ownerPath);
+  }
+  /**
+   * Re-keys the registry onto a renamed path, so a lock follows the resource it was taken on. Moves
+   * the entries of the renamed path AND of every descendant key (a folder rename changes a whole path
+   * prefix), and rebases every active {@link ResourceLockManager.bypass} scope the same way — without
+   * that second half an operation that renames a folder it locked would have its OWN later mutations
+   * read as intruders.
+   *
+   * Idempotent: a path that no longer matches is left alone, so it does not matter whether Obsidian
+   * emits the folder's rename event before or after its descendants'.
+   *
+   * @param app - The Obsidian app instance.
+   * @param oldPath - The path the resource was renamed from.
+   * @param newPath - The path the resource was renamed to.
+   */
+  handleRename(app, oldPath, newPath) {
+    const movedEntriesByPath = /* @__PURE__ */ new Map();
+    for (const [lockedPath, entries] of this.lockEntriesByPath) {
+      const rebasedPath = rebasePath(lockedPath, oldPath, newPath);
+      if (rebasedPath === null) {
+        continue;
+      }
+      for (const entry of entries) {
+        entry.path = rebasedPath;
+      }
+      movedEntriesByPath.set(rebasedPath, entries);
+      this.lockEntriesByPath.delete(lockedPath);
+    }
+    for (const [rebasedPath, entries] of movedEntriesByPath) {
+      const existingEntries = this.lockEntriesByPath.get(rebasedPath);
+      if (existingEntries) {
+        existingEntries.push(...entries);
+      } else {
+        this.lockEntriesByPath.set(rebasedPath, entries);
+      }
+    }
+    for (const bypassedPaths of this.bypassPathSets) {
+      const rebasedBypassedPaths = /* @__PURE__ */ new Map();
+      for (const bypassedPath of bypassedPaths) {
+        const rebasedPath = rebasePath(bypassedPath, oldPath, newPath);
+        if (rebasedPath !== null) {
+          rebasedBypassedPaths.set(bypassedPath, rebasedPath);
+        }
+      }
+      for (const [bypassedPath, rebasedPath] of rebasedBypassedPaths) {
+        bypassedPaths.delete(bypassedPath);
+        bypassedPaths.add(rebasedPath);
+      }
+    }
+    this.reconcile(app);
+  }
+  hasBlockingLock() {
+    for (const entries of this.lockEntriesByPath.values()) {
+      if (entries.some((entry) => entry.blocksMutations)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Checks whether the path is covered by an active {@link ResourceLockManager.bypass} scope — the
+   * owner declaring that its own mutations of the path (and, for a folder, its subtree) are sanctioned.
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path being mutated.
+   * @returns `true` if some active bypass scope covers the path.
+   */
+  isBypassed(app, path) {
+    for (const bypassedPaths of this.bypassPathSets) {
+      for (const bypassedPath of bypassedPaths) {
+        if (isChildOrSelf({ app, childPathOrFile: path, parentPathOrFile: bypassedPath })) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  isPathLocked(path) {
+    return (this.lockEntriesByPath.get(path)?.length ?? 0) > 0;
+  }
+  /**
+   * Builds the deduplicated list of `(plugin name, operation name)` pairs describing the locks on a
+   * path — one per distinct plugin+operation. Drives the unlock confirmation, so the user sees exactly
+   * which operations an unlock would cancel. Only ever called for a locked path, so its entries are
+   * always present.
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The directly-locked path whose lock descriptors to build.
+   * @returns The distinct lock descriptors covering the path.
+   */
+  lockDescriptors(app, path) {
+    const entries = this.lockEntriesByPath.get(path);
+    assertNonNullable(entries);
+    const seen = /* @__PURE__ */ new Set();
+    const descriptors = [];
+    for (const entry of entries) {
+      const pluginName = app.plugins.manifests[entry.pluginId]?.name ?? entry.pluginId;
+      const key = `${pluginName}
+${entry.operationName}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      descriptors.push({ operationName: entry.operationName, pluginName });
+    }
+    return descriptors;
+  }
+  lockingPluginNames(app, path) {
+    const entries = this.lockEntriesByPath.get(path);
+    assertNonNullable(entries);
+    const pluginIds = [...new Set(entries.map((entry) => entry.pluginId))];
+    return pluginIds.map((pluginId) => app.plugins.manifests[pluginId]?.name ?? pluginId);
+  }
+  lockTooltip(app, path) {
+    const header = t(($) => $.obsidianDevUtils.resourceLock.lockedByTooltip);
+    return [header, ...this.lockingPluginNames(app, path)].join("\n");
+  }
+  reconcile(app) {
+    const viewsToLock = /* @__PURE__ */ new Set();
+    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+      const view = leaf.view;
+      if (!(view instanceof MarkdownView)) {
+        continue;
+      }
+      const path = view.file?.path;
+      if (path === void 0) {
+        continue;
+      }
+      const ownerPath = this.resolveLockOwnerPath(app, path);
+      if (ownerPath === null) {
+        continue;
+      }
+      viewsToLock.add(view);
+      const tooltip = this.lockTooltip(app, ownerPath);
+      toggleEditorReadOnly(view.editor, true);
+      const indicators = this.indicatorsByView.get(view);
+      if (indicators) {
+        this.updateIndicatorTooltips(indicators, tooltip);
+      } else {
+        this.indicatorsByView.set(view, this.createIndicators(app, view, tooltip));
+      }
+    }
+    for (const [view, indicators] of this.indicatorsByView) {
+      if (viewsToLock.has(view)) {
+        continue;
+      }
+      toggleEditorReadOnly(view.editor, false);
+      indicators.disposeTypeListener();
+      indicators.actionIconEl.remove();
+      indicators.tabIconEl?.remove();
+      this.indicatorsByView.delete(view);
+    }
+    this.updateStatusBar(app);
+  }
+  reconcileAndCleanup(app) {
+    this.reconcile(app);
+    if (this.lockEntriesByPath.size === 0) {
+      this.eventsComponent?.unload();
+      this.eventsComponent = null;
+    }
+    if (this.hasBlockingLock()) {
+      return;
+    }
+    this.mutationBlockerComponent?.unload();
+    this.mutationBlockerComponent = null;
+  }
+  registerUnlockMenu(app, element, getContextPath) {
+    const openUnlockMenu = ($event) => {
+      $event.preventDefault();
+      const path = getContextPath();
+      if (path === void 0) {
+        return;
+      }
+      const menu = new Menu();
+      this.addUnlockMenuItem(app, menu, path);
+      menu.showAtMouseEvent($event);
+    };
+    element.addEventListener("click", openUnlockMenu);
+    element.addEventListener("contextmenu", openUnlockMenu);
+    element.addEventListener("auxclick", ($event) => {
+      if ($event.button === MIDDLE_MOUSE_BUTTON) {
+        openUnlockMenu($event);
+      }
+    });
+  }
+  removeEntry(app, entry) {
+    const entries = this.lockEntriesByPath.get(entry.path);
+    if (!entries) {
+      return;
+    }
+    const index = entries.indexOf(entry);
+    if (index === -1) {
+      return;
+    }
+    entries.splice(index, 1);
+    if (entries.length === 0) {
+      this.lockEntriesByPath.delete(entry.path);
+    }
+    this.reconcileAndCleanup(app);
+  }
+  /**
+   * Resolves which locked path (if any) covers the given path: the path itself when directly locked,
+   * otherwise the longest `subtree`-locked ancestor folder that contains it (longest so a nested
+   * subtree lock wins deterministically over an outer one).
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path to resolve an owner lock for.
+   * @returns The covering locked path, or `null` when nothing covers it.
+   */
+  resolveLockOwnerPath(app, path) {
+    if (this.isPathLocked(path)) {
+      return path;
+    }
+    let bestOwnerPath = null;
+    for (const [lockedPath, entries] of this.lockEntriesByPath) {
+      const hasSubtreeLock = entries.some((entry) => entry.mode === "subtree");
+      if (hasSubtreeLock && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath }) && (bestOwnerPath === null || lockedPath.length > bestOwnerPath.length)) {
+        bestOwnerPath = lockedPath;
+      }
+    }
+    return bestOwnerPath;
+  }
+  /**
+   * Resolves the lock covering the note a view currently shows — its own path when directly locked,
+   * otherwise the enclosing `subtree`-locked folder. Read at click time by the view's lock indicators,
+   * so it reflects renames of the note and of the locked folder alike.
+   *
+   * @param app - The Obsidian app instance.
+   * @param view - The view whose current file to resolve an owner lock for.
+   * @returns The covering locked path, or `undefined` when the view has no file or nothing covers it.
+   */
+  resolveViewOwnerPath(app, view) {
+    const path = view.file?.path;
+    return path === void 0 ? void 0 : this.resolveLockOwnerPath(app, path) ?? void 0;
+  }
+  /**
+   * Decides whether a mutation of the path must be blocked: `true` when the path is mutation-blocked
+   * and not covered by any active {@link ResourceLockManager.bypass} scope.
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path being mutated.
+   * @returns `true` to reject the mutation, `false` to allow it.
+   */
+  shouldBlockMutation(app, path) {
+    return this.isMutationBlockedByAncestor(app, path) && !this.isBypassed(app, path);
+  }
+  unlockConfirmMessage(app, path) {
+    const fragment = createFragment();
+    fragment.appendText(t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmMessage));
+    for (const descriptor of this.lockDescriptors(app, path)) {
+      fragment.createEl("br");
+      appendCodeBlock(fragment, descriptor.pluginName);
+      fragment.appendText(`: ${descriptor.operationName}`);
+    }
+    return fragment;
+  }
+  updateIndicatorTooltips(indicators, tooltip) {
+    setTooltip(indicators.actionIconEl, tooltip);
+    if (indicators.tabIconEl) {
+      setTooltip(indicators.tabIconEl, tooltip);
+    }
+  }
+  updateStatusBar(app) {
+    const activeView = app.workspace.getActiveViewOfType(MarkdownView);
+    const activePath = activeView?.file?.path;
+    const activeOwnerPath = activePath === void 0 ? null : this.resolveLockOwnerPath(app, activePath);
+    if (activeOwnerPath === null || !activeView) {
+      this.statusBarItemEl?.remove();
+      this.statusBarItemEl = null;
+      return;
+    }
+    if (!this.statusBarItemEl) {
+      const statusBarEl = activeView.containerEl.ownerDocument.body.querySelector(STATUS_BAR_CSS_SELECTOR);
+      if (!statusBarEl) {
+        return;
+      }
+      this.statusBarItemEl = statusBarEl.createDiv({ cls: [STATUS_BAR_ITEM_CSS_CLASS, LOCK_INDICATOR_CSS_CLASS] });
+      setIcon(this.statusBarItemEl, LOCK_ICON_ID);
+      this.registerUnlockMenu(app, this.statusBarItemEl, () => {
+        const path = app.workspace.getActiveViewOfType(MarkdownView)?.file?.path;
+        return path === void 0 ? void 0 : this.resolveLockOwnerPath(app, path) ?? void 0;
+      });
+    }
+    setTooltip(this.statusBarItemEl, this.lockTooltip(app, activeOwnerPath));
+  }
+  /**
+   * Wires an opt-in `abort` listener for a lock entry: when the entry's controller aborts, releases
+   * the entry (if {@link LockEntry.shouldReleaseOnAbort}) and/or invokes
+   * {@link LockEntry.onUnlockRequested}. A no-op when the entry has no controller or neither opt-in is
+   * set, so transactional locks keep releasing via their own cleanup.
+   *
+   * @param app - The Obsidian app instance.
+   * @param entry - The lock entry whose controller to observe.
+   */
+  wireReleaseOnAbort(app, entry) {
+    const { onUnlockRequested, shouldReleaseOnAbort } = entry;
+    if (!entry.abortController || !shouldReleaseOnAbort && !onUnlockRequested) {
+      return;
+    }
+    entry.abortController.signal.addEventListener("abort", () => {
+      if (shouldReleaseOnAbort) {
+        this.removeEntry(app, entry);
+      }
+      onUnlockRequested?.();
+    }, { once: true });
+  }
+}
+class ResourceLockMutationBlockerComponent extends MonkeyAroundComponent {
+  shouldBlockMutation;
+  constructor(params) {
+    super();
+    this.shouldBlockMutation = params.shouldBlockMutation;
+  }
+  onload() {
+    super.onload();
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "append",
+      patchHandler: ({ fallback, originalArguments: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "copy",
+      patchHandler: ({ fallback, originalArguments: [, newPath] }) => {
+        this.assertNotBlocked([newPath]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "create",
+      patchHandler: ({ fallback, originalArguments: [path] }) => {
+        this.assertNotBlocked([path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "createBinary",
+      patchHandler: ({ fallback, originalArguments: [path] }) => {
+        this.assertNotBlocked([path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "createFolder",
+      patchHandler: ({ fallback, originalArguments: [path] }) => {
+        this.assertNotBlocked([path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "delete",
+      patchHandler: ({ fallback, originalArguments: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "modify",
+      patchHandler: ({ fallback, originalArguments: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "modifyBinary",
+      patchHandler: ({ fallback, originalArguments: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "process",
+      patchHandler: ({ fallback, originalArguments: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "rename",
+      patchHandler: ({ fallback, originalArguments: [file, newPath] }) => {
+        this.assertNotBlocked([file.path, newPath]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "trash",
+      patchHandler: ({ fallback, originalArguments: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: FileManager.prototype,
+      methodName: "renameFile",
+      patchHandler: ({ fallback, originalArguments: [file, newPath] }) => {
+        this.assertNotBlocked([file.path, newPath]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      $object: FileManager.prototype,
+      methodName: "trashFile",
+      patchHandler: ({ fallback, originalArguments: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+  }
+  assertNotBlocked(paths) {
+    for (const path of paths) {
+      if (this.shouldBlockMutation(path)) {
+        throw new ResourceLockedError(path);
+      }
+    }
+  }
+}
+class ResourceLockComponent extends ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to it for
+   * reference-counting and the indicators' "locked by" tooltip.
+   */
+  pluginId;
+  /**
+   * Creates an resource-lock handle owned by a plugin.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pluginId - The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to
+   * it for reference-counting and the indicators' "locked by" tooltip.
+   */
+  constructor(app, pluginId) {
+    super();
+    this.app = app;
+    this.pluginId = pluginId;
+  }
+  /**
+   * Opens an **ambient bypass scope**: while the returned {@link Disposable} is not disposed, this
+   * plugin's own mutations of the given paths (and, for a folder, its whole subtree) pass through the
+   * mutation blocker instead of throwing {@link ResourceLockedError}. Any mutation of a blocked path
+   * NOT covered by an active bypass scope is still rejected. Use it with a `using` declaration around
+   * the operation that legitimately mutates resources it has locked with
+   * {@link ResourceLockComponentLockForPathParams.shouldBlockMutations}:
+   *
+   * ```ts
+   * using _bypass = component.bypassBlockedMutations([sourceFile, targetFile]);
+   * // ... the operation's own vault mutations of those paths are allowed ...
+   * // scope end: the paths are enforced again
+   * ```
+   *
+   * @param pathsOrFiles - The paths (or files/folders) whose mutation by this operation is sanctioned.
+   * @returns A {@link Disposable} that ends the bypass scope when disposed.
+   */
+  bypassBlockedMutations(pathsOrFiles) {
+    return getManager().bypass(this.app, pathsOrFiles);
+  }
+  /**
+   * Checks whether the path is locked directly or lies under a `subtree`-locked ancestor folder.
+   *
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if the path is itself locked or is covered by a `subtree` lock on an ancestor.
+   */
+  isLockedByAncestorForPath(pathOrFile) {
+    return getManager().isLockedByAncestor(this.app, pathOrFile);
+  }
+  /**
+   * Checks whether the note at the given path is currently locked by any plugin.
+   *
+   * @param pathOrFile - The path or file of the note to check.
+   * @returns `true` if the note has at least one active lock, `false` otherwise.
+   */
+  isLockedForPath(pathOrFile) {
+    return getManager().isLocked(this.app, pathOrFile);
+  }
+  /**
+   * Checks whether a vault mutation of the path is currently blocked by a `shouldBlockMutations` lock
+   * on the path itself or on a `subtree`-locked ancestor folder.
+   *
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if editing/deleting/renaming/moving/creating the path would throw a
+   * {@link ResourceLockedError}.
+   */
+  isMutationBlockedByAncestorForPath(pathOrFile) {
+    return getManager().isMutationBlockedByAncestor(this.app, pathOrFile);
+  }
+  /**
+   * Locks the note at the given path on behalf of this plugin, making it read-only in every current
+   * and future {@link MarkdownView} until the lock is released. Reference-counted: balance each call
+   * with a dispose of the returned {@link Disposable} (ideally via `using`) or {@link unlockForPath}.
+   *
+   * @param params - Locking parameters. Its {@link ResourceLockComponentLockForPathParams.pathOrFile}
+   * and {@link ResourceLockComponentLockForPathParams.operationName} are required (the latter is shown
+   * in the unlock confirmation). Pass an {@link ResourceLockComponentLockForPathParams.abortController}
+   * to make the lock cancelable via a lock indicator's "unlock" menu, the "Unlock active note" command,
+   * or {@link requestResourceUnlockForPath}.
+   * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+   */
+  lockForPath(params) {
+    return getManager().lock({
+      abortController: params.abortController,
+      app: this.app,
+      blocksMutations: params.shouldBlockMutations,
+      mode: params.mode,
+      onUnlockRequested: params.onUnlockRequested,
+      operationName: params.operationName,
+      pathOrFile: params.pathOrFile,
+      pluginId: this.pluginId,
+      shouldReleaseOnAbort: params.shouldReleaseOnAbort
+    });
+  }
+  /**
+   * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,
+   * so no note is left stuck read-only by an operation that never completed.
+   */
+  onunload() {
+    getManager().unlockAllForPlugin(this.app, this.pluginId);
+    super.onunload();
+  }
+  /**
+   * Fully unlocks the note at the given path: resolves the lock covering it (the path itself when
+   * directly locked, otherwise a `subtree`-locked ancestor folder), cancels the operation(s) that took
+   * the lock by aborting their {@link AbortController}s, and releases the lock so the note becomes
+   * editable — regardless of which plugin holds the lock. Powers the "Unlock active note" command. A
+   * no-op when nothing covers the path.
+   *
+   * @param pathOrFile - The path or file of the note to unlock.
+   */
+  requestUnlockForPath(pathOrFile) {
+    getManager().forceUnlock(this.app, pathOrFile);
+  }
+  /**
+   * Releases one lock previously acquired for the note at the given path via {@link lockForPath}.
+   *
+   * @param pathOrFile - The path or file of the note to unlock.
+   */
+  unlockForPath(pathOrFile) {
+    getManager().unlock(this.app, pathOrFile, this.pluginId);
+  }
+}
+class ResourceLockedError extends Error {
+  /**
+   * The vault path whose mutation was blocked.
+   */
+  path;
+  /**
+   * Creates a {@link ResourceLockedError}.
+   *
+   * @param path - The vault path whose mutation was blocked.
+   */
+  constructor(path) {
+    super(`The resource "${path}" is locked and cannot be mutated.`);
+    this.name = "ResourceLockedError";
+    this.path = path;
+  }
+}
+function isResourceLockedForPath(app, pathOrFile) {
+  return getManager().isLocked(app, pathOrFile);
+}
+function isResourceLockedForPathByAncestor(app, pathOrFile) {
+  return getManager().isLockedByAncestor(app, pathOrFile);
+}
+function lockResourceForPath(params) {
+  return getManager().lock({
+    app: params.app,
+    operationName: params.operationName,
+    pathOrFile: params.pathOrFile,
+    pluginId: params.pluginId
+  });
+}
+function requestResourceUnlockForPath(app, pathOrFile) {
+  getManager().requestUnlock(app, pathOrFile);
+}
+function unlockResourceForPath(app, pathOrFile, pluginId) {
+  getManager().unlock(app, pathOrFile, pluginId);
+}
+function getManager() {
+  return getObsidianDevUtilsState(RESOURCE_LOCK_STATE_KEY, new ResourceLockManager()).value;
+}
+function rebasePath(path, oldPath, newPath) {
+  if (path === oldPath) {
+    return newPath;
+  }
+  return path.startsWith(`${oldPath}/`) ? newPath + path.slice(oldPath.length) : null;
+}
+export {
+  ResourceLockComponent,
+  ResourceLockedError,
+  isResourceLockedForPath,
+  isResourceLockedForPathByAncestor,
+  lockResourceForPath,
+  requestResourceUnlockForPath,
+  unlockResourceForPath
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/resource-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Path-scoped resource locking for vault files and folders, with three enforcement layers over one\n * shared locked-path set:\n *\n * 1. **Editor read-only** \u2014 while a path is locked, every current and future {@link MarkdownView} of\n *    that note (in any window, including popouts) is made read-only and shows a lock indicator in its\n *    tab header, its view action bar, and the status bar; a note inside a `subtree`-locked folder is\n *    covered too. Locks are reference-counted per locking plugin (the indicators' tooltip lists which\n *    plugins hold a lock), so nested/concurrent operations are safe \u2014 the path is unlocked only when\n *    the last lock is released.\n * 2. **Vault-mutation blocking** (opt-in via `shouldBlockMutations`) \u2014 any edit/delete/rename/move/\n *    create of a locked path through the `Vault`/`FileManager` API throws {@link ResourceLockedError},\n *    unless the owning operation has opened a {@link ResourceLockComponent.bypassBlockedMutations} scope\n *    over that path.\n * 3. **External-change detection** \u2014 a vault/metadata event on a locked path that no bypass scope\n *    covers is treated as an intruder (Sync / raw filesystem / another plugin) and aborts the owning\n *    operation's {@link AbortController}.\n *\n * A lock **follows its resource across a rename**: when a locked path (or an ancestor folder of it) is\n * renamed, the lock registry and every active bypass scope are re-keyed onto the new path, so a\n * multi-step operation that renames a folder it locked keeps its coverage for the rest of the\n * transaction.\n *\n * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration that\n * releases automatically at scope exit (including on throw):\n *\n * ```ts\n * using _lock = lockResourceForPath({ app, pathOrFile: path, pluginId: this.manifest.id, operationName: 'Process note' });\n * // ... long-running work (process, processFrontMatter, merge/split) ...\n * // auto-unlocked at scope exit\n * ```\n *\n * The explicit {@link unlockResourceForPath} pair remains available for non-`using` call sites.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { convertAsyncToSync } from '@mnaoumov/typescript-lib/async';\nimport { Beeper } from '@mnaoumov/typescript-lib/beeper';\nimport {\n  CallbackDisposable,\n  MultipleDisposeBehavior\n} from '@mnaoumov/typescript-lib/disposable';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  FileManager,\n  MarkdownView,\n  Menu,\n  setIcon,\n  setTooltip,\n  Vault\n} from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport { ComponentEx } from './components/component-ex.ts';\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { toggleEditorReadOnly } from './editor.ts';\nimport { getPath } from './file-system.ts';\nimport { appendCodeBlock } from './html-element.ts';\nimport { t } from './i18n/i18n.ts';\nimport { confirm } from './modals/confirm.ts';\nimport { getObsidianDevUtilsState } from './obsidian-dev-utils-state.ts';\nimport {\n  isChild,\n  isChildOrSelf\n} from './vault.ts';\n\nconst RESOURCE_LOCK_STATE_KEY = 'resourceLock';\nconst LOCK_ICON_ID = 'lock';\nconst LOCK_INDICATOR_CSS_CLASS = 'obsidian-dev-utils-lock-indicator';\nconst LOCK_INDICATOR_FLASH_CSS_CLASS = 'obsidian-dev-utils-lock-indicator-flash';\nconst STATUS_BAR_ITEM_CSS_CLASS = 'status-bar-item';\nconst STATUS_BAR_CSS_SELECTOR = '.status-bar';\nconst UNLOCK_ICON_ID = 'unlock';\nconst MIDDLE_MOUSE_BUTTON = 1;\n\n/**\n * Parameters for {@link lockResourceForPath}.\n */\nexport interface LockResourceForPathParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * A human-readable name of the operation taking the lock (e.g. `'Move selection'`). Shown next to\n   * the plugin name in the unlock confirmation dialog.\n   */\n  readonly operationName: string;\n\n  /**\n   * The path or file of the note to lock.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * The id of the locking plugin (e.g. its `manifest.id`). The lock is attributed to it for\n   * reference-counting and the indicators' \"locked by\" tooltip.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link ResourceLockComponent.lockForPath}.\n */\nexport interface ResourceLockComponentLockForPathParams {\n  /**\n   * An optional {@link AbortController} associated with the lock. When a lock indicator is clicked (with\n   * any mouse button) and the user confirms an unlock, the \"Unlock active note\" command runs, or\n   * {@link ResourceLockComponent.requestUnlockForPath} / {@link requestResourceUnlockForPath} is called\n   * for the path, this controller is aborted so the operation holding the lock can cancel itself. Unless\n   * {@link ResourceLockComponentLockForPathParams.shouldReleaseOnAbort} is set, the operation is\n   * expected to release the lock in its own cleanup. When omitted, an unlock still releases the lock but\n   * cannot cancel the operation that took it.\n   */\n  readonly abortController?: AbortController;\n\n  /**\n   * The lock scope. `'subtree'` also locks every descendant of a folder path; `'file'` locks only the\n   * exact path. A `subtree` lock must be released via the returned {@link Disposable} (not the\n   * explicit {@link ResourceLockComponent.unlockForPath}).\n   *\n   * @default `'file'`\n   */\n  readonly mode?: ResourceLockMode;\n\n  /**\n   * When provided, this callback is invoked when an unlock of the lock is requested \u2014 i.e. when the\n   * lock's {@link ResourceLockComponentLockForPathParams.abortController} is aborted (by the\n   * indicator's \"Unlock\" menu, the \"Unlock active note\" command, {@link ResourceLockComponent.requestUnlockForPath},\n   * or {@link handleExternalMutation}). Use it to clear consumer-side state that shadows the lock (e.g.\n   * a pending-operation buffer or a notice) without hand-wiring an `abort` listener. Fires at most once.\n   */\n  readonly onUnlockRequested?: () => void;\n\n  /**\n   * A human-readable name of the operation that took the lock (e.g. `'Move selection'`, `'Merge\n   * notes'`). It is shown \u2014 next to the locking plugin's name \u2014 in the unlock confirmation dialog, so\n   * the user sees exactly which operation an unlock would cancel.\n   */\n  readonly operationName: string;\n\n  /**\n   * The path or file of the note to lock.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * When `true`, the lock also **blocks vault mutations** of the covered path(s): any attempt to edit,\n   * delete, rename, move, or (re)create the resource through the `Vault`/`FileManager` API throws a\n   * {@link ResourceLockedError}. Installed lazily on the first such lock and removed when the last one\n   * is released. When `false` (the default) the lock only makes the editor read-only \u2014 legacy behavior,\n   * so existing consumers that write to a note they hold an editor lock on are unaffected.\n   *\n   * @default `false`\n   */\n  readonly shouldBlockMutations?: boolean;\n\n  /**\n   * When `true`, the lock releases itself the moment its\n   * {@link ResourceLockComponentLockForPathParams.abortController} is aborted, instead of relying on\n   * the owning operation to release it in its own cleanup. Use it for a lock held **indefinitely**\n   * outside a `using` scope (so there is no `finally` to release it) \u2014 e.g. a lock that stays until the\n   * user explicitly unlocks. Leave it `false` for a transactional operation that holds the lock through\n   * its own abort-driven rollback and releases it via `using` at scope exit. Has no effect without an\n   * {@link ResourceLockComponentLockForPathParams.abortController}.\n   *\n   * @default `false`\n   */\n  readonly shouldReleaseOnAbort?: boolean;\n}\n\n/**\n * The scope of a lock.\n *\n * - `'file'` locks only the exact path.\n * - `'subtree'` locks the path and every descendant under it (its whole folder subtree), so a file\n *   inside a `subtree`-locked folder is treated as locked too.\n */\nexport type ResourceLockMode = 'file' | 'subtree';\n\ninterface LockDescriptor {\n  readonly operationName: string;\n  readonly pluginName: string;\n}\n\ninterface LockEntry {\n  readonly abortController: AbortController | null;\n  readonly blocksMutations: boolean;\n  readonly mode: ResourceLockMode;\n  readonly onUnlockRequested: (() => void) | null;\n  readonly operationName: string;\n  /**\n   * The path the entry is currently registered under. Deliberately mutable: a rename re-keys the\n   * registry, and release must find the entry at its CURRENT path \u2014 a release that captured the path\n   * at lock time would silently no-op after the resource moved, leaking the lock forever.\n   */\n  path: string;\n  readonly pluginId: string;\n  readonly shouldReleaseOnAbort: boolean;\n}\n\ninterface LockIndicators {\n  readonly actionIconEl: HTMLElement;\n  disposeTypeListener: () => void;\n  readonly tabIconEl: HTMLElement | null;\n}\n\ninterface ManagerLockParams {\n  readonly abortController?: AbortController | undefined;\n  readonly app: App;\n  readonly blocksMutations?: boolean | undefined;\n  readonly mode?: ResourceLockMode | undefined;\n  readonly onUnlockRequested?: (() => void) | undefined;\n  readonly operationName: string;\n  readonly pathOrFile: PathOrFile;\n  readonly pluginId: string;\n  readonly shouldReleaseOnAbort?: boolean | undefined;\n}\n\n/**\n * Constructor parameters for {@link ResourceLockEventsComponent}.\n */\ninterface ResourceLockEventsComponentConstructorParams {\n  readonly app: App;\n  readonly onChange: () => void;\n  readonly onExternalMutation: (path: string) => void;\n  readonly onFileMenu: (menu: Menu, file: TAbstractFile) => void;\n  readonly onRename: (oldPath: string, newPath: string) => void;\n}\n\ninterface ResourceLockMutationBlockerComponentConstructorParams {\n  readonly shouldBlockMutation: (path: string) => boolean;\n}\n\n/**\n * Subscribes to the workspace events that should trigger a lock reconcile (and the file context-menu\n * event that offers an \"Unlock\" item). Implemented as a {@link ComponentEx} so the subscriptions are\n * registered on `load()` and automatically removed on `unload()`, instead of being tracked by hand.\n */\nclass ResourceLockEventsComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly onChange: () => void;\n  private readonly onExternalMutation: (path: string) => void;\n  private readonly onFileMenu: (menu: Menu, file: TAbstractFile) => void;\n  private readonly onRename: (oldPath: string, newPath: string) => void;\n\n  public constructor(params: ResourceLockEventsComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.onChange = params.onChange;\n    this.onExternalMutation = params.onExternalMutation;\n    this.onFileMenu = params.onFileMenu;\n    this.onRename = params.onRename;\n  }\n\n  public override onload(): void {\n    super.onload();\n    this.registerEvent(this.app.workspace.on('active-leaf-change', this.onChange));\n    this.registerEvent(this.app.workspace.on('layout-change', this.onChange));\n    // Same-leaf navigation to another note fires no leaf/layout change; without this it stays read-only.\n    this.registerEvent(this.app.workspace.on('file-open', this.onChange));\n    // Adds an \"Unlock\" item to a locked note's tab/file context menu (alongside the indicator menus).\n    this.registerEvent(this.app.workspace.on('file-menu', this.onFileMenu));\n    // External-change backstop: a vault/metadata event on a mutation-blocked path not covered by an active bypass scope is an intruder (a sync/FS/adapter change that bypassed the blocker patch).\n    this.registerEvent(this.app.vault.on('create', (file): void => {\n      this.onExternalMutation(file.path);\n    }));\n    this.registerEvent(this.app.vault.on('delete', (file): void => {\n      this.onExternalMutation(file.path);\n    }));\n    this.registerEvent(this.app.vault.on('rename', (file, oldPath): void => {\n      // Re-key FIRST, so the checks below run against where the locks actually are now.\n      // Intruder detection is unaffected: the old path stops resolving, but the new one is covered instead.\n      this.onRename(oldPath, file.path);\n      this.onExternalMutation(oldPath);\n      this.onExternalMutation(file.path);\n    }));\n    this.registerEvent(this.app.metadataCache.on('deleted', (file): void => {\n      this.onExternalMutation(file.path);\n    }));\n  }\n}\n\n/**\n * Tracks path-scoped editor locks and keeps every open {@link MarkdownView} in sync with the locked\n * set. A single instance lives on the shared `obsidian-dev-utils` state. Each lock is one\n * {@link LockEntry} in a per-path list, so a path can be held by several plugins (or several times by\n * one) concurrently and is released only when its last entry is removed; the indicators report which\n * plugins currently hold a lock.\n */\nclass ResourceLockManager {\n  private readonly beeper = new Beeper();\n  // The inner sets are mutable so a rename can re-key the paths of an in-flight bypass scope in place;\n  // the scope's `Disposable` deletes by set identity, so mutating the contents cannot orphan it.\n  private readonly bypassPathSets = new Set<Set<string>>();\n  private eventsComponent: null | ResourceLockEventsComponent = null;\n  private readonly indicatorsByView = new Map<MarkdownView, LockIndicators>();\n  private readonly lockEntriesByPath = new Map<string, LockEntry[]>();\n  private mutationBlockerComponent: null | ResourceLockMutationBlockerComponent = null;\n  private statusBarItemEl: HTMLElement | null = null;\n\n  public bypass(app: App, pathsOrFiles: readonly PathOrFile[]): Disposable {\n    const bypassedPaths = new Set(pathsOrFiles.map((pathOrFile) => getPath(app, pathOrFile)));\n    this.bypassPathSets.add(bypassedPaths);\n    return new CallbackDisposable({\n      callback: (): void => {\n        this.bypassPathSets.delete(bypassedPaths);\n      },\n      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n    });\n  }\n\n  /**\n   * Fully unlocks the note at the given path. Resolves the lock covering it \u2014 the path itself when\n   * directly locked, otherwise the enclosing `subtree`-locked folder \u2014 then aborts every\n   * {@link AbortController} registered on that owner (cancelling the operations that took the locks)\n   * AND removes the owner's lock entries (releasing the lock unconditionally). Unlike\n   * {@link requestUnlock}, which only aborts the exact path's controllers and relies on each operation\n   * releasing its own lock, this resolves ancestor coverage and always releases \u2014 so a note held by an\n   * indefinitely-held lock is guaranteed to become editable. A no-op when nothing covers the path.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file of the note to unlock.\n   */\n  public forceUnlock(app: App, pathOrFile: PathOrFile): void {\n    const ownerPath = this.resolveLockOwnerPath(app, getPath(app, pathOrFile));\n    if (ownerPath === null) {\n      return;\n    }\n    this.abortAndReleaseEntries(app, ownerPath);\n  }\n\n  public isLocked(app: App, pathOrFile: PathOrFile): boolean {\n    return this.isPathLocked(getPath(app, pathOrFile));\n  }\n\n  /**\n   * Checks whether the given path is locked directly or is covered by a `subtree`-locked ancestor\n   * folder.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if the path is itself locked or lies under a `subtree`-locked folder.\n   */\n  public isLockedByAncestor(app: App, pathOrFile: PathOrFile): boolean {\n    return this.resolveLockOwnerPath(app, getPath(app, pathOrFile)) !== null;\n  }\n\n  /**\n   * Checks whether the given path is covered by a mutation-blocking lock (one taken with\n   * `blocksMutations`) directly or on a `subtree`-locked ancestor folder.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if a mutation of the path is currently blocked.\n   */\n  public isMutationBlockedByAncestor(app: App, pathOrFile: PathOrFile): boolean {\n    const path = getPath(app, pathOrFile);\n    const exactEntries = this.lockEntriesByPath.get(path);\n    if (exactEntries?.some((entry) => entry.blocksMutations)) {\n      return true;\n    }\n    for (const [lockedPath, entries] of this.lockEntriesByPath) {\n      if (entries.some((entry) => entry.mode === 'subtree' && entry.blocksMutations) && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath })) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  public lock(params: ManagerLockParams): Disposable {\n    const { app } = params;\n    const path = getPath(app, params.pathOrFile);\n    const entry: LockEntry = {\n      abortController: params.abortController ?? null,\n      blocksMutations: params.blocksMutations ?? false,\n      mode: params.mode ?? 'file',\n      onUnlockRequested: params.onUnlockRequested ?? null,\n      operationName: params.operationName,\n      path,\n      pluginId: params.pluginId,\n      shouldReleaseOnAbort: params.shouldReleaseOnAbort ?? false\n    };\n    let entries = this.lockEntriesByPath.get(path);\n    if (!entries) {\n      entries = [];\n      this.lockEntriesByPath.set(path, entries);\n    }\n    entries.push(entry);\n    this.ensureSubscribed(app);\n    if (entry.blocksMutations) {\n      this.ensureBlockerInstalled(app);\n    }\n    this.wireReleaseOnAbort(app, entry);\n    this.reconcile(app);\n\n    return new CallbackDisposable({\n      callback: (): void => {\n        this.removeEntry(app, entry);\n      },\n      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n    });\n  }\n\n  /**\n   * Aborts every {@link AbortController} currently registered for the note at the given path, which\n   * cancels the operations holding the lock. Each operation releases its own lock in its `finally`\n   * when it observes the abort, so this does not unlock the path directly. A no-op when no controller\n   * is registered for the path.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file of the note to request an unlock for.\n   */\n  public requestUnlock(app: App, pathOrFile: PathOrFile): void {\n    const entries = this.lockEntriesByPath.get(getPath(app, pathOrFile));\n    if (!entries) {\n      return;\n    }\n    for (const entry of entries) {\n      entry.abortController?.abort();\n    }\n  }\n\n  public unlock(app: App, pathOrFile: PathOrFile, pluginId: string): void {\n    const path = getPath(app, pathOrFile);\n    const entries = this.lockEntriesByPath.get(path);\n    if (!entries) {\n      return;\n    }\n    const index = entries.findIndex((entry) => entry.pluginId === pluginId);\n    if (index === -1) {\n      return;\n    }\n    entries.splice(index, 1);\n    if (entries.length === 0) {\n      this.lockEntriesByPath.delete(path);\n    }\n    this.reconcileAndCleanup(app);\n  }\n\n  public unlockAllForPlugin(app: App, pluginId: string): void {\n    for (const [path, entries] of this.lockEntriesByPath) {\n      const remaining = entries.filter((entry) => entry.pluginId !== pluginId);\n      if (remaining.length === 0) {\n        this.lockEntriesByPath.delete(path);\n      } else if (remaining.length !== entries.length) {\n        this.lockEntriesByPath.set(path, remaining);\n      }\n    }\n    this.reconcileAndCleanup(app);\n  }\n\n  /**\n   * Aborts every {@link AbortController} on the given (already-resolved) owner path's lock entries \u2014\n   * cancelling the owning operations \u2014 and removes those entries, releasing the lock. The entries\n   * snapshot is copied first because an entry's `shouldReleaseOnAbort` abort listener mutates the\n   * array as it fires. Always leaves the owner path with no entries.\n   *\n   * @param app - The Obsidian app instance.\n   * @param ownerPath - The directly-locked owner path whose entries to abort and release.\n   */\n  private abortAndReleaseEntries(app: App, ownerPath: string): void {\n    const entries = this.lockEntriesByPath.get(ownerPath);\n    assertNonNullable(entries);\n    for (const entry of snapshot(entries)) {\n      entry.abortController?.abort();\n    }\n    this.lockEntriesByPath.delete(ownerPath);\n    this.reconcileAndCleanup(app);\n  }\n\n  private addUnlockMenuItem(app: App, menu: Menu, path: string): void {\n    menu.addItem((item) => {\n      item\n        .setTitle(t(($) => $.obsidianDevUtils.resourceLock.unlockMenuItem))\n        .setIcon(UNLOCK_ICON_ID)\n        .onClick(convertAsyncToSync(async () => {\n          const isConfirmed = await confirm({\n            app,\n            message: this.unlockConfirmMessage(app, path),\n            title: t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmTitle)\n          });\n          if (isConfirmed) {\n            // `path` is the resolved owner path, so cancel its operations and release the lock outright.\n            this.abortAndReleaseEntries(app, path);\n          }\n        }));\n    });\n  }\n\n  private createIndicators(app: App, view: MarkdownView, tooltip: string): LockIndicators {\n    // The indicators outlive a rename of the note (or of an enclosing locked folder), so they resolve\n    // the owner lock at CLICK time from the view's current file, exactly as the status-bar item does.\n    // A captured owner path would go stale the moment the lock is re-keyed.\n    const getOwnerPath = (): string | undefined => this.resolveViewOwnerPath(app, view);\n\n    const actionIconEl = view.addAction(LOCK_ICON_ID, tooltip, noop);\n    this.registerUnlockMenu(app, actionIconEl, getOwnerPath);\n\n    let tabIconEl: HTMLElement | null = null;\n    const tabStatusContainerEl = view.leaf.tabHeaderStatusContainerEl;\n    if (tabStatusContainerEl) {\n      tabIconEl = tabStatusContainerEl.createSpan({ cls: LOCK_INDICATOR_CSS_CLASS });\n      setIcon(tabIconEl, LOCK_ICON_ID);\n      setTooltip(tabIconEl, tooltip);\n      this.registerUnlockMenu(app, tabIconEl, getOwnerPath);\n    }\n\n    // A locked view is read-only but still editable-focusable, so a keystroke fires `beforeinput`.\n    // On that rejected attempt, flash the indicators and beep so it's clear the note is locked.\n    // The listener is removed on unlock.\n    const onTypeAttempt = (): void => {\n      this.flashIndicators(view);\n      this.beeper.beep();\n    };\n    view.contentEl.addEventListener('beforeinput', onTypeAttempt);\n\n    return {\n      actionIconEl,\n      disposeTypeListener: (): void => {\n        view.contentEl.removeEventListener('beforeinput', onTypeAttempt);\n      },\n      tabIconEl\n    };\n  }\n\n  private ensureBlockerInstalled(app: App): void {\n    if (this.mutationBlockerComponent) {\n      return;\n    }\n    this.mutationBlockerComponent = new ResourceLockMutationBlockerComponent({\n      shouldBlockMutation: (path): boolean => this.shouldBlockMutation(app, path)\n    });\n    this.mutationBlockerComponent.load();\n  }\n\n  private ensureSubscribed(app: App): void {\n    if (this.eventsComponent) {\n      return;\n    }\n    this.eventsComponent = new ResourceLockEventsComponent({\n      app,\n      onChange: (): void => {\n        this.reconcile(app);\n      },\n      onExternalMutation: (path): void => {\n        this.handleExternalMutation(app, path);\n      },\n      onFileMenu: (menu, file): void => {\n        this.handleFileMenu(app, menu, file);\n      },\n      onRename: (oldPath, newPath): void => {\n        this.handleRename(app, oldPath, newPath);\n      }\n    });\n    this.eventsComponent.load();\n  }\n\n  private flashElement(element: HTMLElement): void {\n    element.removeClass(LOCK_INDICATOR_FLASH_CSS_CLASS);\n    // Read layout to force a reflow so the flash animation restarts on every rejected keystroke.\n    element.getBoundingClientRect();\n    element.addClass(LOCK_INDICATOR_FLASH_CSS_CLASS);\n  }\n\n  private flashIndicators(view: MarkdownView): void {\n    const indicators = this.indicatorsByView.get(view);\n    for (const element of [indicators?.actionIconEl, indicators?.tabIconEl, this.statusBarItemEl]) {\n      if (element) {\n        this.flashElement(element);\n      }\n    }\n  }\n\n  /**\n   * Reacts to a vault/metadata event on a path. If the path is mutation-blocked and NOT covered by an\n   * active bypass scope, the change bypassed the blocker patch (sync / filesystem / a raw-adapter\n   * write) \u2014 an intruder. Abort the `abortController` of every mutation-blocking lock covering the path\n   * so the owning operation cancels and rolls back. A no-op for the owner's own (bypassed) mutations,\n   * for unblocked paths, and for blocking locks with no `abortController`.\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path the event fired on.\n   */\n  private handleExternalMutation(app: App, path: string): void {\n    if (!this.isMutationBlockedByAncestor(app, path) || this.isBypassed(app, path)) {\n      return;\n    }\n    for (const [lockedPath, entries] of this.lockEntriesByPath) {\n      for (const entry of entries) {\n        if (!entry.blocksMutations || !entry.abortController) {\n          continue;\n        }\n        const doesCoverPath = lockedPath === path || (entry.mode === 'subtree' && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath }));\n        if (doesCoverPath) {\n          entry.abortController.abort();\n        }\n      }\n    }\n  }\n\n  private handleFileMenu(app: App, menu: Menu, file: TAbstractFile): void {\n    // Offer \"Unlock\" for a directly-locked file/folder, or anything covered by a `subtree` lock on an ancestor. The menu targets the owner lock's path.\n    const ownerPath = this.resolveLockOwnerPath(app, file.path);\n    if (ownerPath === null) {\n      return;\n    }\n    this.addUnlockMenuItem(app, menu, ownerPath);\n  }\n\n  /**\n   * Re-keys the registry onto a renamed path, so a lock follows the resource it was taken on. Moves\n   * the entries of the renamed path AND of every descendant key (a folder rename changes a whole path\n   * prefix), and rebases every active {@link ResourceLockManager.bypass} scope the same way \u2014 without\n   * that second half an operation that renames a folder it locked would have its OWN later mutations\n   * read as intruders.\n   *\n   * Idempotent: a path that no longer matches is left alone, so it does not matter whether Obsidian\n   * emits the folder's rename event before or after its descendants'.\n   *\n   * @param app - The Obsidian app instance.\n   * @param oldPath - The path the resource was renamed from.\n   * @param newPath - The path the resource was renamed to.\n   */\n  private handleRename(app: App, oldPath: string, newPath: string): void {\n    // Collect first, apply after: writing back while iterating would re-visit the just-moved keys.\n    const movedEntriesByPath = new Map<string, LockEntry[]>();\n    for (const [lockedPath, entries] of this.lockEntriesByPath) {\n      const rebasedPath = rebasePath(lockedPath, oldPath, newPath);\n      if (rebasedPath === null) {\n        continue;\n      }\n      for (const entry of entries) {\n        entry.path = rebasedPath;\n      }\n      movedEntriesByPath.set(rebasedPath, entries);\n      this.lockEntriesByPath.delete(lockedPath);\n    }\n\n    for (const [rebasedPath, entries] of movedEntriesByPath) {\n      const existingEntries = this.lockEntriesByPath.get(rebasedPath);\n      if (existingEntries) {\n        // A swap renames one locked path onto another, so the two entry lists MERGE \u2014 neither holder loses its lock.\n        existingEntries.push(...entries);\n      } else {\n        this.lockEntriesByPath.set(rebasedPath, entries);\n      }\n    }\n\n    for (const bypassedPaths of this.bypassPathSets) {\n      // Same collect-then-apply shape: the set may not be mutated while it is being iterated.\n      const rebasedBypassedPaths = new Map<string, string>();\n      for (const bypassedPath of bypassedPaths) {\n        const rebasedPath = rebasePath(bypassedPath, oldPath, newPath);\n        if (rebasedPath !== null) {\n          rebasedBypassedPaths.set(bypassedPath, rebasedPath);\n        }\n      }\n      for (const [bypassedPath, rebasedPath] of rebasedBypassedPaths) {\n        bypassedPaths.delete(bypassedPath);\n        bypassedPaths.add(rebasedPath);\n      }\n    }\n\n    // Reconcile unconditionally: a rename changes coverage even when no key moved \u2014 a note renamed INTO\n    // A `subtree`-locked folder becomes covered, one renamed OUT of it stops being covered.\n    this.reconcile(app);\n  }\n\n  private hasBlockingLock(): boolean {\n    for (const entries of this.lockEntriesByPath.values()) {\n      if (entries.some((entry) => entry.blocksMutations)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Checks whether the path is covered by an active {@link ResourceLockManager.bypass} scope \u2014 the\n   * owner declaring that its own mutations of the path (and, for a folder, its subtree) are sanctioned.\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path being mutated.\n   * @returns `true` if some active bypass scope covers the path.\n   */\n  private isBypassed(app: App, path: string): boolean {\n    for (const bypassedPaths of this.bypassPathSets) {\n      for (const bypassedPath of bypassedPaths) {\n        if (isChildOrSelf({ app, childPathOrFile: path, parentPathOrFile: bypassedPath })) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  private isPathLocked(path: string): boolean {\n    return (this.lockEntriesByPath.get(path)?.length ?? 0) > 0;\n  }\n\n  /**\n   * Builds the deduplicated list of `(plugin name, operation name)` pairs describing the locks on a\n   * path \u2014 one per distinct plugin+operation. Drives the unlock confirmation, so the user sees exactly\n   * which operations an unlock would cancel. Only ever called for a locked path, so its entries are\n   * always present.\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The directly-locked path whose lock descriptors to build.\n   * @returns The distinct lock descriptors covering the path.\n   */\n  private lockDescriptors(app: App, path: string): LockDescriptor[] {\n    const entries = this.lockEntriesByPath.get(path);\n    assertNonNullable(entries);\n    const seen = new Set<string>();\n    const descriptors: LockDescriptor[] = [];\n    for (const entry of entries) {\n      const pluginName = app.plugins.manifests[entry.pluginId]?.name ?? entry.pluginId;\n      const key = `${pluginName}\\n${entry.operationName}`;\n      if (seen.has(key)) {\n        continue;\n      }\n      seen.add(key);\n      descriptors.push({ operationName: entry.operationName, pluginName });\n    }\n    return descriptors;\n  }\n\n  private lockingPluginNames(app: App, path: string): string[] {\n    const entries = this.lockEntriesByPath.get(path);\n    // `lockingPluginNames` is only ever called for a locked path, so its entries are always present.\n    assertNonNullable(entries);\n    const pluginIds = [...new Set(entries.map((entry) => entry.pluginId))];\n    return pluginIds.map((pluginId) => app.plugins.manifests[pluginId]?.name ?? pluginId);\n  }\n\n  private lockTooltip(app: App, path: string): string {\n    const header = t(($) => $.obsidianDevUtils.resourceLock.lockedByTooltip);\n    // A runtime-length list of plugin names, one per line under the header.\n    return [header, ...this.lockingPluginNames(app, path)].join('\\n');\n  }\n\n  private reconcile(app: App): void {\n    const viewsToLock = new Set<MarkdownView>();\n    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n      const view = leaf.view;\n      if (!(view instanceof MarkdownView)) {\n        continue;\n      }\n\n      const path = view.file?.path;\n      if (path === undefined) {\n        continue;\n      }\n\n      // Resolve the lock covering this view: the exact path when directly locked, otherwise the enclosing `subtree`-locked folder. Indicators/tooltip/unlock menu key off that owner path.\n      const ownerPath = this.resolveLockOwnerPath(app, path);\n      if (ownerPath === null) {\n        continue;\n      }\n\n      viewsToLock.add(view);\n      const tooltip = this.lockTooltip(app, ownerPath);\n      // Re-apply the read-only toggle on every reconcile, not only the first time a view is tracked.\n      // The toggle is idempotent, so re-applying to an already-locked view is cheap.\n      // A view opened after the lock is reconciled synchronously, before its CodeMirror is ready.\n      // Its first toggle is therefore a no-op; re-applying makes the lock take hold once it settles.\n      toggleEditorReadOnly(view.editor, true);\n      const indicators = this.indicatorsByView.get(view);\n      if (indicators) {\n        this.updateIndicatorTooltips(indicators, tooltip);\n      } else {\n        this.indicatorsByView.set(view, this.createIndicators(app, view, tooltip));\n      }\n    }\n\n    for (const [view, indicators] of this.indicatorsByView) {\n      if (viewsToLock.has(view)) {\n        continue;\n      }\n\n      toggleEditorReadOnly(view.editor, false);\n      indicators.disposeTypeListener();\n      indicators.actionIconEl.remove();\n      indicators.tabIconEl?.remove();\n      this.indicatorsByView.delete(view);\n    }\n\n    this.updateStatusBar(app);\n  }\n\n  private reconcileAndCleanup(app: App): void {\n    this.reconcile(app);\n    if (this.lockEntriesByPath.size === 0) {\n      this.eventsComponent?.unload();\n      this.eventsComponent = null;\n    }\n    if (this.hasBlockingLock()) {\n      return;\n    }\n\n    this.mutationBlockerComponent?.unload();\n    this.mutationBlockerComponent = null;\n  }\n\n  private registerUnlockMenu(app: App, element: HTMLElement, getContextPath: () => string | undefined): void {\n    // A click of ANY mouse button on a lock indicator opens the same unlock context menu:\n    // `click` fires only for the primary (left) button, `contextmenu` for the right button, and\n    // `auxclick` for the middle button (the browser fires no `click` for it). `auxclick` also fires for\n    // the right button, so it is guarded to the middle button to avoid double-opening alongside `contextmenu`.\n    // A plain listener dies with the element when it is `.remove()`d on unlock, so it never leaks.\n    const openUnlockMenu = ($event: MouseEvent): void => {\n      $event.preventDefault();\n      const path = getContextPath();\n      if (path === undefined) {\n        return;\n      }\n      const menu = new Menu();\n      this.addUnlockMenuItem(app, menu, path);\n      menu.showAtMouseEvent($event);\n    };\n    element.addEventListener('click', openUnlockMenu);\n    element.addEventListener('contextmenu', openUnlockMenu);\n    element.addEventListener('auxclick', ($event) => {\n      if ($event.button === MIDDLE_MOUSE_BUTTON) {\n        openUnlockMenu($event);\n      }\n    });\n  }\n\n  private removeEntry(app: App, entry: LockEntry): void {\n    // Read the entry's CURRENT path, not one captured when the lock was taken: a rename may have\n    // re-keyed it since, and looking it up under the old path would silently leak the lock.\n    const entries = this.lockEntriesByPath.get(entry.path);\n    if (!entries) {\n      return;\n    }\n    const index = entries.indexOf(entry);\n    if (index === -1) {\n      return;\n    }\n    entries.splice(index, 1);\n    if (entries.length === 0) {\n      this.lockEntriesByPath.delete(entry.path);\n    }\n    this.reconcileAndCleanup(app);\n  }\n\n  /**\n   * Resolves which locked path (if any) covers the given path: the path itself when directly locked,\n   * otherwise the longest `subtree`-locked ancestor folder that contains it (longest so a nested\n   * subtree lock wins deterministically over an outer one).\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path to resolve an owner lock for.\n   * @returns The covering locked path, or `null` when nothing covers it.\n   */\n  private resolveLockOwnerPath(app: App, path: string): null | string {\n    if (this.isPathLocked(path)) {\n      return path;\n    }\n    let bestOwnerPath: null | string = null;\n    for (const [lockedPath, entries] of this.lockEntriesByPath) {\n      const hasSubtreeLock = entries.some((entry) => entry.mode === 'subtree');\n      if (hasSubtreeLock && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath }) && (bestOwnerPath === null || lockedPath.length > bestOwnerPath.length)) {\n        bestOwnerPath = lockedPath;\n      }\n    }\n    return bestOwnerPath;\n  }\n\n  /**\n   * Resolves the lock covering the note a view currently shows \u2014 its own path when directly locked,\n   * otherwise the enclosing `subtree`-locked folder. Read at click time by the view's lock indicators,\n   * so it reflects renames of the note and of the locked folder alike.\n   *\n   * @param app - The Obsidian app instance.\n   * @param view - The view whose current file to resolve an owner lock for.\n   * @returns The covering locked path, or `undefined` when the view has no file or nothing covers it.\n   */\n  private resolveViewOwnerPath(app: App, view: MarkdownView): string | undefined {\n    const path = view.file?.path;\n    return path === undefined ? undefined : this.resolveLockOwnerPath(app, path) ?? undefined;\n  }\n\n  /**\n   * Decides whether a mutation of the path must be blocked: `true` when the path is mutation-blocked\n   * and not covered by any active {@link ResourceLockManager.bypass} scope.\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path being mutated.\n   * @returns `true` to reject the mutation, `false` to allow it.\n   */\n  private shouldBlockMutation(app: App, path: string): boolean {\n    return this.isMutationBlockedByAncestor(app, path) && !this.isBypassed(app, path);\n  }\n\n  private unlockConfirmMessage(app: App, path: string): DocumentFragment {\n    const fragment = createFragment();\n    fragment.appendText(t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmMessage));\n    // A runtime-length list of the locks currently held: each plugin name as a code block followed by\n    // the operation it is running, one per line.\n    for (const descriptor of this.lockDescriptors(app, path)) {\n      fragment.createEl('br');\n      appendCodeBlock(fragment, descriptor.pluginName);\n      fragment.appendText(`: ${descriptor.operationName}`);\n    }\n    return fragment;\n  }\n\n  private updateIndicatorTooltips(indicators: LockIndicators, tooltip: string): void {\n    setTooltip(indicators.actionIconEl, tooltip);\n    if (indicators.tabIconEl) {\n      setTooltip(indicators.tabIconEl, tooltip);\n    }\n  }\n\n  private updateStatusBar(app: App): void {\n    const activeView = app.workspace.getActiveViewOfType(MarkdownView);\n    const activePath = activeView?.file?.path;\n    const activeOwnerPath = activePath === undefined ? null : this.resolveLockOwnerPath(app, activePath);\n\n    if (activeOwnerPath === null || !activeView) {\n      this.statusBarItemEl?.remove();\n      this.statusBarItemEl = null;\n      return;\n    }\n\n    if (!this.statusBarItemEl) {\n      const statusBarEl = activeView.containerEl.ownerDocument.body.querySelector<HTMLElement>(STATUS_BAR_CSS_SELECTOR);\n      if (!statusBarEl) {\n        return;\n      }\n      this.statusBarItemEl = statusBarEl.createDiv({ cls: [STATUS_BAR_ITEM_CSS_CLASS, LOCK_INDICATOR_CSS_CLASS] });\n      setIcon(this.statusBarItemEl, LOCK_ICON_ID);\n      // The single status-bar item is reused across active-note switches.\n      // It must resolve the currently active note's owner lock at click time rather than capturing one path.\n      this.registerUnlockMenu(app, this.statusBarItemEl, () => {\n        const path = app.workspace.getActiveViewOfType(MarkdownView)?.file?.path;\n        return path === undefined ? undefined : this.resolveLockOwnerPath(app, path) ?? undefined;\n      });\n    }\n\n    setTooltip(this.statusBarItemEl, this.lockTooltip(app, activeOwnerPath));\n  }\n\n  /**\n   * Wires an opt-in `abort` listener for a lock entry: when the entry's controller aborts, releases\n   * the entry (if {@link LockEntry.shouldReleaseOnAbort}) and/or invokes\n   * {@link LockEntry.onUnlockRequested}. A no-op when the entry has no controller or neither opt-in is\n   * set, so transactional locks keep releasing via their own cleanup.\n   *\n   * @param app - The Obsidian app instance.\n   * @param entry - The lock entry whose controller to observe.\n   */\n  private wireReleaseOnAbort(app: App, entry: LockEntry): void {\n    const { onUnlockRequested, shouldReleaseOnAbort } = entry;\n    if (!entry.abortController || (!shouldReleaseOnAbort && !onUnlockRequested)) {\n      return;\n    }\n    entry.abortController.signal.addEventListener('abort', () => {\n      if (shouldReleaseOnAbort) {\n        this.removeEntry(app, entry);\n      }\n      onUnlockRequested?.();\n    }, { once: true });\n  }\n}\n\n/**\n * Monkey-patches the vault-mutation choke points on `Vault`/`FileManager` so that any edit, delete,\n * rename, move, or (re)create of a mutation-blocked path throws a {@link ResourceLockedError}.\n * Installed lazily by {@link ResourceLockManager} on the first `shouldBlockMutations` lock and removed\n * when the last one is released; being a {@link MonkeyAroundComponent}, every patch is torn down on\n * `unload`. Rename/copy check both source and destination; the other methods check their single path.\n */\nclass ResourceLockMutationBlockerComponent extends MonkeyAroundComponent {\n  private readonly shouldBlockMutation: (path: string) => boolean;\n\n  public constructor(params: ResourceLockMutationBlockerComponentConstructorParams) {\n    super();\n    this.shouldBlockMutation = params.shouldBlockMutation;\n  }\n\n  public override onload(): void {\n    super.onload();\n\n    this.registerMethodPatch<Vault, 'append'>({\n      $object: Vault.prototype,\n      methodName: 'append',\n      patchHandler: ({ fallback, originalArguments: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'copy'>({\n      $object: Vault.prototype,\n      methodName: 'copy',\n      patchHandler: ({ fallback, originalArguments: [, newPath] }) => {\n        this.assertNotBlocked([newPath]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'create'>({\n      $object: Vault.prototype,\n      methodName: 'create',\n      patchHandler: ({ fallback, originalArguments: [path] }) => {\n        this.assertNotBlocked([path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'createBinary'>({\n      $object: Vault.prototype,\n      methodName: 'createBinary',\n      patchHandler: ({ fallback, originalArguments: [path] }) => {\n        this.assertNotBlocked([path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'createFolder'>({\n      $object: Vault.prototype,\n      methodName: 'createFolder',\n      patchHandler: ({ fallback, originalArguments: [path] }) => {\n        this.assertNotBlocked([path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'delete'>({\n      $object: Vault.prototype,\n      methodName: 'delete',\n      patchHandler: ({ fallback, originalArguments: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'modify'>({\n      $object: Vault.prototype,\n      methodName: 'modify',\n      patchHandler: ({ fallback, originalArguments: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'modifyBinary'>({\n      $object: Vault.prototype,\n      methodName: 'modifyBinary',\n      patchHandler: ({ fallback, originalArguments: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'process'>({\n      $object: Vault.prototype,\n      methodName: 'process',\n      patchHandler: ({ fallback, originalArguments: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'rename'>({\n      $object: Vault.prototype,\n      methodName: 'rename',\n      patchHandler: ({ fallback, originalArguments: [file, newPath] }) => {\n        this.assertNotBlocked([file.path, newPath]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'trash'>({\n      $object: Vault.prototype,\n      methodName: 'trash',\n      patchHandler: ({ fallback, originalArguments: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<FileManager, 'renameFile'>({\n      $object: FileManager.prototype,\n      methodName: 'renameFile',\n      patchHandler: ({ fallback, originalArguments: [file, newPath] }) => {\n        this.assertNotBlocked([file.path, newPath]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<FileManager, 'trashFile'>({\n      $object: FileManager.prototype,\n      methodName: 'trashFile',\n      patchHandler: ({ fallback, originalArguments: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n  }\n\n  private assertNotBlocked(paths: string[]): void {\n    for (const path of paths) {\n      if (this.shouldBlockMutation(path)) {\n        throw new ResourceLockedError(path);\n      }\n    }\n  }\n}\n\n/**\n * A per-plugin handle for path-scoped resource locking (editor read-only, optional vault-mutation\n * blocking, and external-change detection \u2014 see the file overview). Add it as a child of your plugin\n * (`this.addChild(new ResourceLockComponent(this.app))`) so that any locks it still holds are released\n * automatically when the plugin unloads \u2014 a resource can never be left stuck locked because the plugin\n * that locked it was disabled or reloaded mid-operation.\n *\n * Locks are reference-counted and attributed to this plugin, so the lock indicators' tooltip names it\n * among the plugins currently holding a lock.\n */\nexport class ResourceLockComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to it for\n   * reference-counting and the indicators' \"locked by\" tooltip.\n   */\n  protected readonly pluginId: string;\n\n  /**\n   * Creates an resource-lock handle owned by a plugin.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pluginId - The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to\n   * it for reference-counting and the indicators' \"locked by\" tooltip.\n   */\n  public constructor(app: App, pluginId: string) {\n    super();\n    this.app = app;\n    this.pluginId = pluginId;\n  }\n\n  /**\n   * Opens an **ambient bypass scope**: while the returned {@link Disposable} is not disposed, this\n   * plugin's own mutations of the given paths (and, for a folder, its whole subtree) pass through the\n   * mutation blocker instead of throwing {@link ResourceLockedError}. Any mutation of a blocked path\n   * NOT covered by an active bypass scope is still rejected. Use it with a `using` declaration around\n   * the operation that legitimately mutates resources it has locked with\n   * {@link ResourceLockComponentLockForPathParams.shouldBlockMutations}:\n   *\n   * ```ts\n   * using _bypass = component.bypassBlockedMutations([sourceFile, targetFile]);\n   * // ... the operation's own vault mutations of those paths are allowed ...\n   * // scope end: the paths are enforced again\n   * ```\n   *\n   * @param pathsOrFiles - The paths (or files/folders) whose mutation by this operation is sanctioned.\n   * @returns A {@link Disposable} that ends the bypass scope when disposed.\n   */\n  public bypassBlockedMutations(pathsOrFiles: readonly PathOrFile[]): Disposable {\n    return getManager().bypass(this.app, pathsOrFiles);\n  }\n\n  /**\n   * Checks whether the path is locked directly or lies under a `subtree`-locked ancestor folder.\n   *\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if the path is itself locked or is covered by a `subtree` lock on an ancestor.\n   */\n  public isLockedByAncestorForPath(pathOrFile: PathOrFile): boolean {\n    return getManager().isLockedByAncestor(this.app, pathOrFile);\n  }\n\n  /**\n   * Checks whether the note at the given path is currently locked by any plugin.\n   *\n   * @param pathOrFile - The path or file of the note to check.\n   * @returns `true` if the note has at least one active lock, `false` otherwise.\n   */\n  public isLockedForPath(pathOrFile: PathOrFile): boolean {\n    return getManager().isLocked(this.app, pathOrFile);\n  }\n\n  /**\n   * Checks whether a vault mutation of the path is currently blocked by a `shouldBlockMutations` lock\n   * on the path itself or on a `subtree`-locked ancestor folder.\n   *\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if editing/deleting/renaming/moving/creating the path would throw a\n   * {@link ResourceLockedError}.\n   */\n  public isMutationBlockedByAncestorForPath(pathOrFile: PathOrFile): boolean {\n    return getManager().isMutationBlockedByAncestor(this.app, pathOrFile);\n  }\n\n  /**\n   * Locks the note at the given path on behalf of this plugin, making it read-only in every current\n   * and future {@link MarkdownView} until the lock is released. Reference-counted: balance each call\n   * with a dispose of the returned {@link Disposable} (ideally via `using`) or {@link unlockForPath}.\n   *\n   * @param params - Locking parameters. Its {@link ResourceLockComponentLockForPathParams.pathOrFile}\n   * and {@link ResourceLockComponentLockForPathParams.operationName} are required (the latter is shown\n   * in the unlock confirmation). Pass an {@link ResourceLockComponentLockForPathParams.abortController}\n   * to make the lock cancelable via a lock indicator's \"unlock\" menu, the \"Unlock active note\" command,\n   * or {@link requestResourceUnlockForPath}.\n   * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n   */\n  public lockForPath(params: ResourceLockComponentLockForPathParams): Disposable {\n    return getManager().lock({\n      abortController: params.abortController,\n      app: this.app,\n      blocksMutations: params.shouldBlockMutations,\n      mode: params.mode,\n      onUnlockRequested: params.onUnlockRequested,\n      operationName: params.operationName,\n      pathOrFile: params.pathOrFile,\n      pluginId: this.pluginId,\n      shouldReleaseOnAbort: params.shouldReleaseOnAbort\n    });\n  }\n\n  /**\n   * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,\n   * so no note is left stuck read-only by an operation that never completed.\n   */\n  public override onunload(): void {\n    getManager().unlockAllForPlugin(this.app, this.pluginId);\n    super.onunload();\n  }\n\n  /**\n   * Fully unlocks the note at the given path: resolves the lock covering it (the path itself when\n   * directly locked, otherwise a `subtree`-locked ancestor folder), cancels the operation(s) that took\n   * the lock by aborting their {@link AbortController}s, and releases the lock so the note becomes\n   * editable \u2014 regardless of which plugin holds the lock. Powers the \"Unlock active note\" command. A\n   * no-op when nothing covers the path.\n   *\n   * @param pathOrFile - The path or file of the note to unlock.\n   */\n  public requestUnlockForPath(pathOrFile: PathOrFile): void {\n    getManager().forceUnlock(this.app, pathOrFile);\n  }\n\n  /**\n   * Releases one lock previously acquired for the note at the given path via {@link lockForPath}.\n   *\n   * @param pathOrFile - The path or file of the note to unlock.\n   */\n  public unlockForPath(pathOrFile: PathOrFile): void {\n    getManager().unlock(this.app, pathOrFile, this.pluginId);\n  }\n}\n\n/**\n * Thrown by the vault-mutation blocker when a plugin tries to edit, delete, rename, move, or create a\n * resource whose path is covered by a lock taken with\n * {@link ResourceLockComponentLockForPathParams.shouldBlockMutations}.\n */\nexport class ResourceLockedError extends Error {\n  /**\n   * The vault path whose mutation was blocked.\n   */\n  public readonly path: string;\n\n  /**\n   * Creates a {@link ResourceLockedError}.\n   *\n   * @param path - The vault path whose mutation was blocked.\n   */\n  public constructor(path: string) {\n    super(`The resource \"${path}\" is locked and cannot be mutated.`);\n    this.name = 'ResourceLockedError';\n    this.path = path;\n  }\n}\n\n/**\n * Checks whether the note at the given path is currently locked.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to check.\n * @returns `true` if the note has at least one active lock, `false` otherwise.\n */\nexport function isResourceLockedForPath(app: App, pathOrFile: PathOrFile): boolean {\n  return getManager().isLocked(app, pathOrFile);\n}\n\n/**\n * Checks whether the note at the given path is currently locked directly OR is covered by a\n * `subtree`-locked ancestor folder.\n *\n * Unlike {@link isResourceLockedForPath}, which only reports an exact-path lock, this also reports a\n * path that lies under a folder locked in `subtree` mode. Use it to detect that a rename/move is\n * happening inside a foreign plugin's in-flight locked transaction (which locks the affected folder\n * subtree), so that a bystander (e.g. the rename/delete handler) can stay out of the way and let the\n * transaction's owner keep its own links consistent.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to check.\n * @returns `true` if the path is itself locked or lies under a `subtree`-locked ancestor folder.\n */\nexport function isResourceLockedForPathByAncestor(app: App, pathOrFile: PathOrFile): boolean {\n  return getManager().isLockedByAncestor(app, pathOrFile);\n}\n\n/**\n * Locks the note at the given path, making it read-only in every current and future\n * {@link MarkdownView} until the lock is released, and showing a lock indicator in the tab header,\n * view action bar, and (while active) the status bar. The indicators' tooltip lists the plugins\n * that currently hold a lock on the note.\n *\n * The lock is reference-counted per calling plugin: each call must be balanced by exactly one\n * release (either disposing the returned {@link Disposable} \u2014 ideally via a `using` declaration \u2014 or\n * a matching {@link unlockResourceForPath} call).\n *\n * @param params - The parameters for locking the note.\n * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n */\nexport function lockResourceForPath(params: LockResourceForPathParams): Disposable {\n  return getManager().lock({\n    app: params.app,\n    operationName: params.operationName,\n    pathOrFile: params.pathOrFile,\n    pluginId: params.pluginId\n  });\n}\n\n/**\n * Requests an unlock of the note at the given path by aborting every {@link AbortController} that was\n * associated with a lock on it (via {@link ResourceLockComponent.lockForPath}'s\n * {@link ResourceLockComponentLockForPathParams.abortController}). The operations holding the lock\n * observe the abort and release their own locks. A no-op when no abortable lock is registered for the\n * path.\n *\n * This lets a consuming plugin wire its own \"unlock active note\" command without reaching into the\n * lock manager directly.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to request an unlock for.\n */\nexport function requestResourceUnlockForPath(app: App, pathOrFile: PathOrFile): void {\n  getManager().requestUnlock(app, pathOrFile);\n}\n\n/**\n * Releases one lock previously acquired for the note at the given path via {@link lockResourceForPath}.\n *\n * When the last lock is released the note becomes fully editable again and its lock indicators are\n * removed. Calling this when the note is not locked is a no-op.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to unlock.\n * @param pluginId - The id of the plugin that holds the lock (e.g. its `manifest.id`); one of its\n * locks on the note is released.\n */\nexport function unlockResourceForPath(app: App, pathOrFile: PathOrFile, pluginId: string): void {\n  getManager().unlock(app, pathOrFile, pluginId);\n}\n\nfunction getManager(): ResourceLockManager {\n  return getObsidianDevUtilsState<ResourceLockManager>(RESOURCE_LOCK_STATE_KEY, new ResourceLockManager()).value;\n}\n\n/**\n * Maps a stored path through a rename: the renamed path itself becomes the new path, and a descendant\n * of it keeps its suffix under the new path. Spelled out rather than reusing {@link isChildOrSelf}\n * because the rebased suffix has to be computed from the same prefix the test matched, and a rename\n * source is never the vault root (the one case those helpers treat specially).\n *\n * @param path - The stored path to map.\n * @param oldPath - The path the resource was renamed from.\n * @param newPath - The path the resource was renamed to.\n * @returns The rebased path, or `null` when the rename does not affect it.\n */\nfunction rebasePath(path: string, oldPath: string, newPath: string): null | string {\n  if (path === oldPath) {\n    return newPath;\n  }\n  return path.startsWith(`${oldPath}/`) ? newPath + path.slice(oldPath.length) : null;\n}\n"],
  "mappings": "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",
  "names": []
}
