@abraca/nuxt 0.1.0

package/dist/runtime/plugin-abracadabra.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,71 @@
+import { shallowRef, ref, computed } from "vue";
+import { PluginRegistry } from "./plugin-registry.js";
+export default defineNuxtPlugin({
+  name: "abracadabra:server-stub",
+  enforce: "post",
+  setup(nuxtApp) {
+    const registry = new PluginRegistry();
+    registry.freeze();
+    const noop = () => {
+    };
+    const noopAsync = async () => {
+    };
+    nuxtApp.provide("abracadabra", {
+      // CRDT objects — null on server
+      doc: shallowRef(null),
+      provider: shallowRef(null),
+      client: shallowRef(null),
+      keystore: shallowRef(null),
+      // Connection state
+      status: ref("disconnected"),
+      synced: ref(false),
+      isReady: ref(false),
+      connectionError: ref(null),
+      isConnectionBlocked: ref(false),
+      // User identity
+      userName: ref(""),
+      userColor: ref("#6366f1"),
+      userColorName: ref("indigo"),
+      userNeutralColorName: ref("zinc"),
+      userCount: ref(0),
+      publicKeyB64: ref(""),
+      isClaimed: ref(false),
+      identityLost: ref(false),
+      needsReauth: ref(false),
+      requirePasskeyOnLogin: ref(false),
+      // Servers / spaces
+      currentServerUrl: ref(""),
+      savedServers: ref([]),
+      currentServerSpaces: computed(() => []),
+      currentServerSpacesEnabled: computed(() => false),
+      // Misc
+      pendingInviteCode: ref(null),
+      logs: ref([]),
+      // Plugin registry (empty, frozen)
+      registry,
+      // Methods — all no-ops on server
+      addLog: noop,
+      setUserName: noop,
+      setUserColor: noop,
+      setNeutralColor: noop,
+      setRequirePasskey: noop,
+      reconnect: noop,
+      removeServer: noop,
+      claimAccount: noopAsync,
+      loginWithHardware: noopAsync,
+      logout: noopAsync,
+      addServer: noopAsync,
+      switchServer: noopAsync,
+      switchSpace: noopAsync,
+      refreshSpaces: noopAsync,
+      createSpace: noopAsync,
+      updateSpace: noopAsync,
+      deleteSpace: noopAsync,
+      redeemInvite: noopAsync,
+      createInvite: async () => ({}),
+      listInvites: async () => [],
+      revokeInvite: noopAsync,
+      init: noopAsync
+    });
+  }
+});

package/dist/runtime/plugin-registry.d.ts

@@ -0,0 +1,34 @@
+import type { Extension } from '@tiptap/core';
+import type { AbracadabraPlugin, AbracadabraPageType, AbracadabraToolbarItem, AbracadabraSuggestionItem, AbracadabraDragHandleItem, AbracadabraMentionProvider, AbracadabraAwarenessContribution, AbracadabraCommandItem, AbracadabraNodePanelSlot, AbracadabraSettingsPanel, AbracadabraKeyboardShortcut, EditorPluginCtx, DragHandlePluginCtx, CommandPaletteCtx } from './types.js';
+/**
+ * PluginRegistry — manages the lifecycle of AbracadabraPlugin instances.
+ *
+ * Instantiated once per Nuxt app inside the main client plugin.
+ * After freezePluginRegistry() is called, no new plugins can be registered.
+ * All aggregator methods are safe to call after freezing.
+ */
+export declare class PluginRegistry {
+    private _plugins;
+    private _frozen;
+    register(plugin: AbracadabraPlugin): void;
+    /** Lock the registry. Called after all plugins (built-in + external) are loaded. */
+    freeze(): void;
+    isFrozen(): boolean;
+    getPlugins(): readonly AbracadabraPlugin[];
+    getAllExtensions(): Extension[];
+    /** Waits until all plugins with async extension bundles have finished loading. */
+    waitForExtensions(): Promise<void>;
+    getServerExtensions(): Extension[];
+    getAllPageTypes(): Record<string, AbracadabraPageType>;
+    getAllCustomHandlers(): Record<string, (...args: any[]) => any>;
+    getAllToolbarItems(ctx: EditorPluginCtx): AbracadabraToolbarItem[][];
+    getAllBubbleMenuItems(ctx: EditorPluginCtx): AbracadabraToolbarItem[][];
+    getAllSuggestionItems(ctx: EditorPluginCtx): AbracadabraSuggestionItem[][];
+    getAllDragHandleItems(ctx: DragHandlePluginCtx): AbracadabraDragHandleItem[][];
+    getAllMentionProviders(): AbracadabraMentionProvider[];
+    getAllAwarenessContributions(): AbracadabraAwarenessContribution[];
+    getAllCommandPaletteItems(ctx: CommandPaletteCtx): Promise<AbracadabraCommandItem[]>;
+    getAllNodePanelSlots(): AbracadabraNodePanelSlot[];
+    getSettingsPanels(): AbracadabraSettingsPanel[];
+    getAllKeyboardShortcuts(): AbracadabraKeyboardShortcut[];
+}

