@ecsplico/editor 0.0.0-stage → 2.0.0

package/dist/core/define-editor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-editor.js","names":[],"sources":["../../src/core/define-editor.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { EditorContext } from './context'\nimport { type AiBlock, type AiBlockDataProvider, type AiContext, type AiContextKind, type BlockPipeline, type ConversionProvider, type EditorFeature, type EditorPreset, type SettingsTab, SINGLETON_PIPELINE_HOOKS } from './feature'\nimport { DEFAULT_BLOCK_PIPELINE } from './pipeline'\n\nconst FEATURE_SINGLETONS = ['anchorResolver', 'formatAiResult'] as const satisfies readonly (keyof EditorFeature)[]\n\nfunction fail(message: string): never {\n  throw new Error(`@ecsplico/editor: defineEditor: ${message}`)\n}\n\n/**\n * Validates `features` and resolves their pipeline and conversion providers. Keeps the given order; neither\n * deduplicates nor installs missing dependencies. Throws on duplicate ids, a `requires` entry that is not installed\n * and a singleton hook (`parseMarkdown`, `segment`, `structure`, `wrapImport`, `migrateContent`, `anchorResolver`,\n * `formatAiResult`) contributed twice. `normalize` hooks chain left to right. `aiContext` contributions merge (`kinds` and `blocks`\n * concatenated in feature order, `structure` from one feature only); their conflicts surface when the merged `aiContext` reads the editor.\n * `aiBlockData` contributions are additive too: they run in parallel per block and their data concatenate in feature order.\n */\nexport function defineEditor<C = unknown>(config: { features: readonly EditorFeature<C>[] }): EditorPreset<C> {\n  const features = Object.freeze([...config.features])\n  const ids = new Set<string>()\n  for (const feature of features) {\n    if (ids.has(feature.id)) fail(`duplicate feature id \"${feature.id}\"`)\n    ids.add(feature.id)\n  }\n  for (const feature of features) {\n    for (const required of feature.requires ?? []) {\n      if (!ids.has(required)) fail(`feature \"${feature.id}\" requires \"${required}\", which is not installed`)\n    }\n  }\n\n  const owners = new Map<string, string>()\n  const claim = (hook: string, feature: EditorFeature<C>) => {\n    const owner = owners.get(hook)\n    if (owner) fail(`features \"${owner}\" and \"${feature.id}\" both contribute the singleton hook \"${hook}\"`)\n    owners.set(hook, feature.id)\n  }\n  const pipeline: BlockPipeline = { ...DEFAULT_BLOCK_PIPELINE }\n  const normalizers: BlockPipeline['normalize'][] = []\n  for (const feature of features) {\n    for (const hook of FEATURE_SINGLETONS) if (feature[hook]) claim(hook, feature)\n    const blocks = feature.blocks\n    if (!blocks) continue\n    if (blocks.normalize) normalizers.push(blocks.normalize)\n    for (const hook of SINGLETON_PIPELINE_HOOKS) {\n      const fn = blocks[hook]\n      if (!fn) continue\n      claim(hook, feature)\n      Object.assign(pipeline, { [hook]: fn })\n    }\n  }\n  if (normalizers.length) pipeline.normalize = (editor, blocks) => normalizers.reduce((current, normalize) => normalize(editor, current), blocks)\n\n  const conversions: ConversionProvider[] = features.flatMap(feature => [...(feature.conversions ?? [])])\n  const contexts = features.flatMap(feature => feature.aiContext ? [{ id: feature.id, read: feature.aiContext }] : [])\n  const aiContext = contexts.length\n    ? (editor: Editor): AiContext => {\n        const merged: { kinds: AiContextKind[], blocks: AiBlock[], structure?: AiContext['structure'], owner?: string } = { kinds: [], blocks: [] }\n        const blockIds = new Set<string>()\n        for (const { id, read } of contexts) {\n          const context = read(editor)\n          merged.kinds.push(...(context.kinds ?? []))\n          for (const block of context.blocks ?? []) {\n            if (blockIds.has(block.id)) fail(`the AI block \"${block.id}\" is described by more than one feature`)\n            blockIds.add(block.id)\n            merged.blocks.push(block)\n          }\n          if (context.structure === undefined) continue\n          if (merged.owner) fail(`features \"${merged.owner}\" and \"${id}\" both set aiContext.structure`)\n          merged.owner = id\n          merged.structure = context.structure\n        }\n        return { kinds: merged.kinds, blocks: merged.blocks, ...(merged.structure && { structure: merged.structure }) }\n      }\n    : undefined\n  const dataProviders = features.flatMap(feature => feature.aiBlockData ? [feature.aiBlockData] : [])\n  const aiBlockData: AiBlockDataProvider | undefined = dataProviders.length\n    ? async request => (await Promise.all(dataProviders.map(provide => provide(request)))).flat()\n    : undefined\n  const formatAiResult = features.find(feature => feature.formatAiResult)?.formatAiResult\n  return Object.freeze({\n    features,\n    pipeline: Object.freeze(pipeline),\n    conversions: Object.freeze(conversions),\n    ...(aiContext && { aiContext }),\n    ...(aiBlockData && { aiBlockData }),\n    ...(formatAiResult && { formatAiResult }),\n  })\n}\n\n/**\n * The settings tabs the features of `preset` contribute for the app context `ctx` (labels in its language), in feature\n * order; none means there is no settings UI. Throws when two features contribute the same tab id.\n */\nexport function settingsTabsOf<C = unknown>(preset: EditorPreset<C>, ctx: EditorContext): readonly SettingsTab<C>[] {\n  const owners = new Map<string, string>()\n  return preset.features.flatMap((feature) => {\n    const tabs = feature.settingsTabs?.(ctx) ?? []\n    for (const tab of tabs) {\n      const owner = owners.get(tab.id)\n      if (owner) fail(`features \"${owner}\" and \"${feature.id}\" both contribute the settings tab \"${tab.id}\"`)\n      owners.set(tab.id, feature.id)\n    }\n    return tabs\n  })\n}\n\n/** Features of `preset` that fill the contribution `key`, in order. */\nexport function contributions<C, K extends keyof EditorFeature<C>>(preset: EditorPreset<C>, key: K): NonNullable<EditorFeature<C>[K]>[] {\n  return preset.features.flatMap(feature => feature[key] ? [feature[key] as NonNullable<EditorFeature<C>[K]>] : [])\n}\n"],"mappings":"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"}

