@lapis-notes/api 0.1.0

package/dist/cache.svelte.js

@@ -0,0 +1,1433 @@
+import { md5, parseLinktext, stripHeadingForLink } from "./utils";
+import { EventDispatcher } from "./events";
+import { logging } from "./logging";
+import { defaultLinkSettings, getLinkPath, normalizeVaultPath, } from "./links";
+import { basename, TFile, } from "./storage";
+import { debounce } from "lodash-es";
+import { dirname, resolvePath } from "./storage/path";
+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";
+const METADATA_RECONCILE_CHECKPOINT_VERSION = 1;
+const FINGERPRINT_MASK = (1n << 128n) - 1n;
+class StreamingManifestFingerprint {
+    count = 0;
+    sum = 0n;
+    xor = 0n;
+    add(value) {
+        const digest = BigInt(`0x${md5(value)}`);
+        this.count += 1;
+        this.sum = (this.sum + digest) & FINGERPRINT_MASK;
+        this.xor ^= digest;
+    }
+    finish(scope) {
+        return `${scope}:${this.count}:${this.sum.toString(16).padStart(32, "0")}:${this.xor.toString(16).padStart(32, "0")}`;
+    }
+}
+function isReconcileCheckpoint(value) {
+    return (isRecord(value) &&
+        value.version === METADATA_RECONCILE_CHECKPOINT_VERSION &&
+        typeof value.fingerprint === "string" &&
+        typeof value.completedAt === "number" &&
+        Number.isFinite(value.completedAt));
+}
+function yieldToUi() {
+    return new Promise((resolve) => {
+        setTimeout(resolve, 0);
+    });
+}
+function isCancellationError(error) {
+    return ((error instanceof Error && error.name === "AbortError") ||
+        (error instanceof Error && /cancel/iu.test(error.message)));
+}
+function notify(message) {
+    const Notice = globalThis.Notice;
+    if (typeof Notice === "function") {
+        new Notice(message);
+    }
+    else {
+        console.warn(message);
+    }
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function cloneAppDatabaseChange(change) {
+    return {
+        revision: change.revision,
+        domains: [...change.domains],
+        paths: [...change.paths],
+        renamed: change.renamed?.map((entry) => ({ ...entry })),
+        reset: change.reset,
+        committedAt: change.committedAt,
+    };
+}
+export function getFrontMatterInfo(content) {
+    const regexp = /^-{3}\s*[\n\r](.*?)[\n\r]-{3}\s*[\n\r]+/s;
+    let match;
+    if ((match = regexp.exec(content))) {
+        return {
+            exists: true,
+            frontmatter: match[1],
+            from: match.index,
+            to: regexp.lastIndex,
+            contentStart: match[0].length,
+        };
+    }
+    return { exists: false, frontmatter: "", from: 0, to: 0, contentStart: 0 };
+}
+export function parseFrontMatterTags(frontmatter) {
+    if (!frontmatter)
+        return null;
+    const tags = [];
+    const pushTag = (value) => {
+        const tag = value?.toString().trim();
+        if (!tag) {
+            return;
+        }
+        const normalized = tag.startsWith("#") ? tag : `#${tag}`;
+        if (/^#[/a-zA-Z0-9 _-]+$/.test(normalized)) {
+            tags.push(normalized);
+        }
+    };
+    if (typeof frontmatter === "object") {
+        for (const [key, value] of Object.entries(frontmatter)) {
+            const id = key.toLowerCase().trim();
+            if (id === "tags" || id === "tag") {
+                if (Array.isArray(value)) {
+                    value.forEach(pushTag);
+                }
+                else if (typeof value === "string") {
+                    value.split(/[,;\s]+/).forEach(pushTag);
+                }
+            }
+        }
+    }
+    return tags;
+}
+export function parseFrontMatterStringArray(frontmatter, key) {
+    if (!frontmatter || !(key in frontmatter))
+        return null;
+    const value = frontmatter[key];
+    if (Array.isArray(value)) {
+        return value.map((item) => item.toString());
+    }
+    if (typeof value === "string") {
+        return value
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    return null;
+}
+export function parseFrontMatterAliases(frontmatter) {
+    return (parseFrontMatterStringArray(frontmatter, "aliases") ??
+        parseFrontMatterStringArray(frontmatter, "alias"));
+}
+export function parseFrontMatterEntry(frontmatter, key) {
+    return frontmatter?.[key] ?? null;
+}
+export function iterateRefs(refs, cb) {
+    for (const ref of refs) {
+        if (cb(ref))
+            return true;
+    }
+    return false;
+}
+function uniquePaths(paths) {
+    return [...new Set([...paths].filter(Boolean))];
+}
+export function iterateCacheRefs(cache, cb) {
+    return iterateRefs([...(cache.links ?? []), ...(cache.embeds ?? [])], cb);
+}
+export function resolveSubpath(cache, subpath) {
+    const target = subpath.replace(/^#/, "").trim();
+    if (!target)
+        return null;
+    if (target.startsWith("^")) {
+        const id = target.slice(1);
+        const block = cache.blocks?.[id];
+        if (!block)
+            return null;
+        return {
+            type: "block",
+            block,
+            list: cache.listItems?.find((item) => item.id === id),
+            start: block.position.start,
+            end: block.position.end,
+        };
+    }
+    const footnoteId = /^\[(.+)]$/.exec(target)?.[1];
+    if (footnoteId) {
+        const footnote = cache.footnotes?.find((item) => item.id === footnoteId);
+        if (!footnote)
+            return null;
+        return {
+            type: "footnote",
+            footnote,
+            start: footnote.position.start,
+            end: footnote.position.end,
+        };
+    }
+    const normalized = stripHeadingForLink(target).toLowerCase();
+    const headings = cache.headings ?? [];
+    const index = headings.findIndex((heading) => {
+        return stripHeadingForLink(heading.heading).toLowerCase() === normalized;
+    });
+    if (index === -1)
+        return null;
+    const current = headings[index];
+    const next = headings[index + 1] ?? null;
+    return {
+        type: "heading",
+        current,
+        next,
+        start: current.position.start,
+        end: next?.position.start ?? null,
+    };
+}
+function clearObject(data) {
+    for (const key of Object.keys(data)) {
+        delete data[key];
+    }
+}
+function frontmatterValueType(value) {
+    if (Array.isArray(value))
+        return "array";
+    if (value === null)
+        return "null";
+    return typeof value;
+}
+function tagParts(tag) {
+    const parts = tag
+        .replace(/^#/, "")
+        .split("/")
+        .map((part) => part.trim())
+        .filter(Boolean);
+    const hierarchy = [];
+    for (let index = 1; index <= parts.length; index++) {
+        hierarchy.push(parts.slice(0, index).join("/"));
+    }
+    return { parts, hierarchy };
+}
+/**
+ * Indexes parsed markdown metadata, tags, headings, and resolved links for the
+ * active vault.
+ *
+ * @public
+ */
+export class MetadataCache extends EventDispatcher {
+    app;
+    processors = new Map();
+    projectionContributors = new Set();
+    #fileCache = $state({});
+    #metadataCache = $state({});
+    #resolvedLinks = $state({});
+    #unresolvedLinks = $state({});
+    logger = logging.getLogger("cache");
+    disposed = false;
+    didLoad = false;
+    loadPromise = null;
+    disposePromise = null;
+    pendingOperations = new Set();
+    hotPathOrder = new Map();
+    localMutationPaths = new Set();
+    reconcileIndexChangeDepth = 0;
+    deferredReconcileIndexChange = null;
+    reconcileCheckpointReady = false;
+    reconcileCheckpointDirty = false;
+    reconcileCheckpointGeneration = 0;
+    activeReconcileMutations = 0;
+    reconcileCheckpointWrite = null;
+    snapshotLeaseCount = 0;
+    snapshotLeasePromise = null;
+    snapshotLeaseValue = null;
+    databaseChangeUnsubscribe = null;
+    handleVaultChange = (event, file) => this.handleChange(event, file);
+    handleVaultRename = (file, oldPath) => this.handleRename(file, oldPath);
+    saveSnapshotDebounced = debounce(() => void this.saveSnapshotNow(), 500);
+    constructor(app) {
+        super();
+        this.app = app;
+        app.vault.on("all", this.handleVaultChange);
+        app.vault.on("rename", this.handleVaultRename);
+        this.databaseChangeUnsubscribe =
+            app.appDatabase.subscribeToChanges?.((change) => this.handleDatabaseChange(change)) ?? null;
+    }
+    get metadataCache() {
+        return this.#metadataCache;
+    }
+    get resolvedLinks() {
+        return this.#resolvedLinks;
+    }
+    get unresolvedLinks() {
+        return this.#unresolvedLinks;
+    }
+    get fileCache() {
+        return this.#fileCache;
+    }
+    get initialized() {
+        return this.didLoad;
+    }
+    getAllItems() {
+        const map = new Map();
+        for (const [path, cache] of Object.entries(this.#fileCache)) {
+            const item = this.#metadataCache[cache.hash];
+            const file = this.app.vault.getFileByPath(path);
+            if (item && file) {
+                map.set(file, item);
+            }
+        }
+        return map;
+    }
+    scheduleSnapshotSave() {
+        if (this.disposed || this.snapshotLeaseCount === 0)
+            return;
+        this.saveSnapshotDebounced();
+    }
+    async flushSnapshotSave() {
+        this.saveSnapshotDebounced.cancel();
+        await this.saveSnapshotNow({ forceBackup: true });
+    }
+    async dispose(options = {}) {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.app.vault.off("all", this.handleVaultChange);
+        this.app.vault.off("rename", this.handleVaultRename);
+        this.databaseChangeUnsubscribe?.();
+        this.databaseChangeUnsubscribe = null;
+        this.snapshotLeaseCount = 0;
+        this.snapshotLeasePromise = null;
+        this.snapshotLeaseValue = null;
+        this.saveSnapshotDebounced.cancel();
+        this.disposePromise = (async () => {
+            await Promise.allSettled([...this.pendingOperations]);
+            await this.persistReconcileCheckpoint({ allowDisposed: true });
+            void options;
+        })();
+        return this.disposePromise;
+    }
+    async saveSnapshotNow(_options = {}) {
+        const snapshot = await this.buildCompatibilitySnapshot();
+        try {
+            await this.app.appDatabase.saveMetadataSnapshot(snapshot);
+        }
+        catch (err) {
+            console.error("Failure saving metadata cache", err);
+            notify(`Failure saving metadata cache: ${err}`);
+        }
+    }
+    toJSON() {
+        return {
+            fileCache: $state.snapshot(this.#fileCache),
+            metadataCache: $state.snapshot(this.metadataCache),
+            resolvedLinks: $state.snapshot(this.resolvedLinks),
+            unresolvedLinks: $state.snapshot(this.unresolvedLinks),
+        };
+    }
+    applySnapshot(snapshot) {
+        if (this.disposed)
+            return;
+        this.didLoad = true;
+        this.#fileCache = snapshot.fileCache;
+        this.#metadataCache = snapshot.metadataCache;
+        this.#resolvedLinks = snapshot.resolvedLinks;
+        this.#unresolvedLinks = snapshot.unresolvedLinks;
+    }
+    async load() {
+        if (this.disposed)
+            return;
+        if (this.loadPromise)
+            return this.loadPromise;
+        this.loadPromise = this.performLoad();
+        this.trackOperation(this.loadPromise);
+        return this.loadPromise;
+    }
+    async performLoad() {
+        try {
+            await this.app.telemetry.measureAsync("metadata.cache.load", async (loadSpan) => this.app.notifications.withProgress({
+                title: "Loading metadata cache",
+                source: "Metadata",
+                location: "status",
+                persistOnError: true,
+            }, async (progress) => {
+                if (this.disposed)
+                    return;
+                progress.report({ message: "Opening metadata store" });
+                await this.app.appDatabase.open();
+                if (this.disposed)
+                    return;
+                this.didLoad = true;
+                this.trigger("loaded");
+                const total = this.countProcessableVaultFiles();
+                loadSpan.setAttribute("metadata.files.total", total);
+                const fingerprint = this.getReconciliationFingerprint();
+                const checkpoint = await this.app.appDatabase.getMeta(METADATA_RECONCILE_CHECKPOINT_KEY);
+                if (isReconcileCheckpoint(checkpoint) &&
+                    checkpoint.fingerprint === fingerprint) {
+                    this.reconcileCheckpointReady = true;
+                    this.reconcileCheckpointDirty = false;
+                    loadSpan.setAttribute("metadata.checkpoint", "hit");
+                    progress.report({ message: "Metadata index ready" });
+                    this.app.telemetry.recordEvent("metadata.reconcile.complete", {
+                        checkpoint: "hit",
+                        "files.total": total,
+                        "files.processed": 0,
+                        "files.changed": 0,
+                        "files.deleted": 0,
+                    });
+                    return;
+                }
+                loadSpan.setAttribute("metadata.checkpoint", "miss");
+                progress.report({ message: "Reconciling metadata index" });
+                const summary = await this.reconcileDatabaseWithVault(progress);
+                if (this.disposed)
+                    return;
+                this.reconcileCheckpointReady = true;
+                this.markReconcileCheckpointDirty();
+                await this.persistReconcileCheckpoint();
+                this.app.telemetry.recordEvent("metadata.reconcile.complete", {
+                    checkpoint: "miss",
+                    "files.total": summary.total,
+                    "files.processed": summary.processed,
+                    "files.changed": summary.changed,
+                    "files.deleted": summary.deleted,
+                });
+            }));
+        }
+        catch (error) {
+            this.app.telemetry.recordEvent(isCancellationError(error)
+                ? "metadata.reconcile.cancelled"
+                : "metadata.reconcile.failed", { status: isCancellationError(error) ? "cancelled" : "failed" });
+            throw error;
+        }
+    }
+    async reconcileDatabaseWithVault(progress) {
+        const summary = {
+            total: this.countProcessableVaultFiles(),
+            processed: 0,
+            changed: 0,
+            deleted: 0,
+            batches: 0,
+        };
+        if (this.disposed)
+            return summary;
+        const reconcileSpan = this.app.telemetry.startSpan("metadata.reconcile", {
+            attributes: { "metadata.files.total": summary.total },
+        });
+        this.reconcileIndexChangeDepth += 1;
+        let processed = 0;
+        let total = summary.total;
+        let cursor;
+        try {
+            progress?.report({
+                current: 0,
+                total,
+                message: total > 0
+                    ? `Reconciling metadata index (0 of ${total})`
+                    : "Reconciling metadata index",
+            });
+            const report = async (path) => {
+                progress?.throwIfCancellationRequested();
+                processed += 1;
+                total = Math.max(total, processed);
+                progress?.report({
+                    current: processed,
+                    total,
+                    message: `${path} (${processed} of ${total})`,
+                });
+                await yieldToUi();
+            };
+            const reportProcessing = async (path, stage = "Indexing") => {
+                progress?.throwIfCancellationRequested();
+                progress?.report({
+                    current: processed,
+                    total,
+                    message: `${stage}: ${path} (${processed + 1} of ${total})`,
+                });
+                await yieldToUi();
+            };
+            do {
+                progress?.report({
+                    current: processed,
+                    total,
+                    message: `Querying existing metadata index (${processed} of ${total})`,
+                });
+                const batchSpan = this.app.telemetry.startSpan("metadata.reconcile.batch", {
+                    parent: reconcileSpan,
+                    attributes: {
+                        "metadata.batch.kind": "indexed",
+                        "metadata.batch.limit": 500,
+                    },
+                });
+                summary.batches += 1;
+                let page;
+                try {
+                    page = await this.app.appDatabase.listIndexedFileManifest({
+                        after: cursor,
+                        limit: 500,
+                    });
+                    batchSpan.end({ "metadata.batch.rows": page.rows.length });
+                }
+                catch (error) {
+                    batchSpan.recordException(error);
+                    batchSpan.end();
+                    throw error;
+                }
+                for (const indexed of page.rows) {
+                    if (this.disposed)
+                        return summary;
+                    const current = this.app.vault.getFileByPath(indexed.path);
+                    if (!current ||
+                        !this.processors.has(current.extension.toLowerCase())) {
+                        await this.mutateDatabasePaths([indexed.path], () => this.app.appDatabase.deleteIndexedFile(indexed.path));
+                        this.evictHotPath(indexed.path);
+                        summary.deleted += 1;
+                        await report(indexed.path);
+                        continue;
+                    }
+                    if (current.stat.mtime !== indexed.mtime ||
+                        current.stat.size !== indexed.size ||
+                        indexed.parserVersion !== this.parserSignature(current)) {
+                        await reportProcessing(current.path);
+                        await this.processFile(current, (stage) => reportProcessing(current.path, stage));
+                        summary.changed += 1;
+                    }
+                    await report(current.path);
+                }
+                cursor = page.nextCursor;
+            } while (cursor && !this.disposed);
+            const batch = [];
+            const reconcileCreatedBatch = async () => {
+                if (!batch.length || this.disposed)
+                    return;
+                const batchSize = batch.length;
+                progress?.report({
+                    current: processed,
+                    total,
+                    message: `Querying ${batch.length} vault files against metadata index (${processed} of ${total})`,
+                });
+                const batchSpan = this.app.telemetry.startSpan("metadata.reconcile.batch", {
+                    parent: reconcileSpan,
+                    attributes: {
+                        "metadata.batch.kind": "vault",
+                        "metadata.batch.limit": batchSize,
+                    },
+                });
+                summary.batches += 1;
+                let manifest;
+                try {
+                    manifest = await this.app.appDatabase.listIndexedFileManifest({
+                        paths: batch.map((file) => file.path),
+                        limit: batch.length,
+                    });
+                    batchSpan.end({ "metadata.batch.rows": manifest.rows.length });
+                }
+                catch (error) {
+                    batchSpan.recordException(error);
+                    batchSpan.end();
+                    throw error;
+                }
+                const indexedPaths = new Set(manifest.rows.map((file) => file.path));
+                for (const file of batch) {
+                    if (this.disposed)
+                        return;
+                    if (!indexedPaths.has(file.path)) {
+                        await reportProcessing(file.path);
+                        await this.processFile(file, (stage) => reportProcessing(file.path, stage));
+                        summary.changed += 1;
+                        await report(file.path);
+                    }
+                }
+                batch.length = 0;
+            };
+            for (const file of this.app.vault.iterateFiles()) {
+                if (this.disposed)
+                    return summary;
+                if (!this.processors.has(file.extension.toLowerCase()))
+                    continue;
+                batch.push(file);
+                if (batch.length >= 500)
+                    await reconcileCreatedBatch();
+            }
+            await reconcileCreatedBatch();
+        }
+        catch (error) {
+            reconcileSpan.recordException(error);
+            throw error;
+        }
+        finally {
+            summary.total = total;
+            summary.processed = processed;
+            reconcileSpan.end({
+                "metadata.files.total": summary.total,
+                "metadata.files.processed": summary.processed,
+                "metadata.files.changed": summary.changed,
+                "metadata.files.deleted": summary.deleted,
+                "metadata.batch.count": summary.batches,
+            });
+            this.reconcileIndexChangeDepth = Math.max(0, this.reconcileIndexChangeDepth - 1);
+            if (this.reconcileIndexChangeDepth === 0) {
+                this.flushDeferredReconcileIndexChange();
+            }
+        }
+        return summary;
+    }
+    countProcessableVaultFiles() {
+        let total = 0;
+        for (const file of this.app.vault.iterateFiles()) {
+            if (this.processors.has(file.extension.toLowerCase())) {
+                total += 1;
+            }
+        }
+        return total;
+    }
+    /**
+     * Return the current vault/parser manifest fingerprint used to validate the
+     * durable metadata index and disposable indexed-consumer snapshots.
+     */
+    getReconciliationFingerprint() {
+        const fingerprint = new StreamingManifestFingerprint();
+        for (const file of this.app.vault.iterateFiles()) {
+            if (!this.processors.has(file.extension.toLowerCase()))
+                continue;
+            fingerprint.add([
+                file.path,
+                file.stat.mtime,
+                file.stat.size,
+                this.parserSignature(file),
+            ].join("\u0000"));
+        }
+        return fingerprint.finish("metadata-cache-v1");
+    }
+    markReconcileCheckpointDirty() {
+        this.reconcileCheckpointDirty = true;
+        this.reconcileCheckpointGeneration += 1;
+    }
+    async persistReconcileCheckpoint(options = {}) {
+        if (this.reconcileCheckpointWrite) {
+            await this.reconcileCheckpointWrite;
+            return;
+        }
+        if ((!options.allowDisposed && this.disposed) ||
+            !this.reconcileCheckpointReady ||
+            !this.reconcileCheckpointDirty ||
+            this.activeReconcileMutations > 0) {
+            return;
+        }
+        this.reconcileCheckpointWrite = (async () => {
+            while ((options.allowDisposed || !this.disposed) &&
+                this.reconcileCheckpointReady &&
+                this.reconcileCheckpointDirty &&
+                this.activeReconcileMutations === 0) {
+                const generation = this.reconcileCheckpointGeneration;
+                const fingerprint = this.getReconciliationFingerprint();
+                try {
+                    await this.app.appDatabase.setMeta(METADATA_RECONCILE_CHECKPOINT_KEY, {
+                        version: METADATA_RECONCILE_CHECKPOINT_VERSION,
+                        fingerprint,
+                        completedAt: Date.now(),
+                    });
+                }
+                catch (error) {
+                    this.reconcileCheckpointReady = false;
+                    this.logger.warn("Failed to persist metadata reconciliation checkpoint", error);
+                    return;
+                }
+                if (generation === this.reconcileCheckpointGeneration) {
+                    this.reconcileCheckpointDirty = false;
+                }
+            }
+        })();
+        try {
+            await this.reconcileCheckpointWrite;
+        }
+        finally {
+            this.reconcileCheckpointWrite = null;
+        }
+    }
+    async invalidateReconcileCheckpoint() {
+        this.reconcileCheckpointReady = false;
+        this.markReconcileCheckpointDirty();
+        await this.app.appDatabase.setMeta(METADATA_RECONCILE_CHECKPOINT_KEY, {
+            version: METADATA_RECONCILE_CHECKPOINT_VERSION,
+            fingerprint: "",
+            completedAt: 0,
+        });
+    }
+    trackReconcileMutation(operation, completed = () => true) {
+        this.markReconcileCheckpointDirty();
+        this.activeReconcileMutations += 1;
+        const tracked = operation
+            .then((value) => {
+            if (!completed(value))
+                this.reconcileCheckpointReady = false;
+            return value;
+        })
+            .catch((error) => {
+            this.reconcileCheckpointReady = false;
+            throw error;
+        })
+            .finally(() => {
+            this.activeReconcileMutations = Math.max(0, this.activeReconcileMutations - 1);
+            void this.persistReconcileCheckpoint();
+        });
+        this.trackOperation(tracked);
+    }
+    getFileCache(file) {
+        return this.getCache(file.path);
+    }
+    getCache(path) {
+        const entry = this.fileCache[path];
+        const cache = this.metadataCache[entry?.hash];
+        if (cache)
+            this.touchHotPath(path);
+        return cache ?? null;
+    }
+    async getFileCacheAsync(file) {
+        const path = typeof file === "string" ? file : file.path;
+        const hot = this.getCache(path);
+        if (hot)
+            return hot;
+        const row = await this.app.appDatabase.getIndexedFile(path);
+        if (!row?.metadata)
+            return null;
+        return this.cacheDatabaseRow(row);
+    }
+    queryMetadataPage(query = {}) {
+        return this.app.appDatabase.queryIndexedMetadataPage(query);
+    }
+    queryMetadata(query = {}) {
+        return this.app.appDatabase.queryIndexedMetadata(query);
+    }
+    queryFacets(query) {
+        return this.app.appDatabase.queryMetadataFacets(query);
+    }
+    queryLinks(query) {
+        return this.app.appDatabase.queryMetadataLinks(query);
+    }
+    watchQuery(query, listener, onError) {
+        let current;
+        let generation = 0;
+        let disposed = false;
+        const refresh = async () => {
+            const requestGeneration = ++generation;
+            try {
+                const page = await this.queryMetadataPage(query);
+                if (disposed || requestGeneration !== generation)
+                    return;
+                current = page;
+                listener(page);
+            }
+            catch (error) {
+                if (disposed || requestGeneration !== generation)
+                    return;
+                onError?.(error);
+                if (!onError)
+                    throw error;
+            }
+        };
+        const scheduleRefresh = () => {
+            void refresh().catch((error) => {
+                this.logger.warn("Metadata query watch failed", error);
+            });
+        };
+        const event = this.on("index-changed", (change) => {
+            if (change.reset || change.domains.includes("metadata"))
+                scheduleRefresh();
+        });
+        scheduleRefresh();
+        return {
+            get current() {
+                return current;
+            },
+            refresh,
+            dispose: () => {
+                disposed = true;
+                generation += 1;
+                this.offref(event);
+            },
+        };
+    }
+    async acquireMetadataSnapshotLease() {
+        this.snapshotLeaseCount += 1;
+        try {
+            if (!this.snapshotLeaseValue) {
+                this.snapshotLeasePromise ??= this.buildCompatibilitySnapshot().finally(() => {
+                    this.snapshotLeasePromise = null;
+                });
+                this.snapshotLeaseValue = await this.snapshotLeasePromise;
+                this.applySnapshot(this.snapshotLeaseValue);
+            }
+        }
+        catch (error) {
+            this.snapshotLeaseCount = Math.max(0, this.snapshotLeaseCount - 1);
+            if (this.snapshotLeaseCount === 0)
+                this.snapshotLeaseValue = null;
+            throw error;
+        }
+        const snapshot = this.snapshotLeaseValue;
+        let released = false;
+        return {
+            snapshot,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.snapshotLeaseCount = Math.max(0, this.snapshotLeaseCount - 1);
+                if (this.snapshotLeaseCount === 0) {
+                    this.snapshotLeaseValue = null;
+                    this.trimToHotPaths();
+                }
+            },
+        };
+    }
+    getDirectReferencePaths(sourcePath) {
+        const cache = this.getCache(sourcePath);
+        if (!cache) {
+            return [];
+        }
+        const targets = new Set();
+        iterateCacheRefs(cache, (ref) => {
+            const target = this.getFirstLinkpathDest(ref.link, sourcePath);
+            if (target?.path) {
+                targets.add(target.path);
+            }
+        });
+        return uniquePaths(targets);
+    }
+    pathDirectlyReferences(sourcePath, targetPath) {
+        if (!sourcePath || !targetPath) {
+            return false;
+        }
+        return this.getDirectReferencePaths(sourcePath).includes(targetPath);
+    }
+    getDirectReferencingPaths(targetPath) {
+        if (!targetPath) {
+            return [];
+        }
+        const matches = [];
+        for (const sourcePath of Object.keys(this.fileCache)) {
+            if (this.pathDirectlyReferences(sourcePath, targetPath)) {
+                matches.push(sourcePath);
+            }
+        }
+        return uniquePaths(matches);
+    }
+    isDirectlyAffectedByPathChange(watchedPath, changedPath) {
+        if (!watchedPath || !changedPath) {
+            return false;
+        }
+        return (watchedPath === changedPath ||
+            this.pathDirectlyReferences(watchedPath, changedPath) ||
+            this.pathDirectlyReferences(changedPath, watchedPath));
+    }
+    getFirstLinkpathDest(linkpath, sourcePath) {
+        const parsed = parseLinktext(linkpath);
+        const normalizedPath = normalizeVaultPath(parsed.path);
+        if (!normalizedPath.length) {
+            return null;
+        }
+        const sourceDir = normalizeVaultPath(sourcePath ? dirname(normalizeVaultPath(sourcePath)) : "");
+        const relativePath = sourceDir.length
+            ? normalizeVaultPath(resolvePath(sourceDir, normalizedPath))
+            : normalizedPath;
+        const linkName = basename(normalizedPath);
+        const basenamePath = linkName.replace(/\.(md|markdown)$/i, "");
+        const candidates = [
+            relativePath,
+            `${relativePath}.md`,
+            `${relativePath}.markdown`,
+            normalizedPath,
+            `${normalizedPath}.md`,
+            `${normalizedPath}.markdown`,
+            ...this.app.vault
+                .getMarkdownFiles()
+                .filter((file) => file.basename === basenamePath ||
+                file.baseName === basenamePath ||
+                file.path === normalizedPath)
+                .map((file) => file.path),
+            ...this.app.vault
+                .getFiles()
+                .filter((file) => {
+                const filePath = normalizeVaultPath(file.path);
+                return (filePath.endsWith(`/${normalizedPath}`) ||
+                    filePath.endsWith(`/${normalizedPath}.md`) ||
+                    filePath.endsWith(`/${normalizedPath}.markdown`));
+            })
+                .map((file) => file.path),
+            ...this.app.vault
+                .getFiles()
+                .filter((file) => file.baseName === linkName)
+                .map((file) => file.path),
+        ];
+        const dedupedCandidates = [...new Set(candidates.filter(Boolean))];
+        for (const candidate of dedupedCandidates) {
+            const file = this.app.vault.getFileByPath(candidate);
+            if (file)
+                return file;
+        }
+        return null;
+    }
+    fileToLinktext(file, sourcePath, omitMdExtension) {
+        const vaultIndex = {
+            getFiles: () => this.app.vault.getFiles().map((vaultFile) => ({
+                path: vaultFile.path,
+                basename: vaultFile.basename,
+                extension: vaultFile.extension,
+            })),
+        };
+        return getLinkPath(file.path, sourcePath, {
+            ...defaultLinkSettings,
+            omitMarkdownExtension: omitMdExtension ?? defaultLinkSettings.omitMarkdownExtension,
+        }, vaultIndex);
+    }
+    rebuild(progress) {
+        if (progress) {
+            return this.performRebuild(progress);
+        }
+        return this.app.notifications.withProgress({
+            title: "Rebuilding metadata cache",
+            source: "Metadata",
+            location: "status",
+            cancellable: true,
+            persistOnError: true,
+        }, (handle) => this.performRebuild(handle));
+    }
+    async performRebuild(progress) {
+        await this.invalidateReconcileCheckpoint();
+        clearObject(this.fileCache);
+        clearObject(this.metadataCache);
+        clearObject(this.resolvedLinks);
+        clearObject(this.unresolvedLinks);
+        this.hotPathOrder.clear();
+        let manifestCursor;
+        do {
+            const page = await this.app.appDatabase.listIndexedFileManifest({
+                after: manifestCursor,
+                limit: 500,
+            });
+            for (const indexed of page.rows) {
+                if (this.disposed)
+                    return;
+                progress.throwIfCancellationRequested();
+                await this.mutateDatabasePaths([indexed.path], () => this.app.appDatabase.deleteIndexedFile(indexed.path));
+            }
+            manifestCursor = page.nextCursor;
+        } while (manifestCursor && !this.disposed);
+        const files = this.app.vault.getFiles();
+        let processed = 0;
+        for (const file of files) {
+            if (this.disposed)
+                return;
+            progress.throwIfCancellationRequested();
+            progress.report({
+                current: processed,
+                total: files.length,
+                message: file.path,
+            });
+            await this.processFile(file);
+            processed += 1;
+            await yieldToUi();
+        }
+        if (this.disposed)
+            return;
+        progress.report({
+            current: processed,
+            total: files.length,
+            message: "Metadata index rebuilt",
+        });
+        this.reconcileCheckpointReady = true;
+        this.markReconcileCheckpointDirty();
+        await this.persistReconcileCheckpoint();
+    }
+    addProcessor(ext, processor) {
+        if (!ext?.trim())
+            return;
+        ext = ext.trim().toLowerCase();
+        if (!this.processors.has(ext)) {
+            this.processors.set(ext, new Set());
+        }
+        this.processors.get(ext).add(processor);
+    }
+    removeProcessor(ext, processor) {
+        if (!ext?.trim())
+            return false;
+        ext = ext.trim().toLowerCase();
+        if (!this.processors.has(ext))
+            return false;
+        return this.processors.get(ext).delete(processor);
+    }
+    async projectRegisteredIndexes(file, content, cache, hash) {
+        const fileRef = {
+            path: file.path,
+            extension: file.extension,
+            name: file.name,
+        };
+        for (const entry of this.app.indexProjections.matching(fileRef, cache)) {
+            try {
+                const result = await entry.registration.project({
+                    file: fileRef,
+                    content,
+                    cache,
+                });
+                await this.app.appDatabase.replaceProjectionSource({
+                    projectionId: entry.projectionId,
+                    sourcePath: file.path,
+                    sourceHash: hash,
+                    rows: result.rows,
+                    edges: result.edges,
+                });
+            }
+            catch (error) {
+                await this.app.appDatabase.markProjectionSourceError({
+                    projectionId: entry.projectionId,
+                    sourcePath: file.path,
+                    sourceHash: hash,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    addIndexedProjectionContributor(contributor) {
+        this.projectionContributors.add(contributor);
+    }
+    removeIndexedProjectionContributor(contributor) {
+        return this.projectionContributors.delete(contributor);
+    }
+    parserSignature(file) {
+        const processorCount = this.processors.get(file.extension.toLowerCase())?.size ?? 0;
+        return `metadata-cache-v2:${file.extension.toLowerCase()}:${processorCount}`;
+    }
+    cacheDatabaseRow(row) {
+        if (!row.metadata || !isRecord(row.metadata.metadata))
+            return null;
+        const cache = row.metadata.metadata;
+        this.#fileCache[row.file.path] = {
+            mtime: row.file.mtime,
+            size: row.file.size,
+            hash: row.metadata.hash,
+        };
+        this.#metadataCache[row.metadata.hash] = cache;
+        this.#resolvedLinks[row.file.path] = {};
+        this.#unresolvedLinks[row.file.path] = {};
+        for (const link of row.links) {
+            const target = link.resolvedTargetPath;
+            const collection = target
+                ? this.#resolvedLinks[row.file.path]
+                : this.#unresolvedLinks[row.file.path];
+            const key = target ?? link.targetText;
+            collection[key] = (collection[key] ?? 0) + Math.max(1, link.count);
+        }
+        this.touchHotPath(row.file.path);
+        return cache;
+    }
+    touchHotPath(path) {
+        this.hotPathOrder.delete(path);
+        this.hotPathOrder.set(path, true);
+        if (this.snapshotLeaseCount > 0)
+            return;
+        while (this.hotPathOrder.size > METADATA_CACHE_HOT_LIMIT) {
+            const oldest = this.hotPathOrder.keys().next().value;
+            if (!oldest)
+                break;
+            this.evictHotPath(oldest);
+        }
+    }
+    evictHotPath(path) {
+        const hash = this.#fileCache[path]?.hash;
+        delete this.#fileCache[path];
+        delete this.#resolvedLinks[path];
+        delete this.#unresolvedLinks[path];
+        this.hotPathOrder.delete(path);
+        if (hash &&
+            !Object.values(this.#fileCache).some((entry) => entry.hash === hash)) {
+            delete this.#metadataCache[hash];
+        }
+    }
+    trimToHotPaths() {
+        for (const path of Object.keys(this.#fileCache)) {
+            if (!this.hotPathOrder.has(path))
+                this.evictHotPath(path);
+        }
+        while (this.hotPathOrder.size > METADATA_CACHE_HOT_LIMIT) {
+            const oldest = this.hotPathOrder.keys().next().value;
+            if (!oldest)
+                break;
+            this.evictHotPath(oldest);
+        }
+    }
+    handleDatabaseChange(change) {
+        if (this.disposed)
+            return;
+        if (this.snapshotLeaseCount > 0) {
+            this.trackOperation(this.refreshCompatibilitySnapshot(change));
+        }
+        else if (change.reset) {
+            for (const path of [...this.hotPathOrder.keys()]) {
+                if (!this.localMutationPaths.has(path))
+                    this.evictHotPath(path);
+            }
+        }
+        else if (change.domains.includes("metadata")) {
+            for (const path of change.paths) {
+                if (!this.localMutationPaths.has(path))
+                    this.evictHotPath(path);
+            }
+        }
+        if (this.reconcileIndexChangeDepth > 0 &&
+            change.domains.includes("metadata")) {
+            this.deferReconcileIndexChange(change);
+            return;
+        }
+        this.trigger("index-changed", change);
+    }
+    deferReconcileIndexChange(change) {
+        if (!this.deferredReconcileIndexChange) {
+            this.deferredReconcileIndexChange = cloneAppDatabaseChange(change);
+            return;
+        }
+        const current = this.deferredReconcileIndexChange;
+        this.deferredReconcileIndexChange = {
+            revision: Math.max(current.revision, change.revision),
+            domains: [...new Set([...current.domains, ...change.domains])],
+            paths: [...new Set([...current.paths, ...change.paths])],
+            renamed: [
+                ...(current.renamed ?? []),
+                ...(change.renamed?.map((entry) => ({ ...entry })) ?? []),
+            ],
+            reset: current.reset || change.reset,
+            committedAt: Math.max(current.committedAt, change.committedAt),
+        };
+    }
+    flushDeferredReconcileIndexChange() {
+        const change = this.deferredReconcileIndexChange;
+        this.deferredReconcileIndexChange = null;
+        if (!change || this.disposed)
+            return;
+        this.trigger("index-changed", change);
+    }
+    async refreshCompatibilitySnapshot(change) {
+        if (this.disposed || this.snapshotLeaseCount === 0)
+            return;
+        if (change.reset) {
+            const snapshot = await this.buildCompatibilitySnapshot();
+            if (this.disposed || this.snapshotLeaseCount === 0)
+                return;
+            this.snapshotLeaseValue = snapshot;
+            this.applySnapshot(snapshot);
+            return;
+        }
+        if (!change.domains.includes("metadata"))
+            return;
+        for (const path of change.paths) {
+            if (this.disposed || this.snapshotLeaseCount === 0)
+                return;
+            if (this.localMutationPaths.has(path))
+                continue;
+            const row = await this.app.appDatabase.getIndexedFile(path);
+            if (row?.metadata)
+                this.cacheDatabaseRow(row);
+            else
+                this.evictHotPath(path);
+        }
+    }
+    async mutateDatabasePaths(paths, operation) {
+        paths.forEach((path) => this.localMutationPaths.add(path));
+        try {
+            return await operation();
+        }
+        finally {
+            paths.forEach((path) => this.localMutationPaths.delete(path));
+        }
+    }
+    async buildCompatibilitySnapshot() {
+        const snapshot = {
+            fileCache: {},
+            metadataCache: {},
+            resolvedLinks: {},
+            unresolvedLinks: {},
+        };
+        let cursor;
+        do {
+            const page = await this.app.appDatabase.queryIndexedMetadataPage({
+                after: cursor,
+                limit: 500,
+            });
+            for (const row of page.rows) {
+                if (!row.metadata || !isRecord(row.metadata.metadata))
+                    continue;
+                snapshot.fileCache[row.file.path] = {
+                    mtime: row.file.mtime,
+                    size: row.file.size,
+                    hash: row.metadata.hash,
+                };
+                snapshot.metadataCache[row.metadata.hash] = row.metadata.metadata;
+                snapshot.resolvedLinks[row.file.path] = {};
+                snapshot.unresolvedLinks[row.file.path] = {};
+                for (const link of row.links) {
+                    const target = link.resolvedTargetPath;
+                    const collection = target
+                        ? snapshot.resolvedLinks[row.file.path]
+                        : snapshot.unresolvedLinks[row.file.path];
+                    const key = target ?? link.targetText;
+                    collection[key] = (collection[key] ?? 0) + Math.max(1, link.count);
+                }
+            }
+            cursor = page.nextCursor;
+        } while (cursor);
+        return snapshot;
+    }
+    handleChange(event, file) {
+        if (this.disposed)
+            return;
+        if (!(file instanceof TFile))
+            return;
+        switch (event) {
+            case "create":
+            case "modify":
+                if (!this.processors.has(file.extension.toLowerCase()))
+                    break;
+                this.trackReconcileMutation(this.processFile(file), (processed) => processed);
+                break;
+            case "delete":
+                const existing = this.fileCache[file.path];
+                this.trigger("deleted", file, existing ? (this.metadataCache[existing.hash] ?? null) : null);
+                this.evictHotPath(file.path);
+                this.trackReconcileMutation(this.mutateDatabasePaths([file.path], () => this.app.appDatabase.deleteIndexedFile(file.path)));
+                break;
+        }
+    }
+    handleRename(file, oldPath) {
+        if (this.disposed)
+            return;
+        if (!(file instanceof TFile))
+            return;
+        const existing = this.fileCache[oldPath];
+        if (existing) {
+            this.fileCache[file.path] = {
+                ...existing,
+                mtime: file.stat.mtime,
+                size: file.stat.size,
+            };
+            delete this.fileCache[oldPath];
+            if (this.resolvedLinks[oldPath]) {
+                this.resolvedLinks[file.path] = this.resolvedLinks[oldPath];
+                delete this.resolvedLinks[oldPath];
+            }
+            if (this.unresolvedLinks[oldPath]) {
+                this.unresolvedLinks[file.path] = this.unresolvedLinks[oldPath];
+                delete this.unresolvedLinks[oldPath];
+            }
+            this.hotPathOrder.delete(oldPath);
+            this.touchHotPath(file.path);
+        }
+        this.trackReconcileMutation(this.mutateDatabasePaths([oldPath, file.path], () => this.app.appDatabase.renameIndexedFile(oldPath, file.path)));
+    }
+    trackOperation(operation) {
+        this.pendingOperations.add(operation);
+        void operation
+            .catch((error) => {
+            this.logger.warn("Metadata cache background operation failed", error);
+        })
+            .finally(() => {
+            this.pendingOperations.delete(operation);
+        });
+    }
+    async processFile(file, onStage) {
+        if (this.disposed || !file)
+            return false;
+        file = this.app.vault.getFileByPath(file.path);
+        if (this.disposed || !file)
+            return false;
+        const processors = this.processors.get(file.extension.toLowerCase());
+        if (!processors || !processors.size)
+            return false;
+        await onStage?.("Reading");
+        const content = await this.app.vault.read(file);
+        if (this.disposed)
+            return false;
+        await onStage?.("Hashing");
+        const hash = md5(content);
+        const existing = this.fileCache[file.path];
+        if (existing && existing.hash === hash)
+            return false;
+        await onStage?.("Parsing metadata");
+        let cachedMetadata = await this.read(content, file);
+        if (this.disposed)
+            return false;
+        if (cachedMetadata) {
+            this.#metadataCache[hash] = cachedMetadata;
+            this.#fileCache[file.path] = {
+                mtime: file.stat.mtime,
+                size: file.stat.size,
+                hash,
+            };
+            this.touchHotPath(file.path);
+            this.processLink(file);
+            const record = this.toDatabaseRecord(file, hash, cachedMetadata);
+            await onStage?.("Writing metadata index");
+            await this.mutateDatabasePaths([file.path], () => this.app.appDatabase.upsertIndexedFile(record));
+            await onStage?.("Writing projection index");
+            await this.projectRegisteredIndexes(file, content, cachedMetadata, hash);
+            await onStage?.("Notifying metadata listeners");
+            this.trigger("changed", file, content, cachedMetadata);
+        }
+        if (existing && existing.hash !== hash) {
+            if (!Object.values(this.fileCache).some((entry) => entry.hash === existing.hash)) {
+                delete this.metadataCache[existing.hash];
+            }
+        }
+        this.logger.debug("Processing file", file.path);
+        return Boolean(cachedMetadata);
+    }
+    extractLink(path) {
+        const [segment, description] = path.split("|", 2);
+        const [url, sectionId] = segment.split("#", 2);
+        return {
+            url,
+            sectionId,
+            displayText: description || basename(path) + (sectionId ? ` > ${sectionId}` : ""),
+        };
+    }
+    processLink(file) {
+        const cachedMetadata = this.metadataCache[this.fileCache[file.path]?.hash];
+        if (!cachedMetadata)
+            return;
+        this.resolvedLinks[file.path] = {};
+        this.unresolvedLinks[file.path] = {};
+        const links = cachedMetadata.links;
+        if (!links?.length)
+            return;
+        links.forEach((link) => {
+            const spec = this.extractLink(link.link);
+            const path = ([...this.processors.keys()]
+                .map((ext) => `${spec.url}.${ext}`)
+                .find((path) => this.app.vault.getFileByPath(path)) ??
+                this.app.vault.getFileByPath(spec.url))
+                ? spec.url
+                : null;
+            if (path) {
+                this.resolvedLinks[file.path][path] ||= 0;
+                this.resolvedLinks[file.path][path] += 1;
+            }
+            else {
+                this.unresolvedLinks[file.path][link.link] ||= 0;
+                this.unresolvedLinks[file.path][link.link] += 1;
+            }
+        });
+    }
+    toDatabaseRecord(file, hash, cache) {
+        const refs = [];
+        (cache.links ?? []).forEach((ref, ordinal) => {
+            const spec = this.extractLink(ref.link);
+            refs.push({
+                sourcePath: file.path,
+                targetText: ref.link,
+                original: ref.original,
+                resolvedTargetPath: this.getFirstLinkpathDest(spec.url, file.path)?.path ?? null,
+                type: "link",
+                position: ref.position,
+                count: 1,
+                heading: ref.heading ?? null,
+                kind: "reference",
+                ordinal,
+            });
+        });
+        for (const ref of cache.embeds ?? []) {
+            const spec = this.extractLink(ref.link);
+            refs.push({
+                sourcePath: file.path,
+                targetText: ref.link,
+                original: ref.original,
+                resolvedTargetPath: this.getFirstLinkpathDest(spec.url, file.path)?.path ?? null,
+                type: "embed",
+                position: ref.position,
+                count: 1,
+            });
+        }
+        const inlineTags = new Map((cache.tags ?? []).map((tag) => [tag.tag, tag.position]));
+        const tagNames = new Set([
+            ...inlineTags.keys(),
+            ...(parseFrontMatterTags(cache.frontmatter) ?? []),
+        ]);
+        const tags = [...tagNames].map((tag) => {
+            const parts = tagParts(tag);
+            return {
+                path: file.path,
+                tag,
+                parts: parts.parts,
+                hierarchy: parts.hierarchy,
+                position: inlineTags.get(tag),
+            };
+        });
+        const properties = Object.entries(cache.frontmatter ?? {}).map(([name, value]) => ({
+            path: file.path,
+            name,
+            inferredType: this.app.metadataTypeManager?.determinePropertyType(name, value) ??
+                frontmatterValueType(value),
+            declaredType: this.app.metadataTypeManager?.types?.[name]?.type,
+            value,
+        }));
+        return {
+            file: {
+                path: file.path,
+                normalizedPath: file.path,
+                extension: file.extension.toLowerCase(),
+                mtime: file.stat.mtime,
+                size: file.stat.size,
+                hash,
+                indexed: true,
+            },
+            metadata: {
+                path: file.path,
+                hash,
+                parserVersion: this.parserSignature(file),
+                metadata: cache,
+            },
+            links: refs,
+            tags,
+            properties,
+        };
+    }
+    async processFileCache(file) {
+        if (!file)
+            return null;
+        if (typeof file === "string") {
+            return this.processFileCache(this.app.vault.getFileByPath(file));
+        }
+        return this.read(await this.app.vault.read(file), file);
+    }
+    async read(content, file) {
+        const processors = this.processors.get(file.extension.toLowerCase());
+        if (!processors || !processors.size)
+            return null;
+        let cachedMetadata = {};
+        for (const processor of processors) {
+            const cache = await processor.read(content, {
+                file,
+                cache: cachedMetadata,
+            });
+            if (cache) {
+                cachedMetadata = cache;
+            }
+        }
+        return cachedMetadata;
+    }
+    writeFrontmatter(file, data) {
+        const processors = this.processors.get(file.extension.toLowerCase());
+        if (!processors || !processors.size)
+            return "";
+        for (const processor of processors) {
+            const value = processor.write(data);
+            if (value) {
+                return value;
+            }
+        }
+        return "";
+    }
+}
+export function getAllTags(cache) {
+    return (cache.tags || []).map((it) => it.tag);
+}