@tensor_1/react 2.18.0 → 2.19.0

package/dist/markdown.d.ts

@@ -0,0 +1,4 @@
+export { Markdown, MarkdownProps, defaultMarkdownIsSafeUrl } from './components/Markdown.js';
+export { MarkdownBlock, MarkdownInline, MarkdownList, MarkdownListItem, TableAlign, parseInline, parseMarkdown, plainText } from './markdown-model.js';
+import 'react';
+import './url-policy.js';

package/dist/markdown.js

@@ -0,0 +1,9 @@
+import { Markdown, defaultMarkdownIsSafeUrl } from "./components/Markdown.js";
+import { parseMarkdown, parseInline, plainText } from "./markdown-model.js";
+export {
+  Markdown,
+  defaultMarkdownIsSafeUrl,
+  parseInline,
+  parseMarkdown,
+  plainText
+};

package/dist/overlay-position-CEGSz6Z2.d.cts

@@ -0,0 +1,59 @@
+/**
+ * uix overlay positioning — framework-agnostic, dependency-free anchored placement.
+ *
+ * Pure geometry (no DOM): given the anchor's rect, the floating element's size, and
+ * the viewport, compute where to put the floating element with two behaviours:
+ *   • flip  — if the preferred side doesn't fit, use the opposite side (or whichever
+ *             side has more room);
+ *   • shift — slide along the cross axis so the element stays within the viewport.
+ *
+ * The React hook (useAnchoredPosition) and the vanilla styleguide both feed this
+ * getBoundingClientRect() values, so anchored overlays land in the same place in every
+ * browser — instead of relying on CSS anchor() positioning, which is Chromium-only and
+ * silently detaches the overlay from its trigger everywhere else (UIX-FIX-02).
+ *
+ * Everything here is deterministic and unit-tested (see overlay-position.test.mjs).
+ */
+type Side = 'top' | 'bottom' | 'left' | 'right';
+type Align = 'start' | 'center' | 'end';
+type Placement = Side | `${Side}-${Align}`;
+/** A viewport-space rectangle, as returned by getBoundingClientRect(). */
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+interface PositionOptions {
+    /** Preferred placement. Default `'bottom-start'`; a bare side (e.g. `'top'`) centers on the cross axis. */
+    placement?: Placement;
+    /** Gap between the anchor and the floating element, in px. Default 6. */
+    offset?: number;
+    /** Minimum gap kept from each viewport edge when shifting, in px. Default 8. */
+    padding?: number;
+    /** Flip to the opposite side when the preferred one doesn't fit. Default true. */
+    flip?: boolean;
+    /** Slide along the cross axis to stay on-screen. Default true. */
+    shift?: boolean;
+}
+interface PositionResult {
+    /** Viewport-space left, for `position: fixed`. */
+    x: number;
+    /** Viewport-space top, for `position: fixed`. */
+    y: number;
+    /** The placement actually used (after any flip). */
+    placement: Placement;
+    side: Side;
+    align: Align;
+}
+/**
+ * Compute the floating element's viewport-space position anchored to `anchor`.
+ * Coordinates are for `position: fixed` (same space as getBoundingClientRect).
+ */
+declare function computePosition(anchor: Rect, floating: Size, viewport: Size, options?: PositionOptions): PositionResult;
+
+export { type Align as A, type Placement as P, type Rect as R, type Side as S, type PositionOptions as a, type PositionResult as b, type Size as c, computePosition as d };

package/dist/rich-text/emoji-items.d.ts

@@ -0,0 +1,14 @@
+import { EmojiItem } from '@tiptap/extension-emoji';
+
+/**
+ * The emoji list the editor configures `@tiptap/extension-emoji` with (RTE-01, on-prem).
+ *
+ * Upstream's default list carries a `fallbackImage` on a public CDN for nearly every
+ * entry, and its GitHub list adds image-only custom emoji. Either would make a browser
+ * request third-party images for emoji the device cannot draw. This list keeps only
+ * Unicode emoji and drops every image URL, so the editor never builds a remote URL.
+ * Same-origin fallback images are opt-in through `emojiImageBaseUrl`.
+ */
+declare const OFFLINE_EMOJI_ITEMS: ReadonlyArray<EmojiItem>;
+
+export { OFFLINE_EMOJI_ITEMS };

