@lapis-notes/api 0.1.4 → 0.2.1

package/dist/storage/vault.svelte.js

@@ -1,7 +1,10 @@
+import { projectVaultTree, scanVaultTree } from "./vault-reconciliation";
+import { DEFAULT_APP_STATE_DIRECTORY } from "./path";
 import { EventDispatcher } from "../events";
 import { hasEditorAssociationGlobMagic, matchesEditorAssociationGlob, normalizeEditorAssociationGlob, validateEditorAssociationGlob, } from "../glob";
 import { FileCache, TFile, TFolder, } from "./fs";
 import { dirname, joinPath, normalizePath } from "./path";
+import { createVaultListingFilter, DEFAULT_VAULT_EXCLUDES, } from "./vault-listing";
 function Err(name) {
     return class extends Error {
         code = "";
@@ -28,13 +31,37 @@ export const ENOTDIR = Err("ENOTDIR");
  */
 export class Vault extends EventDispatcher {
     adapter;
+    operations;
     files = {};
     filesByName = new Map();
-    configDir = ".obsidian";
+    mutationTail = Promise.resolve();
+    mutate(operation) {
+        const enqueue = () => {
+            const pending = this.mutationTail.then(async () => {
+                await this.load();
+                return operation();
+            });
+            this.mutationTail = pending.then(() => { }, () => { });
+            return pending;
+        };
+        return this.operations ? this.operations.track(enqueue) : enqueue();
+    }
+    mutateFile(file, operation) {
+        const path = file.path;
+        return this.mutate(async () => {
+            if (file.path !== path)
+                throw new Error("Mutation target changed during admission");
+            return operation();
+        });
+    }
+    configDir = DEFAULT_APP_STATE_DIRECTORY;
     cache = new FileCache(1024);
-    constructor(adapter) {
+    listingFilter;
+    constructor(adapter, operations, options = {}) {
         super();
         this.adapter = adapter;
+        this.operations = operations;
+        this.listingFilter = createVaultListingFilter(options.listingExclusions ?? (() => DEFAULT_VAULT_EXCLUDES));
         this.load();
     }
     getPath(path) {
@@ -53,7 +80,14 @@ export class Vault extends EventDispatcher {
         return this.adapter.stat(this.getPath(path));
     }
     list(path = "/") {
-        return this.adapter.list(this.getPath(path));
+        const base = this.getPath(path);
+        const included = this.listingFilter();
+        if (!included(base))
+            return Promise.resolve({ files: [], folders: [] });
+        return this.adapter.list(base).then(({ files, folders }) => ({
+            files: files.filter((entry) => included(joinPath(base, entry))),
+            folders: folders.filter((entry) => included(joinPath(base, entry))),
+        }));
     }
     #loaded = null;
     load() {
@@ -67,14 +101,54 @@ export class Vault extends EventDispatcher {
         return this.#loaded;
     }
     reload() {
-        const files = {};
-        return this.loadPath("/", files).then(() => {
-            this.files = files;
-            this.rebuildFileNameIndex();
+        return this.mutate(async () => {
+            await this.reconcileNow();
             this.trigger("load");
             return this.getRoot();
         });
     }
+    /** Reconcile a complete disk snapshot without replacing live resources. */
+    reconcile(hints = [], current = () => true, context = {}) {
+        return this.mutate(() => this.reconcileNow(hints, current, context));
+    }
+    async reconcileNow(hints = [], current = () => true, context = {}) {
+        await this.load();
+        const snapshot = await scanVaultTree(this.adapter, current);
+        if (!snapshot || !current())
+            return;
+        const projected = projectVaultTree(this, this.files, snapshot, hints);
+        this.files = projected.files;
+        this.rebuildFileNameIndex();
+        for (const event of projected.events) {
+            if (event.type === "rename")
+                this.cache.rename(event.oldPath, event.file.path);
+            else
+                this.cache.invalidate(event.file.path);
+            if (event.type === "rename")
+                this.dispatch("rename", event.file, event.oldPath);
+            else
+                this.dispatch(event.type, event.file);
+            this.dispatch("all", event.type, event.file, {
+                ...context,
+                ...(event.oldPath === undefined ? {} : { oldPath: event.oldPath }),
+            });
+        }
+    }
+    recordFile(path, stat) {
+        const existing = this.files[path];
+        if (existing instanceof TFile) {
+            Object.assign(existing.stat, stat);
+            return existing;
+        }
+        const parent = this.files[dirname(path)];
+        if (!(parent instanceof TFolder))
+            throw new ENOTDIR(dirname(path));
+        const file = new TFile(path, stat, parent, this);
+        this.files[path] = file;
+        this.addToFileNameIndex(file);
+        parent.children.push(file);
+        return file;
+    }
     addToFileNameIndex(file) {
         const paths = this.filesByName.get(file.name) ?? new Set();
         paths.add(file.path);
@@ -136,10 +210,14 @@ export class Vault extends EventDispatcher {
      * @public
      */
     create(path, data, options) {
+        const run = () => this.createNow(path, data, options);
+        return this.mutate(run);
+    }
+    createNow(path, data, options) {
         path = this.getPath(path);
         const file = this.getFileByPath(path);
         if (file) {
-            return this.modify(file, data, options).then(() => file);
+            return this.modifyNow(file, data, options).then(() => file);
         }
         return this.adapter
             .write(path, data, options)
@@ -148,16 +226,51 @@ export class Vault extends EventDispatcher {
             if (!stat) {
                 return Promise.reject(`Unable to write file: ${path}`);
             }
-            let parent = this.files[dirname(path)];
+            const file = this.recordFile(path, stat);
+            this.cache.put(path, data);
+            this.dispatch("create", file);
+            this.dispatch("all", "create", file, {});
+            return file;
+        });
+    }
+    get supportsExclusiveCreate() {
+        const adapter = this.adapter;
+        return (adapter.getCapabilities?.().exclusiveCreate === true &&
+            typeof adapter.writeExclusive === "function");
+    }
+    /** Create new bytes without replacing a cached or newly arriving file. */
+    createExclusive(path, data, options) {
+        if (!this.supportsExclusiveCreate)
+            return Promise.reject(Object.assign(new Error("Exclusive file creation is unavailable"), {
+                code: "ENOTSUP",
+            }));
+        const run = async () => {
+            await this.load();
+            path = this.getPath(path);
+            if (this.files[path])
+                throw Object.assign(new Error(`A file already exists at ${path}`), {
+                    code: "EEXIST",
+                });
+            const parent = this.files[dirname(path)];
+            if (!(parent instanceof TFolder))
+                throw new ENOTDIR(dirname(path));
+            await this.adapter.writeExclusive(path, data, options);
+            const stat = await this.adapter.stat(path);
+            if (!stat || stat.type !== "file")
+                throw new Error(`Unable to create file: ${path}`);
             const file = new TFile(path, stat, parent, this);
             this.files[path] = file;
             this.addToFileNameIndex(file);
-            this.cache.put(path, data);
+            if (typeof data === "string")
+                this.cache.put(path, data);
+            else
+                this.cache.invalidate(path);
             parent.children.push(file);
             this.dispatch("create", file);
             this.dispatch("all", "create", file, {});
             return file;
-        });
+        };
+        return this.mutate(run);
     }
     /**
      * Create a new binary file inside the vault.
@@ -169,6 +282,10 @@ export class Vault extends EventDispatcher {
      * @public
      */
     createBinary(path, data, options) {
+        const run = () => this.createBinaryNow(path, data, options);
+        return this.mutate(run);
+    }
+    createBinaryNow(path, data, options) {
         path = this.getPath(path);
         return this.adapter
             .writeBinary(path, data, options)
@@ -177,11 +294,8 @@ export class Vault extends EventDispatcher {
             if (!stat) {
                 return Promise.reject(`Unable to write file: ${path}`);
             }
-            let parent = this.files[dirname(path)];
-            const file = new TFile(path, stat, parent, this);
-            this.files[path] = file;
-            this.addToFileNameIndex(file);
-            parent.children.push(file);
+            const file = this.recordFile(path, stat);
+            this.cache.invalidate(path);
             this.dispatch("create", file);
             this.dispatch("all", "create", file, {});
             return file;
@@ -194,7 +308,11 @@ export class Vault extends EventDispatcher {
      * @throws Error if folder already exists
      * @public
      */
-    async createFolder(path) {
+    createFolder(path) {
+        const run = () => this.createFolderNow(path);
+        return this.mutate(run);
+    }
+    async createFolderNow(path) {
         path = this.getPath(path);
         try {
             const folder = await this.adapter.mkdir(path).then(() => {
@@ -261,6 +379,9 @@ export class Vault extends EventDispatcher {
      * @public
      */
     delete(file, force, context = {}) {
+        return this.mutateFile(file, () => this.deleteNow(file, force, context));
+    }
+    deleteNow(file, force, context = {}) {
         const remove = file instanceof TFolder
             ? this.adapter.rmdir(file.path, force ?? true)
             : this.adapter.remove(file.path);
@@ -286,18 +407,16 @@ export class Vault extends EventDispatcher {
         });
     }
     trash(file, system = true) {
+        return this.mutateFile(file, () => this.trashNow(file, system));
+    }
+    trashNow(file, system = true) {
         const trash = system
             ? this.adapter.trashSystem(file.path)
             : Promise.resolve(false);
-        return trash.then((handled) => {
-            if (handled) {
-                return this.delete(file, true);
-            }
-            return this.adapter.trashLocal(file.path).then(async () => {
-                await this.reload();
-                this.dispatch("delete", file);
-                this.dispatch("all", "delete", file, { system });
-            });
+        return trash.then(async (handled) => {
+            if (!handled)
+                await this.adapter.trashLocal(file.path);
+            await this.reconcileNow([], () => true, { system });
         });
     }
     /**
@@ -360,7 +479,10 @@ export class Vault extends EventDispatcher {
         };
     }
     /** Stream a file into the adapter's atomic or strongest safe replacement path. */
-    async atomicWrite(path, source, options = {}) {
+    atomicWrite(path, source, options = {}) {
+        return this.mutate(() => this.atomicWriteNow(path, source, options));
+    }
+    async atomicWriteNow(path, source, options = {}) {
         path = this.getPath(path);
         const existed = this.getFileByPath(path);
         const adapter = this.adapter;
@@ -374,7 +496,7 @@ export class Vault extends EventDispatcher {
             try {
                 while (true) {
                     if (options.signal?.aborted) {
-                        throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
+                        throw (options.signal.reason ?? new DOMException("Aborted", "AbortError"));
                     }
                     const next = await reader.read();
                     if (next.done)
@@ -394,17 +516,10 @@ export class Vault extends EventDispatcher {
             }
             await adapter.writeBinary(path, data.buffer, options);
         }
-        this.files = await this.loadPath("/", {});
-        this.rebuildFileNameIndex();
+        await this.reconcileNow([{ type: existed ? "modify" : "create", path }], () => true, { operationOrigin: options.operationOrigin });
         const file = this.getFileByPath(path);
         if (!file)
             throw new Error(`Unable to write file: ${path}`);
-        this.cache.invalidate(path);
-        const event = existed ? "modify" : "create";
-        this.dispatch(event, file);
-        this.dispatch("all", event, file, {
-            operationOrigin: options.operationOrigin,
-        });
         return file;
     }
     /**
@@ -416,33 +531,19 @@ export class Vault extends EventDispatcher {
      * @public
      */
     rename(file, newPath) {
+        return this.mutateFile(file, () => this.renameNow(file, newPath));
+    }
+    renameNow(file, newPath) {
         newPath = this.getPath(newPath);
         if (file.path == newPath) {
             return Promise.resolve();
         }
         const oldPath = file.path;
-        const paths = new Set();
-        if (file instanceof TFile) {
-            paths.add(file.parent?.path ?? "/");
-            paths.add(dirname(newPath));
-        }
-        else {
-            paths.add(file.path);
-            paths.add(newPath);
-        }
-        return this.adapter.rename(file.path, newPath).then(async () => {
-            this.files = await this.loadPath("/", {});
-            this.rebuildFileNameIndex();
-            let newFile = this.getAbstractFileByPath(newPath);
-            if (newFile) {
-                this.cache.rename(file.path, newFile.path);
-                this.dispatch("rename", newFile, oldPath);
-                this.dispatch("all", "rename", newFile, { oldPath });
-            }
-            else {
-                console.warn(`Failed to rename file: ${file.path}`);
-            }
-        });
+        return this.adapter
+            .rename(oldPath, newPath)
+            .then(() => this.reconcileNow([
+            { type: "create", path: newPath, previousPath: oldPath },
+        ]));
     }
     /**
      * Modify the contents of a plaintext file.
@@ -453,21 +554,41 @@ export class Vault extends EventDispatcher {
      * @public
      */
     modify(file, data, options) {
+        return this.mutateFile(file, () => this.modifyNow(file, data, options));
+    }
+    modifyNow(file, data, options) {
         if (!this.getFileByPath(file.path)) {
-            return this.create(file.path, data, options).then(() => { });
+            return this.createNow(file.path, data, options).then(() => { });
         }
         const path = file.path;
         return this.adapter
             .write(path, data, options)
-            .then(() => this.adapter.stat(path))
-            .then((stat) => {
+            .then(() => this.#recordTextWrite(path, data, options));
+    }
+    get supportsConditionalTextWrites() {
+        const adapter = this.adapter;
+        return (adapter.getCapabilities?.().conditionalTextWrite === true &&
+            typeof adapter.writeTextIfUnchanged === "function");
+    }
+    /** Persist only the caller's captured text version; never fall back to write. */
+    modifyIfUnchanged(file, data, expected, options) {
+        return this.mutateFile(file, () => this.modifyIfUnchangedNow(file, data, expected, options));
+    }
+    async modifyIfUnchangedNow(file, data, expected, options) {
+        if (!this.supportsConditionalTextWrites)
+            throw new Error("Conditional text writes are unavailable");
+        if (expected !== null && typeof expected !== "string")
+            throw new Error("Invalid expected text snapshot");
+        const path = file.path;
+        await this.adapter.writeTextIfUnchanged(path, data, expected, options);
+        await this.#recordTextWrite(path, data, options);
+    }
+    #recordTextWrite(path, data, options) {
+        return this.adapter.stat(path).then((stat) => {
             if (!stat) {
                 return Promise.reject(`Unable to write file: ${path}`);
             }
-            let parent = this.files[dirname(path)];
-            const file = new TFile(path, stat, parent, this);
-            this.files[path] = file;
-            this.cache.put(path, data);
+            const file = this.recordFile(path, stat);
             this.cache.put(file.path, data);
             this.dispatch("modify", file);
             this.dispatch("all", "modify", file, { data, options });
@@ -482,8 +603,11 @@ export class Vault extends EventDispatcher {
      * @public
      */
     modifyBinary(file, data, options) {
+        return this.mutateFile(file, () => this.modifyBinaryNow(file, data, options));
+    }
+    modifyBinaryNow(file, data, options) {
         if (!this.getFileByPath(file.path)) {
-            return this.createBinary(file.path, data, options).then(() => { });
+            return this.createBinaryNow(file.path, data, options).then(() => { });
         }
         const path = file.path;
         return this.adapter
@@ -493,9 +617,8 @@ export class Vault extends EventDispatcher {
             if (!stat) {
                 return Promise.reject(`Unable to write file: ${path}`);
             }
-            let parent = this.files[dirname(path)];
-            const file = new TFile(path, stat, parent, this);
-            this.files[path] = file;
+            const file = this.recordFile(path, stat);
+            this.cache.invalidate(path);
             this.dispatch("modify", file);
             this.dispatch("all", "modify", file, { data, options });
         });
@@ -518,14 +641,18 @@ export class Vault extends EventDispatcher {
      * @public
      */
     process(file, fn, options) {
-        return this.adapter.process(file.path, fn, options).then((data) => {
-            this.cache.put(file.path, data);
-            this.dispatch("modify", file);
-            this.dispatch("all", "modify", file, { data, options });
+        return this.mutateFile(file, () => this.processNow(file, fn, options));
+    }
+    processNow(file, fn, options) {
+        return this.adapter.process(file.path, fn, options).then(async (data) => {
+            await this.#recordTextWrite(file.path, data, options);
             return data;
         });
     }
     append(file, data, options) {
+        return this.mutateFile(file, () => this.appendNow(file, data, options));
+    }
+    appendNow(file, data, options) {
         return this.adapter
             .append(file.path, data, options)
             .then(() => this.adapter.stat(file.path))
@@ -533,15 +660,16 @@ export class Vault extends EventDispatcher {
             if (!stat) {
                 return Promise.reject(`Unable to append file: ${file.path}`);
             }
-            const parent = this.files[dirname(file.path)];
-            const next = new TFile(file.path, stat, parent, this);
-            this.files[file.path] = next;
+            const next = this.recordFile(file.path, stat);
             this.cache.invalidate(file.path);
             this.dispatch("modify", next);
             this.dispatch("all", "modify", next, { data, options });
         });
     }
     appendBinary(file, data, options) {
+        return this.mutateFile(file, () => this.appendBinaryNow(file, data, options));
+    }
+    appendBinaryNow(file, data, options) {
         return this.adapter
             .appendBinary(file.path, data, options)
             .then(() => this.adapter.stat(file.path))
@@ -549,24 +677,23 @@ export class Vault extends EventDispatcher {
             if (!stat) {
                 return Promise.reject(`Unable to append file: ${file.path}`);
             }
-            const parent = this.files[dirname(file.path)];
-            const next = new TFile(file.path, stat, parent, this);
-            this.files[file.path] = next;
+            const next = this.recordFile(file.path, stat);
             this.cache.invalidate(file.path);
             this.dispatch("modify", next);
             this.dispatch("all", "modify", next, { data, options });
         });
     }
-    async copy(file, newPath) {
+    copy(file, newPath) {
+        return this.mutateFile(file, () => this.copyNow(file, newPath));
+    }
+    async copyNow(file, newPath) {
         newPath = this.getPath(newPath);
         await this.adapter.copy(file.path, newPath);
-        await this.reload();
+        await this.reconcileNow([], () => true, { originalPath: file.path });
         const copied = this.getAbstractFileByPath(newPath);
         if (!copied) {
             throw new Error(`Unable to copy file: ${file.path}`);
         }
-        this.dispatch("create", copied);
-        this.dispatch("all", "create", copied, { originalPath: file.path });
         return copied;
     }
     /**
@@ -636,7 +763,8 @@ export class Vault extends EventDispatcher {
         adapter.revokeResourceUrl?.(url);
     }
     getAllLoadedFiles() {
-        return Object.values(this.files);
+        const included = this.listingFilter();
+        return Object.values(this.files).filter((file) => included(file.path));
     }
     /**
      * Get all folders in the vault.
@@ -645,7 +773,10 @@ export class Vault extends EventDispatcher {
      * @public
      */
     getAllFolders(includeRoot) {
-        return Object.values(this.files).filter((it) => it instanceof TFolder && (includeRoot || it.path !== "/"));
+        const included = this.listingFilter();
+        return Object.values(this.files).filter((it) => it instanceof TFolder &&
+            included(it.path) &&
+            (includeRoot || it.path !== "/"));
     }
     /**
      * Get all files in the vault.
@@ -653,7 +784,8 @@ export class Vault extends EventDispatcher {
      * @public
      */
     getFiles() {
-        return Object.values(this.files).filter((it) => it instanceof TFile);
+        const included = this.listingFilter();
+        return Object.values(this.files).filter((it) => it instanceof TFile && included(it.path));
     }
     /**
      * Iterate loaded files without allocating a second vault-sized collection.
@@ -666,8 +798,11 @@ export class Vault extends EventDispatcher {
         const root = this.files["/"];
         if (!(root instanceof TFolder))
             return;
+        const included = this.listingFilter();
         function* visit(folder) {
             for (const child of folder.children) {
+                if (!included(child.path))
+                    continue;
                 if (child instanceof TFile)
                     yield child.copy();
                 else if (child instanceof TFolder)
@@ -715,9 +850,10 @@ export class Vault extends EventDispatcher {
                 }
             }
         }
+        const included = this.listingFilter();
         return [...paths]
             .map((path) => this.getFileByPath(path))
-            .filter((file) => Boolean(file))
+            .filter((file) => Boolean(file) && included(file.path))
             .sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
     }
     getMarkdownFiles() {

package/dist/sync-host.d.ts

@@ -141,14 +141,20 @@ export type SyncEndpointSecurityCapabilities = Pick<SyncHostCapabilities, "crypt
 /** Trusted host custody. This controller is never included in plugin facades. */
 export interface SyncHostSecurityProvider {
     forRuntime(runtimeId: string): SyncEndpointSecurityCapabilities;
-    /** Must stop admission synchronously, then drain and destroy this runtime's keys. */
+    /**
+     * Must stop admission synchronously, then drain and destroy this runtime's
+     * keys.
+     */
     revokeRuntime(runtimeId: string): void | Promise<void>;
 }
 export interface SyncHostServiceOptions {
     localProvider?: (pluginId: string) => SyncHostLocalProvider | undefined;
     /** Required before local mutations or receipt recovery can enter a provider. */
     guardLocalApply?: SyncLocalApplyGuard;
-    /** Select custody per plugin; returning undefined explicitly retains legacy custody. */
+    /**
+     * Select custody per plugin; returning undefined explicitly retains legacy
+     * custody.
+     */
     securityProvider?: (pluginId: string) => SyncHostSecurityProvider | undefined;
     /** Dedicated host custody; omitted only for legacy AppDatabase-backed callers. */
     securityStore?: SyncSecurityStore;
@@ -180,7 +186,10 @@ export declare class SyncHostService {
     revokePlugin(pluginId: string): Promise<void>;
     /** Invalidate first, then wait for every admitted host cleanup and file event. */
     dispose(): Promise<void>;
-    /** Host-controlled enrollment; this operation is intentionally absent from plugin facades. */
+    /**
+     * Host-controlled enrollment; this operation is intentionally absent from
+     * plugin facades.
+     */
     enrollPluginCrypto(pluginId: string, passphrase: string, request?: SyncCryptoEnrollmentRequest): Promise<SyncCryptoStatus>;
     /** Host-controlled unlock; plugins can only observe locked state. */
     unlockPluginCrypto(pluginId: string, passphrase: string): Promise<SyncCryptoStatus>;

package/dist/sync-host.js

@@ -113,6 +113,7 @@ export class SyncHostService {
                 : undefined;
             this.#eventQueue = this.#eventQueue
                 .then(async () => {
+                await this.#ready;
                 await this.#recordFileChange(event, file, previousPath, originId);
             })
                 .catch(() => undefined);
@@ -454,7 +455,10 @@ export class SyncHostService {
         if (this.#securityProvider(pluginId))
             throw new Error(`Sync security for ${pluginId} is delegated to its host provider`);
     }
-    /** Host-controlled enrollment; this operation is intentionally absent from plugin facades. */
+    /**
+     * Host-controlled enrollment; this operation is intentionally absent from
+     * plugin facades.
+     */
     async enrollPluginCrypto(pluginId, passphrase, request) {
         this.#assertLocalSecurity(pluginId);
         return this.#security.enroll(requireBoundedString(pluginId, "Plugin ID", 128), passphrase, request);

package/dist/vault-change-views.d.ts

@@ -0,0 +1,4 @@
+import type { App } from "./context.svelte";
+import { TFile } from "./storage/fs";
+/** Project into existing owned views; no replacement editor or persistence path. */
+export declare function projectVaultChange(app: App, event: string, file: TFile, context: Record<string, unknown>, current: () => boolean): Promise<void>;

package/dist/vault-change-views.js

@@ -0,0 +1,43 @@
+import { TFile } from "./storage/fs";
+import { FileView } from "./view.svelte";
+/** Project into existing owned views; no replacement editor or persistence path. */
+export async function projectVaultChange(app, event, file, context, current) {
+    if (!current())
+        return;
+    if (context.external === true)
+        app.workspace.trigger("file-change", file, event);
+    if (event !== "rename" && event !== "delete")
+        return;
+    const oldPath = event === "rename" ? String(context.oldPath) : file.path;
+    if (app.fileEditingSessions.hasDirty(oldPath)) {
+        app.notifications.notify({
+            id: `vault-file-change:${oldPath}`,
+            title: "File changed on disk",
+            message: event === "rename"
+                ? `${oldPath} moved to ${file.path}. Local edits remain in the original view for recovery.`
+                : `${oldPath} was removed on disk. Local edits remain in the original view for recovery.`,
+            severity: "warning",
+            source: "vault",
+        });
+        return;
+    }
+    const leaves = [];
+    app.workspace.iterateAllLeaves((leaf) => {
+        if (leaf.view instanceof FileView && leaf.view.file?.path === oldPath)
+            leaves.push(leaf);
+    });
+    for (const leaf of leaves) {
+        if (!current() ||
+            !(leaf.view instanceof FileView) ||
+            leaf.view.file?.path !== oldPath)
+            continue;
+        if (event === "rename")
+            await leaf.view.onRename(file.copy());
+        else
+            await leaf.setViewState({ type: "empty", state: {} });
+        if (current())
+            app.workspace.requestSaveLayout();
+    }
+    if (current())
+        app.workspace.reconcileFileReference(oldPath, event === "rename" ? file : null);
+}