@lapis-notes/api 0.1.0

package/dist/storage/native-vault-bootstrap-kv.d.ts

@@ -0,0 +1,22 @@
+import { type KeyValueStore } from "./vault-state";
+/**
+ * Persists vault bootstrap keys (saved vault profiles and current profile id)
+ * in the native Deno host instead of renderer IndexedDB so a corrupted webview
+ * storage partition cannot strand the shell on “Opening vault”.
+ */
+export declare class NativeDesktopVaultBootstrapKeyValueStore implements KeyValueStore {
+    get<T = unknown>(key: IDBValidKey): Promise<T | undefined>;
+    set(key: IDBValidKey, value: unknown): Promise<void>;
+    setMany(entries: [IDBValidKey, unknown][]): Promise<void>;
+    getMany<T = unknown>(requestedKeys: IDBValidKey[]): Promise<T[]>;
+    del(key: IDBValidKey): Promise<void>;
+    keys(): Promise<IDBValidKey[]>;
+}
+/**
+ * One-time migration from the legacy IndexedDB vault-state store when the main
+ * copy is still empty. Uses a timeout so a stuck IndexedDB open cannot block
+ * desktop startup indefinitely.
+ */
+export declare function migrateVaultBootstrapStoreFromIndexedDb(options?: {
+    timeoutMs?: number;
+}): Promise<void>;

package/dist/storage/native-vault-bootstrap-kv.js

