@lapis-notes/search 0.1.0

package/dist/search-panel.svelte.d.ts

@@ -0,0 +1,11 @@
+import "./search-panel.css";
+import { type App } from "@lapis-notes/api";
+type $$ComponentProps = {
+    app: App;
+    initialQuery?: string;
+};
+declare const SearchPanel: import("svelte").Component<$$ComponentProps, {
+    setSearchQuery: (next: string) => void;
+}, "">;
+type SearchPanel = ReturnType<typeof SearchPanel>;
+export default SearchPanel;

package/dist/search-plugin.d.ts

@@ -0,0 +1,22 @@
+import { type App, Plugin, type PluginManifest } from "@lapis-notes/api";
+import { SearchManager, type SearchRuntimeStatus } from "./search-manager";
+import { type SearchPluginSettings, type SearchPluginSettingsPatch } from "./search-settings";
+export declare class SearchPlugin extends Plugin {
+    private settings;
+    private startupRefreshStarted;
+    private startupRefreshPromise;
+    private providerReconcileReason;
+    private providerReconcilePromise;
+    readonly searchManager: SearchManager;
+    constructor(app: App, pluginManifest?: PluginManifest);
+    getSettings(): SearchPluginSettings;
+    updateSettings(patch: SearchPluginSettingsPatch): Promise<void>;
+    getSearchStatus(): Promise<SearchRuntimeStatus>;
+    rebuildSemanticSearch(): Promise<SearchRuntimeStatus>;
+    onload(): Promise<void>;
+    refreshIndex(reason?: string): Promise<SearchRuntimeStatus>;
+    onunload(): Promise<void>;
+    private startupRefresh;
+    private scheduleProviderReconciliation;
+    private openSearchInLeftSidebar;
+}

package/dist/search-plugin.js

