@rgby/collab-core 1.0.1

package/dist/collab-provider.js

@@ -0,0 +1,1389 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { HocuspocusProvider, HocuspocusProviderWebsocket } from "@hocuspocus/provider";
+import * as Yjs from "yjs";
+import { IndexeddbPersistence } from "y-indexeddb";
+import { UploadQueueManager } from "./upload-queue.js";
+// Re-export Yjs as Y for compatibility
+export const Y = Yjs;
+export class LocalStorageAdapter {
+    getItem(key) {
+        try {
+            return localStorage.getItem(key);
+        }
+        catch {
+            return null;
+        }
+    }
+    setItem(key, value) {
+        try {
+            localStorage.setItem(key, value);
+        }
+        catch {
+            // Ignore errors (quota exceeded, etc.)
+        }
+    }
+    removeItem(key) {
+        try {
+            localStorage.removeItem(key);
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+}
+export class SessionStorageAdapter {
+    getItem(key) {
+        try {
+            return sessionStorage.getItem(key);
+        }
+        catch {
+            return null;
+        }
+    }
+    setItem(key, value) {
+        try {
+            sessionStorage.setItem(key, value);
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    removeItem(key) {
+        try {
+            sessionStorage.removeItem(key);
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+}
+export class MemoryStorageAdapter {
+    store = new Map();
+    getItem(key) {
+        return this.store.get(key) ?? null;
+    }
+    setItem(key, value) {
+        this.store.set(key, value);
+    }
+    removeItem(key) {
+        this.store.delete(key);
+    }
+}
+export class AuthManager {
+    baseUrl;
+    storage;
+    storageKey;
+    autoRefresh;
+    refreshBuffer;
+    session = null;
+    subscribers = new Set();
+    refreshTimer = null;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        this.storage = options.storage ?? new LocalStorageAdapter();
+        this.storageKey = options.storageKey ?? 'collab_session';
+        this.autoRefresh = options.autoRefresh ?? true;
+        this.refreshBuffer = options.refreshBuffer ?? 3600; // 1 hour default
+        // Restore session from storage
+        this.restoreSession();
+    }
+    async restoreSession() {
+        try {
+            const stored = await this.storage.getItem(this.storageKey);
+            if (stored) {
+                const session = JSON.parse(stored);
+                // Check if session is still valid
+                const now = Math.floor(Date.now() / 1000);
+                if (session.expiresAt > now) {
+                    this.session = session;
+                    this.scheduleRefresh();
+                    this.notifySubscribers();
+                }
+                else {
+                    // Session expired, clear it
+                    await this.storage.removeItem(this.storageKey);
+                }
+            }
+        }
+        catch (e) {
+            console.error('[AuthManager] Failed to restore session:', e);
+        }
+    }
+    async persistSession(session) {
+        try {
+            if (session) {
+                await this.storage.setItem(this.storageKey, JSON.stringify(session));
+            }
+            else {
+                await this.storage.removeItem(this.storageKey);
+            }
+        }
+        catch (e) {
+            console.error('[AuthManager] Failed to persist session:', e);
+        }
+    }
+    scheduleRefresh() {
+        if (!this.autoRefresh || !this.session)
+            return;
+        // Clear existing timer
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const timeUntilRefresh = (this.session.expiresAt - this.refreshBuffer) - now;
+        if (timeUntilRefresh > 0) {
+            this.refreshTimer = setTimeout(() => {
+                this.refreshSession();
+            }, timeUntilRefresh * 1000);
+        }
+    }
+    async refreshSession() {
+        if (!this.session)
+            return;
+        try {
+            const res = await fetch(`${this.baseUrl}/api/auth/session`, {
+                headers: {
+                    'Authorization': `Bearer ${this.session.token}`
+                }
+            });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.session?.token && data.user) {
+                    const newSession = {
+                        token: data.session.token,
+                        user: {
+                            id: data.user.id,
+                            name: data.user.name,
+                            email: data.user.email,
+                            image: data.user.image
+                        },
+                        expiresAt: data.session.expiresAt
+                    };
+                    this.session = newSession;
+                    await this.persistSession(newSession);
+                    this.scheduleRefresh();
+                    this.notifySubscribers();
+                }
+            }
+        }
+        catch (e) {
+            console.error('[AuthManager] Failed to refresh session:', e);
+        }
+    }
+    notifySubscribers() {
+        this.subscribers.forEach(callback => callback(this.session));
+    }
+    async login(email, password) {
+        const res = await fetch(`${this.baseUrl}/api/auth/sign-in/email`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Origin': this.baseUrl
+            },
+            body: JSON.stringify({ email, password })
+        });
+        if (!res.ok) {
+            const error = await res.json().catch(() => ({ message: res.statusText }));
+            throw new Error(error.message || 'Login failed');
+        }
+        const data = await res.json();
+        // Better Auth can return token in different formats
+        const token = data.token || data.session?.token;
+        const expiresAt = data.session?.expiresAt || data.expiresAt;
+        if (!token || !data.user) {
+            throw new Error('Invalid response from server');
+        }
+        const session = {
+            token,
+            user: {
+                id: data.user.id,
+                name: data.user.name,
+                email: data.user.email,
+                image: data.user.image
+            },
+            expiresAt: expiresAt || (Math.floor(Date.now() / 1000) + 7200) // 2 hours default
+        };
+        this.session = session;
+        await this.persistSession(session);
+        this.scheduleRefresh();
+        this.notifySubscribers();
+        return session;
+    }
+    async signup(email, password, name) {
+        const res = await fetch(`${this.baseUrl}/api/auth/sign-up/email`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Origin': this.baseUrl
+            },
+            body: JSON.stringify({ email, password, name })
+        });
+        if (!res.ok) {
+            const error = await res.json().catch(() => ({ message: res.statusText }));
+            throw new Error(error.message || 'Signup failed');
+        }
+        const data = await res.json();
+        // Better Auth can return token in different formats
+        const token = data.token || data.session?.token;
+        const expiresAt = data.session?.expiresAt || data.expiresAt;
+        if (!token || !data.user) {
+            throw new Error('Invalid response from server');
+        }
+        const session = {
+            token,
+            user: {
+                id: data.user.id,
+                name: data.user.name,
+                email: data.user.email,
+                image: data.user.image
+            },
+            expiresAt: expiresAt || (Math.floor(Date.now() / 1000) + 7200) // 2 hours default
+        };
+        this.session = session;
+        await this.persistSession(session);
+        this.scheduleRefresh();
+        this.notifySubscribers();
+        return session;
+    }
+    async logout() {
+        if (!this.session)
+            return;
+        try {
+            await fetch(`${this.baseUrl}/api/auth/sign-out`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.session.token}`
+                }
+            });
+        }
+        catch (e) {
+            console.error('[AuthManager] Logout request failed:', e);
+        }
+        this.session = null;
+        await this.persistSession(null);
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        this.notifySubscribers();
+    }
+    getSession() {
+        return this.session;
+    }
+    getToken() {
+        return this.session?.token ?? null;
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
+    }
+    // AuthClient compatibility methods
+    async getSessionCompat() {
+        if (!this.session)
+            return null;
+        return {
+            session: {
+                token: this.session.token
+            }
+        };
+    }
+    subscribeCompat(callback) {
+        const wrappedCallback = (session) => {
+            callback(session ? { session: { token: session.token } } : null);
+        };
+        return this.subscribe(wrappedCallback);
+    }
+}
+export class PersistenceManager {
+    persistence = null;
+    isReady = false;
+    readyPromise;
+    listeners = new Set();
+    constructor(options) {
+        const { documentName, document, enablePersistence = true, persistenceDbName = 'y-collab' } = options;
+        if (!enablePersistence || typeof indexedDB === 'undefined') {
+            this.readyPromise = Promise.resolve();
+            this.isReady = true;
+            console.log('[PersistenceManager] Persistence disabled or IndexedDB unavailable');
+            return;
+        }
+        // Check for private browsing mode
+        try {
+            const test = indexedDB.open('test');
+            test.onerror = () => {
+                console.warn('[PersistenceManager] IndexedDB not available (private browsing?)');
+                this.readyPromise = Promise.resolve();
+                this.isReady = true;
+            };
+        }
+        catch (e) {
+            console.warn('[PersistenceManager] IndexedDB check failed:', e);
+            this.readyPromise = Promise.resolve();
+            this.isReady = true;
+            return;
+        }
+        console.log(`[PersistenceManager] Initializing for ${documentName} in database ${persistenceDbName}`);
+        this.persistence = new IndexeddbPersistence(documentName, document);
+        this.readyPromise = new Promise((resolve) => {
+            if (!this.persistence) {
+                resolve();
+                return;
+            }
+            this.persistence.on('synced', () => {
+                console.log(`[PersistenceManager] Synced from IndexedDB for ${documentName}`);
+                this.isReady = true;
+                this.notifyListeners();
+                resolve();
+            });
+        });
+    }
+    waitForReady() {
+        return this.readyPromise;
+    }
+    isReadySync() {
+        return this.isReady;
+    }
+    onReady(callback) {
+        this.listeners.add(callback);
+        if (this.isReady) {
+            callback();
+        }
+        return () => this.listeners.delete(callback);
+    }
+    notifyListeners() {
+        this.listeners.forEach(callback => callback());
+    }
+    async clearData() {
+        if (this.persistence) {
+            try {
+                await this.persistence.clearData();
+                console.log('[PersistenceManager] Cleared local data');
+            }
+            catch (e) {
+                console.error('[PersistenceManager] Failed to clear data:', e);
+            }
+        }
+    }
+    destroy() {
+        if (this.persistence) {
+            this.persistence.destroy();
+            this.persistence = null;
+        }
+        this.listeners.clear();
+    }
+}
+export class CollabProviderWebsocket extends HocuspocusProviderWebsocket {
+    _authUnsubscribe = null;
+    spaceId;
+    _token;
+    _readyPromise;
+    _readyResolve;
+    _spaceDoc; // Y.Doc for the space itself
+    constructor(options) {
+        const { baseUrl, spaceId, auth, token, ...config } = options;
+        // Connect to the collaboration endpoint with spaceId for routing
+        // Matches server route /collaboration/:documentName
+        const url = `${baseUrl.replace(/^http/, 'ws')}/collaboration/space:${spaceId}`;
+        console.log(`[CollabProviderWebsocket] Creating with URL: ${url}, token: ${token ? 'present' : 'missing'}`);
+        // HocuspocusProviderWebsocket is just a WebSocket wrapper
+        // Individual HocuspocusProvider instances will attach and send sync messages
+        super({
+            url: (token ? `${url}?token=${token}` : url),
+            ...config,
+        });
+        this._spaceDoc = null; // No space doc needed for the WebSocket wrapper
+        this._token = token;
+        this.spaceId = spaceId;
+        // Set up ready promise
+        this._readyPromise = new Promise((resolve) => {
+            this._readyResolve = resolve;
+            // Also resolve immediately if already connected
+            if (this.status === 'connected') {
+                resolve();
+            }
+        });
+        // Listen for connection status
+        this.on('status', ({ status }) => {
+            console.log(`[CollabProviderWebsocket] Status changed to: ${status}`);
+            if (status === 'connected' && this._readyResolve) {
+                this._readyResolve();
+            }
+        });
+        // Debug: Listen to all events
+        this.on('synced', ({ state }) => {
+            console.log(`[CollabProviderWebsocket] Synced state: ${state}`);
+        });
+        // Message event listener removed - was causing blocking due to JSON.stringify
+        this.on('authenticationFailed', ({ reason }) => {
+            console.error(`[CollabProviderWebsocket] Authentication failed: ${reason}`);
+        });
+        // Awareness update listener removed - was causing blocking
+        if (auth && !token) {
+            // Only setup async auth if we don't have a token yet
+            console.log('[CollabProviderWebsocket] No token, setting up auth');
+            this.setupAuth(auth);
+        }
+        else if (auth) {
+            // Setup auth subscription for token refresh, but don't fetch initially
+            console.log('[CollabProviderWebsocket] Token provided, setting up auth subscription only');
+            this._authUnsubscribe = auth.subscribe(async (session) => {
+                const newToken = session?.session?.token;
+                if (newToken && newToken !== this._token) {
+                    this.updateToken(newToken);
+                }
+            });
+        }
+    }
+    /**
+     * Wait for the websocket to be connected and ready
+     */
+    async waitForReady() {
+        // If already connected, resolve immediately
+        if (this.status === 'connected') {
+            return Promise.resolve();
+        }
+        return this._readyPromise;
+    }
+    async setupAuth(auth) {
+        // Subscribe to session changes
+        this._authUnsubscribe = auth.subscribe(async (session) => {
+            const token = session?.session?.token;
+            console.log('[CollabProviderWebsocket] Auth subscription callback, token:', token ? 'present' : 'missing');
+            if (token && token !== this._token) {
+                this.updateToken(token);
+            }
+        });
+        // Initial fetch if no token provided yet
+        if (!this._token) {
+            console.log('[CollabProviderWebsocket] Fetching initial session...');
+            const session = await auth.getSession();
+            console.log('[CollabProviderWebsocket] Session fetched, token:', session?.session?.token ? 'present' : 'missing');
+            if (session?.session?.token) {
+                this.updateToken(session.session.token);
+                // Connect now that we have the token
+                console.log('[CollabProviderWebsocket] Calling connect()');
+                this.connect();
+            }
+        }
+    }
+    updateToken(newToken) {
+        this._token = newToken;
+        // HocuspocusProviderWebsocket doesn't expose a clean way to update query params on the fly
+        // without reconnecting. We assume the server handles auth on connect.
+        // If we want to support seamless token rotation, we might need to send a message or reconnect.
+        // For now, we update the URL generic so next reconnect works.
+        const base = this.configuration.url.toString().split('?')[0];
+        this.configuration.url = `${base}?token=${newToken}`;
+        // If we are currently disconnected/connecting, this helps.
+        // If connected, the socket stays open until it expires or we force it.
+        // Some setups prefer forcing reconnect on token change:
+        // this.disconnect();
+        // this.connect();
+    }
+    getToken() {
+        return this._token;
+    }
+    getSpaceDoc() {
+        return this._spaceDoc;
+    }
+    destroy() {
+        if (this._authUnsubscribe) {
+            this._authUnsubscribe();
+        }
+        super.destroy();
+    }
+}
+/**
+ * HocuspocusProvider wrapper that handles constructing the correct name/url
+ * based on our platform's conventions.
+ */
+export class CollabProvider extends HocuspocusProvider {
+    _authUnsubscribe = null;
+    documentId;
+    persistenceManager = null;
+    constructor(options) {
+        const { baseUrl, spaceId, documentId, websocketProvider, auth, token, enablePersistence = true, persistenceDbName, ...providerOptions } = options;
+        let config;
+        let parentToken = token;
+        // Mode 1: Multiplexing via Shared Socket
+        if (websocketProvider) {
+            const finalSpaceId = spaceId || (websocketProvider instanceof CollabProviderWebsocket ? websocketProvider.spaceId : spaceId);
+            const fullName = `space:${finalSpaceId}:doc:${documentId}`;
+            parentToken = parentToken || (websocketProvider instanceof CollabProviderWebsocket ? websocketProvider.getToken() : undefined);
+            console.log(`[CollabProvider] Creating in multiplexing mode`);
+            console.log(`[CollabProvider] Document name: ${fullName}`);
+            console.log(`[CollabProvider] WebsocketProvider status:`, websocketProvider.status);
+            console.log(`[CollabProvider] WebsocketProvider URL:`, websocketProvider.configuration?.url);
+            console.log(`[CollabProvider] Options passed:`, providerOptions);
+            config = {
+                name: fullName,
+                websocketProvider: websocketProvider,
+                token: parentToken,
+                ...providerOptions
+            };
+            console.log(`[CollabProvider] Final config:`, config);
+        }
+        // Mode 2: Standalone Connection
+        else if (baseUrl && spaceId) {
+            const fullName = `space:${spaceId}:doc:${documentId}`;
+            const url = `${baseUrl.replace(/^http/, 'ws')}/collaboration/${fullName}`;
+            console.log(`[CollabProvider] Creating in standalone mode`);
+            console.log(`[CollabProvider] URL: ${url}`);
+            console.log(`[CollabProvider] Document name: ${fullName}`);
+            config = {
+                url,
+                name: fullName,
+                token,
+                ...providerOptions
+            };
+        }
+        else {
+            throw new Error("CollabProvider requires either 'websocketProvider' or 'baseUrl' + 'spaceId'");
+        }
+        super(config);
+        this.documentId = documentId;
+        console.log(`[CollabProvider] Created, status:`, this.status);
+        console.log(`[CollabProvider] Awareness instance present:`, !!this.awareness);
+        console.log(`[CollabProvider] Awareness check:`, this.awareness);
+        // Initialize persistence
+        const fullName = config.name;
+        this.persistenceManager = new PersistenceManager({
+            documentName: fullName,
+            document: this.document,
+            enablePersistence,
+            persistenceDbName
+        });
+        // When using websocketProvider (multiplexing), we must manually attach
+        // The parent constructor only calls attach() if manageSocket is true (standalone mode)
+        // The attach() method will automatically call onOpen() if the websocket is already connected
+        if (websocketProvider) {
+            console.log(`[CollabProvider] Attaching to parent websocket`);
+            console.time('[CollabProvider] attach()');
+            this.attach();
+            console.timeEnd('[CollabProvider] attach()');
+        }
+        // Debug: Listen to events
+        this.on('status', ({ status }) => {
+            const timestamp = new Date().toISOString();
+            console.log(`[CollabProvider] ${timestamp} Status changed to: ${status}`, {
+                documentId: this.documentId,
+                status: status
+            });
+        });
+        this.on('synced', ({ state }) => {
+            const timestamp = new Date().toISOString();
+            console.log(`[CollabProvider] ${timestamp} Synced state: ${state}`, {
+                documentId: this.documentId,
+                synced: state
+            });
+        });
+        // Message event listener removed - was causing blocking
+        this.on('authenticationFailed', ({ reason }) => {
+            const timestamp = new Date().toISOString();
+            console.error(`[CollabProvider] ${timestamp} Authentication failed: ${reason}`, {
+                documentId: this.documentId,
+                reason: reason
+            });
+        });
+        // Awareness logging removed - was causing blocking
+        // Setup auth watchers
+        if (!websocketProvider && auth) {
+            this.setupAuth(auth);
+        }
+        else if (websocketProvider && websocketProvider instanceof CollabProviderWebsocket) {
+            // In multiplexed mode, we might want to listen to the parent socket's token changes?
+            // Actually, HocuspocusProvider reads `this.configuration.token` during authentication steps.
+            // We should ensure `this.configuration.token` is kept fresh.
+            // Currently Hocuspocus doesn't re-read it actively unless we push it.
+        }
+    }
+    async setupAuth(auth) {
+        this._authUnsubscribe = auth.subscribe(async (session) => {
+            const token = session?.session?.token;
+            if (token) {
+                this.setToken(token);
+            }
+        });
+        const session = await auth.getSession();
+        if (session?.session?.token) {
+            this.setToken(session.session.token);
+        }
+    }
+    setToken(token) {
+        this.configuration.token = token;
+        // If connected, send auth message
+        if (this.status === "connected") {
+            this.sendStateless(JSON.stringify({ type: "auth", token: token }));
+        }
+    }
+    destroy() {
+        if (this._authUnsubscribe) {
+            this._authUnsubscribe();
+        }
+        if (this.persistenceManager) {
+            this.persistenceManager.destroy();
+        }
+        super.destroy();
+    }
+    /**
+     * Wait for persistence to be ready
+     */
+    async waitForPersistence() {
+        if (this.persistenceManager) {
+            return this.persistenceManager.waitForReady();
+        }
+    }
+    /**
+     * Check if persistence is ready
+     */
+    isPersistenceReady() {
+        return this.persistenceManager?.isReadySync() ?? false;
+    }
+    /**
+     * Clear local persistence data
+     */
+    async clearLocalData() {
+        if (this.persistenceManager) {
+            return this.persistenceManager.clearData();
+        }
+    }
+    /**
+     * Send a comment action via stateless message
+     */
+    sendComment(action, data) {
+        this.sendStateless(JSON.stringify({
+            type: "comment",
+            action,
+            data
+        }));
+    }
+    /**
+     * Listen for real-time comment events
+     */
+    onComment(callback) {
+        const handler = (payload) => {
+            try {
+                const msg = JSON.parse(payload.payload);
+                if (msg.type === "comment" || msg.type === "comment_error") {
+                    callback(msg);
+                }
+            }
+            catch (e) {
+                // Ignore parsing errors
+            }
+        };
+        this.on("stateless", handler);
+        return () => this.off("stateless", handler);
+    }
+}
+// ----------------------------------------------------------------------
+// CollabClient (Full SDK)
+// ----------------------------------------------------------------------
+export class CollabClient {
+    baseUrl;
+    auth;
+    authManager = null;
+    offlineOptions;
+    // Cache for shared websockets by spaceId
+    _sockets = new Map();
+    _token = null;
+    // Upload queue for offline uploads
+    uploadQueue = null;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        this.offlineOptions = {
+            enablePersistence: true,
+            enableImageCache: true,
+            enableUploadQueue: true,
+            persistenceDbName: 'y-collab',
+            maxCacheSize: 50, // MB
+            maxDocuments: 20,
+            autoCleanup: true,
+            cleanupThreshold: 0.9,
+            ...options.offline
+        };
+        if (options.authClient) {
+            // Custom auth implementation
+            this.auth = options.authClient;
+        }
+        else {
+            // Managed auth (default)
+            this.authManager = new AuthManager({
+                baseUrl: this.baseUrl,
+                storage: options.managedAuth?.storage,
+                autoRefresh: options.managedAuth?.autoRefresh,
+                refreshBuffer: options.managedAuth?.refreshBuffer
+            });
+            this.auth = {
+                getSession: () => this.authManager.getSessionCompat(),
+                subscribe: (callback) => this.authManager.subscribeCompat(callback)
+            };
+        }
+        this.auth.subscribe((session) => {
+            this._token = session?.session?.token || null;
+        });
+        this.auth.getSession().then(s => {
+            this._token = s?.session?.token || null;
+        });
+        // Initialize upload queue
+        if (this.offlineOptions.enableUploadQueue && typeof indexedDB !== 'undefined') {
+            this.uploadQueue = new UploadQueueManager();
+            this.uploadQueue.init().catch((error) => {
+                console.error('[CollabClient] Failed to initialize upload queue:', error);
+                this.uploadQueue = null;
+            });
+            // Process queue when client is created and online
+            if (navigator.onLine) {
+                setTimeout(() => {
+                    this.processUploadQueue().catch(error => {
+                        console.error('[CollabClient] Failed to process upload queue:', error);
+                    });
+                }, 1000);
+            }
+        }
+    }
+    // Convenience methods (only available when using managed auth)
+    async login(email, password) {
+        if (!this.authManager) {
+            throw new Error('login() is only available in managed auth mode');
+        }
+        return this.authManager.login(email, password);
+    }
+    async signup(email, password, name) {
+        if (!this.authManager) {
+            throw new Error('signup() is only available in managed auth mode');
+        }
+        return this.authManager.signup(email, password, name);
+    }
+    async logout() {
+        if (!this.authManager) {
+            throw new Error('logout() is only available in managed auth mode');
+        }
+        return this.authManager.logout();
+    }
+    getSession() {
+        if (!this.authManager) {
+            throw new Error('getSession() is only available in managed auth mode');
+        }
+        return this.authManager.getSession();
+    }
+    async getToken() {
+        if (this._token)
+            return this._token;
+        const session = await this.auth.getSession();
+        this._token = session?.session?.token || null;
+        if (!this._token) {
+            throw new Error("Not authenticated");
+        }
+        return this._token;
+    }
+    async fetch(path, options = {}) {
+        const token = await this.getToken();
+        const headers = new Headers(options.headers);
+        headers.set("Authorization", `Bearer ${token}`);
+        if (!headers.has("Content-Type") && !(options.body instanceof FormData)) {
+            headers.set("Content-Type", "application/json");
+        }
+        const res = await fetch(`${this.baseUrl}/api${path}`, {
+            ...options,
+            headers,
+        });
+        if (!res.ok) {
+            const error = await res.json().catch(() => ({ message: res.statusText }));
+            throw new Error(error.message || error.error || `Request failed: ${res.status}`);
+        }
+        // Return empty for 204
+        if (res.status === 204)
+            return {};
+        return res.json();
+    }
+    // --- Extensions ---
+    async getExtensions(deps) {
+        // Make dependencies available for extension scripts that use bare specifiers
+        if (deps) {
+            globalThis.__collab_deps = { ...globalThis.__collab_deps, ...deps };
+        }
+        const res = await this.fetch("/extensions/config");
+        const defs = res.extensions || [];
+        const loadedExtensions = [];
+        for (const def of defs) {
+            if (def.scriptUrl) {
+                try {
+                    const fullUrl = new URL(def.scriptUrl, this.baseUrl).toString();
+                    // Fetch script text and rewrite bare specifiers to use provided deps
+                    const response = await fetch(fullUrl);
+                    const scriptText = await response.text();
+                    // Replace bare module specifiers with global deps lookup
+                    const rewritten = scriptText.replace(/import\s*\{([^}]+)\}\s*from\s*['"]([^./][^'"]*)['"]/g, (_match, imports, specifier) => {
+                        return `const {${imports}} = globalThis.__collab_deps?.['${specifier}'] ?? (() => { throw new Error('Missing dependency: ${specifier}') })()`;
+                    });
+                    const blob = new Blob([rewritten], { type: 'application/javascript' });
+                    const blobUrl = URL.createObjectURL(blob);
+                    try {
+                        // @ts-ignore
+                        const module = await import(__rewriteRelativeImportExtension(/* @vite-ignore */ blobUrl));
+                        if (module.default) {
+                            if (typeof module.default.configure === 'function') {
+                                loadedExtensions.push(module.default.configure(def.options || {}));
+                            }
+                            else {
+                                loadedExtensions.push(module.default);
+                            }
+                        }
+                    }
+                    finally {
+                        URL.revokeObjectURL(blobUrl);
+                    }
+                }
+                catch (e) {
+                    console.error(`[CollabClient] Failed to load extension ${def.name}`, e);
+                }
+            }
+        }
+        return loadedExtensions;
+    }
+    // --- WebSocket / Provider Factory ---
+    async getWebsocketProvider(spaceId) {
+        const cached = this._sockets.get(spaceId);
+        // Check if cached socket exists and is still valid (not destroyed)
+        if (cached) {
+            const status = cached.status;
+            const shouldConnect = cached.shouldConnect;
+            // Only reuse if the websocket hasn't been destroyed (shouldConnect should be true for active sockets)
+            if (shouldConnect !== false && status !== 'destroyed') {
+                console.log(`[CollabClient] Reusing cached websocket for space: ${spaceId}`);
+                return cached;
+            }
+            // Remove destroyed websocket from cache
+            console.log(`[CollabClient] Removing destroyed websocket from cache for space: ${spaceId}`);
+            this._sockets.delete(spaceId);
+        }
+        console.log(`[CollabClient] Creating new websocket for space: ${spaceId}`);
+        // Get token first before creating websocket
+        const token = await this.getToken();
+        console.log(`[CollabClient] Token obtained:`, token ? 'present' : 'missing');
+        const ws = new CollabProviderWebsocket({
+            baseUrl: this.baseUrl,
+            spaceId,
+            auth: this.auth,
+            token, // Pass token directly so it connects immediately
+        });
+        this._sockets.set(spaceId, ws);
+        return ws;
+    }
+    /**
+     * Get a CollabProvider for a specific document.
+     * Uses a shared WebSocket for the space if possible.
+     */
+    async getProvider(spaceId, documentId, options = {}) {
+        const documentName = `space:${spaceId}:doc:${documentId}`;
+        // Check if this document is already attached to the websocket
+        const socket = await this.getWebsocketProvider(spaceId);
+        const providerMap = socket.configuration?.providerMap;
+        // CRITICAL: If the same document is already attached, create a NEW websocket
+        // because providerMap.set() overwrites - only one provider per document name per socket
+        if (providerMap && providerMap.has(documentName)) {
+            console.log(`[CollabClient] Document ${documentId} already attached to this websocket - creating separate websocket for this tab`);
+            // Create a unique websocket for this tab
+            const token = await this.getToken();
+            const newSocket = new CollabProviderWebsocket({
+                baseUrl: this.baseUrl,
+                spaceId,
+                auth: this.auth,
+                token,
+            });
+            // Don't cache this one - it's tab-specific
+            console.log(`[CollabClient] Created separate websocket for tab accessing doc ${documentId}`);
+            await newSocket.waitForReady();
+            return new CollabProvider({
+                websocketProvider: newSocket,
+                spaceId,
+                documentId,
+                enablePersistence: this.offlineOptions.enablePersistence,
+                persistenceDbName: this.offlineOptions.persistenceDbName,
+                ...options
+            });
+        }
+        // Normal path: document not yet attached, safe to use shared websocket
+        console.log(`[CollabClient] Waiting for websocket to be ready before creating provider for doc ${documentId}`);
+        await socket.waitForReady();
+        console.log(`[CollabClient] Websocket ready, creating provider for doc ${documentId}`);
+        return new CollabProvider({
+            websocketProvider: socket,
+            spaceId,
+            documentId,
+            enablePersistence: this.offlineOptions.enablePersistence,
+            persistenceDbName: this.offlineOptions.persistenceDbName,
+            ...options
+        });
+    }
+    // --- REST API: Documents ---
+    documents = {
+        /**
+         * List documents in a space
+         * @param parentId - null for root only, undefined for all, string for specific parent
+         */
+        list: (spaceId, params) => {
+            const searchParams = new URLSearchParams();
+            if (params?.parentId === null) {
+                searchParams.set('parentId', 'null');
+            }
+            else if (params?.parentId) {
+                searchParams.set('parentId', params.parentId);
+            }
+            if (params?.limit)
+                searchParams.set('limit', String(params.limit));
+            if (params?.offset)
+                searchParams.set('offset', String(params.offset));
+            const qs = searchParams.toString() ? `?${searchParams}` : '';
+            return this.fetch(`/spaces/${spaceId}/documents${qs}`).then(r => ({ items: r.data, pagination: r.pagination }));
+        },
+        get: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}`).then(r => r.data),
+        create: (spaceId, options) => this.fetch(`/spaces/${spaceId}/documents`, {
+            method: "POST",
+            body: JSON.stringify(options || {}),
+        }),
+        update: (spaceId, docId, data) => this.fetch(`/spaces/${spaceId}/documents/${docId}`, {
+            method: "PATCH",
+            body: JSON.stringify(data),
+        }),
+        delete: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}`, {
+            method: "DELETE",
+        }),
+        getContent: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/content`).then(r => r.content),
+        /**
+         * Update document content via patch (merge or replace strategy)
+         */
+        patch: (spaceId, docId, content, options) => this.fetch(`/spaces/${spaceId}/documents/${docId}/content`, {
+            method: "PATCH",
+            body: JSON.stringify({ content, ...options }),
+        }).then(r => r.document),
+        /**
+         * Apply transformation operations to document
+         */
+        transform: (spaceId, docId, operations) => this.fetch(`/spaces/${spaceId}/documents/${docId}/transform`, {
+            method: "POST",
+            body: JSON.stringify({ operations }),
+        }).then(r => r.document),
+        // Hierarchy methods
+        tree: (spaceId) => this.fetch(`/spaces/${spaceId}/documents/tree`).then(r => r.data),
+        children: (spaceId, docId, params) => {
+            const searchParams = new URLSearchParams();
+            if (params?.limit)
+                searchParams.set('limit', String(params.limit));
+            if (params?.offset)
+                searchParams.set('offset', String(params.offset));
+            const qs = searchParams.toString() ? `?${searchParams}` : '';
+            return this.fetch(`/spaces/${spaceId}/documents/${docId}/children${qs}`).then(r => ({ items: r.data, pagination: r.pagination }));
+        },
+        ancestors: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/ancestors`).then(r => r.data),
+        move: (spaceId, docId, parentId, position) => this.fetch(`/spaces/${spaceId}/documents/${docId}/move`, {
+            method: "POST",
+            body: JSON.stringify({ parentId, position }),
+        }),
+        // History / Snapshots
+        getSnapshots: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/snapshots`).then(r => r.snapshots),
+        restoreSnapshot: (spaceId, docId, snapshotId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/restore/${snapshotId}`, {
+            method: "POST",
+        }),
+        // Maintenance / Recovery
+        listDeleted: (spaceId, params) => {
+            const searchParams = new URLSearchParams();
+            if (params?.limit)
+                searchParams.set('limit', String(params.limit));
+            if (params?.offset)
+                searchParams.set('offset', String(params.offset));
+            const qs = searchParams.toString() ? `?${searchParams}` : '';
+            return this.fetch(`/spaces/${spaceId}/documents/deleted${qs}`).then(r => ({ items: r.data, pagination: r.pagination }));
+        },
+        restore: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/restore`, {
+            method: "POST",
+        }),
+        deletePermanent: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/permanent`, {
+            method: "DELETE",
+        }),
+        // Export - returns raw HTML string or JSON object depending on format
+        export: async (spaceId, docId, format = 'html') => {
+            const token = await this.getToken();
+            const res = await fetch(`${this.baseUrl}/api/spaces/${spaceId}/documents/${docId}/export?format=${format}`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            if (!res.ok)
+                throw new Error(`Export failed: ${res.status}`);
+            return format === 'json' ? res.json() : res.text();
+        },
+    };
+    // --- REST API: Spaces ---
+    spaces = {
+        list: () => this.fetch("/spaces").then(r => r.data),
+        get: (spaceId) => this.fetch(`/spaces/${spaceId}`).then(r => r.data),
+        getMembers: (spaceId) => this.fetch(`/spaces/${spaceId}/members`).then(r => r.data),
+        create: (data) => this.fetch("/organizations", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(data),
+        }),
+        /**
+         * Add a member to a space/organization
+         */
+        addMember: (spaceId, email, role) => this.fetch(`/organizations/${spaceId}/members`, {
+            method: "POST",
+            body: JSON.stringify({ email, role }),
+        }),
+        /**
+         * Update a member's role
+         */
+        updateRole: (spaceId, userId, role) => this.fetch(`/organizations/${spaceId}/members/${userId}`, {
+            method: "PATCH",
+            body: JSON.stringify({ role }),
+        }),
+        /**
+         * Remove a member from a space/organization
+         */
+        removeMember: (spaceId, userId) => this.fetch(`/organizations/${spaceId}/members/${userId}`, {
+            method: "DELETE",
+        }),
+    };
+    // --- REST API: Uploads ---
+    uploads = {
+        list: (spaceId, documentId, params) => {
+            const searchParams = new URLSearchParams();
+            if (documentId)
+                searchParams.set('documentId', documentId);
+            if (params?.limit)
+                searchParams.set('limit', String(params.limit));
+            if (params?.offset)
+                searchParams.set('offset', String(params.offset));
+            const qs = searchParams.toString() ? `?${searchParams}` : '';
+            return this.fetch(`/spaces/${spaceId}/files${qs}`).then(r => ({ items: r.data, pagination: r.pagination }));
+        },
+        upload: async (spaceId, file, documentId) => {
+            // Check if online
+            if (!navigator.onLine && this.uploadQueue) {
+                console.log('[CollabClient] Offline - queuing upload:', file.name);
+                // Add to queue and return temp data
+                const pendingUpload = await this.uploadQueue.add({
+                    spaceId,
+                    documentId: documentId || null,
+                    file,
+                    filename: file.name,
+                    mimeType: file.type
+                });
+                // Return temporary file info that looks like a FileUpload
+                return {
+                    id: pendingUpload.id,
+                    url: pendingUpload.tempUrl,
+                    filename: pendingUpload.filename,
+                    mimeType: pendingUpload.mimeType,
+                    size: file.size
+                };
+            }
+            // Online - upload directly
+            const formData = new FormData();
+            formData.append("file", file);
+            const qs = documentId ? `?documentId=${documentId}` : "";
+            return this.fetch(`/spaces/${spaceId}/upload${qs}`, {
+                method: "POST",
+                body: formData,
+            }).then(r => r.data);
+        },
+        delete: (spaceId, fileId) => this.fetch(`/spaces/${spaceId}/files/${fileId}`, {
+            method: "DELETE",
+        }),
+        deletePermanent: (spaceId, fileId) => this.fetch(`/spaces/${spaceId}/files/${fileId}/permanent`, {
+            method: "DELETE",
+        }),
+    };
+    // --- REST API: Comments ---
+    comments = {
+        /**
+         * List comments for a document (threaded)
+         */
+        list: (spaceId, docId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/comments`).then(r => ({ threads: r.data, meta: r.meta })),
+        /**
+         * Get a single comment
+         */
+        get: (spaceId, docId, commentId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/comments/${commentId}`).then(r => r.data),
+        /**
+         * Create a new comment
+         */
+        create: (spaceId, docId, data) => this.fetch(`/spaces/${spaceId}/documents/${docId}/comments`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        }).then(r => r.data),
+        /**
+         * Update a comment's content
+         */
+        update: (spaceId, docId, commentId, content) => this.fetch(`/spaces/${spaceId}/documents/${docId}/comments/${commentId}`, {
+            method: "PATCH",
+            body: JSON.stringify({ content }),
+        }).then(r => r.data),
+        /**
+         * Delete a comment
+         */
+        delete: (spaceId, docId, commentId) => this.fetch(`/spaces/${spaceId}/documents/${docId}/comments/${commentId}`, {
+            method: "DELETE",
+        }),
+        /**
+         * Resolve or unresolve a comment thread
+         */
+        resolve: (spaceId, docId, commentId, resolved) => this.fetch(`/spaces/${spaceId}/documents/${docId}/comments/${commentId}/resolve`, {
+            method: "POST",
+            body: JSON.stringify({ resolved }),
+        }).then(r => r.data),
+    };
+    // --- REST API: Sharing ---
+    share = {
+        /**
+         * Get share status for a document
+         */
+        get: async (spaceId, docId) => {
+            const token = await this.getToken();
+            const res = await fetch(`${this.baseUrl}/api/spaces/${spaceId}/documents/${docId}/share`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            if (!res.ok)
+                throw new Error("Failed to get share status");
+            return res.json();
+        },
+        /**
+         * Enable sharing for a document
+         */
+        enable: async (spaceId, docId) => {
+            const token = await this.getToken();
+            const res = await fetch(`${this.baseUrl}/api/spaces/${spaceId}/documents/${docId}/share`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            if (!res.ok)
+                throw new Error("Failed to enable sharing");
+            return res.json();
+        },
+        /**
+         * Disable sharing for a document
+         */
+        disable: async (spaceId, docId) => {
+            const token = await this.getToken();
+            const res = await fetch(`${this.baseUrl}/api/spaces/${spaceId}/documents/${docId}/share`, {
+                method: "DELETE",
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            if (!res.ok)
+                throw new Error("Failed to disable sharing");
+            return res.json();
+        }
+    };
+    /**
+     * Process the upload queue
+     */
+    async processUploadQueue() {
+        if (!this.uploadQueue)
+            return;
+        await this.uploadQueue.processQueue(async (upload) => {
+            console.log('[CollabClient] Processing queued upload:', upload.filename);
+            // Re-create File from Blob
+            const file = new File([upload.file], upload.filename, { type: upload.mimeType });
+            // Upload to server
+            const formData = new FormData();
+            formData.append("file", file);
+            const qs = upload.documentId ? `?documentId=${upload.documentId}` : "";
+            const result = await this.fetch(`/spaces/${upload.spaceId}/upload${qs}`, {
+                method: "POST",
+                body: formData,
+            });
+            return result.data;
+        });
+    }
+    /**
+     * Get pending uploads count
+     */
+    async getPendingUploadsCount() {
+        if (!this.uploadQueue)
+            return 0;
+        return this.uploadQueue.count();
+    }
+    /**
+     * Get all pending uploads
+     */
+    async getPendingUploads() {
+        if (!this.uploadQueue)
+            return [];
+        return this.uploadQueue.getAll();
+    }
+    /**
+     * Subscribe to upload queue events
+     */
+    onUploadQueue(event, callback) {
+        if (!this.uploadQueue)
+            return () => { };
+        return this.uploadQueue.on(event, callback);
+    }
+    /**
+     * Get storage quota information
+     */
+    async getStorageInfo() {
+        if (!navigator.storage || !navigator.storage.estimate) {
+            return { usage: 0, quota: 0, percentUsed: 0 };
+        }
+        try {
+            const estimate = await navigator.storage.estimate();
+            const usage = estimate.usage || 0;
+            const quota = estimate.quota || 0;
+            const percentUsed = quota > 0 ? (usage / quota) * 100 : 0;
+            return { usage, quota, percentUsed };
+        }
+        catch (error) {
+            console.error('[CollabClient] Failed to get storage info:', error);
+            return { usage: 0, quota: 0, percentUsed: 0 };
+        }
+    }
+    /**
+     * Clear all local data (IndexedDB and caches)
+     */
+    async clearAllLocalData() {
+        console.log('[CollabClient] Clearing all local data...');
+        // Clear upload queue
+        if (this.uploadQueue) {
+            await this.uploadQueue.clear();
+        }
+        // Clear all IndexedDB databases
+        if (typeof indexedDB !== 'undefined') {
+            try {
+                // Get all database names
+                const databases = await indexedDB.databases();
+                for (const db of databases) {
+                    if (db.name) {
+                        console.log('[CollabClient] Deleting database:', db.name);
+                        await new Promise((resolve, reject) => {
+                            const request = indexedDB.deleteDatabase(db.name);
+                            request.onsuccess = () => resolve();
+                            request.onerror = () => reject(request.error);
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                console.error('[CollabClient] Failed to clear IndexedDB:', error);
+            }
+        }
+        // Clear caches
+        if (typeof caches !== 'undefined') {
+            try {
+                const cacheNames = await caches.keys();
+                for (const name of cacheNames) {
+                    console.log('[CollabClient] Deleting cache:', name);
+                    await caches.delete(name);
+                }
+            }
+            catch (error) {
+                console.error('[CollabClient] Failed to clear caches:', error);
+            }
+        }
+        console.log('[CollabClient] Local data cleared');
+    }
+    /**
+     * Clear specific document cache
+     */
+    async clearDocumentCache(spaceId, docId) {
+        const dbName = this.offlineOptions.persistenceDbName || 'y-collab';
+        const documentName = `space:${spaceId}:doc:${docId}`;
+        try {
+            // Open the database and clear the specific document
+            const db = await new Promise((resolve, reject) => {
+                const request = indexedDB.open(dbName);
+                request.onsuccess = () => resolve(request.result);
+                request.onerror = () => reject(request.error);
+            });
+            // Check if the store exists
+            if (!db.objectStoreNames.contains(documentName)) {
+                db.close();
+                return;
+            }
+            // Clear the document store
+            await new Promise((resolve, reject) => {
+                const transaction = db.transaction([documentName], 'readwrite');
+                const store = transaction.objectStore(documentName);
+                const request = store.clear();
+                request.onsuccess = () => resolve();
+                request.onerror = () => reject(request.error);
+            });
+            db.close();
+            console.log('[CollabClient] Document cache cleared:', documentName);
+        }
+        catch (error) {
+            console.error('[CollabClient] Failed to clear document cache:', error);
+        }
+    }
+    /**
+     * Perform cleanup when storage quota is exceeded
+     */
+    async performCleanup() {
+        console.log('[CollabClient] Performing storage cleanup...');
+        const { percentUsed } = await this.getStorageInfo();
+        const threshold = (this.offlineOptions.cleanupThreshold || 0.9) * 100;
+        if (percentUsed < threshold) {
+            console.log('[CollabClient] Storage usage below threshold, no cleanup needed');
+            return;
+        }
+        // Strategy: Clear image cache first (non-critical data)
+        if (typeof caches !== 'undefined') {
+            try {
+                const cacheNames = await caches.keys();
+                for (const name of cacheNames) {
+                    if (name.includes('image')) {
+                        console.log('[CollabClient] Clearing image cache:', name);
+                        await caches.delete(name);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('[CollabClient] Failed to clear image caches:', error);
+            }
+        }
+        // Check again
+        const { percentUsed: newPercentUsed } = await this.getStorageInfo();
+        if (newPercentUsed < threshold) {
+            console.log('[CollabClient] Cleanup complete, storage usage:', newPercentUsed, '%');
+            return;
+        }
+        // If still over threshold, implement LRU eviction for documents
+        // This is a placeholder - would need to track document access times
+        console.warn('[CollabClient] Storage still over threshold after cleanup');
+    }
+    /**
+     * Check storage quota and perform cleanup if needed
+     */
+    async checkStorageQuota() {
+        if (!this.offlineOptions.autoCleanup) {
+            return;
+        }
+        const { percentUsed } = await this.getStorageInfo();
+        const threshold = (this.offlineOptions.cleanupThreshold || 0.9) * 100;
+        if (percentUsed >= threshold) {
+            console.warn('[CollabClient] Storage quota exceeded:', percentUsed, '%');
+            await this.performCleanup();
+        }
+    }
+    /**
+     * Get document content using a share token (public access)
+     */
+    async getPublicContent(spaceId, docId, shareToken) {
+        const res = await fetch(`${this.baseUrl}/api/spaces/${spaceId}/documents/${docId}/content`, {
+            headers: {
+                "Share-Token": shareToken
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to load public document: ${res.status}`);
+        }
+        return res.json();
+    }
+}
+//# sourceMappingURL=collab-provider.js.map