@@ -0,0 +1,96 @@
+import { getNativeDesktopBridge } from "./desktop-native";
+import { IndexedDbKeyValueStore } from "./vault-state";
+function requireDesktopInvoke() {
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        throw new Error("Native desktop bridge is unavailable");
+    }
+    return bridge.invoke.bind(bridge);
+}
+/**
+ * Persists vault bootstrap keys (saved vault profiles and current profile id)
+ * in the native Deno host instead of renderer IndexedDB so a corrupted webview
+ * storage partition cannot strand the shell on “Opening vault”.
+ */
+export class NativeDesktopVaultBootstrapKeyValueStore {
+    async get(key) {
+        const invoke = requireDesktopInvoke();
+        return invoke("desktop_vault_bootstrap_kv_get", {
+            key: String(key),
+        });
+    }
+    async set(key, value) {
+        const invoke = requireDesktopInvoke();
+        await invoke("desktop_vault_bootstrap_kv_set", {
+            key: String(key),
+            value,
+        });
+    }
+    async setMany(entries) {
+        if (!entries.length) {
+            return;
+        }
+        const invoke = requireDesktopInvoke();
+        await invoke("desktop_vault_bootstrap_kv_set_many", {
+            entries: entries.map(([k, v]) => [String(k), v]),
+        });
+    }
+    async getMany(requestedKeys) {
+        const invoke = requireDesktopInvoke();
+        return invoke("desktop_vault_bootstrap_kv_get_many", {
+            keys: requestedKeys.map((k) => String(k)),
+        });
+    }
+    async del(key) {
+        const invoke = requireDesktopInvoke();
+        await invoke("desktop_vault_bootstrap_kv_del", { key: String(key) });
+    }
+    async keys() {
+        const invoke = requireDesktopInvoke();
+        return invoke("desktop_vault_bootstrap_kv_keys", {});
+    }
+}
+const DEFAULT_MIGRATION_TIMEOUT_MS = 2500;
+/**
+ * One-time migration from the legacy IndexedDB vault-state store when the main
+ * copy is still empty. Uses a timeout so a stuck IndexedDB open cannot block
+ * desktop startup indefinitely.
+ */
+export async function migrateVaultBootstrapStoreFromIndexedDb(options = {}) {
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        return;
+    }
+    const isEmpty = await bridge.invoke("desktop_vault_bootstrap_kv_is_empty", {});
+    if (!isEmpty) {
+        return;
+    }
+    const timeoutMs = options.timeoutMs ?? DEFAULT_MIGRATION_TIMEOUT_MS;
+    const idb = new IndexedDbKeyValueStore();
+    const run = async () => {
+        const rawKeys = await idb.keys();
+        if (!rawKeys.length) {
+            return;
+        }
+        const entries = [];
+        for (const k of rawKeys) {
+            entries.push({ key: String(k), value: await idb.get(k) });
+        }
+        await bridge.invoke("desktop_vault_bootstrap_kv_import_if_empty", {
+            entries,
+        });
+    };
+    try {
+        await Promise.race([
+            run(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`IndexedDB vault-state migration timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        console.warn("[lapis] Vault profile store migration from IndexedDB skipped:", error);
+    }
+}

package/dist/storage/path.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Normalize a vault-style path by removing redundant segments and separators.
+ *
+ * @public
+ */
+export declare function normalizePath(path: string): string;
+export declare function resolvePath(...paths: string[]): string;
+export declare function joinPath(...parts: string[]): string;
+export declare function splitPath(path: string): string[];
+export declare function dirname(path: string): string;
+export declare function basename(path: string): string;
+/**
+ * Returns whether a vault path belongs to Lapis' portable internal data.
+ *
+ * Internal data can occur beneath any folder-scoped feature root. Callers
+ * that present ordinary vault content should hide these paths, while explicit
+ * storage and indexing operations remain free to address them directly.
+ *
+ * @public
+ */
+export declare function isLapisInternalPath(path: string): boolean;
+export declare function reducer(ancestors: string[], current: string): string[];

package/dist/storage/path.js

@@ -0,0 +1,110 @@
+/**
+ * Normalize a vault-style path by removing redundant segments and separators.
+ *
+ * @public
+ */
+export function normalizePath(path) {
+    if (path.length === 0) {
+        return "";
+    }
+    let parts = splitPath(path);
+    parts = parts.reduce(reducer, []);
+    return joinPath(...parts).replace(/^\.\//, "");
+}
+export function resolvePath(...paths) {
+    let result = "";
+    for (let path of paths) {
+        if (path.startsWith("/")) {
+            result = path;
+        }
+        else {
+            result = normalizePath(joinPath(result, path));
+        }
+    }
+    return result;
+}
+export function joinPath(...parts) {
+    if (parts.length === 0)
+        return "";
+    let path = parts.join("/");
+    path = path.replace(/\/{2,}/g, "/");
+    return path;
+}
+export function splitPath(path) {
+    if (path.length === 0)
+        return [];
+    if (path === "/")
+        return ["/"];
+    let parts = path.split("/");
+    if (parts[parts.length - 1] === "") {
+        parts.pop();
+    }
+    if (path[0] === "/") {
+        parts[0] = "/";
+    }
+    else {
+        if (parts[0] !== ".") {
+            parts.unshift(".");
+        }
+    }
+    return parts;
+}
+export function dirname(path) {
+    const last = path.lastIndexOf("/");
+    if (last === 0 || last === -1)
+        return "/";
+    return path.slice(0, last);
+}
+export function basename(path) {
+    if (path === "/")
+        throw new Error(`Cannot get basename of "${path}"`);
+    const last = path.lastIndexOf("/");
+    if (last === -1)
+        return path;
+    return path.slice(last + 1);
+}
+/**
+ * Returns whether a vault path belongs to Lapis' portable internal data.
+ *
+ * Internal data can occur beneath any folder-scoped feature root. Callers
+ * that present ordinary vault content should hide these paths, while explicit
+ * storage and indexing operations remain free to address them directly.
+ *
+ * @public
+ */
+export function isLapisInternalPath(path) {
+    return path
+        .replaceAll("\\", "/")
+        .replace(/^\/+/, "")
+        .split("/")
+        .includes(".lapis");
+}
+export function reducer(ancestors, current) {
+    if (ancestors.length === 0) {
+        ancestors.push(current);
+        return ancestors;
+    }
+    if (current === ".")
+        return ancestors;
+    if (current === "..") {
+        if (ancestors.length === 1) {
+            if (ancestors[0] === "/") {
+                throw new Error("Unable to normalize path - traverses above root directory");
+            }
+            if (ancestors[0] === ".") {
+                ancestors.push(current);
+                return ancestors;
+            }
+        }
+        if (ancestors[ancestors.length - 1] === "..") {
+            ancestors.push("..");
+            return ancestors;
+        }
+        else {
+            ancestors.pop();
+            return ancestors;
+        }
+    }
+    ancestors.push(current);
+    return ancestors;
+}

package/dist/storage/search-embedding-provider.d.ts

@@ -0,0 +1,75 @@
+import type { SearchDocumentRecord } from "./app-database";
+export interface TokenHashSearchEmbeddingProviderConfig {
+    kind: "token-hash";
+    modelId?: string;
+    modelVersion?: string;
+    dimensions?: number;
+}
+export interface TransformersJsSearchEmbeddingProviderConfig {
+    kind: "transformers-js";
+    modelId: string;
+    modelVersion?: string;
+    revision?: string;
+    dtype?: string;
+    device?: "wasm" | "webgpu";
+    dimensions?: number;
+    pooling?: "mean";
+    normalize?: boolean;
+    allowRemoteModels?: boolean;
+    localModelPath?: string;
+    wasmPaths?: string;
+}
+export type SearchEmbeddingProviderConfig = TokenHashSearchEmbeddingProviderConfig | TransformersJsSearchEmbeddingProviderConfig;
+export type SearchEmbeddingRuntimePhase = "ready" | "downloading" | "embedding" | "error";
+export interface SearchEmbeddingRuntimeStatus {
+    providerKind: SearchEmbeddingProviderConfig["kind"];
+    phase: SearchEmbeddingRuntimePhase;
+    modelId?: string;
+    message?: string;
+    progress?: number;
+    file?: string;
+    loadedBytes?: number;
+    totalBytes?: number;
+    updatedAt: number;
+}
+export interface SearchEmbeddingChunkVector {
+    chunkId: string;
+    vector: number[];
+    fingerprint: string;
+}
+export interface SearchEmbeddingProvider {
+    readonly config: SearchEmbeddingProviderConfig;
+    ready(): Promise<boolean>;
+    embedDocument(document: SearchDocumentRecord): Promise<SearchEmbeddingChunkVector[]>;
+    embedQuery(query: string): Promise<number[] | null>;
+    getRuntimeStatus(): SearchEmbeddingRuntimeStatus;
+    dispose?(): Promise<void> | void;
+}
+type TransformersFeatureExtractionResult = {
+    tolist(): unknown;
+};
+type TransformersFeatureExtractor = (input: string | string[], options?: Record<string, unknown>) => Promise<TransformersFeatureExtractionResult>;
+type TransformersRuntime = {
+    env: {
+        allowLocalModels?: boolean;
+        allowRemoteModels?: boolean;
+        useBrowserCache?: boolean;
+        useFSCache?: boolean;
+        remoteHost?: string;
+        remotePathTemplate?: string;
+        localModelPath?: string;
+        backends?: {
+            onnx?: {
+                wasm?: {
+                    wasmPaths?: string;
+                };
+            };
+        };
+    };
+    pipeline(task: "feature-extraction", model: string, options?: Record<string, unknown>): Promise<TransformersFeatureExtractor>;
+};
+export declare function setBrowserSearchEmbeddingWorkerFactory(factory: (() => Worker) | null): void;
+export declare function createSearchEmbeddingProvider(config: SearchEmbeddingProviderConfig | null): SearchEmbeddingProvider | null;
+export declare function setSearchEmbeddingProviderRuntimeLoaderForTests(loader: (() => Promise<TransformersRuntime>) | null): void;
+export declare function cosineSimilarity(left: number[], right: number[]): number;
+export {};