flappa-doormal 2.10.0 → 2.11.0

package/dist/index.mjs

@@ -1278,7 +1278,7 @@ const estimateStartOffsetInCurrentPage = (remainingContent, currentFromIdx, page
 * This is used to define breakpoint windows in terms of actual content being split, rather than
 * raw per-page offsets which can desync when structural rules strip markers.
 */
-const findPageStartNearExpectedBoundary = (remainingContent, _currentFromIdx, targetPageIdx, expectedBoundary, pageIds, normalizedPages) => {
+const findPageStartNearExpectedBoundary = (remainingContent, _currentFromIdx, targetPageIdx, expectedBoundary, pageIds, normalizedPages, logger) => {
 	const targetPageData = normalizedPages.get(pageIds[targetPageIdx]);
 	if (!targetPageData) return -1;
 	const approx = Math.min(Math.max(0, expectedBoundary), remainingContent.length);
@@ -1288,13 +1288,45 @@ const findPageStartNearExpectedBoundary = (remainingContent, _currentFromIdx, ta
 	for (const len of WINDOW_PREFIX_LENGTHS) {
 		const prefix = targetTrimmed.slice(0, Math.min(len, targetTrimmed.length)).trim();
 		if (!prefix) continue;
+		const candidates = [];
 		let pos = remainingContent.indexOf(prefix, searchStart);
 		while (pos !== -1 && pos <= searchEnd) {
-			if (pos > 0 && /\s/.test(remainingContent[pos - 1] ?? "")) return pos;
+			if (pos > 0) {
+				const charBefore = remainingContent[pos - 1];
+				if (charBefore === "\n") candidates.push({
+					isNewline: true,
+					pos
+				});
+				else if (/\s/.test(charBefore)) candidates.push({
+					isNewline: false,
+					pos
+				});
+			}
 			pos = remainingContent.indexOf(prefix, pos + 1);
 		}
-		const last = remainingContent.lastIndexOf(prefix, approx);
-		if (last > 0) return last;
+		if (candidates.length > 0) {
+			const newlineCandidates = candidates.filter((c) => c.isNewline);
+			const pool = newlineCandidates.length > 0 ? newlineCandidates : candidates;
+			let bestCandidate = pool[0];
+			let bestDistance = Math.abs(pool[0].pos - expectedBoundary);
+			for (let i = 1; i < pool.length; i++) {
+				const dist = Math.abs(pool[i].pos - expectedBoundary);
+				if (dist < bestDistance) {
+					bestDistance = dist;
+					bestCandidate = pool[i];
+				}
+			}
+			const MAX_DEVIATION = 2e3;
+			if (bestDistance <= MAX_DEVIATION) return bestCandidate.pos;
+			logger?.debug?.("[breakpoints] findPageStartNearExpectedBoundary: Rejected match exceeding deviation", {
+				bestDistance,
+				expectedBoundary,
+				matchPos: bestCandidate.pos,
+				maxDeviation: MAX_DEVIATION,
+				prefixLength: len,
+				targetPageIdx
+			});
+		}
 	}
 	return -1;
 };
@@ -1314,6 +1346,7 @@ const findPageStartNearExpectedBoundary = (remainingContent, _currentFromIdx, ta
 * @param pageIds - Array of all page IDs
 * @param normalizedPages - Map of page ID to normalized content
 * @param cumulativeOffsets - Cumulative character offsets (for estimates)
+* @param logger - Optional logger for debugging
 * @returns Array where boundaryPositions[i] = start position of page (fromIdx + i),
 *          with a sentinel boundary at segmentContent.length as the last element
 *
@@ -1322,12 +1355,12 @@ const findPageStartNearExpectedBoundary = (remainingContent, _currentFromIdx, ta
 * buildBoundaryPositions(content, 0, 2, pageIds, normalizedPages, offsets)
 * // → [0, 23, 45, 67] where 67 is content.length (sentinel)
 */
-const buildBoundaryPositions = (segmentContent, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets) => {
+const buildBoundaryPositions = (segmentContent, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger) => {
 	const boundaryPositions = [0];
 	const startOffsetInFromPage = estimateStartOffsetInCurrentPage(segmentContent, fromIdx, pageIds, normalizedPages);
 	for (let i = fromIdx + 1; i <= toIdx; i++) {
 		const expectedBoundary = cumulativeOffsets[i] !== void 0 && cumulativeOffsets[fromIdx] !== void 0 ? Math.max(0, cumulativeOffsets[i] - cumulativeOffsets[fromIdx] - startOffsetInFromPage) : segmentContent.length;
-		const pos = findPageStartNearExpectedBoundary(segmentContent, fromIdx, i, expectedBoundary, pageIds, normalizedPages);
+		const pos = findPageStartNearExpectedBoundary(segmentContent, fromIdx, i, expectedBoundary, pageIds, normalizedPages, logger);
 		const prevBoundary = boundaryPositions[boundaryPositions.length - 1];
 		if (pos > 0 && pos > prevBoundary && Math.abs(pos - expectedBoundary) < 2e3) boundaryPositions.push(pos);
 		else {
@@ -1371,18 +1404,20 @@ const findPageIndexForPosition = (position, boundaryPositions, fromIdx) => {
 * found within the actual `remainingContent` string being split. This avoids relying on raw page offsets
 * that can diverge when structural rules strip markers (e.g. `lineStartsAfter`).
 */
-const findBreakpointWindowEndPosition = (remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets) => {
+const findBreakpointWindowEndPosition = (remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger) => {
 	if (windowEndIdx >= toIdx) return remainingContent.length;
 	const desiredNextIdx = windowEndIdx + 1;
 	const minNextIdx = currentFromIdx + 1;
 	const maxNextIdx = Math.min(desiredNextIdx, toIdx);
 	const startOffsetInCurrentPage = estimateStartOffsetInCurrentPage(remainingContent, currentFromIdx, pageIds, normalizedPages);
+	let bestExpectedBoundary = remainingContent.length;
 	for (let nextIdx = maxNextIdx; nextIdx >= minNextIdx; nextIdx--) {
 		const expectedBoundary = cumulativeOffsets[nextIdx] !== void 0 && cumulativeOffsets[currentFromIdx] !== void 0 ? Math.max(0, cumulativeOffsets[nextIdx] - cumulativeOffsets[currentFromIdx] - startOffsetInCurrentPage) : remainingContent.length;
-		const pos = findPageStartNearExpectedBoundary(remainingContent, currentFromIdx, nextIdx, expectedBoundary, pageIds, normalizedPages);
+		if (nextIdx === maxNextIdx) bestExpectedBoundary = expectedBoundary;
+		const pos = findPageStartNearExpectedBoundary(remainingContent, currentFromIdx, nextIdx, expectedBoundary, pageIds, normalizedPages, logger);
 		if (pos > 0) return pos;
 	}
-	return remainingContent.length;
+	return Math.min(bestExpectedBoundary, remainingContent.length);
 };
 /**
 * Finds exclusion-based break position using raw cumulative offsets.
@@ -1460,7 +1495,8 @@ const handlePageBoundaryBreak = (remainingContent, windowEndIdx, windowEndPositi
 		const nextPageData = normalizedPages.get(pageIds[nextPageIdx]);
 		if (nextPageData) {
 			const pos = findNextPagePosition(remainingContent, nextPageData);
-			if (pos > 0) return Math.min(pos, windowEndPosition, remainingContent.length);
+			const tolerance = Math.max(2e3, windowEndPosition * .5);
+			if (pos > 0 && Math.abs(pos - windowEndPosition) <= tolerance) return Math.min(pos, windowEndPosition, remainingContent.length);
 		}
 	}
 	return Math.min(windowEndPosition, remainingContent.length);
@@ -1484,19 +1520,47 @@ const findBreakPosition = (remainingContent, currentFromIdx, toIdx, windowEndIdx
 		if (hasExcludedPageInRange(excludeSet, pageIds, currentFromIdx, windowEndIdx)) continue;
 		if (skipWhenRegex?.test(remainingContent)) continue;
 		if (regex === null) return {
-			breakpointIndex: i,
 			breakPos: handlePageBoundaryBreak(remainingContent, windowEndIdx, windowEndPosition, toIdx, pageIds, normalizedPages),
+			breakpointIndex: i,
 			rule
 		};
 		const breakPos = findPatternBreakPosition(remainingContent.slice(0, Math.min(windowEndPosition, remainingContent.length)), regex, prefer);
 		if (breakPos > 0) return {
-			breakpointIndex: i,
 			breakPos,
+			breakpointIndex: i,
 			rule
 		};
 	}
 	return null;
 };
+/**
+* Searches backward from a target position to find a "safe" split point.
+* A safe split point is after whitespace or punctuation.
+*
+* @param content The text content
+* @param targetPosition The desired split position (hard limit)
+* @param lookbackChars How far back to search for a safe break
+* @returns The new split position (index), or -1 if no safe break found
+*/
+const findSafeBreakPosition = (content, targetPosition, lookbackChars = 100) => {
+	const startSearch = Math.max(0, targetPosition - lookbackChars);
+	for (let i = targetPosition - 1; i >= startSearch; i--) {
+		const char = content[i];
+		if (/[\s\n.,;!?؛،۔]/.test(char)) return i + 1;
+	}
+	return -1;
+};
+/**
+* Ensures the position does not split a surrogate pair.
+* If position is between High and Low surrogate, returns position - 1.
+*/
+const adjustForSurrogate = (content, position) => {
+	if (position <= 0 || position >= content.length) return position;
+	const high = content.charCodeAt(position - 1);
+	const low = content.charCodeAt(position);
+	if (high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343) return position - 1;
+	return position;
+};
 
 //#endregion
 //#region src/segmentation/debug-meta.ts
@@ -1623,7 +1687,7 @@ const createPieceSegment = (pieceContent, actualStartIdx, actualEndIdx, pageIds,
 *
 * @returns Break offset relative to remainingContent, or windowEndPosition as fallback
 */
-const findBreakOffsetForWindow = (remainingContent, currentFromIdx, windowEndIdx, toIdx, windowEndPosition, pageIds, expandedBreakpoints, cumulativeOffsets, normalizedPages, prefer) => {
+const findBreakOffsetForWindow = (remainingContent, currentFromIdx, windowEndIdx, toIdx, windowEndPosition, pageIds, expandedBreakpoints, cumulativeOffsets, normalizedPages, prefer, maxContentLength) => {
 	if (hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, windowEndIdx)) {
 		const exclusionBreak = findExclusionBreakPosition(currentFromIdx, windowEndIdx, toIdx, pageIds, expandedBreakpoints, cumulativeOffsets);
 		if (exclusionBreak > 0) return { breakOffset: exclusionBreak };
@@ -1639,6 +1703,11 @@ const findBreakOffsetForWindow = (remainingContent, currentFromIdx, windowEndIdx
 		breakpointIndex: patternMatch.breakpointIndex,
 		breakpointRule: patternMatch.rule
 	};
+	if (maxContentLength && windowEndPosition === maxContentLength) {
+		const safeOffset = findSafeBreakPosition(remainingContent, windowEndPosition);
+		if (safeOffset !== -1) return { breakOffset: safeOffset };
+		return { breakOffset: adjustForSurrogate(remainingContent, windowEndPosition) };
+	}
 	return { breakOffset: windowEndPosition };
 };
 /**
@@ -1655,71 +1724,118 @@ const skipWhitespace$1 = (content, startPos) => {
 *
 * Uses precomputed boundary positions for O(log n) page attribution lookups.
 */
-const processOversizedSegment = (segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, prefer, logger, debugMetaKey) => {
+const processOversizedSegment = (segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, prefer, logger, debugMetaKey, maxContentLength) => {
 	const result = [];
 	const fullContent = segment.content;
 	let cursorPos = 0;
 	let currentFromIdx = fromIdx;
 	let isFirstPiece = true;
 	let lastBreakpoint = null;
-	const boundaryPositions = buildBoundaryPositions(fullContent, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets);
+	const boundaryPositions = buildBoundaryPositions(fullContent, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger);
 	logger?.debug?.("[breakpoints] boundaryPositions built", {
 		boundaryPositions,
 		fromIdx,
 		fullContentLength: fullContent.length,
 		toIdx
 	});
-	const maxIterations = 1e4;
-	for (let i = 0; i < maxIterations && cursorPos < fullContent.length && currentFromIdx <= toIdx; i++) {
+	let i = 0;
+	const MAX_SAFE_ITERATIONS = 1e5;
+	while (cursorPos < fullContent.length && currentFromIdx <= toIdx && i < MAX_SAFE_ITERATIONS) {
+		i++;
 		const remainingContent = fullContent.slice(cursorPos);
 		if (!remainingContent.trim()) break;
-		const remainingSpan = computeRemainingSpan(currentFromIdx, toIdx, pageIds);
-		const remainingHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, toIdx);
-		if (remainingSpan <= maxPages && !remainingHasExclusions) {
-			const includeMeta = isFirstPiece || Boolean(debugMetaKey);
-			const meta = debugMetaKey && lastBreakpoint ? mergeDebugIntoMeta(includeMeta ? segment.meta : void 0, debugMetaKey, buildBreakpointDebugPatch(lastBreakpoint.breakpointIndex, lastBreakpoint.rule)) : includeMeta ? segment.meta : void 0;
-			const finalSeg = createFinalSegment(remainingContent, currentFromIdx, toIdx, pageIds, meta, includeMeta);
-			if (finalSeg) result.push(finalSeg);
-			break;
-		}
+		if (handleOversizedSegmentFit(remainingContent, currentFromIdx, toIdx, pageIds, expandedBreakpoints, maxPages, maxContentLength, isFirstPiece, debugMetaKey, segment.meta, lastBreakpoint, result)) break;
 		const windowEndIdx = computeWindowEndIdx(currentFromIdx, toIdx, pageIds, maxPages);
-		const windowEndPosition = findBreakpointWindowEndPosition(remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets);
+		const windowEndPosition = getWindowEndPosition(remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, maxContentLength, logger);
 		logger?.debug?.(`[breakpoints] iteration=${i}`, {
 			currentFromIdx,
 			cursorPos,
-			windowEndIdx
+			windowEndIdx,
+			windowEndPosition
 		});
-		const found = findBreakOffsetForWindow(remainingContent, currentFromIdx, windowEndIdx, toIdx, windowEndPosition, pageIds, expandedBreakpoints, cumulativeOffsets, normalizedPages, prefer);
+		const found = findBreakOffsetForWindow(remainingContent, currentFromIdx, windowEndIdx, toIdx, windowEndPosition, pageIds, expandedBreakpoints, cumulativeOffsets, normalizedPages, prefer, maxContentLength);
+		let breakOffset = found.breakOffset;
+		if (breakOffset <= 0) {
+			const fallbackPos = maxContentLength ? Math.min(maxContentLength, remainingContent.length) : 1;
+			breakOffset = Math.max(1, fallbackPos);
+			logger?.warn?.("[breakpoints] No progress from findBreakOffsetForWindow; forcing forward movement", {
+				breakOffset,
+				cursorPos
+			});
+		}
 		if (found.breakpointIndex !== void 0 && found.breakpointRule) lastBreakpoint = {
 			breakpointIndex: found.breakpointIndex,
 			rule: found.breakpointRule
 		};
-		const breakPos = cursorPos + found.breakOffset;
+		const breakPos = cursorPos + breakOffset;
 		const pieceContent = fullContent.slice(cursorPos, breakPos).trim();
-		const { actualEndIdx, actualStartIdx } = computePiecePages(cursorPos, breakPos, boundaryPositions, fromIdx, toIdx);
-		logger?.trace?.("[breakpoints] piece", {
-			actualEndIdx,
-			actualStartIdx,
-			pieceLength: pieceContent.length
-		});
 		if (pieceContent) {
-			const includeMeta = isFirstPiece || Boolean(debugMetaKey);
-			const pieceSeg = createPieceSegment(pieceContent, actualStartIdx, actualEndIdx, pageIds, debugMetaKey && lastBreakpoint ? mergeDebugIntoMeta(includeMeta ? segment.meta : void 0, debugMetaKey, buildBreakpointDebugPatch(lastBreakpoint.breakpointIndex, lastBreakpoint.rule)) : includeMeta ? segment.meta : void 0, includeMeta);
+			const { actualEndIdx, actualStartIdx } = computePiecePages(cursorPos, breakPos, boundaryPositions, fromIdx, toIdx);
+			const pieceSeg = createPieceSegment(pieceContent, actualStartIdx, actualEndIdx, pageIds, getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, segment.meta, lastBreakpoint), true);
 			if (pieceSeg) result.push(pieceSeg);
-		}
-		cursorPos = skipWhitespace$1(fullContent, breakPos);
-		currentFromIdx = computeNextFromIdx(fullContent.slice(cursorPos), actualEndIdx, toIdx, pageIds, normalizedPages);
+			const next = advanceCursorAndIndex(fullContent, breakPos, actualEndIdx, toIdx, pageIds, normalizedPages);
+			cursorPos = next.cursorPos;
+			currentFromIdx = next.currentFromIdx;
+		} else cursorPos = breakPos;
 		isFirstPiece = false;
 	}
+	if (i >= MAX_SAFE_ITERATIONS) logger?.error?.("[breakpoints] Stopped processing oversized segment: reached MAX_SAFE_ITERATIONS", {
+		cursorPos,
+		fullContentLength: fullContent.length,
+		iterations: i
+	});
 	logger?.debug?.("[breakpoints] done", { resultCount: result.length });
 	return result;
 };
 /**
+* Checks if the remaining content fits within paged/length limits.
+* If so, pushes the final segment and returns true.
+*/
+const handleOversizedSegmentFit = (remainingContent, currentFromIdx, toIdx, pageIds, expandedBreakpoints, maxPages, maxContentLength, isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint, result) => {
+	const remainingSpan = computeRemainingSpan(currentFromIdx, toIdx, pageIds);
+	const remainingHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, toIdx);
+	const fitsInPages = remainingSpan <= maxPages;
+	const fitsInLength = !maxContentLength || remainingContent.length <= maxContentLength;
+	if (fitsInPages && fitsInLength && !remainingHasExclusions) {
+		const includeMeta = isFirstPiece || Boolean(debugMetaKey);
+		const finalSeg = createFinalSegment(remainingContent, currentFromIdx, toIdx, pageIds, getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint), includeMeta);
+		if (finalSeg) result.push(finalSeg);
+		return true;
+	}
+	return false;
+};
+/**
+* Builds metadata for a segment piece, optionally including debug info.
+*/
+const getSegmentMetaWithDebug = (isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint) => {
+	if (!(isFirstPiece || Boolean(debugMetaKey))) return;
+	if (debugMetaKey && lastBreakpoint) return mergeDebugIntoMeta(isFirstPiece ? originalMeta : void 0, debugMetaKey, buildBreakpointDebugPatch(lastBreakpoint.breakpointIndex, lastBreakpoint.rule));
+	return isFirstPiece ? originalMeta : void 0;
+};
+/**
+* Calculates window end position, capped by maxContentLength if present.
+*/
+const getWindowEndPosition = (remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, maxContentLength, logger) => {
+	let windowEndPosition = findBreakpointWindowEndPosition(remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger);
+	if (maxContentLength && maxContentLength < windowEndPosition) windowEndPosition = maxContentLength;
+	return windowEndPosition;
+};
+/**
+* Advances cursorPos and currentFromIdx for the next iteration.
+*/
+const advanceCursorAndIndex = (fullContent, breakPos, actualEndIdx, toIdx, pageIds, normalizedPages) => {
+	const nextCursorPos = skipWhitespace$1(fullContent, breakPos);
+	return {
+		currentFromIdx: computeNextFromIdx(fullContent.slice(nextCursorPos), actualEndIdx, toIdx, pageIds, normalizedPages),
+		cursorPos: nextCursorPos
+	};
+};
+/**
 * Applies breakpoints to oversized segments.
 *
 * Note: This is an internal engine used by `segmentPages()`.
 */
-const applyBreakpoints = (segments, pages, normalizedContent, maxPages, breakpoints, prefer, patternProcessor, logger, pageJoiner = "space", debugMetaKey) => {
+const applyBreakpoints = (segments, pages, normalizedContent, maxPages, breakpoints, prefer, patternProcessor, logger, pageJoiner = "space", debugMetaKey, maxContentLength) => {
 	const pageIds = pages.map((p) => p.id);
 	const pageIdToIndex = buildPageIdToIndexMap(pageIds);
 	const normalizedPages = buildNormalizedPagesMap(pages, normalizedContent);
@@ -1743,11 +1859,13 @@ const applyBreakpoints = (segments, pages, normalizedContent, maxPages, breakpoi
 		const toIdx = segment.to !== void 0 ? pageIdToIndex.get(segment.to) ?? fromIdx : fromIdx;
 		const segmentSpan = (segment.to ?? segment.from) - segment.from;
 		const hasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, fromIdx, toIdx);
-		if (segmentSpan <= maxPages && !hasExclusions) {
+		const fitsInPages = segmentSpan <= maxPages;
+		const fitsInLength = !maxContentLength || segment.content.length <= maxContentLength;
+		if (fitsInPages && fitsInLength && !hasExclusions) {
 			result.push(segment);
 			continue;
 		}
-		const broken = processOversizedSegment(segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, prefer, logger, debugMetaKey);
+		const broken = processOversizedSegment(segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, prefer, logger, debugMetaKey, maxContentLength);
 		result.push(...broken.map((s) => {
 			const segFromIdx = pageIdToIndex.get(s.from) ?? -1;
 			const segToIdx = s.to !== void 0 ? pageIdToIndex.get(s.to) ?? segFromIdx : segFromIdx;
@@ -2210,6 +2328,47 @@ const createPageStartGuardChecker = (matchContent, pageMap) => {
 		return prevReq.test(lastChar);
 	};
 };
+/**
+* Checks if a pageId matches the min/max/exclude constraints of a rule.
+*/
+const passesRuleConstraints$1 = (rule, pageId) => {
+	return (rule.min === void 0 || pageId >= rule.min) && (rule.max === void 0 || pageId <= rule.max) && !isPageExcluded(pageId, rule.exclude);
+};
+/**
+* Records a split point for a specific rule.
+*/
+const recordSplitPointAt = (splitPointsByRule, ruleIndex, sp) => {
+	const arr = splitPointsByRule.get(ruleIndex);
+	if (!arr) {
+		splitPointsByRule.set(ruleIndex, [sp]);
+		return;
+	}
+	arr.push(sp);
+};
+/**
+* Processes matches for all fast-fuzzy rules at a specific line start.
+*/
+const processFastFuzzyMatchesAt = (matchContent, lineStart, pageId, fastFuzzyRules, passesPageStartGuard, isPageStart, splitPointsByRule) => {
+	for (const { compiled, kind, rule, ruleIndex } of fastFuzzyRules) {
+		if (!passesRuleConstraints$1(rule, pageId)) continue;
+		if (isPageStart && !passesPageStartGuard(rule, ruleIndex, lineStart)) continue;
+		const end = matchFastFuzzyTokenAt(matchContent, lineStart, compiled);
+		if (end === null) continue;
+		const splitIndex = (rule.split ?? "at") === "at" ? lineStart : end;
+		if (kind === "startsWith") recordSplitPointAt(splitPointsByRule, ruleIndex, {
+			index: splitIndex,
+			meta: rule.meta
+		});
+		else {
+			const markerLength = end - lineStart;
+			recordSplitPointAt(splitPointsByRule, ruleIndex, {
+				contentStartOffset: (rule.split ?? "at") === "at" ? markerLength : void 0,
+				index: splitIndex,
+				meta: rule.meta
+			});
+		}
+	}
+};
 const collectFastFuzzySplitPoints = (matchContent, pageMap, fastFuzzyRules, passesPageStartGuard) => {
 	const splitPointsByRule = /* @__PURE__ */ new Map();
 	if (fastFuzzyRules.length === 0 || pageMap.boundaries.length === 0) return splitPointsByRule;
@@ -2221,38 +2380,12 @@ const collectFastFuzzySplitPoints = (matchContent, pageMap, fastFuzzyRules, pass
 			currentBoundary = pageMap.boundaries[boundaryIdx];
 		}
 	};
-	const recordSplitPoint = (ruleIndex, sp) => {
-		const arr = splitPointsByRule.get(ruleIndex);
-		if (!arr) {
-			splitPointsByRule.set(ruleIndex, [sp]);
-			return;
-		}
-		arr.push(sp);
-	};
 	const isPageStart = (offset) => offset === currentBoundary?.start;
 	for (let lineStart = 0; lineStart <= matchContent.length;) {
 		advanceBoundaryTo(lineStart);
 		const pageId = currentBoundary?.id ?? 0;
 		if (lineStart >= matchContent.length) break;
-		for (const { compiled, kind, rule, ruleIndex } of fastFuzzyRules) {
-			if (!((rule.min === void 0 || pageId >= rule.min) && (rule.max === void 0 || pageId <= rule.max) && !isPageExcluded(pageId, rule.exclude))) continue;
-			if (isPageStart(lineStart) && !passesPageStartGuard(rule, ruleIndex, lineStart)) continue;
-			const end = matchFastFuzzyTokenAt(matchContent, lineStart, compiled);
-			if (end === null) continue;
-			const splitIndex = (rule.split ?? "at") === "at" ? lineStart : end;
-			if (kind === "startsWith") recordSplitPoint(ruleIndex, {
-				index: splitIndex,
-				meta: rule.meta
-			});
-			else {
-				const markerLength = end - lineStart;
-				recordSplitPoint(ruleIndex, {
-					contentStartOffset: (rule.split ?? "at") === "at" ? markerLength : void 0,
-					index: splitIndex,
-					meta: rule.meta
-				});
-			}
-		}
+		processFastFuzzyMatchesAt(matchContent, lineStart, pageId, fastFuzzyRules, passesPageStartGuard, isPageStart(lineStart), splitPointsByRule);
 		const nextNl = matchContent.indexOf("\n", lineStart);
 		if (nextNl === -1) break;
 		lineStart = nextNl + 1;
@@ -2577,20 +2710,6 @@ const convertPageBreaks = (content, startOffset, pageBreaks) => {
 	return content.replace(/\n/g, (match, offset) => breakSet.has(offset) ? " " : match);
 };
 /**
-* Applies breakpoints to oversized segments.
-*
-* For each segment that spans more than maxPages, tries the breakpoint patterns
-* in order to find a suitable split point. Structural markers (from rules) are
-* always respected - segments are only broken within their boundaries.
-*
-* @param segments - Initial segments from rule processing
-* @param pages - Original pages for page lookup
-* @param maxPages - Maximum pages before breakpoints apply
-* @param breakpoints - Patterns to try in order (tokens supported)
-* @param prefer - 'longer' for last match, 'shorter' for first match
-* @returns Processed segments with oversized ones broken up
-*/
-/**
 * Segments pages of content based on pattern-matching rules.
 *
 * This is the main entry point for the segmentation engine. It takes an array
@@ -2633,11 +2752,14 @@ const convertPageBreaks = (content, startOffset, pageBreaks) => {
 * });
 */
 const segmentPages = (pages, options) => {
-	const { rules = [], maxPages = 0, breakpoints = [], prefer = "longer", pageJoiner = "space", logger } = options;
+	const { rules = [], breakpoints = [], prefer = "longer", pageJoiner = "space", logger, maxContentLength } = options;
+	if (maxContentLength && maxContentLength < 50) throw new Error(`maxContentLength must be at least 50 characters.`);
+	const maxPages = options.maxPages ?? (maxContentLength ? Number.MAX_SAFE_INTEGER : 0);
 	const debug = resolveDebugConfig(options.debug);
 	const debugMetaKey = debug?.includeRule ? debug.metaKey : void 0;
 	logger?.info?.("[segmenter] starting segmentation", {
 		breakpointCount: breakpoints.length,
+		maxContentLength,
 		maxPages,
 		pageCount: pages.length,
 		prefer,
@@ -2665,10 +2787,10 @@ const segmentPages = (pages, options) => {
 		}))
 	});
 	segments = ensureFallbackSegment(segments, processedPages, normalizedContent, pageJoiner);
-	if (maxPages >= 0 && breakpoints.length) {
+	if ((maxPages >= 0 || maxContentLength && maxContentLength > 0) && breakpoints.length) {
 		logger?.debug?.("[segmenter] applying breakpoints to oversized segments");
 		const patternProcessor = (p) => processPattern(p, false).pattern;
-		const result = applyBreakpoints(segments, processedPages, normalizedContent, maxPages, breakpoints, prefer, patternProcessor, logger, pageJoiner, debug?.includeBreakpoint ? debug.metaKey : void 0);
+		const result = applyBreakpoints(segments, processedPages, normalizedContent, maxPages, breakpoints, prefer, patternProcessor, logger, pageJoiner, debug?.includeBreakpoint ? debug.metaKey : void 0, maxContentLength);
 		logger?.info?.("[segmenter] segmentation complete (with breakpoints)", { finalSegmentCount: result.length });
 		return result;
 	}