@@ -0,0 +1,174 @@
+import { Notice, Plugin, TextFileView, } from "@lapis-notes/api";
+import { SearchManager } from "./search-manager";
+import { CANVAS_SEARCH_DOCUMENT_PROVIDER, MARKDOWN_SEARCH_DOCUMENT_PROVIDER, } from "./built-in-search-document-providers";
+import { mergeSearchSettings, patchSearchSettings, resolveSearchEmbeddingProviderConfig, } from "./search-settings";
+import { SearchSettingsTab } from "./search-settings-tab";
+import { SearchView, SearchViewType } from "./search-view";
+import { createNotesSearchSlashCommand } from "./notes-search-command";
+import { createNotesSearchTool } from "./notes-search-tool";
+import SearchToolResult from "./search-tool-result.svelte";
+import { reconcileSearchAfterMetadata } from "./search-startup";
+import manifestSpec from "../../manifest.json";
+export class SearchPlugin extends Plugin {
+    settings;
+    startupRefreshStarted = false;
+    startupRefreshPromise = null;
+    providerReconcileReason = null;
+    providerReconcilePromise = null;
+    searchManager;
+    constructor(app, pluginManifest = manifestSpec) {
+        super(app, pluginManifest);
+        this.settings = mergeSearchSettings(null);
+        this.searchManager = new SearchManager(app, () => this.settings);
+    }
+    getSettings() {
+        return {
+            chunking: { ...this.settings.chunking },
+            query: { ...this.settings.query },
+            embeddings: { ...this.settings.embeddings },
+            view: {
+                ...this.settings.view,
+                recentSearches: [...this.settings.view.recentSearches],
+            },
+        };
+    }
+    async updateSettings(patch) {
+        const previousProvider = resolveSearchEmbeddingProviderConfig(this.settings);
+        this.settings = patchSearchSettings(this.settings, patch);
+        await this.saveData(this.settings);
+        const nextProvider = resolveSearchEmbeddingProviderConfig(this.settings);
+        if (JSON.stringify(previousProvider) !== JSON.stringify(nextProvider)) {
+            await this.app.appDatabase.configureSearchEmbeddingProvider(nextProvider);
+        }
+    }
+    getSearchStatus() {
+        return this.searchManager.getStatus();
+    }
+    rebuildSemanticSearch() {
+        return this.searchManager.refreshFromVault("manual-semantic-rebuild");
+    }
+    async onload() {
+        this.settings = mergeSearchSettings(await this.loadData());
+        await this.app.appDatabase.configureSearchEmbeddingProvider(resolveSearchEmbeddingProviderConfig(this.settings));
+        this.registerEvent(this.app.searchDocumentProviders.on("changed", ({ reason }) => {
+            if (this.state !== "enabled")
+                return;
+            if (!this.app.metadataCache.initialized ||
+                !this.startupRefreshStarted) {
+                return;
+            }
+            this.scheduleProviderReconciliation(`provider-${reason}`);
+        }));
+        this.registerSearchDocumentProvider("markdown", MARKDOWN_SEARCH_DOCUMENT_PROVIDER);
+        this.registerSearchDocumentProvider("canvas", CANVAS_SEARCH_DOCUMENT_PROVIDER);
+        this.registerAgentTool(createNotesSearchTool(this.searchManager));
+        this.registerAgentSlashCommand(createNotesSearchSlashCommand());
+        this.registerAgentResultView({
+            tool: "notes_search",
+            component: SearchToolResult,
+        });
+        this.addSettingTab(new SearchSettingsTab(this.app, this));
+        this.register(this.searchManager.trackChanges());
+        this.registerSidebarView(SearchViewType, (leaf) => new SearchView(leaf), { side: "left", title: "Search", icon: "search" }, {
+            kind: "command",
+            command: {
+                id: "open-search",
+                name: "Open Search",
+                callback: (query) => void this.openSearchInLeftSidebar(query),
+            },
+        });
+        this.registerEvent(this.app.metadataCache.on("loaded", () => {
+            void this.startupRefresh();
+        }));
+        if (this.app.metadataCache.initialized) {
+            void this.startupRefresh();
+        }
+        this.addCommand({
+            id: "rebuild-semantic-search",
+            name: "Rebuild semantic search embeddings",
+            callback: async () => {
+                const status = await this.rebuildSemanticSearch();
+                new Notice(`Semantic search refreshed (${status.readyChunkCount}/${status.chunkCount} ready)`);
+            },
+        });
+        this.addCommand({
+            id: "search-selected-text",
+            name: "Search selected text",
+            callback: () => {
+                const view = this.app.workspace.activeLeaf?.view;
+                const query = view instanceof TextFileView ? view.editor.getSelection().trim() : "";
+                void this.openSearchInLeftSidebar(query);
+            },
+        });
+        this.addCommand({
+            id: "rebuild-search-index",
+            name: "Rebuild search index",
+            callback: async () => {
+                await this.app.appDatabase.rebuildSearchIndex();
+                await this.refreshIndex("rebuild");
+                new Notice("Search index rebuilt");
+            },
+        });
+        this.addCommand({
+            id: "refresh-search-index",
+            name: "Refresh search index",
+            callback: () => void this.refreshIndex("command"),
+        });
+    }
+    refreshIndex(reason = "manual") {
+        return this.searchManager.refreshFromVault(reason);
+    }
+    async onunload() {
+        await this.searchManager.dispose();
+    }
+    startupRefresh() {
+        if (this.startupRefreshPromise)
+            return this.startupRefreshPromise;
+        if (this.startupRefreshStarted)
+            return Promise.resolve();
+        this.startupRefreshStarted = true;
+        this.startupRefreshPromise = reconcileSearchAfterMetadata(this.app, this.searchManager)
+            .then(() => undefined)
+            .catch((error) => {
+            this.startupRefreshStarted = false;
+            new Notice(`Search index refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => {
+            if (!this.startupRefreshStarted)
+                this.startupRefreshPromise = null;
+        });
+        return this.startupRefreshPromise;
+    }
+    scheduleProviderReconciliation(reason) {
+        this.providerReconcileReason = reason;
+        if (this.providerReconcilePromise)
+            return;
+        this.providerReconcilePromise = (async () => {
+            await this.startupRefresh();
+            while (this.providerReconcileReason) {
+                this.providerReconcileReason = null;
+                await this.searchManager.reconcileStartup();
+            }
+        })()
+            .catch((error) => {
+            new Notice(`Search provider refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => {
+            this.providerReconcilePromise = null;
+            if (this.providerReconcileReason) {
+                this.scheduleProviderReconciliation(this.providerReconcileReason);
+            }
+        });
+    }
+    async openSearchInLeftSidebar(query = "") {
+        const existing = this.app.workspace.getLeavesOfType(SearchViewType)[0];
+        const target = existing ?? this.app.workspace.ensureSideLeaf(SearchViewType, "left");
+        await target.setViewState({ type: SearchViewType, state: { query } });
+        this.app.workspace.activateLeaf(target, {
+            focusRootHost: false,
+            source: "api",
+            operation: "open-search",
+        });
+        await this.app.workspace.revealLeaf(target);
+    }
+}

package/dist/search-result-model.d.ts

@@ -0,0 +1,29 @@
+import type { App, EditorPosition, TFile } from "@lapis-notes/api";
+import type { SearchQueryHit } from "./search-manager";
+export type SearchRange = {
+    start: number;
+    end: number;
+};
+export type SearchMatch = {
+    id: string;
+    key: string;
+    text: string;
+    ranges: SearchRange[];
+    pos?: EditorPosition;
+    context?: {
+        start: number;
+        end: number;
+        ranges: SearchRange[];
+        sourceLength: number;
+    };
+};
+export type SearchResult = {
+    file: TFile;
+    title: {
+        text: string;
+        ranges: SearchRange[];
+    } | null;
+    matches: SearchMatch[];
+    hit: SearchQueryHit;
+};
+export declare function searchResultFromHit(app: App, hit: SearchQueryHit): SearchResult | null;

package/dist/search-result-model.js

@@ -0,0 +1,50 @@
+function offsetPosition(content, offset) {
+    const before = content.slice(0, Math.max(0, offset));
+    const lines = before.split("\n");
+    return {
+        line: lines.length - 1,
+        ch: lines.at(-1)?.length ?? 0,
+    };
+}
+export function searchResultFromHit(app, hit) {
+    const file = app.vault.getFileByPath(hit.id);
+    if (!file)
+        return null;
+    const title = hit.snippets.find((snippet) => snippet.field === "name");
+    const matches = hit.snippets
+        .filter((snippet) => snippet.field !== "name")
+        .map((snippet, index) => ({
+        id: `${snippet.field}:${snippet.offset}:${index}`,
+        key: snippet.field === "tags" ? "tag" : snippet.field,
+        text: snippet.text,
+        ranges: snippet.ranges,
+        ...(snippet.field === "content" && snippet.ranges.length
+            ? {
+                pos: offsetPosition(hit.document.content, snippet.offset + snippet.ranges[0].start),
+                context: {
+                    start: snippet.offset,
+                    end: snippet.offset + snippet.text.length,
+                    ranges: snippet.ranges.map((range) => ({
+                        start: snippet.offset + range.start,
+                        end: snippet.offset + range.end,
+                    })),
+                    sourceLength: hit.document.content.length,
+                },
+            }
+            : {}),
+    }));
+    if (matches.length === 0) {
+        matches.push({
+            id: "name:0:fallback",
+            key: "name",
+            text: title?.text || file.name,
+            ranges: title?.ranges ?? [],
+        });
+    }
+    return {
+        file,
+        title: title ? { text: title.text, ranges: title.ranges } : null,
+        matches,
+        hit,
+    };
+}

package/dist/search-settings-tab.d.ts

@@ -0,0 +1,12 @@
+import { PluginSettingTab, type App } from "@lapis-notes/api";
+import type { SearchPlugin } from "./search-plugin";
+export declare class SearchSettingsTab extends PluginSettingTab {
+    private readonly searchPlugin;
+    private rebuilding;
+    constructor(app: App, searchPlugin: SearchPlugin);
+    display(): void;
+    private addSlider;
+    private update;
+    private configureRebuildButton;
+    private rebuild;
+}

package/dist/search-settings-tab.js

@@ -0,0 +1,139 @@
+import { Notice, PluginSettingTab, Setting, } from "@lapis-notes/api";
+import { CUSTOM_SEARCH_EMBEDDING_MODEL_OPTION, SEARCH_EMBEDDING_MODEL_OPTIONS, getSearchEmbeddingCustomOptionLabel, getSearchEmbeddingModelOptionValue, isPresetSearchEmbeddingModelId, } from "./search-settings";
+export class SearchSettingsTab extends PluginSettingTab {
+    searchPlugin;
+    rebuilding = false;
+    constructor(app, searchPlugin) {
+        super(app, searchPlugin);
+        this.searchPlugin = searchPlugin;
+    }
+    display() {
+        const settings = this.searchPlugin.getSettings();
+        const modelOption = getSearchEmbeddingModelOptionValue(settings.embeddings.modelId);
+        this.containerEl.empty();
+        new Setting(this.containerEl)
+            .setName("Semantic search provider")
+            .setDesc("Semantic search is disabled until you opt in to the local Transformers.js provider.")
+            .addDropdown((dropdown) => {
+            dropdown
+                .addOption("disabled", "Disabled")
+                .addOption("transformers-js", "Transformers.js")
+                .setValue(settings.embeddings.provider)
+                .onChange((provider) => {
+                void this.update({
+                    embeddings: {
+                        provider: provider,
+                    },
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Embedding model")
+            .setDesc("Model used for local document and query vectors.")
+            .addDropdown((dropdown) => {
+            for (const modelId of SEARCH_EMBEDDING_MODEL_OPTIONS) {
+                dropdown.addOption(modelId, modelId);
+            }
+            dropdown
+                .addOption(CUSTOM_SEARCH_EMBEDDING_MODEL_OPTION, getSearchEmbeddingCustomOptionLabel(settings.embeddings.modelId))
+                .setValue(modelOption)
+                .onChange((modelId) => {
+                if (Array.isArray(modelId))
+                    return;
+                if (modelId === CUSTOM_SEARCH_EMBEDDING_MODEL_OPTION) {
+                    this.display();
+                    return;
+                }
+                void this.update({ embeddings: { modelId } });
+            });
+        });
+        if (modelOption === CUSTOM_SEARCH_EMBEDDING_MODEL_OPTION) {
+            new Setting(this.containerEl)
+                .setName("Custom embedding model")
+                .setDesc("Hugging Face model id used by Transformers.js.")
+                .addText((text) => {
+                text
+                    .setPlaceholder("org/model-name")
+                    .setValue(isPresetSearchEmbeddingModelId(settings.embeddings.modelId)
+                    ? ""
+                    : settings.embeddings.modelId)
+                    .onChange((modelId) => {
+                    void this.update({ embeddings: { modelId } }, false);
+                });
+            });
+        }
+        new Setting(this.containerEl)
+            .setName("Allow remote model downloads")
+            .setDesc("Allow the selected model files to download and cache on first semantic use. Note contents remain local.")
+            .addToggle((toggle) => {
+            toggle
+                .setValue(settings.embeddings.allowRemoteModels)
+                .onChange((allowRemoteModels) => {
+                void this.update({ embeddings: { allowRemoteModels } });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Local model path")
+            .setDesc("Optional host path for locally supplied model files.")
+            .addText((text) => {
+            text
+                .setPlaceholder("/models/")
+                .setValue(settings.embeddings.localModelPath)
+                .onChange((localModelPath) => {
+                void this.update({ embeddings: { localModelPath } }, false);
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Semantic index")
+            .setDesc("Rebuild document chunks and embeddings using current settings.")
+            .addButton((button) => {
+            this.configureRebuildButton(button);
+            button.onClick(() => void this.rebuild());
+        });
+        this.addSlider("Chunk target size", "Approximate character target for each indexed chunk.", settings.chunking.targetChars, 400, 3000, 50, (targetChars) => ({ chunking: { targetChars } }));
+        this.addSlider("Breakpoint search window", "Distance searched for a stronger heading or paragraph boundary.", settings.chunking.breakpointWindowChars, 80, 1000, 20, (breakpointWindowChars) => ({ chunking: { breakpointWindowChars } }));
+        this.addSlider("Breakpoint decay", "How strongly distance from the ideal cutoff penalizes a boundary.", settings.chunking.breakpointDecay, 0.1, 1, 0.05, (breakpointDecay) => ({ chunking: { breakpointDecay } }));
+        this.addSlider("Result limit", "Maximum files returned for one query.", settings.query.resultLimit, 10, 300, 10, (resultLimit) => ({ query: { resultLimit } }));
+        this.addSlider("Snippet length", "Maximum characters shown around each match.", settings.query.snippetLength, 80, 400, 20, (snippetLength) => ({ query: { snippetLength } }));
+    }
+    addSlider(name, description, value, min, max, step, patch) {
+        new Setting(this.containerEl)
+            .setName(name)
+            .setDesc(description)
+            .addSlider((slider) => {
+            slider
+                .setDynamicTooltip()
+                .setLimits(min, max, step)
+                .setValue(value)
+                .onChange((next) => void this.update(patch(Number(next)), false));
+        });
+    }
+    async update(patch, redisplay = true) {
+        await this.searchPlugin.updateSettings(patch);
+        if (redisplay)
+            this.display();
+    }
+    configureRebuildButton(button) {
+        button.setCta();
+        button
+            .setButtonText(this.rebuilding ? "Rebuilding…" : "Rebuild embeddings")
+            .setDisabled(this.rebuilding);
+    }
+    async rebuild() {
+        if (this.rebuilding)
+            return;
+        this.rebuilding = true;
+        this.display();
+        try {
+            const status = await this.searchPlugin.rebuildSemanticSearch();
+            new Notice(`Semantic search refreshed (${status.readyChunkCount}/${status.chunkCount} ready)`);
+        }
+        catch (error) {
+            new Notice(`Semantic search refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            this.rebuilding = false;
+            this.display();
+        }
+    }
+}

package/dist/search-settings.d.ts

@@ -0,0 +1,54 @@
+import type { SearchEmbeddingProviderConfig } from "@lapis-notes/api";
+export type SearchEmbeddingProviderSetting = "disabled" | "transformers-js";
+export type SearchViewSortMode = "filename-asc" | "filename-desc" | "modified-desc" | "modified-asc" | "created-desc" | "created-asc";
+export type SearchResultFacet = "all" | "markdown" | "canvas";
+export type SearchRetrievalMode = "auto" | "lexical" | "vector" | "hybrid";
+export declare function resolveSearchRetrievalModeForQuery(requested: SearchRetrievalMode, structured: boolean, allowSemanticStructuredQueries: boolean): SearchRetrievalMode;
+export declare function resolveSearchSnippetLength(configuredLength: number, showMoreContext: boolean): number;
+export declare const SEARCH_EMBEDDING_MODEL_OPTIONS: readonly ["Xenova/all-MiniLM-L6-v2", "onnx-community/bge-small-en-v1.5-ONNX", "nomic-ai/nomic-embed-text-v1.5", "Xenova/paraphrase-multilingual-MiniLM-L12-v2"];
+export declare const CUSTOM_SEARCH_EMBEDDING_MODEL_OPTION = "custom";
+export interface SearchPluginSettings {
+    chunking: {
+        targetChars: number;
+        breakpointWindowChars: number;
+        breakpointDecay: number;
+    };
+    query: {
+        resultLimit: number;
+        snippetLength: number;
+    };
+    embeddings: {
+        provider: SearchEmbeddingProviderSetting;
+        modelId: string;
+        allowRemoteModels: boolean;
+        localModelPath: string;
+    };
+    view: {
+        sortMode: SearchViewSortMode;
+        collapseResults: boolean;
+        showMoreContext: boolean;
+        explainSearchTerms: boolean;
+        semanticSearchInStructuredQueries: boolean;
+        matchCase: boolean;
+        recentSearches: string[];
+        resultFacet: SearchResultFacet;
+        retrievalMode: SearchRetrievalMode;
+    };
+}
+export type SearchPluginSettingsPatch = {
+    chunking?: Partial<SearchPluginSettings["chunking"]>;
+    query?: Partial<SearchPluginSettings["query"]>;
+    embeddings?: Partial<SearchPluginSettings["embeddings"]>;
+    view?: Partial<SearchPluginSettings["view"]>;
+};
+export declare const SEARCH_VIEW_SORT_OPTIONS: ReadonlyArray<{
+    value: SearchViewSortMode;
+    label: string;
+}>;
+export declare const DEFAULT_SEARCH_SETTINGS: SearchPluginSettings;
+export declare function isPresetSearchEmbeddingModelId(modelId: string): boolean;
+export declare function getSearchEmbeddingModelOptionValue(modelId: string): string;
+export declare function getSearchEmbeddingCustomOptionLabel(modelId: string): string;
+export declare function mergeSearchSettings(stored: SearchPluginSettingsPatch | null | undefined): SearchPluginSettings;
+export declare function patchSearchSettings(current: SearchPluginSettings, patch: SearchPluginSettingsPatch): SearchPluginSettings;
+export declare function resolveSearchEmbeddingProviderConfig(settings: SearchPluginSettings): SearchEmbeddingProviderConfig | null;

package/dist/search-settings.js

@@ -0,0 +1,107 @@
+export function resolveSearchRetrievalModeForQuery(requested, structured, allowSemanticStructuredQueries) {
+    return structured && !allowSemanticStructuredQueries ? "lexical" : requested;
+}
+export function resolveSearchSnippetLength(configuredLength, showMoreContext) {
+    return showMoreContext ? Math.max(configuredLength, 280) : configuredLength;
+}
+export const SEARCH_EMBEDDING_MODEL_OPTIONS = [
+    "Xenova/all-MiniLM-L6-v2",
+    "onnx-community/bge-small-en-v1.5-ONNX",
+    "nomic-ai/nomic-embed-text-v1.5",
+    "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+];
+export const CUSTOM_SEARCH_EMBEDDING_MODEL_OPTION = "custom";
+export const SEARCH_VIEW_SORT_OPTIONS = [
+    { value: "filename-asc", label: "Filename (A to Z)" },
+    { value: "filename-desc", label: "Filename (Z to A)" },
+    { value: "modified-desc", label: "Modified (new to old)" },
+    { value: "modified-asc", label: "Modified (old to new)" },
+    { value: "created-desc", label: "Created (new to old)" },
+    { value: "created-asc", label: "Created (old to new)" },
+];
+export const DEFAULT_SEARCH_SETTINGS = {
+    chunking: {
+        targetChars: 1200,
+        breakpointWindowChars: 320,
+        breakpointDecay: 0.7,
+    },
+    query: {
+        resultLimit: 100,
+        snippetLength: 160,
+    },
+    embeddings: {
+        provider: "disabled",
+        modelId: "Xenova/all-MiniLM-L6-v2",
+        allowRemoteModels: true,
+        localModelPath: "",
+    },
+    view: {
+        sortMode: "filename-asc",
+        collapseResults: true,
+        showMoreContext: false,
+        explainSearchTerms: false,
+        semanticSearchInStructuredQueries: false,
+        matchCase: false,
+        recentSearches: [],
+        resultFacet: "all",
+        retrievalMode: "auto",
+    },
+};
+function boundedRecentSearches(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .filter((item, index, items) => items.indexOf(item) === index)
+        .slice(0, 10);
+}
+export function isPresetSearchEmbeddingModelId(modelId) {
+    return SEARCH_EMBEDDING_MODEL_OPTIONS.includes(modelId.trim());
+}
+export function getSearchEmbeddingModelOptionValue(modelId) {
+    return isPresetSearchEmbeddingModelId(modelId)
+        ? modelId.trim()
+        : CUSTOM_SEARCH_EMBEDDING_MODEL_OPTION;
+}
+export function getSearchEmbeddingCustomOptionLabel(modelId) {
+    const trimmed = modelId.trim();
+    return !trimmed || isPresetSearchEmbeddingModelId(trimmed)
+        ? "Custom"
+        : `Custom (${trimmed})`;
+}
+export function mergeSearchSettings(stored) {
+    return {
+        chunking: { ...DEFAULT_SEARCH_SETTINGS.chunking, ...stored?.chunking },
+        query: { ...DEFAULT_SEARCH_SETTINGS.query, ...stored?.query },
+        embeddings: {
+            ...DEFAULT_SEARCH_SETTINGS.embeddings,
+            ...stored?.embeddings,
+        },
+        view: {
+            ...DEFAULT_SEARCH_SETTINGS.view,
+            ...stored?.view,
+            recentSearches: boundedRecentSearches(stored?.view?.recentSearches),
+        },
+    };
+}
+export function patchSearchSettings(current, patch) {
+    return mergeSearchSettings({
+        chunking: { ...current.chunking, ...patch.chunking },
+        query: { ...current.query, ...patch.query },
+        embeddings: { ...current.embeddings, ...patch.embeddings },
+        view: { ...current.view, ...patch.view },
+    });
+}
+export function resolveSearchEmbeddingProviderConfig(settings) {
+    if (settings.embeddings.provider === "disabled")
+        return null;
+    return {
+        kind: "transformers-js",
+        modelId: settings.embeddings.modelId.trim() ||
+            DEFAULT_SEARCH_SETTINGS.embeddings.modelId,
+        allowRemoteModels: settings.embeddings.allowRemoteModels,
+        localModelPath: settings.embeddings.localModelPath.trim() || undefined,
+    };
+}

package/dist/search-sort.d.ts

@@ -0,0 +1,8 @@
+import type { TFile } from "@lapis-notes/api";
+import { type SearchViewSortMode } from "./search-settings";
+type SortableFile = Pick<TFile, "name" | "path" | "stat">;
+export declare function formatSearchViewSortLabel(mode: SearchViewSortMode): string;
+export declare function sortSearchResults<T extends {
+    file: SortableFile;
+}>(items: T[], mode: SearchViewSortMode): T[];
+export {};

package/dist/search-sort.js

@@ -0,0 +1,36 @@
+import { SEARCH_VIEW_SORT_OPTIONS, } from "./search-settings";
+function compareText(left, right) {
+    return left.localeCompare(right, undefined, {
+        sensitivity: "base",
+        numeric: true,
+    });
+}
+export function formatSearchViewSortLabel(mode) {
+    return (SEARCH_VIEW_SORT_OPTIONS.find((option) => option.value === mode)?.label ??
+        SEARCH_VIEW_SORT_OPTIONS[0].label);
+}
+export function sortSearchResults(items, mode) {
+    return [...items].sort((left, right) => {
+        switch (mode) {
+            case "filename-desc":
+                return (compareText(right.file.name, left.file.name) ||
+                    compareText(left.file.path, right.file.path));
+            case "modified-desc":
+                return (right.file.stat.mtime - left.file.stat.mtime ||
+                    compareText(left.file.path, right.file.path));
+            case "modified-asc":
+                return (left.file.stat.mtime - right.file.stat.mtime ||
+                    compareText(left.file.path, right.file.path));
+            case "created-desc":
+                return (right.file.stat.ctime - left.file.stat.ctime ||
+                    compareText(left.file.path, right.file.path));
+            case "created-asc":
+                return (left.file.stat.ctime - right.file.stat.ctime ||
+                    compareText(left.file.path, right.file.path));
+            case "filename-asc":
+            default:
+                return (compareText(left.file.name, right.file.name) ||
+                    compareText(left.file.path, right.file.path));
+        }
+    });
+}

package/dist/search-startup.d.ts

@@ -0,0 +1,3 @@
+import type { App } from "@lapis-notes/api";
+import type { SearchManager, SearchRuntimeStatus } from "./search-manager";
+export declare function reconcileSearchAfterMetadata(app: Pick<App, "metadataCache">, manager: Pick<SearchManager, "reconcileStartup">): Promise<SearchRuntimeStatus>;

package/dist/search-startup.js

@@ -0,0 +1,4 @@
+export async function reconcileSearchAfterMetadata(app, manager) {
+    await app.metadataCache.load();
+    return manager.reconcileStartup();
+}