@lapis-notes/api 0.1.3 → 0.2.0

package/dist/storage/turso-app-database.js

@@ -1,6 +1,8 @@
+import { rebindSearchDocument } from "./search-embedding-record";
 import { collectSearchQueryTerms } from "../search-query";
 import { buildSearchResult, compareSearchResults, embeddingErrorState, EMPTY_APP_DATABASE_CAPABILITIES, hasSearchPropertyNames, MIN_VECTOR_SEARCH_SCORE, normalizeSearchDocument, pathWithinPrefix, rankSearchScores, resolveSearchQueryEnhancementDiagnostics, scoreSearchDocument, scoreVectorDocument, searchDocumentProperties, searchPropertyNames, } from "./app-database";
 import { assertProjectionReadAccess, assertProjectionWriteAccess, compileProjectionQuerySql, evaluateProjectionQuery, indexedValuesForRow, MAX_PROJECTION_ROWS_PER_SOURCE, projectionIndexStatus, PUBLIC_TASKS_PROJECTION_ID, } from "./index-projection";
+import { projectionQueryCandidates } from "./projection-query-candidates";
 import { TASK_PROJECTION_FIELDS, TASK_PROJECTION_VERSION, taskQueryToIndexQuery, } from "./task-projection";
 import { createSearchEmbeddingProvider, } from "./search-embedding-provider";
 import { isStructuredSearchQuery } from "./search-query-evaluator";
