@lapis-notes/api 0.1.4 → 0.2.1

package/dist/__tests__/projection-query-support.js

@@ -0,0 +1,40 @@
+import { connect } from "@tursodatabase/database";
+import fixture from "./fixtures/projection-query.json";
+import { MemoryAppDatabase } from "../storage/app-database";
+import { TursoAppDatabase, } from "../storage/turso-app-database";
+export async function database(native, edges = []) {
+    const db = native
+        ? new TursoAppDatabase("projection-query-contract", {
+            kind: "turso-native",
+            transport: "native",
+            connectionFactory: async () => (await connect(":memory:", {
+                experimental: ["index_method"],
+            })),
+        })
+        : new MemoryAppDatabase("projection-query-contract");
+    await db.open();
+    await db.registerProjectionDefinition({
+        projectionId: fixture.projectionId,
+        ownerPluginId: "books",
+        schemaVersion: 1,
+        configHash: "fixture-1",
+        visibility: "public",
+        fields: {
+            title: { type: "string", sortable: true },
+            rank: { type: "number", sortable: true },
+            optional: { type: "string", indexed: true },
+            "literal.key": { type: "string", indexed: true },
+        },
+        active: true,
+        updatedAt: 1,
+    });
+    for (const row of fixture.rows)
+        await db.replaceProjectionSource({
+            projectionId: fixture.projectionId,
+            sourcePath: `${row.id}.md`,
+            sourceHash: "fixture-hash",
+            rows: [{ id: row.id, kind: "book", data: row }],
+            edges: edges.filter((edge) => edge.sourceRowId === row.id),
+        });
+    return db;
+}

package/dist/__tests__/search-retrieval-support.js

@@ -0,0 +1,47 @@
+import { connect } from "@tursodatabase/database";
+import { MemoryAppDatabase, } from "../storage/app-database";
+import { TursoAppDatabase, } from "../storage/turso-app-database";
+import input from "./fixtures/search-retrieval.json";
+export const fixture = input;
+export async function database(native) {
+    const db = native
+        ? new TursoAppDatabase("retrieval", {
+            kind: "turso-native",
+            transport: "native",
+            connectionFactory: async () => (await connect(":memory:", {
+                experimental: ["index_method"],
+            })),
+        })
+        : new MemoryAppDatabase("retrieval");
+    await db.open();
+    for (const { document, properties } of fixture.records) {
+        const file = {
+            path: document.path,
+            normalizedPath: document.path,
+            extension: "md",
+            mtime: 1,
+            size: 1,
+            hash: "reference",
+            indexed: true,
+        };
+        await db.upsertIndexedFile({
+            file,
+            metadata: {
+                path: file.path,
+                hash: file.hash,
+                parserVersion: "fixture",
+                metadata: {},
+            },
+            links: [],
+            tags: [],
+            properties: Object.entries(properties).map(([name, value]) => ({
+                path: file.path,
+                name,
+                value,
+                inferredType: typeof value,
+            })),
+        });
+        await db.upsertSearchDocument(document);
+    }
+    return db;
+}

package/dist/app-database-host.d.ts

@@ -3,3 +3,4 @@ export * from "./storage/remote-app-database";
 export * from "./storage/index-projection";
 export * from "./storage/task-projection";
 export * from "./storage/turso-app-database";
+export type * from "./native-database-protocol";

package/dist/app-shell-plugin-persistence.d.ts

