@ecsplico/editor 0.0.0-stage → 1.0.0

package/dist/core/metadata.js

@@ -0,0 +1,76 @@
+import { Extension } from "@tiptap/core";
+//#region src/core/metadata.ts
+function createMetadataRegistry(options = {}) {
+	const lists = {};
+	const created = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Map();
+	const remember = (into, list, items) => {
+		let byId = into.get(list);
+		if (!byId) into.set(list, byId = /* @__PURE__ */ new Map());
+		for (const item of items) byId.set(item.id, item);
+	};
+	const withCreated = (list, items) => [...items, ...[...created.get(list)?.values() ?? []].filter((i) => !items.some((s) => s.id === i.id))];
+	let host = {};
+	const fallback = {};
+	const apply = () => {
+		const next = {
+			...fallback,
+			...host
+		};
+		for (const key of Object.keys(lists)) if (!(key in next)) delete lists[key];
+		Object.assign(lists, next);
+	};
+	return {
+		lists,
+		replace(metadata) {
+			host = metadata;
+			apply();
+		},
+		defaults(metadata) {
+			Object.assign(fallback, metadata);
+			apply();
+		},
+		has: (list) => list in lists,
+		async search(list, q) {
+			const source = lists[list];
+			if (!source) return [];
+			if (typeof source !== "function") return filterMetadataItems(withCreated(list, source), q.query);
+			const items = await source(q);
+			remember(seen, list, items);
+			const extra = filterMetadataItems(withCreated(list, items).slice(items.length), q.query);
+			return [...items, ...extra];
+		},
+		known(list) {
+			const source = lists[list];
+			if (source && typeof source !== "function") return withCreated(list, source);
+			return withCreated(list, [...seen.get(list)?.values() ?? []]);
+		},
+		create(list, item) {
+			remember(created, list, [item]);
+			options.onCreate?.(list, item);
+		}
+	};
+}
+/** Case-insensitive; label-prefix matches first, then substring (same order as server/api/editor/users.get.ts); max `limit`. */
+function filterMetadataItems(items, query, limit = 20) {
+	const q = query.trim().toLowerCase();
+	const matches = items.filter((i) => i.label.toLowerCase().includes(q)).sort((a, b) => a.label.localeCompare(b.label, "de"));
+	const prefix = matches.filter((i) => i.label.toLowerCase().startsWith(q));
+	return [...prefix, ...matches.filter((i) => !prefix.includes(i))].slice(0, limit);
+}
+/** Makes the host's metadata registry reachable as `editor.storage.metadata.registry` (see `metadataOf`). */
+const Metadata = Extension.create({
+	name: "metadata",
+	addOptions() {
+		return { registry: null };
+	},
+	addStorage() {
+		if (!this.options.registry) throw new Error("tiptap-editor: Metadata.configure({ registry }) fehlt");
+		return { registry: this.options.registry };
+	}
+});
+const metadataOf = (editor) => editor.storage.metadata.registry;
+//#endregion
+export { Metadata, createMetadataRegistry, filterMetadataItems, metadataOf };
+
+//# sourceMappingURL=metadata.js.map

