@lapis-notes/api 0.1.0 → 0.1.2

package/dist/storage/index.d.ts

@@ -2,6 +2,7 @@ export * from "./fs";
 export * from "./memory-vault-adapter";
 export * from "./blob-store";
 export * from "./app-database";
+export * from "./remote-app-database";
 export * from "./task-projection";
 export * from "./index-projection";
 export * from "./turso-app-database";

package/dist/storage/index.js

@@ -2,6 +2,7 @@ export * from "./fs";
 export * from "./memory-vault-adapter";
 export * from "./blob-store";
 export * from "./app-database";
+export * from "./remote-app-database";
 export * from "./task-projection";
 export * from "./index-projection";
 export * from "./turso-app-database";

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

@@ -1,4 +1,4 @@
-import type { DataWriteOptions, ListedFiles, Stat, VaultAdapter, VaultAdapterCapabilities, VaultIdentityAdapter } from "./fs";
+import type { DataWriteOptions, AtomicDataWriteOptions, ListedFiles, Stat, VaultAdapter, VaultAdapterCapabilities, VaultIdentityAdapter, VaultReadHandle } from "./fs";
 export type MemoryVaultClock = number | (() => number);
 export interface MemoryVaultAdapterOptions {
     name?: string;
@@ -24,6 +24,8 @@ export declare class MemoryVaultAdapter implements VaultAdapter, VaultIdentityAd
     stat(path: string): Promise<Stat | null>;
     read(path: string): Promise<string>;
     readBinary(path: string): Promise<ArrayBuffer>;
+    openRead(path: string): Promise<VaultReadHandle>;
+    atomicWrite(path: string, source: ReadableStream<Uint8Array>, options?: AtomicDataWriteOptions): Promise<void>;
     write(path: string, data: string, options?: DataWriteOptions): Promise<void>;
     writeBinary(path: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
     append(path: string, data: string, options?: DataWriteOptions): Promise<void>;

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

@@ -94,6 +94,66 @@ export class MemoryVaultAdapter {
             ? toArrayBuffer(new TextEncoder().encode(value))
             : value.slice(0);
     }
+    async openRead(path) {
+        const normalized = this.#path(path);
+        const value = this.#files.get(normalized);
+        if (!value)
+            throw fsError("ENOENT", normalized);
+        const bytes = typeof value.data === "string"
+            ? new TextEncoder().encode(value.data)
+            : new Uint8Array(value.data.slice(0));
+        return {
+            size: bytes.byteLength,
+            mtime: value.stat.mtime,
+            stream: ({ offset = 0, length, signal } = {}) => {
+                const start = Math.max(0, Math.min(bytes.byteLength, Math.floor(offset)));
+                const end = Math.min(bytes.byteLength, start + Math.max(0, Math.floor(length ?? bytes.byteLength - start)));
+                let cursor = start;
+                return new ReadableStream({
+                    pull(controller) {
+                        if (signal?.aborted) {
+                            controller.error(signal.reason ?? new DOMException("Aborted", "AbortError"));
+                            return;
+                        }
+                        if (cursor >= end) {
+                            controller.close();
+                            return;
+                        }
+                        const next = Math.min(end, cursor + 64 * 1024);
+                        controller.enqueue(bytes.slice(cursor, next));
+                        cursor = next;
+                    },
+                });
+            },
+        };
+    }
+    async atomicWrite(path, source, options = {}) {
+        const reader = source.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            while (true) {
+                if (options.signal?.aborted) {
+                    throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
+                }
+                const next = await reader.read();
+                if (next.done)
+                    break;
+                chunks.push(next.value);
+                size += next.value.byteLength;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        await this.writeBinary(path, bytes.buffer, options);
+    }
     async write(path, data, options) {
         await this.#writeValue(path, data, options);
     }

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

@@ -0,0 +1,19 @@
+import { z } from "zod";
+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 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> {
+    readonly method: Method;
+    readonly domain: RemoteAppDatabaseDomain;
+    readonly input: z.ZodType<RemoteAppDatabaseArgs<Method>>;
+    readonly output: z.ZodType<RemoteAppDatabaseResult<Method>>;
+}
+export declare const REMOTE_APP_DATABASE_CONTRACT: { readonly [Method in RemoteAppDatabaseMethod]: RemoteAppDatabaseContractEntry<Method>; };
+export declare function isRemoteAppDatabaseMethod(value: unknown): value is RemoteAppDatabaseMethod;
+export declare function parseRemoteAppDatabaseArgs<Method extends RemoteAppDatabaseMethod>(method: Method, value: unknown): RemoteAppDatabaseArgs<Method>;
+export declare function parseRemoteAppDatabaseResult<Method extends RemoteAppDatabaseMethod>(method: Method, value: unknown): RemoteAppDatabaseResult<Method>;

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

@@ -0,0 +1,130 @@
+import { z } from "zod";
+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 = [
+    "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",
+];
+const remoteMethodSet = new Set(REMOTE_APP_DATABASE_METHODS);
+function jsonBytes(value) {
+    const json = JSON.stringify(value);
+    return typeof json === "string"
+        ? new TextEncoder().encode(json).byteLength
+        : 0;
+}
+function isBoundedJson(value) {
+    try {
+        return jsonBytes(value) <= REMOTE_APP_DATABASE_MAX_MESSAGE_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+function methodDomain(method) {
+    if (/memory/iu.test(method))
+        return "memory";
+    if (/notification/iu.test(method))
+        return "notifications";
+    if (/history/iu.test(method))
+        return "history";
+    if (/task|childLinks/iu.test(method))
+        return "tasks";
+    if (/projection|related/iu.test(method))
+        return "projections";
+    if (/search/iu.test(method))
+        return "search";
+    if (method === "migrate" ||
+        method === "beginSearchIndexingBatch" ||
+        method === "endSearchIndexingBatch" ||
+        method === "getChangeRevision" ||
+        method === "clearMemoryDerivedState") {
+        return "lifecycle";
+    }
+    return "metadata";
+}
+function contractEntry(method) {
+    return {
+        method,
+        domain: methodDomain(method),
+        input: z.custom((value) => Array.isArray(value) &&
+            value.length <= REMOTE_APP_DATABASE_MAX_ARGUMENTS &&
+            isBoundedJson(value), "Invalid or oversized AppDatabase arguments"),
+        output: z.custom((value) => value === undefined || isBoundedJson(value), "Invalid or oversized AppDatabase result"),
+    };
+}
+export const REMOTE_APP_DATABASE_CONTRACT = Object.fromEntries(REMOTE_APP_DATABASE_METHODS.map((method) => [method, contractEntry(method)]));
+export function isRemoteAppDatabaseMethod(value) {
+    return typeof value === "string" && remoteMethodSet.has(value);
+}
+export function parseRemoteAppDatabaseArgs(method, value) {
+    return REMOTE_APP_DATABASE_CONTRACT[method].input.parse(value);
+}
+export function parseRemoteAppDatabaseResult(method, value) {
+    return REMOTE_APP_DATABASE_CONTRACT[method].output.parse(value);
+}

package/dist/storage/task-projection.d.ts

@@ -1,5 +1,5 @@
 import { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID, type IndexFieldDefinition, type IndexQuery } from "./index-projection";
-export declare const TASK_PROJECTION_VERSION = 3;
+export declare const TASK_PROJECTION_VERSION = 4;
 export declare const TASK_OCCURRENCE_PROJECTION_VERSION = 1;
 export { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID };
 export declare const TASK_PROJECTION_FIELDS: Record<string, IndexFieldDefinition>;
@@ -91,6 +91,7 @@ export interface AppDatabaseTaskRecord {
     kind: AppDatabaseTaskKind;
     title: string;
     status: AppDatabaseTaskStatus;
+    priority?: "low" | "medium" | "high" | null;
     inbox: boolean;
     startKind: AppDatabaseTaskStartKind;
     startDate?: string | null;

package/dist/storage/task-projection.js

@@ -1,5 +1,5 @@
 import { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID, and, eq, gt, isNull, lt, lte, or, } from "./index-projection";
-export const TASK_PROJECTION_VERSION = 3;
+export const TASK_PROJECTION_VERSION = 4;
 export const TASK_OCCURRENCE_PROJECTION_VERSION = 1;
 export { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID };
 export const TASK_PROJECTION_FIELDS = {
@@ -8,6 +8,7 @@ export const TASK_PROJECTION_FIELDS = {
     kind: { type: "string", indexed: true },
     title: { type: "string", indexed: true, sortable: true },
     status: { type: "string", indexed: true, sortable: true },
+    priority: { type: "string", indexed: true, sortable: true },
     inbox: { type: "boolean", indexed: true },
     startKind: { type: "string", indexed: true },
     startDate: { type: "date", indexed: true, sortable: true },
@@ -148,7 +149,11 @@ export function taskQueryToIndexQuery(query = {}) {
         }
     }
     return {
-        where: clauses.length === 1 ? clauses[0] : clauses.length ? and(...clauses) : undefined,
+        where: clauses.length === 1
+            ? clauses[0]
+            : clauses.length
+                ? and(...clauses)
+                : undefined,
         limit: query.limit,
     };
 }

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

@@ -1,4 +1,4 @@
-import { type AppDatabase, type AppDatabaseChangeListener, type AppDatabaseDescriptor, type AppDatabaseFileHistory, type AppDatabaseIndexedFile, type AppDatabaseIndexedFileManifestPage, type AppDatabaseIndexedFileManifestQuery, type AppDatabaseIndexedMetadataPage, type AppDatabaseIndexedMetadataPageQuery, type AppDatabaseIndexedMetadataQuery, type AppDatabaseIndexedMetadataRow, type AppDatabaseKind, type AppDatabaseLinkRecord, type AppDatabaseMetadataFacetQuery, type AppDatabaseMetadataFacetRow, type AppDatabaseMetadataLinkQuery, type AppDatabaseMemoryCandidateInput, type AppDatabaseMemoryCandidateQuery, type AppDatabaseMemoryCandidateResult, type AppDatabaseMemoryJobClaimInput, type AppDatabaseMemoryJobRecord, type AppDatabaseMemoryJobUpdateInput, type AppDatabaseMemoryRecallSignalRecord, type AppDatabaseMemorySourceRecord, type AppDatabaseNotebookState, type AppDatabaseNotificationRecord, type AppDatabaseOpenContext, type AppDatabaseProvider, type AppDatabaseSearchIndexStats, type AppDatabaseSearchOptions, type AppDatabaseSearchResult, type AppDatabaseStoreFileHistoryRevisionInput, type AppDatabaseStoreFileHistoryRevisionResult, type MetadataCacheSnapshot, type SearchDocumentRecord, type SearchDocumentManifestPage, type SearchDocumentManifestQuery, type SearchEmbeddingProviderConfig } from "./app-database";
+import { type AppDatabase, type AppDatabaseChangeListener, type AppDatabaseDescriptor, type AppDatabaseFileHistory, type AppDatabaseIndexedFile, type AppDatabaseIndexedFileManifestPage, type AppDatabaseIndexedFileManifestQuery, type AppDatabaseIndexedMetadataPage, type AppDatabaseIndexedMetadataPageQuery, type AppDatabaseIndexedMetadataQuery, type AppDatabaseIndexedMetadataRow, type AppDatabaseKind, type AppDatabaseLinkRecord, type AppDatabaseMetadataFacetQuery, type AppDatabaseMetadataFacetRow, type AppDatabaseMetadataLinkQuery, type AppDatabaseMemoryCandidateInput, type AppDatabaseMemoryCandidateQuery, type AppDatabaseMemoryCandidateResult, type AppDatabaseMemoryJobClaimInput, type AppDatabaseMemoryJobRecord, type AppDatabaseMemoryJobUpdateInput, type AppDatabaseMemoryRecallSignalRecord, type AppDatabaseMemorySourceRecord, type AppDatabaseMetaScanPage, type AppDatabaseMetaScanQuery, type AppDatabaseMetaTransaction, type AppDatabaseMetaTransactionResult, type AppDatabaseNotebookState, type AppDatabaseNotificationRecord, type AppDatabaseOpenContext, type AppDatabaseProvider, type AppDatabaseSearchIndexStats, type AppDatabaseSearchOptions, type AppDatabaseSearchResult, type AppDatabaseStoreFileHistoryRevisionInput, type AppDatabaseStoreFileHistoryRevisionResult, type MetadataCacheSnapshot, type SearchDocumentRecord, type SearchDocumentManifestPage, type SearchDocumentManifestQuery, type SearchEmbeddingProviderConfig } from "./app-database";
 import { type IndexProjectionDefinitionRecord, type IndexQuery, type IndexQueryResult, type IndexRelatedQuery, type MarkProjectionSourceErrorInput, type ReplaceProjectionSourceInput } from "./index-projection";
 import type { AppDatabaseTaskChildQuery, AppDatabaseTaskQuery, AppDatabaseTaskRecord } from "./task-projection";
 import { type SearchEmbeddingRuntimeStatus } from "./search-embedding-provider";
@@ -52,6 +52,8 @@ export declare class TursoAppDatabase implements AppDatabase {
     getSearchIndexStats(): Promise<AppDatabaseSearchIndexStats>;
     getMeta<T = unknown>(key: string): Promise<T | undefined>;
     setMeta(key: string, value: unknown): Promise<void>;
+    scanMeta<T = unknown>({ prefix, after, limit, }: AppDatabaseMetaScanQuery): Promise<AppDatabaseMetaScanPage<T>>;
+    transactMeta({ checks, mutations, }: AppDatabaseMetaTransaction): Promise<AppDatabaseMetaTransactionResult>;
     getNotebookState(sourcePath: string): Promise<AppDatabaseNotebookState | undefined>;
     setNotebookState(sourcePath: string, state: AppDatabaseNotebookState): Promise<void>;
     deleteNotebookState(sourcePath: string): Promise<void>;

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

@@ -735,6 +735,10 @@ export class TursoAppDatabase {
             : undefined;
     }
     async setMeta(key, value) {
+        if (value === undefined) {
+            await this.commit([{ sql: "DELETE FROM app_meta WHERE key = ?", args: [key] }], ["meta"]);
+            return;
+        }
         await this.commit([
             {
                 sql: `INSERT INTO app_meta (key, value_json) VALUES (?, ?)
@@ -743,6 +747,47 @@ export class TursoAppDatabase {
             },
         ], ["meta"]);
     }
+    async scanMeta({ prefix, after, limit = 100, }) {
+        const boundedLimit = Math.max(1, Math.min(500, Math.floor(limit)));
+        const rows = await this.requireConnection().all(`SELECT key, value_json FROM app_meta
+       WHERE substr(key, 1, ?) = ? AND key > ?
+       ORDER BY key ASC LIMIT ?`, prefix.length, prefix, after ?? prefix, boundedLimit + 1);
+        const pageRows = rows.slice(0, boundedLimit);
+        return {
+            entries: pageRows.map((row) => ({
+                key: row.key,
+                value: parseJson(row.value_json, undefined),
+            })),
+            nextCursor: rows.length > pageRows.length ? pageRows.at(-1)?.key : undefined,
+        };
+    }
+    async transactMeta({ checks = [], mutations, }) {
+        const committed = this.commitQueue.then(async () => {
+            for (const check of checks) {
+                const row = await this.requireConnection().get("SELECT value_json FROM app_meta WHERE key = ?", check.key);
+                if (check.exists !== undefined && Boolean(row) !== check.exists) {
+                    return { applied: false };
+                }
+                if ("value" in check &&
+                    JSON.stringify(row ? parseJson(row.value_json, undefined) : undefined) !== JSON.stringify(check.value)) {
+                    return { applied: false };
+                }
+            }
+            const statements = mutations.map((mutation) => mutation.delete || mutation.value === undefined
+                ? { sql: "DELETE FROM app_meta WHERE key = ?", args: [mutation.key] }
+                : {
+                    sql: `INSERT INTO app_meta (key, value_json) VALUES (?, ?)
+                    ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json`,
+                    args: [mutation.key, JSON.stringify(mutation.value)],
+                });
+            if (statements.length > 0) {
+                await this.commitImmediately(statements, ["meta"]);
+            }
+            return { applied: true };
+        });
+        this.commitQueue = committed.then(() => undefined, () => undefined);
+        return committed;
+    }
     async getNotebookState(sourcePath) {
         return this.getMeta(notebookStateMetaKey(sourcePath));
     }

package/dist/storage/vault-session.js

@@ -138,6 +138,17 @@ async function createPreferredAppDatabase(vaultId, runtime, provider) {
             });
         return { appDatabase: database, state: readyState(database, false) };
     }
+    if (runtime === "deno-server") {
+        if (!provider) {
+            throw new Error("deno-server requires an AppDatabaseProvider");
+        }
+        const database = await provider.open({
+            vaultId,
+            runtime,
+            role: "direct",
+        });
+        return { appDatabase: database, state: readyState(database, false) };
+    }
     if (runtime === "web-pwa") {
         return createBrowserAppDatabase(vaultId, provider ?? new TursoWasmAppDatabaseProvider());
     }

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

@@ -1,6 +1,6 @@
 import type { DataAdapter } from "./fs";
 import { type UseStore } from "./keyval";
-export type VaultStorageKind = "opfs" | "file-system-access" | "desktop-folder";
+export type VaultStorageKind = "opfs" | "file-system-access" | "desktop-folder" | "server-hosted";
 export type BootstrapAppearanceMode = "dark" | "light" | "system";
 export interface VaultProfileDemoMetadata {
     source: "e2e-vault";

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

@@ -103,7 +103,9 @@ export declare class Vault extends EventDispatcher<{
    *   children
    * @public
    */
-  delete(file: TAbstractFile, force?: boolean): 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.

package/dist/storage/vault.svelte.js

@@ -260,7 +260,7 @@ export class Vault extends EventDispatcher {
      *   children
      * @public
      */
-    delete(file, force) {
+    delete(file, force, context = {}) {
         const remove = file instanceof TFolder
             ? this.adapter.rmdir(file.path, force ?? true)
             : this.adapter.remove(file.path);
@@ -282,7 +282,7 @@ export class Vault extends EventDispatcher {
             }
             this.cache.invalidate(file.path);
             this.dispatch("delete", file);
-            this.dispatch("all", "delete", file, { force });
+            this.dispatch("all", "delete", file, { force, ...context });
         });
     }
     trash(file, system = true) {
@@ -334,6 +334,79 @@ export class Vault extends EventDispatcher {
     readBinary(file) {
         return this.adapter.readBinary(file.path);
     }
+    /** Open a stable streamed snapshot of a file when the adapter supports it. */
+    async openRead(file) {
+        const adapter = this.adapter;
+        if (adapter.openRead)
+            return adapter.openRead(file.path);
+        const data = new Uint8Array(await adapter.readBinary(file.path));
+        return {
+            size: data.byteLength,
+            mtime: file.stat.mtime,
+            stream: ({ offset = 0, length, signal } = {}) => {
+                const start = Math.max(0, Math.min(data.byteLength, Math.floor(offset)));
+                const end = Math.min(data.byteLength, start + Math.max(0, Math.floor(length ?? data.byteLength - start)));
+                return new ReadableStream({
+                    start(controller) {
+                        if (signal?.aborted) {
+                            controller.error(signal.reason ?? new DOMException("Aborted", "AbortError"));
+                            return;
+                        }
+                        controller.enqueue(data.slice(start, end));
+                        controller.close();
+                    },
+                });
+            },
+        };
+    }
+    /** Stream a file into the adapter's atomic or strongest safe replacement path. */
+    async atomicWrite(path, source, options = {}) {
+        path = this.getPath(path);
+        const existed = this.getFileByPath(path);
+        const adapter = this.adapter;
+        if (adapter.atomicWrite) {
+            await adapter.atomicWrite(path, source, options);
+        }
+        else {
+            const reader = source.getReader();
+            const chunks = [];
+            let size = 0;
+            try {
+                while (true) {
+                    if (options.signal?.aborted) {
+                        throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
+                    }
+                    const next = await reader.read();
+                    if (next.done)
+                        break;
+                    chunks.push(next.value);
+                    size += next.value.byteLength;
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            const data = new Uint8Array(size);
+            let offset = 0;
+            for (const chunk of chunks) {
+                data.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            await adapter.writeBinary(path, data.buffer, options);
+        }
+        this.files = await this.loadPath("/", {});
+        this.rebuildFileNameIndex();
+        const file = this.getFileByPath(path);
+        if (!file)
+            throw new Error(`Unable to write file: ${path}`);
+        this.cache.invalidate(path);
+        const event = existed ? "modify" : "create";
+        this.dispatch(event, file);
+        this.dispatch("all", event, file, {
+            operationOrigin: options.operationOrigin,
+        });
+        return file;
+    }
     /**
      * Rename or move a file. To ensure links are automatically renamed, use
      * {@link FileManager.renameFile} instead.
@@ -364,7 +437,7 @@ export class Vault extends EventDispatcher {
             if (newFile) {
                 this.cache.rename(file.path, newFile.path);
                 this.dispatch("rename", newFile, oldPath);
-                this.dispatch("all", "rename", file, { oldPath });
+                this.dispatch("all", "rename", newFile, { oldPath });
             }
             else {
                 console.warn(`Failed to rename file: ${file.path}`);