package/dist/runtime/plugin-registry.js

@@ -0,0 +1,83 @@
+export class PluginRegistry {
+  _plugins = [];
+  _frozen = false;
+  register(plugin) {
+    if (this._frozen) {
+      console.warn(`[abracadabra] Plugin registry frozen \u2014 cannot register "${plugin.name}"`);
+      return;
+    }
+    if (this._plugins.some((p) => p.name === plugin.name)) {
+      console.warn(`[abracadabra] Plugin "${plugin.name}" already registered`);
+      return;
+    }
+    this._plugins.push(plugin);
+  }
+  /** Lock the registry. Called after all plugins (built-in + external) are loaded. */
+  freeze() {
+    this._frozen = true;
+  }
+  isFrozen() {
+    return this._frozen;
+  }
+  getPlugins() {
+    return this._plugins;
+  }
+  // ── Aggregated getters ───────────────────────────────────────────────────────
+  getAllExtensions() {
+    return this._plugins.flatMap((p) => p.extensions?.() ?? []);
+  }
+  /** Waits until all plugins with async extension bundles have finished loading. */
+  async waitForExtensions() {
+    await Promise.all(this._plugins.map((p) => p.extensionsReady ?? Promise.resolve()));
+  }
+  getServerExtensions() {
+    return this._plugins.flatMap((p) => p.serverExtensions?.() ?? []);
+  }
+  getAllPageTypes() {
+    const merged = {};
+    for (const p of this._plugins) {
+      if (p.pageTypes) Object.assign(merged, p.pageTypes);
+    }
+    return merged;
+  }
+  getAllCustomHandlers() {
+    const merged = {};
+    for (const p of this._plugins) {
+      if (p.customHandlers) Object.assign(merged, p.customHandlers());
+    }
+    return merged;
+  }
+  getAllToolbarItems(ctx) {
+    return this._plugins.flatMap((p) => p.toolbarItems?.(ctx) ?? []);
+  }
+  getAllBubbleMenuItems(ctx) {
+    return this._plugins.flatMap((p) => p.bubbleMenuItems?.(ctx) ?? []);
+  }
+  getAllSuggestionItems(ctx) {
+    return this._plugins.flatMap((p) => p.suggestionItems?.(ctx) ?? []);
+  }
+  getAllDragHandleItems(ctx) {
+    return this._plugins.flatMap((p) => p.dragHandleItems?.(ctx) ?? []);
+  }
+  getAllMentionProviders() {
+    return this._plugins.flatMap((p) => p.mentionProviders ?? []);
+  }
+  getAllAwarenessContributions() {
+    return this._plugins.flatMap((p) => p.awarenessContributions ?? []);
+  }
+  async getAllCommandPaletteItems(ctx) {
+    const results = await Promise.all(
+      this._plugins.filter((p) => p.commandPaletteItems).map((p) => Promise.resolve(p.commandPaletteItems(ctx)))
+    );
+    return results.flat().filter((item) => !item.when || item.when(ctx));
+  }
+  getAllNodePanelSlots() {
+    return this._plugins.flatMap((p) => p.nodePanelSlots ?? []);
+  }
+  getSettingsPanels() {
+    return this._plugins.flatMap((p) => p.settingsPanel ? [p.settingsPanel] : []);
+  }
+  getAllKeyboardShortcuts() {
+    return this._plugins.flatMap((p) => p.keyboardShortcuts ?? []);
+  }
+}

