@ecsplico/editor 3.5.1 → 4.0.0

package/dist/core/extension-points.d.ts

@@ -32,6 +32,13 @@ interface BlockActionBase {
   icon: string;
   /** Shown only on blocks that have this ability; shown on every block when unset. */
   ability?: Ability;
+  /**
+   * Block capabilities (`EditorFeature.blockCapabilities`, built-in `container` and `title`) the block must all have; hidden
+   * otherwise. Replaces node-name checks in `isVisible`. An id no Feature declares is an error when the actions are collected (`blockActionsOf`).
+   */
+  requires?: readonly string[];
+  /** Block type ids (`attrs.blockType`) the action is for; hidden on blocks of any other type. Only for an action that is truly type-specific: what a block can do is a capability (`requires`). */
+  blockTypes?: readonly string[];
   /** Further condition; hidden when it returns false. */
   isVisible?: (ctx: BlockActionContext) => boolean;
   /** Position among the actions (ascending, stable); built-ins use their visual sequence, host actions follow them. */
@@ -41,6 +48,15 @@ interface BlockActionBase {
    * selection, or both (default). The block-ui feature decides which of these surfaces exist (`BlockUiOptions.actions`).
    */
   placement?: 'hover' | 'toolbar' | 'both';
+  /**
+   * The block the action is about. `'block'` (default): the block the surface addresses (hover: the hovered block;
+   * toolbar: the block holding the selection, the innermost one). `'typedBlock'`: on the toolbar, the Typed block around that
+   * block (the block itself when it is a Typed block), so an action of a Typed block stays reachable while the caret is in
+   * a paragraph inside it. The action is then checked against that Typed block (`ability`, `requires`, `blockTypes`,
+   * `isVisible`) and gets its node and position in the context; with no Typed block around, it is absent. The hover bar
+   * ignores it: hovering a Typed block's chrome already addresses the Typed block.
+   */
+  target?: 'block' | 'typedBlock';
 }
 /**
  * An entry of the block actions shown top-right of a block (`BlockActionsOverlay`); hosts add their own via `blockActions`.

package/dist/core/feature-context.d.ts

@@ -27,7 +27,11 @@ export interface FeatureContextOptions {
  * list lazily (features' commands, then the host's transformer), once. Call it during component setup.
  */
 export declare function createFeatureContext(options: FeatureContextOptions): FeatureContext;
-/** The features' block actions in `order` (stable), followed by the host's. */
+/**
+ * The features' block actions and the actions of their derive methods (`deriveActionsOf`) in `order` (stable), followed by the
+ * host's. Throws when an action `requires` a capability no feature of `preset` declares (the actions only exist once a feature
+ * context does, so `defineEditor` cannot check them; a derive method's `requires` it does check).
+ */
 export declare function blockActionsOf(preset: EditorPreset, ctx: FeatureContext, hostActions?: readonly BlockAction[]): BlockAction[];
 //#endregion
 //# sourceMappingURL=feature-context.d.ts.map

package/dist/core/feature-context.js

@@ -1,4 +1,5 @@
-import { byOrder } from "./util.js";
+import { byOrder, fail } from "./util.js";
+import { deriveActionsOf } from "./derive.js";
 import { contributions } from "./define-editor.js";
 import { assertUniqueCommandIds, commandsOf } from "./commands.js";
 //#region src/core/feature-context.ts
@@ -37,9 +38,15 @@ function createFeatureContext(options) {
 	for (const defaults of contributions(preset, "metadataDefaults")) ctx.metadata.defaults(defaults(ctx));
 	return ctx;
 }
-/** The features' block actions in `order` (stable), followed by the host's. */
+/**
+* The features' block actions and the actions of their derive methods (`deriveActionsOf`) in `order` (stable), followed by the
+* host's. Throws when an action `requires` a capability no feature of `preset` declares (the actions only exist once a feature
+* context does, so `defineEditor` cannot check them; a derive method's `requires` it does check).
+*/
 function blockActionsOf(preset, ctx, hostActions = []) {
-	return [...contributions(preset, "blockActions").flatMap((factory) => factory(ctx)).sort(byOrder), ...hostActions];
+	const actions = [...[...contributions(preset, "blockActions").flatMap((factory) => factory(ctx)), ...deriveActionsOf(preset, ctx)].sort(byOrder), ...hostActions];
+	for (const action of actions) for (const required of action.requires ?? []) if (!preset.capabilities.has(required)) fail(`the block action "${action.id}" requires the capability "${required}", which no feature declares`, "blockActionsOf");
+	return actions;
 }
 //#endregion
 export { blockActionsOf, createFeatureContext };

package/dist/core/feature-context.js.map

@@ -1 +1 @@
-{"version":3,"file":"feature-context.js","names":[],"sources":["../../src/core/feature-context.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { EditorContext } from './context'\nimport { assertUniqueCommandIds, type CommandDef, commandsOf } from './commands'\nimport { contributions } from './define-editor'\nimport type { EditorUi } from './editor-ui'\nimport type { AbilitiesOptions, BlockAction } from './extension-points'\nimport type { CollaborationSession, EditorPreset, FeatureContext } from './feature'\nimport type { MetadataRegistry } from './metadata'\nimport type { Notifier } from './notify'\nimport { byOrder } from './util'\n\nexport interface FeatureContextOptions {\n  app: EditorContext\n  preset: EditorPreset\n  ui: EditorUi\n  metadata: MetadataRegistry\n  /** The surface's notice renderer (Nuxt UI toast, sonner). */\n  notify: Notifier\n  getEditor: () => Editor | undefined\n  documentId?: string\n  collaboration?: CollaborationSession\n  abilities?: Partial<AbilitiesOptions>\n  /** Host transformer of the command list (and with it the `/` menu): receives the features' commands, returns the final list. */\n  commands?: (defaults: CommandDef[]) => CommandDef[]\n}\n\n/**\n * The context of one mounted surface (see `FeatureContext`). Resolves the preset's anchor resolver and builds the command\n * list lazily (features' commands, then the host's transformer), once. Call it during component setup.\n */\nexport function createFeatureContext(options: FeatureContextOptions): FeatureContext {\n  const { app, preset } = options\n  let list: CommandDef[] | undefined\n  const ctx: { -readonly [K in keyof FeatureContext]: FeatureContext[K] } = {\n    app,\n    settings: app.settings,\n    metadata: options.metadata,\n    ui: options.ui,\n    notify: options.notify,\n    locale: app.locale,\n    t: app.t,\n    backend: app.backend,\n    ai: app.ai,\n    documentId: options.documentId,\n    collaboration: options.collaboration,\n    anchorResolver: null,\n    abilities: options.abilities ?? {},\n    commands: () => {\n      if (!list) {\n        const defaults = commandsOf(preset, ctx)\n        list = options.commands ? options.commands(defaults) : defaults\n        if (options.commands) assertUniqueCommandIds(list)\n      }\n      return list\n    },\n    getEditor: options.getEditor,\n  }\n  ctx.anchorResolver = contributions(preset, 'anchorResolver')[0]?.(ctx) ?? null\n  for (const defaults of contributions(preset, 'metadataDefaults')) ctx.metadata.defaults(defaults(ctx))\n  return ctx\n}\n\n/** The features' block actions in `order` (stable), followed by the host's. */\nexport function blockActionsOf(preset: EditorPreset, ctx: FeatureContext, hostActions: readonly BlockAction[] = []): BlockAction[] {\n  return [...contributions(preset, 'blockActions').flatMap(factory => factory(ctx)).sort(byOrder), ...hostActions]\n}\n"],"mappings":";;;;;;;;AA8BA,SAAgB,qBAAqB,SAAgD;CACnF,MAAM,EAAE,KAAK,WAAW;CACxB,IAAI;CACJ,MAAM,MAAoE;EACxE;EACA,UAAU,IAAI;EACd,UAAU,QAAQ;EAClB,IAAI,QAAQ;EACZ,QAAQ,QAAQ;EAChB,QAAQ,IAAI;EACZ,GAAG,IAAI;EACP,SAAS,IAAI;EACb,IAAI,IAAI;EACR,YAAY,QAAQ;EACpB,eAAe,QAAQ;EACvB,gBAAgB;EAChB,WAAW,QAAQ,aAAa,CAAC;EACjC,gBAAgB;GACd,IAAI,CAAC,MAAM;IACT,MAAM,WAAW,WAAW,QAAQ,GAAG;IACvC,OAAO,QAAQ,WAAW,QAAQ,SAAS,QAAQ,IAAI;IACvD,IAAI,QAAQ,UAAU,uBAAuB,IAAI;GACnD;GACA,OAAO;EACT;EACA,WAAW,QAAQ;CACrB;CACA,IAAI,iBAAiB,cAAc,QAAQ,gBAAgB,CAAC,CAAC,EAAE,GAAG,GAAG,KAAK;CAC1E,KAAK,MAAM,YAAY,cAAc,QAAQ,kBAAkB,GAAG,IAAI,SAAS,SAAS,SAAS,GAAG,CAAC;CACrG,OAAO;AACT;;AAGA,SAAgB,eAAe,QAAsB,KAAqB,cAAsC,CAAC,GAAkB;CACjI,OAAO,CAAC,GAAG,cAAc,QAAQ,cAAc,CAAC,CAAC,SAAQ,YAAW,QAAQ,GAAG,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,GAAG,WAAW;AACjH"}
+{"version":3,"file":"feature-context.js","names":[],"sources":["../../src/core/feature-context.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { EditorContext } from './context'\nimport { assertUniqueCommandIds, type CommandDef, commandsOf } from './commands'\nimport { contributions } from './define-editor'\nimport { deriveActionsOf } from './derive'\nimport type { EditorUi } from './editor-ui'\nimport type { AbilitiesOptions, BlockAction } from './extension-points'\nimport type { CollaborationSession, EditorPreset, FeatureContext } from './feature'\nimport type { MetadataRegistry } from './metadata'\nimport type { Notifier } from './notify'\nimport { byOrder, fail } from './util'\n\nexport interface FeatureContextOptions {\n  app: EditorContext\n  preset: EditorPreset\n  ui: EditorUi\n  metadata: MetadataRegistry\n  /** The surface's notice renderer (Nuxt UI toast, sonner). */\n  notify: Notifier\n  getEditor: () => Editor | undefined\n  documentId?: string\n  collaboration?: CollaborationSession\n  abilities?: Partial<AbilitiesOptions>\n  /** Host transformer of the command list (and with it the `/` menu): receives the features' commands, returns the final list. */\n  commands?: (defaults: CommandDef[]) => CommandDef[]\n}\n\n/**\n * The context of one mounted surface (see `FeatureContext`). Resolves the preset's anchor resolver and builds the command\n * list lazily (features' commands, then the host's transformer), once. Call it during component setup.\n */\nexport function createFeatureContext(options: FeatureContextOptions): FeatureContext {\n  const { app, preset } = options\n  let list: CommandDef[] | undefined\n  const ctx: { -readonly [K in keyof FeatureContext]: FeatureContext[K] } = {\n    app,\n    settings: app.settings,\n    metadata: options.metadata,\n    ui: options.ui,\n    notify: options.notify,\n    locale: app.locale,\n    t: app.t,\n    backend: app.backend,\n    ai: app.ai,\n    documentId: options.documentId,\n    collaboration: options.collaboration,\n    anchorResolver: null,\n    abilities: options.abilities ?? {},\n    commands: () => {\n      if (!list) {\n        const defaults = commandsOf(preset, ctx)\n        list = options.commands ? options.commands(defaults) : defaults\n        if (options.commands) assertUniqueCommandIds(list)\n      }\n      return list\n    },\n    getEditor: options.getEditor,\n  }\n  ctx.anchorResolver = contributions(preset, 'anchorResolver')[0]?.(ctx) ?? null\n  for (const defaults of contributions(preset, 'metadataDefaults')) ctx.metadata.defaults(defaults(ctx))\n  return ctx\n}\n\n/**\n * The features' block actions and the actions of their derive methods (`deriveActionsOf`) in `order` (stable), followed by the\n * host's. Throws when an action `requires` a capability no feature of `preset` declares (the actions only exist once a feature\n * context does, so `defineEditor` cannot check them; a derive method's `requires` it does check).\n */\nexport function blockActionsOf(preset: EditorPreset, ctx: FeatureContext, hostActions: readonly BlockAction[] = []): BlockAction[] {\n  const actions = [...[...contributions(preset, 'blockActions').flatMap(factory => factory(ctx)), ...deriveActionsOf(preset, ctx)].sort(byOrder), ...hostActions]\n  for (const action of actions) {\n    for (const required of action.requires ?? []) {\n      if (!preset.capabilities.has(required)) fail(`the block action \"${action.id}\" requires the capability \"${required}\", which no feature declares`, 'blockActionsOf')\n    }\n  }\n  return actions\n}\n"],"mappings":";;;;;;;;;AA+BA,SAAgB,qBAAqB,SAAgD;CACnF,MAAM,EAAE,KAAK,WAAW;CACxB,IAAI;CACJ,MAAM,MAAoE;EACxE;EACA,UAAU,IAAI;EACd,UAAU,QAAQ;EAClB,IAAI,QAAQ;EACZ,QAAQ,QAAQ;EAChB,QAAQ,IAAI;EACZ,GAAG,IAAI;EACP,SAAS,IAAI;EACb,IAAI,IAAI;EACR,YAAY,QAAQ;EACpB,eAAe,QAAQ;EACvB,gBAAgB;EAChB,WAAW,QAAQ,aAAa,CAAC;EACjC,gBAAgB;GACd,IAAI,CAAC,MAAM;IACT,MAAM,WAAW,WAAW,QAAQ,GAAG;IACvC,OAAO,QAAQ,WAAW,QAAQ,SAAS,QAAQ,IAAI;IACvD,IAAI,QAAQ,UAAU,uBAAuB,IAAI;GACnD;GACA,OAAO;EACT;EACA,WAAW,QAAQ;CACrB;CACA,IAAI,iBAAiB,cAAc,QAAQ,gBAAgB,CAAC,CAAC,EAAE,GAAG,GAAG,KAAK;CAC1E,KAAK,MAAM,YAAY,cAAc,QAAQ,kBAAkB,GAAG,IAAI,SAAS,SAAS,SAAS,GAAG,CAAC;CACrG,OAAO;AACT;;;;;;AAOA,SAAgB,eAAe,QAAsB,KAAqB,cAAsC,CAAC,GAAkB;CACjI,MAAM,UAAU,CAAC,GAAG,CAAC,GAAG,cAAc,QAAQ,cAAc,CAAC,CAAC,SAAQ,YAAW,QAAQ,GAAG,CAAC,GAAG,GAAG,gBAAgB,QAAQ,GAAG,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,GAAG,WAAW;CAC9J,KAAK,MAAM,UAAU,SACnB,KAAK,MAAM,YAAY,OAAO,YAAY,CAAC,GACzC,IAAI,CAAC,OAAO,aAAa,IAAI,QAAQ,GAAG,KAAK,qBAAqB,OAAO,GAAG,6BAA6B,SAAS,+BAA+B,gBAAgB;CAGrK,OAAO;AACT"}

package/dist/core/feature.d.ts

@@ -9,8 +9,11 @@ import { ConvertTarget } from "./convert.js";
 import { CommandDef, InsertGuard, ToolbarGroupDef, TransactionGuard } from "./command-types.js";
 import { AbilitiesOptions, BlockAction, BlockUiOptions } from "./extension-points.js";
 import { EditorUi } from "./editor-ui.js";
+import { BlockCapability, BlockTypeData, CapabilityRegistry } from "./capabilities.js";
+import { DeriveMethod, DeriveRegistry } from "./derive.js";
 import { EditorMetadata } from "./metadata-types.js";
 import { MetadataRegistry } from "./metadata.js";
+import { PropertyDefinition } from "./properties.js";
 import { AnyExtension, Editor, JSONContent } from "@tiptap/core";
 import { EditorState, Transaction } from "@tiptap/pm/state";
 import { Node as Node$1, ResolvedPos } from "@tiptap/pm/model";
@@ -32,7 +35,7 @@ export interface CollaborationSession {
   provider?: HocuspocusProvider;
   user?: AuthorIdentity;
   /**
-   * Token the collaboration server's `Identity.authenticate` receives (`{ headers, token }`), for clients without
+   * Token the collaboration server's `AccessControl.authenticate` receives (`{ headers, token }`), for clients without
    * the session cookie of the server's origin (scripts, agents, cross-origin hosts). A string, or a function called
    * every time the socket opens (so it can refresh an expired token). Applied to `provider`'s configuration when the
    * surface is set up, which the provider reads when its socket opens: create the provider and mount the surface in the
@@ -99,7 +102,7 @@ export interface SettingsTab<C = unknown> {
   label: string;
   icon?: string;
   component: C;
-  /** Props handed to `component`, e.g. the configured composite kinds. */
+  /** Props handed to `component`, e.g. the configured Block types. */
   props?: Record<string, unknown>;
 }
 /** The stages `parseBlocks` and the import/AI insertion paths run; features replace stages, defaults are identity/Markdown. */
@@ -109,6 +112,7 @@ export interface BlockPipeline {
   segment: (editor: Editor, blocks: JSONContent[]) => JSONContent[];
   structure: (editor: Editor, blocks: JSONContent[]) => JSONContent[];
   wrapImport: (editor: Editor, file: File, blocks: JSONContent[]) => JSONContent[];
+  /** The loaded document as the current schema reads it. The rename of the old persisted names (`migratePersistedNames`) runs before it: `defineEditor` puts it in front of a contributed hook, so the hook sees current names only. */
   migrateContent: (content: JSONContent) => JSONContent;
 }
 /** Pipeline hooks that allow a single contributor; `normalize` chains instead. */
@@ -137,22 +141,14 @@ export interface ConversionProvider {
   } | null;
 }
 /**
- * Inert public data AI reads about the editor's document model. A kind's `fields` carry what the model needs to write
- * them (`type`, and the choices of a `select`).
+ * Inert public data AI reads about the editor's document model. A Block type's `fields` are its Property definitions: they carry
+ * what the model needs to write the properties (`type`, and the choices of a `select`).
  */
