@lapis-notes/api 0.1.4 → 0.2.1

package/dist/storage/app-database.js

@@ -1,8 +1,10 @@
+import { rebindSearchDocument } from "./search-embedding-record";
 import { canCollectSearchQueryPropertyNames, canCollectSearchQueryTerms, collectSearchQueryPropertyNames, collectSearchQueryTerms, parseSearchQueryAst, } from "../search-query";
 import { cosineSimilarity, createSearchEmbeddingProvider, } from "./search-embedding-provider";
 import { evaluateSearchQueryForDocument, findSearchQueryRangesInText, isStructuredSearchQuery, } from "./search-query-evaluator";
 import { assertProjectionReadAccess, assertProjectionWriteAccess, evaluateProjectionQuery, indexedValuesForRow, MAX_PROJECTION_ROWS_PER_SOURCE, projectionIndexStatus, PUBLIC_TASKS_PROJECTION_ID, sourceIsCurrent, } from "./index-projection";
 import { taskQueryToIndexQuery, TASK_PROJECTION_FIELDS, TASK_PROJECTION_VERSION, } from "./task-projection";
+export { isNativeDesktopRuntime } from "./runtime";
 export function supportsSearchQueryEnhancementRuntime(runtimeTarget) {
     return runtimeTarget === "deno-desktop";
 }
