@abraca/nuxt 1.8.2 → 2.0.0

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

@@ -0,0 +1,79 @@
+/**
+ * useDocSnapshots
+ *
+ * CRUD over a document's snapshot history with paginated fetch and a
+ * derived "display items" view that collapses runs of consecutive
+ * auto-snapshots from the same author within a 30-min window into one
+ * cluster (manual / unload / shutdown / labelled snapshots stay
+ * individual). Keeps the side-panel timeline scannable while losing
+ * nothing.
+ *
+ * Mirrors the `cou-sh` implementation 1-to-1 — the cou-sh version is the
+ * source of truth (see project memory: nuxt-module-must-match-coush). If
+ * this composable drifts from cou-sh's, fix it back rather than
+ * "improving" it here.
+ *
+ * Usage:
+ *   const docId = computed(() => route.params.id as string)
+ *   const snaps = useDocSnapshots(docId)
+ *   onMounted(() => snaps.fetchList())
+ */
+import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
+import type { SnapshotMeta } from '@abraca/dabra';
+import type { AbracadabraLocale } from '../locale.js';
+export type DocSnapshotsCtx = ReturnType<typeof useDocSnapshots>;
+export declare const DOC_SNAPSHOTS_KEY: InjectionKey<DocSnapshotsCtx>;
+/** Trigger badge color, matching cou-sh's mapping exactly. */
+export declare function triggerBadgeColor(trigger: string): 'primary' | 'neutral' | 'warning';
+/**
+ * Trigger label key — consumers translate via their own i18n if they
+ *  don't use `useAbraLocale`. Returns the dot-path key cou-sh uses.
+ */
+export declare function triggerLabelKey(trigger: string): string;
+/**
+ * Per-row item for the side-panel list. Auto runs collapse into a
+ *  single `cluster` item; everything else stays as its own `snap`.
+ */
+export type SnapshotDisplayItem = {
+    kind: 'snap';
+    snap: SnapshotMeta;
+} | {
+    kind: 'cluster';
+    items: SnapshotMeta[];
+    firstAt: number;
+    lastAt: number;
+    createdBy: string | null;
+};
+export declare function useDocSnapshots(docId: Ref<string> | ComputedRef<string>, overrides?: Partial<AbracadabraLocale['snapshots']> | null): {
+    snapshots: Ref<{
+        version: number;
+        size_bytes: number;
+        trigger: string;
+        label?: string | null | undefined;
+        created_by?: string | null | undefined;
+        created_at: number;
+        file_count?: number | undefined;
+        delta_bytes?: number | null | undefined;
+    }[], SnapshotMeta[] | {
+        version: number;
+        size_bytes: number;
+        trigger: string;
+        label?: string | null | undefined;
+        created_by?: string | null | undefined;
+        created_at: number;
+        file_count?: number | undefined;
+        delta_bytes?: number | null | undefined;
+    }[]>;
+    displayItems: ComputedRef<SnapshotDisplayItem[]>;
+    loading: Ref<boolean, boolean>;
+    error: Ref<string | null, string | null>;
+    hasMore: Ref<boolean, boolean>;
+    creating: Ref<boolean, boolean>;
+    pending: Ref<Record<number, "delete" | "restore" | "fork" | undefined>, Record<number, "delete" | "restore" | "fork" | undefined>>;
+    fetchList: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    create: (label?: string) => Promise<void>;
+    remove: (version: number) => Promise<void>;
+    restore: (version: number) => Promise<void>;
+    fork: (version: number) => Promise<void>;
+};

package/dist/runtime/composables/useDocSnapshots.js

