rapier-markdown-kit 1.2.45 → 1.2.48

package/dist/kit/assets.d.mts

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: MIT
+import type {MarkdownParser} from './marks.mjs';
+import type {Splice} from './ledger.mjs';
+
+/** A parser instance or a factory for the caller's Markdown grammar. */
+export type ParserFactory = MarkdownParser | ((options: {html: boolean; maxNesting: number}) => MarkdownParser);
+export interface ImageDefinition { href: string; title: string; }
+export type ImageCodec = 'image/jxl' | 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif' | 'image/svg+xml';
+export interface DataImage {
+  codec: ImageCodec;
+  byteLength: number;
+  /** UTF-16 offset within the data URL. */
+  payloadStart: number;
+  encoding?: 'percent';
+}
+export interface AssetBlock {
+  id: string;
+  label: string;
+  source: string;
+  url: string;
+  title: string;
+  start: number;
+  end: number;
+  codec: ImageCodec;
+  byteLength: number;
+  encoding?: 'percent';
+  urlStart: number | null;
+  urlEnd: number | null;
+  payloadStart: number | null;
+  payloadEnd: number | null;
+  status: 'unverified' | 'asset_count_limit';
+  active: boolean;
+  topLevel: boolean;
+}
+export interface AssetIndex {
+  assets: Map<string, AssetBlock>;
+  blocks: AssetBlock[];
+  duplicateLabels: Set<string>;
+  appendixStart: number;
+  references: Record<string, ImageDefinition>;
+}
+export interface PackedAssetIndex {
+  blocks: (Omit<AssetBlock, 'source' | 'url'> & {url?: string})[];
+  references: Record<string, ImageDefinition | {row: number; title: string}>;
+  duplicateLabels: string[];
+  appendixStart: number;
+}
+export interface ImageProjection {
+  source: string;
+  records: {start: number; end: number; id: string; codec: ImageCodec; payload: string; url: string}[];
+  references: Record<string, ImageDefinition>;
+}
+export interface AssetInput {label: string; url: string; title?: string;}
+export interface AddressedAsset extends AssetInput {id: string;}
+export interface AssetAppend {
+  source: string;
+  id: string;
+  reference: string;
+  added: boolean;
+  suffix: string;
+}
+export interface AssetOmission {
+  start: number;
+  end: number;
+  chars: number;
+  domain: 'image_bytes';
+  reason: 'embedded_asset';
+  profile: 'embedded';
+  type: string;
+  bytes: number | null;
+}
+export interface AssetSourceStore {
+  readonly length: number;
+  contains(text: string, ignoreCase?: boolean): boolean;
+  readSlice(start: number, end: number): string;
+  read(): string;
+}
+export const IMAGE_LIMITS: Readonly<{bytes: number; sourceChars: number; dimension: number; pixels: number; assets: number}>;
+/** Sets the default parser and opening-front-matter splitter for this module instance. */
+export function configureParser(parser: ParserFactory | null, split?: ((source: string) => {bodyOffset: number}) | null): void;
+export function normalizeLabel(label: unknown): string;
+export function assetTitle(value: unknown): string;
+export function installMarkdownImages<T extends MarkdownParser>(md: T): T;
+export function markdownParser(factory?: ParserFactory): MarkdownParser;
+export function markdownBodyOffset(source: string): number;
+/** Inspects the URL spelling; does not decode or validate its image pixels. */
+export function dataImage(url: unknown): DataImage | null;
+export function parseAssets(source: string, factory?: ParserFactory, bodyOffset?: number): AssetIndex;
+export function documentAssets(source: string, factory?: ParserFactory): AssetIndex;
+export function packAssetIndex(index: AssetIndex, offset?: number): PackedAssetIndex;
+/** Restores a packet from a trusted parse of this exact source. It is not input validation. */
+export function restoreAssetIndex(source: string, packet: PackedAssetIndex, options?: {offset?: number; bodyOffset?: number; factory?: ParserFactory}): AssetIndex;
+export function projectImageDefinitions(source: string, index: AssetIndex): ImageProjection;
+export function blockwiseAssets<T extends {start: number; raw: string}>(source: string, rows: T[], parse?: (raw: string, row: T) => AssetIndex, bodyOffset?: number): AssetIndex | null;
+export function imageEnvironment(source: string, factory?: ParserFactory): {references: Record<string, ImageDefinition>};
+/** Uncertainty retains the definition: a parser failure returns true. */
+export function referenceOccurs(source: string, id: string, factory?: ParserFactory): boolean;
+export function mayRetireImageDefinitions(source: string | AssetSourceStore, splices: Splice[], factory?: ParserFactory, hint?: {excluded?: {start: number; end: number}}): boolean;
+export function retireDeletedImageDefinitions(before: string, after: string, splices: Splice[], factory?: ParserFactory): Splice[];
+export function assetOmissions(source: string): AssetOmission[];
+export function isAssetBlock(raw: string): boolean;
+export function escapeImageAlt(value: unknown): string;
+export function serializeAsset(asset: AssetInput): string;
+/** Appends or reuses an exact image definition; throws on conflicting labels or limits. */
+export function appendAssetText(source: string, asset: AddressedAsset, lineEnding?: '\n' | '\r\n' | '\r', options?: {preserveLabel?: boolean}): AssetAppend;
+export function appendAsset(source: string, asset: AddressedAsset): Promise<AssetAppend>;