package/dist/runtime/plugin-shared-globals.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin-shared-globals.client.js

@@ -0,0 +1,20 @@
+import * as Vue from "vue";
+import * as Yjs from "yjs";
+export default defineNuxtPlugin({
+  name: "abracadabra:shared-globals",
+  enforce: "pre",
+  setup() {
+    Promise.all([
+      import("@tiptap/core").catch(() => null),
+      import("@tiptap/vue-3").catch(() => null)
+    ]).then(([core, vue3]) => {
+      ;
+      globalThis.__ABRACA_SHARED__ = {
+        vue: Vue,
+        yjs: Yjs,
+        ...core ? { "@tiptap/core": core } : {},
+        ...vue3 ? { "@tiptap/vue-3": vue3 } : {}
+      };
+    });
+  }
+});

package/dist/runtime/plugins/core.plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Core built-in plugin for nuxt-abracadabra.
+ *
+ * Provides structural TipTap extensions that most collaborative documents need.
+ * Extensions are split into two loaders:
+ *  - loadClientExtensions(): full set including Vue NodeViews (client only)
+ *  - loadServerExtensions(): pure ProseMirror extensions safe for SSR rendering
+ *
+ * Registered automatically by the module.
+ */
+import type { AbracadabraPlugin } from '../types.js';
+export declare const corePlugin: AbracadabraPlugin;

package/dist/runtime/plugins/core.plugin.js

