@abraca/nuxt 0.3.0 → 1.5.0

package/dist/runtime/composables/useEditorSuggestions.js

@@ -1,4 +1,6 @@
+import { computed } from "vue";
 import { META_FIELD_DEFINITIONS } from "../utils/metaFieldDefinitions.js";
+import { usePluginRegistry } from "./usePluginRegistry.js";
 export function useEditorSuggestions(options = {}) {
   const registry = usePluginRegistry();
   const items = computed(() => {
@@ -6,21 +8,24 @@ export function useEditorSuggestions(options = {}) {
     const base = options.onlyPlugins ? [] : [
       [
         { type: "label", label: "Style" },
-        { kind: "paragraph", label: "Paragraph", icon: "i-lucide-type" },
-        { kind: "heading", level: 1, label: "Heading 1", icon: "i-lucide-heading-1" },
-        { kind: "heading", level: 2, label: "Heading 2", icon: "i-lucide-heading-2" },
-        { kind: "heading", level: 3, label: "Heading 3", icon: "i-lucide-heading-3" },
-        { kind: "bulletList", label: "Bullet List", icon: "i-lucide-list" },
-        { kind: "orderedList", label: "Numbered List", icon: "i-lucide-list-ordered" },
-        { kind: "taskList", label: "Task List", icon: "i-lucide-list-check" },
-        { kind: "blockquote", label: "Blockquote", icon: "i-lucide-text-quote" },
-        { kind: "codeBlock", label: "Code Block", icon: "i-lucide-square-code" }
+        { kind: "paragraph", label: "Paragraph", icon: "i-lucide-type", description: "Plain text block", keywords: ["text", "body"] },
+        { kind: "heading", level: 1, label: "Heading 1", icon: "i-lucide-heading-1", description: "Large section heading", keywords: ["h1", "title"] },
+        { kind: "heading", level: 2, label: "Heading 2", icon: "i-lucide-heading-2", description: "Medium section heading", keywords: ["h2", "subtitle"] },
+        { kind: "heading", level: 3, label: "Heading 3", icon: "i-lucide-heading-3", description: "Small section heading", keywords: ["h3"] },
+        { kind: "bulletList", label: "Bullet List", icon: "i-lucide-list", description: "Unordered list", keywords: ["ul", "bullets"] },
+        { kind: "orderedList", label: "Numbered List", icon: "i-lucide-list-ordered", description: "Numbered list", keywords: ["ol", "numbers"] },
+        { kind: "taskList", label: "Task List", icon: "i-lucide-list-check", description: "Checkable task list", keywords: ["todo", "checkbox", "checklist"] },
+        { kind: "blockquote", label: "Blockquote", icon: "i-lucide-text-quote", description: "Quoted text block", keywords: ["quote", "cite"] },
+        { kind: "codeBlock", label: "Code Block", icon: "i-lucide-square-code", description: "Code with syntax highlighting", keywords: ["code", "syntax", "pre"] }
       ],
       [
         { type: "label", label: "Insert" },
-        { kind: "mention", label: "Mention", icon: "i-lucide-at-sign" },
-        { kind: "table", label: "Table", icon: "i-lucide-table" },
-        { kind: "horizontalRule", label: "Divider", icon: "i-lucide-minus" }
+        { kind: "mention", label: "Mention", icon: "i-lucide-at-sign", description: "Mention a person or document", keywords: ["user", "people", "tag"] },
+        { kind: "table", label: "Table", icon: "i-lucide-table", description: "Insert a table", keywords: ["grid", "rows", "columns"] },
+        { kind: "horizontalRule", label: "Divider", icon: "i-lucide-minus", description: "Visual separator", keywords: ["line", "separator", "hr"] },
+        { kind: "docEmbed", label: "Document Embed", icon: "i-lucide-file-symlink", description: "Embed another document", keywords: ["embed", "include", "transclusion", "link"] },
+        { kind: "imageUpload", label: "Image", icon: "i-lucide-image", description: "Upload an image", keywords: ["picture", "photo", "upload", "img"] },
+        { kind: "fileUpload", label: "File", icon: "i-lucide-paperclip", description: "Upload a file attachment", keywords: ["attachment", "upload", "document"] }
       ],
       [
         { type: "label", label: "Properties" },
@@ -33,13 +38,16 @@ export function useEditorSuggestions(options = {}) {
       ],
       [
         { type: "label", label: "Components" },
-        { kind: "callout", label: "Callout", icon: "i-lucide-info" },
-        { kind: "collapsible", label: "Collapsible", icon: "i-lucide-chevron-down" },
-        { kind: "accordion", label: "Accordion", icon: "i-lucide-chevrons-down-up" },
-        { kind: "tabs", label: "Tabs", icon: "i-lucide-panel-top" },
-        { kind: "card", label: "Card", icon: "i-lucide-square" },
-        { kind: "steps", label: "Steps", icon: "i-lucide-list-ordered" },
-        { kind: "codeGroup", label: "Code Group", icon: "i-lucide-folder-code" }
+        { kind: "callout", label: "Callout", icon: "i-lucide-info", description: "Highlighted info box", keywords: ["alert", "note", "warning", "tip"] },
+        { kind: "collapsible", label: "Collapsible", icon: "i-lucide-chevron-down", description: "Expandable content section", keywords: ["toggle", "expand", "collapse", "details"] },
+        { kind: "accordion", label: "Accordion", icon: "i-lucide-chevrons-down-up", description: "Multiple collapsible sections", keywords: ["faq", "expand"] },
+        { kind: "tabs", label: "Tabs", icon: "i-lucide-panel-top", description: "Tabbed content panels", keywords: ["switch", "panels"] },
+        { kind: "card", label: "Card", icon: "i-lucide-square", description: "Bordered content card", keywords: ["box", "container", "panel"] },
+        { kind: "steps", label: "Steps", icon: "i-lucide-list-ordered", description: "Numbered step-by-step guide", keywords: ["guide", "tutorial", "process"] },
+        { kind: "codeGroup", label: "Code Group", icon: "i-lucide-folder-code", description: "Tabbed code blocks", keywords: ["code", "multi", "language"] },
+        { kind: "codePreview", label: "Code Preview", icon: "i-lucide-eye", description: "Live code with preview", keywords: ["demo", "preview", "live"] },
+        { kind: "codeTree", label: "Code Tree", icon: "i-lucide-folder-tree", description: "File tree visualization", keywords: ["files", "directory", "structure"] },
+        { kind: "fieldGroup", label: "Field Group", icon: "i-lucide-rows-3", description: "Group of form fields", keywords: ["form", "fields", "properties", "meta"] }
       ]
     ];
     try {

package/dist/runtime/composables/useEditorToolbar.d.ts

@@ -18,5 +18,5 @@ export interface UseEditorToolbarOptions {
     extraItems?: any[][];
 }
 export declare function useEditorToolbar(options?: UseEditorToolbarOptions): {
-    items: any;
+    items: import("vue").ComputedRef<any[][]>;
 };

package/dist/runtime/composables/useEditorToolbar.js

@@ -1,3 +1,6 @@
+import { computed } from "vue";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { usePluginRegistry } from "./usePluginRegistry.js";
 export function useEditorToolbar(options = {}) {
   const registry = usePluginRegistry();
   const abra = useAbracadabra();

package/dist/runtime/composables/useFavorites.d.ts

@@ -0,0 +1,13 @@
+import type { ShallowRef } from 'vue';
+import type * as Y from 'yjs';
+export declare function useFavorites(rootDoc: ShallowRef<Y.Doc | null>, options?: {
+    readonly?: boolean;
+}): {
+    favorites: import("vue").ComputedRef<string[]>;
+    isFavorite: (id: string) => boolean;
+    addFavorite: (id: string) => void;
+    addFavoriteAt: (id: string, index: number) => void;
+    removeFavorite: (id: string) => void;
+    moveFavorite: (from: number, to: number) => void;
+    toggleFavorite: (id: string) => void;
+};

package/dist/runtime/composables/useFavorites.js

@@ -0,0 +1,42 @@
+import { computed } from "vue";
+import { useSyncedArray } from "./useYDoc.js";
+export function useFavorites(rootDoc, options) {
+  const { list, push, deleteAt, insert } = useSyncedArray(
+    rootDoc,
+    "doc-favorites"
+  );
+  const favorites = computed(() => list.value);
+  function isFavorite(id) {
+    return list.value.includes(id);
+  }
+  function addFavorite(id) {
+    if (options?.readonly) return;
+    if (!isFavorite(id)) push(id);
+  }
+  function removeFavorite(id) {
+    if (options?.readonly) return;
+    const idx = list.value.indexOf(id);
+    if (idx >= 0) deleteAt(idx);
+  }
+  function moveFavorite(from, to) {
+    if (options?.readonly) return;
+    const doc = rootDoc.value;
+    if (!doc) return;
+    const id = list.value[from];
+    if (!id) return;
+    doc.transact(() => {
+      deleteAt(from);
+      insert(to > from ? to - 1 : to, [id]);
+    });
+  }
+  function addFavoriteAt(id, index) {
+    if (options?.readonly) return;
+    if (isFavorite(id)) return;
+    insert(Math.min(index, list.value.length), [id]);
+  }
+  function toggleFavorite(id) {
+    if (isFavorite(id)) removeFavorite(id);
+    else addFavorite(id);
+  }
+  return { favorites, isFavorite, addFavorite, addFavoriteAt, removeFavorite, moveFavorite, toggleFavorite };
+}

package/dist/runtime/composables/useFileIndex.js

@@ -1,5 +1,7 @@
 import { watch } from "vue";
 import * as Y from "yjs";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { useBackgroundSync } from "./useBackgroundSync.js";
 let _fileEntries = /* @__PURE__ */ new Map();
 let _stopWatcher = null;
 function walkXmlForFiles(node, docId, docLabel, results) {

package/dist/runtime/composables/useFileTransfer.js

@@ -1,4 +1,6 @@
 import { ref, shallowRef } from "vue";
+import { useWebRTC } from "./useWebRTC.js";
+const MAX_COMPLETED_FILES = 50;
 const inboundTransfers = shallowRef(/* @__PURE__ */ new Map());
 const outboundTransfers = shallowRef(/* @__PURE__ */ new Map());
 const completedFiles = ref([]);
@@ -38,7 +40,7 @@ export function _wireFileTransferEvents(rtc) {
     next.delete(data.transferId);
     inboundTransfers.value = next;
     const objectUrl = URL.createObjectURL(data.blob);
-    completedFiles.value = [
+    const updated = [
       ...completedFiles.value,
       {
         transferId: data.transferId,
@@ -51,6 +53,16 @@ export function _wireFileTransferEvents(rtc) {
         receivedAt: Date.now()
       }
     ];
+    while (updated.length > MAX_COMPLETED_FILES) {
+      const evicted = updated.shift();
+      if (evicted) {
+        try {
+          URL.revokeObjectURL(evicted.objectUrl);
+        } catch {
+        }
+      }
+    }
+    completedFiles.value = updated;
   });
   on("fileReceiveError", (data) => {
     const existing = inboundTransfers.value.get(data.transferId);

package/dist/runtime/composables/useFollowUser.js

@@ -1,4 +1,6 @@
 import { ref } from "vue";
+import { navigateTo } from "#imports";
+import { useDocSlugs } from "./useDocSlugs.js";
 const followingUserKey = ref(null);
 let cleanup = null;
 let navLock = false;

package/dist/runtime/composables/useIdentityDoc.d.ts

@@ -0,0 +1,89 @@
+import type * as Y from 'yjs';
+/**
+ * Initialize the identity doc for the given public key.
+ * Call this once the keystore has provided the account-level public key.
+ * Safe to call multiple times — only the first call initializes.
+ *
+ * @param publicKeyB64 Base64url Ed25519 public key
+ * @param signChallenge Optional signing function for crypto auth with servers
+ * @param opts Optional WebRTC/E2EE config (consuming app provides its own E2EE setup)
+ * @param opts.webrtc WebRTC configuration
+ * @param opts.webrtc.signalingServerUrl URL of the signaling server
+ * @param opts.webrtc.token Function returning a token promise
+ * @param opts.webrtc.e2ee End-to-end encryption keypair
+ * @param opts.webrtc.e2ee.publicKey Public key for E2EE
+ * @param opts.webrtc.e2ee.privateKey Private key for E2EE
+ */
+declare function init(publicKeyB64: string, signChallenge?: (challenge: string) => Promise<string>, opts?: {
+    webrtc?: {
+        signalingServerUrl: string;
+        token: () => Promise<string>;
+        e2ee?: {
+            publicKey: string;
+            privateKey: string;
+        };
+    };
+}): Promise<void>;
+declare function setUserName(name: string): void;
+declare function setUserColor(colorName: string): void;
+declare function setNeutralColor(colorName: string): void;
+declare function setSecurityTier(tier: 'relaxed' | 'standard' | 'paranoid'): void;
+declare function getServers(): Map<string, any>;
+declare function setServer(url: string, entry: any): void;
+declare function removeServer(url: string): void;
+declare function getSpaces(): any[];
+declare function addSpace(space: any): void;
+declare function removeSpace(spaceId: string): void;
+declare function updateSpace(spaceId: string, updates: Record<string, any>): void;
+declare function observeSpaces(callback: (event: any, transaction: any) => void): () => void;
+declare function getDevices(): Map<string, any>;
+declare function getDevice(publicKey: string): any | undefined;
+declare function addDevice(publicKey: string, opts: {
+    deviceName: string;
+    tier?: string;
+    x25519Key?: string;
+    serverUrl?: string;
+    keyId?: string;
+}): void;
+declare function revokeDevice(publicKey: string, revokedBy: string): void;
+declare function observeDevices(callback: (events: any[], transaction: any) => void): () => void;
+declare function connectSyncServer(url: string): void;
+declare function disconnectSyncServer(): void;
+declare function setSyncServerUrl(url: string | null): void;
+declare function getSyncServerUrl(): string | null;
+declare function getDocument(): Y.Doc | null;
+declare function getProvider(): any;
+declare function destroy(): void;
+export declare function useIdentityDoc(): {
+    ready: import("vue").Ref<boolean, boolean>;
+    userName: import("vue").Ref<string, string>;
+    userColorName: import("vue").Ref<string, string>;
+    neutralColorName: import("vue").Ref<string, string>;
+    securityTier: import("vue").Ref<"relaxed" | "standard" | "paranoid", "relaxed" | "standard" | "paranoid">;
+    init: typeof init;
+    destroy: typeof destroy;
+    setUserName: typeof setUserName;
+    setUserColor: typeof setUserColor;
+    setNeutralColor: typeof setNeutralColor;
+    setSecurityTier: typeof setSecurityTier;
+    getServers: typeof getServers;
+    setServer: typeof setServer;
+    removeServer: typeof removeServer;
+    getSpaces: typeof getSpaces;
+    addSpace: typeof addSpace;
+    removeSpace: typeof removeSpace;
+    updateSpace: typeof updateSpace;
+    observeSpaces: typeof observeSpaces;
+    getDevices: typeof getDevices;
+    getDevice: typeof getDevice;
+    addDevice: typeof addDevice;
+    revokeDevice: typeof revokeDevice;
+    observeDevices: typeof observeDevices;
+    connectSyncServer: typeof connectSyncServer;
+    disconnectSyncServer: typeof disconnectSyncServer;
+    setSyncServerUrl: typeof setSyncServerUrl;
+    getSyncServerUrl: typeof getSyncServerUrl;
+    getDocument: typeof getDocument;
+    getProvider: typeof getProvider;
+};
+export {};

package/dist/runtime/composables/useIdentityDoc.js

@@ -0,0 +1,349 @@
+import { ref } from "vue";
+const SYNC_SERVER_KEY = "abracadabra_identity_sync_server";
+let _provider = null;
+let _initPromise = null;
+let _publicKey = null;
+let _signChallengeFn = null;
+const _ready = ref(false);
+const userName = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_username") || ""
+);
+const userColorName = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_usercolor") || "blue"
+);
+const neutralColorName = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_neutralcolor") || "zinc"
+);
+const securityTier = ref(
+  typeof localStorage !== "undefined" && localStorage.getItem("abracadabra_security_tier") || "standard"
+);
+async function init(publicKeyB64, signChallenge, opts) {
+  if (_initPromise) return _initPromise;
+  _publicKey = publicKeyB64;
+  _signChallengeFn = signChallenge ?? null;
+  _initPromise = _doInit(publicKeyB64, opts);
+  return _initPromise;
+}
+async function _doInit(publicKeyB64, opts) {
+  if (typeof window === "undefined") return;
+  const { IdentityDocProvider } = await import("@abraca/dabra");
+  const providerConfig = {
+    publicKey: publicKeyB64,
+    autoConnect: false,
+    disableOfflineStore: false
+  };
+  if (_signChallengeFn) {
+    providerConfig.cryptoIdentity = { publicKey: publicKeyB64 };
+    providerConfig.signChallenge = _signChallengeFn;
+  }
+  if (opts?.webrtc) {
+    providerConfig.webrtc = opts.webrtc;
+  }
+  _provider = new IdentityDocProvider(providerConfig);
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  if (_provider.isEmpty()) {
+    _migrateFromLocalStorage(_provider);
+  }
+  _syncRefsFromDoc(_provider);
+  _observeDoc(_provider);
+  _ready.value = true;
+  const syncUrl = _getSyncServerUrl();
+  if (syncUrl) {
+    _provider.connectToServer("sync", syncUrl);
+  }
+}
+function _migrateFromLocalStorage(provider) {
+  const doc = provider.document;
+  doc.transact(() => {
+    const profile = doc.getMap("profile");
+    const storedName = localStorage.getItem("abracadabra_username");
+    if (storedName) profile.set("username", storedName);
+    const storedColor = localStorage.getItem("abracadabra_usercolor");
+    if (storedColor) profile.set("colorName", storedColor);
+    const storedNeutral = localStorage.getItem("abracadabra_neutralcolor");
+    if (storedNeutral) profile.set("neutralColorName", storedNeutral);
+    const serversMap = doc.getMap("servers");
+    try {
+      const raw = localStorage.getItem("abracadabra_servers");
+      if (raw) {
+        const servers = JSON.parse(raw);
+        for (const server of servers) {
+          const { Y: YModule } = provider;
+          const entry = new YModule.Map();
+          entry.set("label", server.label);
+          if (server.hubDocId) entry.set("hubDocId", server.hubDocId);
+          if (server.entryDocId) entry.set("entryDocId", server.entryDocId);
+          if (server.spacesEnabled) entry.set("spacesEnabled", server.spacesEnabled);
+          entry.set("addedAt", Date.now());
+          serversMap.set(server.url, entry);
+        }
+      }
+    } catch {
+    }
+    const spacesArr = doc.getArray("spaces");
+    try {
+      const raw = localStorage.getItem("abracadabra_space_registry");
+      if (raw) {
+        const spaces = JSON.parse(raw);
+        for (const space of spaces) {
+          const { Y: YModule } = provider;
+          const yMap = new YModule.Map();
+          yMap.set("id", space.id);
+          yMap.set("name", space.name);
+          if (space.description) yMap.set("description", space.description);
+          yMap.set("type", space.type);
+          yMap.set("serverUrl", space.serverUrl);
+          yMap.set("docId", space.docId);
+          if (space.remoteSpaceId) yMap.set("remoteSpaceId", space.remoteSpaceId);
+          yMap.set("visibility", space.visibility);
+          yMap.set("isHub", space.isHub);
+          yMap.set("order", space.order);
+          if (space.lastSyncedAt) yMap.set("lastSyncedAt", space.lastSyncedAt);
+          yMap.set("createdAt", space.createdAt);
+          spacesArr.push([yMap]);
+        }
+      }
+    } catch {
+    }
+  });
+}
+function _syncRefsFromDoc(provider) {
+  const profile = provider.profileMap;
+  userName.value = profile.get("username") || userName.value;
+  userColorName.value = profile.get("colorName") || userColorName.value;
+  neutralColorName.value = profile.get("neutralColorName") || neutralColorName.value;
+  const tier = profile.get("securityTier");
+  if (tier === "relaxed" || tier === "standard" || tier === "paranoid") {
+    securityTier.value = tier;
+  }
+}
+function _observeDoc(provider) {
+  const profile = provider.profileMap;
+  profile.observe((event) => {
+    for (const [key] of event.changes.keys) {
+      switch (key) {
+        case "username": {
+          const v = profile.get("username");
+          if (v && v !== userName.value) {
+            userName.value = v;
+            try {
+              localStorage.setItem("abracadabra_username", v);
+            } catch {
+            }
+          }
+          break;
+        }
+        case "colorName": {
+          const v = profile.get("colorName");
+          if (v && v !== userColorName.value) {
+            userColorName.value = v;
+            try {
+              localStorage.setItem("abracadabra_usercolor", v);
+            } catch {
+            }
+          }
+          break;
+        }
+        case "neutralColorName": {
+          const v = profile.get("neutralColorName");
+          if (v && v !== neutralColorName.value) {
+            neutralColorName.value = v;
+            try {
+              localStorage.setItem("abracadabra_neutralcolor", v);
+            } catch {
+            }
+          }
+          break;
+        }
+        case "securityTier": {
+          const v = profile.get("securityTier");
+          if (v && (v === "relaxed" || v === "standard" || v === "paranoid") && v !== securityTier.value) {
+            securityTier.value = v;
+            try {
+              localStorage.setItem("abracadabra_security_tier", v);
+            } catch {
+            }
+          }
+          break;
+        }
+      }
+    }
+  });
+}
+function setUserName(name) {
+  if (_provider) {
+    _provider.setProfile({ username: name });
+  } else {
+    userName.value = name;
+    try {
+      localStorage.setItem("abracadabra_username", name);
+    } catch {
+    }
+  }
+}
+function setUserColor(colorName) {
+  if (_provider) {
+    _provider.setProfile({ colorName });
+  } else {
+    userColorName.value = colorName;
+    try {
+      localStorage.setItem("abracadabra_usercolor", colorName);
+    } catch {
+    }
+  }
+}
+function setNeutralColor(colorName) {
+  if (_provider) {
+    _provider.setProfile({ neutralColorName: colorName });
+  } else {
+    neutralColorName.value = colorName;
+    try {
+      localStorage.setItem("abracadabra_neutralcolor", colorName);
+    } catch {
+    }
+  }
+}
+function setSecurityTier(tier) {
+  if (_provider) {
+    _provider.setProfile({ securityTier: tier });
+  } else {
+    securityTier.value = tier;
+    try {
+      localStorage.setItem("abracadabra_security_tier", tier);
+    } catch {
+    }
+  }
+}
+function getServers() {
+  if (!_provider) return /* @__PURE__ */ new Map();
+  return _provider.getServers();
+}
+function setServer(url, entry) {
+  _provider?.setServer(url, entry);
+}
+function removeServer(url) {
+  _provider?.removeServer(url);
+}
+function getSpaces() {
+  if (!_provider) return [];
+  return _provider.getSpaces();
+}
+function addSpace(space) {
+  _provider?.addSpace(space);
+}
+function removeSpace(spaceId) {
+  _provider?.removeSpace(spaceId);
+}
+function updateSpace(spaceId, updates) {
+  _provider?.updateSpace(spaceId, updates);
+}
+function observeSpaces(callback) {
+  if (!_provider) return () => {
+  };
+  return _provider.observeSpaces(callback);
+}
+function getDevices() {
+  if (!_provider) return /* @__PURE__ */ new Map();
+  return _provider.getDevices();
+}
+function getDevice(publicKey) {
+  if (!_provider) return void 0;
+  return _provider.getDevice(publicKey);
+}
+function addDevice(publicKey, opts) {
+  _provider?.addDevice(publicKey, opts);
+}
+function revokeDevice(publicKey, revokedBy) {
+  _provider?.revokeDevice(publicKey, revokedBy);
+}
+function observeDevices(callback) {
+  if (!_provider) return () => {
+  };
+  return _provider.observe("devices", callback);
+}
+function _getSyncServerUrl() {
+  if (typeof localStorage === "undefined") return null;
+  return localStorage.getItem(SYNC_SERVER_KEY);
+}
+function connectSyncServer(url) {
+  if (!_provider) return;
+  _provider.setSyncServer(url);
+}
+function disconnectSyncServer() {
+  if (!_provider) return;
+  _provider.setSyncServer(null);
+}
+function setSyncServerUrl(url) {
+  if (typeof localStorage === "undefined") return;
+  if (url) {
+    localStorage.setItem(SYNC_SERVER_KEY, url);
+    if (_provider) connectSyncServer(url);
+  } else {
+    localStorage.removeItem(SYNC_SERVER_KEY);
+    if (_provider) disconnectSyncServer();
+  }
+}
+function getSyncServerUrl() {
+  return _getSyncServerUrl();
+}
+function getDocument() {
+  return _provider?.document ?? null;
+}
+function getProvider() {
+  return _provider;
+}
+function destroy() {
+  if (_provider) {
+    try {
+      _provider.destroy();
+    } catch {
+    }
+    _provider = null;
+  }
+  _initPromise = null;
+  _publicKey = null;
+  _signChallengeFn = null;
+  _ready.value = false;
+}
+export function useIdentityDoc() {
+  return {
+    // State
+    ready: _ready,
+    userName,
+    userColorName,
+    neutralColorName,
+    securityTier,
+    // Lifecycle
+    init,
+    destroy,
+    // Profile setters
+    setUserName,
+    setUserColor,
+    setNeutralColor,
+    setSecurityTier,
+    // Servers
+    getServers,
+    setServer,
+    removeServer,
+    // Spaces
+    getSpaces,
+    addSpace,
+    removeSpace,
+    updateSpace,
+    observeSpaces,
+    // Devices
+    getDevices,
+    getDevice,
+    addDevice,
+    revokeDevice,
+    observeDevices,
+    // Server sync
+    connectSyncServer,
+    disconnectSyncServer,
+    setSyncServerUrl,
+    getSyncServerUrl,
+    // Raw access
+    getDocument,
+    getProvider
+  };
+}

package/dist/runtime/composables/useInstalledPlugins.d.ts

@@ -0,0 +1,31 @@
+export interface ExternalPluginEntry {
+    url: string;
+    /** Plugin name from the loaded bundle's `plugin.name` field */
+    name: string;
+    label?: string;
+    version?: string;
+    description?: string;
+    enabled: boolean;
+    /** Error message from the last load attempt, if any */
+    error?: string;
+    installedAt: number;
+}
+/**
+ * Normalizes user-entered shorthand to a full CDN URL.
+ *
+ * Supported formats:
+ * - `npm:package-name[@version]` -> jsDelivr npm CDN
+ * - `github:user/repo[@branch]` -> jsDelivr GitHub CDN
+ * - Any other string is returned as-is (assumed to be a full URL)
+ */
+export declare function normalizePluginUrl(input: string): string;
+export declare function useInstalledPlugins(): {
+    entries: import("@vueuse/shared").RemovableRef<ExternalPluginEntry[]>;
+    install: (rawUrl: string) => void;
+    uninstall: (url: string) => void;
+    setEnabled: (url: string, enabled: boolean) => void;
+    updateMeta: (url: string, meta: Partial<ExternalPluginEntry>) => void;
+    disabledBuiltins: import("@vueuse/shared").RemovableRef<string[]>;
+    isBuiltinEnabled: (name: string) => boolean;
+    setBuiltinEnabled: (name: string, enabled: boolean) => void;
+};