@ecsplico/editor 2.1.1 → 3.0.0

package/dist/features/composites/derivation.js

@@ -0,0 +1,98 @@
+import { EDITOR_API } from "../../core/api-routes.js";
+import { compositeKind } from "./kinds.js";
+import { DERIVATION_KEY } from "./meta-keys.js";
+import "./nodes.js";
+//#region src/features/composites/derivation.ts
+/** The derivation of a composite (`meta.derivation` with a `from` object and a `method`); null when it has none. */
+function derivationOf(node) {
+	const meta = node.attrs.meta;
+	const value = meta && typeof meta === "object" ? meta[DERIVATION_KEY] : void 0;
+	if (!value || typeof value !== "object") return null;
+	const { from, method } = value;
+	if (!from || typeof from !== "object" || typeof method !== "string") return null;
+	return value;
+}
+const ASSET_URL_PREFIX = `${EDITOR_API}/assets/`;
+const ASSET_NAME = /^[0-9a-f-]{36}\.[a-z0-9]{1,8}$/;
+const ASSET_DOCUMENT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+/** The stored asset behind an `/api/editor/assets/<documentId>/<name>` URL; null for any other `src`. */
+function assetRefOf(src) {
+	if (!src.startsWith(ASSET_URL_PREFIX)) return null;
+	const [documentId, name, ...rest] = src.slice(ASSET_URL_PREFIX.length).split("/");
+	if (rest.length || !documentId || !name || !ASSET_DOCUMENT_ID.test(documentId) || !ASSET_NAME.test(name)) return null;
+	return {
+		documentId,
+		name
+	};
+}
+/** The media block a source-holding kind keeps its original in: first body child of a type in `kind.source`. */
+function sourceOf(composite, kinds) {
+	if (composite.type.name !== "composite") return null;
+	const types = compositeKind(kinds, String(composite.attrs.kind)).source;
+	if (!types) return null;
+	for (let index = 3; index < composite.childCount; index++) {
+		const node = composite.child(index);
+		if (!types.includes(node.type.name)) continue;
+		const hash = node.attrs.hash;
+		return {
+			node,
+			index,
+			asset: assetRefOf(String(node.attrs.src ?? "")),
+			hash: typeof hash === "string" && hash ? hash : null
+		};
+	}
+	return null;
+}
+/** The body children of `composite` that are derived Bausteine, with their child index. */
+function renditionsOf(composite) {
+	const found = [];
+	composite.forEach((node, _offset, index) => {
+		if (index < 3 || node.type.name !== "composite") return;
+		const derivation = derivationOf(node);
+		if (derivation) found.push({
+			node,
+			index,
+			derivation
+		});
+	});
+	return found;
+}
+/**
+* Whether `derived` (a Baustein with a derivation, a child of `composite`) is out of date or was edited since it was made.
+* `stale`: for an asset source, the block `sourceOf(composite, kinds)` finds has a `hash` that differs from `inputHash`; null
+* when either is unknown. A block source is null here: callers with the document compare the hash of the source block's
+* Markdown. `edited`: the body's
+* hash (computed lazily, it serialises the whole body) differs from `outputHash`; null when `outputHash` is unknown.
+*/
+function derivationState(composite, derived, bodyHash, kinds) {
+	const derivation = derivationOf(derived);
+	if (!derivation) return {
+		stale: null,
+		edited: null
+	};
+	let stale = null;
+	if ("asset" in derivation.from) {
+		const hash = sourceOf(composite, kinds)?.hash;
+		stale = hash && derivation.inputHash ? hash !== derivation.inputHash : null;
+	}
+	const edited = derivation.outputHash ? bodyHash() !== derivation.outputHash : null;
+	return {
+		stale,
+		edited
+	};
+}
+/** Markdown of the body of `composite` (everything after title, description and tags). */
+function bodyMarkdown(editor, composite) {
+	const content = [];
+	composite.forEach((child, _offset, index) => {
+		if (index >= 3) content.push(child.toJSON());
+	});
+	return editor.markdown.serialize({
+		type: "doc",
+		content
+	});
+}
+//#endregion
+export { DERIVATION_KEY, assetRefOf, bodyMarkdown, derivationOf, derivationState, renditionsOf, sourceOf };
+
+//# sourceMappingURL=derivation.js.map