@@ -0,0 +1,179 @@
+import { DOC_TYPES } from "../utils/docTypes.js";
+async function loadClientExtensions() {
+  const [
+    { default: TaskList },
+    { default: TaskItem },
+    { Table },
+    { default: TableRow },
+    { default: TableHeader },
+    { default: TableCell },
+    { default: CharacterCount },
+    { default: TextAlign },
+    { default: Highlight },
+    { default: Color },
+    { TextStyle },
+    { default: Superscript },
+    { default: Subscript },
+    { default: CodeBlockLowlight },
+    { createLowlight, common },
+    { Document },
+    { DocumentHeader },
+    { DocumentMeta },
+    { FileDrop },
+    { SearchHighlight },
+    { Callout },
+    { Collapsible },
+    { Accordion, AccordionItem },
+    { Tabs, TabsItem },
+    { Card, CardGroup },
+    { Steps },
+    { CodeCollapse },
+    { CodeGroup },
+    { Badge },
+    { Kbd },
+    { ProseIcon },
+    { FileBlock }
+  ] = await Promise.all([
+    import("@tiptap/extension-task-list"),
+    import("@tiptap/extension-task-item"),
+    import("@tiptap/extension-table"),
+    import("@tiptap/extension-table-row"),
+    import("@tiptap/extension-table-header"),
+    import("@tiptap/extension-table-cell"),
+    import("@tiptap/extension-character-count"),
+    import("@tiptap/extension-text-align"),
+    import("@tiptap/extension-highlight"),
+    import("@tiptap/extension-color"),
+    import("@tiptap/extension-text-style"),
+    import("@tiptap/extension-superscript"),
+    import("@tiptap/extension-subscript"),
+    import("@tiptap/extension-code-block-lowlight"),
+    import("lowlight"),
+    import("../extensions/document.js"),
+    import("../extensions/document-header.js"),
+    import("../extensions/document-meta.js"),
+    import("../extensions/file-drop.js"),
+    import("../extensions/search-highlight.js"),
+    import("../extensions/callout.js"),
+    import("../extensions/collapsible.js"),
+    import("../extensions/accordion.js"),
+    import("../extensions/tabs.js"),
+    import("../extensions/card.js"),
+    import("../extensions/steps.js"),
+    import("../extensions/code-collapse.js"),
+    import("../extensions/code-group.js"),
+    import("../extensions/badge.js"),
+    import("../extensions/kbd.js"),
+    import("../extensions/prose-icon.js"),
+    import("../extensions/file-block.js")
+  ]);
+  const lowlight = createLowlight(common);
+  return [
+    TaskList,
+    TaskItem.configure({ nested: true }),
+    Table.configure({ resizable: true }),
+    TableRow,
+    TableHeader,
+    TableCell,
+    CharacterCount,
+    TextAlign.configure({ types: ["heading", "paragraph"] }),
+    Highlight.configure({ multicolor: true }),
+    Color,
+    TextStyle,
+    Superscript,
+    Subscript,
+    CodeBlockLowlight.configure({ lowlight }),
+    // Document structure
+    Document,
+    DocumentHeader,
+    DocumentMeta,
+    // File handling
+    FileDrop,
+    // Search
+    SearchHighlight,
+    // Content blocks
+    Callout,
+    Collapsible,
+    Accordion,
+    AccordionItem,
+    Tabs,
+    TabsItem,
+    Card,
+    CardGroup,
+    Steps,
+    CodeCollapse,
+    CodeGroup,
+    // Inline nodes
+    Badge,
+    Kbd,
+    ProseIcon,
+    // File block
+    FileBlock
+  ];
+}
+async function loadServerExtensions() {
+  const [
+    { default: StarterKit },
+    { default: CodeBlockLowlight },
+    { createLowlight, common },
+    { Document },
+    { DocumentHeader },
+    { DocumentMeta },
+    { FileDrop }
+  ] = await Promise.all([
+    import("@tiptap/starter-kit"),
+    import("@tiptap/extension-code-block-lowlight"),
+    import("lowlight"),
+    import("../extensions/document.js"),
+    import("../extensions/document-header.js"),
+    import("../extensions/document-meta.js"),
+    import("../extensions/file-drop.js")
+  ]);
+  const lowlight = createLowlight(common);
+  return [
+    StarterKit.configure({
+      history: false,
+      codeBlock: false,
+      document: false
+    }),
+    CodeBlockLowlight.configure({ lowlight }),
+    Document,
+    DocumentHeader,
+    DocumentMeta,
+    FileDrop
+  ];
+}
+let _cachedClient = null;
+let _cachedServer = null;
+const _clientReady = loadClientExtensions().then((exts) => {
+  _cachedClient = exts;
+}).catch((e) => console.warn("[abracadabra:core] Failed to preload client extensions:", e));
+export const corePlugin = {
+  name: "core",
+  label: "Core",
+  version: "0.1.0",
+  description: "Core TipTap extensions: rich text, tables, tasks, code blocks, document structure, and more.",
+  // Expose the loading promise so PluginRegistry.waitForExtensions() can await it.
+  extensionsReady: _clientReady,
+  pageTypes: Object.fromEntries(
+    Object.entries(DOC_TYPES).map(([key, def]) => [
+      key,
+      {
+        label: def.label,
+        icon: def.icon,
+        component: def.component,
+        hasEditor: def.hasEditor
+      }
+    ])
+  ),
+  extensions() {
+    return _cachedClient ?? [];
+  },
+  serverExtensions() {
+    if (_cachedServer) return _cachedServer;
+    loadServerExtensions().then((exts) => {
+      _cachedServer = exts;
+    }).catch((e) => console.warn("[abracadabra:core] Failed to load server extensions:", e));
+    return _cachedServer ?? [];
+  }
+};

package/dist/runtime/server/api/_abracadabra/render/[docId].get.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GET /api/_abracadabra/render/:docId
+ *
+ * SSR-friendly endpoint that returns document HTML + metadata.
+ *
+ * Strategy (fastest first):
+ *  1. CRDT cache — if the service provider is running, documents are kept
+ *     pre-rendered in Nitro storage with 2s debounce on each update.
+ *     This path is effectively instant and always fresh.
+ *  2. REST fallback — fetches HTML + metadata from the Abracadabra REST API.
+ *     Used when the service provider is not configured or for uncached docs.
+ *
+ * Usage in a Nuxt page:
+ *   const { data } = await useFetch(`/api/_abracadabra/render/${docId}`)
+ *   // data.value: { html, title, type, meta, docId, source }
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_abracadabra/render/[docId].get.js

