@abraca/nuxt 0.2.0 → 1.5.0

package/dist/runtime/server/utils/spaceManager.js

@@ -0,0 +1,188 @@
+import { startRunner, stopRunner, stopRunnersWithPrefix } from "./serverRunner.js";
+import { createDocCacheAPI } from "./docCache.js";
+import { loadServerPlugin } from "./serverPluginLoader.js";
+import { docTreeCacheRunner } from "../runners/doc-tree-cache.js";
+const _spaces = /* @__PURE__ */ new Map();
+let _baseCtx = null;
+let _pollInterval = null;
+const POLL_INTERVAL_MS = 6e4;
+export async function initSpaceManager(baseCtx) {
+  _baseCtx = baseCtx;
+  globalThis.__ABRACA_SHARED__ = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- shared globals bridge
+    ...globalThis.__ABRACA_SHARED__
+  };
+  await discoverSpaces();
+  _pollInterval = setInterval(() => {
+    discoverSpaces().catch(
+      (err) => console.error("[space-manager] Poll failed:", err)
+    );
+  }, POLL_INTERVAL_MS);
+}
+export async function shutdownSpaceManager() {
+  if (_pollInterval) {
+    clearInterval(_pollInterval);
+    _pollInterval = null;
+  }
+  const spaceIds = [..._spaces.keys()];
+  for (const spaceId of spaceIds) {
+    await disconnectSpace(spaceId);
+  }
+}
+export function getConnectedSpaces() {
+  return [..._spaces.keys()];
+}
+async function discoverSpaces() {
+  if (!_baseCtx) return;
+  let spaces;
+  try {
+    spaces = await _baseCtx.client.listSpaces();
+  } catch (err) {
+    console.error("[space-manager] Failed to list spaces:", err);
+    return;
+  }
+  const currentIds = new Set(spaces.map((s) => s.id));
+  for (const meta of spaces) {
+    if (meta.is_hub) continue;
+    if (!_spaces.has(meta.id)) {
+      await connectSpace(meta);
+    }
+  }
+  const existingIds = [..._spaces.keys()];
+  for (const spaceId of existingIds) {
+    if (!currentIds.has(spaceId)) {
+      await disconnectSpace(spaceId);
+    }
+  }
+}
+async function connectSpace(meta) {
+  if (!_baseCtx || _spaces.has(meta.id)) return;
+  console.log(`[space-manager] Connecting space: ${meta.name} (${meta.id})`);
+  const Y = await import("yjs");
+  const doc = new Y.Doc();
+  const { AbracadabraProvider } = await import("@abraca/dabra");
+  const provider = new AbracadabraProvider({
+    client: _baseCtx.client,
+    document: doc,
+    name: meta.doc_id,
+    websocketProvider: _baseCtx.wsp,
+    disableOfflineStore: true
+  });
+  provider.attach();
+  await new Promise((resolve) => {
+    const done = () => {
+      provider.off("synced", done);
+      resolve();
+    };
+    provider.on("synced", done);
+    setTimeout(resolve, 1e4);
+  });
+  const conn = {
+    spaceId: meta.id,
+    docId: meta.doc_id,
+    meta,
+    provider,
+    doc,
+    pluginObserver: null,
+    loadedPlugins: /* @__PURE__ */ new Map()
+  };
+  _spaces.set(meta.id, conn);
+  console.log(`[space-manager] Space synced: ${meta.name}`);
+  const spaceCtx = buildSpaceContext(conn);
+  await startRunner(docTreeCacheRunner, spaceCtx, meta.doc_id);
+  observeSpacePlugins(conn);
+}
+async function disconnectSpace(spaceId) {
+  const conn = _spaces.get(spaceId);
+  if (!conn) return;
+  console.log(`[space-manager] Disconnecting space: ${conn.meta.name} (${spaceId})`);
+  if (conn.pluginObserver) {
+    try {
+      const pluginsMap = conn.doc.getMap("space-plugins");
+      pluginsMap.unobserve(conn.pluginObserver);
+    } catch {
+    }
+  }
+  await stopRunnersWithPrefix(conn.docId);
+  conn.provider.destroy();
+  conn.doc.destroy();
+  _spaces.delete(spaceId);
+}
+function observeSpacePlugins(conn) {
+  const pluginsMap = conn.doc.getMap("space-plugins");
+  processPluginMap(conn, pluginsMap);
+  conn.pluginObserver = (event) => {
+    processPluginMapChanges(conn, pluginsMap, event);
+  };
+  pluginsMap.observe(conn.pluginObserver);
+}
+async function processPluginMap(conn, pluginsMap) {
+  const Y = await import("yjs");
+  const toLoad = [];
+  pluginsMap.forEach((value, pluginName) => {
+    const entry = value instanceof Y.Map ? value.toJSON() : value;
+    if (entry?.enabled && entry?.url) {
+      toLoad.push({ name: pluginName, url: entry.url });
+    }
+  });
+  for (const { name, url } of toLoad) {
+    await loadAndStartPlugin(conn, name, url);
+  }
+}
+async function processPluginMapChanges(conn, pluginsMap, event) {
+  const Y = await import("yjs");
+  for (const key of event.keysChanged) {
+    const value = pluginsMap.get(key);
+    if (!value) {
+      await stopPluginRunners(conn, key);
+      continue;
+    }
+    const entry = value instanceof Y.Map ? value.toJSON() : value;
+    if (entry?.enabled && entry?.url) {
+      if (!conn.loadedPlugins.has(key)) {
+        await loadAndStartPlugin(conn, key, entry.url);
+      }
+    } else {
+      await stopPluginRunners(conn, key);
+    }
+  }
+}
+async function loadAndStartPlugin(conn, pluginName, url) {
+  try {
+    const plugin = await loadServerPlugin(url);
+    if (!plugin.serverRunners?.length) {
+      console.warn(`[space-manager] Plugin "${pluginName}" has no server runners`);
+      return;
+    }
+    const spaceCtx = buildSpaceContext(conn);
+    const runnerKeys = [];
+    for (const def of plugin.serverRunners) {
+      const key = `${conn.docId}:${def.name}`;
+      await startRunner(def, spaceCtx, conn.docId);
+      runnerKeys.push(key);
+    }
+    conn.loadedPlugins.set(pluginName, runnerKeys);
+    console.log(`[space-manager] Started plugin "${pluginName}" in space "${conn.meta.name}" (${plugin.serverRunners.length} runners)`);
+  } catch (err) {
+    console.error(`[space-manager] Failed to load plugin "${pluginName}" from ${url}:`, err);
+  }
+}
+async function stopPluginRunners(conn, pluginName) {
+  const keys = conn.loadedPlugins.get(pluginName);
+  if (!keys) return;
+  for (const key of keys) {
+    await stopRunner(key);
+  }
+  conn.loadedPlugins.delete(pluginName);
+  console.log(`[space-manager] Stopped plugin "${pluginName}" in space "${conn.meta.name}"`);
+}
+function buildSpaceContext(conn) {
+  return {
+    client: _baseCtx.client,
+    wsp: _baseCtx.wsp,
+    rootDoc: conn.doc,
+    rootProvider: conn.provider,
+    storage: _baseCtx.storage,
+    docCache: createDocCacheAPI(conn.doc)
+  };
+}

