@tldraw/commenting 5.3.0-next.2fa9c61a8de6 → 5.3.0-next.7654e7ac2a02

package/src/clustering/replay.test.ts

@@ -51,7 +51,6 @@ function eventShapes(events: RawMergeEvent[]) {
 	return events.map(eventShape)
 }
 
-// --- Reference oracle -------------------------------------------------------
 // Direct transcription of contract clause 4 (CLUSTERING-STEPS.md step 2): at
 // each of the n−1 steps, evaluate every unfired MST edge's zEff against the
 // CURRENT clusters and fire the highest, tie-broken by the edge's normalized
@@ -181,8 +180,6 @@ function referenceReplay(
 	return events
 }
 
-// --- Shared invariant assertions --------------------------------------------
-
 function expectNonIncreasingZ(events: RawMergeEvent[]) {
 	for (let i = 1; i < events.length; i++) {
 		expect(events[i].z).toBeLessThanOrEqual(events[i - 1].z)
@@ -260,8 +257,6 @@ function expectCentroids(events: RawMergeEvent[], leaves: readonly LeafInput[])
 	}
 }
 
-// --- Fixtures ----------------------------------------------------------------
-
 describe('cappedReplay fixtures', () => {
 	it('exports the pinned D_FLOOR constant', () => {
 		expect(D_FLOOR).toBe(1e-9)
@@ -409,8 +404,6 @@ describe('cappedReplay fixtures', () => {
 	})
 })
 
-// --- Properties against the reference oracle ---------------------------------
-
 describe('cappedReplay vs reference simulator', () => {
 	const OPTION_SETS = [
 		{ Tc: 40, Dmax: 120 }, // default shape

package/src/clustering/replay.ts

@@ -1,17 +1,20 @@
-import type { ClusterNode, LeafInput, MstEdge, RawMergeEvent } from './types'
+import type { ClusterNode, LeafInput, LeafScreenOffsets, MstEdge, RawMergeEvent } from './types'
 
 export const D_FLOOR = 1e-9
 
 export function cappedReplay(
 	leaves: readonly LeafInput[],
 	edges: readonly MstEdge[],
-	opts: { Tc: number; Dmax: number }
+	opts: { Tc: number; Dmax: number },
+	// Render offsets for markers that draw off their anchor (imprecise pins). Omitted or empty,
+	// every code path below is the offset-unaware original — pricing, events, and floats alike.
+	screenOffsets?: LeafScreenOffsets
 ): RawMergeEvent[] {
 	validateOptions(opts)
 
 	if (edges.length === 0) return []
 
-	const clusters = new ClusterState(leaves)
+	const clusters = new ClusterState(leaves, screenOffsets)
 	const heap = new EdgeMaxHeap(edges, leaves)
 	// Edges incident to each current cluster root, for eager repricing: a merge
 	// moves the result's centroid, which can RAISE an incident edge's key (the
@@ -95,19 +98,64 @@ function zForRoots(
 	clusters: ClusterState,
 	opts: { Tc: number; Dmax: number }
 ): number {
-	if (edge.d < D_FLOOR) return Number.POSITIVE_INFINITY
-	// Badge-anchored gap pricing: clusters render as badges at their centroids,
-	// so the merge is priced by the distance between the rendered centers, not
-	// the nearest members. For leaves the two are identical; for clusters the
-	// centroid distance is larger, so groups merge later than their closest
-	// members would suggest — matching what the user actually sees.
-	// (Coincident CENTROIDS with non-coincident members leave the gap term
-	// Infinity and the fit term finite — the min stays finite, no special case.)
-	const gap = opts.Tc / clusters.centroidDistance(aRoot, bRoot)
+	// Null unless offset pricing is active AND this pair's mean render offsets differ. Every
+	// other pair — including every pair when no offsets were passed — takes the branch below,
+	// which is the offset-unaware pricing verbatim.
+	const off = clusters.offsetDelta(aRoot, bRoot)
+	if (off === null) {
+		if (edge.d < D_FLOOR) return Number.POSITIVE_INFINITY
+		// Badge-anchored gap pricing: clusters render as badges at their centroids,
+		// so the merge is priced by the distance between the rendered centers, not
+		// the nearest members. For leaves the two are identical; for clusters the
+		// centroid distance is larger, so groups merge later than their closest
+		// members would suggest — matching what the user actually sees.
+		// (Coincident CENTROIDS with non-coincident members leave the gap term
+		// Infinity and the fit term finite — the min stays finite, no special case.)
+		const gap = opts.Tc / clusters.centroidDistance(aRoot, bRoot)
+		const fit = opts.Dmax / clusters.unionBboxDiag(aRoot, bRoot)
+		return Math.min(gap, fit)
+	}
+
+	// Offset-aware gap pricing: these markers render at `z·centroid + meanOffset`, so their
+	// visual distance at zoom z is |z·ΔC + Δō| and the merge prices at its Tc crossing. When
+	// that distance never reaches Tc (the constant offsets hold the visuals apart harder than
+	// the anchors close), the pair prices at 0 — visually never mergeable, pruned by finalize's
+	// minZoom cut. No D_FLOOR fast path here: coincident anchors with differing offsets are a
+	// constant |Δō| apart on screen, which is exactly the ΔC = 0 case below.
+	const dc = clusters.centroidDelta(aRoot, bRoot)
+	if (dc.x === 0 && dc.y === 0) {
+		return Math.hypot(off.x, off.y) < opts.Tc ? Number.POSITIVE_INFINITY : 0
+	}
+	const gap = largestVisualCrossing(dc.x, dc.y, off.x, off.y, opts.Tc)
+	if (gap === null) return 0
 	const fit = opts.Dmax / clusters.unionBboxDiag(aRoot, bRoot)
 	return Math.min(gap, fit)
 }
 
+/**
+ * The largest positive root of `|z·ΔC + Δō| = level`, i.e. of
+ * `|ΔC|²·z² + 2(ΔC·Δō)·z + (|Δō|² − level²) = 0` — the zoom at which two offset markers are
+ * exactly `level` screen px apart, with the distance below the level for every smaller zoom
+ * (matching the "merged at z ≤ threshold" model; a lower second crossing, where opposed offsets
+ * push the visuals back above the level near z = 0, is deliberately collapsed). Null when the
+ * visual distance never reaches the level. Callers handle ΔC = 0 (constant distance) themselves.
+ */
+function largestVisualCrossing(
+	dcx: number,
+	dcy: number,
+	dox: number,
+	doy: number,
+	level: number
+): number | null {
+	const a = dcx * dcx + dcy * dcy
+	const b = 2 * (dcx * dox + dcy * doy)
+	const c = dox * dox + doy * doy - level * level
+	const disc = b * b - 4 * a * c
+	if (disc < 0) return null
+	const z = (-b + Math.sqrt(disc)) / (2 * a)
+	return z > 0 ? z : null
+}
+
 class ClusterState {
 	private readonly parent: Int32Array
 	private readonly minX: Float64Array
@@ -120,8 +168,13 @@ class ClusterState {
 	private readonly nodes: ClusterNode[]
 	private readonly memberLists: string[][]
 	private readonly minMemberIds: string[]
+	// Per-cluster sums of member render offsets (screen px), maintained like the centroid sums.
+	// Null when no offsets were passed — offsetDelta() then answers null unconditionally, which
+	// routes every pricing call down the offset-unaware path.
+	private readonly offsetX: Float64Array | null
+	private readonly offsetY: Float64Array | null
 
-	constructor(leaves: readonly LeafInput[]) {
+	constructor(leaves: readonly LeafInput[], screenOffsets?: LeafScreenOffsets) {
 		const n = leaves.length
 		this.parent = new Int32Array(n)
 		this.minX = new Float64Array(n)
@@ -135,6 +188,21 @@ class ClusterState {
 		this.memberLists = new Array(n)
 		this.minMemberIds = new Array(n)
 
+		if (screenOffsets !== undefined && screenOffsets.size > 0) {
+			this.offsetX = new Float64Array(n)
+			this.offsetY = new Float64Array(n)
+			for (let i = 0; i < n; i++) {
+				const offset = screenOffsets.get(leaves[i].id)
+				if (offset) {
+					this.offsetX[i] = offset.x
+					this.offsetY[i] = offset.y
+				}
+			}
+		} else {
+			this.offsetX = null
+			this.offsetY = null
+		}
+
 		for (let i = 0; i < n; i++) {
 			const leaf = leaves[i]
 			this.parent[i] = i
@@ -176,6 +244,24 @@ class ClusterState {
 		)
 	}
 
+	centroidDelta(aRoot: number, bRoot: number): { x: number; y: number } {
+		return {
+			x: this.centroidX[aRoot] - this.centroidX[bRoot],
+			y: this.centroidY[aRoot] - this.centroidY[bRoot],
+		}
+	}
+
+	/** The difference of the two clusters' mean render offsets (screen px), or null when it's
+	 *  zero — including always when no offsets were passed. Null routes pricing down the
+	 *  offset-unaware path. */
+	offsetDelta(aRoot: number, bRoot: number): { x: number; y: number } | null {
+		if (this.offsetX === null || this.offsetY === null) return null
+		const x = this.offsetX[aRoot] / this.counts[aRoot] - this.offsetX[bRoot] / this.counts[bRoot]
+		const y = this.offsetY[aRoot] / this.counts[aRoot] - this.offsetY[bRoot] / this.counts[bRoot]
+		if (x === 0 && y === 0) return null
+		return { x, y }
+	}
+
 	unionBboxDiag(aRoot: number, bRoot: number): number {
 		const minX = Math.min(this.minX[aRoot], this.minX[bRoot])
 		const minY = Math.min(this.minY[aRoot], this.minY[bRoot])
@@ -224,6 +310,10 @@ class ClusterState {
 		this.nodes[leftRoot] = result
 		this.memberLists[leftRoot] = members
 		this.minMemberIds[leftRoot] = members[0]
+		if (this.offsetX !== null && this.offsetY !== null) {
+			this.offsetX[leftRoot] += this.offsetX[rightRoot]
+			this.offsetY[leftRoot] += this.offsetY[rightRoot]
+		}
 
 		return { z, children: [left, right], result }
 	}
@@ -253,11 +343,29 @@ interface HeapEntry {
 
 class EdgeMaxHeap {
 	private readonly items: HeapEntry[] = []
-
-	constructor(
-		private readonly edges: readonly MstEdge[],
-		private readonly leaves: readonly LeafInput[]
-	) {}
+	// Per-edge normalized (lo, hi) id pair for the z tie-break, precomputed once so comparisons
+	// allocate nothing. With coincident anchors every edge prices to the same z (+Infinity), so
+	// the tie-break runs on nearly every comparison of a rebuild — allocating the pair there
+	// churned millions of short-lived tuples.
+	private readonly loIds: string[]
+	private readonly hiIds: string[]
+
+	constructor(edges: readonly MstEdge[], leaves: readonly LeafInput[]) {
+		const n = edges.length
+		this.loIds = new Array(n)
+		this.hiIds = new Array(n)
+		for (let i = 0; i < n; i++) {
+			const aId = leaves[edges[i].a].id
+			const bId = leaves[edges[i].b].id
+			if (aId < bId) {
+				this.loIds[i] = aId
+				this.hiIds[i] = bId
+			} else {
+				this.loIds[i] = bId
+				this.hiIds[i] = aId
+			}
+		}
+	}
 
 	peek(): HeapEntry | undefined {
 		return this.items[0]
@@ -282,7 +390,11 @@ class EdgeMaxHeap {
 	higherPriority(a: HeapEntry, b: HeapEntry): boolean {
 		if (a.z > b.z) return true
 		if (a.z < b.z) return false
-		return edgeIdPairLess(this.edges[a.edgeIndex], this.edges[b.edgeIndex], this.leaves)
+		// Tie-break on the normalized leaf-id pair, ascending.
+		const aLo = this.loIds[a.edgeIndex]
+		const bLo = this.loIds[b.edgeIndex]
+		if (aLo !== bLo) return aLo < bLo
+		return this.hiIds[a.edgeIndex] < this.hiIds[b.edgeIndex]
 	}
 
 	private siftUp(index: number) {
@@ -311,16 +423,3 @@ class EdgeMaxHeap {
 		}
 	}
 }
-
-function edgeIdPairLess(a: MstEdge, b: MstEdge, leaves: readonly LeafInput[]): boolean {
-	const [aLo, aHi] = normalizedEdgeIds(a, leaves)
-	const [bLo, bHi] = normalizedEdgeIds(b, leaves)
-	if (aLo !== bLo) return aLo < bLo
-	return aHi < bHi
-}
-
-function normalizedEdgeIds(edge: MstEdge, leaves: readonly LeafInput[]): [string, string] {
-	const aId = leaves[edge.a].id
-	const bId = leaves[edge.b].id
-	return aId < bId ? [aId, bId] : [bId, aId]
-}

package/src/clustering/runtime.test.ts

@@ -5,8 +5,6 @@ import { createClusterRuntime } from './runtime'
 import { contract, finalize } from './schedule'
 import { ClusterNode, ClusterTable, LeafInput, MergeEvent } from './types'
 
-// --- Synthetic builders --------------------------------------------------------
-
 function node(ids: string[], x = 0, y = 0): ClusterNode {
 	const members = ids.slice().sort()
 	return {
@@ -79,8 +77,6 @@ function microTraceTable(): ClusterTable {
 	}
 }
 
-// --- Fixtures -------------------------------------------------------------------
-
 describe('createClusterRuntime micro-trace (CLUSTERING.md §8.5)', () => {
 	it('walks the exact documented trace', () => {
 		const table = microTraceTable()
@@ -239,8 +235,6 @@ describe('createClusterRuntime edge cases', () => {
 	})
 })
 
-// --- Property tests against real pipeline tables --------------------------------
-
 function leaf(id: string, x: number, y: number): LeafInput {
 	return { id, point: { x, y } }
 }
@@ -793,6 +787,56 @@ describe('createClusterRuntime detachLeaf (local partition edits)', () => {
 		expect(rt.getVisible().get(P.id)).toEqual(P)
 	})
 
+	it('detachLeaves batches a whole set into one version bump', () => {
+		const table = microTraceTable()
+		const rt = createClusterRuntime(table)
+		rt.seed(4) // P = a+b+c visible, d separate
+		const versionBefore = rt.version
+		rt.detachLeaves(['a', 'b'])
+		expect(rt.version).toBe(versionBefore + 1)
+		expect(rt.getDetachedCount()).toBe(2)
+		// P = {a,b,c} minus a,b → the leaf node c, keyed by its own id
+		expect(rt.getVisible().get('c')).toEqual(C)
+		expect(rt.getVisible().has(P.id)).toBe(false)
+		expect(visibleIds(rt)).toEqual(['c', 'd'])
+	})
+
+	it('detachLeaves matches the equivalent one-at-a-time detaches', () => {
+		const makeDetached = (detach: (rt: ReturnType<typeof createClusterRuntime>) => void) => {
+			const rt = createClusterRuntime(microTraceTable())
+			rt.seed(4)
+			detach(rt)
+			return rt
+		}
+		const batched = makeDetached((rt) => rt.detachLeaves(['a', 'd']))
+		const oneByOne = makeDetached((rt) => {
+			rt.detachLeaf('a')
+			rt.detachLeaf('d')
+		})
+		expect(visibleIds(batched)).toEqual(visibleIds(oneByOne))
+		for (const id of visibleIds(batched)) {
+			expect(batched.getVisible().get(id)).toEqual(oneByOne.getVisible().get(id))
+		}
+	})
+
+	it('detachLeaves skips unknown and already-detached ids, and no-ops on an empty batch', () => {
+		const table = microTraceTable()
+		const rt = createClusterRuntime(table)
+		rt.seed(4)
+		rt.detachLeaf('a')
+		const version = rt.version
+		const visible = rt.getVisible()
+		rt.detachLeaves([])
+		rt.detachLeaves(['a', 'nonexistent'])
+		expect(rt.version).toBe(version)
+		expect(rt.getDetachedCount()).toBe(1)
+		expect(rt.getVisible()).toBe(visible)
+		// a mixed batch still applies the new id in a single bump
+		rt.detachLeaves(['a', 'b', 'nonexistent'])
+		expect(rt.version).toBe(version + 1)
+		expect(rt.getDetachedCount()).toBe(2)
+	})
+
 	it('getVisible returns a stable reference until the partition changes', () => {
 		const table = microTraceTable()
 		const rt = createClusterRuntime(table)

package/src/clustering/runtime.ts

@@ -16,28 +16,29 @@ export interface ClusterRuntime {
 	/** Reset state from scratch for the given zoom (cold start / after rebuild). Clears detaches. */
 	seed(zoom: number): void
 	/**
-	 * Reset state for the given zoom, carrying hysteresis state over from a previous partition
-	 * (the visible map of the model being replaced). Threshold-forced events ignore history:
-	 * zoom \<= zMerge is always merged, zoom \>= zSplit always split. An event inside its band
-	 * keeps its previous state: merged iff its members were merged together in `previous`; a band
-	 * event that was unmerged (or has no history, e.g. introduced by the rebuild) stays unmerged —
-	 * inside the cursor but suppressed — until a zoom-out crosses its own zMerge, exactly like any
-	 * other pending merge. Carryover is exact: no group changes state because of the swap alone.
-	 * Clears detaches.
+	 * Reset state for the given zoom, carrying hysteresis state over from a previous partition.
+	 * Threshold-forced events ignore history: zoom \<= zMerge is always merged, zoom \>= zSplit always
+	 * split. An event inside its band keeps its previous state; one that was unmerged (or has no
+	 * history) stays suppressed inside the cursor until a zoom-out crosses its own zMerge. Carryover is
+	 * exact — no group changes state because of the swap alone. Clears detaches.
 	 */
 	seedFrom(zoom: number, previous: ReadonlyMap<string, ClusterNode>): void
 	/** Advance/retreat the cursor for a camera change. No-op if zoom sits inside all bands. */
 	onCamera(zoom: number): void
 	/**
 	 * Remove one leaf from the displayed partition without touching the event table. Local by
-	 * construction: only the nodes containing the leaf change — a badge shrinks in place (count
-	 * and centroid recomputed from its remaining members), a pair collapses to its surviving
-	 * leaf, and the leaf on its own disappears. Everything else is untouched, so a deletion,
-	 * pop-out, or thread-open never re-flows the rest of the document. The table's thresholds
-	 * around the detached leaf go stale; the caller is expected to hold a corrected rebuild and
-	 * adopt it (with seedFrom) at the next zoom-out. Unknown or already-detached ids are no-ops.
+	 * construction: only the nodes containing the leaf change, so a deletion, pop-out, or thread-open
+	 * never re-flows the rest of the document. The table's thresholds around the detached leaf go
+	 * stale; the caller is expected to adopt a corrected rebuild (with seedFrom) at the next zoom-out.
+	 * Unknown or already-detached ids are no-ops.
 	 */
 	detachLeaf(leafId: string): void
+	/**
+	 * Batch form of {@link ClusterRuntime.detachLeaf}: detach every given leaf with a single
+	 * patch rebuild and a single version bump. Ids that are unknown or already detached are
+	 * skipped; if nothing new detaches, nothing changes.
+	 */
+	detachLeaves(leafIds: Iterable<string>): void
 	/** The displayed partition: cluster id → node, with detaches applied. Do not mutate. */
 	getVisible(): ReadonlyMap<string, ClusterNode>
 }
@@ -56,10 +57,9 @@ class ClusterRuntimeImpl implements ClusterRuntime {
 	// time in getVisible().
 	private visible = new Map<string, ClusterNode>()
 	private seeded = false
-	// Indices (< k) of band events held unmerged by seedFrom carryover. The single cursor can
-	// only express "merged up to here", but a carried-over partition can be "merged except these"
-	// — the exceptions live here. Self-draining: an entry leaves via onCamera when the zoom
-	// crosses its own zMerge (merges) or its zSplit (the split walk retreats past it).
+	// Indices (< k) of band events held unmerged by seedFrom carryover. The single cursor can only
+	// express "merged up to here", but a carried-over partition can be "merged except these". Self-
+	// draining: an entry leaves via onCamera when the zoom crosses its zMerge or its zSplit.
 	private suppressed = new Set<number>()
 	// Leaves removed from the displayed partition (deleted / popped out / opened). Patches map
 	// each structural node containing a detached leaf to its displayed replacement (or null to
@@ -121,10 +121,8 @@ class ClusterRuntimeImpl implements ClusterRuntime {
 		for (let i = 0; i < k; i++) {
 			const event = events[i]
 			if (zoom > event.zMerge && !wasMergedTogether(event.result.members, ownerByMember)) {
-				// In its band and previously unmerged: keep it unmerged, as an exception inside
-				// the cursor. Dependency-safe: an applied event can never consume a suppressed
-				// result — merged members imply merged (subset) children, and threshold-forced
-				// events force their children too (zMerge is non-increasing down the table).
+				// In its band and previously unmerged: keep it unmerged, as an exception inside the cursor.
+				// Dependency-safe, since an applied event can never consume a suppressed result.
 				this.suppressed.add(i)
 			} else {
 				applyEvent(this.visible, event)
@@ -141,17 +139,13 @@ class ClusterRuntimeImpl implements ClusterRuntime {
 		}
 
 		let changed = false
-		// Heal suppressed events at their own merge threshold BEFORE the merge walk: a zoom-out
-		// past zMerge merges a held-out band event exactly as if it had still been ahead of the
-		// cursor. Healing must precede the walk because a single zoom jump can cross both a
-		// suppressed event and an event that consumes its result; applying the consumer first
-		// would leave the unapplied producer's children in `visible` (its delete is a no-op) and
-		// then re-add the producer on top, double-counting those leaves. Threshold monotonicity
-		// guarantees a suppressed producer's zMerge is >= its consumer's, so anything the walk
-		// needs has already healed. Set iteration is insertion order (ascending index), so a
-		// healed event's suppressed children (larger zMerge, smaller index) heal before it.
+		// Heal suppressed events at their own merge threshold BEFORE the merge walk, so a zoom-out past
+		// zMerge merges a held-out band event as if it had still been ahead of the cursor. Healing must come
+		// first: one zoom jump can cross both a suppressed event and an event consuming its result, and
+		// applying the consumer first would double-count the producer's leaves. Iterated live — deleting only
+		// the entry being visited is safe, and Set iteration still yields the rest in insertion order.
 		if (this.suppressed.size > 0) {
-			for (const i of [...this.suppressed]) {
+			for (const i of this.suppressed) {
 				if (zoom <= this.table.events[i].zMerge) {
 					this.suppressed.delete(i)
 					applyEvent(this.visible, this.table.events[i])
@@ -176,9 +170,19 @@ class ClusterRuntimeImpl implements ClusterRuntime {
 	}
 
 	detachLeaf(leafId: string): void {
-		if (this.detached.has(leafId)) return
-		if (!this.getLeafById().has(leafId)) return
-		this.detached.add(leafId)
+		this.detachLeaves([leafId])
+	}
+
+	detachLeaves(leafIds: Iterable<string>): void {
+		const leafById = this.getLeafById()
+		let changed = false
+		for (const leafId of leafIds) {
+			if (this.detached.has(leafId)) continue
+			if (!leafById.has(leafId)) continue
+			this.detached.add(leafId)
+			changed = true
+		}
+		if (!changed) return
 		this.rebuildPatches()
 		this.version++
 	}
@@ -208,10 +212,9 @@ class ClusterRuntimeImpl implements ClusterRuntime {
 		return this.leafById
 	}
 
-	/** Recompute the patch map from the detached set. A node is patched iff it contains a
-	 *  detached member; the patch drops those members and recomputes count/centroid, collapsing
-	 *  to the surviving leaf node at count 1 and to nothing at count 0. Patched nodes keep their
-	 *  structural id, so cursor events keep addressing them. */
+	/** Recompute the patch map from the detached set. A node is patched iff it contains a detached
+	 *  member; the patch drops those members and recomputes count/centroid, collapsing to the surviving
+	 *  leaf at count 1 and to nothing at count 0. Patched nodes keep their structural id. */
 	private rebuildPatches() {
 		this.patched.clear()
 		const leafById = this.getLeafById()

package/src/clustering/schedule.test.ts

@@ -7,7 +7,6 @@ import { cappedReplay } from './replay'
 import { contract, finalize } from './schedule'
 import { ClusterNode, ContractedEvent, LeafInput, MergeEvent, RawMergeEvent } from './types'
 
-// --- Synthetic builders -------------------------------------------------------
 // `contract` is specified over plain RawMergeEvent[] input precisely so it can
 // be tested with hand-built events, without running the replay.
 
@@ -55,8 +54,6 @@ const F = node(['f'])
 const X = node(['x'])
 const Y = node(['y'])
 
-// --- contract: fixtures -------------------------------------------------------
-
 describe('contract fixtures', () => {
 	it('returns [] for empty input', () => {
 		expect(contract([], 0.12)).toEqual([])
@@ -210,8 +207,6 @@ describe('contract validation and purity', () => {
 	})
 })
 
-// --- finalize: fixtures --------------------------------------------------------
-
 const FIN_OPTS = { Tc: 40, Tu: 60, minZoom: 0.1, maxZoom: 8, maxSplitZoom: 1e9 } // r = 1.5
 
 function contracted(zMerge: number, children: ClusterNode[], result: ClusterNode): ContractedEvent {
@@ -322,7 +317,6 @@ describe('finalize fixtures', () => {
 	})
 })
 
-// --- Composed pipeline properties ---------------------------------------------
 // finalize(contract(cappedReplay(mstEdges(leaves)))) must satisfy every table
 // invariant of CLUSTERING.md §7.6.