rapier-markdown-kit 1.2.33 → 1.2.42

package/dist/agent/vendor/pretext/rich-inline.js

@@ -1,9 +1,10 @@
-/*! Pretext Unreleased (bac1774c0) | MIT; BSD/Unicode/ICU notices in LICENSE | Copyright (c) 2026 Pretext contributors */
+/*! Pretext 1.0.0 + main (0d102a5cd) | MIT; BSD/Unicode/ICU notices in LICENSE | Copyright (c) 2026 Pretext contributors */
                                                               
 import {
   alignToSource,
   analyzeText,
   isCollapsibleSpaceCode,
+  DROPPED,
   HARD_BREAK,
   KIND_BITS,
   OBJECT,
@@ -20,7 +21,6 @@ import {
                       
                       
 } from './analysis.js'
-import { getSegmentEntryWidth,                           } from './entry-geometry.js'
 import { buildLineTextFromRange, buildRangeText, getGraphemeEnds,                       } from './line-text.js'
 import {
   getItemTabAdvance,
@@ -166,7 +166,8 @@ const PRESERVED_WHITE_SPACE = 1 << PRESERVED_SPACE | 1 << TAB
                                                                                                   
                                                                                                
                                                                                                
-                                                                                         
+                                                                                           
+                                                                                
                                
                              
                                          
@@ -300,8 +301,6 @@ export function prepareRichInline(items                                       ,
   // Firefox 156 and Safari 27 prepare CJK styled paragraphs again up to 8% faster with the lists
   // made whole than with each filled by a call and a push a segment (RESEARCH.md, Keeping Work
   // Bounded, JavaScript Engines, under A paragraph's sparse lists made whole).
-  let entryGeometry                                         = null
-  let lineStartProhibitions                               = null
   let breakableLineStartExtras                             = null
   let lineStartExtras                  = null
   let lineEndTrims                  = null
@@ -531,8 +530,6 @@ export function prepareRichInline(items                                       ,
       }
       const units = getSourceUnits(offsets, normalizedStart, textEnd, starts[index] )
       if (units !== null) (sourceUnits ??= new Array                 (flags.length).fill(null))[at] = units
-      if (sub.entryGeometry !== null && sub.entryGeometry[s] !== null) (entryGeometry ??= new Array                             (flags.length).fill(null))[at] = sub.entryGeometry[s] 
-      if (sub.lineStartProhibitions !== null && sub.lineStartProhibitions[s] !== null) (lineStartProhibitions ??= new Array                   (flags.length).fill(null))[at] = sub.lineStartProhibitions[s] 
       if (sub.breakableLineStartExtras !== null && sub.breakableLineStartExtras[s] !== null) (breakableLineStartExtras ??= new Array                 (flags.length).fill(null))[at] = sub.breakableLineStartExtras[s] 
       const startExtra = (sub.lineStartExtras === null ? 0 : sub.lineStartExtras[s] ) + (i > first ? extraWidth : 0)
       if (startExtra !== 0) (lineStartExtras ??= zeroList(flags.length))[at] = startExtra
@@ -621,7 +618,7 @@ export function prepareRichInline(items                                       ,
     itemEndHalts,
     hyphenRooms: discretionaryHyphenContexts !== null && profile.unfitHyphenRetreat === 'reduced-width' ? getHyphenRooms(hyphenWidths, itemSegments, segmentItems) : null,
     insideExtras, fillExtras, openingEdges,
-    emptyObjectSpaces: null, emptyObjectReturns: null,
+    emptyObjectSpaces: null, emptyObjectReturns: null, hangEnds: null,
   }
   // The properties measureAnalysis() gives a text's handle, in its order, then the paragraph's own.
   const data = {
@@ -630,11 +627,9 @@ export function prepareRichInline(items                                       ,
     simpleLineWalkFastPath: simple,
     simpleLineCountFastPath: false,
     breakableFitAdvances,
-    entryGeometry,
     letterSpacing: spacingsDiffer || sharedSpacing === null ? 0 : sharedSpacing,
     discretionaryHyphenWidth: firstTextItem < 0 ? 0 : hyphenWidths[firstTextItem] ,
     discretionaryHyphenContexts,
-    lineStartProhibitions,
     breakableLineStartExtras,
     lineStartExtras,
     lineEndTrims,
@@ -645,6 +640,15 @@ export function prepareRichInline(items                                       ,
   }                                               
   data.segments = segments
   if (hasEmptyObject && profile.emptyAtomicAlwaysFits) setEmptyObjectFacts(segmentData, data, items, itemSegments, segmentItems, source, starts)
+  // Each item is a text frame: a zero-width space after preserved spaces of its own item ends
+  // the run of them that hangs (ParagraphSegmentData, hangEnds).
+  if (preserve && profile.hangsSpacesPerTextFrame && source.includes('\u200B')) {
+    for (let i = 1; i < segmentCount; i++) {
+      if ((segmentFlags[i]  & (KIND_BITS | DROPPED)) === ZERO_WIDTH_BREAK && (segmentFlags[i - 1]  & KIND_BITS) === PRESERVED_SPACE && segmentItems[i] === segmentItems[i - 1]) {
+        ;(segmentData.hangEnds ??= new Uint8Array(segmentCount))[i] = 1
+      }
+    }
+  }
 
   let onlyItem = -1
   for (let index = 0; index < items.length && !paddedOrObject; index++) {
@@ -894,19 +898,13 @@ function getOpeningFit(flags          , from        , to        , extraWidth
 // (`startsLine`), the first of them adds what a line that starts with it does
 // (breakableLineStartExtras), as the walker's line does.
 function getPartWidth(data                  , i        , from        , to        , startsLine         )         {
-  const { breakableFitAdvances, breakableLineStartExtras, entryGeometry, letterSpacing, items } = data
+  const { breakableFitAdvances, breakableLineStartExtras, letterSpacing, items } = data
   const advances = breakableFitAdvances[i] 
   if (to < 0) to = advances.length
-  const entry = from > 0 && entryGeometry !== null ? entryGeometry[i]  : null
-  const entryWidth = entry === null ? null : getSegmentEntryWidth(entry, from, to)
   let w = 0
-  if (entryWidth !== null) {
-    w = entryWidth
-  } else {
-    for (let g = from; g < to; g++) w += advances[g]  + letterSpacing
-    const startExtras = startsLine && breakableLineStartExtras !== null ? breakableLineStartExtras[i]  : null
-    if (startExtras !== null) w += startExtras[from] 
-  }
+  for (let g = from; g < to; g++) w += advances[g]  + letterSpacing
+  const startExtras = startsLine && breakableLineStartExtras !== null ? breakableLineStartExtras[i]  : null
+  if (startExtras !== null) w += startExtras[from] 
   if (items !== undefined && (from > 0 ? items.insideExtras !== null : items.fillExtras !== null)) w += from > 0 ? items.insideExtras [i]  : items.fillExtras [i] 
   return w
 }
@@ -928,7 +926,7 @@ function createOnlyItemLine(
   endGraphemeIndex        ,
 )                      {
   const { onlyItem } = flow
-  const ended = endSegmentIndex >= flow.data.segmentFlags.length
+  const ended = endSegmentIndex >= flow.data.widths.length
   return {
     fragments: [{
       itemIndex: onlyItem,
@@ -974,7 +972,7 @@ function createLine(
   const segmentItems = flow.segmentItems 
   const gapSegments = flow.gapSegments 
   const itemCount = itemSegments.length - 1
-  const endItemIndex = endSegmentIndex >= segmentItems.length ? itemCount : segmentItems[endSegmentIndex] 
+  const endItemIndex = endSegmentIndex >= widths.length ? itemCount : segmentItems[endSegmentIndex] 
   const end                   = { itemIndex: endItemIndex, segmentIndex: endSegmentIndex - itemSegments[endItemIndex] , graphemeIndex: endGraphemeIndex }
   const tabsInAppUnits = getEngineProfile().tabsInAppUnits
   const itemEndHalts = items.itemEndHalts
@@ -1108,7 +1106,7 @@ function createLine(
 // The paragraph's segment a cursor names, or the segment count for one past the last item.
 function getSegmentIndex(flow                            , cursor                  )         {
   const { itemSegments } = flow
-  return cursor.itemIndex < itemSegments.length ? itemSegments[cursor.itemIndex]  + cursor.segmentIndex : flow.data.segmentFlags.length
+  return cursor.itemIndex < itemSegments.length ? itemSegments[cursor.itemIndex]  + cursor.segmentIndex : flow.data.widths.length
 }
 
 export function layoutNextRichInlineLineRange(
@@ -1142,9 +1140,26 @@ function getSourceUnits(offsets            , from        , to        , itemStart
   return units
 }
 
+// Per frozen handle of a paragraph that is one text's handle, the three lists of where its
+// segments are in the item's text (InternalPreparedRichInline), found when a line of it is
+// first materialized. A handle keeps them itself; a frozen one can't take them, so they are
+// kept beside it, as its segments' grapheme ends are (getGraphemeEnds): no line function writes
+// to a frozen handle or to anything it holds, so one the app froze, or a copy of one in a store
+// that freezes its state, materializes as any other. Kept beside every handle, the lookup took
+// a pass that walks and materializes 3,000 of the chat demo's one-item paragraphs, each asked
+// once, 35-47% longer with the handles out of the processor's caches and 7-25% with them in,
+// and 40 of them over and over 1-9% (JavaScriptCore of bun 1.4.2, V8 15.4 and node 23.10's,
+// SpiderMonkey 156, one build a process on the harness's stand-in Canvas, 2026-10-12). Found
+// while preparing, the lists took such paragraphs 6-13% longer to prepare and count once in
+// JavaScriptCore and 12-20% in V8, text seen before, and a third more heap a handle, for lines
+// a long list mostly never paints; found again at every line, walking and materializing took
+// 5-9 times as long, and over 100 times in a paragraph of 6,000 units.
+                                                                                                     
+const textSources = new WeakMap                                         ()
+
 // Per segment of a paragraph that is one text's handle, where its text starts and ends in the
 // item's.
-function findSegmentSources(flow                            )       {
+function findSegmentSources(flow                            )              {
   const { segments } = flow.data
   const offsets = alignToSource(flow.text, segments.join(''), getEngineProfile().lineBreakScan)
   const sourceStarts           = []
@@ -1156,15 +1171,21 @@ function findSegmentSources(flow                            )       {
     sourceEnds.push(flow.text.charCodeAt(end - 1) === 0x0D && flow.text.charCodeAt(end) === 0x0A && segments[i] === '\n' ? end + 1 : end)
     sourceUnits.push(getSourceUnits(offsets, at, at + segments[i] .length, 0))
   }
-  flow.sourceStarts = sourceStarts
-  flow.sourceEnds = sourceEnds
-  flow.sourceUnits = sourceUnits
+  const sources = { sourceStarts, sourceEnds, sourceUnits }
+  if (Object.isFrozen(flow)) {
+    textSources.set(flow, sources)
+  } else {
+    flow.sourceStarts = sourceStarts
+    flow.sourceEnds = sourceEnds
+    flow.sourceUnits = sourceUnits
+  }
+  return sources
 }
 
 // Where unit `unit` of a segment's text is in its item's text.
-function getSourceOffset(flow                            , segmentIndex        , unit        )         {
-  const units = flow.sourceUnits === null ? null : flow.sourceUnits[segmentIndex] 
-  return units === null ? flow.sourceStarts [segmentIndex]  + unit : units[unit] 
+function getSourceOffset(sourceStarts          , sourceUnits                            , segmentIndex        , unit        )         {
+  const units = sourceUnits === null ? null : sourceUnits[segmentIndex] 
+  return units === null ? sourceStarts[segmentIndex]  + unit : units[unit] 
 }
 
 // Bridge from cheap range walking to full fragment text. Lets callers do
@@ -1176,9 +1197,8 @@ export function materializeRichInlineLineRange(
 )                 {
   const flow = getInternalPreparedRichInline(prepared)
   const { data, itemSegments } = flow
-  if (flow.sourceStarts === null) findSegmentSources(flow)
-  const sourceStarts = flow.sourceStarts 
-  const sourceEnds = flow.sourceEnds 
+  let { sourceStarts, sourceEnds, sourceUnits } = flow
+  if (sourceStarts === null) ({ sourceStarts, sourceEnds, sourceUnits } = textSources.get(flow) ?? findSegmentSources(flow))
   const lineEndSegmentIndex = getSegmentIndex(flow, line.end)
   const fragments                               = []
 
@@ -1194,11 +1214,11 @@ export function materializeRichInlineLineRange(
     const endGraphemeIndex = endSegmentIndex < itemEnd ? fragment.end.graphemeIndex : 0
     // Only the fragment a line ends with shows the hyphen of a soft hyphen it ends at.
     const endsLine = i === line.fragments.length - 1 && endSegmentIndex === lineEndSegmentIndex && endGraphemeIndex === line.end.graphemeIndex
-    let sourceStart = startSegmentIndex < itemEnd ? sourceStarts[startSegmentIndex]  : startSegmentIndex > first ? sourceEnds[startSegmentIndex - 1]  : 0
-    if (startGraphemeIndex > 0 && startSegmentIndex < itemEnd) sourceStart = getSourceOffset(flow, startSegmentIndex, getGraphemeEnds(data, startSegmentIndex)[startGraphemeIndex - 1] )
+    let sourceStart = startSegmentIndex < itemEnd ? sourceStarts[startSegmentIndex]  : startSegmentIndex > first ? sourceEnds [startSegmentIndex - 1]  : 0
+    if (startGraphemeIndex > 0 && startSegmentIndex < itemEnd) sourceStart = getSourceOffset(sourceStarts, sourceUnits, startSegmentIndex, getGraphemeEnds(data, startSegmentIndex)[startGraphemeIndex - 1] )
     let sourceEnd = sourceStart
-    if (endGraphemeIndex > 0) sourceEnd = getSourceOffset(flow, endSegmentIndex, getGraphemeEnds(data, endSegmentIndex)[endGraphemeIndex - 1]  - 1) + 1
-    else if (endSegmentIndex > startSegmentIndex) sourceEnd = sourceEnds[endSegmentIndex - 1] 
+    if (endGraphemeIndex > 0) sourceEnd = getSourceOffset(sourceStarts, sourceUnits, endSegmentIndex, getGraphemeEnds(data, endSegmentIndex)[endGraphemeIndex - 1]  - 1) + 1
+    else if (endSegmentIndex > startSegmentIndex) sourceEnd = sourceEnds [endSegmentIndex - 1] 
     fragments.push({
       itemIndex: fragment.itemIndex,
       text: endsLine ? buildLineTextFromRange(data, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex)

package/dist/agent/will.mjs

@@ -162,5 +162,78 @@ function _rapierWillStripOneTerminator(text) {
 		text.charCodeAt(end - 1), end >= 2 ? text.charCodeAt(end - 2) : -1)) : text;
 }
 
+export function willOffsetBefore(rows, offset) {
+	for (let index = rows.length - 1; index >= 0 && offset >= 0; index--) {
+		const {pos, removed, inserted} = rows[index];
+		if (offset >= pos) offset = offset >= pos + inserted.length ? offset - inserted.length + removed.length : -1;
+	}
+	return offset;
+}
+
+function _rapierWillRestores(restores, region, splices, text) {
+	if (!Array.isArray(restores) || region.law !== 'append') return null;
+	const reaching = splices.filter(row => row.pos <= region.end && row.pos + row.removed.length >= region.start &&
+		(row.removed || row.inserted)).toSorted((a, b) => a.pos - b.pos);
+	if (!reaching.length || reaching.some((row, index) => row.pos < region.start || row.pos + row.removed.length > region.end ||
+		(index && row.pos !== reaching[index - 1].pos + reaching[index - 1].removed.length) || !restores.includes(row)) ||
+		!/^(?:\r\n|\r|\n)?$/.test(text.slice(reaching.at(-1).pos + reaching.at(-1).removed.length - region.start))) return null;
+	return reaching;
+}
+
+export function willTransition(beforeText, afterText, splices, markerSplices = splices, {restores = null, restored = null} = {}) {
+	const before = _rapierWillParse(beforeText), after = _rapierWillParse(afterText);
+	if (!before.present && !after.present) return null;
+	const bounds = region => ({start: region.start, end: region.end});
+	const faults = will => will.faults.slice(0, 4).map(({mode, line}) => ({mode, line}));
+	if (before.faults.length) return {law: 'keep', rule: 'before_faulted', faults: faults(before), start: 0, end: beforeText.length};
+	for (const region of before.regions) {
+		const markers = [[region.openerStart, region.openerEnd], [region.closerStart, region.closerEnd]];
+		for (let index = 0; index < splices.length; index++) {
+			const row = splices[index], end = row.pos + row.removed.length;
+			for (const marker of markers) {
+				if (row.removed.length ? row.pos < marker[1] && marker[0] < end : row.pos > marker[0] && row.pos < marker[1])
+					return {law: region.law, rule: 'marker_span_touched', editIndex: index, region: region.index, ...bounds(region)};
+				if (end <= marker[0]) { const shift = row.inserted.length - row.removed.length; marker[0] += shift; marker[1] += shift; }
+			}
+		}
+	}
+	if (after.faults.length) return {law: 'keep', rule: 'result_faulted', faults: faults(after), start: 0, end: beforeText.length};
+	if (before.markers.length !== after.markers.length || before.markers.some((marker, index) => {
+		const next = after.markers[index];
+		return marker.kind !== next.kind || beforeText.slice(marker.start, marker.end) !== afterText.slice(next.start, next.end) ||
+			willOffsetBefore(markerSplices, next.start) !== marker.start || willOffsetBefore(markerSplices, next.end - 1) !== marker.end - 1;
+	})) return {law: 'keep', rule: 'marker_sequence_mismatch', start: 0, end: beforeText.length};
+	for (const region of before.regions) {
+		const was = beforeText.slice(region.start, region.end), next = after.regions[region.index], now = afterText.slice(next.start, next.end);
+		if (region.law === 'keep' && was !== now)
+			return {law: region.law, rule: 'law_violated', region: region.index, ...bounds(region)};
+		if (region.law !== 'append' || _rapierWillStripOneTerminator(now).startsWith(_rapierWillStripOneTerminator(was))) continue;
+		const reaching = _rapierWillRestores(restores, region, splices, was);
+		if (!reaching) return {law: region.law, rule: 'law_violated', region: region.index, ...bounds(region)};
+		restored?.set(region.index, reaching);
+	}
+	return null;
+}
+
+export function evaluateWill(beforeText, splices, {restores = null} = {}) {
+	const invalid = rule => ({outcome: 'invalid', reason: 'precondition', rule});
+	if (typeof beforeText !== 'string' || !beforeText.isWellFormed()) return invalid('invalid_unicode');
+	if (!Array.isArray(splices)) return invalid('malformed_splice');
+	const boundary = (text, at) => !(at > 0 && at < text.length &&
+		(text.charCodeAt(at - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(at) & 0xfc00) === 0xdc00);
+	let afterText = beforeText;
+	for (const row of splices) {
+		if (!row || !Number.isSafeInteger(row.pos) || row.pos < 0 || Object.is(row.pos, -0) ||
+			typeof row.removed !== 'string' || typeof row.inserted !== 'string' ||
+			!row.removed.isWellFormed() || !row.inserted.isWellFormed()) return invalid('malformed_splice');
+		const end = row.pos + row.removed.length;
+		if (end > afterText.length || !boundary(afterText, row.pos) || !boundary(afterText, end)) return invalid('out_of_range_splice');
+		if (afterText.slice(row.pos, end) !== row.removed) return invalid('source_mismatch');
+		afterText = afterText.slice(0, row.pos) + row.inserted + afterText.slice(end);
+	}
+	const refusal = splices.length && willTransition(beforeText, afterText, splices, splices, {restores});
+	return refusal ? {outcome: 'refused', reason: 'document_law', ...refusal} : {outcome: 'applied'};
+}
+
 
 export { hasWillMarkers, _rapierWillParse as parseWill, _rapierWillMarkerOf as willMarkerOf, _rapierWillRegionsIn as willRegionsIn, _rapierWillTouchesMarker as willTouchesMarker, _rapierWillGovern as willGovern, _rapierWillIntentOf as willIntentOf, _rapierWillStripOneTerminator as stripOneTerminator, _rapierWillTerminatorWidth as terminatorWidth };

package/dist/kit/ledger/data.mjs

@@ -17,7 +17,7 @@ export function fields(value, depth, active, sorted = true) {
 }
 export function scalar(value) {
   if (value === null || typeof value === 'boolean') return true;
-  if (typeof value === 'string') { if (/[\uD800-\uDFFF]/u.test(value)) throw fault('unpaired surrogate'); return true; }
+  if (typeof value === 'string') { if (!value.isWellFormed()) throw fault('unpaired surrogate'); return true; }
   return typeof value === 'number' && Number.isFinite(value) && !Object.is(value, -0);
 }
 export function plainData(value) {
@@ -39,16 +39,18 @@ function* quoted(text, whole = true) {
     let end = Math.min(text.length, at + 16384);
     if (end < text.length && (text.charCodeAt(end - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(end) & 0xfc00) === 0xdc00) end--;
     const part = text.slice(at, end);
-    if (whole && /[\uD800-\uDFFF]/u.test(part)) throw fault('unpaired surrogate');
+    if (whole && !part.isWellFormed()) throw fault('unpaired surrogate');
     yield JSON.stringify(part).slice(1, -1); at = end;
   }
   yield '"';
 }
-function* dataParts(value, depth, active, sorted) {
+function* dataParts(value, depth, active, sorted, known = null) {
   if (typeof value === 'string') { yield* quoted(value); return; }
   if (value === null || typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value) && !Object.is(value, -0)) {
     yield JSON.stringify(value); return;
   }
+  const text = known?.(value, depth);
+  if (text !== undefined) { yield text; return; }
   const {array, descriptors, keys} = fields(value, depth, active, sorted);
   active.add(value);
   yield array ? '[' : '{';
@@ -56,14 +58,65 @@ function* dataParts(value, depth, active, sorted) {
     if (i) yield ',';
     const key = keys[i];
     if (!array) { yield* quoted(key, false); yield ':'; }
-    yield* dataParts(descriptors[key].value, depth + 1, active, sorted);
+    yield* dataParts(descriptors[key].value, depth + 1, active, sorted, known);
   }
   yield array ? ']' : '}';
   active.delete(value);
 }
 export function canonicalParts(value, depth = 0, active = new Set()) { return dataParts(value, depth, active, true); }
 export function jsonParts(value) { return dataParts(value, 0, new Set(), false); }
+export function jsonPartsKnown(value, known) { return dataParts(value, 0, new Set(), false, known); }
+export function jsonTextAt(value, depth) { return Array.from(dataParts(value, depth, new Set(), false)).join(''); }
 export function canonicalJSON(value, depth = 0, active = new Set()) { return Array.from(canonicalParts(value, depth, active)).join(''); }
+const ownedRows = new WeakSet(), rowCanonical = new Map();
+let rowCanonicalChars = 0;
+const ROW_CANONICAL_LIMIT = 32 * 1024 * 1024;
+function freezeData(value) {
+  if (!value || typeof value !== 'object' || ownedRows.has(value) || ownedLedgers.has(value)) return value;
+  for (const key of Object.keys(value)) freezeData(value[key]);
+  return Object.freeze(value);
+}
+export function ownRow(row) { if (!ownedRows.has(row)) { freezeData(row); ownedRows.add(row); } return row; }
+const ownedLedgers = new WeakSet();
+export function ownLedger(ledger) {
+  if (ledger && typeof ledger === 'object' && !ownedLedgers.has(ledger)) { freezeData(ledger); ownedLedgers.add(ledger); }
+  return ledger;
+}
+export function isOwnedLedger(ledger) { return !!ledger && ownedLedgers.has(ledger); }
+const rowText = new WeakMap();
+function canonicalRow(row, depth) {
+  if (!ownedRows.has(row)) return canonicalJSON(row, depth);
+  const own = rowText.get(row);
+  if (own?.depth === depth) return own.json;
+  const json = keyedRow(row, depth);
+  rowText.set(row, {depth, json});
+  return json;
+}
+function keyedRow(row, depth) {
+  const id = typeof row.transaction?.id === 'string' ? row.transaction.id : null, seen = JSON.stringify(row);
+  const hit = id === null ? null : rowCanonical.get(id);
+  if (hit && hit.depth === depth && hit.seen.includes(seen)) return hit.json;
+  const json = canonicalJSON(row, depth);
+  if (id !== null && 2 * seen.length + json.length <= ROW_CANONICAL_LIMIT / 4) {
+    const size = entry => entry.seen.reduce((sum, text) => sum + text.length, entry.json.length);
+    const seenAlso = hit && hit.depth === depth && hit.json === json ? [hit.seen.at(-1), seen] : [seen];
+    if (hit) { rowCanonical.delete(id); rowCanonicalChars -= size(hit); }
+    const entry = {depth, seen: seenAlso, json};
+    rowCanonical.set(id, entry); rowCanonicalChars += size(entry);
+    for (const [key, value] of rowCanonical) {
+      if (rowCanonicalChars <= ROW_CANONICAL_LIMIT) break;
+      rowCanonical.delete(key); rowCanonicalChars -= size(value);
+    }
+  }
+  return json;
+}
+export function* canonicalRowsParts(rows, depth = 0) {
+  const {array, keys} = fields(rows, depth, new Set());
+  if (!array) { yield* canonicalParts(rows, depth); return; }
+  yield '[';
+  for (let i = 0; i < keys.length; i++) { if (i) yield ','; yield canonicalRow(rows[keys[i]], depth + 1); }
+  yield ']';
+}
 export function exactKeys(value, keys) {
   return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
 }