Chapter 6: Backend and collaboration

  extends: ['nuxt-layer-annotation-inbox'],
  compatibilityDate: '2026-09-01',
  devtools: { enabled: true },
  devServer: { port: 3056 }, // assigned by dev-server skill (~/.skills/devskill/ports.tsv)
  ssr: false, // TipTap is client-only
  // Nuxt does not honour custom export conditions when it resolves a module name, so the source module is loaded by path.
  modules: ['@nuxt/ui', '@skaile/forge-chat/nuxt', 'nuxt-auth-utils', './packages/editor/src/nuxt/module.ts'],
  ui: { fonts: false },
  // `EDITOR_LOCALE=en` renders the editor chrome in English (default: German). Speech-to-text (“Create readable rendition” on
  // audio/video) runs on Deepgram only when `NUXT_TIPTAP_EDITOR_AI_TRANSCRIPTION_API_KEY` is set (the key itself is read at runtime).

import type { User } from '#auth-utils'
import { createJsonAdapter } from '@skaile/forge-editor/adapters/json'
import { provideEditorServer } from '@skaile/forge-editor/server/nitro'
import { createWorkspaceTools } from '@skaile/forge-editor/server'

// Connects the editor package's Nuxt integration to this app's sessions, JSON document store and per-user settings.
// Synchronous on purpose: Nitro does not await a plugin, so registering after an `await` would leave the first requests without an editor server.
export default defineNitroPlugin(() => {
  // The add-ons' ports (render targets, speech, knowledge graph) and Block types; each add-on is on behind its flag, `runtimeConfig.public.addons.<name>` (`server/utils/addons.ts`).
  const addons = createAddonServer({ storeAsset, loadAsset }, addonFlagsOf(useRuntimeConfig().public.addons))
  provideEditorServer({
    ports: {
      identity: {
        // Without a session cookie h3 throws ("Cannot initialize a new session") outside a main handler.
        authenticate: request => getUserSession({ headers: request.headers, context: {} }).then(s => s.user ?? null, () => null),
      },
      documents: {
        loadContent: async id => (await getDocument(id))?.content ?? null,
        async storeContent(id, content) {
          const existing = await getDocument(id)
          if (!existing) return // deleted while a store was pending
          await putDocument({ ...existing, content, updatedAt: new Date().toISOString() })
        },
        listContents: async () => (await listAllDocuments()).map(({ id, content }) => ({ id, content })),
        // Document management over the package store: folders, create, move, delete (`/api/editor/{documents,tree}`).
        listDocumentIds: async () => indexedIds(),
        listTree,
        async createDocument(input) {
          const { id, title, updatedAt } = await createDocument(input)
          return { id, title, updatedAt, folder: input.folder ?? '' }
        },
        moveDocument,
        deleteDocument: removeDocument,
      },
      directory: { listUsers: async () => (await listUsers()).map(toSessionUser) },
      collabState: { loadState, storeState, removeState },
      assets: { storeAsset, loadAsset },
      // `user` is what `authenticate` returned: the session user.
      settings: {
        loadSettings: user => getUserSettings((user as User).id),
        storeSettings: (user, settings) => putUserSettings((user as User).id, settings),
      },
      themes: { listThemes, loadTheme, storeTheme, removeTheme },
      // Block index (`index` capability): a projection of the documents above, rebuilt on start and kept current by the editor server; in memory (memory adapter, PGlite with `NUXT_BLOCK_INDEX=pglite`, or PGlite with trigram search and vectors with `NUXT_BLOCK_INDEX=pg-vector`), so nothing to migrate.
      index: createHostBlockIndex(addons.ports.embeddings, addons.embeddingsError),
      // Prüfung records (`pruefung` capability): the editor's JSON store on `<documents dir>/.pruefung.json`, a dot-named file the document store never lists.
      pruefung: createJsonAdapter({ dir: storeRoot() }).pruefung,
      // Change sets of the document chat (`changeSets` capability): what the model proposed for other Documents, decided per Document; `<documents dir>/.change-sets.json`, likewise dot-named.
      changeSets: createJsonAdapter({ dir: storeRoot() }).changeSets,
      // Demo of the model port (`DEMO_STUB_MODEL=1`): the stub answers `{ preset: 'stub' }`; `null` for anything else falls through to the environment presets.
      models: {
        languageModel: async ref => stubModelEnabled() && 'preset' in ref && ref.preset === STUB_MODEL_ID ? stubLanguageModel : null,
        listModels: async () => stubModelEnabled() ? [...publicEnvPresets(), stubModelProfile] : null,
      },
      ...addons.ports,
    },
    ...(addons.blockTypes && { blockTypes: addons.blockTypes }),
    // The document chat's read-only workspace tools (`find_blocks`, `read_block`): the model finds and reads Blocks of the user's other Documents through the block index above.
    tools: createWorkspaceTools(addons.blockTypes && { blockTypes: addons.blockTypes }),
  })
})

const commentsOpen = useState('tiptap-editor-comments', () => false)
// The editor's scroll container: CommentsMargin aligns its cards with the commented text inside it.
const scrollEl = useTemplateRef<HTMLElement>('scrollEl')

// Demo of the opt-in `pruefung` feature: the built-in Block types plus „Prüfabschnitt“ (`shared/utils/host-block-types.ts`); the user
// holds `pruefung.record` (not part of ROOT_ABILITIES).
// The optional add-ons (flags `runtimeConfig.public.addons`, `app/editor/addons.ts`) add their Block types (slides, quotes) and features, loaded here
// before the editor mounts and only for the flags that are on; Explore is always on.
const { t, locale } = useEditorI18n()
const exploreTarget = useExploreTarget()
// Choosing a Block in the Explore panel opens it like an embed's source; „Verknüpfungen anzeigen“ shows the panel in the sidebar.
const addons = await loadAddons({
  addons: addonFlagsOf(useRuntimeConfig().public.addons),

              >
                {{ titleError }}
              </p>
            </div>
            <AdvancedEditor
              v-model:sidebar-open="sidebarOpen"
              v-model:comments-open="commentsOpen"
              :document-id="id"
              :collaboration="{ ydoc, provider, user: { id: user.id, name: user.username, color: user.color } }"
              :block-types="blockTypes"