package/dist/core/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","names":[],"sources":["../../src/core/metadata.ts"],"sourcesContent":["import { type Editor, Extension } from '@tiptap/core'\nimport type { EditorMetadata, MetadataItem, MetadataQuery, MetadataSource } from './metadata-types'\n\nexport interface MetadataRegistry {\n  /** Current sources by list name; one object mutated in place on `replace`/`defaults` (not observable). */\n  readonly lists: Readonly<Record<string, MetadataSource>>\n  /** Sets the host's lists; lists the host does not supply fall back to `defaults`. */\n  replace(metadata: EditorMetadata): void\n  /** Adds fallback lists (features' built-in sources) used for every list name the host does not supply. */\n  defaults(metadata: EditorMetadata): void\n  has(list: string): boolean\n  /** Array source → `filterMetadataItems`; function source → its awaited result; unknown list → `[]`. */\n  search(list: string, q: MetadataQuery): Promise<MetadataItem[]>\n  /** Array source: the array; function source: union (by id) of everything searches returned so far, plus created items. */\n  known(list: string): readonly MetadataItem[]\n  /** Adds `item` to `known(list)`, then reports it via `onCreate`. */\n  create(list: string, item: MetadataItem): void\n}\n\nexport function createMetadataRegistry(options: { onCreate?: (list: string, item: MetadataItem) => void } = {}): MetadataRegistry {\n  const lists: Record<string, MetadataSource> = {}\n  // Per list, by id: items created in this editor (merged into every search, so a new item is suggested before the\n  // host's source knows it) and everything function sources returned. Kept across `replace`.\n  const created = new Map<string, Map<string, MetadataItem>>()\n  const seen = new Map<string, Map<string, MetadataItem>>()\n\n  const remember = (into: Map<string, Map<string, MetadataItem>>, list: string, items: readonly MetadataItem[]) => {\n    let byId = into.get(list)\n    if (!byId) into.set(list, byId = new Map())\n    for (const item of items) byId.set(item.id, item)\n  }\n  const withCreated = (list: string, items: readonly MetadataItem[]) =>\n    [...items, ...[...(created.get(list)?.values() ?? [])].filter(i => !items.some(s => s.id === i.id))]\n\n  // The host's lists over the features' fallbacks; applied whenever either changes.\n  let host: EditorMetadata = {}\n  const fallback: EditorMetadata = {}\n  const apply = () => {\n    const next = { ...fallback, ...host }\n    for (const key of Object.keys(lists)) if (!(key in next)) delete lists[key]\n    Object.assign(lists, next)\n  }\n\n  return {\n    lists,\n    replace(metadata) {\n      host = metadata\n      apply()\n    },\n    defaults(metadata) {\n      Object.assign(fallback, metadata)\n      apply()\n    },\n    has: list => list in lists,\n    async search(list, q) {\n      const source = lists[list]\n      if (!source) return []\n      if (typeof source !== 'function') return filterMetadataItems(withCreated(list, source), q.query)\n      const items = await source(q)\n      remember(seen, list, items)\n      const extra = filterMetadataItems(withCreated(list, items).slice(items.length), q.query)\n      return [...items, ...extra]\n    },\n    known(list) {\n      const source = lists[list]\n      if (source && typeof source !== 'function') return withCreated(list, source)\n      return withCreated(list, [...(seen.get(list)?.values() ?? [])])\n    },\n    create(list, item) {\n      remember(created, list, [item])\n      options.onCreate?.(list, item)\n    },\n  }\n}\n\n/** Case-insensitive; label-prefix matches first, then substring (same order as server/api/editor/users.get.ts); max `limit`. */\nexport function filterMetadataItems(items: readonly MetadataItem[], query: string, limit = 20): MetadataItem[] {\n  const q = query.trim().toLowerCase()\n  const matches = items\n    .filter(i => i.label.toLowerCase().includes(q))\n    .sort((a, b) => a.label.localeCompare(b.label, 'de'))\n  const prefix = matches.filter(i => i.label.toLowerCase().startsWith(q))\n  return [...prefix, ...matches.filter(i => !prefix.includes(i))].slice(0, limit)\n}\n\n/** Makes the host's metadata registry reachable as `editor.storage.metadata.registry` (see `metadataOf`). */\nexport const Metadata = Extension.create<{ registry: MetadataRegistry | null }, { registry: MetadataRegistry }>({\n  name: 'metadata',\n\n  addOptions() {\n    return { registry: null }\n  },\n\n  addStorage() {\n    if (!this.options.registry) throw new Error('tiptap-editor: Metadata.configure({ registry }) fehlt')\n    return { registry: this.options.registry }\n  },\n})\n\ndeclare module '@tiptap/core' {\n  interface Storage {\n    metadata: { registry: MetadataRegistry }\n  }\n}\n\nexport const metadataOf = (editor: Editor): MetadataRegistry => editor.storage.metadata.registry\n"],"mappings":"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"}

package/dist/core/notify.d.ts

@@ -0,0 +1,31 @@
+//#region src/core/notify.d.ts
+/**
+ * A user-facing notice (toast). The framework layer renders it: the UI kit's notifier on the Vue surface (Nuxt UI
+ * `useToast` or PrimeVue `useToast`; `kind` maps to the kit's colour/severity), sonner on the React surface. `id` deduplicates: a notice with the id of a visible one replaces it.
+ */
+export interface Notice {
+  id?: string;
+  title: string;
+  description?: string;
+  kind?: 'info' | 'success' | 'warning' | 'error';
+  /** Iconify name (`i-lucide-…`). */
+  icon?: string;
+  /** Milliseconds until it closes; 0 keeps it until a notice with the same `id` replaces it. Default: the framework's. */
+  duration?: number;
+  /** One button on the notice (e.g. „Rückgängig“); activating it also closes the notice. */
+  action?: {
+    label: string;
+    onClick: () => void;
+  };
+}
+/**
+ * Shows a notice; features reach it through `FeatureContext.notify`, app-level models through `EditorContext.notify`.
+ * `dismiss(id)` closes the visible notice with that id (a persistent `duration: 0` progress notice); absent on notifiers that cannot.
+ */
+export type Notifier = ((notice: Notice) => void) & {
+  dismiss?: (id: string) => void;
+};
+/** Drops every notice: the default of headless contexts. */
+export declare const silentNotifier: Notifier;
+//#endregion
+//# sourceMappingURL=notify.d.ts.map

package/dist/core/notify.js

@@ -0,0 +1,7 @@
+//#region src/core/notify.ts
+/** Drops every notice: the default of headless contexts. */
+const silentNotifier = () => {};
+//#endregion
+export { silentNotifier };
+
+//# sourceMappingURL=notify.js.map

package/dist/core/notify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify.js","names":[],"sources":["../../src/core/notify.ts"],"sourcesContent":["/**\n * A user-facing notice (toast). The framework layer renders it: the UI kit's notifier on the Vue surface (Nuxt UI\n * `useToast` or PrimeVue `useToast`; `kind` maps to the kit's colour/severity), sonner on the React surface. `id` deduplicates: a notice with the id of a visible one replaces it.\n */\nexport interface Notice {\n  id?: string\n  title: string\n  description?: string\n  kind?: 'info' | 'success' | 'warning' | 'error'\n  /** Iconify name (`i-lucide-…`). */\n  icon?: string\n  /** Milliseconds until it closes; 0 keeps it until a notice with the same `id` replaces it. Default: the framework's. */\n  duration?: number\n  /** One button on the notice (e.g. „Rückgängig“); activating it also closes the notice. */\n  action?: { label: string, onClick: () => void }\n}\n\n/**\n * Shows a notice; features reach it through `FeatureContext.notify`, app-level models through `EditorContext.notify`.\n * `dismiss(id)` closes the visible notice with that id (a persistent `duration: 0` progress notice); absent on notifiers that cannot.\n */\nexport type Notifier = ((notice: Notice) => void) & { dismiss?: (id: string) => void }\n\n/** Drops every notice: the default of headless contexts. */\nexport const silentNotifier: Notifier = () => {}\n"],"mappings":";;AAwBA,MAAa,uBAAiC,CAAC"}

package/dist/core/pipeline.d.ts

@@ -0,0 +1,52 @@
+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.
+ */
+export declare const DEFAULT_BLOCK_PIPELINE: BlockPipeline;
+export interface PresetStorage {
+  pipeline: BlockPipeline;
+  conversions: readonly ConversionProvider[];
+  aiContext?: EditorFeature['aiContext'];
+  aiBlockData?: AiBlockDataProvider;
+  formatAiResult?: EditorFeature['formatAiResult'];
+}
+declare module '@tiptap/core' {
+  interface Storage {
+    editorPreset: PresetStorage;
+  }
+}
+/** Makes the preset's resolved pipeline, conversion providers and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`). */
+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. */
+export declare function aiContextOf(editor: Editor): {
+  kinds: NonNullable<AiContext['kinds']>;
+  blocks: NonNullable<AiContext['blocks']>;
+  structure: NonNullable<AiContext['structure']>;
+};
+/** The preset's `formatAiResult` hook, or null when no feature contributes one. */
+export declare const formatAiResultOf: (editor: Editor) => ((markdown: string, heading?: string) => string) | null;
+/** The merged `aiBlockData` of the preset's features; without contributors it resolves to no data. */
+export declare const aiBlockDataOf: (editor: Editor) => AiBlockDataProvider;
+/**
+ * `markdown` as document JSON (`parsed`: parse, then normalize) and as the blocks to insert (`blocks`: `parsed` after
+ * the segment stage). `parsed` is never changed by segmenting. Inline replacements use `parsed`, block insertion and
+ * file import use `blocks`.
+ */
+export declare function parseBlocks(editor: Editor, markdown: string): {
+  parsed: JSONContent;
+  blocks: JSONContent[];
+};
+/** Applies the structure stage to blocks about to be inserted (AI block insertion, file import). */
+export declare const structureBlocks: (editor: Editor, blocks: JSONContent[]) => JSONContent[];
+/** Applies the file-wrapping stage to the blocks of an imported file. */
+export declare const wrapImportBlocks: (editor: Editor, file: File, blocks: JSONContent[]) => JSONContent[];
+//#endregion
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/core/pipeline.js

@@ -0,0 +1,78 @@
+import { opaqueFenceJSON, splitCompositeFences } from "./fences.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.
+*/
+const DEFAULT_BLOCK_PIPELINE = {
+	parseMarkdown: (editor, markdown) => {
+		const parse = (text) => editor.markdown?.parse(text).content ?? [];
+		const segments = editor.schema.nodes.opaqueFence ? splitCompositeFences(markdown) : [];
+		if (!segments.some((segment) => "inner" in segment)) return parse(markdown);
+		return segments.flatMap((segment) => "inner" in segment ? [opaqueFenceJSON(segment)] : parse(segment.markdown));
+	},
+	normalize: (_editor, blocks) => blocks,
+	segment: (_editor, blocks) => blocks,
+	structure: (_editor, blocks) => blocks,
+	wrapImport: (_editor, _file, blocks) => blocks,
+	migrateContent: (content) => content
+};
+/** Makes the preset's resolved pipeline, conversion providers and AI hooks reachable from the editor instance (`pipelineOf`, `conversionsOf`, `aiContextOf`). */
+function presetExtension(preset) {
+	return Extension.create({
+		name: "editorPreset",
+		addStorage: () => ({
+			pipeline: preset.pipeline,
+			conversions: preset.conversions,
+			...preset.aiContext && { aiContext: preset.aiContext },
+			...preset.aiBlockData && { aiBlockData: preset.aiBlockData },
+			...preset.formatAiResult && { formatAiResult: preset.formatAiResult }
+		})
+	});
+}
+/** 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. */
+function aiContextOf(editor) {
+	const context = editor.storage.editorPreset?.aiContext?.(editor);
+	return {
+		kinds: context?.kinds ?? [],
+		blocks: context?.blocks ?? [],
+		structure: context?.structure ?? "flat"
+	};
+}
+/** The preset's `formatAiResult` hook, or null when no feature contributes one. */
+const formatAiResultOf = (editor) => {
+	const format = editor.storage.editorPreset?.formatAiResult;
+	return format ? (markdown, heading) => format(editor, markdown, heading) : null;
+};
+/** The merged `aiBlockData` of the preset's features; without contributors it resolves to no data. */
+const aiBlockDataOf = (editor) => editor.storage.editorPreset?.aiBlockData ?? (() => []);
+/**
+* `markdown` as document JSON (`parsed`: parse, then normalize) and as the blocks to insert (`blocks`: `parsed` after
+* the segment stage). `parsed` is never changed by segmenting. Inline replacements use `parsed`, block insertion and
+* file import use `blocks`.
+*/
+function parseBlocks(editor, markdown) {
+	const pipeline = pipelineOf(editor);
+	const content = pipeline.normalize(editor, pipeline.parseMarkdown(editor, markdown));
+	return {
+		parsed: {
+			type: "doc",
+			content
+		},
+		blocks: pipeline.segment(editor, [...content])
+	};
+}
+/** Applies the structure stage to blocks about to be inserted (AI block insertion, file import). */
+const structureBlocks = (editor, blocks) => pipelineOf(editor).structure(editor, blocks);
+/** Applies the file-wrapping stage to the blocks of an imported file. */
+const wrapImportBlocks = (editor, file, blocks) => pipelineOf(editor).wrapImport(editor, file, blocks);
+//#endregion
+export { DEFAULT_BLOCK_PIPELINE, aiBlockDataOf, aiContextOf, conversionsOf, formatAiResultOf, parseBlocks, pipelineOf, presetExtension, structureBlocks, wrapImportBlocks };
+
+//# sourceMappingURL=pipeline.js.map

package/dist/core/pipeline.js.map

@@ -0,0 +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"}

package/dist/core/schema/abilities.d.ts

@@ -0,0 +1,55 @@
+import { Node } from "@tiptap/pm/model";
+//#region src/core/schema/abilities.d.ts
+/** Ability ids. Hosts may add their own strings; these are the ones the editor itself checks. */
+export declare const ABILITY: {
+  readonly marks: "format.marks";
+  readonly headings: "format.headings";
+  readonly lists: "format.lists";
+  readonly blockquote: "format.blockquote";
+  readonly codeBlock: "format.codeBlock";
+  readonly rule: "format.rule";
+  readonly blockContent: "block.content";
+  readonly composite: "format.composite";
+  readonly transcript: "transcript.segment";
+  readonly media: "insert.media";
+  readonly record: "insert.record";
+  readonly mention: "insert.mention";
+  readonly tag: "insert.tag";
+  readonly aiRewrite: "ai.rewrite";
+  readonly aiGenerate: "ai.generate";
+  readonly aiAutocomplete: "ai.autocomplete";
+  readonly blockDelete: "block.delete";
+  readonly blockDuplicate: "block.duplicate";
+  readonly blockConvert: "block.convert";
+  readonly compositeMeta: "composite.meta";
+  readonly compositeSummarize: "composite.summarize";
+  readonly compositeExport: "composite.export";
+  readonly compositeTranscribe: "composite.transcribe";
+};
+export type Ability = (typeof ABILITY)[keyof typeof ABILITY] | (string & {});
+/** How a node changes the abilities of everything inside it: `grants`, then `revokes`; `own` only applies when it is the innermost node. */
+export interface AbilityRule {
+  grants?: readonly Ability[];
+  revokes?: readonly Ability[];
+  own?: readonly Ability[];
+}
+export type AbilityRuleSource = AbilityRule | ((node: Node) => AbilityRule);
+/** Everything a plain paragraph at document root can do. `composite.*` are `own` abilities of composites only. */
+export declare const ROOT_ABILITIES: readonly Ability[];
+/** Text-editing abilities an atom block (image/audio/video) or a tags row can never have. */
+export declare const TEXT_ABILITIES: readonly Ability[];
+/** Node/mark type → ability its creation/toggling needs (toolbar fallback, shortcut + input-rule gate). */
+export declare const TYPE_ABILITIES: Readonly<Record<string, Ability>>;
+/**
+ * Abilities at the end of `chain` (ancestors from depth 1 down to and including the innermost node):
+ * start with `root`; per node add its `grants`, remove its `revokes`; finally add the innermost node's `own`.
+ */
+export declare function resolveAbilities(rules: ReadonlyMap<string, AbilityRuleSource>, root: readonly Ability[], chain: readonly Node[]): ReadonlySet<Ability>;
+declare module '@tiptap/core' {
+  interface NodeConfig<Options, Storage> {
+    /** Abilities this node grants/revokes for its content (`own`: only when it is the innermost node). Host rules override it. */
+    abilities?: AbilityRuleSource;
+  }
+}
+//#endregion
+//# sourceMappingURL=abilities.d.ts.map

package/dist/core/schema/abilities.js

@@ -0,0 +1,113 @@
+//#region src/core/schema/abilities.ts
+/** Ability ids. Hosts may add their own strings; these are the ones the editor itself checks. */
+const ABILITY = {
+	marks: "format.marks",
+	headings: "format.headings",
+	lists: "format.lists",
+	blockquote: "format.blockquote",
+	codeBlock: "format.codeBlock",
+	rule: "format.rule",
+	blockContent: "block.content",
+	composite: "format.composite",
+	transcript: "transcript.segment",
+	media: "insert.media",
+	record: "insert.record",
+	mention: "insert.mention",
+	tag: "insert.tag",
+	aiRewrite: "ai.rewrite",
+	aiGenerate: "ai.generate",
+	aiAutocomplete: "ai.autocomplete",
+	blockDelete: "block.delete",
+	blockDuplicate: "block.duplicate",
+	blockConvert: "block.convert",
+	compositeMeta: "composite.meta",
+	compositeSummarize: "composite.summarize",
+	compositeExport: "composite.export",
+	compositeTranscribe: "composite.transcribe"
+};
+/** Everything a plain paragraph at document root can do. `composite.*` are `own` abilities of composites only. */
+const ROOT_ABILITIES = [
+	ABILITY.marks,
+	ABILITY.headings,
+	ABILITY.lists,
+	ABILITY.blockquote,
+	ABILITY.codeBlock,
+	ABILITY.rule,
+	ABILITY.blockContent,
+	ABILITY.composite,
+	ABILITY.transcript,
+	ABILITY.media,
+	ABILITY.record,
+	ABILITY.mention,
+	ABILITY.tag,
+	ABILITY.aiRewrite,
+	ABILITY.aiGenerate,
+	ABILITY.aiAutocomplete,
+	ABILITY.blockDelete,
+	ABILITY.blockDuplicate,
+	ABILITY.blockConvert
+];
+/** Text-editing abilities an atom block (image/audio/video) or a tags row can never have. */
+const TEXT_ABILITIES = [
+	ABILITY.marks,
+	ABILITY.headings,
+	ABILITY.lists,
+	ABILITY.blockquote,
+	ABILITY.codeBlock,
+	ABILITY.rule,
+	ABILITY.blockContent,
+	ABILITY.composite,
+	ABILITY.transcript,
+	ABILITY.media,
+	ABILITY.record,
+	ABILITY.mention,
+	ABILITY.tag,
+	ABILITY.aiRewrite,
+	ABILITY.aiGenerate,
+	ABILITY.aiAutocomplete
+];
+/** Node/mark type → ability its creation/toggling needs (toolbar fallback, shortcut + input-rule gate). */
+const TYPE_ABILITIES = {
+	bold: ABILITY.marks,
+	italic: ABILITY.marks,
+	strike: ABILITY.marks,
+	code: ABILITY.marks,
+	heading: ABILITY.headings,
+	bulletList: ABILITY.lists,
+	orderedList: ABILITY.lists,
+	listItem: ABILITY.lists,
+	taskList: ABILITY.lists,
+	taskItem: ABILITY.lists,
+	blockquote: ABILITY.blockquote,
+	codeBlock: ABILITY.codeBlock,
+	horizontalRule: ABILITY.rule,
+	composite: ABILITY.composite,
+	transcriptSegment: ABILITY.transcript,
+	image: ABILITY.media,
+	audio: ABILITY.media,
+	video: ABILITY.media,
+	file: ABILITY.media,
+	mention: ABILITY.mention,
+	tag: ABILITY.tag
+};
+/**
+* Abilities at the end of `chain` (ancestors from depth 1 down to and including the innermost node):
+* start with `root`; per node add its `grants`, remove its `revokes`; finally add the innermost node's `own`.
+*/
+function resolveAbilities(rules, root, chain) {
+	const set = new Set(root);
+	let own;
+	for (const node of chain) {
+		const source = rules.get(node.type.name);
+		const rule = typeof source === "function" ? source(node) : source;
+		for (const ability of rule?.grants ?? []) set.add(ability);
+		for (const ability of rule?.revokes ?? []) set.delete(ability);
+		own = rule?.own;
+	}
+	for (const ability of own ?? []) set.add(ability);
+	return set;
+}
+//#endregion
+export { ABILITY, ROOT_ABILITIES, TEXT_ABILITIES, TYPE_ABILITIES, resolveAbilities };
+
+//# sourceMappingURL=abilities.js.map

package/dist/core/schema/abilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abilities.js","names":[],"sources":["../../../src/core/schema/abilities.ts"],"sourcesContent":["import type { Node as PMNode } from '@tiptap/pm/model'\n\n// Vue-free and server-importable: node schemas shared with the server declare their rule via `NodeConfig.abilities`.\n\n/** Ability ids. Hosts may add their own strings; these are the ones the editor itself checks. */\nexport const ABILITY = {\n  marks: 'format.marks',\n  headings: 'format.headings',\n  lists: 'format.lists',\n  blockquote: 'format.blockquote',\n  codeBlock: 'format.codeBlock',\n  rule: 'format.rule',\n  blockContent: 'block.content',\n  composite: 'format.composite',\n  transcript: 'transcript.segment',\n  media: 'insert.media',\n  record: 'insert.record',\n  mention: 'insert.mention',\n  tag: 'insert.tag',\n  aiRewrite: 'ai.rewrite',\n  aiGenerate: 'ai.generate',\n  aiAutocomplete: 'ai.autocomplete',\n  blockDelete: 'block.delete',\n  blockDuplicate: 'block.duplicate',\n  blockConvert: 'block.convert',\n  compositeMeta: 'composite.meta',\n  compositeSummarize: 'composite.summarize',\n  compositeExport: 'composite.export',\n  compositeTranscribe: 'composite.transcribe',\n} as const\n\nexport type Ability = (typeof ABILITY)[keyof typeof ABILITY] | (string & {})\n\n/** How a node changes the abilities of everything inside it: `grants`, then `revokes`; `own` only applies when it is the innermost node. */\nexport interface AbilityRule {\n  grants?: readonly Ability[]\n  revokes?: readonly Ability[]\n  own?: readonly Ability[]\n}\n\nexport type AbilityRuleSource = AbilityRule | ((node: PMNode) => AbilityRule)\n\n/** Everything a plain paragraph at document root can do. `composite.*` are `own` abilities of composites only. */\nexport const ROOT_ABILITIES: readonly Ability[] = [\n  ABILITY.marks, ABILITY.headings, ABILITY.lists, ABILITY.blockquote, ABILITY.codeBlock, ABILITY.rule, ABILITY.blockContent, ABILITY.composite,\n  ABILITY.transcript, ABILITY.media, ABILITY.record, ABILITY.mention, ABILITY.tag, ABILITY.aiRewrite, ABILITY.aiGenerate,\n  ABILITY.aiAutocomplete, ABILITY.blockDelete, ABILITY.blockDuplicate, ABILITY.blockConvert,\n]\n\n/** Text-editing abilities an atom block (image/audio/video) or a tags row can never have. */\nexport const TEXT_ABILITIES: readonly Ability[] = [\n  ABILITY.marks, ABILITY.headings, ABILITY.lists, ABILITY.blockquote, ABILITY.codeBlock, ABILITY.rule, ABILITY.blockContent, ABILITY.composite,\n  ABILITY.transcript, ABILITY.media, ABILITY.record, ABILITY.mention, ABILITY.tag, ABILITY.aiRewrite, ABILITY.aiGenerate,\n  ABILITY.aiAutocomplete,\n]\n\n/** Node/mark type → ability its creation/toggling needs (toolbar fallback, shortcut + input-rule gate). */\nexport const TYPE_ABILITIES: Readonly<Record<string, Ability>> = {\n  bold: ABILITY.marks,\n  italic: ABILITY.marks,\n  strike: ABILITY.marks,\n  code: ABILITY.marks,\n  heading: ABILITY.headings,\n  bulletList: ABILITY.lists,\n  orderedList: ABILITY.lists,\n  listItem: ABILITY.lists,\n  taskList: ABILITY.lists,\n  taskItem: ABILITY.lists,\n  blockquote: ABILITY.blockquote,\n  codeBlock: ABILITY.codeBlock,\n  horizontalRule: ABILITY.rule,\n  composite: ABILITY.composite,\n  transcriptSegment: ABILITY.transcript,\n  image: ABILITY.media,\n  audio: ABILITY.media,\n  video: ABILITY.media,\n  file: ABILITY.media,\n  mention: ABILITY.mention,\n  tag: ABILITY.tag,\n}\n\n/**\n * Abilities at the end of `chain` (ancestors from depth 1 down to and including the innermost node):\n * start with `root`; per node add its `grants`, remove its `revokes`; finally add the innermost node's `own`.\n */\nexport function resolveAbilities(rules: ReadonlyMap<string, AbilityRuleSource>, root: readonly Ability[], chain: readonly PMNode[]): ReadonlySet<Ability> {\n  const set = new Set<Ability>(root)\n  let own: readonly Ability[] | undefined\n  for (const node of chain) {\n    const source = rules.get(node.type.name)\n    const rule = typeof source === 'function' ? source(node) : source\n    for (const ability of rule?.grants ?? []) set.add(ability)\n    for (const ability of rule?.revokes ?? []) set.delete(ability)\n    own = rule?.own\n  }\n  for (const ability of own ?? []) set.add(ability)\n  return set\n}\n\ndeclare module '@tiptap/core' {\n  interface NodeConfig<Options, Storage> {\n    /** Abilities this node grants/revokes for its content (`own`: only when it is the innermost node). Host rules override it. */\n    abilities?: AbilityRuleSource\n  }\n}\n"],"mappings":";;AAKA,MAAa,UAAU;CACrB,OAAO;CACP,UAAU;CACV,OAAO;CACP,YAAY;CACZ,WAAW;CACX,MAAM;CACN,cAAc;CACd,WAAW;CACX,YAAY;CACZ,OAAO;CACP,QAAQ;CACR,SAAS;CACT,KAAK;CACL,WAAW;CACX,YAAY;CACZ,gBAAgB;CAChB,aAAa;CACb,gBAAgB;CAChB,cAAc;CACd,eAAe;CACf,oBAAoB;CACpB,iBAAiB;CACjB,qBAAqB;AACvB;;AAcA,MAAa,iBAAqC;CAChD,QAAQ;CAAO,QAAQ;CAAU,QAAQ;CAAO,QAAQ;CAAY,QAAQ;CAAW,QAAQ;CAAM,QAAQ;CAAc,QAAQ;CACnI,QAAQ;CAAY,QAAQ;CAAO,QAAQ;CAAQ,QAAQ;CAAS,QAAQ;CAAK,QAAQ;CAAW,QAAQ;CAC5G,QAAQ;CAAgB,QAAQ;CAAa,QAAQ;CAAgB,QAAQ;AAC/E;;AAGA,MAAa,iBAAqC;CAChD,QAAQ;CAAO,QAAQ;CAAU,QAAQ;CAAO,QAAQ;CAAY,QAAQ;CAAW,QAAQ;CAAM,QAAQ;CAAc,QAAQ;CACnI,QAAQ;CAAY,QAAQ;CAAO,QAAQ;CAAQ,QAAQ;CAAS,QAAQ;CAAK,QAAQ;CAAW,QAAQ;CAC5G,QAAQ;AACV;;AAGA,MAAa,iBAAoD;CAC/D,MAAM,QAAQ;CACd,QAAQ,QAAQ;CAChB,QAAQ,QAAQ;CAChB,MAAM,QAAQ;CACd,SAAS,QAAQ;CACjB,YAAY,QAAQ;CACpB,aAAa,QAAQ;CACrB,UAAU,QAAQ;CAClB,UAAU,QAAQ;CAClB,UAAU,QAAQ;CAClB,YAAY,QAAQ;CACpB,WAAW,QAAQ;CACnB,gBAAgB,QAAQ;CACxB,WAAW,QAAQ;CACnB,mBAAmB,QAAQ;CAC3B,OAAO,QAAQ;CACf,OAAO,QAAQ;CACf,OAAO,QAAQ;CACf,MAAM,QAAQ;CACd,SAAS,QAAQ;CACjB,KAAK,QAAQ;AACf;;;;;AAMA,SAAgB,iBAAiB,OAA+C,MAA0B,OAAgD;CACxJ,MAAM,MAAM,IAAI,IAAa,IAAI;CACjC,IAAI;CACJ,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,SAAS,MAAM,IAAI,KAAK,KAAK,IAAI;EACvC,MAAM,OAAO,OAAO,WAAW,aAAa,OAAO,IAAI,IAAI;EAC3D,KAAK,MAAM,WAAW,MAAM,UAAU,CAAC,GAAG,IAAI,IAAI,OAAO;EACzD,KAAK,MAAM,WAAW,MAAM,WAAW,CAAC,GAAG,IAAI,OAAO,OAAO;EAC7D,MAAM,MAAM;CACd;CACA,KAAK,MAAM,WAAW,OAAO,CAAC,GAAG,IAAI,IAAI,OAAO;CAChD,OAAO;AACT"}

package/dist/core/schema/block-ids.d.ts

@@ -0,0 +1,29 @@
+import { Node } from "@tiptap/pm/model";
+//#region src/core/schema/block-ids.d.ts
+/** Node attribute holding a block's stable ID; rendered as `data-id`. */
+export declare const BLOCK_ID_ATTR = "id";
+/** The built-in block types: every type that can be a top-level block (paragraphs nested in lists and quotes get one too). Other nodes opt in with `editorBlock: true`. */
+export declare const BLOCK_ID_TYPES: readonly string[];
+/** A fresh block ID (UUID v4; unlike `crypto.randomUUID()` also available outside secure contexts). */
+export declare const newBlockId: () => string;
+/** The block ID of `node`; `null` for node types without IDs and for blocks that have none yet. */
+export declare function blockIdOf(node: Node): string | null;
+/** The block with ID `id` (top-level or nested) and its position in `doc`, or `null`. */
+export declare function findBlockById(doc: Node, id: string): {
+  node: Node;
+  pos: number;
+} | null;
+/**
+ * `doc` with a fresh ID on every block that has none or repeats an earlier block's ID, or `null` when all IDs are
+ * present and unique. For content no editor has touched: JSON seeds, Yjs state from before block IDs, server inserts.
+ */
+export declare function assignBlockIds(doc: Node): Node | null;
+/**
+ * Stable block IDs. `@tiptap/extension-unique-id` assigns IDs only in the local user's transactions: it skips
+ * `y-sync$` (remote Yjs) transactions, gives the new half of a split a fresh ID (also the speaker segment's own Enter,
+ * whose new half starts without an ID) and strips IDs from pasted and copy-dropped content. Part of
+ * `schemaExtensions()`, so the server schema, the JSON mirror and the Yjs state carry the attribute.
+ */
+export declare const BlockId: import("@tiptap/core").Extension<import("@tiptap/extension-unique-id").UniqueIDOptions, any>;
+//#endregion
+//# sourceMappingURL=block-ids.d.ts.map

package/dist/core/schema/block-ids.js

@@ -0,0 +1,134 @@
+import { combineTransactionSteps, findChildrenInRange, getChangedRanges, getExtensionField, splitExtensions } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { UniqueID } from "@tiptap/extension-unique-id";
+import { Transform } from "@tiptap/pm/transform";
+import { v4 } from "uuid";
+//#region src/core/schema/block-ids.ts
+/** Node attribute holding a block's stable ID; rendered as `data-id`. */
+const BLOCK_ID_ATTR = "id";
+/** The built-in block types: every type that can be a top-level block (paragraphs nested in lists and quotes get one too). Other nodes opt in with `editorBlock: true`. */
+const BLOCK_ID_TYPES = [
+	"paragraph",
+	"heading",
+	"bulletList",
+	"orderedList",
+	"blockquote",
+	"codeBlock",
+	"image",
+	"audio",
+	"video",
+	"file",
+	"horizontalRule",
+	"transcriptSegment",
+	"composite"
+];
+/** The node types among `extensions` that carry a block ID: `editorBlock` declared, else built-in (same rule as `NodeFlags`). */
+const blockTypesOf = (extensions) => splitExtensions(extensions).nodeExtensions.filter((ext) => getExtensionField(ext, "editorBlock") ?? BLOCK_ID_TYPES.includes(ext.name)).map((ext) => ext.name);
+const carriesId = (node) => node.type.spec.editorBlock === true;
+/** A fresh block ID (UUID v4; unlike `crypto.randomUUID()` also available outside secure contexts). */
+const newBlockId = () => v4();
+/** The block ID of `node`; `null` for node types without IDs and for blocks that have none yet. */
+function blockIdOf(node) {
+	const id = carriesId(node) ? node.attrs["id"] : null;
+	return typeof id === "string" && id ? id : null;
+}
+/** The block with ID `id` (top-level or nested) and its position in `doc`, or `null`. */
+function findBlockById(doc, id) {
+	let found = null;
+	doc.descendants((node, pos) => {
+		if (found) return false;
+		if (blockIdOf(node) === id) found = {
+			node,
+			pos
+		};
+		return !found && !node.isTextblock;
+	});
+	return found;
+}
+/**
+* `doc` with a fresh ID on every block that has none or repeats an earlier block's ID, or `null` when all IDs are
+* present and unique. For content no editor has touched: JSON seeds, Yjs state from before block IDs, server inserts.
+*/
+function assignBlockIds(doc) {
+	const tr = new Transform(doc);
+	const seen = /* @__PURE__ */ new Set();
+	doc.descendants((node, pos) => {
+		if (carriesId(node)) {
+			const id = blockIdOf(node);
+			if (id && !seen.has(id)) seen.add(id);
+			else tr.setNodeAttribute(pos, "id", newBlockId());
+		}
+		return !node.isTextblock;
+	});
+	return tr.docChanged ? tr.doc : null;
+}
+/**
+* UniqueID only compares IDs within the changed ranges, so a block inserted with an ID that exists elsewhere in the
+* document (Alt-drop of a drag-handle drag, `insertContent` of a copied block's JSON) would keep the duplicate. This
+* gives such inserted blocks a fresh ID; the block that was already there keeps its own.
+*/
+const dedupeInserted = () => new Plugin({
+	key: new PluginKey("blockIdDedupe"),
+	appendTransaction(transactions, oldState, newState) {
+		if (!transactions.some((tr) => tr.docChanged) || transactions.some((tr) => tr.getMeta("y-sync$"))) return;
+		const transform = combineTransactionSteps(oldState.doc, [...transactions]);
+		const inverse = transform.mapping.invert();
+		const inserted = /* @__PURE__ */ new Map();
+		for (const { newRange } of getChangedRanges(transform)) for (const { node, pos } of findChildrenInRange(newState.doc, newRange, carriesId)) {
+			const id = blockIdOf(node);
+			if (id && inverse.mapResult(pos).deleted) inserted.set(pos, id);
+		}
+		if (!inserted.size) return;
+		const total = /* @__PURE__ */ new Map();
+		const ofInserted = /* @__PURE__ */ new Map();
+		for (const id of inserted.values()) ofInserted.set(id, (ofInserted.get(id) ?? 0) + 1);
+		newState.doc.descendants((node) => {
+			const id = blockIdOf(node);
+			if (id && ofInserted.has(id)) total.set(id, (total.get(id) ?? 0) + 1);
+			return !node.isTextblock;
+		});
+		const tr = newState.tr;
+		const kept = /* @__PURE__ */ new Set();
+		for (const [pos, id] of [...inserted].sort(([a], [b]) => a - b)) {
+			if ((total.get(id) ?? 0) < 2) continue;
+			if (total.get(id) === ofInserted.get(id) && !kept.has(id)) {
+				kept.add(id);
+				continue;
+			}
+			tr.setNodeAttribute(pos, "id", newBlockId());
+		}
+		if (!tr.docChanged) return;
+		return tr.setStoredMarks(newState.storedMarks).setMeta("__uniqueIDTransaction", true);
+	}
+});
+/**
+* Stable block IDs. `@tiptap/extension-unique-id` assigns IDs only in the local user's transactions: it skips
+* `y-sync$` (remote Yjs) transactions, gives the new half of a split a fresh ID (also the speaker segment's own Enter,
+* whose new half starts without an ID) and strips IDs from pasted and copy-dropped content. Part of
+* `schemaExtensions()`, so the server schema, the JSON mirror and the Yjs state carry the attribute.
+*/
+const BlockId = UniqueID.extend({
+	addGlobalAttributes() {
+		this.options.types = blockTypesOf(this.extensions);
+		return this.parent?.() ?? [];
+	},
+	onCreate(event) {
+		const { extensions } = this.editor.extensionManager;
+		if (extensions.some((ext) => ext.name === "collaboration")) return;
+		this.options.types = blockTypesOf(extensions);
+		this.parent?.(event);
+	},
+	addProseMirrorPlugins() {
+		this.options.types = blockTypesOf(this.editor.extensionManager.extensions);
+		const plugins = this.parent?.() ?? [];
+		this.storage.needsInitialIdGeneration = false;
+		return [...plugins, dedupeInserted()];
+	}
+}).configure({
+	attributeName: "id",
+	generateID: newBlockId
+});
+//#endregion
+export { BLOCK_ID_ATTR, BLOCK_ID_TYPES, BlockId, assignBlockIds, blockIdOf, findBlockById, newBlockId };
+
+//# sourceMappingURL=block-ids.js.map