@@ -0,0 +1,234 @@
+import { computed, ref } from "vue";
+import { useToast, useRouter } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { useAbraLocale } from "./useAbraLocale.js";
+export const DOC_SNAPSHOTS_KEY = Symbol("doc-snapshots");
+export function triggerBadgeColor(trigger) {
+  switch (trigger) {
+    case "manual":
+      return "primary";
+    case "unload":
+    case "shutdown":
+      return "warning";
+    default:
+      return "neutral";
+  }
+}
+export function triggerLabelKey(trigger) {
+  switch (trigger) {
+    case "manual":
+      return "docPanel.snapshots.triggerManual";
+    case "auto":
+      return "docPanel.snapshots.triggerAuto";
+    case "unload":
+      return "docPanel.snapshots.triggerUnload";
+    case "shutdown":
+      return "docPanel.snapshots.triggerShutdown";
+    default:
+      return "";
+  }
+}
+const PAGE_SIZE = 20;
+const CLUSTER_WINDOW_S = 30 * 60;
+function errMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function applyTemplate(tmpl, vars) {
+  return tmpl.replace(/\{(\w+)\}/g, (_, k) => String(vars[k] ?? ""));
+}
+export function useDocSnapshots(docId, overrides) {
+  const { client } = useAbracadabra();
+  const locale = useAbraLocale("snapshots", overrides);
+  const toast = useToast();
+  const router = useRouter();
+  const snapshots = ref([]);
+  const loading = ref(false);
+  const error = ref(null);
+  const hasMore = ref(false);
+  const creating = ref(false);
+  const pending = ref({});
+  const displayItems = computed(() => {
+    const result = [];
+    const arr = snapshots.value;
+    let i = 0;
+    while (i < arr.length) {
+      const cur = arr[i];
+      if (cur.trigger !== "auto") {
+        result.push({ kind: "snap", snap: cur });
+        i++;
+        continue;
+      }
+      const cluster = [cur];
+      let j = i + 1;
+      while (j < arr.length) {
+        const nxt = arr[j];
+        if (nxt.trigger !== "auto") break;
+        if ((nxt.created_by ?? null) !== (cur.created_by ?? null)) break;
+        const last = cluster[cluster.length - 1];
+        if (Math.abs(last.created_at - nxt.created_at) > CLUSTER_WINDOW_S) break;
+        cluster.push(nxt);
+        j++;
+      }
+      if (cluster.length === 1) {
+        result.push({ kind: "snap", snap: cur });
+      } else {
+        const ts = cluster.map((c) => c.created_at);
+        result.push({
+          kind: "cluster",
+          items: cluster,
+          firstAt: Math.min(...ts),
+          lastAt: Math.max(...ts),
+          createdBy: cur.created_by ?? null
+        });
+      }
+      i = j;
+    }
+    return result;
+  });
+  async function fetchList() {
+    if (!docId.value) return;
+    if (!client.value) {
+      snapshots.value = [];
+      return;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await client.value.listSnapshots(docId.value, { limit: PAGE_SIZE + 1 });
+      hasMore.value = res.length > PAGE_SIZE;
+      snapshots.value = res.slice(0, PAGE_SIZE);
+    } catch (e) {
+      error.value = errMessage(e);
+      snapshots.value = [];
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function loadMore() {
+    if (!client.value || !docId.value || !hasMore.value || loading.value) return;
+    loading.value = true;
+    try {
+      const res = await client.value.listSnapshots(docId.value, {
+        limit: PAGE_SIZE + 1,
+        offset: snapshots.value.length
+      });
+      hasMore.value = res.length > PAGE_SIZE;
+      snapshots.value = [...snapshots.value, ...res.slice(0, PAGE_SIZE)];
+    } catch (e) {
+      toast.add({ title: locale.failed, description: errMessage(e), color: "error" });
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function create(label) {
+    if (!client.value || !docId.value) return;
+    creating.value = true;
+    try {
+      const res = await client.value.createSnapshot(docId.value, label ? { label } : void 0);
+      toast.add({
+        title: locale.createdTitle,
+        description: applyTemplate(locale.createdDesc, { version: res.version }),
+        color: "success"
+      });
+      await fetchList();
+    } catch (e) {
+      toast.add({
+        title: locale.createFailed,
+        description: errMessage(e),
+        color: "error"
+      });
+    } finally {
+      creating.value = false;
+    }
+  }
+  async function remove(version) {
+    if (!client.value || !docId.value) return;
+    pending.value[version] = "delete";
+    try {
+      await client.value.deleteSnapshot(docId.value, version);
+      toast.add({
+        title: locale.deletedTitle,
+        description: applyTemplate(locale.deletedDesc, { version }),
+        color: "success"
+      });
+      await fetchList();
+    } catch (e) {
+      toast.add({
+        title: locale.deleteFailed,
+        description: errMessage(e),
+        color: "error"
+      });
+    } finally {
+      pending.value[version] = void 0;
+    }
+  }
+  async function restore(version) {
+    if (!client.value || !docId.value) return;
+    pending.value[version] = "restore";
+    try {
+      const res = await client.value.restoreSnapshot(docId.value, version);
+      toast.add({
+        title: locale.restoredTitle,
+        description: applyTemplate(locale.restoredDesc, {
+          version: res.restored_from,
+          bytes: res.diff_bytes
+        }),
+        color: "success"
+      });
+    } catch (e) {
+      toast.add({
+        title: locale.restoreFailed,
+        description: errMessage(e),
+        color: "error"
+      });
+    } finally {
+      pending.value[version] = void 0;
+    }
+  }
+  async function fork(version) {
+    if (!client.value || !docId.value) return;
+    pending.value[version] = "fork";
+    try {
+      const res = await client.value.forkSnapshot(docId.value, version);
+      toast.add({
+        title: locale.forkedTitle,
+        description: applyTemplate(locale.forkedDesc, { version }),
+        color: "success",
+        actions: [{
+          label: locale.openFork,
+          color: "neutral",
+          variant: "outline",
+          onClick: (e) => {
+            e?.stopPropagation();
+            router.push(`/doc/${res.doc_id}`);
+          }
+        }]
+      });
+    } catch (e) {
+      toast.add({
+        title: locale.forkFailed,
+        description: errMessage(e),
+        color: "error"
+      });
+    } finally {
+      pending.value[version] = void 0;
+    }
+  }
+  return {
+    // State
+    snapshots,
+    displayItems,
+    loading,
+    error,
+    hasMore,
+    creating,
+    pending,
+    // Actions
+    fetchList,
+    loadMore,
+    create,
+    remove,
+    restore,
+    fork
+  };
+}

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

@@ -0,0 +1,24 @@
+import type { ContentNavigationItem } from '../utils/content.js';
+export interface DocsSearchFile {
+    id: string;
+    title: string;
+    titles: string[];
+    content: string;
+    level: number;
+}
+export interface DocsSearchItem {
+    prefix?: string;
+    label: string;
+    suffix: string;
+    to: string;
+    icon?: string;
+    level: number;
+}
+declare function _useDocsSearch(): {
+    open: import("vue").Ref<boolean, boolean>;
+    mapFile: (file: DocsSearchFile, link: ContentNavigationItem, parent?: ContentNavigationItem) => DocsSearchItem;
+    mapNavigationItems: (children: ContentNavigationItem[], files: DocsSearchFile[], parent?: ContentNavigationItem) => DocsSearchItem[];
+    postFilter: (query: string, items: DocsSearchItem[]) => DocsSearchItem[];
+};
+export declare const useDocsSearch: typeof _useDocsSearch;
+export {};

package/dist/runtime/composables/useDocsSearch.js

@@ -0,0 +1,34 @@
+import { ref } from "vue";
+import { createSharedComposable } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+function _useDocsSearch() {
+  const open = ref(false);
+  const appConfig = useAppConfig();
+  function mapFile(file, link, parent) {
+    const prefix = [...new Set([parent?.title, ...file.titles].filter(Boolean))];
+    return {
+      prefix: prefix?.length ? prefix.join(" > ") + " >" : void 0,
+      label: file.id === link.path ? link.title : file.title,
+      suffix: file.content.replaceAll("<", "&lt;").replaceAll(">", "&gt;"),
+      to: file.id,
+      icon: link.icon || parent?.icon || (file.level > 1 ? appConfig.ui.icons.hash : appConfig.ui.icons.file),
+      level: file.level
+    };
+  }
+  function mapNavigationItems(children, files, parent) {
+    return children.flatMap((link) => {
+      if (link.children?.length) {
+        return mapNavigationItems(link.children, files, link);
+      }
+      return files?.filter((file) => file.id === link.path || file.id.startsWith(`${link.path}#`))?.map((file) => mapFile(file, link, parent)) || [];
+    });
+  }
+  function postFilter(query, items) {
+    if (!query) {
+      return items?.filter((item) => item.level === 1);
+    }
+    return items;
+  }
+  return { open, mapFile, mapNavigationItems, postFilter };
+}
+export const useDocsSearch = /* @__PURE__ */ createSharedComposable(_useDocsSearch);

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

@@ -9,6 +9,13 @@ export declare function useEditorDragHandle(pageConfig?: {
     }>;
     onChangePageType?: (typeKey: string) => void;
     onInsertDocLink?: () => void;
+    /**
+     * Optional callback for "Create child document" — apps that own a doc-tree
+     * implement this to spawn a new child under the current node and (usually)
+     * link to it from the editor. Called with no args; the consumer reads the
+     * editor's current selection from its own state.
+     */
+    onCreateChildDoc?: () => void;
 }): {
     selectedNode: import("vue").Ref<{
         node: JSONContent | null;

package/dist/runtime/composables/useEditorDragHandle.js

@@ -29,6 +29,9 @@ export function useEditorDragHandle(pageConfig) {
             { label: "Heading 1", icon: "i-lucide-heading-1", onSelect: () => editor.chain().focus().toggleHeading({ level: 1 }).run() },
             { label: "Heading 2", icon: "i-lucide-heading-2", onSelect: () => editor.chain().focus().toggleHeading({ level: 2 }).run() },
             { label: "Heading 3", icon: "i-lucide-heading-3", onSelect: () => editor.chain().focus().toggleHeading({ level: 3 }).run() },
+            { label: "Heading 4", icon: "i-lucide-heading-4", onSelect: () => editor.chain().focus().toggleHeading({ level: 4 }).run() },
+            { label: "Heading 5", icon: "i-lucide-heading-5", onSelect: () => editor.chain().focus().toggleHeading({ level: 5 }).run() },
+            { label: "Heading 6", icon: "i-lucide-heading-6", onSelect: () => editor.chain().focus().toggleHeading({ level: 6 }).run() },
             { label: "Bullet List", icon: "i-lucide-list", onSelect: () => editor.chain().focus().toggleBulletList().run() },
             { label: "Ordered List", icon: "i-lucide-list-ordered", onSelect: () => editor.chain().focus().toggleOrderedList().run() },
             { label: "Task List", icon: "i-lucide-list-check", onSelect: () => editor.chain().focus().toggleTaskList().run() },
@@ -131,7 +134,22 @@ export function useEditorDragHandle(pageConfig) {
           label: "Insert doc link",
           icon: "i-lucide-file-symlink",
           onSelect: () => pageConfig.onInsertDocLink()
-        }] : []
+        }] : [],
+        ...pageConfig?.onCreateChildDoc ? [{
+          label: "Create child document",
+          icon: "i-lucide-file-plus",
+          onSelect: () => pageConfig.onCreateChildDoc()
+        }] : [],
+        {
+          label: "Reset formatting",
+          icon: "i-lucide-eraser",
+          onSelect: () => {
+            if (pos === void 0) return;
+            const node = editor.state.doc.nodeAt(pos);
+            if (!node) return;
+            editor.chain().focus().setTextSelection({ from: pos, to: pos + node.nodeSize }).clearNodes().unsetAllMarks().run();
+          }
+        }
       ],
       [
         {

package/dist/runtime/composables/useEditorSuggestions.js

@@ -1,8 +1,17 @@
 import { computed } from "vue";
+import { useRuntimeConfig } from "#imports";
 import { META_FIELD_DEFINITIONS } from "../utils/metaFieldDefinitions.js";
 import { usePluginRegistry } from "./usePluginRegistry.js";
 export function useEditorSuggestions(options = {}) {
   const registry = usePluginRegistry();
+  const disabledBuiltins = computed(() => {
+    try {
+      return useRuntimeConfig().public?.abracadabra?.disabledBuiltins ?? [];
+    } catch {
+      return [];
+    }
+  });
+  const extEnabled = (name) => !disabledBuiltins.value.includes(name);
   const items = computed(() => {
     const ctx = { docId: options.docId ?? "" };
     const base = options.onlyPlugins ? [] : [
@@ -47,7 +56,23 @@ export function useEditorSuggestions(options = {}) {
         { 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"] }
+        { kind: "fieldGroup", label: "Field Group", icon: "i-lucide-rows-3", description: "Group of form fields", keywords: ["form", "fields", "properties", "meta"] },
+        // Optional built-ins — filtered out when listed in disabledBuiltins.
+        ...extEnabled("divider") ? [{ kind: "divider", label: "Labelled Divider", icon: "i-lucide-separator-horizontal", description: "Section divider with optional label", keywords: ["line", "separator", "section"] }] : [],
+        ...extEnabled("quote") ? [{ kind: "quote", label: "Quote", icon: "i-lucide-quote", description: "Quoted text with author and avatar", keywords: ["blockquote", "citation", "testimonial"] }] : [],
+        ...extEnabled("figure") ? [{ kind: "figure", label: "Figure", icon: "i-lucide-image", description: "Image with caption", keywords: ["image", "picture", "photo", "caption"] }] : [],
+        ...extEnabled("embed") ? [{ kind: "embed", label: "Embed", icon: "i-lucide-code-xml", description: "iframe embed (CodePen, Figma, \u2026)", keywords: ["iframe", "codepen", "figma", "tweet"] }] : [],
+        ...extEnabled("video") ? [{ kind: "video", label: "Video", icon: "i-lucide-play-circle", description: "YouTube, Vimeo, or self-hosted video", keywords: ["youtube", "vimeo", "mp4", "movie"] }] : [],
+        ...extEnabled("stat") ? [{ kind: "stat", label: "Stat", icon: "i-lucide-chart-no-axes-column", description: "KPI display with label, value, and trend", keywords: ["metric", "kpi", "number", "dashboard"] }] : [],
+        ...extEnabled("statGroup") ? [{ kind: "statGroup", label: "Stat Group", icon: "i-lucide-grid-2x2", description: "Grid of three KPI stats", keywords: ["metrics", "kpi", "dashboard"] }] : [],
+        ...extEnabled("button") ? [{ kind: "button", label: "Button", icon: "i-lucide-mouse-pointer-click", description: "Call-to-action button with link", keywords: ["cta", "link", "action"] }] : [],
+        ...extEnabled("buttonGroup") ? [{ kind: "buttonGroup", label: "Button Group", icon: "i-lucide-square-mouse-pointer", description: "Two paired buttons", keywords: ["cta", "actions", "paired"] }] : [],
+        ...extEnabled("progress") ? [{ kind: "progress", label: "Progress Bar", icon: "i-lucide-bar-chart-horizontal", description: "Labeled progress bar", keywords: ["bar", "completion", "percent"] }] : [],
+        ...extEnabled("spoiler") ? [{ kind: "spoiler", label: "Spoiler", icon: "i-lucide-eye-off", description: "Hide-and-reveal block", keywords: ["hide", "collapse", "spoiler"] }] : [],
+        ...extEnabled("colorSwatch") ? [{ kind: "colorSwatch", label: "Color Swatch", icon: "i-lucide-palette", description: "Inline color chip with picker", keywords: ["color", "swatch", "token", "palette"] }] : [],
+        ...extEnabled("mathBlock") ? [{ kind: "mathBlock", label: "Math (block)", icon: "i-lucide-square-sigma", description: "Display-mode LaTeX equation", keywords: ["katex", "latex", "equation", "formula", "math"] }] : [],
+        ...extEnabled("mathInline") ? [{ kind: "mathInline", label: "Math (inline)", icon: "i-lucide-sigma", description: "Inline LaTeX expression", keywords: ["katex", "latex", "inline math"] }] : [],
+        ...extEnabled("diff") ? [{ kind: "diff", label: "Diff", icon: "i-lucide-git-compare", description: "Side-by-side text diff", keywords: ["compare", "changes", "git"] }] : []
       ]
     ];
     try {

package/dist/runtime/composables/useEditorToolbar.js

@@ -43,7 +43,15 @@ export function useEditorToolbar(options = {}) {
       { kind: "mark", mark: "strike", icon: "i-lucide-strikethrough", tooltip: { text: "Strikethrough" } },
       { kind: "mark", mark: "code", icon: "i-lucide-code", tooltip: { text: "Inline code" } }
     ], [
-      { kind: "mark", mark: "link", icon: "i-lucide-link", tooltip: { text: "Link" } }
+      // Slot-based items — UEditorToolbar renders whatever the consumer
+      // supplies via <template #link>, <template #doc-link>, etc. AEditor
+      // provides defaults for `link` and `doc-link` (the popover primitives);
+      // `create-child-doc` and `send-to-chat` render nothing unless the
+      // consuming app fills the slot.
+      { slot: "link" },
+      { slot: "doc-link" },
+      { slot: "create-child-doc" },
+      { slot: "send-to-chat" }
     ]];
     try {
       const pluginGroups = registry.getAllToolbarItems(ctx);

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

@@ -0,0 +1,33 @@
+/**
+ * useEmailVerification
+ *
+ * Wraps the email-verification half of the auth lifecycle.
+ * - `request()` triggers a verification email (rate-limited 1/min, 10/day).
+ * - `confirm(token)` consumes the token from the email link; no auth needed.
+ *
+ * `verified` mirrors the most recent local result of `confirm()` — the
+ * server doesn't currently expose `email_verified_at` on `getMe()`, so
+ * the canonical signal is "did `confirm()` succeed in this session".
+ *
+ * Usage:
+ *   const { verified, isRequesting, isConfirming, error, request, confirm } = useEmailVerification()
+ */
+declare function request(): Promise<void>;
+declare function confirm(token: string): Promise<void>;
+export declare function useEmailVerification(): {
+    /** True after a successful `confirm()` in the current session. */
+    verified: import("vue").Ref<boolean, boolean>;
+    /** Whether a `request()` is in flight. */
+    isRequesting: import("vue").Ref<boolean, boolean>;
+    /** Whether a `confirm()` is in flight. */
+    isConfirming: import("vue").Ref<boolean, boolean>;
+    /** Last error message, or null. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** Epoch ms of the last successful `request()`, or null. */
+    lastSentAt: import("vue").Ref<number | null, number | null>;
+    /** Send a verification email to the current user. Requires auth. */
+    request: typeof request;
+    /** Confirm a verification token from the email link. No auth required. */
+    confirm: typeof confirm;
+};
+export {};

package/dist/runtime/composables/useEmailVerification.js

@@ -0,0 +1,58 @@
+import { ref } from "vue";
+import { useAbracadabra } from "#imports";
+const verified = ref(false);
+const isRequesting = ref(false);
+const isConfirming = ref(false);
+const error = ref(null);
+const lastSentAt = ref(null);
+async function request() {
+  const abra = useAbracadabra();
+  const client = abra.client.value;
+  if (!client) throw new Error("Not connected");
+  isRequesting.value = true;
+  error.value = null;
+  try {
+    await client.requestEmailVerification();
+    lastSentAt.value = Date.now();
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to send verification email";
+    throw e;
+  } finally {
+    isRequesting.value = false;
+  }
+}
+async function confirm(token) {
+  const abra = useAbracadabra();
+  const client = abra.client.value;
+  if (!client) throw new Error("Not connected");
+  isConfirming.value = true;
+  error.value = null;
+  try {
+    await client.confirmEmailVerification(token);
+    verified.value = true;
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Verification failed";
+    verified.value = false;
+    throw e;
+  } finally {
+    isConfirming.value = false;
+  }
+}
+export function useEmailVerification() {
+  return {
+    /** True after a successful `confirm()` in the current session. */
+    verified,
+    /** Whether a `request()` is in flight. */
+    isRequesting,
+    /** Whether a `confirm()` is in flight. */
+    isConfirming,
+    /** Last error message, or null. */
+    error,
+    /** Epoch ms of the last successful `request()`, or null. */
+    lastSentAt,
+    /** Send a verification email to the current user. Requires auth. */
+    request,
+    /** Confirm a verification token from the email link. No auth required. */
+    confirm
+  };
+}

package/dist/runtime/composables/useIdentityDoc.js

@@ -71,9 +71,7 @@ function _migrateFromLocalStorage(provider) {
           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);
         }
@@ -96,7 +94,6 @@ function _migrateFromLocalStorage(provider) {
           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);

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

@@ -0,0 +1,47 @@
+import { type Ref, type MaybeRefOrGetter } from 'vue';
+export interface PresenceUser {
+    name: string;
+    color: string;
+    publicKey?: string;
+    clientId: number;
+}
+/**
+ * Renderer-facing helper for "who is currently viewing this item" indicators.
+ *
+ * Derives a `docId → users` map from awareness states (both `state.docId`
+ * for full-page navigation and `state.viewingDocId` for slideover-opened
+ * docs), so a user with a side panel open shows up on both the parent doc
+ * and the panel doc.
+ *
+ * Renderers iterate their items and call `getViewers(item.id)` to render
+ * avatars and a viewing-style accent. Hover-style accents remain
+ * renderer-local; viewing is always sourced from this shared map so it
+ * stays consistent across renderers.
+ *
+ * Ported from cou-sh/app/composables/useItemPresence.ts. The cou-sh version
+ * aggregates across all connected `useSpaceConnections` providers; this
+ * single-space port reads from the active provider only. Multi-space
+ * aggregation is deferred until `useAggregatedPresence` /
+ * `useSpaceConnections` are ported (~1200 LOC, see _NEXT_ROUND_BLOCKERS.md).
+ */
+export declare function useItemPresence(): {
+    getViewers: (itemId: string | undefined | null) => PresenceUser[];
+    viewingColor: (itemId: string | undefined | null) => string | null;
+    viewingBorderLeft: (itemId: string | undefined | null) => {
+        borderLeft: string;
+    } | undefined;
+    viewingRingStyle: (itemId: string | undefined | null) => {
+        boxShadow: string;
+        outline: string;
+    } | undefined;
+    docPresence: import("vue").ComputedRef<Map<string, PresenceUser[]>>;
+};
+/**
+ * Broadcasts "this user has a slideover open on `nodeId`" to the active
+ * provider's awareness, where it lands on `state.viewingDocId`. This is the
+ * write-side counterpart to `useItemPresence().getViewers()`.
+ *
+ * Single-space port: writes only to the current provider's awareness. The
+ * cou-sh version routes by `spaceId` lookup across multi-space connections.
+ */
+export declare function useViewingBroadcast(parentDocIdRef: MaybeRefOrGetter<string>, openNodeId: Ref<string | null>): void;