@@ -1,4 +1,5 @@
-export declare const APP_SHELL_PLUGINS_PATH = ".obsidian/app-shell-plugins.json";
+import type { App } from "./context.svelte";
+export declare const APP_SHELL_PLUGINS_PATH: string;
 export interface AppShellPluginPersistenceVault {
     mkpath?(path: string): Promise<unknown>;
     adapter?: {
@@ -12,4 +13,4 @@ export interface AppShellPluginEnablementPersistence {
     load(): Promise<unknown | null>;
     save(enabledById: Record<string, boolean>): Promise<void>;
 }
-export declare function createAppShellPluginPersistence(vault: AppShellPluginPersistenceVaultSource): AppShellPluginEnablementPersistence;
+export declare function createAppShellPluginPersistence(vault: AppShellPluginPersistenceVaultSource, app?: App, apply?: (enabled: Record<string, boolean>) => Promise<void>): AppShellPluginEnablementPersistence;

package/dist/app-shell-plugin-persistence.js

@@ -1,17 +1,42 @@
-export const APP_SHELL_PLUGINS_PATH = ".obsidian/app-shell-plugins.json";
+import { appStatePath, DEFAULT_APP_STATE_DIRECTORY } from "./storage/path";
+import { readFileState, saveFileState } from "./file-state-store";
+export const APP_SHELL_PLUGINS_PATH = appStatePath("app-shell-plugins.json");
 function resolvePluginPersistenceVault(source) {
     if (typeof source === "function") {
         return source() ?? undefined;
     }
     return source ?? undefined;
 }
-export function createAppShellPluginPersistence(vault) {
+export function createAppShellPluginPersistence(vault, app, apply) {
+    let resetting = false;
+    let snapshot = {};
+    const reset = async (text) => {
+        const value = JSON.parse(text || "{}");
+        if (!value ||
+            typeof value !== "object" ||
+            Array.isArray(value) ||
+            Object.values(value).some((enabled) => typeof enabled !== "boolean"))
+            throw new Error("Invalid App Shell plugin configuration");
+        resetting = true;
+        try {
+            await apply?.(value);
+            snapshot = value;
+        }
+        finally {
+            resetting = false;
+        }
+    };
     return {
         async load() {
             const adapter = resolvePluginPersistenceVault(vault)?.adapter;
             if (!adapter?.read)
                 return null;
             try {
+                if (app?.vault.supportsConditionalTextWrites) {
+                    const raw = await readFileState(app, APP_SHELL_PLUGINS_PATH, reset);
+                    snapshot = raw ? JSON.parse(raw) : {};
+                    return raw ? snapshot : null;
+                }
                 if (adapter.exists && !(await adapter.exists(APP_SHELL_PLUGINS_PATH))) {
                     return null;
                 }
@@ -23,11 +48,20 @@ export function createAppShellPluginPersistence(vault) {
             }
         },
         async save(enabledById) {
+            if (resetting)
+                return;
+            if (app?.vault.supportsConditionalTextWrites) {
+                snapshot = { ...snapshot, ...enabledById };
+                await saveFileState(app, APP_SHELL_PLUGINS_PATH, `${JSON.stringify(snapshot, null, 2)}\n`);
+                return;
+            }
             const resolved = resolvePluginPersistenceVault(vault);
             const adapter = resolved?.adapter;
             if (!adapter?.write)
                 return;
-            await resolved?.mkpath?.(".obsidian").catch(() => undefined);
+            await resolved
+                ?.mkpath?.(DEFAULT_APP_STATE_DIRECTORY)
+                .catch(() => undefined);
             await adapter.write(APP_SHELL_PLUGINS_PATH, `${JSON.stringify(enabledById, null, 2)}\n`);
         },
     };

package/dist/cache.svelte.d.ts

@@ -1,3 +1,5 @@
+import type { ContributionStatus } from "./native-indexing-protocol";
+import type { IndexProjectionRegistration } from "./storage/index-projection";
 import type { App } from "./context.svelte";
 import { EventDispatcher } from "./events";
 import {
@@ -310,6 +312,7 @@ export declare class MetadataCache extends EventDispatcher<{
     readonly logger: import("./logging").Logger;
     private readonly saveSnapshotDebounced;
     constructor(app: App);
+    get backgroundIndexing(): import("./native-background-indexing").NativeBackgroundIndexingObserver | undefined;
     get metadataCache(): Record<string, CachedMetadata>;
     get resolvedLinks(): Record<string, Record<string, number>>;
     get unresolvedLinks(): Record<string, Record<string, number>>;
@@ -552,7 +555,11 @@ export declare class MetadataCache extends EventDispatcher<{
     getFirstLinkpathDest(linkpath: string, sourcePath: string): TFile | null;
     fileToLinktext(file: TFile, sourcePath: string, omitMdExtension?: boolean): string;
     rebuild(): Promise<void>;
-    addProcessor(ext: string, processor: MetadataProcessor): void;
+    registerNativeProjection(owner: string, id: string, registration: IndexProjectionRegistration): void;
+    finishNativeContributions(owner: string): Promise<void>;
+    disableNativeContributions(owner: string): Promise<void>;
+    get nativeContributionStatuses(): ContributionStatus[];
+    addProcessor(ext: string, processor: MetadataProcessor, owner?: string): void;
     removeProcessor(ext: string, processor: MetadataProcessor): boolean;
     addIndexedProjectionContributor(contributor: IndexedProjectionContributor): void;
     removeIndexedProjectionContributor(contributor: IndexedProjectionContributor): boolean;

package/dist/cache.svelte.js

@@ -5,6 +5,7 @@ import { defaultLinkSettings, getLinkPath, normalizeVaultPath, } from "./links";
 import { basename, TFile, } from "./storage";
 import { debounce } from "lodash-es";
 import { dirname, resolvePath } from "./storage/path";
+import { NativeBackgroundIndexingSession, } from "./native-background-indexing";
 export const METADATA_CACHE_BACKUP_PATH = ".lapis/cache/metadata-cache.json";
 export const METADATA_CACHE_HOT_LIMIT = 512;
 const METADATA_RECONCILE_CHECKPOINT_KEY = "metadata-cache.reconcile-checkpoint.v1";
@@ -226,6 +227,7 @@ export class MetadataCache extends EventDispatcher {
     #unresolvedLinks = $state({});
     logger = logging.getLogger("cache");
     disposed = false;
+    nativeIndexing;
     didLoad = false;
     loadPromise = null;
     disposePromise = null;
@@ -249,11 +251,17 @@ export class MetadataCache extends EventDispatcher {
     constructor(app) {
         super();
         this.app = app;
+        const port = app.session?.backgroundIndexing;
+        if (port)
+            this.nativeIndexing = new NativeBackgroundIndexingSession(app, port);
         app.vault.on("all", this.handleVaultChange);
         app.vault.on("rename", this.handleVaultRename);
         this.databaseChangeUnsubscribe =
             app.appDatabase.subscribeToChanges?.((change) => this.handleDatabaseChange(change)) ?? null;
     }
+    get backgroundIndexing() {
+        return this.nativeIndexing;
+    }
     get metadataCache() {
         return this.#metadataCache;
     }
@@ -281,7 +289,7 @@ export class MetadataCache extends EventDispatcher {
         return map;
     }
     scheduleSnapshotSave() {
-        if (this.disposed || this.snapshotLeaseCount === 0)
+        if (this.nativeIndexing || this.disposed || this.snapshotLeaseCount === 0)
             return;
         this.saveSnapshotDebounced();
     }
@@ -292,7 +300,9 @@ export class MetadataCache extends EventDispatcher {
     async dispose(options = {}) {
         if (this.disposePromise)
             return this.disposePromise;
+        const nativeTasksDetached = this.app.nativeTasks?.detach();
         this.disposed = true;
+        this.nativeIndexing?.dispose();
         this.app.vault.off("all", this.handleVaultChange);
         this.app.vault.off("rename", this.handleVaultRename);
         this.databaseChangeUnsubscribe?.();
@@ -302,13 +312,20 @@ export class MetadataCache extends EventDispatcher {
         this.snapshotLeaseValue = null;
         this.saveSnapshotDebounced.cancel();
         this.disposePromise = (async () => {
+            if (nativeTasksDetached)
+                await nativeTasksDetached;
+            if (this.nativeIndexing)
+                return;
             await Promise.allSettled([...this.pendingOperations]);
-            await this.persistReconcileCheckpoint({ allowDisposed: true });
+            if (!this.nativeIndexing)
+                await this.persistReconcileCheckpoint({ allowDisposed: true });
             void options;
         })();
         return this.disposePromise;
     }
     async saveSnapshotNow(_options = {}) {
+        if (this.nativeIndexing)
+            return;
         const snapshot = await this.buildCompatibilitySnapshot();
         try {
             await this.app.appDatabase.saveMetadataSnapshot(snapshot);
@@ -345,6 +362,14 @@ export class MetadataCache extends EventDispatcher {
         return this.loadPromise;
     }
     async performLoad() {
+        if (this.nativeIndexing) {
+            await this.nativeIndexing.load();
+            if (this.disposed)
+                return;
+            this.didLoad = true;
+            this.trigger("loaded");
+            return;
+        }
         try {
             await this.app.telemetry.measureAsync("metadata.cache.load", async (loadSpan) => this.app.notifications.withProgress({
                 title: "Loading metadata cache",
@@ -585,8 +610,8 @@ export class MetadataCache extends EventDispatcher {
     }
     /**
      * Return the current vault/parser manifest fingerprint used to validate the
-     * durable metadata index and disposable indexed-consumer snapshots.
-     * Consumers may restrict the fingerprint to their accepted metadata files.
+     * durable metadata index and disposable indexed-consumer snapshots. Consumers
+     * may restrict the fingerprint to their accepted metadata files.
      */
     getReconciliationFingerprint(acceptsFile) {
         const fingerprint = new StreamingManifestFingerprint();
@@ -887,6 +912,8 @@ export class MetadataCache extends EventDispatcher {
         }, vaultIndex);
     }
     rebuild(progress) {
+        if (this.nativeIndexing)
+            return this.nativeIndexing.refresh(true);
         if (progress) {
             return this.performRebuild(progress);
         }
@@ -945,7 +972,19 @@ export class MetadataCache extends EventDispatcher {
         this.markReconcileCheckpointDirty();
         await this.persistReconcileCheckpoint();
     }
-    addProcessor(ext, processor) {
+    registerNativeProjection(owner, id, registration) {
+        this.nativeIndexing?.registerProjection(owner, id, registration);
+    }
+    async finishNativeContributions(owner) {
+        await this.nativeIndexing?.ready(owner);
+    }
+    async disableNativeContributions(owner) {
+        await this.nativeIndexing?.disable(owner);
+    }
+    get nativeContributionStatuses() {
+        return this.nativeIndexing?.getContributionStatuses() ?? [];
+    }
+    addProcessor(ext, processor, owner) {
         if (!ext?.trim())
             return;
         ext = ext.trim().toLowerCase();
@@ -953,6 +992,7 @@ export class MetadataCache extends EventDispatcher {
             this.processors.set(ext, new Set());
         }
         this.processors.get(ext).add(processor);
+        this.nativeIndexing?.registerProcessor(owner ?? "application", ext);
     }
     removeProcessor(ext, processor) {
         if (!ext?.trim())
@@ -1064,6 +1104,13 @@ export class MetadataCache extends EventDispatcher {
     handleDatabaseChange(change) {
         if (this.disposed)
             return;
+        if (this.nativeIndexing) {
+            this.trackOperation(this.observeNativeChange(change).finally(() => {
+                if (!this.disposed)
+                    this.trigger("index-changed", change);
+            }));
+            return;
+        }
         if (this.snapshotLeaseCount > 0) {
             this.trackOperation(this.refreshCompatibilitySnapshot(change));
         }
@@ -1086,6 +1133,41 @@ export class MetadataCache extends EventDispatcher {
         }
         this.trigger("index-changed", change);
     }
+    async observeNativeChange(change) {
+        if (change.reset) {
+            if (this.snapshotLeaseCount > 0)
+                await this.refreshCompatibilitySnapshot(change);
+            else
+                for (const path of [...this.hotPathOrder.keys()])
+                    this.evictHotPath(path);
+        }
+        if (change.domains.includes("metadata")) {
+            for (const path of change.paths) {
+                await this.observeNativeFile(path);
+            }
+        }
+    }
+    async observeNativeFile(path) {
+        if (this.disposed)
+            return;
+        const row = await this.app.appDatabase.getIndexedFile(path);
+        if (this.disposed)
+            return;
+        this.evictHotPath(path);
+        const file = this.app.vault.getFileByPath(path);
+        if (!row?.metadata)
+            return;
+        this.cacheDatabaseRow(row);
+        if (!file)
+            return;
+        const text = await this.app.vault.read(file);
+        if (this.disposed ||
+            file.path !== path ||
+            !this.app.vault.getFileByPath(path) ||
+            md5(text) !== row.metadata.hash)
+            return;
+        this.trigger("changed", file, text, row.metadata.metadata);
+    }
     deferReconcileIndexChange(change) {
         if (!this.deferredReconcileIndexChange) {
             this.deferredReconcileIndexChange = cloneAppDatabaseChange(change);
@@ -1187,6 +1269,16 @@ export class MetadataCache extends EventDispatcher {
             return;
         if (!(file instanceof TFile))
             return;
+        if (this.nativeIndexing) {
+            if (event === "delete") {
+                this.trigger("deleted", file, this.getCache(file.path));
+                this.evictHotPath(file.path);
+            }
+            else if (event === "create" || event === "modify") {
+                this.trackOperation(this.observeNativeFile(file.path));
+            }
+            return;
+        }
         switch (event) {
             case "create":
             case "modify":
@@ -1207,6 +1299,12 @@ export class MetadataCache extends EventDispatcher {
             return;
         if (!(file instanceof TFile))
             return;
+        if (this.nativeIndexing) {
+            this.evictHotPath(oldPath);
+            this.evictHotPath(file.path);
+            this.trackOperation(this.observeNativeFile(file.path));
+            return;
+        }
         const existing = this.fileCache[oldPath];
         if (existing) {
             this.fileCache[file.path] = {

package/dist/command.svelte.js

@@ -1,6 +1,9 @@
+import { appStatePath, DEFAULT_APP_STATE_DIRECTORY, normalizePath, } from "./storage/path";
 import { EventDispatcher } from "./events";
+import { TFile as VaultFile } from "./storage/fs";
+import { FileTextStateWriter } from "./file-text-state-writer";
 import { resolveApplication } from "./application-compatibility";
-const HOTKEYS_PATH = "/.obsidian/hotkeys.json";
+const HOTKEYS_PATH = "/" + appStatePath("hotkeys.json");
 const MODIFIER_ORDER = ["Mod", "Ctrl", "Meta", "Alt", "Shift"];
 const WORKSPACE_ROOT_COMMAND_HOST_ID = "root";
 function isModifierValue(value) {
@@ -63,6 +66,8 @@ export class CommandManager extends EventDispatcher {
     editorCommands = $state({});
     bindings = $state({});
     hotkeyOverrides = $state({});
+    hotkeysBaseline = null;
+    hotkeysWriter;
     constructor(app) {
         super();
         this.app = app;
@@ -157,13 +162,21 @@ export class CommandManager extends EventDispatcher {
         return deduped;
     }
     async loadHotkeys() {
+        if (this.hotkeysWriter?.dirty)
+            return;
         const file = this.readHotkeyOverrideFile();
         if (!file) {
+            this.hotkeysBaseline = null;
+            if (this.hotkeysWriter && !this.hotkeysWriter.acceptBaseline(null))
+                return;
             this.replaceHotkeyOverrides({});
             return;
         }
         try {
             const raw = await this.app.vault.read(file);
+            if (this.hotkeysWriter && !this.hotkeysWriter.acceptBaseline(raw))
+                return;
+            this.hotkeysBaseline = raw;
             this.replaceHotkeyOverrides(this.normalizeOverrides(JSON.parse(raw)));
         }
         catch (error) {
@@ -173,14 +186,24 @@ export class CommandManager extends EventDispatcher {
     }
     async saveHotkeys() {
         const data = JSON.stringify(this.hotkeyOverrides, null, 2);
+        if (this.app.vault.supportsConditionalTextWrites)
+            return this.getHotkeysWriter().set(data);
         const file = this.readHotkeyOverrideFile();
         if (file) {
             await this.app.vault.modify(file, data);
             return;
         }
-        await this.app.vault.mkpath("/.obsidian");
+        await this.app.vault.mkpath("/" + DEFAULT_APP_STATE_DIRECTORY);
         await this.app.vault.create(HOTKEYS_PATH, data);
     }
+    getHotkeysWriter() {
+        if (this.hotkeysWriter)
+            return this.hotkeysWriter;
+        const file = this.readHotkeyOverrideFile() ??
+            new VaultFile(normalizePath(HOTKEYS_PATH), { ctime: 0, mtime: 0, size: 0 }, null);
+        this.hotkeysWriter = new FileTextStateWriter(this.app, file, this.hotkeysBaseline, (text) => this.replaceHotkeyOverrides(this.normalizeOverrides(JSON.parse(text || "{}"))));
+        return this.hotkeysWriter;
+    }
     replaceHotkeyOverrides(overrides) {
         for (const id of Object.keys(this.hotkeyOverrides)) {
             delete this.hotkeyOverrides[id];
@@ -206,6 +229,8 @@ export class CommandManager extends EventDispatcher {
         return this.hasHotkeyOverride(commandId);
     }
     async setHotkeys(commandId, hotkeys) {
+        if (this.app.vault.supportsConditionalTextWrites)
+            this.getHotkeysWriter().assertEditable();
         this.hotkeyOverrides[commandId] = this.dedupeHotkeys(hotkeys);
         this.rebuildBindings();
         this.emit("hotkeys-updated", {
@@ -225,6 +250,8 @@ export class CommandManager extends EventDispatcher {
         await this.setHotkeys(commandId, this.getEffectiveHotkeys(commandId).filter((candidate) => keyId(candidate) !== removeId));
     }
     async resetHotkeys(commandId) {
+        if (this.app.vault.supportsConditionalTextWrites)
+            this.getHotkeysWriter().assertEditable();
         delete this.hotkeyOverrides[commandId];
         this.rebuildBindings();
         this.emit("hotkeys-updated", {

package/dist/components/editor/editor.css

@@ -101,6 +101,8 @@
  */
 [data-ui-component="editor"] .inline-title,
 [data-ui-component="editor"] .cm-editor-inline-title {
+  box-sizing: border-box;
+  padding-inline-start: var(--ui-editor-inline-title-inset, 0px);
   color: var(--ui-editor-inline-title-color);
   font-family: var(--ui-editor-inline-title-font);
   font-size: var(--ui-editor-inline-title-size);
@@ -112,12 +114,14 @@
   margin-block-end: var(--ui-editor-inline-title-margin-bottom);
   width: 100%;
   white-space: pre-wrap;
+  overflow-wrap: anywhere;
   border: none;
   outline: none;
 }
 
 [data-ui-component="editor"]
   .cm-editor-inline-title[data-mobile-inline-title="true"] {
+  padding-inline-start: 0;
   text-align: center;
 }
 

package/dist/components/editor/editor.svelte

@@ -4,6 +4,7 @@
   import { dirname } from "../../storage/path";
   import { WorkspaceLeaf } from "../../workspace.svelte";
   import { editorConfig } from "./editor";
+  import { syncInlineTitleAlignment } from "./inline-title-alignment";
   import { ScrollArea } from "@lapismd/design-core/shadcn/scroll-area";
   import { cn } from "../../utils";
   import type { App } from "../../context.svelte";
@@ -53,10 +54,11 @@
   const codeMirror = (node: HTMLDivElement) => {
     let focusTimeout: ReturnType<typeof setTimeout> | null = null;
     const root = node.getRootNode();
-    if (root instanceof Document || root instanceof ShadowRoot) {
-      editor.view.setRoot(root);
+    if (root.nodeType === 9 || root.nodeType === 11) {
+      editor.view.setRoot(root as Document | ShadowRoot);
     }
     node.append(editor.view.dom);
+    const stopTitleAlignment = syncInlineTitleAlignment(editor.view, node);
     focusTimeout = setTimeout(() => {
       editor.view.focus();
     });
@@ -64,6 +66,7 @@
     return {
       update(qs: string) {},
       destroy() {
+        stopTitleAlignment();
         if (focusTimeout !== null) {
           clearTimeout(focusTimeout);
           focusTimeout = null;
@@ -93,9 +96,20 @@
     }
   }
 
+  function titleText(node: HTMLDivElement, name: string) {
+    const update = (value: string) => {
+      // Native contenteditable input can replace Svelte's original text node.
+      // Project committed filenames onto the element, including after renames.
+      if (node.textContent !== value) node.textContent = value;
+    };
+    update(name);
+    return { update };
+  }
+
   function renameDone(evt: KeyboardEvent) {
     if (evt.key == "Enter") {
-      renameFile((evt.target as HTMLDivElement).getText());
+      // Focusing the editor commits through onfocusout. Starting another rename
+      // here races that same file operation against its original source path.
       editor.view.focus();
       evt.preventDefault();
     }
@@ -122,6 +136,7 @@
           <!-- svelte-ignore a11y_no_static_element_interactions -->
           {#if shouldShowDesktopInlineTitle && file}
             <div
+              use:titleText={file?.name ?? ""}
               onkeydown={renameDone}
               onfocusout={(evt) =>
                 renameFile((evt.target as HTMLDivElement).getText())}
@@ -131,13 +146,12 @@
               autocapitalize="on"
               tabindex="-1"
               enterkeyhint="done"
-            >
-              {file?.name}
-            </div>
+            ></div>
           {/if}
           {#if shouldShowMobileInlineTitle && file}
             <!-- svelte-ignore a11y_no_static_element_interactions -->
             <div
+              use:titleText={file?.name ?? ""}
               onkeydown={renameDone}
               onfocusout={(evt) =>
                 renameFile((evt.target as HTMLDivElement).getText())}
@@ -150,9 +164,7 @@
               autocapitalize="on"
               tabindex="-1"
               enterkeyhint="done"
-            >
-              {file?.name}
-            </div>
+            ></div>
           {/if}
           <div use:codeMirror class="cm-editor-content"></div>
         </div>

package/dist/components/editor/embedded-editor-surface.js

@@ -1,3 +1,4 @@
+import { untrack } from "svelte";
 import { markupEditor } from "./editor";
 export function embeddedEditorContext(options) {
     return {
@@ -18,5 +19,6 @@ export function resolveEmbeddedEditorExtensions(app, options) {
     ];
 }
 export function applyEmbeddedEditorExtensions(app, editor, options) {
-    editor.updateExtensions(resolveEmbeddedEditorExtensions(app, options));
+    const extensions = resolveEmbeddedEditorExtensions(app, options);
+    untrack(() => editor.updateExtensions(extensions));
 }

package/dist/components/editor/inline-title-alignment.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from "@codemirror/view";
+/** Keep the sibling filename aligned with CodeMirror's unindented text column. */
+export declare function syncInlineTitleAlignment(view: EditorView, host: HTMLElement): () => void;