-export interface AiContextKind {
+export interface AiContextBlockType {
   id: string;
   label: string;
-  fields: readonly {
-    key: string;
-    label: string;
-    type?: 'text' | 'textarea' | 'date' | 'number' | 'select' | 'multiselect' | 'reference' | 'bibliography' | 'derivation';
-    options?: readonly {
-      value: string;
-      label: string;
-    }[];
-  }[];
-  /** The kind's `ai.purpose`, when configured. */
+  fields: readonly PropertyDefinition[];
+  /** The Block type's `ai.purpose`, when configured. */
   purpose?: string;
 }
 /** A host block as AI learns it: what it is for, its Markdown form and one example. `id` is the node type name and the `convert` target id. */
@@ -167,9 +163,9 @@ export interface AiBlock {
   example: string;
 }
 export interface AiContext {
-  kinds?: readonly AiContextKind[];
+  blockTypes?: readonly AiContextBlockType[];
   blocks?: readonly AiBlock[];
-  structure?: 'flat' | 'composite';
+  structure?: 'flat' | 'structured';
 }
 /** One piece of material a feature fetched for a block before the model fills it (a host's examples, a record). */
 export interface AiBlockDatum {
@@ -206,6 +202,26 @@ export interface EditorFeature<C = unknown> {
   backend?: readonly BackendCapability[];
   extensions?: (ctx: FeatureContext) => AnyExtension[];
   blockActions?: (ctx: FeatureContext) => BlockAction[];
+  /**
+   * Block capabilities the feature declares (`container` and `title` are built in): descriptors of what a block is, which a
+   * `BlockAction.requires` names and `capabilitiesAt` answers. Ids are unique across features. A capability installs nothing:
+   * schema, extensions and node views stay with the feature that owns the mechanism.
+   */
+  blockCapabilities?: readonly BlockCapability[];
+  /**
+   * Ways to make a new block or text from a block (transcription, text extraction, summary, AI fill, AI derivation, bibliography fetch):
+   * one registry across all features, each method declaring the capabilities the original must have (`requires`) and its backend
+   * flags (`available`). The block actions of the methods are generated from it. Ids are unique across features and every
+   * `requires` id must be a declared capability; `defineEditor` throws otherwise.
+   */
+  deriveMethods?: readonly DeriveMethod[];
+  /**
+   * The Block types the feature's editor offers: data (an id and the capabilities each type lists with their config) the capability
+   * registry answers from. Additive: the contributions of all features concatenate in feature order. An editor created from the preset
+   * checks them against the declared capabilities (`validateBlockTypes`): an unknown capability id or an invalid config throws. Block
+   * types are per editor (the composites feature builds its defaults in the surface's language).
+   */
+  blockTypes?: (editor: Editor) => readonly BlockTypeData[];
   /**
    * Options of the block UI (`BlockUiOptions`: which surfaces render block actions). Set by the block-ui feature; the
    * overlay components are mounted by the surface without props, so they read it from the editor entry (`EditorEntry.blockUi`).
@@ -215,7 +231,7 @@ export interface EditorFeature<C = unknown> {
   commands?: (ctx: FeatureContext) => CommandDef<C>[];
   /** Toolbar groups the feature declares; every command's `toolbar.group` must be declared by some feature. Ids are unique across features. */
   toolbarGroups?: ToolbarGroupDef[];
-  /** Rules a command's `creates` must pass at the caret besides the schema (e.g. a Baustein's accepted children). */
+  /** Rules a command's `creates` must pass at the caret besides the schema (e.g. a Typed block's accepted children). */
   insertGuards?: (ctx: FeatureContext) => InsertGuard[];
   /**
    * Refusals of whole transactions: every transaction that changes the document runs through the guards of all
@@ -240,7 +256,7 @@ export interface EditorFeature<C = unknown> {
   anchorResolver?: (ctx: FeatureContext) => AnchorResolver;
   /** Additive: the contributions of all features are merged (`kinds` and `blocks` concatenated in feature order; `structure` may be set by one feature only). Reads AI's view of the document model. */
   aiContext?: (editor: Editor) => AiContext;
-  /** Additive: every contributor runs for the block (in parallel), their data concatenate in feature order; one rejection fails the whole fill. Read by „Baustein füllen (KI)“. */
+  /** Additive: every contributor runs for the block (in parallel), their data concatenate in feature order; one rejection fails the whole fill. Read by „Block füllen (KI)“. */
   aiBlockData?: AiBlockDataProvider;
   /** At most one contributor: formats an AI result's markdown before the generic pipeline. */
   formatAiResult?: (editor: Editor, markdown: string, heading?: string) => string;
@@ -250,6 +266,12 @@ export interface EditorPreset<C = unknown> {
   readonly features: readonly EditorFeature<C>[];
   readonly pipeline: BlockPipeline;
   readonly conversions: readonly ConversionProvider[];
+  /** The built-in and the features' block capabilities; each editor answers over them per node (`capabilitiesAt`). */
+  readonly capabilities: CapabilityRegistry;
+  /** The features' derive methods, merged (`deriveMethodsAt`, `blockActionsOf`). */
+  readonly deriveMethods: DeriveRegistry;
+  /** All `blockTypes` contributions merged (`capabilityIndexOf` answers from them). */
+  readonly blockTypes?: (editor: Editor) => readonly BlockTypeData[];
   /** All `aiContext` contributions merged (`aiContextOf`). */
   readonly aiContext?: EditorFeature['aiContext'];
   /** All `aiBlockData` contributions merged (`aiBlockDataOf`). */

package/dist/core/feature.js.map

@@ -1 +1 @@
-{"version":3,"file":"feature.js","names":[],"sources":["../../src/core/feature.ts"],"sourcesContent":["import type { HocuspocusProvider } from '@hocuspocus/provider'\nimport type { AnyExtension, Editor, JSONContent } from '@tiptap/core'\nimport type { Node as PMNode, ResolvedPos } from '@tiptap/pm/model'\nimport type { EditorState, Transaction } from '@tiptap/pm/state'\nimport type * as Y from 'yjs'\nimport type { Locale, Translate } from '../i18n'\nimport type { EditorSettings } from '../settings'\nimport type { EditorBackend } from './backend'\nimport type { BackendCapability } from './backend-capability'\nimport type { EditorAiConfig, EditorContext } from './context'\nimport type { ConvertTarget } from './convert'\nimport type { EditorUi } from './editor-ui'\nimport type { AbilitiesOptions, BlockAction, BlockUiOptions } from './extension-points'\nimport type { MetadataRegistry } from './metadata'\nimport type { CommandDef, InsertGuard, ToolbarGroupDef, TransactionGuard } from './command-types'\nimport type { Notifier } from './notify'\nimport type { EditorMetadata } from './metadata-types'\nimport type { Store } from './store'\n\n// The composition contracts: an `EditorFeature` contributes extensions and descriptors, `defineEditor` validates a\n// feature list into an immutable `EditorPreset`, and `EditorSurface` mounts one. Everything here is inert data and\n// types; features only differ by which of these seams they fill.\n\n/**\n * The user writing in an editor: the collaboration session's `user`, labelled on remote carets, and (authors and comments\n * features) copied into the author mark of every text run and into every comment the user writes.\n */\nexport interface AuthorIdentity {\n  id: string\n  name: string\n  color: string\n}\n\n/** A host-owned collaboration session handed to the surface; only the collab feature turns it into extensions. */\nexport interface CollaborationSession {\n  ydoc: Y.Doc\n  provider?: HocuspocusProvider\n  user?: AuthorIdentity\n  /**\n   * Token the collaboration server's `Identity.authenticate` receives (`{ headers, token }`), for clients without\n   * the session cookie of the server's origin (scripts, agents, cross-origin hosts). A string, or a function called\n   * every time the socket opens (so it can refresh an expired token). Applied to `provider`'s configuration when the\n   * surface is set up, which the provider reads when its socket opens: create the provider and mount the surface in the\n   * same tick, or give the provider its own `token` option instead.\n   */\n  token?: string | (() => string) | (() => Promise<string>)\n}\n\n/**\n * A mapping between document positions and positions that survive collaborative edits. The collab feature supplies\n * the Yjs implementation; without one, `DocAnchors` maps positions through local transactions only.\n */\nexport interface AnchorResolver {\n  /** The transaction applies a Yjs change to the document: remote edits and Yjs undo/redo. */\n  isYSync: (tr: Transaction) => boolean\n  /** The transaction applies an edit of another client (excludes Yjs undo/redo). */\n  isRemoteChange: (tr: Transaction) => boolean\n  /** Opaque token of `range` that `resolve` can turn back into positions after remote changes; null when unavailable. */\n  capture: (state: EditorState, range: { from: number, to: number }, startInside: boolean) => unknown | null\n  resolve: (state: EditorState, token: unknown) => { from: number, to: number } | null\n  /** Stops undo capturing around a programmatic change; true iff a Yjs undo manager exists. */\n  stopUndoCapture: (state: EditorState) => boolean\n}\n\n/** Per-surface dependencies of a feature's factories. Created when a surface is set up; never shared between editors. */\nexport interface FeatureContext {\n  /** The app context the surface belongs to (shared by all editors of the app): app-level models key on it. */\n  readonly app: EditorContext\n  /** The app's shared settings (see `createEditorContext`): read with `get()`, write with `update()`, observe with `subscribe()`. */\n  readonly settings: Store<EditorSettings>\n  readonly metadata: MetadataRegistry\n  /** Chrome of the editor this context belongs to (settings, sidebar). */\n  readonly ui: EditorUi\n  /** Shows a notice through the surface's framework (Nuxt UI toast, sonner). */\n  readonly notify: Notifier\n  /** The app's UI language (`createEditorContext({ locale })`). */\n  readonly locale: Locale\n  /** Renders a catalog message in the app's language; every label a feature contributes goes through it. */\n  readonly t: Translate\n  /** The data layer of the app (`createEditorContext({ backend })`): uploads, mention lookups, themes, AI. */\n  readonly backend: EditorBackend\n  /** Inert public AI configuration of the app context; absent when none was supplied. */\n  readonly ai: EditorAiConfig | undefined\n  /** Document whose package stores uploads (media feature). */\n  readonly documentId: string | undefined\n  readonly collaboration: CollaborationSession | undefined\n  /** The collaboration-aware position mapping of the preset's `anchorResolver` feature; null means local mapping only. */\n  readonly anchorResolver: AnchorResolver | null\n  /** Host options for the ability extension (`abilities` prop). */\n  readonly abilities: Partial<AbilitiesOptions>\n  /** The final command list: the features' commands after the host's `commands` transformer. The `/` menu lists the ones with a `slash` placement. */\n  readonly commands: () => CommandDef[]\n  /** Undefined while extensions are constructed; set once the editor exists. Use it in event handlers. */\n  getEditor: () => Editor | undefined\n}\n\n/** A tab of the settings panel/modal, contributed by the feature that owns those settings. */\nexport interface SettingsTab<C = unknown> {\n  id: string\n  /** Already translated (`ctx.t(...)` in the feature's `settingsTabs` factory). */\n  label: string\n  icon?: string\n  component: C\n  /** Props handed to `component`, e.g. the configured composite kinds. */\n  props?: Record<string, unknown>\n}\n\n/** The stages `parseBlocks` and the import/AI insertion paths run; features replace stages, defaults are identity/Markdown. */\nexport interface BlockPipeline {\n  parseMarkdown: (editor: Editor, markdown: string) => JSONContent[]\n  normalize: (editor: Editor, blocks: JSONContent[]) => JSONContent[]\n  segment: (editor: Editor, blocks: JSONContent[]) => JSONContent[]\n  structure: (editor: Editor, blocks: JSONContent[]) => JSONContent[]\n  wrapImport: (editor: Editor, file: File, blocks: JSONContent[]) => JSONContent[]\n  migrateContent: (content: JSONContent) => JSONContent\n}\n\n/** Pipeline hooks that allow a single contributor; `normalize` chains instead. */\nexport const SINGLETON_PIPELINE_HOOKS = ['parseMarkdown', 'segment', 'structure', 'wrapImport', 'migrateContent'] as const satisfies readonly (keyof BlockPipeline)[]\n\n/**\n * A feature's block conversions. Targets keep the inert `ConvertTarget` shapes; the provider that parses a target id\n * owns that target (labels, execution). `handlesSource` claims all conversions of source blocks it understands.\n */\nexport interface ConversionProvider {\n  /** Source blocks this provider converts to any target it can; the first provider claiming a node executes. */\n  handlesSource?: (node: PMNode) => boolean\n  /** Targets offered for `node` in menus (excluding its current type). */\n  targets: (editor: Editor, node: PMNode) => ConvertTarget[]\n  /** The target of `id` when this provider owns it, else null. */\n  parseTarget: (id: string) => ConvertTarget | null\n  /** Menu label (in the language of `t`) and icon of a target this provider owns. */\n  label: (target: ConvertTarget, t: Translate) => { label: string, icon: string } | null\n  /** The conversion of the block after `start` into `target` (absolute range replaced and the converted blocks), or null. */\n  convert: (state: EditorState, start: ResolvedPos, target: ConvertTarget) => { from: number, to: number, blocks: PMNode[] } | null\n}\n\n/**\n * Inert public data AI reads about the editor's document model. A kind's `fields` carry what the model needs to write\n * them (`type`, and the choices of a `select`).\n */\nexport interface AiContextKind {\n  id: string\n  label: string\n  fields: readonly { key: string, label: string, type?: 'text' | 'textarea' | 'date' | 'number' | 'select' | 'multiselect' | 'reference' | 'bibliography' | 'derivation', options?: readonly { value: string, label: string }[] }[]\n  /** The kind's `ai.purpose`, when configured. */\n  purpose?: string\n}\n\n/** A host block as AI learns it: what it is for, its Markdown form and one example. `id` is the node type name and the `convert` target id. */\nexport interface AiBlock {\n  id: string\n  label: string\n  /** One or two German sentences: purpose and what it may contain. */\n  description: string\n  /** The Markdown form, placeholders in angle brackets, e.g. `!!! <info|warning|success>\\n<Inhalt>`. */\n  syntax: string\n  /** One complete Markdown example of the block. */\n  example: string\n}\n\nexport interface AiContext {\n  kinds?: readonly AiContextKind[]\n  blocks?: readonly AiBlock[]\n  structure?: 'flat' | 'composite'\n}\n\n/** One piece of material a feature fetched for a block before the model fills it (a host's examples, a record). */\nexport interface AiBlockDatum { label: string, text: string }\nexport interface AiBlockDataRequest { editor: Editor, node: PMNode, pos: number, signal: AbortSignal }\n/** Material for one block; `signal` aborts when the editor is destroyed or the run is cancelled. */\nexport type AiBlockDataProvider = (request: AiBlockDataRequest) => Promise<readonly AiBlockDatum[]> | readonly AiBlockDatum[]\n\n/**\n * The axis a feature belongs to: `content` (nodes, marks and structure rules the document stores: the server schema comes\n * from here), `interaction` (editing UX, backend-bound UI such as comments and collaboration) or `ai`. A feature\n * belongs to the dimension without which it makes no sense.\n */\nexport type Dimension = 'content' | 'interaction' | 'ai'\n\n/** One named contribution to an editor (blocks, toolbar entries, menus, settings, AI knowledge). Every member is optional but `dimension`; identity and ordering come from the feature list. */\nexport interface EditorFeature<C = unknown> {\n  id: string\n  /** The feature's primary dimension. */\n  dimension: Dimension\n  /**\n   * The Vue-free schema-bearing extensions of this feature (no node views, no UI), collected by `schemaExtensionsOf` for\n   * the server schema. Present on every feature whose nodes or marks the stored document can contain.\n   */\n  schemaExtensions?: () => AnyExtension[]\n  /** Ids of features that must also be installed (`defineEditor` does not install them). */\n  requires?: readonly string[]\n  /** Backend capabilities the feature cannot work without; a surface session over a backend lacking one throws. Optional capabilities (users and tags for mentions) are not listed. */\n  backend?: readonly BackendCapability[]\n  extensions?: (ctx: FeatureContext) => AnyExtension[]\n  blockActions?: (ctx: FeatureContext) => BlockAction[]\n  /**\n   * Options of the block UI (`BlockUiOptions`: which surfaces render block actions). Set by the block-ui feature; the\n   * overlay components are mounted by the surface without props, so they read it from the editor entry (`EditorEntry.blockUi`).\n   */\n  blockUi?: Readonly<BlockUiOptions>\n  /** The feature's commands, each declared once with its toolbar and `/` placements (see `CommandDef`). */\n  commands?: (ctx: FeatureContext) => CommandDef<C>[]\n  /** Toolbar groups the feature declares; every command's `toolbar.group` must be declared by some feature. Ids are unique across features. */\n  toolbarGroups?: ToolbarGroupDef[]\n  /** Rules a command's `creates` must pass at the caret besides the schema (e.g. a Baustein's accepted children). */\n  insertGuards?: (ctx: FeatureContext) => InsertGuard[]\n  /**\n   * Refusals of whole transactions: every transaction that changes the document runs through the guards of all\n   * features, in feature order; the first one answering a string refuses it and shows that string as a notice. For rules\n   * about the document as a whole that no schema expresses (a locked paragraph, a required document shape).\n   */\n  transactionGuards?: (ctx: FeatureContext) => TransactionGuard[]\n  /** Components mounted beside the editor content; they receive `{ editor }`. `C` is the component type of the framework layer that renders them. */\n  overlays?: readonly C[]\n  /**\n   * Runs once when a surface mounts (per-app side effects, e.g. a theme runtime; dedupe inside). Returns the teardown,\n   * called when the surface unmounts; it must be idempotent (React StrictMode mounts twice).\n   */\n  setup?: (ctx: FeatureContext) => void | (() => void)\n  /** The feature's settings tabs. A factory over the app context, so labels render in the context's language. */\n  settingsTabs?: (ctx: EditorContext) => readonly SettingsTab<C>[]\n  /** Built-in metadata lists (`mentions`, `hashtags`, `speakers`, …) used for every list name the host does not supply; searched only when a suggestion uses them. */\n  metadataDefaults?: (ctx: FeatureContext) => EditorMetadata\n  blocks?: Partial<BlockPipeline>\n  conversions?: readonly ConversionProvider[]\n  /** At most one contributor: supplies the collaboration-aware position mapping to `DocAnchors`. */\n  anchorResolver?: (ctx: FeatureContext) => AnchorResolver\n  /** Additive: the contributions of all features are merged (`kinds` and `blocks` concatenated in feature order; `structure` may be set by one feature only). Reads AI's view of the document model. */\n  aiContext?: (editor: Editor) => AiContext\n  /** Additive: every contributor runs for the block (in parallel), their data concatenate in feature order; one rejection fails the whole fill. Read by „Baustein füllen (KI)“. */\n  aiBlockData?: AiBlockDataProvider\n  /** At most one contributor: formats an AI result's markdown before the generic pipeline. */\n  formatAiResult?: (editor: Editor, markdown: string, heading?: string) => string\n}\n\n/** An immutable, validated feature list with its resolved pipeline, conversion providers and AI hooks. */\nexport interface EditorPreset<C = unknown> {\n  readonly features: readonly EditorFeature<C>[]\n  readonly pipeline: BlockPipeline\n  readonly conversions: readonly ConversionProvider[]\n  /** All `aiContext` contributions merged (`aiContextOf`). */\n  readonly aiContext?: EditorFeature['aiContext']\n  /** All `aiBlockData` contributions merged (`aiBlockDataOf`). */\n  readonly aiBlockData?: AiBlockDataProvider\n  /** The single `formatAiResult` contributor, if any. */\n  readonly formatAiResult?: EditorFeature['formatAiResult']\n}\n"],"mappings":";;AAsHA,MAAa,2BAA2B;CAAC;CAAiB;CAAW;CAAa;CAAc;AAAgB"}
+{"version":3,"file":"feature.js","names":[],"sources":["../../src/core/feature.ts"],"sourcesContent":["import type { HocuspocusProvider } from '@hocuspocus/provider'\nimport type { AnyExtension, Editor, JSONContent } from '@tiptap/core'\nimport type { Node as PMNode, ResolvedPos } from '@tiptap/pm/model'\nimport type { EditorState, Transaction } from '@tiptap/pm/state'\nimport type * as Y from 'yjs'\nimport type { Locale, Translate } from '../i18n'\nimport type { EditorSettings } from '../settings'\nimport type { EditorBackend } from './backend'\nimport type { BackendCapability } from './backend-capability'\nimport type { EditorAiConfig, EditorContext } from './context'\nimport type { ConvertTarget } from './convert'\nimport type { EditorUi } from './editor-ui'\nimport type { BlockCapability, BlockTypeData, CapabilityRegistry } from './capabilities'\nimport type { DeriveMethod, DeriveRegistry } from './derive'\nimport type { AbilitiesOptions, BlockAction, BlockUiOptions } from './extension-points'\nimport type { MetadataRegistry } from './metadata'\nimport type { PropertyDefinition } from './properties'\nimport type { CommandDef, InsertGuard, ToolbarGroupDef, TransactionGuard } from './command-types'\nimport type { Notifier } from './notify'\nimport type { EditorMetadata } from './metadata-types'\nimport type { Store } from './store'\n\n// The composition contracts: an `EditorFeature` contributes extensions and descriptors, `defineEditor` validates a\n// feature list into an immutable `EditorPreset`, and `EditorSurface` mounts one. Everything here is inert data and\n// types; features only differ by which of these seams they fill.\n\n/**\n * The user writing in an editor: the collaboration session's `user`, labelled on remote carets, and (authors and comments\n * features) copied into the author mark of every text run and into every comment the user writes.\n */\nexport interface AuthorIdentity {\n  id: string\n  name: string\n  color: string\n}\n\n/** A host-owned collaboration session handed to the surface; only the collab feature turns it into extensions. */\nexport interface CollaborationSession {\n  ydoc: Y.Doc\n  provider?: HocuspocusProvider\n  user?: AuthorIdentity\n  /**\n   * Token the collaboration server's `AccessControl.authenticate` receives (`{ headers, token }`), for clients without\n   * the session cookie of the server's origin (scripts, agents, cross-origin hosts). A string, or a function called\n   * every time the socket opens (so it can refresh an expired token). Applied to `provider`'s configuration when the\n   * surface is set up, which the provider reads when its socket opens: create the provider and mount the surface in the\n   * same tick, or give the provider its own `token` option instead.\n   */\n  token?: string | (() => string) | (() => Promise<string>)\n}\n\n/**\n * A mapping between document positions and positions that survive collaborative edits. The collab feature supplies\n * the Yjs implementation; without one, `DocAnchors` maps positions through local transactions only.\n */\nexport interface AnchorResolver {\n  /** The transaction applies a Yjs change to the document: remote edits and Yjs undo/redo. */\n  isYSync: (tr: Transaction) => boolean\n  /** The transaction applies an edit of another client (excludes Yjs undo/redo). */\n  isRemoteChange: (tr: Transaction) => boolean\n  /** Opaque token of `range` that `resolve` can turn back into positions after remote changes; null when unavailable. */\n  capture: (state: EditorState, range: { from: number, to: number }, startInside: boolean) => unknown | null\n  resolve: (state: EditorState, token: unknown) => { from: number, to: number } | null\n  /** Stops undo capturing around a programmatic change; true iff a Yjs undo manager exists. */\n  stopUndoCapture: (state: EditorState) => boolean\n}\n\n/** Per-surface dependencies of a feature's factories. Created when a surface is set up; never shared between editors. */\nexport interface FeatureContext {\n  /** The app context the surface belongs to (shared by all editors of the app): app-level models key on it. */\n  readonly app: EditorContext\n  /** The app's shared settings (see `createEditorContext`): read with `get()`, write with `update()`, observe with `subscribe()`. */\n  readonly settings: Store<EditorSettings>\n  readonly metadata: MetadataRegistry\n  /** Chrome of the editor this context belongs to (settings, sidebar). */\n  readonly ui: EditorUi\n  /** Shows a notice through the surface's framework (Nuxt UI toast, sonner). */\n  readonly notify: Notifier\n  /** The app's UI language (`createEditorContext({ locale })`). */\n  readonly locale: Locale\n  /** Renders a catalog message in the app's language; every label a feature contributes goes through it. */\n  readonly t: Translate\n  /** The data layer of the app (`createEditorContext({ backend })`): uploads, mention lookups, themes, AI. */\n  readonly backend: EditorBackend\n  /** Inert public AI configuration of the app context; absent when none was supplied. */\n  readonly ai: EditorAiConfig | undefined\n  /** Document whose package stores uploads (media feature). */\n  readonly documentId: string | undefined\n  readonly collaboration: CollaborationSession | undefined\n  /** The collaboration-aware position mapping of the preset's `anchorResolver` feature; null means local mapping only. */\n  readonly anchorResolver: AnchorResolver | null\n  /** Host options for the ability extension (`abilities` prop). */\n  readonly abilities: Partial<AbilitiesOptions>\n  /** The final command list: the features' commands after the host's `commands` transformer. The `/` menu lists the ones with a `slash` placement. */\n  readonly commands: () => CommandDef[]\n  /** Undefined while extensions are constructed; set once the editor exists. Use it in event handlers. */\n  getEditor: () => Editor | undefined\n}\n\n/** A tab of the settings panel/modal, contributed by the feature that owns those settings. */\nexport interface SettingsTab<C = unknown> {\n  id: string\n  /** Already translated (`ctx.t(...)` in the feature's `settingsTabs` factory). */\n  label: string\n  icon?: string\n  component: C\n  /** Props handed to `component`, e.g. the configured Block types. */\n  props?: Record<string, unknown>\n}\n\n/** The stages `parseBlocks` and the import/AI insertion paths run; features replace stages, defaults are identity/Markdown. */\nexport interface BlockPipeline {\n  parseMarkdown: (editor: Editor, markdown: string) => JSONContent[]\n  normalize: (editor: Editor, blocks: JSONContent[]) => JSONContent[]\n  segment: (editor: Editor, blocks: JSONContent[]) => JSONContent[]\n  structure: (editor: Editor, blocks: JSONContent[]) => JSONContent[]\n  wrapImport: (editor: Editor, file: File, blocks: JSONContent[]) => JSONContent[]\n  /** The loaded document as the current schema reads it. The rename of the old persisted names (`migratePersistedNames`) runs before it: `defineEditor` puts it in front of a contributed hook, so the hook sees current names only. */\n  migrateContent: (content: JSONContent) => JSONContent\n}\n\n/** Pipeline hooks that allow a single contributor; `normalize` chains instead. */\nexport const SINGLETON_PIPELINE_HOOKS = ['parseMarkdown', 'segment', 'structure', 'wrapImport', 'migrateContent'] as const satisfies readonly (keyof BlockPipeline)[]\n\n/**\n * A feature's block conversions. Targets keep the inert `ConvertTarget` shapes; the provider that parses a target id\n * owns that target (labels, execution). `handlesSource` claims all conversions of source blocks it understands.\n */\nexport interface ConversionProvider {\n  /** Source blocks this provider converts to any target it can; the first provider claiming a node executes. */\n  handlesSource?: (node: PMNode) => boolean\n  /** Targets offered for `node` in menus (excluding its current type). */\n  targets: (editor: Editor, node: PMNode) => ConvertTarget[]\n  /** The target of `id` when this provider owns it, else null. */\n  parseTarget: (id: string) => ConvertTarget | null\n  /** Menu label (in the language of `t`) and icon of a target this provider owns. */\n  label: (target: ConvertTarget, t: Translate) => { label: string, icon: string } | null\n  /** The conversion of the block after `start` into `target` (absolute range replaced and the converted blocks), or null. */\n  convert: (state: EditorState, start: ResolvedPos, target: ConvertTarget) => { from: number, to: number, blocks: PMNode[] } | null\n}\n\n/**\n * Inert public data AI reads about the editor's document model. A Block type's `fields` are its Property definitions: they carry\n * what the model needs to write the properties (`type`, and the choices of a `select`).\n */\nexport interface AiContextBlockType {\n  id: string\n  label: string\n  fields: readonly PropertyDefinition[]\n  /** The Block type's `ai.purpose`, when configured. */\n  purpose?: string\n}\n\n/** A host block as AI learns it: what it is for, its Markdown form and one example. `id` is the node type name and the `convert` target id. */\nexport interface AiBlock {\n  id: string\n  label: string\n  /** One or two German sentences: purpose and what it may contain. */\n  description: string\n  /** The Markdown form, placeholders in angle brackets, e.g. `!!! <info|warning|success>\\n<Inhalt>`. */\n  syntax: string\n  /** One complete Markdown example of the block. */\n  example: string\n}\n\nexport interface AiContext {\n  blockTypes?: readonly AiContextBlockType[]\n  blocks?: readonly AiBlock[]\n  structure?: 'flat' | 'structured'\n}\n\n/** One piece of material a feature fetched for a block before the model fills it (a host's examples, a record). */\nexport interface AiBlockDatum { label: string, text: string }\nexport interface AiBlockDataRequest { editor: Editor, node: PMNode, pos: number, signal: AbortSignal }\n/** Material for one block; `signal` aborts when the editor is destroyed or the run is cancelled. */\nexport type AiBlockDataProvider = (request: AiBlockDataRequest) => Promise<readonly AiBlockDatum[]> | readonly AiBlockDatum[]\n\n/**\n * The axis a feature belongs to: `content` (nodes, marks and structure rules the document stores: the server schema comes\n * from here), `interaction` (editing UX, backend-bound UI such as comments and collaboration) or `ai`. A feature\n * belongs to the dimension without which it makes no sense.\n */\nexport type Dimension = 'content' | 'interaction' | 'ai'\n\n/** One named contribution to an editor (blocks, toolbar entries, menus, settings, AI knowledge). Every member is optional but `dimension`; identity and ordering come from the feature list. */\nexport interface EditorFeature<C = unknown> {\n  id: string\n  /** The feature's primary dimension. */\n  dimension: Dimension\n  /**\n   * The Vue-free schema-bearing extensions of this feature (no node views, no UI), collected by `schemaExtensionsOf` for\n   * the server schema. Present on every feature whose nodes or marks the stored document can contain.\n   */\n  schemaExtensions?: () => AnyExtension[]\n  /** Ids of features that must also be installed (`defineEditor` does not install them). */\n  requires?: readonly string[]\n  /** Backend capabilities the feature cannot work without; a surface session over a backend lacking one throws. Optional capabilities (users and tags for mentions) are not listed. */\n  backend?: readonly BackendCapability[]\n  extensions?: (ctx: FeatureContext) => AnyExtension[]\n  blockActions?: (ctx: FeatureContext) => BlockAction[]\n  /**\n   * Block capabilities the feature declares (`container` and `title` are built in): descriptors of what a block is, which a\n   * `BlockAction.requires` names and `capabilitiesAt` answers. Ids are unique across features. A capability installs nothing:\n   * schema, extensions and node views stay with the feature that owns the mechanism.\n   */\n  blockCapabilities?: readonly BlockCapability[]\n  /**\n   * Ways to make a new block or text from a block (transcription, text extraction, summary, AI fill, AI derivation, bibliography fetch):\n   * one registry across all features, each method declaring the capabilities the original must have (`requires`) and its backend\n   * flags (`available`). The block actions of the methods are generated from it. Ids are unique across features and every\n   * `requires` id must be a declared capability; `defineEditor` throws otherwise.\n   */\n  deriveMethods?: readonly DeriveMethod[]\n  /**\n   * The Block types the feature's editor offers: data (an id and the capabilities each type lists with their config) the capability\n   * registry answers from. Additive: the contributions of all features concatenate in feature order. An editor created from the preset\n   * checks them against the declared capabilities (`validateBlockTypes`): an unknown capability id or an invalid config throws. Block\n   * types are per editor (the composites feature builds its defaults in the surface's language).\n   */\n  blockTypes?: (editor: Editor) => readonly BlockTypeData[]\n  /**\n   * Options of the block UI (`BlockUiOptions`: which surfaces render block actions). Set by the block-ui feature; the\n   * overlay components are mounted by the surface without props, so they read it from the editor entry (`EditorEntry.blockUi`).\n   */\n  blockUi?: Readonly<BlockUiOptions>\n  /** The feature's commands, each declared once with its toolbar and `/` placements (see `CommandDef`). */\n  commands?: (ctx: FeatureContext) => CommandDef<C>[]\n  /** Toolbar groups the feature declares; every command's `toolbar.group` must be declared by some feature. Ids are unique across features. */\n  toolbarGroups?: ToolbarGroupDef[]\n  /** Rules a command's `creates` must pass at the caret besides the schema (e.g. a Typed block's accepted children). */\n  insertGuards?: (ctx: FeatureContext) => InsertGuard[]\n  /**\n   * Refusals of whole transactions: every transaction that changes the document runs through the guards of all\n   * features, in feature order; the first one answering a string refuses it and shows that string as a notice. For rules\n   * about the document as a whole that no schema expresses (a locked paragraph, a required document shape).\n   */\n  transactionGuards?: (ctx: FeatureContext) => TransactionGuard[]\n  /** Components mounted beside the editor content; they receive `{ editor }`. `C` is the component type of the framework layer that renders them. */\n  overlays?: readonly C[]\n  /**\n   * Runs once when a surface mounts (per-app side effects, e.g. a theme runtime; dedupe inside). Returns the teardown,\n   * called when the surface unmounts; it must be idempotent (React StrictMode mounts twice).\n   */\n  setup?: (ctx: FeatureContext) => void | (() => void)\n  /** The feature's settings tabs. A factory over the app context, so labels render in the context's language. */\n  settingsTabs?: (ctx: EditorContext) => readonly SettingsTab<C>[]\n  /** Built-in metadata lists (`mentions`, `hashtags`, `speakers`, …) used for every list name the host does not supply; searched only when a suggestion uses them. */\n  metadataDefaults?: (ctx: FeatureContext) => EditorMetadata\n  blocks?: Partial<BlockPipeline>\n  conversions?: readonly ConversionProvider[]\n  /** At most one contributor: supplies the collaboration-aware position mapping to `DocAnchors`. */\n  anchorResolver?: (ctx: FeatureContext) => AnchorResolver\n  /** Additive: the contributions of all features are merged (`kinds` and `blocks` concatenated in feature order; `structure` may be set by one feature only). Reads AI's view of the document model. */\n  aiContext?: (editor: Editor) => AiContext\n  /** Additive: every contributor runs for the block (in parallel), their data concatenate in feature order; one rejection fails the whole fill. Read by „Block füllen (KI)“. */\n  aiBlockData?: AiBlockDataProvider\n  /** At most one contributor: formats an AI result's markdown before the generic pipeline. */\n  formatAiResult?: (editor: Editor, markdown: string, heading?: string) => string\n}\n\n/** An immutable, validated feature list with its resolved pipeline, conversion providers and AI hooks. */\nexport interface EditorPreset<C = unknown> {\n  readonly features: readonly EditorFeature<C>[]\n  readonly pipeline: BlockPipeline\n  readonly conversions: readonly ConversionProvider[]\n  /** The built-in and the features' block capabilities; each editor answers over them per node (`capabilitiesAt`). */\n  readonly capabilities: CapabilityRegistry\n  /** The features' derive methods, merged (`deriveMethodsAt`, `blockActionsOf`). */\n  readonly deriveMethods: DeriveRegistry\n  /** All `blockTypes` contributions merged (`capabilityIndexOf` answers from them). */\n  readonly blockTypes?: (editor: Editor) => readonly BlockTypeData[]\n  /** All `aiContext` contributions merged (`aiContextOf`). */\n  readonly aiContext?: EditorFeature['aiContext']\n  /** All `aiBlockData` contributions merged (`aiBlockDataOf`). */\n  readonly aiBlockData?: AiBlockDataProvider\n  /** The single `formatAiResult` contributor, if any. */\n  readonly formatAiResult?: EditorFeature['formatAiResult']\n}\n"],"mappings":";;AA0HA,MAAa,2BAA2B;CAAC;CAAiB;CAAW;CAAa;CAAc;AAAgB"}

package/dist/core/fences.js

@@ -96,7 +96,7 @@ const splitCompositeFences = (markdown) => splitFences(markdown).segments;
 const opaqueFenceJSON = (fence) => ({
 	type: "opaqueFence",
 	attrs: {
-		kind: fence.kind,
+		blockType: fence.kind,
 		raw: fence.raw
 	}
 });

package/dist/core/fences.js.map

@@ -1 +1 @@
-{"version":3,"file":"fences.js","names":[],"sources":["../../src/core/fences.ts"],"sourcesContent":["import type { JSONContent } from '@tiptap/core'\n\n// The `::: kind #id {meta}` … `:::` fence grammar of Markdown documents, shared by the composite feature (registered kinds\n// become composites) and the Markdown entry (every other kind stays an `opaqueFence`). `#id` (optional, Pandoc-like) is\n// the block id of the fenced composite; `{meta}` is a JSON object. Nested fences close with the\n// same bare `:::`, so a closer always ends the innermost open fence. Lines inside ``` / ~~~ code fences are never fence\n// syntax.\n\n/** A well-formed fence: its kind, optional block id (`#id` after the kind), JSON meta, inner text and the exact source text, opener line through closer line. */\nexport interface CompositeFence { kind: string, id?: string, meta: Record<string, unknown>, inner: string, raw: string }\nexport type FenceSegment = { markdown: string } | CompositeFence\n\n/** A fence-like construct that did not become a fence: `invalid-fence-meta` (the `{…}` after the kind is no JSON object) or `unclosed-fence` (no matching `:::`). `line` is 1-based. */\nexport interface FenceProblem { code: 'invalid-fence-meta' | 'unclosed-fence', line: number, kind: string }\n\nconst OPENER = /^\\s*:::[ \\t]*([\\p{L}\\p{N}_-]+)(?:[ \\t]+#([0-9a-f-]{36}))?[ \\t]*(\\{.*\\})?[ \\t]*$/u\nconst CLOSER = /^\\s*:::\\s*$/\nconst CODE_FENCE = /^ {0,3}(`{3,}|~{3,})/\n\nfunction parseMeta(json: string | undefined): Record<string, unknown> | null {\n  if (!json) return {}\n  try {\n    const value: unknown = JSON.parse(json)\n    return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null\n  }\n  catch {\n    return null\n  }\n}\n\n/** For every line whether it is part of a ``` / ~~~ code fence (the fence lines included). */\nfunction codeLines(lines: readonly string[]): boolean[] {\n  const inside: boolean[] = []\n  let open: { char: string, length: number } | null = null\n  for (const line of lines) {\n    const match = CODE_FENCE.exec(line)\n    if (!open) {\n      if (match) open = { char: match[1]![0]!, length: match[1]!.length }\n      inside.push(open !== null)\n      continue\n    }\n    inside.push(true)\n    const closing = /^ {0,3}(`{3,}|~{3,})\\s*$/.exec(line)\n    if (closing && closing[1]![0] === open.char && closing[1]!.length >= open.length) open = null\n  }\n  return inside\n}\n\n/** Splits `::: kind {json}` … `:::` fences (nestable) into segments; text outside fences stays markdown. `problems` lists the opener lines that stayed plain text. */\nexport function splitFences(markdown: string): { segments: FenceSegment[], problems: FenceProblem[] } {\n  const lines = markdown.split('\\n')\n  const code = codeLines(lines)\n  const segments: FenceSegment[] = []\n  const problems: FenceProblem[] = []\n  let plain: string[] = []\n  const flush = () => {\n    if (plain.join('').trim()) segments.push({ markdown: plain.join('\\n') })\n    plain = []\n  }\n  let i = 0\n  while (i < lines.length) {\n    const line = lines[i]!\n    const match = code[i] ? null : OPENER.exec(line)\n    const meta = match ? parseMeta(match[3]) : null\n    if (!match || !meta) {\n      if (match) problems.push({ code: 'invalid-fence-meta', line: i + 1, kind: match[1]! })\n      plain.push(line)\n      i++\n      continue\n    }\n    // Find the matching closer, counting nested openers; none → the opener line stays plain text.\n    let depth = 1\n    let end = i + 1\n    for (; end < lines.length; end++) {\n      if (code[end]) continue\n      if (OPENER.test(lines[end]!)) depth++\n      else if (CLOSER.test(lines[end]!) && --depth === 0) break\n    }\n    if (depth) {\n      problems.push({ code: 'unclosed-fence', line: i + 1, kind: match[1]! })\n      plain.push(line)\n      i++\n      continue\n    }\n    flush()\n    segments.push({ kind: match[1]!, ...(match[2] && { id: match[2] }), meta, inner: lines.slice(i + 1, end).join('\\n'), raw: lines.slice(i, end + 1).join('\\n') })\n    i = end + 1\n  }\n  flush()\n  return { segments, problems }\n}\n\n/** The fences of `markdown` (see `splitFences`) without the problem report. */\nexport const splitCompositeFences = (markdown: string): FenceSegment[] => splitFences(markdown).segments\n\n/** An opaque fence node: `raw` is the fence's source text, written back verbatim by the Markdown serializer. */\nexport const opaqueFenceJSON = (fence: CompositeFence): JSONContent => ({ type: 'opaqueFence', attrs: { kind: fence.kind, raw: fence.raw } })\n"],"mappings":";AAeA,MAAM,SAAS;AACf,MAAM,SAAS;AACf,MAAM,aAAa;AAEnB,SAAS,UAAU,MAA0D;CAC3E,IAAI,CAAC,MAAM,OAAO,CAAC;CACnB,IAAI;EACF,MAAM,QAAiB,KAAK,MAAM,IAAI;EACtC,OAAO,SAAS,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK,IAAI,QAAmC;CAC1G,QACM;EACJ,OAAO;CACT;AACF;;AAGA,SAAS,UAAU,OAAqC;CACtD,MAAM,SAAoB,CAAC;CAC3B,IAAI,OAAgD;CACpD,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,QAAQ,WAAW,KAAK,IAAI;EAClC,IAAI,CAAC,MAAM;GACT,IAAI,OAAO,OAAO;IAAE,MAAM,MAAM,EAAE,CAAE;IAAK,QAAQ,MAAM,EAAE,CAAE;GAAO;GAClE,OAAO,KAAK,SAAS,IAAI;GACzB;EACF;EACA,OAAO,KAAK,IAAI;EAChB,MAAM,UAAU,2BAA2B,KAAK,IAAI;EACpD,IAAI,WAAW,QAAQ,EAAE,CAAE,OAAO,KAAK,QAAQ,QAAQ,EAAE,CAAE,UAAU,KAAK,QAAQ,OAAO;CAC3F;CACA,OAAO;AACT;;AAGA,SAAgB,YAAY,UAA0E;CACpG,MAAM,QAAQ,SAAS,MAAM,IAAI;CACjC,MAAM,OAAO,UAAU,KAAK;CAC5B,MAAM,WAA2B,CAAC;CAClC,MAAM,WAA2B,CAAC;CAClC,IAAI,QAAkB,CAAC;CACvB,MAAM,cAAc;EAClB,IAAI,MAAM,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,SAAS,KAAK,EAAE,UAAU,MAAM,KAAK,IAAI,EAAE,CAAC;EACvE,QAAQ,CAAC;CACX;CACA,IAAI,IAAI;CACR,OAAO,IAAI,MAAM,QAAQ;EACvB,MAAM,OAAO,MAAM;EACnB,MAAM,QAAQ,KAAK,KAAK,OAAO,OAAO,KAAK,IAAI;EAC/C,MAAM,OAAO,QAAQ,UAAU,MAAM,EAAE,IAAI;EAC3C,IAAI,CAAC,SAAS,CAAC,MAAM;GACnB,IAAI,OAAO,SAAS,KAAK;IAAE,MAAM;IAAsB,MAAM,IAAI;IAAG,MAAM,MAAM;GAAI,CAAC;GACrF,MAAM,KAAK,IAAI;GACf;GACA;EACF;EAEA,IAAI,QAAQ;EACZ,IAAI,MAAM,IAAI;EACd,OAAO,MAAM,MAAM,QAAQ,OAAO;GAChC,IAAI,KAAK,MAAM;GACf,IAAI,OAAO,KAAK,MAAM,IAAK,GAAG;QACzB,IAAI,OAAO,KAAK,MAAM,IAAK,KAAK,EAAE,UAAU,GAAG;EACtD;EACA,IAAI,OAAO;GACT,SAAS,KAAK;IAAE,MAAM;IAAkB,MAAM,IAAI;IAAG,MAAM,MAAM;GAAI,CAAC;GACtE,MAAM,KAAK,IAAI;GACf;GACA;EACF;EACA,MAAM;EACN,SAAS,KAAK;GAAE,MAAM,MAAM;GAAK,GAAI,MAAM,MAAM,EAAE,IAAI,MAAM,GAAG;GAAI;GAAM,OAAO,MAAM,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI;GAAG,KAAK,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI;EAAE,CAAC;EAC9J,IAAI,MAAM;CACZ;CACA,MAAM;CACN,OAAO;EAAE;EAAU;CAAS;AAC9B;;AAGA,MAAa,wBAAwB,aAAqC,YAAY,QAAQ,CAAC,CAAC;;AAGhG,MAAa,mBAAmB,WAAwC;CAAE,MAAM;CAAe,OAAO;EAAE,MAAM,MAAM;EAAM,KAAK,MAAM;CAAI;AAAE"}
+{"version":3,"file":"fences.js","names":[],"sources":["../../src/core/fences.ts"],"sourcesContent":["import type { JSONContent } from '@tiptap/core'\n\n// The `::: kind #id {meta}` … `:::` fence grammar of Markdown documents, shared by the composite feature (registered kinds\n// become composites) and the Markdown entry (every other kind stays an `opaqueFence`). `#id` (optional, Pandoc-like) is\n// the block id of the fenced composite; `{meta}` is a JSON object. Nested fences close with the\n// same bare `:::`, so a closer always ends the innermost open fence. Lines inside ``` / ~~~ code fences are never fence\n// syntax.\n\n/** A well-formed fence: its kind, optional block id (`#id` after the kind), JSON meta, inner text and the exact source text, opener line through closer line. */\nexport interface CompositeFence { kind: string, id?: string, meta: Record<string, unknown>, inner: string, raw: string }\nexport type FenceSegment = { markdown: string } | CompositeFence\n\n/** A fence-like construct that did not become a fence: `invalid-fence-meta` (the `{…}` after the kind is no JSON object) or `unclosed-fence` (no matching `:::`). `line` is 1-based. */\nexport interface FenceProblem { code: 'invalid-fence-meta' | 'unclosed-fence', line: number, kind: string }\n\nconst OPENER = /^\\s*:::[ \\t]*([\\p{L}\\p{N}_-]+)(?:[ \\t]+#([0-9a-f-]{36}))?[ \\t]*(\\{.*\\})?[ \\t]*$/u\nconst CLOSER = /^\\s*:::\\s*$/\nconst CODE_FENCE = /^ {0,3}(`{3,}|~{3,})/\n\nfunction parseMeta(json: string | undefined): Record<string, unknown> | null {\n  if (!json) return {}\n  try {\n    const value: unknown = JSON.parse(json)\n    return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null\n  }\n  catch {\n    return null\n  }\n}\n\n/** For every line whether it is part of a ``` / ~~~ code fence (the fence lines included). */\nfunction codeLines(lines: readonly string[]): boolean[] {\n  const inside: boolean[] = []\n  let open: { char: string, length: number } | null = null\n  for (const line of lines) {\n    const match = CODE_FENCE.exec(line)\n    if (!open) {\n      if (match) open = { char: match[1]![0]!, length: match[1]!.length }\n      inside.push(open !== null)\n      continue\n    }\n    inside.push(true)\n    const closing = /^ {0,3}(`{3,}|~{3,})\\s*$/.exec(line)\n    if (closing && closing[1]![0] === open.char && closing[1]!.length >= open.length) open = null\n  }\n  return inside\n}\n\n/** Splits `::: kind {json}` … `:::` fences (nestable) into segments; text outside fences stays markdown. `problems` lists the opener lines that stayed plain text. */\nexport function splitFences(markdown: string): { segments: FenceSegment[], problems: FenceProblem[] } {\n  const lines = markdown.split('\\n')\n  const code = codeLines(lines)\n  const segments: FenceSegment[] = []\n  const problems: FenceProblem[] = []\n  let plain: string[] = []\n  const flush = () => {\n    if (plain.join('').trim()) segments.push({ markdown: plain.join('\\n') })\n    plain = []\n  }\n  let i = 0\n  while (i < lines.length) {\n    const line = lines[i]!\n    const match = code[i] ? null : OPENER.exec(line)\n    const meta = match ? parseMeta(match[3]) : null\n    if (!match || !meta) {\n      if (match) problems.push({ code: 'invalid-fence-meta', line: i + 1, kind: match[1]! })\n      plain.push(line)\n      i++\n      continue\n    }\n    // Find the matching closer, counting nested openers; none → the opener line stays plain text.\n    let depth = 1\n    let end = i + 1\n    for (; end < lines.length; end++) {\n      if (code[end]) continue\n      if (OPENER.test(lines[end]!)) depth++\n      else if (CLOSER.test(lines[end]!) && --depth === 0) break\n    }\n    if (depth) {\n      problems.push({ code: 'unclosed-fence', line: i + 1, kind: match[1]! })\n      plain.push(line)\n      i++\n      continue\n    }\n    flush()\n    segments.push({ kind: match[1]!, ...(match[2] && { id: match[2] }), meta, inner: lines.slice(i + 1, end).join('\\n'), raw: lines.slice(i, end + 1).join('\\n') })\n    i = end + 1\n  }\n  flush()\n  return { segments, problems }\n}\n\n/** The fences of `markdown` (see `splitFences`) without the problem report. */\nexport const splitCompositeFences = (markdown: string): FenceSegment[] => splitFences(markdown).segments\n\n/** An opaque fence node: `raw` is the fence's source text, written back verbatim by the Markdown serializer. */\nexport const opaqueFenceJSON = (fence: CompositeFence): JSONContent => ({ type: 'opaqueFence', attrs: { blockType: fence.kind, raw: fence.raw } })\n"],"mappings":";AAeA,MAAM,SAAS;AACf,MAAM,SAAS;AACf,MAAM,aAAa;AAEnB,SAAS,UAAU,MAA0D;CAC3E,IAAI,CAAC,MAAM,OAAO,CAAC;CACnB,IAAI;EACF,MAAM,QAAiB,KAAK,MAAM,IAAI;EACtC,OAAO,SAAS,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK,IAAI,QAAmC;CAC1G,QACM;EACJ,OAAO;CACT;AACF;;AAGA,SAAS,UAAU,OAAqC;CACtD,MAAM,SAAoB,CAAC;CAC3B,IAAI,OAAgD;CACpD,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,QAAQ,WAAW,KAAK,IAAI;EAClC,IAAI,CAAC,MAAM;GACT,IAAI,OAAO,OAAO;IAAE,MAAM,MAAM,EAAE,CAAE;IAAK,QAAQ,MAAM,EAAE,CAAE;GAAO;GAClE,OAAO,KAAK,SAAS,IAAI;GACzB;EACF;EACA,OAAO,KAAK,IAAI;EAChB,MAAM,UAAU,2BAA2B,KAAK,IAAI;EACpD,IAAI,WAAW,QAAQ,EAAE,CAAE,OAAO,KAAK,QAAQ,QAAQ,EAAE,CAAE,UAAU,KAAK,QAAQ,OAAO;CAC3F;CACA,OAAO;AACT;;AAGA,SAAgB,YAAY,UAA0E;CACpG,MAAM,QAAQ,SAAS,MAAM,IAAI;CACjC,MAAM,OAAO,UAAU,KAAK;CAC5B,MAAM,WAA2B,CAAC;CAClC,MAAM,WAA2B,CAAC;CAClC,IAAI,QAAkB,CAAC;CACvB,MAAM,cAAc;EAClB,IAAI,MAAM,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,SAAS,KAAK,EAAE,UAAU,MAAM,KAAK,IAAI,EAAE,CAAC;EACvE,QAAQ,CAAC;CACX;CACA,IAAI,IAAI;CACR,OAAO,IAAI,MAAM,QAAQ;EACvB,MAAM,OAAO,MAAM;EACnB,MAAM,QAAQ,KAAK,KAAK,OAAO,OAAO,KAAK,IAAI;EAC/C,MAAM,OAAO,QAAQ,UAAU,MAAM,EAAE,IAAI;EAC3C,IAAI,CAAC,SAAS,CAAC,MAAM;GACnB,IAAI,OAAO,SAAS,KAAK;IAAE,MAAM;IAAsB,MAAM,IAAI;IAAG,MAAM,MAAM;GAAI,CAAC;GACrF,MAAM,KAAK,IAAI;GACf;GACA;EACF;EAEA,IAAI,QAAQ;EACZ,IAAI,MAAM,IAAI;EACd,OAAO,MAAM,MAAM,QAAQ,OAAO;GAChC,IAAI,KAAK,MAAM;GACf,IAAI,OAAO,KAAK,MAAM,IAAK,GAAG;QACzB,IAAI,OAAO,KAAK,MAAM,IAAK,KAAK,EAAE,UAAU,GAAG;EACtD;EACA,IAAI,OAAO;GACT,SAAS,KAAK;IAAE,MAAM;IAAkB,MAAM,IAAI;IAAG,MAAM,MAAM;GAAI,CAAC;GACtE,MAAM,KAAK,IAAI;GACf;GACA;EACF;EACA,MAAM;EACN,SAAS,KAAK;GAAE,MAAM,MAAM;GAAK,GAAI,MAAM,MAAM,EAAE,IAAI,MAAM,GAAG;GAAI;GAAM,OAAO,MAAM,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI;GAAG,KAAK,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI;EAAE,CAAC;EAC9J,IAAI,MAAM;CACZ;CACA,MAAM;CACN,OAAO;EAAE;EAAU;CAAS;AAC9B;;AAGA,MAAa,wBAAwB,aAAqC,YAAY,QAAQ,CAAC,CAAC;;AAGhG,MAAa,mBAAmB,WAAwC;CAAE,MAAM;CAAe,OAAO;EAAE,WAAW,MAAM;EAAM,KAAK,MAAM;CAAI;AAAE"}

package/dist/core/index.d.ts

@@ -8,9 +8,13 @@ import { CORE_TARGET_IDS, ConvertTarget, Converter, ForeignBlocks, TextblockSpec
 import { CommandBase, CommandDef, CommandState, Creates, InsertGuard, MenuItem, PlacedToolbarGroup, ToolbarGroupDef, TransactionGuard } from "./command-types.js";
 import { AbilitiesOptions, BlockAction, BlockActionContext, BlockActionSurface, BlockTarget, BlockUiOptions } from "./extension-points.js";
 import { EditorEntry, EditorUi, editorEntryOf, notifierOf, registerEditor } from "./editor-ui.js";
+import { BUILT_IN_BLOCK_CAPABILITIES, BlockCapability, BlockTypeCapability, BlockTypeData, CapabilityContext, CapabilityIndex, CapabilityIssue, CapabilityRegistry, blockTypeConfigOf, blockTypeIdOf, capabilitiesAt, capabilitiesOf, capabilityConfigOf, capabilityDataOf, capabilityIndexOf, capabilityIssues, createCapabilityIndex, createCapabilityRegistry, listsCapability, validateBlockTypes } from "./capabilities.js";
+import { DeriveContext, DeriveMethod, DeriveRegistry, createDeriveRegistry, deriveActionsOf, deriveMethodsAt } from "./derive.js";
 import { EditorMetadata, METADATA_LIST, MetadataItem, MetadataQuery, MetadataSource } from "./metadata-types.js";
 import { Metadata, MetadataRegistry, createMetadataRegistry, filterMetadataItems, metadataOf } from "./metadata.js";
-import { AiBlock, AiBlockDataProvider, AiBlockDataRequest, AiBlockDatum, AiContext, AiContextKind, AnchorResolver, AuthorIdentity, BlockPipeline, CollaborationSession, ConversionProvider, Dimension, EditorFeature, EditorPreset, FeatureContext, SINGLETON_PIPELINE_HOOKS, SettingsTab } from "./feature.js";
+import { PROPERTY_TYPES, PropertyDefinition } from "./properties.js";
+import { AiBlock, AiBlockDataProvider, AiBlockDataRequest, AiBlockDatum, AiContext, AiContextBlockType, AnchorResolver, AuthorIdentity, BlockPipeline, CollaborationSession, ConversionProvider, Dimension, EditorFeature, EditorPreset, FeatureContext, SINGLETON_PIPELINE_HOOKS, SettingsTab } from "./feature.js";
+import { AssetBlock, DERIVATION_KEY, Derivation, DerivationIndex, DerivationMethod, DerivationOrigin, DerivationSource, DerivationState, DerivedEntry, assetRefOf, derivationIndexOf, derivationOf, derivationOriginOf, derivationState, derivedChildrenOf, derivedOf, isForeignSource } from "./derivation.js";
 import { Abilities, AbilitiesStorage, DEFAULT_ABILITY_RULES, abilitiesAt, abilitiesAtSelection, hasAbility } from "./abilities.js";
 import { BlockConvert, blockConversion, conversionLabel, conversionTargetGroups, convertMenuItems, coreConversions, parseConversionTarget, targetOwner } from "./block-convert.js";
 import { startBlockDrag } from "./block-drag.js";
@@ -33,4 +37,4 @@ import { selectionRange } from "./selection-range.js";
 import { SlashCommand, SlashCommandOptions, SlashCommandPluginKey } from "./slash.js";
 import { SuggestionDisplay, SuggestionListProps, SuggestionPopup, SuggestionPopupHandle, SuggestionPopupRenderer, createSuggestionRender, suggestionPopupOf } from "./suggestion-popup.js";
 import { CORE_TOOLBAR_GROUPS, coreCommands } from "./toolbar-items.js";
-export { Abilities, type AbilitiesOptions, type AbilitiesStorage, type AiBlock, type AiBlockDataProvider, type AiBlockDataRequest, type AiBlockDatum, type AiContext, type AiContextKind, type AiStreamEvent, type AnchorResolver, type AuthorIdentity, BLOCK_MIME, type BackendCapability, type BackendCommentsOptions, BackendError, type BlockAction, type BlockActionContext, type BlockActionSurface, BlockConvert, BlockFlash, type BlockPipeline, type BlockTarget, type BlockTransfer, BlockTransferStorage, type BlockTransferStorageData, type BlockUiOptions, CATALOGS, CORE_TARGET_IDS, CORE_TOOLBAR_GROUPS, type CollaborationSession, type CollaborationToken, type CommandBase, type CommandDef, type CommandState, type ConversionProvider, type ConvertTarget, type Converter, type CoreContentOptions, type CoreUi, type Creates, DEFAULT_ABILITY_RULES, DEFAULT_BLOCK_PIPELINE, DEFAULT_LOCALE, type Dimension, type DocAnchor, DocAnchors, type DocAnchorsMeta, type DocAnchorsOptions, DocumentMarkdown, type EditorAiConfig, type EditorBackend, type EditorContext, type EditorContextOptions, type EditorEntry, type EditorFeature, type EditorMetadata, type EditorPreset, type EditorUi, type FeatureContext, type FeatureContextOptions, type ForeignBlocks, type InsertGuard, LOCALES, type Locale, METADATA_LIST, type MenuItem, type MessageKey, type MessageParams, type Messages, Metadata, type MetadataItem, type MetadataQuery, type MetadataRegistry, type MetadataSource, type Notice, type Notifier, PALETTE_OTHER_GROUP, type PaletteEntry, type PaletteGroup, type PlacedToolbarGroup, type PresetStorage, type ReadonlyStore, SINGLETON_PIPELINE_HOOKS, type SettingsTab, SlashCommand, type SlashCommandOptions, SlashCommandPluginKey, type Store, type SuggestionDisplay, type SuggestionListProps, SuggestionPopup, type SuggestionPopupHandle, type SuggestionPopupRenderer, type TextblockSpec, type ToolbarGroupDef, type TransactionGuard, TransactionGuards, type TransactionGuardsOptions, type Translate, abilitiesAt, abilitiesAtSelection, aiBlockDataOf, aiContextOf, anchorResolverOf, blockActionsOf, blockConversion, blockTransferOf, canCreateAt, captureRange, childrenOf, command, commandState, commandsOf, contributions, conversionLabel, conversionTargetGroups, conversionsOf, convertCoreBlocks, convertMenuItems, convertTargetId, coreBlockActions, coreCommands, coreContentFeature, coreConversionTargets, coreConversions, coreUiFeature, createConverter, createEditorContext, createFeatureContext, createMetadataRegistry, createStore, createSuggestionRender, createTranslator, defineEditor, derived, docAnchorsKey, downloadText, editorEntryOf, fetchErrorMessage, filterMetadataItems, filterPalette, finishConversion, formatAiResultOf, guardsAccept, hasAbility, isCoreSource, isCoreTarget, isCurrentTarget, isListNode, isLocale, isQuoteNode, isTextblockNode, isWrapperBlock, metadataOf, notifierOf, paletteGroupsOf, parseBlocks, parseConversionTarget, parseCoreTarget, pipelineOf, presetExtension, readBlockTransfer, registerEditor, releaseRanges, resolveRange, selectionRange, settingsTabsOf, sha256Hex, silentNotifier, startBlockDrag, structureBlocks, suggestionPopupOf, targetOwner, textblockSpecOf, toolbarOf, transactionGuardExtensions, wrapImportBlocks, writeBlockTransfer };
+export { Abilities, type AbilitiesOptions, type AbilitiesStorage, type AiBlock, type AiBlockDataProvider, type AiBlockDataRequest, type AiBlockDatum, type AiContext, type AiContextBlockType, type AiStreamEvent, type AnchorResolver, type AssetBlock, type AuthorIdentity, BLOCK_MIME, BUILT_IN_BLOCK_CAPABILITIES, type BackendCapability, type BackendCommentsOptions, BackendError, type BlockAction, type BlockActionContext, type BlockActionSurface, type BlockCapability, BlockConvert, BlockFlash, type BlockPipeline, type BlockTarget, type BlockTransfer, BlockTransferStorage, type BlockTransferStorageData, type BlockTypeCapability, type BlockTypeData, type BlockUiOptions, CATALOGS, CORE_TARGET_IDS, CORE_TOOLBAR_GROUPS, type CapabilityContext, type CapabilityIndex, type CapabilityIssue, type CapabilityRegistry, type CollaborationSession, type CollaborationToken, type CommandBase, type CommandDef, type CommandState, type ConversionProvider, type ConvertTarget, type Converter, type CoreContentOptions, type CoreUi, type Creates, DEFAULT_ABILITY_RULES, DEFAULT_BLOCK_PIPELINE, DEFAULT_LOCALE, DERIVATION_KEY, type Derivation, type DerivationIndex, type DerivationMethod, type DerivationOrigin, type DerivationSource, type DerivationState, type DeriveContext, type DeriveMethod, type DeriveRegistry, type DerivedEntry, type Dimension, type DocAnchor, DocAnchors, type DocAnchorsMeta, type DocAnchorsOptions, DocumentMarkdown, type EditorAiConfig, type EditorBackend, type EditorContext, type EditorContextOptions, type EditorEntry, type EditorFeature, type EditorMetadata, type EditorPreset, type EditorUi, type FeatureContext, type FeatureContextOptions, type ForeignBlocks, type InsertGuard, LOCALES, type Locale, METADATA_LIST, type MenuItem, type MessageKey, type MessageParams, type Messages, Metadata, type MetadataItem, type MetadataQuery, type MetadataRegistry, type MetadataSource, type Notice, type Notifier, PALETTE_OTHER_GROUP, PROPERTY_TYPES, type PaletteEntry, type PaletteGroup, type PlacedToolbarGroup, type PresetStorage, type PropertyDefinition, type ReadonlyStore, SINGLETON_PIPELINE_HOOKS, type SettingsTab, SlashCommand, type SlashCommandOptions, SlashCommandPluginKey, type Store, type SuggestionDisplay, type SuggestionListProps, SuggestionPopup, type SuggestionPopupHandle, type SuggestionPopupRenderer, type TextblockSpec, type ToolbarGroupDef, type TransactionGuard, TransactionGuards, type TransactionGuardsOptions, type Translate, abilitiesAt, abilitiesAtSelection, aiBlockDataOf, aiContextOf, anchorResolverOf, assetRefOf, blockActionsOf, blockConversion, blockTransferOf, blockTypeConfigOf, blockTypeIdOf, canCreateAt, capabilitiesAt, capabilitiesOf, capabilityConfigOf, capabilityDataOf, capabilityIndexOf, capabilityIssues, captureRange, childrenOf, command, commandState, commandsOf, contributions, conversionLabel, conversionTargetGroups, conversionsOf, convertCoreBlocks, convertMenuItems, convertTargetId, coreBlockActions, coreCommands, coreContentFeature, coreConversionTargets, coreConversions, coreUiFeature, createCapabilityIndex, createCapabilityRegistry, createConverter, createDeriveRegistry, createEditorContext, createFeatureContext, createMetadataRegistry, createStore, createSuggestionRender, createTranslator, defineEditor, derivationIndexOf, derivationOf, derivationOriginOf, derivationState, deriveActionsOf, deriveMethodsAt, derived, derivedChildrenOf, derivedOf, docAnchorsKey, downloadText, editorEntryOf, fetchErrorMessage, filterMetadataItems, filterPalette, finishConversion, formatAiResultOf, guardsAccept, hasAbility, isCoreSource, isCoreTarget, isCurrentTarget, isForeignSource, isListNode, isLocale, isQuoteNode, isTextblockNode, isWrapperBlock, listsCapability, metadataOf, notifierOf, paletteGroupsOf, parseBlocks, parseConversionTarget, parseCoreTarget, pipelineOf, presetExtension, readBlockTransfer, registerEditor, releaseRanges, resolveRange, selectionRange, settingsTabsOf, sha256Hex, silentNotifier, startBlockDrag, structureBlocks, suggestionPopupOf, targetOwner, textblockSpecOf, toolbarOf, transactionGuardExtensions, validateBlockTypes, wrapImportBlocks, writeBlockTransfer };

package/dist/core/index.js

@@ -1,5 +1,7 @@
 import { BackendError } from "./backend.js";
 import { Abilities, DEFAULT_ABILITY_RULES, abilitiesAt, abilitiesAtSelection, hasAbility } from "./abilities.js";
+import { BUILT_IN_BLOCK_CAPABILITIES, blockTypeConfigOf, blockTypeIdOf, capabilitiesAt, capabilitiesOf, capabilityConfigOf, capabilityDataOf, capabilityIndexOf, capabilityIssues, createCapabilityIndex, createCapabilityRegistry, listsCapability, validateBlockTypes } from "./capabilities.js";
+import { createDeriveRegistry, deriveActionsOf, deriveMethodsAt } from "./derive.js";
 import { SINGLETON_PIPELINE_HOOKS } from "./feature.js";
 import { DEFAULT_BLOCK_PIPELINE, aiBlockDataOf, aiContextOf, conversionsOf, formatAiResultOf, parseBlocks, pipelineOf, presetExtension, structureBlocks, wrapImportBlocks } from "./pipeline.js";
 import { contributions, defineEditor, settingsTabsOf } from "./define-editor.js";
@@ -8,6 +10,8 @@ import { editorEntryOf, notifierOf, registerEditor } from "./editor-ui.js";
 import { canCreateAt, command, commandState, commandsOf, guardsAccept, toolbarOf } from "./commands.js";
 import { CORE_TARGET_IDS, childrenOf, convertCoreBlocks, convertTargetId, coreConversionTargets, createConverter, finishConversion, isCoreSource, isCoreTarget, isCurrentTarget, isListNode, isQuoteNode, isTextblockNode, isWrapperBlock, parseCoreTarget, textblockSpecOf } from "./convert.js";
 import { BlockConvert, blockConversion, conversionLabel, conversionTargetGroups, convertMenuItems, coreConversions, parseConversionTarget, targetOwner } from "./block-convert.js";
+import { DERIVATION_KEY, assetRefOf, derivationIndexOf, derivationOf, derivationOriginOf, derivationState, derivedChildrenOf, derivedOf, isForeignSource } from "./derivation.js";
+import { PROPERTY_TYPES } from "./properties.js";
 import { BLOCK_MIME, BlockTransferStorage, blockTransferOf, readBlockTransfer, writeBlockTransfer } from "./block-transfer.js";
 import { startBlockDrag } from "./block-drag.js";
 import { BlockFlash } from "./block-flash.js";
@@ -29,4 +33,4 @@ import { sha256Hex } from "./hash.js";
 import { METADATA_LIST } from "./metadata-types.js";
 import { PALETTE_OTHER_GROUP, filterPalette, paletteGroupsOf } from "./palette.js";
 import { selectionRange } from "./selection-range.js";
-export { Abilities, BLOCK_MIME, BackendError, BlockConvert, BlockFlash, BlockTransferStorage, CATALOGS, CORE_TARGET_IDS, CORE_TOOLBAR_GROUPS, DEFAULT_ABILITY_RULES, DEFAULT_BLOCK_PIPELINE, DEFAULT_LOCALE, DocAnchors, DocumentMarkdown, LOCALES, METADATA_LIST, Metadata, PALETTE_OTHER_GROUP, SINGLETON_PIPELINE_HOOKS, SlashCommand, SlashCommandPluginKey, SuggestionPopup, TransactionGuards, abilitiesAt, abilitiesAtSelection, aiBlockDataOf, aiContextOf, anchorResolverOf, blockActionsOf, blockConversion, blockTransferOf, canCreateAt, captureRange, childrenOf, command, commandState, commandsOf, contributions, conversionLabel, conversionTargetGroups, conversionsOf, convertCoreBlocks, convertMenuItems, convertTargetId, coreBlockActions, coreCommands, coreContentFeature, coreConversionTargets, coreConversions, coreUiFeature, createConverter, createEditorContext, createFeatureContext, createMetadataRegistry, createStore, createSuggestionRender, createTranslator, defineEditor, derived, docAnchorsKey, downloadText, editorEntryOf, fetchErrorMessage, filterMetadataItems, filterPalette, finishConversion, formatAiResultOf, guardsAccept, hasAbility, isCoreSource, isCoreTarget, isCurrentTarget, isListNode, isLocale, isQuoteNode, isTextblockNode, isWrapperBlock, metadataOf, notifierOf, paletteGroupsOf, parseBlocks, parseConversionTarget, parseCoreTarget, pipelineOf, presetExtension, readBlockTransfer, registerEditor, releaseRanges, resolveRange, selectionRange, settingsTabsOf, sha256Hex, silentNotifier, startBlockDrag, structureBlocks, suggestionPopupOf, targetOwner, textblockSpecOf, toolbarOf, transactionGuardExtensions, wrapImportBlocks, writeBlockTransfer };
+export { Abilities, BLOCK_MIME, BUILT_IN_BLOCK_CAPABILITIES, BackendError, BlockConvert, BlockFlash, BlockTransferStorage, CATALOGS, CORE_TARGET_IDS, CORE_TOOLBAR_GROUPS, DEFAULT_ABILITY_RULES, DEFAULT_BLOCK_PIPELINE, DEFAULT_LOCALE, DERIVATION_KEY, DocAnchors, DocumentMarkdown, LOCALES, METADATA_LIST, Metadata, PALETTE_OTHER_GROUP, PROPERTY_TYPES, SINGLETON_PIPELINE_HOOKS, SlashCommand, SlashCommandPluginKey, SuggestionPopup, TransactionGuards, abilitiesAt, abilitiesAtSelection, aiBlockDataOf, aiContextOf, anchorResolverOf, assetRefOf, blockActionsOf, blockConversion, blockTransferOf, blockTypeConfigOf, blockTypeIdOf, canCreateAt, capabilitiesAt, capabilitiesOf, capabilityConfigOf, capabilityDataOf, capabilityIndexOf, capabilityIssues, captureRange, childrenOf, command, commandState, commandsOf, contributions, conversionLabel, conversionTargetGroups, conversionsOf, convertCoreBlocks, convertMenuItems, convertTargetId, coreBlockActions, coreCommands, coreContentFeature, coreConversionTargets, coreConversions, coreUiFeature, createCapabilityIndex, createCapabilityRegistry, createConverter, createDeriveRegistry, createEditorContext, createFeatureContext, createMetadataRegistry, createStore, createSuggestionRender, createTranslator, defineEditor, derivationIndexOf, derivationOf, derivationOriginOf, derivationState, deriveActionsOf, deriveMethodsAt, derived, derivedChildrenOf, derivedOf, docAnchorsKey, downloadText, editorEntryOf, fetchErrorMessage, filterMetadataItems, filterPalette, finishConversion, formatAiResultOf, guardsAccept, hasAbility, isCoreSource, isCoreTarget, isCurrentTarget, isForeignSource, isListNode, isLocale, isQuoteNode, isTextblockNode, isWrapperBlock, listsCapability, metadataOf, notifierOf, paletteGroupsOf, parseBlocks, parseConversionTarget, parseCoreTarget, pipelineOf, presetExtension, readBlockTransfer, registerEditor, releaseRanges, resolveRange, selectionRange, settingsTabsOf, sha256Hex, silentNotifier, startBlockDrag, structureBlocks, suggestionPopupOf, targetOwner, textblockSpecOf, toolbarOf, transactionGuardExtensions, validateBlockTypes, wrapImportBlocks, writeBlockTransfer };

package/dist/core/pipeline.d.ts

@@ -1,15 +1,21 @@
+import { BlockTypeData, CapabilityRegistry } from "./capabilities.js";
+import { DeriveRegistry } from "./derive.js";
 import { AiBlockDataProvider, AiContext, BlockPipeline, ConversionProvider, EditorFeature, EditorPreset } from "./feature.js";
 import { Editor, Extension, JSONContent } from "@tiptap/core";
 //#region src/core/pipeline.d.ts
 /**
  * Tiptap Markdown parsing and identity transforms: what an editor without contributing features does. Every
- * `::: kind` … `:::` fence becomes an `opaqueFence` that keeps its text verbatim (a feature that knows kinds, composites,
- * parses those first); an editor without that node parses the fences as text.
+ * `::: <block type id>` … `:::` fence becomes an `opaqueFence` that keeps its text verbatim (a feature that knows Block types,
+ * typed blocks, parses those first); an editor without that node parses the fences as text. Loaded JSON still goes through
+ * the persisted-name migration (an `opaqueFence` stored with `kind`).
  */
 export declare const DEFAULT_BLOCK_PIPELINE: BlockPipeline;
 export interface PresetStorage {
   pipeline: BlockPipeline;
   conversions: readonly ConversionProvider[];
+  capabilities: CapabilityRegistry;
+  deriveMethods: DeriveRegistry;
+  blockTypes?: (editor: Editor) => readonly BlockTypeData[];
   aiContext?: EditorFeature['aiContext'];
   aiBlockData?: AiBlockDataProvider;
   formatAiResult?: EditorFeature['formatAiResult'];
@@ -19,15 +25,18 @@ declare module '@tiptap/core' {
     editorPreset: PresetStorage;
   }
 }
-/** Makes the preset's resolved pipeline, conversion providers and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`). */
+/**
+ * Makes the preset's resolved pipeline, conversion providers, block capabilities and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`).
+ * Creating the editor also checks the Features' Block types against the declared capabilities (`validateBlockTypes`), so an unknown capability id throws from the editor's constructor.
+ */
 export declare function presetExtension(preset: EditorPreset): Extension;
 /** The pipeline `editor` was created with (the defaults for an editor without a preset). */
 export declare const pipelineOf: (editor: Editor) => BlockPipeline;
 /** The conversion providers of the preset `editor` was created with, in feature order. */
 export declare const conversionsOf: (editor: Editor) => readonly ConversionProvider[];
-/** What AI knows about `editor`'s document model: the merged `aiContext` of the preset's features, else no kinds, no blocks and a flat structure. */
+/** What AI knows about `editor`'s document model: the merged `aiContext` of the preset's features, else no Block types, no blocks and a flat structure. */
 export declare function aiContextOf(editor: Editor): {
-  kinds: NonNullable<AiContext['kinds']>;
+  blockTypes: NonNullable<AiContext['blockTypes']>;
   blocks: NonNullable<AiContext['blocks']>;
   structure: NonNullable<AiContext['structure']>;
 };

package/dist/core/pipeline.js

@@ -1,10 +1,13 @@
+import { validateBlockTypes } from "./capabilities.js";
 import { opaqueFenceJSON, splitCompositeFences } from "./fences.js";
+import { migratePersistedNames } from "./schema/persisted-names.js";
 import { Extension } from "@tiptap/core";
 //#region src/core/pipeline.ts
 /**
 * Tiptap Markdown parsing and identity transforms: what an editor without contributing features does. Every
-* `::: kind` … `:::` fence becomes an `opaqueFence` that keeps its text verbatim (a feature that knows kinds, composites,
-* parses those first); an editor without that node parses the fences as text.
+* `::: <block type id>` … `:::` fence becomes an `opaqueFence` that keeps its text verbatim (a feature that knows Block types,
+* typed blocks, parses those first); an editor without that node parses the fences as text. Loaded JSON still goes through
+* the persisted-name migration (an `opaqueFence` stored with `kind`).
 */
 const DEFAULT_BLOCK_PIPELINE = {
 	parseMarkdown: (editor, markdown) => {
@@ -17,30 +20,39 @@ const DEFAULT_BLOCK_PIPELINE = {
 	segment: (_editor, blocks) => blocks,
 	structure: (_editor, blocks) => blocks,
 	wrapImport: (_editor, _file, blocks) => blocks,
-	migrateContent: (content) => content
+	migrateContent: migratePersistedNames
 };
-/** Makes the preset's resolved pipeline, conversion providers and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`). */
+/**
+* Makes the preset's resolved pipeline, conversion providers, block capabilities and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`).
+* Creating the editor also checks the Features' Block types against the declared capabilities (`validateBlockTypes`), so an unknown capability id throws from the editor's constructor.
+*/
 function presetExtension(preset) {
 	return Extension.create({
 		name: "editorPreset",
 		addStorage: () => ({
 			pipeline: preset.pipeline,
 			conversions: preset.conversions,
+			capabilities: preset.capabilities,
+			deriveMethods: preset.deriveMethods,
+			...preset.blockTypes && { blockTypes: preset.blockTypes },
 			...preset.aiContext && { aiContext: preset.aiContext },
 			...preset.aiBlockData && { aiBlockData: preset.aiBlockData },
 			...preset.formatAiResult && { formatAiResult: preset.formatAiResult }
-		})
+		}),
+		onBeforeCreate() {
+			if (preset.blockTypes) validateBlockTypes(preset.capabilities, preset.blockTypes(this.editor));
+		}
 	});
 }
 /** The pipeline `editor` was created with (the defaults for an editor without a preset). */
 const pipelineOf = (editor) => editor.storage.editorPreset?.pipeline ?? DEFAULT_BLOCK_PIPELINE;
 /** The conversion providers of the preset `editor` was created with, in feature order. */
 const conversionsOf = (editor) => editor.storage.editorPreset?.conversions ?? [];
-/** What AI knows about `editor`'s document model: the merged `aiContext` of the preset's features, else no kinds, no blocks and a flat structure. */
+/** What AI knows about `editor`'s document model: the merged `aiContext` of the preset's features, else no Block types, no blocks and a flat structure. */
 function aiContextOf(editor) {
 	const context = editor.storage.editorPreset?.aiContext?.(editor);
 	return {
-		kinds: context?.kinds ?? [],
+		blockTypes: context?.blockTypes ?? [],
 		blocks: context?.blocks ?? [],
 		structure: context?.structure ?? "flat"
 	};

package/dist/core/pipeline.js.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.js","names":[],"sources":["../../src/core/pipeline.ts"],"sourcesContent":["import { type Editor, Extension, type JSONContent } from '@tiptap/core'\nimport { opaqueFenceJSON, splitCompositeFences } from './fences'\nimport type { AiBlockDataProvider, AiContext, BlockPipeline, ConversionProvider, EditorFeature, EditorPreset } from './feature'\n\n/**\n * Tiptap Markdown parsing and identity transforms: what an editor without contributing features does. Every\n * `::: kind` … `:::` fence becomes an `opaqueFence` that keeps its text verbatim (a feature that knows kinds, composites,\n * parses those first); an editor without that node parses the fences as text.\n */\nexport const DEFAULT_BLOCK_PIPELINE: BlockPipeline = {\n  parseMarkdown: (editor, markdown) => {\n    const parse = (text: string) => editor.markdown?.parse(text).content ?? []\n    const segments = editor.schema.nodes.opaqueFence ? splitCompositeFences(markdown) : []\n    if (!segments.some(segment => 'inner' in segment)) return parse(markdown)\n    return segments.flatMap(segment => 'inner' in segment ? [opaqueFenceJSON(segment)] : parse(segment.markdown))\n  },\n  normalize: (_editor, blocks) => blocks,\n  segment: (_editor, blocks) => blocks,\n  structure: (_editor, blocks) => blocks,\n  wrapImport: (_editor, _file, blocks) => blocks,\n  migrateContent: content => content,\n}\n\nexport interface PresetStorage {\n  pipeline: BlockPipeline\n  conversions: readonly ConversionProvider[]\n  aiContext?: EditorFeature['aiContext']\n  aiBlockData?: AiBlockDataProvider\n  formatAiResult?: EditorFeature['formatAiResult']\n}\n\ndeclare module '@tiptap/core' {\n  interface Storage { editorPreset: PresetStorage }\n}\n\n/** Makes the preset's resolved pipeline, conversion providers and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`). */\nexport function presetExtension(preset: EditorPreset): Extension {\n  return Extension.create({\n    name: 'editorPreset',\n    addStorage: (): PresetStorage => ({\n      pipeline: preset.pipeline,\n      conversions: preset.conversions,\n      ...(preset.aiContext && { aiContext: preset.aiContext }),\n      ...(preset.aiBlockData && { aiBlockData: preset.aiBlockData }),\n      ...(preset.formatAiResult && { formatAiResult: preset.formatAiResult }),\n    }),\n  })\n}\n\n/** The pipeline `editor` was created with (the defaults for an editor without a preset). */\nexport const pipelineOf = (editor: Editor): BlockPipeline => editor.storage.editorPreset?.pipeline ?? DEFAULT_BLOCK_PIPELINE\n\n/** The conversion providers of the preset `editor` was created with, in feature order. */\nexport const conversionsOf = (editor: Editor): readonly ConversionProvider[] => editor.storage.editorPreset?.conversions ?? []\n\n/** What AI knows about `editor`'s document model: the merged `aiContext` of the preset's features, else no kinds, no blocks and a flat structure. */\nexport function aiContextOf(editor: Editor): { kinds: NonNullable<AiContext['kinds']>, blocks: NonNullable<AiContext['blocks']>, structure: NonNullable<AiContext['structure']> } {\n  const context = editor.storage.editorPreset?.aiContext?.(editor)\n  return { kinds: context?.kinds ?? [], blocks: context?.blocks ?? [], structure: context?.structure ?? 'flat' }\n}\n\n/** The preset's `formatAiResult` hook, or null when no feature contributes one. */\nexport const formatAiResultOf = (editor: Editor): ((markdown: string, heading?: string) => string) | null => {\n  const format = editor.storage.editorPreset?.formatAiResult\n  return format ? (markdown, heading) => format(editor, markdown, heading) : null\n}\n\n/** The merged `aiBlockData` of the preset's features; without contributors it resolves to no data. */\nexport const aiBlockDataOf = (editor: Editor): AiBlockDataProvider => editor.storage.editorPreset?.aiBlockData ?? (() => [])\n\n/**\n * `markdown` as document JSON (`parsed`: parse, then normalize) and as the blocks to insert (`blocks`: `parsed` after\n * the segment stage). `parsed` is never changed by segmenting. Inline replacements use `parsed`, block insertion and\n * file import use `blocks`.\n */\nexport function parseBlocks(editor: Editor, markdown: string): { parsed: JSONContent, blocks: JSONContent[] } {\n  const pipeline = pipelineOf(editor)\n  const content = pipeline.normalize(editor, pipeline.parseMarkdown(editor, markdown))\n  return { parsed: { type: 'doc', content }, blocks: pipeline.segment(editor, [...content]) }\n}\n\n/** Applies the structure stage to blocks about to be inserted (AI block insertion, file import). */\nexport const structureBlocks = (editor: Editor, blocks: JSONContent[]): JSONContent[] => pipelineOf(editor).structure(editor, blocks)\n\n/** Applies the file-wrapping stage to the blocks of an imported file. */\nexport const wrapImportBlocks = (editor: Editor, file: File, blocks: JSONContent[]): JSONContent[] => pipelineOf(editor).wrapImport(editor, file, blocks)\n"],"mappings":";;;;;;;;AASA,MAAa,yBAAwC;CACnD,gBAAgB,QAAQ,aAAa;EACnC,MAAM,SAAS,SAAiB,OAAO,UAAU,MAAM,IAAI,CAAC,CAAC,WAAW,CAAC;EACzE,MAAM,WAAW,OAAO,OAAO,MAAM,cAAc,qBAAqB,QAAQ,IAAI,CAAC;EACrF,IAAI,CAAC,SAAS,MAAK,YAAW,WAAW,OAAO,GAAG,OAAO,MAAM,QAAQ;EACxE,OAAO,SAAS,SAAQ,YAAW,WAAW,UAAU,CAAC,gBAAgB,OAAO,CAAC,IAAI,MAAM,QAAQ,QAAQ,CAAC;CAC9G;CACA,YAAY,SAAS,WAAW;CAChC,UAAU,SAAS,WAAW;CAC9B,YAAY,SAAS,WAAW;CAChC,aAAa,SAAS,OAAO,WAAW;CACxC,iBAAgB,YAAW;AAC7B;;AAeA,SAAgB,gBAAgB,QAAiC;CAC/D,OAAO,UAAU,OAAO;EACtB,MAAM;EACN,mBAAkC;GAChC,UAAU,OAAO;GACjB,aAAa,OAAO;GACpB,GAAI,OAAO,aAAa,EAAE,WAAW,OAAO,UAAU;GACtD,GAAI,OAAO,eAAe,EAAE,aAAa,OAAO,YAAY;GAC5D,GAAI,OAAO,kBAAkB,EAAE,gBAAgB,OAAO,eAAe;EACvE;CACF,CAAC;AACH;;AAGA,MAAa,cAAc,WAAkC,OAAO,QAAQ,cAAc,YAAY;;AAGtG,MAAa,iBAAiB,WAAkD,OAAO,QAAQ,cAAc,eAAe,CAAC;;AAG7H,SAAgB,YAAY,QAAsJ;CAChL,MAAM,UAAU,OAAO,QAAQ,cAAc,YAAY,MAAM;CAC/D,OAAO;EAAE,OAAO,SAAS,SAAS,CAAC;EAAG,QAAQ,SAAS,UAAU,CAAC;EAAG,WAAW,SAAS,aAAa;CAAO;AAC/G;;AAGA,MAAa,oBAAoB,WAA4E;CAC3G,MAAM,SAAS,OAAO,QAAQ,cAAc;CAC5C,OAAO,UAAU,UAAU,YAAY,OAAO,QAAQ,UAAU,OAAO,IAAI;AAC7E;;AAGA,MAAa,iBAAiB,WAAwC,OAAO,QAAQ,cAAc,sBAAsB,CAAC;;;;;;AAO1H,SAAgB,YAAY,QAAgB,UAAkE;CAC5G,MAAM,WAAW,WAAW,MAAM;CAClC,MAAM,UAAU,SAAS,UAAU,QAAQ,SAAS,cAAc,QAAQ,QAAQ,CAAC;CACnF,OAAO;EAAE,QAAQ;GAAE,MAAM;GAAO;EAAQ;EAAG,QAAQ,SAAS,QAAQ,QAAQ,CAAC,GAAG,OAAO,CAAC;CAAE;AAC5F;;AAGA,MAAa,mBAAmB,QAAgB,WAAyC,WAAW,MAAM,CAAC,CAAC,UAAU,QAAQ,MAAM;;AAGpI,MAAa,oBAAoB,QAAgB,MAAY,WAAyC,WAAW,MAAM,CAAC,CAAC,WAAW,QAAQ,MAAM,MAAM"}
+{"version":3,"file":"pipeline.js","names":[],"sources":["../../src/core/pipeline.ts"],"sourcesContent":["import { type Editor, Extension, type JSONContent } from '@tiptap/core'\nimport { type BlockTypeData, type CapabilityRegistry, validateBlockTypes } from './capabilities'\nimport type { DeriveRegistry } from './derive'\nimport { opaqueFenceJSON, splitCompositeFences } from './fences'\nimport type { AiBlockDataProvider, AiContext, BlockPipeline, ConversionProvider, EditorFeature, EditorPreset } from './feature'\nimport { migratePersistedNames } from './schema/persisted-names'\n\n/**\n * Tiptap Markdown parsing and identity transforms: what an editor without contributing features does. Every\n * `::: <block type id>` … `:::` fence becomes an `opaqueFence` that keeps its text verbatim (a feature that knows Block types,\n * typed blocks, parses those first); an editor without that node parses the fences as text. Loaded JSON still goes through\n * the persisted-name migration (an `opaqueFence` stored with `kind`).\n */\nexport const DEFAULT_BLOCK_PIPELINE: BlockPipeline = {\n  parseMarkdown: (editor, markdown) => {\n    const parse = (text: string) => editor.markdown?.parse(text).content ?? []\n    const segments = editor.schema.nodes.opaqueFence ? splitCompositeFences(markdown) : []\n    if (!segments.some(segment => 'inner' in segment)) return parse(markdown)\n    return segments.flatMap(segment => 'inner' in segment ? [opaqueFenceJSON(segment)] : parse(segment.markdown))\n  },\n  normalize: (_editor, blocks) => blocks,\n  segment: (_editor, blocks) => blocks,\n  structure: (_editor, blocks) => blocks,\n  wrapImport: (_editor, _file, blocks) => blocks,\n  migrateContent: migratePersistedNames,\n}\n\nexport interface PresetStorage {\n  pipeline: BlockPipeline\n  conversions: readonly ConversionProvider[]\n  capabilities: CapabilityRegistry\n  deriveMethods: DeriveRegistry\n  blockTypes?: (editor: Editor) => readonly BlockTypeData[]\n  aiContext?: EditorFeature['aiContext']\n  aiBlockData?: AiBlockDataProvider\n  formatAiResult?: EditorFeature['formatAiResult']\n}\n\ndeclare module '@tiptap/core' {\n  interface Storage { editorPreset: PresetStorage }\n}\n\n/**\n * Makes the preset's resolved pipeline, conversion providers, block capabilities and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`).\n * Creating the editor also checks the Features' Block types against the declared capabilities (`validateBlockTypes`), so an unknown capability id throws from the editor's constructor.\n */\nexport function presetExtension(preset: EditorPreset): Extension {\n  return Extension.create({\n    name: 'editorPreset',\n    addStorage: (): PresetStorage => ({\n      pipeline: preset.pipeline,\n      conversions: preset.conversions,\n      capabilities: preset.capabilities,\n      deriveMethods: preset.deriveMethods,\n      ...(preset.blockTypes && { blockTypes: preset.blockTypes }),\n      ...(preset.aiContext && { aiContext: preset.aiContext }),\n      ...(preset.aiBlockData && { aiBlockData: preset.aiBlockData }),\n      ...(preset.formatAiResult && { formatAiResult: preset.formatAiResult }),\n    }),\n    onBeforeCreate() {\n      if (preset.blockTypes) validateBlockTypes(preset.capabilities, preset.blockTypes(this.editor))\n    },\n  })\n}\n\n/** The pipeline `editor` was created with (the defaults for an editor without a preset). */\nexport const pipelineOf = (editor: Editor): BlockPipeline => editor.storage.editorPreset?.pipeline ?? DEFAULT_BLOCK_PIPELINE\n\n/** The conversion providers of the preset `editor` was created with, in feature order. */\nexport const conversionsOf = (editor: Editor): readonly ConversionProvider[] => editor.storage.editorPreset?.conversions ?? []\n\n/** What AI knows about `editor`'s document model: the merged `aiContext` of the preset's features, else no Block types, no blocks and a flat structure. */\nexport function aiContextOf(editor: Editor): { blockTypes: NonNullable<AiContext['blockTypes']>, blocks: NonNullable<AiContext['blocks']>, structure: NonNullable<AiContext['structure']> } {\n  const context = editor.storage.editorPreset?.aiContext?.(editor)\n  return { blockTypes: context?.blockTypes ?? [], blocks: context?.blocks ?? [], structure: context?.structure ?? 'flat' }\n}\n\n/** The preset's `formatAiResult` hook, or null when no feature contributes one. */\nexport const formatAiResultOf = (editor: Editor): ((markdown: string, heading?: string) => string) | null => {\n  const format = editor.storage.editorPreset?.formatAiResult\n  return format ? (markdown, heading) => format(editor, markdown, heading) : null\n}\n\n/** The merged `aiBlockData` of the preset's features; without contributors it resolves to no data. */\nexport const aiBlockDataOf = (editor: Editor): AiBlockDataProvider => editor.storage.editorPreset?.aiBlockData ?? (() => [])\n\n/**\n * `markdown` as document JSON (`parsed`: parse, then normalize) and as the blocks to insert (`blocks`: `parsed` after\n * the segment stage). `parsed` is never changed by segmenting. Inline replacements use `parsed`, block insertion and\n * file import use `blocks`.\n */\nexport function parseBlocks(editor: Editor, markdown: string): { parsed: JSONContent, blocks: JSONContent[] } {\n  const pipeline = pipelineOf(editor)\n  const content = pipeline.normalize(editor, pipeline.parseMarkdown(editor, markdown))\n  return { parsed: { type: 'doc', content }, blocks: pipeline.segment(editor, [...content]) }\n}\n\n/** Applies the structure stage to blocks about to be inserted (AI block insertion, file import). */\nexport const structureBlocks = (editor: Editor, blocks: JSONContent[]): JSONContent[] => pipelineOf(editor).structure(editor, blocks)\n\n/** Applies the file-wrapping stage to the blocks of an imported file. */\nexport const wrapImportBlocks = (editor: Editor, file: File, blocks: JSONContent[]): JSONContent[] => pipelineOf(editor).wrapImport(editor, file, blocks)\n"],"mappings":";;;;;;;;;;;AAaA,MAAa,yBAAwC;CACnD,gBAAgB,QAAQ,aAAa;EACnC,MAAM,SAAS,SAAiB,OAAO,UAAU,MAAM,IAAI,CAAC,CAAC,WAAW,CAAC;EACzE,MAAM,WAAW,OAAO,OAAO,MAAM,cAAc,qBAAqB,QAAQ,IAAI,CAAC;EACrF,IAAI,CAAC,SAAS,MAAK,YAAW,WAAW,OAAO,GAAG,OAAO,MAAM,QAAQ;EACxE,OAAO,SAAS,SAAQ,YAAW,WAAW,UAAU,CAAC,gBAAgB,OAAO,CAAC,IAAI,MAAM,QAAQ,QAAQ,CAAC;CAC9G;CACA,YAAY,SAAS,WAAW;CAChC,UAAU,SAAS,WAAW;CAC9B,YAAY,SAAS,WAAW;CAChC,aAAa,SAAS,OAAO,WAAW;CACxC,gBAAgB;AAClB;;;;;AAqBA,SAAgB,gBAAgB,QAAiC;CAC/D,OAAO,UAAU,OAAO;EACtB,MAAM;EACN,mBAAkC;GAChC,UAAU,OAAO;GACjB,aAAa,OAAO;GACpB,cAAc,OAAO;GACrB,eAAe,OAAO;GACtB,GAAI,OAAO,cAAc,EAAE,YAAY,OAAO,WAAW;GACzD,GAAI,OAAO,aAAa,EAAE,WAAW,OAAO,UAAU;GACtD,GAAI,OAAO,eAAe,EAAE,aAAa,OAAO,YAAY;GAC5D,GAAI,OAAO,kBAAkB,EAAE,gBAAgB,OAAO,eAAe;EACvE;EACA,iBAAiB;GACf,IAAI,OAAO,YAAY,mBAAmB,OAAO,cAAc,OAAO,WAAW,KAAK,MAAM,CAAC;EAC/F;CACF,CAAC;AACH;;AAGA,MAAa,cAAc,WAAkC,OAAO,QAAQ,cAAc,YAAY;;AAGtG,MAAa,iBAAiB,WAAkD,OAAO,QAAQ,cAAc,eAAe,CAAC;;AAG7H,SAAgB,YAAY,QAAgK;CAC1L,MAAM,UAAU,OAAO,QAAQ,cAAc,YAAY,MAAM;CAC/D,OAAO;EAAE,YAAY,SAAS,cAAc,CAAC;EAAG,QAAQ,SAAS,UAAU,CAAC;EAAG,WAAW,SAAS,aAAa;CAAO;AACzH;;AAGA,MAAa,oBAAoB,WAA4E;CAC3G,MAAM,SAAS,OAAO,QAAQ,cAAc;CAC5C,OAAO,UAAU,UAAU,YAAY,OAAO,QAAQ,UAAU,OAAO,IAAI;AAC7E;;AAGA,MAAa,iBAAiB,WAAwC,OAAO,QAAQ,cAAc,sBAAsB,CAAC;;;;;;AAO1H,SAAgB,YAAY,QAAgB,UAAkE;CAC5G,MAAM,WAAW,WAAW,MAAM;CAClC,MAAM,UAAU,SAAS,UAAU,QAAQ,SAAS,cAAc,QAAQ,QAAQ,CAAC;CACnF,OAAO;EAAE,QAAQ;GAAE,MAAM;GAAO;EAAQ;EAAG,QAAQ,SAAS,QAAQ,QAAQ,CAAC,GAAG,OAAO,CAAC;CAAE;AAC5F;;AAGA,MAAa,mBAAmB,QAAgB,WAAyC,WAAW,MAAM,CAAC,CAAC,UAAU,QAAQ,MAAM;;AAGpI,MAAa,oBAAoB,QAAgB,MAAY,WAAyC,WAAW,MAAM,CAAC,CAAC,WAAW,QAAQ,MAAM,MAAM"}

package/dist/core/properties.d.ts

@@ -0,0 +1,22 @@
+//#region src/core/properties.d.ts
+/** The value types of a Block property. */
+export declare const PROPERTY_TYPES: readonly ["text", "textarea", "date", "number", "select", "multiselect", "reference", "bibliography", "derivation"];
+/** One Property definition: a Block property stored under `key` in the block's `meta` attribute. */
+export interface PropertyDefinition {
+  key: string;
+  label: string;
+  /**
+   * `bibliography`: CSL-JSON item under `meta.bib`; `derivation`: read-only Derivation of a Derived block; `reference`: block id of another Typed block;
+   * `multiselect`: several of `options`, stored as `string[]` (the key is removed when none is chosen).
+   */
+  type: typeof PROPERTY_TYPES[number];
+  /** Choices of a `select` or `multiselect` property (required for `multiselect`). */
+  options?: {
+    value: string;
+    label: string;
+  }[];
+  /** `reference`: Block type ids the property may point to; absent = any Typed block. */
+  targets?: readonly string[];
+}
+//#endregion
+//# sourceMappingURL=properties.d.ts.map