@lapis-notes/api 0.1.0

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

@@ -0,0 +1,184 @@
+/**
+ * Desktop-neutral native bridge for Lapis Notes desktop hosts.
+ *
+ * The Deno shell registers its host bridge before mounting the workspace, and
+ * shared storage/session code in `packages/api` picks it up through
+ * `getNativeDesktopBridge()` / `hasNativeDesktopBridge()`.
+ */
+import type { AppDatabaseChangeSet, AppDatabaseNotificationSeverity } from "./app-database";
+import type { ChangeEvent, AsyncResourceAdapter, DataWriteOptions, ListedFiles, NativeWatchAdapter, NativeWatchSubscription, Stat, VaultAdapter, VaultAdapterCapabilities, VaultIdentityAdapter, WatchErrorEvent, WatchOptions } from "./fs";
+import { type KeyValueStore, type VaultProfile } from "./vault-state";
+export type NativeDesktopRuntime = "deno-desktop";
+export type NativeDesktopPlatformOs = "macos" | "windows" | "linux" | "unknown";
+export interface NativeDesktopPlatformInfo {
+    readonly runtime: NativeDesktopRuntime;
+    readonly os: NativeDesktopPlatformOs;
+    readonly arch: string;
+    readonly runtimeVersion?: string;
+    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" | "agent-runtime" | "terminal-runtime";
+export type NativeAgentProcessMessage = {
+    processId: string;
+    type: "stdout" | "stderr" | "exit";
+    data?: string;
+    exitCode?: number;
+};
+export type NativeAgentRuntimeEvent = {
+    sessionId: string;
+    runId: string;
+    sequence: number;
+    event: {
+        type: "event" | "permission" | "closed";
+        event?: Record<string, unknown>;
+        request?: Record<string, unknown>;
+    };
+};
+export type NativeAgentRunSnapshot = {
+    sessionId: string;
+    runId?: string;
+    sequence: number;
+    state: "idle" | "running" | "terminal";
+    events?: NativeAgentRuntimeEvent[];
+    terminalEvent?: NativeAgentRuntimeEvent;
+};
+export type NativeAgentToolCall = {
+    bridgeId: string;
+    bindingId: string;
+    callId: string;
+    name: string;
+    input: unknown;
+};
+export type NativeAgentToolCancel = Pick<NativeAgentToolCall, "bridgeId" | "bindingId" | "callId">;
+export type NativeTerminalOutputEvent = {
+    sessionId: string;
+    data: string;
+};
+export type NativeTerminalExitEvent = {
+    sessionId: string;
+    code: number | null;
+};
+export type NativeAppDatabaseChangeEvent = {
+    vaultId: string;
+    change: AppDatabaseChangeSet;
+};
+export type NativeDesktopCapabilityStatus = "available" | "unavailable";
+export interface NativeDesktopCapability {
+    readonly id: NativeDesktopCapabilityId;
+    readonly status: NativeDesktopCapabilityStatus;
+    readonly provider?: string;
+    readonly details?: Record<string, string | number | boolean | null>;
+}
+export type NativeDesktopCapabilityRegistry = Partial<Record<NativeDesktopCapabilityId, NativeDesktopCapability>>;
+/**
+ * The native bridge interface implemented and registered by the Deno desktop
+ * host through `setNativeDesktopBridge`.
+ */
+export interface NativeDesktopBridge {
+    readonly runtime: NativeDesktopRuntime;
+    readonly platform?: NativeDesktopPlatformInfo;
+    readonly capabilities?: NativeDesktopCapabilityRegistry;
+    invoke<T>(command: string, payload?: Record<string, unknown>): Promise<T>;
+    toFileUrl(path: string): string;
+    getResourceUrl?(rootPath: string, normalizedPath: string): Promise<string>;
+    showNotification?(payload: NativeDesktopNotificationPayload): Promise<void>;
+    startDragging?(): Promise<void>;
+    onOpenVaultPicker?(listener: () => void): () => void;
+    onAppUrlOpen?(listener: (url: string) => void): () => void;
+    onAgentProcessMessage?(listener: (event: NativeAgentProcessMessage) => void): () => void;
+    onAgentRuntimeEvent?(listener: (event: NativeAgentRuntimeEvent) => void): () => void;
+    onAgentToolCall?(listener: (event: NativeAgentToolCall) => void): () => void;
+    onAgentToolCancel?(listener: (event: NativeAgentToolCancel) => void): () => void;
+    onTerminalOutput?(listener: (event: NativeTerminalOutputEvent) => void): () => void;
+    onTerminalExit?(listener: (event: NativeTerminalExitEvent) => void): () => void;
+    onAppDatabaseChange?(listener: (event: NativeAppDatabaseChangeEvent) => void): () => void;
+    watch?(rootPath: string, normalizedPath: string, options: WatchOptions, listener: (event: ChangeEvent | WatchErrorEvent) => void): NativeWatchSubscription | void;
+}
+export interface NativeVaultSelection {
+    path: string;
+    name: string;
+}
+export interface NativeVaultHandle {
+    rootPath: string;
+}
+export interface NativeVaultOptions {
+    vaultId?: string;
+    name?: string;
+    stateStore?: KeyValueStore;
+}
+declare global {
+    var __LAPIS_NATIVE_DESKTOP__: NativeDesktopBridge | undefined;
+}
+export declare function getNativeDesktopBridge(): NativeDesktopBridge | null;
+export interface NativeDesktopNotificationPayload {
+    readonly id: string;
+    readonly title?: string;
+    readonly message: string;
+    readonly severity: AppDatabaseNotificationSeverity;
+    readonly source?: string;
+}
+export declare function hasNativeDesktopBridge(): boolean;
+export declare function getNativeDesktopPlatform(): NativeDesktopPlatformInfo | null;
+export declare function getNativeDesktopCapabilities(): NativeDesktopCapabilityRegistry;
+export declare function getNativeDesktopCapability(id: NativeDesktopCapabilityId): NativeDesktopCapability | null;
+export declare function hasNativeDesktopCapability(id: NativeDesktopCapabilityId): boolean;
+export declare function setNativeDesktopBridge(bridge: NativeDesktopBridge | null): void;
+export declare function startNativeDesktopWindowDragging(): Promise<void>;
+export declare function showNativeDesktopNotification(payload: NativeDesktopNotificationPayload): Promise<void>;
+export declare function resolveNativeDesktopVaultPath(rootPath: string, normalizedPath: string): Promise<string | null>;
+export declare function resolveNativeDesktopVaultPathToRelative(rootPath: string, absolutePath: string): Promise<string | null>;
+export declare function openNativeDesktopVaultPath(rootPath: string, normalizedPath: string): Promise<void>;
+export declare function revealNativeDesktopVaultPath(rootPath: string, normalizedPath: string): Promise<void>;
+export declare function moveNativeDesktopVaultProfile(profile: VaultProfile, options?: {
+    stateStore?: KeyValueStore;
+}): Promise<VaultProfile | null>;
+export declare function removeStoredVaultProfile(profileId: string, options?: {
+    stateStore?: KeyValueStore;
+}): Promise<void>;
+export declare class NativeDesktopVaultAdapter implements VaultAdapter, VaultIdentityAdapter, AsyncResourceAdapter, NativeWatchAdapter {
+    readonly rootPath: string;
+    readonly runtime: NativeDesktopRuntime;
+    readonly vaultId: string;
+    readonly name: string;
+    constructor(rootPath: string, options?: NativeVaultOptions, runtime?: NativeDesktopRuntime);
+    static fromProfile(profile: VaultProfile, options?: NativeVaultOptions): Promise<NativeDesktopVaultAdapter>;
+    getName(): string;
+    getVaultId(): string;
+    getCapabilities(): Partial<VaultAdapterCapabilities>;
+    watch(normalizedPath: string | string[], options: WatchOptions, listener: (event: ChangeEvent | WatchErrorEvent) => void): NativeWatchSubscription | void;
+    exists(normalizedPath: string): Promise<boolean>;
+    stat(normalizedPath: string): Promise<Stat | null>;
+    read(normalizedPath: string): Promise<string>;
+    readBinary(normalizedPath: string): Promise<ArrayBuffer>;
+    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>;
+    appendBinary(normalizedPath: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
+    process(normalizedPath: string, fn: (data: string) => string, options?: DataWriteOptions): Promise<string>;
+    list(normalizedPath: string): Promise<ListedFiles>;
+    mkdir(normalizedPath: string, options?: Partial<{
+        recursive: boolean;
+        mode: string;
+    }>): Promise<void>;
+    rmdir(normalizedPath: string, recursive: boolean): Promise<void>;
+    remove(normalizedPath: string): Promise<void>;
+    rename(normalizedPath: string, normalizedNewPath: string): Promise<void>;
+    copy(normalizedPath: string, normalizedNewPath: string): Promise<void>;
+    getResourcePath(normalizedPath: string): string;
+    getResourceUrl(normalizedPath: string): Promise<string>;
+    trashSystem(): Promise<boolean>;
+    trashLocal(normalizedPath: string): Promise<void>;
+}
+export declare function pickNativeDesktopVault(options?: NativeVaultOptions): Promise<{
+    adapter: NativeDesktopVaultAdapter;
+    profile: VaultProfile;
+} | null>;
+export declare function createNativeDesktopVault(options?: NativeVaultOptions): Promise<{
+    adapter: NativeDesktopVaultAdapter;
+    profile: VaultProfile;
+} | null>;
+export declare function openNativeDesktopDemoVault(options?: NativeVaultOptions): Promise<{
+    adapter: NativeDesktopVaultAdapter;
+    profile: VaultProfile;
+} | null>;

package/dist/storage/desktop-native.js

@@ -0,0 +1,415 @@
+/**
+ * Desktop-neutral native bridge for Lapis Notes desktop hosts.
+ *
+ * The Deno shell registers its host bridge before mounting the workspace, and
+ * shared storage/session code in `packages/api` picks it up through
+ * `getNativeDesktopBridge()` / `hasNativeDesktopBridge()`.
+ */
+import { dirname, joinPath, normalizePath, basename } from "./path";
+import { deleteVaultProfile, getDefaultVaultStateStore, getVaultProfile, replaceVaultProfile, saveVaultProfile, } from "./vault-state";
+// ─── Bridge global ────────────────────────────────────────────────────────────
+const NATIVE_BRIDGE_GLOBAL = "__LAPIS_NATIVE_DESKTOP__";
+let registeredNativeDesktopBridge = null;
+// ─── Bridge registration ──────────────────────────────────────────────────────
+export function getNativeDesktopBridge() {
+    return (registeredNativeDesktopBridge ?? globalThis[NATIVE_BRIDGE_GLOBAL] ?? null);
+}
+export function hasNativeDesktopBridge() {
+    return getNativeDesktopBridge() !== null;
+}
+export function getNativeDesktopPlatform() {
+    return getNativeDesktopBridge()?.platform ?? null;
+}
+export function getNativeDesktopCapabilities() {
+    return getNativeDesktopBridge()?.capabilities ?? {};
+}
+export function getNativeDesktopCapability(id) {
+    return getNativeDesktopCapabilities()[id] ?? null;
+}
+export function hasNativeDesktopCapability(id) {
+    return getNativeDesktopCapability(id)?.status === "available";
+}
+export function setNativeDesktopBridge(bridge) {
+    registeredNativeDesktopBridge = bridge;
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, NATIVE_BRIDGE_GLOBAL);
+    if (bridge) {
+        if (!descriptor || descriptor.writable || descriptor.set) {
+            globalThis[NATIVE_BRIDGE_GLOBAL] = bridge;
+        }
+    }
+    else if (!descriptor || descriptor.configurable) {
+        delete globalThis[NATIVE_BRIDGE_GLOBAL];
+    }
+    else if (descriptor.writable || descriptor.set) {
+        globalThis[NATIVE_BRIDGE_GLOBAL] = undefined;
+    }
+}
+export async function startNativeDesktopWindowDragging() {
+    await getNativeDesktopBridge()?.startDragging?.();
+}
+export async function showNativeDesktopNotification(payload) {
+    if (!hasNativeDesktopCapability("notifications")) {
+        return;
+    }
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        return;
+    }
+    if (bridge.showNotification) {
+        await bridge.showNotification(payload);
+        return;
+    }
+    await bridge.invoke("desktop_notifications_show", { notification: payload });
+}
+export async function resolveNativeDesktopVaultPath(rootPath, normalizedPath) {
+    if (!hasNativeDesktopCapability("file-system-actions")) {
+        return null;
+    }
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        return null;
+    }
+    return bridge.invoke("desktop_fs_resolve_path", {
+        rootPath,
+        normalizedPath,
+    });
+}
+export async function resolveNativeDesktopVaultPathToRelative(rootPath, absolutePath) {
+    if (!hasNativeDesktopCapability("file-system-actions")) {
+        return null;
+    }
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        return null;
+    }
+    return bridge.invoke("desktop_fs_to_vault_path", {
+        rootPath,
+        absolutePath,
+    });
+}
+export async function openNativeDesktopVaultPath(rootPath, normalizedPath) {
+    const bridge = getNativeDesktopBridge();
+    if (!bridge || !hasNativeDesktopCapability("file-system-actions")) {
+        throw new Error("Native file actions are unavailable");
+    }
+    await bridge.invoke("desktop_fs_open_path", { rootPath, normalizedPath });
+}
+export async function revealNativeDesktopVaultPath(rootPath, normalizedPath) {
+    const bridge = getNativeDesktopBridge();
+    if (!bridge || !hasNativeDesktopCapability("file-system-actions")) {
+        throw new Error("Native file actions are unavailable");
+    }
+    await bridge.invoke("desktop_fs_reveal_path", { rootPath, normalizedPath });
+}
+export async function moveNativeDesktopVaultProfile(profile, options = {}) {
+    const rootPath = getVaultHandleRootPath(profile);
+    if (!rootPath) {
+        throw new Error("Stored desktop vault path is unavailable");
+    }
+    const selection = await invokeNative("desktop_move_vault_folder", {
+        path: rootPath,
+        vaultId: profile.id,
+    });
+    if (!selection) {
+        return null;
+    }
+    const nextProfile = {
+        ...profile,
+        id: buildVaultId(selection.path),
+        updatedAt: Date.now(),
+        handle: { rootPath: selection.path },
+    };
+    await replaceVaultProfile(profile.id, nextProfile, options.stateStore ?? getDefaultVaultStateStore());
+    return nextProfile;
+}
+export async function removeStoredVaultProfile(profileId, options = {}) {
+    await deleteVaultProfile(profileId, options.stateStore ?? getDefaultVaultStateStore());
+}
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+function createFsError(code, path) {
+    const error = new Error(`${code}: ${path}`);
+    error.code = code;
+    return error;
+}
+function toNativeError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    const message = typeof error === "string" ? error : String(error);
+    const match = /^([A-Z0-9_]+):\s*(.*)$/u.exec(message);
+    const wrapped = new Error(match?.[2] || message);
+    if (match) {
+        wrapped.code = match[1];
+    }
+    return wrapped;
+}
+function normalizeVaultPath(path) {
+    path = normalizePath(path);
+    if (path === "/" || !path)
+        return "/";
+    if (path.startsWith("../") || path === "..") {
+        throw createFsError("EINVAL", path);
+    }
+    return path.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function normalizeRootPath(rootPath) {
+    return rootPath.replace(/[\\/]+$/u, "");
+}
+function buildVaultId(rootPath) {
+    return `desktop-folder:${normalizeRootPath(rootPath).replace(/\\/gu, "/")}`;
+}
+function getVaultHandleRootPath(profile) {
+    const handle = profile.handle;
+    if (typeof handle === "string") {
+        return handle;
+    }
+    if (handle && typeof handle === "object" && "rootPath" in handle) {
+        return typeof handle.rootPath === "string" ? handle.rootPath : null;
+    }
+    return null;
+}
+function resolveAbsolutePath(rootPath, normalizedPath) {
+    const path = normalizeVaultPath(normalizedPath);
+    const basePath = normalizeRootPath(rootPath);
+    if (path === "/") {
+        return basePath;
+    }
+    const separator = rootPath.includes("\\") ? "\\" : "/";
+    return `${basePath}${separator}${path.split("/").join(separator)}`;
+}
+function requireBridge() {
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        throw new Error("Native desktop bridge is unavailable");
+    }
+    return bridge;
+}
+async function invokeNative(command, payload) {
+    try {
+        return await requireBridge().invoke(command, payload);
+    }
+    catch (error) {
+        throw toNativeError(error);
+    }
+}
+// ─── Vault adapter ────────────────────────────────────────────────────────────
+export class NativeDesktopVaultAdapter {
+    rootPath;
+    runtime;
+    vaultId;
+    name;
+    constructor(rootPath, options = {}, runtime = "deno-desktop") {
+        this.rootPath = rootPath;
+        this.runtime = runtime;
+        this.vaultId = options.vaultId ?? buildVaultId(rootPath);
+        this.name = options.name ?? basename(normalizeRootPath(rootPath));
+    }
+    static async fromProfile(profile, options = {}) {
+        const rootPath = getVaultHandleRootPath(profile);
+        if (!rootPath) {
+            throw new Error("Stored desktop vault path is unavailable");
+        }
+        const bridge = requireBridge();
+        const adapter = new NativeDesktopVaultAdapter(rootPath, {
+            ...options,
+            vaultId: options.vaultId ?? profile.id,
+            name: options.name ?? profile.name,
+        }, bridge.runtime);
+        const stat = await adapter.stat("/");
+        if (!stat || stat.type !== "folder") {
+            throw createFsError("ENOENT", rootPath);
+        }
+        return adapter;
+    }
+    getName() {
+        return this.name;
+    }
+    getVaultId() {
+        return this.vaultId;
+    }
+    getCapabilities() {
+        return {
+            persistent: true,
+            userVisibleFiles: true,
+            requiresPermission: false,
+            nativeWatch: hasNativeDesktopCapability("file-watch") ||
+                typeof getNativeDesktopBridge()?.watch === "function",
+            resourceUrls: true,
+            systemTrash: false,
+        };
+    }
+    watch(normalizedPath, options, listener) {
+        if (Array.isArray(normalizedPath)) {
+            const subscriptions = normalizedPath
+                .map((path) => this.watch(path, options, listener))
+                .filter((subscription) => Boolean(subscription));
+            return {
+                close: () => {
+                    subscriptions.forEach((subscription) => subscription.close());
+                },
+            };
+        }
+        return getNativeDesktopBridge()?.watch?.(this.rootPath, normalizeVaultPath(normalizedPath), options, listener);
+    }
+    async exists(normalizedPath) {
+        return invokeNative("desktop_fs_exists", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+        });
+    }
+    async stat(normalizedPath) {
+        return invokeNative("desktop_fs_stat", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+        });
+    }
+    async read(normalizedPath) {
+        return invokeNative("desktop_fs_read_text", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+        });
+    }
+    async readBinary(normalizedPath) {
+        const data = await invokeNative("desktop_fs_read_binary", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+        });
+        return new Uint8Array(data).buffer;
+    }
+    async write(normalizedPath, data, options) {
+        await invokeNative("desktop_fs_write_text", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            data,
+            options,
+        });
+    }
+    async writeBinary(normalizedPath, data, options) {
+        await invokeNative("desktop_fs_write_binary", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            data: [...new Uint8Array(data)],
+            options,
+        });
+    }
+    async append(normalizedPath, data, options) {
+        await invokeNative("desktop_fs_append_text", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            data,
+            options,
+        });
+    }
+    async appendBinary(normalizedPath, data, options) {
+        const current = await this.readBinary(normalizedPath).catch((error) => {
+            if (error.code === "ENOENT") {
+                return new ArrayBuffer(0);
+            }
+            throw error;
+        });
+        const previous = new Uint8Array(current);
+        const next = new Uint8Array(previous.byteLength + data.byteLength);
+        next.set(previous);
+        next.set(new Uint8Array(data), previous.byteLength);
+        await this.writeBinary(normalizedPath, next.buffer, options);
+    }
+    async process(normalizedPath, fn, options) {
+        const next = fn(await this.read(normalizedPath));
+        await this.write(normalizedPath, next, options);
+        return next;
+    }
+    async list(normalizedPath) {
+        return invokeNative("desktop_fs_list", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+        });
+    }
+    async mkdir(normalizedPath, options) {
+        await invokeNative("desktop_fs_mkdir", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            recursive: options?.recursive ?? false,
+        });
+    }
+    async rmdir(normalizedPath, recursive) {
+        await invokeNative("desktop_fs_rmdir", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            recursive,
+        });
+    }
+    async remove(normalizedPath) {
+        await invokeNative("desktop_fs_remove", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+        });
+    }
+    async rename(normalizedPath, normalizedNewPath) {
+        await invokeNative("desktop_fs_rename", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            normalizedNewPath: normalizeVaultPath(normalizedNewPath),
+        });
+    }
+    async copy(normalizedPath, normalizedNewPath) {
+        await invokeNative("desktop_fs_copy", {
+            rootPath: this.rootPath,
+            normalizedPath: normalizeVaultPath(normalizedPath),
+            normalizedNewPath: normalizeVaultPath(normalizedNewPath),
+        });
+    }
+    getResourcePath(normalizedPath) {
+        return requireBridge().toFileUrl(resolveAbsolutePath(this.rootPath, normalizedPath));
+    }
+    async getResourceUrl(normalizedPath) {
+        const path = normalizeVaultPath(normalizedPath);
+        const bridge = requireBridge();
+        if (bridge.getResourceUrl) {
+            return bridge.getResourceUrl(this.rootPath, path);
+        }
+        return this.getResourcePath(normalizedPath);
+    }
+    async trashSystem() {
+        return false;
+    }
+    async trashLocal(normalizedPath) {
+        const path = normalizeVaultPath(normalizedPath);
+        const trashPath = normalizeVaultPath(joinPath(".trash", path));
+        await this.mkdir(dirname(trashPath), { recursive: true }).catch(() => { });
+        await this.rename(path, trashPath);
+    }
+}
+// ─── Vault picker ─────────────────────────────────────────────────────────────
+async function selectNativeDesktopVault(command, options = {}) {
+    const bridge = requireBridge();
+    const selection = await invokeNative(command);
+    if (!selection) {
+        return null;
+    }
+    const adapter = new NativeDesktopVaultAdapter(selection.path, {
+        ...options,
+        name: options.name ?? selection.name,
+    }, bridge.runtime);
+    const now = Date.now();
+    const store = options.stateStore ?? getDefaultVaultStateStore();
+    const existingProfile = await getVaultProfile(adapter.getVaultId(), store);
+    const profile = {
+        id: adapter.getVaultId(),
+        name: adapter.getName(),
+        kind: "desktop-folder",
+        handle: { rootPath: selection.path },
+        createdAt: existingProfile?.createdAt ?? now,
+        updatedAt: now,
+    };
+    await saveVaultProfile(profile, store);
+    return { adapter, profile };
+}
+export async function pickNativeDesktopVault(options = {}) {
+    return selectNativeDesktopVault("desktop_pick_vault_folder", options);
+}
+export async function createNativeDesktopVault(options = {}) {
+    return selectNativeDesktopVault("desktop_create_vault_folder", options);
+}
+export async function openNativeDesktopDemoVault(options = {}) {
+    return selectNativeDesktopVault("desktop_open_demo_vault", options);
+}