@embedpdf/engine-core 3.0.0-next.0 → 3.0.0-next.10

package/dist/{builders-C548U47M.js → builders-B_KufGJ9.js}

@@ -1,120 +1,5 @@
-import { o as EngineErrorCode } from "./subtype-BvAzLCGC.js";
-import { i as EngineError, n as foldText, r as toOriginalRange } from "./fold-CB4fAOOy.js";
-//#region src/geometry/convert.ts
-/**
-* Normalize a `PdfRect` to the y-up invariant (`left <= right`, `bottom <= top`),
-* regardless of how the PDF ordered the corners (a `/Rect` array or `FS_RECTF`
-* may carry them in any order). THE enforcement point for the "PdfRect is always
-* normalized" rule: every producer that reads a raw box from PDFium passes it
-* through here, so the invariant holds once, centrally — downstream `width =
-* right - left` is never negative.
-*/
-function normalizePdfRect(r) {
-	return {
-		left: Math.min(r.left, r.right),
-		right: Math.max(r.left, r.right),
-		bottom: Math.min(r.top, r.bottom),
-		top: Math.max(r.top, r.bottom)
-	};
-}
-function pdfRectWidth(r) {
-	return r.right - r.left;
-}
-function pdfRectHeight(r) {
-	return r.top - r.bottom;
-}
-function pdfRectSize(r) {
-	return {
-		width: r.right - r.left,
-		height: r.top - r.bottom
-	};
-}
-/** Convert edges -> origin+size, staying y-up (origin at bottom-left). */
-function pdfRectToOriginSize(r) {
-	return {
-		x: r.left,
-		y: r.bottom,
-		width: r.right - r.left,
-		height: r.top - r.bottom
-	};
-}
-/** Convert y-up origin+size back to edges. */
-function pdfRectFromOriginSize(o) {
-	return {
-		left: o.x,
-		bottom: o.y,
-		right: o.x + o.width,
-		top: o.y + o.height
-	};
-}
-/**
-* Enclosing axis-aligned box of a quad, in PDF user space. Orientation
-* agnostic (correct for rotated/skewed quads) — this is what highlight
-* rendering and hit-testing want.
-*/
-function pdfQuadBounds(q) {
-	const xs = [
-		q.p1.x,
-		q.p2.x,
-		q.p3.x,
-		q.p4.x
-	];
-	const ys = [
-		q.p1.y,
-		q.p2.y,
-		q.p3.y,
-		q.p4.y
-	];
-	return {
-		left: Math.min(...xs),
-		right: Math.max(...xs),
-		bottom: Math.min(...ys),
-		top: Math.max(...ys)
-	};
-}
-/**
-* Axis-aligned named-corner interpretation of a quad.
-*
-* VALID ONLY for upright (non-rotated, non-skewed) quads: it is derived from
-* the enclosing bounds, so for rotated/skewed quads it returns the bounding
-* box corners, not the true geometric corners. For arbitrary quads use the
-* positional `p1..p4` or `pdfQuadBounds` directly.
-*/
-function pdfQuadCorners(q) {
-	const b = pdfQuadBounds(q);
-	return {
-		topLeft: {
-			x: b.left,
-			y: b.top
-		},
-		topRight: {
-			x: b.right,
-			y: b.top
-		},
-		bottomLeft: {
-			x: b.left,
-			y: b.bottom
-		},
-		bottomRight: {
-			x: b.right,
-			y: b.bottom
-		}
-	};
-}
-/**
-* Build a quad from named corners, in PDFium `FS_QUADPOINTSF` slot order
-* (`p1 = topLeft`, `p2 = topRight`, `p3 = bottomLeft`, `p4 = bottomRight`).
-* The inverse of `pdfQuadCorners` for upright quads.
-*/
-function pdfQuadFromCorners(c) {
-	return {
-		p1: c.topLeft,
-		p2: c.topRight,
-		p3: c.bottomLeft,
-		p4: c.bottomRight
-	};
-}
-//#endregion
+import { i as EngineError, n as foldText, r as toOriginalRange, u as isRotatedGeometryRun } from "./fold-BfyxxwS6.js";
+import { f as EngineErrorCode } from "./PageInsertBlankInput-WKY0tr6S.js";
 //#region src/dto/PageRender.ts
 function createPageImageHandle(result, blobSource) {
 	return {
@@ -524,6 +409,164 @@ function buildThreads(annotations) {
 	return threads;
 }
 //#endregion
+//#region src/annotation/comments.ts
+/** Subtypes that never participate in comment threads. `unsupported`
+*  covers `/Popup` dictionaries (raw code 16) and unreadable foreign
+*  blobs — neither makes a meaningful comment card. */
+const EXCLUDED_SUBTYPES = /* @__PURE__ */ new Set([
+	"widget",
+	"link",
+	"unsupported"
+]);
+const REVIEW_STATES = /* @__PURE__ */ new Set([
+	"accepted",
+	"rejected",
+	"cancelled",
+	"completed",
+	"none"
+]);
+const MARKED_STATES = /* @__PURE__ */ new Set(["marked", "unmarked"]);
+const nonEmpty = (v) => typeof v === "string" && v !== "";
+/**
+* An ISO 32000 §12.5.6.3 state annotation: a text annotation carrying a
+* non-empty `/State` or `/StateModel`. Classification never relies on
+* flags — producers disagree on how state annotations are flagged.
+*/
+function isStateAnnotation(a) {
+	return a.subtype === "text" && (nonEmpty(a.state) || nonEmpty(a.stateModel));
+}
+function buildCommentThreads(annotations, opts = {}) {
+	const eligible = annotations.filter((a) => !EXCLUDED_SUBTYPES.has(a.subtype));
+	const byKey = /* @__PURE__ */ new Map();
+	for (const a of eligible) {
+		const key = refKey(a.ref);
+		if (!byKey.has(key)) byKey.set(key, a);
+		if (a.nm) {
+			const aliasKey = refKey({
+				kind: "nm",
+				pageObjectNumber: a.pageObjectNumber,
+				nm: a.nm
+			});
+			if (!byKey.has(aliasKey)) byKey.set(aliasKey, a);
+		}
+	}
+	const children = /* @__PURE__ */ new Map();
+	for (const a of eligible) {
+		if (!a.inReplyTo) continue;
+		const parent = byKey.get(refKey(a.inReplyTo));
+		if (!parent) continue;
+		const parentKey = refKey(parent.ref);
+		const list = children.get(parentKey);
+		if (list) list.push(a);
+		else children.set(parentKey, [a]);
+	}
+	const visited = /* @__PURE__ */ new Set();
+	const threads = [];
+	const walk = (root) => {
+		const replies = [];
+		const groupedParts = [];
+		const states = [];
+		visited.add(refKey(root.ref));
+		const stack = [...children.get(refKey(root.ref)) ?? []];
+		while (stack.length > 0) {
+			const a = stack.pop();
+			const key = refKey(a.ref);
+			if (visited.has(key)) continue;
+			visited.add(key);
+			if (isStateAnnotation(a)) states.push(a);
+			else if (classifyRelation(a) === "grouped-subordinate") groupedParts.push(a);
+			else replies.push(a);
+			stack.push(...children.get(key) ?? []);
+		}
+		replies.sort(chronological);
+		states.sort(chronological);
+		threads.push({
+			root,
+			pageObjectNumber: root.pageObjectNumber,
+			replies,
+			groupedParts,
+			review: computeReview(states, opts)
+		});
+	};
+	for (const a of eligible) if (!a.inReplyTo && !isStateAnnotation(a)) walk(a);
+	for (const a of eligible) {
+		if (visited.has(refKey(a.ref))) continue;
+		if (isStateAnnotation(a)) continue;
+		walk(a);
+	}
+	return threads;
+}
+/** `created ?? modified` ascending; undated last; z-order tiebreak. */
+function chronological(a, b) {
+	const at = a.created ?? a.modified;
+	const bt = b.created ?? b.modified;
+	if (at !== null && bt !== null && at !== bt) return at < bt ? -1 : 1;
+	if (at !== null && bt === null) return -1;
+	if (at === null && bt !== null) return 1;
+	return a.index - b.index;
+}
+function computeReview(states, opts) {
+	const byReviewer = {};
+	const markedLatest = {};
+	let lastChange = null;
+	for (const a of states) {
+		const status = toReviewStatus(a);
+		if (!status) continue;
+		if (status.stateModel === "marked") {
+			if (status.by !== null && isNewer(status, markedLatest[status.by])) markedLatest[status.by] = status;
+			continue;
+		}
+		if (status.by !== null && isNewer(status, byReviewer[status.by])) byReviewer[status.by] = status;
+		if (isNewer(status, lastChange)) lastChange = status;
+	}
+	const markedBy = Object.keys(markedLatest).filter((key) => markedLatest[key].state === "marked").sort();
+	const review = {
+		byReviewer,
+		lastChange,
+		markedBy,
+		statusRefs: states.map((a) => a.ref)
+	};
+	if (opts.currentUserId !== void 0) review.mine = byReviewer[opts.currentUserId] ?? null;
+	return review;
+}
+/**
+* Derive a `ReviewStatus` from one state annotation, or null when nothing
+* classifiable can be derived. ISO defaulting happens HERE, not in the
+* engine reader: a known model with an absent state means `none` /
+* `unmarked`; an absent model infers from a known state; a custom model
+* with no state has no derivable status.
+*/
+function toReviewStatus(a) {
+	if (a.subtype !== "text") return null;
+	const rawState = nonEmpty(a.state) ? a.state : null;
+	let stateModel = nonEmpty(a.stateModel) ? a.stateModel : null;
+	if (stateModel === null && rawState !== null) if (REVIEW_STATES.has(rawState)) stateModel = "review";
+	else if (MARKED_STATES.has(rawState)) stateModel = "marked";
+	else return null;
+	let state = rawState;
+	if (state === null) if (stateModel === "review") state = "none";
+	else if (stateModel === "marked") state = "unmarked";
+	else return null;
+	if (stateModel === null) return null;
+	return {
+		state,
+		stateModel,
+		by: a.userId ?? (nonEmpty(a.author) ? a.author : null),
+		at: a.modified ?? a.created ?? null,
+		ref: a.ref
+	};
+}
+/** `a` newer than (or supersedes) `b`. `at` decides; dated beats undated.
+*  States arrive pre-sorted by `chronological` (date, then z-order), so on
+*  equal or missing dates the later entry wins via `>=` / `true`. */
+function isNewer(a, b) {
+	if (!b) return true;
+	if (a.at !== null && b.at !== null) return a.at >= b.at;
+	if (a.at !== null) return true;
+	if (b.at !== null) return false;
+	return true;
+}
+//#endregion
 //#region src/mutation/AnnotationMutationImpactPolicy.ts
 function changesAnnotationList(_kind) {
 	return true;
@@ -547,14 +590,19 @@ function invalidatesWeakIndexRefs(kind, weakStateBefore) {
 const EPSILON = .001;
 /**
 * Keys that never affect `/AP` on any kind: the discriminator, behavioral
-* flags, reply relationships, and grouping.
+* flags, reply relationships, grouping, and the conversation-plane
+* entries (`/Subj` subject line, `/State` + `/StateModel` review status —
+* dictionary-only per ISO 32000 §12.5.6.3, never painted).
 */
 const INERT_KEYS = /* @__PURE__ */ new Set([
 	"subtype",
 	"flags",
 	"inReplyTo",
 	"replyType",
-	"groupId"
+	"groupId",
+	"subject",
+	"state",
+	"stateModel"
 ]);
 /**
 * Kinds whose `/AP` paints `/Contents`. Everywhere else `contents` is popup
@@ -1007,37 +1055,275 @@ function buildSnippet(text, range, context = 48) {
 	};
 }
 //#endregion
-//#region src/search/rects.ts
-/**
-* Match-range → merged line rects, in PDF user space (y-up).
-*
-* This is the same line-merge text selection uses (adapted from Chromium's
-* pdf/pdfium/pdfium_range.cc `MergeAdjacentRects`, BSD-licensed, Copyright
-* 2010 The Chromium Authors), operating directly on the engine's
-* `PageGeometrySnapshot`: glyph loose boxes → sub-runs (split on big
-* intra-run gaps) → one rect per visual line. Search highlights therefore
-* look exactly like selections — never a rect per glyph (the v2 bug).
-*
-* It lives in engine-core because BOTH sides need it: the server computes
-* rects here for `'rects'`-mode responses (geometry never leaves the trust
-* boundary), and the local engine computes them in the worker.
-*/
+//#region src/text/layout.ts
 const FLAG_EMPTY = 2;
+const isBoundary = (flags) => (flags & 3) !== 0;
+const isEmpty = (flags) => (flags & FLAG_EMPTY) !== 0;
 const CHAR_DISTANCE_FACTOR = 2.5;
 const FONT_SIZE_RATIO_THRESHOLD = 1.5;
 const VERTICAL_OVERLAP_THRESHOLD = .8;
+const LINE_OVERLAP_THRESHOLD = .5;
+/** Baseline directions within ~0.5° share a frame. */
+const FRAME_DOT_TOLERANCE = Math.cos(.0087);
+const EDGE_EPSILON = 1e-6;
+const IDENTITY_FRAME = {
+	baseline: {
+		x: 1,
+		y: 0
+	},
+	ascent: {
+		x: 0,
+		y: 1
+	}
+};
+const toFrame = (f, p) => ({
+	x: p.x * f.baseline.x + p.y * f.baseline.y,
+	y: p.x * f.ascent.x + p.y * f.ascent.y
+});
+const fromFrame = (f, p) => ({
+	x: f.baseline.x * p.x + f.ascent.x * p.y,
+	y: f.baseline.y * p.x + f.ascent.y * p.y
+});
+const ZERO_RECT = {
+	left: 0,
+	bottom: 0,
+	right: 0,
+	top: 0
+};
+/** Frame-local AABB of a page-space cell (exact under the frame's rotation;
+*  shear residue is the documented in-frame envelope). */
+function frameBoxOfQuad(f, q) {
+	const pts = [
+		q.p1,
+		q.p2,
+		q.p3,
+		q.p4
+	].map((p) => toFrame(f, p));
+	const xs = pts.map((p) => p.x);
+	const ys = pts.map((p) => p.y);
+	return {
+		left: Math.min(...xs),
+		bottom: Math.min(...ys),
+		right: Math.max(...xs),
+		top: Math.max(...ys)
+	};
+}
+/** Find-or-create the frame for a rotated run, keyed by the baseline
+*  direction + ascent handedness of its first classifiable glyph's edges. */
+function frameForRun(frames, run) {
+	const seed = run.glyphs.find((g) => !isEmpty(g.flags));
+	if (!seed) return 0;
+	const q = seed.looseQuad;
+	const bx = q.p2.x - q.p1.x;
+	const by = q.p2.y - q.p1.y;
+	const len = Math.hypot(bx, by);
+	if (len <= EDGE_EPSILON) return 0;
+	const baseline = {
+		x: bx / len,
+		y: by / len
+	};
+	const ax = q.p1.x - q.p3.x;
+	const ay = q.p1.y - q.p3.y;
+	const sign = baseline.x * ay - baseline.y * ax >= 0 ? 1 : -1;
+	const ascent = {
+		x: -baseline.y * sign,
+		y: baseline.x * sign
+	};
+	for (let i = 0; i < frames.length; i++) {
+		const f = frames[i];
+		const dot = f.baseline.x * baseline.x + f.baseline.y * baseline.y;
+		const sameHandedness = f.ascent.x * ascent.x + f.ascent.y * ascent.y > 0;
+		if (dot >= FRAME_DOT_TOLERANCE && sameHandedness) return i;
+	}
+	frames.push({
+		baseline,
+		ascent
+	});
+	return frames.length - 1;
+}
 /**
-* Merged line rects for the text-page char range
-* `[charStart, charStart + charCount)`. Ranges index the same space as
-* `PageGeometryRun.charStart`; chars outside the snapshot are ignored.
+* Flatten a page's geometry snapshot into the canonical layout. Upright runs
+* copy their wire boxes verbatim (frame 0 — byte-identical to the
+* pre-orientation behavior, wire run rects included); rotated runs project
+* their glyph cells into their cluster's frame.
 */
-function searchRectsForRange(snapshot, charStart, charCount) {
-	if (charCount <= 0) return [];
-	const lo = charStart;
-	const hi = charStart + charCount - 1;
-	const subRuns = [];
+function buildPageTextLayout(snapshot) {
+	const glyphs = [];
+	const runs = [];
+	const frames = [IDENTITY_FRAME];
 	for (const run of snapshot.runs) {
-		const runEnd = run.charStart + run.glyphs.length - 1;
+		if (!isRotatedGeometryRun(run)) {
+			for (const g of run.glyphs) glyphs.push({
+				loose: g.looseBox,
+				tight: g.tightBox,
+				flags: g.flags
+			});
+			runs.push({
+				charStart: run.charStart,
+				count: run.glyphs.length,
+				rect: run.rect,
+				fontSize: run.fontSize,
+				frame: 0
+			});
+			continue;
+		}
+		const frame = frameForRun(frames, run);
+		const f = frames[frame];
+		let runBox = null;
+		for (const g of run.glyphs) {
+			if (isEmpty(g.flags)) {
+				glyphs.push({
+					loose: ZERO_RECT,
+					flags: g.flags
+				});
+				continue;
+			}
+			const loose = frameBoxOfQuad(f, g.looseQuad);
+			const tight = g.tightQuad ? frameBoxOfQuad(f, g.tightQuad) : void 0;
+			glyphs.push({
+				loose,
+				tight,
+				flags: g.flags
+			});
+			runBox = runBox ? {
+				left: Math.min(runBox.left, loose.left),
+				bottom: Math.min(runBox.bottom, loose.bottom),
+				right: Math.max(runBox.right, loose.right),
+				top: Math.max(runBox.top, loose.top)
+			} : loose;
+		}
+		runs.push({
+			charStart: run.charStart,
+			count: run.glyphs.length,
+			rect: runBox ?? ZERO_RECT,
+			fontSize: run.fontSize,
+			frame
+		});
+	}
+	return {
+		glyphs,
+		runs,
+		frames
+	};
+}
+const inRect = (r, p) => p.x >= r.left && p.x <= r.right && p.y >= r.bottom && p.y <= r.top;
+function avgGlyphHeight(layout) {
+	let total = 0;
+	let count = 0;
+	for (const g of layout.glyphs) {
+		if (isEmpty(g.flags)) continue;
+		total += g.loose.top - g.loose.bottom;
+		count++;
+	}
+	return count === 0 ? 0 : total / count;
+}
+/** The point expressed in every frame (index-aligned with `layout.frames`).
+*  Frame 0 returns the point itself — no float round-trip on the fast path. */
+function pointPerFrame(layout, p) {
+	return layout.frames.map((f, i) => i === 0 ? p : toFrame(f, p));
+}
+/**
+* The glyph (char) index at a page-space point, or null when nothing is near
+* (so callers can show the pointer cursor off-text). PDFium `GetIndexAtPos`:
+* exact tight-box containment first, then a tolerance pass (closest by
+* Manhattan distance within `toleranceFactor × average glyph height`). Each
+* run tests the point in ITS OWN frame, so rotated text hit-tests exactly.
+*/
+function textGlyphAt(layout, point, toleranceFactor = 1.5) {
+	const pts = pointPerFrame(layout, point);
+	for (const run of layout.runs) {
+		const q = pts[run.frame];
+		if (!inRect(run.rect, q)) continue;
+		for (let i = 0; i < run.count; i++) {
+			const g = layout.glyphs[run.charStart + i];
+			if (inRect(g.tight ?? g.loose, q)) return run.charStart + i;
+		}
+	}
+	if (toleranceFactor <= 0) return null;
+	const half = avgGlyphHeight(layout) * toleranceFactor / 2;
+	let best = -1;
+	let bestDist = Infinity;
+	for (const run of layout.runs) {
+		const q = pts[run.frame];
+		const r = run.rect;
+		if (q.x < r.left - half || q.x > r.right + half || q.y < r.bottom - half || q.y > r.top + half) continue;
+		for (let i = 0; i < run.count; i++) {
+			const g = layout.glyphs[run.charStart + i];
+			if (isEmpty(g.flags)) continue;
+			const b = g.tight ?? g.loose;
+			if (q.x < b.left - half || q.x > b.right + half || q.y < b.bottom - half || q.y > b.top + half) continue;
+			const dx = Math.min(Math.abs(q.x - b.left), Math.abs(q.x - b.right));
+			const dy = Math.min(Math.abs(q.y - b.bottom), Math.abs(q.y - b.top));
+			if (dx + dy < bestDist) {
+				bestDist = dx + dy;
+				best = run.charStart + i;
+			}
+		}
+	}
+	return best >= 0 ? best : null;
+}
+/** Double-click: the word around `glyph` (walk to space/empty glyphs both ways). */
+function expandTextRangeToWord(layout, glyph) {
+	const n = layout.glyphs.length;
+	if (glyph < 0 || glyph >= n) return [glyph, glyph];
+	let from = glyph;
+	while (from > 0 && !isBoundary(layout.glyphs[from - 1].flags)) from--;
+	let to = glyph;
+	while (to < n - 1 && !isBoundary(layout.glyphs[to + 1].flags)) to++;
+	return [from, to];
+}
+/** Triple-click: the full visual line — SAME-FRAME runs whose vertical extent
+*  overlaps the anchor run's. A differently-oriented run is a line boundary. */
+function expandTextRangeToLine(layout, glyph) {
+	const ri = layout.runs.findIndex((r) => glyph >= r.charStart && glyph < r.charStart + r.count);
+	if (ri < 0) return [glyph, glyph];
+	const anchor = layout.runs[ri];
+	const bottom = anchor.rect.bottom;
+	const top = anchor.rect.top;
+	let from = anchor.charStart;
+	let to = anchor.charStart + anchor.count - 1;
+	for (let r = ri - 1; r >= 0; r--) {
+		const run = layout.runs[r];
+		if (isZero(run.rect)) continue;
+		if (run.frame !== anchor.frame) break;
+		if (!overlapV(run.rect.bottom, run.rect.top, bottom, top)) break;
+		from = run.charStart;
+	}
+	for (let r = ri + 1; r < layout.runs.length; r++) {
+		const run = layout.runs[r];
+		if (isZero(run.rect)) continue;
+		if (run.frame !== anchor.frame) break;
+		if (!overlapV(run.rect.bottom, run.rect.top, bottom, top)) break;
+		to = run.charStart + run.count - 1;
+	}
+	return [from, to];
+}
+/**
+* A single glyph's oriented cell in page space, or null for degenerate
+* glyphs — the anchor for caret placement at a selection boundary.
+*/
+function textGlyphQuad(layout, glyph) {
+	const g = layout.glyphs[glyph];
+	if (!g || isEmpty(g.flags)) return null;
+	const b = g.loose;
+	if (b.right <= b.left || b.top <= b.bottom) return null;
+	const run = layout.runs.find((r) => glyph >= r.charStart && glyph < r.charStart + r.count);
+	const f = layout.frames[run?.frame ?? 0];
+	return quadOfFrameRect(f, run?.frame ?? 0, b);
+}
+/**
+* Merged visual-line segments for the half-open char range
+* `[charStart, charStart + charCount)` — THE canonical segmentation. Chars
+* outside the layout are ignored.
+*/
+function textSegmentsForRange(layout, charStart, charCount) {
+	if (charCount <= 0 || layout.glyphs.length === 0) return [];
+	const lo = Math.max(0, charStart);
+	const hi = Math.min(layout.glyphs.length - 1, charStart + charCount - 1);
+	if (hi < lo) return [];
+	const subRuns = [];
+	for (const run of layout.runs) {
+		const runEnd = run.charStart + run.count - 1;
 		if (runEnd < lo || run.charStart > hi) continue;
 		const s = Math.max(lo, run.charStart);
 		const e = Math.min(hi, runEnd);
@@ -1045,63 +1331,141 @@ function searchRectsForRange(snapshot, charStart, charCount) {
 		let right = -Infinity;
 		let bottom = Infinity;
 		let top = -Infinity;
-		let count = 0;
+		let charCountAcc = 0;
 		let widthSum = 0;
 		let prevRight = -Infinity;
+		let firstX = 0;
+		let lastX = 0;
 		const flush = () => {
-			if (count > 0 && right > left && top > bottom) subRuns.push({
+			if (charCountAcc > 0 && left !== Infinity) subRuns.push({
 				rect: {
 					left,
 					bottom,
 					right,
 					top
 				},
-				charCount: count,
-				fontSize: run.fontSize
+				charCount: charCountAcc,
+				fontSize: run.fontSize,
+				frame: run.frame,
+				firstX,
+				lastX
 			});
 			left = Infinity;
 			right = -Infinity;
 			bottom = Infinity;
 			top = -Infinity;
-			count = 0;
+			charCountAcc = 0;
 			widthSum = 0;
 			prevRight = -Infinity;
 		};
 		for (let ci = s; ci <= e; ci++) {
-			const g = run.glyphs[ci - run.charStart];
-			if ((g.flags & FLAG_EMPTY) !== 0) continue;
-			const b = g.looseBox;
-			if (count > 0 && prevRight > -Infinity) {
-				const avg = widthSum / count;
+			const g = layout.glyphs[ci];
+			if (isEmpty(g.flags)) continue;
+			const b = g.loose;
+			if (charCountAcc > 0 && prevRight > -Infinity) {
+				const avg = widthSum / charCountAcc;
 				if (avg > 0 && Math.abs(b.left - prevRight) > CHAR_DISTANCE_FACTOR * avg) flush();
 			}
+			const centerX = (b.left + b.right) / 2;
+			if (charCountAcc === 0) firstX = centerX;
+			lastX = centerX;
 			left = Math.min(left, b.left);
 			right = Math.max(right, b.right);
 			bottom = Math.min(bottom, b.bottom);
 			top = Math.max(top, b.top);
-			count++;
+			charCountAcc++;
 			widthSum += b.right - b.left;
 			prevRight = b.right;
 		}
 		flush();
 	}
-	return mergeAdjacentRects(subRuns);
+	return mergeAdjacentSubRuns(subRuns).map((m) => materializeSegment(layout, m));
 }
-function mergeAdjacentRects(runs) {
+function mergeAdjacentSubRuns(runs) {
 	const out = [];
 	let prev = null;
 	let cur = null;
 	for (const run of runs) {
-		if (prev && cur && shouldMerge(prev, run)) cur = union(cur, run.rect);
+		if (prev && cur && prev.frame === run.frame && shouldMerge(prev, run)) cur = {
+			rect: {
+				left: Math.min(cur.rect.left, run.rect.left),
+				bottom: Math.min(cur.rect.bottom, run.rect.bottom),
+				right: Math.max(cur.rect.right, run.rect.right),
+				top: Math.max(cur.rect.top, run.rect.top)
+			},
+			frame: cur.frame,
+			firstX: cur.firstX,
+			lastX: run.lastX
+		};
 		else {
 			if (cur) out.push(cur);
-			cur = run.rect;
+			cur = {
+				rect: run.rect,
+				frame: run.frame,
+				firstX: run.firstX,
+				lastX: run.lastX
+			};
 		}
 		prev = run;
 	}
-	if (cur) out.push(cur);
+	if (cur && cur.rect.right > cur.rect.left && cur.rect.top > cur.rect.bottom) out.push(cur);
 	return out;
 }
+/** Segment quad for a frame-local rect (frame 0: the rect's own corners,
+*  no float round-trip). Slot order US, UE, LS, LE; frame is y-up, so the
+*  upper corners sit at the frame TOP. */
+function quadOfFrameRect(f, frameIndex, r) {
+	if (frameIndex === 0) return {
+		p1: {
+			x: r.left,
+			y: r.top
+		},
+		p2: {
+			x: r.right,
+			y: r.top
+		},
+		p3: {
+			x: r.left,
+			y: r.bottom
+		},
+		p4: {
+			x: r.right,
+			y: r.bottom
+		}
+	};
+	return {
+		p1: fromFrame(f, {
+			x: r.left,
+			y: r.top
+		}),
+		p2: fromFrame(f, {
+			x: r.right,
+			y: r.top
+		}),
+		p3: fromFrame(f, {
+			x: r.left,
+			y: r.bottom
+		}),
+		p4: fromFrame(f, {
+			x: r.right,
+			y: r.bottom
+		})
+	};
+}
+function materializeSegment(layout, m) {
+	const frame = layout.frames[m.frame];
+	const quad = quadOfFrameRect(frame, m.frame, m.rect);
+	return {
+		quad,
+		rect: m.frame === 0 ? m.rect : {
+			left: Math.min(quad.p1.x, quad.p2.x, quad.p3.x, quad.p4.x),
+			bottom: Math.min(quad.p1.y, quad.p2.y, quad.p3.y, quad.p4.y),
+			right: Math.max(quad.p1.x, quad.p2.x, quad.p3.x, quad.p4.x),
+			top: Math.max(quad.p1.y, quad.p2.y, quad.p3.y, quad.p4.y)
+		},
+		advance: m.lastX >= m.firstX ? 1 : -1
+	};
+}
 function shouldMerge(a, b) {
 	if (a.fontSize != null && b.fontSize != null && a.fontSize > 0 && b.fontSize > 0) {
 		if (Math.max(a.fontSize, b.fontSize) / Math.min(a.fontSize, b.fontSize) > FONT_SIZE_RATIO_THRESHOLD) return false;
@@ -1114,14 +1478,6 @@ function shouldMerge(a, b) {
 	const bL = b.rect.left - bw;
 	return aL < b.rect.right + bw && aR > bL;
 }
-function union(a, b) {
-	return {
-		left: Math.min(a.left, b.left),
-		bottom: Math.min(a.bottom, b.bottom),
-		right: Math.max(a.right, b.right),
-		top: Math.max(a.top, b.top)
-	};
-}
 function verticalOverlap(a, b) {
 	const ah = a.top - a.bottom;
 	const bh = b.top - b.bottom;
@@ -1130,6 +1486,28 @@ function verticalOverlap(a, b) {
 	if (u === ah || u === bh) return 1;
 	return Math.max(0, Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom)) / u;
 }
+const isZero = (r) => r.right === r.left && r.top === r.bottom;
+function overlapV(bottom1, top1, bottom2, top2) {
+	const u = Math.max(top1, top2) - Math.min(bottom1, bottom2);
+	if (u === 0) return false;
+	return Math.max(0, Math.min(top1, top2) - Math.max(bottom1, bottom2)) / u >= LINE_OVERLAP_THRESHOLD;
+}
+//#endregion
+//#region src/search/rects.ts
+/**
+* Match-range → canonical visual-line segments. Thin wrappers over the ONE
+* text layout (`src/text/layout.ts`) — search owns matching and cursors,
+* never segmentation, so a match highlights exactly like a selection of the
+* same characters. No frame or merge logic lives here.
+*/
+/** Canonical segments for `[charStart, charStart + charCount)`. */
+function searchSegmentsForRange(snapshot, charStart, charCount) {
+	return textSegmentsForRange(buildPageTextLayout(snapshot), charStart, charCount);
+}
+/** The segments' AABBs — for consumers that genuinely want boxes. */
+function searchRectsForRange(snapshot, charStart, charCount) {
+	return searchSegmentsForRange(snapshot, charStart, charCount).map((s) => s.rect);
+}
 //#endregion
 //#region src/search/epoch.ts
 /**
@@ -1362,6 +1740,6 @@ function materializePdfPermissions(b) {
 	return [...out];
 }
 //#endregion
-export { pdfRectWidth as $, refKey as A, decodeStableIdKey as B, appearanceImpactOf as C, shiftsExistingAnnotationIndices as D, invalidatesWeakIndexRefs as E, resolveBinarySource as F, normalizePdfRect as G, isValidPageObjectNumber as H, NO_ANNOTATION_FLAGS as I, pdfQuadFromCorners as J, pdfQuadBounds as K, UNKNOWN_WEAK_ANNOTATION_STATE as L, normalizeAnnotationPatch as M, normalizeAttachmentFileSource as N, buildThreads as O, sniffBinaryMetadata as P, pdfRectToOriginSize as Q, knownWeakAnnotationState as R, encodeFieldRefKey as S, changesAnnotationList as T, DEFAULT_PDF_SAVE_MODE as U, encodeStableIdKey as V, createPageImageHandle as W, pdfRectHeight as X, pdfRectFromOriginSize as Y, pdfRectSize as Z, foldOptionsFor as _, PDF_BITS as a, wordBefore as b, searchContentEpoch as c, buildSnippet as d, matchPageText as f, validateSearchRegex as g, validateSearchQuery as h, pdfPermissions as i, normalizeAnnotationDraft as j, classifyRelation as k, searchRectsForRange as l, matchRegex as m, collab as n, decodePdfBits as o, SEARCH_REGEX_MAX_LENGTH as p, pdfQuadCorners as q, materializePdfPermissions as r, canonicalSearchQuery as s, caps as t, SEARCH_SNIPPET_CONTEXT as u, matchLiteral as v, semanticEqual as w, decodeFieldRefKey as x, wordAt as y, revisionTokensEqual as z };
+export { createPageImageHandle as $, appearanceImpactOf as A, normalizeAnnotationDraft as B, validateSearchRegex as C, wordBefore as D, wordAt as E, buildCommentThreads as F, NO_ANNOTATION_FLAGS as G, normalizeAttachmentFileSource as H, isStateAnnotation as I, revisionTokensEqual as J, UNKNOWN_WEAK_ANNOTATION_STATE as K, buildThreads as L, changesAnnotationList as M, invalidatesWeakIndexRefs as N, decodeFieldRefKey as O, shiftsExistingAnnotationIndices as P, DEFAULT_PDF_SAVE_MODE as Q, classifyRelation as R, validateSearchQuery as S, matchLiteral as T, sniffBinaryMetadata as U, normalizeAnnotationPatch as V, resolveBinarySource as W, encodeStableIdKey as X, decodeStableIdKey as Y, isValidPageObjectNumber as Z, SEARCH_SNIPPET_CONTEXT as _, PDF_BITS as a, SEARCH_REGEX_MAX_LENGTH as b, searchContentEpoch as c, buildPageTextLayout as d, expandTextRangeToLine as f, textSegmentsForRange as g, textGlyphQuad as h, pdfPermissions as i, semanticEqual as j, encodeFieldRefKey as k, searchRectsForRange as l, textGlyphAt as m, collab as n, decodePdfBits as o, expandTextRangeToWord as p, knownWeakAnnotationState as q, materializePdfPermissions as r, canonicalSearchQuery as s, caps as t, searchSegmentsForRange as u, buildSnippet as v, foldOptionsFor as w, matchRegex as x, matchPageText as y, refKey as z };
 
-//# sourceMappingURL=builders-C548U47M.js.map
+//# sourceMappingURL=builders-B_KufGJ9.js.map