@abraca/nuxt 0.1.0

package/dist/runtime/plugin-abracadabra.client.js

@@ -0,0 +1,898 @@
+import { shallowRef, ref, computed, watch } from "vue";
+import * as Y from "yjs";
+import { PluginRegistry } from "./plugin-registry.js";
+import { corePlugin } from "./plugins/core.plugin.js";
+import {
+  UI_COLORS,
+  UI_NEUTRALS,
+  COLOR_HUES,
+  deriveColorFromPubKey
+} from "./types.js";
+import {
+  _initBackgroundSync,
+  _destroyBackgroundSync
+} from "./composables/useBackgroundSync.js";
+import {
+  _initFileBlobStore,
+  _destroyFileBlobStore
+} from "./composables/useFileBlobStore.js";
+import {
+  _initSearchIndex,
+  _destroySearchIndex
+} from "./composables/useSearchIndex.js";
+import {
+  _initNotifications,
+  _destroyNotifications,
+  _handleStatelessNotification
+} from "./composables/useNotifications.js";
+import {
+  _initChat,
+  _destroyChat,
+  _handleStatelessChat
+} from "./composables/useChat.js";
+import {
+  _initFileIndex,
+  _destroyFileIndex
+} from "./composables/useFileIndex.js";
+const STORAGE_KEY_EXTERNAL_PLUGINS = "abracadabra_external_plugins";
+const STORAGE_KEY_DISABLED_BUILTINS = "abracadabra_disabled_builtins";
+const CLAIMED_FLAG_KEY = "abracadabra_was_claimed";
+const PUBKEY_KEY = "abracadabra_pubkey";
+const CURRENT_SERVER_KEY = "abracadabra_current_server";
+const REQUIRE_PASSKEY_KEY = "abracadabra_require_passkey";
+const SERVERS_KEY = "abracadabra_servers";
+const DEFAULT_ADJECTIVES = ["Swift", "Bright", "Mystic", "Cosmic", "Lucky", "Bold", "Wild", "Keen", "Deft", "Sly"];
+const DEFAULT_NOUNS = ["Wizard", "Mage", "Phoenix", "Raven", "Wolf", "Sage", "Bard", "Druid", "Seer", "Lynx"];
+function randomName(abraConfig) {
+  const adjs = abraConfig.guestName?.adjectives?.length ? abraConfig.guestName.adjectives : DEFAULT_ADJECTIVES;
+  const nouns = abraConfig.guestName?.nouns?.length ? abraConfig.guestName.nouns : DEFAULT_NOUNS;
+  return `${adjs[Math.floor(Math.random() * adjs.length)]}-${nouns[Math.floor(Math.random() * nouns.length)]}`;
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+function toBase64Url(bytes) {
+  let b = "";
+  for (const byte of bytes) b += String.fromCharCode(byte);
+  return btoa(b).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function fromBase64Url(str) {
+  const b = atob(str.replace(/-/g, "+").replace(/_/g, "/"));
+  const a = new Uint8Array(b.length);
+  for (let i = 0; i < b.length; i++) a[i] = b.charCodeAt(i);
+  return a;
+}
+async function fetchServerInfo(baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl}/info`);
+    if (res.ok) return await res.json();
+  } catch {
+  }
+  return {};
+}
+async function fetchSpacesInfo(baseUrl) {
+  try {
+    const [spacesRes, hubRes] = await Promise.all([
+      fetch(`${baseUrl}/spaces`),
+      fetch(`${baseUrl}/spaces/hub`)
+    ]);
+    if (!spacesRes.ok) return null;
+    const spacesData = await spacesRes.json();
+    const hubDocId = hubRes.ok ? (await hubRes.json()).doc_id : void 0;
+    return { spaces: spacesData.spaces, hubDocId };
+  } catch {
+    return null;
+  }
+}
+export default defineNuxtPlugin({
+  name: "abracadabra",
+  enforce: "post",
+  // run after shared-globals
+  async setup(nuxtApp) {
+    const config = useRuntimeConfig();
+    const abraConfig = config.public.abracadabra ?? {};
+    const defaultUrl = abraConfig.url ?? "https://abra.cou.sh";
+    const persistAuth = abraConfig.persistAuth ?? true;
+    const authStorageKey = abraConfig.authStorageKey ?? "abracadabra:auth";
+    const disabledBuiltins = abraConfig.disabledBuiltins ?? [];
+    const features = abraConfig.features ?? {};
+    const debug = abraConfig.debug ?? false;
+    const configEntryDocId = abraConfig.entryDocId || void 0;
+    const registry = new PluginRegistry();
+    const storedDisabledBuiltins = JSON.parse(
+      localStorage.getItem(STORAGE_KEY_DISABLED_BUILTINS) ?? "[]"
+    );
+    const allDisabled = [...disabledBuiltins, ...storedDisabledBuiltins];
+    if (!allDisabled.includes("core")) {
+      registry.register(corePlugin);
+    }
+    const storedExternal = JSON.parse(
+      localStorage.getItem(STORAGE_KEY_EXTERNAL_PLUGINS) ?? "[]"
+    );
+    for (const entry of storedExternal.filter((p) => p.enabled)) {
+      try {
+        const mod = await import(
+          /* @vite-ignore */
+          entry.url
+        );
+        const plugin = mod.default ?? mod;
+        if (plugin?.name) {
+          registry.register(plugin);
+          const updated = storedExternal.map(
+            (e) => e.url === entry.url ? { ...e, name: plugin.name, label: plugin.label, version: plugin.version, error: void 0 } : e
+          );
+          localStorage.setItem(STORAGE_KEY_EXTERNAL_PLUGINS, JSON.stringify(updated));
+        }
+      } catch (e) {
+        console.error(`[abracadabra] Failed to load plugin from ${entry.url}:`, e);
+        const updated = storedExternal.map(
+          (en) => en.url === entry.url ? { ...en, error: e?.message ?? String(e) } : en
+        );
+        localStorage.setItem(STORAGE_KEY_EXTERNAL_PLUGINS, JSON.stringify(updated));
+      }
+    }
+    registry.freeze();
+    if (debug) {
+      console.log("[abracadabra] plugins:", registry.getPlugins().map((p) => p.name));
+    }
+    const doc = shallowRef(new Y.Doc());
+    const provider = shallowRef(null);
+    const client = shallowRef(null);
+    const keystore = shallowRef(null);
+    const status = ref("disconnected");
+    const synced = ref(false);
+    const logs = ref([]);
+    const isReady = ref(false);
+    const publicKeyB64 = ref("");
+    const connectionError = ref(null);
+    const isClaimed = ref(false);
+    const identityLost = ref(false);
+    const needsReauth = ref(false);
+    const requirePasskeyOnLogin = ref(false);
+    const isConnectionBlocked = ref(false);
+    const userCount = ref(1);
+    const pendingInviteCode = ref(null);
+    const userName = ref(localStorage.getItem("abracadabra_username") || randomName(abraConfig));
+    const userColor = ref("hsl(217, 70%, 75%)");
+    const userColorName = ref("blue");
+    const userNeutralColorName = ref("zinc");
+    const currentServerUrl = ref(defaultUrl);
+    const savedServers = ref([]);
+    let _serversLoaded = false;
+    let _initPromise = null;
+    let _wsp = null;
+    let authFailureCount = 0;
+    const AUTH_FAILURE_LIMIT = 3;
+    let lastClientIds = /* @__PURE__ */ new Set();
+    const clientNameCache = /* @__PURE__ */ new Map();
+    function addLog(message, type = "system") {
+      logs.value = [...logs.value.slice(-200), { time: ts(), message, type }];
+    }
+    function loadServers() {
+      if (_serversLoaded) return;
+      _serversLoaded = true;
+      const DEFAULT_SERVER = { url: defaultUrl, label: new URL(defaultUrl).hostname };
+      try {
+        const raw = localStorage.getItem(SERVERS_KEY);
+        if (raw) savedServers.value = JSON.parse(raw);
+      } catch {
+      }
+      if (!savedServers.value.some((s) => s.url === DEFAULT_SERVER.url)) {
+        savedServers.value = [DEFAULT_SERVER, ...savedServers.value];
+        persistServers();
+      }
+    }
+    function persistServers() {
+      try {
+        localStorage.setItem(SERVERS_KEY, JSON.stringify(savedServers.value));
+      } catch {
+      }
+    }
+    async function addServer(rawUrl) {
+      let url = rawUrl.trim();
+      if (!url.startsWith("http://") && !url.startsWith("https://")) url = "https://" + url;
+      url = url.replace(/\/$/, "");
+      if (savedServers.value.some((s) => s.url === url)) return;
+      let label = url;
+      try {
+        label = new URL(url).hostname;
+      } catch {
+      }
+      const entry = { url, label };
+      const [info, spacesInfo] = await Promise.all([fetchServerInfo(url), fetchSpacesInfo(url)]);
+      if (info.index_doc_id) entry.entryDocId = info.index_doc_id;
+      if (info.name) entry.label = info.name;
+      if (spacesInfo) {
+        entry.spacesEnabled = true;
+        entry.cachedSpaces = spacesInfo.spaces;
+        if (spacesInfo.hubDocId) entry.hubDocId = spacesInfo.hubDocId;
+      }
+      savedServers.value = [...savedServers.value, entry];
+      persistServers();
+    }
+    function removeServer(url) {
+      if (url === defaultUrl) return;
+      savedServers.value = savedServers.value.filter((s) => s.url !== url);
+      persistServers();
+    }
+    const currentServerSpaces = computed(
+      () => savedServers.value.find((s) => s.url === currentServerUrl.value)?.cachedSpaces ?? []
+    );
+    const currentServerSpacesEnabled = computed(
+      () => savedServers.value.find((s) => s.url === currentServerUrl.value)?.spacesEnabled ?? false
+    );
+    async function refreshSpaces() {
+      const url = currentServerUrl.value;
+      if (!url) return;
+      const spacesInfo = await fetchSpacesInfo(url);
+      const idx = savedServers.value.findIndex((s) => s.url === url);
+      if (idx !== -1) {
+        if (spacesInfo) {
+          savedServers.value[idx] = { ...savedServers.value[idx], spacesEnabled: true, cachedSpaces: spacesInfo.spaces, hubDocId: spacesInfo.hubDocId ?? savedServers.value[idx].hubDocId };
+        }
+        persistServers();
+      }
+    }
+    async function createSpace(opts) {
+      if (!client.value) throw new Error("Not connected");
+      const result = await client.value.createSpace(opts);
+      await refreshSpaces();
+      return result;
+    }
+    async function updateSpace(id, opts) {
+      if (!client.value) throw new Error("Not connected");
+      const result = await client.value.updateSpace(id, opts);
+      await refreshSpaces();
+      return result;
+    }
+    async function deleteSpace(id) {
+      if (!client.value) throw new Error("Not connected");
+      await client.value.deleteSpace(id);
+      await refreshSpaces();
+    }
+    function setUserName(name) {
+      userName.value = name;
+      localStorage.setItem("abracadabra_username", name);
+      provider.value?.setAwarenessField("user", { name, color: userColor.value, publicKey: publicKeyB64.value });
+      client.value?.updateMe({ displayName: name }).catch(() => {
+      });
+    }
+    function setUserColor(colorName) {
+      const h = COLOR_HUES[colorName] ?? 0;
+      const hsl = `hsl(${h}, 70%, 75%)`;
+      userColor.value = hsl;
+      userColorName.value = colorName;
+      localStorage.setItem("abracadabra_usercolor", colorName);
+      const appConfig = useAppConfig();
+      if (appConfig.ui?.colors) appConfig.ui.colors.primary = colorName;
+      provider.value?.setAwarenessField("user", { name: userName.value, color: hsl, publicKey: publicKeyB64.value });
+    }
+    function setNeutralColor(colorName) {
+      userNeutralColorName.value = colorName;
+      localStorage.setItem("abracadabra_neutralcolor", colorName);
+      const appConfig = useAppConfig();
+      if (appConfig.ui?.colors) appConfig.ui.colors.neutral = colorName;
+    }
+    function setRequirePasskey(enabled) {
+      requirePasskeyOnLogin.value = enabled;
+      localStorage.setItem(REQUIRE_PASSKEY_KEY, enabled ? "1" : "0");
+    }
+    function reconnect() {
+      if (!_wsp) return;
+      authFailureCount = 0;
+      isConnectionBlocked.value = false;
+      connectionError.value = null;
+      _wsp.connect();
+    }
+    function _teardown() {
+      if (_wsp) {
+        _wsp.disconnect();
+        _wsp = null;
+      }
+      if (provider.value) {
+        try {
+          provider.value.destroy();
+        } catch {
+        }
+        ;
+        provider.value = null;
+      }
+      client.value = null;
+      keystore.value = null;
+      isReady.value = false;
+      synced.value = false;
+      status.value = "disconnected";
+      isConnectionBlocked.value = false;
+      connectionError.value = null;
+      authFailureCount = 0;
+      lastClientIds = /* @__PURE__ */ new Set();
+      clientNameCache.clear();
+      doc.value = new Y.Doc();
+      _destroyBackgroundSync();
+      _destroyFileBlobStore();
+      _destroySearchIndex();
+      _destroyNotifications();
+      _destroyChat();
+      _destroyFileIndex();
+    }
+    async function switchServer(url) {
+      if (url === currentServerUrl.value) return;
+      try {
+        localStorage.setItem(CURRENT_SERVER_KEY, url);
+      } catch {
+      }
+      addLog(`Switching server \u2192 ${url}`, "connection");
+      _teardown();
+      _initPromise = null;
+      _initPromise = init(url);
+      await _initPromise;
+    }
+    async function switchSpace(serverUrl, spaceDocId) {
+      if (serverUrl !== currentServerUrl.value) await switchServer(serverUrl);
+      await navigateTo(`${abraConfig.docBasePath ?? "/doc"}/${spaceDocId}`);
+    }
+    async function claimAccount() {
+      if (!client.value || !keystore.value) {
+        addLog("Cannot claim: client or keystore not initialized", "auth");
+        return;
+      }
+      addLog("Upgrading to hardware-bound identity...", "auth");
+      try {
+        const { publicKey: newPubKey, x25519PublicKey } = await keystore.value.register(
+          userName.value,
+          window.location.hostname,
+          "Abracadabra"
+        );
+        await client.value.addKey({
+          publicKey: newPubKey,
+          x25519Key: x25519PublicKey,
+          deviceName: "Hardware Auth (" + (navigator.platform || "Device") + ")"
+        });
+        publicKeyB64.value = newPubKey;
+        isClaimed.value = true;
+        identityLost.value = false;
+        localStorage.removeItem("abracadabra_privkey");
+        localStorage.setItem(CLAIMED_FLAG_KEY, "1");
+        localStorage.setItem(PUBKEY_KEY, newPubKey);
+        addLog("Account protected by hardware/biometrics", "auth");
+        return true;
+      } catch (e) {
+        addLog(`Claim failed: ${e.message}`, "auth");
+        throw e;
+      }
+    }
+    async function loginWithHardware(credentialIdHint) {
+      if (!keystore.value) throw new Error("Keystore not initialized");
+      try {
+        let hasPk;
+        let pubKey;
+        if (credentialIdHint) {
+          try {
+            pubKey = await keystore.value.getPublicKey(credentialIdHint);
+            hasPk = !!pubKey;
+          } catch {
+            hasPk = await keystore.value.hasIdentity();
+            pubKey = hasPk ? await keystore.value.getPublicKey() : null;
+          }
+        } else {
+          hasPk = await keystore.value.hasIdentity();
+          pubKey = hasPk ? await keystore.value.getPublicKey() : null;
+        }
+        if (!hasPk || !pubKey) throw new Error("No passkey found on this device.");
+        if (identityLost.value) {
+          identityLost.value = false;
+          isClaimed.value = true;
+          localStorage.setItem(CLAIMED_FLAG_KEY, "1");
+          localStorage.setItem(PUBKEY_KEY, pubKey);
+          addLog("Identity recovered via hardware key \u2014 reinitializing", "auth");
+          _teardown();
+          _initPromise = null;
+          _initPromise = init(currentServerUrl.value);
+          await _initPromise;
+          return true;
+        }
+        if (!client.value) throw new Error("Not connected to server");
+        const oldPubKey = publicKeyB64.value;
+        await client.value.loginWithKey(pubKey, (ch) => keystore.value.sign(ch));
+        publicKeyB64.value = pubKey;
+        isClaimed.value = true;
+        needsReauth.value = false;
+        localStorage.setItem(CLAIMED_FLAG_KEY, "1");
+        localStorage.setItem(PUBKEY_KEY, pubKey);
+        addLog("Re-authenticated via hardware key", "auth");
+        if (pubKey !== oldPubKey) {
+          _teardown();
+          _initPromise = null;
+          _initPromise = init(currentServerUrl.value);
+          await _initPromise;
+        } else if (_wsp) {
+          _wsp.disconnect();
+          setTimeout(() => _wsp?.connect(), 300);
+        }
+        return true;
+      } catch (e) {
+        addLog(`Hardware login failed: ${e.message}`, "auth");
+        throw e;
+      }
+    }
+    async function logout() {
+      addLog("Clearing identity...", "auth");
+      if (client.value) client.value.logout();
+      if (keystore.value) await keystore.value.clear();
+      localStorage.removeItem("abracadabra_privkey");
+      localStorage.removeItem("abracadabra_usercolor");
+      localStorage.removeItem("abracadabra_neutralcolor");
+      localStorage.removeItem("abracadabra_username");
+      localStorage.removeItem(CLAIMED_FLAG_KEY);
+      localStorage.removeItem(PUBKEY_KEY);
+      window.location.reload();
+    }
+    async function redeemInvite(code) {
+      if (!client.value) throw new Error("Not connected");
+      await client.value.redeemInvite(code);
+      addLog(`Invite redeemed: ${code}`, "auth");
+      const pubKey = publicKeyB64.value;
+      if (pubKey) {
+        try {
+          const ed = await import("@noble/ed25519");
+          const storedPrivKey = localStorage.getItem("abracadabra_privkey");
+          await client.value.loginWithKey(pubKey, async (ch) => {
+            if (isClaimed.value && keystore.value) return keystore.value.sign(ch);
+            if (storedPrivKey) {
+              const privKey = fromBase64Url(storedPrivKey);
+              const sig = await ed.sign(fromBase64Url(ch), privKey);
+              return toBase64Url(sig);
+            }
+            throw new Error("No signing key available");
+          });
+          if (_wsp) {
+            _wsp.disconnect();
+            setTimeout(() => _wsp?.connect(), 300);
+          }
+        } catch {
+        }
+      }
+    }
+    async function createInvite(opts) {
+      if (!client.value) throw new Error("Not connected");
+      return client.value.createInvite(opts);
+    }
+    async function listInvites() {
+      if (!client.value) throw new Error("Not connected");
+      return client.value.listInvites();
+    }
+    async function revokeInvite(code) {
+      if (!client.value) throw new Error("Not connected");
+      return client.value.revokeInvite(code);
+    }
+    async function init(serverUrl) {
+      currentServerUrl.value = serverUrl;
+      addLog("Initializing Abracadabra...", "system");
+      if (!pendingInviteCode.value) {
+        const urlParams = new URLSearchParams(window.location.search);
+        const hashParams = new URLSearchParams(window.location.hash.replace(/^#/, ""));
+        const code = urlParams.get("invite") || hashParams.get("invite");
+        if (code) {
+          pendingInviteCode.value = code.toUpperCase();
+          addLog(`Invite code found in URL: ${pendingInviteCode.value}`, "auth");
+        }
+      }
+      try {
+        const [
+          { AbracadabraClient, AbracadabraProvider, HocuspocusProviderWebsocket, CryptoIdentityKeystore },
+          ed,
+          { sha512 }
+        ] = await Promise.all([
+          import("@abraca/dabra"),
+          import("@noble/ed25519"),
+          import("@noble/hashes/sha512")
+        ]);
+        ed.etc.sha512Sync = (m) => sha512(m);
+        const ks = new CryptoIdentityKeystore();
+        keystore.value = ks;
+        let privKey = null;
+        let pubKey;
+        const storedName = localStorage.getItem("abracadabra_username");
+        if (storedName) userName.value = storedName;
+        else localStorage.setItem("abracadabra_username", userName.value);
+        const wasPreviouslyClaimed = localStorage.getItem(CLAIMED_FLAG_KEY) === "1";
+        const storedPubKey = localStorage.getItem(PUBKEY_KEY);
+        requirePasskeyOnLogin.value = localStorage.getItem(REQUIRE_PASSKEY_KEY) === "1";
+        if (wasPreviouslyClaimed && storedPubKey) {
+          pubKey = storedPubKey;
+          isClaimed.value = true;
+          identityLost.value = false;
+          addLog("Restored claimed identity from cache", "auth");
+        } else if (wasPreviouslyClaimed && !storedPubKey) {
+          identityLost.value = true;
+          isClaimed.value = false;
+          addLog("Previously claimed account \u2014 cached key missing, waiting for recovery", "auth");
+          publicKeyB64.value = "";
+          return;
+        } else {
+          const storedPrivKey = localStorage.getItem("abracadabra_privkey");
+          if (storedPrivKey) {
+            privKey = fromBase64Url(storedPrivKey);
+            addLog("Using guest identity (soft key)", "auth");
+          } else {
+            privKey = ed.utils.randomPrivateKey();
+            localStorage.setItem("abracadabra_privkey", toBase64Url(privKey));
+            addLog("Created new guest identity (soft key)", "auth");
+          }
+          isClaimed.value = false;
+          identityLost.value = false;
+          const pubKeyBytes = ed.getPublicKey(privKey);
+          pubKey = toBase64Url(pubKeyBytes);
+        }
+        publicKeyB64.value = pubKey;
+        const storedColor = localStorage.getItem("abracadabra_usercolor");
+        const storedNeutral = localStorage.getItem("abracadabra_neutralcolor");
+        const derived = deriveColorFromPubKey(pubKey);
+        if (storedColor && UI_COLORS.includes(storedColor)) {
+          const h = COLOR_HUES[storedColor] ?? 0;
+          userColor.value = `hsl(${h}, 70%, 75%)`;
+          userColorName.value = storedColor;
+        } else {
+          userColor.value = derived.hsl;
+          userColorName.value = derived.name;
+        }
+        if (storedNeutral && UI_NEUTRALS.includes(storedNeutral)) {
+          userNeutralColorName.value = storedNeutral;
+        } else {
+          userNeutralColorName.value = derived.neutralName;
+        }
+        try {
+          const appConfig = useAppConfig();
+          if (appConfig.ui?.colors) {
+            appConfig.ui.colors.primary = userColorName.value;
+            appConfig.ui.colors.neutral = userNeutralColorName.value;
+          }
+        } catch {
+        }
+        addLog(`Public key: ${pubKey.slice(0, 16)}...`, "auth");
+        const signChallengeFn = async (challenge) => {
+          if (isClaimed.value) return await ks.sign(challenge);
+          if (privKey) {
+            const sig = await ed.sign(fromBase64Url(challenge), privKey);
+            return toBase64Url(sig);
+          }
+          throw new Error("No identity available for signing");
+        };
+        const _client = new AbracadabraClient({ url: serverUrl, persistAuth, storageKey: authStorageKey });
+        client.value = _client;
+        addLog(`Server: ${serverUrl}`, "connection");
+        if (_client.isAuthenticated && isClaimed.value) {
+          addLog("Resumed session from persisted token", "auth");
+        } else if (isClaimed.value && !requirePasskeyOnLogin.value) {
+          needsReauth.value = true;
+          addLog("Session expired \u2014 passkey sign-in available", "auth");
+        } else {
+          needsReauth.value = false;
+          try {
+            await _client.registerWithKey({
+              publicKey: pubKey,
+              displayName: userName.value,
+              inviteCode: pendingInviteCode.value ?? void 0
+            });
+            addLog("Registered with crypto identity", "auth");
+            if (pendingInviteCode.value) {
+              addLog("Invite code applied during registration", "auth");
+              pendingInviteCode.value = null;
+            }
+          } catch (e) {
+            if (!e.message?.includes("already exists")) addLog(`Register: ${e.message}`, "auth");
+          }
+          try {
+            const token = await _client.loginWithKey(pubKey, (ch) => signChallengeFn(ch));
+            addLog("Authenticated via Ed25519 challenge-response", "auth");
+            addLog(`JWT obtained (${token.slice(0, 12)}...)`, "auth");
+          } catch (e) {
+            addLog(`Login failed: ${e.message}`, "auth");
+          }
+        }
+        _client.updateMe({ displayName: userName.value }).catch(() => {
+        });
+        const [info, spacesInfo] = await Promise.all([
+          fetchServerInfo(serverUrl),
+          fetchSpacesInfo(serverUrl)
+        ]);
+        const idx = savedServers.value.findIndex((s) => s.url === serverUrl);
+        if (idx >= 0) {
+          const updates = {};
+          if (info.name && info.name !== savedServers.value[idx].label) updates.label = info.name;
+          if (spacesInfo) {
+            updates.spacesEnabled = true;
+            updates.cachedSpaces = spacesInfo.spaces;
+            if (spacesInfo.hubDocId) updates.hubDocId = spacesInfo.hubDocId;
+          }
+          if (Object.keys(updates).length) {
+            savedServers.value[idx] = { ...savedServers.value[idx], ...updates };
+            persistServers();
+          }
+        }
+        const server = savedServers.value.find((s) => s.url === serverUrl);
+        let docId = configEntryDocId ?? server?.hubDocId ?? spacesInfo?.hubDocId ?? server?.cachedSpaces?.[0]?.doc_id ?? spacesInfo?.spaces?.[0]?.doc_id ?? server?.entryDocId ?? info.index_doc_id ?? void 0;
+        if (!docId) {
+          connectionError.value = "No entry document found. Configure entryDocId or ensure the server has spaces or an index document.";
+          addLog("No entry document \u2014 cannot connect", "system");
+          try {
+            const { useToast } = await import("#imports");
+            useToast().add({ title: "Server not configured", description: "No entry document found. Set entryDocId in your abracadabra module config.", color: "error" });
+          } catch {
+          }
+          return;
+        }
+        addLog(`Using document: ${docId}`, "data");
+        const wsUrl = _client.wsUrl;
+        addLog(`WebSocket: ${wsUrl}`, "connection");
+        const wsp = new HocuspocusProviderWebsocket({
+          url: wsUrl,
+          delay: 1e3,
+          minDelay: 1e3,
+          maxDelay: 3e4,
+          factor: 2,
+          jitter: true,
+          maxAttempts: 0
+        });
+        _wsp = wsp;
+        const _doc = new Y.Doc();
+        doc.value = _doc;
+        let wasConnected = false;
+        const _provider = new AbracadabraProvider({
+          name: docId,
+          document: _doc,
+          websocketProvider: wsp,
+          client: _client,
+          onStatus({ status: s }) {
+            if (s === status.value) return;
+            const oldStatus = status.value;
+            status.value = s;
+            if (s === "connected") {
+              connectionError.value = null;
+              return;
+            }
+            if (s === "connecting" && oldStatus === "disconnected") return;
+            if (s === "disconnected" && oldStatus === "connecting") return;
+            addLog(`WebSocket: ${s}`, "connection");
+          },
+          onSynced({ state }) {
+            const wasSynced = synced.value;
+            synced.value = state;
+            if (state) {
+              addLog("Document synced", "sync");
+              isReady.value = true;
+              if (wasConnected && !wasSynced) {
+                addLog("Reconnected", "connection");
+                try {
+                  import("#imports").then(({ useToast }) => {
+                    useToast().add({ title: "Reconnected", color: "success", duration: 2e3 });
+                  }).catch(() => {
+                  });
+                } catch {
+                }
+              }
+              wasConnected = true;
+              if (!wasSynced && features.backgroundSync !== false) {
+                import("@abraca/dabra").then(({ BackgroundSyncManager }) => {
+                  if (_client && _provider) {
+                    const manager = new BackgroundSyncManager(_client, _provider);
+                    _initBackgroundSync(manager);
+                    if (features.search !== false) {
+                      _initSearchIndex(serverUrl);
+                      _initFileIndex();
+                    }
+                  }
+                }).catch(() => {
+                });
+              }
+              try {
+                _provider.sendStateless?.(JSON.stringify({ type: "notify:fetch", limit: 20 }));
+              } catch {
+              }
+              try {
+                const trashMap = _doc.getMap("doc-trash");
+                const settings = (() => {
+                  try {
+                    return JSON.parse(localStorage.getItem("abracadabra_trash_settings") || "{}");
+                  } catch {
+                    return {};
+                  }
+                })();
+                const purgeDays = settings.autoPurgeDays ?? 30;
+                if (purgeDays > 0) {
+                  const cutoff = Date.now() - purgeDays * 24 * 60 * 60 * 1e3;
+                  const expired = [];
+                  trashMap.forEach((val, key) => {
+                    if (val?.deletedAt < cutoff) expired.push(key);
+                  });
+                  if (expired.length) _doc.transact(() => {
+                    for (const id of expired) trashMap.delete(id);
+                  });
+                }
+              } catch {
+              }
+            }
+          },
+          onAuthenticated({ scope }) {
+            addLog(`Scope: ${scope}`, "auth");
+            connectionError.value = null;
+            authFailureCount = 0;
+          },
+          onAuthenticationFailed({ reason }) {
+            authFailureCount++;
+            const msg = reason || "Authentication failed";
+            const isPermanent = /disabled|not allowed|forbidden|revoked/i.test(msg);
+            if (isPermanent || authFailureCount >= AUTH_FAILURE_LIMIT) {
+              isConnectionBlocked.value = true;
+              connectionError.value = `${msg} \u2014 reconnection paused`;
+              addLog(`Auth denied \u2014 pausing reconnect: ${msg}`, "auth");
+              wsp.disconnect();
+            } else {
+              connectionError.value = msg;
+              addLog(`Denied: ${msg}`, "auth");
+            }
+          },
+          onAwarenessChange({ states }) {
+            const currentIds = new Set(states.map((s) => s.clientId));
+            for (const id of currentIds) {
+              const state = states.find((s) => s.clientId === id);
+              const name = state?.user?.name || "Anonymous";
+              clientNameCache.set(id, name);
+              if (!lastClientIds.has(id) && id !== _provider?.awareness?.clientID) {
+                addLog(`${name} joined (${states.length} online)`, "user");
+              }
+            }
+            for (const id of lastClientIds) {
+              if (!currentIds.has(id)) {
+                const name = clientNameCache.get(id) || "User";
+                addLog(`${name} left (${states.length} online)`, "user");
+                clientNameCache.delete(id);
+              }
+            }
+            lastClientIds = currentIds;
+            userCount.value = states.length;
+          },
+          onDisconnect() {
+            if (status.value === "connected") {
+              addLog("Disconnected", "connection");
+            }
+          }
+        });
+        _provider.setAwarenessField("user", { name: userName.value, color: userColor.value, publicKey: publicKeyB64.value });
+        _provider.attach();
+        provider.value = _provider;
+        try {
+          const { FileBlobStore } = await import("@abraca/dabra");
+          const blobStore = new FileBlobStore(_client);
+          _initFileBlobStore(blobStore);
+        } catch {
+        }
+        _initNotifications(publicKeyB64);
+        _initChat(publicKeyB64, userName);
+        if (_provider.onStateless !== void 0) {
+          _provider.onStateless = (payload) => {
+            _handleStatelessNotification(payload);
+            _handleStatelessChat(payload);
+          };
+        }
+        _provider.ready.then(() => {
+          isReady.value = true;
+        }, () => null);
+        watch(
+          [userName, userColor, publicKeyB64],
+          () => {
+            _provider.setAwarenessField("user", { name: userName.value, color: userColor.value, publicKey: publicKeyB64.value });
+          },
+          { immediate: true }
+        );
+        addLog("Provider attached, connecting...", "connection");
+      } catch (e) {
+        addLog(`Error: ${e.message}`, "system");
+        console.error("[abracadabra] init error:", e);
+      }
+    }
+    const abra = {
+      doc,
+      provider,
+      client,
+      keystore,
+      status,
+      synced,
+      isReady,
+      logs,
+      userName,
+      userColor,
+      userColorName,
+      userNeutralColorName,
+      userCount,
+      publicKeyB64,
+      connectionError,
+      isClaimed,
+      identityLost,
+      needsReauth,
+      requirePasskeyOnLogin,
+      isConnectionBlocked,
+      currentServerUrl,
+      savedServers,
+      currentServerSpaces,
+      currentServerSpacesEnabled,
+      pendingInviteCode,
+      registry,
+      addLog,
+      setUserName,
+      setUserColor,
+      setNeutralColor,
+      setRequirePasskey,
+      claimAccount,
+      loginWithHardware,
+      logout,
+      reconnect,
+      addServer,
+      removeServer,
+      switchServer,
+      switchSpace,
+      refreshSpaces,
+      createSpace,
+      updateSpace,
+      deleteSpace,
+      redeemInvite,
+      createInvite,
+      listInvites,
+      revokeInvite,
+      init
+    };
+    nuxtApp.provide("abracadabra", abra);
+    if (debug) {
+      watch(abra.status, (s) => console.log("[abracadabra] status \u2192", s));
+      watch(abra.synced, (s) => console.log("[abracadabra] synced \u2192", s));
+    }
+    loadServers();
+    const storedServer = localStorage.getItem(CURRENT_SERVER_KEY);
+    const initialUrl = storedServer && savedServers.value.some((s) => s.url === storedServer) ? storedServer : currentServerUrl.value || savedServers.value[0]?.url || defaultUrl;
+    if (initialUrl !== currentServerUrl.value) currentServerUrl.value = initialUrl;
+    _initPromise = init(initialUrl);
+    _initPromise.then(async () => {
+      if (!provider.value) return;
+      const ctx = { abracadabra: abra };
+      const teardowns = [];
+      for (const plugin of registry.getPlugins()) {
+        if (plugin.clientSetup) {
+          try {
+            const result = await plugin.clientSetup(ctx);
+            if (typeof result === "function") teardowns.push(result);
+          } catch (e) {
+            console.error(`[abracadabra] Plugin "${plugin.name}" clientSetup failed:`, e);
+          }
+        }
+      }
+      const shortcuts = registry.getAllKeyboardShortcuts();
+      if (shortcuts.length > 0) {
+        const handleKey = (e) => {
+          for (const s of shortcuts) {
+            const parts = s.key.split("+");
+            const key = parts[parts.length - 1].toLowerCase();
+            const needsMeta = parts.includes("Meta") || parts.includes("Cmd");
+            const needsCtrl = parts.includes("Control") || parts.includes("Ctrl");
+            const needsShift = parts.includes("Shift");
+            const needsAlt = parts.includes("Alt");
+            if (e.key.toLowerCase() === key && (!needsMeta || e.metaKey || e.ctrlKey) && (!needsCtrl || e.ctrlKey) && (!needsShift || e.shiftKey) && (!needsAlt || e.altKey)) {
+              e.preventDefault();
+              s.handler();
+            }
+          }
+        };
+        document.addEventListener("keydown", handleKey);
+        nuxtApp.hook("app:beforeMount", () => {
+          nuxtApp.hook("app:suspense:resolve", () => {
+          });
+        });
+        const origUnmount = nuxtApp._cleanup;
+        nuxtApp._cleanup = () => {
+          document.removeEventListener("keydown", handleKey);
+          teardowns.forEach((fn) => fn());
+          origUnmount?.();
+        };
+      }
+    }).catch((e) => console.error("[abracadabra] boot error:", e));
+  }
+});