package/dist/features/composites/derivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.js","names":[],"sources":["../../../src/features/composites/derivation.ts"],"sourcesContent":["// Vue-free and server-importable: where a Baustein's content comes from. A source-holding Baustein (`recording`, `paper`,\n// `book`, `figure`, `document`) carries its original as an `image|audio|video|file` block in the body; a derived\n// Baustein (transcript, full text, description, AI result) records in `meta.derivation` what it was made from.\nimport type { Editor, JSONContent } from '@tiptap/core'\n// Types only: brings in the `editor.markdown` augmentation of `@tiptap/markdown` for contexts that do not otherwise load it.\nimport type {} from '@tiptap/markdown'\nimport type { Node as PMNode } from '@tiptap/pm/model'\nimport { EDITOR_API } from '../../core/api-routes'\nimport { type CompositeKind, compositeKind } from './kinds'\nimport { COMPOSITE_CHROME_COUNT } from './nodes'\nimport { DERIVATION_KEY } from './meta-keys'\n\n/** How a derived Baustein was made; `ai:<kindId>` for a block derived from another block by the model. */\nexport type DerivationMethod = 'transcription' | 'pdf-text' | 'ocr' | 'description' | 'bibliography' | (string & {})\n\n/** What a derived Baustein was made from: an uploaded asset (by asset name) or another block (by block id). */\nexport type DerivationSource = { asset: string } | { block: string }\n\n/** `meta.derivation` of a derived Baustein. */\nexport interface Derivation {\n  from: DerivationSource\n  method: DerivationMethod\n  model?: string\n  /** ISO timestamp. */\n  createdAt: string\n  /** SHA-256 hex of the asset bytes / of the source block's Markdown; `''` when unknown. */\n  inputHash: string\n  /** SHA-256 hex of the produced body's Markdown; `''` when unknown. */\n  outputHash: string\n  /** Asset name of the stored raw output (text/markdown). */\n  output?: string\n}\n\nexport { DERIVATION_KEY }\n\n/** The derivation of a composite (`meta.derivation` with a `from` object and a `method`); null when it has none. */\nexport function derivationOf(node: PMNode): Derivation | null {\n  const meta: unknown = node.attrs.meta\n  const value = meta && typeof meta === 'object' ? (meta as Record<string, unknown>)[DERIVATION_KEY] : undefined\n  if (!value || typeof value !== 'object') return null\n  const { from, method } = value as Record<string, unknown>\n  if (!from || typeof from !== 'object' || typeof method !== 'string') return null\n  return value as Derivation\n}\n\nconst ASSET_URL_PREFIX = `${EDITOR_API}/assets/`\n// Same patterns as `features/media/assets.ts`; copied because composites must not import media.\nconst ASSET_NAME = /^[0-9a-f-]{36}\\.[a-z0-9]{1,8}$/\nconst ASSET_DOCUMENT_ID = /^[A-Za-z0-9_-]{1,64}$/\n\n/** The stored asset behind an `/api/editor/assets/<documentId>/<name>` URL; null for any other `src`. */\nexport function assetRefOf(src: string): { documentId: string, name: string } | null {\n  if (!src.startsWith(ASSET_URL_PREFIX)) return null\n  const [documentId, name, ...rest] = src.slice(ASSET_URL_PREFIX.length).split('/')\n  if (rest.length || !documentId || !name || !ASSET_DOCUMENT_ID.test(documentId) || !ASSET_NAME.test(name)) return null\n  return { documentId, name }\n}\n\n/** The media block a source-holding kind keeps its original in: first body child of a type in `kind.source`. */\nexport function sourceOf(\n  composite: PMNode,\n  kinds: readonly CompositeKind[],\n): { node: PMNode, index: number, asset: { documentId: string, name: string } | null, hash: string | null } | null {\n  if (composite.type.name !== 'composite') return null\n  const types = compositeKind(kinds, String(composite.attrs.kind)).source\n  if (!types) return null\n  for (let index = COMPOSITE_CHROME_COUNT; index < composite.childCount; index++) {\n    const node = composite.child(index)\n    if (!(types as readonly string[]).includes(node.type.name)) continue\n    const hash: unknown = node.attrs.hash\n    return { node, index, asset: assetRefOf(String(node.attrs.src ?? '')), hash: typeof hash === 'string' && hash ? hash : null }\n  }\n  return null\n}\n\n/** The body children of `composite` that are derived Bausteine, with their child index. */\nexport function renditionsOf(composite: PMNode): { node: PMNode, index: number, derivation: Derivation }[] {\n  const found: { node: PMNode, index: number, derivation: Derivation }[] = []\n  composite.forEach((node, _offset, index) => {\n    if (index < COMPOSITE_CHROME_COUNT || node.type.name !== 'composite') return\n    const derivation = derivationOf(node)\n    if (derivation) found.push({ node, index, derivation })\n  })\n  return found\n}\n\n/**\n * Whether `derived` (a Baustein with a derivation, a child of `composite`) is out of date or was edited since it was made.\n * `stale`: for an asset source, the block `sourceOf(composite, kinds)` finds has a `hash` that differs from `inputHash`; null\n * when either is unknown. A block source is null here: callers with the document compare the hash of the source block's\n * Markdown. `edited`: the body's\n * hash (computed lazily, it serialises the whole body) differs from `outputHash`; null when `outputHash` is unknown.\n */\nexport function derivationState(\n  composite: PMNode,\n  derived: PMNode,\n  bodyHash: () => string,\n  kinds: readonly CompositeKind[],\n): { stale: boolean | null, edited: boolean | null } {\n  const derivation = derivationOf(derived)\n  if (!derivation) return { stale: null, edited: null }\n  let stale: boolean | null = null\n  if ('asset' in derivation.from) {\n    const hash = sourceOf(composite, kinds)?.hash\n    stale = hash && derivation.inputHash ? hash !== derivation.inputHash : null\n  }\n  const edited = derivation.outputHash ? bodyHash() !== derivation.outputHash : null\n  return { stale, edited }\n}\n\n/** Markdown of the body of `composite` (everything after title, description and tags). */\nexport function bodyMarkdown(editor: Editor, composite: PMNode): string {\n  const content: JSONContent[] = []\n  composite.forEach((child, _offset, index) => {\n    if (index >= COMPOSITE_CHROME_COUNT) content.push(child.toJSON() as JSONContent)\n  })\n  return editor.markdown!.serialize({ type: 'doc', content })\n}\n"],"mappings":";;;;;;AAoCA,SAAgB,aAAa,MAAiC;CAC5D,MAAM,OAAgB,KAAK,MAAM;CACjC,MAAM,QAAQ,QAAQ,OAAO,SAAS,WAAY,KAAiC,kBAAkB,KAAA;CACrG,IAAI,CAAC,SAAS,OAAO,UAAU,UAAU,OAAO;CAChD,MAAM,EAAE,MAAM,WAAW;CACzB,IAAI,CAAC,QAAQ,OAAO,SAAS,YAAY,OAAO,WAAW,UAAU,OAAO;CAC5E,OAAO;AACT;AAEA,MAAM,mBAAmB,GAAG,WAAW;AAEvC,MAAM,aAAa;AACnB,MAAM,oBAAoB;;AAG1B,SAAgB,WAAW,KAA0D;CACnF,IAAI,CAAC,IAAI,WAAW,gBAAgB,GAAG,OAAO;CAC9C,MAAM,CAAC,YAAY,MAAM,GAAG,QAAQ,IAAI,MAAM,iBAAiB,MAAM,CAAC,CAAC,MAAM,GAAG;CAChF,IAAI,KAAK,UAAU,CAAC,cAAc,CAAC,QAAQ,CAAC,kBAAkB,KAAK,UAAU,KAAK,CAAC,WAAW,KAAK,IAAI,GAAG,OAAO;CACjH,OAAO;EAAE;EAAY;CAAK;AAC5B;;AAGA,SAAgB,SACd,WACA,OACiH;CACjH,IAAI,UAAU,KAAK,SAAS,aAAa,OAAO;CAChD,MAAM,QAAQ,cAAc,OAAO,OAAO,UAAU,MAAM,IAAI,CAAC,CAAC,CAAC;CACjE,IAAI,CAAC,OAAO,OAAO;CACnB,KAAK,IAAI,QAAA,GAAgC,QAAQ,UAAU,YAAY,SAAS;EAC9E,MAAM,OAAO,UAAU,MAAM,KAAK;EAClC,IAAI,CAAE,MAA4B,SAAS,KAAK,KAAK,IAAI,GAAG;EAC5D,MAAM,OAAgB,KAAK,MAAM;EACjC,OAAO;GAAE;GAAM;GAAO,OAAO,WAAW,OAAO,KAAK,MAAM,OAAO,EAAE,CAAC;GAAG,MAAM,OAAO,SAAS,YAAY,OAAO,OAAO;EAAK;CAC9H;CACA,OAAO;AACT;;AAGA,SAAgB,aAAa,WAA8E;CACzG,MAAM,QAAmE,CAAC;CAC1E,UAAU,SAAS,MAAM,SAAS,UAAU;EAC1C,IAAI,QAAA,KAAkC,KAAK,KAAK,SAAS,aAAa;EACtE,MAAM,aAAa,aAAa,IAAI;EACpC,IAAI,YAAY,MAAM,KAAK;GAAE;GAAM;GAAO;EAAW,CAAC;CACxD,CAAC;CACD,OAAO;AACT;;;;;;;;AASA,SAAgB,gBACd,WACA,SACA,UACA,OACmD;CACnD,MAAM,aAAa,aAAa,OAAO;CACvC,IAAI,CAAC,YAAY,OAAO;EAAE,OAAO;EAAM,QAAQ;CAAK;CACpD,IAAI,QAAwB;CAC5B,IAAI,WAAW,WAAW,MAAM;EAC9B,MAAM,OAAO,SAAS,WAAW,KAAK,CAAC,EAAE;EACzC,QAAQ,QAAQ,WAAW,YAAY,SAAS,WAAW,YAAY;CACzE;CACA,MAAM,SAAS,WAAW,aAAa,SAAS,MAAM,WAAW,aAAa;CAC9E,OAAO;EAAE;EAAO;CAAO;AACzB;;AAGA,SAAgB,aAAa,QAAgB,WAA2B;CACtE,MAAM,UAAyB,CAAC;CAChC,UAAU,SAAS,OAAO,SAAS,UAAU;EAC3C,IAAI,SAAA,GAAiC,QAAQ,KAAK,MAAM,OAAO,CAAgB;CACjF,CAAC;CACD,OAAO,OAAO,SAAU,UAAU;EAAE,MAAM;EAAO;CAAQ,CAAC;AAC5D"}