@@ -580,6 +582,7 @@ export class TursoAppDatabase {
     kind;
     connection = null;
     opened = false;
+    closeTask = null;
     nativeFullTextSearch = false;
     nativeVectorSearch = false;
     searchEmbeddingProviderConfig = null;
@@ -669,33 +672,65 @@ export class TursoAppDatabase {
         }
     }
     async close() {
-        if (!this.connection)
-            return;
+        if (this.closeTask)
+            return this.closeTask;
         const connection = this.connection;
-        this.connection = null;
-        this.opened = false;
-        await this.searchEmbeddingProvider?.dispose?.();
-        this.searchEmbeddingProvider = null;
-        this.changeListeners.clear();
-        await connection.close();
+        if (!connection)
+            return;
+        this.closeTask = (async () => {
+            await this.commitQueue;
+            await this.searchEmbeddingProvider?.dispose?.();
+            this.searchEmbeddingProvider = null;
+            await connection.close();
+            this.connection = null;
+            this.opened = false;
+            this.changeListeners.clear();
+        })();
+        try {
+            await this.closeTask;
+        }
+        finally {
+            this.closeTask = null;
+        }
     }
     async beginSearchIndexingBatch() { }
     async endSearchIndexingBatch() { }
     async configureSearchEmbeddingProvider(provider) {
+        const pending = this.commitQueue.then(() => this.configureSearchProviderImmediately(provider));
+        this.commitQueue = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
+    async configureSearchProviderImmediately(provider) {
         if (JSON.stringify(provider) ===
             JSON.stringify(this.searchEmbeddingProviderConfig))
             return;
         const previous = this.searchEmbeddingProvider;
-        this.searchEmbeddingProviderConfig = clone(provider);
-        this.searchEmbeddingProvider = createSearchEmbeddingProvider(provider);
-        await previous?.dispose?.();
-        await this.commit([
-            {
-                sql: `INSERT INTO app_meta (key, value_json) VALUES (?, ?)
+        const next = createSearchEmbeddingProvider(provider);
+        try {
+            const statements = [
+                {
+                    sql: `INSERT INTO app_meta (key, value_json) VALUES (?, ?)
               ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json`,
-                args: [SEARCH_EMBEDDING_PROVIDER_META_KEY, JSON.stringify(provider)],
-            },
-        ], ["search"]);
+                    args: [SEARCH_EMBEDDING_PROVIDER_META_KEY, JSON.stringify(provider)],
+                },
+            ];
+            if (next)
+                for (const document of await this.listSearchDocuments()) {
+                    statements.push(...this.searchDocumentStatements(rebindSearchDocument(document, next.config)));
+                }
+            await this.commitImmediately(statements, ["search"], [], undefined, () => {
+                this.searchEmbeddingProviderConfig = clone(provider);
+                this.searchEmbeddingProvider = next;
+            });
+        }
+        catch (error) {
+            if (this.searchEmbeddingProvider === next)
+                await previous?.dispose?.();
+            else
+                await next?.dispose?.();
+            throw error;
+        }
+        await previous?.dispose?.();
     }
     async getSearchEmbeddingProvider() {
         return clone(this.searchEmbeddingProviderConfig);
@@ -1207,7 +1242,7 @@ export class TursoAppDatabase {
             ...input.patch,
             ownerId: input.patch.status === "running" ? existing.ownerId : undefined,
             leaseUntil: input.patch.status === "running"
-                ? input.patch.leaseUntil ?? existing.leaseUntil
+                ? (input.patch.leaseUntil ?? existing.leaseUntil)
                 : undefined,
         };
         await this.commit([
@@ -1561,7 +1596,7 @@ export class TursoAppDatabase {
             Boolean(options.sourceProviderIds?.length) ||
             Boolean(options.pathPrefix);
         if (allPathsRequired) {
-            return this.evaluateSearchDocumentsForPaths(query, options, await this.queryAllSearchPaths(options.limit, options));
+            return this.evaluateSearchDocumentsForPaths(query, options, await this.queryAllSearchPaths(options));
         }
         const candidates = new Set();
         const includesLexical = requestedMode !== "vector";
@@ -1588,7 +1623,7 @@ export class TursoAppDatabase {
     async searchDocumentPaths(query, options = {}) {
         return (await this.searchDocuments(query, options)).map((result) => result.document.path);
     }
-    async queryAllSearchPaths(limit = 100, options = {}) {
+    async queryAllSearchPaths(options = {}) {
         const clauses = [];
         const args = [];
         if (options.sourceProviderIds?.length) {
@@ -1601,13 +1636,13 @@ export class TursoAppDatabase {
         }
         const rows = await this.requireConnection().all(`SELECT path FROM search_docs
        ${clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : ""}
-       ORDER BY path LIMIT ?`, ...args, Math.max(limit, 100));
+       ORDER BY path`, ...args);
         return rows.map((row) => row.path);
     }
     async queryLexicalPaths(query, limit = 100) {
         const terms = collectSearchQueryTerms(query);
         if (!terms.length || !this.nativeFullTextSearch) {
-            return this.queryAllSearchPaths(limit);
+            return this.queryAllSearchPaths();
         }
         const ftsQuery = ftsQueryForTerms(terms);
         const rows = await this.requireConnection().all(`SELECT path,
@@ -1857,11 +1892,7 @@ export class TursoAppDatabase {
     async queryProjection(projectionId, query = {}, readerPluginId) {
         const definition = await this.getProjectionDefinition(projectionId);
         assertProjectionReadAccess(definition, readerPluginId);
-        const compiled = compileProjectionQuerySql(projectionId, {
-            ...query,
-            after: undefined,
-            limit: query.after ? undefined : query.limit,
-        }, definition);
+        const compiled = compileProjectionQuerySql(projectionId, projectionQueryCandidates(query), definition);
         const [rows, sources] = await Promise.all([
             this.requireConnection().all(compiled.sql, ...compiled.args),
             this.getProjectionSources(projectionId),
@@ -1893,8 +1924,13 @@ export class TursoAppDatabase {
         const definition = await this.getProjectionDefinition(query.projectionId);
         assertProjectionReadAccess(definition, readerPluginId);
         const edges = await this.requireConnection().all(query.direction === "in"
-            ? `SELECT * FROM index_projection_edges WHERE projection_id = ? AND relation = ? AND target_row_id = ? ORDER BY ordinal LIMIT ?`
-            : `SELECT * FROM index_projection_edges WHERE projection_id = ? AND relation = ? AND source_row_id = ? ORDER BY ordinal LIMIT ?`, query.projectionId, query.relation, query.rowId, query.limit ?? 1000);
+            ? `SELECT * FROM index_projection_edges
+           WHERE projection_id = ? AND relation = ?
+             AND (target_row_id = ? OR target_path = (
+               SELECT source_path FROM index_projection_rows
+               WHERE projection_id = ? AND row_id = ?
+             )) ORDER BY ordinal`
+            : `SELECT * FROM index_projection_edges WHERE projection_id = ? AND relation = ? AND source_row_id = ? ORDER BY ordinal`, query.projectionId, query.relation, query.rowId, ...(query.direction === "in" ? [query.projectionId, query.rowId] : []));
         const rows = [];
         for (const edge of edges) {
             const targetId = query.direction === "in"
@@ -1933,7 +1969,7 @@ export class TursoAppDatabase {
         this.commitQueue = committed.then(() => undefined, () => undefined);
         return committed;
     }
-    async commitImmediately(statements, domains, paths = [], renamed) {
+    async commitImmediately(statements, domains, paths = [], renamed, onCommitted) {
         const revision = this.currentRevision + 1;
         const change = {
             revision,
@@ -1963,6 +1999,7 @@ export class TursoAppDatabase {
             },
         ], "immediate");
         this.currentRevision = revision;
+        onCommitted?.();
         for (const listener of this.changeListeners)
             listener(clone(change));
         return change;

package/dist/storage/vault-listing.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_VAULT_EXCLUDES: readonly string[];
+/** Discovery projection only; explicit resources and adapter IO stay unchanged. */
+export declare function createVaultListingFilter(readPatterns: () => readonly string[]): () => (path: string) => boolean;

package/dist/storage/vault-listing.js

@@ -0,0 +1,36 @@
+import { compileEditorAssociationGlob } from "../glob";
+import { normalizePath } from "./path";
+export const DEFAULT_VAULT_EXCLUDES = Object.freeze([
+    ".git",
+    ".jj",
+]);
+/** Discovery projection only; explicit resources and adapter IO stay unchanged. */
+export function createVaultListingFilter(readPatterns) {
+    let signature;
+    let matchers = [];
+    return () => {
+        const value = readPatterns();
+        const patterns = Array.isArray(value) ? value : DEFAULT_VAULT_EXCLUDES;
+        const next = JSON.stringify(patterns);
+        if (signature !== next) {
+            matchers = patterns
+                .filter((pattern) => typeof pattern === "string")
+                .map((pattern) => compileEditorAssociationGlob(pattern, { caseSensitive: true }))
+                .filter((matcher) => matcher !== null);
+            signature = next;
+        }
+        const current = matchers;
+        return (path) => {
+            const relative = normalizePath(path).replace(/^\/+|\/+$/gu, "");
+            if (!relative)
+                return true;
+            const parts = relative.split("/");
+            for (let length = 1; length <= parts.length; length++) {
+                const ancestor = parts.slice(0, length).join("/");
+                if (current.some((matcher) => matcher.match(ancestor)))
+                    return false;
+            }
+            return true;
+        };
+    };
+}

package/dist/storage/vault-reconciliation.d.ts

@@ -0,0 +1,19 @@
+import { type ChangeEvent, type DataAdapter, type Stat, type TAbstractFile } from "./fs";
+import type { Vault } from "./vault.svelte";
+type Snapshot = Map<string, Stat>;
+export type VaultTreeEvent = {
+    type: "create" | "modify" | "delete" | "rename";
+    file: TAbstractFile;
+    oldPath?: string;
+};
+/** Scan privately; a failed or retired scan cannot mutate the live tree. */
+export declare function scanVaultTree(adapter: DataAdapter, current: () => boolean, bounds?: {
+    entries: number;
+    bytes: number;
+}): Promise<Snapshot | null>;
+/** Prepare all identities/events before the synchronous tree commit. */
+export declare function projectVaultTree(vault: Vault, previous: Record<string, TAbstractFile>, snapshot: Snapshot, hints: readonly ChangeEvent[]): {
+    files: Record<string, TAbstractFile>;
+    events: VaultTreeEvent[];
+};
+export {};

package/dist/storage/vault-reconciliation.js

@@ -0,0 +1,137 @@
+import { TFile, TFolder, } from "./fs";
+import { dirname } from "./path";
+const limits = { entries: 100_000, bytes: 16 * 1024 * 1024 };
+/** Scan privately; a failed or retired scan cannot mutate the live tree. */
+export async function scanVaultTree(adapter, current, bounds = limits) {
+    const snapshot = new Map([
+        ["/", { type: "folder", ctime: 0, mtime: 0, size: 0 }],
+    ]);
+    const folders = ["/"];
+    let bytes = 96;
+    const encoder = new TextEncoder();
+    for (let index = 0; index < folders.length; index++) {
+        if (!current())
+            return null;
+        const parent = folders[index];
+        const listed = await adapter.list(parent);
+        for (const [type, names] of [
+            ["file", listed.files],
+            ["folder", listed.folders],
+        ]) {
+            for (const name of names) {
+                if (!current())
+                    return null;
+                if (!name || name === "." || name === ".." || /[/\\\0]/u.test(name))
+                    throw new Error("Invalid vault snapshot child path");
+                const path = parent === "/" ? name : `${parent}/${name}`;
+                bytes += encoder.encode(path).byteLength + 96;
+                if (snapshot.has(path) ||
+                    snapshot.size >= bounds.entries ||
+                    bytes > bounds.bytes)
+                    throw new Error("Vault reconciliation snapshot exceeds its bounds or duplicates a path");
+                const stat = await adapter.stat(path);
+                if (!stat ||
+                    stat.type !== type ||
+                    ![stat.ctime, stat.mtime, stat.size].every(Number.isFinite) ||
+                    stat.size < 0)
+                    throw new Error(`Incomplete vault reconciliation snapshot: ${path}`);
+                snapshot.set(path, { ...stat });
+                if (type === "folder")
+                    folders.push(path);
+            }
+        }
+    }
+    return current() ? snapshot : null;
+}
+function validPath(path) {
+    return (!!path &&
+        !/[\\\0]/u.test(path) &&
+        path.split("/").every((part) => !!part && part !== "." && part !== ".."));
+}
+function depth(path) {
+    return path.split("/").length;
+}
+function sameType(file, stat) {
+    return stat.type === "file" ? file instanceof TFile : file instanceof TFolder;
+}
+/** Prepare all identities/events before the synchronous tree commit. */
+export function projectVaultTree(vault, previous, snapshot, hints) {
+    const renamed = new Map();
+    const forced = new Set();
+    for (const hint of hints) {
+        if (!validPath(hint.path) ||
+            (hint.previousPath !== undefined && !validPath(hint.previousPath)))
+            throw new Error("Invalid vault reconciliation hint");
+        if (hint.type === "modify")
+            forced.add(hint.path);
+        const old = hint.previousPath;
+        if (!old || old === hint.path || snapshot.has(old) || previous[hint.path])
+            continue;
+        const source = previous[old], target = snapshot.get(hint.path);
+        if (!source || !target || !sameType(source, target))
+            continue;
+        for (const path of Object.keys(previous)) {
+            if (path !== old &&
+                !(source instanceof TFolder && path.startsWith(`${old}/`)))
+                continue;
+            const destination = hint.path + path.slice(old.length);
+            const stat = snapshot.get(destination);
+            if (stat &&
+                !previous[destination] &&
+                !snapshot.has(path) &&
+                sameType(previous[path], stat)) {
+                const existing = renamed.get(destination);
+                if (existing && existing !== path)
+                    throw new Error("Ambiguous vault rename hints");
+                renamed.set(destination, path);
+            }
+        }
+    }
+    const files = Object.create(null);
+    const events = [];
+    const consumed = new Set();
+    const paths = [...snapshot.keys()].sort((a, b) => depth(a) - depth(b) || a.localeCompare(b));
+    for (const path of paths) {
+        const stat = snapshot.get(path);
+        const oldPath = renamed.get(path) ?? path;
+        const existing = previous[oldPath];
+        const file = sameType(existing, stat)
+            ? existing
+            : stat.type === "file"
+                ? new TFile(path, { ...stat }, null, vault)
+                : new TFolder(path, [], null, vault);
+        if (consumed.has(file))
+            throw new Error("Duplicate vault resource identity");
+        consumed.add(file);
+        files[path] = file;
+        if (path === "/")
+            continue;
+        if (file !== existing)
+            events.push({ type: "create", file });
+        else if (oldPath !== path)
+            events.push({ type: "rename", file, oldPath });
+        else if (file instanceof TFile &&
+            (forced.has(path) ||
+                file.stat.mtime !== stat.mtime ||
+                file.stat.ctime !== stat.ctime ||
+                file.stat.size !== stat.size))
+            events.push({ type: "modify", file });
+    }
+    const deleted = Object.values(previous).filter((file) => !consumed.has(file));
+    deleted.sort((a, b) => depth(b.path) - depth(a.path) || a.path.localeCompare(b.path));
+    events.unshift(...deleted.map((file) => ({ type: "delete", file })));
+    // Nothing above mutates canonical nodes. Commit after all validation succeeds.
+    for (const path of paths) {
+        const file = files[path];
+        file.path = path === "/" ? "" : path;
+        file.parent = path === "/" ? null : files[dirname(path)];
+        if (file instanceof TFile)
+            Object.assign(file.stat, snapshot.get(path));
+        else if (file instanceof TFolder)
+            file.children.splice(0);
+    }
+    for (const path of paths)
+        if (path !== "/")
+            files[path].parent.children.push(files[path]);
+    return { files, events };
+}

package/dist/storage/vault-session.d.ts

@@ -1,4 +1,8 @@
+import type { NativeTasks } from "../native-tasks";
 import { type AppDatabase, type AppDatabaseCapabilities, type AppDatabaseDescriptor, type AppDatabaseProvider, type RuntimeTarget } from "./app-database";
+import type { NativeBackgroundIndexing } from "../native-background-indexing";
+import type { NativeHistoryIndex } from "../native-history-index";
+import type { NativeEditingIntents } from "../native-editing-intents";
 import type { VaultAdapter } from "./fs";
 import { type VaultProfile } from "./vault-state";
 export type VaultSessionAppDatabaseStatus = "ready" | "blocked";
@@ -22,6 +26,10 @@ export interface VaultSession {
     profile?: VaultProfile;
     vaultAdapter: VaultAdapter;
     appDatabase?: AppDatabase;
+    backgroundIndexing?: NativeBackgroundIndexing;
+    nativeHistoryIndex?: NativeHistoryIndex;
+    nativeEditingIntents?: NativeEditingIntents;
+    nativeTasks?: NativeTasks;
     appDatabaseState: VaultSessionAppDatabaseState;
     awaitAppDatabase?: (options?: {
         signal?: AbortSignal;

package/dist/storage/vault-session.js

@@ -128,6 +128,12 @@ async function createPreferredAppDatabase(vaultId, runtime, provider) {
             await database.open();
         return { appDatabase: database, state: readyState(database, false) };
     }
+    if (runtime === "tauri-desktop") {
+        if (!provider)
+            throw new Error("tauri-desktop requires an AppDatabaseProvider");
+        const database = await provider.open({ vaultId, runtime, role: "direct" });
+        return { appDatabase: database, state: readyState(database, false) };
+    }
     if (runtime === "deno-desktop") {
         const database = provider
             ? await provider.open({ vaultId, runtime, role: "direct" })
@@ -138,9 +144,11 @@ async function createPreferredAppDatabase(vaultId, runtime, provider) {
             });
         return { appDatabase: database, state: readyState(database, false) };
     }
-    if (runtime === "deno-server") {
+    if (runtime === "node-server" ||
+        runtime === "deno-server" ||
+        runtime === "rust-server") {
         if (!provider) {
-            throw new Error("deno-server requires an AppDatabaseProvider");
+            throw new Error("server-hosted vaults require an AppDatabaseProvider");
         }
         const database = await provider.open({
             vaultId,

package/dist/storage/vault.svelte.d.ts

@@ -1,9 +1,11 @@
+import type { FileEditingSessionRegistry } from "../file-editing-sessions";
 import { EventDispatcher } from "../events";
 import {
   FileCache,
   TFile,
   TFolder,
   type DataAdapter,
+  type ChangeEvent,
   type DataWriteOptions,
   type TAbstractFile,
 } from "./fs";
@@ -19,6 +21,9 @@ export declare const ENOTDIR: {
   prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
   stackTraceLimit: number;
 };
+export interface VaultListingOptions {
+  listingExclusions?: () => readonly string[];
+}
 export interface VaultGlobOptions {
   caseSensitive?: boolean;
 }
@@ -42,9 +47,18 @@ export declare class Vault extends EventDispatcher<{
   readonly adapter: DataAdapter;
   private files;
   private filesByName;
+  private mutationTail;
+  private mutate;
+  private mutateFile;
+  private reconcileNow;
   configDir: string;
   readonly cache: FileCache;
-  constructor(adapter: DataAdapter);
+  private readonly listingFilter;
+  constructor(
+    adapter: DataAdapter,
+    operations?: Pick<FileEditingSessionRegistry, "track">,
+    options?: VaultListingOptions,
+  );
   private getPath;
   getName(): string;
   exists(path: string, sensitive?: boolean): Promise<boolean>;
@@ -52,6 +66,23 @@ export declare class Vault extends EventDispatcher<{
   list(path?: string): Promise<import("./fs").ListedFiles>;
   load(): Promise<void>;
   reload(): Promise<TFolder>;
+  reconcile(
+    hints?: readonly ChangeEvent[],
+    current?: () => boolean,
+    context?: Record<string, unknown>,
+  ): Promise<void>;
+  private deleteNow;
+  private trashNow;
+  private atomicWriteNow;
+  private renameNow;
+  private modifyNow;
+  private modifyIfUnchangedNow;
+  private modifyBinaryNow;
+  private processNow;
+  private appendNow;
+  private appendBinaryNow;
+  private copyNow;
+  private recordFile;
   private addToFileNameIndex;
   private removeFromFileNameIndex;
   private rebuildFileNameIndex;
@@ -72,6 +103,12 @@ export declare class Vault extends EventDispatcher<{
     data: string,
     options?: DataWriteOptions,
   ): Promise<TFile>;
+  get supportsExclusiveCreate(): boolean;
+  createExclusive(
+    path: string,
+    data: string | ArrayBuffer,
+    options?: DataWriteOptions,
+  ): Promise<TFile>;
   /**
    * Create a new binary file inside the vault.
    *
@@ -103,9 +140,13 @@ export declare class Vault extends EventDispatcher<{
    *   children
    * @public
    */
-  delete(file: TAbstractFile, force?: boolean, context?: {
-    operationOrigin?: string;
-  }): Promise<void>;
+  delete(
+    file: TAbstractFile,
+    force?: boolean,
+    context?: {
+      operationOrigin?: string;
+    },
+  ): Promise<void>;
   trash(file: TAbstractFile, system?: boolean): Promise<void>;
   /**
    * Read a plaintext file that is stored inside the vault, directly from disk.
@@ -147,6 +188,13 @@ export declare class Vault extends EventDispatcher<{
    * @public
    */
   modify(file: TFile, data: string, options?: DataWriteOptions): Promise<void>;
+  get supportsConditionalTextWrites(): boolean;
+  modifyIfUnchanged(
+    file: TFile,
+    data: string,
+    expected: string | null,
+    options?: DataWriteOptions,
+  ): Promise<void>;
   /**
    * Modify the contents of a binary file.
    *
@@ -241,6 +289,7 @@ export declare class Vault extends EventDispatcher<{
   getFiles(): TFile[];
   /**
    * Iterate loaded files without allocating a second vault-sized collection.
+   *
    * @public
    */
   iterateFiles(): IterableIterator<TFile>;