--- title: "Public exports" description: "Every explicit subpath of @skaile/forge-editor and the names it exports." canonical_url: "https://skaile-ai.github.io/forge-editor/reference/exports" --- # Public exports > Every explicit subpath of @skaile/forge-editor and the names it exports. Every entry is an explicit subpath of `package.json#exports`; there is no wildcard into internal folders and no runtime umbrella barrel. Importing an entry registers nothing globally.
Import Contents
@skaile/forge-editor Type-only: EditorSettings , EditorFeature , EditorPreset , FeatureContext , AnchorResolver , CommandDef , ToolbarGroupDef , BlockAction , AbilitiesOptions , EditorMetadata , MetadataItem , AuthorIdentity , …
@skaile/forge-editor/vue The Vue layer (Nuxt UI chrome): createEditor (Vue plugin around createEditorContext ), EDITOR_CONTEXT , useEditorContext , useEditorSettings , useNotifier , trackedStore , useStoreRef , useWritableStoreRef , storeFromRef , EDITOR_UI , useEditorUi ( openSettings , toggleSidebar , toggleComments , commentsOpen , togglePalette , paletteOpen ), vueSuggestionRenderer , the components EditorSurface , EditorToolbar , EditorSettingsPanel , EditorSettingsModal , EditorCommandPalette (the ⌘K palette, the core-ui overlay: coreUiFeature({ palette: EditorCommandPalette }) ), SettingsSection , SuggestionList , and the types VueFeature , VuePreset (the preset components are the two entries below)
@skaile/forge-editor/vue/simple SimpleEditor component ( core-content + core-ui plus the host features in add , e.g. aiFeature() ; no composeEditor , so the bundle holds no catalog feature; exposes editor and the preset it mounts)
@skaile/forge-editor/vue/advanced AdvancedEditor component (same props, defaults 'rich' , 'full' , true ; optional collaboration session) and advancedEditor(options): VuePreset (the preset for an EditorSurface you mount yourself, and the base for own feature lists); EditorToolbar / EditorSettingsPanel / EditorSettingsModal beside it take the editor and find the preset through it
@skaile/forge-editor/react The React layer (shadcn/ui chrome; Vue-free): EditorContextProvider , useEditorContext , the components EditorSurface (ref handle EditorSurfaceHandle : editor , openSettings ), EditorToolbar , EditorSettingsPanel , EditorSettingsModal , EditorCommandPalette (the ⌘K palette, the core-ui overlay: coreUiFeature({ palette: EditorCommandPalette }) ), SettingsSection , SuggestionList , Icon , the hooks useEditorSettings ( settings , update , set , ready , synced ), useEditorUi , useNotifier , useStore , EditorUiContext , reactSuggestionRenderer , the notice seam reactNotifier and sonner's Toaster (mount it once per page), the cn class helper, and the types ReactFeature , ReactPreset , EditorSurfaceProps , EditorSurfaceHandle , SuggestionListHandle . Presets are defineEditor({ features }) from /core over the //react bindings and framework-free features, or advancedEditor() from /react/advanced
@skaile/forge-editor/react/simple SimpleEditor component (props: the surface's except preset , plus add ; ref handle SimpleEditorHandle : editor , openSettings , preset ), SimpleEditorProps
@skaile/forge-editor/react/advanced AdvancedEditor component (every feature and integration with its React binding, optional collaboration session; props AdvancedEditorProps = EditorSurface 's except preset , plus content , interaction , ai , add , remove , backend , blockTypes , blockUi , coreContent ; ref handle AdvancedEditorHandle ) and advancedEditor(options): ReactPreset ; mount Toaster from /react beside it
@skaile/forge-editor/react/styles/ui-vars.css Maps the shadcn tokens ( --primary , --background , …) to the --ui-* variables the feature sheets read; import it before core.css
@skaile/forge-editor/react/styles/advanced.css One import for React hosts of the advanced editor: ui-vars.css , core.css , every feature sheet and themes.css (with the shadcn bridge for Obsidian themes), in the order the Nuxt module registers them
@skaile/forge-editor/presets/compose Framework-free: composeEditor(ui, { content, interaction, ai, backend?, add?, remove?, blockTypes?, comments?, blockUi?, coreContent? }) builds a preset from three dimensions ( content : 'basic' / 'rich' ; interaction : 'minimal' / 'full' / [] ; ai : boolean) and prunes by the backend's capabilities ( omitted ), with CONTENT , INTERACTION , AI (feature ids in canonical order), UiBindings (the layer binds only the UI-bound features), ComposeOptions , ComposedEditor , and simpleEditor(): ComposedEditor ( core-content + core-ui , no ⌘K palette). The ready compositions with the palette are composeEditor and advancedEditor of /vue/advanced and /react/advanced
@skaile/forge-editor/core Framework-free (Tiptap/ProseMirror only; imports no vue , @tiptap/vue-3 , @nuxt/ui or React): defineEditor , coreContentFeature , coreUiFeature , createEditorContext (settings context and the translator ctx.t , options locale: 'de' | 'en' and partial messages ; with createStore createStore , derived , Store , ReadonlyStore ), the notice seam ( Notice , Notifier , silentNotifier ), the suggestion renderer seam ( SuggestionPopup , suggestionPopupOf , SuggestionListProps , SuggestionPopupHandle , SuggestionPopupRenderer ), registerEditor , Abilities and ability helpers, BlockFlash , SlashCommand , Metadata , parseBlocks / DEFAULT_BLOCK_PIPELINE , generic helpers downloadText and fetchErrorMessage , the feature/toolbar/extension-point types ( EditorFeature , FeatureContext , CommandDef , MenuItem , …), command / commandState / toolbarOf , and the block-conversion engine for own features ( ConversionProvider , ConvertTarget with its custom member for host blocks, createConverter , convertCoreBlocks , finishConversion )
@skaile/forge-editor/core (Typed block) Framework-free; the one definition of the Typed block ( core/typed-block.ts ): the persisted names TYPED_BLOCK , TYPED_BLOCK_TITLE , TYPED_BLOCK_DESCRIPTION , TYPED_BLOCK_TAGS , BLOCK_TYPE_ATTR , BIB_KEY (the meta key of the bibliographic record); newTypedBlockJSON(blockType, body?, meta?, title?) (the JSON of a fresh Typed block); isTypedBlock(node | json) , typedBlockAt(doc, pos) ( null for an invalid or non-Typed-block position), typeIdOf(block) , findBlockType(blockTypes, block) , metaOf / withMeta / withoutMeta (copies, the block is never changed). The Derivation record ( Derivation , DERIVATION_KEY , derivationOf ) is part of it. /core/schema does not export the names
@skaile/forge-editor/core (derivation and derive methods) Framework-free. Derivation , DerivationSource , DerivationMethod , DERIVATION_KEY , derivationOf , derivedChildrenOf , derivationIndexOf (original → Derived blocks, computed from block IDs and memoised per document node), derivedOf(doc, pos) , derivationOriginOf , derivedStateLabel(state, t) (the reason label of a Derived block's state), derivationState ( source: 'found' | 'missing' | 'foreign' ); the derive method registry: EditorFeature.deriveMethods , DeriveMethod ( id , label , icon , requires , available , run or menu ), DeriveContext , DeriveRegistry , createDeriveRegistry , deriveMethodsAt(editor, ctx, pos) , deriveActionsOf(preset, ctx) ; preset.deriveMethods is the merged registry
@skaile/forge-editor/core/schema Vue-free base schema: coreSchemaExtensions() , coreContentSchemaExtensions(options?) with CoreContentOptions (drop headings, lists, blockquote, code block, rule) and starterKitOf , EMPTY_EDITOR_CONTENT , StrikeX , BlockId helpers ( BLOCK_ID_TYPES , blockIdOf , findBlockById , assignBlockIds ), NodeFlags (copies the node flags editorBlockContainer , editorChrome and editorBlock onto the node spec; editorBlock: true gives an own node block IDs), isEditorBlock , isBlockContainer , isChromeNode , the ability vocabulary ( ABILITY , ROOT_ABILITIES )
@skaile/forge-editor/schema/simple Vue-free simpleSchemaExtensions() for servers and validators
@skaile/forge-editor/settings EditorSettings , EDITOR_SETTINGS_VERSION , EDITOR_SETTINGS_DEFAULTS , editorSettingsSchema , parseEditorSettings , ModelRole , inert value constants ( MODEL_ROLES , the Model roles; STRUCTURE_MODES , TREE_ROOTS , BLOCK_TYPE_ICON_VISIBILITIES , DRAG_HANDLE_VISIBILITIES , AI_LANGUAGES , AUTHOR_COLOR_STYLES , COMMENTS_LAYOUTS , …)
@skaile/forge-editor/outline , /outline/vue , /outline/react /vue and /react : EditorOutline (the Block outline); framework-free: headingOutline , revealBlockInEditor , HeadingOutlineNode (imports no tree and no Typed block code)
@skaile/forge-editor/search , /search/vue , /search/react Workspace search over the Block index (backend capability index ). /vue and /react : SearchPanel (props open(hit) and optional documentTitle(id) ; React also className ; renders nothing without the index capability), useSearchModel ; framework-free: createSearchModel , hitLabel , SearchModel , SearchModelOptions , SearchState , SearchStatus (imports no tree, no feature)
@skaile/forge-editor/change-sets , /change-sets/vue , /change-sets/react What the document chat proposed for other Documents than the open one, reviewed per Document (backend capability changeSets ). /vue and /react : ChangeSetPanel (props model , optional documentTitle(id) and open(id) ; React also className ; renders nothing while there is nothing to show), useChangeSetModel({ backend }) (one model per app, shared with the chat through AiSidebar 's changeSets ); framework-free: createChangeSetModel , groupChangeSets , hunkLabel , HUNK_STATUS_KEYS , ChangeSetModel , ChangeSetModelOptions , ChangeSetState , ChangeSetGroup , ChangeSetEntry , ChangeSetFailure and the types ChangeSet , ChangeSetHunk , ChangeSetHunkStatus , ChangeSetOp , ChangeSetFeed (imports no tree, no feature)
@skaile/forge-editor/tree , /tree/vue , /tree/react , /tree/types Document tree. /vue and /react : DocumentTree (Vue: props store , editor , v-model:selectedFolder , slot document-actions ; React: props store , editor , selectedFolder / onSelectedFolderChange (uncontrolled when omitted), documentActions , className ; needs EditorContextProvider and a mounted Toaster ), useTreeView (Vue: nodeFilters / expanded as refs; React: as values); framework-free: DocumentStore (the tree's store interface; store-based: tree , documents , activeId are ReadonlyStore s plus the host's operations), createTreeView , treeView(context) (the per-app view state: node filters, expanded folders), TreeViewModel , NodeFilters , TreeFolder , DocumentSummary ; /vue also useStoreRef and storeFromRef (adapters from Vue refs to the store shape). Depends on core, outline, composites and media; see the integration guide . /tree/types has the TreeFolder / DocumentSummary types alone, for servers whose typecheck has no DOM. Content tree: TreeViewModel.basketFilter ( Store , persisted under tip-tree:basket-filter ), setBasketShown(id, shown) , clearBasketFilter() ; TreeState.basketFilter , focusKey , focusPath ; the model's focus(key) and defocus() ; TreeRowState.dimmed ; the TreeCommand members transferBlock and focusBlock ; DragPayload foreign-block with TreeModel.foreignDragOver(item) and dropForeign(item, payload, menu, x, y) . See Document tree
@skaile/forge-editor/media , /media/vue , /media/react , /media/schema /vue and /react : mediaFeature , useFileImport , AudioRecorderModal , useAudioRecorder ; framework-free: mediaFeatureCore , fileImport , createAudioRecorder , pickFiles , openAudioRecorder , mediaSchemaExtensions() , MEDIA_TYPES , MAX_MEDIA_BYTES , asset helpers
@skaile/forge-editor/image-studio , /image-studio/vue , /image-studio/react , /image-studio/schema The Bild-Studio block ( guide ). /vue : imageStudioFeature() , ImageStudioDialog (props open / v-model:open , store , title? ), createImageStudioNodeStore({ editor, getPos, backend, documentId }) (with ImageStudioNodeStore , ImageStudioNodeStoreOptions ; dispose() detaches it), ImageStudioStore (the contract the dialog drives: state , promptBlocks , update , generate , upload , problem , all as refs) and everything from the framework-free entry. /react : imageStudioFeature() , ImageStudioDialog (props open , onOpenChange , store , title? ), ImageStudioReactStore (the same contract with plain values instead of refs; the host re-renders the dialog with the new state after update , and keeps update stable per image: its identity is the store's), useImageStudioNodeStore({ editor, getPos, backend, documentId }) (the store of one node, undefined on the first render), createImageStudioNodeCore , ImageStudioNodeCore , ImageStudioNodeCoreOptions , ImageStudioNodeSnapshot and the state and reducers. Framework-free: imageStudioFeatureCore(ui?) , ImageStudioUi , IMAGE_STUDIO_OPEN , ImageStudioNode , imageStudioSchemaExtensions() ( /schema is Vue-free, for servers), ImageStudioAttrs , the types ImageStudioState , ImageStudioImage , ImageStudioTurn , ImageStudioPromptBlock , the gallery types ImageStudioLibrary , ImageStudioLibraryFacet , ImageStudioLibraryQuery , ImageStudioLibraryItem , EMPTY_IMAGE_STUDIO_STATE , the pure reducers setDescription , togglePromptBlock , toggleImage , select , removeImage , addReference , adoptImage , addGeneration , and selectedImage , isEmptyImageStudioState , normalizeImageStudioState . The backend side is EditorBackend.images (capability images ), EditorPorts.images ( ImageProvider ) and the routes under /api/editor/images/
@skaile/forge-editor/mentions , /mentions/schema mentionsFeature , mentionSuggestion , tagSuggestion ; Vue-free: mentionsSchemaExtensions() , MentionNode , TagNode , mentionsFromText , tagsFromText , normalizeTagName
@skaile/forge-editor/tables , /tables/schema tablesFeature() (GFM tables and task lists: the nodes, toolbar group table with insert 3×3, add/delete row, add/delete column, delete table, slash entries table.insert and task.insert ; no components, so it fits both framework layers); Vue-free: tablesSchemaExtensions() (also part of /schema/simple and /schema/advanced )
@skaile/forge-editor/markdown , /markdown/vue , /markdown/react Framework-free: splitFrontmatter(text) / joinFrontmatter(frontmatter, body) (YAML block at offset 0 only, kept verbatim), markdownToContent(editor, body, { policy? }): { content, diagnostics } (policy { allowHtml?, allowDataUrls? } : raw HTML, links and media with unsafe URLs are dropped and reported as MarkdownDiagnostic s — raw-html , unsafe-url , unknown-fence (info), unclosed-fence and invalid-fence-meta (errors); hasFatalDiagnostics ), contentToMarkdown(editor) , MarkdownClipboard.configure({ policy }) (an extension: pastes text/markdown and plain text with block syntax as blocks, sanitizes pasted HTML, copies and cuts as text/markdown next to text/html and text/plain ), createSourceMode({ getEditor, toMarkdown?, fromMarkdown?, policy? }): SourceMode ( state store { mode: 'visual' | 'source', source, diagnostics } , enter() , edit(text) , commit(): boolean — false with the editor untouched on a fatal diagnostic or a document the schema rejects —, cancel() ). Unknown ::: kind fences are OpaqueFence nodes (in coreSchemaExtensions() ) that are written back byte for byte; the Block types a Typed block feature registers parse first. Vue: MarkdownSurface ( v-model is the Markdown string, frontmatter included; props, emits and slots of EditorSurface forwarded; an incoming value equal to the last emitted one is ignored; prop policy (also configures the MarkdownClipboard it installs), prop sourceMode (a SourceMode : while its state is source the surface shows the draft in a text area with the diagnostics of a rejected commit and Apply/Cancel, sourceLabels for their texts), event diagnostics ). React: MarkdownSurface ( value / onChange / onFrontmatterChange / onDiagnostics , prop policy (also configures the installed MarkdownClipboard ), the EditorSurface props forwarded, same semantics; no source view). Neither imports CodeMirror
@skaile/forge-editor/code , /code/vue , /code/react CodeMirror 6 on a string, themed by the shared --sk-* tokens ( styles/tokens.css ; fallbacks are the token defaults). Framework-free: createCodeEditor({ parent, doc?, readOnly?, wordWrap?, language?, onSaveShortcut?, onChange? }) , setReadOnly , setWordWrap , setLanguage(view, support) , loadLanguage(view, id) , setDocument(view, text) (a host text, not an edit), registerLanguage(id, loader, { core? }) / resolveLanguage(id) / isCoreLang(id) (language packs are the host's: register the @codemirror/lang-* packs you depend on; jsonl is built in), formatJsonInEditor(view) , formatJsonText , jsonlLanguage , kindOf(path, mime?) ( 'markdown' | 'code' | 'binary' ), languageOf(path) . /code/vue : CodeSurface ( v-model string, editable , language , wordWrap ; emits update:modelValue , save on Mod-S, ready(view) ). /code/react : CodeSurface ( value , onChange , onSave , onReady , same flags). No ProseMirror or TipTap is reachable from these entries
@skaile/forge-editor/document/vue , /document/react DocumentSurface : MarkdownSurface for kindOf(path, mime) === 'markdown' (props markdown : the Markdown surface's own props, preset at least), CodeSurface for text (language from languageOf(path) unless language is given), a binary slot (Vue) / binary(path) render prop (React) otherwise. ready carries { kind: 'markdown', editor } or { kind: 'code', view } . These entries reach both editors; use /markdown/* or /code/* alone to keep one out of a bundle
@skaile/forge-editor/transcript , /transcript/vue , /transcript/react , /transcript/schema /vue and /react : transcriptFeature , TranscriptSegmentView ; framework-free: transcriptFeatureCore , transcriptSegment , speakerConversions , segmentSpeakerLines , transcriptSchemaExtensions() , speakerParagraphsToSegments , lastSpeaker , speakersIn , and the subtitle export vttOf(cues) , srtOf(cues) , transcriptCuesOf(node) , TranscriptCue (block action transcript-export ; see Speech )
@skaile/forge-editor/authors , /authors/vue , /authors/react , /authors/schema /vue and /react : authorsFeature , AuthorColorsPanel , AuthorColorsButton , SettingsAuthorsTab ; framework-free: authorsFeatureCore , currentAuthor , AuthorAttribution , authorsSchemaExtensions() , AuthorMark , documentAuthors , AuthorIdentity , AUTHOR_COLOR_STYLES , AuthorColorStyle
@skaile/forge-editor/themes , /themes/vue , /themes/react , /themes/schema /vue and /react : themesFeature() (site-wide Obsidian themes: its setup hook starts the theme runtime and returns its teardown, its appearance settings tab picks the theme), SettingsAppearanceTab ; framework-free: themesFeatureCore , startObsidianTheme(ctx) (reference-counted per app, returns the release), pinObsidianTheme(ctx, id) (shows a theme over the setting until released, nothing persisted), ThemeHost , scopeThemeCss , THEME_SCOPE_CLASS ; Vue-free schema: ThemeRecord , ThemeManifest , themeManifestSchema , THEME_ID , MAX_THEME_BYTES . Needs an adapter with listThemes / loadTheme ; see the usage guide
@skaile/forge-editor/comments , /comments/vue , /comments/react , /comments/schema /vue and /react : commentsFeature (requires collab ), useComments , CommentsMargin , CommentsPopover , CommentsListMenu , CommentThreadView , CommentComposer , CommentBubble , SettingsCommentsTab ( /vue also the type CommentsStore ); framework-free: commentsFeatureCore , createCommentsModel , Comments plugin helpers, commentsSchemaExtensions() , CommentMark , CommentThread , CommentReply , COMMENT_LIMITS , COMMENTS_LAYOUTS , CommentsLayout , and the margin's layout (the active thread pinned to its text's line, the others one-line cards out of its way): layoutMargin(entries, activeId, { gap, minTop }) (with MarginEntry , MarginLayout , MARGIN_GAP ), marginCards (with MarginCard , DRAFT_CARD ; an orphaned thread sits at its deletion point, CommentsSnapshot.orphanAt , which host models may omit), createMarginController (with MarginController , MarginSource , MarginState : measuring and scheduling for both CommentsMargin s)
@skaile/forge-editor/composites/vue , /composites/react compositeFeature() (Vue: Nuxt UI, React: shadcn), the host-placed CompositeTable and CompositeInspector , SettingsEditingTab , CompositeChrome , CompositeDetails , CompositeView and editors, useCompositeRows , useCompositeAnchors
@skaile/forge-editor/composites , /composites/schema Framework-free: compositeFeatureCore , Composite , BlockType , BlockTypeAi , defaultBlockTypes , blockTypeOf , acceptsChild (the Block types' Accepted children, BlockType.accepts ), AcceptedChildren (the editor extension that enforces them; registered by compositeFeatureCore ). Also compositeOutline , documentOutline(doc, untitled, capabilitiesOf?, documentId?) (the Block outline: headings and Typed blocks as one tree; DocumentOutlineEntry , DocumentOutlineBlock , DocumentOutlineHeading ), moveBlockInto (returns whether the document changed), moveIntoVerdict(editor, id, targetId, t) (with MoveVerdict : { ok: true } or { ok: false, reason } in the language of t ), canMoveBlockInto ( moveIntoVerdict(...).ok ), headingsMarkdown , documentCompositeMarkdown , Structure , createCompositeRows , createCompositeInspector , compositeFieldText , observeCompositeAnchors , compositeRows , setBlockProperty , setCompositeTags , setCompositeDescription , compositeDescriptionText , compositeSchemaExtensions() , blocksFromMarkdown , compositeFence , conversions and heading↔Typed block transforms. Source-holding Typed blocks: SOURCE_MEDIA_TYPES , sourceOf , derivedChildrenOf (the Derived blocks of a Typed block), Derivation with DERIVATION_KEY , derivationOf , derivationState , bodyMarkdown ; bibliography: CslItem , CSL_TYPES , bibOf , cslOf , citeShort , citeFull , bibtexOf , yearOf , cslTypeOptions ; references: ReferenceNode , referencesFromText , normalizeReferences , referenceMarkdown ; /composites also referenceSuggestion , referenceLabel , compositeBacklinks (with CompositeBacklink , CompositeReference ) and revealSource , seekSource , parseLocator , SourceReveal (show a Typed block's source at a time or page); /composites/schema also compositeIdsOf . Baskets: Basket ( { id, label, color } ), BASKET_IDS , defaultBaskets(t) , `basketOf(node
@skaile/forge-editor/ai , /ai/protocol Framework-free: aiFeatureCore , modelProfiles(app) , createAiAssistant , createDocumentChat , createAiSelectionFlow (with AI_SELECTION_MENU_KEY ), createAiReviewBar({ notify, t, editor }) (model of the review bar), createAgentOpReview({ notify, t }) (host-driven agent edit review), notifyAiRateLimited(notify, t) , review/apply helpers ( startAiReview , applyAiResult , …) and the protocol ( AI_TASKS , ModelRef , AGENT_OP_TYPES , AGENT_OP_OUTCOMES , CHAT_LIMITS , …), importable alone from /ai/protocol ; the model-facing agent texts ( checkAgentOps , agentShownMessage , agentFeedbackText , agentRetryMessage ) take a locale: 'de' | 'en' option (default de ), and agentRetryMessage(problems, scoped, { locale, tool }) names the tool the model must call again (default edit_document ). The [id] line format of the chat's document text has one owner there, block-lines : writer helpers ( blockLine , singleBlockLine , nestedLinePrefix , quoteLinePrefix , listLinePrefix , continuedLinePrefix , compositeChromePart , compositeLineHeader , compositeLineClose , TRUNCATED_LINE ), the reader readBlockLines (the block ids and which blocks lie inside which; lines in fenced code are not block lines; type BlockLines ), the echo strippers stripBlockLineEcho and stripListMarkerEcho , and the (German, model-facing) prompt texts BLOCK_LINES_LABEL , BLOCK_LINE_INTRO , BLOCK_LINE_MARKERS , BLOCK_LINE_LIST_TEXT , BLOCK_LINE_HOST_TEXT , BLOCK_LINE_COMPOSITE_TEXT , BLOCK_LINE_ECHO_TEXT , BLOCK_LINE_IDS_HINT with the example ( BLOCK_LINE_EXAMPLE , BLOCK_LINE_EXAMPLE_ID , BLOCK_LINE_EXAMPLE_TEXT )
@skaile/forge-editor/ai/actions documentActions({ editor, review, scope?, targets? }) ( DocumentActionsOptions ): the forge actions doc.read and doc.propose_ops for a host chat with client tools (optional peer @skaile/forge-app-actions ; see Chat agent operations )
@skaile/forge-editor/ai/vue , /ai/react aiFeature() , AiSidebar (React only; the Vue one is /ai/vue/chat ), ModelQuickSwitch , AiReviewBar , AiSelectionMenu , SettingsAiTab , SettingsModelProfiles ; /ai/vue also useAiAssistant , useDocumentChat , useModelProfiles (thin hooks over the models); /ai/vue is free of @skaile/forge-chat
@skaile/forge-editor/ai/vue/chat The Vue AiSidebar . Renders on the optional peer @skaile/forge-chat ( ChatPanel ): importing the entry without it throws an error naming the peer. The host imports @skaile/forge-chat/styles/chat.css and adds Tailwind @source for the package
@skaile/forge-editor/adapters/direct-ai createDirectAi({ presets, roles?, users?, fetch? }) ( DirectAiOptions , DirectAiPreset ): an EditorBackend['ai'] that calls OpenAI-compatible chat-completion endpoints from the browser ( models , complete , generate , transcriptCleanup ; chat and extract answer 501). The preset keys are readable by the page and no server rate limit applies; see Browser-direct AI and the capability locality table
@skaile/forge-editor/adapters/render createRenderer(targets) (a Renderer over RenderTarget s, the port EditorPorts.render ), markdownTarget(options?) (the built-in markdown target), RenderTarget , RenderOutput , MarkdownTargetOptions ; Node program, no Vue, React, Nitro or drizzle. See Render and the Renderer port
@skaile/forge-editor/adapters/speech createOpenAiSpeech(options) (a SpeechProvider over an OpenAI-compatible /audio/speech endpoint, the port EditorPorts.speech ), OPENAI_VOICES , createMemorySpeech(options?) (one second of silent WAV, for tests and demos), silentWav(seconds?) ; Node program, no Vue, React, Nitro or drizzle. The daily budget createSpeechBudget and SPEECH_CHARS_PER_DAY are in @skaile/forge-editor/server . See Speech and the Speech port
@skaile/forge-editor/adapters/embeddings createOpenAiEmbedder(options) (an Embedder over an OpenAI-compatible /embeddings endpoint, the port EditorPorts.embeddings ), OPENAI_EMBEDDING_DIMENSIONS ; Node program, no Vue, React, Nitro or drizzle. See Index on Postgres
@skaile/forge-editor/adapters/knowledge createMemoryKnowledgeGraph(nodes, edges) (a KnowledgeGraph over fixed nodes and edges, searched by the words of the labels, the port EditorPorts.knowledge , for tests and demos), MEMORY_KNOWLEDGE_LIMIT ; Node program, no Vue, React, Nitro or drizzle. A real graph is the host's: @skaile/forge-editor-kgs wraps the KGS SDK. See Knowledge graph
@skaile/forge-editor/integrations/composite-ai Framework-free (labels quoted in their English catalog form): compositeAiFeature (requires composites , ai , media ), fillComposite , generateCompositeBody (with CompositeBodyResult ), summarizeComposite , createRendition , regenerateRendition , canCreateRendition , canRegenerateRendition , RenditionOptions (“Create readable rendition”, “Regenerate (replace)”), deriveComposite , canDeriveAfter , derivableBlockTypesOf , isDerivableSource (“Derive (AI)”), fetchBibliography , canFetchBibliography , doiOf (“Fetch bibliography”), compositeSourceText , COMPOSITE_BODY_START . Splitting and outline: splitCompositeWithAi , bodyUnchanged , splitByInsertedHeadings (“Split into sub-blocks with AI” / “Split into blocks with AI”); sanitizeOutline , collectHeadings , parseOutlineResponse , applyOutline , OutlineHeading , OutlineEntry (“Clean up outline (AI)”); writeDerivedBody , discardDerived (the write-back of “Derive (AI)”). Transfer: summaryTransform , bulletsTransform ( BlockTransform s for the transfer menu: “Insert summary”, “Insert bullet points”), transferRequest
@skaile/forge-editor/integrations/composite-media Framework-free: compositeMediaFeature (requires composites , media ): imported files become Typed blocks of the Block type whose import capability takes their media (built in: recording for audio/video, figure for images, document otherwise); block action “Replace source” (English label)
@skaile/forge-editor/integrations/transcript-ai , /transcript-ai/protocol Framework-free: transcriptAiFeature (requires transcript , ai ), createTranscriptCleanup , hasTranscriptSegments ; server contract: TRANSCRIPT_CLEANUP_LIMITS , transcriptCleanupRequestSchema , transcriptCleanupMessages , transcriptCleanupChunks , parseTranscriptCleanup
@skaile/forge-editor/collab , /collab/vue , /collab/react Framework-free: collabFeatureCore(ui?) (Yjs Collaboration / CollaborationCaret , active only with a collaboration session on the surface), yjsAnchorResolver ; /vue and /react : collabFeature() (the Vue one adds the @tiptap/vue-3 state-sync workaround, the React one needs none)
@skaile/forge-editor/block-ui , /block-ui/vue , /block-ui/react /vue and /react : blockUiFeature(options?) ( BlockUiOptions.actions : 'hover' default, 'toolbar' , 'both' , 'none' ), BlockUi , BlockActionsOverlay ; framework-free: blockUiFeatureCore(ui, options?) , blockActionsFor(editor, target, actions, surface) , selectedBlockOf , sameBlock , actionSurfacesOf , effectiveTarget , BLOCK_CORNER_ATTR and blockCornerOf (a node view marks its own top-right icons with data-block-corner ; the bar docks left of them): drag handle, hover targeting and block actions (opt-in; the simple editor never includes it)
@skaile/forge-editor/transfer , /transfer/vue , /transfer/react Block transfer between editor surfaces and trees. Framework-free: transferFeatureCore(ui, options?) , TransferFeatureOptions ( { transforms?, defaultTransform? } ), TransferUi , BlockTransform , TransformContext , TransferEnv , copyTransform , DEFAULT_TRANSFORMS (the copy), runTransform , availableTransforms , transformContextOf , transferKindOf , transferSourceHash , createsOf , withFreshBlockIds , isSelfDrop , BlockDropTargetStorage , TransferDrop , PendingDrop ; the AI transforms summaryTransform , bulletsTransform and transferRequest are in @skaile/forge-editor/integrations/composite-ai ; /vue and /react : transferFeature(options?) , TransferMenu . The payload side ( BLOCK_MIME , BlockTransfer , readBlockTransfer , writeBlockTransfer , blockTransferOf , BlockTransferStorage ) is in @skaile/forge-editor/core . See Content tree mechanics
@skaile/forge-editor/schema/advanced Vue-free advancedSchemaExtensions() : the advanced schema for servers, validators and migrations
@skaile/forge-editor/server , /server/handlers , /server/node , /nuxt Server side without a web framework: createCollabServer , createAiModels , createRateLimiter , loadCurrentContent , listCurrentContents , currentContent (stored content in the current shape), EditorPorts with its port interfaces ( AccessControl , DocumentContentStore , CollabStateStore , Directory , AssetStore , SettingsStore , ThemeStore , ModelProvider ), serverCapabilities , one request handler per route ( /server/handlers ), listenCollab for a plain Node script ( /server/node ); the Nitro installers installEditorServer , provideEditorServer and useEditorServer ( /server/nitro ), whose EditorServer handle offers forgetDocument , liveContent , enforceRateLimit , resolveModel ; the Nuxt module (config key tiptapEditor ) wraps the same core. See the integration guide
@skaile/forge-editor/styles/core.css (required), /composites.css , /media.css , /mentions.css , /tables.css , /authors.css , /comments.css , /transcript.css , /ai.css , /collab.css , /block-ui.css , /themes.css Feature CSS (import after Tailwind, Nuxt UI (Vue) or ui-vars.css (React) and core.css ; themes.css after the feature sheets). The Nuxt module adds all of them itself
## Sitemap See the full [sitemap](https://skaile-ai.github.io/forge-editor/sitemap.md) for all pages.