package/dist/features/composites/derived-chrome.js

@@ -0,0 +1,69 @@
+import { findBlockById } from "../../core/schema/block-ids.js";
+import { EDITOR_API } from "../../core/api-routes.js";
+import { sha256Hex } from "../../core/hash.js";
+import { bodyMarkdown, derivationOf, derivationState, sourceOf } from "./derivation.js";
+import { compositeKindsOf } from "./nodes.js";
+import { compositeOfRow } from "./rows.js";
+//#region src/features/composites/derived-chrome.ts
+/**
+* The chrome state of the row's Baustein when it is derived (null when it is not): `stale` when its asset source has
+* changed since it was made, i.e. the enclosing Baustein's source block hash differs from the stored `inputHash`.
+* Cheap on purpose (no body hashing): the chrome runs it for every row on every refresh. „bearbeitet“ and the staleness
+* of a block-derived Baustein hash Markdown, so only the details card computes them (`derivationDetailsOf`).
+*/
+function derivedChromeOf(editor, row) {
+	const { doc } = editor.state;
+	const at = doc.nodeAt(row.pos);
+	const found = at?.type.name === "composite" && (at.attrs.id ?? null) === row.id ? {
+		pos: row.pos,
+		node: at
+	} : compositeOfRow(doc, row);
+	if (!found || !derivationOf(found.node)) return null;
+	const parent = doc.resolve(found.pos).parent;
+	return { stale: parent.type.name === "composite" && derivationState(parent, found.node, () => "", compositeKindsOf(editor)).stale === true };
+}
+/**
+* Details of the derived Baustein `node` of `editor`'s document (null when it is not derived). Serialises and hashes
+* the body (and for a block source the source block), so call it for one Baustein at a time, not for every row.
+*/
+function derivationDetailsOf(editor, node) {
+	const derivation = derivationOf(node);
+	if (!derivation) return null;
+	const { doc } = editor.state;
+	const kinds = compositeKindsOf(editor);
+	const id = node.attrs.id;
+	const found = typeof id === "string" && id ? findBlockById(doc, id) : null;
+	const parent = found ? doc.resolve(found.pos).parent : null;
+	const holder = parent?.type.name === "composite" ? parent : null;
+	let bodyHash;
+	const state = derivationState(holder ?? node, node, () => bodyHash ??= sha256Hex(bodyMarkdown(editor, node)), kinds);
+	let stale = state.stale;
+	if ("block" in derivation.from) {
+		const source = findBlockById(doc, derivation.from.block);
+		stale = source && derivation.inputHash ? sha256Hex(bodyMarkdown(editor, source.node)) !== derivation.inputHash : null;
+	}
+	const documentId = holder ? sourceOf(holder, kinds)?.asset?.documentId : void 0;
+	const outputUrl = derivation.output && documentId ? `${EDITOR_API}/assets/${documentId}/${derivation.output}` : null;
+	return {
+		derivation,
+		stale,
+		edited: state.edited,
+		outputUrl
+	};
+}
+const KNOWN_METHODS = [
+	"transcription",
+	"pdf-text",
+	"ocr",
+	"description",
+	"bibliography"
+];
+/** The words for a derivation method: the known ones translated, `ai:<kind>` as „KI-Ableitung“, anything else as stored. */
+function derivationMethodLabel(t, method) {
+	if (method.startsWith("ai:")) return t("composites.derivation.method.ai");
+	return KNOWN_METHODS.includes(method) ? t(`composites.derivation.method.${method}`) : method;
+}
+//#endregion
+export { derivationDetailsOf, derivationMethodLabel, derivedChromeOf };
+
+//# sourceMappingURL=derived-chrome.js.map

