@abraca/nuxt 0.2.0 → 1.5.0

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

@@ -9,7 +9,7 @@
  *   const { trashedItems, moveToTrash, restoreFromTrash, emptyTrash } = useTrash()
  */
 import type { ShallowRef } from 'vue';
-import * as Y from 'yjs';
+import type * as Y from 'yjs';
 export interface TrashEntry {
     label: string;
     parentId: string | null;
@@ -18,6 +18,8 @@ export interface TrashEntry {
     meta?: Record<string, any>;
     deletedAt: number;
     deletedBy?: string;
+    /** Batch ID for grouping items deleted together (for accurate restore). */
+    batchId?: string;
 }
 export declare function useTrash(rootDoc?: ShallowRef<Y.Doc | null>): {
     trashMap: {
@@ -37,6 +39,8 @@ export declare function useTrash(rootDoc?: ShallowRef<Y.Doc | null>): {
         meta?: Record<string, any>;
         deletedAt: number;
         deletedBy?: string;
+        /** Batch ID for grouping items deleted together (for accurate restore). */
+        batchId?: string;
         id: string;
     }[]>;
     trashedCount: import("vue").ComputedRef<number>;

package/dist/runtime/composables/useTrash.js

@@ -1,18 +1,21 @@
 import { computed, ref } from "vue";
 import { useSyncedMap } from "./useYDoc.js";
+import { useAbracadabra } from "./useAbracadabra.js";
 const TRASH_SETTINGS_KEY = "abracadabra_trash_settings";
 function loadTrashSettings() {
   try {
     const raw = localStorage.getItem(TRASH_SETTINGS_KEY);
     if (raw) return JSON.parse(raw);
-  } catch {
+  } catch (e) {
+    if (import.meta.dev) console.debug("[abracadabra] trash: failed to load settings from localStorage:", e);
   }
   return { autoPurgeDays: 30 };
 }
 function saveTrashSettings(settings) {
   try {
     localStorage.setItem(TRASH_SETTINGS_KEY, JSON.stringify(settings));
-  } catch {
+  } catch (e) {
+    if (import.meta.dev) console.debug("[abracadabra] trash: failed to save settings to localStorage:", e);
   }
 }
 export function useTrash(rootDoc) {
@@ -40,6 +43,7 @@ export function useTrash(rootDoc) {
     const doc = _doc.value;
     if (!doc) return;
     const now = Date.now();
+    const batchId = crypto.randomUUID();
     doc.transact(() => {
       for (const id of collectDescendants(docId)) {
         const entry = treeMap.get(id);
@@ -51,7 +55,8 @@ export function useTrash(rootDoc) {
           type: entry.type,
           meta: entry.meta,
           deletedAt: now,
-          deletedBy: deletedBy ?? userName.value
+          deletedBy: deletedBy ?? userName.value,
+          batchId
         });
         treeMap.remove(id);
       }
@@ -62,9 +67,9 @@ export function useTrash(rootDoc) {
     if (!doc) return;
     const entry = trashMap.get(docId);
     if (!entry) return;
-    const { deletedAt } = entry;
+    const { deletedAt, batchId } = entry;
     doc.transact(() => {
-      const toRestore = Object.entries(trashMap.data).filter(([, e]) => Math.abs(e.deletedAt - deletedAt) < 1e3);
+      const toRestore = Object.entries(trashMap.data).filter(([, e]) => batchId ? e.batchId === batchId : Math.abs(e.deletedAt - deletedAt) < 1e3);
       for (const [id, trashEntry] of toRestore) {
         const parentExists = trashEntry.parentId === null || treeMap.get(trashEntry.parentId) !== void 0 || toRestore.some(([rid]) => rid === trashEntry.parentId);
         treeMap.set(id, {
@@ -109,7 +114,8 @@ export function useTrash(rootDoc) {
       for (const db of dbs) {
         if (db.name?.includes(docId)) indexedDB.deleteDatabase(db.name);
       }
-    } catch {
+    } catch (e) {
+      if (import.meta.dev) console.debug("[abracadabra] trash: failed to cleanup IDB for doc:", e);
     }
   }
   return {

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

@@ -0,0 +1,22 @@
+import type { ShallowRef, Ref, InjectionKey } from 'vue';
+import * as Y from 'yjs';
+export interface TreeUndoContext {
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+    undo: () => void;
+    redo: () => void;
+    undoManager: ShallowRef<Y.UndoManager | null>;
+}
+export declare const treeUndoKey: InjectionKey<TreeUndoContext>;
+/**
+ * Creates a Y.UndoManager scoped to the root doc's "doc-tree" and "doc-trash"
+ * Y.Maps. Tracks only local user changes (origin === null) so remote CRDT
+ * updates are never reversed.
+ *
+ * Both maps are tracked because deleteEntry moves items from tree -> trash in a
+ * single transaction — the UndoManager must see both sides to reverse it
+ * atomically.
+ *
+ * Should be called once in the layout and provided via `treeUndoKey`.
+ */
+export declare function useTreeUndoManager(rootDoc: ShallowRef<Y.Doc | null>): TreeUndoContext;

package/dist/runtime/composables/useTreeUndoManager.js

@@ -0,0 +1,45 @@
+import { ref, shallowRef, watch, onBeforeUnmount } from "vue";
+import * as Y from "yjs";
+export const treeUndoKey = Symbol("treeUndo");
+export function useTreeUndoManager(rootDoc) {
+  const undoManager = shallowRef(null);
+  const canUndo = ref(false);
+  const canRedo = ref(false);
+  function updateState() {
+    const um = undoManager.value;
+    canUndo.value = (um?.undoStack.length ?? 0) > 0;
+    canRedo.value = (um?.redoStack.length ?? 0) > 0;
+  }
+  watch(rootDoc, (doc, _oldDoc, onCleanup) => {
+    undoManager.value?.destroy();
+    undoManager.value = null;
+    canUndo.value = false;
+    canRedo.value = false;
+    if (!doc) return;
+    const treeMap = doc.getMap("doc-tree");
+    const trashMap = doc.getMap("doc-trash");
+    const um = new Y.UndoManager([treeMap, trashMap], {
+      trackedOrigins: /* @__PURE__ */ new Set([null]),
+      captureTimeout: 500
+    });
+    um.on("stack-item-added", updateState);
+    um.on("stack-item-popped", updateState);
+    undoManager.value = um;
+    onCleanup(() => {
+      um.off("stack-item-added", updateState);
+      um.off("stack-item-popped", updateState);
+      um.destroy();
+    });
+  }, { immediate: true });
+  onBeforeUnmount(() => {
+    undoManager.value?.destroy();
+    undoManager.value = null;
+  });
+  function undo() {
+    undoManager.value?.undo();
+  }
+  function redo() {
+    undoManager.value?.redo();
+  }
+  return { canUndo, canRedo, undo, redo, undoManager };
+}

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

@@ -0,0 +1,37 @@
+import type { ShallowRef, Ref, ComputedRef, InjectionKey } from 'vue';
+import type { Editor } from '@tiptap/vue-3';
+export interface UndoRedoContext {
+    /** Undo in the currently active context (editor or tree) */
+    undo: () => void;
+    /** Redo in the currently active context (editor or tree) */
+    redo: () => void;
+    /** Tree-specific undo/redo */
+    treeUndo: () => void;
+    treeRedo: () => void;
+    treeCanUndo: Ref<boolean>;
+    treeCanRedo: Ref<boolean>;
+    /** Editor-specific undo/redo */
+    editorUndo: () => void;
+    editorRedo: () => void;
+    editorCanUndo: ComputedRef<boolean>;
+    editorCanRedo: ComputedRef<boolean>;
+    /** Which domain last received focus */
+    activeContext: Ref<'editor' | 'tree'>;
+}
+export declare const undoRedoKey: InjectionKey<UndoRedoContext>;
+/**
+ * Coordinator composable that routes undo/redo to the correct domain:
+ * - TipTap editor focused -> editor's built-in Y.UndoManager
+ * - Otherwise -> tree Y.UndoManager (doc-tree + doc-trash)
+ *
+ * Meta field values (color, dates, tags) live in the tree Y.Map but are edited
+ * via popups inside the TipTap editor. To handle this, we track which domain
+ * had the most recent mutation and use that as a tiebreaker when the editor
+ * has focus — so Cmd+Z after a meta field change undoes the meta change even
+ * though focus returned to the editor.
+ *
+ * Injects the shared tree UndoManager from the layout (via treeUndoKey).
+ * Installs a page-level keydown listener for Cmd+Z / Cmd+Shift+Z when
+ * the TipTap editor does NOT have focus.
+ */
+export declare function useUndoRedo(editor: ShallowRef<Editor | null>): UndoRedoContext;

package/dist/runtime/composables/useUndoRedo.js

@@ -0,0 +1,115 @@
+import { computed, onBeforeUnmount, ref, inject, watch } from "vue";
+import { treeUndoKey } from "./useTreeUndoManager.js";
+export const undoRedoKey = Symbol("undoRedo");
+export function useUndoRedo(editor) {
+  const tree = inject(treeUndoKey);
+  const activeContext = ref("tree");
+  const lastMutatedDomain = ref("editor");
+  const lastUndoDomain = ref(null);
+  function editorHasFocus() {
+    const el = document.activeElement;
+    if (!el) return false;
+    return !!el.closest(".tiptap, .ProseMirror");
+  }
+  function editorUndo() {
+    editor.value?.commands.undo();
+  }
+  function editorRedo() {
+    editor.value?.commands.redo();
+  }
+  const editorCanUndo = computed(() => editor.value?.can().undo() ?? false);
+  const editorCanRedo = computed(() => editor.value?.can().redo() ?? false);
+  function onTreeStackAdded() {
+    lastMutatedDomain.value = "tree";
+  }
+  watch(() => tree.undoManager.value, (um, oldUm) => {
+    oldUm?.off("stack-item-added", onTreeStackAdded);
+    um?.on("stack-item-added", onTreeStackAdded);
+  }, { immediate: true });
+  function onEditorTransaction({ transaction }) {
+    if (transaction.docChanged) {
+      lastMutatedDomain.value = "editor";
+    }
+  }
+  watch(editor, (ed, oldEd) => {
+    oldEd?.off("transaction", onEditorTransaction);
+    ed?.on("transaction", onEditorTransaction);
+  }, { immediate: true });
+  function undo() {
+    if (!editorHasFocus() || !editor.value) {
+      activeContext.value = "tree";
+      lastUndoDomain.value = "tree";
+      tree.undo();
+    } else if (lastMutatedDomain.value === "tree" && tree.canUndo.value) {
+      activeContext.value = "tree";
+      lastUndoDomain.value = "tree";
+      tree.undo();
+      if (!tree.canUndo.value) {
+        lastMutatedDomain.value = "editor";
+      }
+    } else {
+      activeContext.value = "editor";
+      lastUndoDomain.value = "editor";
+      editorUndo();
+    }
+  }
+  function redo() {
+    if (!editorHasFocus() || !editor.value) {
+      activeContext.value = "tree";
+      tree.redo();
+    } else if (lastUndoDomain.value === "tree" && tree.canRedo.value) {
+      activeContext.value = "tree";
+      tree.redo();
+      if (!tree.canRedo.value) {
+        lastUndoDomain.value = null;
+      }
+    } else {
+      activeContext.value = "editor";
+      editorRedo();
+    }
+  }
+  function onKeydown(e) {
+    const mod = e.metaKey || e.ctrlKey;
+    if (!mod) return;
+    if (editorHasFocus()) return;
+    if (e.key === "z") {
+      e.preventDefault();
+      if (e.shiftKey) redo();
+      else undo();
+    } else if (e.key === "y") {
+      e.preventDefault();
+      redo();
+    }
+  }
+  function onFocusIn(e) {
+    const target = e.target;
+    if (target?.closest(".tiptap, .ProseMirror")) {
+      activeContext.value = "editor";
+    } else {
+      activeContext.value = "tree";
+    }
+  }
+  if (import.meta.client) {
+    window.addEventListener("keydown", onKeydown);
+    window.addEventListener("focusin", onFocusIn);
+    onBeforeUnmount(() => {
+      window.removeEventListener("keydown", onKeydown);
+      window.removeEventListener("focusin", onFocusIn);
+      tree.undoManager.value?.off("stack-item-added", onTreeStackAdded);
+      editor.value?.off("transaction", onEditorTransaction);
+    });
+  }
+  return {
+    undo,
+    redo,
+    treeUndo: tree.undo,
+    treeRedo: tree.redo,
+    treeCanUndo: tree.canUndo,
+    treeCanRedo: tree.canRedo,
+    editorUndo,
+    editorRedo,
+    editorCanUndo,
+    editorCanRedo,
+    activeContext
+  };
+}

package/dist/runtime/composables/useVoice.js

@@ -1,6 +1,8 @@
 import { ref, shallowRef, computed } from "vue";
 import { VoiceClient } from "../utils/VoiceClient.js";
 import { TRANSIENT_ERROR_CODES } from "../utils/voiceErrors.js";
+import { useToast } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
 const voiceStatus = ref("idle");
 const voiceRoomId = ref(null);
 const isMuted = ref(false);

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

@@ -0,0 +1,50 @@
+/**
+ * useWebRTC
+ *
+ * Wraps AbracadabraWebRTC from @abraca/dabra for P2P Y.js sync, awareness,
+ * and file transfer over WebRTC data channels.
+ *
+ * Follows the same singleton pattern as useVoice — module-level state,
+ * _wireEvents for event→ref mapping, and user-driven connect/disconnect.
+ *
+ * Usage:
+ *   const { isConnected, peers, peerCount, connect, disconnect } = useWebRTC()
+ */
+export declare function _initWebRTC(rtc: any): void;
+export declare function _destroyWebRTC(): void;
+/**
+ * Connect to WebRTC P2P mesh.
+ * Uses the current provider from useAbracadabra() to create an AbracadabraWebRTC instance.
+ * When E2EE is enabled and the user has a claimed passkey, triggers WebAuthn prompt
+ * to derive X25519 private key.
+ */
+declare function connect(options?: {
+    e2ee?: boolean;
+}): Promise<void>;
+declare function disconnect(): void;
+declare function sendFile(peerId: string, file: File | Blob, filename: string): Promise<any>;
+export declare function useWebRTC(): {
+    /** Current WebRTC connection status. */
+    webrtcStatus: import("vue").Ref<"idle" | "disconnected" | "connecting" | "connected", "idle" | "disconnected" | "connecting" | "connected">;
+    /** Whether the WebRTC signaling connection is active. */
+    isConnected: import("vue").Ref<boolean, boolean>;
+    /** Map of connected peers (peerId → PeerState). */
+    peers: import("vue").ShallowRef<Map<string, any>, Map<string, any>>;
+    /** Local peer ID assigned by the signaling server. */
+    localPeerId: import("vue").Ref<string | null, string | null>;
+    /** Whether E2EE is enabled for this connection. */
+    e2eeEnabled: import("vue").Ref<boolean, boolean>;
+    /** Set of peer IDs with established E2EE channels. */
+    e2eeEstablishedPeers: import("vue").ShallowRef<Set<string>, Set<string>>;
+    /** Array of connected peers (computed from peers map). */
+    peerList: import("vue").ComputedRef<any[]>;
+    /** Number of connected peers (computed). */
+    peerCount: import("vue").ComputedRef<number>;
+    /** Connect to WebRTC P2P mesh using the current provider. */
+    connect: typeof connect;
+    /** Disconnect and clean up WebRTC resources. */
+    disconnect: typeof disconnect;
+    /** Send a file to a specific peer. */
+    sendFile: typeof sendFile;
+};
+export {};

package/dist/runtime/composables/useWebRTC.js

@@ -0,0 +1,179 @@
+import { ref, shallowRef, computed } from "vue";
+import { getSdkModule } from "../utils/sdkRef.js";
+import { useToast, useRuntimeConfig } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { _wireFileTransferEvents, _destroyFileTransfer } from "./useFileTransfer.js";
+const webrtcStatus = ref("idle");
+const isConnected = ref(false);
+const peers = shallowRef(/* @__PURE__ */ new Map());
+const localPeerId = ref(null);
+const e2eeEnabled = ref(false);
+const e2eeEstablishedPeers = shallowRef(/* @__PURE__ */ new Set());
+let _rtc = null;
+const _unbinds = [];
+const peerList = computed(() => [...peers.value.values()]);
+const peerCount = computed(() => peers.value.size);
+function _wireEvents(rtc) {
+  const on = (event, handler) => {
+    rtc.on(event, handler);
+    _unbinds.push(() => rtc.off(event, handler));
+  };
+  on("connected", () => {
+    isConnected.value = true;
+    webrtcStatus.value = "connected";
+    localPeerId.value = rtc.localPeerId;
+  });
+  on("disconnected", () => {
+    isConnected.value = false;
+    webrtcStatus.value = "disconnected";
+  });
+  on("peerJoined", (peer) => {
+    const next = new Map(peers.value);
+    next.set(peer.peerId, peer);
+    peers.value = next;
+  });
+  on("peerLeft", ({ peerId }) => {
+    const next = new Map(peers.value);
+    next.delete(peerId);
+    peers.value = next;
+    const nextE2ee = new Set(e2eeEstablishedPeers.value);
+    nextE2ee.delete(peerId);
+    e2eeEstablishedPeers.value = nextE2ee;
+  });
+  on("peerConnectionState", ({ peerId, state }) => {
+    const existing = peers.value.get(peerId);
+    if (existing) {
+      const next = new Map(peers.value);
+      next.set(peerId, { ...existing, connectionState: state });
+      peers.value = next;
+    }
+  });
+  on("e2eeEstablished", ({ peerId }) => {
+    const next = new Set(e2eeEstablishedPeers.value);
+    next.add(peerId);
+    e2eeEstablishedPeers.value = next;
+  });
+  on("e2eeFailed", ({ peerId, error }) => {
+    console.warn(`[abracadabra] E2EE failed for peer ${peerId}:`, error);
+    try {
+      const toast = useToast();
+      toast.add({
+        title: "E2EE handshake failed",
+        description: `Could not establish encrypted channel with peer`,
+        color: "warning",
+        icon: "i-lucide-shield-alert"
+      });
+    } catch {
+    }
+  });
+}
+function _cleanup() {
+  for (const unsub of _unbinds) unsub();
+  _unbinds.length = 0;
+  _destroyFileTransfer();
+  if (_rtc) {
+    _rtc.destroy();
+    _rtc = null;
+  }
+  webrtcStatus.value = "idle";
+  isConnected.value = false;
+  peers.value = /* @__PURE__ */ new Map();
+  localPeerId.value = null;
+  e2eeEnabled.value = false;
+  e2eeEstablishedPeers.value = /* @__PURE__ */ new Set();
+}
+export function _initWebRTC(rtc) {
+  _cleanup();
+  _rtc = rtc;
+  _wireEvents(rtc);
+  _wireFileTransferEvents(rtc);
+  webrtcStatus.value = "connecting";
+}
+export function _destroyWebRTC() {
+  _cleanup();
+}
+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 connect(options) {
+  if (_rtc && isConnected.value) return;
+  const { provider, keystore, isClaimed } = useAbracadabra();
+  if (!provider.value) return;
+  const config = useRuntimeConfig();
+  const webrtcConfig = config.public.abracadabra?.webrtc ?? {};
+  const sdk = getSdkModule();
+  if (!sdk?.AbracadabraWebRTC) {
+    console.error("[abracadabra] SDK not loaded \u2014 cannot connect WebRTC");
+    return;
+  }
+  const { AbracadabraWebRTC } = sdk;
+  let e2eeIdentity;
+  const wantE2ee = options?.e2ee ?? webrtcConfig.e2ee ?? false;
+  if (wantE2ee && isClaimed.value && keystore.value) {
+    try {
+      const pubKeyB64 = await keystore.value.getPublicKey();
+      if (pubKeyB64) {
+        const publicKey = fromBase64Url(pubKeyB64);
+        const x25519PrivateKey = await keystore.value.getX25519PrivateKey();
+        e2eeIdentity = { publicKey, x25519PrivateKey };
+        e2eeEnabled.value = true;
+      }
+    } catch (e) {
+      console.warn("[abracadabra] E2EE identity derivation failed:", e.message);
+    }
+  }
+  let resolvedIceServers = webrtcConfig.iceServers;
+  if (!resolvedIceServers) {
+    try {
+      const { client } = useAbracadabra();
+      if (client.value?.getIceServers) {
+        resolvedIceServers = await client.value.getIceServers();
+      }
+    } catch (e) {
+      if (import.meta.dev) console.debug("[abracadabra] webrtc: failed to fetch ICE servers from server:", e);
+    }
+  }
+  const rtc = AbracadabraWebRTC.fromProvider(provider.value, {
+    iceServers: resolvedIceServers,
+    enableFileTransfer: webrtcConfig.fileTransfer ?? false,
+    e2ee: e2eeIdentity
+  });
+  _initWebRTC(rtc);
+  await rtc.connect();
+}
+function disconnect() {
+  _cleanup();
+}
+async function sendFile(peerId, file, filename) {
+  if (!_rtc) return null;
+  return _rtc.sendFile(peerId, file, filename);
+}
+export function useWebRTC() {
+  return {
+    /** Current WebRTC connection status. */
+    webrtcStatus,
+    /** Whether the WebRTC signaling connection is active. */
+    isConnected,
+    /** Map of connected peers (peerId → PeerState). */
+    peers,
+    /** Local peer ID assigned by the signaling server. */
+    localPeerId,
+    /** Whether E2EE is enabled for this connection. */
+    e2eeEnabled,
+    /** Set of peer IDs with established E2EE channels. */
+    e2eeEstablishedPeers,
+    /** Array of connected peers (computed from peers map). */
+    peerList,
+    /** Number of connected peers (computed). */
+    peerCount,
+    /** Connect to WebRTC P2P mesh using the current provider. */
+    connect,
+    /** Disconnect and clean up WebRTC resources. */
+    disconnect,
+    /** Send a file to a specific peer. */
+    sendFile
+  };
+}

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

@@ -119,4 +119,6 @@ export declare function useWindowManager(): {
     toggleMaximize: (id: string) => void;
     moveWindow: (id: string, x: number, y: number) => void;
     resizeWindow: (id: string, width: number, height: number, x?: number, y?: number) => void;
+    restoreLayout: () => void;
+    clearLayout: () => void;
 };

package/dist/runtime/composables/useWindowManager.js

@@ -1,7 +1,9 @@
 import { reactive, ref, computed } from "vue";
+const LAYOUT_STORAGE_KEY = "abracadabra_window_layout";
 const windows = reactive(/* @__PURE__ */ new Map());
 const topZIndex = ref(30);
 let cascadeOffset = 0;
+let _saveDebounce = null;
 export function useWindowManager() {
   function bringToFront(id) {
     const win = windows.get(id);
@@ -62,12 +64,15 @@ export function useWindowManager() {
       initialTab: opts.initialTab,
       meta: opts.meta
     });
+    _saveLayout();
   }
   function closeWindow(id) {
     windows.delete(id);
+    _saveLayout();
   }
   function closeAll() {
     windows.clear();
+    clearLayout();
   }
   function minimizeWindow(id, target) {
     const win = windows.get(id);
@@ -109,6 +114,7 @@ export function useWindowManager() {
     if (!win || win.isMaximized) return;
     win.x = x;
     win.y = y;
+    _saveLayout();
   }
   function resizeWindow(id, width, height, x, y) {
     const win = windows.get(id);
@@ -117,6 +123,7 @@ export function useWindowManager() {
     win.height = Math.max(height, 200);
     if (x !== void 0) win.x = x;
     if (y !== void 0) win.y = y;
+    _saveLayout();
   }
   const activeWindows = computed(
     () => [...windows.values()].filter((w) => !w.isMinimized).sort((a, b) => a.zIndex - b.zIndex)
@@ -124,6 +131,59 @@ export function useWindowManager() {
   const minimizedWindows = computed(
     () => [...windows.values()].filter((w) => w.isMinimized)
   );
+  function _saveLayout() {
+    if (_saveDebounce) clearTimeout(_saveDebounce);
+    _saveDebounce = setTimeout(() => {
+      try {
+        const layout = [...windows.values()].map((w) => ({
+          id: w.id,
+          docId: w.docId,
+          title: w.title,
+          icon: w.icon,
+          docType: w.docType,
+          channelId: w.channelId,
+          x: w.x,
+          y: w.y,
+          width: w.width,
+          height: w.height,
+          isMinimized: w.isMinimized,
+          isMaximized: w.isMaximized,
+          initialTab: w.initialTab,
+          meta: w.meta
+        }));
+        localStorage.setItem(LAYOUT_STORAGE_KEY, JSON.stringify(layout));
+      } catch {
+      }
+    }, 500);
+  }
+  function restoreLayout() {
+    try {
+      const raw = localStorage.getItem(LAYOUT_STORAGE_KEY);
+      if (!raw) return;
+      const layout = JSON.parse(raw);
+      for (const entry of layout) {
+        if (windows.has(entry.id)) continue;
+        topZIndex.value++;
+        windows.set(entry.id, {
+          ...entry,
+          provider: null,
+          zIndex: topZIndex.value,
+          isFocused: false,
+          prevX: entry.x,
+          prevY: entry.y,
+          prevWidth: entry.width,
+          prevHeight: entry.height
+        });
+      }
+    } catch {
+    }
+  }
+  function clearLayout() {
+    try {
+      localStorage.removeItem(LAYOUT_STORAGE_KEY);
+    } catch {
+    }
+  }
   return {
     windows,
     activeWindows,
@@ -136,6 +196,8 @@ export function useWindowManager() {
     restoreWindow,
     toggleMaximize,
     moveWindow,
-    resizeWindow
+    resizeWindow,
+    restoreLayout,
+    clearLayout
   };
 }

package/dist/runtime/extensions/code-preview.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const CodePreview: Node<any, any>;

package/dist/runtime/extensions/code-preview.js

@@ -0,0 +1,17 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import CodePreviewView from "./views/CodePreviewView.vue";
+export const CodePreview = Node.create({
+  name: "codePreview",
+  group: "block",
+  content: "block+",
+  parseHTML() {
+    return [{ tag: "div[data-code-preview]" }];
+  },
+  renderHTML() {
+    return ["div", mergeAttributes({ "data-code-preview": "" }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CodePreviewView);
+  }
+});