package/dist/kit/export-fonts.mjs

@@ -165,7 +165,6 @@ function fontSource(bytes) {
 
 function writeFace(face, source) {
   const properties = {...face.properties, src: source};
-  delete properties['unicode-range'];
   return '@font-face{' + Object.entries(properties).map(([name, value]) => name + ':' + value).join(';') + '}';
 }
 
@@ -188,8 +187,29 @@ function fontRuns(root, {settings, css = '', fontCss = '', faces = fontFaces(fon
         '--md-font-main': settings?.mainfont?.css || settings?.sansfont?.css || FAMILY,
         '--md-font-mono': settings?.monofont?.css || MONO}};
     const computed = new WeakMap();
-    let priorFace = null, priorStyle = '';
-    const breakRun = () => { priorFace = null; priorStyle = ''; };
+    let pending = null, segmenter;
+    const breakRun = () => {
+      if (!pending) return;
+      const {text, families, state} = pending;
+      let prior = new Set();
+      for (const {segment} of (segmenter ||= new Intl.Segmenter(undefined, {granularity: 'grapheme'})).segment(text)) {
+        const selected = new Set();
+        for (const character of segment) for (const family of families) {
+          const candidates = faces.filter(face => face.family === family && unicodeIncludes(face, character));
+          if (!candidates.length) continue;
+          candidates.sort((a, b) => stretchOrder(a, b, state['font-stretch']) ||
+            styleDistance(a, state['font-style']) - styleDistance(b, state['font-style']) ||
+            weightDistance(a, state['font-weight']) - weightDistance(b, state['font-weight']));
+          selected.add(candidates[0]); break;
+        }
+        for (const face of selected) {
+          if (prior.has(face)) face.runs[face.runs.length - 1] += segment;
+          else face.runs.push(segment);
+        }
+        prior = selected;
+      }
+      pending = null;
+    };
     function styleOf(element) {
       if (computed.has(element)) return computed.get(element);
       const parent = element === root ? initial : styleOf(element.parentElement || root);
@@ -231,22 +251,10 @@ function fontRuns(root, {settings, css = '', fontCss = '', faces = fontFaces(fon
       else if (state['text-transform'] === 'capitalize') text = text.replace(/(^|\s)(\p{L})/gu, (_, gap, letter) => gap + letter.toUpperCase());
       const families = splitCss(state['font-family'], ',').filter(name => /^\s*['"]/.test(name) || !CSS_GENERIC_FONT_FAMILIES.includes(unquote(name).toLowerCase()))
         .map(name => unquote(name).toLowerCase());
-      const runStyle = [state['font-weight'], state['font-style'], state['font-stretch']].join('/');
-      for (const character of text) {
-        let selected = null;
-        for (const family of families) {
-          const candidates = faces.filter(face => face.family === family && unicodeIncludes(face, character));
-          if (!candidates.length) continue;
-          candidates.sort((a, b) => stretchOrder(a, b, state['font-stretch']) ||
-            styleDistance(a, state['font-style']) - styleDistance(b, state['font-style']) ||
-            weightDistance(a, state['font-weight']) - weightDistance(b, state['font-weight']));
-          selected = candidates[0]; break;
-        }
-        if (!selected) { breakRun(); continue; }
-        if (selected === priorFace && runStyle === priorStyle) selected.runs[selected.runs.length - 1] += character;
-        else selected.runs.push(character);
-        priorFace = selected; priorStyle = runStyle;
-      }
+      const key = JSON.stringify([families, state['font-weight'], state['font-style'], state['font-stretch']]);
+      if (pending?.key !== key) breakRun();
+      if (pending) pending.text += text;
+      else pending = {text, families, state, key};
     }
     function walk(element) {
       const name = element.localName?.toLowerCase();
@@ -277,6 +285,7 @@ function fontRuns(root, {settings, css = '', fontCss = '', faces = fontFaces(fon
       if (boundary) breakRun();
     }
     walk(root);
+    breakRun();
   } finally {
     if (oldClass == null) root.removeAttribute('class'); else root.setAttribute('class', oldClass);
   }

package/dist/kit/index.d.mts

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: MIT
+export {
+  INDENT_LIMIT,
+  SPACING_FIELDS,
+  alignments,
+  decodeLayoutAttribute,
+  fields,
+  formatLayout,
+  imageStyle,
+  indentLevel,
+  linesHeightCss,
+  objectHeight,
+  parseLayout,
+  parseLayoutAttribute,
+  stepIndent,
+  textLayout,
+  textStyle,
+  validLayout,
+  wrapColumnFloor,
+  wrapNeighbour,
+  wrapTextBlock,
+  wraps
+} from './layout.mjs';
+export {
+  FONT_STACKS,
+  INK_CLOSE,
+  INK_INT_MAX,
+  INK_KINDS,
+  INK_OPEN_PATTERN,
+  INK_PATH_MAX,
+  PAGE_BREAK_MARKER,
+  TEXT_COLOR_NAMES,
+  fontFamilyCss,
+  formatColorRun,
+  formatFontRun,
+  formatInkOpen,
+  formatInkOpenFromBody,
+  formatInkRun,
+  formatPageBreak,
+  hasInkMarker,
+  inkOpenBody,
+  isInkClose,
+  isPageBreakBlock,
+  isPageBreakLine,
+  matchInkOpen,
+  mayRetireInk,
+  normalizeFontFamily,
+  pairInkMarkers,
+  pairInkSpans,
+  pairMarkers,
+  parseInkBody,
+  parseInkOpen,
+  prepareInkPaste,
+  quotedWillSpan,
+  readInkMatch,
+  scanInkMarkers,
+  sliceInkArrows,
+  stripInkMarkers,
+  typography,
+  typographySourceRanges
+} from './marks.mjs';
+export {
+  alphaProfile,
+  bandsProfile,
+  besideSlices,
+  boxClearance,
+  captureFontAuthority,
+  columnsFilled,
+  createLineMeasurer,
+  createPreparationScope,
+  edgeLines,
+  edgeMarks,
+  flowLines,
+  frameScale,
+  imageBox,
+  imageOnly,
+  invalidateRichMetrics,
+  layoutNextRichInlineLineRange,
+  lineMetrics,
+  linesHeight,
+  linesSlices,
+  linesTop,
+  mapFragment,
+  materializeRichInlineLineRange,
+  parseProfile,
+  pictureSlices,
+  polygonProfile,
+  prepareRichParagraph,
+  rasterReserved,
+  rasterTiltProfile,
+  rotatedBoundsRad,
+  rotatedRasterAlpha,
+  serializeProfile,
+  slotSequence,
+  slotsForBand,
+  supportsRichStyle,
+  wrapShape
+} from './model.mjs';
+export {
+  evaluateWill,
+  hasWillMarkers,
+  parseWill,
+  stripOneTerminator,
+  terminatorWidth,
+  willGovern,
+  willIntentOf,
+  willMarkerOf,
+  willOffsetBefore,
+  willRegionsIn,
+  willTouchesMarker,
+  willTransition
+} from './will.mjs';
+export {
+  IMAGE_LIMITS,
+  appendAsset,
+  appendAssetText,
+  assetOmissions,
+  assetTitle,
+  blockwiseAssets,
+  configureParser,
+  dataImage,
+  documentAssets,
+  escapeImageAlt,
+  imageEnvironment,
+  installMarkdownImages,
+  isAssetBlock,
+  markdownBodyOffset,
+  markdownParser,
+  mayRetireImageDefinitions,
+  normalizeLabel,
+  packAssetIndex,
+  parseAssets,
+  projectImageDefinitions,
+  referenceOccurs,
+  restoreAssetIndex,
+  retireDeletedImageDefinitions,
+  serializeAsset
+} from './assets.mjs';
+export {
+  createMarkdownRenderer,
+  createPrintRenderer,
+  createRenderSanitizer,
+  createRenderStyles,
+  createRenderer,
+  exportFontCss,
+  fontRequests,
+  requireDocumentFonts,
+  waitForFontRequests,
+  waitForFonts
+} from './render-entry.mjs';
+export * as ledger from './ledger.mjs';

package/dist/kit/layout.d.mts

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+export {};
+export type Alignment = 'left' | 'center' | 'right' | 'justify';
+export type Wrap = 'around' | 'beside' | 'box' | 'behind' | 'front';
+export type LineSpacing = number | `${number}pt` | `${number}pt+`;
+export interface TextLayout {
+  first?: number;
+  indent?: number;
+  marker?: number;
+  hyphens?: 'auto';
+  caps?: 'small';
+  hanging?: 'on';
+  before?: number;
+  after?: number;
+  line?: LineSpacing;
+}
+interface LayoutFacts extends TextLayout {
+  rotate?: number;
+  opacity?: number;
+  lock?: 'on';
+}
+type LayoutSize = {width?: number; lines?: never} | {lines?: number; width?: never};
+type LayoutPosition =
+  | {align?: Alignment; wrap?: never; x?: never; y?: never}
+  | {align?: never; wrap: Wrap; x?: number; y?: number}
+  | {align?: never; wrap?: never; width: number; x?: number; y?: never};
+/** Numeric bounds and precision are checked by validLayout and formatLayout. */
+export type Layout = LayoutFacts & LayoutSize & LayoutPosition;
+export type LayoutField = 'align' | 'width' | 'lines' | 'wrap' | 'x' | 'y' | 'rotate' | 'opacity' |
+  'first' | 'indent' | 'marker' | 'lock' | 'hyphens' | 'caps' | 'hanging' | 'before' | 'after' | 'line';
+export const fields: Set<LayoutField>;
+export const SPACING_FIELDS: readonly ['before', 'after', 'line'];
+export const alignments: Set<Alignment>;
+export const wraps: Set<Wrap>;
+export const INDENT_LIMIT: 64;
+export function indentLevel(value: unknown): value is number;
+export function stepIndent(value: number | null | undefined, step: number): number;
+export function validLayout(value: unknown): value is Layout;
+export function parseLayout(comment: string): Layout | null;
+export function decodeLayoutAttribute(value: string | null | undefined): string;
+export function parseLayoutAttribute(value: string | null | undefined): Layout | null;
+export function textStyle(value: Layout, options?: {portable?: boolean; pointSize?: number; indentOffset?: number}): string;
+export function textLayout(style: CSSStyleDeclaration | Readonly<Record<string, string>> | null | undefined,
+  options?: {listMarker?: boolean; pointSize?: number; offset?: number}): TextLayout;
+export function imageStyle(value: Layout): string;
+export function linesHeightCss(lines: number): string;
+export interface ObjectSizeAttributes {
+  height?: number | `${number}` | 'auto';
+  viewport?: `${number}x${number}`;
+  resize?: 'scale' | 'reflow';
+}
+export function objectHeight(width: number, naturalHeight: number, attrs: ObjectSizeAttributes, line: number): number;
+export function wrapTextBlock<T extends Element>(element: T | null | undefined): T | null;
+export type WrapClassification<Stop> = string | false | null | undefined | {stop: Stop};
+export function wrapNeighbour<T extends Element, Stop = T | null>(node: T,
+  classify: (node: Element) => WrapClassification<Stop>): Element | Stop | null;
+export function wrapNeighbour<T, Stop = T | null>(node: T,
+  classify: (node: T) => WrapClassification<Stop>, step: (node: T, direction: 1 | -1) => T | null | undefined): T | Stop | null;
+export function wrapColumnFloor(fontSize: number | null | undefined): number;
+/** Throws TypeError when the supplied values do not belong to the closed v1 grammar. */
+export function formatLayout(value: Layout): string;

package/dist/kit/ledger/carried.d.mts

@@ -10,13 +10,19 @@ export function documentTrailer(text: string, parts?: DocumentParts): string;
 /** Splits a saved file into its exact text and verified parts; throws on a damaged or mismatched comment. */
 export function readDocument(source: string): ReadParts;
 export function writeParts(text: string, parts?: DocumentParts): string;
-export function readParts(text: string, elements: unknown): {ledger: LedgerEnvelope | null; authorship: AuthorshipEnvelope | null};
+/** Inert browser script elements or equivalent parsed records; no DOM dependency. */
+export interface CarriedElement { id: string; type: string; textContent: string | null; tagName?: string; }
+export function readParts(text: string, elements: Iterable<CarriedElement>): {ledger: LedgerEnvelope | null; authorship: AuthorshipEnvelope | null};
 export function validateParts(text: string, parts?: DocumentParts): {ledger: LedgerEnvelope | null; authorship: AuthorshipEnvelope | null};
-export function takeParts(html: string, text?: string): {html: string; ledger: LedgerEnvelope | null; authorship: AuthorshipEnvelope | null};
+export function takeParts(html: string, text?: string | null): {html: string; ledger: LedgerEnvelope | null; authorship: AuthorshipEnvelope | null};
 export function encodeCarried(text: string): string;
 export function decodeCarried(text: string): string;
-export interface ComparisonBase { text: string; sha256: string; revision: string; name: string; by: string; at: string; }
-export function readBase(value: Partial<ComparisonBase>): ComparisonBase;
-export function writeBase(text: string, value: Partial<ComparisonBase>): string;
-export function readBaseElements(elements: unknown): ComparisonBase | null;
+export interface ComparisonBase { text: string; sha256: string; revision: string; name: string; by: string; at: string; fonts?: string; }
+export function readBase(value: ComparisonBase): ComparisonBase;
+export function writeBase(text: string, value?: ComparisonBase | null): string;
+export interface ComparisonBaseElement extends CarriedElement {
+  getAttribute?: (name: string) => string | null;
+  name?: string; sha256?: string; revision?: string; by?: string; at?: string; fonts?: string;
+}
+export function readBaseElements(elements: Iterable<ComparisonBaseElement>): ComparisonBase | null;
 export function takeBase(html: string): {html: string; base: ComparisonBase | null};

package/dist/kit/ledger/carried.mjs

@@ -56,11 +56,19 @@ export function documentTrailer(text, options) {
 export function writeDocument(text, options) {
   return text + documentTrailer(text, options);
 }
+function trailerOpening(source) {
+  const marker = '<!-- rapier-carried/1', at = source.lastIndexOf(marker);
+  if (at < 0) return null;
+  if (source.slice(at - 2, at + marker.length + 1) === OPEN) return {start: at - 2, body: at + marker.length + 1};
+  const before = /(?:\r\n|\r|\n){2}$/.exec(source.slice(Math.max(0, at - 4), at));
+  const after = /^(?:\r\n|\r|\n)/.exec(source.slice(at + marker.length, at + marker.length + 2));
+  return before && after ? {start: at - before[0].length, body: at + marker.length + after[0].length} : null;
+}
 function unfinishedTrailer(source) {
-  const at = source.lastIndexOf(OPEN);
-  if (at < 0) return false;
+  const opening = trailerOpening(source);
+  if (!opening) return false;
   let fence = null;
-  for (const line of source.slice(0, at).split('\n')) {
+  for (const line of source.slice(0, opening.start).split(/\r\n?|\n/)) {
     const found = /^ {0,3}(`{3,}|~{3,})/.exec(line);
     if (!found) continue;
     if (!fence) fence = found[1];
@@ -69,17 +77,18 @@ function unfinishedTrailer(source) {
   return !fence;
 }
 export function readDocument(source) {
-  if (!source.endsWith(CLOSE)) {
+  const closing = /(?:\r\n|\r|\n)-->(?:\r\n|\r|\n)$/.exec(source.slice(-7));
+  if (!closing) {
     if (unfinishedTrailer(source)) throw fault('unfinished document metadata');
     return {text: source, ledger: null, authorship: null};
   }
-  const at = source.lastIndexOf(OPEN);
-  if (at < 0) return {text: source, ledger: null, authorship: null};
+  const opening = trailerOpening(source);
+  if (!opening) return {text: source, ledger: null, authorship: null};
   let parts;
-  try { parts = JSON.parse(source.slice(at + OPEN.length, -CLOSE.length)); }
+  try { parts = JSON.parse(source.slice(opening.body, -closing[0].length)); }
   catch (_) { throw fault('invalid document metadata'); }
   if (!parts || Object.keys(parts).length !== 2 || !Object.hasOwn(parts, 'ledger') || !Object.hasOwn(parts, 'authorship')) throw fault('invalid document parts');
-  const text = source.slice(0, at);
+  const text = source.slice(0, opening.start);
   return {text, ...validateParts(text, parts)};
 }
 

package/dist/kit/ledger/format.mjs

@@ -170,6 +170,7 @@ const expandedRows = new WeakMap();
 const sameSplices = (a, b) => a === b || a.length === b.length &&
   a.every((row, i) => row.pos === b[i].pos && row.removed === b[i].removed && row.inserted === b[i].inserted);
 const sameEffect = (a, b) => a === b || !!a && !!b && canonicalJSON(a) === canonicalJSON(b);
+const RECENT_TEXT_LIMIT = 1 << 19;
 let recentLedgers = [];
 function* produceLedger({text, metadata, records, documentAuthority, revision, root, complete = false, earlier = records} = {}, native = false) {
   if (!_rapierValidMetadata(metadata)) throw fault('document metadata required');
@@ -239,9 +240,10 @@ function* produceLedger({text, metadata, records, documentAuthority, revision, r
   const replayedMetadata = prepared.replayMetadata(startMetadata);
   if (!replayedMetadata || canonicalJSON(replayedMetadata) !== canonicalJSON(metadata)) throw fault('metadata does not describe this document');
   const ledger = {...payload, sha256: yield* checksum(envelopeParts(payload), native)};
-  recentLedgers = [{rows: expanded, headText: text, headMetadata: canonicalJSON(metadata), headBytes, startText, startMetadata: {...startMetadata},
-    startFacts, startBytes: bytes, documentAuthority, complete: payload.complete, startRoot, startRevision, chainRoot: payload.head.root,
-    chainRevision: payload.head.revision}, ...recentLedgers.filter(row => row.rows[0] !== expanded[0] && row.documentAuthority === documentAuthority)].slice(0, 4);
+  const others = recentLedgers.filter(row => row.rows[0] !== expanded[0] && row.documentAuthority === documentAuthority);
+  recentLedgers = text.length + startText.length > RECENT_TEXT_LIMIT ? [] : [{rows: expanded, headText: text, headMetadata: canonicalJSON(metadata),
+    headBytes, startText, startMetadata: {...startMetadata}, startFacts, startBytes: bytes, documentAuthority, complete: payload.complete,
+    startRoot, startRevision, chainRoot: payload.head.root, chainRevision: payload.head.revision}, ...others].slice(0, 4);
   ownLedger(ledger);
   proofs.set(ledger, {shell: Array.from(envelopeParts({...ledger, start: {...ledger.start, text: ''}})).join(''), startText,
     text, metadata: {...metadata}, root, revision, prepared: _rapierPrepareHistoryRecords(ledger.records),

package/dist/kit/ledger/source.mjs

@@ -70,13 +70,42 @@ function sourceString(node) {
 }
 const replacements = new WeakMap(), texts = new WeakMap(), edits = new WeakMap();
 export const sourceEdit = source => edits.get(source) || null;
+const INITIAL_LEAF_CHARS = 16384;
 export class HistorySource {
 	#root;
-	constructor(text) { this.#root = sourceLeaf(text); Object.freeze(this); }
+	constructor(text) {
+		if (typeof text === 'string' && text.length > INITIAL_LEAF_CHARS) {
+			const leaves = [];
+			for (let from = 0; from < text.length;) {
+				let to = Math.min(text.length, from + INITIAL_LEAF_CHARS);
+				if (to < text.length && (text.charCodeAt(to - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(to) & 0xfc00) === 0xdc00) to++;
+				leaves.push(sourceLeaf(text, from, to));
+				from = to;
+			}
+			const build = (from, to) => from === to ? null : to - from === 1 ? leaves[from]
+				: sourceNode(build(from, (from + to) >> 1), build((from + to) >> 1, to));
+			this.#root = build(0, leaves.length);
+		} else this.#root = sourceLeaf(text);
+		Object.freeze(this);
+	}
 	static owns(value) { return value !== null && typeof value === 'object' && #root in value; }
 	static #fromRoot(root) { const source = new HistorySource(''); source.#root = root; return source; }
 	static fromParts(parts) {
-		const leaves = Array.from(parts, text => sourceLeaf(text)).filter(Boolean);
+		const leaves = [];
+		for (const text of parts) {
+			if (typeof text !== 'string') throw new TypeError('source string required');
+			if (text.length <= INITIAL_LEAF_CHARS) {
+				const leaf = sourceLeaf(text);
+				if (leaf) leaves.push(leaf);
+				continue;
+			}
+			for (let from = 0; from < text.length;) {
+				let to = Math.min(text.length, from + INITIAL_LEAF_CHARS);
+				if (to < text.length && (text.charCodeAt(to - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(to) & 0xfc00) === 0xdc00) to++;
+				leaves.push(sourceLeaf(text, from, to));
+				from = to;
+			}
+		}
 		const build = (from, to) => from === to ? null : to - from === 1 ? leaves[from]
 			: sourceNode(build(from, Math.floor((from + to) / 2)), build(Math.floor((from + to) / 2), to));
 		return HistorySource.#fromRoot(build(0, leaves.length));

package/dist/kit/ledger/text-merge.mjs

@@ -1,5 +1,8 @@
 // SPDX-License-Identifier: MIT
 import {parseWill, stripOneTerminator} from '../../agent/will.mjs';
+import {diff} from '../../packages/rapier-diff/index.mjs';
+import {transposeRecord} from './transport.mjs';
+import {parseComments, commentSplices, derivedCommentEdits} from '../../spec/md-comments.mjs';
 
 export function willMergeConflict(base, ours, theirs) {
 	const snapshot = text => {
@@ -450,6 +453,32 @@ function textRefineGroup({before, av, bv}, options) {
 	}
 	return textRefineLevel(before, av, bv, options, 'word');
 }
+function mergeDerivedComments(base, ours, theirs, options) {
+  if (!base.includes('<!-- md-comments:')) return null;
+  try {
+    const parsed = [base, ours, theirs].map(parseComments);
+    if (parsed.some(value => !value.record || value.reason || !value.current)) return null;
+    const edits = [ours, theirs].map(text => {
+      const changed = diff(base, text, {_unit: 'char'}).edits;
+      if (changed.length > 64 || changed.some(row => row.coarse)) return null;
+      const rows = changed.map(row => ({pos: row.before[0], removed: base.slice(...row.before),
+        inserted: text.slice(...row.after)})).reverse();
+      const proof = derivedCommentEdits(base, rows);
+      if (!proof) return null;
+      const footer = commentSplices(base, proof.edits);
+      return footer.length === 1 ? {splices: [...proof.edits, ...footer], derivedCommentIndex: proof.edits.length} : null;
+    });
+    if (edits.some(value => !value)) return null;
+    const body = mergeText(...parsed.map(value => value.body), options);
+    if (!body.clean) return null;
+    const [oursId, theirsId] = textDeviceOptions(options);
+    const moved = transposeRecord(base, edits[1].splices, theirsId,
+      [{...edits[0], transaction: {id: oursId}}], edits[1].derivedCommentIndex);
+    if (parseComments(moved.text).body !== body.text) return null;
+    return {text: moved.text, clean: true, conflicts: []};
+  } catch (_) { return null; }
+}
+
 export function mergeText(base, ours, theirs, options = {}) {
 	canonicalNote(ours); canonicalNote(theirs); if (base !== null) canonicalNote(base);
 	const unchanged = value => ({text: value, clean: !value.includes(TEXT_CONFLICT), conflicts: value.includes(TEXT_CONFLICT) ? [{kind: 'existing-conflict', advisory: true}] : []});
@@ -457,6 +486,10 @@ export function mergeText(base, ours, theirs, options = {}) {
 	const willConflict = willMergeConflict(base, ours, theirs);
 	if (!willConflict && base === ours) return unchanged(theirs);
 	if (!willConflict && base === theirs) return unchanged(ours);
+	if (!willConflict && base !== null) {
+		const commented = mergeDerivedComments(base, ours, theirs, options);
+		if (commented) return commented;
+	}
 	const conflicts = []; let text = '', a, b;
 	const conflict = (before, a, b, kind) => {
 		const ab = inspectTextConflicts(a), bb = inspectTextConflicts(b);