rapier-markdown-kit 1.2.45 → 1.2.46

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

@@ -57,8 +57,8 @@ export function writeDocument(text, options) {
   return text + documentTrailer(text, options);
 }
 function unfinishedTrailer(source) {
+  if (!source.includes(OPEN)) return false;
   const at = source.lastIndexOf(OPEN);
-  if (at < 0) return false;
   let fence = null;
   for (const line of source.slice(0, at).split('\n')) {
     const found = /^ {0,3}(`{3,}|~{3,})/.exec(line);

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/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);

package/dist/kit/ledger/transport.mjs

@@ -4,6 +4,7 @@ import {projectInverseSource} from './inverse-source.mjs';
 import {authoredBasis, authoredPlacement, authoredPlacements} from './authored-origin.mjs';
 import {sha256} from './hash.mjs';
 import {canonicalJSON} from './data.mjs';
+import {parseComments, commentSplices, derivedCommentEdits} from '../../spec/md-comments.mjs';
 
 const whole = text => typeof text === 'string' && !/[\uD800-\uDFFF]/u.test(text);
 function admitted(rows) {
@@ -59,7 +60,65 @@ function applyBatch(text, rows) {
   return {text: after, splices: exact};
 }
 
-export function transposeRecord(base, splices, id, records) {
+export function transposeRecord(base, splices, id, records, derivedCommentIndex) {
+  const comments = transposeCommentRecord(base, splices, id, records, derivedCommentIndex);
+  return comments || transposeTextRecord(base, splices, id, records);
+}
+
+function commentRecordProof(source, splices, index) {
+  if (typeof source !== 'string' || !source.includes('<!-- md-comments:') ||
+      !Array.isArray(splices) || !Number.isSafeInteger(index) || index !== splices.length - 1) return null;
+  try {
+    const parsed = parseComments(source), proof = derivedCommentEdits(source, splices);
+    if (!parsed.record || parsed.reason || !parsed.current || !proof || proof.edits.length !== index ||
+        canonicalJSON(proof.edits) !== canonicalJSON(splices.slice(0, index))) return null;
+    let start = parsed.record.start;
+    for (const row of proof.edits) {
+      if (row.pos >= start || row.pos + row.removed.length > start) return null;
+      start += row.inserted.length - row.removed.length;
+    }
+    const derived = commentSplices(source, proof.edits);
+    if (derived.length !== 1 || canonicalJSON(derived[0]) !== canonicalJSON(splices[index])) return null;
+    return {parsed, edits: proof.edits, text: _rapierTransformSplices(source, splices)};
+  } catch (_) { return null; }
+}
+
+function transposeCommentRecord(base, splices, id, records, derivedCommentIndex) {
+  if (!Array.isArray(records) || !records.length) return null;
+  const local = commentRecordProof(base, splices, derivedCommentIndex);
+  if (!local) return null;
+  const bodyRecords = []; let current = base;
+  for (const record of records) {
+    const proof = commentRecordProof(current, record.splices, record.derivedCommentIndex);
+    if (!proof) return null;
+    bodyRecords.push({...record, splices: proof.edits}); current = proof.text;
+  }
+  const moved = transposeTextRecord(local.parsed.body, local.edits, id, bodyRecords);
+  const derive = (source, rows) => {
+    const parsed = parseComments(source); let start = parsed.record?.start;
+    if (!parsed.record || parsed.reason || !parsed.current) throw new RangeError('canonical_act_rebase_conflict');
+    for (const row of rows) {
+      if (row.pos >= start || row.pos + row.removed.length > start) throw new RangeError('canonical_act_rebase_conflict');
+      start += row.inserted.length - row.removed.length;
+    }
+    const footer = commentSplices(source, rows), splices = [...rows, ...footer];
+    const text = _rapierTransformSplices(source, splices), after = text === null ? null : parseComments(text);
+    if (!after?.record || after.reason || !after.current) throw new RangeError('canonical_act_rebase_conflict');
+    return {text, splices, footer};
+  };
+  const accepted = derive(current, moved.splices);
+  let reciprocal = local.text;
+  const against = moved.against.map(record => {
+    const value = derive(reciprocal, record.splices); reciprocal = value.text;
+    return {...record, splices: value.splices};
+  });
+  if (reciprocal !== accepted.text || parseComments(accepted.text).body !== moved.text)
+    throw new RangeError('canonical_transport_invalid');
+  return {text: accepted.text, splices: accepted.splices, against,
+    sourceIndices: [...moved.sourceIndices, ...accepted.footer.map(() => derivedCommentIndex)]};
+}
+
+function transposeTextRecord(base, splices, id, records) {
   if (typeof base !== 'string' || !Array.isArray(splices) || typeof id !== 'string' || !Array.isArray(records))
     throw new RangeError('canonical_transport_invalid');
   let source = base, current = base;
@@ -305,7 +364,7 @@ function authoredReplay(base, records, append = null) {
           throw new RangeError('canonical_origin_invalid');
         const accepted = projectInverse(text, aligned.records, id);
         moved = {text: accepted.after, splices: accepted.splices};
-      } else moved = transposeRecord(basis.text, origin.splices, id, crossed);
+      } else moved = transposeRecord(basis.text, origin.splices, id, crossed, original.derivedCommentIndex);
       if (_rapierTransformSplices(text, moved.splices) !== moved.text) throw new RangeError('canonical_origin_invalid');
       placed.push({...original, splices: moved.splices}); text = moved.text; ids.add(id);
       if (original.derivedCommentIndex != null) sourceIndices.set(id, moved.sourceIndices);

package/dist/kit/ledger.d.mts

@@ -2,17 +2,32 @@
 // rapier-markdown-kit/rapier-ledger: a document's edit history with authorship, Undo of any act and offline merge.
 // Offsets count UTF-16 code units; splices run in their recorded order.
 export type ActorKind = 'human' | 'agent' | 'system';
-export interface Actor { kind: ActorKind; id: string; }
+export interface Actor { kind: ActorKind; id: string; name?: string; }
 export type DocKind = 'markdown' | 'text' | 'code';
 export interface Metadata { filename: string; docKind: DocKind; }
+export interface MetadataEffect {
+  filename?: {before: string; after: string};
+  docKind?: {before: DocKind; after: DocKind};
+}
+export type LedgerData = null | boolean | number | string | LedgerData[] | {[key: string]: LedgerData};
 export interface Splice { pos: number; removed: string; inserted: string; }
 export interface Transaction {
   id: string; documentAuthority: string; baseRevision: number; revision: number; actor: Actor;
-  transport: string; operation: string; requestId: string | null; sourceTransactionId: string | null;
-  affectedBlockIds: string[]; parent: string | null; reverts: string | null; reapplies: string | null;
-  createdAt: string | null; turnId?: string; sourceTransactionIds?: string[];
+  transport: 'platform' | 'webmcp'; operation: string; requestId: string | null; sourceTransactionId: string | null;
+  affectedBlockIds: number[]; parent: string | null; reverts: string | null; reapplies: string | null;
+  createdAt: number | null; turnId?: string | null; sourceTransactionIds?: string[];
+  label?: string | null; turnLabel?: string | null; turnBaseRevision?: number;
+  contribution?: string; contributionBaseRevision?: number; remoteTransactionId?: string;
+}
+export interface AuthoredPlacement { basis: string[]; source: string; splices: Splice[]; }
+/** A retained journal may omit navigation splices: the target's exact rows supply them. */
+export interface JournalRecord {
+  transaction: Transaction; splices?: Splice[]; beforeHash: string; afterHash: string;
+  metadata?: MetadataEffect; authored?: AuthoredPlacement; derivedCommentIndex?: number;
+  changeSet?: {[key: string]: LedgerData};
 }
-export interface LedgerRecord { transaction: Transaction; splices: Splice[]; beforeHash: string; afterHash: string; metadata?: Record<string, unknown>; authored?: unknown; }
+/** An exported envelope expands every navigation record to exact splices. */
+export interface LedgerRecord extends JournalRecord { splices: Splice[]; }
 /** rapier-ledger/2: plain JSON. */
 export interface LedgerEnvelope {
   format: 'rapier-ledger/2';
@@ -24,9 +39,9 @@ export interface LedgerEnvelope {
   sha256: string;
 }
 /** Runs of [start, end, actor kind, actor id, createdAt] over the current text. */
-export interface AuthorshipEnvelope { format: 'rapier-authorship/1'; sha256: string; runs: [number, number, ActorKind, string, string | number | null][]; }
+export interface AuthorshipEnvelope { format: 'rapier-authorship/1'; sha256: string; runs: [number, number, ActorKind, string, number | null][]; }
 export interface ReadLedger { ledger: LedgerEnvelope; text: string; metadata: Metadata; root: string; revision: number; complete: boolean; }
-export interface LedgerInput { text: string; metadata: Metadata; records: LedgerRecord[]; documentAuthority?: string; revision?: number; root?: string; complete?: boolean; }
+export interface LedgerInput { text: string; metadata: Metadata; records: JournalRecord[]; earlier?: JournalRecord[]; documentAuthority?: string; revision?: number; root?: string; complete?: boolean; }
 
 /** A new ledger with no history. Give every copy that may later merge the same documentAuthority. */
 export function openLedger(text: string, options?: {filename?: string; docKind?: DocKind; documentAuthority?: string}): LedgerEnvelope;
@@ -34,20 +49,31 @@ export function exportLedger(input: LedgerInput): LedgerEnvelope;
 /** Verifies the envelope (and, when given, that it describes this text and metadata); throws when it does not. */
 export function readLedger(input: LedgerEnvelope, expectedText?: string, expectedMetadata?: Metadata): ReadLedger;
 /** Records one replacement of the whole text as an act by `actor`. */
-export function replaceLedgerText(input: LedgerEnvelope, text: string, options?: {actor?: Actor; operation?: string; at?: string}): LedgerEnvelope;
+export function replaceLedgerText(input: LedgerEnvelope, text: string, options?: {actor?: Actor; operation?: string; at?: number | null}): LedgerEnvelope;
 export function ledgerWithStart(input: LedgerEnvelope, text: string): LedgerEnvelope;
-export function historyEnvelope(input: LedgerEnvelope, segmentIdentity?: unknown[], expectedText?: string, expectedMetadata?: Metadata): Record<string, unknown>;
+export interface HistoryEnvelope<Segment = unknown> {
+  schemaVersion: 5; documentAuthority: string; documentRevision: number;
+  ledger: LedgerRecord[]; branch: string[]; cursor: number; earliestRevision: number;
+  earliestHash: string; sourceRootId: string; earliestMetadata: Metadata; documentMetadata: Metadata;
+  segmentIdentity: Segment[]; historyComplete: boolean; trimReason: '' | 'carried_start'; trimmedBytes: 0;
+}
+export function historyEnvelope<Segment = unknown>(input: LedgerEnvelope, segmentIdentity?: Segment[], expectedText?: string, expectedMetadata?: Metadata): HistoryEnvelope<Segment>;
 /** The actor id an agent writes under, for a door and an agent name. */
-export function agentActorId(door: string, agent: string): string;
+export function agentActorId(door: string, agent?: {name: string} | null): string;
 export function textRoot(text: string): string;
 export function rootAfter(root: string, splice: Splice): string;
-export function sha256State(): {update(text: string): unknown; digest(): string};
+/** Feed bytes, then call finish once. `bytes` counts the input supplied so far. */
+export function sha256State(): {update(input: Uint8Array): void; finish(): string; readonly bytes: number};
 
 export function authorship(input: LedgerEnvelope): AuthorshipEnvelope;
 export function readAuthorship(input: AuthorshipEnvelope, text: string): AuthorshipEnvelope;
 export function ledgerFromAuthorship(input: AuthorshipEnvelope, text: string, documentAuthority: string, metadata: Metadata): LedgerEnvelope;
 
-export interface MergeConflict { kind: string; code?: string; actId?: string; [key: string]: unknown; }
+export type MergeConflict =
+  | {kind: 'identity'; code: 'act_identity_conflict' | 'act_order_conflict'; actId?: string}
+  | {kind: 'history'; code: 'record_transport_conflict'}
+  | {kind: 'metadata'; code: 'metadata_assignment_conflict' | 'inverse_target_unavailable' | 'record_transport_conflict'; fields?: (keyof Metadata)[]}
+  | (TextMergeConflict & {code: 'text_overlap_unpreserved'});
 export interface MergeResult {
   text: string; metadata: Metadata; ledger: LedgerEnvelope;
   /** False when a person must review: conflicts, or Will keep regions that differ. */
@@ -60,29 +86,109 @@ export function merge(first: LedgerEnvelope, second: LedgerEnvelope): MergeResul
 export function transportInterval(start: number, end: number, splices: Splice[]): {start: number; end: number} | null;
 export function transportTouchedInterval(start: number, end: number, splices: Splice[]): {start: number; end: number};
 
-export interface HistoryInput { source: string; metadata: Metadata; records: LedgerRecord[]; revision: number; earliestRevision: number; complete: boolean; }
-export interface HistoryFailure { ok?: false; code: string; [key: string]: unknown; }
+export type HistoryTransaction = Pick<Transaction, 'id' | 'baseRevision' | 'revision' | 'actor' | 'createdAt'> & Partial<Transaction>;
+export interface HistoryRecord {
+  transaction: HistoryTransaction; splices?: Splice[]; beforeHash?: string; afterHash?: string;
+  metadata?: MetadataEffect; authored?: AuthoredPlacement; derivedCommentIndex?: number;
+  changeSet?: {[key: string]: LedgerData};
+}
+export interface HistoryInput {
+  source: string; metadata: Metadata; records: HistoryRecord[];
+  revision?: number; earliestRevision?: number; earliestRoot?: string; complete?: boolean;
+}
+export interface HistoryFailure {
+  ok: false;
+  reason: 'history_invalid' | 'history_unavailable' | 'range_invalid' | 'act_unavailable' | 'act_invalid' | 'act_forbidden' | 'will_refused';
+}
+export interface HistoryAct {
+  id: string; actor: Actor; createdAt: number | null; baseRevision: number; revision: number; operation: string;
+  turnId?: string; contribution?: string; sourceTransactionId?: string; sourceTransactionIds?: string[];
+  reverts?: string; reapplies?: string; label?: LedgerData; affectedBlockIds?: number[];
+  metadata?: MetadataEffect; active?: boolean;
+}
+export interface HistoryGroup { id: string; actor: Actor; actIds: string[]; createdAt: number | null; turnId?: string; }
+export interface HistorySnapshot { source: string; revision: number; earliestRevision: number; complete: boolean; }
+export interface HistoryReplay extends HistorySnapshot {
+  ok: true; initialSource: string; metadata: Metadata; initialMetadata: Metadata;
+  acts: HistoryAct[]; effectiveActIds: string[]; groups: HistoryGroup[];
+}
+export interface HistorySourceBefore extends HistorySnapshot { ok: true; metadata: Metadata; act: HistoryAct; }
+export interface HistoryRange { from?: number; to?: number; actId?: string; }
+export interface HistorySourceRange { from: number; to: number; source: string; }
+export interface ProjectedHistoryAct extends HistoryAct { before: HistorySourceRange; after: HistorySourceRange; }
+export interface HistoryProjection extends HistorySnapshot, HistorySourceRange {
+  ok: true; acts: ProjectedHistoryAct[]; groups: HistoryGroup[]; before?: HistorySourceRange;
+}
+export interface HistoryBlock<Id = unknown> { id: Id; from: number; to: number; }
+export interface HistoryPlaces<Id = unknown> extends HistorySnapshot {
+  ok: true; initialSource: string; acts: HistoryAct[];
+  blocks: (HistoryBlock<Id> & {source: string; acts: ProjectedHistoryAct[]})[]; reversed: string[];
+}
+export interface UndoHunk {
+  actId: string; spliceIndex: number; hunkIndex: number; splice: Splice;
+  beforeSource: string; actSource: string; priorSplices: Splice[];
+}
+export interface SelectiveUndoOptions {
+  actor?: Actor;
+  /** Retain this exact hunk while reversing the other selected hunks. */
+  keepHunk?: (hunk: UndoHunk) => boolean;
+  /** Refinements must replay to the same exact text as the supplied splice. */
+  splitSplice?: (input: {actId: string; beforeSource: string; splice: Splice}) => Splice[];
+}
+export interface SupersededHunk { actId: string; hunk: string; laterActIds: string[]; reason: 'later_edit' | 'already_undone'; }
+export interface SelectiveUndo {
+  ok: true; splices: Splice[]; after: string; actIds: string[]; sourceTransactionIds: string[];
+  metadata: MetadataEffect | null; afterMetadata: Metadata; effectChanged: boolean; unchanged: boolean;
+  superseded: SupersededHunk[]; overlaps: SupersededHunk[];
+}
 /** Reverses chosen acts while later work stays. */
-export function selectiveUndo(input: HistoryInput, actIds: string[], options?: {actor?: Actor; splitSplice?: (...args: unknown[]) => unknown}): Record<string, unknown> | HistoryFailure;
-export function replayHistory(input: HistoryInput): unknown;
-export function sourceBefore(input: HistoryInput, actId: string): unknown;
-export function historyProjection(input: HistoryInput, range?: {from?: number; to?: number; actId?: string}): unknown;
-export function historyProjections(input: HistoryInput, ranges: unknown[]): unknown;
-export function historyPlaces(input: HistoryInput, blocks: unknown[]): unknown;
-export function groupHistoryActs(acts: unknown[]): unknown;
-export function pictureHistorySplices(input: unknown, target: unknown, redo: boolean): Splice[] | null;
-export function transposeSource(base: string, splices: Splice[], client: unknown, log: unknown): unknown;
-export function authoredBasis(...args: unknown[]): unknown;
-export function authoredPlacement(...args: unknown[]): unknown;
-export function authoredHistory(base: string, records: LedgerRecord[], selected?: unknown): unknown;
-export function transposeAuthored(base: string, records: LedgerRecord[], incoming: unknown, submitted: unknown): unknown;
+export function selectiveUndo(input: HistoryInput, actIds: string[], options?: SelectiveUndoOptions): SelectiveUndo | HistoryFailure;
+export function replayHistory(input: HistoryInput): HistoryReplay | HistoryFailure;
+export function sourceBefore(input: HistoryInput, actId: string): HistorySourceBefore | HistoryFailure;
+export function historyProjection(input: HistoryInput, range?: HistoryRange): HistoryProjection | HistoryFailure;
+export function historyProjections(input: HistoryInput, ranges: (HistoryRange | undefined)[]): {ok: true; projections: (HistoryProjection | HistoryFailure)[]} | HistoryFailure;
+export function historyPlaces<Id>(input: HistoryInput, blocks: HistoryBlock<Id>[]): HistoryPlaces<Id> | HistoryFailure;
+export function groupHistoryActs(acts: Pick<HistoryAct, 'id' | 'actor' | 'createdAt' | 'turnId'>[]): HistoryGroup[];
+export function pictureHistorySplices(input: Pick<HistoryInput, 'source' | 'records'>, target: HistoryRecord, redo: boolean): Splice[] | null;
+/** Canonical input splices use `pos/removed/inserted`; the host's reciprocal log uses `at/remove/insert`. */
+export interface SourceTransportEntry { client: string; splices: {at: number; remove: number; insert: string}[]; }
+export interface AuthoredRecord {
+  transaction: Pick<Transaction, 'id'> & Partial<Transaction>; splices: Splice[];
+  authored?: AuthoredPlacement; metadata?: MetadataEffect; derivedCommentIndex?: number;
+}
+export interface SourceTransposition {
+  text: string; splices: Splice[]; sourceIndices: number[];
+  against: {transaction: {id: string}; splices: Splice[]}[];
+}
+export interface AuthoredHistory<Record extends AuthoredRecord = AuthoredRecord> {
+  text: string; records: Record[]; origins: Map<string, AuthoredPlacement>;
+}
+export interface ProjectedAuthoredHistory<Record extends AuthoredRecord = AuthoredRecord> extends AuthoredHistory<Record> {
+  sourceIndices: Map<string, number[]>;
+}
+export interface AuthoredTransposition<Record extends AuthoredRecord = AuthoredRecord> {
+  text: string; splices: Splice[]; submittedBefore: string; submitted: string; against: Record[];
+}
+export function transposeSource(base: string, splices: Splice[], client: string, log: SourceTransportEntry[]): SourceTransposition;
+export function authoredBasis(records: Pick<AuthoredRecord, 'transaction' | 'authored'>[]): string[];
+export function authoredPlacement(source: string, splices: Splice[], basis: string[]): AuthoredPlacement;
+export function authoredHistory<Record extends AuthoredRecord>(base: string, records: Record[], selected: ReadonlySet<string>): ProjectedAuthoredHistory<Record>;
+export function authoredHistory<Record extends AuthoredRecord>(base: string, records: Record[], selected?: null): AuthoredHistory<Record>;
+export function authoredHistory<Record extends AuthoredRecord>(base: string, records: Record[], selected?: ReadonlySet<string> | null): AuthoredHistory<Record> | ProjectedAuthoredHistory<Record>;
+export function transposeAuthored<Record extends AuthoredRecord>(base: string, records: Record[], incoming: AuthoredRecord & {authored: AuthoredPlacement}, submitted: string[]): AuthoredTransposition<Record>;
 
 export {writeDocument, readDocument, writeParts, readParts} from './ledger/carried.mjs';
 
-export interface TextConflict { kind: 'text'; id: string; start: number; end: number; block: string; variants: string[]; }
-export interface TextMerge { text: string; clean: boolean; conflicts: (TextConflict | {kind: string; advisory?: boolean})[]; }
+export interface TextConflictVariant { device: string; text: string; }
+export interface TextConflictDescriptor { start: number; end: number; block: string; variants: TextConflictVariant[]; }
+export interface TextConflict extends TextConflictDescriptor { kind: 'text'; id: string; }
+export type TextMergeConflict =
+  | (TextConflictDescriptor & {kind: 'text' | 'no-ancestor' | 'will' | 'document-bindings' | 'ambiguous-alignment-or-budget'; base: string | null})
+  | {kind: 'existing-conflict'; advisory: true};
+export interface TextMerge { text: string; clean: boolean; conflicts: TextMergeConflict[]; }
+export interface TextMergeOptions { oursId: string; theirsId: string; }
 /** Exact three-way text merge; a region both sides changed becomes a marked choice in the text. */
-export function mergeText(base: string | null, ours: string, theirs: string, options?: Record<string, unknown>): TextMerge;
+export function mergeText(base: string | null, ours: string, theirs: string, options?: TextMergeOptions): TextMerge;
 export function inspectTextConflicts(text: string, options?: {nested?: boolean}): TextConflict[];
-export function resolveTextConflict(text: string, conflict: TextConflict | string, device: unknown): string;
+export function resolveTextConflict(text: string, conflict: TextConflictDescriptor, device: string | number): string;
 export function mapTextConflictVariants(text: string, mapper: (variant: string) => string): string;

package/dist/kit/markdown-it.d.mts

@@ -1,4 +1,4 @@
 // SPDX-License-Identifier: MIT
 // md.use(rapierMarkdown): Self-contained Markdown in markdown-it, with the reference style's markup.
-interface MarkdownItLike { use(plugin: (md: any, ...params: any[]) => unknown, ...params: any[]): any; renderer: {rules: Record<string, unknown>}; core: {ruler: {after(after: string, name: string, rule: (state: any) => unknown): void}}; }
-export function rapierMarkdown<T extends MarkdownItLike>(md: T): T;
+import type {MarkdownParser} from './marks.mjs';
+export function rapierMarkdown<T extends MarkdownParser>(md: T): T;