@interocitor/core 0.0.0-beta.10

package/dist/adapters/google-drive.js

@@ -0,0 +1,339 @@
+/**
+ * Google Drive Storage Adapter
+ *
+ * Uses Google Drive API v3 via OAuth2 with `drive.file` scope.
+ * The app can only see files it created or the user explicitly shared.
+ *
+ * Requires: Google API client ID from Google Cloud Console.
+ * Auth flow: Google Identity Services (GIS) popup or redirect.
+ */
+const SCOPES = 'https://www.googleapis.com/auth/drive.file';
+const DRIVE_API = 'https://www.googleapis.com/drive/v3';
+const UPLOAD_API = 'https://www.googleapis.com/upload/drive/v3';
+/**
+ * Google Drive adapter using the browser OAuth token flow.
+ *
+ * This is the easiest zero-infrastructure option when your users already live
+ * in Google Workspace or personal Drive.
+ *
+ * @example
+ * ```ts
+ * const adapter = new GoogleDriveAdapter({ clientId: 'YOUR_GOOGLE_CLIENT_ID' });
+ * const engine = new Interocitor(adapter, { remotePath: '/MyApp' });
+ * ```
+ */
+export class GoogleDriveAdapter {
+    constructor(config) {
+        this.name = 'google-drive';
+        this.accessToken = null;
+        // Cache: path → Google Drive file ID
+        this.fileIdCache = new Map();
+        this.folderIdCache = new Map();
+        this.config = config;
+    }
+    // ── Auth ─────────────────────────────────────────────────────────
+    async authenticate() {
+        // Google Identity Services (GIS) token model
+        // In production, use google.accounts.oauth2.initTokenClient
+        // This is a simplified version using the implicit grant flow
+        return new Promise((resolve) => {
+            const params = new URLSearchParams({
+                client_id: this.config.clientId,
+                redirect_uri: this.config.redirectUri || window.location.origin,
+                response_type: 'token',
+                scope: SCOPES,
+                include_granted_scopes: 'true',
+            });
+            const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?${params}`;
+            // Check if we already have a token from a redirect
+            const hash = window.location.hash;
+            if (hash.includes('access_token=')) {
+                const tokenMatch = hash.match(/access_token=([^&]+)/);
+                if (tokenMatch) {
+                    this.accessToken = decodeURIComponent(tokenMatch[1]);
+                    // Clean the URL
+                    window.history.replaceState(null, '', window.location.pathname);
+                    resolve();
+                    return;
+                }
+            }
+            // Check localStorage for cached token
+            const cached = localStorage.getItem('gdrive-access-token');
+            if (cached) {
+                this.accessToken = cached;
+                // Verify token is still valid
+                this.verifyToken().then(valid => {
+                    if (valid) {
+                        resolve();
+                    }
+                    else {
+                        localStorage.removeItem('gdrive-access-token');
+                        window.location.href = authUrl;
+                    }
+                });
+                return;
+            }
+            // Redirect to Google OAuth
+            window.location.href = authUrl;
+        });
+    }
+    /** Set token directly (for apps that handle their own OAuth flow). */
+    setAccessToken(token) {
+        this.accessToken = token;
+        localStorage.setItem('gdrive-access-token', token);
+    }
+    /**
+     * Returns the Google OAuth clientId for embedding in a QR payload.
+     * The scanner uses this to configure their GoogleDriveAdapter.
+     * The OAuth flow (and resulting access token) is performed separately by the user.
+     */
+    getHandshakeConfig() {
+        return JSON.stringify({ clientId: this.config.clientId });
+    }
+    isAuthenticated() {
+        return this.accessToken !== null;
+    }
+    async verifyToken() {
+        try {
+            const res = await fetch(`${DRIVE_API}/about?fields=user`, {
+                headers: { Authorization: `Bearer ${this.accessToken}` },
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    headers() {
+        if (!this.accessToken)
+            throw new Error('Not authenticated');
+        return { Authorization: `Bearer ${this.accessToken}` };
+    }
+    // ── File ID resolution ───────────────────────────────────────────
+    /**
+     * Resolve a path like "/Interocitor/changes/dev_abc.ndjson"
+     * to a Google Drive file ID by walking the folder tree.
+     */
+    async resolveFileId(path) {
+        if (this.fileIdCache.has(path))
+            return this.fileIdCache.get(path);
+        const parts = path.split('/').filter(Boolean);
+        let parentId = 'root';
+        for (let i = 0; i < parts.length; i++) {
+            const name = parts[i];
+            const isLast = i === parts.length - 1;
+            const cacheKey = '/' + parts.slice(0, i + 1).join('/');
+            if (this.folderIdCache.has(cacheKey)) {
+                parentId = this.folderIdCache.get(cacheKey);
+                continue;
+            }
+            if (isLast && this.fileIdCache.has(cacheKey)) {
+                return this.fileIdCache.get(cacheKey);
+            }
+            const mimeFilter = isLast ? '' : " and mimeType='application/vnd.google-apps.folder'";
+            const q = `name='${name}' and '${parentId}' in parents and trashed=false${mimeFilter}`;
+            const res = await fetch(`${DRIVE_API}/files?q=${encodeURIComponent(q)}&fields=files(id,name)`, { headers: this.headers() });
+            const data = await res.json();
+            if (!data.files || data.files.length === 0)
+                return null;
+            const fileId = data.files[0].id;
+            if (isLast) {
+                this.fileIdCache.set(path, fileId);
+            }
+            else {
+                this.folderIdCache.set(cacheKey, fileId);
+            }
+            parentId = fileId;
+        }
+        return parentId;
+    }
+    async resolveFolderId(path) {
+        if (this.folderIdCache.has(path))
+            return this.folderIdCache.get(path);
+        const parts = path.split('/').filter(Boolean);
+        let parentId = 'root';
+        for (let i = 0; i < parts.length; i++) {
+            const name = parts[i];
+            const cacheKey = '/' + parts.slice(0, i + 1).join('/');
+            if (this.folderIdCache.has(cacheKey)) {
+                parentId = this.folderIdCache.get(cacheKey);
+                continue;
+            }
+            const q = `name='${name}' and '${parentId}' in parents and trashed=false and mimeType='application/vnd.google-apps.folder'`;
+            const res = await fetch(`${DRIVE_API}/files?q=${encodeURIComponent(q)}&fields=files(id)`, { headers: this.headers() });
+            const data = await res.json();
+            if (!data.files || data.files.length === 0)
+                return null;
+            parentId = data.files[0].id;
+            this.folderIdCache.set(cacheKey, parentId);
+        }
+        return parentId;
+    }
+    // ── StorageAdapter interface ───────────────────────────────────────
+    async ensureFolder(path) {
+        const parts = path.split('/').filter(Boolean);
+        let parentId = 'root';
+        for (let i = 0; i < parts.length; i++) {
+            const name = parts[i];
+            const cacheKey = '/' + parts.slice(0, i + 1).join('/');
+            if (this.folderIdCache.has(cacheKey)) {
+                parentId = this.folderIdCache.get(cacheKey);
+                continue;
+            }
+            // Check if exists
+            const q = `name='${name}' and '${parentId}' in parents and trashed=false and mimeType='application/vnd.google-apps.folder'`;
+            const res = await fetch(`${DRIVE_API}/files?q=${encodeURIComponent(q)}&fields=files(id)`, { headers: this.headers() });
+            const data = await res.json();
+            if (data.files && data.files.length > 0) {
+                parentId = data.files[0].id;
+            }
+            else {
+                // Create folder
+                const createRes = await fetch(`${DRIVE_API}/files`, {
+                    method: 'POST',
+                    headers: {
+                        ...this.headers(),
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        name,
+                        mimeType: 'application/vnd.google-apps.folder',
+                        parents: [parentId],
+                    }),
+                });
+                const created = await createRes.json();
+                parentId = created.id;
+            }
+            this.folderIdCache.set(cacheKey, parentId);
+        }
+    }
+    async listFiles(folderPath) {
+        const folderId = await this.resolveFolderId(folderPath);
+        if (!folderId)
+            return [];
+        const q = `'${folderId}' in parents and trashed=false and mimeType!='application/vnd.google-apps.folder'`;
+        const fields = 'files(id,name,size,modifiedTime)';
+        const res = await fetch(`${DRIVE_API}/files?q=${encodeURIComponent(q)}&fields=${fields}`, { headers: this.headers() });
+        const data = await res.json();
+        return (data.files || []).map((f) => {
+            const path = `${folderPath}/${f.name}`;
+            this.fileIdCache.set(path, f.id);
+            return {
+                name: f.name,
+                path,
+                size: parseInt(f.size ?? '0', 10),
+                modifiedTime: f.modifiedTime,
+            };
+        });
+    }
+    async listFolders(folderPath) {
+        const folderId = await this.resolveFolderId(folderPath);
+        if (!folderId)
+            return [];
+        const q = `'${folderId}' in parents and trashed=false and mimeType='application/vnd.google-apps.folder'`;
+        const fields = 'files(name)';
+        const res = await fetch(`${DRIVE_API}/files?q=${encodeURIComponent(q)}&fields=${fields}`, { headers: this.headers() });
+        const data = await res.json();
+        return (data.files || []).map((f) => f.name);
+    }
+    async readFile(path) {
+        const fileId = await this.resolveFileId(path);
+        if (!fileId)
+            throw new Error(`File not found: ${path}`);
+        const res = await fetch(`${DRIVE_API}/files/${fileId}?alt=media`, { headers: this.headers() });
+        if (!res.ok)
+            throw new Error(`Failed to read ${path}: ${res.status}`);
+        const buffer = await res.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    async writeFile(path, data) {
+        const bytes = typeof data === 'string'
+            ? new TextEncoder().encode(data)
+            : data;
+        const existingId = await this.resolveFileId(path);
+        if (existingId) {
+            // Update existing file
+            const res = await fetch(`${UPLOAD_API}/files/${existingId}?uploadType=media`, {
+                method: 'PATCH',
+                headers: {
+                    ...this.headers(),
+                    'Content-Type': 'application/octet-stream',
+                },
+                body: bytes,
+            });
+            if (!res.ok)
+                throw new Error(`Failed to write ${path}: ${res.status}`);
+        }
+        else {
+            // Create new file
+            const parts = path.split('/').filter(Boolean);
+            const fileName = parts.pop();
+            const parentPath = '/' + parts.join('/');
+            let parentId = await this.resolveFolderId(parentPath);
+            if (!parentId) {
+                await this.ensureFolder(parentPath);
+                parentId = await this.resolveFolderId(parentPath);
+            }
+            const metadata = {
+                name: fileName,
+                parents: [parentId],
+            };
+            // Multipart upload
+            const boundary = 'interocitor_boundary';
+            const body = `--${boundary}\r\n` +
+                `Content-Type: application/json; charset=UTF-8\r\n\r\n` +
+                `${JSON.stringify(metadata)}\r\n` +
+                `--${boundary}\r\n` +
+                `Content-Type: application/octet-stream\r\n\r\n`;
+            const bodyEnd = `\r\n--${boundary}--`;
+            const bodyBytes = new TextEncoder().encode(body);
+            const endBytes = new TextEncoder().encode(bodyEnd);
+            const combined = new Uint8Array(bodyBytes.length + bytes.length + endBytes.length);
+            combined.set(bodyBytes, 0);
+            combined.set(bytes, bodyBytes.length);
+            combined.set(endBytes, bodyBytes.length + bytes.length);
+            const res = await fetch(`${UPLOAD_API}/files?uploadType=multipart`, {
+                method: 'POST',
+                headers: {
+                    ...this.headers(),
+                    'Content-Type': `multipart/related; boundary=${boundary}`,
+                },
+                body: combined,
+            });
+            if (!res.ok)
+                throw new Error(`Failed to create ${path}: ${res.status}`);
+            const created = await res.json();
+            this.fileIdCache.set(path, created.id);
+        }
+    }
+    async deleteFile(path) {
+        const fileId = await this.resolveFileId(path);
+        if (!fileId)
+            return;
+        await fetch(`${DRIVE_API}/files/${fileId}`, {
+            method: 'DELETE',
+            headers: this.headers(),
+        });
+        this.fileIdCache.delete(path);
+    }
+    async getFileMetadata(path) {
+        const fileId = await this.resolveFileId(path);
+        if (!fileId)
+            return null;
+        const res = await fetch(`${DRIVE_API}/files/${fileId}?fields=id,name,size,modifiedTime`, { headers: this.headers() });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return {
+            name: data.name,
+            path,
+            size: parseInt(data.size ?? '0', 10),
+            modifiedTime: data.modifiedTime,
+        };
+    }
+    /** Clear caches (useful after compaction deletes files). */
+    clearCache() {
+        this.fileIdCache.clear();
+        this.folderIdCache.clear();
+    }
+}

package/dist/adapters/memory.d.ts

@@ -0,0 +1,53 @@
+/**
+ * In-Memory Storage Adapter
+ *
+ * For testing and development. No network, no persistence.
+ * Also serves as a reference implementation for the StorageAdapter interface.
+ */
+import type { StorageAdapter, FileEntry, StoredFileMetadata, StoredFileWriteOptions } from '../core/types.ts';
+/**
+ * In-memory implementation of {@link StorageAdapter}.
+ *
+ * Useful for tests, demos, and local experiments where persistence is not
+ * required.
+ *
+ * @example
+ * ```ts
+ * const adapter = new MemoryAdapter();
+ * const engine = new Interocitor(adapter, { remotePath: '/Demo' });
+ * ```
+ */
+export declare class MemoryAdapter implements StorageAdapter {
+    readonly name = "memory";
+    private files;
+    private storedFileMetadata;
+    private folders;
+    private authenticated;
+    private ensuredFolders;
+    authenticate(): Promise<void>;
+    /**
+     * Memory adapter has no real backend — returns an empty config.
+     * Only useful in tests where both sides share the same in-memory store.
+     */
+    getHandshakeConfig(): string;
+    isAuthenticated(): boolean;
+    ensureFolder(path: string): Promise<void>;
+    /** Drop the per-session ensureFolder cache. Tests / mesh-swap callers. */
+    resetFolderCache(): void;
+    listFiles(folderPath: string): Promise<FileEntry[]>;
+    /** List immediate subfolder names under a path. */
+    listFolders(folderPath: string): Promise<string[]>;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array | string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    getFileMetadata(path: string): Promise<FileEntry | null>;
+    putStoredFile(path: string, data: Uint8Array | string, options?: StoredFileWriteOptions): Promise<StoredFileMetadata>;
+    getStoredFile(path: string): Promise<Uint8Array>;
+    deleteStoredFile(path: string): Promise<void>;
+    getStoredFileMetadata(path: string): Promise<StoredFileMetadata | null>;
+    /** Test helper: dump all files for inspection. */
+    dump(): Record<string, string>;
+    /** Test helper: reset all state. */
+    reset(): void;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/adapters/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/adapters/memory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE9G;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,QAAQ,CAAC,IAAI,YAAY;IAEzB,OAAO,CAAC,KAAK,CAAsE;IACnF,OAAO,CAAC,kBAAkB,CAA8C;IACxE,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,aAAa,CAAS;IAK9B,OAAO,CAAC,cAAc,CAA0B;IAE1C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC;;;OAGG;IACH,kBAAkB,IAAI,MAAM;IAI5B,eAAe,IAAI,OAAO;IAIpB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM/C,0EAA0E;IAC1E,gBAAgB,IAAI,IAAI;IAIlB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAsBzD,mDAAmD;IAC7C,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAuBlD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAM3C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUjE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAYxD,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAqBzH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAUhD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7C,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAO7E,kDAAkD;IAClD,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAS9B,oCAAoC;IACpC,KAAK,IAAI,IAAI;CAKd"}

package/dist/adapters/memory.js

@@ -0,0 +1,182 @@
+/**
+ * In-Memory Storage Adapter
+ *
+ * For testing and development. No network, no persistence.
+ * Also serves as a reference implementation for the StorageAdapter interface.
+ */
+/**
+ * In-memory implementation of {@link StorageAdapter}.
+ *
+ * Useful for tests, demos, and local experiments where persistence is not
+ * required.
+ *
+ * @example
+ * ```ts
+ * const adapter = new MemoryAdapter();
+ * const engine = new Interocitor(adapter, { remotePath: '/Demo' });
+ * ```
+ */
+export class MemoryAdapter {
+    constructor() {
+        this.name = 'memory';
+        this.files = new Map();
+        this.storedFileMetadata = new Map();
+        this.folders = new Set();
+        this.authenticated = false;
+        // Mirrors the cloud-adapter convention: cache "ensured" paths so a
+        // re-`ensureFolder` is a no-op. Memory adapter is cheap, but keeping
+        // the same shape lets tests assert call-count parity with the real
+        // adapters (cloudflare, webdav).
+        this.ensuredFolders = new Set();
+    }
+    async authenticate() {
+        this.authenticated = true;
+    }
+    /**
+     * Memory adapter has no real backend — returns an empty config.
+     * Only useful in tests where both sides share the same in-memory store.
+     */
+    getHandshakeConfig() {
+        return JSON.stringify({});
+    }
+    isAuthenticated() {
+        return this.authenticated;
+    }
+    async ensureFolder(path) {
+        if (this.ensuredFolders.has(path))
+            return;
+        this.folders.add(path);
+        this.ensuredFolders.add(path);
+    }
+    /** Drop the per-session ensureFolder cache. Tests / mesh-swap callers. */
+    resetFolderCache() {
+        this.ensuredFolders.clear();
+    }
+    async listFiles(folderPath) {
+        const prefix = folderPath.endsWith('/') ? folderPath : folderPath + '/';
+        const entries = [];
+        for (const [path, file] of this.files) {
+            if (path.startsWith(prefix)) {
+                const remaining = path.slice(prefix.length);
+                // Only direct children (no nested slashes)
+                if (!remaining.includes('/')) {
+                    entries.push({
+                        name: remaining,
+                        path,
+                        size: file.data.length,
+                        modifiedTime: file.modifiedTime,
+                    });
+                }
+            }
+        }
+        return entries;
+    }
+    /** List immediate subfolder names under a path. */
+    async listFolders(folderPath) {
+        const prefix = folderPath.endsWith('/') ? folderPath : folderPath + '/';
+        const names = new Set();
+        for (const path of this.files.keys()) {
+            if (path.startsWith(prefix)) {
+                const remaining = path.slice(prefix.length);
+                const slash = remaining.indexOf('/');
+                if (slash > 0) {
+                    names.add(remaining.slice(0, slash));
+                }
+            }
+        }
+        for (const folder of this.folders) {
+            if (folder.startsWith(prefix)) {
+                const remaining = folder.slice(prefix.length);
+                if (remaining && !remaining.includes('/')) {
+                    names.add(remaining);
+                }
+            }
+        }
+        return [...names];
+    }
+    async readFile(path) {
+        const file = this.files.get(path);
+        if (!file)
+            throw new Error(`File not found: ${path}`);
+        return file.data;
+    }
+    async writeFile(path, data) {
+        const bytes = typeof data === 'string'
+            ? new TextEncoder().encode(data)
+            : data;
+        this.files.set(path, {
+            data: bytes,
+            modifiedTime: new Date().toISOString(),
+        });
+    }
+    async deleteFile(path) {
+        this.files.delete(path);
+    }
+    async getFileMetadata(path) {
+        const file = this.files.get(path);
+        if (!file)
+            return null;
+        const name = path.split('/').pop() || path;
+        return {
+            name,
+            path,
+            size: file.data.length,
+            modifiedTime: file.modifiedTime,
+        };
+    }
+    async putStoredFile(path, data, options = {}) {
+        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        await this.writeFile(path, bytes);
+        const now = new Date().toISOString();
+        const meta = {
+            name: path.split('/').pop() || path,
+            path,
+            size: bytes.byteLength,
+            modifiedTime: now,
+            uploadedAt: now,
+            uploadedByDeviceId: options.uploadedByDeviceId,
+            plaintextSize: options.plaintextSize,
+            storedSize: bytes.byteLength,
+            contentType: options.contentType,
+            lastAccessedAt: undefined,
+            useCount: 0,
+        };
+        this.storedFileMetadata.set(path, meta);
+        return { ...meta };
+    }
+    async getStoredFile(path) {
+        const bytes = await this.readFile(path);
+        const meta = this.storedFileMetadata.get(path);
+        if (meta) {
+            const next = { ...meta, lastAccessedAt: new Date().toISOString(), useCount: (meta.useCount ?? 0) + 1 };
+            this.storedFileMetadata.set(path, next);
+        }
+        return bytes;
+    }
+    async deleteStoredFile(path) {
+        await this.deleteFile(path);
+        this.storedFileMetadata.delete(path);
+    }
+    async getStoredFileMetadata(path) {
+        const meta = this.storedFileMetadata.get(path);
+        if (meta)
+            return { ...meta };
+        const file = await this.getFileMetadata(path);
+        return file ? { ...file, storedSize: file.size } : null;
+    }
+    /** Test helper: dump all files for inspection. */
+    dump() {
+        const result = {};
+        const decoder = new TextDecoder();
+        for (const [path, file] of this.files) {
+            result[path] = decoder.decode(file.data);
+        }
+        return result;
+    }
+    /** Test helper: reset all state. */
+    reset() {
+        this.files.clear();
+        this.storedFileMetadata.clear();
+        this.folders.clear();
+    }
+}

package/dist/adapters/webdav.d.ts

@@ -0,0 +1,70 @@
+/**
+ * WebDAV Storage Adapter
+ *
+ * For self-hosted clouds: Nextcloud, ownCloud, or any WebDAV server.
+ * "My own cloud" option — user runs their own server.
+ *
+ * WebDAV is HTTP-based, works from any browser.
+ * Most implementations support Basic auth or Bearer tokens.
+ */
+import type { StorageAdapter, FileEntry, StoredFileMetadata, StoredFileWriteOptions } from '../core/types.ts';
+interface WebDAVConfig {
+    /** Base URL of the WebDAV endpoint, e.g. "https://cloud.example.com/remote.php/dav/files/username" */
+    baseUrl: string;
+    /** Auth: either { username, password } for Basic auth, or { token } for Bearer */
+    auth: {
+        username: string;
+        password: string;
+    } | {
+        token: string;
+    };
+}
+/**
+ * Browser-friendly WebDAV adapter for Nextcloud, ownCloud, and compatible DAV servers.
+ *
+ * @example
+ * ```ts
+ * const adapter = new WebDAVAdapter({
+ *   baseUrl: 'https://cloud.example.com/remote.php/dav/files/alice',
+ *   auth: { username: 'alice', password: 'APP_PASSWORD' },
+ * });
+ * ```
+ */
+export declare class WebDAVAdapter implements StorageAdapter {
+    readonly name = "webdav";
+    private config;
+    private authenticated;
+    private ensuredFolders;
+    constructor(config: WebDAVConfig);
+    private url;
+    private authHeader;
+    private headers;
+    authenticate(): Promise<void>;
+    /**
+     * Returns the WebDAV base URL (without credentials) for embedding in a QR payload.
+     * The scanner uses this to point their WebDAVAdapter at the same server.
+     * Auth (username/password or token) must be configured separately by the user.
+     */
+    getHandshakeConfig(): string;
+    isAuthenticated(): boolean;
+    ensureFolder(path: string): Promise<void>;
+    /** Drop the per-session ensureFolder cache. Call after mesh swap, poison,
+     *  or any state where we cannot trust a previous "this folder exists"
+     *  observation. */
+    resetFolderCache(): void;
+    listFiles(folderPath: string): Promise<FileEntry[]>;
+    private parsePropfindResponse;
+    listFolders(folderPath: string): Promise<string[]>;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array | string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    private parentDir;
+    private storedMetaPath;
+    putStoredFile(path: string, data: Uint8Array | string, options?: StoredFileWriteOptions): Promise<StoredFileMetadata>;
+    getStoredFile(path: string): Promise<Uint8Array>;
+    deleteStoredFile(path: string): Promise<void>;
+    getStoredFileMetadata(path: string): Promise<StoredFileMetadata | null>;
+    getFileMetadata(path: string): Promise<FileEntry | null>;
+}
+export {};
+//# sourceMappingURL=webdav.d.ts.map

package/dist/adapters/webdav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webdav.d.ts","sourceRoot":"","sources":["../../src/adapters/webdav.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE9G,UAAU,YAAY;IACpB,sGAAsG;IACtG,OAAO,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAClE;AAED;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,QAAQ,CAAC,IAAI,YAAY;IAEzB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,aAAa,CAAS;IAM9B,OAAO,CAAC,cAAc,CAA0B;gBAEpC,MAAM,EAAE,YAAY;IAIhC,OAAO,CAAC,GAAG;IAMX,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,OAAO;IAOT,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBnC;;;;OAIG;IACH,kBAAkB,IAAI,MAAM;IAI5B,eAAe,IAAI,OAAO;IAIpB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB/C;;uBAEmB;IACnB,gBAAgB,IAAI,IAAI;IAIlB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IA0BzD,OAAO,CAAC,qBAAqB;IAoCvB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmClD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAY3C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBjE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY7C,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,cAAc;IAIhB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuBzH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAahD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7C,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAUvE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;CAyC/D"}