package/dist/runtime/types.d.ts

@@ -1,7 +1,10 @@
 import type { ShallowRef, Ref, Component } from 'vue';
 import type { Extension } from '@tiptap/core';
 import type { Editor } from '@tiptap/vue-3';
+import type { Node as ProsemirrorNode } from '@tiptap/pm/model';
 import type * as Y from 'yjs';
+import type { AbracadabraClient, AbracadabraProvider, AbracadabraWS, CryptoIdentityKeystore } from '@abraca/dabra';
+import type { Router } from 'vue-router';
 /**
  * An Abracadabra plugin contributes editor extensions, page types, toolbar items,
  * slash commands, mentions, awareness fields, command palette items, and more.
@@ -34,7 +37,7 @@ export interface AbracadabraPlugin {
     /** Extra drag-handle menu items (per-block context menu) */
     dragHandleItems?: (ctx: DragHandlePluginCtx) => AbracadabraDragHandleItem[][];
     /** Custom editor handlers merged into UEditorCustomHandlers */
-    customHandlers?: () => Record<string, (...args: any[]) => any>;
+    customHandlers?: () => Record<string, (...args: unknown[]) => unknown>;
     /** Mention (@) providers contributing items to the mention popup */
     mentionProviders?: AbracadabraMentionProvider[];
     /** Awareness field declarations — keys this plugin reads/writes on awareness */