@@ -245,7 +247,16 @@ function buildSearchChunks(path, content, metadata) {
         const chunkEnd = remaining > metadata.chunking.targetChars
             ? findBestCutoff(breakPoints, chunkStart, targetEnd, metadata.chunking.breakpointWindowChars, metadata.chunking.breakpointDecay, codeFences)
             : content.length;
-        const safeEnd = chunkEnd > chunkStart ? chunkEnd : targetEnd;
+        let safeEnd = chunkEnd > chunkStart ? chunkEnd : targetEnd;
+        // Search offsets use UTF-16, but chunks must remain complete Unicode text.
+        if (safeEnd > 0 &&
+            safeEnd < content.length &&
+            content.charCodeAt(safeEnd - 1) >= 0xd800 &&
+            content.charCodeAt(safeEnd - 1) <= 0xdbff &&
+            content.charCodeAt(safeEnd) >= 0xdc00 &&
+            content.charCodeAt(safeEnd) <= 0xdfff) {
+            safeEnd += 1;
+        }
         const chunk = createChunk(path, content, metadata, chunkStart, safeEnd);
         if (!chunk) {
             if (safeEnd <= chunkStart) {
@@ -554,6 +565,18 @@ function renameChunkId(chunkId, oldPath, newPath) {
     }
     return `${newPath}${chunkId.slice(oldPath.length)}`;
 }
+function searchSnippetBounds(text, start, end) {
+    const splitsPair = (offset) => offset > 0 &&
+        offset < text.length &&
+        text.charCodeAt(offset - 1) >= 0xd800 &&
+        text.charCodeAt(offset - 1) <= 0xdbff &&
+        text.charCodeAt(offset) >= 0xdc00 &&
+        text.charCodeAt(offset) <= 0xdfff;
+    return [
+        splitsPair(start) ? start - 1 : start,
+        splitsPair(end) ? end + 1 : end,
+    ];
+}
 function buildFieldSnippet(field, text, ranges, snippetLength) {
     if (!ranges.length || !text.length)
         return [];
@@ -569,8 +592,9 @@ function buildFieldSnippet(field, text, ranges, snippetLength) {
     }
     const focus = ranges[0];
     const padding = Math.max(16, Math.floor(snippetLength / 3));
-    const start = Math.max(0, focus.start - padding);
-    const end = Math.min(text.length, Math.max(start + snippetLength, focus.end + padding));
+    const initialStart = Math.max(0, focus.start - padding);
+    const initialEnd = Math.min(text.length, Math.max(initialStart + snippetLength, focus.end + padding));
+    const [start, end] = searchSnippetBounds(text, initialStart, initialEnd);
     return [
         {
             field,
@@ -612,8 +636,9 @@ function buildContentSnippets(text, ranges, snippetLength) {
             return { ...snippet, ranges };
         }
         const focus = ranges[0];
-        const start = Math.max(0, focus.start - Math.floor(snippetLength / 3));
-        const end = Math.min(snippet.text.length, Math.max(start + snippetLength, focus.end + Math.floor(snippetLength / 3)));
+        const initialStart = Math.max(0, focus.start - Math.floor(snippetLength / 3));
+        const initialEnd = Math.min(snippet.text.length, Math.max(initialStart + snippetLength, focus.end + Math.floor(snippetLength / 3)));
+        const [start, end] = searchSnippetBounds(snippet.text, initialStart, initialEnd);
         return {
             field: "content",
             text: snippet.text.slice(start, end),
@@ -1335,7 +1360,7 @@ export class MemoryAppDatabase {
             ...clone(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,
         };
         this.memoryJobs.set(updated.id, updated);
@@ -1898,13 +1923,15 @@ export class MemoryAppDatabase {
             const targetProjection = query.direction === "in"
                 ? edge.projectionId
                 : (edge.targetProjectionId ?? query.projectionId);
+            const targetDefinition = this.projections.get(targetProjection);
+            assertProjectionReadAccess(targetDefinition, readerPluginId);
             const row = query.direction === "in"
                 ? this.projectionRows.get(this.projectionRowKey(targetProjection, edge.sourceRowId))
                 : edge.targetRowId
                     ? this.projectionRows.get(this.projectionRowKey(targetProjection, edge.targetRowId))
                     : [...this.projectionRows.values()].find((candidate) => candidate.projectionId === targetProjection &&
                         candidate.sourcePath === edge.targetPath);
-            if (!row)
+            if (!row || !this.currentProjectionData(row, targetDefinition))
                 continue;
             if (query.targetWhere &&
                 !evaluateProjectionQuery([row], { where: query.targetWhere }, 0, "ready").rows.length) {
@@ -2103,28 +2130,7 @@ export class MemoryAppDatabase {
         }
     }
     rebindSearchDocumentForProvider(document) {
-        const provider = this.searchEmbeddingProvider;
-        if (!provider || !document.chunks?.length) {
-            return clone(document);
-        }
-        return {
-            ...clone(document),
-            chunks: document.chunks.map((chunk) => {
-                if (!chunk.text.trim().length) {
-                    return clone(chunk);
-                }
-                return {
-                    ...clone(chunk),
-                    embedding: {
-                        status: "pending",
-                        modelId: provider.config.modelId ?? "lapis/token-hash-v0",
-                        modelVersion: provider.config.modelVersion,
-                        dimensions: provider.config.dimensions,
-                        dirty: true,
-                    },
-                };
-            }),
-        };
+        return rebindSearchDocument(document, this.searchEmbeddingProvider?.config ?? null);
     }
     toState() {
         return {
@@ -2154,9 +2160,7 @@ export class MemoryAppDatabase {
             projectionRevision: this.projectionRevision,
             memorySources: [...this.memorySources.values()].map((value) => clone(value)),
             memoryCandidates: [...this.memoryCandidates.values()].map((value) => clone(value)),
-            memoryCandidateOrigins: [
-                ...this.memoryCandidateOrigins.values(),
-            ].flatMap((origins) => origins.map((origin) => clone(origin))),
+            memoryCandidateOrigins: [...this.memoryCandidateOrigins.values()].flatMap((origins) => origins.map((origin) => clone(origin))),
             memoryRecallSignals: [...this.memoryRecallSignals.values()].map((value) => clone(value)),
             memoryJobs: [...this.memoryJobs.values()].map((value) => clone(value)),
         };
@@ -2252,6 +2256,9 @@ export class MemoryAppDatabase {
                     errorChunkCount += 1;
                     lastError ??= embedding.error ?? null;
                     break;
+                default:
+                    pendingChunkCount += 1;
+                    break;
             }
         }
         return {
@@ -2286,7 +2293,7 @@ export class MemoryAppDatabase {
         this.searchIndexStats.readyChunkCount += stats.readyChunkCount;
         this.searchIndexStats.pendingChunkCount += stats.pendingChunkCount;
         this.searchIndexStats.errorChunkCount += stats.errorChunkCount;
-        if (stats.lastError) {
+        if (stats.lastError !== null) {
             this.searchIndexStats.lastError = stats.lastError;
             this.searchIndexLastErrorPath = path;
         }
@@ -2301,7 +2308,7 @@ export class MemoryAppDatabase {
             this.searchIndexStats.lastError = null;
             this.searchIndexLastErrorPath = null;
             for (const [nextPath, nextStats] of this.searchIndexStatsByPath) {
-                if (nextPath === path || !nextStats.lastError) {
+                if (nextPath === path || nextStats.lastError === null) {
                     continue;
                 }
                 this.searchIndexStats.lastError = nextStats.lastError;

package/dist/storage/desktop-native.d.ts

@@ -8,7 +8,7 @@
 import type { AppDatabaseChangeSet, AppDatabaseNotificationSeverity } from "./app-database";
 import type { ChangeEvent, AsyncResourceAdapter, DataWriteOptions, ListedFiles, NativeWatchAdapter, NativeWatchSubscription, Stat, VaultAdapter, VaultAdapterCapabilities, VaultReadHandle, AtomicDataWriteOptions, VaultIdentityAdapter, WatchErrorEvent, WatchOptions } from "./fs";
 import { type KeyValueStore, type VaultProfile } from "./vault-state";
-export type NativeDesktopRuntime = "deno-desktop";
+export type NativeDesktopRuntime = "deno-desktop" | "tauri-desktop";
 export type NativeDesktopPlatformOs = "macos" | "windows" | "linux" | "unknown";
 export interface NativeDesktopPlatformInfo {
     readonly runtime: NativeDesktopRuntime;
@@ -18,7 +18,7 @@ export interface NativeDesktopPlatformInfo {
     readonly appVersion?: string;
     readonly packaged?: boolean;
 }
-export type NativeDesktopCapabilityId = "resource" | "database" | "search" | "notebook" | "language-service" | "model" | "plugin-sidecar" | "plugin-assets" | "file-watch" | "notifications" | "file-system-actions" | "nostr-signer" | "agent-runtime" | "terminal-runtime" | "secure-storage";
+export type NativeDesktopCapabilityId = "system-trash" | "exclusive-create" | "conditional-text-write" | "resource" | "database" | "search" | "notebook" | "language-service" | "model" | "plugin-sidecar" | "plugin-assets" | "file-watch" | "notifications" | "file-system-actions" | "nostr-signer" | "agent-runtime" | "terminal-runtime" | "secure-storage";
 export type NativeAgentProcessMessage = {
     processId: string;
     type: "stdout" | "stderr" | "exit";
@@ -151,8 +151,10 @@ export declare class NativeDesktopVaultAdapter implements VaultAdapter, VaultIde
     stat(normalizedPath: string): Promise<Stat | null>;
     read(normalizedPath: string): Promise<string>;
     readBinary(normalizedPath: string): Promise<ArrayBuffer>;
+    writeExclusive(normalizedPath: string, data: string | ArrayBuffer, options?: DataWriteOptions): Promise<void>;
     openRead(normalizedPath: string): Promise<VaultReadHandle>;
     atomicWrite(normalizedPath: string, source: ReadableStream<Uint8Array>, options?: AtomicDataWriteOptions): Promise<void>;
+    writeTextIfUnchanged(normalizedPath: string, data: string, expected: string | null, options?: DataWriteOptions): Promise<void>;
     write(normalizedPath: string, data: string, options?: DataWriteOptions): Promise<void>;
     writeBinary(normalizedPath: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
     append(normalizedPath: string, data: string, options?: DataWriteOptions): Promise<void>;
@@ -169,7 +171,7 @@ export declare class NativeDesktopVaultAdapter implements VaultAdapter, VaultIde
     copy(normalizedPath: string, normalizedNewPath: string): Promise<void>;
     getResourcePath(normalizedPath: string): string;
     getResourceUrl(normalizedPath: string): Promise<string>;
-    trashSystem(): Promise<boolean>;
+    trashSystem(normalizedPath: string): Promise<boolean>;
     trashLocal(normalizedPath: string): Promise<void>;
 }
 export declare function pickNativeDesktopVault(options?: NativeVaultOptions): Promise<{

package/dist/storage/desktop-native.js

@@ -237,13 +237,15 @@ export class NativeDesktopVaultAdapter {
     }
     getCapabilities() {
         return {
+            exclusiveCreate: hasNativeDesktopCapability("exclusive-create"),
+            conditionalTextWrite: hasNativeDesktopCapability("conditional-text-write"),
             persistent: true,
             userVisibleFiles: true,
             requiresPermission: false,
             nativeWatch: hasNativeDesktopCapability("file-watch") ||
                 typeof getNativeDesktopBridge()?.watch === "function",
             resourceUrls: true,
-            systemTrash: false,
+            systemTrash: hasNativeDesktopCapability("system-trash"),
         };
     }
     watch(normalizedPath, options, listener) {
@@ -251,9 +253,15 @@ export class NativeDesktopVaultAdapter {
             const subscriptions = normalizedPath
                 .map((path) => this.watch(path, options, listener))
                 .filter((subscription) => Boolean(subscription));
+            const ready = Promise.all(subscriptions.map((subscription) => subscription.ready)).then(() => { });
+            void ready.catch(() => { });
             return {
-                close: () => {
-                    subscriptions.forEach((subscription) => subscription.close());
+                ready,
+                close: async () => {
+                    const results = await Promise.allSettled(subscriptions.map(async (subscription) => subscription.close()));
+                    const failed = results.find((result) => result.status === "rejected");
+                    if (failed?.status === "rejected")
+                        throw failed.reason;
                 },
             };
         }
@@ -284,6 +292,20 @@ export class NativeDesktopVaultAdapter {
         });
         return new Uint8Array(data).buffer;
     }
+    async writeExclusive(normalizedPath, data, options = {}) {
+        const path = normalizeVaultPath(normalizedPath);
+        if (!hasNativeDesktopCapability("exclusive-create"))
+            throw createFsError("ENOTSUP", "Exclusive file creation is unavailable");
+        const bytes = typeof data === "string"
+            ? new TextEncoder().encode(data)
+            : new Uint8Array(data);
+        await invokeNative("desktop_fs_create_exclusive", {
+            rootPath: this.rootPath,
+            normalizedPath: path,
+            data: [...bytes],
+            options,
+        });
+    }
     async openRead(normalizedPath) {
         const path = normalizeVaultPath(normalizedPath);
         const rootPath = this.rootPath;
@@ -335,7 +357,7 @@ export class NativeDesktopVaultAdapter {
         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)
@@ -365,6 +387,19 @@ export class NativeDesktopVaultAdapter {
             reader.releaseLock();
         }
     }
+    async writeTextIfUnchanged(normalizedPath, data, expected, options) {
+        if (expected !== null && typeof expected !== "string")
+            throw new Error("Invalid expected text snapshot");
+        if (!hasNativeDesktopCapability("conditional-text-write"))
+            throw new Error("Conditional text writes are unavailable in this native host");
+        await invokeNative("desktop_fs_write_text_if_unchanged", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            data,
+            expected,
+            options,
+        });
+    }
     async write(normalizedPath, data, options) {
         await invokeNative("desktop_fs_write_text", {
             rootPath: this.rootPath,
@@ -458,8 +493,26 @@ export class NativeDesktopVaultAdapter {
         }
         return this.getResourcePath(normalizedPath);
     }
-    async trashSystem() {
-        return false;
+    async trashSystem(normalizedPath) {
+        const path = normalizeVaultPath(normalizedPath);
+        if (path === "/")
+            throw createFsError("EINVAL", "Cannot trash the vault root");
+        if (!hasNativeDesktopCapability("system-trash"))
+            return false;
+        try {
+            const handled = await invokeNative("desktop_fs_trash_system", {
+                rootPath: this.rootPath,
+                normalizedPath: path,
+            });
+            if (typeof handled !== "boolean")
+                throw createFsError("EINVAL", "Invalid native trash acknowledgement");
+            return handled;
+        }
+        catch (error) {
+            if (error?.code === "ENOTSUP")
+                return false;
+            throw error;
+        }
     }
     async trashLocal(normalizedPath) {
         const path = normalizeVaultPath(normalizedPath);

package/dist/storage/directory-watcher.d.ts

@@ -0,0 +1,27 @@
+import { EventDispatcher } from "../events";
+import type { ChangeEvent, DataAdapter, NativeWatchSubscription, WatchErrorEvent, WatchOptions } from "./fs";
+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;
+    private retired;
+    constructor(adapter: DataAdapter, pollingInterval?: number);
+    watch(path: string | string[], options?: WatchOptions): NativeWatchSubscription;
+    unwatch(path: string): Promise<void>;
+    close(): Promise<void>;
+    private live;
+    private retire;
+    private deliver;
+    private eventPath;
+    private snapshot;
+    private poll;
+}

package/dist/storage/directory-watcher.js

@@ -0,0 +1,201 @@
+import { EventDispatcher } from "../events";
+import { joinPath, normalizePath } from "./path";
+async function drain(operations) {
+    const results = await Promise.allSettled(operations);
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed?.status === "rejected")
+        throw failed.reason;
+}
+export class DirectoryWatcher extends EventDispatcher {
+    adapter;
+    pollingInterval;
+    watchers = new Map();
+    retired = new Set();
+    constructor(adapter, pollingInterval = 5000) {
+        super();
+        this.adapter = adapter;
+        this.pollingInterval = pollingInterval;
+    }
+    watch(path, options = {}) {
+        if (Array.isArray(path)) {
+            const subscriptions = path.map((entry) => this.watch(entry, options));
+            const ready = Promise.all(subscriptions.map((entry) => entry.ready)).then(() => { });
+            void ready.catch(() => { });
+            return {
+                ready,
+                close: () => drain(subscriptions.map(async (entry) => entry.close())),
+            };
+        }
+        path = normalizePath(path);
+        const previous = this.watchers.get(path);
+        if (previous)
+            void this.retire(previous).catch(() => { });
+        const state = {
+            path,
+            recursive: options.recursive ?? false,
+            interval: options.interval ?? this.pollingInterval,
+            active: true,
+            registering: false,
+            snapshot: null,
+            timeout: null,
+            native: null,
+            pending: Promise.resolve(),
+        };
+        this.watchers.set(path, state);
+        let ready = Promise.resolve();
+        const adapter = this.adapter;
+        if (typeof adapter.watch === "function" &&
+            adapter.getCapabilities?.().nativeWatch === true) {
+            state.registering = true;
+            try {
+                state.native =
+                    adapter.watch(path, options, (event) => {
+                        if (!this.live(state))
+                            return;
+                        this.deliver(event.type === "error"
+                            ? { ...event, path: this.eventPath(event.path) }
+                            : {
+                                ...event,
+                                path: this.eventPath(event.path),
+                                ...(event.previousPath === undefined
+                                    ? {}
+                                    : { previousPath: this.eventPath(event.previousPath) }),
+                            });
+                    }) ?? null;
+                ready = state.native?.ready ?? ready;
+            }
+            catch (error) {
+                state.active = false;
+                if (this.watchers.get(path) === state)
+                    this.watchers.delete(path);
+                throw error;
+            }
+            finally {
+                state.registering = false;
+            }
+        }
+        else {
+            state.pending = this.poll(state);
+            ready = state.pending;
+        }
+        void ready.catch(() => { });
+        return { ready, close: () => this.retire(state) };
+    }
+    unwatch(path) {
+        path = normalizePath(path);
+        return drain([...new Set([...this.watchers.values(), ...this.retired])]
+            .filter((state) => state.path === path)
+            .map((state) => this.retire(state)));
+    }
+    close() {
+        return drain([...new Set([...this.watchers.values(), ...this.retired])].map((state) => this.retire(state)));
+    }
+    live(state) {
+        return state.active && this.watchers.get(state.path) === state;
+    }
+    retire(state) {
+        state.active = false;
+        if (this.watchers.get(state.path) === state)
+            this.watchers.delete(state.path);
+        if (state.timeout)
+            clearTimeout(state.timeout);
+        state.timeout = null;
+        if (state.closing)
+            return state.closing;
+        this.retired.add(state);
+        let cleanup;
+        try {
+            cleanup = state.registering
+                ? Promise.resolve().then(() => state.native?.close())
+                : state.native?.close();
+        }
+        catch (error) {
+            cleanup = Promise.reject(error);
+        }
+        state.closing = drain([state.pending, cleanup]).then(() => {
+            this.retired.delete(state);
+        });
+        void state.closing.catch(() => {
+            state.closing = undefined;
+        });
+        return state.closing;
+    }
+    deliver(event) {
+        this.dispatch("all", event);
+        if (event.type === "error")
+            this.dispatch("error", { error: event.error, path: event.path });
+        else
+            this.dispatch(event.type, event.path);
+    }
+    eventPath(path) {
+        const normalized = normalizePath(path);
+        return normalized === "/" ? "/" : normalized.replace(/^\/+/, "");
+    }
+    async snapshot(path, recursive) {
+        const snapshot = new Map();
+        const stats = await this.adapter.stat(path);
+        if (!stats)
+            return snapshot;
+        snapshot.set(this.eventPath(path), stats);
+        if (stats.type !== "folder")
+            return snapshot;
+        const { files, folders } = await this.adapter.list(path);
+        for (const file of files) {
+            const entry = joinPath(path, file);
+            const stat = await this.adapter.stat(entry);
+            if (stat)
+                snapshot.set(this.eventPath(entry), stat);
+        }
+        for (const folder of folders) {
+            const entry = joinPath(path, folder);
+            if (recursive) {
+                for (const [key, stat] of await this.snapshot(entry, true))
+                    snapshot.set(key, stat);
+            }
+            else {
+                const stat = await this.adapter.stat(entry);
+                if (stat)
+                    snapshot.set(this.eventPath(entry), stat);
+            }
+        }
+        return snapshot;
+    }
+    async poll(state) {
+        try {
+            const next = await this.snapshot(state.path, state.recursive);
+            if (!this.live(state))
+                return;
+            if (state.snapshot) {
+                const changes = [];
+                for (const [path, stat] of next) {
+                    const previous = state.snapshot.get(path);
+                    if (!previous)
+                        changes.push({ type: "create", path });
+                    else if (previous.mtime !== stat.mtime ||
+                        previous.size !== stat.size ||
+                        previous.type !== stat.type)
+                        changes.push({ type: "modify", path });
+                }
+                for (const path of state.snapshot.keys())
+                    if (!next.has(path))
+                        changes.push({ type: "delete", path });
+                for (const event of changes) {
+                    if (!this.live(state))
+                        break;
+                    this.deliver(event);
+                }
+            }
+            state.snapshot = next;
+        }
+        catch (error) {
+            if (this.live(state))
+                this.deliver({ type: "error", path: state.path, error });
+        }
+        finally {
+            if (this.live(state))
+                state.timeout = setTimeout(() => {
+                    state.pending = this.poll(state);
+                }, state.interval);
+        }
+    }
+}

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 {};