@@ -0,0 +1,51 @@
+export default defineCachedEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const baseUrl = config.public?.abracadabra?.url;
+  if (!baseUrl) {
+    throw createError({ statusCode: 500, message: "[abracadabra] module url not configured" });
+  }
+  const docId = getRouterParam(event, "docId");
+  if (!docId) {
+    throw createError({ statusCode: 400, message: "docId is required" });
+  }
+  const storage = useStorage();
+  const [cachedHtml, cachedJson] = await Promise.all([
+    storage.getItem(`doc-cache:html:${docId}`),
+    storage.getItem(`doc-cache:json:${docId}`)
+  ]);
+  if (cachedHtml !== null) {
+    const treeEntry = cachedJson?.["doc-tree"]?.[docId] ?? {};
+    return {
+      docId,
+      html: cachedHtml ?? "",
+      title: treeEntry.label ?? "",
+      type: treeEntry.type ?? "doc",
+      meta: treeEntry.meta ?? {},
+      source: "crdt-cache"
+    };
+  }
+  const token = getHeader(event, "x-abra-token") ?? getHeader(event, "authorization") ?? "";
+  const authHeader = token.startsWith("Bearer ") ? token : token ? `Bearer ${token}` : void 0;
+  const headers = {};
+  if (authHeader) headers["Authorization"] = authHeader;
+  const [exportRes, metaRes] = await Promise.all([
+    $fetch(`${baseUrl}/api/docs/${docId}/export?format=html`, {
+      headers
+    }).catch(() => null),
+    $fetch(
+      `${baseUrl}/api/docs/${docId}`,
+      { headers }
+    ).catch(() => null)
+  ]);
+  return {
+    docId,
+    html: exportRes?.html ?? "",
+    title: metaRes?.label ?? "",
+    type: metaRes?.type ?? "doc",
+    meta: metaRes?.meta ?? {},
+    source: "rest"
+  };
+}, {
+  maxAge: 60,
+  getKey: (event) => `abra:render:${getRouterParam(event, "docId")}`
+});

package/dist/runtime/server/api/_abracadabra/spaces.get.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GET /api/_abracadabra/spaces
+ *
+ * Proxies the Abracadabra REST space list endpoint.
+ * Enables app devs to server-side render space navigation.
+ *
+ * Usage:
+ *   const { data } = await useFetch('/api/_abracadabra/spaces')
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_abracadabra/spaces.get.js

@@ -0,0 +1,16 @@
+export default defineCachedEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const baseUrl = config.public?.abracadabra?.url;
+  if (!baseUrl) {
+    throw createError({ statusCode: 500, message: "[abracadabra] module url not configured" });
+  }
+  const token = getHeader(event, "x-abra-token") ?? getHeader(event, "authorization") ?? "";
+  const authHeader = token.startsWith("Bearer ") ? token : token ? `Bearer ${token}` : void 0;
+  const headers = {};
+  if (authHeader) headers["Authorization"] = authHeader;
+  const spaces = await $fetch(`${baseUrl}/api/spaces`, { headers }).catch(() => []);
+  return spaces;
+}, {
+  maxAge: 30,
+  getKey: () => "abra:spaces"
+});

package/dist/runtime/server/plugins/abracadabra-service.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/abracadabra-service.js