package/dist/core/doc-anchors.d.ts

@@ -0,0 +1,67 @@
+import { AnchorResolver } from "./feature.js";
+import { Editor, Extension } from "@tiptap/core";
+import { EditorState, PluginKey } from "@tiptap/pm/state";
+//#region src/core/doc-anchors.d.ts
+/** A document range captured with `captureRange`: survives local and remote (collaborative) edits until released. */
+export interface DocAnchor {
+  readonly id: string;
+}
+/** Current positions (-1 when gone) plus, with an `AnchorResolver`, its token for re-resolving after remote changes. */
+interface AnchorEntry {
+  from: number;
+  to: number;
+  token: unknown | null;
+}
+export declare const docAnchorsKey: PluginKey<ReadonlyMap<string, AnchorEntry>>;
+export type DocAnchorsMeta = {
+  add: {
+    id: string;
+    from: number;
+    to: number;
+    startInside: boolean;
+  };
+} | {
+  remove: readonly string[];
+};
+export interface DocAnchorsOptions {
+  /** Position mapping that survives collaborative edits (see the collab feature); without one anchors only map through local transactions. */
+  resolver: AnchorResolver | null;
+}
+/**
+ * Edit-surviving ranges for AI flows (selection menu, AI sidebar, reviews, chat ops): anchors map through local
+ * transactions and, with an `AnchorResolver`, re-resolve from its tokens on collaboration (y-sync) transactions, which
+ * replace the whole document. Client-only: not part of the Vue-free schema.
+ */
+export declare const DocAnchors: Extension<DocAnchorsOptions, {
+  resolver: AnchorResolver | null;
+}>;
+/**
+ * Captures [from, to] of the current document. Both ends stick to the text before them; `startInside` binds a
+ * non-empty range's start to its own first character instead, so text inserted right before it stays outside.
+ * Release with `releaseRanges` when the flow ends.
+ */
+export declare function captureRange(editor: Editor, { from, to }: {
+  from: number;
+  to: number;
+}, options?: {
+  startInside?: boolean;
+}): DocAnchor;
+/** Current positions of `anchor`, collapsed (`from === to`) when its content was deleted; null when unknown or gone. */
+export declare function resolveRange(state: EditorState, anchor: DocAnchor): {
+  from: number;
+  to: number;
+} | null;
+/** Forgets `anchors` (unknown ones are ignored). */
+export declare function releaseRanges(editor: Editor, anchors: readonly DocAnchor[]): void;
+declare module '@tiptap/core' {
+  interface Storage {
+    docAnchors: {
+      resolver: AnchorResolver | null;
+    };
+  }
+}
+/** The anchor resolver `editor` was created with; null without a collaboration-aware feature. */
+export declare const anchorResolverOf: (editor: Editor) => AnchorResolver | null;
+//#endregion
+export {};
+//# sourceMappingURL=doc-anchors.d.ts.map

package/dist/core/doc-anchors.js