package/dist/features/composites/derived-chrome.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived-chrome.js","names":[],"sources":["../../../src/features/composites/derived-chrome.ts"],"sourcesContent":["// Vue-free: what the composite chrome and the details card show for a derived Baustein (one with a `meta.derivation`).\nimport type { Editor } from '@tiptap/core'\nimport type { Node as PMNode } from '@tiptap/pm/model'\nimport { EDITOR_API } from '../../core/api-routes'\nimport { sha256Hex } from '../../core/hash'\nimport { findBlockById } from '../../core/schema/block-ids'\nimport type { MessageKey, Translate } from '../../i18n'\nimport { type Derivation, bodyMarkdown, derivationOf, derivationState, sourceOf } from './derivation'\nimport { compositeKindsOf } from './nodes'\nimport { type CompositeRow, compositeOfRow } from './rows'\n\n/**\n * The chrome state of the row's Baustein when it is derived (null when it is not): `stale` when its asset source has\n * changed since it was made, i.e. the enclosing Baustein's source block hash differs from the stored `inputHash`.\n * Cheap on purpose (no body hashing): the chrome runs it for every row on every refresh. „bearbeitet“ and the staleness\n * of a block-derived Baustein hash Markdown, so only the details card computes them (`derivationDetailsOf`).\n */\nexport function derivedChromeOf(editor: Editor, row: Pick<CompositeRow, 'id' | 'pos'>): { stale: boolean } | null {\n  const { doc } = editor.state\n  // The row's position may be stale for a moment after an edit; take it only when it still holds the same Baustein.\n  const at = doc.nodeAt(row.pos)\n  const found = at?.type.name === 'composite' && (at.attrs.id ?? null) === row.id ? { pos: row.pos, node: at } : compositeOfRow(doc, row)\n  if (!found || !derivationOf(found.node)) return null\n  const parent = doc.resolve(found.pos).parent\n  const stale = parent.type.name === 'composite' && derivationState(parent, found.node, () => '', compositeKindsOf(editor)).stale === true\n  return { stale }\n}\n\n/** Everything the details card shows about the derivation of `node`; `stale`/`edited` are null when they cannot be told. */\nexport interface DerivationDetails {\n  derivation: Derivation\n  /** The source changed since `node` was made: asset hash for an asset source, Markdown hash of the source block for a block source. */\n  stale: boolean | null\n  /** The body differs from what was generated. */\n  edited: boolean | null\n  /** URL of the stored raw output, when there is one and its document is known. */\n  outputUrl: string | null\n}\n\n/**\n * Details of the derived Baustein `node` of `editor`'s document (null when it is not derived). Serialises and hashes\n * the body (and for a block source the source block), so call it for one Baustein at a time, not for every row.\n */\nexport function derivationDetailsOf(editor: Editor, node: PMNode): DerivationDetails | null {\n  const derivation = derivationOf(node)\n  if (!derivation) return null\n  const { doc } = editor.state\n  const kinds = compositeKindsOf(editor)\n  const id: unknown = node.attrs.id\n  const found = typeof id === 'string' && id ? findBlockById(doc, id) : null\n  const parent = found ? doc.resolve(found.pos).parent : null\n  const holder = parent?.type.name === 'composite' ? parent : null\n\n  let bodyHash: string | undefined\n  const state = derivationState(holder ?? node, node, () => (bodyHash ??= sha256Hex(bodyMarkdown(editor, node))), kinds)\n  let stale = state.stale\n  if ('block' in derivation.from) {\n    const source = findBlockById(doc, derivation.from.block)\n    stale = source && derivation.inputHash ? sha256Hex(bodyMarkdown(editor, source.node)) !== derivation.inputHash : null\n  }\n\n  const documentId = holder ? sourceOf(holder, kinds)?.asset?.documentId : undefined\n  const outputUrl = derivation.output && documentId ? `${EDITOR_API}/assets/${documentId}/${derivation.output}` : null\n  return { derivation, stale, edited: state.edited, outputUrl }\n}\n\nconst KNOWN_METHODS: readonly string[] = ['transcription', 'pdf-text', 'ocr', 'description', 'bibliography']\n\n/** The words for a derivation method: the known ones translated, `ai:<kind>` as „KI-Ableitung“, anything else as stored. */\nexport function derivationMethodLabel(t: Translate, method: string): string {\n  if (method.startsWith('ai:')) return t('composites.derivation.method.ai')\n  return KNOWN_METHODS.includes(method) ? t(`composites.derivation.method.${method}` as MessageKey) : method\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,gBAAgB,QAAgB,KAAkE;CAChH,MAAM,EAAE,QAAQ,OAAO;CAEvB,MAAM,KAAK,IAAI,OAAO,IAAI,GAAG;CAC7B,MAAM,QAAQ,IAAI,KAAK,SAAS,gBAAgB,GAAG,MAAM,MAAM,UAAU,IAAI,KAAK;EAAE,KAAK,IAAI;EAAK,MAAM;CAAG,IAAI,eAAe,KAAK,GAAG;CACtI,IAAI,CAAC,SAAS,CAAC,aAAa,MAAM,IAAI,GAAG,OAAO;CAChD,MAAM,SAAS,IAAI,QAAQ,MAAM,GAAG,CAAC,CAAC;CAEtC,OAAO,EAAE,OADK,OAAO,KAAK,SAAS,eAAe,gBAAgB,QAAQ,MAAM,YAAY,IAAI,iBAAiB,MAAM,CAAC,CAAC,CAAC,UAAU,KACrH;AACjB;;;;;AAiBA,SAAgB,oBAAoB,QAAgB,MAAwC;CAC1F,MAAM,aAAa,aAAa,IAAI;CACpC,IAAI,CAAC,YAAY,OAAO;CACxB,MAAM,EAAE,QAAQ,OAAO;CACvB,MAAM,QAAQ,iBAAiB,MAAM;CACrC,MAAM,KAAc,KAAK,MAAM;CAC/B,MAAM,QAAQ,OAAO,OAAO,YAAY,KAAK,cAAc,KAAK,EAAE,IAAI;CACtE,MAAM,SAAS,QAAQ,IAAI,QAAQ,MAAM,GAAG,CAAC,CAAC,SAAS;CACvD,MAAM,SAAS,QAAQ,KAAK,SAAS,cAAc,SAAS;CAE5D,IAAI;CACJ,MAAM,QAAQ,gBAAgB,UAAU,MAAM,YAAa,aAAa,UAAU,aAAa,QAAQ,IAAI,CAAC,GAAI,KAAK;CACrH,IAAI,QAAQ,MAAM;CAClB,IAAI,WAAW,WAAW,MAAM;EAC9B,MAAM,SAAS,cAAc,KAAK,WAAW,KAAK,KAAK;EACvD,QAAQ,UAAU,WAAW,YAAY,UAAU,aAAa,QAAQ,OAAO,IAAI,CAAC,MAAM,WAAW,YAAY;CACnH;CAEA,MAAM,aAAa,SAAS,SAAS,QAAQ,KAAK,CAAC,EAAE,OAAO,aAAa,KAAA;CACzE,MAAM,YAAY,WAAW,UAAU,aAAa,GAAG,WAAW,UAAU,WAAW,GAAG,WAAW,WAAW;CAChH,OAAO;EAAE;EAAY;EAAO,QAAQ,MAAM;EAAQ;CAAU;AAC9D;AAEA,MAAM,gBAAmC;CAAC;CAAiB;CAAY;CAAO;CAAe;AAAc;;AAG3G,SAAgB,sBAAsB,GAAc,QAAwB;CAC1E,IAAI,OAAO,WAAW,KAAK,GAAG,OAAO,EAAE,iCAAiC;CACxE,OAAO,cAAc,SAAS,MAAM,IAAI,EAAE,gCAAgC,QAAsB,IAAI;AACtG"}