@@ -51,14 +54,14 @@ export interface AbracadabraPlugin {
      * Client-side setup hook — called once after client + provider are ready.
      * May return a teardown function called on app unmount.
      */
-    clientSetup?: (ctx: ClientPluginCtx) => void | Promise<void | (() => void)>;
+    clientSetup?: (ctx: ClientPluginCtx) => undefined | Promise<undefined | (() => void)>;
     /** TipTap extensions safe for server-side Y.Doc → HTML rendering (no Vue NodeViews) */
     serverExtensions?: () => Extension[];
     /**
      * Custom cache renderer for non-doc page types.
      * Receives the Y.Doc and returns serializable data for the cache.
      */
-    serverCacheRenderer?: (docId: string, ydoc: Y.Doc) => any;
+    serverCacheRenderer?: (docId: string, ydoc: Y.Doc) => unknown;
     /**
      * Server-side background runners (Nitro context).
      * Each runner receives a ServerRunnerContext and returns a cleanup function.
@@ -78,7 +81,7 @@ export interface EditorPluginCtx {
 /** Context passed to drag-handle plugin hooks */
 export interface DragHandlePluginCtx extends EditorPluginCtx {
     selectedNode: Ref<{
-        node: any | null;
+        node: ProsemirrorNode | null;
         pos: number;
     } | undefined>;
 }
@@ -130,9 +133,30 @@ export interface AbracadabraDragHandleItem {
 }
 export interface CommandPaletteCtx {
     docId: string | null;
-    router: any;
-    abracadabra: any;
-    tree: any | null;
+    router: Router;
+    abracadabra: AbracadabraState;
+    tree: DocTreeHelper | null;
+}
+/**
+ * Tree helper shape — matches useChildTree()'s return type.
+ * Declared here to avoid circular imports.
+ */
+export interface DocTreeHelper {
+    entries: import('vue').ComputedRef<TreeEntry[]>;
+    childrenOf: (parentId: string | null) => TreeEntry[];
+    descendantsOf: (id: string) => TreeEntry[];
+    createChild: (parentId: string | null, label: string, type?: string) => string;
+    moveEntry: (id: string, newParentId: string | null, newOrder: number) => void;
+    deleteEntry: (id: string) => void;
+    renameEntry: (id: string, label: string) => void;
+    updateMeta: (id: string, patch: Partial<DocPageMeta>) => void;
+    duplicateEntry: (id: string) => string;
+    treeMap: {
+        data: Record<string, any>;
+    };
+    trashMap: {
+        data: Record<string, any>;
+    };
 }
 export interface AbracadabraCommandItem {
     id: string;
@@ -152,14 +176,14 @@ export interface AbracadabraMentionProvider {
 export interface MentionPluginCtx {
     docId: string;
     connectedUsers: CollaborationUser[];
-    rootDoc: any;
+    rootDoc: Y.Doc;
 }
 export interface AbracadabraMentionItem {
     id: string;
     label: string;
     avatar?: string;
     color?: string;
-    attrs?: Record<string, any>;
+    attrs?: Record<string, unknown>;
 }
 export interface AbracadabraAwarenessContribution {
     /** Namespaced keys this plugin writes, e.g. ['cursor', 'presence:kanban'] */
@@ -176,11 +200,11 @@ export interface AbracadabraNodePanelSlot {
 }
 export interface NodePanelCtx {
     childId: string;
-    childDoc: any | null;
+    childDoc: Y.Doc | null;
     parentDocId: string;
     parentType: string | undefined;
-    meta: Record<string, any>;
-    tree: any;
+    meta: Record<string, unknown>;
+    tree: DocTreeHelper;
 }
 export interface AbracadabraSettingsPanel {
     label: string;
@@ -259,6 +283,27 @@ export interface DocPageMeta extends Record<string, unknown> {
     graphPinned?: boolean;
     _metaFields?: UserMetaField[];
     _metaInitialized?: boolean;
+    tableMode?: 'hierarchy' | 'flat';
+    tableColumns?: TableColumnDef[];
+    tableColumnOrder?: string[];
+    tableColumnWidths?: Record<string, number>;
+    tableSortKey?: string;
+    tableSortDir?: 'asc' | 'desc';
+    timelinePixelsPerDay?: number;
+    timelineCenterDate?: string;
+    timelineZoom?: string;
+}
+export interface TableColumnDef {
+    id: string;
+    type: 'label' | 'meta';
+    metaKey?: string;
+    metaType?: string;
+    label: string;
+    options?: string[];
+    sliderMin?: number;
+    sliderMax?: number;
+    step?: number;
+    unit?: string;
 }
 export interface TreeEntry {
     id: string;
@@ -306,6 +351,15 @@ export interface SpaceMeta {
     created_at: number;
     updated_at: number;
 }
+export interface InviteInfo {
+    code: string;
+    role: string;
+    max_uses: number;
+    uses: number;
+    created_at: number;
+    expires_at: number | null;
+    created_by: string | null;
+}
 export interface SavedServer {
     url: string;
     label: string;
@@ -324,20 +378,37 @@ export interface LogEntry {
     message: string;
     type: 'system' | 'connection' | 'auth' | 'sync' | 'user' | 'data';
 }
-export declare const UI_COLORS: readonly ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose", "grass", "diamond", "gold", "redstone", "lapis", "wood", "discord", "steam", "oxidized"];
-export declare const UI_NEUTRALS: readonly ["slate", "gray", "zinc", "neutral", "stone", "cobblestone", "bedrock", "cream", "sage", "lavender", "blush", "copper", "oxidized", "mint", "peach", "mist", "mauve"];
+export declare const UI_COLORS: readonly ["red", "coral", "orange", "amber", "yellow", "chartreuse", "lime", "green", "jade", "emerald", "teal", "cyan", "sky", "blue", "sapphire", "indigo", "violet", "purple", "fuchsia", "magenta", "pink", "rose", "oxidized"];
+export declare const UI_NEUTRALS: readonly ["slate", "gray", "zinc", "neutral", "stone", "cobblestone", "bedrock", "cream", "sand", "bark", "sage", "moss", "lavender", "blush", "wine", "copper", "oxidized", "mint", "peach", "fog", "mist", "mauve", "dusk"];
 export declare const COLOR_HUES: Record<string, number>;
 export declare function deriveColorFromPubKey(pubKey: string): {
     name: string;
     hsl: string;
     neutralName: string;
 };
+/**
+ * Explicit identity state machine.
+ *
+ * Transitions:
+ *   initializing → guest       (soft-key generated)
+ *   initializing → claimed     (passkey restored from cache)
+ *   initializing → identityLost (was claimed but cached key missing)
+ *   guest → claimed            (claimAccount succeeds)
+ *   claimed → needsReauth      (token expired, passkey re-auth available)
+ *   claimed → identityLost     (passkey/key cache lost)
+ *   needsReauth → claimed      (loginWithHardware succeeds)
+ *   → connectionBlocked      (AUTH_FAILURE_LIMIT reached or permanent denial)
+ *   connectionBlocked → (previous) (unblockConnection called)
+ */
+export type IdentityState = 'initializing' | 'guest' | 'claimed' | 'identityLost' | 'needsReauth' | 'connectionBlocked';
 /** Injected into nuxtApp as $abracadabra */
 export interface AbracadabraState {
     doc: ShallowRef<Y.Doc>;
-    provider: ShallowRef<any | null>;
-    client: ShallowRef<any | null>;
-    keystore: ShallowRef<any | null>;
+    /** The doc ID of the current space (the invisible root of the tree). */
+    spaceDocId: Ref<string | null>;
+    provider: ShallowRef<AbracadabraProvider | null>;
+    client: ShallowRef<AbracadabraClient | null>;
+    keystore: ShallowRef<CryptoIdentityKeystore | null>;
     status: Ref<'disconnected' | 'connecting' | 'connected'>;
     synced: Ref<boolean>;
     isReady: Ref<boolean>;
@@ -349,15 +420,23 @@ export interface AbracadabraState {
     userCount: Ref<number>;
     publicKeyB64: Ref<string>;
     connectionError: Ref<string | null>;
+    /** Explicit identity state machine — prefer over individual booleans. */
+    identityState: Ref<IdentityState>;
+    /** @deprecated Use `identityState === 'claimed'` */
     isClaimed: Ref<boolean>;
+    /** @deprecated Use `identityState === 'identityLost'` */
     identityLost: Ref<boolean>;
+    /** @deprecated Use `identityState === 'needsReauth'` */
     needsReauth: Ref<boolean>;
     requirePasskeyOnLogin: Ref<boolean>;
+    /** @deprecated Use `identityState === 'connectionBlocked'` */
     isConnectionBlocked: Ref<boolean>;
+    effectiveRole: Ref<string | null>;
+    unsyncedChanges: Ref<number>;
     currentServerUrl: Ref<string>;
     savedServers: Ref<SavedServer[]>;
-    currentServerSpaces: any;
-    currentServerSpacesEnabled: any;
+    currentServerSpaces: Ref<SpaceMeta[]>;
+    currentServerSpacesEnabled: Ref<boolean>;
     pendingInviteCode: Ref<string | null>;
     registry: import('./plugin-registry').PluginRegistry;
     addLog: (message: string, type?: LogEntry['type']) => void;
@@ -387,31 +466,51 @@ export interface AbracadabraState {
         role?: string;
         maxUses?: number;
         expiresIn?: number;
-    }) => Promise<any>;
-    listInvites: () => Promise<any[]>;
+    }) => Promise<InviteInfo>;
+    listInvites: () => Promise<InviteInfo[]>;
     revokeInvite: (code: string) => Promise<void>;
+    /**
+     * Attempt identity recovery: tries silent passkey re-auth, then falls back
+     * to emitting a recoverable event so the app can show mnemonic input.
+     * Returns true if recovery succeeded.
+     */
+    recoverIdentity: () => Promise<boolean>;
+    /**
+     * Reset auth failure count and reconnect. Use when the user has resolved
+     * the issue that caused repeated auth failures (e.g. re-invited, role fixed).
+     */
+    unblockConnection: () => void;
+    broadcastSyncActive: Ref<boolean>;
     init: (serverUrl?: string) => Promise<void>;
 }
+/** Nitro storage interface (subset used by runners) */
+export interface NitroStorage {
+    getItem: (key: string) => Promise<unknown>;
+    setItem: (key: string, value: unknown) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    getKeys: (base?: string) => Promise<string[]>;
+    hasItem: (key: string) => Promise<boolean>;
+}
 /**
  * Cleanup function returned by a runner's start().
  * Called on graceful server shutdown.
  */
-export type RunnerCleanup = (() => void | Promise<void>) | void;
+export type RunnerCleanup = (() => void | Promise<void>) | undefined;
 /**
  * Context provided to every server-side runner.
  * Available after the service provider successfully syncs with the root document.
  */
 export interface ServerRunnerContext {
     /** Service-role REST + auth client (AbracadabraClient) */
-    client: any;
-    /** Shared HocuspocusProviderWebsocket — reuse for all child providers */
-    wsp: any;
+    client: AbracadabraClient;
+    /** Shared AbracadabraWS — reuse for all child providers */
+    wsp: AbracadabraWS;
     /** Root Y.Doc (the world document) */
-    rootDoc: any;
+    rootDoc: Y.Doc;
     /** Root AbracadabraProvider — call .loadChild(docId) to open sub-documents */
-    rootProvider: any;
+    rootProvider: AbracadabraProvider;
     /** Nitro useStorage() handle — use for persistent cache across requests */
-    storage: any;
+    storage: NitroStorage;
     /** Document cache API: read/write HTML+JSON renders, build tree snapshots */
     docCache: DocCacheAPI;
 }
@@ -429,7 +528,7 @@ export interface ServerRunnerDefinition {
  */
 export interface DocCacheAPI {
     getHTML: (docId: string) => Promise<string | null>;
-    getJSON: (docId: string) => Promise<any | null>;
+    getJSON: (docId: string) => Promise<Record<string, unknown> | null>;
     invalidate: (docId: string) => Promise<void>;
     getTree: () => Promise<CachedTreeNode[]>;
 }
@@ -439,6 +538,6 @@ export interface CachedTreeNode {
     label: string;
     type: string;
     html: string | null;
-    data: any | null;
+    data: Record<string, unknown> | null;
     children: CachedTreeNode[];
 }

package/dist/runtime/types.js

@@ -1,29 +1,26 @@
 export const UI_COLORS = [
   "red",
+  "coral",
   "orange",
   "amber",
   "yellow",
+  "chartreuse",
   "lime",
   "green",
+  "jade",
   "emerald",
   "teal",
   "cyan",
   "sky",
   "blue",
+  "sapphire",
   "indigo",
   "violet",
   "purple",
   "fuchsia",
+  "magenta",
   "pink",
   "rose",
-  "grass",
-  "diamond",
-  "gold",
-  "redstone",
-  "lapis",
-  "wood",
-  "discord",
-  "steam",
   "oxidized"
 ];
 export const UI_NEUTRALS = [
@@ -35,15 +32,21 @@ export const UI_NEUTRALS = [
   "cobblestone",
   "bedrock",
   "cream",
+  "sand",
+  "bark",
   "sage",
+  "moss",
   "lavender",
   "blush",
+  "wine",
   "copper",
   "oxidized",
   "mint",
   "peach",
+  "fog",
   "mist",
-  "mauve"
+  "mauve",
+  "dusk"
 ];
 export const COLOR_HUES = {
   red: 0,
@@ -61,16 +64,13 @@ export const COLOR_HUES = {
   violet: 258,
   purple: 271,
   fuchsia: 292,
+  magenta: 310,
   pink: 330,
   rose: 350,
-  grass: 142,
-  diamond: 187,
-  gold: 48,
-  redstone: 0,
-  lapis: 217,
-  wood: 20,
-  discord: 235,
-  steam: 84,
+  coral: 16,
+  chartreuse: 75,
+  jade: 152,
+  sapphire: 225,
   oxidized: 168
 };
 export function deriveColorFromPubKey(pubKey) {

package/dist/runtime/utils/chatContent.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Chat message content parsing and rendering utilities.
+ *
+ * Handles doc-quote, doc-link, and plain text messages with @mention
+ * and URL segment extraction for rich rendering.
+ *
+ * Ported from cou-sh/app/utils/chatContent.ts.
+ */
+export type ParsedMessage = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'doc-quote';
+    text: string;
+    docId: string;
+    from: number;
+    to: number;
+    label: string;
+    section: string;
+} | {
+    kind: 'doc-link';
+    docId: string;
+    label: string;
+    icon?: string;
+};
+export declare function parseMessageContent(content: string): ParsedMessage;
+/** Segment types for rich text rendering */
+export type TextSegment = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'link';
+    url: string;
+} | {
+    type: 'mention';
+    name: string;
+};
+/** Split plain text into segments for rich rendering (links, @mentions) */
+export declare function renderMessageSegments(text: string): TextSegment[];
+/** Return a short plain-text preview for any message content string. */
+export declare function previewMessageContent(content: string): string;

package/dist/runtime/utils/chatContent.js

@@ -0,0 +1,65 @@
+export function parseMessageContent(content) {
+  if (content.startsWith("{")) {
+    try {
+      const obj = JSON.parse(content);
+      if (obj.type === "doc-quote") {
+        return {
+          kind: "doc-quote",
+          text: obj.text ?? "",
+          docId: obj.docId ?? "",
+          from: obj.from ?? 0,
+          to: obj.to ?? 0,
+          label: obj.label ?? "",
+          section: obj.section ?? ""
+        };
+      }
+      if (obj.type === "doc-link") {
+        return {
+          kind: "doc-link",
+          docId: obj.docId ?? "",
+          label: obj.label ?? "",
+          icon: obj.icon
+        };
+      }
+    } catch {
+    }
+  }
+  return { kind: "text", text: content };
+}
+const URL_RE = /https?:\/\/[^\s<>)"']+/g;
+const MENTION_RE = /@(\w+)/g;
+export function renderMessageSegments(text) {
+  const segments = [];
+  const matches = [];
+  for (const m of text.matchAll(URL_RE)) {
+    matches.push({ index: m.index, length: m[0].length, segment: { type: "link", url: m[0] } });
+  }
+  for (const m of text.matchAll(MENTION_RE)) {
+    matches.push({ index: m.index, length: m[0].length, segment: { type: "mention", name: m[1] } });
+  }
+  matches.sort((a, b) => a.index - b.index);
+  let cursor = 0;
+  for (const m of matches) {
+    if (m.index < cursor) continue;
+    if (m.index > cursor) {
+      segments.push({ type: "text", value: text.slice(cursor, m.index) });
+    }
+    segments.push(m.segment);
+    cursor = m.index + m.length;
+  }
+  if (cursor < text.length) {
+    segments.push({ type: "text", value: text.slice(cursor) });
+  }
+  return segments.length > 0 ? segments : [{ type: "text", value: text }];
+}
+export function previewMessageContent(content) {
+  const parsed = parseMessageContent(content);
+  if (parsed.kind === "doc-quote") {
+    const quote = parsed.text ? `"${parsed.text}"` : "";
+    return parsed.label ? `${parsed.label} \u2014 ${quote}` : quote || content;
+  }
+  if (parsed.kind === "doc-link") {
+    return parsed.label || "Document";
+  }
+  return parsed.text;
+}