@@ -0,0 +1,112 @@
+import { newBlockId } from "./schema/block-ids.js";
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+//#region src/core/doc-anchors.ts
+const docAnchorsKey = new PluginKey("docAnchors");
+/**
+* Edit-surviving ranges for AI flows (selection menu, AI sidebar, reviews, chat ops): anchors map through local
+* transactions and, with an `AnchorResolver`, re-resolve from its tokens on collaboration (y-sync) transactions, which
+* replace the whole document. Client-only: not part of the Vue-free schema.
+*/
+const DocAnchors = Extension.create({
+	name: "docAnchors",
+	priority: 1e3,
+	addOptions: () => ({ resolver: null }),
+	addStorage() {
+		return { resolver: this.options.resolver };
+	},
+	addProseMirrorPlugins() {
+		const { resolver } = this.options;
+		return [new Plugin({
+			key: docAnchorsKey,
+			state: {
+				init: () => /* @__PURE__ */ new Map(),
+				apply(tr, value, _oldState, newState) {
+					const meta = tr.getMeta(docAnchorsKey);
+					if (!meta && (!tr.docChanged || !value.size)) return value;
+					let next = value;
+					if (tr.docChanged && value.size) {
+						const synced = resolver?.isYSync(tr) === true;
+						const mapped = /* @__PURE__ */ new Map();
+						for (const [id, entry] of value) {
+							if (synced && resolver && entry.token != null) {
+								mapped.set(id, {
+									...entry,
+									...resolver.resolve(newState, entry.token) ?? {
+										from: -1,
+										to: -1
+									}
+								});
+								continue;
+							}
+							if (entry.from < 0) {
+								mapped.set(id, entry);
+								continue;
+							}
+							const collapsed = entry.from === entry.to;
+							mapped.set(id, {
+								...entry,
+								from: tr.mapping.map(entry.from, collapsed ? -1 : 1),
+								to: tr.mapping.map(entry.to, -1)
+							});
+						}
+						next = mapped;
+					}
+					if (meta && "add" in meta) {
+						const { id, from, to, startInside } = meta.add;
+						next = new Map(next).set(id, {
+							from,
+							to,
+							token: resolver?.capture(newState, {
+								from,
+								to
+							}, startInside) ?? null
+						});
+					} else if (meta && meta.remove.some((id) => next.has(id))) {
+						const kept = new Map(next);
+						for (const id of meta.remove) kept.delete(id);
+						next = kept;
+					}
+					return next;
+				}
+			}
+		})];
+	}
+});
+/**
+* Captures [from, to] of the current document. Both ends stick to the text before them; `startInside` binds a
+* non-empty range's start to its own first character instead, so text inserted right before it stays outside.
+* Release with `releaseRanges` when the flow ends.
+*/
+function captureRange(editor, { from, to }, options = {}) {
+	const id = newBlockId();
+	const meta = { add: {
+		id,
+		from,
+		to,
+		startInside: options.startInside ?? false
+	} };
+	editor.view.dispatch(editor.state.tr.setMeta(docAnchorsKey, meta).setMeta("addToHistory", false));
+	return { id };
+}
+/** Current positions of `anchor`, collapsed (`from === to`) when its content was deleted; null when unknown or gone. */
+function resolveRange(state, anchor) {
+	const entry = docAnchorsKey.getState(state)?.get(anchor.id);
+	if (!entry || entry.from < 0 || entry.from > entry.to || entry.to > state.doc.content.size) return null;
+	return {
+		from: entry.from,
+		to: entry.to
+	};
+}
+/** Forgets `anchors` (unknown ones are ignored). */
+function releaseRanges(editor, anchors) {
+	if (editor.isDestroyed || !anchors.length) return;
+	const meta = { remove: anchors.map((a) => a.id) };
+	editor.view.dispatch(editor.state.tr.setMeta(docAnchorsKey, meta).setMeta("addToHistory", false));
+}
+/** The anchor resolver `editor` was created with; null without a collaboration-aware feature. */
+const anchorResolverOf = (editor) => editor.storage.docAnchors?.resolver ?? null;
+//#endregion
+export { DocAnchors, anchorResolverOf, captureRange, docAnchorsKey, releaseRanges, resolveRange };
+
+//# sourceMappingURL=doc-anchors.js.map