package/dist/features/composites/feature.js

@@ -1,17 +1,25 @@
 import { ABILITY } from "../../core/schema/abilities.js";
 import { abilitiesAtSelection } from "../../core/abilities.js";
 import { settingsTabsOf } from "../../core/define-editor.js";
-import { downloadText } from "../../core/download.js";
 import { editorEntryOf } from "../../core/editor-ui.js";
+import { findBlockById } from "../../core/schema/block-ids.js";
+import { downloadText } from "../../core/download.js";
 import { compositeKind, defaultCompositeKinds } from "./kinds.js";
 import { blocksFromMarkdown } from "./fences.js";
+import { bodyMarkdown, derivationOf } from "./derivation.js";
 import { structureBlocks } from "./heading-composites.js";
 import { CompositeDescriptionNode, CompositeTitleNode, compositeKindsOf } from "./nodes.js";
+import { bibOf, bibtexOf, cslOf } from "./bibliography.js";
 import { compositeConversions } from "./convert.js";
 import { migrateLegacyContent } from "./legacy.js";
-import { AcceptedChildren } from "./accepted-children.js";
+import { compositeIdsOf, normalizeReferences } from "./reference-text.js";
+import { compositeSchemaExtensions } from "./schema.js";
+import { AcceptedChildren, compositeInsertGuard } from "./accepted-children.js";
 import { documentCompositeMarkdown, markdownFileName } from "./markdown-export.js";
 import { compositeNodes } from "./node-views.js";