package/dist/rich-text/emoji-items.js

@@ -0,0 +1,7 @@
+import { emojis } from "@tiptap/extension-emoji";
+const OFFLINE_EMOJI_ITEMS = Object.freeze(
+  emojis.filter((item) => typeof item.emoji === "string" && item.emoji !== "").map(({ fallbackImage: _remote, ...item }) => item).filter((item) => !/https?:|\/\//i.test(JSON.stringify(item)))
+);
+export {
+  OFFLINE_EMOJI_ITEMS
+};

package/dist/rich-text/pipeline.d.ts

@@ -0,0 +1,91 @@
+import { JSONContent, AnyExtension } from '@tiptap/core';
+import { Schema } from '@tiptap/pm/model';
+import { MarkdownManager } from '@tiptap/markdown';
+import { Marked } from 'marked';
+export { defaultIsSafeUrl } from '../url-policy.js';
+
+interface SchemaExtensionOptions {
+    /** Heading levels the schema accepts. Parsed headings outside the set still round-trip (see below). */
+    headingLevels?: ReadonlyArray<1 | 2 | 3>;
+    isSafeUrl?: (url: string) => boolean;
+    /** Replacement for the image node (same name and attributes), e.g. with a render policy. */
+    image?: AnyExtension;
+}
+/**
+ * The node/mark set, identical in the editor and in headless use so the same markdown
+ * produces the same document everywhere. `headingLevels` limits what input rules,
+ * shortcuts and pasted HTML can create; the heading `level` attribute itself is not
+ * validated, so existing content at another level (a PIR with an old `## `) still
+ * round-trips unchanged.
+ */
+declare function createSchemaExtensions(options?: SchemaExtensionOptions): AnyExtension[];
+interface EncodeTextOptions {
+    /** The text sits in a table cell, where `|` ends the cell. */
+    inTable?: boolean;
+    /** The next inline node opens a link, so a trailing `!` would turn it into an image. */
+    beforeLink?: boolean;
+    /** The text starts a line (first in its block, or after a hard break). Default true. */
+    lineStart?: boolean;
+    /** The text ends an ATX heading, where a trailing ` #` run would be dropped as a closing sequence. */
+    headingEnd?: boolean;
+}
+declare function encodeText(text: string, options?: EncodeTextOptions): string;
+/**
+ * A marked instance of our own: raw HTML is never tokenized (it stays literal text),
+ * and `use()` calls made by Tiptap extensions land here, not on the global `marked`.
+ */
+declare function createMarked(): Marked;
+/**
+ * Applies the narrower text encoding to a Tiptap MarkdownManager. The method is
+ * private upstream; the exact version pin plus the byte-exact fixture suite guard it.
+ */
+declare function patchManager(manager: MarkdownManager): MarkdownManager;
+declare function createManager(extensions: AnyExtension[]): MarkdownManager;
+interface MarkdownBlock {
+    /** Source text of the block without its trailing blank lines. */
+    raw: string;
+    /** Whitespace and reference definitions between the previous block and this one. */
+    lead: string;
+    /** Normalized top-level nodes the block parsed to (usually one). */
+    nodes: JSONContent[];
+    /** JSON keys of `nodes`, for comparison with the live document. */
+    keys: string[];
+    /** Reference definitions (and other text that parses to nothing) inside `lead`. */
+    defs: string[];
+}
+interface MarkdownSource {
+    source: string;
+    blocks: MarkdownBlock[];
+    /** Text after the last block (usually the final newline). */
+    tail: string;
+    /** Reference definitions inside `tail`. */
+    tailDefs: string[];
+    /** Line ending the document uses throughout (CRLF only when every break is CRLF). */
+    eol: string;
+    /** The document the editor loads. */
+    doc: JSONContent;
+}
+/** Stable key of a node for equality; attribute order is fixed by the schema. */
+declare const nodeKey: (node: JSONContent) => string;
+/**
+ * Split markdown into blocks and build the editor document from them. Each block is
+ * parsed alone, so reference-style links render as their literal text (the same as
+ * the UIx Markdown viewer) and a block that fails to parse is kept as literal text.
+ */
+declare function readMarkdown(source: string, manager: MarkdownManager, schema: Schema): MarkdownSource;
+/**
+ * Serialize a document, reusing the source bytes of every unchanged block.
+ * `origin` is the MarkdownSource the document was loaded from.
+ */
+declare function writeMarkdown(doc: JSONContent, origin: MarkdownSource, manager: MarkdownManager): string;
+interface MarkdownPipeline {
+    extensions: AnyExtension[];
+    schema: Schema;
+    manager: MarkdownManager;
+    read: (source: string) => MarkdownSource;
+    write: (doc: JSONContent, origin: MarkdownSource) => string;
+}
+/** Headless pipeline over the editor's node set. */
+declare function createPipeline(options?: SchemaExtensionOptions): MarkdownPipeline;
+
+export { type EncodeTextOptions, type MarkdownBlock, type MarkdownPipeline, type MarkdownSource, type SchemaExtensionOptions, createManager, createMarked, createPipeline, createSchemaExtensions, encodeText, nodeKey, patchManager, readMarkdown, writeMarkdown };

package/dist/rich-text/pipeline.js

@@ -0,0 +1,379 @@
+import { getSchema, renderNestedMarkdownContent } from "@tiptap/core";
+import { MarkdownManager } from "@tiptap/markdown";
+import { ListItem, TaskItem, TaskList } from "@tiptap/extension-list";
+import { TableKit } from "@tiptap/extension-table";
+import { Image } from "@tiptap/extension-image";
+import { StarterKit } from "@tiptap/starter-kit";
+import { Marked } from "marked";
+import { defaultIsSafeUrl } from "../url-policy.js";
+const indentContinuation = (h) => {
+  let first = true;
+  return {
+    ...h,
+    renderChildren: (nodes) => {
+      const out = h.renderChildren(nodes);
+      if (!first) return out;
+      first = false;
+      return out.split("\n").map((line, n) => n > 0 && line ? h.indent(line) : line).join("\n");
+    }
+  };
+};
+const listItemRender = ListItem.config.renderMarkdown;
+const UixListItem = ListItem.extend({
+  renderMarkdown: (node, h, ctx) => listItemRender(node, indentContinuation(h), ctx)
+});
+const UixTaskItem = TaskItem.extend({
+  renderMarkdown: (node, h) => {
+    const prefix = `- [${node.attrs?.checked ? "x" : " "}] `;
+    const [first, ...rest] = node.content ?? [];
+    if (first?.type !== "paragraph" || !(first.content ?? []).some((c) => c.type === "hardBreak")) {
+      return renderNestedMarkdownContent(node, h, prefix);
+    }
+    const lines = [[]];
+    for (const child of first.content ?? []) {
+      if (child.type === "hardBreak") lines.push([]);
+      else lines[lines.length - 1].push(child);
+    }
+    const paragraphs = lines.filter((line) => line.length > 0).map((content) => ({ type: "paragraph", content }));
+    return renderNestedMarkdownContent({ ...node, content: [...paragraphs, ...rest] }, h, prefix);
+  }
+});
+function createSchemaExtensions(options = {}) {
+  const isSafeUrl = options.isSafeUrl ?? defaultIsSafeUrl;
+  return [
+    StarterKit.configure({
+      underline: false,
+      listItem: false,
+      heading: { levels: [...options.headingLevels ?? [1, 2, 3]] },
+      link: {
+        openOnClick: false,
+        autolink: true,
+        linkOnPaste: true,
+        defaultProtocol: "https",
+        // Unsafe links never become marks: pasted or typed, they stay text.
+        isAllowedUri: (url) => isSafeUrl(url),
+        shouldAutoLink: (url) => isSafeUrl(url),
+        HTMLAttributes: { rel: "noopener noreferrer nofollow", target: null }
+      }
+    }),
+    UixListItem,
+    TaskList,
+    UixTaskItem.configure({ nested: true }),
+    TableKit.configure({ table: { resizable: false } }),
+    options.image ?? Image.configure({ inline: true, allowBase64: false })
+  ];
+}
+const ENTITY_AFTER_AMP = /^(?:#\d+;|#x[\da-f]+;|[a-z][a-z\d]*;)/i;
+const TAG_START = /^[a-z/!?]$/i;
+const ASCII_PUNCT = /[!-/:-@[-`{-~]/;
+const LIST_MARKER = /^(?:\d+|[ivxlcdmIVXLCDM]+|[a-zA-Z]{1,2})$/;
+const BACKSLASH = String.fromCharCode(92);
+function encodeText(text, options = {}) {
+  let out = "";
+  const chars = Array.from(text);
+  let lineStart = 0;
+  let inLead = options.lineStart ?? true;
+  for (let i = 0; i < chars.length; i += 1) {
+    const ch = chars[i];
+    const prev = chars[i - 1] ?? "";
+    const next = chars[i + 1] ?? "";
+    if (ch === "\n") {
+      out += ch;
+      lineStart = i + 1;
+      inLead = true;
+      continue;
+    }
+    if (inLead && (ch === " " || ch === "	")) {
+      continue;
+    }
+    const atStart = inLead;
+    inLead = false;
+    const lineRest = chars.slice(i).join("").split("\n")[0];
+    const endOrSpace = next === "" || next === "\n" || /\s/u.test(next);
+    const markerBefore = !atStart && LIST_MARKER.test(out.slice(out.lastIndexOf("\n") + 1));
+    if (
+      // `#` always: marked ends a list item at a line starting with `#`, space or not.
+      atStart && (ch === "#" || /[-+*]/.test(ch) && endOrSpace) || atStart && /[-=*_]/.test(ch) && new RegExp(`^(?:\\${ch}[ \\t]*)+$`).test(lineRest) || markerBefore && /[.)]/.test(ch) && endOrSpace
+    ) {
+      out += BACKSLASH + ch;
+      continue;
+    }
+    if (ch === "#" && options.headingEnd && (prev === "" || /\s/u.test(prev)) && /^#+$/.test(lineRest)) {
+      out += BACKSLASH + ch;
+      continue;
+    }
+    switch (ch) {
+      case BACKSLASH:
+        out += ASCII_PUNCT.test(next) || next === "" ? BACKSLASH + BACKSLASH : BACKSLASH;
+        break;
+      case "`":
+      case "[":
+      case "]":
+      case "~":
+        out += BACKSLASH + ch;
+        break;
+      case "|":
+        out += options.inTable ? BACKSLASH + ch : ch;
+        break;
+      case "&":
+        out += ENTITY_AFTER_AMP.test(chars.slice(i + 1, i + 40).join("")) ? "&amp;" : ch;
+        break;
+      case "<":
+        out += TAG_START.test(next) ? "&lt;" : ch;
+        break;
+      case "!":
+        out += next === "" && options.beforeLink ? BACKSLASH + ch : ch;
+        break;
+      case "*":
+      case "_": {
+        const spaced = (prev === "" || /\s/u.test(prev)) && (next === "" || /\s/u.test(next));
+        const intraword = ch === "_" && /[\p{L}\p{N}]/u.test(prev) && /[\p{L}\p{N}]/u.test(next);
+        out += spaced || intraword ? ch : BACKSLASH + ch;
+        break;
+      }
+      case ">":
+        out += atStart ? BACKSLASH + ch : ch;
+        break;
+      default:
+        out += ch;
+    }
+  }
+  return out;
+}
+function createMarked() {
+  return new Marked({
+    gfm: true,
+    tokenizer: {
+      html: () => void 0,
+      // `<br>` is the one tag read: GFM tables have no other way to hold a line break,
+      // and Tiptap writes hard breaks in cells that way.
+      tag: (src) => {
+        const br = /^<br\s*\/?>/i.exec(src);
+        return br ? { type: "br", raw: br[0] } : void 0;
+      }
+    }
+  });
+}
+const hasLink = (node) => (node?.marks ?? []).some((m) => (typeof m === "string" ? m : m.type) === "link");
+function patchManager(manager) {
+  const internals = manager;
+  internals.encodeTextForMarkdown = function encode(text, node, parentNode) {
+    const inCode = parentNode?.type != null && internals.codeTypes.has(parentNode.type) || (node.marks ?? []).some((m) => internals.codeTypes.has(typeof m === "string" ? m : m.type));
+    if (inCode) return text;
+    const siblings = parentNode?.content ?? [];
+    const index = siblings.indexOf(node);
+    const previous = index > 0 ? siblings[index - 1] : void 0;
+    const next = index >= 0 ? siblings[index + 1] : void 0;
+    return encodeText(text, {
+      inTable: !!internals.uixInTable,
+      beforeLink: hasLink(next) && !hasLink(node),
+      // Unknown position (node not found among its siblings): assume a line start, the safe side.
+      lineStart: index <= 0 || previous?.type === "hardBreak",
+      headingEnd: parentNode?.type === "heading" && (index < 0 || index === siblings.length - 1)
+    });
+  };
+  return manager;
+}
+function serializeNode(manager, node) {
+  const internals = manager;
+  internals.uixInTable = node.type === "table";
+  try {
+    return manager.serialize({ type: "doc", content: [node] }).replace(/^\n+|\n+$/g, "");
+  } finally {
+    internals.uixInTable = false;
+  }
+}
+function createManager(extensions) {
+  return patchManager(new MarkdownManager({ marked: createMarked(), extensions }));
+}
+const SEPARATOR_TOKENS = /* @__PURE__ */ new Set(["space", "def"]);
+const nodeKey = (node) => JSON.stringify(node);
+const normalize = (schema, content) => {
+  if (content.length === 0) return [];
+  const blocks = [];
+  for (const node of content) {
+    if (node.type && schema.nodes[node.type]?.isInline) {
+      const last = blocks[blocks.length - 1];
+      if (last?.type === "paragraph" && last.wrapped) last.content.push(node);
+      else blocks.push({ type: "paragraph", content: [node], wrapped: true });
+    } else {
+      blocks.push(node);
+    }
+  }
+  for (const block of blocks) delete block.wrapped;
+  const doc = schema.nodeFromJSON({ type: "doc", content: blocks });
+  doc.check();
+  return doc.toJSON().content ?? [];
+};
+function readMarkdown(source, manager, schema) {
+  const normalized = source.replace(/\r\n?/g, "\n");
+  const lexed = manager.instance.lexer(normalized);
+  const origin = [];
+  for (let i = 0, o = 0; i <= normalized.length; i += 1, o += 1) {
+    origin.push(o);
+    if (source[o] === "\r" && source[o + 1] === "\n") o += 1;
+  }
+  let cursor = 0;
+  const tokens = lexed.map((t) => {
+    const start = origin[cursor];
+    cursor += t.raw.length;
+    return { type: t.type, raw: source.slice(start, origin[cursor]) };
+  });
+  const joined = lexed.map((t) => t.raw).join("") === normalized ? tokens.map((t) => t.raw).join("") : null;
+  const blocks = [];
+  const eol = /\r\n/.test(source) && !/(^|[^\r])\n/.test(source) ? "\r\n" : "\n";
+  let lead = "";
+  let defs = [];
+  const keepInLead = (raw) => {
+    lead += raw;
+    const text = raw.replace(/\s+$/u, "").replace(/^\s+/u, "");
+    if (text) defs.push(text);
+  };
+  const pushBlock = (raw) => {
+    let nodes;
+    try {
+      nodes = normalize(schema, manager.parse(raw).content ?? []);
+    } catch {
+      nodes = normalize(schema, [{ type: "paragraph", content: [{ type: "text", text: raw }] }]);
+    }
+    if (nodes.length === 0) {
+      keepInLead(raw);
+      return;
+    }
+    blocks.push({ raw, lead, nodes, keys: nodes.map(nodeKey), defs });
+    lead = "";
+    defs = [];
+  };
+  if (joined !== source) {
+    const core = source.replace(/\s+$/u, "");
+    lead = source.slice(0, source.length - source.trimStart().length);
+    if (core.trim()) pushBlock(core.trimStart());
+    const tail = source.slice(core.length);
+    return { source, blocks, tail, tailDefs: [], eol, doc: { type: "doc", content: blocks.flatMap((b) => b.nodes) } };
+  }
+  for (const token of tokens) {
+    if (SEPARATOR_TOKENS.has(token.type) || token.raw.trim() === "") {
+      if (token.type === "def") keepInLead(token.raw);
+      else lead += token.raw;
+      continue;
+    }
+    const leading = /^(?:[ \t]*\r?\n)*/.exec(token.raw)[0];
+    lead += leading;
+    const body = token.raw.slice(leading.length);
+    const core = body.replace(/\s+$/u, "");
+    pushBlock(core);
+    lead += body.slice(core.length);
+  }
+  return {
+    source,
+    blocks,
+    tail: lead,
+    tailDefs: defs,
+    eol,
+    doc: { type: "doc", content: blocks.flatMap((b) => b.nodes) }
+  };
+}
+const isEmptyParagraph = (node) => node.type === "paragraph" && !(node.content ?? []).some((c) => c.type !== "text" || (c.text ?? "").trim() !== "");
+const matchesAt = (children, at, block) => block.keys.every((key, k) => children[at + k] === key);
+const LOOKAHEAD = 8;
+function writeMarkdown(doc, origin, manager) {
+  const content = [...doc.content ?? []];
+  while (content.length > 0 && isEmptyParagraph(content[content.length - 1])) content.pop();
+  if (content.length === 0) {
+    return origin.blocks.length === 0 ? origin.source : "";
+  }
+  const keys = content.map(nodeKey);
+  const { blocks, eol } = origin;
+  const pieces = [];
+  let i = 0;
+  let j = 0;
+  while (i < content.length) {
+    if (j < blocks.length && matchesAt(keys, i, blocks[j])) {
+      pieces.push({ text: blocks[j].raw, slot: j, edited: false });
+      i += blocks[j].keys.length;
+      j += 1;
+      continue;
+    }
+    let skip = 0;
+    for (let d = 1; d <= LOOKAHEAD && j + d < blocks.length; d += 1) {
+      if (matchesAt(keys, i, blocks[j + d])) {
+        skip = d;
+        break;
+      }
+    }
+    let insert = 0;
+    if (j < blocks.length) {
+      for (let d = 1; d <= LOOKAHEAD && i + d < content.length; d += 1) {
+        if (matchesAt(keys, i + d, blocks[j])) {
+          insert = d;
+          break;
+        }
+      }
+    }
+    if (skip && (!insert || skip <= insert)) {
+      j += skip;
+      continue;
+    }
+    let text = serializeNode(manager, content[i]);
+    if (eol !== "\n") text = text.replace(/\n/g, eol);
+    const inPlace = !insert && j < blocks.length && blocks[j].keys.length === 1;
+    pieces.push(inPlace ? { text, slot: j, edited: true } : { text, edited: true });
+    i += 1;
+    if (!insert && j < blocks.length) j += 1;
+  }
+  const blank = eol + eol;
+  const emitted = /* @__PURE__ */ new Set();
+  let out = "";
+  pieces.forEach((piece, n) => {
+    const prev = pieces[n - 1];
+    const slot = piece.slot;
+    const lead = slot !== void 0 ? blocks[slot].lead : "";
+    if (n === 0) {
+      if (slot === 0) {
+        out += lead;
+        emitted.add(0);
+      }
+    } else if (slot !== void 0 && prev?.slot === slot - 1 && // Next to a re-serialized block, only a separator with a blank line is safe.
+    (!(piece.edited || prev.edited) || /\n[ \t]*\r?\n/.test(lead))) {
+      out += lead;
+      emitted.add(slot);
+    } else {
+      out += blank;
+    }
+    out += piece.text;
+  });
+  const last = pieces[pieces.length - 1];
+  const tailKept = last.slot === blocks.length - 1;
+  const lost = [
+    ...blocks.flatMap((block, n) => emitted.has(n) ? [] : block.defs),
+    ...tailKept ? [] : origin.tailDefs
+  ];
+  if (lost.length) out += blank + lost.join(eol);
+  if (tailKept) out += origin.tail;
+  else if (/\n$/.test(origin.tail)) out += eol;
+  return out;
+}
+function createPipeline(options = {}) {
+  const extensions = createSchemaExtensions(options);
+  const schema = getSchema(extensions);
+  const manager = createManager(extensions);
+  return {
+    extensions,
+    schema,
+    manager,
+    read: (source) => readMarkdown(source, manager, schema),
+    write: (doc, origin) => writeMarkdown(doc, origin, manager)
+  };
+}
+export {
+  createManager,
+  createMarked,
+  createPipeline,
+  createSchemaExtensions,
+  defaultIsSafeUrl,
+  encodeText,
+  nodeKey,
+  patchManager,
+  readMarkdown,
+  writeMarkdown
+};

