@lapis-notes/api 0.1.3 → 0.2.0

package/dist/storage/fs.d.ts

@@ -1,4 +1,3 @@
-import { EventDispatcher } from "../events";
 import type { Vault } from "./vault.svelte";
 interface FileProperties {
     /**
@@ -90,6 +89,7 @@ export type WatchOptions = {
     interval?: number;
 };
 export interface ChangeEvent {
+    previousPath?: string;
     type: "create" | "modify" | "delete";
     path: string;
 }
@@ -99,7 +99,9 @@ export interface WatchErrorEvent {
     error: unknown;
 }
 export interface NativeWatchSubscription {
-    close(): void;
+    /** Resolves after native registration and its initial snapshot complete. */
+    readonly ready?: Promise<void>;
+    close(): void | Promise<void>;
 }
 export interface NativeWatchAdapter {
     watch(path: string | string[], options: WatchOptions, listener: (event: ChangeEvent | WatchErrorEvent) => void): NativeWatchSubscription | void;
@@ -140,6 +142,8 @@ export interface DataAdapter {
     trashLocal(normalizedPath: string): Promise<void>;
 }
 export interface VaultAdapterCapabilities {
+    exclusiveCreate?: boolean;
+    conditionalTextWrite?: boolean;
     persistent: boolean;
     userVisibleFiles: boolean;
     requiresPermission: boolean;
@@ -155,6 +159,13 @@ export interface VaultAdapterCapabilities {
  */
 export interface VaultAdapter extends DataAdapter {
     getCapabilities?(): Partial<VaultAdapterCapabilities>;
+    /** Publish new complete bytes without replacing an existing destination. */
+    writeExclusive?(normalizedPath: string, data: string | ArrayBuffer, options?: DataWriteOptions): Promise<void>;
+    /**
+     * Reject when the file no longer has these exact contents (null means
+     * absent).
+     */
+    writeTextIfUnchanged?(normalizedPath: string, data: string, expected: string | null, options?: DataWriteOptions): Promise<void>;
     openRead?(normalizedPath: string): Promise<VaultReadHandle>;
     atomicWrite?(normalizedPath: string, source: ReadableStream<Uint8Array>, options?: AtomicDataWriteOptions): Promise<void>;
 }
@@ -165,30 +176,7 @@ export interface AsyncResourceAdapter {
     getResourceUrl(normalizedPath: string): Promise<string>;
     revokeResourceUrl?(url: string): void;
 }
-export declare class DirectoryWatcher extends EventDispatcher<{
-    error: [{
-        error: unknown;
-        path: string;
-    }];
-    all: [event: ChangeEvent | WatchErrorEvent];
-    create: [path: string];
-    modify: [path: string];
-    delete: [path: string];
-}> {
-    readonly adapter: DataAdapter;
-    readonly pollingInterval: number;
-    private watchers;
-    constructor(adapter: DataAdapter, pollingInterval?: number);
-    watch(path: string | string[], options?: WatchOptions): {
-        close: () => void;
-    } | undefined;
-    unwatch(path: string): void;
-    close(): void;
-    private takeSnapshot;
-    private toEventPath;
-    private checkForChanges;
-    private diffSnapshot;
-}
+export { DirectoryWatcher } from "./directory-watcher";
 export declare class FileCache {
     private capacity;
     private cache;
@@ -202,4 +190,3 @@ export declare class FileCache {
     has(key: string): boolean;
     keys(): string[];
 }
-export {};

package/dist/storage/fs.js

@@ -1,5 +1,4 @@
-import { EventDispatcher } from "../events";
-import { basename, joinPath, normalizePath } from "./path";
+import { basename, normalizePath } from "./path";
 export class TAbstractFile {
     parent;
     path;
@@ -76,172 +75,7 @@ export class TFolder extends TAbstractFile {
         return this.parent === null;
     }
 }
-function isNativeWatchAdapter(adapter) {
-    const vaultAdapter = adapter;
-    return (typeof vaultAdapter.watch === "function" &&
-        vaultAdapter.getCapabilities?.().nativeWatch === true);
-}
-export class DirectoryWatcher extends EventDispatcher {
-    adapter;
-    pollingInterval;
-    watchers = new Map();
-    constructor(adapter, pollingInterval = 5000) {
-        super();
-        this.adapter = adapter;
-        this.pollingInterval = pollingInterval;
-    }
-    watch(path, options = {}) {
-        if (Array.isArray(path)) {
-            path.forEach((p) => this.watch(p));
-            return;
-        }
-        path = normalizePath(path);
-        const watcherOptions = {
-            recursive: options.recursive || false,
-            interval: options.interval || this.pollingInterval,
-            lastSnapshot: null,
-            timeout: null,
-            nativeSubscription: null,
-        };
-        this.watchers.set(path, watcherOptions);
-        if (isNativeWatchAdapter(this.adapter)) {
-            watcherOptions.nativeSubscription =
-                this.adapter.watch(path, options, (event) => {
-                    const normalizedEvent = event.type === "error"
-                        ? { ...event, path: this.toEventPath(event.path) }
-                        : { ...event, path: this.toEventPath(event.path) };
-                    this.dispatch("all", normalizedEvent);
-                    if (normalizedEvent.type === "error") {
-                        this.dispatch("error", {
-                            error: normalizedEvent.error,
-                            path: normalizedEvent.path,
-                        });
-                        return;
-                    }
-                    this.dispatch(normalizedEvent.type, normalizedEvent.path);
-                }) ?? null;
-            return {
-                close: () => this.unwatch(path),
-            };
-        }
-        this.takeSnapshot(path, watcherOptions.recursive).then((snapshot) => {
-            watcherOptions.lastSnapshot = snapshot;
-            watcherOptions.timeout = setInterval(() => {
-                this.checkForChanges(path, watcherOptions);
-            }, watcherOptions.interval);
-        });
-        return {
-            close: () => this.unwatch(path),
-        };
-    }
-    unwatch(path) {
-        path = normalizePath(path);
-        const watcher = this.watchers.get(path);
-        if (!watcher) {
-            return;
-        }
-        watcher.nativeSubscription?.close();
-        if (watcher.timeout) {
-            clearInterval(watcher.timeout);
-        }
-        this.watchers.delete(path);
-    }
-    close() {
-        for (const path of this.watchers.keys()) {
-            this.unwatch(path);
-        }
-    }
-    async takeSnapshot(path, recursive) {
-        path = normalizePath(path);
-        const snapshot = new Map();
-        try {
-            const stats = await this.adapter.stat(path);
-            if (!stats)
-                return snapshot;
-            snapshot.set(this.toEventPath(path), stats);
-            if (stats.type === "folder") {
-                const { files, folders } = await this.adapter.list(path);
-                for (const file of files) {
-                    const entryPath = joinPath(path, file);
-                    const entryStats = await this.adapter.stat(entryPath);
-                    if (!entryStats)
-                        continue;
-                    snapshot.set(this.toEventPath(entryPath), entryStats);
-                }
-                if (!recursive)
-                    return snapshot;
-                for (const folder of folders) {
-                    const entryPath = joinPath(path, folder);
-                    const subSnapshot = await this.takeSnapshot(entryPath, recursive);
-                    for (const [subPath, subStats] of subSnapshot.entries()) {
-                        snapshot.set(subPath, subStats);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error("fs:watch", error);
-            this.trigger("error", { error, path });
-            this.trigger("all", { type: "error", path, error });
-        }
-        return snapshot;
-    }
-    toEventPath(path) {
-        path = normalizePath(path);
-        return path === "/" ? "/" : path.replace(/^\/+/, "");
-    }
-    async checkForChanges(path, watcherOptions) {
-        path = normalizePath(path);
-        try {
-            const newSnapshot = await this.takeSnapshot(path, watcherOptions.recursive);
-            if (watcherOptions.lastSnapshot) {
-                const changes = this.diffSnapshot(watcherOptions.lastSnapshot, newSnapshot);
-                for (const change of changes) {
-                    this.dispatch(change.type, change.path);
-                    this.dispatch("all", change);
-                }
-            }
-            watcherOptions.lastSnapshot = newSnapshot;
-        }
-        catch (err) {
-            const error = err;
-            if (error.code === "ENOENT") {
-                this.dispatch("delete", path);
-                this.dispatch("all", { type: "delete", path });
-                if (this.watchers.has(path)) {
-                    this.unwatch(path);
-                }
-            }
-            else {
-                console.error("fs:watch", error);
-                this.dispatch("error", { error, path });
-                this.trigger("all", { type: "error", path, error });
-            }
-        }
-    }
-    diffSnapshot(oldSnapshot, newSnapshot) {
-        const changes = [];
-        for (const [path, stats] of newSnapshot) {
-            if (!oldSnapshot.has(path)) {
-                changes.push({ type: "create", path });
-            }
-            else {
-                const oldStats = oldSnapshot.get(path);
-                if (oldStats.mtime !== stats.mtime ||
-                    oldStats.size !== stats.size ||
-                    oldStats.type !== stats.type) {
-                    changes.push({ type: "modify", path });
-                }
-            }
-        }
-        for (const path of oldSnapshot.keys()) {
-            if (!newSnapshot.has(path)) {
-                changes.push({ type: "delete", path });
-            }
-        }
-        return changes;
-    }
-}
+export { DirectoryWatcher } from "./directory-watcher";
 export class FileCache {
     capacity;
     cache;

package/dist/storage/index-projection.js

@@ -83,7 +83,9 @@ export function fieldValue(data, field) {
 function scalarOf(value) {
     if (value === undefined)
         return undefined;
-    if (value === null || typeof value === "string" || typeof value === "number") {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number") {
         return value;
     }
     if (typeof value === "boolean")
@@ -161,20 +163,22 @@ function afterCursor(sortValues, rowId, after, orderBy) {
     for (let index = 0; index < length; index += 1) {
         const spec = orderBy[index] ?? { field: "id", direction: "asc" };
         const direction = spec.direction === "desc" ? -1 : 1;
-        const comparison = compareScalars(sortValues[index] ?? null, cursor.values[index] ?? null);
+        const left = sortValues[index] ?? null;
+        const right = cursor.values[index] ?? null;
+        const comparison = compareScalars(left, right);
         if (comparison === 0)
             continue;
+        if (spec.nulls && (left == null || right == null)) {
+            return left == null ? spec.nulls === "last" : spec.nulls === "first";
+        }
         return comparison * direction > 0;
     }
-    return rowId > cursor.rowId;
+    return rowId.localeCompare(cursor.rowId) > 0;
 }
 export function selectProjectionRow(data, select) {
     if (!select?.length)
         return data;
-    const picked = {};
-    for (const field of select)
-        picked[field] = data[field];
-    return picked;
+    return Object.fromEntries(select.map((field) => [field, fieldValue(data, field)]));
 }
 export function evaluateProjectionQuery(rows, query, revision, indexStatus) {
     const orderBy = query.orderBy ?? [];
@@ -186,7 +190,8 @@ export function evaluateProjectionQuery(rows, query, revision, indexStatus) {
             if (comparison !== 0) {
                 if (spec.nulls === "first" && fieldValue(left.data, spec.field) == null)
                     return -1;
-                if (spec.nulls === "first" && fieldValue(right.data, spec.field) == null)
+                if (spec.nulls === "first" &&
+                    fieldValue(right.data, spec.field) == null)
                     return 1;
                 if (spec.nulls === "last" && fieldValue(left.data, spec.field) == null)
                     return 1;
@@ -253,7 +258,11 @@ export function indexedValuesForRow(projectionId, row, fields) {
     return values;
 }
 export function compileProjectionQuerySql(projectionId, query, definition) {
-    const args = [projectionId, definition.schemaVersion, definition.configHash];
+    const args = [
+        projectionId,
+        definition.schemaVersion,
+        definition.configHash,
+    ];
     const where = query.includeStale
         ? "r.projection_id = ? AND s.schema_version = ? AND s.config_hash = ?"
         : `r.projection_id = ?
@@ -280,14 +289,18 @@ export function compileProjectionQuerySql(projectionId, query, definition) {
     };
 }
 function jsonExtract(field) {
-    return `json_extract(r.data_json, '$.${field.replaceAll("'", "''")}')`;
+    return `json_extract(r.data_json, '$.${JSON.stringify(field).replaceAll("'", "''")}')`;
 }
 function compileFilterSql(filter, args) {
     switch (filter.op) {
         case "and":
-            return filter.operands.map((operand) => `(${compileFilterSql(operand, args)})`).join(" AND ");
+            return (filter.operands
+                .map((operand) => `(${compileFilterSql(operand, args)})`)
+                .join(" AND ") || "1");
         case "or":
-            return filter.operands.map((operand) => `(${compileFilterSql(operand, args)})`).join(" OR ");
+            return (filter.operands
+                .map((operand) => `(${compileFilterSql(operand, args)})`)
+                .join(" OR ") || "0");
         case "not":
             return `NOT (${compileFilterSql(filter.operand, args)})`;
         case "exists":
@@ -297,9 +310,14 @@ function compileFilterSql(filter, args) {
         case "in": {
             if (filter.values.length === 0)
                 return "0";
-            const placeholders = filter.values.map(() => "?").join(", ");
-            args.push(...filter.values);
-            return `${jsonExtract(filter.field)} IN (${placeholders})`;
+            const values = filter.values.filter((value) => value != null);
+            const placeholders = values.map(() => "?").join(", ");
+            args.push(...values);
+            const expr = jsonExtract(filter.field);
+            const member = values.length ? `${expr} IN (${placeholders})` : "0";
+            return values.length !== filter.values.length
+                ? `(${expr} IS NULL OR ${member})`
+                : member;
         }
         case "compare": {
             const expr = jsonExtract(filter.field);

package/dist/storage/memory-vault-adapter.d.ts

@@ -27,6 +27,8 @@ export declare class MemoryVaultAdapter implements VaultAdapter, VaultIdentityAd
     openRead(path: string): Promise<VaultReadHandle>;
     atomicWrite(path: string, source: ReadableStream<Uint8Array>, options?: AtomicDataWriteOptions): Promise<void>;
     write(path: string, data: string, options?: DataWriteOptions): Promise<void>;
+    /** Compare and mutate synchronously before yielding to another memory writer. */
+    writeTextIfUnchanged(path: string, data: string, expected: string | null, options?: DataWriteOptions): Promise<void>;
     writeBinary(path: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
     append(path: string, data: string, options?: DataWriteOptions): Promise<void>;
     appendBinary(path: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;

package/dist/storage/memory-vault-adapter.js

@@ -67,6 +67,7 @@ export class MemoryVaultAdapter {
             nativeWatch: false,
             resourceUrls: false,
             systemTrash: false,
+            conditionalTextWrite: true,
         };
     }
     async exists(path) {
@@ -134,7 +135,7 @@ export class MemoryVaultAdapter {
         try {
             while (true) {
                 if (options.signal?.aborted) {
-                    throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
+                    throw (options.signal.reason ?? new DOMException("Aborted", "AbortError"));
                 }
                 const next = await reader.read();
                 if (next.done)
@@ -157,6 +158,18 @@ export class MemoryVaultAdapter {
     async write(path, data, options) {
         await this.#writeValue(path, data, options);
     }
+    /** Compare and mutate synchronously before yielding to another memory writer. */
+    async writeTextIfUnchanged(path, data, expected, options) {
+        if (expected !== null && typeof expected !== "string")
+            throw fsError("EINVAL", path);
+        const normalized = this.#path(path);
+        const stored = this.#files.get(normalized);
+        if (stored
+            ? typeof stored.data !== "string" || stored.data !== expected
+            : expected !== null)
+            throw fsError("ECONFLICT", normalized);
+        return this.#writeValue(normalized, data, options);
+    }
     async writeBinary(path, data, options) {
         await this.#writeValue(path, data, options);
     }

package/dist/storage/path.d.ts

@@ -1,3 +1,7 @@
+/** Shared vault-local state default for every Lapis application host. */
+export declare const DEFAULT_APP_STATE_DIRECTORY = ".lapis";
+/** Resolve an application-owned path beneath the shared state directory. */
+export declare function appStatePath(...parts: string[]): string;
 /**
  * Normalize a vault-style path by removing redundant segments and separators.
  *
@@ -12,8 +16,8 @@ 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
+ * 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

package/dist/storage/path.js

@@ -1,3 +1,9 @@
+/** Shared vault-local state default for every Lapis application host. */
+export const DEFAULT_APP_STATE_DIRECTORY = ".lapis";
+/** Resolve an application-owned path beneath the shared state directory. */
+export function appStatePath(...parts) {
+    return joinPath(DEFAULT_APP_STATE_DIRECTORY, ...parts);
+}
 /**
  * Normalize a vault-style path by removing redundant segments and separators.
  *
@@ -66,8 +72,8 @@ export function basename(path) {
 /**
  * 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
+ * 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

package/dist/storage/projection-query-candidates.d.ts

@@ -0,0 +1,3 @@
+import type { IndexQuery } from "./index-projection";
+/** SQL narrows only what its scalar semantics can prove; the AST remains final. */
+export declare function projectionQueryCandidates(query: IndexQuery): IndexQuery;

package/dist/storage/projection-query-candidates.js

@@ -0,0 +1,69 @@
+/** SQL narrows only what its scalar semantics can prove; the AST remains final. */
+export function projectionQueryCandidates(query) {
+    return {
+        where: query.where ? candidate(query.where).filter : undefined,
+        includeStale: query.includeStale,
+    };
+}
+function candidate(filter) {
+    switch (filter.op) {
+        case "and":
+        case "or": {
+            const branches = filter.operands.map(candidate);
+            const exact = branches.every((branch) => branch.exact);
+            if (filter.op === "or" && branches.some((branch) => !branch.filter)) {
+                return { exact };
+            }
+            return {
+                filter: {
+                    op: filter.op,
+                    operands: branches.flatMap((branch) => branch.filter ? [branch.filter] : []),
+                },
+                exact,
+            };
+        }
+        case "not": {
+            const child = candidate(filter.operand);
+            return child.exact
+                ? {
+                    filter: {
+                        op: "not",
+                        operand: child.filter ?? { op: "and", operands: [] },
+                    },
+                    exact: true,
+                }
+                : { exact: false };
+        }
+        case "exists":
+        case "not-exists":
+            return { filter, exact: true };
+        case "in": {
+            if (!filter.values.length)
+                return { filter: { op: "or", operands: [] }, exact: true };
+            if (filter.values.every((value) => value == null)) {
+                return {
+                    filter: { op: "not-exists", field: filter.field },
+                    exact: true,
+                };
+            }
+            return filter.values.some((value) => value == null)
+                ? { exact: false }
+                : { filter: { op: "exists", field: filter.field }, exact: false };
+        }
+        case "compare": {
+            if (filter.value == null) {
+                if (filter.comparison === "eq" || filter.comparison === "ne")
+                    return { filter, exact: true };
+                return {
+                    filter: filter.comparison === "lt" || filter.comparison === "lte"
+                        ? { op: "exists", field: filter.field }
+                        : { op: "or", operands: [] },
+                    exact: true,
+                };
+            }
+            return filter.comparison === "ne"
+                ? { exact: false }
+                : { filter: { op: "exists", field: filter.field }, exact: false };
+        }
+    }
+}

package/dist/storage/remote-app-database.d.ts

@@ -1,10 +1,10 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 import type { AppDatabase } from "./app-database";
 export declare const REMOTE_APP_DATABASE_MAX_ARGUMENTS = 4;
 export declare const REMOTE_APP_DATABASE_MAX_MESSAGE_BYTES: number;
 export declare const REMOTE_APP_DATABASE_METHODS: readonly ["migrate", "beginSearchIndexingBatch", "endSearchIndexingBatch", "configureSearchEmbeddingProvider", "getSearchEmbeddingProvider", "getSearchEmbeddingRuntimeStatus", "getSearchIndexStats", "getMeta", "setMeta", "scanMeta", "transactMeta", "getNotebookState", "setNotebookState", "deleteNotebookState", "loadMetadataSnapshot", "saveMetadataSnapshot", "getFileHistory", "storeFileHistoryRevision", "listNotifications", "upsertNotification", "markNotificationRead", "clearNotification", "clearAllNotifications", "getMemorySourceState", "listMemorySourceStates", "upsertMemorySourceState", "deleteMemorySourceState", "upsertMemoryCandidate", "queryMemoryCandidates", "deleteMemoryCandidatesByConversation", "recordMemoryRecallSignal", "listMemoryRecallSignals", "claimMemoryJob", "updateMemoryJob", "listMemoryJobs", "clearMemoryDerivedState", "getChangeRevision", "upsertIndexedFile", "getIndexedFile", "listIndexedFileManifest", "queryIndexedMetadata", "queryIndexedMetadataPage", "queryMetadataFacets", "queryMetadataLinks", "deleteIndexedFile", "renameIndexedFile", "upsertSearchDocument", "deleteSearchDocument", "getSearchDocument", "listSearchDocumentManifest", "listSearchDocuments", "rebuildSearchIndex", "searchDocuments", "searchDocumentPaths", "upsertTaskProjection", "deleteTaskProjection", "queryTasks", "getTaskRow", "listChildLinks", "listTaskDescendants", "registerProjectionDefinition", "unregisterProjectionDefinition", "replaceProjectionSource", "markProjectionSourceError", "deleteProjectionSource", "queryProjection", "getProjectionRow", "queryRelated"];
 export type RemoteAppDatabaseMethod = (typeof REMOTE_APP_DATABASE_METHODS)[number];
-export type RemoteAppDatabaseArgs<Method extends RemoteAppDatabaseMethod> = AppDatabase[Method] extends (...args: infer Args) => unknown ? Args : never;
+export type RemoteAppDatabaseArgs<Method extends RemoteAppDatabaseMethod> = Method extends RemoteAppDatabaseMethod ? AppDatabase[Method] extends (...args: infer Args) => unknown ? Args : never : never;
 export type RemoteAppDatabaseResult<Method extends RemoteAppDatabaseMethod> = AppDatabase[Method] extends (...args: never[]) => infer Result ? Awaited<Result> : never;
 export type RemoteAppDatabaseDomain = "lifecycle" | "metadata" | "search" | "history" | "notifications" | "memory" | "tasks" | "projections";
 export interface RemoteAppDatabaseContractEntry<Method extends RemoteAppDatabaseMethod> {

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 export const REMOTE_APP_DATABASE_MAX_ARGUMENTS = 4;
 export const REMOTE_APP_DATABASE_MAX_MESSAGE_BYTES = 32 * 1024 * 1024;
 export const REMOTE_APP_DATABASE_METHODS = [

package/dist/storage/runtime.d.ts

@@ -0,0 +1,3 @@
+/** Application host identity, independent of optional database/model services. */
+export type RuntimeTarget = "web-pwa" | "deno-desktop" | "tauri-desktop" | "node-server" | "rust-server" | "deno-server" | "test";
+export declare function isNativeDesktopRuntime(runtime?: RuntimeTarget | null): runtime is "deno-desktop" | "tauri-desktop";

package/dist/storage/runtime.js

@@ -0,0 +1,3 @@
+export function isNativeDesktopRuntime(runtime) {
+    return runtime === "deno-desktop" || runtime === "tauri-desktop";
+}

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

@@ -0,0 +1,3 @@
+import type { SearchDocumentRecord } from "./app-database";
+import type { SearchEmbeddingProviderConfig } from "./search-embedding-provider";
+export declare function rebindSearchDocument(document: SearchDocumentRecord, config: SearchEmbeddingProviderConfig | null): SearchDocumentRecord;

package/dist/storage/search-embedding-record.js

@@ -0,0 +1,18 @@
+export function rebindSearchDocument(document, config) {
+    const copy = JSON.parse(JSON.stringify(document));
+    if (!config || !copy.chunks?.length)
+        return copy;
+    copy.chunks = copy.chunks.map((chunk) => chunk.text.trim().length
+        ? {
+            ...chunk,
+            embedding: {
+                status: "pending",
+                modelId: config.modelId ?? "lapis/token-hash-v0",
+                modelVersion: config.modelVersion,
+                dimensions: config.dimensions,
+                dirty: true,
+            },
+        }
+        : chunk);
+    return copy;
+}

package/dist/storage/turso-app-database.d.ts

@@ -32,6 +32,7 @@ export declare class TursoAppDatabase implements AppDatabase {
     readonly kind: Extract<AppDatabaseKind, "turso-native" | "turso-wasm">;
     private connection;
     private opened;
+    private closeTask;
     private nativeFullTextSearch;
     private nativeVectorSearch;
     private searchEmbeddingProviderConfig;
@@ -47,6 +48,7 @@ export declare class TursoAppDatabase implements AppDatabase {
     beginSearchIndexingBatch(): Promise<void>;
     endSearchIndexingBatch(): Promise<void>;
     configureSearchEmbeddingProvider(provider: SearchEmbeddingProviderConfig | null): Promise<void>;
+    private configureSearchProviderImmediately;
     getSearchEmbeddingProvider(): Promise<SearchEmbeddingProviderConfig | null>;
     getSearchEmbeddingRuntimeStatus(): Promise<SearchEmbeddingRuntimeStatus | null>;
     getSearchIndexStats(): Promise<AppDatabaseSearchIndexStats>;