flappa-doormal 2.19.0 → 2.21.0

package/dist/index.mjs

@@ -1,1123 +1,4 @@
-//#region src/segmentation/tokens.ts
-/**
-* Arabic base letters used by low-level dictionary-style regex helpers.
-*
-* This is intentionally broader than `{{harf}}`:
-* - includes standalone hamza `ء`
-* - stays as a raw regex fragment rather than a template token
-*/
-const ARABIC_BASE_LETTER_CLASS = "[ء-غف-ي]";
-/**
-* Arabic combining marks / annotation signs used by low-level regex helpers.
-*/
-const ARABIC_MARKS_CLASS = "[\\u0610-\\u061A\\u0640\\u064B-\\u065F\\u0670\\u06D6-\\u06ED]";
-/**
-* A single Arabic base letter followed by zero or more combining marks.
-*/
-const ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN = `${ARABIC_BASE_LETTER_CLASS}${ARABIC_MARKS_CLASS}*`;
-/**
-* One or more Arabic letters, where each letter may carry combining marks.
-*/
-const ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN = `(?:${ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN})+`;
-const ARABIC_SPACED_CODE_ATOM = `[أ-غف-ي]${ARABIC_MARKS_CLASS}*`;
-const RUMUZ_ATOM = `(?:${[
-	"تمييز(?![\\u064B-\\u0652\\u0670أ-ي])",
-	"خت",
-	"خغ",
-	"بخ",
-	"عخ",
-	"مق",
-	"مت",
-	"عس",
-	"سي",
-	"سن",
-	"كن",
-	"مد",
-	"قد",
-	"خد",
-	"فد",
-	"دل",
-	"كد",
-	"غد",
-	"صد",
-	"دت",
-	"دس",
-	"تم",
-	"فق",
-	"دق",
-	"[خرزيمنصسدفلتقع](?![\\u064B-\\u0652\\u0670أ-ي])",
-	"(?<![\\u0660-\\u0669])٤(?![\\u0660-\\u0669])"
-].join("|")})`;
-const RUMUZ_BLOCK = `${RUMUZ_ATOM}(?:\\s+${RUMUZ_ATOM})*`;
-const BASE_TOKENS = {
-	/** Chapter marker (باب). */
-	bab: "باب",
-	/** Basmala (بسم الله). Also matches ﷽. */
-	basmalah: ["بسم الله", "﷽"].join("|"),
-	/** Bullet point variants: `•`, `*`, `°`. */
-	bullet: "[•*°]",
-	/** Dash variants: `-` (U+002D), `–` (U+2013), `—` (U+2014), `ـ` (tatweel U+0640). */
-	dash: "[-–—ـ]",
-	/** Section marker (فصل / مسألة). */
-	fasl: ["مسألة", "فصل"].join("|"),
-	/** Single Arabic letter (أ-ي). Does NOT include diacritics. */
-	harf: "[أ-ي]",
-	/** One or more single Arabic letters separated by spaces, allowing marks/tatweel on each isolated letter (e.g. `د ت س`, `هـ ث`). For multi-letter codes use `{{rumuz}}`. */
-	harfs: `${ARABIC_SPACED_CODE_ATOM}(?:\\s+${ARABIC_SPACED_CODE_ATOM})*`,
-	/** Horizontal rule / separator: 5+ repeated dashes, underscores, equals, or tatweels. Mixed allowed. */
-	hr: "[-–—ـ_=]{5,}",
-	/** Book marker (كتاب). */
-	kitab: "كتاب",
-	/** Hadith transmission phrases (حدثنا, أخبرنا, حدثني, etc.). */
-	naql: [
-		"حدثني",
-		"وأخبرنا",
-		"حدثنا",
-		"سمعت",
-		"أنبأنا",
-		"وحدثنا",
-		"أخبرنا",
-		"وحدثني",
-		"وحدثنيه"
-	].join("|"),
-	/** Newline character. Useful for breakpoints that split on line boundaries. */
-	newline: "\\n",
-	/** Single ASCII digit (0-9). */
-	num: "\\d",
-	/** One or more ASCII digits (0-9)+. */
-	nums: "\\d+",
-	/** Single Arabic-Indic digit (٠-٩, U+0660-U+0669). */
-	raqm: "[\\u0660-\\u0669]",
-	/** One or more Arabic-Indic digits (٠-٩)+. */
-	raqms: "[\\u0660-\\u0669]+",
-	/** Rijāl/takhrīj source abbreviations. Matches one or more codes separated by whitespace. */
-	rumuz: RUMUZ_BLOCK,
-	/** Arabic/common punctuation: `.`, `!`, `?`, `؟`, `؛`. */
-	tarqim: "[.!?؟؛]"
-};
-/** Pre-defined token constants for use in patterns. */
-const Token = {
-	/** Chapter marker - باب */
-	BAB: "{{bab}}",
-	/** Basmala - بسم الله */
-	BASMALAH: "{{basmalah}}",
-	/** Bullet point variants */
-	BULLET: "{{bullet}}",
-	/** Dash variants (hyphen, en-dash, em-dash, tatweel) */
-	DASH: "{{dash}}",
-	/** Section marker - فصل / مسألة */
-	FASL: "{{fasl}}",
-	/** Single Arabic letter */
-	HARF: "{{harf}}",
-	/** Multiple Arabic letters separated by spaces, allowing marks/tatweel on each isolated letter */
-	HARFS: "{{harfs}}",
-	/** Horizontal rule / separator (repeated dashes) */
-	HR: "{{hr}}",
-	/** Book marker - كتاب */
-	KITAB: "{{kitab}}",
-	/** Hadith transmission phrases */
-	NAQL: "{{naql}}",
-	/** Newline character (for breakpoints) */
-	NEWLINE: "{{newline}}",
-	/** Single ASCII digit */
-	NUM: "{{num}}",
-	/** Composite: {{raqms}} {{dash}} (space) */
-	NUMBERED: "{{numbered}}",
-	/** One or more ASCII digits */
-	NUMS: "{{nums}}",
-	/** Single Arabic-Indic digit */
-	RAQM: "{{raqm}}",
-	/** One or more Arabic-Indic digits */
-	RAQMS: "{{raqms}}",
-	/** Source abbreviations (rijāl/takhrīj) */
-	RUMUZ: "{{rumuz}}",
-	/** Punctuation marks */
-	TARQIM: "{{tarqim}}"
-};
-/** Wraps a token constant with a named capture: `{{token}}` → `{{token:name}}`. */
-const withCapture = (token, name) => {
-	const match = token.match(/^\{\{(\w+)\}\}$/);
-	if (!match) return `{{:${name}}}`;
-	return `{{${match[1]}:${name}}}`;
-};
-/** Composite tokens that reference base tokens. Pre-expanded at load time. @internal */
-const COMPOSITE_TOKENS = { 
-/** Common hadith numbering format: Arabic-Indic digits + dash + space. */
-numbered: "{{raqms}} {{dash}} " };
-/** Expands composite tokens (e.g. `{{numbered}}`) to their underlying template form. */
-const expandCompositeTokensInTemplate = (template) => {
-	let out = template;
-	for (let i = 0; i < 10; i++) {
-		const next = out.replace(/\{\{(\w+)\}\}/g, (m, tokenName) => COMPOSITE_TOKENS[tokenName] ?? m);
-		if (next === out) break;
-		out = next;
-	}
-	return out;
-};
-/**
-* Expands base tokens in a template string.
-* Used internally to pre-expand composite tokens.
-*
-* @param template - Template string with `{{token}}` placeholders
-* @returns Expanded pattern with base tokens replaced
-* @internal
-*/
-const expandBaseTokens = (template) => template.replace(/\{\{(\w+)\}\}/g, (_, tokenName) => BASE_TOKENS[tokenName] ?? `{{${tokenName}}}`);
-/**
-* Token definitions mapping human-readable token names to regex patterns.
-*
-* Tokens are used in template strings with double-brace syntax:
-* - `{{token}}` - Expands to the pattern (non-capturing in context)
-* - `{{token:name}}` - Expands to a named capture group `(?<name>pattern)`
-* - `{{:name}}` - Captures any content with the given name `(?<name>.+)`
-*
-* @remarks
-* These patterns are designed for Arabic text matching. For diacritic-insensitive
-* matching of Arabic patterns, use the `fuzzy: true` option in split rules,
-* which applies `makeDiacriticInsensitive()` to the expanded patterns.
-*
-* @example
-* // Using tokens in a split rule
-* { lineStartsWith: ['{{kitab}}', '{{bab}}'], split: 'at', fuzzy: true }
-*
-* @example
-* // Using tokens with named captures
-* { lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '], split: 'at' }
-*
-* @example
-* // Using the numbered convenience token
-* { lineStartsAfter: ['{{numbered}}'], split: 'at' }
-*/
-const TOKEN_PATTERNS = {
-	...BASE_TOKENS,
-	...Object.fromEntries(Object.entries(COMPOSITE_TOKENS).map(([k, v]) => [k, expandBaseTokens(v)]))
-};
-/**
-* Regex pattern for matching tokens with optional named capture syntax.
-*
-* Matches:
-* - `{{token}}` - Simple token (group 1 = token name, group 2 = empty)
-* - `{{token:name}}` - Token with capture (group 1 = token, group 2 = name)
-* - `{{:name}}` - Capture-only (group 1 = empty, group 2 = name)
-*
-* @internal
-*/
-const TOKEN_WITH_CAPTURE_REGEX = /\{\{(\w*):?(\w*)\}\}/g;
-/**
-* Regex pattern for simple token matching (no capture syntax).
-*
-* Matches only `{{token}}` format where token is one or more word characters.
-* Used by `containsTokens()` for quick detection.
-*
-* @internal
-*/
-const SIMPLE_TOKEN_REGEX = /\{\{(\w+)\}\}/g;
-/**
-* Checks if a query string contains template tokens.
-*
-* Performs a quick test for `{{token}}` patterns without actually
-* expanding them. Useful for determining whether to apply token
-* expansion to a string.
-*
-* @param query - String to check for tokens
-* @returns `true` if the string contains at least one `{{token}}` pattern
-*
-* @example
-* containsTokens('{{raqms}} {{dash}}') // → true
-* containsTokens('plain text')          // → false
-* containsTokens('[٠-٩]+ - ')           // → false (raw regex, no tokens)
-*/
-const containsTokens = (query) => {
-	SIMPLE_TOKEN_REGEX.lastIndex = 0;
-	return SIMPLE_TOKEN_REGEX.test(query);
-};
-const splitTemplateIntoSegments = (query) => {
-	const segments = [];
-	let lastIndex = 0;
-	TOKEN_WITH_CAPTURE_REGEX.lastIndex = 0;
-	for (const match of query.matchAll(TOKEN_WITH_CAPTURE_REGEX)) {
-		if (match.index > lastIndex) segments.push({
-			type: "text",
-			value: query.slice(lastIndex, match.index)
-		});
-		segments.push({
-			type: "token",
-			value: match[0]
-		});
-		lastIndex = match.index + match[0].length;
-	}
-	if (lastIndex < query.length) segments.push({
-		type: "text",
-		value: query.slice(lastIndex)
-	});
-	return segments;
-};
-const maybeApplyFuzzyToText = (text, fuzzyTransform) => fuzzyTransform && /[\u0600-\u06FF]/u.test(text) ? fuzzyTransform(text) : text;
-const maybeApplyFuzzyToTokenPattern = (tokenPattern, fuzzyTransform) => !fuzzyTransform ? tokenPattern : tokenPattern.split("|").map((part) => /[\u0600-\u06FF]/u.test(part) ? fuzzyTransform(part) : part).join("|");
-const parseTokenLiteral = (literal) => {
-	TOKEN_WITH_CAPTURE_REGEX.lastIndex = 0;
-	const m = TOKEN_WITH_CAPTURE_REGEX.exec(literal);
-	return m ? {
-		captureName: m[2],
-		tokenName: m[1]
-	} : null;
-};
-const createCaptureRegistry = (capturePrefix) => {
-	const captureNames = [];
-	const captureNameCounts = /* @__PURE__ */ new Map();
-	const register = (baseName) => {
-		const count = captureNameCounts.get(baseName) ?? 0;
-		captureNameCounts.set(baseName, count + 1);
-		const uniqueName = count === 0 ? baseName : `${baseName}_${count + 1}`;
-		const prefixedName = capturePrefix ? `${capturePrefix}${uniqueName}` : uniqueName;
-		captureNames.push(prefixedName);
-		return prefixedName;
-	};
-	return {
-		captureNames,
-		register
-	};
-};
-const expandTokenLiteral = (literal, opts) => {
-	const parsed = parseTokenLiteral(literal);
-	if (!parsed) return literal;
-	const { tokenName, captureName } = parsed;
-	if (!tokenName && captureName) return `(?<${opts.registerCapture(captureName)}>.+)`;
-	let tokenPattern = TOKEN_PATTERNS[tokenName];
-	if (!tokenPattern) return literal;
-	tokenPattern = maybeApplyFuzzyToTokenPattern(tokenPattern, opts.fuzzyTransform);
-	if (captureName) return `(?<${opts.registerCapture(captureName)}>${tokenPattern})`;
-	return tokenPattern;
-};
-/**
-* Expands template tokens with support for named captures.
-*
-* This is the primary token expansion function that handles all token syntax:
-* - `{{token}}` → Expands to the token's pattern (no capture group)
-* - `{{token:name}}` → Expands to `(?<name>pattern)` (named capture)
-* - `{{:name}}` → Expands to `(?<name>.+)` (capture anything)
-*
-* Unknown tokens are left as-is in the output, allowing for partial templates.
-*
-* @param query - The template string containing tokens
-* @param fuzzyTransform - Optional function to transform Arabic text for fuzzy matching.
-*                         Applied to both token patterns and plain Arabic text between tokens.
-*                         Typically `makeDiacriticInsensitive` from the fuzzy module.
-* @returns Object with expanded pattern, capture names, and capture flag
-*
-* @example
-* // Simple token expansion
-* expandTokensWithCaptures('{{raqms}} {{dash}}')
-* // → { pattern: '[\\u0660-\\u0669]+ [-–—ـ]', captureNames: [], hasCaptures: false }
-*
-* @example
-* // Named capture
-* expandTokensWithCaptures('{{raqms:num}} {{dash}}')
-* // → { pattern: '(?<num>[\\u0660-\\u0669]+) [-–—ـ]', captureNames: ['num'], hasCaptures: true }
-*
-* @example
-* // Capture-only token
-* expandTokensWithCaptures('{{raqms:num}} {{dash}} {{:content}}')
-* // → { pattern: '(?<num>[٠-٩]+) [-–—ـ] (?<content>.+)', captureNames: ['num', 'content'], hasCaptures: true }
-*
-* @example
-* // With fuzzy transform
-* expandTokensWithCaptures('{{bab}}', makeDiacriticInsensitive)
-* // → { pattern: 'بَ?ا?بٌ?', captureNames: [], hasCaptures: false }
-*/
-const expandTokensWithCaptures = (query, fuzzyTransform, capturePrefix) => {
-	const segments = splitTemplateIntoSegments(query);
-	const registry = createCaptureRegistry(capturePrefix);
-	const pattern = segments.map((segment) => segment.type === "text" ? maybeApplyFuzzyToText(segment.value, fuzzyTransform) : expandTokenLiteral(segment.value, {
-		capturePrefix,
-		fuzzyTransform,
-		registerCapture: registry.register
-	})).join("");
-	return {
-		captureNames: registry.captureNames,
-		hasCaptures: registry.captureNames.length > 0,
-		pattern
-	};
-};
-/**
-* Expands template tokens in a query string to their regex equivalents.
-*
-* This is the simple version without capture support. It returns only the
-* expanded pattern string, not capture metadata.
-*
-* Unknown tokens are left as-is, allowing for partial templates.
-*
-* @param query - Template string containing `{{token}}` placeholders
-* @returns Expanded regex pattern string
-*
-* @example
-* expandTokens('، {{raqms}}')     // → '، [\\u0660-\\u0669]+'
-* expandTokens('{{raqm}}*')       // → '[\\u0660-\\u0669]*'
-* expandTokens('{{dash}}{{raqm}}') // → '[-–—ـ][\\u0660-\\u0669]'
-* expandTokens('{{unknown}}')     // → '{{unknown}}' (left as-is)
-*
-* @see expandTokensWithCaptures for full capture group support
-*/
-const expandTokens = (query) => expandTokensWithCaptures(query).pattern;
-/**
-* Converts a template string to a compiled RegExp.
-*
-* Expands all tokens and attempts to compile the result as a RegExp
-* with Unicode flag. Returns `null` if the resulting pattern is invalid.
-*
-* @remarks
-* This function dynamically compiles regular expressions from template strings.
-* If templates may come from untrusted sources, be aware of potential ReDoS
-* (Regular Expression Denial of Service) risks due to catastrophic backtracking.
-* Consider validating pattern complexity or applying execution timeouts when
-* running user-submitted patterns.
-*
-* @param template - Template string containing `{{token}}` placeholders
-* @returns Compiled RegExp with 'u' flag, or `null` if invalid
-*
-* @example
-* templateToRegex('، {{raqms}}')  // → /، [٠-٩]+/u
-* templateToRegex('{{raqms}}+')   // → /[٠-٩]++/u (might be invalid in some engines)
-* templateToRegex('(((')          // → null (invalid regex)
-*/
-const templateToRegex = (template) => {
-	const expanded = expandTokens(template);
-	try {
-		return new RegExp(expanded, "u");
-	} catch {
-		return null;
-	}
-};
-/**
-* Lists all available token names defined in `TOKEN_PATTERNS`.
-*
-* Useful for documentation, validation, or building user interfaces
-* that show available tokens.
-*
-* @returns Array of token names (e.g., `['bab', 'basmalah', 'bullet', ...]`)
-*
-* @example
-* getAvailableTokens()
-* // → ['bab', 'basmalah', 'bullet', 'dash', 'harf', 'kitab', 'naql', 'raqm', 'raqms']
-*/
-const getAvailableTokens = () => Object.keys(TOKEN_PATTERNS);
-/**
-* Gets the regex pattern for a specific token name.
-*
-* Returns the raw pattern string as defined in `TOKEN_PATTERNS`,
-* without any expansion or capture group wrapping.
-*
-* @param tokenName - The token name to look up (e.g., `'raqms'`, `'dash'`, `'harfs'`)
-* @returns The regex pattern string for that known token
-*
-* @example
-* getTokenPattern('raqms')   // → '[\\u0660-\\u0669]+'
-* getTokenPattern('dash')    // → '[-–—ـ]'
-* getTokenPattern('harfs')     // → pattern for spaced isolated Arabic letter codes
-*/
-const getTokenPattern = (tokenName) => TOKEN_PATTERNS[tokenName];
-/**
-* Regex to detect fuzzy-default tokens in a pattern string.
-* Matches {{token}} or {{token:name}} syntax.
-*/
-const FUZZY_TOKEN_REGEX = new RegExp(`\\{\\{(?:${[
-	"bab",
-	"basmalah",
-	"fasl",
-	"kitab",
-	"naql"
-].join("|")})(?::\\w+)?\\}\\}`, "g");
-/**
-* Checks if a pattern (or array of patterns) contains tokens that should
-* default to fuzzy matching.
-*
-* Fuzzy-default tokens are: bab, basmalah, fasl, kitab, naql
-*
-* @param patterns - Single pattern string or array of pattern strings
-* @returns `true` if any pattern contains a fuzzy-default token
-*
-* @example
-* shouldDefaultToFuzzy('{{bab}} الإيمان')     // true
-* shouldDefaultToFuzzy('{{raqms}} {{dash}}')  // false
-* shouldDefaultToFuzzy(['{{kitab}}', '{{raqms}}']) // true
-*/
-const shouldDefaultToFuzzy = (patterns) => {
-	return (Array.isArray(patterns) ? patterns : [patterns]).some((p) => {
-		FUZZY_TOKEN_REGEX.lastIndex = 0;
-		return FUZZY_TOKEN_REGEX.test(p);
-	});
-};
-/**
-* Apply token mappings to a template string.
-*
-* Transforms `{{token}}` into `{{token:name}}` based on the provided mappings.
-* Useful for applying user-configured capture names to a raw template.
-*
-* - Only affects exact matches of `{{token}}`.
-* - Does NOT affect tokens that already have a capture name (e.g. `{{token:existing}}`).
-* - Does NOT affect capture-only tokens (e.g. `{{:name}}`).
-*
-* @param template - The template string to transform
-* @param mappings - Array of mappings from token name to capture name
-* @returns Transformed template string with captures applied
-*
-* @example
-* applyTokenMappings('{{raqms}} {{dash}}', [{ token: 'raqms', name: 'num' }])
-* // → '{{raqms:num}} {{dash}}'
-*/
-const applyTokenMappings = (template, mappings) => {
-	let result = template;
-	for (const { token, name } of mappings) {
-		if (!token || !name) continue;
-		const regex = new RegExp(`\\{\\{${token}\\}\\}`, "g");
-		result = result.replace(regex, `{{${token}:${name}}}`);
-	}
-	return result;
-};
-/**
-* Strip token mappings from a template string.
-*
-* Transforms `{{token:name}}` back into `{{token}}`.
-* Also transforms `{{:name}}` patterns (capture-only) into `{{}}` (which is invalid/empty).
-*
-* Useful for normalizing templates for storage or comparison.
-*
-* @param template - The template string to strip
-* @returns Template string with capture names removed
-*
-* @example
-* stripTokenMappings('{{raqms:num}} {{dash}}')
-* // → '{{raqms}} {{dash}}'
-*/
-const stripTokenMappings = (template) => {
-	return template.replace(/\{\{([^:}]+):[^}]+\}\}/g, "{{$1}}");
-};
-//#endregion
-//#region src/utils/textUtils.ts
-/**
-* Normalizes line endings to Unix-style (`\n`).
-*
-* Converts Windows (`\r\n`) and old Mac (`\r`) line endings to Unix style
-* for consistent pattern matching across platforms.
-*
-* @param content - Raw content with potentially mixed line endings
-* @returns Content with all line endings normalized to `\n`
-*/
-const normalizeLineEndings = (content) => {
-	return content.includes("\r") ? content.replace(/\r\n?/g, "\n") : content;
-};
-/**
-* Escapes regex metacharacters (parentheses and brackets) in template patterns,
-* but preserves content inside `{{...}}` token delimiters.
-*
-* This allows users to write intuitive patterns like `({{harf}}):` instead of
-* the verbose `\\({{harf}}\\):`. The escaping is applied BEFORE token expansion,
-* so tokens like `{{harf}}` which expand to `[أ-ي]` work correctly.
-*
-* @param pattern - Template pattern that may contain `()[]` and `{{tokens}}`
-* @returns Pattern with `()[]` escaped outside of `{{...}}` delimiters
-*
-* @example
-* escapeTemplateBrackets('({{harf}}): ')
-* // → '\\({{harf}}\\): '
-*
-* @example
-* escapeTemplateBrackets('[{{raqm}}] ')
-* // → '\\[{{raqm}}\\] '
-*
-* @example
-* escapeTemplateBrackets('{{harf}}')
-* // → '{{harf}}' (unchanged - no brackets outside tokens)
-*/
-const escapeTemplateBrackets = (pattern) => {
-	return pattern.replace(/(\{\{[^}]*\}\})|([()[\]])/g, (_match, token, bracket) => token || `\\${bracket}`);
-};
-/**
-* Character class matching all Arabic diacritics (Tashkeel/Harakat).
-*
-* Includes the following diacritical marks:
-* - U+0640: ـ (tatweel / kashida)
-* - U+064B: ً (fathatan - double fatha)
-* - U+064C: ٌ (dammatan - double damma)
-* - U+064D: ٍ (kasratan - double kasra)
-* - U+064E: َ (fatha - short a)
-* - U+064F: ُ (damma - short u)
-* - U+0650: ِ (kasra - short i)
-* - U+0651: ّ (shadda - gemination)
-* - U+0652: ْ (sukun - no vowel)
-*
-* @internal
-*/
-const DIACRITICS_CLASS = "[ـًٌٍَُِّْ]";
-/**
-* Groups of equivalent Arabic characters.
-*
-* Characters within the same group are considered equivalent for matching purposes.
-* This handles common variations in Arabic text where different characters are
-* used interchangeably or have the same underlying meaning.
-*
-* Equivalence groups:
-* - Alef variants: ا (bare), آ (with madda), أ (with hamza above), إ (with hamza below)
-* - Ta marbuta and Ha: ة ↔ ه (often interchangeable at word endings)
-* - Alef maqsura and Ya: ى ↔ ي (often interchangeable at word endings)
-*
-* @internal
-*/
-const EQUIV_GROUPS = [
-	[
-		"ا",
-		"آ",
-		"أ",
-		"إ"
-	],
-	["ة", "ه"],
-	["ى", "ي"]
-];
-const DIACRITICS_AND_MARKS_REGEX = new RegExp(ARABIC_MARKS_CLASS, "g");
-/**
-* Escapes a string for safe inclusion in a regular expression.
-*
-* Escapes all regex metacharacters: `.*+?^${}()|[\]\\`
-*
-* @param s - Any string to escape
-* @returns String with regex metacharacters escaped
-*
-* @example
-* escapeRegex('hello.world')   // → 'hello\\.world'
-* escapeRegex('[test]')        // → '\\[test\\]'
-* escapeRegex('a+b*c?')        // → 'a\\+b\\*c\\?'
-*/
-const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const getEquivClass = (ch) => {
-	const group = EQUIV_GROUPS.find((g) => g.includes(ch));
-	return group ? `[${group.map(escapeRegex).join("")}]` : escapeRegex(ch);
-};
-const normalizeArabicLight = (str) => {
-	return str.normalize("NFC").replace(/[\u200C\u200D]/g, "").replace(/\s+/g, " ").trim();
-};
-/**
-* Normalizes Arabic text for exact comparisons while tolerating common variants.
-*
-* This removes Arabic diacritics, collapses whitespace, removes joiners, and
-* maps common equivalent letters to a shared canonical form:
-* - ا/آ/أ/إ -> ا
-* - ة/ه -> ه
-* - ى/ي -> ي
-*/
-const normalizeArabicForComparison = (text) => {
-	return Array.from(normalizeArabicLight(text).replace(DIACRITICS_AND_MARKS_REGEX, "")).map((ch) => {
-		if (ch === "آ" || ch === "أ" || ch === "إ") return "ا";
-		if (ch === "ة") return "ه";
-		if (ch === "ى") return "ي";
-		return ch;
-	}).join("");
-};
-const makeDiacriticInsensitive = (text) => {
-	const diacriticsMatcher = `${DIACRITICS_CLASS}*`;
-	return Array.from(normalizeArabicLight(text)).map((ch) => getEquivClass(ch) + diacriticsMatcher).join("");
-};
-const isCombiningMarkOrSelector = (char) => {
-	if (!char) return false;
-	return /\p{M}/u.test(char) || char === "︎" || char === "️";
-};
-const isJoiner = (char) => char === "‌" || char === "‍";
-/**
-* Ensures the position does not split a grapheme cluster (surrogate pairs,
-* combining marks, or zero-width joiners / variation selectors).
-*
-* This is only used as a last-resort fallback when we are forced to split
-* near a hard limit (e.g. maxContentLength with no safe whitespace/punctuation).
-*/
-const adjustForUnicodeBoundary = (content, position) => {
-	let adjusted = position;
-	while (adjusted > 0) {
-		const high = content.charCodeAt(adjusted - 1);
-		const low = content.charCodeAt(adjusted);
-		if (high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343) {
-			adjusted -= 1;
-			continue;
-		}
-		const nextChar = content[adjusted];
-		const prevChar = content[adjusted - 1];
-		if (isCombiningMarkOrSelector(nextChar) || isJoiner(nextChar) || isJoiner(prevChar)) {
-			adjusted -= 1;
-			continue;
-		}
-		break;
-	}
-	return adjusted;
-};
-//#endregion
-//#region src/analysis/shared.ts
-const escapeSignatureLiteral = (s) => s.replace(/[.*+?^${}|\\{}]/g, "\\$&");
-const TOKEN_PRIORITY_ORDER$1 = [
-	"basmalah",
-	"kitab",
-	"bab",
-	"fasl",
-	"naql",
-	"rumuz",
-	"numbered",
-	"raqms",
-	"raqm",
-	"dash",
-	"bullet",
-	"tarqim"
-];
-const buildTokenPriority = () => {
-	const allTokens = new Set(getAvailableTokens());
-	return TOKEN_PRIORITY_ORDER$1.filter((t) => allTokens.has(t));
-};
-const collapseWhitespace = (s) => s.replace(/\s+/g, " ").trim();
-const stripArabicDiacritics = (s) => s.replace(/[\u064B-\u065F\u0670\u06D6-\u06ED]/gu, "");
-const compileTokenRegexes = (tokenNames) => tokenNames.map((token) => {
-	const pat = TOKEN_PATTERNS[token];
-	if (!pat) return null;
-	try {
-		return {
-			re: new RegExp(pat, "uy"),
-			token
-		};
-	} catch {
-		return null;
-	}
-}).filter((x) => x !== null);
-const appendWs = (out, mode) => {
-	if (!out) return out;
-	const suffix = mode === "space" ? " " : "\\s*";
-	return out.endsWith(suffix) ? out : `${out}${suffix}`;
-};
-const findBestTokenMatchAt = (s, pos, compiled, isArabicLetter) => {
-	let best = null;
-	for (const { token, re } of compiled) {
-		re.lastIndex = pos;
-		const m = re.exec(s);
-		if (!m || m.index !== pos) continue;
-		if (!best || m[0].length > best.text.length) best = {
-			text: m[0],
-			token
-		};
-	}
-	if (best?.token === "rumuz") {
-		const end = pos + best.text.length;
-		const next = end < s.length ? s[end] : "";
-		if (next && isArabicLetter(next) && !/\s/u.test(next)) return null;
-	}
-	return best;
-};
-const isArabicLetter = (ch) => /\p{Script=Arabic}/u.test(ch) && /\p{L}/u.test(ch);
-const isCommonDelimiter = (ch) => /[:：\-–—ـ،؛.?!؟()[\]{}]/u.test(ch);
-//#endregion
-//#region src/analysis/line-starts.ts
-const resolveOptions$1 = (options = {}) => ({
-	includeFirstWordFallback: options.includeFirstWordFallback ?? true,
-	lineFilter: options.lineFilter,
-	maxExamples: options.maxExamples ?? 1,
-	minCount: options.minCount ?? 3,
-	minLineLength: options.minLineLength ?? 6,
-	normalizeArabicDiacritics: options.normalizeArabicDiacritics ?? true,
-	prefixChars: options.prefixChars ?? 60,
-	prefixMatchers: options.prefixMatchers ?? [/^#+/u],
-	sortBy: options.sortBy ?? "specificity",
-	topK: options.topK ?? 40,
-	whitespace: options.whitespace ?? "regex"
-});
-const countTokenMarkers = (pattern) => (pattern.match(/\{\{/g) ?? []).length;
-const computeSpecificity = (pattern) => ({
-	literalLen: pattern.replace(/\\s\*/g, "").replace(/[ \t]+/g, "").length,
-	tokenCount: countTokenMarkers(pattern)
-});
-const compareBySpecificity = (a, b) => {
-	const sa = computeSpecificity(a.pattern), sb = computeSpecificity(b.pattern);
-	return sb.tokenCount - sa.tokenCount || sb.literalLen - sa.literalLen || b.count - a.count || a.pattern.localeCompare(b.pattern);
-};
-const compareByCount = (a, b) => b.count !== a.count ? b.count - a.count : compareBySpecificity(a, b);
-const appendPrefix = (s, pos, out, matchers, ws) => {
-	for (const re of matchers) {
-		if (pos >= s.length) break;
-		const m = re.exec(s.slice(pos));
-		if (!m?.index && m?.[0]) {
-			out += escapeSignatureLiteral(m[0]);
-			pos += m[0].length;
-			const wsm = /^[ \t]+/u.exec(s.slice(pos));
-			if (wsm) {
-				pos += wsm[0].length;
-				out = appendWs(out, ws);
-			}
-			return {
-				matched: true,
-				out,
-				pos
-			};
-		}
-	}
-	return {
-		matched: false,
-		out,
-		pos
-	};
-};
-const appendToken = (s, pos, out, compiled) => {
-	const best = findBestTokenMatchAt(s, pos, compiled, isArabicLetter);
-	return best ? {
-		matched: true,
-		out: `${out}{{${best.token}}}`,
-		pos: pos + best.text.length
-	} : {
-		matched: false,
-		out,
-		pos
-	};
-};
-const appendDelimiter = (s, pos, out) => {
-	const ch = s[pos];
-	return ch && isCommonDelimiter(ch) ? {
-		matched: true,
-		out: `${out}${escapeSignatureLiteral(ch)}`,
-		pos: pos + 1
-	} : {
-		matched: false,
-		out,
-		pos
-	};
-};
-const appendFallbackWord = (s, pos, out) => {
-	const word = extractFirstWord(s.slice(pos));
-	return word ? `${out}${escapeSignatureLiteral(word)}` : null;
-};
-const consumeLineStartStep = (s, pos, out, compiled, opts, matchedAny, matchedToken) => {
-	const ws = skipWhitespace$1(s, pos, out, opts.whitespace);
-	if (ws.skipped) return {
-		done: false,
-		matchedAny,
-		matchedToken,
-		out: ws.out,
-		pos: ws.pos,
-		steps: 0
-	};
-	const tok = appendToken(s, pos, out, compiled);
-	if (tok.matched) return {
-		done: false,
-		matchedAny: true,
-		matchedToken: true,
-		out: tok.out,
-		pos: tok.pos,
-		steps: 1
-	};
-	if (matchedAny) {
-		const delim = appendDelimiter(s, pos, out);
-		if (delim.matched) return {
-			done: false,
-			matchedAny,
-			matchedToken,
-			out: delim.out,
-			pos: delim.pos,
-			steps: 0
-		};
-		if (opts.includeFirstWordFallback && !matchedToken) {
-			const fallback = appendFallbackWord(s, pos, out);
-			if (fallback) return {
-				done: true,
-				matchedAny,
-				matchedToken,
-				out: fallback,
-				pos,
-				steps: 1
-			};
-		}
-		return {
-			done: true,
-			matchedAny,
-			matchedToken,
-			out,
-			pos,
-			steps: 0
-		};
-	}
-	if (!opts.includeFirstWordFallback) return {
-		done: true,
-		matchedAny,
-		matchedToken,
-		out,
-		pos,
-		steps: 0
-	};
-	const fallback = appendFallbackWord(s, pos, out);
-	return fallback ? {
-		done: true,
-		matchedAny: true,
-		matchedToken,
-		out: fallback,
-		pos,
-		steps: 0
-	} : {
-		done: true,
-		matchedAny,
-		matchedToken,
-		out,
-		pos,
-		steps: 0
-	};
-};
-/** Remove trailing whitespace placeholders */
-const trimTrailingWs = (out, mode) => {
-	const suffix = mode === "regex" ? "\\s*" : " ";
-	while (out.endsWith(suffix)) out = out.slice(0, -suffix.length);
-	return out;
-};
-/** Try to extract first word for fallback */
-const extractFirstWord = (s) => (s.match(/^[^\s:،؛.?!؟]+/u) ?? [])[0] ?? null;
-/** Skip whitespace at position */
-const skipWhitespace$1 = (s, pos, out, ws) => {
-	const m = /^[ \t]+/u.exec(s.slice(pos));
-	if (!m) return {
-		out,
-		pos,
-		skipped: false
-	};
-	return {
-		out: appendWs(out, ws),
-		pos: pos + m[0].length,
-		skipped: true
-	};
-};
-const tokenizeLineStart = (line, tokenNames, opts) => {
-	const trimmed = collapseWhitespace(line);
-	if (!trimmed) return null;
-	const s = (opts.normalizeArabicDiacritics ? stripArabicDiacritics(trimmed) : trimmed).slice(0, opts.prefixChars);
-	const compiled = compileTokenRegexes(tokenNames);
-	let pos = 0, out = "", matchedAny = false, matchedToken = false, steps = 0;
-	const prefix = appendPrefix(s, pos, out, opts.prefixMatchers, opts.whitespace);
-	pos = prefix.pos;
-	out = prefix.out;
-	matchedAny = prefix.matched;
-	while (steps < 6 && pos < s.length) {
-		const next = consumeLineStartStep(s, pos, out, compiled, opts, matchedAny, matchedToken);
-		if (next.done) {
-			if (!next.matchedAny && !next.matchedToken && next.out === out && next.pos === pos) return null;
-			if (next.steps > 0) steps += next.steps;
-			matchedAny = next.matchedAny;
-			matchedToken = next.matchedToken;
-			out = next.out;
-			break;
-		}
-		pos = next.pos;
-		out = next.out;
-		matchedAny = next.matchedAny;
-		matchedToken = next.matchedToken;
-		steps += next.steps;
-	}
-	return matchedAny ? trimTrailingWs(out, opts.whitespace) : null;
-};
-const processLine = (line, pageId, tokenPriority, opts, acc) => {
-	const trimmed = collapseWhitespace(line);
-	if (trimmed.length < opts.minLineLength) return;
-	if (opts.lineFilter && !opts.lineFilter(trimmed, pageId)) return;
-	const sig = tokenizeLineStart(trimmed, tokenPriority, opts);
-	if (!sig) return;
-	const entry = acc.get(sig);
-	if (!entry) acc.set(sig, {
-		count: 1,
-		examples: [{
-			line: trimmed,
-			pageId
-		}]
-	});
-	else {
-		entry.count++;
-		if (entry.examples.length < opts.maxExamples) entry.examples.push({
-			line: trimmed,
-			pageId
-		});
-	}
-};
-const processPage = (page, tokenPriority, opts, acc) => {
-	for (const line of normalizeLineEndings(page.content ?? "").split("\n")) processLine(line, page.id, tokenPriority, opts, acc);
-};
-/**
-* Analyze pages and return the most common line-start patterns (top K).
-*/
-const analyzeCommonLineStarts = (pages, options = {}) => {
-	const opts = resolveOptions$1(options);
-	const tokenPriority = buildTokenPriority();
-	const acc = /* @__PURE__ */ new Map();
-	for (const page of pages) processPage(page, tokenPriority, opts, acc);
-	const comparator = opts.sortBy === "count" ? compareByCount : compareBySpecificity;
-	return [...acc.entries()].map(([pattern, v]) => ({
-		count: v.count,
-		examples: v.examples,
-		pattern
-	})).filter((p) => p.count >= opts.minCount).sort(comparator).slice(0, opts.topK);
-};
-//#endregion
-//#region src/analysis/repeating-sequences.ts
-const resolveOptions = (options) => {
-	const minElements = Math.max(1, options?.minElements ?? 1);
-	return {
-		contextChars: options?.contextChars ?? 50,
-		maxElements: Math.max(minElements, options?.maxElements ?? 3),
-		maxExamples: options?.maxExamples ?? 3,
-		maxUniquePatterns: options?.maxUniquePatterns ?? 1e3,
-		minCount: Math.max(1, options?.minCount ?? 3),
-		minElements,
-		normalizeArabicDiacritics: options?.normalizeArabicDiacritics ?? true,
-		requireToken: options?.requireToken ?? true,
-		topK: Math.max(1, options?.topK ?? 20),
-		whitespace: options?.whitespace ?? "regex"
-	};
-};
-/** Creates a cursor that tracks position in both normalized and raw text */
-const createRawCursor = (text, normalize) => {
-	let rawPos = 0;
-	return {
-		/** Advance cursor, returning the raw text chunk consumed */
-		advance(normalizedLen) {
-			if (!normalize) {
-				const chunk = text.slice(rawPos, rawPos + normalizedLen);
-				rawPos += normalizedLen;
-				return chunk;
-			}
-			const start = rawPos;
-			let matchedLen = 0;
-			while (matchedLen < normalizedLen && rawPos < text.length) {
-				if (stripArabicDiacritics(text[rawPos]).length > 0) matchedLen++;
-				rawPos++;
-			}
-			while (rawPos < text.length && stripArabicDiacritics(text[rawPos]).length === 0) rawPos++;
-			return text.slice(start, rawPos);
-		},
-		get pos() {
-			return rawPos;
-		}
-	};
-};
-/** Scans text and produces a stream of tokens and literals. */
-const tokenizeContent = (text, normalize) => {
-	const normalized = normalize ? stripArabicDiacritics(text) : text;
-	const compiled = compileTokenRegexes(buildTokenPriority());
-	const cursor = createRawCursor(text, normalize);
-	const items = [];
-	let pos = 0;
-	while (pos < normalized.length) {
-		const ws = /^\s+/u.exec(normalized.slice(pos));
-		if (ws) {
-			pos += ws[0].length;
-			cursor.advance(ws[0].length);
-			continue;
-		}
-		const token = findBestTokenMatchAt(normalized, pos, compiled, isArabicLetter);
-		if (token) {
-			const raw = cursor.advance(token.text.length);
-			items.push({
-				end: cursor.pos,
-				raw,
-				start: cursor.pos - raw.length,
-				text: `{{${token.token}}}`,
-				type: "token"
-			});
-			pos += token.text.length;
-			continue;
-		}
-		if (isCommonDelimiter(normalized[pos])) {
-			const raw = cursor.advance(1);
-			items.push({
-				end: cursor.pos,
-				raw,
-				start: cursor.pos - 1,
-				text: escapeSignatureLiteral(normalized[pos]),
-				type: "literal"
-			});
-			pos++;
-			continue;
-		}
-		const word = /^[^\s:：\-–—ـ،؛.?!؟()[\]{}]+/u.exec(normalized.slice(pos));
-		if (word) {
-			const raw = cursor.advance(word[0].length);
-			items.push({
-				end: cursor.pos,
-				raw,
-				start: cursor.pos - raw.length,
-				text: escapeSignatureLiteral(word[0]),
-				type: "literal"
-			});
-			pos += word[0].length;
-			continue;
-		}
-		cursor.advance(1);
-		pos++;
-	}
-	return items;
-};
-/** Build pattern string from window items */
-const buildPattern = (window, whitespace) => window.map((i) => i.text).join(whitespace === "space" ? " " : "\\s*");
-/** Check if window contains at least one token */
-const hasTokenInWindow = (window) => window.some((i) => i.type === "token");
-/** Compute token count and literal length for a window */
-const computeWindowStats = (window) => {
-	let tokenCount = 0, literalLen = 0;
-	for (const item of window) if (item.type === "token") tokenCount++;
-	else literalLen += item.text.length;
-	return {
-		literalLen,
-		tokenCount
-	};
-};
-/** Build example from page content and window */
-const buildExample = (page, window, contextChars) => {
-	const start = window[0].start;
-	const end = window.at(-1).end;
-	const ctxStart = Math.max(0, start - contextChars);
-	const ctxEnd = Math.min(page.content.length, end + contextChars);
-	return {
-		context: (ctxStart > 0 ? "..." : "") + page.content.slice(ctxStart, ctxEnd) + (ctxEnd < page.content.length ? "..." : ""),
-		pageId: page.id,
-		startIndices: window.map((w) => w.start),
-		text: page.content.slice(start, end)
-	};
-};
-const recordPattern = (page, window, opts, stats) => {
-	if (opts.requireToken && !hasTokenInWindow(window)) return;
-	const pattern = buildPattern(window, opts.whitespace);
-	let entry = stats.get(pattern);
-	if (!entry) {
-		if (stats.size >= opts.maxUniquePatterns) return;
-		entry = {
-			count: 0,
-			examples: [],
-			...computeWindowStats(window)
-		};
-		stats.set(pattern, entry);
-	}
-	entry.count++;
-	if (entry.examples.length < opts.maxExamples) entry.examples.push(buildExample(page, window, opts.contextChars));
-};
-/** Extract N-grams from a single page */
-const extractPageNgrams = (page, items, opts, stats) => {
-	for (let i = 0; i <= items.length - opts.minElements; i++) {
-		const maxWindowSize = Math.min(opts.maxElements, items.length - i);
-		for (let n = opts.minElements; n <= maxWindowSize; n++) recordPattern(page, items.slice(i, i + n), opts, stats);
-	}
-};
-/**
-* Analyze pages for commonly repeating word sequences.
-*
-* Use for continuous text without line breaks. For line-based analysis,
-* use `analyzeCommonLineStarts()` instead.
-*/
-const analyzeRepeatingSequences = (pages, options) => {
-	const opts = resolveOptions(options);
-	const stats = /* @__PURE__ */ new Map();
-	for (const page of pages) {
-		if (!page.content) continue;
-		extractPageNgrams(page, tokenizeContent(page.content, opts.normalizeArabicDiacritics), opts, stats);
-	}
-	return [...stats.entries()].filter(([, s]) => s.count >= opts.minCount).sort((a, b) => b[1].count - a[1].count || b[1].tokenCount - a[1].tokenCount || b[1].literalLen - a[1].literalLen).slice(0, opts.topK).map(([pattern, s]) => ({
-		count: s.count,
-		examples: s.examples,
-		pattern
-	}));
-};
-//#endregion
+import { A as ARABIC_MARKS_CLASS, B as getTokenPattern, C as analyzeCommonLineStarts, D as normalizeArabicForComparison, E as makeDiacriticInsensitive, F as containsTokens, H as stripTokenMappings, I as expandCompositeTokensInTemplate, L as expandTokens, M as TOKEN_PATTERNS, N as Token, O as ARABIC_BASE_LETTER_CLASS, P as applyTokenMappings, R as expandTokensWithCaptures, S as analyzeRepeatingSequences, T as escapeTemplateBrackets, U as templateToRegex, V as shouldDefaultToFuzzy, W as withCapture, _ as removeZeroWidth, a as diagnoseDictionaryProfile, b as optimizeRules, c as analyzeDictionaryMarkdownPages, d as getDebugReason, f as getSegmentDebugReason, g as fixTrailingWaw, h as condenseEllipsis, i as escapeWordsOutsideTokens, j as ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN, k as ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN, l as classifyDictionaryHeading, m as applyPreprocessToPage, n as segmentPages, o as DictionaryProfileValidationError, p as validateSegments, r as createArabicDictionaryEntryRule, s as validateDictionaryProfile, t as suggestSegmentationOptions, u as scanDictionaryMarkdownPage, v as formatValidationReport, w as escapeRegex, x as PATTERN_TYPE_KEYS, y as validateRules, z as getAvailableTokens } from "./segmentation-advisor-D375TL8-.mjs";
 //#region src/detection.ts
 /**
 * Token detection order - more specific patterns first to avoid partial matches.
@@ -1279,3330 +160,6 @@ const analyzeTextForRule = (text) => {
 	};
 };
 //#endregion
-//#region src/types/rules.ts
-/**
-* Pattern type key names for split rules.
-*
-* Use this array to dynamically iterate over pattern types in UIs,
-* or use the `PatternTypeKey` type for type-safe string unions.
-*
-* @example
-* // Build a dropdown/select in UI
-* PATTERN_TYPE_KEYS.map(key => <option value={key}>{key}</option>)
-*
-* @example
-* // Type-safe pattern key validation
-* const validateKey = (k: string): k is PatternTypeKey =>
-*   (PATTERN_TYPE_KEYS as readonly string[]).includes(k);
-*/
-const PATTERN_TYPE_KEYS = [
-	"lineStartsWith",
-	"lineStartsAfter",
-	"lineEndsWith",
-	"template",
-	"regex",
-	"dictionaryEntry"
-];
-//#endregion
-//#region src/optimization/optimize-rules.ts
-const MERGEABLE_KEYS = new Set([
-	"lineStartsWith",
-	"lineStartsAfter",
-	"lineEndsWith"
-]);
-/**
-* Get the pattern type key for a rule.
-*/
-const getPatternKey = (rule) => PATTERN_TYPE_KEYS.find((key) => key in rule) ?? "regex";
-const getPatternArray = (rule, key) => {
-	const value = rule[key];
-	return Array.isArray(value) ? value : [];
-};
-const getPatternString = (rule, key) => {
-	const value = rule[key];
-	return typeof value === "string" ? value : Array.isArray(value) ? value.join("\n") : value ? JSON.stringify(value) : "";
-};
-const normalizePatterns = (patterns) => [...new Set(patterns)].sort((a, b) => b.length - a.length || a.localeCompare(b));
-const getDictionaryEntrySpecificityScore = (rule) => {
-	if (!("dictionaryEntry" in rule)) return 0;
-	const { allowCommaSeparated = false, allowParenthesized = false, allowWhitespaceBeforeColon = false, maxLetters = 10, midLineSubentries = true, minLetters = 2, stopWords } = rule.dictionaryEntry;
-	return minLetters * 20 + maxLetters + (allowCommaSeparated ? 0 : 120) + (allowParenthesized ? 0 : 60) + (allowWhitespaceBeforeColon ? 0 : 20) + (midLineSubentries ? 0 : 160) + Math.min(stopWords.length, 25);
-};
-const getSpecificityScore = (rule) => {
-	const key = getPatternKey(rule);
-	if (key === "dictionaryEntry") return getDictionaryEntrySpecificityScore(rule);
-	return MERGEABLE_KEYS.has(key) ? getPatternArray(rule, key).reduce((max, p) => Math.max(max, p.length), 0) : getPatternString(rule, key).length;
-};
-const createMergeKey = (rule) => {
-	const key = getPatternKey(rule);
-	const { [key]: _, ...rest } = rule;
-	return `${key}|${JSON.stringify(rest)}`;
-};
-const optimizeRules = (rules) => {
-	const output = [];
-	const indexByMergeKey = /* @__PURE__ */ new Map();
-	let mergedCount = 0;
-	for (const rule of rules) {
-		const key = getPatternKey(rule);
-		if (!MERGEABLE_KEYS.has(key)) {
-			output.push(rule);
-			continue;
-		}
-		const mergeKey = createMergeKey(rule);
-		const existingIndex = indexByMergeKey.get(mergeKey);
-		if (existingIndex === void 0) {
-			indexByMergeKey.set(mergeKey, output.length);
-			output.push({
-				...rule,
-				[key]: normalizePatterns(getPatternArray(rule, key))
-			});
-		} else {
-			const existing = output[existingIndex];
-			existing[key] = normalizePatterns([...getPatternArray(existing, key), ...getPatternArray(rule, key)]);
-			mergedCount++;
-		}
-	}
-	return {
-		mergedCount,
-		rules: output.sort((a, b) => getSpecificityScore(b) - getSpecificityScore(a))
-	};
-};
-//#endregion
-//#region src/preprocessing/transforms.ts
-/** Helper for exhaustive switch checking - TypeScript will error if a case is missed */
-const assertNever = (x) => {
-	throw new Error(`Unknown preprocess transform type: ${JSON.stringify(x)}`);
-};
-/** Check if a character is whitespace (space, newline, tab, etc.) */
-const isWhitespace = (char) => /\s/.test(char);
-/**
-* Check if a character code is a zero-width control character.
-*
-* Covers:
-* - U+200B–U+200F (Zero Width Space, Joiners, Direction Marks)
-* - U+202A–U+202E (Bidirectional Formatting)
-* - U+2060–U+2064 (Word Joiner, Invisible Operators)
-* - U+FEFF (Byte Order Mark / Zero Width No-Break Space)
-*/
-const isZeroWidth = (code) => code >= 8203 && code <= 8207 || code >= 8234 && code <= 8238 || code >= 8288 && code <= 8292 || code === 65279;
-/**
-* Remove zero-width control characters from text.
-*
-* @param text - Input text
-* @param mode - 'strip' (default) removes entirely, 'space' replaces with space
-* @returns Text with zero-width characters removed or replaced
-*/
-const removeZeroWidth = (text, mode = "strip") => {
-	if (mode === "space") {
-		const parts = [];
-		let lastWasWhitespace = true;
-		for (let i = 0; i < text.length; i++) if (isZeroWidth(text.charCodeAt(i))) {
-			if (!lastWasWhitespace && parts.length > 0) {
-				parts.push(" ");
-				lastWasWhitespace = true;
-			}
-		} else {
-			const char = text[i];
-			parts.push(char);
-			lastWasWhitespace = isWhitespace(char);
-		}
-		return parts.join("");
-	}
-	return text.replace(/[\u200B-\u200F\u202A-\u202E\u2060-\u2064\uFEFF]/g, "");
-};
-/**
-* Condense multiple periods (...) into ellipsis character (…).
-*
-* Prevents `{{tarqim}}` from false-matching inside ellipsis since
-* the `.` in tarqim matches individual periods.
-*
-* @param text - Input text
-* @returns Text with period sequences replaced by ellipsis
-*/
-const condenseEllipsis = (text) => text.replace(/\.{2,}/g, "…");
-/**
-* Join trailing و (waw) to the next word.
-*
-* Fixes OCR/digitization artifacts: ' و ' → ' و' (waw joined to next word)
-*
-* @param text - Input text
-* @returns Text with trailing waw joined to following word
-*/
-const fixTrailingWaw = (text) => text.replace(/ و /g, " و");
-/**
-* Check if a page ID is within a constraint range.
-*/
-const isInRange = (pageId, constraint) => {
-	if (constraint.min !== void 0 && pageId < constraint.min) return false;
-	if (constraint.max !== void 0 && pageId > constraint.max) return false;
-	return true;
-};
-/**
-* Normalize a transform to its object form.
-*/
-const normalizeTransform = (transform) => {
-	if (typeof transform === "string") return { type: transform };
-	return transform;
-};
-/**
-* Apply preprocessing transforms to a page's content.
-*
-* Transforms run in array order. Each can be limited to specific pages
-* via `min`/`max` constraints.
-*
-* @param content - Page content to transform
-* @param pageId - Page ID for constraint checking
-* @param transforms - Array of transforms to apply
-* @returns Transformed content
-*/
-const applyPreprocessToPage = (content, pageId, transforms) => {
-	let result = content;
-	for (const transform of transforms) {
-		const rule = normalizeTransform(transform);
-		if (!isInRange(pageId, rule)) continue;
-		switch (rule.type) {
-			case "removeZeroWidth":
-				result = removeZeroWidth(result, rule.mode ?? "strip");
-				break;
-			case "condenseEllipsis":
-				result = condenseEllipsis(result);
-				break;
-			case "fixTrailingWaw":
-				result = fixTrailingWaw(result);
-				break;
-			default: assertNever(rule.type);
-		}
-	}
-	return result;
-};
-//#endregion
-//#region src/segmentation/arabic-dictionary-rule.ts
-const uniqueCanonicalWords = (words) => {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const word of words) {
-		const normalized = normalizeArabicForComparison(word);
-		if (!normalized || seen.has(normalized)) continue;
-		seen.add(normalized);
-		result.push(word);
-	}
-	return result;
-};
-const buildStopAlternation = (stopWords) => {
-	const unique = uniqueCanonicalWords(stopWords);
-	if (unique.length === 0) return "";
-	return unique.map((word) => makeDiacriticInsensitive(normalizeArabicForComparison(word))).join("|");
-};
-const buildHeadwordBody = ({ allowCommaSeparated, colonPattern, stopAlternation, stopwordBody, unit }) => {
-	if (!stopAlternation) return allowCommaSeparated ? `${unit}(?:\\s*[،,]\\s*${unit})*` : unit;
-	const guardedUnit = `(?!(?:${stopwordBody})${allowCommaSeparated ? `(?:\\s*[،,]\\s*|${colonPattern})` : colonPattern})${unit}`;
-	return allowCommaSeparated ? `${guardedUnit}(?:\\s*[،,]\\s*${guardedUnit})*` : guardedUnit;
-};
-const buildBalancedMarker = ({ allowParenthesized, allowWhitespaceBeforeColon, captureName, headwordBody }) => {
-	const colon = allowWhitespaceBeforeColon ? "\\s*:" : ":";
-	const withCapture = `(?<${captureName}>${headwordBody})`;
-	if (!allowParenthesized) return `${withCapture}${colon}`;
-	return `(?:\\(\\s*${withCapture}\\s*\\)|${withCapture})${colon}`;
-};
-const validateDictionaryEntryOptions = ({ captureName = "lemma", maxLetters = 10, minLetters = 2 }) => {
-	if (!Number.isInteger(minLetters) || minLetters < 1) throw new Error(`createArabicDictionaryEntryRule: minLetters must be an integer >= 1, got ${minLetters}`);
-	if (!Number.isInteger(maxLetters) || maxLetters < minLetters) throw new Error(`createArabicDictionaryEntryRule: maxLetters must be an integer >= minLetters, got ${maxLetters}`);
-	if (!captureName.match(/^[A-Za-z_]\w*$/)) throw new Error(`createArabicDictionaryEntryRule: invalid captureName "${captureName}"`);
-};
-const buildArabicDictionaryEntryRegexSource = ({ allowCommaSeparated = false, allowParenthesized = false, allowWhitespaceBeforeColon = false, captureName = "lemma", maxLetters = 10, midLineSubentries = true, minLetters = 2, stopWords }, capturePrefix) => {
-	validateDictionaryEntryOptions({
-		captureName,
-		maxLetters,
-		minLetters
-	});
-	const zeroWidthPrefix = "[\\u200E\\u200F\\u061C\\u200B\\u200C\\u200D\\uFEFF]*";
-	const wawWithMarks = `و${ARABIC_MARKS_CLASS}*`;
-	const alWithMarks = `ا${ARABIC_MARKS_CLASS}*ل${ARABIC_MARKS_CLASS}*`;
-	const lemmaUnit = `(?:${wawWithMarks})?(?:${alWithMarks})?${`${ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN}(?:${ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN}){${minLetters - 1},${maxLetters - 1}}`}`;
-	const stopAlternation = buildStopAlternation(stopWords);
-	const lemmaBody = buildHeadwordBody({
-		allowCommaSeparated,
-		colonPattern: allowWhitespaceBeforeColon ? "\\s*:" : ":",
-		stopAlternation,
-		stopwordBody: stopAlternation ? `(?:${wawWithMarks})?(?:${stopAlternation})` : "",
-		unit: lemmaUnit
-	});
-	const lineStartBoundary = `(?:(?<=^)|(?<=\\n))${zeroWidthPrefix}`;
-	const midLineTrigger = allowParenthesized ? `(?<=\\s)(?=(?:\\(\\s*)?${wawWithMarks}(?:${alWithMarks})?)` : `(?<=\\s)(?=${wawWithMarks}(?:${alWithMarks})?)`;
-	const prefixedCaptureName = capturePrefix ? `${capturePrefix}${captureName}` : captureName;
-	const regex = `(?:${lineStartBoundary}${midLineSubentries ? `|${midLineTrigger}` : ""})` + buildBalancedMarker({
-		allowParenthesized,
-		allowWhitespaceBeforeColon,
-		captureName: prefixedCaptureName,
-		headwordBody: lemmaBody
-	});
-	return {
-		captureNames: [prefixedCaptureName],
-		regex
-	};
-};
-/**
-* Creates a reusable split rule for Arabic dictionary entries.
-*
-* The returned rule preserves authoring intent as a serializable
-* `{ dictionaryEntry: ... }` pattern rather than eagerly compiling to a raw
-* regex string.
-*
-* @example
-* createArabicDictionaryEntryRule({
-*   stopWords: ['وقيل', 'ويقال', 'قال'],
-*   pageStartPrevWordStoplist: ['قال', 'وقيل', 'ويقال'],
-* })
-*
-* @example
-* createArabicDictionaryEntryRule({
-*   allowParenthesized: true,
-*   allowWhitespaceBeforeColon: true,
-*   allowCommaSeparated: true,
-*   stopWords: ['الليث', 'العجاج'],
-* })
-*/
-const createArabicDictionaryEntryRule = ({ allowCommaSeparated = false, allowParenthesized = false, allowWhitespaceBeforeColon = false, captureName = "lemma", maxLetters = 10, meta, midLineSubentries = true, minLetters = 2, pageStartPrevWordStoplist, samePagePrevWordStoplist, stopWords }) => {
-	validateDictionaryEntryOptions({
-		captureName,
-		maxLetters,
-		minLetters
-	});
-	return {
-		dictionaryEntry: {
-			allowCommaSeparated,
-			allowParenthesized,
-			allowWhitespaceBeforeColon,
-			captureName,
-			maxLetters,
-			midLineSubentries,
-			minLetters,
-			stopWords: uniqueCanonicalWords(stopWords)
-		},
-		meta,
-		pageStartPrevWordStoplist,
-		samePagePrevWordStoplist
-	};
-};
-const WINDOW_PREFIX_LENGTHS = [
-	80,
-	60,
-	40,
-	30,
-	20,
-	15
-];
-const JOINER_PREFIX_LENGTHS = [
-	80,
-	60,
-	40,
-	30,
-	20,
-	15,
-	12,
-	10,
-	8,
-	6
-];
-const STOP_CHARACTERS = /[\s\n.,;!?؛،۔۝۞]/;
-/**
-* Maximum allowed deviation between expected and actual boundary positions (characters).
-* Matches outside this range are rejected unless `ignoreDeviation` is active.
-*/
-const MAX_DEVIATION = 2e3;
-//#endregion
-//#region src/segmentation/match-utils.ts
-/**
-* Extracts named capture groups from a regex match.
-*
-* Only includes groups that are in the `captureNames` list and have
-* defined values. This filters out positional captures and ensures
-* only explicitly requested named captures are returned.
-*
-* @param groups - The `match.groups` object from `RegExp.exec()`
-* @param captureNames - List of capture names to extract (from `{{token:name}}` syntax)
-* @returns Object with capture name → value pairs, or `undefined` if none found
-*
-* @example
-* const match = /(?<num>[٠-٩]+) -/.exec('٦٦٩٦ - text');
-* extractNamedCaptures(match.groups, ['num'])
-* // → { num: '٦٦٩٦' }
-*
-* @example
-* // No matching captures
-* extractNamedCaptures({}, ['num'])
-* // → undefined
-*
-* @example
-* // Undefined groups
-* extractNamedCaptures(undefined, ['num'])
-* // → undefined
-*/
-const extractNamedCaptures = (groups, captureNames) => {
-	if (!groups || captureNames.length === 0) return;
-	const namedCaptures = {};
-	for (const name of captureNames) if (groups[name] !== void 0) namedCaptures[name] = groups[name];
-	return Object.keys(namedCaptures).length > 0 ? namedCaptures : void 0;
-};
-/**
-* Gets the last defined positional capture group from a match array.
-*
-* Used for `lineStartsAfter` patterns where the content capture (`.*`)
-* is always at the end of the pattern. Named captures may shift the
-* positional indices, so we iterate backward to find the actual content.
-*
-* @param match - RegExp exec result array
-* @returns The last defined capture group value, or `undefined` if none
-*
-* @example
-* // Pattern: ^(?:(?<num>[٠-٩]+) - )(.*)
-* // Match array: ['٦٦٩٦ - content', '٦٦٩٦', 'content']
-* getLastPositionalCapture(match)
-* // → 'content'
-*
-* @example
-* // No captures
-* getLastPositionalCapture(['full match'])
-* // → undefined
-*/
-const getLastPositionalCapture = (match) => {
-	if (match.length <= 1) return;
-	for (let i = match.length - 1; i >= 1; i--) if (match[i] !== void 0) return match[i];
-};
-/**
-* Filters matches to only include those within page ID constraints.
-*
-* Applies the `min`, `max`, and `exclude` constraints from a rule to filter out
-* matches that occur on pages outside the allowed range or explicitly excluded.
-*
-* @param matches - Array of match results to filter
-* @param rule - Rule containing `min`, `max`, and/or `exclude` page constraints
-* @param getId - Function that returns the page ID for a given offset
-* @returns Filtered array containing only matches within constraints
-*
-* @example
-* const matches = [
-*   { start: 0, end: 10 },   // Page 1
-*   { start: 100, end: 110 }, // Page 5
-*   { start: 200, end: 210 }, // Page 10
-* ];
-* filterByConstraints(matches, { min: 3, max: 8 }, getId)
-* // → [{ start: 100, end: 110 }] (only page 5 match)
-*/
-const filterByConstraints = (matches, rule, getId) => matches.filter((m) => {
-	const id = getId(m.start);
-	return (rule.min === void 0 || id >= rule.min) && (rule.max === void 0 || id <= rule.max) && !isPageExcluded(id, rule.exclude);
-});
-/**
-* Checks if any rule in the list allows the given page ID.
-*
-* A rule allows an ID if it falls within the rule's `min`/`max` constraints.
-* Rules without constraints allow all page IDs.
-*
-* This is used to determine whether to create a segment for content
-* that appears before any split points (the "first segment").
-*
-* @param rules - Array of rules with optional `min` and `max` constraints
-* @param pageId - Page ID to check
-* @returns `true` if at least one rule allows the page ID
-*
-* @example
-* const rules = [
-*   { min: 5, max: 10 },  // Allows pages 5-10
-*   { min: 20 },          // Allows pages 20+
-* ];
-*
-* anyRuleAllowsId(rules, 7)   // → true (first rule allows)
-* anyRuleAllowsId(rules, 3)   // → false (no rule allows)
-* anyRuleAllowsId(rules, 25)  // → true (second rule allows)
-*
-* @example
-* // Rules without constraints allow everything
-* anyRuleAllowsId([{}], 999) // → true
-*/
-const anyRuleAllowsId = (rules, pageId) => rules.some((r) => (r.min === void 0 || pageId >= r.min) && (r.max === void 0 || pageId <= r.max));
-const extractDebugIndex = (groups, prefix) => {
-	if (!groups) return;
-	for (const key in groups) if (key.startsWith(prefix) && groups[key] !== void 0) {
-		const idx = Number.parseInt(key.slice(prefix.length), 10);
-		if (!Number.isNaN(idx)) return idx;
-	}
-};
-//#endregion
-//#region src/segmentation/breakpoint-utils.ts
-/**
-* Escapes regex metacharacters outside of `{{token}}` delimiters.
-*
-* This allows words in the `words` field to contain tokens while treating
-* most other characters as literals.
-*
-* Note: `()[]` are NOT escaped here because `processPattern` will handle them
-* via `escapeTemplateBrackets`. This avoids double-escaping.
-*
-* @param word - Word string that may contain {{tokens}}
-* @returns String with metacharacters escaped outside tokens (except ()[] which are escaped by processPattern)
-*
-* @example
-* escapeWordsOutsideTokens('a.*b')
-* // → 'a\\.\\*b'
-*
-* escapeWordsOutsideTokens('{{naql}}.test')
-* // → '{{naql}}\\.test'
-*
-* escapeWordsOutsideTokens('(literal)')
-* // → '(literal)' (not escaped here - processPattern handles it)
-*/
-const escapeWordsOutsideTokens = (word) => word.split(/(\{\{[^}]+\}\})/g).map((part) => part.startsWith("{{") && part.endsWith("}}") ? part : part.replace(/[.*+?^${}|\\]/g, "\\$&")).join("");
-/**
-* Normalizes a breakpoint to the object form.
-* Strings are converted to { pattern: str, split: 'after' } with no constraints.
-* Invalid `split` values are treated as `'after'` for backward compatibility.
-* If both `pattern` and `regex` are specified, `regex` takes precedence.
-*
-* When `words` is specified:
-* - Defaults `split` to `'at'` (can be overridden)
-* - Throws if combined with `pattern` or `regex`
-*
-* @param bp - Breakpoint as string or object
-* @returns Normalized BreakpointRule object with resolved pattern/regex
-*
-* @example
-* normalizeBreakpoint('\\n\\n')
-* // → { pattern: '\\n\\n', split: 'after' }
-*
-* normalizeBreakpoint({ pattern: '\\n', min: 10 })
-* // → { pattern: '\\n', min: 10, split: 'after' }
-*
-* normalizeBreakpoint({ pattern: 'X', split: 'at' })
-* // → { pattern: 'X', split: 'at' }
-*
-* normalizeBreakpoint({ words: ['فهذا', 'ثم'] })
-* // → { words: ['فهذا', 'ثم'], split: 'at' }
-*/
-const normalizeBreakpoint = (bp) => {
-	if (typeof bp === "string") return {
-		pattern: bp,
-		split: "after"
-	};
-	if (bp.words && (bp.pattern !== void 0 || bp.regex !== void 0)) throw new Error("BreakpointRule: \"words\" cannot be combined with \"pattern\" or \"regex\"");
-	const defaultSplit = bp.words ? "at" : "after";
-	const split = bp.split === "at" || bp.split === "after" ? bp.split : defaultSplit;
-	return {
-		...bp,
-		split
-	};
-};
-/**
-* Checks if a page ID is in an excluded list (single pages or ranges).
-*
-* @param pageId - Page ID to check
-* @param excludeList - List of page IDs or [from, to] ranges to exclude
-* @returns True if page is excluded
-*
-* @example
-* isPageExcluded(5, [1, 5, 10])
-* // → true
-*
-* isPageExcluded(5, [[3, 7]])
-* // → true
-*
-* isPageExcluded(5, [[10, 20]])
-* // → false
-*/
-const isPageExcluded = (pageId, excludeList) => excludeList?.some((item) => typeof item === "number" ? pageId === item : pageId >= item[0] && pageId <= item[1]) ?? false;
-/**
-* Checks if a page ID is within a breakpoint's min/max range and not excluded.
-*
-* @param pageId - Page ID to check
-* @param rule - Breakpoint rule with optional min/max/exclude constraints
-* @returns True if page is within valid range
-*
-* @example
-* isInBreakpointRange(50, { pattern: '\\n', min: 10, max: 100 })
-* // → true
-*
-* isInBreakpointRange(5, { pattern: '\\n', min: 10 })
-* // → false (below min)
-*/
-const isInBreakpointRange = (pageId, rule) => {
-	const { min, max, exclude } = rule;
-	return (min === void 0 || pageId >= min) && (max === void 0 || pageId <= max) && !isPageExcluded(pageId, exclude);
-};
-/**
-* Builds an exclude set from a PageRange array for O(1) lookups.
-*
-* @param excludeList - List of page IDs or [from, to] ranges
-* @returns Set of all excluded page IDs
-*
-* @remarks
-* This expands ranges into explicit page IDs for fast membership checks. For typical
-* book-scale inputs (thousands of pages), this is small and keeps downstream logic
-* simple and fast. If you expect extremely large ranges (e.g., millions of pages),
-* consider avoiding broad excludes or introducing a range-based membership structure.
-*
-* @example
-* buildExcludeSet([1, 5, [10, 12]])
-* // → Set { 1, 5, 10, 11, 12 }
-*/
-const buildExcludeSet = (excludeList) => {
-	const excludeSet = /* @__PURE__ */ new Set();
-	for (const item of excludeList || []) if (typeof item === "number") excludeSet.add(item);
-	else for (let i = item[0]; i <= item[1]; i++) excludeSet.add(i);
-	return excludeSet;
-};
-/**
-* Creates a segment with optional to and meta fields.
-* Returns null if content is empty after trimming.
-*
-* @param content - Segment content
-* @param fromPageId - Starting page ID
-* @param toPageId - Optional ending page ID (omitted if same as from)
-* @param meta - Optional metadata to attach
-* @returns Segment object or null if empty
-*
-* @example
-* createSegment('Hello world', 1, 3, { chapter: 1 })
-* // → { content: 'Hello world', from: 1, to: 3, meta: { chapter: 1 } }
-*
-* createSegment('   ', 1, undefined, undefined)
-* // → null (empty content)
-*/
-const createSegment = (content, fromPageId, toPageId, meta) => {
-	const trimmed = content.trim();
-	if (!trimmed) return null;
-	return {
-		content: trimmed,
-		from: fromPageId,
-		...toPageId !== void 0 && toPageId !== fromPageId && { to: toPageId },
-		...meta && { meta }
-	};
-};
-/**
-* Expands breakpoint patterns and pre-computes exclude sets.
-*
-* @param breakpoints - Array of breakpoint patterns or rules
-* @param processPattern - Function to expand tokens in patterns
-* @returns Array of expanded breakpoints with compiled regexes
-*
-* @remarks
-* This function compiles regex patterns dynamically. This can be a ReDoS vector
-* if patterns come from untrusted sources. In typical usage, breakpoint rules
-* are application configuration, not user input.
-/**
-* @param processPattern - Function to expand tokens in patterns (with bracket escaping)
-* @param processRawPattern - Function to expand tokens without bracket escaping (for regex field)
-*/
-/**
-* Builds regex source from words array.
-* Words are escaped, processed, sorted by length, and joined with alternation.
-*/
-const buildWordsRegex = (words, processPattern) => {
-	const processed = words.map((w, i) => ({
-		originalIndex: i,
-		w: w.trimStart()
-	})).filter(({ w }) => w.length > 0).map(({ w, originalIndex }) => ({
-		originalIndex,
-		pattern: processPattern(escapeWordsOutsideTokens(w))
-	}));
-	if (processed.length === 0) return null;
-	const seen = /* @__PURE__ */ new Set();
-	const unique = [];
-	for (const item of processed) if (!seen.has(item.pattern)) {
-		seen.add(item.pattern);
-		unique.push(item);
-	}
-	unique.sort((a, b) => b.pattern.length - a.pattern.length);
-	return `\\s+(?:${unique.map((item) => `(?<_w${item.originalIndex}>${item.pattern})`).join("|")})`;
-};
-/** Compiles skipWhen pattern to regex, or null if not present. */
-const compileSkipWhenRegex = (rule, processPattern) => {
-	if (rule.skipWhen === void 0) return null;
-	const expandedSkip = processPattern(rule.skipWhen);
-	try {
-		return new RegExp(expandedSkip, "mu");
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Invalid breakpoint skipWhen regex: ${rule.skipWhen}\n  Cause: ${message}`);
-	}
-};
-/** Compiles a regex from a pattern string, throws descriptive error on failure. */
-const compilePatternRegex = (pattern, fieldName) => {
-	try {
-		return new RegExp(pattern, "gmu");
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Invalid breakpoint ${fieldName}: ${pattern}\n  Cause: ${message}`);
-	}
-};
-/** Expands a single breakpoint to its expanded form. */
-const expandSingleBreakpoint = (bp, processPattern, processRawPattern) => {
-	const rule = normalizeBreakpoint(bp);
-	const excludeSet = buildExcludeSet(rule.exclude);
-	const skipWhenRegex = compileSkipWhenRegex(rule, processPattern);
-	if (rule.words !== void 0) {
-		const wordsPattern = buildWordsRegex(rule.words, processPattern);
-		if (wordsPattern === null) return null;
-		return {
-			excludeSet,
-			regex: compilePatternRegex(wordsPattern, `words: ${rule.words.join(", ")}`),
-			rule,
-			skipWhenRegex,
-			splitAt: rule.split === "at"
-		};
-	}
-	const rawPattern = rule.regex ?? rule.pattern;
-	if (rawPattern === "" || rawPattern === void 0) return {
-		excludeSet,
-		regex: null,
-		rule,
-		skipWhenRegex,
-		splitAt: false
-	};
-	return {
-		excludeSet,
-		regex: compilePatternRegex(rule.regex !== void 0 && processRawPattern ? processRawPattern(rawPattern) : processPattern(rawPattern), rule.regex !== void 0 ? "regex" : "pattern"),
-		rule,
-		skipWhenRegex,
-		splitAt: rule.split === "at"
-	};
-};
-const expandBreakpoints = (breakpoints, processPattern, processRawPattern) => breakpoints.map((bp) => expandSingleBreakpoint(bp, processPattern, processRawPattern)).filter((bp) => bp !== null);
-/**
-* Applies a configured joiner at detected page boundaries within a multi-page content chunk.
-*
-* This is used for breakpoint-generated segments which don't have access to the original
-* `pageMap.pageBreaks` offsets. We detect page starts sequentially by searching for each page's
-* prefix after the previous boundary, then replace ONLY the single newline immediately before
-* that page start.
-*
-* This avoids converting real in-page newlines, while still normalizing page joins consistently.
-*/
-const applyPageJoinerBetweenPages = (content, fromIdx, toIdx, pageIds, normalizedPages, joiner) => {
-	if (joiner === "newline" || fromIdx >= toIdx || !content.includes("\n")) return content;
-	let updated = content;
-	let searchFrom = 0;
-	for (let pi = fromIdx + 1; pi <= toIdx; pi++) {
-		const pageData = normalizedPages.get(pageIds[pi]);
-		if (!pageData) continue;
-		const found = findPrefixPositionInContent(updated, pageData.content.trimStart(), searchFrom);
-		if (found > 0 && updated[found - 1] === "\n") updated = `${updated.slice(0, found - 1)} ${updated.slice(found)}`;
-		if (found > 0) searchFrom = found;
-	}
-	return updated;
-};
-/**
-* Finds the position of a page prefix in content, trying multiple prefix lengths.
-*/
-const findPrefixPositionInContent = (content, trimmedPageContent, searchFrom) => {
-	for (const len of JOINER_PREFIX_LENGTHS) {
-		const prefix = trimmedPageContent.slice(0, Math.min(len, trimmedPageContent.length)).trim();
-		if (!prefix) continue;
-		const pos = content.indexOf(prefix, searchFrom);
-		if (pos > 0) return pos;
-	}
-	return -1;
-};
-/**
-* Estimates how far into the current page `remainingContent` begins.
-*
-* During breakpoint processing, `remainingContent` can begin mid-page after a previous split.
-* When that happens, raw cumulative page offsets (computed from full page starts) can overestimate
-* expected boundary positions. This helper computes an approximate starting offset by matching
-* a short prefix of `remainingContent` inside the current page content.
-*/
-const estimateStartOffsetInCurrentPage = (remainingContent, currentFromIdx, pageIds, normalizedPages) => {
-	const currentPageData = normalizedPages.get(pageIds[currentFromIdx]);
-	if (!currentPageData) return 0;
-	const remPrefix = remainingContent.slice(0, 500).trimStart();
-	if (!remPrefix) return 0;
-	const maxNeedleLen = Math.min(30, remPrefix.length);
-	for (let len = maxNeedleLen; len >= 5; len -= 5) {
-		const needle = remPrefix.slice(0, len);
-		const idx = currentPageData.content.indexOf(needle);
-		if (idx >= 0) return idx;
-	}
-	if (remPrefix.length >= 3) {
-		const needle = remPrefix.slice(0, 3);
-		const idx = currentPageData.content.indexOf(needle);
-		if (idx >= 0) return idx;
-	}
-	return 0;
-};
-const estimateStartOffsetInCurrentPageFromEnd = (remainingContent, currentFromIdx, pageIds, normalizedPages) => {
-	const currentPageData = normalizedPages.get(pageIds[currentFromIdx]);
-	if (!currentPageData) return 0;
-	const remPrefix = remainingContent.slice(0, 500).trimStart();
-	if (!remPrefix) return 0;
-	const maxNeedleLen = Math.min(30, remPrefix.length);
-	for (let len = maxNeedleLen; len >= 5; len -= 5) {
-		const needle = remPrefix.slice(0, len);
-		const idx = currentPageData.content.lastIndexOf(needle);
-		if (idx >= 0) return idx;
-	}
-	if (remPrefix.length >= 3) {
-		const needle = remPrefix.slice(0, 3);
-		const idx = currentPageData.content.lastIndexOf(needle);
-		if (idx >= 0) return idx;
-	}
-	return 0;
-};
-const selectStartOffsetInCurrentPage = (segmentContent, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger) => {
-	const first = estimateStartOffsetInCurrentPage(segmentContent, fromIdx, pageIds, normalizedPages);
-	const last = estimateStartOffsetInCurrentPageFromEnd(segmentContent, fromIdx, pageIds, normalizedPages);
-	const candidates = [...new Set([first, last])];
-	if (candidates.length <= 1 || fromIdx + 1 > toIdx) return candidates[0] ?? 0;
-	const rawBoundary = cumulativeOffsets[fromIdx + 1] !== void 0 && cumulativeOffsets[fromIdx] !== void 0 ? Math.max(0, cumulativeOffsets[fromIdx + 1] - cumulativeOffsets[fromIdx]) : void 0;
-	if (rawBoundary === void 0) return candidates[0] ?? 0;
-	let best = candidates[0] ?? 0;
-	let bestScore = Number.POSITIVE_INFINITY;
-	for (const candidate of candidates) {
-		const expectedBoundary = Math.max(0, rawBoundary - candidate);
-		const pos = findPageStartNearExpectedBoundary(segmentContent, fromIdx + 1, expectedBoundary, pageIds, normalizedPages, logger);
-		if (pos > 0) {
-			const score = Math.abs(pos - expectedBoundary);
-			if (score < bestScore) {
-				bestScore = score;
-				best = candidate;
-			}
-		}
-	}
-	return best;
-};
-/**
-* Attempts to find the start position of a target page within remainingContent,
-* anchored near an expected boundary position to reduce collisions.
-*
-* 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, 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);
-	const searchStart = Math.max(0, approx - 1e4);
-	const searchEnd = Math.min(remainingContent.length, approx + 2e3);
-	const targetTrimmed = targetPageData.content.trimStart();
-	const ignoreDeviation = expectedBoundary >= remainingContent.length;
-	const scanStart = ignoreDeviation ? 0 : searchStart;
-	const scanEnd = ignoreDeviation ? remainingContent.length : searchEnd;
-	const expectedForRanking = ignoreDeviation ? 0 : expectedBoundary;
-	for (const len of WINDOW_PREFIX_LENGTHS) {
-		const prefix = targetTrimmed.slice(0, Math.min(len, targetTrimmed.length)).trim();
-		if (!prefix) continue;
-		const candidates = findAnchorCandidates(remainingContent, prefix, scanStart, scanEnd);
-		if (candidates.length === 0) continue;
-		const deviationLimit = ignoreDeviation ? Number.POSITIVE_INFINITY : MAX_DEVIATION;
-		const inRange = candidates.filter((c) => Math.abs(c.pos - expectedBoundary) <= deviationLimit);
-		if (inRange.length > 0) return selectBestAnchor(inRange, expectedForRanking).pos;
-		const bestOverall = selectBestAnchor(candidates, expectedForRanking);
-		logger?.debug?.("[breakpoints] findPageStartNearExpectedBoundary: Rejected match exceeding deviation", {
-			bestDistance: Math.abs(bestOverall.pos - expectedForRanking),
-			expectedBoundary,
-			matchPos: bestOverall.pos,
-			maxDeviation: deviationLimit,
-			prefixLength: len,
-			targetPageIdx
-		});
-	}
-	return -1;
-};
-/** Finds all whitespace-preceded occurrences of a prefix within a search range */
-const findAnchorCandidates = (content, prefix, start, end) => {
-	const candidates = [];
-	let pos = content.indexOf(prefix, start);
-	while (pos !== -1 && pos <= end) {
-		if (pos > 0) {
-			const charBefore = content[pos - 1];
-			if (charBefore === "\n") candidates.push({
-				isNewline: true,
-				pos
-			});
-			else if (/\s/.test(charBefore)) candidates.push({
-				isNewline: false,
-				pos
-			});
-		}
-		pos = content.indexOf(prefix, pos + 1);
-	}
-	return candidates;
-};
-/** Selects the best anchor candidate, prioritizing newlines then proximity to boundary */
-const selectBestAnchor = (candidates, expectedBoundary) => {
-	return candidates.reduce((best, curr) => {
-		const bestScore = Math.abs(best.pos - expectedBoundary) + (best.isNewline ? 0 : 20);
-		return Math.abs(curr.pos - expectedBoundary) + (curr.isNewline ? 0 : 20) < bestScore ? curr : best;
-	});
-};
-/**
-* Finds the start position of a target page after a minimum position.
-* Used to avoid duplicate earlier matches when content repeats.
-*/
-const findPageStartAfterPosition = (remainingContent, targetPageIdx, minPos, pageIds, normalizedPages) => {
-	const targetPageData = normalizedPages.get(pageIds[targetPageIdx]);
-	if (!targetPageData) return -1;
-	const targetTrimmed = targetPageData.content.trimStart();
-	for (const len of WINDOW_PREFIX_LENGTHS) {
-		const prefix = targetTrimmed.slice(0, Math.min(len, targetTrimmed.length)).trim();
-		if (!prefix) continue;
-		const after = findAnchorCandidates(remainingContent, prefix, Math.max(0, minPos), remainingContent.length).filter((c) => c.pos > minPos);
-		if (after.length > 0) return selectBestAnchor(after, minPos).pos;
-	}
-	return -1;
-};
-const buildBoundaryPositionsFastPath = (segmentContent, fromIdx, toIdx, pageCount, cumulativeOffsets, logger) => {
-	const boundaryPositions = [0];
-	logger?.debug?.("[breakpoints] Using fast-path for large segment in buildBoundaryPositions", {
-		fromIdx,
-		pageCount,
-		toIdx
-	});
-	const baseOffset = cumulativeOffsets[fromIdx] ?? 0;
-	for (let i = fromIdx + 1; i <= toIdx; i++) {
-		const offset = cumulativeOffsets[i];
-		if (offset !== void 0) {
-			const boundary = Math.max(0, offset - baseOffset);
-			const prevBoundary = boundaryPositions[boundaryPositions.length - 1];
-			boundaryPositions.push(Math.max(prevBoundary + 1, Math.min(boundary, segmentContent.length)));
-		}
-	}
-	boundaryPositions.push(segmentContent.length);
-	return boundaryPositions;
-};
-const isBoundaryPositionValid = (pos, prevBoundary, expectedBoundary, segmentLength, ignoreDeviation = false) => {
-	if (pos <= 0 || pos <= prevBoundary) return false;
-	if (ignoreDeviation) return true;
-	if (expectedBoundary >= segmentLength) return true;
-	const deviationLimit = MAX_DEVIATION;
-	return Math.abs(pos - expectedBoundary) < deviationLimit;
-};
-const resolveBoundaryMatch = (segmentContent, pageIdx, rawBoundary, startOffsetInFromPage, canInferStartOffset, pageIds, normalizedPages, logger) => {
-	let expectedBoundary = rawBoundary !== void 0 ? Math.max(0, rawBoundary - startOffsetInFromPage) : segmentContent.length;
-	let pos = findPageStartNearExpectedBoundary(segmentContent, pageIdx, expectedBoundary, pageIds, normalizedPages, logger);
-	let didInferStartOffset = false;
-	if (pos < 0 && canInferStartOffset && rawBoundary !== void 0) {
-		const relaxedPos = findPageStartNearExpectedBoundary(segmentContent, pageIdx, segmentContent.length, pageIds, normalizedPages, logger);
-		if (relaxedPos > 0) {
-			const inferredStartOffset = rawBoundary - relaxedPos;
-			const currentExpected = Math.max(0, rawBoundary - startOffsetInFromPage);
-			if (inferredStartOffset >= 0 && Math.abs(relaxedPos - currentExpected) < 500) {
-				startOffsetInFromPage = inferredStartOffset;
-				expectedBoundary = Math.max(0, rawBoundary - startOffsetInFromPage);
-				pos = relaxedPos;
-				didInferStartOffset = true;
-			}
-		}
-	}
-	return {
-		didInferStartOffset,
-		expectedBoundary,
-		pos,
-		startOffsetInFromPage
-	};
-};
-const buildBoundaryPositionsAccurate = (segmentContent, fromIdx, toIdx, pageCount, pageIds, normalizedPages, cumulativeOffsets, logger) => {
-	const boundaryPositions = [0];
-	logger?.debug?.("[breakpoints] buildBoundaryPositions: Using accurate string-search path", {
-		contentLength: segmentContent.length,
-		fromIdx,
-		pageCount,
-		toIdx
-	});
-	let startOffsetInFromPage = selectStartOffsetInCurrentPage(segmentContent, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger);
-	let didInferStartOffset = false;
-	for (let i = fromIdx + 1; i <= toIdx; i++) {
-		const rawBoundary = cumulativeOffsets[i] !== void 0 && cumulativeOffsets[fromIdx] !== void 0 ? Math.max(0, cumulativeOffsets[i] - cumulativeOffsets[fromIdx]) : void 0;
-		const resolved = resolveBoundaryMatch(segmentContent, i, rawBoundary, startOffsetInFromPage, !didInferStartOffset && i === fromIdx + 1, pageIds, normalizedPages, logger);
-		startOffsetInFromPage = resolved.startOffsetInFromPage;
-		didInferStartOffset = didInferStartOffset || resolved.didInferStartOffset;
-		const prevBoundary = boundaryPositions[boundaryPositions.length - 1];
-		let resolvedPos = resolved.pos;
-		if (resolvedPos <= prevBoundary) {
-			const afterPos = findPageStartAfterPosition(segmentContent, i, prevBoundary + 1, pageIds, normalizedPages);
-			if (afterPos > prevBoundary) resolvedPos = afterPos;
-		}
-		if (isBoundaryPositionValid(resolvedPos, prevBoundary, resolved.expectedBoundary, segmentContent.length)) boundaryPositions.push(resolvedPos);
-		else {
-			const estimate = Math.max(prevBoundary + 1, resolved.expectedBoundary);
-			boundaryPositions.push(Math.min(estimate, segmentContent.length));
-		}
-	}
-	boundaryPositions.push(segmentContent.length);
-	logger?.debug?.("[breakpoints] buildBoundaryPositions: Complete", { boundaryCount: boundaryPositions.length });
-	return boundaryPositions;
-};
-/**
-* Builds a boundary position map for pages within the given range.
-*
-* This function computes page boundaries once per segment and enables
-* O(log n) page lookups via binary search with `findPageIndexForPosition`.
-*
-* Boundaries are derived from segmentContent (post-structural-rules).
-* When the segment starts mid-page, an offset correction is applied to
-* keep boundary estimates aligned with the segment's actual content space.
-*
-* @param segmentContent - Full segment content (already processed by structural rules)
-* @param fromIdx - Starting page index
-* @param toIdx - Ending page index
-* @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
-*
-* @example
-* // For a 3-page segment:
-* 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, logger) => {
-	const pageCount = toIdx - fromIdx + 1;
-	const expectedLength = (cumulativeOffsets[toIdx + 1] ?? 0) - (cumulativeOffsets[fromIdx] ?? 0);
-	if (pageCount >= 1e3 && segmentContent.length === expectedLength) return buildBoundaryPositionsFastPath(segmentContent, fromIdx, toIdx, pageCount, cumulativeOffsets, logger);
-	return buildBoundaryPositionsAccurate(segmentContent, fromIdx, toIdx, pageCount, pageIds, normalizedPages, cumulativeOffsets, logger);
-};
-/**
-* Binary search to find which page a position falls within.
-* Uses "largest i where boundaryPositions[i] <= position" semantics.
-*
-* @param position - Character position in segmentContent
-* @param boundaryPositions - Precomputed boundary positions (from buildBoundaryPositions)
-* @param fromIdx - Base page index (boundaryPositions[0] corresponds to pageIds[fromIdx])
-* @returns Page index in pageIds array
-*
-* @example
-* // With boundaries [0, 20, 40, 60] and fromIdx=0:
-* findPageIndexForPosition(15, boundaries, 0) // → 0 (first page)
-* findPageIndexForPosition(25, boundaries, 0) // → 1 (second page)
-* findPageIndexForPosition(40, boundaries, 0) // → 2 (exactly on boundary = that page)
-*/
-const findPageIndexForPosition = (position, boundaryPositions, fromIdx) => {
-	if (boundaryPositions.length <= 1) return fromIdx;
-	let left = 0;
-	let right = boundaryPositions.length - 2;
-	while (left < right) {
-		const mid = Math.ceil((left + right) / 2);
-		if (boundaryPositions[mid] <= position) left = mid;
-		else right = mid - 1;
-	}
-	return fromIdx + left;
-};
-/**
-* Finds the end position of a breakpoint window inside `remainingContent`.
-*
-* The window end is defined as the start of the page AFTER `windowEndIdx` (i.e. `windowEndIdx + 1`),
-* 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, 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;
-		if (nextIdx === maxNextIdx) bestExpectedBoundary = expectedBoundary;
-		const pos = findPageStartNearExpectedBoundary(remainingContent, nextIdx, expectedBoundary, pageIds, normalizedPages, logger);
-		if (pos > 0) return pos;
-	}
-	return Math.min(bestExpectedBoundary, remainingContent.length);
-};
-/**
-* Finds exclusion-based break position using raw cumulative offsets.
-*
-* This is used to ensure pages excluded by breakpoints are never merged into the same output segment.
-* Returns a break position relative to the start of `remainingContent` (i.e. the currentFromIdx start).
-*/
-const findExclusionBreakPosition = (currentFromIdx, windowEndIdx, toIdx, pageIds, expandedBreakpoints, cumulativeOffsets) => {
-	const startingPageId = pageIds[currentFromIdx];
-	if (expandedBreakpoints.some((bp) => bp.excludeSet.has(startingPageId)) && currentFromIdx < toIdx) return cumulativeOffsets[currentFromIdx + 1] - cumulativeOffsets[currentFromIdx];
-	for (let pageIdx = currentFromIdx + 1; pageIdx <= windowEndIdx; pageIdx++) {
-		const pageId = pageIds[pageIdx];
-		if (expandedBreakpoints.some((bp) => bp.excludeSet.has(pageId))) return cumulativeOffsets[pageIdx] - cumulativeOffsets[currentFromIdx];
-	}
-	return -1;
-};
-/**
-* Checks if any page in a range is excluded by the given exclude set.
-*
-* @param excludeSet - Set of excluded page IDs
-* @param pageIds - Array of page IDs
-* @param fromIdx - Start index (inclusive)
-* @param toIdx - End index (inclusive)
-* @returns True if any page in range is excluded
-*/
-const hasExcludedPageInRange = (excludeSet, pageIds, fromIdx, toIdx) => {
-	if (excludeSet.size === 0) return false;
-	for (let pageIdx = fromIdx; pageIdx <= toIdx; pageIdx++) if (excludeSet.has(pageIds[pageIdx])) return true;
-	return false;
-};
-/**
-* Finds the position of the next page content within remaining content.
-* Returns -1 if not found.
-*
-* @param remainingContent - Content to search in
-* @param nextPageData - Normalized data for the next page
-* @returns Position of next page content, or -1 if not found
-*/
-const findNextPagePosition = (remainingContent, nextPageData) => {
-	const searchPrefix = nextPageData.content.trim().slice(0, Math.min(30, nextPageData.length));
-	if (searchPrefix.length === 0) return -1;
-	const pos = remainingContent.indexOf(searchPrefix);
-	return pos > 0 ? pos : -1;
-};
-/**
-* Finds matches within a window and returns the selected position based on preference and split mode.
-*
-* @param windowContent - Content to search
-* @param regex - Regex to match
-* @param prefer - 'longer' for last match, 'shorter' for first match
-* @param splitAt - If true, return position BEFORE match (at index). If false, return position AFTER match (at index + length).
-* @returns Break position, or -1 if no valid matches
-*
-* @remarks
-* - Matches with length 0 are skipped (prevents infinite loops with lookahead patterns)
-* - Matches that would result in position 0 are skipped (prevents empty first segments)
-* - For prefer:'shorter', returns immediately on first valid match (optimization)
-*/
-const findPatternBreakPosition = (windowContent, regex, prefer, splitAt = false) => {
-	let last;
-	for (const m of windowContent.matchAll(regex)) {
-		const idx = m.index ?? -1;
-		const len = m[0]?.length ?? 0;
-		if (idx < 0 || len === 0) continue;
-		const pos = splitAt ? idx : idx + len;
-		if (pos === 0) continue;
-		last = {
-			groups: m.groups,
-			index: idx,
-			length: len
-		};
-		if (prefer === "shorter") return {
-			groups: m.groups,
-			pos
-		};
-	}
-	if (!last) return { pos: -1 };
-	const finalPos = splitAt ? last.index : last.index + last.length;
-	return {
-		groups: last.groups,
-		pos: finalPos
-	};
-};
-/**
-* Handles page boundary breakpoint (empty pattern).
-* Returns break position or -1 if no valid position found.
-*/
-const findStartOfNextPageInWindow = (remainingContent, currentFromIdx, toIdx, pageIds, normalizedPages, targetPos) => {
-	const targetNextPageIdx = currentFromIdx + 1;
-	for (let nextIdx = targetNextPageIdx; nextIdx > currentFromIdx; nextIdx--) if (nextIdx <= toIdx) {
-		const nextPageData = normalizedPages.get(pageIds[nextIdx]);
-		if (nextPageData) {
-			const boundaryPos = findNextPagePosition(remainingContent, nextPageData);
-			if (boundaryPos > 0 && boundaryPos <= targetPos) return boundaryPos;
-		}
-	}
-	return -1;
-};
-const handlePageBoundaryBreak = (remainingContent, currentFromIdx, windowEndPosition, maxContentLength, toIdx, pageIds, normalizedPages) => {
-	const targetPos = Math.min(windowEndPosition, remainingContent.length);
-	const isLengthBounded = maxContentLength !== void 0 && windowEndPosition === maxContentLength;
-	if (!isLengthBounded) {
-		const boundaryPos = findStartOfNextPageInWindow(remainingContent, currentFromIdx, toIdx, pageIds, normalizedPages, targetPos);
-		if (boundaryPos > 0) return { pos: boundaryPos };
-	}
-	if (targetPos < remainingContent.length) {
-		const safePos = findSafeBreakPosition(remainingContent, targetPos);
-		if (safePos !== -1) return {
-			pos: safePos,
-			splitReason: isLengthBounded ? "whitespace" : void 0
-		};
-		return {
-			pos: adjustForUnicodeBoundary(remainingContent, targetPos),
-			splitReason: isLengthBounded ? "unicode_boundary" : void 0
-		};
-	}
-	return { pos: targetPos };
-};
-const checkBreakpointMatch = (i, remainingContent, currentFromIdx, toIdx, windowEndIdx, windowEndPosition, ctx, maxContentLength) => {
-	const { pageIds, normalizedPages, expandedBreakpoints, prefer } = ctx;
-	const bpCtx = expandedBreakpoints[i];
-	const { rule, regex, excludeSet, skipWhenRegex } = bpCtx;
-	if (!isInBreakpointRange(pageIds[currentFromIdx], rule)) return null;
-	if (hasExcludedPageInRange(excludeSet, pageIds, currentFromIdx, windowEndIdx)) return null;
-	if (skipWhenRegex?.test(remainingContent)) return null;
-	if (regex === null) {
-		const result = handlePageBoundaryBreak(remainingContent, currentFromIdx, windowEndPosition, maxContentLength, toIdx, pageIds, normalizedPages);
-		return {
-			breakPos: result.pos,
-			breakpointIndex: i,
-			contentLengthSplit: result.splitReason && maxContentLength ? {
-				maxContentLength,
-				reason: result.splitReason
-			} : void 0,
-			rule
-		};
-	}
-	const { pos: breakPos, groups } = findPatternBreakPosition(remainingContent.slice(0, Math.min(windowEndPosition, remainingContent.length)), regex, prefer, bpCtx.splitAt);
-	if (breakPos > 0) return {
-		breakPos,
-		breakpointIndex: i,
-		rule,
-		wordIndex: extractDebugIndex(groups, "_w")
-	};
-	return null;
-};
-/**
-* Tries to find a break position within the current window using breakpoint patterns.
-* Returns the break position or -1 if no suitable break was found.
-*
-* @param remainingContent - Content remaining to be segmented
-* @param currentFromIdx - Current starting page index
-* @param toIdx - Ending page index
-* @param windowEndIdx - Maximum window end index
-* @param ctx - Breakpoint context with page data and patterns
-* @returns Break position in the content, or -1 if no break found
-*/
-const findBreakPosition = (remainingContent, currentFromIdx, toIdx, windowEndIdx, windowEndPosition, ctx, maxContentLength) => {
-	const { expandedBreakpoints } = ctx;
-	for (let i = 0; i < expandedBreakpoints.length; i++) {
-		const match = checkBreakpointMatch(i, remainingContent, currentFromIdx, toIdx, windowEndIdx, windowEndPosition, ctx, maxContentLength);
-		if (match) return match;
-	}
-	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 (STOP_CHARACTERS.test(char)) return i + 1;
-	}
-	return -1;
-};
-//#endregion
-//#region src/segmentation/debug-meta.ts
-const resolveDebugConfig = (debug) => {
-	if (debug === true) return {
-		includeBreakpoint: true,
-		includeRule: true,
-		metaKey: "_flappa"
-	};
-	if (!debug || typeof debug !== "object") return null;
-	const { metaKey, include } = debug;
-	const includeRule = Array.isArray(include) ? include.includes("rule") : true;
-	return {
-		includeBreakpoint: Array.isArray(include) ? include.includes("breakpoint") : true,
-		includeRule,
-		metaKey: typeof metaKey === "string" && metaKey ? metaKey : "_flappa"
-	};
-};
-const getRulePatternType = (rule) => {
-	return PATTERN_TYPE_KEYS.find((key) => key in rule) ?? "regex";
-};
-const isPlainObject = (v) => Boolean(v) && typeof v === "object" && !Array.isArray(v);
-const mergeDebugIntoMeta = (meta, metaKey, patch) => {
-	const out = meta ? { ...meta } : {};
-	const existing = out[metaKey];
-	out[metaKey] = {
-		...isPlainObject(existing) ? existing : {},
-		...patch
-	};
-	return out;
-};
-const buildRuleDebugPatch = (ruleIndex, rule, wordIndex) => {
-	const patternType = getRulePatternType(rule);
-	const patterns = rule[patternType];
-	const word = wordIndex !== void 0 && Array.isArray(patterns) && patterns[wordIndex] !== void 0 ? patterns[wordIndex] : void 0;
-	return { rule: {
-		index: ruleIndex,
-		patternType,
-		...wordIndex !== void 0 ? { wordIndex } : {},
-		...word !== void 0 ? { word } : {}
-	} };
-};
-const buildBreakpointDebugPatch = (breakpointIndex, rule, wordIndex) => ({ breakpoint: {
-	index: breakpointIndex,
-	kind: rule.pattern === "" ? "pageBoundary" : rule.regex ? "regex" : "pattern",
-	pattern: rule.pattern ?? rule.regex,
-	...wordIndex !== void 0 ? { wordIndex } : {},
-	...wordIndex !== void 0 && rule.words ? { word: rule.words[wordIndex] } : {}
-} });
-/**
-* Helper to format the debug info into a human-readable string.
-* @param meta - The segment metadata object
-* @param options - Formatting options
-*/
-const formatRuleReason = (rule, concise) => {
-	const { index, patternType, wordIndex, word } = rule;
-	if (concise) return `Rule: ${word ? `"${word}"` : patternType}`;
-	const wordInfo = word ? ` (Matched: "${word}")` : "";
-	return `Rule #${index} (${patternType})${wordIndex !== void 0 ? ` [idx:${wordIndex}]` : ""}${wordInfo}`;
-};
-const formatBreakpointReason = (breakpoint, concise) => {
-	const { index, kind, pattern, wordIndex, word } = breakpoint;
-	if (kind === "pageBoundary") return concise ? "Breakpoint: <page-boundary>" : "Page Boundary (Fallback)";
-	if (concise) return `Breakpoint: ${word ? `"${word}"` : `"${pattern}"`}`;
-	if (word) return `Breakpoint #${index} (Words) [idx:${wordIndex}] - "${word}"`;
-	return `Breakpoint #${index} (${kind}) - "${pattern}"`;
-};
-const formatContentLengthReason = (split, concise) => {
-	const { maxContentLength, splitReason } = split;
-	if (concise) return `> ${maxContentLength} (${splitReason})`;
-	return `Safety Split (${splitReason}) > ${maxContentLength}`;
-};
-/**
-* Helper to format the debug info into a human-readable string.
-* @param meta - The segment metadata object
-* @param options - Formatting options
-*/
-const getDebugReason = (meta, options) => {
-	const debug = meta?._flappa;
-	if (!debug) return "-";
-	const concise = options?.concise;
-	if (debug.rule) return formatRuleReason(debug.rule, concise);
-	if (debug.breakpoint) return formatBreakpointReason(debug.breakpoint, concise);
-	if (debug.contentLengthSplit) return formatContentLengthReason(debug.contentLengthSplit, concise);
-	return "Unknown";
-};
-/**
-* Convenience helper to get the formatted debug reason directly from a segment.
-* @param segment - The segment object
-* @param options - Formatting options
-*/
-const getSegmentDebugReason = (segment, options) => {
-	return getDebugReason(segment.meta, options);
-};
-//#endregion
-//#region src/segmentation/pattern-validator.ts
-const KNOWN_TOKENS = new Set(getAvailableTokens());
-const TOKEN_INSIDE_BRACES = /\{\{(\w+)(?::\w+)?\}\}/g;
-const buildBareTokenRegex = () => {
-	const tokens = [...KNOWN_TOKENS].sort((a, b) => b.length - a.length);
-	return new RegExp(`(?<!\\{\\{)(${tokens.join("|")})(?::\\w+)?(?!\\}\\})`, "g");
-};
-/**
-* Validates a single pattern for common issues.
-*/
-const validatePattern = (pattern, seenPatterns) => {
-	if (!pattern.trim()) return {
-		message: "Empty pattern is not allowed",
-		type: "empty_pattern"
-	};
-	if (seenPatterns.has(pattern)) return {
-		message: `Duplicate pattern: "${pattern}"`,
-		pattern,
-		type: "duplicate"
-	};
-	seenPatterns.add(pattern);
-	TOKEN_INSIDE_BRACES.lastIndex = 0;
-	for (const match of pattern.matchAll(TOKEN_INSIDE_BRACES)) {
-		const name = match[1];
-		if (!KNOWN_TOKENS.has(name)) return {
-			message: `Unknown token: {{${name}}}. Available tokens: ${[...KNOWN_TOKENS].slice(0, 5).join(", ")}...`,
-			suggestion: "Check spelling or use a known token",
-			token: name,
-			type: "unknown_token"
-		};
-	}
-	for (const match of pattern.matchAll(buildBareTokenRegex())) {
-		const [full, name] = match;
-		const idx = match.index;
-		if (pattern.slice(Math.max(0, idx - 2), idx) !== "{{" || pattern.slice(idx + full.length, idx + full.length + 2) !== "}}") return {
-			message: `Token "${name}" appears to be missing {{}}. Did you mean "{{${full}}}"?`,
-			suggestion: `{{${full}}}`,
-			token: name,
-			type: "missing_braces"
-		};
-	}
-};
-/**
-* Validates an array of patterns, returning parallel array of issues.
-*/
-const validatePatternArray = (patterns) => {
-	const seen = /* @__PURE__ */ new Set();
-	const issues = patterns.map((p) => validatePattern(p, seen));
-	return issues.some(Boolean) ? issues : void 0;
-};
-const applyRulePatternValidation = (result, key, patterns) => {
-	if (!patterns) return false;
-	const issues = validatePatternArray(patterns);
-	if (!issues) return false;
-	result[key] = issues;
-	return true;
-};
-const validateTemplateRule = (rule, result) => {
-	if (rule.template === void 0) return false;
-	const issue = validatePattern(rule.template, /* @__PURE__ */ new Set());
-	if (!issue) return false;
-	result.template = issue;
-	return true;
-};
-const validateRegexRule = (rule, result) => {
-	if (rule.regex === void 0) return false;
-	if (!rule.regex.trim()) {
-		result.regex = {
-			message: "Empty pattern is not allowed",
-			type: "empty_pattern"
-		};
-		return true;
-	}
-	try {
-		new RegExp(rule.regex, "u");
-		return false;
-	} catch (error) {
-		result.regex = {
-			message: error instanceof Error ? error.message : String(error),
-			pattern: rule.regex,
-			type: "invalid_regex"
-		};
-		return true;
-	}
-};
-const invalidDictionaryEntryIssue = (message) => ({
-	message,
-	type: "invalid_option"
-});
-const validateDictionaryEntryRule = (rule, result) => {
-	if (!("dictionaryEntry" in rule) || !rule.dictionaryEntry) return false;
-	const issues = {};
-	const { allowCommaSeparated, allowParenthesized, allowWhitespaceBeforeColon, captureName, maxLetters, midLineSubentries, minLetters, stopWords } = rule.dictionaryEntry;
-	if (!Array.isArray(stopWords) || stopWords.some((word) => typeof word !== "string" || !word.trim())) issues.stopWords = invalidDictionaryEntryIssue("stopWords must be a string[] with non-empty entries");
-	if (allowCommaSeparated !== void 0 && typeof allowCommaSeparated !== "boolean") issues.allowCommaSeparated = invalidDictionaryEntryIssue("allowCommaSeparated must be a boolean");
-	if (allowParenthesized !== void 0 && typeof allowParenthesized !== "boolean") issues.allowParenthesized = invalidDictionaryEntryIssue("allowParenthesized must be a boolean");
-	if (allowWhitespaceBeforeColon !== void 0 && typeof allowWhitespaceBeforeColon !== "boolean") issues.allowWhitespaceBeforeColon = invalidDictionaryEntryIssue("allowWhitespaceBeforeColon must be a boolean");
-	if (midLineSubentries !== void 0 && typeof midLineSubentries !== "boolean") issues.midLineSubentries = invalidDictionaryEntryIssue("midLineSubentries must be a boolean");
-	if (captureName !== void 0 && !captureName.match(/^[A-Za-z_]\w*$/)) issues.captureName = invalidDictionaryEntryIssue(`captureName must match /^[A-Za-z_]\\w*$/, got "${captureName}"`);
-	if (minLetters !== void 0 && (!Number.isInteger(minLetters) || minLetters < 1)) issues.minLetters = invalidDictionaryEntryIssue("minLetters must be an integer >= 1");
-	if (maxLetters !== void 0 && (!Number.isInteger(maxLetters) || maxLetters < (minLetters ?? 2))) issues.maxLetters = invalidDictionaryEntryIssue(`maxLetters must be an integer >= ${minLetters ?? 2}`);
-	if (Object.keys(issues).length === 0) return false;
-	result.dictionaryEntry = issues;
-	return true;
-};
-const formatValidationIssue = (_type, issue, loc) => {
-	if (!issue) return null;
-	if (issue.type === "missing_braces") return `${loc}: Missing {{}} around token "${issue.token}"`;
-	if (issue.type === "unknown_token") return `${loc}: Unknown token "{{${issue.token}}}"`;
-	if (issue.type === "duplicate") return `${loc}: Duplicate pattern "${issue.pattern}"`;
-	if (issue.type === "invalid_regex") return `${loc}: Invalid regex (${issue.message})`;
-	return `${loc}: ${issue.message || issue.type}`;
-};
-/**
-* Validates split rules for common pattern issues.
-*
-* Checks for:
-* - Missing `{{}}` around known token names (e.g., `raqms:num` instead of `{{raqms:num}}`)
-* - Unknown token names inside `{{}}` (e.g., `{{nonexistent}}`)
-* - Duplicate patterns within the same rule
-*
-* @param rules - Array of split rules to validate
-* @returns Array parallel to input with validation results (undefined if no issues)
-*
-* @example
-* const issues = validateRules([
-*   { lineStartsAfter: ['raqms:num'] },  // Missing braces
-*   { lineStartsWith: ['{{unknown}}'] }, // Unknown token
-* ]);
-* // issues[0]?.lineStartsAfter?.[0]?.type === 'missing_braces'
-* // issues[1]?.lineStartsWith?.[0]?.type === 'unknown_token'
-*/
-const validateRules = (rules) => rules.map((rule) => {
-	const result = {};
-	const startsWithIssues = applyRulePatternValidation(result, "lineStartsWith", rule.lineStartsWith);
-	const startsAfterIssues = applyRulePatternValidation(result, "lineStartsAfter", rule.lineStartsAfter);
-	const endsWithIssues = applyRulePatternValidation(result, "lineEndsWith", rule.lineEndsWith);
-	const templateIssues = validateTemplateRule(rule, result);
-	const regexIssues = validateRegexRule(rule, result);
-	const dictionaryEntryIssues = validateDictionaryEntryRule(rule, result);
-	return startsWithIssues || startsAfterIssues || endsWithIssues || templateIssues || regexIssues || dictionaryEntryIssues ? result : void 0;
-});
-/**
-* Formats a validation result array into a list of human-readable error messages.
-*
-* Useful for displaying validation errors in UIs.
-*
-* @param results - The result array from `validateRules()`
-* @returns Array of formatted error strings
-*
-* @example
-* const issues = validateRules(rules);
-* const errors = formatValidationReport(issues);
-* // ["Rule 1, lineStartsWith: Missing {{}} around token..."]
-*/
-const formatValidationReport = (results) => results.flatMap((result, i) => {
-	if (!result) return [];
-	return Object.entries(result).flatMap(([type, issues]) => formatValidationIssues(type, issues, i + 1));
-});
-const formatValidationIssues = (type, issues, ruleNumber) => {
-	if (type === "dictionaryEntry" && issues && typeof issues === "object" && !Array.isArray(issues)) return Object.entries(issues).map(([field, issue]) => formatValidationIssue(type, issue, `Rule ${ruleNumber}, ${type}.${field}`)).filter((msg) => msg !== null);
-	return (Array.isArray(issues) ? issues : [issues]).map((issue) => formatValidationIssue(type, issue, `Rule ${ruleNumber}, ${type}`)).filter((msg) => msg !== null);
-};
-//#endregion
-//#region src/segmentation/breakpoint-processor.ts
-const buildPageIdToIndexMap = (pageIds) => new Map(pageIds.map((id, i) => [id, i]));
-const buildNormalizedPagesMap = (pages, normalizedContent) => {
-	const normalizedPages = /* @__PURE__ */ new Map();
-	for (let i = 0; i < pages.length; i++) {
-		const content = normalizedContent[i];
-		normalizedPages.set(pages[i].id, {
-			content,
-			index: i,
-			length: content.length
-		});
-	}
-	return normalizedPages;
-};
-const buildCumulativeOffsets = (pageIds, normalizedPages) => {
-	const cumulativeOffsets = [0];
-	let totalOffset = 0;
-	for (let i = 0; i < pageIds.length; i++) {
-		const pageData = normalizedPages.get(pageIds[i]);
-		totalOffset += pageData?.length ?? 0;
-		if (i < pageIds.length - 1) totalOffset += 1;
-		cumulativeOffsets.push(totalOffset);
-	}
-	return cumulativeOffsets;
-};
-const hasAnyExclusionsInRange = (expandedBreakpoints, pageIds, fromIdx, toIdx) => expandedBreakpoints.some((bp) => hasExcludedPageInRange(bp.excludeSet, pageIds, fromIdx, toIdx));
-const computeWindowEndIdx = (currentFromIdx, toIdx, pageIds, maxPages) => {
-	const maxWindowPageId = pageIds[currentFromIdx] + maxPages;
-	let windowEndIdx = currentFromIdx;
-	for (let i = currentFromIdx; i <= toIdx; i++) if (pageIds[i] <= maxWindowPageId) windowEndIdx = i;
-	else break;
-	return windowEndIdx;
-};
-const computeRemainingSpan = (currentFromIdx, toIdx, pageIds) => pageIds[toIdx] - pageIds[currentFromIdx];
-const createFinalSegment = (remainingContent, currentFromIdx, toIdx, pageIds, meta, includeMeta) => createSegment(remainingContent, pageIds[currentFromIdx], currentFromIdx !== toIdx ? pageIds[toIdx] : void 0, includeMeta ? meta : void 0);
-/**
-* Computes the actual start and end page indices for a piece using
-* precomputed boundary positions and binary search.
-*
-* @param pieceStartPos - Start position of the piece in the full segment content
-* @param pieceEndPos - End position (exclusive) of the piece
-* @param boundaryPositions - Precomputed boundary positions from buildBoundaryPositions
-* @param baseFromIdx - Base page index (boundaryPositions[0] corresponds to pageIds[baseFromIdx])
-* @param toIdx - Maximum page index
-* @returns Object with actualStartIdx and actualEndIdx
-*/
-const computePiecePages = (pieceStartPos, pieceEndPos, boundaryPositions, baseFromIdx, toIdx) => {
-	const actualStartIdx = findPageIndexForPosition(pieceStartPos, boundaryPositions, baseFromIdx);
-	const endPos = Math.max(pieceStartPos, pieceEndPos - 1);
-	return {
-		actualEndIdx: Math.min(findPageIndexForPosition(endPos, boundaryPositions, baseFromIdx), toIdx),
-		actualStartIdx
-	};
-};
-const computeNextFromIdx = (remainingContent, actualEndIdx, toIdx, pageIds, normalizedPages) => {
-	let nextFromIdx = actualEndIdx;
-	if (remainingContent && actualEndIdx + 1 <= toIdx) {
-		const nextPageData = normalizedPages.get(pageIds[actualEndIdx + 1]);
-		if (nextPageData) {
-			const nextPrefix = nextPageData.content.slice(0, 30);
-			const remainingPrefix = remainingContent.trimStart().slice(0, 30);
-			if (nextPrefix && (remainingContent.startsWith(nextPrefix) || nextPageData.content.startsWith(remainingPrefix))) nextFromIdx = actualEndIdx + 1;
-		}
-	}
-	return nextFromIdx;
-};
-const createPieceSegment = (pieceContent, actualStartIdx, actualEndIdx, pageIds, meta, includeMeta) => createSegment(pieceContent, pageIds[actualStartIdx], actualEndIdx > actualStartIdx ? pageIds[actualEndIdx] : void 0, includeMeta ? meta : void 0);
-/**
-* Finds the break offset within a window, trying exclusions first, then patterns.
-*
-* @returns Break offset relative to remainingContent, or windowEndPosition as fallback
-*/
-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 };
-	}
-	const patternMatch = findBreakPosition(remainingContent, currentFromIdx, toIdx, windowEndIdx, windowEndPosition, {
-		expandedBreakpoints,
-		normalizedPages,
-		pageIds,
-		prefer
-	}, maxContentLength);
-	if (patternMatch && patternMatch.breakPos > 0) return {
-		breakOffset: patternMatch.breakPos,
-		breakpointIndex: patternMatch.breakpointIndex,
-		breakpointRule: patternMatch.rule,
-		contentLengthSplit: patternMatch.contentLengthSplit,
-		wordIndex: patternMatch.wordIndex
-	};
-	if (windowEndPosition < remainingContent.length) {
-		const safeOffset = findSafeBreakPosition(remainingContent, windowEndPosition);
-		if (safeOffset !== -1) return {
-			breakOffset: safeOffset,
-			contentLengthSplit: maxContentLength ? {
-				maxContentLength,
-				reason: "whitespace"
-			} : void 0
-		};
-		return {
-			breakOffset: adjustForUnicodeBoundary(remainingContent, windowEndPosition),
-			contentLengthSplit: maxContentLength ? {
-				maxContentLength,
-				reason: "unicode_boundary"
-			} : void 0
-		};
-	}
-	return { breakOffset: windowEndPosition };
-};
-/**
-* Advances cursor position past any leading whitespace.
-*/
-const skipWhitespace = (content, startPos) => {
-	let pos = startPos;
-	while (pos < content.length && /\s/.test(content[pos])) pos++;
-	return pos;
-};
-/**
-* Validates that cumulative offsets match actual content length within a tolerance.
-* Required to detect if structural rules (like `lineStartsAfter`) have stripped content
-* which would make offset-based calculations inaccurate.
-*/
-const checkFastPathAlignment = (cumulativeOffsets, fullContent, fromIdx, toIdx, pageCount, logger) => {
-	const expectedLength = (cumulativeOffsets[toIdx + 1] ?? fullContent.length) - (cumulativeOffsets[fromIdx] ?? 0);
-	const driftTolerance = Math.max(100, fullContent.length * .01);
-	const isAligned = Math.abs(expectedLength - fullContent.length) <= driftTolerance;
-	if (!isAligned && pageCount >= 1e3) logger?.warn?.("[breakpoints] Offset drift detected in fast-path candidate, falling back to slow path", {
-		actualLength: fullContent.length,
-		drift: Math.abs(expectedLength - fullContent.length),
-		expectedLength,
-		pageCount
-	});
-	return isAligned;
-};
-/**
-* Handles the special optimized case for maxPages=0 (1 page per segment).
-* This is O(n) and safer than offset arithmetic as it uses source pages directly.
-*/
-const processTrivialFastPath = (fromIdx, toIdx, pageIds, normalizedPages, pageCount, originalMeta, debugMetaKey, logger) => {
-	logger?.debug?.("[breakpoints] Using trivial per-page fast-path (maxPages=0)", {
-		fromIdx,
-		pageCount,
-		toIdx
-	});
-	const result = [];
-	for (let i = fromIdx; i <= toIdx; i++) {
-		const pageData = normalizedPages.get(pageIds[i]);
-		if (pageData?.content.trim()) {
-			const meta = getSegmentMetaWithDebug(i === fromIdx, debugMetaKey, originalMeta, null);
-			const seg = createSegment(pageData.content.trim(), pageIds[i], void 0, meta);
-			if (seg) result.push(seg);
-		}
-	}
-	return result;
-};
-/**
-* Handles fast-path segmentation for maxPages > 0 using cumulative offsets.
-* Avoids O(n²) string searching but requires accurate offsets.
-*/
-const buildFastPathRawContent = (fullContent, baseOffset, cumulativeOffsets, segStart, segEnd, toIdx) => {
-	const startOffset = Math.max(0, (cumulativeOffsets[segStart] ?? 0) - baseOffset);
-	const endOffset = segEnd < toIdx ? Math.max(0, (cumulativeOffsets[segEnd + 1] ?? fullContent.length) - baseOffset) : fullContent.length;
-	return fullContent.slice(startOffset, endOffset).trim();
-};
-const buildFastPathSegment = (fullContent, baseOffset, cumulativeOffsets, segStart, segEnd, fromIdx, toIdx, pageIds, originalMeta, debugMetaKey) => {
-	const rawContent = buildFastPathRawContent(fullContent, baseOffset, cumulativeOffsets, segStart, segEnd, toIdx);
-	if (!rawContent) return null;
-	const meta = getSegmentMetaWithDebug(segStart === fromIdx, debugMetaKey, originalMeta, null);
-	const seg = {
-		content: rawContent,
-		from: pageIds[segStart]
-	};
-	if (segEnd > segStart) seg.to = pageIds[segEnd];
-	if (meta) seg.meta = meta;
-	return seg;
-};
-const processOffsetFastPath = (fullContent, fromIdx, toIdx, pageIds, cumulativeOffsets, maxPages, originalMeta, debugMetaKey, logger) => {
-	const result = [];
-	const pageCount = toIdx - fromIdx + 1;
-	logger?.debug?.("[breakpoints] Using offset-based fast-path for large segment", {
-		fromIdx,
-		maxPages,
-		pageCount,
-		toIdx
-	});
-	const baseOffset = cumulativeOffsets[fromIdx] ?? 0;
-	let segStart = fromIdx;
-	const needsPeel = (startIdx) => pageIds[toIdx] - pageIds[startIdx] > maxPages;
-	for (; segStart <= toIdx && needsPeel(segStart); segStart++) {
-		const seg = buildFastPathSegment(fullContent, baseOffset, cumulativeOffsets, segStart, segStart, fromIdx, toIdx, pageIds, originalMeta, debugMetaKey);
-		if (seg) result.push(seg);
-	}
-	if (segStart <= toIdx) {
-		const seg = buildFastPathSegment(fullContent, baseOffset, cumulativeOffsets, segStart, toIdx, fromIdx, toIdx, pageIds, originalMeta, debugMetaKey);
-		if (seg) result.push(seg);
-	}
-	return result;
-};
-/**
-* Checks if the remaining content fits within paged/length limits.
-* If so, pushes the final segment and returns true.
-*
-* @param actualRemainingEndIdx - The actual end page index of the remaining content
-*   (computed from boundaryPositions), NOT the original segment's toIdx. This is critical
-*   for maxPages=0 scenarios where remaining content may end before toIdx.
-*/
-const handleOversizedSegmentFit = (remainingContent, currentFromIdx, actualRemainingEndIdx, pageIds, expandedBreakpoints, maxPages, maxContentLength, isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint, result) => {
-	const remainingSpan = computeRemainingSpan(currentFromIdx, actualRemainingEndIdx, pageIds);
-	const remainingHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, actualRemainingEndIdx);
-	const fitsInPages = remainingSpan <= maxPages;
-	const fitsInLength = !maxContentLength || remainingContent.length <= maxContentLength;
-	if (fitsInPages && fitsInLength && !remainingHasExclusions) {
-		const includeMeta = isFirstPiece || Boolean(debugMetaKey);
-		const finalSeg = createFinalSegment(remainingContent, currentFromIdx, actualRemainingEndIdx, 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, contentLengthSplit) => {
-	if (!(isFirstPiece || Boolean(debugMetaKey))) return;
-	let meta = isFirstPiece ? originalMeta : void 0;
-	if (debugMetaKey) {
-		if (lastBreakpoint) meta = mergeDebugIntoMeta(meta, debugMetaKey, buildBreakpointDebugPatch(lastBreakpoint.breakpointIndex, lastBreakpoint.rule, lastBreakpoint.wordIndex));
-		if (contentLengthSplit) meta = mergeDebugIntoMeta(meta, debugMetaKey, { contentLengthSplit: {
-			maxContentLength: contentLengthSplit.maxContentLength,
-			splitReason: contentLengthSplit.reason
-		} });
-	}
-	return meta;
-};
-/**
-* Calculates window end position, capped by maxContentLength if present.
-*/
-const getWindowEndPosition = (remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, maxContentLength, logger) => {
-	const pos = findBreakpointWindowEndPosition(remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger);
-	return maxContentLength ? Math.min(pos, maxContentLength) : pos;
-};
-/**
-* Advances cursorPos and currentFromIdx for the next iteration.
-*/
-const advanceCursorAndIndex = (fullContent, breakPos, actualEndIdx, toIdx, pageIds, normalizedPages) => {
-	const nextCursorPos = skipWhitespace(fullContent, breakPos);
-	return {
-		currentFromIdx: computeNextFromIdx(fullContent.slice(nextCursorPos, nextCursorPos + 500), actualEndIdx, toIdx, pageIds, normalizedPages),
-		cursorPos: nextCursorPos
-	};
-};
-const computeIterationWindow = (fullContent, cursorPos, currentFromIdx, fromIdx, toIdx, pageIds, boundaryPositions, maxPages, maxContentLength) => {
-	const windowEndIdx = computeWindowEndIdx(currentFromIdx, toIdx, pageIds, maxPages);
-	const windowEndAbsPos = boundaryPositions[windowEndIdx - fromIdx + 1] ?? fullContent.length;
-	const sliceEndByPages = Math.min(fullContent.length, windowEndAbsPos + 4e3);
-	const sliceEndByLength = maxContentLength ? Math.min(fullContent.length, cursorPos + maxContentLength + 4e3) : fullContent.length;
-	const sliceEnd = Math.max(cursorPos + 1, Math.min(sliceEndByPages, sliceEndByLength));
-	return {
-		remainingContent: fullContent.slice(cursorPos, sliceEnd),
-		sliceEnd,
-		windowEndIdx
-	};
-};
-const computeWindowEndPositionForIteration = (remainingContent, cursorPos, currentFromIdx, fromIdx, windowEndIdx, toIdx, pageIds, boundaryPositions, normalizedPages, cumulativeOffsets, maxPages, maxContentLength, logger) => {
-	if (maxPages === 0) {
-		const nextPageStartPos = boundaryPositions[currentFromIdx - fromIdx + 1] ?? Number.POSITIVE_INFINITY;
-		const remainingInCurrentPage = Math.max(0, nextPageStartPos - cursorPos);
-		return Math.min(maxContentLength ? Math.min(remainingInCurrentPage, maxContentLength) : remainingInCurrentPage, remainingContent.length);
-	}
-	const pos = getWindowEndPosition(remainingContent, currentFromIdx, windowEndIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, maxContentLength, logger);
-	return Math.min(pos, remainingContent.length);
-};
-const ensureProgressingBreakOffset = (foundBreakOffset, remainingContent, cursorPos, maxContentLength, logger) => {
-	if (foundBreakOffset > 0) return foundBreakOffset;
-	const fallbackPos = maxContentLength ? Math.min(maxContentLength, remainingContent.length) : 1;
-	const breakOffset = Math.max(1, fallbackPos);
-	logger?.warn?.("[breakpoints] No progress from findBreakOffsetForWindow; forcing forward movement", {
-		breakOffset,
-		cursorPos
-	});
-	return breakOffset;
-};
-const updateLastBreakpointFromFound = (found, lastBreakpoint) => {
-	if (found.breakpointIndex !== void 0 && found.breakpointRule) return {
-		breakpointIndex: found.breakpointIndex,
-		rule: found.breakpointRule,
-		wordIndex: found.wordIndex
-	};
-	return lastBreakpoint;
-};
-const appendPieceAndAdvance = (fullContent, cursorPos, breakPos, pieceContent, currentFromIdx, fromIdx, toIdx, pageIds, boundaryPositions, normalizedPages, maxPages, isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint, result, logger, contentLengthSplit) => {
-	let { actualEndIdx, actualStartIdx } = computePiecePages(cursorPos, breakPos, boundaryPositions, fromIdx, toIdx);
-	if (actualStartIdx < currentFromIdx) {
-		logger?.warn?.("[breakpoints] Page attribution drift detected; clamping actualStartIdx", {
-			actualStartIdx,
-			currentFromIdx
-		});
-		actualStartIdx = currentFromIdx;
-	}
-	if (maxPages === 0) {
-		actualEndIdx = Math.min(actualEndIdx, currentFromIdx);
-		actualStartIdx = Math.min(actualStartIdx, currentFromIdx);
-	} else if (maxPages > 0) {
-		const maxAllowedEndIdx = computeWindowEndIdx(actualStartIdx, toIdx, pageIds, maxPages);
-		actualEndIdx = Math.min(actualEndIdx, maxAllowedEndIdx);
-	}
-	const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint, contentLengthSplit);
-	const pieceSeg = createPieceSegment(pieceContent, actualStartIdx, actualEndIdx, pageIds, meta, true);
-	if (pieceSeg) result.push(pieceSeg);
-	const next = advanceCursorAndIndex(fullContent, breakPos, actualEndIdx, toIdx, pageIds, normalizedPages);
-	let nextFromIdx = next.currentFromIdx;
-	if (maxPages === 0) nextFromIdx = findPageIndexForPosition(next.cursorPos, boundaryPositions, fromIdx);
-	return {
-		currentFromIdx: nextFromIdx,
-		cursorPos: next.cursorPos
-	};
-};
-const tryProcessOversizedSegmentFastPath = (segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, logger, debugMetaKey, maxContentLength) => {
-	const fullContent = segment.content;
-	const pageCount = toIdx - fromIdx + 1;
-	const isAligned = checkFastPathAlignment(cumulativeOffsets, fullContent, fromIdx, toIdx, pageCount, logger);
-	const isPageBoundaryOnly = expandedBreakpoints.every((bp) => bp.regex === null && bp.excludeSet.size === 0 && bp.skipWhenRegex === null);
-	if (pageCount < 1e3 || !isAligned || !isPageBoundaryOnly || maxContentLength || debugMetaKey) return null;
-	if (maxPages === 0) return processTrivialFastPath(fromIdx, toIdx, pageIds, normalizedPages, pageCount, segment.meta, debugMetaKey, logger);
-	return processOffsetFastPath(fullContent, fromIdx, toIdx, pageIds, cumulativeOffsets, maxPages, segment.meta, debugMetaKey, logger);
-};
-/**
-* For maxPages=0 with maxContentLength: if current page's remaining content fits,
-* create a segment and advance to next page without applying breakpoints.
-*/
-const tryHandleCurrentPageFit = (fullContent, cursorPos, currentFromIdx, fromIdx, actualRemainingEndIdx, boundaryPositions, pageIds, expandedBreakpoints, maxPages, maxContentLength, isFirstPiece, debugMetaKey, segmentMeta, lastBreakpoint, result) => {
-	if (maxPages !== 0 || !maxContentLength || currentFromIdx >= actualRemainingEndIdx) return { handled: false };
-	const currentPageEndPos = boundaryPositions[currentFromIdx - fromIdx + 1] ?? fullContent.length;
-	const currentPageRemainingContent = fullContent.slice(cursorPos, currentPageEndPos).trim();
-	if (!currentPageRemainingContent) return { handled: false };
-	const currentPageFitsInLength = currentPageRemainingContent.length <= maxContentLength;
-	const currentPageHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, currentFromIdx);
-	if (!currentPageFitsInLength || currentPageHasExclusions) return { handled: false };
-	const pageBoundaryIdx = expandedBreakpoints.findIndex((bp) => bp.regex === null);
-	const pageBoundaryBreakpoint = pageBoundaryIdx >= 0 ? {
-		breakpointIndex: pageBoundaryIdx,
-		rule: { pattern: "" }
-	} : lastBreakpoint;
-	const includeMeta = isFirstPiece || Boolean(debugMetaKey);
-	const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, segmentMeta, pageBoundaryBreakpoint);
-	const seg = createSegment(currentPageRemainingContent, pageIds[currentFromIdx], void 0, includeMeta ? meta : void 0);
-	if (seg) result.push(seg);
-	let newCursorPos = currentPageEndPos;
-	while (newCursorPos < fullContent.length && /\s/.test(fullContent[newCursorPos])) newCursorPos++;
-	return {
-		handled: true,
-		newCursorPos,
-		newFromIdx: currentFromIdx + 1,
-		newLastBreakpoint: pageBoundaryBreakpoint
-	};
-};
-const processOversizedSegmentIterative = (segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, prefer, logger, debugMetaKey, maxContentLength) => {
-	const result = [];
-	const fullContent = segment.content;
-	const pageCount = toIdx - fromIdx + 1;
-	logger?.debug?.("[breakpoints] processOversizedSegment: Using iterative path", {
-		contentLength: fullContent.length,
-		fromIdx,
-		maxContentLength,
-		maxPages,
-		pageCount,
-		toIdx
-	});
-	let cursorPos = 0;
-	let currentFromIdx = fromIdx;
-	let isFirstPiece = true;
-	let lastBreakpoint = null;
-	const boundaryPositions = buildBoundaryPositions(fullContent, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, logger);
-	logger?.debug?.("[breakpoints] boundaryPositions built", {
-		boundaryPositions,
-		fromIdx,
-		fullContentLength: fullContent.length,
-		toIdx
-	});
-	const MAX_SAFE_ITERATIONS = 1e5;
-	let didHitMaxIterations = true;
-	for (let i = 1; i <= MAX_SAFE_ITERATIONS; i++) {
-		if (cursorPos >= fullContent.length || currentFromIdx > toIdx) {
-			didHitMaxIterations = false;
-			break;
-		}
-		const { remainingContent, windowEndIdx } = computeIterationWindow(fullContent, cursorPos, currentFromIdx, fromIdx, toIdx, pageIds, boundaryPositions, maxPages, maxContentLength);
-		if (!remainingContent.trim()) {
-			didHitMaxIterations = false;
-			break;
-		}
-		const actualRemainingContent = fullContent.slice(cursorPos);
-		const actualEndPos = Math.max(cursorPos, fullContent.length - 1);
-		const actualRemainingEndIdx = Math.min(findPageIndexForPosition(actualEndPos, boundaryPositions, fromIdx), toIdx);
-		const currentPageFit = tryHandleCurrentPageFit(fullContent, cursorPos, currentFromIdx, fromIdx, actualRemainingEndIdx, boundaryPositions, pageIds, expandedBreakpoints, maxPages, maxContentLength, isFirstPiece, debugMetaKey, segment.meta, lastBreakpoint, result);
-		if (currentPageFit.handled) {
-			cursorPos = currentPageFit.newCursorPos;
-			currentFromIdx = currentPageFit.newFromIdx;
-			lastBreakpoint = currentPageFit.newLastBreakpoint;
-			isFirstPiece = false;
-			continue;
-		}
-		if (handleOversizedSegmentFit(actualRemainingContent, currentFromIdx, actualRemainingEndIdx, pageIds, expandedBreakpoints, maxPages, maxContentLength, isFirstPiece, debugMetaKey, segment.meta, lastBreakpoint, result)) {
-			didHitMaxIterations = false;
-			break;
-		}
-		const windowEndPosition = computeWindowEndPositionForIteration(remainingContent, cursorPos, currentFromIdx, fromIdx, windowEndIdx, toIdx, pageIds, boundaryPositions, normalizedPages, cumulativeOffsets, maxPages, maxContentLength, logger);
-		logger?.trace?.(`[breakpoints] iteration=${i}`, {
-			currentFromIdx,
-			cursorPos,
-			windowEndIdx,
-			windowEndPosition
-		});
-		const found = findBreakOffsetForWindow(remainingContent, currentFromIdx, windowEndIdx, toIdx, windowEndPosition, pageIds, expandedBreakpoints, cumulativeOffsets, normalizedPages, prefer, maxContentLength);
-		const breakOffset = ensureProgressingBreakOffset(found.breakOffset, remainingContent, cursorPos, maxContentLength, logger);
-		lastBreakpoint = updateLastBreakpointFromFound(found, lastBreakpoint);
-		const breakPos = cursorPos + breakOffset;
-		const pieceContent = fullContent.slice(cursorPos, breakPos).trim();
-		if (!pieceContent) {
-			cursorPos = breakPos;
-			isFirstPiece = false;
-			continue;
-		}
-		const next = appendPieceAndAdvance(fullContent, cursorPos, breakPos, pieceContent, currentFromIdx, fromIdx, toIdx, pageIds, boundaryPositions, normalizedPages, maxPages, isFirstPiece, debugMetaKey, segment.meta, lastBreakpoint, result, logger, found.contentLengthSplit);
-		cursorPos = next.cursorPos;
-		currentFromIdx = next.currentFromIdx;
-		isFirstPiece = false;
-	}
-	if (didHitMaxIterations) logger?.error?.("[breakpoints] Stopped processing oversized segment: reached MAX_SAFE_ITERATIONS", {
-		cursorPos,
-		fullContentLength: fullContent.length,
-		iterations: MAX_SAFE_ITERATIONS
-	});
-	logger?.debug?.("[breakpoints] processOversizedSegment: Complete", { resultCount: result.length });
-	return result;
-};
-/**
-* Applies breakpoints to oversized segments.
-*
-* Note: This is an internal engine used by `segmentPages()`.
-*/
-/**
-* Processes an oversized segment by iterating through the content and
-* breaking it into smaller pieces that fit within maxPages constraints.
-*
-* Uses precomputed boundary positions for O(log n) page attribution lookups.
-*/
-const processOversizedSegment = (segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, prefer, logger, debugMetaKey, maxContentLength) => {
-	const fast = tryProcessOversizedSegmentFastPath(segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, logger, debugMetaKey, maxContentLength);
-	if (fast) return fast;
-	return processOversizedSegmentIterative(segment, fromIdx, toIdx, pageIds, normalizedPages, cumulativeOffsets, expandedBreakpoints, maxPages, prefer, logger, debugMetaKey, maxContentLength);
-};
-const applyBreakpoints = (segments, pages, normalizedContent, maxPages, breakpoints, prefer, patternProcessor, logger, pageJoiner = "space", debugMetaKey, maxContentLength, rawPatternProcessor) => {
-	const pageIds = pages.map((p) => p.id);
-	const pageIdToIndex = buildPageIdToIndexMap(pageIds);
-	const normalizedPages = buildNormalizedPagesMap(pages, normalizedContent);
-	const cumulativeOffsets = buildCumulativeOffsets(pageIds, normalizedPages);
-	const expandedBreakpoints = expandBreakpoints(breakpoints, patternProcessor, rawPatternProcessor);
-	const result = [];
-	logger?.info?.("Starting breakpoint processing", {
-		maxPages,
-		segmentCount: segments.length
-	});
-	logger?.debug?.("[breakpoints] inputSegments", {
-		segmentCount: segments.length,
-		segments: segments.map((s) => ({
-			contentLength: s.content.length,
-			from: s.from,
-			to: s.to
-		}))
-	});
-	for (const segment of segments) {
-		const fromIdx = pageIdToIndex.get(segment.from) ?? -1;
-		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);
-		const fitsInPages = segmentSpan <= maxPages;
-		const fitsInLength = !maxContentLength || segment.content.length <= maxContentLength;
-		if (fitsInPages && fitsInLength && !hasExclusions) {
-			result.push(segment);
-			continue;
-		}
-		logger?.debug?.("[breakpoints] Processing oversized segment", {
-			contentLength: segment.content.length,
-			from: segment.from,
-			hasExclusions,
-			pageSpan: toIdx - fromIdx + 1,
-			reasonFitsInLength: fitsInLength,
-			reasonFitsInPages: fitsInPages,
-			to: segment.to
-		});
-		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;
-			if (segFromIdx >= 0 && segToIdx > segFromIdx) return {
-				...s,
-				content: applyPageJoinerBetweenPages(s.content, segFromIdx, segToIdx, pageIds, normalizedPages, pageJoiner)
-			};
-			return s;
-		}));
-	}
-	logger?.info?.("Breakpoint processing completed", { resultCount: result.length });
-	return result;
-};
-//#endregion
-//#region src/segmentation/rule-regex.ts
-/**
-* Checks if a regex pattern contains standard (anonymous) capturing groups.
-*
-* Detects standard capturing groups `(...)` while excluding:
-* - Non-capturing groups `(?:...)`
-* - Lookahead assertions `(?=...)` and `(?!...)`
-* - Lookbehind assertions `(?<=...)` and `(?<!...)`
-* - Named groups `(?<name>...)` (start with `(?` so excluded here)
-*
-* NOTE: Named capture groups are still captures, but they're tracked via `captureNames`.
-*/
-const hasCapturingGroup = (pattern) => /\((?!\?)/.test(pattern);
-/**
-* Extracts named capture group names from a regex pattern.
-*
-* Parses patterns like `(?<num>[0-9]+)` and returns `['num']`.
-*
-* @example
-* extractNamedCaptureNames('^(?<num>[٠-٩]+)\\s+') // ['num']
-* extractNamedCaptureNames('^(?<a>\\d+)(?<b>\\w+)') // ['a', 'b']
-* extractNamedCaptureNames('^\\d+') // []
-*/
-const extractNamedCaptureNames = (pattern) => [...pattern.matchAll(/\(\?<([A-Za-z_]\w*)>/g)].map((m) => m[1]).filter((n) => !n.startsWith("_r") && !n.startsWith("_w"));
-/**
-* Safely compiles a regex pattern, throwing a helpful error if invalid.
-*/
-const compileRuleRegex = (pattern) => {
-	try {
-		return new RegExp(pattern, "gmu");
-	} catch (error) {
-		throw new Error(`Invalid regex pattern: ${pattern}\n  Cause: ${error instanceof Error ? error.message : String(error)}`);
-	}
-};
-/**
-* Processes a pattern string by expanding tokens and optionally applying fuzzy matching.
-*
-* Brackets `()[]` outside `{{tokens}}` are auto-escaped.
-*/
-const processPattern = (pattern, fuzzy, capturePrefix) => {
-	const { pattern: expanded, captureNames } = expandTokensWithCaptures(escapeTemplateBrackets(pattern), fuzzy ? makeDiacriticInsensitive : void 0, capturePrefix);
-	return {
-		captureNames,
-		pattern: expanded
-	};
-};
-/**
-* Processes a breakpoint pattern by expanding tokens only.
-*
-* Unlike `processPattern`, this does NOT escape brackets because breakpoints
-* are treated as raw regex patterns (like the `regex` rule type).
-* Users have full control over regex syntax including `(?:...)` groups.
-*/
-const processBreakpointPattern = (pattern) => {
-	const { pattern: expanded } = expandTokensWithCaptures(pattern);
-	return expanded;
-};
-/**
-* Builds the raw regex source for a `lineStartsAfter` rule.
-*
-* Expands each pattern through `processPattern()`, combines them into an
-* alternation at the start of a line, and appends a trailing content capture.
-*
-* @param patterns - Template-like line-start markers to match
-* @param fuzzy - Whether Arabic fuzzy matching should be applied during expansion
-* @param capturePrefix - Optional prefix used for internal named captures
-* @returns Regex source plus the named captures extracted from the patterns
-*/
-const buildLineStartsAfterRegexSource = (patterns, fuzzy, capturePrefix) => {
-	const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));
-	const alternatives = processed.map((p, i) => `(?<_r${i}>${p.pattern})`).join("|");
-	return {
-		captureNames: processed.flatMap((p) => p.captureNames),
-		regex: `^[\\u200E\\u200F\\u061C\\u200B\\u200C\\u200D\\uFEFF]*(?:${alternatives})${capturePrefix ? `(?<${capturePrefix}__content>.*)` : "(.*)"}`
-	};
-};
-/**
-* Builds the raw regex source for a `lineStartsWith` rule.
-*
-* Expands each pattern through `processPattern()` and combines them into an
-* alternation anchored at the start of a line.
-*
-* @param patterns - Template-like line-start markers to match
-* @param fuzzy - Whether Arabic fuzzy matching should be applied during expansion
-* @param capturePrefix - Optional prefix used for internal named captures
-* @returns Regex source plus the named captures extracted from the patterns
-*/
-const buildLineStartsWithRegexSource = (patterns, fuzzy, capturePrefix) => {
-	const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));
-	const alternatives = processed.map((p, i) => `(?<_r${i}>${p.pattern})`).join("|");
-	return {
-		captureNames: processed.flatMap((p) => p.captureNames),
-		regex: `^[\\u200E\\u200F\\u061C\\u200B\\u200C\\u200D\\uFEFF]*(?:${alternatives})`
-	};
-};
-/**
-* Builds the raw regex source for a `lineEndsWith` rule.
-*
-* Expands each pattern through `processPattern()` and combines them into an
-* end-anchored alternation.
-*
-* @param patterns - Template-like line-end markers to match
-* @param fuzzy - Whether Arabic fuzzy matching should be applied during expansion
-* @param capturePrefix - Optional prefix used for internal named captures
-* @returns Regex source plus the named captures extracted from the patterns
-*/
-const buildLineEndsWithRegexSource = (patterns, fuzzy, capturePrefix) => {
-	const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));
-	const alternatives = processed.map((p, i) => `(?<_r${i}>${p.pattern})`).join("|");
-	return {
-		captureNames: processed.flatMap((p) => p.captureNames),
-		regex: `(?:${alternatives})$`
-	};
-};
-/**
-* Builds the raw regex source for a `template` rule.
-*
-* Expands tokens and named captures via `expandTokensWithCaptures()` after
-* applying `escapeTemplateBrackets()` to non-token brackets.
-*
-* @param template - Template string containing optional `{{token}}` markers
-* @param capturePrefix - Optional prefix used for internal named captures
-* @returns Regex source plus the named captures extracted from the template
-*/
-const buildTemplateRegexSource = (template, capturePrefix) => {
-	const { pattern, captureNames } = expandTokensWithCaptures(escapeTemplateBrackets(template), void 0, capturePrefix);
-	return {
-		captureNames,
-		regex: pattern
-	};
-};
-const getFuzzyCandidatePatterns = (rule) => [
-	..."lineStartsWith" in rule && Array.isArray(rule.lineStartsWith) ? rule.lineStartsWith : [],
-	..."lineStartsAfter" in rule && Array.isArray(rule.lineStartsAfter) ? rule.lineStartsAfter : [],
-	..."lineEndsWith" in rule && Array.isArray(rule.lineEndsWith) ? rule.lineEndsWith : []
-];
-const buildLineBasedRuleRegex = (rule, fuzzy, capturePrefix) => {
-	if ("lineStartsWith" in rule && Array.isArray(rule.lineStartsWith) && rule.lineStartsWith.length > 0) return buildLineStartsWithRegexSource(rule.lineStartsWith, fuzzy, capturePrefix);
-	if ("lineEndsWith" in rule && Array.isArray(rule.lineEndsWith) && rule.lineEndsWith.length > 0) return buildLineEndsWithRegexSource(rule.lineEndsWith, fuzzy, capturePrefix);
-	if ("template" in rule && typeof rule.template === "string") return buildTemplateRegexSource(rule.template, capturePrefix);
-	if ("dictionaryEntry" in rule && rule.dictionaryEntry) return buildArabicDictionaryEntryRegexSource(rule.dictionaryEntry, capturePrefix);
-	return null;
-};
-/**
-* Builds a compiled regex and metadata from a split rule.
-*
-* Behavior mirrors the previous implementation in `segmenter.ts`.
-*/
-const buildRuleRegex = (rule, capturePrefix) => {
-	const fuzzy = rule.fuzzy ?? shouldDefaultToFuzzy(getFuzzyCandidatePatterns(rule));
-	if ("lineStartsAfter" in rule && Array.isArray(rule.lineStartsAfter) && rule.lineStartsAfter.length > 0) {
-		const { regex: lsaRegex, captureNames } = buildLineStartsAfterRegexSource(rule.lineStartsAfter, fuzzy, capturePrefix);
-		return {
-			captureNames,
-			regex: compileRuleRegex(lsaRegex),
-			usesCapture: true,
-			usesLineStartsAfter: true
-		};
-	}
-	const ruleRegexSource = buildLineBasedRuleRegex(rule, fuzzy, capturePrefix);
-	let finalRegex = ruleRegexSource?.regex;
-	let allCaptureNames = ruleRegexSource?.captureNames ?? [];
-	if (!finalRegex && "regex" in rule && typeof rule.regex === "string") finalRegex = rule.regex;
-	if (!finalRegex) throw new Error("Rule must specify exactly one pattern type: regex, template, lineStartsWith, lineStartsAfter, lineEndsWith, or dictionaryEntry");
-	if (allCaptureNames.length === 0) allCaptureNames = extractNamedCaptureNames(finalRegex);
-	return {
-		captureNames: allCaptureNames,
-		regex: compileRuleRegex(finalRegex),
-		usesCapture: hasCapturingGroup(finalRegex),
-		usesLineStartsAfter: false
-	};
-};
-//#endregion
-//#region src/segmentation/fast-fuzzy-prefix.ts
-/**
-* Fast-path fuzzy prefix matching for common Arabic line-start markers.
-*
-* This exists to avoid running expensive fuzzy-expanded regex alternations over
-* a giant concatenated string. Instead, we match only at known line-start
-* offsets and perform a small deterministic comparison:
-* - Skip Arabic diacritics in the CONTENT
-* - Treat common equivalence groups as equal (ا/آ/أ/إ, ة/ه, ى/ي)
-*
-* This module is intentionally conservative: it only supports "literal"
-* token patterns (plain text alternation via `|`), not general regex.
-*/
-const isArabicDiacriticCode = (code) => code >= 1611 && code <= 1618;
-const equivKey = (ch) => {
-	switch (ch) {
-		case "آ":
-		case "أ":
-		case "إ": return "ا";
-		case "ه": return "ة";
-		case "ي": return "ى";
-		default: return ch;
-	}
-};
-const matchFuzzyLiteralPrefixAt = (content, offset, literal) => {
-	let i = offset;
-	while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) i++;
-	for (let j = 0; j < literal.length; j++) {
-		const litCh = literal[j];
-		while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) i++;
-		if (i >= content.length || equivKey(content[i]) !== equivKey(litCh)) return null;
-		i++;
-	}
-	while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) i++;
-	return i;
-};
-const isLiteralOnly = (s) => !/[\\[\]{}()^$.*+?]/.test(s);
-const compileLiteralAlternation = (pattern) => {
-	if (!pattern || !isLiteralOnly(pattern)) return null;
-	const alternatives = pattern.split("|").map((s) => s.trim()).filter(Boolean);
-	return alternatives.length ? { alternatives } : null;
-};
-const compileFastFuzzyTokenRule = (tokenTemplate) => {
-	const m = tokenTemplate.match(/^\{\{(\w+)\}\}$/);
-	if (!m) return null;
-	const token = m[1];
-	if (!(token in TOKEN_PATTERNS)) return null;
-	const compiled = compileLiteralAlternation(getTokenPattern(token));
-	return compiled ? {
-		alternatives: compiled.alternatives,
-		token
-	} : null;
-};
-const matchFastFuzzyTokenAt = (content, offset, compiled) => {
-	for (const alt of compiled.alternatives) {
-		const end = matchFuzzyLiteralPrefixAt(content, offset, alt);
-		if (end !== null) return end;
-	}
-	return null;
-};
-//#endregion
-//#region src/segmentation/segmenter-rule-utils.ts
-const tryCompileFastFuzzyRule = (rule) => {
-	const fuzzyCandidatePatterns = [..."lineStartsWith" in rule ? rule.lineStartsWith : [], ..."lineStartsAfter" in rule ? rule.lineStartsAfter : []];
-	if (!(rule.fuzzy ?? shouldDefaultToFuzzy(fuzzyCandidatePatterns))) return null;
-	if ("lineStartsWith" in rule && rule.lineStartsWith?.length === 1) {
-		const compiled = compileFastFuzzyTokenRule(rule.lineStartsWith[0]);
-		if (compiled) return {
-			compiled,
-			kind: "startsWith"
-		};
-	}
-	if ("lineStartsAfter" in rule && rule.lineStartsAfter?.length === 1) {
-		const compiled = compileFastFuzzyTokenRule(rule.lineStartsAfter[0]);
-		if (compiled) return {
-			compiled,
-			kind: "startsAfter"
-		};
-	}
-	return null;
-};
-const isCombinableRule = (rule) => {
-	if ("regex" in rule && rule.regex) return extractNamedCaptureNames(rule.regex).length === 0 && !/\\[1-9]/.test(rule.regex) && !hasCapturingGroup(rule.regex);
-	return true;
-};
-const partitionRulesForMatching = (rules) => {
-	const combinableRules = [];
-	const standaloneRules = [];
-	const fastFuzzyRules = [];
-	for (let index = 0; index < rules.length; index++) {
-		const rule = rules[index];
-		const fuzzyComp = tryCompileFastFuzzyRule(rule);
-		if (fuzzyComp) {
-			fastFuzzyRules.push({
-				compiled: fuzzyComp.compiled,
-				kind: fuzzyComp.kind,
-				rule,
-				ruleIndex: index
-			});
-			continue;
-		}
-		if (isCombinableRule(rule)) combinableRules.push({
-			index,
-			prefix: `r${index}_`,
-			rule
-		});
-		else standaloneRules.push({
-			index,
-			rule
-		});
-	}
-	return {
-		combinableRules,
-		fastFuzzyRules,
-		standaloneRules
-	};
-};
-const STRONG_SENTENCE_TERMINATORS = /[.!?؟؛۔…]$/u;
-const TRAILING_PAGE_WRAP_NOISE = /[\s\u0660-\u0669\d«»"“”'‘’()[\]{}<>]+$/u;
-const TRAILING_WORD_DELIMITERS = /[\s\u0660-\u0669\d«»"“”'‘’()[\]{}<>.,!?؟؛،:]+$/u;
-const ARABIC_WORD_REGEX = new RegExp(ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN, "gu");
-const trimTrailingPageWrapNoise = (text) => {
-	let trimmed = text.trimEnd();
-	while (trimmed !== trimmed.replace(TRAILING_PAGE_WRAP_NOISE, "")) trimmed = trimmed.replace(TRAILING_PAGE_WRAP_NOISE, "");
-	return trimmed;
-};
-const endsWithStrongSentenceTerminator = (pageContent) => {
-	return STRONG_SENTENCE_TERMINATORS.test(trimTrailingPageWrapNoise(pageContent));
-};
-const extractLastArabicWord = (pageContent) => {
-	return [...trimTrailingPageWrapNoise(pageContent).replace(TRAILING_WORD_DELIMITERS, "").matchAll(ARABIC_WORD_REGEX)].at(-1)?.[0] ?? "";
-};
-const shouldAllowPageStartMatch = (previousPageContent, prevWordStoplist) => {
-	if (!prevWordStoplist || endsWithStrongSentenceTerminator(previousPageContent)) return true;
-	const lastWord = extractLastArabicWord(previousPageContent);
-	return !lastWord || !prevWordStoplist.has(normalizeArabicForComparison(lastWord));
-};
-const shouldAllowSamePageMatch = (contentBeforeMatch, stoplist) => {
-	if (!stoplist) return true;
-	const lastWord = extractLastArabicWord(contentBeforeMatch);
-	return !lastWord || !stoplist.has(normalizeArabicForComparison(lastWord));
-};
-const createPageStartGuardChecker = (matchContent, pageMap) => {
-	const pageStartToBoundaryIndex = new Map(pageMap.boundaries.map((b, i) => [b.start, i]));
-	const compiledPageStartPrev = /* @__PURE__ */ new Map();
-	const compiledPrevWordStoplists = /* @__PURE__ */ new Map();
-	const compiledSamePagePrevWordStoplists = /* @__PURE__ */ new Map();
-	const pageIdToBoundaryIndex = new Map(pageMap.boundaries.map((b, i) => [b.id, i]));
-	const getPageStartPrevRegex = (rule, ruleIndex) => {
-		if (compiledPageStartPrev.has(ruleIndex)) return compiledPageStartPrev.get(ruleIndex) ?? null;
-		const pattern = rule.pageStartGuard;
-		if (!pattern) {
-			compiledPageStartPrev.set(ruleIndex, null);
-			return null;
-		}
-		const re = new RegExp(`(?:${processPattern(pattern, false).pattern})$`, "u");
-		compiledPageStartPrev.set(ruleIndex, re);
-		return re;
-	};
-	const getPrevWordStoplist = (rule, ruleIndex) => {
-		if (compiledPrevWordStoplists.has(ruleIndex)) return compiledPrevWordStoplists.get(ruleIndex) ?? null;
-		const stoplist = rule.pageStartPrevWordStoplist;
-		if (!stoplist?.length) {
-			compiledPrevWordStoplists.set(ruleIndex, null);
-			return null;
-		}
-		const normalized = new Set(stoplist.map((word) => normalizeArabicForComparison(word)).filter(Boolean));
-		compiledPrevWordStoplists.set(ruleIndex, normalized);
-		return normalized;
-	};
-	const getSamePagePrevWordStoplist = (rule, ruleIndex) => {
-		if (compiledSamePagePrevWordStoplists.has(ruleIndex)) return compiledSamePagePrevWordStoplists.get(ruleIndex) ?? null;
-		const stoplist = rule.samePagePrevWordStoplist;
-		if (!stoplist?.length) {
-			compiledSamePagePrevWordStoplists.set(ruleIndex, null);
-			return null;
-		}
-		const normalized = new Set(stoplist.map((word) => normalizeArabicForComparison(word)).filter(Boolean));
-		compiledSamePagePrevWordStoplists.set(ruleIndex, normalized);
-		return normalized;
-	};
-	const getPreviousPageContent = (boundaryIndex) => {
-		if (boundaryIndex <= 0) return "";
-		const prevBoundary = pageMap.boundaries[boundaryIndex - 1];
-		return matchContent.slice(prevBoundary.start, prevBoundary.end);
-	};
-	const getPrevPageLastNonWsChar = (boundaryIndex) => {
-		if (boundaryIndex <= 0) return "";
-		const prevBoundary = pageMap.boundaries[boundaryIndex - 1];
-		for (let i = prevBoundary.end - 1; i >= prevBoundary.start; i--) {
-			const ch = matchContent[i];
-			if (ch && !/\s/u.test(ch)) return ch;
-		}
-		return "";
-	};
-	const getCurrentPageContentBeforeMatch = (matchStart) => {
-		const pageId = pageMap.getId(matchStart);
-		const boundaryIndex = pageIdToBoundaryIndex.get(pageId);
-		if (boundaryIndex === void 0) return "";
-		const boundary = pageMap.boundaries[boundaryIndex];
-		return matchContent.slice(boundary.start, matchStart);
-	};
-	return (rule, ruleIndex, matchStart) => {
-		const boundaryIndex = pageStartToBoundaryIndex.get(matchStart);
-		if (boundaryIndex !== void 0 && boundaryIndex !== 0) {
-			const prevReq = getPageStartPrevRegex(rule, ruleIndex);
-			if (prevReq) {
-				const lastChar = getPrevPageLastNonWsChar(boundaryIndex);
-				if (!lastChar || !prevReq.test(lastChar)) return false;
-			}
-			return shouldAllowPageStartMatch(getPreviousPageContent(boundaryIndex), getPrevWordStoplist(rule, ruleIndex));
-		}
-		return shouldAllowSamePageMatch(getCurrentPageContentBeforeMatch(matchStart), getSamePagePrevWordStoplist(rule, ruleIndex));
-	};
-};
-/**
-* Checks if a pageId matches the min/max/exclude constraints of a rule.
-*/
-const passesRuleConstraints$1 = (rule, pageId) => (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]);
-	else arr.push(sp);
-};
-const attemptFastFuzzyMatch = (matchContent, lineStart, { compiled, kind, rule, ruleIndex }, splitPointsByRule) => {
-	const end = matchFastFuzzyTokenAt(matchContent, lineStart, compiled);
-	if (end === null) return;
-	const splitAt = rule.split ?? "at";
-	const splitIndex = splitAt === "at" ? lineStart : end;
-	if (kind === "startsWith") recordSplitPointAt(splitPointsByRule, ruleIndex, {
-		index: splitIndex,
-		meta: rule.meta
-	});
-	else {
-		const markerLength = end - lineStart;
-		recordSplitPointAt(splitPointsByRule, ruleIndex, {
-			contentStartOffset: splitAt === "at" ? markerLength : void 0,
-			index: splitIndex,
-			meta: rule.meta
-		});
-	}
-};
-/**
-* Processes matches for all fast-fuzzy rules at a specific line start.
-*/
-const processFastFuzzyMatchesAt = (matchContent, lineStart, pageId, fastFuzzyRules, passesPageStartGuard, splitPointsByRule) => {
-	for (const ffRule of fastFuzzyRules) {
-		if (!passesRuleConstraints$1(ffRule.rule, pageId)) continue;
-		if (!passesPageStartGuard(ffRule.rule, ffRule.ruleIndex, lineStart)) continue;
-		attemptFastFuzzyMatch(matchContent, lineStart, ffRule, splitPointsByRule);
-	}
-};
-const collectFastFuzzySplitPoints = (matchContent, pageMap, fastFuzzyRules, passesPageStartGuard) => {
-	const splitPointsByRule = /* @__PURE__ */ new Map();
-	if (fastFuzzyRules.length === 0 || pageMap.boundaries.length === 0) return splitPointsByRule;
-	let boundaryIdx = 0;
-	let currentBoundary = pageMap.boundaries[boundaryIdx];
-	const advanceBoundaryTo = (offset) => {
-		while (currentBoundary && offset > currentBoundary.end && boundaryIdx < pageMap.boundaries.length - 1) {
-			boundaryIdx++;
-			currentBoundary = pageMap.boundaries[boundaryIdx];
-		}
-	};
-	for (let lineStart = 0; lineStart <= matchContent.length;) {
-		advanceBoundaryTo(lineStart);
-		const pageId = currentBoundary?.id ?? 0;
-		if (lineStart >= matchContent.length) break;
-		processFastFuzzyMatchesAt(matchContent, lineStart, pageId, fastFuzzyRules, passesPageStartGuard, splitPointsByRule);
-		const nextNl = matchContent.indexOf("\n", lineStart);
-		if (nextNl === -1) break;
-		lineStart = nextNl + 1;
-	}
-	return splitPointsByRule;
-};
-//#endregion
-//#region src/segmentation/split-point-helpers.ts
-const MAX_REGEX_ITERATIONS = 1e5;
-const extractNamedCapturesForRule = (groups, captureNames, prefix) => {
-	const result = {};
-	if (!groups) return result;
-	for (const name of captureNames) if (groups[name] !== void 0) result[name.slice(prefix.length)] = groups[name];
-	return result;
-};
-const buildContentOffsets = (match, ruleInfo) => {
-	if (!ruleInfo.usesLineStartsAfter) return {};
-	const captured = match.groups?.[`${ruleInfo.prefix}__content`];
-	if (captured === void 0) return {};
-	return { contentStartOffset: (match.groups?.[ruleInfo.prefix] ?? match[0]).length - captured.length };
-};
-const passesRuleConstraints = (rule, pageId) => (rule.min === void 0 || pageId >= rule.min) && (rule.max === void 0 || pageId <= rule.max) && !isPageExcluded(pageId, rule.exclude);
-const createSplitPointFromMatch = (match, rule, ruleInfo) => {
-	const namedCaptures = extractNamedCapturesForRule(match.groups, ruleInfo.captureNames, ruleInfo.prefix);
-	const wordIndex = extractDebugIndex(match.groups, "_r");
-	return {
-		capturedContent: void 0,
-		contentStartOffset: buildContentOffsets(match, ruleInfo).contentStartOffset,
-		index: (rule.split ?? "at") === "at" ? match.index : match.index + match[0].length,
-		meta: rule.meta,
-		namedCaptures: Object.keys(namedCaptures).length > 0 ? namedCaptures : void 0,
-		wordIndex
-	};
-};
-const addSplitPoint = (splitPointsByRule, originalIndex, point) => {
-	const arr = splitPointsByRule.get(originalIndex);
-	if (!arr) {
-		splitPointsByRule.set(originalIndex, [point]);
-		return;
-	}
-	arr.push(point);
-};
-/**
-* Executes a combined regex over the content for combinable rules and records
-* any resulting split points into `splitPointsByRule`.
-*
-* This function mutates `splitPointsByRule` in place and throws if the regex
-* iteration guard is exceeded.
-*
-* @param matchContent - Concatenated content being segmented
-* @param combinableRules - Rules that can be combined into a single alternation
-* @param ruleRegexes - Compiled regex metadata aligned with `combinableRules`
-* @param pageMap - Page boundary mapping utilities for the content
-* @param passesPageStartGuard - Callback that decides whether a match is allowed
-* @param splitPointsByRule - Mutable map collecting split points by rule index
-* @param logger - Optional logger for iteration diagnostics
-* @returns Nothing; results are written into `splitPointsByRule`
-*/
-const processCombinedMatches = (matchContent, combinableRules, ruleRegexes, pageMap, passesPageStartGuard, splitPointsByRule, logger) => {
-	assertCombinedRuleAlignment(combinableRules, ruleRegexes);
-	const combinedSource = ruleRegexes.map((r) => r.source).join("|");
-	const combinedRegex = new RegExp(combinedSource, "gm");
-	logger?.debug?.("[segmenter] combined regex built", {
-		combinableRuleCount: combinableRules.length,
-		combinedSourceLength: combinedSource.length
-	});
-	let m = combinedRegex.exec(matchContent);
-	let iterations = 0;
-	while (m !== null) {
-		if (++iterations > MAX_REGEX_ITERATIONS) throw new Error(`[segmenter] Possible infinite loop: exceeded ${MAX_REGEX_ITERATIONS} iterations at position ${m.index}.`);
-		if (iterations % 1e4 === 0) logger?.warn?.("[segmenter] high iteration count", {
-			iterations,
-			position: m.index
-		});
-		processCombinedMatch(combinableRules, ruleRegexes, pageMap, passesPageStartGuard, splitPointsByRule, m);
-		if (m[0].length === 0) combinedRegex.lastIndex++;
-		m = combinedRegex.exec(matchContent);
-	}
-};
-const assertCombinedRuleAlignment = (combinableRules, ruleRegexes) => {
-	if (combinableRules.length !== ruleRegexes.length) throw new Error(`processCombinedMatches: combinableRules/ruleRegexes length mismatch (${combinableRules.length} !== ${ruleRegexes.length})`);
-	for (let i = 0; i < combinableRules.length; i++) if (!ruleRegexes[i].source.includes(`(?<${combinableRules[i].prefix}>`)) throw new Error(`processCombinedMatches: regex alignment mismatch for prefix "${combinableRules[i].prefix}" at index ${i}`);
-};
-const processCombinedMatch = (combinableRules, ruleRegexes, pageMap, passesPageStartGuard, splitPointsByRule, match) => {
-	const matchedIndex = combinableRules.findIndex(({ prefix }) => match.groups?.[prefix] !== void 0);
-	if (matchedIndex === -1) return;
-	const { rule, index: originalIndex } = combinableRules[matchedIndex];
-	if (!passesRuleConstraints(rule, pageMap.getId(match.index)) || !passesPageStartGuard(rule, originalIndex, match.index)) return;
-	addSplitPoint(splitPointsByRule, originalIndex, createSplitPointFromMatch(match, rule, ruleRegexes[matchedIndex]));
-};
-/**
-* Builds compiled regex metadata for each combinable rule while preserving the
-* prefix used to identify the matching branch inside a combined alternation.
-*
-* @param combinableRules - Rules eligible for combined-regex processing
-* @returns Rule regex metadata aligned with the input order
-*/
-const buildRuleRegexes = (combinableRules) => combinableRules.map(({ rule, prefix }) => {
-	const built = buildRuleRegex(rule, prefix);
-	return {
-		...built,
-		prefix,
-		source: `(?<${prefix}>${built.regex.source})`
-	};
-});
-/**
-* Processes a standalone rule by matching it independently and appending its
-* resulting split points into `splitPointsByRule`.
-*
-* @param rule - The standalone split rule to evaluate
-* @param ruleIndex - Original rule index in the caller's rules array
-* @param matchContent - Concatenated content being segmented
-* @param pageMap - Page boundary mapping utilities for the content
-* @param passesPageStartGuard - Callback that decides whether a match is allowed
-* @param splitPointsByRule - Mutable map collecting split points by rule index
-* @returns Nothing; results are written into `splitPointsByRule`
-*/
-const processStandaloneRule = (rule, ruleIndex, matchContent, pageMap, passesPageStartGuard, splitPointsByRule) => {
-	const { regex, usesCapture, captureNames, usesLineStartsAfter } = buildRuleRegex(rule);
-	const points = filterByConstraints(findMatchesInContent(matchContent, regex, usesCapture, captureNames), rule, pageMap.getId).filter((m) => passesPageStartGuard(rule, ruleIndex, m.start)).map((m) => {
-		const isLSA = usesLineStartsAfter && m.captured !== void 0;
-		return {
-			capturedContent: isLSA ? void 0 : m.captured,
-			contentStartOffset: isLSA ? m.end - m.captured.length - m.start : void 0,
-			index: (rule.split ?? "at") === "at" ? m.start : m.end,
-			meta: rule.meta,
-			namedCaptures: m.namedCaptures,
-			wordIndex: m.wordIndex
-		};
-	});
-	const arr = splitPointsByRule.get(ruleIndex);
-	if (!arr) splitPointsByRule.set(ruleIndex, points);
-	else arr.push(...points);
-};
-const findMatchesInContent = (content, regex, usesCapture, captureNames) => {
-	const matches = [];
-	let m = regex.exec(content);
-	while (m !== null) {
-		const wordIndex = extractDebugIndex(m.groups, "_r");
-		matches.push({
-			captured: usesCapture ? getLastPositionalCapture(m) : void 0,
-			end: m.index + m[0].length,
-			namedCaptures: extractNamedCaptures(m.groups, captureNames),
-			start: m.index,
-			wordIndex
-		});
-		if (m[0].length === 0) regex.lastIndex++;
-		m = regex.exec(content);
-	}
-	return matches;
-};
-/**
-* Applies per-rule occurrence filtering and optional debug metadata patches to
-* the collected split points.
-*
-* @param rules - Full rule list in original order
-* @param splitPointsByRule - Split points grouped by originating rule index
-* @param debugMetaKey - Optional metadata key used for debug provenance patches
-* @returns Flattened split points after occurrence filtering and debug merging
-*/
-const applyOccurrenceFilter = (rules, splitPointsByRule, debugMetaKey) => {
-	const result = [];
-	rules.forEach((rule, index) => {
-		const points = splitPointsByRule.get(index);
-		if (!points?.length) return;
-		const filtered = rule.occurrence === "first" ? [points[0]] : rule.occurrence === "last" ? [points.at(-1)] : points;
-		result.push(...filtered.map((p) => {
-			const debugPatch = debugMetaKey ? buildRuleDebugPatch(index, rule, p.wordIndex) : null;
-			return {
-				...p,
-				meta: debugMetaKey ? mergeDebugIntoMeta(p.meta, debugMetaKey, debugPatch) : p.meta,
-				ruleIndex: index
-			};
-		}));
-	});
-	return result;
-};
-//#endregion
-//#region src/segmentation/segmenter.ts
-/**
-* Builds a concatenated content string and page mapping from input pages.
-*
-* Pages are joined with newline characters, and a page map is created to
-* track which page each offset belongs to. This allows pattern matching
-* across page boundaries while preserving page reference information.
-*
-* @param pages - Array of input pages with id and content
-* @returns Concatenated content string and page mapping utilities
-*
-* @example
-* const pages = [
-*   { id: 1, content: 'Page 1 text' },
-*   { id: 2, content: 'Page 2 text' }
-* ];
-* const { content, pageMap } = buildPageMap(pages);
-* // content = 'Page 1 text\nPage 2 text'
-* // pageMap.getId(0) = 1
-* // pageMap.getId(12) = 2
-*/
-const buildPageMap = (pages) => {
-	const boundaries = [];
-	const pageBreaks = [];
-	let offset = 0;
-	const parts = [];
-	for (let i = 0; i < pages.length; i++) {
-		const normalized = normalizeLineEndings(pages[i].content);
-		boundaries.push({
-			end: offset + normalized.length,
-			id: pages[i].id,
-			start: offset
-		});
-		parts.push(normalized);
-		if (i < pages.length - 1) {
-			pageBreaks.push(offset + normalized.length);
-			offset += normalized.length + 1;
-		} else offset += normalized.length;
-	}
-	const findBoundary = (off) => {
-		let lo = 0, hi = boundaries.length - 1;
-		while (lo <= hi) {
-			const mid = lo + hi >>> 1;
-			const b = boundaries[mid];
-			if (off < b.start) hi = mid - 1;
-			else if (off > b.end) lo = mid + 1;
-			else return b;
-		}
-		return boundaries.at(-1);
-	};
-	return {
-		content: parts.join("\n"),
-		normalizedPages: parts,
-		pageMap: {
-			boundaries,
-			getId: (off) => findBoundary(off)?.id ?? 0,
-			pageBreaks,
-			pageIds: boundaries.map((b) => b.id)
-		}
-	};
-};
-/**
-* Deduplicate split points by index, preferring ones with more information.
-*
-* Preference rules (when same index):
-* - Prefer a split with `contentStartOffset` (needed for `lineStartsAfter` marker stripping)
-* - Otherwise prefer a split with `meta` over one without
-*/
-const dedupeSplitPoints = (splitPoints) => {
-	const byIndex = /* @__PURE__ */ new Map();
-	for (const p of splitPoints) {
-		const existing = byIndex.get(p.index);
-		if (!existing) {
-			byIndex.set(p.index, p);
-			continue;
-		}
-		byIndex.set(p.index, mergeSplitPoints(existing, p));
-	}
-	return [...byIndex.values()].sort((a, b) => a.index - b.index);
-};
-const prefersIncomingSplitPoint = (existing, incoming) => incoming.contentStartOffset !== void 0 && existing.contentStartOffset === void 0 || incoming.meta !== void 0 && existing.meta === void 0;
-const mergeRecord = (existing, incoming) => existing || incoming ? {
-	...existing ?? {},
-	...incoming ?? {}
-} : void 0;
-const mergeSplitPoints = (existing, incoming) => {
-	const preferred = prefersIncomingSplitPoint(existing, incoming) ? incoming : existing;
-	const fallback = preferred === incoming ? existing : incoming;
-	return {
-		...fallback,
-		...preferred,
-		contentStartOffset: preferred.contentStartOffset ?? fallback.contentStartOffset,
-		meta: mergeRecord(existing.meta, incoming.meta),
-		namedCaptures: mergeRecord(existing.namedCaptures, incoming.namedCaptures)
-	};
-};
-/**
-* If no structural rules produced segments, create a single segment spanning all pages.
-* This allows breakpoint processing to still run.
-*/
-const ensureFallbackSegment = (segments, pages, normalizedContent, pageJoiner) => {
-	if (segments.length > 0 || pages.length === 0) return segments;
-	const firstPage = pages[0];
-	const lastPage = pages.at(-1);
-	const joiner = pageJoiner === "newline" ? "\n" : " ";
-	const allContent = normalizedContent.join(joiner).replace(/\s+$/u, "");
-	if (!allContent.trim()) return segments;
-	const initialSeg = {
-		content: allContent,
-		from: firstPage.id
-	};
-	if (lastPage.id !== firstPage.id) initialSeg.to = lastPage.id;
-	return [initialSeg];
-};
-const collectSplitPointsFromRules = (rules, matchContent, pageMap, debugMetaKey, logger) => {
-	logger?.debug?.("[segmenter] collecting split points from rules", {
-		contentLength: matchContent.length,
-		ruleCount: rules.length
-	});
-	const passesPageStartGuard = createPageStartGuardChecker(matchContent, pageMap);
-	const { combinableRules, fastFuzzyRules, standaloneRules } = partitionRulesForMatching(rules);
-	logger?.debug?.("[segmenter] rules partitioned", {
-		combinableCount: combinableRules.length,
-		fastFuzzyCount: fastFuzzyRules.length,
-		standaloneCount: standaloneRules.length
-	});
-	const splitPointsByRule = collectFastFuzzySplitPoints(matchContent, pageMap, fastFuzzyRules, passesPageStartGuard);
-	if (combinableRules.length > 0) processCombinedMatches(matchContent, combinableRules, buildRuleRegexes(combinableRules), pageMap, passesPageStartGuard, splitPointsByRule, logger);
-	for (const { rule, index } of standaloneRules) processStandaloneRule(rule, index, matchContent, pageMap, passesPageStartGuard, splitPointsByRule);
-	return applyOccurrenceFilter(rules, splitPointsByRule, debugMetaKey);
-};
-/**
-* Finds page breaks within a given offset range using binary search.
-* O(log n + k) where n = total breaks, k = breaks in range.
-*
-* @param startOffset - Start of range (inclusive)
-* @param endOffset - End of range (exclusive)
-* @param sortedBreaks - Sorted array of page break offsets
-* @returns Array of break offsets relative to startOffset
-*/
-const findBreaksInRange = (startOffset, endOffset, sortedBreaks) => {
-	if (sortedBreaks.length === 0) return [];
-	let lo = 0, hi = sortedBreaks.length;
-	while (lo < hi) {
-		const mid = lo + hi >>> 1;
-		if (sortedBreaks[mid] < startOffset) lo = mid + 1;
-		else hi = mid;
-	}
-	const result = [];
-	for (let i = lo; i < sortedBreaks.length && sortedBreaks[i] < endOffset; i++) result.push(sortedBreaks[i] - startOffset);
-	return result;
-};
-/**
-* Converts page-break newlines to spaces in segment content.
-*
-* When a segment spans multiple pages, the newline characters that were
-* inserted as page separators during concatenation are converted to spaces
-* for more natural reading.
-*
-* Uses binary search for O(log n + k) lookup instead of O(n) iteration.
-*
-* @param content - Segment content string
-* @param startOffset - Starting offset of this content in concatenated string
-* @param pageBreaks - Sorted array of page break offsets
-* @param pageJoiner - How to represent page boundaries in output (`space` vs `newline`)
-* @returns Content with page-break newlines converted to spaces (or left as-is for `newline`)
-*/
-const convertPageBreaks = (content, startOffset, pageBreaks, pageJoiner) => {
-	if (!content?.includes("\n")) return content;
-	if (pageJoiner === "newline") return content;
-	const breaksInRange = findBreaksInRange(startOffset, startOffset + content.length, pageBreaks);
-	if (breaksInRange.length === 0) return content;
-	const breakSet = new Set(breaksInRange);
-	return content.replace(/\n/g, (match, offset) => breakSet.has(offset) ? " " : match);
-};
-/**
-* Segments pages of content based on pattern-matching rules.
-*
-* This is the main entry point for the segmentation engine. It takes an array
-* of pages and applies the provided rules to identify split points, producing
-* an array of segments with content, page references, and metadata.
-*
-* @param pages - Array of pages with id and content
-* @param options - Segmentation options including splitting rules
-* @returns Array of segments with content, from/to page references, and optional metadata
-*
-* @example
-* // Split markdown by headers
-* const segments = segmentPages(pages, {
-*   rules: [
-*     { lineStartsWith: ['## '], split: 'at', meta: { type: 'chapter' } }
-*   ]
-* });
-*
-* @example
-* // Split Arabic hadith text with number extraction
-* const segments = segmentPages(pages, {
-*   rules: [
-*     {
-*       lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '],
-*       split: 'at',
-*       fuzzy: true,
-*       meta: { type: 'hadith' }
-*     }
-*   ]
-* });
-*
-* @example
-* // Multiple rules with page constraints
-* const segments = segmentPages(pages, {
-*   rules: [
-*     { lineStartsWith: ['{{kitab}}'], split: 'at', meta: { type: 'book' } },
-*     { lineStartsWith: ['{{bab}}'], split: 'at', min: 10, meta: { type: 'chapter' } },
-*     { regex: '^[٠-٩]+ - ', split: 'at', meta: { type: 'hadith' } }
-*   ]
-* });
-*/
-const segmentPages = (pages, options) => {
-	const { rules = [], breakpoints = [], prefer = "longer", pageJoiner = "space", logger, maxContentLength, preprocess } = options;
-	if (maxContentLength && maxContentLength < 50) throw new Error(`maxContentLength must be at least 50 characters.`);
-	const maxPages = options.maxPages ?? Number.MAX_SAFE_INTEGER;
-	const hasLimits = options.maxPages !== void 0 || maxContentLength !== void 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,
-		preprocessCount: preprocess?.length ?? 0,
-		ruleCount: rules.length
-	});
-	const preprocessedPages = preprocess && preprocess.length > 0 ? pages.map((page) => ({
-		...page,
-		content: applyPreprocessToPage(page.content, page.id, preprocess)
-	})) : pages;
-	const { content: matchContent, normalizedPages: normalizedContent, pageMap } = buildPageMap(preprocessedPages);
-	logger?.debug?.("[segmenter] content built", {
-		pageIds: pageMap.pageIds,
-		totalContentLength: matchContent.length
-	});
-	const splitPoints = collectSplitPointsFromRules(rules, matchContent, pageMap, debugMetaKey, logger);
-	const unique = dedupeSplitPoints(splitPoints);
-	logger?.debug?.("[segmenter] split points collected", {
-		rawSplitPoints: splitPoints.length,
-		uniqueSplitPoints: unique.length
-	});
-	let segments = buildSegments(unique, matchContent, pageMap, rules, pageJoiner);
-	logger?.debug?.("[segmenter] structural segments built", { segmentCount: segments.length });
-	segments = ensureFallbackSegment(segments, preprocessedPages, normalizedContent, pageJoiner);
-	if (hasLimits) {
-		logger?.debug?.("[segmenter] applying breakpoints to oversized segments");
-		const result = applyBreakpoints(segments, preprocessedPages, normalizedContent, maxPages, breakpoints, prefer, (p) => processPattern(p, false).pattern, logger, pageJoiner, debug?.includeBreakpoint ? debug.metaKey : void 0, maxContentLength, processBreakpointPattern);
-		logger?.info?.("[segmenter] segmentation complete (with breakpoints)", { finalSegmentCount: result.length });
-		return result;
-	}
-	logger?.info?.("[segmenter] segmentation complete (structural only)", { finalSegmentCount: segments.length });
-	return segments;
-};
-/**
-* Creates segment objects from split points.
-*
-* Handles segment creation including:
-* - Content extraction (with captured content for `lineStartsAfter`)
-* - Page break conversion to spaces
-* - From/to page reference calculation
-* - Metadata merging (static + named captures)
-*
-* @param splitPoints - Sorted, unique split points
-* @param content - Full concatenated content string
-* @param pageMap - Page mapping utilities
-* @param rules - Original rules (for constraint checking on first segment)
-* @returns Array of segment objects
-*/
-const buildSegments = (splitPoints, content, pageMap, rules, pageJoiner) => {
-	const getActualStart = (start, contentStartOffset) => start + (contentStartOffset ?? 0);
-	const trimSegmentText = (sliced, capturedContent, contentStartOffset) => capturedContent?.trim() ?? (contentStartOffset ? sliced.trim() : sliced.replace(/[\s\n]+$/, ""));
-	const getAdjustedStart = (actualStart, sliced, contentStartOffset) => actualStart + (contentStartOffset ? sliced.length - sliced.trimStart().length : 0);
-	const applyMeta = (meta, namedCaptures) => meta || namedCaptures ? {
-		...meta,
-		...namedCaptures
-	} : void 0;
-	/**
-	* Creates a single segment from a content range.
-	*/
-	const createSegment = (start, end, meta, capturedContent, namedCaptures, contentStartOffset) => {
-		const actualStart = getActualStart(start, contentStartOffset);
-		const sliced = content.slice(actualStart, end);
-		let text = trimSegmentText(sliced, capturedContent, contentStartOffset);
-		if (!text) return null;
-		if (!capturedContent) text = convertPageBreaks(text, actualStart, pageMap.pageBreaks, pageJoiner);
-		const adjustedStart = getAdjustedStart(actualStart, sliced, contentStartOffset);
-		const from = pageMap.getId(adjustedStart);
-		const to = capturedContent ? pageMap.getId(end - 1) : pageMap.getId(adjustedStart + text.length - 1);
-		const seg = {
-			content: text,
-			from
-		};
-		if (to !== from) seg.to = to;
-		const mergedMeta = applyMeta(meta, namedCaptures);
-		if (mergedMeta) seg.meta = mergedMeta;
-		return seg;
-	};
-	/**
-	* Creates segments from an array of split points.
-	*/
-	const createSegmentsFromSplitPoints = () => {
-		const result = [];
-		for (let i = 0; i < splitPoints.length; i++) {
-			const sp = splitPoints[i];
-			const end = splitPoints[i + 1]?.index ?? content.length;
-			const s = createSegment(sp.index, end, sp.meta, sp.capturedContent, sp.namedCaptures, sp.contentStartOffset);
-			if (s) result.push(s);
-		}
-		return result;
-	};
-	const segments = [];
-	if (!splitPoints.length) {
-		if (anyRuleAllowsId(rules, pageMap.getId(0))) {
-			const s = createSegment(0, content.length);
-			if (s) segments.push(s);
-		}
-		return segments;
-	}
-	if (splitPoints[0].index > 0) {
-		if (anyRuleAllowsId(rules, pageMap.getId(0))) {
-			const s = createSegment(0, splitPoints[0].index);
-			if (s) segments.push(s);
-		}
-	}
-	return [...segments, ...createSegmentsFromSplitPoints()];
-};
-//#endregion
-//#region src/validation/validate-segments.ts
-/**
-* Creates a short preview string of text content for error reporting.
-* Truncates content exceeding PREVIEW_LIMIT.
-*/
-const buildPreview = (text) => {
-	const normalized = text.replace(/\s+/g, " ").trim();
-	if (normalized.length <= 140) return normalized;
-	return `${normalized.slice(0, 140)}...`;
-};
-/**
-* Creates a lightweight snapshot of a segment for inclusion in validation checks.
-*/
-const buildSegmentSnapshot = (segment) => ({
-	contentPreview: buildPreview(segment.content),
-	from: segment.from,
-	to: segment.to
-});
-/**
-* Normalizes page content by applying preprocessing transforms and standardizing line endings.
-*/
-const normalizePages = (pages, options) => {
-	const transforms = options.preprocess ?? [];
-	return pages.map((page) => {
-		return {
-			content: normalizeLineEndings(transforms.length ? applyPreprocessToPage(page.content, page.id, transforms) : page.content),
-			id: page.id
-		};
-	});
-};
-/**
-* Joins all page content into a single string with boundary tracking.
-* Returns the joined string and a list of boundary mappings (start/end indices for each page).
-*/
-const buildJoinedContent = (pages, joiner) => {
-	const boundaries = [];
-	const joined = pages.map((p) => p.content).join(joiner);
-	let offset = 0;
-	for (let i = 0; i < pages.length; i++) {
-		const content = pages[i].content;
-		const start = offset;
-		const end = start + content.length;
-		boundaries.push({
-			end,
-			id: pages[i].id,
-			start
-		});
-		offset += content.length + (i < pages.length - 1 ? joiner.length : 0);
-	}
-	return {
-		boundaries,
-		joined
-	};
-};
-/**
-* Binary search to find which page ID corresponds to a character offset in the joined content.
-* Returns undefined if the offset falls within a joiner gap or outside bounds.
-*/
-const findBoundaryIdForOffset = (offset, boundaries) => {
-	let lo = 0;
-	let hi = boundaries.length - 1;
-	while (lo <= hi) {
-		const mid = lo + hi >>> 1;
-		const boundary = boundaries[mid];
-		if (offset < boundary.start) hi = mid - 1;
-		else if (offset > boundary.end) lo = mid + 1;
-		else return boundary.id;
-	}
-	if (boundaries.length === 0) return;
-	const last = boundaries.at(-1);
-	return offset > last.end ? last.id : void 0;
-};
-/**
-* Helper to construct a standardized validation issue object.
-*/
-const createIssue = (type, segment, segmentIndex, overrides = {}, pageMap) => {
-	const segmentSnapshot = buildSegmentSnapshot(segment);
-	const page = pageMap?.get(segment.from);
-	const matchIndex = overrides.matchIndex;
-	const { matchIndex: _ignored, ...restOverrides } = overrides;
-	const base = {
-		actual: {
-			from: segment.from,
-			to: segment.to
-		},
-		segment: segmentSnapshot,
-		segmentIndex,
-		...restOverrides
-	};
-	switch (type) {
-		case "page_not_found": return {
-			...base,
-			evidence: overrides.evidence ?? `Segment.from=${segment.from} does not exist in input pages.`,
-			hint: "Check page IDs passed into segmentPages() and validateSegments().",
-			severity: "error",
-			type
-		};
-		case "content_not_found": return {
-			...base,
-			evidence: overrides.evidence ?? "Segment content not found in any page content.",
-			hint: overrides.hint ?? "Check preprocessing options, joiner settings, or whitespace normalization.",
-			pageContext: page ? {
-				pageId: page.id,
-				pagePreview: buildPreview(page.content)
-			} : void 0,
-			severity: "error",
-			type
-		};
-		case "page_attribution_mismatch": {
-			const matchedFromId = overrides.expected?.from ?? overrides.actual?.from ?? segment.from;
-			const actualPage = pageMap?.get(matchedFromId);
-			return {
-				...base,
-				evidence: overrides.evidence ?? `Content found in joined content at page ${matchedFromId}, but segment.from=${segment.from}.`,
-				hint: overrides.hint ?? "Check duplicate content handling and boundary detection rules.",
-				pageContext: actualPage ? {
-					matchIndex: matchIndex ?? -1,
-					pageId: actualPage.id,
-					pagePreview: buildPreview(actualPage.content)
-				} : void 0,
-				severity: "error",
-				type
-			};
-		}
-		case "max_pages_violation": return {
-			...base,
-			evidence: overrides.evidence ?? `Segment spans pages ${segment.from}-${overrides.actual?.to}.`,
-			hint: overrides.hint ?? "Check maxPages windowing in breakpoint-processor.ts and page constraints.",
-			severity: "error",
-			type
-		};
-		default: return {
-			...base,
-			severity: "error",
-			type
-		};
-	}
-};
-/**
-* Finds all occurrences of a content string within the joined text.
-* Respects search limits to avoid performance cliffs on highly repetitive content.
-*/
-const findJoinedMatches = (content, joined, searchStart, searchEnd, limit = Infinity) => {
-	const matches = [];
-	if (!content || searchStart >= searchEnd) return matches;
-	let idx = joined.indexOf(content, searchStart);
-	let count = 0;
-	while (idx >= 0 && idx < searchEnd && count < limit) {
-		matches.push({
-			end: idx + content.length - 1,
-			start: idx
-		});
-		idx = joined.indexOf(content, idx + 1);
-		if (idx >= searchEnd) break;
-		count++;
-	}
-	return matches;
-};
-/**
-* Verifies that a matched segment falls within the allowed maxTerms/maxPages constraints.
-* Checks both implicit spans (calculated from match end) and explicit segment.to claims.
-*/
-const checkMaxPagesViolation = (segment, segmentIndex, maxPages, matchEnd, _expectedBoundaryEnd, boundaries) => {
-	const actualToId = findBoundaryIdForOffset(matchEnd, boundaries);
-	if (actualToId === void 0) return [];
-	if (maxPages === 0) {
-		if (actualToId !== segment.from) return [createIssue("max_pages_violation", segment, segmentIndex, {
-			actual: {
-				from: segment.from,
-				to: actualToId
-			},
-			evidence: `Segment spans pages ${segment.from}-${actualToId} in joined content (maxPages=0).`,
-			expected: {
-				from: segment.from,
-				to: segment.from
-			}
-		})];
-	}
-	if (segment.to !== void 0) {
-		if (actualToId > segment.to) return [createIssue("max_pages_violation", segment, segmentIndex, {
-			actual: {
-				from: segment.from,
-				to: actualToId
-			},
-			evidence: `Segment content ends on page ${actualToId} but segment.to is ${segment.to}.`,
-			expected: {
-				from: segment.from,
-				to: segment.to
-			}
-		})];
-	} else if (maxPages !== void 0) {
-		const span = actualToId - segment.from;
-		if (span > maxPages) return [createIssue("max_pages_violation", segment, segmentIndex, {
-			actual: {
-				from: segment.from,
-				to: actualToId
-			},
-			evidence: `Segment spans ${span} pages (maxPages=${maxPages}).`,
-			expected: {
-				from: segment.from,
-				to: segment.from + maxPages
-			}
-		})];
-	}
-	return [];
-};
-/**
-* Handles validation when content is not found in the expected boundary window.
-* Fallback strategy: search entire document if segment matches existing content elsewhere.
-*/
-const handleMissingBoundary = (segment, segmentIndex, joined, boundaries, pageMap) => {
-	const matches = findJoinedMatches(segment.content, joined, 0, joined.length, 1);
-	if (matches.length === 0) return [createIssue("content_not_found", segment, segmentIndex, { evidence: "Segment content not found in any page content." }, pageMap)];
-	const match = matches[0];
-	const actualFromId = findBoundaryIdForOffset(match.start, boundaries);
-	const actualToId = findBoundaryIdForOffset(match.end, boundaries);
-	return [createIssue("page_attribution_mismatch", segment, segmentIndex, {
-		actual: {
-			from: segment.from,
-			to: segment.to
-		},
-		evidence: `Content found in joined content at page ${actualFromId}, but segment.from=${segment.from}.`,
-		expected: {
-			from: actualFromId,
-			to: actualToId
-		},
-		matchIndex: match.start
-	}, pageMap)];
-};
-/**
-* Performs a widened search when the direct check fails.
-* Includes a small buffer around the expected position, and optionally a full-document search for short segments.
-*/
-const handleFallbackSearch = (segment, segmentIndex, joined, searchStart, searchEnd, expectedBoundary, boundaries, pageMap, maxPages, validationOptions) => {
-	const content = segment.content;
-	const bufferSize = 1e3;
-	const rawMatches = findJoinedMatches(content, joined, Math.max(0, searchStart - bufferSize), Math.min(joined.length, searchEnd + bufferSize), 5);
-	if (rawMatches.length === 0) {
-		const threshold = validationOptions?.fullSearchThreshold ?? 500;
-		if (content.length < threshold) {
-			const fullMatches = findJoinedMatches(content, joined, 0, joined.length, 50);
-			const validMatch = fullMatches.find((m) => {
-				return findBoundaryIdForOffset(m.start, boundaries) === segment.from;
-			});
-			if (validMatch) return checkMaxPagesViolation(segment, segmentIndex, maxPages, validMatch.end, expectedBoundary.end, boundaries);
-			if (fullMatches.length > 0) {
-				const match = fullMatches[0];
-				const actualFromId = findBoundaryIdForOffset(match.start, boundaries);
-				const actualToId = findBoundaryIdForOffset(match.end, boundaries);
-				return [createIssue("page_attribution_mismatch", segment, segmentIndex, {
-					actual: {
-						from: segment.from,
-						to: segment.to
-					},
-					evidence: `Content found in joined content at page ${actualFromId}, but segment.from=${segment.from}.`,
-					expected: {
-						from: actualFromId,
-						to: actualToId
-					},
-					matchIndex: match.start
-				}, pageMap)];
-			}
-		}
-		return [createIssue("content_not_found", segment, segmentIndex, {
-			evidence: `Segment content (${content.length} chars) not found in expected window.`,
-			hint: "Check page boundary attribution in segmenter.ts."
-		}, pageMap)];
-	}
-	const alignedMatches = rawMatches.filter((m) => m.start >= expectedBoundary.start && m.start <= expectedBoundary.end);
-	if (alignedMatches.length > 0) {
-		const primary = alignedMatches[0];
-		return checkMaxPagesViolation(segment, segmentIndex, maxPages, primary.end, expectedBoundary.end, boundaries);
-	}
-	const primary = rawMatches[0];
-	const actualFromId = findBoundaryIdForOffset(primary.start, boundaries);
-	const actualToId = findBoundaryIdForOffset(primary.end, boundaries);
-	return [createIssue("page_attribution_mismatch", segment, segmentIndex, {
-		actual: {
-			from: segment.from,
-			to: segment.to
-		},
-		evidence: `Content found in joined content at page ${actualFromId}, but segment.from=${segment.from}.`,
-		expected: {
-			from: actualFromId,
-			to: actualToId
-		},
-		matchIndex: primary.start
-	}, pageMap)];
-};
-/**
-* Calculates the search range end index based on segment.to or strict bounds.
-*/
-const getSearchRange = (segment, expectedBoundary, boundaryMap, joinedLength) => {
-	let searchEnd = expectedBoundary.end + 1;
-	if (segment.to !== void 0) {
-		const endBoundary = boundaryMap.get(segment.to);
-		if (endBoundary) searchEnd = endBoundary.end + 1;
-		else searchEnd = Math.min(joinedLength, expectedBoundary.end + 5e4);
-	}
-	return searchEnd;
-};
-/**
-* Validates attribution for a single segment by searching for its content in the joined text.
-* Returns issues if content is missing, mis-attributed, or violates page limits.
-*/
-const getAttributionIssues = (segment, segmentIndex, maxPages, joined, boundaries, boundaryMap, pageMap, validationOptions) => {
-	if (!segment.content) return [createIssue("content_not_found", segment, segmentIndex, { evidence: "Segment content is empty." }, pageMap)];
-	const expectedBoundary = boundaryMap.get(segment.from);
-	if (!expectedBoundary) return handleMissingBoundary(segment, segmentIndex, joined, boundaries, pageMap);
-	const searchEnd = getSearchRange(segment, expectedBoundary, boundaryMap, joined.length);
-	const searchStart = expectedBoundary.start;
-	const idx = joined.indexOf(segment.content, searchStart);
-	if (idx !== -1 && idx < searchEnd) return checkMaxPagesViolation(segment, segmentIndex, maxPages, idx + segment.content.length - 1, expectedBoundary.end, boundaries);
-	return handleFallbackSearch(segment, segmentIndex, joined, searchStart, searchEnd, expectedBoundary, boundaries, pageMap, maxPages, validationOptions);
-};
-/**
-* Performs purely static checks on the segment metadata (Ids and spans) before expensive content searching.
-*/
-const checkStaticMaxPages = (segment, index, maxPages) => {
-	if (maxPages === void 0 || segment.to === void 0) return null;
-	if (maxPages === 0) {
-		if (segment.to !== segment.from) return createIssue("max_pages_violation", segment, index, {
-			evidence: "maxPages=0 requires all segments to stay within one page.",
-			expected: {
-				from: segment.from,
-				to: segment.from
-			},
-			hint: "Check boundary detection in breakpoint-utils.ts."
-		});
-		return null;
-	}
-	const span = segment.to - segment.from;
-	if (span > maxPages) return createIssue("max_pages_violation", segment, index, {
-		evidence: `Segment spans ${span} pages (maxPages=${maxPages}).`,
-		expected: {
-			from: segment.from,
-			to: segment.from + maxPages
-		},
-		hint: "Check breakpoint windowing and page attribution in breakpoint-processor.ts."
-	});
-	return null;
-};
-/**
-* Validates a list of segments against the source pages.
-* checks for:
-* - Page existence (invalid IDs)
-* - Content fidelity (content must exist in pages)
-* - Page attribution (from/to must match content location)
-* - Page constraints (maxPages violations)
-*
-* @param pages Input pages used for segmentation
-* @param options Operations used during segmentation (for preprocessing/joining consistency)
-* @param segments The output segments to validate
-* @param validationOptions Optional settings for validation behavior
-* @returns A detailed validation report
-*/
-const validateSegments = (pages, options, segments, validationOptions) => {
-	const normalizedPages = normalizePages(pages, options);
-	const { boundaries, joined } = buildJoinedContent(normalizedPages, options.pageJoiner === "newline" ? "\n" : " ");
-	const boundaryMap = /* @__PURE__ */ new Map();
-	const pageMap = /* @__PURE__ */ new Map();
-	for (const b of boundaries) boundaryMap.set(b.id, b);
-	for (const p of normalizedPages) pageMap.set(p.id, p);
-	const pageIds = new Set(normalizedPages.map((p) => p.id));
-	const maxPages = options.maxPages;
-	const issues = [];
-	for (let i = 0; i < segments.length; i++) {
-		const segment = segments[i];
-		if (!pageIds.has(segment.from)) {
-			issues.push(createIssue("page_not_found", segment, i));
-			continue;
-		}
-		if (segment.to !== void 0 && !pageIds.has(segment.to)) issues.push(createIssue("page_not_found", segment, i, { evidence: `Segment.to=${segment.to} does not exist in input pages.` }));
-		const staticMaxPageIssue = checkStaticMaxPages(segment, i, maxPages);
-		if (staticMaxPageIssue) issues.push(staticMaxPageIssue);
-		const attributionIssues = getAttributionIssues(segment, i, maxPages, joined, boundaries, boundaryMap, pageMap, validationOptions);
-		issues.push(...attributionIssues);
-	}
-	const errors = issues.filter((issue) => issue.severity === "error").length;
-	const warnings = issues.filter((issue) => issue.severity === "warn").length;
-	return {
-		issues,
-		ok: issues.length === 0,
-		summary: {
-			errors,
-			issues: issues.length,
-			pageCount: pages.length,
-			segmentCount: segments.length,
-			warnings
-		}
-	};
-};
-//#endregion
-export { ARABIC_BASE_LETTER_CLASS, ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN, ARABIC_MARKS_CLASS, ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN, PATTERN_TYPE_KEYS, TOKEN_PATTERNS, Token, analyzeCommonLineStarts, analyzeRepeatingSequences, analyzeTextForRule, applyPreprocessToPage, applyTokenMappings, condenseEllipsis, containsTokens, createArabicDictionaryEntryRule, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, escapeWordsOutsideTokens, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, fixTrailingWaw, formatValidationReport, generateTemplateFromText, getAvailableTokens, getDebugReason, getSegmentDebugReason, getTokenPattern, makeDiacriticInsensitive, normalizeArabicForComparison, optimizeRules, removeZeroWidth, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, templateToRegex, validateRules, validateSegments, withCapture };
+export { ARABIC_BASE_LETTER_CLASS, ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN, ARABIC_MARKS_CLASS, ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN, DictionaryProfileValidationError, PATTERN_TYPE_KEYS, TOKEN_PATTERNS, Token, analyzeCommonLineStarts, analyzeDictionaryMarkdownPages, analyzeRepeatingSequences, analyzeTextForRule, applyPreprocessToPage, applyTokenMappings, classifyDictionaryHeading, condenseEllipsis, containsTokens, createArabicDictionaryEntryRule, detectTokenPatterns, diagnoseDictionaryProfile, escapeRegex, escapeTemplateBrackets, escapeWordsOutsideTokens, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, fixTrailingWaw, formatValidationReport, generateTemplateFromText, getAvailableTokens, getDebugReason, getSegmentDebugReason, getTokenPattern, makeDiacriticInsensitive, normalizeArabicForComparison, optimizeRules, removeZeroWidth, scanDictionaryMarkdownPage, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, suggestSegmentationOptions, templateToRegex, validateDictionaryProfile, validateRules, validateSegments, withCapture };
 
 //# sourceMappingURL=index.mjs.map