package/dist/rich-text/round-trip.d.ts

@@ -0,0 +1,24 @@
+/** Editor options that change how markdown is read. */
+interface RoundTripOptions {
+    /** As on RichTextEditor. Does not affect round-trip bytes; accepted for parity. */
+    headingLevels?: ReadonlyArray<1 | 2 | 3>;
+    /** As on RichTextEditor. */
+    isSafeUrl?: (url: string) => boolean;
+}
+/**
+ * Load markdown into the RichTextEditor's document model and write it back, exactly as
+ * the editor does when a user opens a field and saves without editing it. Consumers
+ * use it to gate their own content corpus: every stored value should satisfy
+ * `await roundTripMarkdown(md) === md`.
+ *
+ * Runs without a DOM (Node, Vitest, Jest). Asynchronous so the pipeline can be loaded
+ * lazily in future versions without an API change.
+ *
+ * @example
+ * for (const article of corpus) {
+ *   expect(await roundTripMarkdown(article.body)).toBe(article.body);
+ * }
+ */
+declare function roundTripMarkdown(markdown: string, options?: RoundTripOptions): Promise<string>;
+
+export { type RoundTripOptions, roundTripMarkdown };

package/dist/rich-text/round-trip.js

@@ -0,0 +1,11 @@
+import { createPipeline } from "./pipeline.js";
+let shared;
+async function roundTripMarkdown(markdown, options) {
+  const pipeline = options ? createPipeline(options) : shared ?? (shared = createPipeline());
+  const origin = pipeline.read(markdown);
+  const doc = pipeline.schema.nodeFromJSON(origin.doc).toJSON();
+  return pipeline.write(doc, origin);
+}
+export {
+  roundTripMarkdown
+};