+import { REFERENCE_AI_BLOCK } from "./reference-ai.js";
+import { referenceSuggestion } from "./reference-suggestion.js";
+import { SourceReveal } from "./reveal-source.js";
 import { Structure, structureOf } from "./structure.js";
 import { STRUCTURE_MODE_KEYS } from "./structure-mode.js";
 //#region src/features/composites/feature.ts
@@ -28,9 +36,11 @@ const STRUCTURE_STAGE_LEVEL = 2;
 */
 function compositeFeatureCore(ui, options = {}) {
 	const kindsOf = (ctx) => options.kinds ?? defaultCompositeKinds(ctx.t);
-	const { Composite, CompositeTags } = compositeNodes(ui.nodeViews);
+	const { Composite, CompositeTags, Reference } = compositeNodes(ui.nodeViews);
 	return {
 		id: "composites",
+		dimension: "content",
+		schemaExtensions: () => compositeSchemaExtensions(options.kinds ? { kinds: options.kinds } : {}),
 		extensions: (ctx) => [
 			Composite.configure({ kinds: kindsOf(ctx) }),
 			CompositeTitleNode,
@@ -40,14 +50,13 @@ function compositeFeatureCore(ui, options = {}) {
 			AcceptedChildren.configure({
 				notify: ctx.notify,
 				t: ctx.t
-			})
+			}),
+			SourceReveal,
+			Reference.configure({ suggestion: referenceSuggestion(ctx.t) })
 		],
-		toolbar: (ctx) => [{
-			id: "composites",
-			order: 60,
-			items: compositeToolbarItems(ctx, kindsOf(ctx))
-		}],
-		slashCommands: (ctx) => compositeSlashCommands(ctx, kindsOf(ctx)),
+		toolbarGroups: COMPOSITE_TOOLBAR_GROUPS,
+		commands: (ctx) => compositeCommands(ctx, kindsOf(ctx)),
+		insertGuards: () => [compositeInsertGuard],
 		blockActions: (ctx) => [{
 			id: "document-export",
 			label: ctx.t("composites.blockAction.export"),
@@ -56,6 +65,14 @@ function compositeFeatureCore(ui, options = {}) {
 			order: 400,
 			isVisible: ({ node }) => node.attrs.kind === "document",
 			run: ({ editor, node }) => downloadText(markdownFileName(node), documentCompositeMarkdown(editor, node))
+		}, {
+			id: "bibliography-export",
+			label: ctx.t("composites.blockAction.bibtex"),
+			icon: "i-lucide-book-marked",
+			ability: ABILITY.compositeExport,
+			order: 410,
+			isVisible: ({ node }) => bibOf(node) !== null,
+			run: ({ node }) => downloadText(`${markdownFileName(node).replace(/\.md$/, "")}.bib`, bibtexOf(cslOf(node)), "text/x-bibtex;charset=utf-8")
 		}],
 		overlays: [ui.chrome],
 		settingsTabs: (ctx) => [{
@@ -71,7 +88,8 @@ function compositeFeatureCore(ui, options = {}) {
 				const { schema } = editor;
 				return structureBlocks(schema, blocks.map((block) => schema.nodeFromJSON(block)), structureOf(editor), STRUCTURE_STAGE_LEVEL, compositeKindsOf(editor)).map((node) => node.toJSON());
 			},
-			migrateContent: migrateLegacyContent
+			migrateContent: migrateLegacyContent,
+			normalize: (editor, blocks) => normalizeReferences(blocks, compositeIdsOf(editor.state.doc))
 		},
 		conversions: compositeConversions(options.kinds),
 		aiContext: (editor) => ({
@@ -81,87 +99,57 @@ function compositeFeatureCore(ui, options = {}) {
 				fields,
 				...ai?.purpose && { purpose: ai.purpose }
 			})),
-			structure: structureOf(editor)
-		})
-	};
-}
-function compositeSlashCommands({ settings, t }, kinds) {
-	const insert = (kind) => (editor) => editor.commands.insertComposite(kind);
-	const group = (recursive) => (editor) => {
-		const { editing, blocks } = settings.get();
-		return editor.commands.convertHeadingsToComposites({
-			recursive,
-			scope: editing.headingConversionScope,
-			kind: blocks.defaultKind
-		});
-	};
-	const flatten = (recursive) => (editor) => editor.commands.convertCompositesToHeadings({
-		recursive,
-		scope: settings.get().editing.headingConversionScope
-	});
-	return [
-		{
-			id: "abschnitt",
-			label: t("composites.slash.section"),
-			icon: "i-lucide-layers",
-			ability: ABILITY.composite,
-			run: insert("section")
-		},
-		...kinds.filter((kind) => kind.id !== "section").map((kind) => ({
-			id: kind.id,
-			label: kind.label,
-			icon: kind.icon,
-			ability: ABILITY.composite,
-			run: insert(kind.id)
-		})),
-		{
-			id: "gliedern",
-			label: t("composites.slash.group"),
-			icon: "i-lucide-layers",
-			ability: ABILITY.composite,
-			run: group(false)
-		},
-		{
-			id: "gliedern-alle",
-			label: t("composites.slash.groupAll"),
-			icon: "i-lucide-list-tree",
-			ability: ABILITY.composite,
-			run: group(true)
-		},
-		{
-			id: "aufloesen",
-			label: t("composites.slash.flatten"),
-			icon: "i-lucide-heading",
-			ability: ABILITY.headings,
-			run: flatten(false)
-		},
-		{
-			id: "aufloesen-alle",
-			label: t("composites.slash.flattenAll"),
-			icon: "i-lucide-align-left",
-			ability: ABILITY.headings,
-			run: flatten(true)
+			structure: structureOf(editor),
+			blocks: [REFERENCE_AI_BLOCK]
+		}),
+		aiBlockData: ({ editor, node }) => {
+			const from = derivationOf(node)?.from;
+			const source = from && "block" in from ? findBlockById(editor.state.doc, from.block)?.node : void 0;
+			return source?.type.name === "composite" ? [{
+				label: `Quelle: ${source.child(0).textContent.trim()}`,
+				text: bodyMarkdown(editor, source)
+			}] : [];
 		}
-	];
+	};
 }