package/dist/core/doc-anchors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-anchors.js","names":[],"sources":["../../src/core/doc-anchors.ts"],"sourcesContent":["import { type Editor, Extension } from '@tiptap/core'\nimport { type EditorState, Plugin, PluginKey } from '@tiptap/pm/state'\nimport type { AnchorResolver } from './feature'\nimport { newBlockId } from './schema/block-ids'\n\n/** A document range captured with `captureRange`: survives local and remote (collaborative) edits until released. */\nexport interface DocAnchor { readonly id: string }\n\n/** Current positions (-1 when gone) plus, with an `AnchorResolver`, its token for re-resolving after remote changes. */\ninterface AnchorEntry { from: number, to: number, token: unknown | null }\n\nexport const docAnchorsKey = new PluginKey<ReadonlyMap<string, AnchorEntry>>('docAnchors')\n\nexport type DocAnchorsMeta = { add: { id: string, from: number, to: number, startInside: boolean } } | { remove: readonly string[] }\n\nexport interface DocAnchorsOptions {\n  /** Position mapping that survives collaborative edits (see the collab feature); without one anchors only map through local transactions. */\n  resolver: AnchorResolver | null\n}\n\n/**\n * Edit-surviving ranges for AI flows (selection menu, AI sidebar, reviews, chat ops): anchors map through local\n * transactions and, with an `AnchorResolver`, re-resolve from its tokens on collaboration (y-sync) transactions, which\n * replace the whole document. Client-only: not part of the Vue-free schema.\n */\nexport const DocAnchors = Extension.create<DocAnchorsOptions, { resolver: AnchorResolver | null }>({\n  name: 'docAnchors',\n  priority: 1000,\n\n  addOptions: () => ({ resolver: null }),\n\n  addStorage() {\n    return { resolver: this.options.resolver }\n  },\n\n  addProseMirrorPlugins() {\n    const { resolver } = this.options\n    return [\n      new Plugin<ReadonlyMap<string, AnchorEntry>>({\n        key: docAnchorsKey,\n        state: {\n          init: () => new Map(),\n          apply(tr, value, _oldState, newState) {\n            const meta = tr.getMeta(docAnchorsKey) as DocAnchorsMeta | undefined\n            if (!meta && (!tr.docChanged || !value.size)) return value\n            let next = value\n            if (tr.docChanged && value.size) {\n              const synced = resolver?.isYSync(tr) === true\n              const mapped = new Map<string, AnchorEntry>()\n              for (const [id, entry] of value) {\n                if (synced && resolver && entry.token != null) {\n                  mapped.set(id, { ...entry, ...(resolver.resolve(newState, entry.token) ?? { from: -1, to: -1 }) })\n                  continue\n                }\n                if (entry.from < 0) {\n                  mapped.set(id, entry)\n                  continue\n                }\n                // Like the resolver's positions: text inserted at a boundary stays outside (a collapsed anchor keeps it after itself).\n                const collapsed = entry.from === entry.to\n                mapped.set(id, { ...entry, from: tr.mapping.map(entry.from, collapsed ? -1 : 1), to: tr.mapping.map(entry.to, -1) })\n              }\n              next = mapped\n            }\n            if (meta && 'add' in meta) {\n              const { id, from, to, startInside } = meta.add\n              next = new Map(next).set(id, { from, to, token: resolver?.capture(newState, { from, to }, startInside) ?? null })\n            }\n            else if (meta && meta.remove.some(id => next.has(id))) {\n              const kept = new Map(next)\n              for (const id of meta.remove) kept.delete(id)\n              next = kept\n            }\n            return next\n          },\n        },\n      }),\n    ]\n  },\n})\n\n/**\n * Captures [from, to] of the current document. Both ends stick to the text before them; `startInside` binds a\n * non-empty range's start to its own first character instead, so text inserted right before it stays outside.\n * Release with `releaseRanges` when the flow ends.\n */\nexport function captureRange(editor: Editor, { from, to }: { from: number, to: number }, options: { startInside?: boolean } = {}): DocAnchor {\n  const id = newBlockId()\n  const meta: DocAnchorsMeta = { add: { id, from, to, startInside: options.startInside ?? false } }\n  editor.view.dispatch(editor.state.tr.setMeta(docAnchorsKey, meta).setMeta('addToHistory', false))\n  return { id }\n}\n\n/** Current positions of `anchor`, collapsed (`from === to`) when its content was deleted; null when unknown or gone. */\nexport function resolveRange(state: EditorState, anchor: DocAnchor): { from: number, to: number } | null {\n  const entry = docAnchorsKey.getState(state)?.get(anchor.id)\n  if (!entry || entry.from < 0 || entry.from > entry.to || entry.to > state.doc.content.size) return null\n  return { from: entry.from, to: entry.to }\n}\n\n/** Forgets `anchors` (unknown ones are ignored). */\nexport function releaseRanges(editor: Editor, anchors: readonly DocAnchor[]): void {\n  if (editor.isDestroyed || !anchors.length) return\n  const meta: DocAnchorsMeta = { remove: anchors.map(a => a.id) }\n  editor.view.dispatch(editor.state.tr.setMeta(docAnchorsKey, meta).setMeta('addToHistory', false))\n}\n\ndeclare module '@tiptap/core' {\n  interface Storage { docAnchors: { resolver: AnchorResolver | null } }\n}\n\n/** The anchor resolver `editor` was created with; null without a collaboration-aware feature. */\nexport const anchorResolverOf = (editor: Editor): AnchorResolver | null => editor.storage.docAnchors?.resolver ?? null\n"],"mappings":"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"}

package/dist/core/document-markdown.d.ts

@@ -0,0 +1,13 @@
+import "./schema/mark-flags.js";
+//#region src/core/document-markdown.d.ts
+/**
+ * `@tiptap/markdown`'s `Markdown` whose serializer ignores every mark that declares `markdownInvisible` (author and
+ * comment marks): `editor.getMarkdown()` and every `editor.markdown.serialize()` (AI context and selection, chat
+ * blocks, summaries, transcript cleanup) render as if those marks did not exist. `@tiptap/markdown` already renders
+ * marks without a handler as nothing, but they still split text runs, and its mark-boundary logic then closes and
+ * reopens the formatting around the split (`Ein **Sa**<strong>btz</strong>` for one bold word with another author's
+ * letter inside). The document keeps the marks. Use it instead of `Markdown` in every editor of a preset.
+ */
+export declare const DocumentMarkdown: import("@tiptap/core").Extension<import("@tiptap/markdown").MarkdownExtensionOptions, import("@tiptap/markdown").MarkdownExtensionStorage>;
+//#endregion
+//# sourceMappingURL=document-markdown.d.ts.map

package/dist/core/document-markdown.js

@@ -0,0 +1,31 @@
+import { getExtensionField } from "@tiptap/core";
+import { Markdown } from "@tiptap/markdown";
+//#region src/core/document-markdown.ts
+/** `json` without the marks named in `invisible` on any node; the runs they split become identically marked neighbours. */
+function withoutMarks(json, invisible) {
+	return {
+		...json,
+		...json.marks && { marks: json.marks.filter((mark) => !invisible.has(mark.type)) },
+		...json.content && { content: json.content.map((child) => withoutMarks(child, invisible)) }
+	};
+}
+/**
+* `@tiptap/markdown`'s `Markdown` whose serializer ignores every mark that declares `markdownInvisible` (author and
+* comment marks): `editor.getMarkdown()` and every `editor.markdown.serialize()` (AI context and selection, chat
+* blocks, summaries, transcript cleanup) render as if those marks did not exist. `@tiptap/markdown` already renders
+* marks without a handler as nothing, but they still split text runs, and its mark-boundary logic then closes and
+* reopens the formatting around the split (`Ein **Sa**<strong>btz</strong>` for one bold word with another author's
+* letter inside). The document keeps the marks. Use it instead of `Markdown` in every editor of a preset.
+*/
+const DocumentMarkdown = Markdown.extend({ onBeforeCreate(event) {
+	this.parent?.(event);
+	const invisible = new Set(this.editor.extensionManager.extensions.filter((extension) => extension.type === "mark" && getExtensionField(extension, "markdownInvisible")).map((extension) => extension.name));
+	if (!invisible.size) return;
+	const manager = this.storage.manager;
+	const serialize = manager.serialize.bind(manager);
+	manager.serialize = (json) => serialize(json && withoutMarks(json, invisible));
+} });
+//#endregion
+export { DocumentMarkdown };
+
+//# sourceMappingURL=document-markdown.js.map

package/dist/core/document-markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-markdown.js","names":[],"sources":["../../src/core/document-markdown.ts"],"sourcesContent":["import { getExtensionField, type JSONContent } from '@tiptap/core'\nimport { Markdown } from '@tiptap/markdown'\nimport './schema/mark-flags'\n\n/** `json` without the marks named in `invisible` on any node; the runs they split become identically marked neighbours. */\nfunction withoutMarks(json: JSONContent, invisible: ReadonlySet<string>): JSONContent {\n  return {\n    ...json,\n    ...(json.marks && { marks: json.marks.filter(mark => !invisible.has(mark.type)) }),\n    ...(json.content && { content: json.content.map(child => withoutMarks(child, invisible)) }),\n  }\n}\n\n/**\n * `@tiptap/markdown`'s `Markdown` whose serializer ignores every mark that declares `markdownInvisible` (author and\n * comment marks): `editor.getMarkdown()` and every `editor.markdown.serialize()` (AI context and selection, chat\n * blocks, summaries, transcript cleanup) render as if those marks did not exist. `@tiptap/markdown` already renders\n * marks without a handler as nothing, but they still split text runs, and its mark-boundary logic then closes and\n * reopens the formatting around the split (`Ein **Sa**<strong>btz</strong>` for one bold word with another author's\n * letter inside). The document keeps the marks. Use it instead of `Markdown` in every editor of a preset.\n */\nexport const DocumentMarkdown = Markdown.extend({\n  onBeforeCreate(event) {\n    this.parent?.(event)\n    const invisible = new Set(\n      this.editor.extensionManager.extensions\n        .filter(extension => extension.type === 'mark' && getExtensionField<boolean | undefined>(extension, 'markdownInvisible'))\n        .map(extension => extension.name),\n    )\n    if (!invisible.size) return\n    // `getMarkdown()` serializes through the same manager instance as `editor.markdown`.\n    const manager = this.storage.manager\n    const serialize = manager.serialize.bind(manager)\n    manager.serialize = json => serialize(json && withoutMarks(json, invisible))\n  },\n})\n"],"mappings":";;;;AAKA,SAAS,aAAa,MAAmB,WAA6C;CACpF,OAAO;EACL,GAAG;EACH,GAAI,KAAK,SAAS,EAAE,OAAO,KAAK,MAAM,QAAO,SAAQ,CAAC,UAAU,IAAI,KAAK,IAAI,CAAC,EAAE;EAChF,GAAI,KAAK,WAAW,EAAE,SAAS,KAAK,QAAQ,KAAI,UAAS,aAAa,OAAO,SAAS,CAAC,EAAE;CAC3F;AACF;;;;;;;;;AAUA,MAAa,mBAAmB,SAAS,OAAO,EAC9C,eAAe,OAAO;CACpB,KAAK,SAAS,KAAK;CACnB,MAAM,YAAY,IAAI,IACpB,KAAK,OAAO,iBAAiB,WAC1B,QAAO,cAAa,UAAU,SAAS,UAAU,kBAAuC,WAAW,mBAAmB,CAAC,CAAC,CACxH,KAAI,cAAa,UAAU,IAAI,CACpC;CACA,IAAI,CAAC,UAAU,MAAM;CAErB,MAAM,UAAU,KAAK,QAAQ;CAC7B,MAAM,YAAY,QAAQ,UAAU,KAAK,OAAO;CAChD,QAAQ,aAAY,SAAQ,UAAU,QAAQ,aAAa,MAAM,SAAS,CAAC;AAC7E,EACF,CAAC"}

package/dist/core/download.d.ts

@@ -0,0 +1,5 @@
+//#region src/core/download.d.ts
+/** Offers `text` as a file download named `filename`. */
+export declare function downloadText(filename: string, text: string, mime?: string): void;
+//#endregion
+//# sourceMappingURL=download.d.ts.map

package/dist/core/download.js

@@ -0,0 +1,16 @@
+//#region src/core/download.ts
+/** Offers `text` as a file download named `filename`. */
+function downloadText(filename, text, mime = "text/markdown;charset=utf-8") {
+	const url = URL.createObjectURL(new Blob([text], { type: mime }));
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = filename;
+	document.body.appendChild(link);
+	link.click();
+	link.remove();
+	URL.revokeObjectURL(url);
+}
+//#endregion
+export { downloadText };
+
+//# sourceMappingURL=download.js.map

package/dist/core/download.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.js","names":[],"sources":["../../src/core/download.ts"],"sourcesContent":["/** Offers `text` as a file download named `filename`. */\nexport function downloadText(filename: string, text: string, mime = 'text/markdown;charset=utf-8'): void {\n  const url = URL.createObjectURL(new Blob([text], { type: mime }))\n  const link = document.createElement('a')\n  link.href = url\n  link.download = filename\n  document.body.appendChild(link)\n  link.click()\n  link.remove()\n  URL.revokeObjectURL(url)\n}\n"],"mappings":";;AACA,SAAgB,aAAa,UAAkB,MAAc,OAAO,+BAAqC;CACvG,MAAM,MAAM,IAAI,gBAAgB,IAAI,KAAK,CAAC,IAAI,GAAG,EAAE,MAAM,KAAK,CAAC,CAAC;CAChE,MAAM,OAAO,SAAS,cAAc,GAAG;CACvC,KAAK,OAAO;CACZ,KAAK,WAAW;CAChB,SAAS,KAAK,YAAY,IAAI;CAC9B,KAAK,MAAM;CACX,KAAK,OAAO;CACZ,IAAI,gBAAgB,GAAG;AACzB"}

package/dist/core/editor-ui.d.ts

@@ -0,0 +1,45 @@
+import { BlockAction } from "./extension-points.js";
+import { Notifier } from "./notify.js";
+import { EditorContext } from "./context.js";
+import { EditorPreset, FeatureContext } from "./feature.js";
+import { Editor } from "@tiptap/core";
+//#region src/core/editor-ui.d.ts
+/** Editor chrome an `EditorSurface` owns, for the components around it. Settings tabs are the ids features contribute. */
+export interface EditorUi {
+  /** Opens the settings UI, on `tab` when given (else on the tab shown last). */
+  openSettings: (tab?: string) => void;
+  /** Opens or closes the editor's AI sidebar (the surface's `sidebarOpen` model, which the host binds). */
+  toggleSidebar: () => void;
+  /**
+   * Opens or closes the editor's comments margin (the surface's `commentsOpen` model, which the host binds). Opening it
+   * closes the AI sidebar and vice versa.
+   */
+  toggleComments: () => void;
+  /** Whether the comments margin is open (read-only; for toggles' active state). */
+  readonly commentsOpen: boolean;
+}
+/** What a mounted surface registers for its editor instance: the components beside it read it by `editor`. */
+export interface EditorEntry {
+  ui: EditorUi;
+  preset: EditorPreset;
+  ctx: FeatureContext;
+  /** Features' block actions followed by the host's, for the overlay that renders them. */
+  blockActions: readonly BlockAction[];
+}
+/**
+ * Makes `entry` reachable through `editorEntryOf(editor)` (and the framework layers' `useEditorUi(editor)`); returns the
+ * unregister function. The surface registers once its editor exists (before emitting `ready`) and unregisters on unmount.
+ * Pass the raw editor: framework proxies (e.g. Vue reactive wrappers) are different WeakMap keys.
+ */
+export declare function registerEditor(editor: Editor, entry: EditorEntry): () => void;
+/** The surface entry registered for `editor` (the raw instance); undefined for an unregistered or missing editor. */
+export declare function editorEntryOf(editor: Editor | undefined): EditorEntry | undefined;
+/**
+ * The one notifier policy: a notice goes to the surface notifier of `editor` (`createEditor`/`EditorSurface` of the
+ * host) while it has one, else to the app context's. Both are resolved when a notice is shown (also `dismiss`), so a
+ * request that finishes after an await still reaches the current surface. Pass `editor` (the raw instance) and `app` as
+ * getters when they change over the notifier's life.
+ */
+export declare function notifierOf(editor: Editor | undefined | (() => Editor | undefined), app: Pick<EditorContext, 'notify'> | (() => Pick<EditorContext, 'notify'>)): Notifier;
+//#endregion
+//# sourceMappingURL=editor-ui.d.ts.map

package/dist/core/editor-ui.js

@@ -0,0 +1,38 @@
+//#region src/core/editor-ui.ts
+/** Each mounted surface's entry by its Tiptap editor (raw, unproxied instance), for components outside its subtree. */
+const entries = /* @__PURE__ */ new WeakMap();
+/**
+* Makes `entry` reachable through `editorEntryOf(editor)` (and the framework layers' `useEditorUi(editor)`); returns the
+* unregister function. The surface registers once its editor exists (before emitting `ready`) and unregisters on unmount.
+* Pass the raw editor: framework proxies (e.g. Vue reactive wrappers) are different WeakMap keys.
+*/
+function registerEditor(editor, entry) {
+	entries.set(editor, entry);
+	return () => {
+		if (entries.get(editor) === entry) entries.delete(editor);
+	};
+}
+/** The surface entry registered for `editor` (the raw instance); undefined for an unregistered or missing editor. */
+function editorEntryOf(editor) {
+	return editor ? entries.get(editor) : void 0;
+}
+/**
+* The one notifier policy: a notice goes to the surface notifier of `editor` (`createEditor`/`EditorSurface` of the
+* host) while it has one, else to the app context's. Both are resolved when a notice is shown (also `dismiss`), so a
+* request that finishes after an await still reaches the current surface. Pass `editor` (the raw instance) and `app` as
+* getters when they change over the notifier's life.
+*/
+function notifierOf(editor, app) {
+	const resolve = () => {
+		return editorEntryOf(typeof editor === "function" ? editor() : editor)?.ctx.notify ?? (typeof app === "function" ? app() : app).notify;
+	};
+	const notify = (notice) => resolve()(notice);
+	notify.dismiss = (id) => {
+		resolve().dismiss?.(id);
+	};
+	return notify;
+}
+//#endregion
+export { editorEntryOf, notifierOf, registerEditor };
+
+//# sourceMappingURL=editor-ui.js.map

package/dist/core/editor-ui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-ui.js","names":[],"sources":["../../src/core/editor-ui.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { EditorContext } from './context'\nimport type { EditorPreset, FeatureContext } from './feature'\nimport type { BlockAction } from './extension-points'\nimport type { Notifier } from './notify'\n\n/** Editor chrome an `EditorSurface` owns, for the components around it. Settings tabs are the ids features contribute. */\nexport interface EditorUi {\n  /** Opens the settings UI, on `tab` when given (else on the tab shown last). */\n  openSettings: (tab?: string) => void\n  /** Opens or closes the editor's AI sidebar (the surface's `sidebarOpen` model, which the host binds). */\n  toggleSidebar: () => void\n  /**\n   * Opens or closes the editor's comments margin (the surface's `commentsOpen` model, which the host binds). Opening it\n   * closes the AI sidebar and vice versa.\n   */\n  toggleComments: () => void\n  /** Whether the comments margin is open (read-only; for toggles' active state). */\n  readonly commentsOpen: boolean\n}\n\n/** What a mounted surface registers for its editor instance: the components beside it read it by `editor`. */\nexport interface EditorEntry {\n  ui: EditorUi\n  preset: EditorPreset\n  ctx: FeatureContext\n  /** Features' block actions followed by the host's, for the overlay that renders them. */\n  blockActions: readonly BlockAction[]\n}\n\n/** Each mounted surface's entry by its Tiptap editor (raw, unproxied instance), for components outside its subtree. */\nconst entries = new WeakMap<Editor, EditorEntry>()\n\n/**\n * Makes `entry` reachable through `editorEntryOf(editor)` (and the framework layers' `useEditorUi(editor)`); returns the\n * unregister function. The surface registers once its editor exists (before emitting `ready`) and unregisters on unmount.\n * Pass the raw editor: framework proxies (e.g. Vue reactive wrappers) are different WeakMap keys.\n */\nexport function registerEditor(editor: Editor, entry: EditorEntry): () => void {\n  entries.set(editor, entry)\n  return () => {\n    if (entries.get(editor) === entry) entries.delete(editor)\n  }\n}\n\n/** The surface entry registered for `editor` (the raw instance); undefined for an unregistered or missing editor. */\nexport function editorEntryOf(editor: Editor | undefined): EditorEntry | undefined {\n  return editor ? entries.get(editor) : undefined\n}\n\n/**\n * The one notifier policy: a notice goes to the surface notifier of `editor` (`createEditor`/`EditorSurface` of the\n * host) while it has one, else to the app context's. Both are resolved when a notice is shown (also `dismiss`), so a\n * request that finishes after an await still reaches the current surface. Pass `editor` (the raw instance) and `app` as\n * getters when they change over the notifier's life.\n */\nexport function notifierOf(editor: Editor | undefined | (() => Editor | undefined), app: Pick<EditorContext, 'notify'> | (() => Pick<EditorContext, 'notify'>)): Notifier {\n  const resolve = (): Notifier => {\n    const instance = typeof editor === 'function' ? editor() : editor\n    return editorEntryOf(instance)?.ctx.notify ?? (typeof app === 'function' ? app() : app).notify\n  }\n  const notify: Notifier = notice => resolve()(notice)\n  notify.dismiss = (id) => { resolve().dismiss?.(id) }\n  return notify\n}\n"],"mappings":";;AA+BA,MAAM,0BAAU,IAAI,QAA6B;;;;;;AAOjD,SAAgB,eAAe,QAAgB,OAAgC;CAC7E,QAAQ,IAAI,QAAQ,KAAK;CACzB,aAAa;EACX,IAAI,QAAQ,IAAI,MAAM,MAAM,OAAO,QAAQ,OAAO,MAAM;CAC1D;AACF;;AAGA,SAAgB,cAAc,QAAqD;CACjF,OAAO,SAAS,QAAQ,IAAI,MAAM,IAAI,KAAA;AACxC;;;;;;;AAQA,SAAgB,WAAW,QAAyD,KAAsF;CACxK,MAAM,gBAA0B;EAE9B,OAAO,cADU,OAAO,WAAW,aAAa,OAAO,IAAI,MAC9B,CAAC,EAAE,IAAI,WAAW,OAAO,QAAQ,aAAa,IAAI,IAAI,IAAA,CAAK;CAC1F;CACA,MAAM,UAAmB,WAAU,QAAQ,CAAC,CAAC,MAAM;CACnD,OAAO,WAAW,OAAO;EAAE,QAAQ,CAAC,CAAC,UAAU,EAAE;CAAE;CACnD,OAAO;AACT"}

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

@@ -0,0 +1,64 @@
+import { Ability, AbilityRuleSource } from "./schema/abilities.js";
+import { MenuItem } from "./toolbar.js";
+import { Editor } from "@tiptap/core";
+import { Node as Node$1 } from "@tiptap/pm/model";
+//#region src/core/extension-points.d.ts
+/** A block in the document: the node and the position right before it. */
+export interface BlockTarget {
+  node: Node$1;
+  pos: number;
+}
+export interface BlockActionContext extends BlockTarget {
+  editor: Editor;
+  /** Abilities of the block itself (`abilitiesAt(editor, pos, node)`). */
+  abilities: ReadonlySet<Ability>;
+}
+interface BlockActionBase {
+  id: string;
+  /** Tooltip and aria-label. */
+  label: string;
+  /** Iconify name, e.g. `i-lucide-copy`. */
+  icon: string;
+  /** Shown only on blocks that have this ability. */
+  ability: Ability;
+  /** 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. */
+  order?: number;
+}
+/**
+ * An entry of the hover actions shown top-right of a block (`BlockActionsOverlay`); hosts add their own via `blockActions`.
+ * Either `run` on click, or `menu`: a dropdown of the items it returns (hidden when it returns none).
+ */
+export type BlockAction = BlockActionBase & ({
+  run: (ctx: BlockActionContext) => void;
+  menu?: never;
+} | {
+  menu: (ctx: BlockActionContext) => MenuItem[];
+  run?: never;
+});
+/** A row of the `/` menu. */
+export interface SlashCommandItem {
+  /** Typed after `/` (`/ai`); the query matches it or the label as prefix, case-insensitively. */
+  id: string;
+  label: string;
+  /** Iconify name, e.g. `i-lucide-sparkles`. */
+  icon: string;
+  /** Runs once the `/query` text is deleted; the caret is then in the (now empty) textblock. */
+  run: (editor: Editor) => void;
+  /** Listed only where the caret has this ability; always listed when unset. */
+  ability?: Ability;
+}
+export interface AbilitiesOptions {
+  /** Abilities at document root, before any node rule applies. */
+  root: readonly Ability[];
+  /**
+   * Rules per node type name; replace (not merge) the node's own `NodeConfig.abilities`. `configure()` deep-merges into
+   * `DEFAULT_ABILITY_RULES`: other types keep their default rule; for a type with an object default only the fields
+   * given (`grants`/`revokes`/`own`) replace the default's, a function rule replaces it whole.
+   */
+  rules: Record<string, AbilityRuleSource>;
+}
+//#endregion
+export {};
+//# sourceMappingURL=extension-points.d.ts.map

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

@@ -0,0 +1,32 @@
+import { AbilitiesOptions, BlockAction, SlashCommandItem } from "./extension-points.js";
+import { Notifier } from "./notify.js";
+import { EditorContext } from "./context.js";
+import { EditorUi } from "./editor-ui.js";
+import { MetadataRegistry } from "./metadata.js";
+import { CollaborationSession, EditorPreset, FeatureContext, UploadFn } from "./feature.js";
+import { Editor } from "@tiptap/core";
+//#region src/core/feature-context.d.ts
+export interface FeatureContextOptions {
+  app: EditorContext;
+  preset: EditorPreset;
+  ui: EditorUi;
+  metadata: MetadataRegistry;
+  /** The surface's notice renderer (Nuxt UI toast, sonner). */
+  notify: Notifier;
+  getEditor: () => Editor | undefined;
+  documentId?: string;
+  upload?: UploadFn;
+  collaboration?: CollaborationSession;
+  abilities?: Partial<AbilitiesOptions>;
+  /** Host transformer of the `/` menu: receives the features' commands, returns the final list. */
+  slashCommands?: (defaults: SlashCommandItem[]) => SlashCommandItem[];
+}
+/**
+ * The context of one mounted surface (see `FeatureContext`). Resolves the preset's anchor resolver and builds the `/`
+ * menu 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. */
+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

@@ -0,0 +1,46 @@
+import { contributions } from "./define-editor.js";
+//#region src/core/feature-context.ts
+const byOrder = (a, b) => (a.order ?? 0) - (b.order ?? 0);
+/**
+* The context of one mounted surface (see `FeatureContext`). Resolves the preset's anchor resolver and builds the `/`
+* menu lazily (features' commands, then the host's transformer), once. Call it during component setup.
+*/
+function createFeatureContext(options) {
+	const { app, preset } = options;
+	let slash;
+	const ctx = {
+		app,
+		settings: app.settings,
+		metadata: options.metadata,
+		ui: options.ui,
+		notify: options.notify,
+		locale: app.locale,
+		t: app.t,
+		fetch: app.fetch,
+		ai: app.ai,
+		documentId: options.documentId,
+		upload: options.upload,
+		collaboration: options.collaboration,
+		anchorResolver: null,
+		abilities: options.abilities ?? {},
+		slashCommands: () => {
+			if (!slash) {
+				const defaults = contributions(preset, "slashCommands").flatMap((factory) => factory(ctx));
+				slash = options.slashCommands ? options.slashCommands(defaults) : defaults;
+			}
+			return slash;
+		},
+		getEditor: options.getEditor
+	};
+	ctx.anchorResolver = contributions(preset, "anchorResolver")[0]?.(ctx) ?? null;
+	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. */
+function blockActionsOf(preset, ctx, hostActions = []) {
+	return [...contributions(preset, "blockActions").flatMap((factory) => factory(ctx)).sort(byOrder), ...hostActions];
+}
+//#endregion
+export { blockActionsOf, createFeatureContext };
+
+//# sourceMappingURL=feature-context.js.map

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

@@ -0,0 +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 { contributions } from './define-editor'\nimport type { EditorUi } from './editor-ui'\nimport type { AbilitiesOptions, BlockAction, SlashCommandItem } from './extension-points'\nimport type { CollaborationSession, EditorPreset, FeatureContext, UploadFn } from './feature'\nimport type { MetadataRegistry } from './metadata'\nimport type { Notifier } from './notify'\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  upload?: UploadFn\n  collaboration?: CollaborationSession\n  abilities?: Partial<AbilitiesOptions>\n  /** Host transformer of the `/` menu: receives the features' commands, returns the final list. */\n  slashCommands?: (defaults: SlashCommandItem[]) => SlashCommandItem[]\n}\n\nconst byOrder = <T extends { order?: number }>(a: T, b: T) => (a.order ?? 0) - (b.order ?? 0)\n\n/**\n * The context of one mounted surface (see `FeatureContext`). Resolves the preset's anchor resolver and builds the `/`\n * menu 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 slash: SlashCommandItem[] | 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    fetch: app.fetch,\n    ai: app.ai,\n    documentId: options.documentId,\n    upload: options.upload,\n    collaboration: options.collaboration,\n    anchorResolver: null,\n    abilities: options.abilities ?? {},\n    slashCommands: () => {\n      if (!slash) {\n        const defaults = contributions(preset, 'slashCommands').flatMap(factory => factory(ctx))\n        slash = options.slashCommands ? options.slashCommands(defaults) : defaults\n      }\n      return slash\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":";;AAyBA,MAAM,WAAyC,GAAM,OAAU,EAAE,SAAS,MAAM,EAAE,SAAS;;;;;AAM3F,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,OAAO,IAAI;EACX,IAAI,IAAI;EACR,YAAY,QAAQ;EACpB,QAAQ,QAAQ;EAChB,eAAe,QAAQ;EACvB,gBAAgB;EAChB,WAAW,QAAQ,aAAa,CAAC;EACjC,qBAAqB;GACnB,IAAI,CAAC,OAAO;IACV,MAAM,WAAW,cAAc,QAAQ,eAAe,CAAC,CAAC,SAAQ,YAAW,QAAQ,GAAG,CAAC;IACvF,QAAQ,QAAQ,gBAAgB,QAAQ,cAAc,QAAQ,IAAI;GACpE;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"}