Reference
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<Component>({ 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 /<feature>/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<C> (the layer binds only the UI-bound features), ComposeOptions<C>, ComposedEditor<C>, and simpleEditor(): ComposedEditor<never> (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<C>, 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 ReadonlyStores 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<string[]>, 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 MarkdownDiagnostics — 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 CommentsMargins) |
@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 RenderTargets, 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 (BlockTransforms 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 |