@@ -0,0 +1,116 @@
+import { registerServerPlugin, bootRunners, shutdownAllRunners } from "../utils/serverRunner.js";
+import { createDocCacheAPI } from "../utils/docCache.js";
+import { docTreeCacheRunner } from "../runners/doc-tree-cache.js";
+function fromBase64Url(str) {
+  const b = atob(str.replace(/-/g, "+").replace(/_/g, "/").padEnd(str.length + (4 - str.length % 4) % 4, "="));
+  const a = new Uint8Array(b.length);
+  for (let i = 0; i < b.length; i++) a[i] = b.charCodeAt(i);
+  return a;
+}
+function toBase64Url(bytes) {
+  let b = "";
+  for (const byte of bytes) b += String.fromCharCode(byte);
+  return btoa(b).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export default defineNitroPlugin(async (nitroApp) => {
+  const config = useRuntimeConfig();
+  const abraConfig = config.abracadabra;
+  const pubKeyB64 = abraConfig?.servicePublicKey ?? "";
+  const privKeyB64 = abraConfig?.servicePrivateKey ?? "";
+  const rootDocIdOverride = abraConfig?.serviceRootDocId ?? "";
+  const disabled = abraConfig?.serviceDisabled ?? false;
+  if (disabled || !pubKeyB64 || !privKeyB64) {
+    return;
+  }
+  let wsp = null;
+  try {
+    const [
+      { AbracadabraClient, AbracadabraProvider, HocuspocusProviderWebsocket },
+      ed,
+      { sha512 },
+      Y
+    ] = await Promise.all([
+      import("@abraca/dabra"),
+      import("@noble/ed25519"),
+      import("@noble/hashes/sha2.js"),
+      import("yjs")
+    ]);
+    ed.etc = ed.etc ?? {};
+    ed.etc.sha512Sync = (m) => sha512(m);
+    const privKey = fromBase64Url(privKeyB64);
+    const client = new AbracadabraClient({
+      url: config.public?.abracadabra?.url,
+      persistAuth: false
+    });
+    await client.loginWithKey(pubKeyB64, async (challenge) => {
+      const sig = await ed.sign(fromBase64Url(challenge), privKey);
+      return toBase64Url(sig);
+    });
+    console.log("[abracadabra-service] Authenticated as service role");
+    const wsUrl = client.wsUrl;
+    wsp = new HocuspocusProviderWebsocket({
+      url: wsUrl,
+      delay: 1e3,
+      minDelay: 1e3,
+      maxDelay: 3e4,
+      factor: 2,
+      jitter: true,
+      maxAttempts: 0
+    });
+    let rootDocId = rootDocIdOverride;
+    if (!rootDocId) {
+      try {
+        const info = await $fetch(`${config.public?.abracadabra?.url}/info`);
+        rootDocId = info?.index_doc_id ?? "";
+      } catch {
+      }
+    }
+    if (!rootDocId) {
+      console.warn("[abracadabra-service] Could not determine root doc ID. Set service.rootDocId in module options.");
+      wsp.destroy?.();
+      return;
+    }
+    const rootDoc = new Y.Doc();
+    const rootProvider = new AbracadabraProvider({
+      client,
+      document: rootDoc,
+      name: rootDocId,
+      websocketProvider: wsp,
+      disableOfflineStore: true
+    });
+    rootProvider.attach?.();
+    await Promise.race([
+      new Promise((resolve) => rootProvider.on("synced", resolve)),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("sync timeout")), 3e4))
+    ]);
+    console.log("[abracadabra-service] Root doc synced");
+    const storage = useStorage();
+    const ctx = {
+      client,
+      wsp,
+      rootDoc,
+      rootProvider,
+      storage,
+      docCache: createDocCacheAPI(rootDoc)
+    };
+    const publicConfig = config.public?.abracadabra;
+    if (publicConfig?.features?.serverCache !== false) {
+      const coreServerPlugin = {
+        name: "abracadabra:core-server",
+        serverRunners: [docTreeCacheRunner]
+      };
+      registerServerPlugin(coreServerPlugin);
+    }
+    await nitroApp.hooks.callHook("abracadabra:before-runners", ctx);
+    await bootRunners(ctx);
+    console.log("[abracadabra-service] All runners started");
+    nitroApp.hooks.hook("close", async () => {
+      await shutdownAllRunners();
+      wsp?.destroy?.();
+      console.log("[abracadabra-service] Shutdown complete");
+    });
+  } catch (err) {
+    console.error("[abracadabra-service] Failed to initialize:", err?.message ?? err);
+    wsp?.destroy?.();
+  }
+});

package/dist/runtime/server/runners/doc-tree-cache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Built-in doc-tree-cache server runner.
+ *
+ * Watches the root doc-tree Y.Map, loads each child document via the
+ * service provider, and keeps an HTML+JSON render of every document in
+ * Nitro storage. The SSR render route reads from this cache first.
+ *
+ * Registered automatically on the core plugin when features.serverCache !== false.
+ */
+import type { ServerRunnerDefinition } from '../../types.js';
+export declare const docTreeCacheRunner: ServerRunnerDefinition;