+const COMPOSITE_TOOLBAR_GROUPS = [{
+	id: "composites",
+	order: 60,
+	labelKey: "palette.group.composites"
+}];
 /**
-* The toolbar group beside the inserts: the default kind's insert button (it follows the setting, so label/icon/shortcut
-* are getters read at render time), „In Baustein umwandeln“ (one entry per kind for the caret's block) and „Gliederung
-* umwandeln“ (headings <-> composites in both directions, the preferred structure's direction first).
+* Converting headings to Bausteine and back: the checks and actions the toolbar's „Gliederung umwandeln“ menu and the
+* `/gliedern*` and `/aufloesen*` commands share, so both placements gate and act identically. They read the scope and
+* default kind from the settings at call time.
 */
-function compositeToolbarItems({ settings, t }, kinds) {
-	const defaultKind = () => compositeKind(kinds, settings.get().blocks.defaultKind);
-	const insert = (chain) => chain.insertComposite(defaultKind().id);
-	const scope = () => settings.get().editing.headingConversionScope;
-	const canGroup = (editor, recursive) => editor.can().convertHeadingsToComposites({
+function structureActions({ settings }) {
+	const groupOptions = (recursive) => ({
 		recursive,
-		scope: scope(),
+		scope: settings.get().editing.headingConversionScope,
 		kind: settings.get().blocks.defaultKind
 	});
-	const canFlatten = (editor, recursive) => editor.can().convertCompositesToHeadings({
+	const flattenOptions = (recursive) => ({
 		recursive,
-		scope: scope()
+		scope: settings.get().editing.headingConversionScope
 	});
+	return {
+		canGroup: (editor, recursive) => editor.can().convertHeadingsToComposites(groupOptions(recursive)),
+		canFlatten: (editor, recursive) => editor.can().convertCompositesToHeadings(flattenOptions(recursive)),
+		group: (editor, recursive) => void editor.chain().focus().convertHeadingsToComposites(groupOptions(recursive)).run(),
+		flatten: (editor, recursive) => void editor.chain().focus().convertCompositesToHeadings(flattenOptions(recursive)).run()
+	};
+}
+/**
+* The commands of the composites feature, each declared once. Toolbar group beside the inserts: the default kind's
+* insert button (it follows the setting, so label/icon/shortcut/`creates` are getters read at render time), „In
+* Baustein umwandeln“ (one entry per kind for the caret's block) and „Gliederung umwandeln“ (headings <-> composites in
+* both directions, the preferred structure's direction first). `/` menu: one command per kind (`creates` that kind, so
+* the insert guard hides kinds the surrounding Baustein does not accept) and the four heading conversions.
+*/
+function compositeCommands(ctx, kinds) {
+	const { settings, t } = ctx;
+	const defaultKind = () => compositeKind(kinds, settings.get().blocks.defaultKind);
+	const { canGroup, canFlatten, group, flatten } = structureActions(ctx);
 	function kindItems(editor) {
 		return [{
 			type: "label",
@@ -184,7 +172,6 @@ function compositeToolbarItems({ settings, t }, kinds) {
 		const abilities = abilitiesAtSelection(editor);
 		const composite = abilities.has(ABILITY.composite);
 		const headings = abilities.has(ABILITY.headings);
-		const run = (command) => () => void command();
 		const sep = { type: "separator" };
 		const toComposites = [
 			{
@@ -196,22 +183,14 @@ function compositeToolbarItems({ settings, t }, kinds) {
 				description: t("composites.menu.toComposites.top.description"),
 				icon: "i-lucide-layers",
 				disabled: !composite || !canGroup(editor, false),
-				onSelect: run(() => editor.chain().focus().convertHeadingsToComposites({
-					recursive: false,
-					scope: scope(),
-					kind: settings.get().blocks.defaultKind
-				}).run())
+				onSelect: () => group(editor, false)
 			},
 			{
 				label: t("composites.menu.toComposites.all"),
 				description: t("composites.menu.toComposites.all.description"),
 				icon: "i-lucide-list-tree",
 				disabled: !composite || !canGroup(editor, true),
-				onSelect: run(() => editor.chain().focus().convertHeadingsToComposites({
-					recursive: true,
-					scope: scope(),
-					kind: settings.get().blocks.defaultKind
-				}).run())
+				onSelect: () => group(editor, true)
 			}
 		];
 		const toHeadings = [
@@ -224,20 +203,14 @@ function compositeToolbarItems({ settings, t }, kinds) {
 				description: t("composites.menu.toHeadings.top.description"),
 				icon: "i-lucide-heading",
 				disabled: !headings || !canFlatten(editor, false),
-				onSelect: run(() => editor.chain().focus().convertCompositesToHeadings({
-					recursive: false,
-					scope: scope()
-				}).run())
+				onSelect: () => flatten(editor, false)
 			},
 			{
 				label: t("composites.menu.toHeadings.all"),
 				description: t("composites.menu.toHeadings.all.description"),
 				icon: "i-lucide-align-left",
 				disabled: !headings || !canFlatten(editor, true),
-				onSelect: run(() => editor.chain().focus().convertCompositesToHeadings({
-					recursive: true,
-					scope: scope()
-				}).run())
+				onSelect: () => flatten(editor, true)
 			}
 		];
 		const entry = editorEntryOf(editor);
@@ -263,10 +236,27 @@ function compositeToolbarItems({ settings, t }, kinds) {
 			...settingsEntry
 		];
 	}
+	const insertKind = (kind, slashId, label, icon) => ({
+		id: `composite.${kind}`,
+		slash: { id: slashId },
+		creates: {
+			type: "composite",
+			attrs: { kind }
+		},
+		icon,
+		label,
+		ability: ABILITY.composite,
+		run: (editor) => {
+			editor.chain().focus().insertComposite(kind).run();
+		}
+	});
 	return [
 		{
 			id: "insert",
-			order: 10,
+			toolbar: {
+				group: "composites",
+				order: 10
+			},
 			get icon() {
 				return defaultKind().icon;
 			},
@@ -280,28 +270,88 @@ function compositeToolbarItems({ settings, t }, kinds) {
 					"a"
 				] : void 0;
 			},
+			get creates() {
+				return {
+					type: "composite",
+					attrs: { kind: defaultKind().id }
+				};
+			},
 			ability: ABILITY.composite,
-			disabled: (editor) => !insert(editor.can().chain()).run(),
+			can: (editor) => editor.can().insertComposite(defaultKind().id),
 			run: (editor) => {
-				insert(editor.chain().focus()).run();
+				editor.chain().focus().insertComposite(defaultKind().id).run();
 			}
 		},
 		{
 			id: "to-kind",
-			order: 20,
+			toolbar: {
+				group: "composites",
+				order: 20
+			},
 			icon: "i-lucide-replace",
 			label: t("composites.toolbar.toKind"),
 			ability: ABILITY.composite,
-			disabled: (editor) => kindItems(editor).every((item) => item.type === "label" || item.disabled),
+			can: (editor) => kindItems(editor).some((item) => item.type !== "label" && !item.disabled),
 			menu: kindItems
 		},
 		{
 			id: "structure",
-			order: 30,
+			toolbar: {
+				group: "composites",
+				order: 30
+			},
 			icon: "i-lucide-list-tree",
 			label: t("composites.toolbar.structure"),
-			disabled: (editor) => !canGroup(editor, true) && !canFlatten(editor, true),
+			can: (editor) => canGroup(editor, true) || canFlatten(editor, true),
 			menu: structureItems
+		},
+		insertKind("section", "abschnitt", t("composites.slash.section"), "i-lucide-layers"),
+		...kinds.filter((kind) => kind.id !== "section").map((kind) => insertKind(kind.id, kind.id, kind.label, kind.icon)),
+		{
+			id: "gliedern",
+			slash: {},
+			label: t("composites.slash.group"),
+			icon: "i-lucide-layers",
+			ability: ABILITY.composite,
+			can: (editor) => canGroup(editor, false),
+			run: (editor) => group(editor, false)
+		},
+		{
+			id: "gliedern-alle",
+			slash: {},
+			label: t("composites.slash.groupAll"),
+			icon: "i-lucide-list-tree",
+			ability: ABILITY.composite,
+			can: (editor) => canGroup(editor, true),
+			run: (editor) => group(editor, true)
+		},
+		{
+			id: "aufloesen",
+			slash: {},
+			label: t("composites.slash.flatten"),
+			icon: "i-lucide-heading",
+			ability: ABILITY.headings,
+			can: (editor) => canFlatten(editor, false),
+			run: (editor) => flatten(editor, false)
+		},
+		{
+			id: "aufloesen-alle",
+			slash: {},
+			label: t("composites.slash.flattenAll"),
+			icon: "i-lucide-align-left",
+			ability: ABILITY.headings,
+			can: (editor) => canFlatten(editor, true),
+			run: (editor) => flatten(editor, true)
+		},
+		{
+			id: "verweis",
+			slash: {},
+			label: t("composites.reference.insert"),
+			icon: "i-lucide-link-2",
+			ability: ABILITY.reference,
+			run: (editor) => {
+				editor.chain().focus().insertContent("[@").run();
+			}
 		}
 	];
 }