flappa-doormal 2.13.2 → 2.13.4

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["TOKEN_PRIORITY_ORDER","isArabicLetter","resolveOptions","skipWhitespace","word","processPattern","passesRuleConstraints","createSegment"],"sources":["../src/utils/textUtils.ts","../src/segmentation/tokens.ts","../src/analysis/shared.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/detection.ts","../src/types/rules.ts","../src/optimization/optimize-rules.ts","../src/preprocessing/replace.ts","../src/segmentation/rule-regex.ts","../src/segmentation/breakpoint-constants.ts","../src/segmentation/breakpoint-utils.ts","../src/segmentation/debug-meta.ts","../src/segmentation/breakpoint-processor.ts","../src/segmentation/match-utils.ts","../src/segmentation/fast-fuzzy-prefix.ts","../src/segmentation/segmenter-rule-utils.ts","../src/segmentation/split-point-helpers.ts","../src/segmentation/segmenter.ts","../src/recovery.ts","../src/segmentation/pattern-validator.ts"],"sourcesContent":["/**\n * Normalizes line endings to Unix-style (`\\n`).\n *\n * Converts Windows (`\\r\\n`) and old Mac (`\\r`) line endings to Unix style\n * for consistent pattern matching across platforms.\n *\n * @param content - Raw content with potentially mixed line endings\n * @returns Content with all line endings normalized to `\\n`\n */\n// OPTIMIZATION: Fast-path when no \\r present (common case for Unix/Mac content)\nexport const normalizeLineEndings = (content: string) => {\n    return content.includes('\\r') ? content.replace(/\\r\\n?/g, '\\n') : content;\n}; // Auto-escaping for template patterns\n/**\n * Escapes regex metacharacters (parentheses and brackets) in template patterns,\n * but preserves content inside `{{...}}` token delimiters.\n *\n * This allows users to write intuitive patterns like `({{harf}}):` instead of\n * the verbose `\\\\({{harf}}\\\\):`. The escaping is applied BEFORE token expansion,\n * so tokens like `{{harf}}` which expand to `[أ-ي]` work correctly.\n *\n * @param pattern - Template pattern that may contain `()[]` and `{{tokens}}`\n * @returns Pattern with `()[]` escaped outside of `{{...}}` delimiters\n *\n * @example\n * escapeTemplateBrackets('({{harf}}): ')\n * // → '\\\\({{harf}}\\\\): '\n *\n * @example\n * escapeTemplateBrackets('[{{raqm}}] ')\n * // → '\\\\[{{raqm}}\\\\] '\n *\n * @example\n * escapeTemplateBrackets('{{harf}}')\n * // → '{{harf}}' (unchanged - no brackets outside tokens)\n */\nexport const escapeTemplateBrackets = (pattern: string) =>\n    pattern.replace(/(\\{\\{[^}]*\\}\\})|([()[\\]])/g, (_match, token, bracket) => token || `\\\\${bracket}`);\n\n/**\n * Character class matching all Arabic diacritics (Tashkeel/Harakat).\n *\n * Includes the following diacritical marks:\n * - U+064B: ً (fathatan - double fatha)\n * - U+064C: ٌ (dammatan - double damma)\n * - U+064D: ٍ (kasratan - double kasra)\n * - U+064E: َ (fatha - short a)\n * - U+064F: ُ (damma - short u)\n * - U+0650: ِ (kasra - short i)\n * - U+0651: ّ (shadda - gemination)\n * - U+0652: ْ (sukun - no vowel)\n *\n * @internal\n */\nconst DIACRITICS_CLASS = '[\\u064B\\u064C\\u064D\\u064E\\u064F\\u0650\\u0651\\u0652]';\n\n/**\n * Groups of equivalent Arabic characters.\n *\n * Characters within the same group are considered equivalent for matching purposes.\n * This handles common variations in Arabic text where different characters are\n * used interchangeably or have the same underlying meaning.\n *\n * Equivalence groups:\n * - Alef variants: ا (bare), آ (with madda), أ (with hamza above), إ (with hamza below)\n * - Ta marbuta and Ha: ة ↔ ه (often interchangeable at word endings)\n * - Alef maqsura and Ya: ى ↔ ي (often interchangeable at word endings)\n *\n * @internal\n */\nconst EQUIV_GROUPS = [\n    ['\\u0627', '\\u0622', '\\u0623', '\\u0625'], // ا, آ, أ, إ\n    ['\\u0629', '\\u0647'], // ة <-> ه\n    ['\\u0649', '\\u064A'], // ى <-> ي\n];\n\n/**\n * Escapes a string for safe inclusion in a regular expression.\n *\n * Escapes all regex metacharacters: `.*+?^${}()|[\\]\\\\`\n *\n * @param s - Any string to escape\n * @returns String with regex metacharacters escaped\n *\n * @example\n * escapeRegex('hello.world')   // → 'hello\\\\.world'\n * escapeRegex('[test]')        // → '\\\\[test\\\\]'\n * escapeRegex('a+b*c?')        // → 'a\\\\+b\\\\*c\\\\?'\n */\nexport const escapeRegex = (s: string) => s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\nconst getEquivClass = (ch: string) => {\n    const group = EQUIV_GROUPS.find((g) => g.includes(ch));\n    return group ? `[${group.map(escapeRegex).join('')}]` : escapeRegex(ch);\n};\n\nconst normalizeArabicLight = (str: string) =>\n    str\n        .normalize('NFC')\n        .replace(/[\\u200C\\u200D]/g, '')\n        .replace(/\\s+/g, ' ')\n        .trim();\n\nexport const makeDiacriticInsensitive = (text: string) => {\n    const diacriticsMatcher = `${DIACRITICS_CLASS}*`;\n    return Array.from(normalizeArabicLight(text))\n        .map((ch) => getEquivClass(ch) + diacriticsMatcher)\n        .join('');\n};\n\nconst isCombiningMarkOrSelector = (char: string | undefined) => {\n    if (!char) {\n        return false;\n    }\n    // \\p{M} = Unicode combining mark category (includes Arabic harakat)\n    // FE0E/FE0F = variation selectors\n    return /\\p{M}/u.test(char) || char === '\\uFE0E' || char === '\\uFE0F';\n};\n\nconst isJoiner = (char: string | undefined) => char === '\\u200C' || char === '\\u200D';\n\n/**\n * Ensures the position does not split a grapheme cluster (surrogate pairs,\n * combining marks, or zero-width joiners / variation selectors).\n *\n * This is only used as a last-resort fallback when we are forced to split\n * near a hard limit (e.g. maxContentLength with no safe whitespace/punctuation).\n */\nexport const adjustForUnicodeBoundary = (content: string, position: number) => {\n    let adjusted = position;\n    while (adjusted > 0) {\n        // 1. Ensure we don't split a surrogate pair\n        // (High surrogate at adjusted-1, Low surrogate at adjusted)\n        const high = content.charCodeAt(adjusted - 1);\n        const low = content.charCodeAt(adjusted);\n        if (high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) {\n            adjusted -= 1;\n            continue;\n        }\n\n        const nextChar = content[adjusted];\n        const prevChar = content[adjusted - 1];\n        // 2. If we'd start the next segment with a combining mark / selector / joiner, back up.\n        // For joiners, also avoid ending the previous segment with a joiner.\n        // (Splitting AFTER combining marks / selectors is safe; splitting before them is not.)\n        if (isCombiningMarkOrSelector(nextChar) || isJoiner(nextChar) || isJoiner(prevChar)) {\n            adjusted -= 1;\n            continue;\n        }\n        break;\n    }\n    return adjusted;\n};\n","/**\n * Base token definitions mapping human-readable token names to regex patterns.\n *\n * These tokens contain raw regex patterns and do not reference other tokens.\n * For composite tokens that build on these, see `COMPOSITE_TOKENS`.\n *\n * @internal\n */\n// IMPORTANT:\n// - We include the Arabic-Indic digit `٤` as a rumuz code, but we do NOT match it when it's part of a larger number (e.g. \"٣٤\").\n// - We intentionally do NOT match ASCII `4`.\n// - For performance/clarity, the single-letter rumuz are represented as a character class.\n// - Single-letter codes must NOT be followed by Arabic diacritics (\\u064B-\\u0652, \\u0670) or letters (أ-ي),\n//   otherwise we'd incorrectly match the first letter of Arabic words like عَن as rumuz ع.\nconst RUMUZ_SINGLE_LETTER = '[خرزيمنصسدفلتقع](?![\\\\u064B-\\\\u0652\\\\u0670أ-ي])';\n\nconst RUMUZ_FOUR = '(?<![\\\\u0660-\\\\u0669])٤(?![\\\\u0660-\\\\u0669])';\n\n// IMPORTANT: order matters. Put longer/more specific codes before shorter ones.\nconst RUMUZ_ATOMS: string[] = [\n    // Multi-letter word codes (must NOT be followed by diacritics or letters)\n    'تمييز(?![\\\\u064B-\\\\u0652\\\\u0670أ-ي])',\n    // 2-letter codes\n    'خت',\n    'خغ',\n    'بخ',\n    'عخ',\n    'مق',\n    'مت',\n    'عس',\n    'سي',\n    'سن',\n    'كن',\n    'مد',\n    'قد',\n    'خد',\n    'فد',\n    'دل',\n    'كد',\n    'غد',\n    'صد',\n    'دت',\n    'دس',\n    'تم',\n    'فق',\n    'دق',\n    // Single-letter codes (character class) + special digit atom\n    RUMUZ_SINGLE_LETTER,\n    RUMUZ_FOUR,\n];\n\nconst RUMUZ_ATOM = `(?:${RUMUZ_ATOMS.join('|')})`;\n\nconst RUMUZ_BLOCK = `${RUMUZ_ATOM}(?:\\\\s+${RUMUZ_ATOM})*`;\n\nconst BASE_TOKENS: Record<string, string> = {\n    /** Chapter marker (باب). */\n    bab: 'باب',\n\n    /** Basmala (بسم الله). Also matches ﷽. */\n    basmalah: ['بسم الله', '﷽'].join('|'),\n\n    /** Bullet point variants: `•`, `*`, `°`. */\n    bullet: '[•*°]',\n\n    /** Dash variants: `-` (U+002D), `–` (U+2013), `—` (U+2014), `ـ` (tatweel U+0640). */\n    dash: '[-–—ـ]',\n\n    /** Section marker (فصل / مسألة). */\n    fasl: ['مسألة', 'فصل'].join('|'),\n\n    /** Single Arabic letter (أ-ي). Does NOT include diacritics. */\n    harf: '[أ-ي]',\n\n    /** One or more single Arabic letters separated by spaces. For multi-letter codes use `{{rumuz}}`. */\n    harfs: '[أ-ي](?:\\\\s+[أ-ي])*',\n\n    /** Book marker (كتاب). */\n    kitab: 'كتاب',\n\n    /** Hadith transmission phrases (حدثنا, أخبرنا, حدثني, etc.). */\n    naql: ['حدثني', 'وأخبرنا', 'حدثنا', 'سمعت', 'أنبأنا', 'وحدثنا', 'أخبرنا', 'وحدثني', 'وحدثنيه'].join('|'),\n\n    /** Single ASCII digit (0-9). */\n    num: '\\\\d',\n\n    /** One or more ASCII digits (0-9)+. */\n    nums: '\\\\d+',\n\n    /** Single Arabic-Indic digit (٠-٩, U+0660-U+0669). */\n    raqm: '[\\\\u0660-\\\\u0669]',\n\n    /** One or more Arabic-Indic digits (٠-٩)+. */\n    raqms: '[\\\\u0660-\\\\u0669]+',\n\n    /** Rijāl/takhrīj source abbreviations. Matches one or more codes separated by whitespace. */\n    rumuz: RUMUZ_BLOCK,\n\n    /** Arabic/common punctuation: `.`, `!`, `?`, `؟`, `؛`. */\n    tarqim: '[.!?؟؛]',\n};\n\n/** Pre-defined token constants for use in patterns. */\nexport const Token = {\n    /** Chapter marker - باب */\n    BAB: '{{bab}}',\n    /** Basmala - بسم الله */\n    BASMALAH: '{{basmalah}}',\n    /** Bullet point variants */\n    BULLET: '{{bullet}}',\n    /** Dash variants (hyphen, en-dash, em-dash, tatweel) */\n    DASH: '{{dash}}',\n    /** Section marker - فصل / مسألة */\n    FASL: '{{fasl}}',\n    /** Single Arabic letter */\n    HARF: '{{harf}}',\n    /** Multiple Arabic letters separated by spaces */\n    HARFS: '{{harfs}}',\n    /** Book marker - كتاب */\n    KITAB: '{{kitab}}',\n    /** Hadith transmission phrases */\n    NAQL: '{{naql}}',\n    /** Single ASCII digit */\n    NUM: '{{num}}',\n    /** Composite: {{raqms}} {{dash}} (space) */\n    NUMBERED: '{{numbered}}',\n    /** One or more ASCII digits */\n    NUMS: '{{nums}}',\n    /** Single Arabic-Indic digit */\n    RAQM: '{{raqm}}',\n    /** One or more Arabic-Indic digits */\n    RAQMS: '{{raqms}}',\n    /** Source abbreviations (rijāl/takhrīj) */\n    RUMUZ: '{{rumuz}}',\n    /** Punctuation marks */\n    TARQIM: '{{tarqim}}',\n} as const;\n\n/**\n * Type representing valid token constant keys.\n */\nexport type TokenKey = keyof typeof Token;\n\n/** Wraps a token constant with a named capture: `{{token}}` → `{{token:name}}`. */\nexport const withCapture = (token: string, name: string): string => {\n    // Extract token name from {{token}} format\n    const match = token.match(/^\\{\\{(\\w+)\\}\\}$/);\n    if (!match) {\n        // If not a valid token format, return capture-only syntax\n        return `{{:${name}}}`;\n    }\n    return `{{${match[1]}:${name}}}`;\n};\n\n/** Composite tokens that reference base tokens. Pre-expanded at load time. @internal */\nconst COMPOSITE_TOKENS: Record<string, string> = {\n    /** Common hadith numbering format: Arabic-Indic digits + dash + space. */\n    numbered: '{{raqms}} {{dash}} ',\n};\n\n/** Expands composite tokens (e.g. `{{numbered}}`) to their underlying template form. */\nexport const expandCompositeTokensInTemplate = (template: string) => {\n    let out = template;\n    for (let i = 0; i < 10; i++) {\n        const next = out.replace(/\\{\\{(\\w+)\\}\\}/g, (m, tokenName: string) => COMPOSITE_TOKENS[tokenName] ?? m);\n        if (next === out) {\n            break;\n        }\n        out = next;\n    }\n    return out;\n};\n\n/**\n * Expands base tokens in a template string.\n * Used internally to pre-expand composite tokens.\n *\n * @param template - Template string with `{{token}}` placeholders\n * @returns Expanded pattern with base tokens replaced\n * @internal\n */\nconst expandBaseTokens = (template: string) =>\n    template.replace(/\\{\\{(\\w+)\\}\\}/g, (_, tokenName) => BASE_TOKENS[tokenName] ?? `{{${tokenName}}}`);\n\n/**\n * Token definitions mapping human-readable token names to regex patterns.\n *\n * Tokens are used in template strings with double-brace syntax:\n * - `{{token}}` - Expands to the pattern (non-capturing in context)\n * - `{{token:name}}` - Expands to a named capture group `(?<name>pattern)`\n * - `{{:name}}` - Captures any content with the given name `(?<name>.+)`\n *\n * @remarks\n * These patterns are designed for Arabic text matching. For diacritic-insensitive\n * matching of Arabic patterns, use the `fuzzy: true` option in split rules,\n * which applies `makeDiacriticInsensitive()` to the expanded patterns.\n *\n * @example\n * // Using tokens in a split rule\n * { lineStartsWith: ['{{kitab}}', '{{bab}}'], split: 'at', fuzzy: true }\n *\n * @example\n * // Using tokens with named captures\n * { lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '], split: 'at' }\n *\n * @example\n * // Using the numbered convenience token\n * { lineStartsAfter: ['{{numbered}}'], split: 'at' }\n */\nexport const TOKEN_PATTERNS: Record<string, string> = {\n    ...BASE_TOKENS,\n    // Pre-expand composite tokens at module load time\n    ...Object.fromEntries(Object.entries(COMPOSITE_TOKENS).map(([k, v]) => [k, expandBaseTokens(v)])),\n};\n\n/**\n * Regex pattern for matching tokens with optional named capture syntax.\n *\n * Matches:\n * - `{{token}}` - Simple token (group 1 = token name, group 2 = empty)\n * - `{{token:name}}` - Token with capture (group 1 = token, group 2 = name)\n * - `{{:name}}` - Capture-only (group 1 = empty, group 2 = name)\n *\n * @internal\n */\nconst TOKEN_WITH_CAPTURE_REGEX = /\\{\\{(\\w*):?(\\w*)\\}\\}/g;\n\n/**\n * Regex pattern for simple token matching (no capture syntax).\n *\n * Matches only `{{token}}` format where token is one or more word characters.\n * Used by `containsTokens()` for quick detection.\n *\n * @internal\n */\nconst SIMPLE_TOKEN_REGEX = /\\{\\{(\\w+)\\}\\}/g;\n\n/**\n * Checks if a query string contains template tokens.\n *\n * Performs a quick test for `{{token}}` patterns without actually\n * expanding them. Useful for determining whether to apply token\n * expansion to a string.\n *\n * @param query - String to check for tokens\n * @returns `true` if the string contains at least one `{{token}}` pattern\n *\n * @example\n * containsTokens('{{raqms}} {{dash}}') // → true\n * containsTokens('plain text')          // → false\n * containsTokens('[٠-٩]+ - ')           // → false (raw regex, no tokens)\n */\nexport const containsTokens = (query: string) => {\n    SIMPLE_TOKEN_REGEX.lastIndex = 0;\n    return SIMPLE_TOKEN_REGEX.test(query);\n};\n\n/**\n * Result from expanding tokens with capture information.\n *\n * Contains the expanded pattern string along with metadata about\n * any named capture groups that were created.\n */\nexport type ExpandResult = {\n    /**\n     * The expanded regex pattern string with all tokens replaced.\n     *\n     * Named captures use the `(?<name>pattern)` syntax.\n     */\n    pattern: string;\n\n    /**\n     * Names of captured groups extracted from `{{token:name}}` syntax.\n     *\n     * Empty array if no named captures were found.\n     */\n    captureNames: string[];\n\n    /**\n     * Whether the pattern has any named capturing groups.\n     *\n     * Equivalent to `captureNames.length > 0`.\n     */\n    hasCaptures: boolean;\n};\n\ntype TemplateSegment = { type: 'token' | 'text'; value: string };\n\nconst splitTemplateIntoSegments = (query: string) => {\n    const segments: TemplateSegment[] = [];\n    let lastIndex = 0;\n    TOKEN_WITH_CAPTURE_REGEX.lastIndex = 0;\n\n    for (const match of query.matchAll(TOKEN_WITH_CAPTURE_REGEX)) {\n        if (match.index! > lastIndex) {\n            segments.push({ type: 'text', value: query.slice(lastIndex, match.index) });\n        }\n        segments.push({ type: 'token', value: match[0] });\n        lastIndex = match.index! + match[0].length;\n    }\n\n    if (lastIndex < query.length) {\n        segments.push({ type: 'text', value: query.slice(lastIndex) });\n    }\n    return segments;\n};\n\nconst maybeApplyFuzzyToText = (text: string, fuzzyTransform?: (pattern: string) => string) =>\n    fuzzyTransform && /[\\u0600-\\u06FF]/u.test(text) ? fuzzyTransform(text) : text;\n\n// NOTE: This intentionally preserves the previous behavior:\n// it applies fuzzy per `|`-separated alternative (best-effort) to avoid corrupting regex metacharacters.\nconst maybeApplyFuzzyToTokenPattern = (tokenPattern: string, fuzzyTransform?: (pattern: string) => string) =>\n    !fuzzyTransform\n        ? tokenPattern\n        : tokenPattern\n              .split('|')\n              .map((part) => (/[\\u0600-\\u06FF]/u.test(part) ? fuzzyTransform(part) : part))\n              .join('|');\n\nconst parseTokenLiteral = (literal: string) => {\n    TOKEN_WITH_CAPTURE_REGEX.lastIndex = 0;\n    const m = TOKEN_WITH_CAPTURE_REGEX.exec(literal);\n    return m ? { captureName: m[2], tokenName: m[1] } : null;\n};\n\nconst createCaptureRegistry = (capturePrefix?: string) => {\n    const captureNames: string[] = [];\n    const captureNameCounts = new Map<string, number>();\n\n    const register = (baseName: string) => {\n        const count = captureNameCounts.get(baseName) ?? 0;\n        captureNameCounts.set(baseName, count + 1);\n        const uniqueName = count === 0 ? baseName : `${baseName}_${count + 1}`;\n        const prefixedName = capturePrefix ? `${capturePrefix}${uniqueName}` : uniqueName;\n        captureNames.push(prefixedName);\n        return prefixedName;\n    };\n\n    return { captureNames, register };\n};\n\nconst expandTokenLiteral = (\n    literal: string,\n    opts: {\n        fuzzyTransform?: (pattern: string) => string;\n        registerCapture: (baseName: string) => string;\n        capturePrefix?: string;\n    },\n) => {\n    const parsed = parseTokenLiteral(literal);\n    if (!parsed) {\n        return literal;\n    }\n\n    const { tokenName, captureName } = parsed;\n    if (!tokenName && captureName) {\n        return `(?<${opts.registerCapture(captureName)}>.+)`;\n    }\n\n    let tokenPattern = TOKEN_PATTERNS[tokenName];\n    if (!tokenPattern) {\n        return literal;\n    }\n\n    tokenPattern = maybeApplyFuzzyToTokenPattern(tokenPattern, opts.fuzzyTransform);\n    if (captureName) {\n        return `(?<${opts.registerCapture(captureName)}>${tokenPattern})`;\n    }\n\n    return tokenPattern;\n};\n\n/**\n * Expands template tokens with support for named captures.\n *\n * This is the primary token expansion function that handles all token syntax:\n * - `{{token}}` → Expands to the token's pattern (no capture group)\n * - `{{token:name}}` → Expands to `(?<name>pattern)` (named capture)\n * - `{{:name}}` → Expands to `(?<name>.+)` (capture anything)\n *\n * Unknown tokens are left as-is in the output, allowing for partial templates.\n *\n * @param query - The template string containing tokens\n * @param fuzzyTransform - Optional function to transform Arabic text for fuzzy matching.\n *                         Applied to both token patterns and plain Arabic text between tokens.\n *                         Typically `makeDiacriticInsensitive` from the fuzzy module.\n * @returns Object with expanded pattern, capture names, and capture flag\n *\n * @example\n * // Simple token expansion\n * expandTokensWithCaptures('{{raqms}} {{dash}}')\n * // → { pattern: '[\\\\u0660-\\\\u0669]+ [-–—ـ]', captureNames: [], hasCaptures: false }\n *\n * @example\n * // Named capture\n * expandTokensWithCaptures('{{raqms:num}} {{dash}}')\n * // → { pattern: '(?<num>[\\\\u0660-\\\\u0669]+) [-–—ـ]', captureNames: ['num'], hasCaptures: true }\n *\n * @example\n * // Capture-only token\n * expandTokensWithCaptures('{{raqms:num}} {{dash}} {{:content}}')\n * // → { pattern: '(?<num>[٠-٩]+) [-–—ـ] (?<content>.+)', captureNames: ['num', 'content'], hasCaptures: true }\n *\n * @example\n * // With fuzzy transform\n * expandTokensWithCaptures('{{bab}}', makeDiacriticInsensitive)\n * // → { pattern: 'بَ?ا?بٌ?', captureNames: [], hasCaptures: false }\n */\nexport const expandTokensWithCaptures = (\n    query: string,\n    fuzzyTransform?: (pattern: string) => string,\n    capturePrefix?: string,\n) => {\n    const segments = splitTemplateIntoSegments(query);\n    const registry = createCaptureRegistry(capturePrefix);\n\n    const pattern = segments\n        .map((segment) =>\n            segment.type === 'text'\n                ? maybeApplyFuzzyToText(segment.value, fuzzyTransform)\n                : expandTokenLiteral(segment.value, {\n                      capturePrefix,\n                      fuzzyTransform,\n                      registerCapture: registry.register,\n                  }),\n        )\n        .join('');\n\n    return {\n        captureNames: registry.captureNames,\n        hasCaptures: registry.captureNames.length > 0,\n        pattern,\n    };\n};\n\n/**\n * Expands template tokens in a query string to their regex equivalents.\n *\n * This is the simple version without capture support. It returns only the\n * expanded pattern string, not capture metadata.\n *\n * Unknown tokens are left as-is, allowing for partial templates.\n *\n * @param query - Template string containing `{{token}}` placeholders\n * @returns Expanded regex pattern string\n *\n * @example\n * expandTokens('، {{raqms}}')     // → '، [\\\\u0660-\\\\u0669]+'\n * expandTokens('{{raqm}}*')       // → '[\\\\u0660-\\\\u0669]*'\n * expandTokens('{{dash}}{{raqm}}') // → '[-–—ـ][\\\\u0660-\\\\u0669]'\n * expandTokens('{{unknown}}')     // → '{{unknown}}' (left as-is)\n *\n * @see expandTokensWithCaptures for full capture group support\n */\nexport const expandTokens = (query: string) => expandTokensWithCaptures(query).pattern;\n\n/**\n * Converts a template string to a compiled RegExp.\n *\n * Expands all tokens and attempts to compile the result as a RegExp\n * with Unicode flag. Returns `null` if the resulting pattern is invalid.\n *\n * @remarks\n * This function dynamically compiles regular expressions from template strings.\n * If templates may come from untrusted sources, be aware of potential ReDoS\n * (Regular Expression Denial of Service) risks due to catastrophic backtracking.\n * Consider validating pattern complexity or applying execution timeouts when\n * running user-submitted patterns.\n *\n * @param template - Template string containing `{{token}}` placeholders\n * @returns Compiled RegExp with 'u' flag, or `null` if invalid\n *\n * @example\n * templateToRegex('، {{raqms}}')  // → /، [٠-٩]+/u\n * templateToRegex('{{raqms}}+')   // → /[٠-٩]++/u (might be invalid in some engines)\n * templateToRegex('(((')          // → null (invalid regex)\n */\nexport const templateToRegex = (template: string) => {\n    const expanded = expandTokens(template);\n    try {\n        return new RegExp(expanded, 'u');\n    } catch {\n        return null;\n    }\n};\n\n/**\n * Lists all available token names defined in `TOKEN_PATTERNS`.\n *\n * Useful for documentation, validation, or building user interfaces\n * that show available tokens.\n *\n * @returns Array of token names (e.g., `['bab', 'basmala', 'bullet', ...]`)\n *\n * @example\n * getAvailableTokens()\n * // → ['bab', 'basmala', 'bullet', 'dash', 'harf', 'kitab', 'naql', 'raqm', 'raqms']\n */\nexport const getAvailableTokens = () => Object.keys(TOKEN_PATTERNS);\n\n/**\n * Gets the regex pattern for a specific token name.\n *\n * Returns the raw pattern string as defined in `TOKEN_PATTERNS`,\n * without any expansion or capture group wrapping.\n *\n * @param tokenName - The token name to look up (e.g., 'raqms', 'dash')\n * @returns The regex pattern string, or `undefined` if token doesn't exist\n *\n * @example\n * getTokenPattern('raqms')   // → '[\\\\u0660-\\\\u0669]+'\n * getTokenPattern('dash')    // → '[-–—ـ]'\n * getTokenPattern('unknown') // → undefined\n */\nexport const getTokenPattern = (tokenName: string) => TOKEN_PATTERNS[tokenName];\n\n/**\n * Tokens that should default to fuzzy matching when used in rules.\n *\n * These are Arabic phrase tokens where diacritic-insensitive matching\n * is almost always desired. Users can still override with `fuzzy: false`.\n */\nconst FUZZY_DEFAULT_TOKENS: (keyof typeof BASE_TOKENS)[] = ['bab', 'basmalah', 'fasl', 'kitab', 'naql'];\n\n/**\n * Regex to detect fuzzy-default tokens in a pattern string.\n * Matches {{token}} or {{token:name}} syntax.\n */\nconst FUZZY_TOKEN_REGEX = new RegExp(`\\\\{\\\\{(?:${FUZZY_DEFAULT_TOKENS.join('|')})(?::\\\\w+)?\\\\}\\\\}`, 'g');\n\n/**\n * Checks if a pattern (or array of patterns) contains tokens that should\n * default to fuzzy matching.\n *\n * Fuzzy-default tokens are: bab, basmalah, fasl, kitab, naql\n *\n * @param patterns - Single pattern string or array of pattern strings\n * @returns `true` if any pattern contains a fuzzy-default token\n *\n * @example\n * shouldDefaultToFuzzy('{{bab}} الإيمان')     // true\n * shouldDefaultToFuzzy('{{raqms}} {{dash}}')  // false\n * shouldDefaultToFuzzy(['{{kitab}}', '{{raqms}}']) // true\n */\nexport const shouldDefaultToFuzzy = (patterns: string | string[]) => {\n    const arr = Array.isArray(patterns) ? patterns : [patterns];\n    return arr.some((p) => {\n        FUZZY_TOKEN_REGEX.lastIndex = 0;\n        return FUZZY_TOKEN_REGEX.test(p);\n    });\n};\n\n/**\n * Structure for mapping a token to a capture name.\n */\nexport type TokenMapping = { token: string; name: string };\n\n/**\n * Apply token mappings to a template string.\n *\n * Transforms `{{token}}` into `{{token:name}}` based on the provided mappings.\n * Useful for applying user-configured capture names to a raw template.\n *\n * - Only affects exact matches of `{{token}}`.\n * - Does NOT affect tokens that already have a capture name (e.g. `{{token:existing}}`).\n * - Does NOT affect capture-only tokens (e.g. `{{:name}}`).\n *\n * @param template - The template string to transform\n * @param mappings - Array of mappings from token name to capture name\n * @returns Transformed template string with captures applied\n *\n * @example\n * applyTokenMappings('{{raqms}} {{dash}}', [{ token: 'raqms', name: 'num' }])\n * // → '{{raqms:num}} {{dash}}'\n */\nexport const applyTokenMappings = (template: string, mappings: TokenMapping[]): string => {\n    let result = template;\n    for (const { token, name } of mappings) {\n        if (!token || !name) {\n            continue;\n        }\n        // Match {{token}} but ensure it doesn't already have a suffix like :name\n        // We use a regex dealing with the brace syntax\n        const regex = new RegExp(`\\\\{\\\\{${token}\\\\}\\\\}`, 'g');\n        result = result.replace(regex, `{{${token}:${name}}}`);\n    }\n    return result;\n};\n\n/**\n * Strip token mappings from a template string.\n *\n * Transforms `{{token:name}}` back into `{{token}}`.\n * Also transforms `{{:name}}` patterns (capture-only) into `{{}}` (which is invalid/empty).\n *\n * Useful for normalizing templates for storage or comparison.\n *\n * @param template - The template string to strip\n * @returns Template string with capture names removed\n *\n * @example\n * stripTokenMappings('{{raqms:num}} {{dash}}')\n * // → '{{raqms}} {{dash}}'\n */\nexport const stripTokenMappings = (template: string) => {\n    // Match {{token:name}} and replace with {{token}}\n    return template.replace(/\\{\\{([^:}]+):[^}]+\\}\\}/g, '{{$1}}');\n};\n","// Shared utilities for analysis functions\n\nimport { getAvailableTokens, TOKEN_PATTERNS } from '../segmentation/tokens.js';\n\n// Helpers shared across analysis modules\n\n// For analysis signatures we avoid escaping ()[] because:\n// - These are commonly used literally in texts (e.g., \"(ح)\")\n// - When signatures are later used in template patterns, ()[] are auto-escaped there\n// We still escape other regex metacharacters to keep signatures safe if reused as templates.\nexport const escapeSignatureLiteral = (s: string): string => s.replace(/[.*+?^${}|\\\\{}]/g, '\\\\$&');\n\n// Keep this intentionally focused on \"useful at line start\" tokens, avoiding overly-generic tokens like {{harf}}.\nexport const TOKEN_PRIORITY_ORDER: string[] = [\n    'basmalah',\n    'kitab',\n    'bab',\n    'fasl',\n    'naql',\n    'rumuz',\n    'numbered',\n    'raqms',\n    'raqm',\n    'dash',\n    'bullet',\n    'tarqim',\n];\n\nexport const buildTokenPriority = (): string[] => {\n    const allTokens = new Set(getAvailableTokens());\n    // IMPORTANT: We only use an explicit allow-list here.\n    // Including \"all remaining tokens\" adds overly-generic tokens (e.g., harf) which makes signatures noisy.\n    return TOKEN_PRIORITY_ORDER.filter((t) => allTokens.has(t));\n};\n\nexport const collapseWhitespace = (s: string): string => s.replace(/\\s+/g, ' ').trim();\n\n// Arabic diacritics / tashkeel marks that commonly appear in Shamela texts.\n// This is intentionally conservative: remove combining marks but keep letters.\n// NOTE: Tatweel (U+0640) is NOT stripped here because it's used semantically as a dash/separator.\nexport const stripArabicDiacritics = (s: string): string =>\n    // harakat + common Quranic marks (no tatweel - it's used as a dash)\n    s.replace(/[\\u064B-\\u065F\\u0670\\u06D6-\\u06ED]/gu, '');\n\nexport type CompiledTokenRegex = { token: string; re: RegExp };\n\nexport const compileTokenRegexes = (tokenNames: string[]): CompiledTokenRegex[] =>\n    tokenNames\n        .map((token) => {\n            const pat = TOKEN_PATTERNS[token];\n            if (!pat) {\n                return null;\n            }\n            try {\n                return { re: new RegExp(pat, 'uy'), token };\n            } catch {\n                return null;\n            }\n        })\n        .filter((x): x is CompiledTokenRegex => x !== null);\n\nexport const appendWs = (out: string, mode: 'regex' | 'space'): string => {\n    if (!out) {\n        return out;\n    }\n    const suffix = mode === 'space' ? ' ' : '\\\\s*';\n    return out.endsWith(suffix) ? out : `${out}${suffix}`;\n};\n\nexport const findBestTokenMatchAt = (\n    s: string,\n    pos: number,\n    compiled: CompiledTokenRegex[],\n    isArabicLetter: (ch: string) => boolean,\n): { token: string; text: string } | null => {\n    let best: { token: string; text: string } | null = null;\n    for (const { token, re } of compiled) {\n        re.lastIndex = pos;\n        const m = re.exec(s);\n        if (!m || m.index !== pos) {\n            continue;\n        }\n        if (!best || m[0].length > best.text.length) {\n            best = { text: m[0], token };\n        }\n    }\n\n    if (best?.token === 'rumuz') {\n        const end = pos + best.text.length;\n        const next = end < s.length ? s[end] : '';\n        if (next && isArabicLetter(next) && !/\\s/u.test(next)) {\n            return null;\n        }\n    }\n\n    return best;\n};\n\n// IMPORTANT: do NOT treat all Arabic-block codepoints as \"letters\" (it includes punctuation like \"،\").\n// We only want to consider actual letters here for the rumuz boundary guard.\nexport const isArabicLetter = (ch: string): boolean => /\\p{Script=Arabic}/u.test(ch) && /\\p{L}/u.test(ch);\nexport const isCommonDelimiter = (ch: string): boolean => /[:：\\-–—ـ،؛.?!؟()[\\]{}]/u.test(ch);\n","// Line-starts analysis module\n\nimport type { Page } from '@/types/index.js';\nimport { normalizeLineEndings } from '@/utils/textUtils.js';\nimport {\n    appendWs,\n    buildTokenPriority,\n    type CompiledTokenRegex,\n    collapseWhitespace,\n    compileTokenRegexes,\n    escapeSignatureLiteral,\n    findBestTokenMatchAt,\n    isArabicLetter,\n    isCommonDelimiter,\n    stripArabicDiacritics,\n} from './shared.js';\n\n// Types\n\nexport type LineStartAnalysisOptions = {\n    topK?: number;\n    prefixChars?: number;\n    minLineLength?: number;\n    minCount?: number;\n    maxExamples?: number;\n    includeFirstWordFallback?: boolean;\n    normalizeArabicDiacritics?: boolean;\n    sortBy?: 'specificity' | 'count';\n    lineFilter?: (line: string, pageId: number) => boolean;\n    prefixMatchers?: RegExp[];\n    whitespace?: 'regex' | 'space';\n};\n\nexport type LineStartPatternExample = { line: string; pageId: number };\n\nexport type CommonLineStartPattern = {\n    pattern: string;\n    count: number;\n    examples: LineStartPatternExample[];\n};\n\n// Options resolution\n\ntype ResolvedOptions = Required<Omit<LineStartAnalysisOptions, 'lineFilter'>> & {\n    lineFilter?: LineStartAnalysisOptions['lineFilter'];\n};\n\nconst resolveOptions = (options: LineStartAnalysisOptions = {}): ResolvedOptions => ({\n    includeFirstWordFallback: options.includeFirstWordFallback ?? true,\n    lineFilter: options.lineFilter,\n    maxExamples: options.maxExamples ?? 1,\n    minCount: options.minCount ?? 3,\n    minLineLength: options.minLineLength ?? 6,\n    normalizeArabicDiacritics: options.normalizeArabicDiacritics ?? true,\n    prefixChars: options.prefixChars ?? 60,\n    prefixMatchers: options.prefixMatchers ?? [/^#+/u],\n    sortBy: options.sortBy ?? 'specificity',\n    topK: options.topK ?? 40,\n    whitespace: options.whitespace ?? 'regex',\n});\n\n// Specificity & sorting\n\nconst countTokenMarkers = (pattern: string): number => (pattern.match(/\\{\\{/g) ?? []).length;\n\nconst computeSpecificity = (pattern: string) => ({\n    literalLen: pattern.replace(/\\\\s\\*/g, '').replace(/[ \\t]+/g, '').length,\n    tokenCount: countTokenMarkers(pattern),\n});\n\nconst compareBySpecificity = (a: CommonLineStartPattern, b: CommonLineStartPattern): number => {\n    const sa = computeSpecificity(a.pattern),\n        sb = computeSpecificity(b.pattern);\n    return (\n        sb.tokenCount - sa.tokenCount ||\n        sb.literalLen - sa.literalLen ||\n        b.count - a.count ||\n        a.pattern.localeCompare(b.pattern)\n    );\n};\n\nconst compareByCount = (a: CommonLineStartPattern, b: CommonLineStartPattern): number =>\n    b.count !== a.count ? b.count - a.count : compareBySpecificity(a, b);\n\n// Signature building helpers\n\n/** Remove trailing whitespace placeholders */\nconst trimTrailingWs = (out: string, mode: 'regex' | 'space'): string => {\n    const suffix = mode === 'regex' ? '\\\\s*' : ' ';\n    while (out.endsWith(suffix)) {\n        out = out.slice(0, -suffix.length);\n    }\n    return out;\n};\n\n/** Try to extract first word for fallback */\nconst extractFirstWord = (s: string): string | null => (s.match(/^[^\\s:،؛.?!؟]+/u) ?? [])[0] ?? null;\n\n/** Consume prefix matchers at current position */\nconst consumePrefixes = (\n    s: string,\n    pos: number,\n    out: string,\n    matchers: RegExp[],\n    ws: 'regex' | 'space',\n): { pos: number; out: string; matched: boolean } => {\n    let matched = false;\n    for (const re of matchers) {\n        if (pos >= s.length) {\n            break;\n        }\n        const m = re.exec(s.slice(pos));\n        if (!m?.index && m?.[0]) {\n            out += escapeSignatureLiteral(m[0]);\n            pos += m[0].length;\n            matched = true;\n            const wsm = /^[ \\t]+/u.exec(s.slice(pos));\n            if (wsm) {\n                pos += wsm[0].length;\n                out = appendWs(out, ws);\n            }\n        }\n    }\n    return { matched, out, pos };\n};\n\n/** Try to match a token at current position and append to signature */\nconst tryMatchToken = (\n    s: string,\n    pos: number,\n    out: string,\n    compiled: CompiledTokenRegex[],\n): { pos: number; out: string; matched: boolean } => {\n    const best = findBestTokenMatchAt(s, pos, compiled, isArabicLetter);\n    if (!best) {\n        return { matched: false, out, pos };\n    }\n    return { matched: true, out: `${out}{{${best.token}}}`, pos: pos + best.text.length };\n};\n\n/** Try to match a delimiter at current position */\nconst tryMatchDelimiter = (s: string, pos: number, out: string): { pos: number; out: string; matched: boolean } => {\n    const ch = s[pos];\n    if (!ch || !isCommonDelimiter(ch)) {\n        return { matched: false, out, pos };\n    }\n    return { matched: true, out: out + escapeSignatureLiteral(ch), pos: pos + 1 };\n};\n\n/** Skip whitespace at position */\nconst skipWhitespace = (\n    s: string,\n    pos: number,\n    out: string,\n    ws: 'regex' | 'space',\n): { pos: number; out: string; skipped: boolean } => {\n    const m = /^[ \\t]+/u.exec(s.slice(pos));\n    if (!m) {\n        return { out, pos, skipped: false };\n    }\n    return { out: appendWs(out, ws), pos: pos + m[0].length, skipped: true };\n};\n\n// Main tokenization\n\nconst tokenizeLineStart = (line: string, tokenNames: string[], opts: ResolvedOptions): string | null => {\n    const trimmed = collapseWhitespace(line);\n    if (!trimmed) {\n        return null;\n    }\n\n    const s = (opts.normalizeArabicDiacritics ? stripArabicDiacritics(trimmed) : trimmed).slice(0, opts.prefixChars);\n    const compiled = compileTokenRegexes(tokenNames);\n\n    let pos = 0,\n        out = '',\n        matchedAny = false,\n        matchedToken = false,\n        steps = 0;\n\n    // Consume prefixes\n    const prefix = consumePrefixes(s, pos, out, opts.prefixMatchers, opts.whitespace);\n    pos = prefix.pos;\n    out = prefix.out;\n    matchedAny = prefix.matched;\n\n    while (steps < 6 && pos < s.length) {\n        // Skip whitespace\n        const ws = skipWhitespace(s, pos, out, opts.whitespace);\n        if (ws.skipped) {\n            pos = ws.pos;\n            out = ws.out;\n            continue;\n        }\n\n        // Try token\n        const tok = tryMatchToken(s, pos, out, compiled);\n        if (tok.matched) {\n            pos = tok.pos;\n            out = tok.out;\n            matchedAny = matchedToken = true;\n            steps++;\n            continue;\n        }\n\n        // Try delimiter (only after matching something)\n        if (matchedAny) {\n            const delim = tryMatchDelimiter(s, pos, out);\n            if (delim.matched) {\n                pos = delim.pos;\n                out = delim.out;\n                continue;\n            }\n        }\n\n        // Fallback logic\n        if (matchedAny) {\n            if (opts.includeFirstWordFallback && !matchedToken) {\n                const word = extractFirstWord(s.slice(pos));\n                if (word) {\n                    out += escapeSignatureLiteral(word);\n                    steps++;\n                }\n            }\n            break;\n        }\n\n        if (!opts.includeFirstWordFallback) {\n            return null;\n        }\n\n        const word = extractFirstWord(s.slice(pos));\n        if (!word) {\n            return null;\n        }\n        return escapeSignatureLiteral(word);\n    }\n\n    return matchedAny ? trimTrailingWs(out, opts.whitespace) : null;\n};\n\n// Page processing\n\ntype PatternAccumulator = Map<string, { count: number; examples: LineStartPatternExample[] }>;\n\nconst processLine = (\n    line: string,\n    pageId: number,\n    tokenPriority: string[],\n    opts: ResolvedOptions,\n    acc: PatternAccumulator,\n): void => {\n    const trimmed = collapseWhitespace(line);\n    if (trimmed.length < opts.minLineLength) {\n        return;\n    }\n    if (opts.lineFilter && !opts.lineFilter(trimmed, pageId)) {\n        return;\n    }\n\n    const sig = tokenizeLineStart(trimmed, tokenPriority, opts);\n    if (!sig) {\n        return;\n    }\n\n    const entry = acc.get(sig);\n    if (!entry) {\n        acc.set(sig, { count: 1, examples: [{ line: trimmed, pageId }] });\n    } else {\n        entry.count++;\n        if (entry.examples.length < opts.maxExamples) {\n            entry.examples.push({ line: trimmed, pageId });\n        }\n    }\n};\n\nconst processPage = (page: Page, tokenPriority: string[], opts: ResolvedOptions, acc: PatternAccumulator): void => {\n    for (const line of normalizeLineEndings(page.content ?? '').split('\\n')) {\n        processLine(line, page.id, tokenPriority, opts, acc);\n    }\n};\n\n// Main export\n\n/**\n * Analyze pages and return the most common line-start patterns (top K).\n */\nexport const analyzeCommonLineStarts = (\n    pages: Page[],\n    options: LineStartAnalysisOptions = {},\n): CommonLineStartPattern[] => {\n    const opts = resolveOptions(options);\n    const tokenPriority = buildTokenPriority();\n    const acc: PatternAccumulator = new Map();\n\n    for (const page of pages) {\n        processPage(page, tokenPriority, opts, acc);\n    }\n\n    const comparator = opts.sortBy === 'count' ? compareByCount : compareBySpecificity;\n\n    return [...acc.entries()]\n        .map(([pattern, v]) => ({ count: v.count, examples: v.examples, pattern }))\n        .filter((p) => p.count >= opts.minCount)\n        .sort(comparator)\n        .slice(0, opts.topK);\n};\n","// Repeating sequences analysis module\n\nimport type { Page } from '@/types/index.js';\nimport {\n    buildTokenPriority,\n    compileTokenRegexes,\n    escapeSignatureLiteral,\n    findBestTokenMatchAt,\n    isArabicLetter,\n    isCommonDelimiter,\n    stripArabicDiacritics,\n} from './shared.js';\n\n// Types\n\nexport type TokenStreamItem = {\n    type: 'token' | 'literal';\n    /** The represented value (e.g. \"{{naql}}\" or \"hello\") */\n    text: string;\n    /** The original raw text (e.g. \"حَدَّثَنَا\") */\n    raw: string;\n    start: number;\n    end: number;\n};\n\nexport type RepeatingSequenceOptions = {\n    minElements?: number;\n    maxElements?: number;\n    minCount?: number;\n    topK?: number;\n    normalizeArabicDiacritics?: boolean;\n    requireToken?: boolean;\n    whitespace?: 'regex' | 'space';\n    maxExamples?: number;\n    contextChars?: number;\n    maxUniquePatterns?: number;\n};\n\nexport type RepeatingSequenceExample = {\n    text: string;\n    context: string;\n    pageId: number;\n    startIndices: number[];\n};\n\nexport type RepeatingSequencePattern = {\n    pattern: string;\n    count: number;\n    examples: RepeatingSequenceExample[];\n};\n\ntype PatternStats = {\n    count: number;\n    examples: RepeatingSequenceExample[];\n    tokenCount: number;\n    literalLen: number;\n};\n\n// Resolved options with defaults\n\ntype ResolvedOptions = Required<RepeatingSequenceOptions>;\n\nconst resolveOptions = (options?: RepeatingSequenceOptions): ResolvedOptions => {\n    const minElements = Math.max(1, options?.minElements ?? 1);\n    return {\n        contextChars: options?.contextChars ?? 50,\n        maxElements: Math.max(minElements, options?.maxElements ?? 3),\n        maxExamples: options?.maxExamples ?? 3,\n        maxUniquePatterns: options?.maxUniquePatterns ?? 1000,\n        minCount: Math.max(1, options?.minCount ?? 3),\n        minElements,\n        normalizeArabicDiacritics: options?.normalizeArabicDiacritics ?? true,\n        requireToken: options?.requireToken ?? true,\n        topK: Math.max(1, options?.topK ?? 20),\n        whitespace: options?.whitespace ?? 'regex',\n    };\n};\n\n// Raw position tracking for diacritic normalization\n\n/** Creates a cursor that tracks position in both normalized and raw text */\nconst createRawCursor = (text: string, normalize: boolean) => {\n    let rawPos = 0;\n\n    return {\n        /** Advance cursor, returning the raw text chunk consumed */\n        advance(normalizedLen: number): string {\n            if (!normalize) {\n                const chunk = text.slice(rawPos, rawPos + normalizedLen);\n                rawPos += normalizedLen;\n                return chunk;\n            }\n\n            const start = rawPos;\n            let matchedLen = 0;\n\n            // Match normalized characters\n            while (matchedLen < normalizedLen && rawPos < text.length) {\n                if (stripArabicDiacritics(text[rawPos]).length > 0) {\n                    matchedLen++;\n                }\n                rawPos++;\n            }\n\n            // Consume trailing diacritics (belong to last character)\n            while (rawPos < text.length && stripArabicDiacritics(text[rawPos]).length === 0) {\n                rawPos++;\n            }\n\n            return text.slice(start, rawPos);\n        },\n        get pos() {\n            return rawPos;\n        },\n    };\n};\n\n// Token content scanner\n\n/** Scans text and produces a stream of tokens and literals. */\nexport const tokenizeContent = (text: string, normalize: boolean): TokenStreamItem[] => {\n    const normalized = normalize ? stripArabicDiacritics(text) : text;\n    const compiled = compileTokenRegexes(buildTokenPriority());\n    const cursor = createRawCursor(text, normalize);\n    const items: TokenStreamItem[] = [];\n    let pos = 0;\n\n    while (pos < normalized.length) {\n        // Skip whitespace\n        const ws = /^\\s+/u.exec(normalized.slice(pos));\n        if (ws) {\n            pos += ws[0].length;\n            cursor.advance(ws[0].length);\n            continue;\n        }\n\n        // Try token\n        const token = findBestTokenMatchAt(normalized, pos, compiled, isArabicLetter);\n        if (token) {\n            const raw = cursor.advance(token.text.length);\n            items.push({\n                end: cursor.pos,\n                raw,\n                start: cursor.pos - raw.length,\n                text: `{{${token.token}}}`,\n                type: 'token',\n            });\n            pos += token.text.length;\n            continue;\n        }\n\n        // Try delimiter\n        if (isCommonDelimiter(normalized[pos])) {\n            const raw = cursor.advance(1);\n            items.push({\n                end: cursor.pos,\n                raw,\n                start: cursor.pos - 1,\n                text: escapeSignatureLiteral(normalized[pos]),\n                type: 'literal',\n            });\n            pos++;\n            continue;\n        }\n\n        // Literal word\n        const word = /^[^\\s:：\\-–—ـ،؛.?!؟()[\\]{}]+/u.exec(normalized.slice(pos));\n        if (word) {\n            const raw = cursor.advance(word[0].length);\n            items.push({\n                end: cursor.pos,\n                raw,\n                start: cursor.pos - raw.length,\n                text: escapeSignatureLiteral(word[0]),\n                type: 'literal',\n            });\n            pos += word[0].length;\n            continue;\n        }\n\n        cursor.advance(1);\n        pos++;\n    }\n\n    return items;\n};\n\n// N-gram pattern extraction\n\n/** Build pattern string from window items */\nconst buildPattern = (window: TokenStreamItem[], whitespace: 'regex' | 'space'): string =>\n    window.map((i) => i.text).join(whitespace === 'space' ? ' ' : '\\\\s*');\n\n/** Check if window contains at least one token */\nconst hasTokenInWindow = (window: TokenStreamItem[]): boolean => window.some((i) => i.type === 'token');\n\n/** Compute token count and literal length for a window */\nconst computeWindowStats = (window: TokenStreamItem[]) => {\n    let tokenCount = 0,\n        literalLen = 0;\n    for (const item of window) {\n        if (item.type === 'token') {\n            tokenCount++;\n        } else {\n            literalLen += item.text.length;\n        }\n    }\n    return { literalLen, tokenCount };\n};\n\n/** Build example from page content and window */\nconst buildExample = (page: Page, window: TokenStreamItem[], contextChars: number): RepeatingSequenceExample => {\n    const start = window[0].start;\n    const end = window.at(-1)!.end;\n    const ctxStart = Math.max(0, start - contextChars);\n    const ctxEnd = Math.min(page.content.length, end + contextChars);\n\n    return {\n        context:\n            (ctxStart > 0 ? '...' : '') +\n            page.content.slice(ctxStart, ctxEnd) +\n            (ctxEnd < page.content.length ? '...' : ''),\n        pageId: page.id,\n        startIndices: window.map((w) => w.start),\n        text: page.content.slice(start, end),\n    };\n};\n\n/** Extract N-grams from a single page */\nconst extractPageNgrams = (\n    page: Page,\n    items: TokenStreamItem[],\n    opts: ResolvedOptions,\n    stats: Map<string, PatternStats>,\n): void => {\n    for (let i = 0; i <= items.length - opts.minElements; i++) {\n        for (let n = opts.minElements; n <= Math.min(opts.maxElements, items.length - i); n++) {\n            const window = items.slice(i, i + n);\n\n            if (opts.requireToken && !hasTokenInWindow(window)) {\n                continue;\n            }\n\n            const pattern = buildPattern(window, opts.whitespace);\n\n            if (!stats.has(pattern)) {\n                if (stats.size >= opts.maxUniquePatterns) {\n                    continue;\n                }\n                stats.set(pattern, { count: 0, examples: [], ...computeWindowStats(window) });\n            }\n\n            const entry = stats.get(pattern)!;\n            entry.count++;\n\n            if (entry.examples.length < opts.maxExamples) {\n                entry.examples.push(buildExample(page, window, opts.contextChars));\n            }\n        }\n    }\n};\n\n// Main export\n\n/**\n * Analyze pages for commonly repeating word sequences.\n *\n * Use for continuous text without line breaks. For line-based analysis,\n * use `analyzeCommonLineStarts()` instead.\n */\nexport const analyzeRepeatingSequences = (\n    pages: Page[],\n    options?: RepeatingSequenceOptions,\n): RepeatingSequencePattern[] => {\n    const opts = resolveOptions(options);\n    const stats = new Map<string, PatternStats>();\n\n    for (const page of pages) {\n        if (!page.content) {\n            continue;\n        }\n        extractPageNgrams(page, tokenizeContent(page.content, opts.normalizeArabicDiacritics), opts, stats);\n    }\n\n    return [...stats.entries()]\n        .filter(([, s]) => s.count >= opts.minCount)\n        .sort(\n            (a, b) => b[1].count - a[1].count || b[1].tokenCount - a[1].tokenCount || b[1].literalLen - a[1].literalLen,\n        )\n        .slice(0, opts.topK)\n        .map(([pattern, s]) => ({ count: s.count, examples: s.examples, pattern }));\n};\n","import { getAvailableTokens, TOKEN_PATTERNS } from './segmentation/tokens.js';\n\n/**\n * Result of detecting a token pattern in text\n */\nexport type DetectedPattern = {\n    /** Token name from TOKEN_PATTERNS (e.g., 'raqms', 'dash') */\n    token: string;\n    /** The matched text */\n    match: string;\n    /** Start index in the original text */\n    index: number;\n    /** End index (exclusive) */\n    endIndex: number;\n};\n\n/**\n * Token detection order - more specific patterns first to avoid partial matches.\n * Example: 'raqms' before 'raqm' so \"٣٤\" matches 'raqms' not just the first digit.\n *\n * Tokens not in this list are appended in alphabetical order from TOKEN_PATTERNS.\n */\nconst TOKEN_PRIORITY_ORDER = [\n    'basmalah', // Most specific - full phrase\n    'kitab',\n    'bab',\n    'fasl',\n    'naql',\n    'rumuz', // Source abbreviations (e.g., \"خت\", \"خ سي\", \"٤\")\n    'numbered', // Composite: raqms + dash\n    'raqms', // Multiple digits before single digit\n    'raqm',\n    'tarqim',\n    'bullet',\n    'dash',\n    'harf',\n];\n\n/**\n * Gets the token detection priority order.\n * Returns tokens in priority order, with any TOKEN_PATTERNS not in the priority list appended.\n */\nconst getTokenPriority = () => {\n    const allTokens = getAvailableTokens();\n    const prioritized = TOKEN_PRIORITY_ORDER.filter((t) => allTokens.includes(t));\n    const remaining = allTokens.filter((t) => !TOKEN_PRIORITY_ORDER.includes(t)).sort();\n    return [...prioritized, ...remaining];\n};\n\nconst isRumuzStandalone = (text: string, startIndex: number, endIndex: number): boolean => {\n    // We want rumuz to behave like a standalone marker (e.g. \"س:\" or \"خت ٤:\"),\n    // not a substring match inside normal Arabic words (e.g. \"إِبْرَاهِيم\").\n    const before = startIndex > 0 ? text[startIndex - 1] : '';\n    const after = endIndex < text.length ? text[endIndex] : '';\n\n    const isWhitespace = (ch: string): boolean => !!ch && /\\s/u.test(ch);\n    const isOpenBracket = (ch: string): boolean => !!ch && /[([{]/u.test(ch);\n    const isRightDelimiter = (ch: string): boolean => !!ch && /[:：\\-–—ـ،؛.?!؟)\\]}]/u.test(ch);\n\n    // Treat any Arabic-block codepoint (letters + diacritics + digits) as \"wordy\" context.\n    // Unicode Script properties can classify some combining marks as \"Inherited\", so we avoid \\p{Script=Arabic}.\n    const isArabicWordy = (ch: string): boolean => !!ch && /[\\u0600-\\u06FF]/u.test(ch);\n\n    const leftOk = !before || isWhitespace(before) || isOpenBracket(before) || !isArabicWordy(before);\n    const rightOk = !after || isWhitespace(after) || isRightDelimiter(after) || !isArabicWordy(after);\n\n    return leftOk && rightOk;\n};\n\n/**\n * Analyzes text and returns all detected token patterns with their positions.\n * Patterns are detected in priority order to avoid partial matches.\n *\n * @param text - The text to analyze for token patterns\n * @returns Array of detected patterns sorted by position\n *\n * @example\n * detectTokenPatterns(\"٣٤ - حدثنا\")\n * // Returns: [\n * //   { token: 'raqms', match: '٣٤', index: 0, endIndex: 2 },\n * //   { token: 'dash', match: '-', index: 3, endIndex: 4 },\n * //   { token: 'naql', match: 'حدثنا', index: 5, endIndex: 10 }\n * // ]\n */\nexport const detectTokenPatterns = (text: string) => {\n    if (!text) {\n        return [];\n    }\n\n    const results: DetectedPattern[] = [];\n    const coveredRanges: Array<[number, number]> = [];\n\n    // Check if a position is already covered by a detected pattern\n    const isPositionCovered = (start: number, end: number): boolean => {\n        return coveredRanges.some(\n            ([s, e]) => (start >= s && start < e) || (end > s && end <= e) || (start <= s && end >= e),\n        );\n    };\n\n    // Process tokens in priority order\n    for (const tokenName of getTokenPriority()) {\n        const pattern = TOKEN_PATTERNS[tokenName];\n        if (!pattern) {\n            continue;\n        }\n\n        try {\n            // Create a global regex to find all matches\n            const regex = new RegExp(`(${pattern})`, 'gu');\n            let match: RegExpExecArray | null;\n\n            // biome-ignore lint/suspicious/noAssignInExpressions: standard regex exec loop pattern\n            while ((match = regex.exec(text)) !== null) {\n                const startIndex = match.index;\n                const endIndex = startIndex + match[0].length;\n\n                if (tokenName === 'rumuz' && !isRumuzStandalone(text, startIndex, endIndex)) {\n                    continue;\n                }\n\n                // Skip if this range overlaps with an already detected pattern\n                if (isPositionCovered(startIndex, endIndex)) {\n                    continue;\n                }\n\n                results.push({ endIndex, index: startIndex, match: match[0], token: tokenName });\n\n                coveredRanges.push([startIndex, endIndex]);\n            }\n        } catch {}\n    }\n\n    return results.sort((a, b) => a.index - b.index);\n};\n\n/**\n * Generates a template pattern from text using detected tokens.\n * Replaces matched portions with {{token}} syntax.\n *\n * @param text - Original text\n * @param detected - Array of detected patterns from detectTokenPatterns\n * @returns Template string with tokens, e.g., \"{{raqms}} {{dash}} \"\n *\n * @example\n * const detected = detectTokenPatterns(\"٣٤ - \");\n * generateTemplateFromText(\"٣٤ - \", detected);\n * // Returns: \"{{raqms}} {{dash}} \"\n */\nexport const generateTemplateFromText = (text: string, detected: DetectedPattern[]) => {\n    if (!text || detected.length === 0) {\n        return text;\n    }\n\n    // Build template by replacing detected patterns with tokens\n    // Process in reverse order to preserve indices\n    let template = text;\n    const sortedByIndexDesc = [...detected].sort((a, b) => b.index - a.index);\n\n    for (const d of sortedByIndexDesc) {\n        template = `${template.slice(0, d.index)}{{${d.token}}}${template.slice(d.endIndex)}`;\n    }\n\n    return template;\n};\n\n/**\n * Determines the best pattern type for auto-generated rules based on detected patterns.\n *\n * @param detected - Array of detected patterns\n * @returns Suggested pattern type and whether to use fuzzy matching\n */\nexport const suggestPatternConfig = (\n    detected: DetectedPattern[],\n): { patternType: 'lineStartsWith' | 'lineStartsAfter'; fuzzy: boolean; metaType?: string } => {\n    // Check if the detected patterns suggest a structural marker (chapter, book, etc.)\n    const hasStructuralToken = detected.some((d) => ['basmalah', 'kitab', 'bab', 'fasl'].includes(d.token));\n\n    // Check if the pattern is numbered (hadith-style)\n    const hasNumberedPattern = detected.some((d) => ['raqms', 'raqm', 'numbered'].includes(d.token));\n\n    // If it starts with a structural token, use lineStartsWith (keep marker in content)\n    if (hasStructuralToken) {\n        return {\n            fuzzy: true,\n            metaType: detected.find((d) => ['kitab', 'bab', 'fasl'].includes(d.token))?.token || 'chapter',\n            patternType: 'lineStartsWith',\n        };\n    }\n\n    // If it's a numbered pattern (like hadith numbers), use lineStartsAfter (strip prefix)\n    if (hasNumberedPattern) {\n        return { fuzzy: false, metaType: 'hadith', patternType: 'lineStartsAfter' };\n    }\n\n    // Default: use lineStartsAfter without fuzzy\n    return { fuzzy: false, patternType: 'lineStartsAfter' };\n};\n\n/**\n * Analyzes text and generates a complete suggested rule configuration.\n *\n * @param text - Highlighted text from the page\n * @returns Suggested rule configuration or null if no patterns detected\n */\nexport const analyzeTextForRule = (\n    text: string,\n): {\n    template: string;\n    patternType: 'lineStartsWith' | 'lineStartsAfter';\n    fuzzy: boolean;\n    metaType?: string;\n    detected: DetectedPattern[];\n} | null => {\n    const detected = detectTokenPatterns(text);\n\n    if (detected.length === 0) {\n        return null;\n    }\n\n    const template = generateTemplateFromText(text, detected);\n    const config = suggestPatternConfig(detected);\n\n    return { detected, template, ...config };\n};\n","import type { PageRange } from './index.js';\n\n/**\n * Literal regex pattern rule - no token expansion or auto-escaping is applied.\n *\n * Use this when you need full control over the regex pattern, including:\n * - Character classes like `[أب]` to match أ or ب\n * - Capturing groups like `(test|text)` for alternation\n * - Any other regex syntax that would be escaped in template patterns\n *\n * If the regex contains capturing groups, the captured content\n * will be used as the segment content.\n *\n * **Note**: Unlike `template`, `lineStartsWith`, etc., this pattern type\n * does NOT auto-escape `()[]`. You have full regex control.\n *\n * @example\n * // Match Arabic-Indic numbers followed by a dash\n * { regex: '^[٠-٩]+ - ', split: 'at' }\n *\n * @example\n * // Character class - matches أ or ب\n * { regex: '^[أب] ', split: 'at' }\n *\n * @example\n * // Capture group - content after the marker becomes segment content\n * { regex: '^[٠-٩]+ - (.*)', split: 'at' }\n */\ntype RegexPattern = {\n    /** Raw regex pattern string (no token expansion, no auto-escaping) */\n    regex: string;\n};\n\n/**\n * Template pattern rule - expands `{{tokens}}` before compiling to regex.\n *\n * Supports all tokens defined in `TOKEN_PATTERNS` and named capture syntax.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. Write `({{harf}}):` instead of\n * `\\\\({{harf}}\\\\):`. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Using tokens for Arabic-Indic digits\n * { template: '^{{raqms}} {{dash}}', split: 'at' }\n *\n * @example\n * // Named capture to extract hadith number into metadata\n * { template: '^{{raqms:hadithNum}} {{dash}}', split: 'at' }\n *\n * @example\n * // Auto-escaped brackets - matches literal (أ):\n * { template: '^({{harf}}): ', split: 'at' }\n *\n * @see TOKEN_PATTERNS for available tokens\n */\ntype TemplatePattern = {\n    /** Template string with `{{token}}` or `{{token:name}}` placeholders. Brackets `()[]` are auto-escaped. */\n    template: string;\n};\n\n/**\n * Line-start pattern rule - matches lines starting with any of the given patterns.\n *\n * Syntactic sugar for `^(?:pattern1|pattern2|...)`. The matched marker\n * is **included** in the segment content.\n *\n * Token expansion is applied to each pattern. Use `fuzzy: true` for\n * diacritic-insensitive Arabic matching.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. Write `({{harf}})` instead of\n * `\\\\({{harf}}\\\\)`. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Split at chapter headings (marker included in content)\n * { lineStartsWith: ['## ', '### '], split: 'at' }\n *\n * @example\n * // Split at Arabic book/chapter markers with fuzzy matching\n * { lineStartsWith: ['{{kitab}}', '{{bab}}'], split: 'at', fuzzy: true }\n *\n * @example\n * // Auto-escaped brackets - matches literal (أ)\n * { lineStartsWith: ['({{harf}}) '], split: 'at' }\n */\ntype LineStartsWithPattern = {\n    /** Array of patterns that mark line beginnings (marker included in content). Brackets `()[]` are auto-escaped. */\n    lineStartsWith: string[];\n};\n\n/**\n * Line-start-after pattern rule - matches lines starting with patterns,\n * but **excludes** the marker from the segment content.\n *\n * Behaves like `lineStartsWith` but strips the marker from the output.\n * The segment content starts after the marker and extends to the next split point\n * (not just the end of the matching line).\n *\n * Token expansion is applied to each pattern. Use `fuzzy: true` for\n * diacritic-insensitive Arabic matching.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. Write `({{harf}}):` instead of\n * `\\\\({{harf}}\\\\):`. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Split at numbered hadiths, capturing content without the number prefix\n * // Content extends to next split, not just end of that line\n * { lineStartsAfter: ['{{raqms}} {{dash}} '], split: 'at' }\n *\n * @example\n * // Extract hadith number to metadata while stripping the prefix\n * { lineStartsAfter: ['{{raqms:num}} {{dash}} '], split: 'at' }\n *\n * @example\n * // Auto-escaped brackets - matches literal (أ): prefix\n * { lineStartsAfter: ['({{harf}}): '], split: 'at' }\n */\ntype LineStartsAfterPattern = {\n    /** Array of patterns that mark line beginnings (marker excluded from content). Brackets `()[]` are auto-escaped. */\n    lineStartsAfter: string[];\n};\n\n/**\n * Line-end pattern rule - matches lines ending with any of the given patterns.\n *\n * Syntactic sugar for `(?:pattern1|pattern2|...)$`.\n *\n * Token expansion is applied to each pattern. Use `fuzzy: true` for\n * diacritic-insensitive Arabic matching.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Split at lines ending with Arabic sentence-ending punctuation\n * { lineEndsWith: ['۔', '؟', '!'], split: 'after' }\n *\n * @example\n * // Auto-escaped brackets - matches literal (انتهى) suffix\n * { lineEndsWith: ['(انتهى)'], split: 'after' }\n */\ntype LineEndsWithPattern = {\n    /** Array of patterns that mark line endings. Brackets `()[]` are auto-escaped. */\n    lineEndsWith: string[];\n};\n\n/**\n * Union of all pattern types for split rules.\n *\n * Each rule must have exactly ONE pattern type:\n * - `regex` - Raw regex pattern (no token expansion)\n * - `template` - Pattern with `{{token}}` expansion\n * - `lineStartsWith` - Match line beginnings (marker included)\n * - `lineStartsAfter` - Match line beginnings (marker excluded)\n * - `lineEndsWith` - Match line endings\n */\ntype PatternType =\n    | RegexPattern\n    | TemplatePattern\n    | LineStartsWithPattern\n    | LineStartsAfterPattern\n    | LineEndsWithPattern;\n\n/**\n * Pattern type key names for split rules.\n *\n * Use this array to dynamically iterate over pattern types in UIs,\n * or use the `PatternTypeKey` type for type-safe string unions.\n *\n * @example\n * // Build a dropdown/select in UI\n * PATTERN_TYPE_KEYS.map(key => <option value={key}>{key}</option>)\n *\n * @example\n * // Type-safe pattern key validation\n * const validateKey = (k: string): k is PatternTypeKey =>\n *   (PATTERN_TYPE_KEYS as readonly string[]).includes(k);\n */\nexport const PATTERN_TYPE_KEYS = ['lineStartsWith', 'lineStartsAfter', 'lineEndsWith', 'template', 'regex'] as const;\n\n/**\n * String union of pattern type key names.\n *\n * Derived from `PATTERN_TYPE_KEYS` to stay in sync automatically.\n */\nexport type PatternTypeKey = (typeof PATTERN_TYPE_KEYS)[number];\n\n// Split Behavior\n\n/**\n * Configuration for how and where to split content when a pattern matches.\n *\n * Controls the split position relative to matches, which occurrences to\n * split on, page span limits, and fuzzy matching for Arabic text.\n */\ntype SplitBehavior = {\n    /**\n     * Where to split relative to the match.\n     * - `'at'`: New segment starts at the match position\n     * - `'after'`: New segment starts after the match ends\n     * @default 'at'\n     */\n    split?: 'at' | 'after';\n\n    /**\n     * Which occurrence(s) to split on.\n     * - `'all'`: Split at every match (default)\n     * - `'first'`: Only split at the first match\n     * - `'last'`: Only split at the last match\n     *\n     * @default 'all'\n     */\n    occurrence?: 'first' | 'last' | 'all';\n\n    /**\n     * Enable diacritic-insensitive matching for Arabic text.\n     *\n     * When `true`, patterns in `lineStartsWith`, `lineEndsWith`, and\n     * `lineStartsAfter` are transformed to match text regardless of:\n     * - Diacritics (harakat/tashkeel): فَتْحَة، ضَمَّة، كَسْرَة، etc.\n     * - Character equivalences: ا/آ/أ/إ, ة/ه, ى/ي\n     *\n     * **Note**: Does NOT apply to `regex` or `template` patterns.\n     * For templates, apply fuzzy manually using `makeDiacriticInsensitive()`.\n     *\n     * @default false\n     */\n    fuzzy?: boolean;\n};\n\n/**\n * Optional constraints and metadata for a split rule.\n *\n * Use constraints to limit which pages a rule applies to, and\n * metadata to attach arbitrary data to resulting segments.\n */\ntype RuleConstraints = {\n    /**\n     * Minimum page ID for this rule to apply.\n     *\n     * Matches on pages with `id < min` are ignored.\n     *\n     * @example\n     * // Only apply rule starting from page 10\n     * { min: 10, lineStartsWith: ['##'], split: 'before' }\n     */\n    min?: number;\n\n    /**\n     * Maximum page ID for this rule to apply.\n     *\n     * Matches on pages with `id > max` are ignored.\n     *\n     * @example\n     * // Only apply rule up to page 100\n     * { max: 100, lineStartsWith: ['##'], split: 'before' }\n     */\n    max?: number;\n\n    /**\n     * Specific pages or page ranges to exclude from this rule.\n     *\n     * Use this to skip the rule for specific pages without needing\n     * to repeat the rule with different min/max values.\n     *\n     * @example\n     * // Exclude specific pages\n     * { exclude: [1, 2, 5] }\n     *\n     * @example\n     * // Exclude page ranges\n     * { exclude: [[1, 10], [50, 100]] }\n     *\n     * @example\n     * // Mix single pages and ranges\n     * { exclude: [1, [5, 10], 50] }\n     */\n    exclude?: PageRange[];\n\n    /**\n     * Arbitrary metadata attached to segments matching this rule.\n     *\n     * This metadata is merged with any named captures from the pattern.\n     * Named captures (e.g., `{{raqms:num}}`) take precedence over\n     * static metadata with the same key.\n     *\n     * @example\n     * // Tag segments as chapters\n     * { lineStartsWith: ['{{bab}}'], split: 'before', meta: { type: 'chapter' } }\n     */\n    meta?: Record<string, unknown>;\n\n    /**\n     * Page-start guard: only allow this rule to match at the START of a page if the\n     * previous page's last non-whitespace character matches this pattern.\n     *\n     * This is useful for avoiding false positives caused purely by page wrap.\n     *\n     * Example use-case:\n     * - Split on `{{naql}}` at line starts (e.g. \"أخبرنا ...\")\n     * - BUT if a new page starts with \"أخبرنا ...\" and the previous page did NOT\n     *   end with sentence-ending punctuation, treat it as a continuation and do not split.\n     *\n     * Notes:\n     * - This guard applies ONLY at page starts, not mid-page line starts.\n     * - This is a template pattern (tokens allowed). It is checked against the LAST\n     *   non-whitespace character of the previous page's content.\n     *\n     * @example\n     * // Allow split at page start only if previous page ends with sentence punctuation\n     * { lineStartsWith: ['{{naql}}'], fuzzy: true, pageStartGuard: '{{tarqim}}' }\n     */\n    pageStartGuard?: string;\n};\n\n// Combined Rule Type\n\n/**\n * A complete split rule combining pattern, behavior, and constraints.\n *\n * Each rule must specify:\n * - **Pattern** (exactly one): `regex`, `template`, `lineStartsWith`,\n *   `lineStartsAfter`, or `lineEndsWith`\n * - **Split behavior**: `split` (optional, defaults to `'at'`), `occurrence`, `fuzzy`\n * - **Constraints** (optional): `min`, `max`, `meta`\n *\n * @example\n * // Basic rule: split at markdown headers (split defaults to 'at')\n * const rule: SplitRule = {\n *   lineStartsWith: ['## ', '### '],\n *   meta: { type: 'section' }\n * };\n *\n * @example\n * // Advanced rule: extract hadith numbers with fuzzy Arabic matching\n * const rule: SplitRule = {\n *   lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '],\n *   fuzzy: true,\n *   min: 5,\n *   max: 500,\n *   meta: { type: 'hadith' }\n * };\n */\nexport type SplitRule = PatternType & SplitBehavior & RuleConstraints;\n","import { PATTERN_TYPE_KEYS, type PatternTypeKey, type SplitRule } from '@/types/rules';\n\n// Keys that support array patterns and can be merged\nconst MERGEABLE_KEYS = new Set<PatternTypeKey>(['lineStartsWith', 'lineStartsAfter', 'lineEndsWith']);\n\n/**\n * Result from optimizing rules.\n */\nexport type OptimizeResult = {\n    /** Optimized rules (merged and sorted by specificity) */\n    rules: SplitRule[];\n    /** Number of rules that were merged into existing rules */\n    mergedCount: number;\n};\n\n/**\n * Get the pattern type key for a rule.\n */\nconst getPatternKey = (rule: SplitRule) => PATTERN_TYPE_KEYS.find((key) => key in rule) ?? 'regex';\n\nconst getPatternArray = (rule: SplitRule, key: PatternTypeKey) => {\n    const value = (rule as Record<string, unknown>)[key];\n    return Array.isArray(value) ? (value as string[]) : [];\n};\n\nconst getPatternString = (rule: SplitRule, key: PatternTypeKey) => {\n    const value = (rule as Record<string, unknown>)[key];\n    return typeof value === 'string' ? value : Array.isArray(value) ? value.join('\\n') : '';\n};\n\nconst normalizePatterns = (patterns: string[]) =>\n    [...new Set(patterns)].sort((a, b) => b.length - a.length || a.localeCompare(b));\n\nconst getSpecificityScore = (rule: SplitRule) => {\n    const key = getPatternKey(rule);\n    return MERGEABLE_KEYS.has(key)\n        ? getPatternArray(rule, key).reduce((max, p) => Math.max(max, p.length), 0)\n        : getPatternString(rule, key).length;\n};\n\nconst createMergeKey = (rule: SplitRule) => {\n    const key = getPatternKey(rule);\n    const { [key]: _, ...rest } = rule as any;\n    return `${key}|${JSON.stringify(rest)}`;\n};\n\nexport const optimizeRules = (rules: SplitRule[]) => {\n    const output: SplitRule[] = [];\n    const indexByMergeKey = new Map<string, number>();\n    let mergedCount = 0;\n\n    for (const rule of rules) {\n        const key = getPatternKey(rule);\n        if (!MERGEABLE_KEYS.has(key)) {\n            output.push(rule);\n            continue;\n        }\n\n        const mergeKey = createMergeKey(rule);\n        const existingIndex = indexByMergeKey.get(mergeKey);\n\n        if (existingIndex === undefined) {\n            indexByMergeKey.set(mergeKey, output.length);\n            output.push({ ...rule, [key]: normalizePatterns(getPatternArray(rule, key)) } as SplitRule);\n        } else {\n            const existing = output[existingIndex] as any;\n            existing[key] = normalizePatterns([...getPatternArray(existing, key), ...getPatternArray(rule, key)]);\n            mergedCount++;\n        }\n    }\n\n    return { mergedCount, rules: output.sort((a, b) => getSpecificityScore(b) - getSpecificityScore(a)) };\n};\n","import type { Page } from '@/types';\nimport type { Replacement } from '@/types/options';\n\nconst DEFAULT_REPLACE_FLAGS = 'gu';\n\nconst normalizeReplaceFlags = (flags?: string) => {\n    if (!flags) {\n        return DEFAULT_REPLACE_FLAGS;\n    }\n\n    const allowed = new Set(['g', 'i', 'm', 's', 'u', 'y']);\n    const set = new Set(\n        flags.split('').filter((ch) => {\n            if (!allowed.has(ch)) {\n                throw new Error(`Invalid replace regex flag: \"${ch}\" (allowed: gimsyu)`);\n            }\n            return true;\n        }),\n    );\n    set.add('g');\n    set.add('u');\n\n    return ['g', 'i', 'm', 's', 'y', 'u'].filter((c) => set.has(c)).join('');\n};\n\nconst compileReplaceRules = (rules: Replacement[]) =>\n    rules\n        .filter((r) => !(r.pageIds && r.pageIds.length === 0))\n        .map((r) => ({\n            pageIdSet: r.pageIds ? new Set(r.pageIds) : undefined,\n            re: new RegExp(r.regex, normalizeReplaceFlags(r.flags)),\n            replacement: r.replacement,\n        }));\n\nexport const applyReplacements = (pages: Page[], rules?: Replacement[]) => {\n    if (!rules?.length || !pages.length) {\n        return pages;\n    }\n    const compiled = compileReplaceRules(rules);\n    if (!compiled.length) {\n        return pages;\n    }\n\n    return pages.map((p) => {\n        let content = p.content;\n        for (const rule of compiled) {\n            if (!rule.pageIdSet || rule.pageIdSet.has(p.id)) {\n                content = content.replace(rule.re, rule.replacement);\n            }\n        }\n        return content === p.content ? p : { ...p, content };\n    });\n};\n","/**\n * Split rule → compiled regex builder.\n *\n * Extracted from `segmenter.ts` to reduce cognitive complexity and enable\n * independent unit testing of regex compilation and token expansion behavior.\n */\n\nimport type { SplitRule } from '@/types/rules.js';\nimport { escapeTemplateBrackets, makeDiacriticInsensitive } from '@/utils/textUtils.js';\nimport { expandTokensWithCaptures, shouldDefaultToFuzzy } from './tokens.js';\n\n/**\n * Result of processing a pattern with token expansion and optional fuzzy matching.\n */\nexport type ProcessedPattern = {\n    /** The expanded regex pattern string (tokens replaced with regex) */\n    pattern: string;\n    /** Names of captured groups extracted from `{{token:name}}` syntax */\n    captureNames: string[];\n};\n\n/**\n * Compiled regex and metadata for a split rule.\n */\nexport type RuleRegex = {\n    /** Compiled RegExp with 'gmu' flags (global, multiline, unicode) */\n    regex: RegExp;\n    /** Whether the regex uses capturing groups for content extraction */\n    usesCapture: boolean;\n    /** Names of captured groups from `{{token:name}}` syntax */\n    captureNames: string[];\n    /** Whether this rule uses `lineStartsAfter` (content capture at end) */\n    usesLineStartsAfter: boolean;\n};\n\n/**\n * Checks if a regex pattern contains standard (anonymous) capturing groups.\n *\n * Detects standard capturing groups `(...)` while excluding:\n * - Non-capturing groups `(?:...)`\n * - Lookahead assertions `(?=...)` and `(?!...)`\n * - Lookbehind assertions `(?<=...)` and `(?<!...)`\n * - Named groups `(?<name>...)` (start with `(?` so excluded here)\n *\n * NOTE: Named capture groups are still captures, but they're tracked via `captureNames`.\n */\nexport const hasCapturingGroup = (pattern: string) => /\\((?!\\?)/.test(pattern);\n\n/**\n * Extracts named capture group names from a regex pattern.\n *\n * Parses patterns like `(?<num>[0-9]+)` and returns `['num']`.\n *\n * @example\n * extractNamedCaptureNames('^(?<num>[٠-٩]+)\\\\s+') // ['num']\n * extractNamedCaptureNames('^(?<a>\\\\d+)(?<b>\\\\w+)') // ['a', 'b']\n * extractNamedCaptureNames('^\\\\d+') // []\n */\nexport const extractNamedCaptureNames = (pattern: string) => [...pattern.matchAll(/\\(\\?<([^>]+)>/g)].map((m) => m[1]);\n\n/**\n * Safely compiles a regex pattern, throwing a helpful error if invalid.\n */\nexport const compileRuleRegex = (pattern: string) => {\n    try {\n        return new RegExp(pattern, 'gmu');\n    } catch (error) {\n        throw new Error(\n            `Invalid regex pattern: ${pattern}\\n  Cause: ${error instanceof Error ? error.message : String(error)}`,\n        );\n    }\n};\n\n/**\n * Processes a pattern string by expanding tokens and optionally applying fuzzy matching.\n *\n * Brackets `()[]` outside `{{tokens}}` are auto-escaped.\n */\nexport const processPattern = (pattern: string, fuzzy: boolean, capturePrefix?: string) => {\n    const { pattern: expanded, captureNames } = expandTokensWithCaptures(\n        escapeTemplateBrackets(pattern),\n        fuzzy ? makeDiacriticInsensitive : undefined,\n        capturePrefix,\n    );\n    return { captureNames, pattern: expanded };\n};\n\n/**\n * Processes a breakpoint pattern by expanding tokens only.\n *\n * Unlike `processPattern`, this does NOT escape brackets because breakpoints\n * are treated as raw regex patterns (like the `regex` rule type).\n * Users have full control over regex syntax including `(?:...)` groups.\n */\nexport const processBreakpointPattern = (pattern: string) => {\n    const { pattern: expanded } = expandTokensWithCaptures(pattern);\n    return expanded;\n};\n\nexport const buildLineStartsAfterRegexSource = (patterns: string[], fuzzy: boolean, capturePrefix?: string) => {\n    const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));\n    return {\n        captureNames: processed.flatMap((p) => p.captureNames),\n        regex: `^[\\\\u200E\\\\u200F\\\\u061C\\\\u200B\\\\u200C\\\\u200D\\\\uFEFF]*(?:${processed.map((p) => p.pattern).join('|')})${capturePrefix ? `(?<${capturePrefix}__content>.*)` : '(.*)'}`,\n    };\n};\n\nexport const buildLineStartsWithRegexSource = (patterns: string[], fuzzy: boolean, capturePrefix?: string) => {\n    const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));\n    return {\n        captureNames: processed.flatMap((p) => p.captureNames),\n        regex: `^[\\\\u200E\\\\u200F\\\\u061C\\\\u200B\\\\u200C\\\\u200D\\\\uFEFF]*(?:${processed.map((p) => p.pattern).join('|')})`,\n    };\n};\n\nexport const buildLineEndsWithRegexSource = (patterns: string[], fuzzy: boolean, capturePrefix?: string) => {\n    const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));\n    return {\n        captureNames: processed.flatMap((p) => p.captureNames),\n        regex: `(?:${processed.map((p) => p.pattern).join('|')})$`,\n    };\n};\n\nexport const buildTemplateRegexSource = (template: string, capturePrefix?: string) => {\n    const { pattern, captureNames } = expandTokensWithCaptures(\n        escapeTemplateBrackets(template),\n        undefined,\n        capturePrefix,\n    );\n    return { captureNames, regex: pattern };\n};\n\n/**\n * Builds a compiled regex and metadata from a split rule.\n *\n * Behavior mirrors the previous implementation in `segmenter.ts`.\n */\nexport const buildRuleRegex = (rule: SplitRule, capturePrefix?: string) => {\n    const { lineStartsWith, lineStartsAfter, lineEndsWith, template, regex } = rule as any;\n    const fuzzy =\n        (rule as { fuzzy?: boolean }).fuzzy ??\n        shouldDefaultToFuzzy([...(lineStartsWith ?? []), ...(lineStartsAfter ?? []), ...(lineEndsWith ?? [])]);\n\n    if (lineStartsAfter?.length) {\n        const { regex: lsaRegex, captureNames } = buildLineStartsAfterRegexSource(\n            lineStartsAfter,\n            fuzzy,\n            capturePrefix,\n        );\n        return { captureNames, regex: compileRuleRegex(lsaRegex), usesCapture: true, usesLineStartsAfter: true };\n    }\n\n    let finalRegex = regex;\n    let allCaptureNames: string[] = [];\n\n    if (lineStartsWith?.length) {\n        const res = buildLineStartsWithRegexSource(lineStartsWith, fuzzy, capturePrefix);\n        finalRegex = res.regex;\n        allCaptureNames = res.captureNames;\n    }\n    if (lineEndsWith?.length) {\n        const res = buildLineEndsWithRegexSource(lineEndsWith, fuzzy, capturePrefix);\n        finalRegex = res.regex;\n        allCaptureNames = res.captureNames;\n    }\n    if (template) {\n        const res = buildTemplateRegexSource(template, capturePrefix);\n        finalRegex = res.regex;\n        allCaptureNames = [...allCaptureNames, ...res.captureNames];\n    }\n\n    if (!finalRegex) {\n        throw new Error(\n            'Rule must specify exactly one pattern type: regex, template, lineStartsWith, lineStartsAfter, or lineEndsWith',\n        );\n    }\n    if (allCaptureNames.length === 0) {\n        allCaptureNames = extractNamedCaptureNames(finalRegex);\n    }\n\n    return {\n        captureNames: allCaptureNames,\n        regex: compileRuleRegex(finalRegex),\n        usesCapture: hasCapturingGroup(finalRegex),\n        usesLineStartsAfter: false,\n    };\n};\n","/**\n * Shared constants for segmentation breakpoint processing.\n */\n\n/**\n * Threshold for using offset-based fast path in boundary processing.\n *\n * Below this: accurate string-search (handles offset drift from structural rules).\n * At or above this: O(n) arithmetic (performance critical for large books).\n *\n * The value of 1000 is chosen based on typical Arabic book sizes:\n * - Sahih al-Bukhari: ~1000-3000 pages\n * - Standard hadith collections: 1000-7000 pages\n * - Large aggregated corpora: 10k-50k pages\n *\n * For segments ≥1000 pages, the performance gain from offset-based slicing\n * outweighs the minor accuracy loss from potential offset drift.\n *\n * @remarks\n * Fast path is skipped when:\n * - `maxContentLength` is set (requires character-accurate splitting)\n * - `debugMetaKey` is set (requires proper provenance tracking)\n * - Content was structurally modified by marker stripping (offsets may drift)\n */\nexport const FAST_PATH_THRESHOLD = 1000;\n\nexport const WINDOW_PREFIX_LENGTHS = [80, 60, 40, 30, 20, 15] as const;\n\n// For page-join normalization we need to handle cases where only the very beginning of the next page\n// is present in the current segment (e.g. the segment ends right before the next structural marker).\n// That can be as short as a few words, so we allow shorter prefixes here.\nexport const JOINER_PREFIX_LENGTHS = [80, 60, 40, 30, 20, 15, 12, 10, 8, 6] as const;\n\n// Includes Arabic comma (،), semicolon (؛), full stop (.), etc.\nexport const STOP_CHARACTERS = /[\\s\\n.,;!?؛،۔]/;\n","import type { Breakpoint, BreakpointRule } from '@/types/breakpoints.js';\nimport type { PageRange, Segment } from '@/types/index.js';\nimport type { Logger } from '@/types/options.js';\nimport { adjustForUnicodeBoundary } from '@/utils/textUtils.js';\nimport {\n    FAST_PATH_THRESHOLD,\n    JOINER_PREFIX_LENGTHS,\n    STOP_CHARACTERS,\n    WINDOW_PREFIX_LENGTHS,\n} from './breakpoint-constants.js';\n\n/**\n * Normalizes a breakpoint to the object form.\n * Strings are converted to { pattern: str, split: 'after' } with no constraints.\n * Invalid `split` values are treated as `'after'` for backward compatibility.\n * If both `pattern` and `regex` are specified, `regex` takes precedence.\n *\n * @param bp - Breakpoint as string or object\n * @returns Normalized BreakpointRule object with resolved pattern/regex\n *\n * @example\n * normalizeBreakpoint('\\\\n\\\\n')\n * // → { pattern: '\\\\n\\\\n', split: 'after' }\n *\n * normalizeBreakpoint({ pattern: '\\\\n', min: 10 })\n * // → { pattern: '\\\\n', min: 10, split: 'after' }\n *\n * normalizeBreakpoint({ pattern: 'X', split: 'at' })\n * // → { pattern: 'X', split: 'at' }\n *\n * normalizeBreakpoint({ regex: '(?:X|Y)', split: 'at' })\n * // → { regex: '(?:X|Y)', split: 'at' }\n */\nexport const normalizeBreakpoint = (bp: Breakpoint): BreakpointRule => {\n    if (typeof bp === 'string') {\n        return { pattern: bp, split: 'after' };\n    }\n    // Validate split value - treat invalid as 'after' for backward compatibility\n    const split = bp.split === 'at' || bp.split === 'after' ? bp.split : 'after';\n    return { ...bp, split };\n};\n\n/**\n * Checks if a page ID is in an excluded list (single pages or ranges).\n *\n * @param pageId - Page ID to check\n * @param excludeList - List of page IDs or [from, to] ranges to exclude\n * @returns True if page is excluded\n *\n * @example\n * isPageExcluded(5, [1, 5, 10])\n * // → true\n *\n * isPageExcluded(5, [[3, 7]])\n * // → true\n *\n * isPageExcluded(5, [[10, 20]])\n * // → false\n */\nexport const isPageExcluded = (pageId: number, excludeList: PageRange[] | undefined) =>\n    excludeList?.some((item) =>\n        typeof item === 'number' ? pageId === item : pageId >= item[0] && pageId <= item[1],\n    ) ?? false;\n\n/**\n * Checks if a page ID is within a breakpoint's min/max range and not excluded.\n *\n * @param pageId - Page ID to check\n * @param rule - Breakpoint rule with optional min/max/exclude constraints\n * @returns True if page is within valid range\n *\n * @example\n * isInBreakpointRange(50, { pattern: '\\\\n', min: 10, max: 100 })\n * // → true\n *\n * isInBreakpointRange(5, { pattern: '\\\\n', min: 10 })\n * // → false (below min)\n */\nexport const isInBreakpointRange = (pageId: number, rule: BreakpointRule) => {\n    const { min, max, exclude } = rule;\n    return (\n        (min === undefined || pageId >= min) && (max === undefined || pageId <= max) && !isPageExcluded(pageId, exclude)\n    );\n};\n\n/**\n * Builds an exclude set from a PageRange array for O(1) lookups.\n *\n * @param excludeList - List of page IDs or [from, to] ranges\n * @returns Set of all excluded page IDs\n *\n * @remarks\n * This expands ranges into explicit page IDs for fast membership checks. For typical\n * book-scale inputs (thousands of pages), this is small and keeps downstream logic\n * simple and fast. If you expect extremely large ranges (e.g., millions of pages),\n * consider avoiding broad excludes or introducing a range-based membership structure.\n *\n * @example\n * buildExcludeSet([1, 5, [10, 12]])\n * // → Set { 1, 5, 10, 11, 12 }\n */\nexport const buildExcludeSet = (excludeList: PageRange[] | undefined) => {\n    const excludeSet = new Set<number>();\n    for (const item of excludeList || []) {\n        if (typeof item === 'number') {\n            excludeSet.add(item);\n        } else {\n            for (let i = item[0]; i <= item[1]; i++) {\n                excludeSet.add(i);\n            }\n        }\n    }\n    return excludeSet;\n};\n\n/**\n * Creates a segment with optional to and meta fields.\n * Returns null if content is empty after trimming.\n *\n * @param content - Segment content\n * @param fromPageId - Starting page ID\n * @param toPageId - Optional ending page ID (omitted if same as from)\n * @param meta - Optional metadata to attach\n * @returns Segment object or null if empty\n *\n * @example\n * createSegment('Hello world', 1, 3, { chapter: 1 })\n * // → { content: 'Hello world', from: 1, to: 3, meta: { chapter: 1 } }\n *\n * createSegment('   ', 1, undefined, undefined)\n * // → null (empty content)\n */\nexport const createSegment = (\n    content: string,\n    fromPageId: number,\n    toPageId: number | undefined,\n    meta: Record<string, unknown> | undefined,\n): Segment | null => {\n    const trimmed = content.trim();\n    if (!trimmed) {\n        return null;\n    }\n    return {\n        content: trimmed,\n        from: fromPageId,\n        ...(toPageId !== undefined && toPageId !== fromPageId && { to: toPageId }),\n        ...(meta && { meta }),\n    };\n};\n\n/** Expanded breakpoint with pre-compiled regex and exclude set */\nexport type ExpandedBreakpoint = {\n    rule: BreakpointRule;\n    regex: RegExp | null;\n    excludeSet: Set<number>;\n    skipWhenRegex: RegExp | null;\n    /** true = split AT match (new segment starts with match), false = split AFTER (default) */\n    splitAt: boolean;\n};\n\n/** Function type for pattern processing */\nexport type PatternProcessor = (pattern: string) => string;\n\n/**\n * Expands breakpoint patterns and pre-computes exclude sets.\n *\n * @param breakpoints - Array of breakpoint patterns or rules\n * @param processPattern - Function to expand tokens in patterns\n * @returns Array of expanded breakpoints with compiled regexes\n *\n * @remarks\n * This function compiles regex patterns dynamically. This can be a ReDoS vector\n * if patterns come from untrusted sources. In typical usage, breakpoint rules\n * are application configuration, not user input.\n/**\n * @param processPattern - Function to expand tokens in patterns (with bracket escaping)\n * @param processRawPattern - Function to expand tokens without bracket escaping (for regex field)\n */\nexport const expandBreakpoints = (\n    breakpoints: Breakpoint[],\n    processPattern: PatternProcessor,\n    processRawPattern?: PatternProcessor,\n): ExpandedBreakpoint[] =>\n    breakpoints.map((bp) => {\n        const rule = normalizeBreakpoint(bp);\n        const excludeSet = buildExcludeSet(rule.exclude);\n        const skipWhenRegex =\n            rule.skipWhen !== undefined\n                ? (() => {\n                      const expandedSkip = processPattern(rule.skipWhen);\n                      try {\n                          return new RegExp(expandedSkip, 'mu');\n                      } catch (error) {\n                          const message = error instanceof Error ? error.message : String(error);\n                          throw new Error(`Invalid breakpoint skipWhen regex: ${rule.skipWhen}\\n  Cause: ${message}`);\n                      }\n                  })()\n                : null;\n\n        // Determine which pattern to use: regex takes precedence over pattern\n        const rawPattern = rule.regex ?? rule.pattern;\n\n        // Empty pattern = page boundary fallback, split has no effect\n        if (rawPattern === '' || rawPattern === undefined) {\n            return { excludeSet, regex: null, rule, skipWhenRegex, splitAt: false };\n        }\n\n        // Use raw processor if regex field is set and rawPatternProcessor is provided\n        const useRawProcessor = rule.regex !== undefined && processRawPattern;\n        const expanded = useRawProcessor ? processRawPattern(rawPattern) : processPattern(rawPattern);\n\n        // splitAt = true means new segment starts WITH the match\n        const splitAt = rule.split === 'at';\n        try {\n            return { excludeSet, regex: new RegExp(expanded, 'gmu'), rule, skipWhenRegex, splitAt };\n        } catch (error) {\n            const message = error instanceof Error ? error.message : String(error);\n            const fieldUsed = rule.regex !== undefined ? 'regex' : 'pattern';\n            throw new Error(`Invalid breakpoint ${fieldUsed}: ${rawPattern}\\n  Cause: ${message}`);\n        }\n    });\n\n/** Normalized page data for efficient lookups */\nexport type NormalizedPage = { content: string; length: number; index: number };\n\n/**\n * Applies a configured joiner at detected page boundaries within a multi-page content chunk.\n *\n * This is used for breakpoint-generated segments which don't have access to the original\n * `pageMap.pageBreaks` offsets. We detect page starts sequentially by searching for each page's\n * prefix after the previous boundary, then replace ONLY the single newline immediately before\n * that page start.\n *\n * This avoids converting real in-page newlines, while still normalizing page joins consistently.\n */\nexport const applyPageJoinerBetweenPages = (\n    content: string,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    joiner: 'space' | 'newline',\n) => {\n    if (joiner === 'newline' || fromIdx >= toIdx || !content.includes('\\n')) {\n        return content;\n    }\n\n    let updated = content;\n    let searchFrom = 0;\n\n    for (let pi = fromIdx + 1; pi <= toIdx; pi++) {\n        const pageData = normalizedPages.get(pageIds[pi]);\n        if (!pageData) {\n            continue;\n        }\n\n        const found = findPrefixPositionInContent(updated, pageData.content.trimStart(), searchFrom);\n        if (found > 0 && updated[found - 1] === '\\n') {\n            updated = `${updated.slice(0, found - 1)} ${updated.slice(found)}`;\n        }\n        if (found > 0) {\n            searchFrom = found;\n        }\n    }\n\n    return updated;\n};\n\n/**\n * Finds the position of a page prefix in content, trying multiple prefix lengths.\n */\nconst findPrefixPositionInContent = (content: string, trimmedPageContent: string, searchFrom: number) => {\n    for (const len of JOINER_PREFIX_LENGTHS) {\n        const prefix = trimmedPageContent.slice(0, Math.min(len, trimmedPageContent.length)).trim();\n        if (!prefix) {\n            continue;\n        }\n        const pos = content.indexOf(prefix, searchFrom);\n        if (pos > 0) {\n            return pos;\n        }\n    }\n    return -1;\n};\n\n/**\n * Estimates how far into the current page `remainingContent` begins.\n *\n * During breakpoint processing, `remainingContent` can begin mid-page after a previous split.\n * When that happens, raw cumulative page offsets (computed from full page starts) can overestimate\n * expected boundary positions. This helper computes an approximate starting offset by matching\n * a short prefix of `remainingContent` inside the current page content.\n */\nexport const estimateStartOffsetInCurrentPage = (\n    remainingContent: string,\n    currentFromIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    const currentPageData = normalizedPages.get(pageIds[currentFromIdx]);\n    if (!currentPageData) {\n        return 0;\n    }\n\n    const remStart = remainingContent.trimStart().slice(0, Math.min(60, remainingContent.length));\n    const needle = remStart.slice(0, Math.min(30, remStart.length));\n    if (!needle) {\n        return 0;\n    }\n\n    const idx = currentPageData.content.indexOf(needle);\n    return idx > 0 ? idx : 0;\n};\n\n/**\n * Attempts to find the start position of a target page within remainingContent,\n * anchored near an expected boundary position to reduce collisions.\n *\n * This is used to define breakpoint windows in terms of actual content being split, rather than\n * raw per-page offsets which can desync when structural rules strip markers.\n */\nexport const findPageStartNearExpectedBoundary = (\n    remainingContent: string,\n    targetPageIdx: number,\n    expectedBoundary: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    logger?: Logger,\n) => {\n    const targetPageData = normalizedPages.get(pageIds[targetPageIdx]);\n    if (!targetPageData) {\n        return -1;\n    }\n\n    // Anchor search near the expected boundary to avoid matching repeated phrases earlier in content.\n    const approx = Math.min(Math.max(0, expectedBoundary), remainingContent.length);\n    const searchStart = Math.max(0, approx - 10_000);\n    const searchEnd = Math.min(remainingContent.length, approx + 2_000);\n\n    const targetTrimmed = targetPageData.content.trimStart();\n    for (const len of WINDOW_PREFIX_LENGTHS) {\n        const prefix = targetTrimmed.slice(0, Math.min(len, targetTrimmed.length)).trim();\n        if (!prefix) {\n            continue;\n        }\n\n        const candidates = findAnchorCandidates(remainingContent, prefix, searchStart, searchEnd);\n        if (candidates.length === 0) {\n            continue;\n        }\n\n        // Only accept matches within MAX_DEVIATION of the expected boundary.\n        // Prefer newline-preceded candidates *among valid matches*, otherwise choose the closest.\n        const MAX_DEVIATION = 2000;\n        const inRange = candidates.filter((c) => Math.abs(c.pos - expectedBoundary) <= MAX_DEVIATION);\n        if (inRange.length > 0) {\n            const best = selectBestAnchor(inRange, expectedBoundary);\n            return best.pos;\n        }\n\n        const bestOverall = selectBestAnchor(candidates, expectedBoundary);\n        logger?.debug?.('[breakpoints] findPageStartNearExpectedBoundary: Rejected match exceeding deviation', {\n            bestDistance: Math.abs(bestOverall.pos - expectedBoundary),\n            expectedBoundary,\n            matchPos: bestOverall.pos,\n            maxDeviation: MAX_DEVIATION,\n            prefixLength: len,\n            targetPageIdx,\n        });\n    }\n\n    return -1;\n};\n\n/** Internal candidate for page start anchoring */\ninterface AnchorCandidate {\n    pos: number;\n    isNewline: boolean;\n}\n\n/** Finds all whitespace-preceded occurrences of a prefix within a search range */\nconst findAnchorCandidates = (content: string, prefix: string, start: number, end: number) => {\n    const candidates: AnchorCandidate[] = [];\n    let pos = content.indexOf(prefix, start);\n\n    while (pos !== -1 && pos <= end) {\n        if (pos > 0) {\n            const charBefore = content[pos - 1];\n            if (charBefore === '\\n') {\n                candidates.push({ isNewline: true, pos });\n            } else if (/\\s/.test(charBefore)) {\n                candidates.push({ isNewline: false, pos });\n            }\n        }\n        pos = content.indexOf(prefix, pos + 1);\n    }\n\n    return candidates;\n};\n\n/** Selects the best anchor candidate, prioritizing newlines then proximity to boundary */\nconst selectBestAnchor = (candidates: AnchorCandidate[], expectedBoundary: number) => {\n    const newlines = candidates.filter((c) => c.isNewline);\n    const pool = newlines.length > 0 ? newlines : candidates;\n\n    return pool.reduce((best, curr) =>\n        Math.abs(curr.pos - expectedBoundary) < Math.abs(best.pos - expectedBoundary) ? curr : best,\n    );\n};\n\n/**\n * Builds a boundary position map for pages within the given range.\n *\n * This function computes page boundaries once per segment and enables\n * O(log n) page lookups via binary search with `findPageIndexForPosition`.\n *\n * Boundaries are derived from segmentContent (post-structural-rules).\n * When the segment starts mid-page, an offset correction is applied to\n * keep boundary estimates aligned with the segment's actual content space.\n *\n * @param segmentContent - Full segment content (already processed by structural rules)\n * @param fromIdx - Starting page index\n * @param toIdx - Ending page index\n * @param pageIds - Array of all page IDs\n * @param normalizedPages - Map of page ID to normalized content\n * @param cumulativeOffsets - Cumulative character offsets (for estimates)\n * @param logger - Optional logger for debugging\n * @returns Array where boundaryPositions[i] = start position of page (fromIdx + i),\n *          with a sentinel boundary at segmentContent.length as the last element\n *\n * @example\n * // For a 3-page segment:\n * buildBoundaryPositions(content, 0, 2, pageIds, normalizedPages, offsets)\n * // → [0, 23, 45, 67] where 67 is content.length (sentinel)\n */\nexport const buildBoundaryPositions = (\n    segmentContent: string,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    logger?: Logger,\n) => {\n    const boundaryPositions: number[] = [0];\n    const pageCount = toIdx - fromIdx + 1;\n\n    // FAST PATH: For large segments (1000+ pages), use cumulative offsets directly.\n    // The expensive string-search verification is only useful when structural rules\n    // have stripped content causing offset drift. For large books with simple breakpoints,\n    // the precomputed offsets are accurate and O(n) vs O(n×m) string searching.\n    if (pageCount >= FAST_PATH_THRESHOLD) {\n        logger?.debug?.('[breakpoints] Using fast-path for large segment in buildBoundaryPositions', {\n            fromIdx,\n            pageCount,\n            toIdx,\n        });\n\n        const baseOffset = cumulativeOffsets[fromIdx] ?? 0;\n        for (let i = fromIdx + 1; i <= toIdx; i++) {\n            const offset = cumulativeOffsets[i];\n            if (offset !== undefined) {\n                const boundary = Math.max(0, offset - baseOffset);\n                const prevBoundary = boundaryPositions[boundaryPositions.length - 1];\n                // Ensure strictly increasing boundaries\n                boundaryPositions.push(Math.max(prevBoundary + 1, Math.min(boundary, segmentContent.length)));\n            }\n        }\n        boundaryPositions.push(segmentContent.length); // sentinel\n        return boundaryPositions;\n    }\n\n    // ACCURATE PATH: For smaller segments, verify boundaries with string search\n    // This handles cases where structural rules stripped markers causing offset drift\n    // WARNING: This path is O(n×m) - if this log appears for large pageCount, investigate!\n    logger?.debug?.('[breakpoints] buildBoundaryPositions: Using accurate string-search path', {\n        contentLength: segmentContent.length,\n        fromIdx,\n        pageCount,\n        toIdx,\n    });\n    const startOffsetInFromPage = estimateStartOffsetInCurrentPage(segmentContent, fromIdx, pageIds, normalizedPages);\n\n    for (let i = fromIdx + 1; i <= toIdx; i++) {\n        const expectedBoundary =\n            cumulativeOffsets[i] !== undefined && cumulativeOffsets[fromIdx] !== undefined\n                ? Math.max(0, cumulativeOffsets[i] - cumulativeOffsets[fromIdx] - startOffsetInFromPage)\n                : segmentContent.length;\n\n        const pos = findPageStartNearExpectedBoundary(\n            segmentContent,\n            i,\n            expectedBoundary,\n            pageIds,\n            normalizedPages,\n            logger,\n        );\n\n        const prevBoundary = boundaryPositions[boundaryPositions.length - 1];\n\n        // Strict > prevents duplicate boundaries when pages have identical content\n        const MAX_DEVIATION = 2000;\n        const isValidPosition = pos > 0 && pos > prevBoundary && Math.abs(pos - expectedBoundary) < MAX_DEVIATION;\n\n        if (isValidPosition) {\n            boundaryPositions.push(pos);\n        } else {\n            // Fallback for whitespace-only pages, identical content, or stripped markers.\n            // Ensure estimate is strictly > prevBoundary to prevent duplicate zero-length\n            // boundaries, which would break binary-search page-attribution logic.\n            const estimate = Math.max(prevBoundary + 1, expectedBoundary);\n            boundaryPositions.push(Math.min(estimate, segmentContent.length));\n        }\n    }\n\n    boundaryPositions.push(segmentContent.length); // sentinel\n    logger?.debug?.('[breakpoints] buildBoundaryPositions: Complete', { boundaryCount: boundaryPositions.length });\n    return boundaryPositions;\n};\n\n/**\n * Binary search to find which page a position falls within.\n * Uses \"largest i where boundaryPositions[i] <= position\" semantics.\n *\n * @param position - Character position in segmentContent\n * @param boundaryPositions - Precomputed boundary positions (from buildBoundaryPositions)\n * @param fromIdx - Base page index (boundaryPositions[0] corresponds to pageIds[fromIdx])\n * @returns Page index in pageIds array\n *\n * @example\n * // With boundaries [0, 20, 40, 60] and fromIdx=0:\n * findPageIndexForPosition(15, boundaries, 0) // → 0 (first page)\n * findPageIndexForPosition(25, boundaries, 0) // → 1 (second page)\n * findPageIndexForPosition(40, boundaries, 0) // → 2 (exactly on boundary = that page)\n */\nexport const findPageIndexForPosition = (position: number, boundaryPositions: number[], fromIdx: number) => {\n    // Handle edge cases\n    if (boundaryPositions.length <= 1) {\n        return fromIdx;\n    }\n\n    // Binary search for largest i where boundaryPositions[i] <= position\n    let left = 0;\n    let right = boundaryPositions.length - 2; // Exclude sentinel\n\n    while (left < right) {\n        const mid = Math.ceil((left + right) / 2);\n        if (boundaryPositions[mid] <= position) {\n            left = mid;\n        } else {\n            right = mid - 1;\n        }\n    }\n\n    return fromIdx + left;\n};\n/**\n * Finds the end position of a breakpoint window inside `remainingContent`.\n *\n * The window end is defined as the start of the page AFTER `windowEndIdx` (i.e. `windowEndIdx + 1`),\n * found within the actual `remainingContent` string being split. This avoids relying on raw page offsets\n * that can diverge when structural rules strip markers (e.g. `lineStartsAfter`).\n */\nexport const findBreakpointWindowEndPosition = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    logger?: Logger,\n) => {\n    // If the window already reaches the end of the segment, the window is the remaining content.\n    if (windowEndIdx >= toIdx) {\n        return remainingContent.length;\n    }\n\n    const desiredNextIdx = windowEndIdx + 1;\n    const minNextIdx = currentFromIdx + 1;\n    const maxNextIdx = Math.min(desiredNextIdx, toIdx);\n\n    const startOffsetInCurrentPage = estimateStartOffsetInCurrentPage(\n        remainingContent,\n        currentFromIdx,\n        pageIds,\n        normalizedPages,\n    );\n\n    // Track the best expected boundary for fallback\n    let bestExpectedBoundary = remainingContent.length;\n\n    // If we can't find the boundary for the desired next page, progressively fall back\n    // to earlier page boundaries (smaller window), which is conservative but still correct.\n    for (let nextIdx = maxNextIdx; nextIdx >= minNextIdx; nextIdx--) {\n        const expectedBoundary =\n            cumulativeOffsets[nextIdx] !== undefined && cumulativeOffsets[currentFromIdx] !== undefined\n                ? Math.max(0, cumulativeOffsets[nextIdx] - cumulativeOffsets[currentFromIdx] - startOffsetInCurrentPage)\n                : remainingContent.length;\n\n        // Keep track of the expected boundary for fallback\n        if (nextIdx === maxNextIdx) {\n            bestExpectedBoundary = expectedBoundary;\n        }\n\n        const pos = findPageStartNearExpectedBoundary(\n            remainingContent,\n            nextIdx,\n            expectedBoundary,\n            pageIds,\n            normalizedPages,\n            logger,\n        );\n        if (pos > 0) {\n            return pos;\n        }\n    }\n\n    // Fallback: Use the expected boundary from cumulative offsets.\n    // This is more accurate than returning remainingContent.length, which would\n    // merge all remaining pages into one segment.\n    return Math.min(bestExpectedBoundary, remainingContent.length);\n};\n\n/**\n * Finds exclusion-based break position using raw cumulative offsets.\n *\n * This is used to ensure pages excluded by breakpoints are never merged into the same output segment.\n * Returns a break position relative to the start of `remainingContent` (i.e. the currentFromIdx start).\n */\nexport const findExclusionBreakPosition = (\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    expandedBreakpoints: Array<{ excludeSet: Set<number> }>,\n    cumulativeOffsets: number[],\n) => {\n    const startingPageId = pageIds[currentFromIdx];\n    const startingPageExcluded = expandedBreakpoints.some((bp) => bp.excludeSet.has(startingPageId));\n    if (startingPageExcluded && currentFromIdx < toIdx) {\n        // Output just this one page as a segment (break at next page boundary)\n        return cumulativeOffsets[currentFromIdx + 1] - cumulativeOffsets[currentFromIdx];\n    }\n\n    // Find the first excluded page AFTER the starting page (within window) and split BEFORE it\n    for (let pageIdx = currentFromIdx + 1; pageIdx <= windowEndIdx; pageIdx++) {\n        const pageId = pageIds[pageIdx];\n        const isExcluded = expandedBreakpoints.some((bp) => bp.excludeSet.has(pageId));\n        if (isExcluded) {\n            return cumulativeOffsets[pageIdx] - cumulativeOffsets[currentFromIdx];\n        }\n    }\n    return -1;\n};\n\n/** Context required for finding break positions */\nexport type BreakpointContext = {\n    pageIds: number[];\n    normalizedPages: Map<number, NormalizedPage>;\n    expandedBreakpoints: ExpandedBreakpoint[];\n    prefer: 'longer' | 'shorter';\n};\n\n/**\n * Checks if any page in a range is excluded by the given exclude set.\n *\n * @param excludeSet - Set of excluded page IDs\n * @param pageIds - Array of page IDs\n * @param fromIdx - Start index (inclusive)\n * @param toIdx - End index (inclusive)\n * @returns True if any page in range is excluded\n */\nexport const hasExcludedPageInRange = (excludeSet: Set<number>, pageIds: number[], fromIdx: number, toIdx: number) => {\n    if (excludeSet.size === 0) {\n        return false;\n    }\n    for (let pageIdx = fromIdx; pageIdx <= toIdx; pageIdx++) {\n        if (excludeSet.has(pageIds[pageIdx])) {\n            return true;\n        }\n    }\n    return false;\n};\n\n/**\n * Finds the position of the next page content within remaining content.\n * Returns -1 if not found.\n *\n * @param remainingContent - Content to search in\n * @param nextPageData - Normalized data for the next page\n * @returns Position of next page content, or -1 if not found\n */\nexport const findNextPagePosition = (remainingContent: string, nextPageData: NormalizedPage) => {\n    const searchPrefix = nextPageData.content.trim().slice(0, Math.min(30, nextPageData.length));\n    if (searchPrefix.length === 0) {\n        return -1;\n    }\n    const pos = remainingContent.indexOf(searchPrefix);\n    return pos > 0 ? pos : -1;\n};\n\n/**\n * Finds matches within a window and returns the selected position based on preference and split mode.\n *\n * @param windowContent - Content to search\n * @param regex - Regex to match\n * @param prefer - 'longer' for last match, 'shorter' for first match\n * @param splitAt - If true, return position BEFORE match (at index). If false, return position AFTER match (at index + length).\n * @returns Break position, or -1 if no valid matches\n *\n * @remarks\n * - Matches with length 0 are skipped (prevents infinite loops with lookahead patterns)\n * - Matches that would result in position 0 are skipped (prevents empty first segments)\n * - For prefer:'shorter', returns immediately on first valid match (optimization)\n */\nexport const findPatternBreakPosition = (\n    windowContent: string,\n    regex: RegExp,\n    prefer: 'longer' | 'shorter',\n    splitAt = false,\n) => {\n    // Track last valid match for 'longer' preference\n    let last: { index: number; length: number } | undefined;\n\n    for (const m of windowContent.matchAll(regex)) {\n        const idx = m.index ?? -1;\n        const len = m[0]?.length ?? 0;\n\n        // Skip invalid matches: negative index, zero-length (lookahead)\n        if (idx < 0 || len === 0) {\n            continue;\n        }\n\n        // Compute break position based on split mode\n        const pos = splitAt ? idx : idx + len;\n\n        // Skip position 0 - would create empty first segment\n        if (pos === 0) {\n            continue;\n        }\n\n        last = { index: idx, length: len };\n\n        // Early return for 'shorter' (first valid match)\n        if (prefer === 'shorter') {\n            return pos;\n        }\n    }\n\n    if (!last) {\n        return -1;\n    }\n\n    // For 'longer', use last valid match\n    return splitAt ? last.index : last.index + last.length;\n};\n\n/**\n * Handles page boundary breakpoint (empty pattern).\n * Returns break position or -1 if no valid position found.\n */\nconst handlePageBoundaryBreak = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndPosition: number,\n    maxContentLength: number | undefined,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    // Page-boundary breakpoint (empty pattern '').\n    //\n    // Semantics: when no other breakpoint patterns match, break at the NEXT PAGE boundary\n    // (i.e. swallow the remainder of the current page), not at the end of the maxPages window.\n    //\n    // This ensures that with maxPages=0 each page stays isolated, and with maxPages>0\n    // we don't accidentally swallow the next page when no pattern matches.\n    const targetPos = Math.min(windowEndPosition, remainingContent.length);\n\n    // If the window is currently bounded by maxContentLength, do NOT force an early break at a page boundary.\n    // In length-bounded mode, we want the best possible split *near* the length limit (using safe-break fallbacks),\n    // even if that spans a page boundary.\n    const isLengthBounded = maxContentLength !== undefined && windowEndPosition === maxContentLength;\n\n    if (!isLengthBounded) {\n        // Page-bounded window semantics: swallow the remainder of the CURRENT page.\n        // Even if the maxPages window could include additional pages, an empty breakpoint ('')\n        // must not consume into the next page when no real breakpoint patterns matched.\n        const targetNextPageIdx = currentFromIdx + 1;\n\n        // Progressively try to find the boundary if detection fails (conservative fallback).\n        for (let nextIdx = targetNextPageIdx; nextIdx > currentFromIdx; nextIdx--) {\n            if (nextIdx <= toIdx) {\n                const nextPageData = normalizedPages.get(pageIds[nextIdx]);\n                if (nextPageData) {\n                    const boundaryPos = findNextPagePosition(remainingContent, nextPageData);\n                    if (boundaryPos > 0 && boundaryPos <= targetPos) {\n                        return boundaryPos;\n                    }\n                }\n            }\n        }\n    }\n\n    // If we couldn't reliably detect the boundary (or we're at the end), fall back to a safe split\n    // within the window to avoid mid-word / surrogate corruption.\n    if (targetPos < remainingContent.length) {\n        const safePos = findSafeBreakPosition(remainingContent, targetPos);\n        if (safePos !== -1) {\n            return safePos;\n        }\n        return adjustForUnicodeBoundary(remainingContent, targetPos);\n    }\n    return targetPos;\n};\n\n/**\n * Tries to find a break position within the current window using breakpoint patterns.\n * Returns the break position or -1 if no suitable break was found.\n *\n * @param remainingContent - Content remaining to be segmented\n * @param currentFromIdx - Current starting page index\n * @param toIdx - Ending page index\n * @param windowEndIdx - Maximum window end index\n * @param ctx - Breakpoint context with page data and patterns\n * @returns Break position in the content, or -1 if no break found\n */\nexport const findBreakPosition = (\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    windowEndIdx: number,\n    windowEndPosition: number,\n    ctx: BreakpointContext,\n    maxContentLength?: number,\n) => {\n    const { pageIds, normalizedPages, expandedBreakpoints, prefer } = ctx;\n\n    for (let i = 0; i < expandedBreakpoints.length; i++) {\n        const { rule, regex, excludeSet, skipWhenRegex } = expandedBreakpoints[i];\n        // Check if this breakpoint applies to the current segment's starting page\n        if (!isInBreakpointRange(pageIds[currentFromIdx], rule)) {\n            continue;\n        }\n\n        // Check if ANY page in the current WINDOW is excluded (not the entire segment)\n        if (hasExcludedPageInRange(excludeSet, pageIds, currentFromIdx, windowEndIdx)) {\n            continue;\n        }\n\n        // Check if content matches skipWhen pattern (pre-compiled)\n        if (skipWhenRegex?.test(remainingContent)) {\n            continue;\n        }\n\n        // Handle page boundary (empty pattern)\n        if (regex === null) {\n            return {\n                breakPos: handlePageBoundaryBreak(\n                    remainingContent,\n                    currentFromIdx,\n                    windowEndPosition,\n                    maxContentLength,\n                    toIdx,\n                    pageIds,\n                    normalizedPages,\n                ),\n                breakpointIndex: i,\n                rule,\n            };\n        }\n\n        // Find matches within window\n        const windowContent = remainingContent.slice(0, Math.min(windowEndPosition, remainingContent.length));\n        const breakPos = findPatternBreakPosition(windowContent, regex, prefer, expandedBreakpoints[i].splitAt);\n        if (breakPos > 0) {\n            return { breakPos, breakpointIndex: i, rule };\n        }\n    }\n\n    return null;\n};\n\n/**\n * Searches backward from a target position to find a \"safe\" split point.\n * A safe split point is after whitespace or punctuation.\n *\n * @param content The text content\n * @param targetPosition The desired split position (hard limit)\n * @param lookbackChars How far back to search for a safe break\n * @returns The new split position (index), or -1 if no safe break found\n */\nexport const findSafeBreakPosition = (content: string, targetPosition: number, lookbackChars = 100) => {\n    // 1. Sanity check bounds\n    const startSearch = Math.max(0, targetPosition - lookbackChars);\n\n    // 2. Iterate backward\n    for (let i = targetPosition - 1; i >= startSearch; i--) {\n        const char = content[i];\n\n        // Check for safe delimiter: Whitespace or Punctuation\n        if (STOP_CHARACTERS.test(char)) {\n            return i + 1;\n        }\n    }\n    return -1;\n};\n\n/**\n * Ensures the position does not split a surrogate pair.\n * If position is between High and Low surrogate, returns position - 1.\n */\nexport const adjustForSurrogate = (content: string, position: number) => {\n    if (position <= 0 || position >= content.length) {\n        return position;\n    }\n\n    const high = content.charCodeAt(position - 1);\n    const low = content.charCodeAt(position);\n\n    // Check if previous char is High Surrogate (0xD800–0xDBFF)\n    // AND current char is Low Surrogate (0xDC00–0xDFFF)\n    if (high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) {\n        return position - 1;\n    }\n\n    return position;\n};\n","import type { BreakpointRule } from '@/types/breakpoints';\nimport { PATTERN_TYPE_KEYS, type SplitRule } from '@/types/rules.js';\n\nexport type DebugConfig = { includeBreakpoint: boolean; includeRule: boolean; metaKey: string } | null;\n\nexport const resolveDebugConfig = (debug: unknown) => {\n    if (debug === true) {\n        return { includeBreakpoint: true, includeRule: true, metaKey: '_flappa' };\n    }\n\n    if (!debug || typeof debug !== 'object') {\n        return null;\n    }\n\n    const { metaKey, include } = debug as any;\n    const includeRule = Array.isArray(include) ? include.includes('rule') : true;\n    const includeBreakpoint = Array.isArray(include) ? include.includes('breakpoint') : true;\n    return { includeBreakpoint, includeRule, metaKey: typeof metaKey === 'string' && metaKey ? metaKey : '_flappa' };\n};\n\nexport const getRulePatternType = (rule: SplitRule) => {\n    return PATTERN_TYPE_KEYS.find((key) => key in rule) ?? 'regex';\n};\n\nconst isPlainObject = (v: unknown): v is Record<string, unknown> =>\n    Boolean(v) && typeof v === 'object' && !Array.isArray(v);\n\nexport const mergeDebugIntoMeta = (\n    meta: Record<string, unknown> | undefined,\n    metaKey: string,\n    patch: Record<string, unknown>,\n) => {\n    const out = meta ? { ...meta } : {};\n    const existing = out[metaKey];\n    out[metaKey] = { ...(isPlainObject(existing) ? existing : {}), ...patch };\n    return out;\n};\n\nexport const buildRuleDebugPatch = (ruleIndex: number, rule: SplitRule) => ({\n    rule: { index: ruleIndex, patternType: getRulePatternType(rule) },\n});\n\nexport const buildBreakpointDebugPatch = (breakpointIndex: number, rule: BreakpointRule) => ({\n    breakpoint: {\n        index: breakpointIndex,\n        kind: rule.pattern === '' ? 'pageBoundary' : 'pattern',\n        pattern: rule.pattern ?? rule.regex,\n    },\n});\n\nexport type ContentLengthSplitReason = 'whitespace' | 'unicode_boundary' | 'grapheme_cluster';\n\nexport const buildContentLengthDebugPatch = (\n    maxContentLength: number,\n    actualLength: number,\n    splitReason: ContentLengthSplitReason = 'whitespace',\n) => ({\n    contentLengthSplit: {\n        actualLength,\n        maxContentLength,\n        splitReason,\n    },\n});\n","/**\n * Breakpoint post-processing engine extracted from segmenter.ts.\n *\n * This module is intentionally split into small helpers to reduce cognitive complexity\n * and allow unit testing of tricky edge cases (window sizing, next-page advancement, etc.).\n */\n\nimport type { Breakpoint, BreakpointRule } from '@/types/breakpoints.js';\nimport type { Page, Segment } from '@/types/index.js';\nimport type { Logger } from '@/types/options.js';\nimport { adjustForUnicodeBoundary } from '@/utils/textUtils.js';\nimport { FAST_PATH_THRESHOLD } from './breakpoint-constants.js';\nimport type { PatternProcessor } from './breakpoint-utils.js';\nimport {\n    applyPageJoinerBetweenPages,\n    type BreakpointContext,\n    buildBoundaryPositions,\n    createSegment,\n    expandBreakpoints,\n    findBreakPosition,\n    findBreakpointWindowEndPosition,\n    findExclusionBreakPosition,\n    findPageIndexForPosition,\n    findSafeBreakPosition,\n    hasExcludedPageInRange,\n    type NormalizedPage,\n} from './breakpoint-utils.js';\nimport { buildBreakpointDebugPatch, mergeDebugIntoMeta } from './debug-meta.js';\n\nconst buildPageIdToIndexMap = (pageIds: number[]) => new Map(pageIds.map((id, i) => [id, i]));\n\nconst buildNormalizedPagesMap = (pages: Page[], normalizedContent: string[]) => {\n    const normalizedPages = new Map<number, NormalizedPage>();\n    for (let i = 0; i < pages.length; i++) {\n        const content = normalizedContent[i];\n        normalizedPages.set(pages[i].id, { content, index: i, length: content.length });\n    }\n    return normalizedPages;\n};\n\nconst buildCumulativeOffsets = (pageIds: number[], normalizedPages: Map<number, NormalizedPage>) => {\n    const cumulativeOffsets: number[] = [0];\n    let totalOffset = 0;\n    for (let i = 0; i < pageIds.length; i++) {\n        const pageData = normalizedPages.get(pageIds[i]);\n        totalOffset += pageData?.length ?? 0;\n        if (i < pageIds.length - 1) {\n            totalOffset += 1;\n        }\n        cumulativeOffsets.push(totalOffset);\n    }\n    return cumulativeOffsets;\n};\n\nconst hasAnyExclusionsInRange = (\n    expandedBreakpoints: Array<{ excludeSet: Set<number> }>,\n    pageIds: number[],\n    fromIdx: number,\n    toIdx: number,\n) => expandedBreakpoints.some((bp) => hasExcludedPageInRange(bp.excludeSet, pageIds, fromIdx, toIdx));\n\nexport const computeWindowEndIdx = (currentFromIdx: number, toIdx: number, pageIds: number[], maxPages: number) => {\n    const maxWindowPageId = pageIds[currentFromIdx] + maxPages;\n    let windowEndIdx = currentFromIdx;\n    for (let i = currentFromIdx; i <= toIdx; i++) {\n        if (pageIds[i] <= maxWindowPageId) {\n            windowEndIdx = i;\n        } else {\n            break;\n        }\n    }\n    return windowEndIdx;\n};\n\nconst computeRemainingSpan = (currentFromIdx: number, toIdx: number, pageIds: number[]) =>\n    pageIds[toIdx] - pageIds[currentFromIdx];\n\nconst createFinalSegment = (\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    meta: Segment['meta'] | undefined,\n    includeMeta: boolean,\n) =>\n    createSegment(\n        remainingContent,\n        pageIds[currentFromIdx],\n        currentFromIdx !== toIdx ? pageIds[toIdx] : undefined,\n        includeMeta ? meta : undefined,\n    );\n\n/**\n * Computes the actual start and end page indices for a piece using\n * precomputed boundary positions and binary search.\n *\n * @param pieceStartPos - Start position of the piece in the full segment content\n * @param pieceEndPos - End position (exclusive) of the piece\n * @param boundaryPositions - Precomputed boundary positions from buildBoundaryPositions\n * @param baseFromIdx - Base page index (boundaryPositions[0] corresponds to pageIds[baseFromIdx])\n * @param toIdx - Maximum page index\n * @returns Object with actualStartIdx and actualEndIdx\n */\nconst computePiecePages = (\n    pieceStartPos: number,\n    pieceEndPos: number,\n    boundaryPositions: number[],\n    baseFromIdx: number,\n    toIdx: number,\n) => {\n    const actualStartIdx = findPageIndexForPosition(pieceStartPos, boundaryPositions, baseFromIdx);\n    const endPos = Math.max(pieceStartPos, pieceEndPos - 1);\n    const actualEndIdx = Math.min(findPageIndexForPosition(endPos, boundaryPositions, baseFromIdx), toIdx);\n    return { actualEndIdx, actualStartIdx };\n};\n\nexport const computeNextFromIdx = (\n    remainingContent: string,\n    actualEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    let nextFromIdx = actualEndIdx;\n    if (remainingContent && actualEndIdx + 1 <= toIdx) {\n        const nextPageData = normalizedPages.get(pageIds[actualEndIdx + 1]);\n        if (nextPageData) {\n            const nextPrefix = nextPageData.content.slice(0, 30);\n            const remainingPrefix = remainingContent.trimStart().slice(0, 30);\n            if (\n                nextPrefix &&\n                (remainingContent.startsWith(nextPrefix) || nextPageData.content.startsWith(remainingPrefix))\n            ) {\n                nextFromIdx = actualEndIdx + 1;\n            }\n        }\n    }\n    return nextFromIdx;\n};\n\nconst createPieceSegment = (\n    pieceContent: string,\n    actualStartIdx: number,\n    actualEndIdx: number,\n    pageIds: number[],\n    meta: Segment['meta'] | undefined,\n    includeMeta: boolean,\n): Segment | null =>\n    createSegment(\n        pieceContent,\n        pageIds[actualStartIdx],\n        actualEndIdx > actualStartIdx ? pageIds[actualEndIdx] : undefined,\n        includeMeta ? meta : undefined,\n    );\n\n/**\n * Finds the break offset within a window, trying exclusions first, then patterns.\n *\n * @returns Break offset relative to remainingContent, or windowEndPosition as fallback\n */\nconst findBreakOffsetForWindow = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    windowEndPosition: number,\n    pageIds: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    cumulativeOffsets: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    prefer: 'longer' | 'shorter',\n    maxContentLength?: number,\n) => {\n    const windowHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, windowEndIdx);\n\n    if (windowHasExclusions) {\n        const exclusionBreak = findExclusionBreakPosition(\n            currentFromIdx,\n            windowEndIdx,\n            toIdx,\n            pageIds,\n            expandedBreakpoints,\n            cumulativeOffsets,\n        );\n        if (exclusionBreak > 0) {\n            return { breakOffset: exclusionBreak };\n        }\n    }\n\n    const breakpointCtx: BreakpointContext = { expandedBreakpoints, normalizedPages, pageIds, prefer };\n    const patternMatch = findBreakPosition(\n        remainingContent,\n        currentFromIdx,\n        toIdx,\n        windowEndIdx,\n        windowEndPosition,\n        breakpointCtx,\n        maxContentLength,\n    );\n\n    if (patternMatch && patternMatch.breakPos > 0) {\n        return {\n            breakOffset: patternMatch.breakPos,\n            breakpointIndex: patternMatch.breakpointIndex,\n            breakpointRule: patternMatch.rule,\n        };\n    }\n\n    // Fallback: Always try to find a safe break position (avoid mid-word splits)\n    if (windowEndPosition < remainingContent.length) {\n        const safeOffset = findSafeBreakPosition(remainingContent, windowEndPosition);\n        if (safeOffset !== -1) {\n            return {\n                breakOffset: safeOffset,\n                contentLengthSplit: maxContentLength ? { maxContentLength, reason: 'whitespace' as const } : undefined,\n            };\n        }\n        // If no safe break (whitespace) found, ensure we don't split a surrogate pair\n        const adjustedOffset = adjustForUnicodeBoundary(remainingContent, windowEndPosition);\n        return {\n            breakOffset: adjustedOffset,\n            contentLengthSplit: maxContentLength\n                ? { maxContentLength, reason: 'unicode_boundary' as const }\n                : undefined,\n        };\n    }\n\n    return { breakOffset: windowEndPosition };\n};\n\n/**\n * Advances cursor position past any leading whitespace.\n */\nconst skipWhitespace = (content: string, startPos: number) => {\n    let pos = startPos;\n    while (pos < content.length && /\\s/.test(content[pos])) {\n        pos++;\n    }\n    return pos;\n};\n\n/**\n * Validates that cumulative offsets match actual content length within a tolerance.\n * Required to detect if structural rules (like `lineStartsAfter`) have stripped content\n * which would make offset-based calculations inaccurate.\n */\nconst checkFastPathAlignment = (\n    cumulativeOffsets: number[],\n    fullContent: string,\n    fromIdx: number,\n    toIdx: number,\n    pageCount: number,\n    logger?: Logger,\n) => {\n    const expectedLength = (cumulativeOffsets[toIdx + 1] ?? fullContent.length) - (cumulativeOffsets[fromIdx] ?? 0);\n    const driftTolerance = Math.max(100, fullContent.length * 0.01);\n    const isAligned = Math.abs(expectedLength - fullContent.length) <= driftTolerance;\n\n    if (!isAligned && pageCount >= FAST_PATH_THRESHOLD) {\n        logger?.warn?.('[breakpoints] Offset drift detected in fast-path candidate, falling back to slow path', {\n            actualLength: fullContent.length,\n            drift: Math.abs(expectedLength - fullContent.length),\n            expectedLength,\n            pageCount,\n        });\n    }\n    return isAligned;\n};\n\n/**\n * Handles the special optimized case for maxPages=0 (1 page per segment).\n * This is O(n) and safer than offset arithmetic as it uses source pages directly.\n */\nconst processTrivialFastPath = (\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    pageCount: number,\n    originalMeta?: Segment['meta'],\n    debugMetaKey?: string,\n    logger?: Logger,\n) => {\n    logger?.debug?.('[breakpoints] Using trivial per-page fast-path (maxPages=0)', { fromIdx, pageCount, toIdx });\n    const result: Segment[] = [];\n    for (let i = fromIdx; i <= toIdx; i++) {\n        const pageData = normalizedPages.get(pageIds[i]);\n        if (pageData?.content.trim()) {\n            const isFirstPiece = i === fromIdx;\n            const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, null);\n            const seg = createSegment(pageData.content.trim(), pageIds[i], undefined, meta);\n            if (seg) {\n                result.push(seg);\n            }\n        }\n    }\n    return result;\n};\n\n/**\n * Handles fast-path segmentation for maxPages > 0 using cumulative offsets.\n * Avoids O(n²) string searching but requires accurate offsets.\n */\nconst buildFastPathRawContent = (\n    fullContent: string,\n    baseOffset: number,\n    cumulativeOffsets: number[],\n    segStart: number,\n    segEnd: number,\n    toIdx: number,\n) => {\n    const startOffset = Math.max(0, (cumulativeOffsets[segStart] ?? 0) - baseOffset);\n    const endOffset =\n        segEnd < toIdx\n            ? Math.max(0, (cumulativeOffsets[segEnd + 1] ?? fullContent.length) - baseOffset)\n            : fullContent.length;\n    return fullContent.slice(startOffset, endOffset).trim();\n};\n\nconst buildFastPathSegment = (\n    fullContent: string,\n    baseOffset: number,\n    cumulativeOffsets: number[],\n    segStart: number,\n    segEnd: number,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    originalMeta?: Segment['meta'],\n    debugMetaKey?: string,\n) => {\n    const rawContent = buildFastPathRawContent(fullContent, baseOffset, cumulativeOffsets, segStart, segEnd, toIdx);\n    if (!rawContent) {\n        return null;\n    }\n\n    const isFirstPiece = segStart === fromIdx;\n    const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, null);\n\n    const seg: Segment = {\n        content: rawContent,\n        from: pageIds[segStart],\n    };\n\n    if (segEnd > segStart) {\n        seg.to = pageIds[segEnd];\n    }\n    if (meta) {\n        seg.meta = meta;\n    }\n    return seg;\n};\n\nconst processOffsetFastPath = (\n    fullContent: string,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    cumulativeOffsets: number[],\n    maxPages: number,\n    originalMeta?: Segment['meta'],\n    debugMetaKey?: string,\n    logger?: Logger,\n) => {\n    const result: Segment[] = [];\n    const pageCount = toIdx - fromIdx + 1;\n\n    logger?.debug?.('[breakpoints] Using offset-based fast-path for large segment', {\n        fromIdx,\n        maxPages,\n        pageCount,\n        toIdx,\n    });\n\n    const baseOffset = cumulativeOffsets[fromIdx] ?? 0;\n\n    // IMPORTANT: This fast path is only valid when breakpoint behavior is effectively\n    // \"page boundary fallback\" (empty breakpoint ''), which breaks oversized segments\n    // at the NEXT page boundary (end of the current page) until the remaining span fits.\n    //\n    // That means the output shape is:\n    // - many single-page pieces, then\n    // - one final segment that includes the remaining pages (<= maxPages ID span).\n    //\n    // This mirrors the iterative breakpoint semantics and avoids \"threshold flips\" where\n    // results change at FAST_PATH_THRESHOLD.\n    let segStart = fromIdx;\n    const needsPeel = (startIdx: number) => pageIds[toIdx] - pageIds[startIdx] > maxPages;\n\n    for (; segStart <= toIdx && needsPeel(segStart); segStart++) {\n        const seg = buildFastPathSegment(\n            fullContent,\n            baseOffset,\n            cumulativeOffsets,\n            segStart,\n            segStart,\n            fromIdx,\n            toIdx,\n            pageIds,\n            originalMeta,\n            debugMetaKey,\n        );\n        if (seg) {\n            result.push(seg);\n        }\n    }\n\n    // Final remainder (fits maxPages by ID span)\n    if (segStart <= toIdx) {\n        const seg = buildFastPathSegment(\n            fullContent,\n            baseOffset,\n            cumulativeOffsets,\n            segStart,\n            toIdx,\n            fromIdx,\n            toIdx,\n            pageIds,\n            originalMeta,\n            debugMetaKey,\n        );\n        if (seg) {\n            result.push(seg);\n        }\n    }\n    return result;\n};\n\n/**\n * Checks if the remaining content fits within paged/length limits.\n * If so, pushes the final segment and returns true.\n */\nconst handleOversizedSegmentFit = (\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    expandedBreakpoints: Array<{ excludeSet: Set<number> }>,\n    maxPages: number,\n    maxContentLength: number | undefined,\n    isFirstPiece: boolean,\n    debugMetaKey: string | undefined,\n    originalMeta: Segment['meta'] | undefined,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n    result: Segment[],\n) => {\n    const remainingSpan = computeRemainingSpan(currentFromIdx, toIdx, pageIds);\n    const remainingHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, toIdx);\n\n    const fitsInPages = remainingSpan <= maxPages;\n    const fitsInLength = !maxContentLength || remainingContent.length <= maxContentLength;\n\n    if (fitsInPages && fitsInLength && !remainingHasExclusions) {\n        const includeMeta = isFirstPiece || Boolean(debugMetaKey);\n        const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint);\n        const finalSeg = createFinalSegment(remainingContent, currentFromIdx, toIdx, pageIds, meta, includeMeta);\n        if (finalSeg) {\n            result.push(finalSeg);\n        }\n        return true;\n    }\n    return false;\n};\n\n/**\n * Builds metadata for a segment piece, optionally including debug info.\n */\nconst getSegmentMetaWithDebug = (\n    isFirstPiece: boolean,\n    debugMetaKey: string | undefined,\n    originalMeta: Segment['meta'] | undefined,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n    contentLengthSplit?: { reason: 'whitespace' | 'unicode_boundary'; maxContentLength: number },\n) => {\n    const includeMeta = isFirstPiece || Boolean(debugMetaKey);\n    if (!includeMeta) {\n        return undefined;\n    }\n\n    let meta = isFirstPiece ? originalMeta : undefined;\n\n    if (debugMetaKey) {\n        if (lastBreakpoint) {\n            meta = mergeDebugIntoMeta(\n                meta,\n                debugMetaKey,\n                buildBreakpointDebugPatch(lastBreakpoint.breakpointIndex, lastBreakpoint.rule as any),\n            );\n        }\n        if (contentLengthSplit) {\n            meta = mergeDebugIntoMeta(meta, debugMetaKey, {\n                contentLengthSplit: {\n                    maxContentLength: contentLengthSplit.maxContentLength,\n                    splitReason: contentLengthSplit.reason,\n                },\n            });\n        }\n    }\n\n    return meta;\n};\n\n/**\n * Calculates window end position, capped by maxContentLength if present.\n */\nconst getWindowEndPosition = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    maxContentLength: number | undefined,\n    logger?: Logger,\n) => {\n    const pos = findBreakpointWindowEndPosition(\n        remainingContent,\n        currentFromIdx,\n        windowEndIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        logger,\n    );\n    return maxContentLength ? Math.min(pos, maxContentLength) : pos;\n};\n\n/**\n * Advances cursorPos and currentFromIdx for the next iteration.\n */\nconst advanceCursorAndIndex = (\n    fullContent: string,\n    breakPos: number,\n    actualEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    const nextCursorPos = skipWhitespace(fullContent, breakPos);\n    const nextFromIdx = computeNextFromIdx(\n        fullContent.slice(nextCursorPos, nextCursorPos + 500),\n        actualEndIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n    );\n    return { currentFromIdx: nextFromIdx, cursorPos: nextCursorPos };\n};\n\nconst computeIterationWindow = (\n    fullContent: string,\n    cursorPos: number,\n    currentFromIdx: number,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    boundaryPositions: number[],\n    maxPages: number,\n    maxContentLength: number | undefined,\n) => {\n    const windowEndIdx = computeWindowEndIdx(currentFromIdx, toIdx, pageIds, maxPages);\n\n    // Optimization: slice only the active \"window\" plus a small padding.\n    // This avoids O(N^2) copying when maxContentLength is unset (e.g. debug mode forces iterative path).\n    const windowEndBoundaryIdx = windowEndIdx - fromIdx + 1; // boundaryPositions[0] is fromIdx start\n    const windowEndAbsPos = boundaryPositions[windowEndBoundaryIdx] ?? fullContent.length;\n    const sliceEndByPages = Math.min(fullContent.length, windowEndAbsPos + 4000);\n    const sliceEndByLength = maxContentLength\n        ? Math.min(fullContent.length, cursorPos + maxContentLength + 4000)\n        : fullContent.length;\n    const sliceEnd = Math.max(cursorPos + 1, Math.min(sliceEndByPages, sliceEndByLength));\n\n    const remainingContent = fullContent.slice(cursorPos, sliceEnd);\n    return { remainingContent, sliceEnd, windowEndIdx };\n};\n\nconst computeWindowEndPositionForIteration = (\n    remainingContent: string,\n    cursorPos: number,\n    currentFromIdx: number,\n    fromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    boundaryPositions: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    maxPages: number,\n    maxContentLength: number | undefined,\n    logger?: Logger,\n) => {\n    // When maxPages=0, the window MUST NOT extend beyond the current page boundary.\n    // Otherwise, breakpoint matching can \"see\" into the next page and create segments spanning pages,\n    // even though maxPages=0 semantically means each segment must stay within a single page.\n    if (maxPages === 0) {\n        const boundaryIdx = currentFromIdx - fromIdx + 1; // boundaryPositions[0] is fromIdx start\n        const nextPageStartPos = boundaryPositions[boundaryIdx] ?? Number.POSITIVE_INFINITY;\n        const remainingInCurrentPage = Math.max(0, nextPageStartPos - cursorPos);\n        const capped = maxContentLength ? Math.min(remainingInCurrentPage, maxContentLength) : remainingInCurrentPage;\n        return Math.min(capped, remainingContent.length);\n    }\n\n    const pos = getWindowEndPosition(\n        remainingContent,\n        currentFromIdx,\n        windowEndIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        maxContentLength,\n        logger,\n    );\n    return Math.min(pos, remainingContent.length);\n};\n\nconst ensureProgressingBreakOffset = (\n    foundBreakOffset: number,\n    remainingContent: string,\n    cursorPos: number,\n    maxContentLength: number | undefined,\n    logger?: Logger,\n) => {\n    if (foundBreakOffset > 0) {\n        return foundBreakOffset;\n    }\n\n    // Progress safeguard: Ensure we advance by at least one character to prevent infinite loops.\n    // This is critical if findBreakOffsetForWindow returns 0 (e.g. from an empty windowEndPosition).\n    const fallbackPos = maxContentLength ? Math.min(maxContentLength, remainingContent.length) : 1;\n    const breakOffset = Math.max(1, fallbackPos);\n    logger?.warn?.('[breakpoints] No progress from findBreakOffsetForWindow; forcing forward movement', {\n        breakOffset,\n        cursorPos,\n    });\n    return breakOffset;\n};\n\nconst updateLastBreakpointFromFound = (\n    found: ReturnType<typeof findBreakOffsetForWindow>,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n) => {\n    if (found.breakpointIndex !== undefined && found.breakpointRule) {\n        return { breakpointIndex: found.breakpointIndex, rule: found.breakpointRule };\n    }\n    return lastBreakpoint;\n};\n\nconst appendPieceAndAdvance = (\n    fullContent: string,\n    cursorPos: number,\n    breakPos: number,\n    pieceContent: string,\n    currentFromIdx: number,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    boundaryPositions: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    maxPages: number,\n    isFirstPiece: boolean,\n    debugMetaKey: string | undefined,\n    originalMeta: Segment['meta'] | undefined,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n    result: Segment[],\n    logger?: Logger,\n    contentLengthSplit?: { reason: 'whitespace' | 'unicode_boundary'; maxContentLength: number },\n) => {\n    let { actualEndIdx, actualStartIdx } = computePiecePages(cursorPos, breakPos, boundaryPositions, fromIdx, toIdx);\n\n    // Safety: boundaryPositions can be slightly misaligned in rare cases for very large segments\n    // (e.g. if upstream content was trimmed/normalized). Never allow a piece to \"start\" before\n    // the current page cursor, as that can violate maxPages constraints by inflating from/to span.\n    if (actualStartIdx < currentFromIdx) {\n        logger?.warn?.('[breakpoints] Page attribution drift detected; clamping actualStartIdx', {\n            actualStartIdx,\n            currentFromIdx,\n        });\n        actualStartIdx = currentFromIdx;\n    }\n\n    // When maxPages=0, enforce that the piece cannot span beyond the current page.\n    // This is necessary because boundaryPositions-based page detection can be confused\n    // when pages have duplicate/overlapping content at boundaries.\n    if (maxPages === 0) {\n        actualEndIdx = Math.min(actualEndIdx, currentFromIdx);\n        actualStartIdx = Math.min(actualStartIdx, currentFromIdx);\n    } else if (maxPages > 0) {\n        // Enforce ID-span-based maxPages for page attribution too (handles drift).\n        const maxAllowedEndIdx = computeWindowEndIdx(actualStartIdx, toIdx, pageIds, maxPages);\n        actualEndIdx = Math.min(actualEndIdx, maxAllowedEndIdx);\n    }\n\n    const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint, contentLengthSplit);\n    const pieceSeg = createPieceSegment(pieceContent, actualStartIdx, actualEndIdx, pageIds, meta, true);\n    if (pieceSeg) {\n        result.push(pieceSeg);\n    }\n\n    const next = advanceCursorAndIndex(fullContent, breakPos, actualEndIdx, toIdx, pageIds, normalizedPages);\n    let nextFromIdx = next.currentFromIdx;\n    if (maxPages === 0) {\n        // When maxPages=0, content-based detection can be confused by overlapping content; use positions.\n        nextFromIdx = findPageIndexForPosition(next.cursorPos, boundaryPositions, fromIdx);\n    }\n    return { currentFromIdx: nextFromIdx, cursorPos: next.cursorPos };\n};\n\nconst tryProcessOversizedSegmentFastPath = (\n    segment: Segment,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    maxPages: number,\n    logger?: Logger,\n    debugMetaKey?: string,\n    maxContentLength?: number,\n) => {\n    const fullContent = segment.content;\n    const pageCount = toIdx - fromIdx + 1;\n\n    const isAligned = checkFastPathAlignment(cumulativeOffsets, fullContent, fromIdx, toIdx, pageCount, logger);\n    const isPageBoundaryOnly = expandedBreakpoints.every(\n        (bp) => bp.regex === null && bp.excludeSet.size === 0 && bp.skipWhenRegex === undefined,\n    );\n    if (pageCount < FAST_PATH_THRESHOLD || !isAligned || !isPageBoundaryOnly || maxContentLength || debugMetaKey) {\n        return null;\n    }\n\n    if (maxPages === 0) {\n        return processTrivialFastPath(\n            fromIdx,\n            toIdx,\n            pageIds,\n            normalizedPages,\n            pageCount,\n            segment.meta,\n            debugMetaKey,\n            logger,\n        );\n    }\n\n    return processOffsetFastPath(\n        fullContent,\n        fromIdx,\n        toIdx,\n        pageIds,\n        cumulativeOffsets,\n        maxPages,\n        segment.meta,\n        debugMetaKey,\n        logger,\n    );\n};\n\nconst processOversizedSegmentIterative = (\n    segment: Segment,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    maxPages: number,\n    prefer: 'longer' | 'shorter',\n    logger?: Logger,\n    debugMetaKey?: string,\n    maxContentLength?: number,\n) => {\n    const result: Segment[] = [];\n    const fullContent = segment.content;\n    const pageCount = toIdx - fromIdx + 1;\n\n    // SLOW PATH: Iterative breakpoint processing\n    // WARNING: This path can be slow for large segments - if this log shows large pageCount, investigate!\n    logger?.debug?.('[breakpoints] processOversizedSegment: Using iterative path', {\n        contentLength: fullContent.length,\n        fromIdx,\n        maxContentLength,\n        maxPages,\n        pageCount,\n        toIdx,\n    });\n\n    let cursorPos = 0;\n    let currentFromIdx = fromIdx;\n    let isFirstPiece = true;\n    let lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null = null;\n\n    const boundaryPositions = buildBoundaryPositions(\n        fullContent,\n        fromIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        logger,\n    );\n\n    logger?.debug?.('[breakpoints] boundaryPositions built', {\n        boundaryPositions,\n        fromIdx,\n        fullContentLength: fullContent.length,\n        toIdx,\n    });\n\n    const MAX_SAFE_ITERATIONS = 100_000;\n    let didHitMaxIterations = true;\n\n    for (let i = 1; i <= MAX_SAFE_ITERATIONS; i++) {\n        if (cursorPos >= fullContent.length || currentFromIdx > toIdx) {\n            didHitMaxIterations = false;\n            break;\n        }\n\n        const { remainingContent, windowEndIdx } = computeIterationWindow(\n            fullContent,\n            cursorPos,\n            currentFromIdx,\n            fromIdx,\n            toIdx,\n            pageIds,\n            boundaryPositions,\n            maxPages,\n            maxContentLength,\n        );\n\n        if (!remainingContent.trim()) {\n            didHitMaxIterations = false;\n            break;\n        }\n\n        if (\n            handleOversizedSegmentFit(\n                remainingContent,\n                currentFromIdx,\n                toIdx,\n                pageIds,\n                expandedBreakpoints,\n                maxPages,\n                maxContentLength,\n                isFirstPiece,\n                debugMetaKey,\n                segment.meta,\n                lastBreakpoint,\n                result,\n            )\n        ) {\n            didHitMaxIterations = false;\n            break;\n        }\n\n        const windowEndPosition = computeWindowEndPositionForIteration(\n            remainingContent,\n            cursorPos,\n            currentFromIdx,\n            fromIdx,\n            windowEndIdx,\n            toIdx,\n            pageIds,\n            boundaryPositions,\n            normalizedPages,\n            cumulativeOffsets,\n            maxPages,\n            maxContentLength,\n            logger,\n        );\n\n        // Per-iteration log at trace level to avoid spam in debug mode\n        logger?.trace?.(`[breakpoints] iteration=${i}`, { currentFromIdx, cursorPos, windowEndIdx, windowEndPosition });\n\n        const found = findBreakOffsetForWindow(\n            remainingContent,\n            currentFromIdx,\n            windowEndIdx,\n            toIdx,\n            windowEndPosition,\n            pageIds,\n            expandedBreakpoints,\n            cumulativeOffsets,\n            normalizedPages,\n            prefer,\n            maxContentLength,\n        );\n\n        const breakOffset = ensureProgressingBreakOffset(\n            found.breakOffset,\n            remainingContent,\n            cursorPos,\n            maxContentLength,\n            logger,\n        );\n        lastBreakpoint = updateLastBreakpointFromFound(found, lastBreakpoint);\n\n        const breakPos = cursorPos + breakOffset;\n        const pieceContent = fullContent.slice(cursorPos, breakPos).trim();\n        if (!pieceContent) {\n            cursorPos = breakPos;\n            isFirstPiece = false;\n            continue;\n        }\n\n        const next = appendPieceAndAdvance(\n            fullContent,\n            cursorPos,\n            breakPos,\n            pieceContent,\n            currentFromIdx,\n            fromIdx,\n            toIdx,\n            pageIds,\n            boundaryPositions,\n            normalizedPages,\n            maxPages,\n            isFirstPiece,\n            debugMetaKey,\n            segment.meta,\n            lastBreakpoint,\n            result,\n            logger,\n            found.contentLengthSplit,\n        );\n        cursorPos = next.cursorPos;\n        currentFromIdx = next.currentFromIdx;\n        isFirstPiece = false;\n    }\n\n    if (didHitMaxIterations) {\n        logger?.error?.('[breakpoints] Stopped processing oversized segment: reached MAX_SAFE_ITERATIONS', {\n            cursorPos,\n            fullContentLength: fullContent.length,\n            iterations: MAX_SAFE_ITERATIONS,\n        });\n    }\n\n    logger?.debug?.('[breakpoints] processOversizedSegment: Complete', { resultCount: result.length });\n    return result;\n};\n\n/**\n * Applies breakpoints to oversized segments.\n *\n * Note: This is an internal engine used by `segmentPages()`.\n */\n/**\n * Processes an oversized segment by iterating through the content and\n * breaking it into smaller pieces that fit within maxPages constraints.\n *\n * Uses precomputed boundary positions for O(log n) page attribution lookups.\n */\nconst processOversizedSegment = (\n    segment: Segment,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    maxPages: number,\n    prefer: 'longer' | 'shorter',\n    logger?: Logger,\n    debugMetaKey?: string,\n    maxContentLength?: number,\n) => {\n    const fast = tryProcessOversizedSegmentFastPath(\n        segment,\n        fromIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        expandedBreakpoints,\n        maxPages,\n        logger,\n        debugMetaKey,\n        maxContentLength,\n    );\n    if (fast) {\n        return fast;\n    }\n\n    return processOversizedSegmentIterative(\n        segment,\n        fromIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        expandedBreakpoints,\n        maxPages,\n        prefer,\n        logger,\n        debugMetaKey,\n        maxContentLength,\n    );\n};\n\nexport const applyBreakpoints = (\n    segments: Segment[],\n    pages: Page[],\n    normalizedContent: string[],\n    maxPages: number,\n    breakpoints: Breakpoint[],\n    prefer: 'longer' | 'shorter',\n    patternProcessor: PatternProcessor,\n    logger?: Logger,\n    pageJoiner: 'space' | 'newline' = 'space',\n    debugMetaKey?: string,\n    maxContentLength?: number,\n    rawPatternProcessor?: PatternProcessor,\n) => {\n    const pageIds = pages.map((p) => p.id);\n    const pageIdToIndex = buildPageIdToIndexMap(pageIds);\n    const normalizedPages = buildNormalizedPagesMap(pages, normalizedContent);\n    const cumulativeOffsets = buildCumulativeOffsets(pageIds, normalizedPages);\n    const expandedBreakpoints = expandBreakpoints(breakpoints, patternProcessor, rawPatternProcessor);\n\n    const result: Segment[] = [];\n\n    logger?.info?.('Starting breakpoint processing', { maxPages, segmentCount: segments.length });\n\n    logger?.debug?.('[breakpoints] inputSegments', {\n        segmentCount: segments.length,\n        segments: segments.map((s) => ({ contentLength: s.content.length, from: s.from, to: s.to })),\n    });\n\n    for (const segment of segments) {\n        const fromIdx = pageIdToIndex.get(segment.from) ?? -1;\n        const toIdx = segment.to !== undefined ? (pageIdToIndex.get(segment.to) ?? fromIdx) : fromIdx;\n\n        const segmentSpan = (segment.to ?? segment.from) - segment.from;\n        const hasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, fromIdx, toIdx);\n\n        const fitsInPages = segmentSpan <= maxPages;\n        const fitsInLength = !maxContentLength || segment.content.length <= maxContentLength;\n\n        if (fitsInPages && fitsInLength && !hasExclusions) {\n            result.push(segment);\n            continue;\n        }\n\n        // Log details about why this segment needs breaking up\n        logger?.debug?.('[breakpoints] Processing oversized segment', {\n            contentLength: segment.content.length,\n            from: segment.from,\n            hasExclusions,\n            pageSpan: toIdx - fromIdx + 1,\n            reasonFitsInLength: fitsInLength,\n            reasonFitsInPages: fitsInPages,\n            to: segment.to,\n        });\n\n        const broken = processOversizedSegment(\n            segment,\n            fromIdx,\n            toIdx,\n            pageIds,\n            normalizedPages,\n            cumulativeOffsets,\n            expandedBreakpoints,\n            maxPages,\n            prefer,\n            logger,\n            debugMetaKey,\n            maxContentLength,\n        );\n\n        // Normalize page joins for breakpoint-created pieces\n        result.push(\n            ...broken.map((s) => {\n                const segFromIdx = pageIdToIndex.get(s.from) ?? -1;\n                const segToIdx = s.to !== undefined ? (pageIdToIndex.get(s.to) ?? segFromIdx) : segFromIdx;\n                if (segFromIdx >= 0 && segToIdx > segFromIdx) {\n                    return {\n                        ...s,\n                        content: applyPageJoinerBetweenPages(\n                            s.content,\n                            segFromIdx,\n                            segToIdx,\n                            pageIds,\n                            normalizedPages,\n                            pageJoiner,\n                        ),\n                    };\n                }\n                return s;\n            }),\n        );\n    }\n\n    logger?.info?.('Breakpoint processing completed', { resultCount: result.length });\n    return result;\n};\n","import type { SplitRule } from '@/types/rules.js';\nimport { isPageExcluded } from './breakpoint-utils.js';\n\n/**\n * Result of a regex match with position and optional capture information.\n *\n * Represents a single match found by the segmentation engine, including\n * its position in the concatenated content and any captured values.\n */\nexport type MatchResult = {\n    /**\n     * Start offset (inclusive) of the match in the content string.\n     */\n    start: number;\n\n    /**\n     * End offset (exclusive) of the match in the content string.\n     *\n     * The matched text is `content.slice(start, end)`.\n     */\n    end: number;\n\n    /**\n     * Content captured by `lineStartsAfter` patterns.\n     *\n     * For patterns like `^٦٦٩٦ - (.*)`, this contains the text\n     * matched by the `(.*)` group (the rest of the line after the marker).\n     */\n    captured?: string;\n\n    /**\n     * Named capture group values from `{{token:name}}` syntax.\n     *\n     * Keys are the capture names, values are the matched strings.\n     *\n     * @example\n     * // For pattern '{{raqms:num}} {{dash}}'\n     * { num: '٦٦٩٦' }\n     */\n    namedCaptures?: Record<string, string>;\n};\n\n/**\n * Extracts named capture groups from a regex match.\n *\n * Only includes groups that are in the `captureNames` list and have\n * defined values. This filters out positional captures and ensures\n * only explicitly requested named captures are returned.\n *\n * @param groups - The `match.groups` object from `RegExp.exec()`\n * @param captureNames - List of capture names to extract (from `{{token:name}}` syntax)\n * @returns Object with capture name → value pairs, or `undefined` if none found\n *\n * @example\n * const match = /(?<num>[٠-٩]+) -/.exec('٦٦٩٦ - text');\n * extractNamedCaptures(match.groups, ['num'])\n * // → { num: '٦٦٩٦' }\n *\n * @example\n * // No matching captures\n * extractNamedCaptures({}, ['num'])\n * // → undefined\n *\n * @example\n * // Undefined groups\n * extractNamedCaptures(undefined, ['num'])\n * // → undefined\n */\nexport const extractNamedCaptures = (groups: Record<string, string> | undefined, captureNames: string[]) => {\n    if (!groups || captureNames.length === 0) {\n        return undefined;\n    }\n    const namedCaptures: Record<string, string> = {};\n    for (const name of captureNames) {\n        if (groups[name] !== undefined) {\n            namedCaptures[name] = groups[name];\n        }\n    }\n    return Object.keys(namedCaptures).length > 0 ? namedCaptures : undefined;\n};\n\n/**\n * Gets the last defined positional capture group from a match array.\n *\n * Used for `lineStartsAfter` patterns where the content capture (`.*`)\n * is always at the end of the pattern. Named captures may shift the\n * positional indices, so we iterate backward to find the actual content.\n *\n * @param match - RegExp exec result array\n * @returns The last defined capture group value, or `undefined` if none\n *\n * @example\n * // Pattern: ^(?:(?<num>[٠-٩]+) - )(.*)\n * // Match array: ['٦٦٩٦ - content', '٦٦٩٦', 'content']\n * getLastPositionalCapture(match)\n * // → 'content'\n *\n * @example\n * // No captures\n * getLastPositionalCapture(['full match'])\n * // → undefined\n */\nexport const getLastPositionalCapture = (match: RegExpExecArray) => {\n    if (match.length <= 1) {\n        return undefined;\n    }\n    for (let i = match.length - 1; i >= 1; i--) {\n        if (match[i] !== undefined) {\n            return match[i];\n        }\n    }\n    return undefined;\n};\n\n/**\n * Filters matches to only include those within page ID constraints.\n *\n * Applies the `min`, `max`, and `exclude` constraints from a rule to filter out\n * matches that occur on pages outside the allowed range or explicitly excluded.\n *\n * @param matches - Array of match results to filter\n * @param rule - Rule containing `min`, `max`, and/or `exclude` page constraints\n * @param getId - Function that returns the page ID for a given offset\n * @returns Filtered array containing only matches within constraints\n *\n * @example\n * const matches = [\n *   { start: 0, end: 10 },   // Page 1\n *   { start: 100, end: 110 }, // Page 5\n *   { start: 200, end: 210 }, // Page 10\n * ];\n * filterByConstraints(matches, { min: 3, max: 8 }, getId)\n * // → [{ start: 100, end: 110 }] (only page 5 match)\n */\nexport const filterByConstraints = (\n    matches: MatchResult[],\n    rule: Pick<SplitRule, 'min' | 'max' | 'exclude'>,\n    getId: (offset: number) => number,\n) =>\n    matches.filter((m) => {\n        const id = getId(m.start);\n        return (\n            (rule.min === undefined || id >= rule.min) &&\n            (rule.max === undefined || id <= rule.max) &&\n            !isPageExcluded(id, rule.exclude)\n        );\n    });\n\n/**\n * Filters matches based on occurrence setting (first, last, or all).\n *\n * Applies occurrence-based selection to a list of matches:\n * - `'all'` or `undefined`: Return all matches (default)\n * - `'first'`: Return only the first match\n * - `'last'`: Return only the last match\n *\n * @param matches - Array of match results to filter\n * @param occurrence - Which occurrence(s) to keep\n * @returns Filtered array based on occurrence setting\n *\n * @example\n * const matches = [{ start: 0 }, { start: 10 }, { start: 20 }];\n *\n * filterByOccurrence(matches, 'first')\n * // → [{ start: 0 }]\n *\n * filterByOccurrence(matches, 'last')\n * // → [{ start: 20 }]\n *\n * filterByOccurrence(matches, 'all')\n * // → [{ start: 0 }, { start: 10 }, { start: 20 }]\n *\n * filterByOccurrence(matches, undefined)\n * // → [{ start: 0 }, { start: 10 }, { start: 20 }] (default: all)\n */\nexport const filterByOccurrence = (matches: MatchResult[], occurrence?: 'first' | 'last' | 'all') => {\n    if (!matches.length) {\n        return [];\n    }\n    if (occurrence === 'first') {\n        return [matches[0]];\n    }\n    if (occurrence === 'last') {\n        return [matches.at(-1)!];\n    }\n    return matches;\n};\n\n/**\n * Checks if any rule in the list allows the given page ID.\n *\n * A rule allows an ID if it falls within the rule's `min`/`max` constraints.\n * Rules without constraints allow all page IDs.\n *\n * This is used to determine whether to create a segment for content\n * that appears before any split points (the \"first segment\").\n *\n * @param rules - Array of rules with optional `min` and `max` constraints\n * @param pageId - Page ID to check\n * @returns `true` if at least one rule allows the page ID\n *\n * @example\n * const rules = [\n *   { min: 5, max: 10 },  // Allows pages 5-10\n *   { min: 20 },          // Allows pages 20+\n * ];\n *\n * anyRuleAllowsId(rules, 7)   // → true (first rule allows)\n * anyRuleAllowsId(rules, 3)   // → false (no rule allows)\n * anyRuleAllowsId(rules, 25)  // → true (second rule allows)\n *\n * @example\n * // Rules without constraints allow everything\n * anyRuleAllowsId([{}], 999) // → true\n */\nexport const anyRuleAllowsId = (rules: Pick<SplitRule, 'min' | 'max'>[], pageId: number) =>\n    rules.some((r) => (r.min === undefined || pageId >= r.min) && (r.max === undefined || pageId <= r.max));\n","/**\n * Fast-path fuzzy prefix matching for common Arabic line-start markers.\n *\n * This exists to avoid running expensive fuzzy-expanded regex alternations over\n * a giant concatenated string. Instead, we match only at known line-start\n * offsets and perform a small deterministic comparison:\n * - Skip Arabic diacritics in the CONTENT\n * - Treat common equivalence groups as equal (ا/آ/أ/إ, ة/ه, ى/ي)\n *\n * This module is intentionally conservative: it only supports \"literal\"\n * token patterns (plain text alternation via `|`), not general regex.\n */\n\nimport { getTokenPattern } from './tokens.js';\n\nexport type FastFuzzyTokenRule = {\n    token: string;\n    alternatives: string[];\n};\n\n// U+064B..U+0652 (tashkeel/harakat)\nconst isArabicDiacriticCode = (code: number) => code >= 0x064b && code <= 0x0652;\n\nconst equivKey = (ch: string) => {\n    switch (ch) {\n        case '\\u0622': // آ\n        case '\\u0623': // أ\n        case '\\u0625': // إ\n            return '\\u0627'; // ا\n        case '\\u0647': // ه\n            return '\\u0629'; // ة\n        case '\\u064a': // ي\n            return '\\u0649'; // ى\n        default:\n            return ch;\n    }\n};\n\nexport const matchFuzzyLiteralPrefixAt = (content: string, offset: number, literal: string) => {\n    let i = offset;\n    while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) {\n        i++;\n    }\n\n    for (let j = 0; j < literal.length; j++) {\n        const litCh = literal[j];\n        while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) {\n            i++;\n        }\n        if (i >= content.length || equivKey(content[i]) !== equivKey(litCh)) {\n            return null;\n        }\n        i++;\n    }\n\n    while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) {\n        i++;\n    }\n    return i;\n};\n\nconst isLiteralOnly = (s: string) => !/[\\\\[\\]{}()^$.*+?]/.test(s);\n\nexport const compileLiteralAlternation = (pattern: string) => {\n    if (!pattern || !isLiteralOnly(pattern)) {\n        return null;\n    }\n    const alternatives = pattern\n        .split('|')\n        .map((s) => s.trim())\n        .filter(Boolean);\n    return alternatives.length ? { alternatives } : null;\n};\n\nexport const compileFastFuzzyTokenRule = (tokenTemplate: string) => {\n    const m = tokenTemplate.match(/^\\{\\{(\\w+)\\}\\}$/);\n    if (!m) {\n        return null;\n    }\n    const token = m[1];\n    const tokenPattern = getTokenPattern(token);\n    if (!tokenPattern) {\n        return null;\n    }\n    const compiled = compileLiteralAlternation(tokenPattern);\n    return compiled ? { alternatives: compiled.alternatives, token } : null;\n};\n\nexport const matchFastFuzzyTokenAt = (content: string, offset: number, compiled: FastFuzzyTokenRule) => {\n    for (const alt of compiled.alternatives) {\n        const end = matchFuzzyLiteralPrefixAt(content, offset, alt);\n        if (end !== null) {\n            return end;\n        }\n    }\n    return null;\n};\n","import type { SplitRule } from '@/types/rules.js';\nimport type { PageMap, SplitPoint } from '@/types/segmenter.js';\nimport { isPageExcluded } from './breakpoint-utils.js';\nimport { compileFastFuzzyTokenRule, type FastFuzzyTokenRule, matchFastFuzzyTokenAt } from './fast-fuzzy-prefix.js';\nimport { extractNamedCaptureNames, hasCapturingGroup, processPattern } from './rule-regex.js';\n\nexport type FastFuzzyRule = {\n    compiled: FastFuzzyTokenRule;\n    rule: SplitRule;\n    ruleIndex: number;\n    kind: 'startsWith' | 'startsAfter';\n};\n\nexport type PartitionedRules = {\n    combinableRules: Array<{ rule: SplitRule; prefix: string; index: number }>;\n    standaloneRules: SplitRule[];\n    fastFuzzyRules: FastFuzzyRule[];\n};\n\nexport const partitionRulesForMatching = (rules: SplitRule[]) => {\n    const combinableRules: { rule: SplitRule; prefix: string; index: number }[] = [];\n    const standaloneRules: SplitRule[] = [];\n    const fastFuzzyRules: FastFuzzyRule[] = [];\n\n    rules.forEach((rule, index) => {\n        const fuzzy = (rule as { fuzzy?: boolean }).fuzzy;\n        if (fuzzy) {\n            if ('lineStartsWith' in rule && rule.lineStartsWith.length === 1) {\n                const compiled = compileFastFuzzyTokenRule(rule.lineStartsWith[0]);\n                if (compiled) {\n                    return fastFuzzyRules.push({ compiled, kind: 'startsWith', rule, ruleIndex: index });\n                }\n            }\n            if ('lineStartsAfter' in rule && rule.lineStartsAfter.length === 1) {\n                const compiled = compileFastFuzzyTokenRule(rule.lineStartsAfter[0]);\n                if (compiled) {\n                    return fastFuzzyRules.push({ compiled, kind: 'startsAfter', rule, ruleIndex: index });\n                }\n            }\n        }\n\n        let isCombinable = true;\n        if ('regex' in rule && rule.regex) {\n            isCombinable =\n                extractNamedCaptureNames(rule.regex).length === 0 &&\n                !/\\\\[1-9]/.test(rule.regex) &&\n                !hasCapturingGroup(rule.regex);\n        }\n\n        if (isCombinable) {\n            combinableRules.push({ index, prefix: `r${index}_`, rule });\n        } else {\n            standaloneRules.push(rule);\n        }\n    });\n\n    return { combinableRules, fastFuzzyRules, standaloneRules };\n};\n\nexport type PageStartGuardChecker = (rule: SplitRule, ruleIndex: number, matchStart: number) => boolean;\n\nexport const createPageStartGuardChecker = (matchContent: string, pageMap: PageMap) => {\n    const pageStartToBoundaryIndex = new Map(pageMap.boundaries.map((b, i) => [b.start, i]));\n    const compiledPageStartPrev = new Map<number, RegExp | null>();\n\n    const getPageStartPrevRegex = (rule: SplitRule, ruleIndex: number) => {\n        if (compiledPageStartPrev.has(ruleIndex)) {\n            return compiledPageStartPrev.get(ruleIndex) ?? null;\n        }\n        const pattern = (rule as { pageStartGuard?: string }).pageStartGuard;\n        if (!pattern) {\n            compiledPageStartPrev.set(ruleIndex, null);\n            return null;\n        }\n        const re = new RegExp(`(?:${processPattern(pattern, false).pattern})$`, 'u');\n        compiledPageStartPrev.set(ruleIndex, re);\n        return re;\n    };\n\n    const getPrevPageLastNonWsChar = (boundaryIndex: number) => {\n        if (boundaryIndex <= 0) {\n            return '';\n        }\n        const prevBoundary = pageMap.boundaries[boundaryIndex - 1];\n        for (let i = prevBoundary.end - 1; i >= prevBoundary.start; i--) {\n            const ch = matchContent[i];\n            if (ch && !/\\s/u.test(ch)) {\n                return ch;\n            }\n        }\n        return '';\n    };\n\n    return (rule: SplitRule, ruleIndex: number, matchStart: number) => {\n        const boundaryIndex = pageStartToBoundaryIndex.get(matchStart);\n        if (boundaryIndex === undefined || boundaryIndex === 0) {\n            return true;\n        }\n        const prevReq = getPageStartPrevRegex(rule, ruleIndex);\n        if (!prevReq) {\n            return true;\n        }\n        const lastChar = getPrevPageLastNonWsChar(boundaryIndex);\n        return lastChar ? prevReq.test(lastChar) : false;\n    };\n};\n\n/**\n * Checks if a pageId matches the min/max/exclude constraints of a rule.\n */\nconst passesRuleConstraints = (rule: SplitRule, pageId: number) =>\n    (rule.min === undefined || pageId >= rule.min) &&\n    (rule.max === undefined || pageId <= rule.max) &&\n    !isPageExcluded(pageId, rule.exclude);\n\n/**\n * Records a split point for a specific rule.\n */\nconst recordSplitPointAt = (splitPointsByRule: Map<number, SplitPoint[]>, ruleIndex: number, sp: SplitPoint) => {\n    const arr = splitPointsByRule.get(ruleIndex);\n    if (!arr) {\n        splitPointsByRule.set(ruleIndex, [sp]);\n    } else {\n        arr.push(sp);\n    }\n};\n\n/**\n * Processes matches for all fast-fuzzy rules at a specific line start.\n */\nconst processFastFuzzyMatchesAt = (\n    matchContent: string,\n    lineStart: number,\n    pageId: number,\n    fastFuzzyRules: FastFuzzyRule[],\n    passesPageStartGuard: PageStartGuardChecker,\n    isPageStart: boolean,\n    splitPointsByRule: Map<number, SplitPoint[]>,\n) => {\n    for (const { compiled, kind, rule, ruleIndex } of fastFuzzyRules) {\n        if (!passesRuleConstraints(rule, pageId)) {\n            continue;\n        }\n\n        if (isPageStart && !passesPageStartGuard(rule, ruleIndex, lineStart)) {\n            continue;\n        }\n\n        const end = matchFastFuzzyTokenAt(matchContent, lineStart, compiled);\n        if (end === null) {\n            continue;\n        }\n\n        const splitIndex = (rule.split ?? 'at') === 'at' ? lineStart : end;\n        if (kind === 'startsWith') {\n            recordSplitPointAt(splitPointsByRule, ruleIndex, { index: splitIndex, meta: rule.meta });\n        } else {\n            const markerLength = end - lineStart;\n            recordSplitPointAt(splitPointsByRule, ruleIndex, {\n                contentStartOffset: (rule.split ?? 'at') === 'at' ? markerLength : undefined,\n                index: splitIndex,\n                meta: rule.meta,\n            });\n        }\n    }\n};\n\nexport const collectFastFuzzySplitPoints = (\n    matchContent: string,\n    pageMap: PageMap,\n    fastFuzzyRules: FastFuzzyRule[],\n    passesPageStartGuard: PageStartGuardChecker,\n) => {\n    const splitPointsByRule = new Map<number, SplitPoint[]>();\n    if (fastFuzzyRules.length === 0 || pageMap.boundaries.length === 0) {\n        return splitPointsByRule;\n    }\n\n    // Stream page boundary cursor to avoid O(log n) getId calls in hot loop.\n    let boundaryIdx = 0;\n    let currentBoundary = pageMap.boundaries[boundaryIdx];\n    const advanceBoundaryTo = (offset: number) => {\n        while (currentBoundary && offset > currentBoundary.end && boundaryIdx < pageMap.boundaries.length - 1) {\n            boundaryIdx++;\n            currentBoundary = pageMap.boundaries[boundaryIdx];\n        }\n    };\n\n    const isPageStart = (offset: number) => offset === currentBoundary?.start;\n\n    // Line starts are offset 0 and any char after '\\n'\n    for (let lineStart = 0; lineStart <= matchContent.length; ) {\n        advanceBoundaryTo(lineStart);\n        const pageId = currentBoundary?.id ?? 0;\n\n        if (lineStart >= matchContent.length) {\n            break;\n        }\n\n        processFastFuzzyMatchesAt(\n            matchContent,\n            lineStart,\n            pageId,\n            fastFuzzyRules,\n            passesPageStartGuard,\n            isPageStart(lineStart),\n            splitPointsByRule,\n        );\n\n        const nextNl = matchContent.indexOf('\\n', lineStart);\n        if (nextNl === -1) {\n            break;\n        }\n        lineStart = nextNl + 1;\n    }\n\n    return splitPointsByRule;\n};\n","/**\n * Helper module for collectSplitPointsFromRules to reduce complexity.\n * Handles combined regex matching and split point creation.\n */\n\nimport type { Logger } from '@/types/options.js';\nimport type { SplitRule } from '@/types/rules.js';\nimport type { PageMap, SplitPoint } from '../types/segmenter.js';\nimport { isPageExcluded } from './breakpoint-utils.js';\nimport { buildRuleDebugPatch, mergeDebugIntoMeta } from './debug-meta.js';\nimport {\n    extractNamedCaptures,\n    filterByConstraints,\n    getLastPositionalCapture,\n    type MatchResult,\n} from './match-utils.js';\nimport { buildRuleRegex, type RuleRegex } from './rule-regex.js';\n\n// Maximum iterations before throwing to prevent infinite loops\nconst MAX_REGEX_ITERATIONS = 100000;\n\ntype CombinableRule = { rule: SplitRule; prefix: string; index: number };\n\ntype RuleRegexInfo = RuleRegex & { prefix: string; source: string };\n\n// Combined regex matching\n\nconst extractNamedCapturesForRule = (\n    groups: Record<string, string> | undefined,\n    captureNames: string[],\n    prefix: string,\n) => {\n    const result: Record<string, string> = {};\n    if (!groups) {\n        return result;\n    }\n    for (const name of captureNames) {\n        if (groups[name] !== undefined) {\n            result[name.slice(prefix.length)] = groups[name];\n        }\n    }\n    return result;\n};\n\nconst buildContentOffsets = (\n    match: RegExpExecArray,\n    ruleInfo: RuleRegexInfo,\n): { capturedContent?: string; contentStartOffset?: number } => {\n    if (!ruleInfo.usesLineStartsAfter) {\n        return {};\n    }\n\n    const captured = match.groups?.[`${ruleInfo.prefix}__content`];\n    if (captured === undefined) {\n        return {};\n    }\n\n    const fullMatch = match.groups?.[ruleInfo.prefix] || match[0];\n    return { contentStartOffset: fullMatch.length - captured.length };\n};\n\nconst passesRuleConstraints = (rule: SplitRule, pageId: number) =>\n    (rule.min === undefined || pageId >= rule.min) &&\n    (rule.max === undefined || pageId <= rule.max) &&\n    !isPageExcluded(pageId, rule.exclude);\n\nconst createSplitPointFromMatch = (match: RegExpExecArray, rule: SplitRule, ruleInfo: RuleRegexInfo): SplitPoint => {\n    const namedCaptures = extractNamedCapturesForRule(match.groups, ruleInfo.captureNames, ruleInfo.prefix);\n    return {\n        capturedContent: undefined,\n        contentStartOffset: buildContentOffsets(match, ruleInfo).contentStartOffset,\n        index: (rule.split ?? 'at') === 'at' ? match.index : match.index + match[0].length,\n        meta: rule.meta,\n        namedCaptures: Object.keys(namedCaptures).length > 0 ? namedCaptures : undefined,\n    };\n};\n\nexport const processCombinedMatches = (\n    matchContent: string,\n    combinableRules: CombinableRule[],\n    ruleRegexes: RuleRegexInfo[],\n    pageMap: PageMap,\n    passesPageStartGuard: (rule: SplitRule, index: number, pos: number) => boolean,\n    splitPointsByRule: Map<number, SplitPoint[]>,\n    logger?: Logger,\n) => {\n    const combinedSource = ruleRegexes.map((r) => r.source).join('|');\n    const combinedRegex = new RegExp(combinedSource, 'gm');\n\n    logger?.debug?.('[segmenter] combined regex built', {\n        combinableRuleCount: combinableRules.length,\n        combinedSourceLength: combinedSource.length,\n    });\n\n    let m = combinedRegex.exec(matchContent);\n    let iterations = 0;\n\n    while (m !== null) {\n        if (++iterations > MAX_REGEX_ITERATIONS) {\n            throw new Error(\n                `[segmenter] Possible infinite loop: exceeded ${MAX_REGEX_ITERATIONS} iterations at position ${m.index}.`,\n            );\n        }\n        if (iterations % 10000 === 0) {\n            logger?.warn?.('[segmenter] high iteration count', { iterations, position: m.index });\n        }\n\n        const matchedIndex = combinableRules.findIndex(({ prefix }) => m?.groups?.[prefix] !== undefined);\n        if (matchedIndex !== -1) {\n            const { rule, index: originalIndex } = combinableRules[matchedIndex];\n            if (\n                passesRuleConstraints(rule, pageMap.getId(m.index)) &&\n                passesPageStartGuard(rule, originalIndex, m.index)\n            ) {\n                const arr = splitPointsByRule.get(originalIndex);\n                if (!arr) {\n                    splitPointsByRule.set(originalIndex, [\n                        createSplitPointFromMatch(m, rule, ruleRegexes[matchedIndex]),\n                    ]);\n                } else {\n                    arr.push(createSplitPointFromMatch(m, rule, ruleRegexes[matchedIndex]));\n                }\n            }\n        }\n        if (m[0].length === 0) {\n            combinedRegex.lastIndex++;\n        }\n        m = combinedRegex.exec(matchContent);\n    }\n};\n\nexport const buildRuleRegexes = (combinableRules: CombinableRule[]) =>\n    combinableRules.map(({ rule, prefix }) => {\n        const built = buildRuleRegex(rule, prefix);\n        return { ...built, prefix, source: `(?<${prefix}>${built.regex.source})` };\n    });\n\nexport const processStandaloneRule = (\n    rule: SplitRule,\n    ruleIndex: number,\n    matchContent: string,\n    pageMap: PageMap,\n    passesPageStartGuard: (rule: SplitRule, index: number, pos: number) => boolean,\n    splitPointsByRule: Map<number, SplitPoint[]>,\n) => {\n    const { regex, usesCapture, captureNames, usesLineStartsAfter } = buildRuleRegex(rule);\n    const allMatches = findMatchesInContent(matchContent, regex, usesCapture, captureNames);\n    const constrained = filterByConstraints(allMatches, rule, pageMap.getId);\n    const points = constrained\n        .filter((m) => passesPageStartGuard(rule, ruleIndex, m.start))\n        .map((m) => {\n            const isLSA = usesLineStartsAfter && m.captured !== undefined;\n            return {\n                capturedContent: isLSA ? undefined : m.captured,\n                contentStartOffset: isLSA ? m.end - m.captured!.length - m.start : undefined,\n                index: (rule.split ?? 'at') === 'at' ? m.start : m.end,\n                meta: rule.meta,\n                namedCaptures: m.namedCaptures,\n            };\n        });\n\n    const arr = splitPointsByRule.get(ruleIndex);\n    if (!arr) {\n        splitPointsByRule.set(ruleIndex, points);\n    } else {\n        arr.push(...points);\n    }\n};\n\nconst findMatchesInContent = (content: string, regex: RegExp, usesCapture: boolean, captureNames: string[]) => {\n    const matches: MatchResult[] = [];\n    let m = regex.exec(content);\n\n    while (m !== null) {\n        matches.push({\n            captured: usesCapture ? getLastPositionalCapture(m) : undefined,\n            end: m.index + m[0].length,\n            namedCaptures: extractNamedCaptures(m.groups, captureNames),\n            start: m.index,\n        });\n        if (m[0].length === 0) {\n            regex.lastIndex++;\n        }\n        m = regex.exec(content);\n    }\n\n    return matches;\n};\n\n// Occurrence filtering\n\nexport const applyOccurrenceFilter = (\n    rules: SplitRule[],\n    splitPointsByRule: Map<number, SplitPoint[]>,\n    debugMetaKey?: string,\n) => {\n    const result: SplitPoint[] = [];\n\n    rules.forEach((rule, index) => {\n        const points = splitPointsByRule.get(index);\n        if (!points?.length) {\n            return;\n        }\n\n        const filtered =\n            rule.occurrence === 'first' ? [points[0]] : rule.occurrence === 'last' ? [points.at(-1)!] : points;\n        const debugPatch = debugMetaKey ? buildRuleDebugPatch(index, rule) : null;\n\n        result.push(\n            ...filtered.map((p) => ({\n                ...p,\n                meta: debugMetaKey ? mergeDebugIntoMeta(p.meta, debugMetaKey, debugPatch!) : p.meta,\n                ruleIndex: index,\n            })),\n        );\n    });\n    return result;\n};\n","import { applyReplacements } from '@/preprocessing/replace.js';\nimport type { Page, Segment } from '@/types';\nimport type { Logger, SegmentationOptions } from '@/types/options.js';\nimport type { SplitRule } from '@/types/rules.js';\nimport { normalizeLineEndings } from '@/utils/textUtils.js';\nimport type { PageBoundary, PageMap, SplitPoint } from '../types/segmenter.js';\nimport { applyBreakpoints } from './breakpoint-processor.js';\nimport { resolveDebugConfig } from './debug-meta.js';\nimport { anyRuleAllowsId } from './match-utils.js';\nimport { processBreakpointPattern, processPattern } from './rule-regex.js';\nimport {\n    collectFastFuzzySplitPoints,\n    createPageStartGuardChecker,\n    partitionRulesForMatching,\n} from './segmenter-rule-utils.js';\nimport {\n    applyOccurrenceFilter,\n    buildRuleRegexes,\n    processCombinedMatches,\n    processStandaloneRule,\n} from './split-point-helpers.js';\n\n/**\n * Builds a concatenated content string and page mapping from input pages.\n *\n * Pages are joined with newline characters, and a page map is created to\n * track which page each offset belongs to. This allows pattern matching\n * across page boundaries while preserving page reference information.\n *\n * @param pages - Array of input pages with id and content\n * @returns Concatenated content string and page mapping utilities\n *\n * @example\n * const pages = [\n *   { id: 1, content: 'Page 1 text' },\n *   { id: 2, content: 'Page 2 text' }\n * ];\n * const { content, pageMap } = buildPageMap(pages);\n * // content = 'Page 1 text\\nPage 2 text'\n * // pageMap.getId(0) = 1\n * // pageMap.getId(12) = 2\n */\nconst buildPageMap = (pages: Page[]) => {\n    const boundaries: PageBoundary[] = [];\n    const pageBreaks: number[] = [];\n    let offset = 0;\n    const parts: string[] = [];\n\n    for (let i = 0; i < pages.length; i++) {\n        const normalized = normalizeLineEndings(pages[i].content);\n        boundaries.push({ end: offset + normalized.length, id: pages[i].id, start: offset });\n        parts.push(normalized);\n        if (i < pages.length - 1) {\n            pageBreaks.push(offset + normalized.length);\n            offset += normalized.length + 1;\n        } else {\n            offset += normalized.length;\n        }\n    }\n\n    const findBoundary = (off: number) => {\n        let lo = 0,\n            hi = boundaries.length - 1;\n        while (lo <= hi) {\n            const mid = (lo + hi) >>> 1;\n            const b = boundaries[mid];\n            if (off < b.start) {\n                hi = mid - 1;\n            } else if (off > b.end) {\n                lo = mid + 1;\n            } else {\n                return b;\n            }\n        }\n        return boundaries.at(-1);\n    };\n\n    return {\n        content: parts.join('\\n'),\n        normalizedPages: parts,\n        pageMap: {\n            boundaries,\n            getId: (off: number) => findBoundary(off)?.id ?? 0,\n            pageBreaks,\n            pageIds: boundaries.map((b) => b.id),\n        },\n    };\n};\n\n/**\n * Deduplicate split points by index, preferring ones with more information.\n *\n * Preference rules (when same index):\n * - Prefer a split with `contentStartOffset` (needed for `lineStartsAfter` marker stripping)\n * - Otherwise prefer a split with `meta` over one without\n */\nexport const dedupeSplitPoints = (splitPoints: SplitPoint[]) => {\n    const byIndex = new Map<number, SplitPoint>();\n    for (const p of splitPoints) {\n        const existing = byIndex.get(p.index);\n        const hasMoreInfo =\n            !existing ||\n            (p.contentStartOffset !== undefined && existing.contentStartOffset === undefined) ||\n            (p.meta !== undefined && existing.meta === undefined);\n        if (hasMoreInfo) {\n            byIndex.set(p.index, p);\n        }\n    }\n    return [...byIndex.values()].sort((a, b) => a.index - b.index);\n};\n\n/**\n * If no structural rules produced segments, create a single segment spanning all pages.\n * This allows breakpoint processing to still run.\n */\nexport const ensureFallbackSegment = (\n    segments: Segment[],\n    pages: Page[],\n    normalizedContent: string[],\n    pageJoiner: 'space' | 'newline',\n) => {\n    if (segments.length > 0 || pages.length === 0) {\n        return segments;\n    }\n\n    const firstPage = pages[0];\n    const lastPage = pages.at(-1)!;\n    const joiner = pageJoiner === 'newline' ? '\\n' : ' ';\n    const joined = normalizedContent.join(joiner);\n    // Important: do NOT trimStart here.\n    // Trimming the leading content can desync cumulative offsets/boundary positions in breakpoint processing\n    // for very large fallback segments, causing incorrect page attribution and maxPages violations.\n    const allContent = joined.replace(/\\s+$/u, '');\n    if (!allContent.trim()) {\n        return segments;\n    }\n\n    const initialSeg: Segment = { content: allContent, from: firstPage.id };\n    if (lastPage.id !== firstPage.id) {\n        initialSeg.to = lastPage.id;\n    }\n    return [initialSeg];\n};\n\nconst collectSplitPointsFromRules = (\n    rules: SplitRule[],\n    matchContent: string,\n    pageMap: PageMap,\n    debugMetaKey: string | undefined,\n    logger?: Logger,\n) => {\n    logger?.debug?.('[segmenter] collecting split points from rules', {\n        contentLength: matchContent.length,\n        ruleCount: rules.length,\n    });\n\n    const passesPageStartGuard = createPageStartGuardChecker(matchContent, pageMap);\n    const { combinableRules, fastFuzzyRules, standaloneRules } = partitionRulesForMatching(rules);\n\n    logger?.debug?.('[segmenter] rules partitioned', {\n        combinableCount: combinableRules.length,\n        fastFuzzyCount: fastFuzzyRules.length,\n        standaloneCount: standaloneRules.length,\n    });\n\n    const splitPointsByRule = collectFastFuzzySplitPoints(matchContent, pageMap, fastFuzzyRules, passesPageStartGuard);\n\n    if (combinableRules.length > 0) {\n        processCombinedMatches(\n            matchContent,\n            combinableRules,\n            buildRuleRegexes(combinableRules),\n            pageMap,\n            passesPageStartGuard,\n            splitPointsByRule,\n            logger,\n        );\n    }\n\n    for (const rule of standaloneRules) {\n        processStandaloneRule(\n            rule,\n            rules.indexOf(rule),\n            matchContent,\n            pageMap,\n            passesPageStartGuard,\n            splitPointsByRule,\n        );\n    }\n\n    return applyOccurrenceFilter(rules, splitPointsByRule, debugMetaKey);\n};\n\n/**\n * Finds page breaks within a given offset range using binary search.\n * O(log n + k) where n = total breaks, k = breaks in range.\n *\n * @param startOffset - Start of range (inclusive)\n * @param endOffset - End of range (exclusive)\n * @param sortedBreaks - Sorted array of page break offsets\n * @returns Array of break offsets relative to startOffset\n */\nconst findBreaksInRange = (startOffset: number, endOffset: number, sortedBreaks: number[]) => {\n    if (sortedBreaks.length === 0) {\n        return [];\n    }\n\n    let lo = 0,\n        hi = sortedBreaks.length;\n    while (lo < hi) {\n        const mid = (lo + hi) >>> 1;\n        if (sortedBreaks[mid] < startOffset) {\n            lo = mid + 1;\n        } else {\n            hi = mid;\n        }\n    }\n\n    const result: number[] = [];\n    for (let i = lo; i < sortedBreaks.length && sortedBreaks[i] < endOffset; i++) {\n        result.push(sortedBreaks[i] - startOffset);\n    }\n    return result;\n};\n\n/**\n * Converts page-break newlines to spaces in segment content.\n *\n * When a segment spans multiple pages, the newline characters that were\n * inserted as page separators during concatenation are converted to spaces\n * for more natural reading.\n *\n * Uses binary search for O(log n + k) lookup instead of O(n) iteration.\n *\n * @param content - Segment content string\n * @param startOffset - Starting offset of this content in concatenated string\n * @param pageBreaks - Sorted array of page break offsets\n * @param pageJoiner - How to represent page boundaries in output (`space` vs `newline`)\n * @returns Content with page-break newlines converted to spaces (or left as-is for `newline`)\n */\nconst convertPageBreaks = (\n    content: string,\n    startOffset: number,\n    pageBreaks: number[],\n    pageJoiner: 'space' | 'newline',\n) => {\n    if (!content || !content.includes('\\n')) {\n        return content;\n    }\n\n    // If the caller wants newlines preserved between pages, no conversion is needed.\n    if (pageJoiner === 'newline') {\n        return content;\n    }\n\n    const breaksInRange = findBreaksInRange(startOffset, startOffset + content.length, pageBreaks);\n    if (breaksInRange.length === 0) {\n        return content;\n    }\n\n    const breakSet = new Set(breaksInRange);\n    return content.replace(/\\n/g, (match, offset: number) => (breakSet.has(offset) ? ' ' : match));\n};\n\n/**\n * Segments pages of content based on pattern-matching rules.\n *\n * This is the main entry point for the segmentation engine. It takes an array\n * of pages and applies the provided rules to identify split points, producing\n * an array of segments with content, page references, and metadata.\n *\n * @param pages - Array of pages with id and content\n * @param options - Segmentation options including splitting rules\n * @returns Array of segments with content, from/to page references, and optional metadata\n *\n * @example\n * // Split markdown by headers\n * const segments = segmentPages(pages, {\n *   rules: [\n *     { lineStartsWith: ['## '], split: 'at', meta: { type: 'chapter' } }\n *   ]\n * });\n *\n * @example\n * // Split Arabic hadith text with number extraction\n * const segments = segmentPages(pages, {\n *   rules: [\n *     {\n *       lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '],\n *       split: 'at',\n *       fuzzy: true,\n *       meta: { type: 'hadith' }\n *     }\n *   ]\n * });\n *\n * @example\n * // Multiple rules with page constraints\n * const segments = segmentPages(pages, {\n *   rules: [\n *     { lineStartsWith: ['{{kitab}}'], split: 'at', meta: { type: 'book' } },\n *     { lineStartsWith: ['{{bab}}'], split: 'at', min: 10, meta: { type: 'chapter' } },\n *     { regex: '^[٠-٩]+ - ', split: 'at', meta: { type: 'hadith' } }\n *   ]\n * });\n */\nexport const segmentPages = (pages: Page[], options: SegmentationOptions) => {\n    const { rules = [], breakpoints = [], prefer = 'longer', pageJoiner = 'space', logger, maxContentLength } = options;\n\n    if (maxContentLength && maxContentLength < 50) {\n        throw new Error(`maxContentLength must be at least 50 characters.`);\n    }\n\n    const maxPages = options.maxPages ?? Number.MAX_SAFE_INTEGER;\n    const hasLimits = options.maxPages !== undefined || maxContentLength !== undefined;\n    const debug = resolveDebugConfig((options as any).debug);\n    const debugMetaKey = debug?.includeRule ? debug.metaKey : undefined;\n\n    logger?.info?.('[segmenter] starting segmentation', {\n        breakpointCount: breakpoints.length,\n        maxContentLength,\n        maxPages,\n        pageCount: pages.length,\n        prefer,\n        ruleCount: rules.length,\n    });\n\n    const processedPages = options.replace ? applyReplacements(pages, options.replace) : pages;\n    const { content: matchContent, normalizedPages: normalizedContent, pageMap } = buildPageMap(processedPages);\n\n    logger?.debug?.('[segmenter] content built', { pageIds: pageMap.pageIds, totalContentLength: matchContent.length });\n\n    const splitPoints = collectSplitPointsFromRules(rules, matchContent, pageMap, debugMetaKey, logger);\n    const unique = dedupeSplitPoints(splitPoints);\n\n    logger?.debug?.('[segmenter] split points collected', {\n        rawSplitPoints: splitPoints.length,\n        uniqueSplitPoints: unique.length,\n    });\n\n    let segments = buildSegments(unique, matchContent, pageMap, rules, pageJoiner);\n    logger?.debug?.('[segmenter] structural segments built', { segmentCount: segments.length });\n\n    segments = ensureFallbackSegment(segments, processedPages, normalizedContent, pageJoiner);\n\n    if (hasLimits) {\n        logger?.debug?.('[segmenter] applying breakpoints to oversized segments');\n        const result = applyBreakpoints(\n            segments,\n            processedPages,\n            normalizedContent,\n            maxPages,\n            breakpoints,\n            prefer,\n            (p: string) => processPattern(p, false).pattern,\n            logger,\n            pageJoiner,\n            debug?.includeBreakpoint ? debug.metaKey : undefined,\n            maxContentLength,\n            processBreakpointPattern,\n        );\n        logger?.info?.('[segmenter] segmentation complete (with breakpoints)', { finalSegmentCount: result.length });\n        return result;\n    }\n    logger?.info?.('[segmenter] segmentation complete (structural only)', { finalSegmentCount: segments.length });\n    return segments;\n};\n\n/**\n * Creates segment objects from split points.\n *\n * Handles segment creation including:\n * - Content extraction (with captured content for `lineStartsAfter`)\n * - Page break conversion to spaces\n * - From/to page reference calculation\n * - Metadata merging (static + named captures)\n *\n * @param splitPoints - Sorted, unique split points\n * @param content - Full concatenated content string\n * @param pageMap - Page mapping utilities\n * @param rules - Original rules (for constraint checking on first segment)\n * @returns Array of segment objects\n */\nconst buildSegments = (\n    splitPoints: SplitPoint[],\n    content: string,\n    pageMap: PageMap,\n    rules: SplitRule[],\n    pageJoiner: 'space' | 'newline',\n) => {\n    /**\n     * Creates a single segment from a content range.\n     */\n    const createSegment = (\n        start: number,\n        end: number,\n        meta?: Record<string, unknown>,\n        capturedContent?: string,\n        namedCaptures?: Record<string, string>,\n        contentStartOffset?: number,\n    ) => {\n        const actualStart = start + (contentStartOffset ?? 0);\n        const sliced = content.slice(actualStart, end);\n        let text = capturedContent?.trim() ?? (contentStartOffset ? sliced.trim() : sliced.replace(/[\\s\\n]+$/, ''));\n        if (!text) {\n            return null;\n        }\n\n        if (!capturedContent) {\n            text = convertPageBreaks(text, actualStart, pageMap.pageBreaks, pageJoiner);\n        }\n        const from = pageMap.getId(actualStart);\n        const to = capturedContent ? pageMap.getId(end - 1) : pageMap.getId(actualStart + text.length - 1);\n        const seg: Segment = { content: text, from };\n        if (to !== from) {\n            seg.to = to;\n        }\n        if (meta || namedCaptures) {\n            seg.meta = { ...meta, ...namedCaptures };\n        }\n        return seg;\n    };\n\n    /**\n     * Creates segments from an array of split points.\n     */\n    const createSegmentsFromSplitPoints = () => {\n        const result: Segment[] = [];\n        for (let i = 0; i < splitPoints.length; i++) {\n            const sp = splitPoints[i];\n            const end = splitPoints[i + 1]?.index ?? content.length;\n            const s = createSegment(\n                sp.index,\n                end,\n                sp.meta,\n                sp.capturedContent,\n                sp.namedCaptures,\n                sp.contentStartOffset,\n            );\n            if (s) {\n                result.push(s);\n            }\n        }\n        return result;\n    };\n\n    const segments: Segment[] = [];\n\n    // Handle case with no split points\n    if (!splitPoints.length) {\n        const firstId = pageMap.getId(0);\n        if (anyRuleAllowsId(rules, firstId)) {\n            const s = createSegment(0, content.length);\n            if (s) {\n                segments.push(s);\n            }\n        }\n        return segments;\n    }\n\n    // Add first segment if there's content before first split\n    if (splitPoints[0].index > 0) {\n        const firstId = pageMap.getId(0);\n        if (anyRuleAllowsId(rules, firstId)) {\n            const s = createSegment(0, splitPoints[0].index);\n            if (s) {\n                segments.push(s);\n            }\n        }\n    }\n\n    // Create segments from split points using extracted utility\n    return [...segments, ...createSegmentsFromSplitPoints()];\n};\n","import type { Page, Segment } from '@/types/index.js';\nimport type { SegmentationOptions } from '@/types/options.js';\nimport type { SplitRule } from '@/types/rules.js';\nimport { applyReplacements } from './preprocessing/replace.js';\nimport { buildRuleRegex } from './segmentation/rule-regex.js';\nimport { segmentPages } from './segmentation/segmenter.js';\nimport { normalizeLineEndings } from './utils/textUtils.js';\n\nexport type MarkerRecoverySelector =\n    | { type: 'rule_indices'; indices: number[] }\n    | { type: 'lineStartsAfter_patterns'; match?: 'exact' | 'normalized'; patterns: string[] }\n    | { type: 'predicate'; predicate: (rule: SplitRule, index: number) => boolean };\n\nexport type MarkerRecoveryRun = {\n    options: SegmentationOptions;\n    pages: Page[];\n    segments: Segment[];\n    selector: MarkerRecoverySelector;\n};\n\nexport type MarkerRecoveryReport = {\n    summary: {\n        mode: 'rerun_only' | 'best_effort_then_rerun';\n        recovered: number;\n        totalSegments: number;\n        unchanged: number;\n        unresolved: number;\n    };\n    byRun?: Array<{\n        recovered: number;\n        runIndex: number;\n        totalSegments: number;\n        unresolved: number;\n    }>;\n    details: Array<{\n        from: number;\n        originalStartPreview: string;\n        recoveredPrefixPreview?: string;\n        recoveredStartPreview?: string;\n        segmentIndex: number;\n        status: 'recovered' | 'skipped_idempotent' | 'unchanged' | 'unresolved_alignment' | 'unresolved_selector';\n        strategy: 'rerun' | 'stage1' | 'none';\n        to?: number;\n        notes?: string[];\n    }>;\n    errors: string[];\n    warnings: string[];\n};\n\ntype NormalizeCompareMode = 'none' | 'whitespace' | 'whitespace_and_nfkc';\n\nconst preview = (s: string, max = 40): string => (s.length <= max ? s : `${s.slice(0, max)}…`);\n\nconst normalizeForCompare = (s: string, mode: NormalizeCompareMode): string => {\n    if (mode === 'none') {\n        return s;\n    }\n    let out = s;\n    if (mode === 'whitespace_and_nfkc') {\n        // Use alternation (not a character class) to satisfy Biome's noMisleadingCharacterClass rule.\n        out = out.normalize('NFKC').replace(/(?:\\u200C|\\u200D|\\uFEFF)/gu, '');\n    }\n    // Collapse whitespace and normalize line endings\n    out = out.replace(/\\r\\n?/gu, '\\n').replace(/\\s+/gu, ' ').trim();\n    return out;\n};\n\nconst segmentRangeKey = (s: Pick<Segment, 'from' | 'to'>): string => `${s.from}|${s.to ?? s.from}`;\n\nconst buildFixedOptions = (options: SegmentationOptions, selectedRuleIndices: Set<number>): SegmentationOptions => {\n    const rules = options.rules ?? [];\n    const fixedRules: SplitRule[] = rules.map((r, idx) => {\n        if (!selectedRuleIndices.has(idx)) {\n            return r;\n        }\n        if (!('lineStartsAfter' in r) || !r.lineStartsAfter) {\n            return r;\n        }\n\n        // Convert: lineStartsAfter -> lineStartsWith, keep all other fields.\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        const { lineStartsAfter, ...rest } = r as SplitRule & { lineStartsAfter: string[] };\n        return { ...(rest as Omit<SplitRule, 'lineStartsAfter'>), lineStartsWith: lineStartsAfter };\n    });\n\n    return { ...options, rules: fixedRules };\n};\n\nconst buildPageIdToIndex = (pages: Page[]): Map<number, number> => new Map(pages.map((p, i) => [p.id, i]));\n\ntype RangeContent = {\n    matchContent: string;\n    outputContent: string;\n};\n\nconst buildRangeContent = (\n    processedPages: Page[],\n    fromIdx: number,\n    toIdx: number,\n    pageJoiner: 'space' | 'newline',\n): RangeContent => {\n    const parts: string[] = [];\n    for (let i = fromIdx; i <= toIdx; i++) {\n        parts.push(normalizeLineEndings(processedPages[i].content));\n    }\n    const matchContent = parts.join('\\n');\n    if (pageJoiner === 'newline') {\n        return { matchContent, outputContent: matchContent };\n    }\n    // Only convert the inserted page-boundary separators (exactly those join '\\n's) to spaces.\n    // In-page newlines remain as-is.\n    // Since we built matchContent by joining pages with '\\n', the separators are exactly between each part.\n    // Replacing all '\\n' would corrupt in-page newlines, so we rebuild outputContent explicitly.\n    const outputContent = parts.join(' ');\n    return { matchContent, outputContent };\n};\n\ntype CompiledMistakenRule = {\n    ruleIndex: number;\n    // A regex that matches the marker at a line start (equivalent to lineStartsWith).\n    startsWithRegex: RegExp;\n};\n\nconst compileMistakenRulesAsStartsWith = (\n    options: SegmentationOptions,\n    selectedRuleIndices: Set<number>,\n): CompiledMistakenRule[] => {\n    const rules = options.rules ?? [];\n    const compiled: CompiledMistakenRule[] = [];\n\n    for (const idx of selectedRuleIndices) {\n        const r = rules[idx];\n        if (!r || !('lineStartsAfter' in r) || !r.lineStartsAfter?.length) {\n            continue;\n        }\n        // Convert cleanly without using `delete` (keeps TS happy with discriminated unions).\n        const { lineStartsAfter, ...rest } = r as SplitRule & { lineStartsAfter: string[] };\n        const converted: SplitRule = {\n            ...(rest as Omit<SplitRule, 'lineStartsAfter'>),\n            lineStartsWith: lineStartsAfter,\n        };\n\n        const built = buildRuleRegex(converted);\n        // built.regex has flags gmu; we want a stable, non-global matcher.\n        compiled.push({ ruleIndex: idx, startsWithRegex: new RegExp(built.regex.source, 'mu') });\n    }\n\n    return compiled;\n};\n\ntype Stage1Result =\n    | { kind: 'recovered'; recoveredContent: string; recoveredPrefix: string }\n    | { kind: 'skipped_idempotent' }\n    | { kind: 'unresolved'; reason: string };\n\nconst findUniqueAnchorPos = (outputContent: string, segmentContent: string): number | null => {\n    const prefixLens = [80, 60, 40, 30, 20, 15] as const;\n\n    for (const len of prefixLens) {\n        const needle = segmentContent.slice(0, Math.min(len, segmentContent.length));\n        if (!needle.trim()) {\n            continue;\n        }\n\n        const first = outputContent.indexOf(needle);\n        if (first === -1) {\n            continue;\n        }\n        const second = outputContent.indexOf(needle, first + 1);\n        if (second === -1) {\n            return first;\n        }\n    }\n\n    return null;\n};\n\nconst findRecoveredPrefixAtLineStart = (\n    segmentContent: string,\n    matchContent: string,\n    lineStart: number,\n    anchorPos: number,\n    compiledMistaken: CompiledMistakenRule[],\n): { prefix: string } | { reason: string } => {\n    const line = matchContent.slice(lineStart);\n\n    for (const mr of compiledMistaken) {\n        mr.startsWithRegex.lastIndex = 0;\n        const m = mr.startsWithRegex.exec(line);\n        if (!m || m.index !== 0) {\n            continue;\n        }\n\n        const markerMatch = m[0];\n        const markerEnd = lineStart + markerMatch.length;\n        if (anchorPos < markerEnd) {\n            continue; // anchor is inside marker; unsafe\n        }\n\n        // If there is whitespace between the marker match and the anchored content (common when lineStartsAfter trims),\n        // include it in the recovered prefix.\n        const gap = matchContent.slice(markerEnd, anchorPos);\n        const recoveredPrefix = /^\\s*$/u.test(gap) ? `${markerMatch}${gap}` : markerMatch;\n\n        // Idempotency: if content already starts with the marker/prefix, don’t prepend.\n        if (segmentContent.startsWith(markerMatch) || segmentContent.startsWith(recoveredPrefix)) {\n            return { reason: 'content already starts with selected marker' };\n        }\n\n        return { prefix: recoveredPrefix };\n    }\n\n    return { reason: 'no selected marker pattern matched at anchored line start' };\n};\n\nconst tryBestEffortRecoverOneSegment = (\n    segment: Segment,\n    processedPages: Page[],\n    pageIdToIndex: Map<number, number>,\n    compiledMistaken: CompiledMistakenRule[],\n    pageJoiner: 'space' | 'newline',\n): Stage1Result => {\n    const fromIdx = pageIdToIndex.get(segment.from);\n    const toIdx = pageIdToIndex.get(segment.to ?? segment.from) ?? fromIdx;\n    if (fromIdx === undefined || toIdx === undefined || fromIdx < 0 || toIdx < fromIdx) {\n        return { kind: 'unresolved', reason: 'segment page range not found in pages' };\n    }\n\n    const { matchContent, outputContent } = buildRangeContent(processedPages, fromIdx, toIdx, pageJoiner);\n    if (!segment.content) {\n        return { kind: 'unresolved', reason: 'empty segment content' };\n    }\n\n    const anchorPos = findUniqueAnchorPos(outputContent, segment.content);\n    if (anchorPos === null) {\n        return { kind: 'unresolved', reason: 'could not uniquely anchor segment content in page range' };\n    }\n\n    // Find line start in matchContent. (Positions align because outputContent differs only by page-boundary joiner.)\n    const lineStart = matchContent.lastIndexOf('\\n', Math.max(0, anchorPos - 1)) + 1;\n    const found = findRecoveredPrefixAtLineStart(segment.content, matchContent, lineStart, anchorPos, compiledMistaken);\n    if ('reason' in found) {\n        return found.reason.includes('already starts')\n            ? { kind: 'skipped_idempotent' }\n            : { kind: 'unresolved', reason: found.reason };\n    }\n    return { kind: 'recovered', recoveredContent: `${found.prefix}${segment.content}`, recoveredPrefix: found.prefix };\n};\n\nconst resolveRuleIndicesSelector = (rules: SplitRule[], indicesIn: number[]) => {\n    const errors: string[] = [];\n    const indices = new Set<number>();\n    for (const idx of indicesIn) {\n        if (!Number.isInteger(idx) || idx < 0 || idx >= rules.length) {\n            errors.push(`Selector index out of range: ${idx}`);\n            continue;\n        }\n        const rule = rules[idx];\n        if (!rule || !('lineStartsAfter' in rule)) {\n            errors.push(`Selector index ${idx} is not a lineStartsAfter rule`);\n            continue;\n        }\n        indices.add(idx);\n    }\n    return { errors, indices, warnings: [] as string[] };\n};\n\nconst resolvePredicateSelector = (rules: SplitRule[], predicate: (rule: SplitRule, index: number) => boolean) => {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n    const indices = new Set<number>();\n\n    rules.forEach((r, i) => {\n        try {\n            if (!predicate(r, i)) {\n                return;\n            }\n            if ('lineStartsAfter' in r && r.lineStartsAfter?.length) {\n                indices.add(i);\n                return;\n            }\n            warnings.push(`Predicate selected rule ${i}, but it is not a lineStartsAfter rule; skipping`);\n        } catch (e) {\n            const msg = e instanceof Error ? e.message : String(e);\n            errors.push(`Predicate threw at rule ${i}: ${msg}`);\n        }\n    });\n\n    if (indices.size === 0) {\n        warnings.push('Predicate did not select any lineStartsAfter rules');\n    }\n\n    return { errors, indices, warnings };\n};\n\nconst resolvePatternsSelector = (\n    rules: SplitRule[],\n    patterns: string[],\n    matchMode: 'exact' | 'normalized' | undefined,\n): { errors: string[]; indices: Set<number>; warnings: string[] } => {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n    const indices = new Set<number>();\n\n    const normalizePattern = (p: string) =>\n        normalizeForCompare(p, (matchMode ?? 'exact') === 'normalized' ? 'whitespace_and_nfkc' : 'none');\n    const targets = patterns.map(normalizePattern);\n\n    for (let pi = 0; pi < patterns.length; pi++) {\n        const rawPattern = patterns[pi];\n        const pat = targets[pi];\n        const matched: number[] = [];\n\n        for (let i = 0; i < rules.length; i++) {\n            const r = rules[i];\n            if (!('lineStartsAfter' in r) || !r.lineStartsAfter?.length) {\n                continue;\n            }\n            if (r.lineStartsAfter.some((rp) => normalizePattern(rp) === pat)) {\n                matched.push(i);\n            }\n        }\n\n        if (matched.length === 0) {\n            errors.push(`Pattern \"${rawPattern}\" did not match any lineStartsAfter rule`);\n            continue;\n        }\n        if (matched.length > 1) {\n            warnings.push(`Pattern \"${rawPattern}\" matched multiple lineStartsAfter rules: [${matched.join(', ')}]`);\n        }\n        matched.forEach((i) => {\n            indices.add(i);\n        });\n    }\n\n    return { errors, indices, warnings };\n};\n\nconst resolveSelectorToRuleIndices = (options: SegmentationOptions, selector: MarkerRecoverySelector) => {\n    const rules = options.rules ?? [];\n    if (selector.type === 'rule_indices') {\n        return resolveRuleIndicesSelector(rules, selector.indices);\n    }\n    if (selector.type === 'predicate') {\n        return resolvePredicateSelector(rules, selector.predicate);\n    }\n    return resolvePatternsSelector(rules, selector.patterns, selector.match);\n};\n\ntype AlignmentCandidate = { fixedIndex: number; kind: 'exact' | 'exact_suffix' | 'normalized_suffix'; score: number };\n\nconst longestCommonSuffixLength = (a: string, b: string): number => {\n    const max = Math.min(a.length, b.length);\n    let i = 0;\n    while (i < max) {\n        if (a[a.length - 1 - i] !== b[b.length - 1 - i]) {\n            break;\n        }\n        i++;\n    }\n    return i;\n};\n\n// Minimum score difference required to confidently disambiguate between candidates.\n// If the gap between best and second-best is smaller, we consider the match ambiguous.\nconst AMBIGUITY_SCORE_GAP = 5;\n\nconst scoreCandidate = (\n    orig: Segment,\n    fixed: Segment,\n    normalizeMode: NormalizeCompareMode,\n): AlignmentCandidate | null => {\n    // Scoring hierarchy:\n    //   exact (100)           - Content is identical, no recovery needed\n    //   exact_suffix (90-120) - Fixed ends with original; fixed = marker + orig (most reliable)\n    //   normalized_suffix (70-90) - Suffix match after whitespace/NFKC normalization\n    // Higher scores indicate more confident alignment.\n\n    if (fixed.content === orig.content) {\n        return { fixedIndex: -1, kind: 'exact', score: 100 };\n    }\n\n    if (fixed.content.endsWith(orig.content)) {\n        // Most reliable case: fixed = marker + orig.\n        // Bonus points for longer markers (up to 30) to prefer substantive recovery.\n        const markerLen = fixed.content.length - orig.content.length;\n        const bonus = Math.min(30, markerLen);\n        return { fixedIndex: -1, kind: 'exact_suffix', score: 90 + bonus };\n    }\n\n    if (normalizeMode !== 'none') {\n        const normFixed = normalizeForCompare(fixed.content, normalizeMode);\n        const normOrig = normalizeForCompare(orig.content, normalizeMode);\n        if (normFixed.endsWith(normOrig) && normOrig.length > 0) {\n            // Base score 70, plus up to 20 bonus based on overlap ratio\n            const overlap = longestCommonSuffixLength(normFixed, normOrig) / normOrig.length;\n            return { fixedIndex: -1, kind: 'normalized_suffix', score: 70 + Math.floor(overlap * 20) };\n        }\n    }\n\n    return null;\n};\n\nconst buildNoSelectionResult = (\n    segments: Segment[],\n    reportBase: Omit<MarkerRecoveryReport, 'details' | 'summary'>,\n    mode: MarkerRecoveryReport['summary']['mode'],\n    selectorErrors: string[],\n): { report: MarkerRecoveryReport; segments: Segment[] } => {\n    const warnings = [...reportBase.warnings];\n    warnings.push('No lineStartsAfter rules selected for recovery; returning segments unchanged');\n\n    const details: MarkerRecoveryReport['details'] = segments.map((s, i) => {\n        const status: MarkerRecoveryReport['details'][number]['status'] = selectorErrors.length\n            ? 'unresolved_selector'\n            : 'unchanged';\n        return {\n            from: s.from,\n            notes: selectorErrors.length ? (['selector did not resolve'] as string[]) : undefined,\n            originalStartPreview: preview(s.content),\n            segmentIndex: i,\n            status,\n            strategy: 'none',\n            to: s.to,\n        };\n    });\n\n    return {\n        report: {\n            ...reportBase,\n            details,\n            summary: {\n                mode,\n                recovered: 0,\n                totalSegments: segments.length,\n                unchanged: segments.length,\n                unresolved: selectorErrors.length ? segments.length : 0,\n            },\n            warnings,\n        },\n        segments,\n    };\n};\n\nconst runStage1IfEnabled = (\n    pages: Page[],\n    segments: Segment[],\n    options: SegmentationOptions,\n    selectedRuleIndices: Set<number>,\n    mode: MarkerRecoveryReport['summary']['mode'],\n): {\n    recoveredAtIndex: Map<number, Segment>;\n    recoveredDetailAtIndex: Map<number, MarkerRecoveryReport['details'][number]>;\n} => {\n    const recoveredAtIndex = new Map<number, Segment>();\n    const recoveredDetailAtIndex = new Map<number, MarkerRecoveryReport['details'][number]>();\n\n    if (mode !== 'best_effort_then_rerun') {\n        return { recoveredAtIndex, recoveredDetailAtIndex };\n    }\n\n    const processedPages = options.replace ? applyReplacements(pages, options.replace) : pages;\n    const pageIdToIndex = buildPageIdToIndex(processedPages);\n    const pageJoiner = options.pageJoiner ?? 'space';\n    const compiledMistaken = compileMistakenRulesAsStartsWith(options, selectedRuleIndices);\n\n    for (let i = 0; i < segments.length; i++) {\n        const orig = segments[i];\n        const r = tryBestEffortRecoverOneSegment(orig, processedPages, pageIdToIndex, compiledMistaken, pageJoiner);\n        if (r.kind !== 'recovered') {\n            continue;\n        }\n\n        const seg: Segment = { ...orig, content: r.recoveredContent };\n        recoveredAtIndex.set(i, seg);\n        recoveredDetailAtIndex.set(i, {\n            from: orig.from,\n            originalStartPreview: preview(orig.content),\n            recoveredPrefixPreview: preview(r.recoveredPrefix),\n            recoveredStartPreview: preview(seg.content),\n            segmentIndex: i,\n            status: 'recovered',\n            strategy: 'stage1',\n            to: orig.to,\n        });\n    }\n\n    return { recoveredAtIndex, recoveredDetailAtIndex };\n};\n\nconst buildFixedBuckets = (fixedSegments: Segment[]): Map<string, number[]> => {\n    const buckets = new Map<string, number[]>();\n    for (let i = 0; i < fixedSegments.length; i++) {\n        const k = segmentRangeKey(fixedSegments[i]);\n        const arr = buckets.get(k);\n        if (!arr) {\n            buckets.set(k, [i]);\n        } else {\n            arr.push(i);\n        }\n    }\n    return buckets;\n};\n\ntype BestFixedMatch = { kind: 'none' } | { kind: 'ambiguous' } | { kind: 'match'; fixedIdx: number };\n\nconst findBestFixedMatch = (\n    orig: Segment,\n    candidates: number[],\n    fixedSegments: Segment[],\n    usedFixed: Set<number>,\n    normalizeCompare: NormalizeCompareMode,\n): BestFixedMatch => {\n    let best: { fixedIdx: number; score: number } | null = null;\n    let secondBestScore = -Infinity;\n\n    for (const fixedIdx of candidates) {\n        if (usedFixed.has(fixedIdx)) {\n            continue;\n        }\n        const fixed = fixedSegments[fixedIdx];\n        const scored = scoreCandidate(orig, fixed, normalizeCompare);\n        if (!scored) {\n            continue;\n        }\n        const candidateScore = scored.score;\n        if (!best || candidateScore > best.score) {\n            secondBestScore = best?.score ?? -Infinity;\n            best = { fixedIdx, score: candidateScore };\n        } else if (candidateScore > secondBestScore) {\n            secondBestScore = candidateScore;\n        }\n    }\n\n    if (!best) {\n        return { kind: 'none' };\n    }\n    if (best.score - secondBestScore < AMBIGUITY_SCORE_GAP && candidates.length > 1) {\n        return { kind: 'ambiguous' };\n    }\n    return { fixedIdx: best.fixedIdx, kind: 'match' };\n};\n\nconst detailUnresolved = (\n    orig: Segment,\n    segmentIndex: number,\n    notes: string[],\n): MarkerRecoveryReport['details'][number] => ({\n    from: orig.from,\n    notes,\n    originalStartPreview: preview(orig.content),\n    segmentIndex,\n    status: 'unresolved_alignment',\n    strategy: 'rerun',\n    to: orig.to,\n});\n\nconst detailSkippedIdempotent = (\n    orig: Segment,\n    segmentIndex: number,\n    notes: string[],\n): MarkerRecoveryReport['details'][number] => ({\n    from: orig.from,\n    notes,\n    originalStartPreview: preview(orig.content),\n    segmentIndex,\n    status: 'skipped_idempotent',\n    strategy: 'rerun',\n    to: orig.to,\n});\n\nconst detailRecoveredRerun = (\n    orig: Segment,\n    fixed: Segment,\n    segmentIndex: number,\n): MarkerRecoveryReport['details'][number] => {\n    let recoveredPrefixPreview: string | undefined;\n    if (fixed.content.endsWith(orig.content)) {\n        recoveredPrefixPreview = preview(fixed.content.slice(0, fixed.content.length - orig.content.length));\n    }\n    return {\n        from: orig.from,\n        originalStartPreview: preview(orig.content),\n        recoveredPrefixPreview,\n        recoveredStartPreview: preview(fixed.content),\n        segmentIndex,\n        status: 'recovered',\n        strategy: 'rerun',\n        to: orig.to,\n    };\n};\n\nconst mergeWithRerun = (params: {\n    fixedBuckets: Map<string, number[]>;\n    fixedSegments: Segment[];\n    normalizeCompare: NormalizeCompareMode;\n    originalSegments: Segment[];\n    recoveredDetailAtIndex: Map<number, MarkerRecoveryReport['details'][number]>;\n    stage1RecoveredAtIndex: Map<number, Segment>;\n}): {\n    details: MarkerRecoveryReport['details'];\n    segments: Segment[];\n    summary: Omit<MarkerRecoveryReport['summary'], 'mode' | 'totalSegments'>;\n} => {\n    const {\n        fixedBuckets,\n        fixedSegments,\n        normalizeCompare,\n        originalSegments,\n        stage1RecoveredAtIndex,\n        recoveredDetailAtIndex,\n    } = params;\n\n    const usedFixed = new Set<number>();\n    const out: Segment[] = [];\n    const details: MarkerRecoveryReport['details'] = [];\n    let recovered = 0;\n    let unresolved = 0;\n    let unchanged = 0;\n\n    for (let i = 0; i < originalSegments.length; i++) {\n        const stage1Recovered = stage1RecoveredAtIndex.get(i);\n        if (stage1Recovered) {\n            out.push(stage1Recovered);\n            recovered++;\n            details.push(\n                recoveredDetailAtIndex.get(i) ?? {\n                    from: stage1Recovered.from,\n                    originalStartPreview: preview(originalSegments[i].content),\n                    recoveredStartPreview: preview(stage1Recovered.content),\n                    segmentIndex: i,\n                    status: 'recovered',\n                    strategy: 'stage1',\n                    to: stage1Recovered.to,\n                },\n            );\n            continue;\n        }\n\n        const orig = originalSegments[i];\n        const candidates = fixedBuckets.get(segmentRangeKey(orig)) ?? [];\n\n        const best = findBestFixedMatch(orig, candidates, fixedSegments, usedFixed, normalizeCompare);\n        if (best.kind === 'none') {\n            out.push(orig);\n            unresolved++;\n            details.push(detailUnresolved(orig, i, ['no alignment candidate in rerun output for same (from,to)']));\n            continue;\n        }\n        if (best.kind === 'ambiguous') {\n            out.push(orig);\n            unresolved++;\n            details.push(detailUnresolved(orig, i, ['ambiguous alignment (score gap too small)']));\n            continue;\n        }\n\n        usedFixed.add(best.fixedIdx);\n        const fixed = fixedSegments[best.fixedIdx];\n\n        if (fixed.content === orig.content) {\n            out.push(orig);\n            unchanged++;\n            details.push(detailSkippedIdempotent(orig, i, ['content already matches rerun output']));\n            continue;\n        }\n\n        out.push({ ...orig, content: fixed.content });\n        recovered++;\n        details.push(detailRecoveredRerun(orig, fixed, i));\n    }\n\n    return { details, segments: out, summary: { recovered, unchanged, unresolved } };\n};\n\nexport function recoverMistakenLineStartsAfterMarkers(\n    pages: Page[],\n    segments: Segment[],\n    options: SegmentationOptions,\n    selector: MarkerRecoverySelector,\n    opts?: {\n        mode?: 'rerun_only' | 'best_effort_then_rerun';\n        normalizeCompare?: NormalizeCompareMode;\n    },\n): { report: MarkerRecoveryReport; segments: Segment[] } {\n    const mode = opts?.mode ?? 'rerun_only';\n    const normalizeCompare = opts?.normalizeCompare ?? 'whitespace';\n\n    const resolved = resolveSelectorToRuleIndices(options, selector);\n    const reportBase: Omit<MarkerRecoveryReport, 'details' | 'summary'> = {\n        byRun: undefined,\n        errors: resolved.errors,\n        warnings: resolved.warnings,\n    };\n\n    if (resolved.indices.size === 0) {\n        return buildNoSelectionResult(segments, reportBase, mode, resolved.errors);\n    }\n\n    const stage1 = runStage1IfEnabled(pages, segments, options, resolved.indices, mode);\n\n    const fixedOptions = buildFixedOptions(options, resolved.indices);\n    const fixedSegments = segmentPages(pages, fixedOptions);\n    const fixedBuckets = buildFixedBuckets(fixedSegments);\n    const merged = mergeWithRerun({\n        fixedBuckets,\n        fixedSegments,\n        normalizeCompare,\n        originalSegments: segments,\n        recoveredDetailAtIndex: stage1.recoveredDetailAtIndex,\n        stage1RecoveredAtIndex: stage1.recoveredAtIndex,\n    });\n\n    return {\n        report: {\n            ...reportBase,\n            details: merged.details,\n            summary: {\n                mode,\n                recovered: merged.summary.recovered,\n                totalSegments: segments.length,\n                unchanged: merged.summary.unchanged,\n                unresolved: merged.summary.unresolved,\n            },\n        },\n        segments: merged.segments,\n    };\n}\n\nexport function recoverMistakenMarkersForRuns(\n    runs: MarkerRecoveryRun[],\n    opts?: { mode?: 'rerun_only' | 'best_effort_then_rerun'; normalizeCompare?: NormalizeCompareMode },\n): { report: MarkerRecoveryReport; segments: Segment[] } {\n    const allSegments: Segment[] = [];\n    const byRun: NonNullable<MarkerRecoveryReport['byRun']> = [];\n    const details: MarkerRecoveryReport['details'] = [];\n    const warnings: string[] = [];\n    const errors: string[] = [];\n\n    let recovered = 0;\n    let unchanged = 0;\n    let unresolved = 0;\n    let offset = 0;\n\n    for (let i = 0; i < runs.length; i++) {\n        const run = runs[i];\n        const res = recoverMistakenLineStartsAfterMarkers(run.pages, run.segments, run.options, run.selector, opts);\n        allSegments.push(...res.segments);\n\n        // Adjust indices in details to be global\n        for (const d of res.report.details) {\n            details.push({ ...d, segmentIndex: d.segmentIndex + offset });\n        }\n        offset += run.segments.length;\n\n        recovered += res.report.summary.recovered;\n        unchanged += res.report.summary.unchanged;\n        unresolved += res.report.summary.unresolved;\n\n        warnings.push(...res.report.warnings);\n        errors.push(...res.report.errors);\n\n        byRun.push({\n            recovered: res.report.summary.recovered,\n            runIndex: i,\n            totalSegments: run.segments.length,\n            unresolved: res.report.summary.unresolved,\n        });\n    }\n\n    const report: MarkerRecoveryReport = {\n        byRun,\n        details,\n        errors,\n        summary: {\n            mode: opts?.mode ?? 'rerun_only',\n            recovered,\n            totalSegments: offset,\n            unchanged,\n            unresolved,\n        },\n        warnings,\n    };\n\n    return { report, segments: allSegments };\n}\n","/**\n * Pattern validation utilities for detecting common mistakes in rule patterns.\n *\n * These utilities help catch typos and issues early, before rules are used\n * for segmentation.\n */\n\nimport type { SplitRule } from '@/types/rules.js';\nimport { getAvailableTokens } from './tokens.js';\n\n/**\n * Types of validation issues that can be detected.\n */\nexport type ValidationIssueType = 'missing_braces' | 'unknown_token' | 'duplicate' | 'empty_pattern';\n\n/**\n * A validation issue found in a pattern.\n */\nexport type ValidationIssue = {\n    type: ValidationIssueType;\n    message: string;\n    suggestion?: string;\n    /** The token name involved in the issue (for unknown_token / missing_braces) */\n    token?: string;\n    /** The specific pattern involved (for duplicate) */\n    pattern?: string;\n};\n\n/**\n * Validation result for a single rule, with issues keyed by pattern type.\n * Arrays parallel the input pattern arrays - undefined means no issue.\n */\nexport type RuleValidationResult = {\n    lineStartsWith?: (ValidationIssue | undefined)[];\n    lineStartsAfter?: (ValidationIssue | undefined)[];\n    lineEndsWith?: (ValidationIssue | undefined)[];\n    template?: ValidationIssue;\n};\n\n// Known token names from the tokens module\nconst KNOWN_TOKENS = new Set(getAvailableTokens());\n\n// Regex to find tokens inside {{}} - both with and without capture syntax\nconst TOKEN_INSIDE_BRACES = /\\{\\{(\\w+)(?::\\w+)?\\}\\}/g;\n\n// Regex to find potential token names NOT inside {{}}\n// Matches word boundaries around known token names\nconst buildBareTokenRegex = () => {\n    const tokens = [...KNOWN_TOKENS].sort((a, b) => b.length - a.length);\n    return new RegExp(`(?<!\\\\{\\\\{)(${tokens.join('|')})(?::\\\\w+)?(?!\\\\}\\\\})`, 'g');\n};\n\n/**\n * Validates a single pattern for common issues.\n */\nconst validatePattern = (pattern: string, seenPatterns: Set<string>) => {\n    if (!pattern.trim()) {\n        return { message: 'Empty pattern is not allowed', type: 'empty_pattern' } as const;\n    }\n    if (seenPatterns.has(pattern)) {\n        return { message: `Duplicate pattern: \"${pattern}\"`, pattern, type: 'duplicate' } as const;\n    }\n    seenPatterns.add(pattern);\n\n    // TOKEN_INSIDE_BRACES is a global /g regex. Ensure lastIndex does not leak between calls.\n    TOKEN_INSIDE_BRACES.lastIndex = 0;\n    for (const match of pattern.matchAll(TOKEN_INSIDE_BRACES)) {\n        const name = match[1];\n        if (!KNOWN_TOKENS.has(name)) {\n            return {\n                message: `Unknown token: {{${name}}}. Available tokens: ${[...KNOWN_TOKENS].slice(0, 5).join(', ')}...`,\n                suggestion: 'Check spelling or use a known token',\n                token: name,\n                type: 'unknown_token',\n            } as const;\n        }\n    }\n\n    for (const match of pattern.matchAll(buildBareTokenRegex())) {\n        const [full, name] = match;\n        const idx = match.index!;\n        if (\n            pattern.slice(Math.max(0, idx - 2), idx) !== '{{' ||\n            pattern.slice(idx + full.length, idx + full.length + 2) !== '}}'\n        ) {\n            return {\n                message: `Token \"${name}\" appears to be missing {{}}. Did you mean \"{{${full}}}\"?`,\n                suggestion: `{{${full}}}`,\n                token: name,\n                type: 'missing_braces',\n            } as const;\n        }\n    }\n};\n\n/**\n * Validates an array of patterns, returning parallel array of issues.\n */\nconst validatePatternArray = (patterns: string[]) => {\n    const seen = new Set<string>();\n    const issues = patterns.map((p) => validatePattern(p, seen));\n    return issues.some(Boolean) ? issues : undefined;\n};\n\n/**\n * Validates split rules for common pattern issues.\n *\n * Checks for:\n * - Missing `{{}}` around known token names (e.g., `raqms:num` instead of `{{raqms:num}}`)\n * - Unknown token names inside `{{}}` (e.g., `{{nonexistent}}`)\n * - Duplicate patterns within the same rule\n *\n * @param rules - Array of split rules to validate\n * @returns Array parallel to input with validation results (undefined if no issues)\n *\n * @example\n * const issues = validateRules([\n *   { lineStartsAfter: ['raqms:num'] },  // Missing braces\n *   { lineStartsWith: ['{{unknown}}'] }, // Unknown token\n * ]);\n * // issues[0]?.lineStartsAfter?.[0]?.type === 'missing_braces'\n * // issues[1]?.lineStartsWith?.[0]?.type === 'unknown_token'\n */\nexport const validateRules = (rules: SplitRule[]) =>\n    rules.map((rule) => {\n        const result: RuleValidationResult = {};\n        let hasIssues = false;\n\n        for (const key of ['lineStartsWith', 'lineStartsAfter', 'lineEndsWith'] as const) {\n            if (key in rule && (rule as any)[key]) {\n                const issues = validatePatternArray((rule as any)[key]);\n                if (issues) {\n                    result[key] = issues;\n                    hasIssues = true;\n                }\n            }\n        }\n\n        if ('template' in rule && rule.template !== undefined) {\n            const issue = validatePattern(rule.template, new Set());\n            if (issue) {\n                result.template = issue;\n                hasIssues = true;\n            }\n        }\n\n        return hasIssues ? result : undefined;\n    });\n/**\n * Formats a validation result array into a list of human-readable error messages.\n *\n * Useful for displaying validation errors in UIs.\n *\n * @param results - The result array from `validateRules()`\n * @returns Array of formatted error strings\n *\n * @example\n * const issues = validateRules(rules);\n * const errors = formatValidationReport(issues);\n * // [\"Rule 1, lineStartsWith: Missing {{}} around token...\"]\n */\nexport const formatValidationReport = (results: (RuleValidationResult | undefined)[]) =>\n    results.flatMap((result, i) => {\n        if (!result) {\n            return [];\n        }\n        return Object.entries(result)\n            .flatMap(([type, issues]) =>\n                (Array.isArray(issues) ? issues : [issues]).map((issue) => {\n                    if (!issue) {\n                        return null;\n                    }\n                    const loc = `Rule ${i + 1}, ${type}`;\n                    if (issue.type === 'missing_braces') {\n                        return `${loc}: Missing {{}} around token \"${issue.token}\"`;\n                    }\n                    if (issue.type === 'unknown_token') {\n                        return `${loc}: Unknown token \"{{${issue.token}}}\"`;\n                    }\n                    if (issue.type === 'duplicate') {\n                        return `${loc}: Duplicate pattern \"${issue.pattern}\"`;\n                    }\n                    return `${loc}: ${issue.message || issue.type}`;\n                }),\n            )\n            .filter((msg): msg is string => msg !== null);\n    });\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["TOKEN_PRIORITY_ORDER","isArabicLetter","resolveOptions","skipWhitespace","word","processPattern","passesRuleConstraints","createSegment"],"sources":["../src/utils/textUtils.ts","../src/segmentation/tokens.ts","../src/analysis/shared.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/detection.ts","../src/types/rules.ts","../src/optimization/optimize-rules.ts","../src/segmentation/rule-regex.ts","../src/segmentation/breakpoint-constants.ts","../src/segmentation/breakpoint-utils.ts","../src/segmentation/debug-meta.ts","../src/segmentation/breakpoint-processor.ts","../src/segmentation/match-utils.ts","../src/segmentation/fast-fuzzy-prefix.ts","../src/segmentation/segmenter-rule-utils.ts","../src/segmentation/split-point-helpers.ts","../src/segmentation/segmenter.ts","../src/recovery.ts","../src/segmentation/pattern-validator.ts"],"sourcesContent":["/**\n * Normalizes line endings to Unix-style (`\\n`).\n *\n * Converts Windows (`\\r\\n`) and old Mac (`\\r`) line endings to Unix style\n * for consistent pattern matching across platforms.\n *\n * @param content - Raw content with potentially mixed line endings\n * @returns Content with all line endings normalized to `\\n`\n */\n// OPTIMIZATION: Fast-path when no \\r present (common case for Unix/Mac content)\nexport const normalizeLineEndings = (content: string) => {\n    return content.includes('\\r') ? content.replace(/\\r\\n?/g, '\\n') : content;\n};\n\n/**\n * Escapes regex metacharacters (parentheses and brackets) in template patterns,\n * but preserves content inside `{{...}}` token delimiters.\n *\n * This allows users to write intuitive patterns like `({{harf}}):` instead of\n * the verbose `\\\\({{harf}}\\\\):`. The escaping is applied BEFORE token expansion,\n * so tokens like `{{harf}}` which expand to `[أ-ي]` work correctly.\n *\n * @param pattern - Template pattern that may contain `()[]` and `{{tokens}}`\n * @returns Pattern with `()[]` escaped outside of `{{...}}` delimiters\n *\n * @example\n * escapeTemplateBrackets('({{harf}}): ')\n * // → '\\\\({{harf}}\\\\): '\n *\n * @example\n * escapeTemplateBrackets('[{{raqm}}] ')\n * // → '\\\\[{{raqm}}\\\\] '\n *\n * @example\n * escapeTemplateBrackets('{{harf}}')\n * // → '{{harf}}' (unchanged - no brackets outside tokens)\n */\nexport const escapeTemplateBrackets = (pattern: string) => {\n    return pattern.replace(/(\\{\\{[^}]*\\}\\})|([()[\\]])/g, (_match, token, bracket) => token || `\\\\${bracket}`);\n};\n\n/**\n * Character class matching all Arabic diacritics (Tashkeel/Harakat).\n *\n * Includes the following diacritical marks:\n * - U+064B: ً (fathatan - double fatha)\n * - U+064C: ٌ (dammatan - double damma)\n * - U+064D: ٍ (kasratan - double kasra)\n * - U+064E: َ (fatha - short a)\n * - U+064F: ُ (damma - short u)\n * - U+0650: ِ (kasra - short i)\n * - U+0651: ّ (shadda - gemination)\n * - U+0652: ْ (sukun - no vowel)\n *\n * @internal\n */\nconst DIACRITICS_CLASS = '[\\u064B\\u064C\\u064D\\u064E\\u064F\\u0650\\u0651\\u0652]';\n\n/**\n * Groups of equivalent Arabic characters.\n *\n * Characters within the same group are considered equivalent for matching purposes.\n * This handles common variations in Arabic text where different characters are\n * used interchangeably or have the same underlying meaning.\n *\n * Equivalence groups:\n * - Alef variants: ا (bare), آ (with madda), أ (with hamza above), إ (with hamza below)\n * - Ta marbuta and Ha: ة ↔ ه (often interchangeable at word endings)\n * - Alef maqsura and Ya: ى ↔ ي (often interchangeable at word endings)\n *\n * @internal\n */\nconst EQUIV_GROUPS = [\n    ['\\u0627', '\\u0622', '\\u0623', '\\u0625'], // ا, آ, أ, إ\n    ['\\u0629', '\\u0647'], // ة <-> ه\n    ['\\u0649', '\\u064A'], // ى <-> ي\n];\n\n/**\n * Escapes a string for safe inclusion in a regular expression.\n *\n * Escapes all regex metacharacters: `.*+?^${}()|[\\]\\\\`\n *\n * @param s - Any string to escape\n * @returns String with regex metacharacters escaped\n *\n * @example\n * escapeRegex('hello.world')   // → 'hello\\\\.world'\n * escapeRegex('[test]')        // → '\\\\[test\\\\]'\n * escapeRegex('a+b*c?')        // → 'a\\\\+b\\\\*c\\\\?'\n */\nexport const escapeRegex = (s: string) => s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\nconst getEquivClass = (ch: string) => {\n    const group = EQUIV_GROUPS.find((g) => g.includes(ch));\n    return group ? `[${group.map(escapeRegex).join('')}]` : escapeRegex(ch);\n};\n\nconst normalizeArabicLight = (str: string) => {\n    return str\n        .normalize('NFC')\n        .replace(/[\\u200C\\u200D]/g, '')\n        .replace(/\\s+/g, ' ')\n        .trim();\n};\n\nexport const makeDiacriticInsensitive = (text: string) => {\n    const diacriticsMatcher = `${DIACRITICS_CLASS}*`;\n    return Array.from(normalizeArabicLight(text))\n        .map((ch) => getEquivClass(ch) + diacriticsMatcher)\n        .join('');\n};\n\nconst isCombiningMarkOrSelector = (char: string | undefined) => {\n    if (!char) {\n        return false;\n    }\n    // \\p{M} = Unicode combining mark category (includes Arabic harakat)\n    // FE0E/FE0F = variation selectors\n    return /\\p{M}/u.test(char) || char === '\\uFE0E' || char === '\\uFE0F';\n};\n\nconst isJoiner = (char: string | undefined) => char === '\\u200C' || char === '\\u200D';\n\n/**\n * Ensures the position does not split a grapheme cluster (surrogate pairs,\n * combining marks, or zero-width joiners / variation selectors).\n *\n * This is only used as a last-resort fallback when we are forced to split\n * near a hard limit (e.g. maxContentLength with no safe whitespace/punctuation).\n */\nexport const adjustForUnicodeBoundary = (content: string, position: number) => {\n    let adjusted = position;\n\n    while (adjusted > 0) {\n        // 1. Ensure we don't split a surrogate pair\n        // (High surrogate at adjusted-1, Low surrogate at adjusted)\n        const high = content.charCodeAt(adjusted - 1);\n        const low = content.charCodeAt(adjusted);\n        if (high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) {\n            adjusted -= 1;\n            continue;\n        }\n\n        const nextChar = content[adjusted];\n        const prevChar = content[adjusted - 1];\n        // 2. If we'd start the next segment with a combining mark / selector / joiner, back up.\n        // For joiners, also avoid ending the previous segment with a joiner.\n        // (Splitting AFTER combining marks / selectors is safe; splitting before them is not.)\n        if (isCombiningMarkOrSelector(nextChar) || isJoiner(nextChar) || isJoiner(prevChar)) {\n            adjusted -= 1;\n            continue;\n        }\n\n        break;\n    }\n    return adjusted;\n};\n","/**\n * Base token definitions mapping human-readable token names to regex patterns.\n *\n * These tokens contain raw regex patterns and do not reference other tokens.\n * For composite tokens that build on these, see `COMPOSITE_TOKENS`.\n *\n * @internal\n */\n// IMPORTANT:\n// - We include the Arabic-Indic digit `٤` as a rumuz code, but we do NOT match it when it's part of a larger number (e.g. \"٣٤\").\n// - We intentionally do NOT match ASCII `4`.\n// - For performance/clarity, the single-letter rumuz are represented as a character class.\n// - Single-letter codes must NOT be followed by Arabic diacritics (\\u064B-\\u0652, \\u0670) or letters (أ-ي),\n//   otherwise we'd incorrectly match the first letter of Arabic words like عَن as rumuz ع.\nconst RUMUZ_SINGLE_LETTER = '[خرزيمنصسدفلتقع](?![\\\\u064B-\\\\u0652\\\\u0670أ-ي])';\n\nconst RUMUZ_FOUR = '(?<![\\\\u0660-\\\\u0669])٤(?![\\\\u0660-\\\\u0669])';\n\n// IMPORTANT: order matters. Put longer/more specific codes before shorter ones.\nconst RUMUZ_ATOMS: string[] = [\n    // Multi-letter word codes (must NOT be followed by diacritics or letters)\n    'تمييز(?![\\\\u064B-\\\\u0652\\\\u0670أ-ي])',\n    // 2-letter codes\n    'خت',\n    'خغ',\n    'بخ',\n    'عخ',\n    'مق',\n    'مت',\n    'عس',\n    'سي',\n    'سن',\n    'كن',\n    'مد',\n    'قد',\n    'خد',\n    'فد',\n    'دل',\n    'كد',\n    'غد',\n    'صد',\n    'دت',\n    'دس',\n    'تم',\n    'فق',\n    'دق',\n    // Single-letter codes (character class) + special digit atom\n    RUMUZ_SINGLE_LETTER,\n    RUMUZ_FOUR,\n];\n\nconst RUMUZ_ATOM = `(?:${RUMUZ_ATOMS.join('|')})`;\n\nconst RUMUZ_BLOCK = `${RUMUZ_ATOM}(?:\\\\s+${RUMUZ_ATOM})*`;\n\nconst BASE_TOKENS: Record<string, string> = {\n    /** Chapter marker (باب). */\n    bab: 'باب',\n\n    /** Basmala (بسم الله). Also matches ﷽. */\n    basmalah: ['بسم الله', '﷽'].join('|'),\n\n    /** Bullet point variants: `•`, `*`, `°`. */\n    bullet: '[•*°]',\n\n    /** Dash variants: `-` (U+002D), `–` (U+2013), `—` (U+2014), `ـ` (tatweel U+0640). */\n    dash: '[-–—ـ]',\n\n    /** Section marker (فصل / مسألة). */\n    fasl: ['مسألة', 'فصل'].join('|'),\n\n    /** Single Arabic letter (أ-ي). Does NOT include diacritics. */\n    harf: '[أ-ي]',\n\n    /** One or more single Arabic letters separated by spaces. For multi-letter codes use `{{rumuz}}`. */\n    harfs: '[أ-ي](?:\\\\s+[أ-ي])*',\n\n    /** Book marker (كتاب). */\n    kitab: 'كتاب',\n\n    /** Hadith transmission phrases (حدثنا, أخبرنا, حدثني, etc.). */\n    naql: ['حدثني', 'وأخبرنا', 'حدثنا', 'سمعت', 'أنبأنا', 'وحدثنا', 'أخبرنا', 'وحدثني', 'وحدثنيه'].join('|'),\n\n    /** Single ASCII digit (0-9). */\n    num: '\\\\d',\n\n    /** One or more ASCII digits (0-9)+. */\n    nums: '\\\\d+',\n\n    /** Single Arabic-Indic digit (٠-٩, U+0660-U+0669). */\n    raqm: '[\\\\u0660-\\\\u0669]',\n\n    /** One or more Arabic-Indic digits (٠-٩)+. */\n    raqms: '[\\\\u0660-\\\\u0669]+',\n\n    /** Rijāl/takhrīj source abbreviations. Matches one or more codes separated by whitespace. */\n    rumuz: RUMUZ_BLOCK,\n\n    /** Arabic/common punctuation: `.`, `!`, `?`, `؟`, `؛`. */\n    tarqim: '[.!?؟؛]',\n};\n\n/** Pre-defined token constants for use in patterns. */\nexport const Token = {\n    /** Chapter marker - باب */\n    BAB: '{{bab}}',\n    /** Basmala - بسم الله */\n    BASMALAH: '{{basmalah}}',\n    /** Bullet point variants */\n    BULLET: '{{bullet}}',\n    /** Dash variants (hyphen, en-dash, em-dash, tatweel) */\n    DASH: '{{dash}}',\n    /** Section marker - فصل / مسألة */\n    FASL: '{{fasl}}',\n    /** Single Arabic letter */\n    HARF: '{{harf}}',\n    /** Multiple Arabic letters separated by spaces */\n    HARFS: '{{harfs}}',\n    /** Book marker - كتاب */\n    KITAB: '{{kitab}}',\n    /** Hadith transmission phrases */\n    NAQL: '{{naql}}',\n    /** Single ASCII digit */\n    NUM: '{{num}}',\n    /** Composite: {{raqms}} {{dash}} (space) */\n    NUMBERED: '{{numbered}}',\n    /** One or more ASCII digits */\n    NUMS: '{{nums}}',\n    /** Single Arabic-Indic digit */\n    RAQM: '{{raqm}}',\n    /** One or more Arabic-Indic digits */\n    RAQMS: '{{raqms}}',\n    /** Source abbreviations (rijāl/takhrīj) */\n    RUMUZ: '{{rumuz}}',\n    /** Punctuation marks */\n    TARQIM: '{{tarqim}}',\n} as const;\n\n/**\n * Type representing valid token constant keys.\n */\nexport type TokenKey = keyof typeof Token;\n\n/** Wraps a token constant with a named capture: `{{token}}` → `{{token:name}}`. */\nexport const withCapture = (token: string, name: string): string => {\n    // Extract token name from {{token}} format\n    const match = token.match(/^\\{\\{(\\w+)\\}\\}$/);\n    if (!match) {\n        // If not a valid token format, return capture-only syntax\n        return `{{:${name}}}`;\n    }\n    return `{{${match[1]}:${name}}}`;\n};\n\n/** Composite tokens that reference base tokens. Pre-expanded at load time. @internal */\nconst COMPOSITE_TOKENS: Record<string, string> = {\n    /** Common hadith numbering format: Arabic-Indic digits + dash + space. */\n    numbered: '{{raqms}} {{dash}} ',\n};\n\n/** Expands composite tokens (e.g. `{{numbered}}`) to their underlying template form. */\nexport const expandCompositeTokensInTemplate = (template: string) => {\n    let out = template;\n    for (let i = 0; i < 10; i++) {\n        const next = out.replace(/\\{\\{(\\w+)\\}\\}/g, (m, tokenName: string) => COMPOSITE_TOKENS[tokenName] ?? m);\n        if (next === out) {\n            break;\n        }\n        out = next;\n    }\n    return out;\n};\n\n/**\n * Expands base tokens in a template string.\n * Used internally to pre-expand composite tokens.\n *\n * @param template - Template string with `{{token}}` placeholders\n * @returns Expanded pattern with base tokens replaced\n * @internal\n */\nconst expandBaseTokens = (template: string) =>\n    template.replace(/\\{\\{(\\w+)\\}\\}/g, (_, tokenName) => BASE_TOKENS[tokenName] ?? `{{${tokenName}}}`);\n\n/**\n * Token definitions mapping human-readable token names to regex patterns.\n *\n * Tokens are used in template strings with double-brace syntax:\n * - `{{token}}` - Expands to the pattern (non-capturing in context)\n * - `{{token:name}}` - Expands to a named capture group `(?<name>pattern)`\n * - `{{:name}}` - Captures any content with the given name `(?<name>.+)`\n *\n * @remarks\n * These patterns are designed for Arabic text matching. For diacritic-insensitive\n * matching of Arabic patterns, use the `fuzzy: true` option in split rules,\n * which applies `makeDiacriticInsensitive()` to the expanded patterns.\n *\n * @example\n * // Using tokens in a split rule\n * { lineStartsWith: ['{{kitab}}', '{{bab}}'], split: 'at', fuzzy: true }\n *\n * @example\n * // Using tokens with named captures\n * { lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '], split: 'at' }\n *\n * @example\n * // Using the numbered convenience token\n * { lineStartsAfter: ['{{numbered}}'], split: 'at' }\n */\nexport const TOKEN_PATTERNS: Record<string, string> = {\n    ...BASE_TOKENS,\n    // Pre-expand composite tokens at module load time\n    ...Object.fromEntries(Object.entries(COMPOSITE_TOKENS).map(([k, v]) => [k, expandBaseTokens(v)])),\n};\n\n/**\n * Regex pattern for matching tokens with optional named capture syntax.\n *\n * Matches:\n * - `{{token}}` - Simple token (group 1 = token name, group 2 = empty)\n * - `{{token:name}}` - Token with capture (group 1 = token, group 2 = name)\n * - `{{:name}}` - Capture-only (group 1 = empty, group 2 = name)\n *\n * @internal\n */\nconst TOKEN_WITH_CAPTURE_REGEX = /\\{\\{(\\w*):?(\\w*)\\}\\}/g;\n\n/**\n * Regex pattern for simple token matching (no capture syntax).\n *\n * Matches only `{{token}}` format where token is one or more word characters.\n * Used by `containsTokens()` for quick detection.\n *\n * @internal\n */\nconst SIMPLE_TOKEN_REGEX = /\\{\\{(\\w+)\\}\\}/g;\n\n/**\n * Checks if a query string contains template tokens.\n *\n * Performs a quick test for `{{token}}` patterns without actually\n * expanding them. Useful for determining whether to apply token\n * expansion to a string.\n *\n * @param query - String to check for tokens\n * @returns `true` if the string contains at least one `{{token}}` pattern\n *\n * @example\n * containsTokens('{{raqms}} {{dash}}') // → true\n * containsTokens('plain text')          // → false\n * containsTokens('[٠-٩]+ - ')           // → false (raw regex, no tokens)\n */\nexport const containsTokens = (query: string) => {\n    SIMPLE_TOKEN_REGEX.lastIndex = 0;\n    return SIMPLE_TOKEN_REGEX.test(query);\n};\n\n/**\n * Result from expanding tokens with capture information.\n *\n * Contains the expanded pattern string along with metadata about\n * any named capture groups that were created.\n */\nexport type ExpandResult = {\n    /**\n     * The expanded regex pattern string with all tokens replaced.\n     *\n     * Named captures use the `(?<name>pattern)` syntax.\n     */\n    pattern: string;\n\n    /**\n     * Names of captured groups extracted from `{{token:name}}` syntax.\n     *\n     * Empty array if no named captures were found.\n     */\n    captureNames: string[];\n\n    /**\n     * Whether the pattern has any named capturing groups.\n     *\n     * Equivalent to `captureNames.length > 0`.\n     */\n    hasCaptures: boolean;\n};\n\ntype TemplateSegment = { type: 'token' | 'text'; value: string };\n\nconst splitTemplateIntoSegments = (query: string) => {\n    const segments: TemplateSegment[] = [];\n    let lastIndex = 0;\n    TOKEN_WITH_CAPTURE_REGEX.lastIndex = 0;\n\n    for (const match of query.matchAll(TOKEN_WITH_CAPTURE_REGEX)) {\n        if (match.index! > lastIndex) {\n            segments.push({ type: 'text', value: query.slice(lastIndex, match.index) });\n        }\n        segments.push({ type: 'token', value: match[0] });\n        lastIndex = match.index! + match[0].length;\n    }\n\n    if (lastIndex < query.length) {\n        segments.push({ type: 'text', value: query.slice(lastIndex) });\n    }\n    return segments;\n};\n\nconst maybeApplyFuzzyToText = (text: string, fuzzyTransform?: (pattern: string) => string) =>\n    fuzzyTransform && /[\\u0600-\\u06FF]/u.test(text) ? fuzzyTransform(text) : text;\n\n// NOTE: This intentionally preserves the previous behavior:\n// it applies fuzzy per `|`-separated alternative (best-effort) to avoid corrupting regex metacharacters.\nconst maybeApplyFuzzyToTokenPattern = (tokenPattern: string, fuzzyTransform?: (pattern: string) => string) =>\n    !fuzzyTransform\n        ? tokenPattern\n        : tokenPattern\n              .split('|')\n              .map((part) => (/[\\u0600-\\u06FF]/u.test(part) ? fuzzyTransform(part) : part))\n              .join('|');\n\nconst parseTokenLiteral = (literal: string) => {\n    TOKEN_WITH_CAPTURE_REGEX.lastIndex = 0;\n    const m = TOKEN_WITH_CAPTURE_REGEX.exec(literal);\n    return m ? { captureName: m[2], tokenName: m[1] } : null;\n};\n\nconst createCaptureRegistry = (capturePrefix?: string) => {\n    const captureNames: string[] = [];\n    const captureNameCounts = new Map<string, number>();\n\n    const register = (baseName: string) => {\n        const count = captureNameCounts.get(baseName) ?? 0;\n        captureNameCounts.set(baseName, count + 1);\n        const uniqueName = count === 0 ? baseName : `${baseName}_${count + 1}`;\n        const prefixedName = capturePrefix ? `${capturePrefix}${uniqueName}` : uniqueName;\n        captureNames.push(prefixedName);\n        return prefixedName;\n    };\n\n    return { captureNames, register };\n};\n\nconst expandTokenLiteral = (\n    literal: string,\n    opts: {\n        fuzzyTransform?: (pattern: string) => string;\n        registerCapture: (baseName: string) => string;\n        capturePrefix?: string;\n    },\n) => {\n    const parsed = parseTokenLiteral(literal);\n    if (!parsed) {\n        return literal;\n    }\n\n    const { tokenName, captureName } = parsed;\n    if (!tokenName && captureName) {\n        return `(?<${opts.registerCapture(captureName)}>.+)`;\n    }\n\n    let tokenPattern = TOKEN_PATTERNS[tokenName];\n    if (!tokenPattern) {\n        return literal;\n    }\n\n    tokenPattern = maybeApplyFuzzyToTokenPattern(tokenPattern, opts.fuzzyTransform);\n    if (captureName) {\n        return `(?<${opts.registerCapture(captureName)}>${tokenPattern})`;\n    }\n\n    return tokenPattern;\n};\n\n/**\n * Expands template tokens with support for named captures.\n *\n * This is the primary token expansion function that handles all token syntax:\n * - `{{token}}` → Expands to the token's pattern (no capture group)\n * - `{{token:name}}` → Expands to `(?<name>pattern)` (named capture)\n * - `{{:name}}` → Expands to `(?<name>.+)` (capture anything)\n *\n * Unknown tokens are left as-is in the output, allowing for partial templates.\n *\n * @param query - The template string containing tokens\n * @param fuzzyTransform - Optional function to transform Arabic text for fuzzy matching.\n *                         Applied to both token patterns and plain Arabic text between tokens.\n *                         Typically `makeDiacriticInsensitive` from the fuzzy module.\n * @returns Object with expanded pattern, capture names, and capture flag\n *\n * @example\n * // Simple token expansion\n * expandTokensWithCaptures('{{raqms}} {{dash}}')\n * // → { pattern: '[\\\\u0660-\\\\u0669]+ [-–—ـ]', captureNames: [], hasCaptures: false }\n *\n * @example\n * // Named capture\n * expandTokensWithCaptures('{{raqms:num}} {{dash}}')\n * // → { pattern: '(?<num>[\\\\u0660-\\\\u0669]+) [-–—ـ]', captureNames: ['num'], hasCaptures: true }\n *\n * @example\n * // Capture-only token\n * expandTokensWithCaptures('{{raqms:num}} {{dash}} {{:content}}')\n * // → { pattern: '(?<num>[٠-٩]+) [-–—ـ] (?<content>.+)', captureNames: ['num', 'content'], hasCaptures: true }\n *\n * @example\n * // With fuzzy transform\n * expandTokensWithCaptures('{{bab}}', makeDiacriticInsensitive)\n * // → { pattern: 'بَ?ا?بٌ?', captureNames: [], hasCaptures: false }\n */\nexport const expandTokensWithCaptures = (\n    query: string,\n    fuzzyTransform?: (pattern: string) => string,\n    capturePrefix?: string,\n) => {\n    const segments = splitTemplateIntoSegments(query);\n    const registry = createCaptureRegistry(capturePrefix);\n\n    const pattern = segments\n        .map((segment) =>\n            segment.type === 'text'\n                ? maybeApplyFuzzyToText(segment.value, fuzzyTransform)\n                : expandTokenLiteral(segment.value, {\n                      capturePrefix,\n                      fuzzyTransform,\n                      registerCapture: registry.register,\n                  }),\n        )\n        .join('');\n\n    return {\n        captureNames: registry.captureNames,\n        hasCaptures: registry.captureNames.length > 0,\n        pattern,\n    };\n};\n\n/**\n * Expands template tokens in a query string to their regex equivalents.\n *\n * This is the simple version without capture support. It returns only the\n * expanded pattern string, not capture metadata.\n *\n * Unknown tokens are left as-is, allowing for partial templates.\n *\n * @param query - Template string containing `{{token}}` placeholders\n * @returns Expanded regex pattern string\n *\n * @example\n * expandTokens('، {{raqms}}')     // → '، [\\\\u0660-\\\\u0669]+'\n * expandTokens('{{raqm}}*')       // → '[\\\\u0660-\\\\u0669]*'\n * expandTokens('{{dash}}{{raqm}}') // → '[-–—ـ][\\\\u0660-\\\\u0669]'\n * expandTokens('{{unknown}}')     // → '{{unknown}}' (left as-is)\n *\n * @see expandTokensWithCaptures for full capture group support\n */\nexport const expandTokens = (query: string) => expandTokensWithCaptures(query).pattern;\n\n/**\n * Converts a template string to a compiled RegExp.\n *\n * Expands all tokens and attempts to compile the result as a RegExp\n * with Unicode flag. Returns `null` if the resulting pattern is invalid.\n *\n * @remarks\n * This function dynamically compiles regular expressions from template strings.\n * If templates may come from untrusted sources, be aware of potential ReDoS\n * (Regular Expression Denial of Service) risks due to catastrophic backtracking.\n * Consider validating pattern complexity or applying execution timeouts when\n * running user-submitted patterns.\n *\n * @param template - Template string containing `{{token}}` placeholders\n * @returns Compiled RegExp with 'u' flag, or `null` if invalid\n *\n * @example\n * templateToRegex('، {{raqms}}')  // → /، [٠-٩]+/u\n * templateToRegex('{{raqms}}+')   // → /[٠-٩]++/u (might be invalid in some engines)\n * templateToRegex('(((')          // → null (invalid regex)\n */\nexport const templateToRegex = (template: string) => {\n    const expanded = expandTokens(template);\n    try {\n        return new RegExp(expanded, 'u');\n    } catch {\n        return null;\n    }\n};\n\n/**\n * Lists all available token names defined in `TOKEN_PATTERNS`.\n *\n * Useful for documentation, validation, or building user interfaces\n * that show available tokens.\n *\n * @returns Array of token names (e.g., `['bab', 'basmala', 'bullet', ...]`)\n *\n * @example\n * getAvailableTokens()\n * // → ['bab', 'basmala', 'bullet', 'dash', 'harf', 'kitab', 'naql', 'raqm', 'raqms']\n */\nexport const getAvailableTokens = () => Object.keys(TOKEN_PATTERNS);\n\n/**\n * Gets the regex pattern for a specific token name.\n *\n * Returns the raw pattern string as defined in `TOKEN_PATTERNS`,\n * without any expansion or capture group wrapping.\n *\n * @param tokenName - The token name to look up (e.g., 'raqms', 'dash')\n * @returns The regex pattern string, or `undefined` if token doesn't exist\n *\n * @example\n * getTokenPattern('raqms')   // → '[\\\\u0660-\\\\u0669]+'\n * getTokenPattern('dash')    // → '[-–—ـ]'\n * getTokenPattern('unknown') // → undefined\n */\nexport const getTokenPattern = (tokenName: string) => TOKEN_PATTERNS[tokenName];\n\n/**\n * Tokens that should default to fuzzy matching when used in rules.\n *\n * These are Arabic phrase tokens where diacritic-insensitive matching\n * is almost always desired. Users can still override with `fuzzy: false`.\n */\nconst FUZZY_DEFAULT_TOKENS: (keyof typeof BASE_TOKENS)[] = ['bab', 'basmalah', 'fasl', 'kitab', 'naql'];\n\n/**\n * Regex to detect fuzzy-default tokens in a pattern string.\n * Matches {{token}} or {{token:name}} syntax.\n */\nconst FUZZY_TOKEN_REGEX = new RegExp(`\\\\{\\\\{(?:${FUZZY_DEFAULT_TOKENS.join('|')})(?::\\\\w+)?\\\\}\\\\}`, 'g');\n\n/**\n * Checks if a pattern (or array of patterns) contains tokens that should\n * default to fuzzy matching.\n *\n * Fuzzy-default tokens are: bab, basmalah, fasl, kitab, naql\n *\n * @param patterns - Single pattern string or array of pattern strings\n * @returns `true` if any pattern contains a fuzzy-default token\n *\n * @example\n * shouldDefaultToFuzzy('{{bab}} الإيمان')     // true\n * shouldDefaultToFuzzy('{{raqms}} {{dash}}')  // false\n * shouldDefaultToFuzzy(['{{kitab}}', '{{raqms}}']) // true\n */\nexport const shouldDefaultToFuzzy = (patterns: string | string[]) => {\n    const arr = Array.isArray(patterns) ? patterns : [patterns];\n    return arr.some((p) => {\n        FUZZY_TOKEN_REGEX.lastIndex = 0;\n        return FUZZY_TOKEN_REGEX.test(p);\n    });\n};\n\n/**\n * Structure for mapping a token to a capture name.\n */\nexport type TokenMapping = { token: string; name: string };\n\n/**\n * Apply token mappings to a template string.\n *\n * Transforms `{{token}}` into `{{token:name}}` based on the provided mappings.\n * Useful for applying user-configured capture names to a raw template.\n *\n * - Only affects exact matches of `{{token}}`.\n * - Does NOT affect tokens that already have a capture name (e.g. `{{token:existing}}`).\n * - Does NOT affect capture-only tokens (e.g. `{{:name}}`).\n *\n * @param template - The template string to transform\n * @param mappings - Array of mappings from token name to capture name\n * @returns Transformed template string with captures applied\n *\n * @example\n * applyTokenMappings('{{raqms}} {{dash}}', [{ token: 'raqms', name: 'num' }])\n * // → '{{raqms:num}} {{dash}}'\n */\nexport const applyTokenMappings = (template: string, mappings: TokenMapping[]): string => {\n    let result = template;\n    for (const { token, name } of mappings) {\n        if (!token || !name) {\n            continue;\n        }\n        // Match {{token}} but ensure it doesn't already have a suffix like :name\n        // We use a regex dealing with the brace syntax\n        const regex = new RegExp(`\\\\{\\\\{${token}\\\\}\\\\}`, 'g');\n        result = result.replace(regex, `{{${token}:${name}}}`);\n    }\n    return result;\n};\n\n/**\n * Strip token mappings from a template string.\n *\n * Transforms `{{token:name}}` back into `{{token}}`.\n * Also transforms `{{:name}}` patterns (capture-only) into `{{}}` (which is invalid/empty).\n *\n * Useful for normalizing templates for storage or comparison.\n *\n * @param template - The template string to strip\n * @returns Template string with capture names removed\n *\n * @example\n * stripTokenMappings('{{raqms:num}} {{dash}}')\n * // → '{{raqms}} {{dash}}'\n */\nexport const stripTokenMappings = (template: string) => {\n    // Match {{token:name}} and replace with {{token}}\n    return template.replace(/\\{\\{([^:}]+):[^}]+\\}\\}/g, '{{$1}}');\n};\n","// Shared utilities for analysis functions\n\nimport { getAvailableTokens, TOKEN_PATTERNS } from '../segmentation/tokens.js';\n\n// Helpers shared across analysis modules\n\n// For analysis signatures we avoid escaping ()[] because:\n// - These are commonly used literally in texts (e.g., \"(ح)\")\n// - When signatures are later used in template patterns, ()[] are auto-escaped there\n// We still escape other regex metacharacters to keep signatures safe if reused as templates.\nexport const escapeSignatureLiteral = (s: string): string => s.replace(/[.*+?^${}|\\\\{}]/g, '\\\\$&');\n\n// Keep this intentionally focused on \"useful at line start\" tokens, avoiding overly-generic tokens like {{harf}}.\nexport const TOKEN_PRIORITY_ORDER: string[] = [\n    'basmalah',\n    'kitab',\n    'bab',\n    'fasl',\n    'naql',\n    'rumuz',\n    'numbered',\n    'raqms',\n    'raqm',\n    'dash',\n    'bullet',\n    'tarqim',\n];\n\nexport const buildTokenPriority = (): string[] => {\n    const allTokens = new Set(getAvailableTokens());\n    // IMPORTANT: We only use an explicit allow-list here.\n    // Including \"all remaining tokens\" adds overly-generic tokens (e.g., harf) which makes signatures noisy.\n    return TOKEN_PRIORITY_ORDER.filter((t) => allTokens.has(t));\n};\n\nexport const collapseWhitespace = (s: string): string => s.replace(/\\s+/g, ' ').trim();\n\n// Arabic diacritics / tashkeel marks that commonly appear in Shamela texts.\n// This is intentionally conservative: remove combining marks but keep letters.\n// NOTE: Tatweel (U+0640) is NOT stripped here because it's used semantically as a dash/separator.\nexport const stripArabicDiacritics = (s: string): string =>\n    // harakat + common Quranic marks (no tatweel - it's used as a dash)\n    s.replace(/[\\u064B-\\u065F\\u0670\\u06D6-\\u06ED]/gu, '');\n\nexport type CompiledTokenRegex = { token: string; re: RegExp };\n\nexport const compileTokenRegexes = (tokenNames: string[]): CompiledTokenRegex[] =>\n    tokenNames\n        .map((token) => {\n            const pat = TOKEN_PATTERNS[token];\n            if (!pat) {\n                return null;\n            }\n            try {\n                return { re: new RegExp(pat, 'uy'), token };\n            } catch {\n                return null;\n            }\n        })\n        .filter((x): x is CompiledTokenRegex => x !== null);\n\nexport const appendWs = (out: string, mode: 'regex' | 'space'): string => {\n    if (!out) {\n        return out;\n    }\n    const suffix = mode === 'space' ? ' ' : '\\\\s*';\n    return out.endsWith(suffix) ? out : `${out}${suffix}`;\n};\n\nexport const findBestTokenMatchAt = (\n    s: string,\n    pos: number,\n    compiled: CompiledTokenRegex[],\n    isArabicLetter: (ch: string) => boolean,\n): { token: string; text: string } | null => {\n    let best: { token: string; text: string } | null = null;\n    for (const { token, re } of compiled) {\n        re.lastIndex = pos;\n        const m = re.exec(s);\n        if (!m || m.index !== pos) {\n            continue;\n        }\n        if (!best || m[0].length > best.text.length) {\n            best = { text: m[0], token };\n        }\n    }\n\n    if (best?.token === 'rumuz') {\n        const end = pos + best.text.length;\n        const next = end < s.length ? s[end] : '';\n        if (next && isArabicLetter(next) && !/\\s/u.test(next)) {\n            return null;\n        }\n    }\n\n    return best;\n};\n\n// IMPORTANT: do NOT treat all Arabic-block codepoints as \"letters\" (it includes punctuation like \"،\").\n// We only want to consider actual letters here for the rumuz boundary guard.\nexport const isArabicLetter = (ch: string): boolean => /\\p{Script=Arabic}/u.test(ch) && /\\p{L}/u.test(ch);\nexport const isCommonDelimiter = (ch: string): boolean => /[:：\\-–—ـ،؛.?!؟()[\\]{}]/u.test(ch);\n","// Line-starts analysis module\n\nimport type { Page } from '@/types/index.js';\nimport { normalizeLineEndings } from '@/utils/textUtils.js';\nimport {\n    appendWs,\n    buildTokenPriority,\n    type CompiledTokenRegex,\n    collapseWhitespace,\n    compileTokenRegexes,\n    escapeSignatureLiteral,\n    findBestTokenMatchAt,\n    isArabicLetter,\n    isCommonDelimiter,\n    stripArabicDiacritics,\n} from './shared.js';\n\n// Types\n\nexport type LineStartAnalysisOptions = {\n    topK?: number;\n    prefixChars?: number;\n    minLineLength?: number;\n    minCount?: number;\n    maxExamples?: number;\n    includeFirstWordFallback?: boolean;\n    normalizeArabicDiacritics?: boolean;\n    sortBy?: 'specificity' | 'count';\n    lineFilter?: (line: string, pageId: number) => boolean;\n    prefixMatchers?: RegExp[];\n    whitespace?: 'regex' | 'space';\n};\n\nexport type LineStartPatternExample = { line: string; pageId: number };\n\nexport type CommonLineStartPattern = {\n    pattern: string;\n    count: number;\n    examples: LineStartPatternExample[];\n};\n\n// Options resolution\n\ntype ResolvedOptions = Required<Omit<LineStartAnalysisOptions, 'lineFilter'>> & {\n    lineFilter?: LineStartAnalysisOptions['lineFilter'];\n};\n\nconst resolveOptions = (options: LineStartAnalysisOptions = {}): ResolvedOptions => ({\n    includeFirstWordFallback: options.includeFirstWordFallback ?? true,\n    lineFilter: options.lineFilter,\n    maxExamples: options.maxExamples ?? 1,\n    minCount: options.minCount ?? 3,\n    minLineLength: options.minLineLength ?? 6,\n    normalizeArabicDiacritics: options.normalizeArabicDiacritics ?? true,\n    prefixChars: options.prefixChars ?? 60,\n    prefixMatchers: options.prefixMatchers ?? [/^#+/u],\n    sortBy: options.sortBy ?? 'specificity',\n    topK: options.topK ?? 40,\n    whitespace: options.whitespace ?? 'regex',\n});\n\n// Specificity & sorting\n\nconst countTokenMarkers = (pattern: string): number => (pattern.match(/\\{\\{/g) ?? []).length;\n\nconst computeSpecificity = (pattern: string) => ({\n    literalLen: pattern.replace(/\\\\s\\*/g, '').replace(/[ \\t]+/g, '').length,\n    tokenCount: countTokenMarkers(pattern),\n});\n\nconst compareBySpecificity = (a: CommonLineStartPattern, b: CommonLineStartPattern): number => {\n    const sa = computeSpecificity(a.pattern),\n        sb = computeSpecificity(b.pattern);\n    return (\n        sb.tokenCount - sa.tokenCount ||\n        sb.literalLen - sa.literalLen ||\n        b.count - a.count ||\n        a.pattern.localeCompare(b.pattern)\n    );\n};\n\nconst compareByCount = (a: CommonLineStartPattern, b: CommonLineStartPattern): number =>\n    b.count !== a.count ? b.count - a.count : compareBySpecificity(a, b);\n\n// Signature building helpers\n\n/** Remove trailing whitespace placeholders */\nconst trimTrailingWs = (out: string, mode: 'regex' | 'space'): string => {\n    const suffix = mode === 'regex' ? '\\\\s*' : ' ';\n    while (out.endsWith(suffix)) {\n        out = out.slice(0, -suffix.length);\n    }\n    return out;\n};\n\n/** Try to extract first word for fallback */\nconst extractFirstWord = (s: string): string | null => (s.match(/^[^\\s:،؛.?!؟]+/u) ?? [])[0] ?? null;\n\n/** Consume prefix matchers at current position */\nconst consumePrefixes = (\n    s: string,\n    pos: number,\n    out: string,\n    matchers: RegExp[],\n    ws: 'regex' | 'space',\n): { pos: number; out: string; matched: boolean } => {\n    let matched = false;\n    for (const re of matchers) {\n        if (pos >= s.length) {\n            break;\n        }\n        const m = re.exec(s.slice(pos));\n        if (!m?.index && m?.[0]) {\n            out += escapeSignatureLiteral(m[0]);\n            pos += m[0].length;\n            matched = true;\n            const wsm = /^[ \\t]+/u.exec(s.slice(pos));\n            if (wsm) {\n                pos += wsm[0].length;\n                out = appendWs(out, ws);\n            }\n        }\n    }\n    return { matched, out, pos };\n};\n\n/** Try to match a token at current position and append to signature */\nconst tryMatchToken = (\n    s: string,\n    pos: number,\n    out: string,\n    compiled: CompiledTokenRegex[],\n): { pos: number; out: string; matched: boolean } => {\n    const best = findBestTokenMatchAt(s, pos, compiled, isArabicLetter);\n    if (!best) {\n        return { matched: false, out, pos };\n    }\n    return { matched: true, out: `${out}{{${best.token}}}`, pos: pos + best.text.length };\n};\n\n/** Try to match a delimiter at current position */\nconst tryMatchDelimiter = (s: string, pos: number, out: string): { pos: number; out: string; matched: boolean } => {\n    const ch = s[pos];\n    if (!ch || !isCommonDelimiter(ch)) {\n        return { matched: false, out, pos };\n    }\n    return { matched: true, out: out + escapeSignatureLiteral(ch), pos: pos + 1 };\n};\n\n/** Skip whitespace at position */\nconst skipWhitespace = (\n    s: string,\n    pos: number,\n    out: string,\n    ws: 'regex' | 'space',\n): { pos: number; out: string; skipped: boolean } => {\n    const m = /^[ \\t]+/u.exec(s.slice(pos));\n    if (!m) {\n        return { out, pos, skipped: false };\n    }\n    return { out: appendWs(out, ws), pos: pos + m[0].length, skipped: true };\n};\n\n// Main tokenization\n\nconst tokenizeLineStart = (line: string, tokenNames: string[], opts: ResolvedOptions): string | null => {\n    const trimmed = collapseWhitespace(line);\n    if (!trimmed) {\n        return null;\n    }\n\n    const s = (opts.normalizeArabicDiacritics ? stripArabicDiacritics(trimmed) : trimmed).slice(0, opts.prefixChars);\n    const compiled = compileTokenRegexes(tokenNames);\n\n    let pos = 0,\n        out = '',\n        matchedAny = false,\n        matchedToken = false,\n        steps = 0;\n\n    // Consume prefixes\n    const prefix = consumePrefixes(s, pos, out, opts.prefixMatchers, opts.whitespace);\n    pos = prefix.pos;\n    out = prefix.out;\n    matchedAny = prefix.matched;\n\n    while (steps < 6 && pos < s.length) {\n        // Skip whitespace\n        const ws = skipWhitespace(s, pos, out, opts.whitespace);\n        if (ws.skipped) {\n            pos = ws.pos;\n            out = ws.out;\n            continue;\n        }\n\n        // Try token\n        const tok = tryMatchToken(s, pos, out, compiled);\n        if (tok.matched) {\n            pos = tok.pos;\n            out = tok.out;\n            matchedAny = matchedToken = true;\n            steps++;\n            continue;\n        }\n\n        // Try delimiter (only after matching something)\n        if (matchedAny) {\n            const delim = tryMatchDelimiter(s, pos, out);\n            if (delim.matched) {\n                pos = delim.pos;\n                out = delim.out;\n                continue;\n            }\n        }\n\n        // Fallback logic\n        if (matchedAny) {\n            if (opts.includeFirstWordFallback && !matchedToken) {\n                const word = extractFirstWord(s.slice(pos));\n                if (word) {\n                    out += escapeSignatureLiteral(word);\n                    steps++;\n                }\n            }\n            break;\n        }\n\n        if (!opts.includeFirstWordFallback) {\n            return null;\n        }\n\n        const word = extractFirstWord(s.slice(pos));\n        if (!word) {\n            return null;\n        }\n        return escapeSignatureLiteral(word);\n    }\n\n    return matchedAny ? trimTrailingWs(out, opts.whitespace) : null;\n};\n\n// Page processing\n\ntype PatternAccumulator = Map<string, { count: number; examples: LineStartPatternExample[] }>;\n\nconst processLine = (\n    line: string,\n    pageId: number,\n    tokenPriority: string[],\n    opts: ResolvedOptions,\n    acc: PatternAccumulator,\n): void => {\n    const trimmed = collapseWhitespace(line);\n    if (trimmed.length < opts.minLineLength) {\n        return;\n    }\n    if (opts.lineFilter && !opts.lineFilter(trimmed, pageId)) {\n        return;\n    }\n\n    const sig = tokenizeLineStart(trimmed, tokenPriority, opts);\n    if (!sig) {\n        return;\n    }\n\n    const entry = acc.get(sig);\n    if (!entry) {\n        acc.set(sig, { count: 1, examples: [{ line: trimmed, pageId }] });\n    } else {\n        entry.count++;\n        if (entry.examples.length < opts.maxExamples) {\n            entry.examples.push({ line: trimmed, pageId });\n        }\n    }\n};\n\nconst processPage = (page: Page, tokenPriority: string[], opts: ResolvedOptions, acc: PatternAccumulator): void => {\n    for (const line of normalizeLineEndings(page.content ?? '').split('\\n')) {\n        processLine(line, page.id, tokenPriority, opts, acc);\n    }\n};\n\n// Main export\n\n/**\n * Analyze pages and return the most common line-start patterns (top K).\n */\nexport const analyzeCommonLineStarts = (\n    pages: Page[],\n    options: LineStartAnalysisOptions = {},\n): CommonLineStartPattern[] => {\n    const opts = resolveOptions(options);\n    const tokenPriority = buildTokenPriority();\n    const acc: PatternAccumulator = new Map();\n\n    for (const page of pages) {\n        processPage(page, tokenPriority, opts, acc);\n    }\n\n    const comparator = opts.sortBy === 'count' ? compareByCount : compareBySpecificity;\n\n    return [...acc.entries()]\n        .map(([pattern, v]) => ({ count: v.count, examples: v.examples, pattern }))\n        .filter((p) => p.count >= opts.minCount)\n        .sort(comparator)\n        .slice(0, opts.topK);\n};\n","// Repeating sequences analysis module\n\nimport type { Page } from '@/types/index.js';\nimport {\n    buildTokenPriority,\n    compileTokenRegexes,\n    escapeSignatureLiteral,\n    findBestTokenMatchAt,\n    isArabicLetter,\n    isCommonDelimiter,\n    stripArabicDiacritics,\n} from './shared.js';\n\n// Types\n\nexport type TokenStreamItem = {\n    type: 'token' | 'literal';\n    /** The represented value (e.g. \"{{naql}}\" or \"hello\") */\n    text: string;\n    /** The original raw text (e.g. \"حَدَّثَنَا\") */\n    raw: string;\n    start: number;\n    end: number;\n};\n\nexport type RepeatingSequenceOptions = {\n    minElements?: number;\n    maxElements?: number;\n    minCount?: number;\n    topK?: number;\n    normalizeArabicDiacritics?: boolean;\n    requireToken?: boolean;\n    whitespace?: 'regex' | 'space';\n    maxExamples?: number;\n    contextChars?: number;\n    maxUniquePatterns?: number;\n};\n\nexport type RepeatingSequenceExample = {\n    text: string;\n    context: string;\n    pageId: number;\n    startIndices: number[];\n};\n\nexport type RepeatingSequencePattern = {\n    pattern: string;\n    count: number;\n    examples: RepeatingSequenceExample[];\n};\n\ntype PatternStats = {\n    count: number;\n    examples: RepeatingSequenceExample[];\n    tokenCount: number;\n    literalLen: number;\n};\n\n// Resolved options with defaults\n\ntype ResolvedOptions = Required<RepeatingSequenceOptions>;\n\nconst resolveOptions = (options?: RepeatingSequenceOptions): ResolvedOptions => {\n    const minElements = Math.max(1, options?.minElements ?? 1);\n    return {\n        contextChars: options?.contextChars ?? 50,\n        maxElements: Math.max(minElements, options?.maxElements ?? 3),\n        maxExamples: options?.maxExamples ?? 3,\n        maxUniquePatterns: options?.maxUniquePatterns ?? 1000,\n        minCount: Math.max(1, options?.minCount ?? 3),\n        minElements,\n        normalizeArabicDiacritics: options?.normalizeArabicDiacritics ?? true,\n        requireToken: options?.requireToken ?? true,\n        topK: Math.max(1, options?.topK ?? 20),\n        whitespace: options?.whitespace ?? 'regex',\n    };\n};\n\n// Raw position tracking for diacritic normalization\n\n/** Creates a cursor that tracks position in both normalized and raw text */\nconst createRawCursor = (text: string, normalize: boolean) => {\n    let rawPos = 0;\n\n    return {\n        /** Advance cursor, returning the raw text chunk consumed */\n        advance(normalizedLen: number): string {\n            if (!normalize) {\n                const chunk = text.slice(rawPos, rawPos + normalizedLen);\n                rawPos += normalizedLen;\n                return chunk;\n            }\n\n            const start = rawPos;\n            let matchedLen = 0;\n\n            // Match normalized characters\n            while (matchedLen < normalizedLen && rawPos < text.length) {\n                if (stripArabicDiacritics(text[rawPos]).length > 0) {\n                    matchedLen++;\n                }\n                rawPos++;\n            }\n\n            // Consume trailing diacritics (belong to last character)\n            while (rawPos < text.length && stripArabicDiacritics(text[rawPos]).length === 0) {\n                rawPos++;\n            }\n\n            return text.slice(start, rawPos);\n        },\n        get pos() {\n            return rawPos;\n        },\n    };\n};\n\n// Token content scanner\n\n/** Scans text and produces a stream of tokens and literals. */\nexport const tokenizeContent = (text: string, normalize: boolean): TokenStreamItem[] => {\n    const normalized = normalize ? stripArabicDiacritics(text) : text;\n    const compiled = compileTokenRegexes(buildTokenPriority());\n    const cursor = createRawCursor(text, normalize);\n    const items: TokenStreamItem[] = [];\n    let pos = 0;\n\n    while (pos < normalized.length) {\n        // Skip whitespace\n        const ws = /^\\s+/u.exec(normalized.slice(pos));\n        if (ws) {\n            pos += ws[0].length;\n            cursor.advance(ws[0].length);\n            continue;\n        }\n\n        // Try token\n        const token = findBestTokenMatchAt(normalized, pos, compiled, isArabicLetter);\n        if (token) {\n            const raw = cursor.advance(token.text.length);\n            items.push({\n                end: cursor.pos,\n                raw,\n                start: cursor.pos - raw.length,\n                text: `{{${token.token}}}`,\n                type: 'token',\n            });\n            pos += token.text.length;\n            continue;\n        }\n\n        // Try delimiter\n        if (isCommonDelimiter(normalized[pos])) {\n            const raw = cursor.advance(1);\n            items.push({\n                end: cursor.pos,\n                raw,\n                start: cursor.pos - 1,\n                text: escapeSignatureLiteral(normalized[pos]),\n                type: 'literal',\n            });\n            pos++;\n            continue;\n        }\n\n        // Literal word\n        const word = /^[^\\s:：\\-–—ـ،؛.?!؟()[\\]{}]+/u.exec(normalized.slice(pos));\n        if (word) {\n            const raw = cursor.advance(word[0].length);\n            items.push({\n                end: cursor.pos,\n                raw,\n                start: cursor.pos - raw.length,\n                text: escapeSignatureLiteral(word[0]),\n                type: 'literal',\n            });\n            pos += word[0].length;\n            continue;\n        }\n\n        cursor.advance(1);\n        pos++;\n    }\n\n    return items;\n};\n\n// N-gram pattern extraction\n\n/** Build pattern string from window items */\nconst buildPattern = (window: TokenStreamItem[], whitespace: 'regex' | 'space'): string =>\n    window.map((i) => i.text).join(whitespace === 'space' ? ' ' : '\\\\s*');\n\n/** Check if window contains at least one token */\nconst hasTokenInWindow = (window: TokenStreamItem[]): boolean => window.some((i) => i.type === 'token');\n\n/** Compute token count and literal length for a window */\nconst computeWindowStats = (window: TokenStreamItem[]) => {\n    let tokenCount = 0,\n        literalLen = 0;\n    for (const item of window) {\n        if (item.type === 'token') {\n            tokenCount++;\n        } else {\n            literalLen += item.text.length;\n        }\n    }\n    return { literalLen, tokenCount };\n};\n\n/** Build example from page content and window */\nconst buildExample = (page: Page, window: TokenStreamItem[], contextChars: number): RepeatingSequenceExample => {\n    const start = window[0].start;\n    const end = window.at(-1)!.end;\n    const ctxStart = Math.max(0, start - contextChars);\n    const ctxEnd = Math.min(page.content.length, end + contextChars);\n\n    return {\n        context:\n            (ctxStart > 0 ? '...' : '') +\n            page.content.slice(ctxStart, ctxEnd) +\n            (ctxEnd < page.content.length ? '...' : ''),\n        pageId: page.id,\n        startIndices: window.map((w) => w.start),\n        text: page.content.slice(start, end),\n    };\n};\n\n/** Extract N-grams from a single page */\nconst extractPageNgrams = (\n    page: Page,\n    items: TokenStreamItem[],\n    opts: ResolvedOptions,\n    stats: Map<string, PatternStats>,\n): void => {\n    for (let i = 0; i <= items.length - opts.minElements; i++) {\n        for (let n = opts.minElements; n <= Math.min(opts.maxElements, items.length - i); n++) {\n            const window = items.slice(i, i + n);\n\n            if (opts.requireToken && !hasTokenInWindow(window)) {\n                continue;\n            }\n\n            const pattern = buildPattern(window, opts.whitespace);\n\n            if (!stats.has(pattern)) {\n                if (stats.size >= opts.maxUniquePatterns) {\n                    continue;\n                }\n                stats.set(pattern, { count: 0, examples: [], ...computeWindowStats(window) });\n            }\n\n            const entry = stats.get(pattern)!;\n            entry.count++;\n\n            if (entry.examples.length < opts.maxExamples) {\n                entry.examples.push(buildExample(page, window, opts.contextChars));\n            }\n        }\n    }\n};\n\n// Main export\n\n/**\n * Analyze pages for commonly repeating word sequences.\n *\n * Use for continuous text without line breaks. For line-based analysis,\n * use `analyzeCommonLineStarts()` instead.\n */\nexport const analyzeRepeatingSequences = (\n    pages: Page[],\n    options?: RepeatingSequenceOptions,\n): RepeatingSequencePattern[] => {\n    const opts = resolveOptions(options);\n    const stats = new Map<string, PatternStats>();\n\n    for (const page of pages) {\n        if (!page.content) {\n            continue;\n        }\n        extractPageNgrams(page, tokenizeContent(page.content, opts.normalizeArabicDiacritics), opts, stats);\n    }\n\n    return [...stats.entries()]\n        .filter(([, s]) => s.count >= opts.minCount)\n        .sort(\n            (a, b) => b[1].count - a[1].count || b[1].tokenCount - a[1].tokenCount || b[1].literalLen - a[1].literalLen,\n        )\n        .slice(0, opts.topK)\n        .map(([pattern, s]) => ({ count: s.count, examples: s.examples, pattern }));\n};\n","import { getAvailableTokens, TOKEN_PATTERNS } from './segmentation/tokens.js';\n\n/**\n * Result of detecting a token pattern in text\n */\nexport type DetectedPattern = {\n    /** Token name from TOKEN_PATTERNS (e.g., 'raqms', 'dash') */\n    token: string;\n    /** The matched text */\n    match: string;\n    /** Start index in the original text */\n    index: number;\n    /** End index (exclusive) */\n    endIndex: number;\n};\n\n/**\n * Token detection order - more specific patterns first to avoid partial matches.\n * Example: 'raqms' before 'raqm' so \"٣٤\" matches 'raqms' not just the first digit.\n *\n * Tokens not in this list are appended in alphabetical order from TOKEN_PATTERNS.\n */\nconst TOKEN_PRIORITY_ORDER = [\n    'basmalah', // Most specific - full phrase\n    'kitab',\n    'bab',\n    'fasl',\n    'naql',\n    'rumuz', // Source abbreviations (e.g., \"خت\", \"خ سي\", \"٤\")\n    'numbered', // Composite: raqms + dash\n    'raqms', // Multiple digits before single digit\n    'raqm',\n    'tarqim',\n    'bullet',\n    'dash',\n    'harf',\n];\n\n/**\n * Gets the token detection priority order.\n * Returns tokens in priority order, with any TOKEN_PATTERNS not in the priority list appended.\n */\nconst getTokenPriority = () => {\n    const allTokens = getAvailableTokens();\n    const prioritized = TOKEN_PRIORITY_ORDER.filter((t) => allTokens.includes(t));\n    const remaining = allTokens.filter((t) => !TOKEN_PRIORITY_ORDER.includes(t)).sort();\n    return [...prioritized, ...remaining];\n};\n\nconst isRumuzStandalone = (text: string, startIndex: number, endIndex: number): boolean => {\n    // We want rumuz to behave like a standalone marker (e.g. \"س:\" or \"خت ٤:\"),\n    // not a substring match inside normal Arabic words (e.g. \"إِبْرَاهِيم\").\n    const before = startIndex > 0 ? text[startIndex - 1] : '';\n    const after = endIndex < text.length ? text[endIndex] : '';\n\n    const isWhitespace = (ch: string): boolean => !!ch && /\\s/u.test(ch);\n    const isOpenBracket = (ch: string): boolean => !!ch && /[([{]/u.test(ch);\n    const isRightDelimiter = (ch: string): boolean => !!ch && /[:：\\-–—ـ،؛.?!؟)\\]}]/u.test(ch);\n\n    // Treat any Arabic-block codepoint (letters + diacritics + digits) as \"wordy\" context.\n    // Unicode Script properties can classify some combining marks as \"Inherited\", so we avoid \\p{Script=Arabic}.\n    const isArabicWordy = (ch: string): boolean => !!ch && /[\\u0600-\\u06FF]/u.test(ch);\n\n    const leftOk = !before || isWhitespace(before) || isOpenBracket(before) || !isArabicWordy(before);\n    const rightOk = !after || isWhitespace(after) || isRightDelimiter(after) || !isArabicWordy(after);\n\n    return leftOk && rightOk;\n};\n\n/**\n * Analyzes text and returns all detected token patterns with their positions.\n * Patterns are detected in priority order to avoid partial matches.\n *\n * @param text - The text to analyze for token patterns\n * @returns Array of detected patterns sorted by position\n *\n * @example\n * detectTokenPatterns(\"٣٤ - حدثنا\")\n * // Returns: [\n * //   { token: 'raqms', match: '٣٤', index: 0, endIndex: 2 },\n * //   { token: 'dash', match: '-', index: 3, endIndex: 4 },\n * //   { token: 'naql', match: 'حدثنا', index: 5, endIndex: 10 }\n * // ]\n */\nexport const detectTokenPatterns = (text: string) => {\n    if (!text) {\n        return [];\n    }\n\n    const results: DetectedPattern[] = [];\n    const coveredRanges: Array<[number, number]> = [];\n\n    // Check if a position is already covered by a detected pattern\n    const isPositionCovered = (start: number, end: number): boolean => {\n        return coveredRanges.some(\n            ([s, e]) => (start >= s && start < e) || (end > s && end <= e) || (start <= s && end >= e),\n        );\n    };\n\n    // Process tokens in priority order\n    for (const tokenName of getTokenPriority()) {\n        const pattern = TOKEN_PATTERNS[tokenName];\n        if (!pattern) {\n            continue;\n        }\n\n        try {\n            // Create a global regex to find all matches\n            const regex = new RegExp(`(${pattern})`, 'gu');\n            let match: RegExpExecArray | null;\n\n            // biome-ignore lint/suspicious/noAssignInExpressions: standard regex exec loop pattern\n            while ((match = regex.exec(text)) !== null) {\n                const startIndex = match.index;\n                const endIndex = startIndex + match[0].length;\n\n                if (tokenName === 'rumuz' && !isRumuzStandalone(text, startIndex, endIndex)) {\n                    continue;\n                }\n\n                // Skip if this range overlaps with an already detected pattern\n                if (isPositionCovered(startIndex, endIndex)) {\n                    continue;\n                }\n\n                results.push({ endIndex, index: startIndex, match: match[0], token: tokenName });\n\n                coveredRanges.push([startIndex, endIndex]);\n            }\n        } catch {}\n    }\n\n    return results.sort((a, b) => a.index - b.index);\n};\n\n/**\n * Generates a template pattern from text using detected tokens.\n * Replaces matched portions with {{token}} syntax.\n *\n * @param text - Original text\n * @param detected - Array of detected patterns from detectTokenPatterns\n * @returns Template string with tokens, e.g., \"{{raqms}} {{dash}} \"\n *\n * @example\n * const detected = detectTokenPatterns(\"٣٤ - \");\n * generateTemplateFromText(\"٣٤ - \", detected);\n * // Returns: \"{{raqms}} {{dash}} \"\n */\nexport const generateTemplateFromText = (text: string, detected: DetectedPattern[]) => {\n    if (!text || detected.length === 0) {\n        return text;\n    }\n\n    // Build template by replacing detected patterns with tokens\n    // Process in reverse order to preserve indices\n    let template = text;\n    const sortedByIndexDesc = [...detected].sort((a, b) => b.index - a.index);\n\n    for (const d of sortedByIndexDesc) {\n        template = `${template.slice(0, d.index)}{{${d.token}}}${template.slice(d.endIndex)}`;\n    }\n\n    return template;\n};\n\n/**\n * Determines the best pattern type for auto-generated rules based on detected patterns.\n *\n * @param detected - Array of detected patterns\n * @returns Suggested pattern type and whether to use fuzzy matching\n */\nexport const suggestPatternConfig = (\n    detected: DetectedPattern[],\n): { patternType: 'lineStartsWith' | 'lineStartsAfter'; fuzzy: boolean; metaType?: string } => {\n    // Check if the detected patterns suggest a structural marker (chapter, book, etc.)\n    const hasStructuralToken = detected.some((d) => ['basmalah', 'kitab', 'bab', 'fasl'].includes(d.token));\n\n    // Check if the pattern is numbered (hadith-style)\n    const hasNumberedPattern = detected.some((d) => ['raqms', 'raqm', 'numbered'].includes(d.token));\n\n    // If it starts with a structural token, use lineStartsWith (keep marker in content)\n    if (hasStructuralToken) {\n        return {\n            fuzzy: true,\n            metaType: detected.find((d) => ['kitab', 'bab', 'fasl'].includes(d.token))?.token || 'chapter',\n            patternType: 'lineStartsWith',\n        };\n    }\n\n    // If it's a numbered pattern (like hadith numbers), use lineStartsAfter (strip prefix)\n    if (hasNumberedPattern) {\n        return { fuzzy: false, metaType: 'hadith', patternType: 'lineStartsAfter' };\n    }\n\n    // Default: use lineStartsAfter without fuzzy\n    return { fuzzy: false, patternType: 'lineStartsAfter' };\n};\n\n/**\n * Analyzes text and generates a complete suggested rule configuration.\n *\n * @param text - Highlighted text from the page\n * @returns Suggested rule configuration or null if no patterns detected\n */\nexport const analyzeTextForRule = (\n    text: string,\n): {\n    template: string;\n    patternType: 'lineStartsWith' | 'lineStartsAfter';\n    fuzzy: boolean;\n    metaType?: string;\n    detected: DetectedPattern[];\n} | null => {\n    const detected = detectTokenPatterns(text);\n\n    if (detected.length === 0) {\n        return null;\n    }\n\n    const template = generateTemplateFromText(text, detected);\n    const config = suggestPatternConfig(detected);\n\n    return { detected, template, ...config };\n};\n","import type { PageRange } from './index.js';\n\n/**\n * Literal regex pattern rule - no token expansion or auto-escaping is applied.\n *\n * Use this when you need full control over the regex pattern, including:\n * - Character classes like `[أب]` to match أ or ب\n * - Capturing groups like `(test|text)` for alternation\n * - Any other regex syntax that would be escaped in template patterns\n *\n * If the regex contains capturing groups, the captured content\n * will be used as the segment content.\n *\n * **Note**: Unlike `template`, `lineStartsWith`, etc., this pattern type\n * does NOT auto-escape `()[]`. You have full regex control.\n *\n * @example\n * // Match Arabic-Indic numbers followed by a dash\n * { regex: '^[٠-٩]+ - ', split: 'at' }\n *\n * @example\n * // Character class - matches أ or ب\n * { regex: '^[أب] ', split: 'at' }\n *\n * @example\n * // Capture group - content after the marker becomes segment content\n * { regex: '^[٠-٩]+ - (.*)', split: 'at' }\n */\ntype RegexPattern = {\n    /** Raw regex pattern string (no token expansion, no auto-escaping) */\n    regex: string;\n};\n\n/**\n * Template pattern rule - expands `{{tokens}}` before compiling to regex.\n *\n * Supports all tokens defined in `TOKEN_PATTERNS` and named capture syntax.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. Write `({{harf}}):` instead of\n * `\\\\({{harf}}\\\\):`. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Using tokens for Arabic-Indic digits\n * { template: '^{{raqms}} {{dash}}', split: 'at' }\n *\n * @example\n * // Named capture to extract hadith number into metadata\n * { template: '^{{raqms:hadithNum}} {{dash}}', split: 'at' }\n *\n * @example\n * // Auto-escaped brackets - matches literal (أ):\n * { template: '^({{harf}}): ', split: 'at' }\n *\n * @see TOKEN_PATTERNS for available tokens\n */\ntype TemplatePattern = {\n    /** Template string with `{{token}}` or `{{token:name}}` placeholders. Brackets `()[]` are auto-escaped. */\n    template: string;\n};\n\n/**\n * Line-start pattern rule - matches lines starting with any of the given patterns.\n *\n * Syntactic sugar for `^(?:pattern1|pattern2|...)`. The matched marker\n * is **included** in the segment content.\n *\n * Token expansion is applied to each pattern. Use `fuzzy: true` for\n * diacritic-insensitive Arabic matching.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. Write `({{harf}})` instead of\n * `\\\\({{harf}}\\\\)`. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Split at chapter headings (marker included in content)\n * { lineStartsWith: ['## ', '### '], split: 'at' }\n *\n * @example\n * // Split at Arabic book/chapter markers with fuzzy matching\n * { lineStartsWith: ['{{kitab}}', '{{bab}}'], split: 'at', fuzzy: true }\n *\n * @example\n * // Auto-escaped brackets - matches literal (أ)\n * { lineStartsWith: ['({{harf}}) '], split: 'at' }\n */\ntype LineStartsWithPattern = {\n    /** Array of patterns that mark line beginnings (marker included in content). Brackets `()[]` are auto-escaped. */\n    lineStartsWith: string[];\n};\n\n/**\n * Line-start-after pattern rule - matches lines starting with patterns,\n * but **excludes** the marker from the segment content.\n *\n * Behaves like `lineStartsWith` but strips the marker from the output.\n * The segment content starts after the marker and extends to the next split point\n * (not just the end of the matching line).\n *\n * Token expansion is applied to each pattern. Use `fuzzy: true` for\n * diacritic-insensitive Arabic matching.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. Write `({{harf}}):` instead of\n * `\\\\({{harf}}\\\\):`. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Split at numbered hadiths, capturing content without the number prefix\n * // Content extends to next split, not just end of that line\n * { lineStartsAfter: ['{{raqms}} {{dash}} '], split: 'at' }\n *\n * @example\n * // Extract hadith number to metadata while stripping the prefix\n * { lineStartsAfter: ['{{raqms:num}} {{dash}} '], split: 'at' }\n *\n * @example\n * // Auto-escaped brackets - matches literal (أ): prefix\n * { lineStartsAfter: ['({{harf}}): '], split: 'at' }\n */\ntype LineStartsAfterPattern = {\n    /** Array of patterns that mark line beginnings (marker excluded from content). Brackets `()[]` are auto-escaped. */\n    lineStartsAfter: string[];\n};\n\n/**\n * Line-end pattern rule - matches lines ending with any of the given patterns.\n *\n * Syntactic sugar for `(?:pattern1|pattern2|...)$`.\n *\n * Token expansion is applied to each pattern. Use `fuzzy: true` for\n * diacritic-insensitive Arabic matching.\n *\n * **Auto-escaping**: Parentheses `()` and square brackets `[]` outside of\n * `{{tokens}}` are automatically escaped. For raw regex control, use `regex` pattern type.\n *\n * @example\n * // Split at lines ending with Arabic sentence-ending punctuation\n * { lineEndsWith: ['۔', '؟', '!'], split: 'after' }\n *\n * @example\n * // Auto-escaped brackets - matches literal (انتهى) suffix\n * { lineEndsWith: ['(انتهى)'], split: 'after' }\n */\ntype LineEndsWithPattern = {\n    /** Array of patterns that mark line endings. Brackets `()[]` are auto-escaped. */\n    lineEndsWith: string[];\n};\n\n/**\n * Union of all pattern types for split rules.\n *\n * Each rule must have exactly ONE pattern type:\n * - `regex` - Raw regex pattern (no token expansion)\n * - `template` - Pattern with `{{token}}` expansion\n * - `lineStartsWith` - Match line beginnings (marker included)\n * - `lineStartsAfter` - Match line beginnings (marker excluded)\n * - `lineEndsWith` - Match line endings\n */\ntype PatternType =\n    | RegexPattern\n    | TemplatePattern\n    | LineStartsWithPattern\n    | LineStartsAfterPattern\n    | LineEndsWithPattern;\n\n/**\n * Pattern type key names for split rules.\n *\n * Use this array to dynamically iterate over pattern types in UIs,\n * or use the `PatternTypeKey` type for type-safe string unions.\n *\n * @example\n * // Build a dropdown/select in UI\n * PATTERN_TYPE_KEYS.map(key => <option value={key}>{key}</option>)\n *\n * @example\n * // Type-safe pattern key validation\n * const validateKey = (k: string): k is PatternTypeKey =>\n *   (PATTERN_TYPE_KEYS as readonly string[]).includes(k);\n */\nexport const PATTERN_TYPE_KEYS = ['lineStartsWith', 'lineStartsAfter', 'lineEndsWith', 'template', 'regex'] as const;\n\n/**\n * String union of pattern type key names.\n *\n * Derived from `PATTERN_TYPE_KEYS` to stay in sync automatically.\n */\nexport type PatternTypeKey = (typeof PATTERN_TYPE_KEYS)[number];\n\n// Split Behavior\n\n/**\n * Configuration for how and where to split content when a pattern matches.\n *\n * Controls the split position relative to matches, which occurrences to\n * split on, page span limits, and fuzzy matching for Arabic text.\n */\ntype SplitBehavior = {\n    /**\n     * Where to split relative to the match.\n     * - `'at'`: New segment starts at the match position\n     * - `'after'`: New segment starts after the match ends\n     * @default 'at'\n     */\n    split?: 'at' | 'after';\n\n    /**\n     * Which occurrence(s) to split on.\n     * - `'all'`: Split at every match (default)\n     * - `'first'`: Only split at the first match\n     * - `'last'`: Only split at the last match\n     *\n     * @default 'all'\n     */\n    occurrence?: 'first' | 'last' | 'all';\n\n    /**\n     * Enable diacritic-insensitive matching for Arabic text.\n     *\n     * When `true`, patterns in `lineStartsWith`, `lineEndsWith`, and\n     * `lineStartsAfter` are transformed to match text regardless of:\n     * - Diacritics (harakat/tashkeel): فَتْحَة، ضَمَّة، كَسْرَة، etc.\n     * - Character equivalences: ا/آ/أ/إ, ة/ه, ى/ي\n     *\n     * **Note**: Does NOT apply to `regex` or `template` patterns.\n     * For templates, apply fuzzy manually using `makeDiacriticInsensitive()`.\n     *\n     * @default false\n     */\n    fuzzy?: boolean;\n};\n\n/**\n * Optional constraints and metadata for a split rule.\n *\n * Use constraints to limit which pages a rule applies to, and\n * metadata to attach arbitrary data to resulting segments.\n */\ntype RuleConstraints = {\n    /**\n     * Minimum page ID for this rule to apply.\n     *\n     * Matches on pages with `id < min` are ignored.\n     *\n     * @example\n     * // Only apply rule starting from page 10\n     * { min: 10, lineStartsWith: ['##'], split: 'before' }\n     */\n    min?: number;\n\n    /**\n     * Maximum page ID for this rule to apply.\n     *\n     * Matches on pages with `id > max` are ignored.\n     *\n     * @example\n     * // Only apply rule up to page 100\n     * { max: 100, lineStartsWith: ['##'], split: 'before' }\n     */\n    max?: number;\n\n    /**\n     * Specific pages or page ranges to exclude from this rule.\n     *\n     * Use this to skip the rule for specific pages without needing\n     * to repeat the rule with different min/max values.\n     *\n     * @example\n     * // Exclude specific pages\n     * { exclude: [1, 2, 5] }\n     *\n     * @example\n     * // Exclude page ranges\n     * { exclude: [[1, 10], [50, 100]] }\n     *\n     * @example\n     * // Mix single pages and ranges\n     * { exclude: [1, [5, 10], 50] }\n     */\n    exclude?: PageRange[];\n\n    /**\n     * Arbitrary metadata attached to segments matching this rule.\n     *\n     * This metadata is merged with any named captures from the pattern.\n     * Named captures (e.g., `{{raqms:num}}`) take precedence over\n     * static metadata with the same key.\n     *\n     * @example\n     * // Tag segments as chapters\n     * { lineStartsWith: ['{{bab}}'], split: 'before', meta: { type: 'chapter' } }\n     */\n    meta?: Record<string, unknown>;\n\n    /**\n     * Page-start guard: only allow this rule to match at the START of a page if the\n     * previous page's last non-whitespace character matches this pattern.\n     *\n     * This is useful for avoiding false positives caused purely by page wrap.\n     *\n     * Example use-case:\n     * - Split on `{{naql}}` at line starts (e.g. \"أخبرنا ...\")\n     * - BUT if a new page starts with \"أخبرنا ...\" and the previous page did NOT\n     *   end with sentence-ending punctuation, treat it as a continuation and do not split.\n     *\n     * Notes:\n     * - This guard applies ONLY at page starts, not mid-page line starts.\n     * - This is a template pattern (tokens allowed). It is checked against the LAST\n     *   non-whitespace character of the previous page's content.\n     *\n     * @example\n     * // Allow split at page start only if previous page ends with sentence punctuation\n     * { lineStartsWith: ['{{naql}}'], fuzzy: true, pageStartGuard: '{{tarqim}}' }\n     */\n    pageStartGuard?: string;\n};\n\n// Combined Rule Type\n\n/**\n * A complete split rule combining pattern, behavior, and constraints.\n *\n * Each rule must specify:\n * - **Pattern** (exactly one): `regex`, `template`, `lineStartsWith`,\n *   `lineStartsAfter`, or `lineEndsWith`\n * - **Split behavior**: `split` (optional, defaults to `'at'`), `occurrence`, `fuzzy`\n * - **Constraints** (optional): `min`, `max`, `meta`\n *\n * @example\n * // Basic rule: split at markdown headers (split defaults to 'at')\n * const rule: SplitRule = {\n *   lineStartsWith: ['## ', '### '],\n *   meta: { type: 'section' }\n * };\n *\n * @example\n * // Advanced rule: extract hadith numbers with fuzzy Arabic matching\n * const rule: SplitRule = {\n *   lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '],\n *   fuzzy: true,\n *   min: 5,\n *   max: 500,\n *   meta: { type: 'hadith' }\n * };\n */\nexport type SplitRule = PatternType & SplitBehavior & RuleConstraints;\n","import { PATTERN_TYPE_KEYS, type PatternTypeKey, type SplitRule } from '@/types/rules';\n\n// Keys that support array patterns and can be merged\nconst MERGEABLE_KEYS = new Set<PatternTypeKey>(['lineStartsWith', 'lineStartsAfter', 'lineEndsWith']);\n\n/**\n * Result from optimizing rules.\n */\nexport type OptimizeResult = {\n    /** Optimized rules (merged and sorted by specificity) */\n    rules: SplitRule[];\n    /** Number of rules that were merged into existing rules */\n    mergedCount: number;\n};\n\n/**\n * Get the pattern type key for a rule.\n */\nconst getPatternKey = (rule: SplitRule) => PATTERN_TYPE_KEYS.find((key) => key in rule) ?? 'regex';\n\nconst getPatternArray = (rule: SplitRule, key: PatternTypeKey) => {\n    const value = (rule as Record<string, unknown>)[key];\n    return Array.isArray(value) ? (value as string[]) : [];\n};\n\nconst getPatternString = (rule: SplitRule, key: PatternTypeKey) => {\n    const value = (rule as Record<string, unknown>)[key];\n    return typeof value === 'string' ? value : Array.isArray(value) ? value.join('\\n') : '';\n};\n\nconst normalizePatterns = (patterns: string[]) =>\n    [...new Set(patterns)].sort((a, b) => b.length - a.length || a.localeCompare(b));\n\nconst getSpecificityScore = (rule: SplitRule) => {\n    const key = getPatternKey(rule);\n    return MERGEABLE_KEYS.has(key)\n        ? getPatternArray(rule, key).reduce((max, p) => Math.max(max, p.length), 0)\n        : getPatternString(rule, key).length;\n};\n\nconst createMergeKey = (rule: SplitRule) => {\n    const key = getPatternKey(rule);\n    const { [key]: _, ...rest } = rule as any;\n    return `${key}|${JSON.stringify(rest)}`;\n};\n\nexport const optimizeRules = (rules: SplitRule[]) => {\n    const output: SplitRule[] = [];\n    const indexByMergeKey = new Map<string, number>();\n    let mergedCount = 0;\n\n    for (const rule of rules) {\n        const key = getPatternKey(rule);\n        if (!MERGEABLE_KEYS.has(key)) {\n            output.push(rule);\n            continue;\n        }\n\n        const mergeKey = createMergeKey(rule);\n        const existingIndex = indexByMergeKey.get(mergeKey);\n\n        if (existingIndex === undefined) {\n            indexByMergeKey.set(mergeKey, output.length);\n            output.push({ ...rule, [key]: normalizePatterns(getPatternArray(rule, key)) } as SplitRule);\n        } else {\n            const existing = output[existingIndex] as any;\n            existing[key] = normalizePatterns([...getPatternArray(existing, key), ...getPatternArray(rule, key)]);\n            mergedCount++;\n        }\n    }\n\n    return { mergedCount, rules: output.sort((a, b) => getSpecificityScore(b) - getSpecificityScore(a)) };\n};\n","/**\n * Split rule → compiled regex builder.\n *\n * Extracted from `segmenter.ts` to reduce cognitive complexity and enable\n * independent unit testing of regex compilation and token expansion behavior.\n */\n\nimport type { SplitRule } from '@/types/rules.js';\nimport { escapeTemplateBrackets, makeDiacriticInsensitive } from '@/utils/textUtils.js';\nimport { expandTokensWithCaptures, shouldDefaultToFuzzy } from './tokens.js';\n\n/**\n * Result of processing a pattern with token expansion and optional fuzzy matching.\n */\nexport type ProcessedPattern = {\n    /** The expanded regex pattern string (tokens replaced with regex) */\n    pattern: string;\n    /** Names of captured groups extracted from `{{token:name}}` syntax */\n    captureNames: string[];\n};\n\n/**\n * Compiled regex and metadata for a split rule.\n */\nexport type RuleRegex = {\n    /** Compiled RegExp with 'gmu' flags (global, multiline, unicode) */\n    regex: RegExp;\n    /** Whether the regex uses capturing groups for content extraction */\n    usesCapture: boolean;\n    /** Names of captured groups from `{{token:name}}` syntax */\n    captureNames: string[];\n    /** Whether this rule uses `lineStartsAfter` (content capture at end) */\n    usesLineStartsAfter: boolean;\n};\n\n/**\n * Checks if a regex pattern contains standard (anonymous) capturing groups.\n *\n * Detects standard capturing groups `(...)` while excluding:\n * - Non-capturing groups `(?:...)`\n * - Lookahead assertions `(?=...)` and `(?!...)`\n * - Lookbehind assertions `(?<=...)` and `(?<!...)`\n * - Named groups `(?<name>...)` (start with `(?` so excluded here)\n *\n * NOTE: Named capture groups are still captures, but they're tracked via `captureNames`.\n */\nexport const hasCapturingGroup = (pattern: string) => /\\((?!\\?)/.test(pattern);\n\n/**\n * Extracts named capture group names from a regex pattern.\n *\n * Parses patterns like `(?<num>[0-9]+)` and returns `['num']`.\n *\n * @example\n * extractNamedCaptureNames('^(?<num>[٠-٩]+)\\\\s+') // ['num']\n * extractNamedCaptureNames('^(?<a>\\\\d+)(?<b>\\\\w+)') // ['a', 'b']\n * extractNamedCaptureNames('^\\\\d+') // []\n */\nexport const extractNamedCaptureNames = (pattern: string) => [...pattern.matchAll(/\\(\\?<([^>]+)>/g)].map((m) => m[1]);\n\n/**\n * Safely compiles a regex pattern, throwing a helpful error if invalid.\n */\nexport const compileRuleRegex = (pattern: string) => {\n    try {\n        return new RegExp(pattern, 'gmu');\n    } catch (error) {\n        throw new Error(\n            `Invalid regex pattern: ${pattern}\\n  Cause: ${error instanceof Error ? error.message : String(error)}`,\n        );\n    }\n};\n\n/**\n * Processes a pattern string by expanding tokens and optionally applying fuzzy matching.\n *\n * Brackets `()[]` outside `{{tokens}}` are auto-escaped.\n */\nexport const processPattern = (pattern: string, fuzzy: boolean, capturePrefix?: string) => {\n    const { pattern: expanded, captureNames } = expandTokensWithCaptures(\n        escapeTemplateBrackets(pattern),\n        fuzzy ? makeDiacriticInsensitive : undefined,\n        capturePrefix,\n    );\n    return { captureNames, pattern: expanded };\n};\n\n/**\n * Processes a breakpoint pattern by expanding tokens only.\n *\n * Unlike `processPattern`, this does NOT escape brackets because breakpoints\n * are treated as raw regex patterns (like the `regex` rule type).\n * Users have full control over regex syntax including `(?:...)` groups.\n */\nexport const processBreakpointPattern = (pattern: string) => {\n    const { pattern: expanded } = expandTokensWithCaptures(pattern);\n    return expanded;\n};\n\nexport const buildLineStartsAfterRegexSource = (patterns: string[], fuzzy: boolean, capturePrefix?: string) => {\n    const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));\n    return {\n        captureNames: processed.flatMap((p) => p.captureNames),\n        regex: `^[\\\\u200E\\\\u200F\\\\u061C\\\\u200B\\\\u200C\\\\u200D\\\\uFEFF]*(?:${processed.map((p) => p.pattern).join('|')})${capturePrefix ? `(?<${capturePrefix}__content>.*)` : '(.*)'}`,\n    };\n};\n\nexport const buildLineStartsWithRegexSource = (patterns: string[], fuzzy: boolean, capturePrefix?: string) => {\n    const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));\n    return {\n        captureNames: processed.flatMap((p) => p.captureNames),\n        regex: `^[\\\\u200E\\\\u200F\\\\u061C\\\\u200B\\\\u200C\\\\u200D\\\\uFEFF]*(?:${processed.map((p) => p.pattern).join('|')})`,\n    };\n};\n\nexport const buildLineEndsWithRegexSource = (patterns: string[], fuzzy: boolean, capturePrefix?: string) => {\n    const processed = patterns.map((p) => processPattern(p, fuzzy, capturePrefix));\n    return {\n        captureNames: processed.flatMap((p) => p.captureNames),\n        regex: `(?:${processed.map((p) => p.pattern).join('|')})$`,\n    };\n};\n\nexport const buildTemplateRegexSource = (template: string, capturePrefix?: string) => {\n    const { pattern, captureNames } = expandTokensWithCaptures(\n        escapeTemplateBrackets(template),\n        undefined,\n        capturePrefix,\n    );\n    return { captureNames, regex: pattern };\n};\n\n/**\n * Builds a compiled regex and metadata from a split rule.\n *\n * Behavior mirrors the previous implementation in `segmenter.ts`.\n */\nexport const buildRuleRegex = (rule: SplitRule, capturePrefix?: string) => {\n    const { lineStartsWith, lineStartsAfter, lineEndsWith, template, regex } = rule as any;\n    const fuzzy =\n        (rule as { fuzzy?: boolean }).fuzzy ??\n        shouldDefaultToFuzzy([...(lineStartsWith ?? []), ...(lineStartsAfter ?? []), ...(lineEndsWith ?? [])]);\n\n    if (lineStartsAfter?.length) {\n        const { regex: lsaRegex, captureNames } = buildLineStartsAfterRegexSource(\n            lineStartsAfter,\n            fuzzy,\n            capturePrefix,\n        );\n        return { captureNames, regex: compileRuleRegex(lsaRegex), usesCapture: true, usesLineStartsAfter: true };\n    }\n\n    let finalRegex = regex;\n    let allCaptureNames: string[] = [];\n\n    if (lineStartsWith?.length) {\n        const res = buildLineStartsWithRegexSource(lineStartsWith, fuzzy, capturePrefix);\n        finalRegex = res.regex;\n        allCaptureNames = res.captureNames;\n    }\n    if (lineEndsWith?.length) {\n        const res = buildLineEndsWithRegexSource(lineEndsWith, fuzzy, capturePrefix);\n        finalRegex = res.regex;\n        allCaptureNames = res.captureNames;\n    }\n    if (template) {\n        const res = buildTemplateRegexSource(template, capturePrefix);\n        finalRegex = res.regex;\n        allCaptureNames = [...allCaptureNames, ...res.captureNames];\n    }\n\n    if (!finalRegex) {\n        throw new Error(\n            'Rule must specify exactly one pattern type: regex, template, lineStartsWith, lineStartsAfter, or lineEndsWith',\n        );\n    }\n    if (allCaptureNames.length === 0) {\n        allCaptureNames = extractNamedCaptureNames(finalRegex);\n    }\n\n    return {\n        captureNames: allCaptureNames,\n        regex: compileRuleRegex(finalRegex),\n        usesCapture: hasCapturingGroup(finalRegex),\n        usesLineStartsAfter: false,\n    };\n};\n","/**\n * Shared constants for segmentation breakpoint processing.\n */\n\n/**\n * Threshold for using offset-based fast path in boundary processing.\n *\n * Below this: accurate string-search (handles offset drift from structural rules).\n * At or above this: O(n) arithmetic (performance critical for large books).\n *\n * The value of 1000 is chosen based on typical Arabic book sizes:\n * - Sahih al-Bukhari: ~1000-3000 pages\n * - Standard hadith collections: 1000-7000 pages\n * - Large aggregated corpora: 10k-50k pages\n *\n * For segments ≥1000 pages, the performance gain from offset-based slicing\n * outweighs the minor accuracy loss from potential offset drift.\n *\n * @remarks\n * Fast path is skipped when:\n * - `maxContentLength` is set (requires character-accurate splitting)\n * - `debugMetaKey` is set (requires proper provenance tracking)\n * - Content was structurally modified by marker stripping (offsets may drift)\n */\nexport const FAST_PATH_THRESHOLD = 1000;\n\nexport const WINDOW_PREFIX_LENGTHS = [80, 60, 40, 30, 20, 15] as const;\n\n// For page-join normalization we need to handle cases where only the very beginning of the next page\n// is present in the current segment (e.g. the segment ends right before the next structural marker).\n// That can be as short as a few words, so we allow shorter prefixes here.\nexport const JOINER_PREFIX_LENGTHS = [80, 60, 40, 30, 20, 15, 12, 10, 8, 6] as const;\n\n// Includes Arabic comma (،), semicolon (؛), full stop (.), etc.\nexport const STOP_CHARACTERS = /[\\s\\n.,;!?؛،۔]/;\n","import type { Breakpoint, BreakpointRule } from '@/types/breakpoints.js';\nimport type { PageRange, Segment } from '@/types/index.js';\nimport type { Logger } from '@/types/options.js';\nimport { adjustForUnicodeBoundary } from '@/utils/textUtils.js';\nimport {\n    FAST_PATH_THRESHOLD,\n    JOINER_PREFIX_LENGTHS,\n    STOP_CHARACTERS,\n    WINDOW_PREFIX_LENGTHS,\n} from './breakpoint-constants.js';\n\n/**\n * Normalizes a breakpoint to the object form.\n * Strings are converted to { pattern: str, split: 'after' } with no constraints.\n * Invalid `split` values are treated as `'after'` for backward compatibility.\n * If both `pattern` and `regex` are specified, `regex` takes precedence.\n *\n * @param bp - Breakpoint as string or object\n * @returns Normalized BreakpointRule object with resolved pattern/regex\n *\n * @example\n * normalizeBreakpoint('\\\\n\\\\n')\n * // → { pattern: '\\\\n\\\\n', split: 'after' }\n *\n * normalizeBreakpoint({ pattern: '\\\\n', min: 10 })\n * // → { pattern: '\\\\n', min: 10, split: 'after' }\n *\n * normalizeBreakpoint({ pattern: 'X', split: 'at' })\n * // → { pattern: 'X', split: 'at' }\n *\n * normalizeBreakpoint({ regex: '(?:X|Y)', split: 'at' })\n * // → { regex: '(?:X|Y)', split: 'at' }\n */\nexport const normalizeBreakpoint = (bp: Breakpoint): BreakpointRule => {\n    if (typeof bp === 'string') {\n        return { pattern: bp, split: 'after' };\n    }\n    // Validate split value - treat invalid as 'after' for backward compatibility\n    const split = bp.split === 'at' || bp.split === 'after' ? bp.split : 'after';\n    return { ...bp, split };\n};\n\n/**\n * Checks if a page ID is in an excluded list (single pages or ranges).\n *\n * @param pageId - Page ID to check\n * @param excludeList - List of page IDs or [from, to] ranges to exclude\n * @returns True if page is excluded\n *\n * @example\n * isPageExcluded(5, [1, 5, 10])\n * // → true\n *\n * isPageExcluded(5, [[3, 7]])\n * // → true\n *\n * isPageExcluded(5, [[10, 20]])\n * // → false\n */\nexport const isPageExcluded = (pageId: number, excludeList: PageRange[] | undefined) =>\n    excludeList?.some((item) =>\n        typeof item === 'number' ? pageId === item : pageId >= item[0] && pageId <= item[1],\n    ) ?? false;\n\n/**\n * Checks if a page ID is within a breakpoint's min/max range and not excluded.\n *\n * @param pageId - Page ID to check\n * @param rule - Breakpoint rule with optional min/max/exclude constraints\n * @returns True if page is within valid range\n *\n * @example\n * isInBreakpointRange(50, { pattern: '\\\\n', min: 10, max: 100 })\n * // → true\n *\n * isInBreakpointRange(5, { pattern: '\\\\n', min: 10 })\n * // → false (below min)\n */\nexport const isInBreakpointRange = (pageId: number, rule: BreakpointRule) => {\n    const { min, max, exclude } = rule;\n    return (\n        (min === undefined || pageId >= min) && (max === undefined || pageId <= max) && !isPageExcluded(pageId, exclude)\n    );\n};\n\n/**\n * Builds an exclude set from a PageRange array for O(1) lookups.\n *\n * @param excludeList - List of page IDs or [from, to] ranges\n * @returns Set of all excluded page IDs\n *\n * @remarks\n * This expands ranges into explicit page IDs for fast membership checks. For typical\n * book-scale inputs (thousands of pages), this is small and keeps downstream logic\n * simple and fast. If you expect extremely large ranges (e.g., millions of pages),\n * consider avoiding broad excludes or introducing a range-based membership structure.\n *\n * @example\n * buildExcludeSet([1, 5, [10, 12]])\n * // → Set { 1, 5, 10, 11, 12 }\n */\nexport const buildExcludeSet = (excludeList: PageRange[] | undefined) => {\n    const excludeSet = new Set<number>();\n    for (const item of excludeList || []) {\n        if (typeof item === 'number') {\n            excludeSet.add(item);\n        } else {\n            for (let i = item[0]; i <= item[1]; i++) {\n                excludeSet.add(i);\n            }\n        }\n    }\n    return excludeSet;\n};\n\n/**\n * Creates a segment with optional to and meta fields.\n * Returns null if content is empty after trimming.\n *\n * @param content - Segment content\n * @param fromPageId - Starting page ID\n * @param toPageId - Optional ending page ID (omitted if same as from)\n * @param meta - Optional metadata to attach\n * @returns Segment object or null if empty\n *\n * @example\n * createSegment('Hello world', 1, 3, { chapter: 1 })\n * // → { content: 'Hello world', from: 1, to: 3, meta: { chapter: 1 } }\n *\n * createSegment('   ', 1, undefined, undefined)\n * // → null (empty content)\n */\nexport const createSegment = (\n    content: string,\n    fromPageId: number,\n    toPageId: number | undefined,\n    meta: Record<string, unknown> | undefined,\n): Segment | null => {\n    const trimmed = content.trim();\n    if (!trimmed) {\n        return null;\n    }\n    return {\n        content: trimmed,\n        from: fromPageId,\n        ...(toPageId !== undefined && toPageId !== fromPageId && { to: toPageId }),\n        ...(meta && { meta }),\n    };\n};\n\n/** Expanded breakpoint with pre-compiled regex and exclude set */\nexport type ExpandedBreakpoint = {\n    rule: BreakpointRule;\n    regex: RegExp | null;\n    excludeSet: Set<number>;\n    skipWhenRegex: RegExp | null;\n    /** true = split AT match (new segment starts with match), false = split AFTER (default) */\n    splitAt: boolean;\n};\n\n/** Function type for pattern processing */\nexport type PatternProcessor = (pattern: string) => string;\n\n/**\n * Expands breakpoint patterns and pre-computes exclude sets.\n *\n * @param breakpoints - Array of breakpoint patterns or rules\n * @param processPattern - Function to expand tokens in patterns\n * @returns Array of expanded breakpoints with compiled regexes\n *\n * @remarks\n * This function compiles regex patterns dynamically. This can be a ReDoS vector\n * if patterns come from untrusted sources. In typical usage, breakpoint rules\n * are application configuration, not user input.\n/**\n * @param processPattern - Function to expand tokens in patterns (with bracket escaping)\n * @param processRawPattern - Function to expand tokens without bracket escaping (for regex field)\n */\nexport const expandBreakpoints = (\n    breakpoints: Breakpoint[],\n    processPattern: PatternProcessor,\n    processRawPattern?: PatternProcessor,\n): ExpandedBreakpoint[] =>\n    breakpoints.map((bp) => {\n        const rule = normalizeBreakpoint(bp);\n        const excludeSet = buildExcludeSet(rule.exclude);\n        const skipWhenRegex =\n            rule.skipWhen !== undefined\n                ? (() => {\n                      const expandedSkip = processPattern(rule.skipWhen);\n                      try {\n                          return new RegExp(expandedSkip, 'mu');\n                      } catch (error) {\n                          const message = error instanceof Error ? error.message : String(error);\n                          throw new Error(`Invalid breakpoint skipWhen regex: ${rule.skipWhen}\\n  Cause: ${message}`);\n                      }\n                  })()\n                : null;\n\n        // Determine which pattern to use: regex takes precedence over pattern\n        const rawPattern = rule.regex ?? rule.pattern;\n\n        // Empty pattern = page boundary fallback, split has no effect\n        if (rawPattern === '' || rawPattern === undefined) {\n            return { excludeSet, regex: null, rule, skipWhenRegex, splitAt: false };\n        }\n\n        // Use raw processor if regex field is set and rawPatternProcessor is provided\n        const useRawProcessor = rule.regex !== undefined && processRawPattern;\n        const expanded = useRawProcessor ? processRawPattern(rawPattern) : processPattern(rawPattern);\n\n        // splitAt = true means new segment starts WITH the match\n        const splitAt = rule.split === 'at';\n        try {\n            return { excludeSet, regex: new RegExp(expanded, 'gmu'), rule, skipWhenRegex, splitAt };\n        } catch (error) {\n            const message = error instanceof Error ? error.message : String(error);\n            const fieldUsed = rule.regex !== undefined ? 'regex' : 'pattern';\n            throw new Error(`Invalid breakpoint ${fieldUsed}: ${rawPattern}\\n  Cause: ${message}`);\n        }\n    });\n\n/** Normalized page data for efficient lookups */\nexport type NormalizedPage = { content: string; length: number; index: number };\n\n/**\n * Applies a configured joiner at detected page boundaries within a multi-page content chunk.\n *\n * This is used for breakpoint-generated segments which don't have access to the original\n * `pageMap.pageBreaks` offsets. We detect page starts sequentially by searching for each page's\n * prefix after the previous boundary, then replace ONLY the single newline immediately before\n * that page start.\n *\n * This avoids converting real in-page newlines, while still normalizing page joins consistently.\n */\nexport const applyPageJoinerBetweenPages = (\n    content: string,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    joiner: 'space' | 'newline',\n) => {\n    if (joiner === 'newline' || fromIdx >= toIdx || !content.includes('\\n')) {\n        return content;\n    }\n\n    let updated = content;\n    let searchFrom = 0;\n\n    for (let pi = fromIdx + 1; pi <= toIdx; pi++) {\n        const pageData = normalizedPages.get(pageIds[pi]);\n        if (!pageData) {\n            continue;\n        }\n\n        const found = findPrefixPositionInContent(updated, pageData.content.trimStart(), searchFrom);\n        if (found > 0 && updated[found - 1] === '\\n') {\n            updated = `${updated.slice(0, found - 1)} ${updated.slice(found)}`;\n        }\n        if (found > 0) {\n            searchFrom = found;\n        }\n    }\n\n    return updated;\n};\n\n/**\n * Finds the position of a page prefix in content, trying multiple prefix lengths.\n */\nconst findPrefixPositionInContent = (content: string, trimmedPageContent: string, searchFrom: number) => {\n    for (const len of JOINER_PREFIX_LENGTHS) {\n        const prefix = trimmedPageContent.slice(0, Math.min(len, trimmedPageContent.length)).trim();\n        if (!prefix) {\n            continue;\n        }\n        const pos = content.indexOf(prefix, searchFrom);\n        if (pos > 0) {\n            return pos;\n        }\n    }\n    return -1;\n};\n\n/**\n * Estimates how far into the current page `remainingContent` begins.\n *\n * During breakpoint processing, `remainingContent` can begin mid-page after a previous split.\n * When that happens, raw cumulative page offsets (computed from full page starts) can overestimate\n * expected boundary positions. This helper computes an approximate starting offset by matching\n * a short prefix of `remainingContent` inside the current page content.\n */\nexport const estimateStartOffsetInCurrentPage = (\n    remainingContent: string,\n    currentFromIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    const currentPageData = normalizedPages.get(pageIds[currentFromIdx]);\n    if (!currentPageData) {\n        return 0;\n    }\n\n    const remStart = remainingContent.trimStart().slice(0, Math.min(60, remainingContent.length));\n    const needle = remStart.slice(0, Math.min(30, remStart.length));\n    if (!needle) {\n        return 0;\n    }\n\n    const idx = currentPageData.content.indexOf(needle);\n    return idx > 0 ? idx : 0;\n};\n\n/**\n * Attempts to find the start position of a target page within remainingContent,\n * anchored near an expected boundary position to reduce collisions.\n *\n * This is used to define breakpoint windows in terms of actual content being split, rather than\n * raw per-page offsets which can desync when structural rules strip markers.\n */\nexport const findPageStartNearExpectedBoundary = (\n    remainingContent: string,\n    targetPageIdx: number,\n    expectedBoundary: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    logger?: Logger,\n) => {\n    const targetPageData = normalizedPages.get(pageIds[targetPageIdx]);\n    if (!targetPageData) {\n        return -1;\n    }\n\n    // Anchor search near the expected boundary to avoid matching repeated phrases earlier in content.\n    const approx = Math.min(Math.max(0, expectedBoundary), remainingContent.length);\n    const searchStart = Math.max(0, approx - 10_000);\n    const searchEnd = Math.min(remainingContent.length, approx + 2_000);\n\n    const targetTrimmed = targetPageData.content.trimStart();\n    for (const len of WINDOW_PREFIX_LENGTHS) {\n        const prefix = targetTrimmed.slice(0, Math.min(len, targetTrimmed.length)).trim();\n        if (!prefix) {\n            continue;\n        }\n\n        const candidates = findAnchorCandidates(remainingContent, prefix, searchStart, searchEnd);\n        if (candidates.length === 0) {\n            continue;\n        }\n\n        // Only accept matches within MAX_DEVIATION of the expected boundary.\n        // Prefer newline-preceded candidates *among valid matches*, otherwise choose the closest.\n        const MAX_DEVIATION = 2000;\n        const inRange = candidates.filter((c) => Math.abs(c.pos - expectedBoundary) <= MAX_DEVIATION);\n        if (inRange.length > 0) {\n            const best = selectBestAnchor(inRange, expectedBoundary);\n            return best.pos;\n        }\n\n        const bestOverall = selectBestAnchor(candidates, expectedBoundary);\n        logger?.debug?.('[breakpoints] findPageStartNearExpectedBoundary: Rejected match exceeding deviation', {\n            bestDistance: Math.abs(bestOverall.pos - expectedBoundary),\n            expectedBoundary,\n            matchPos: bestOverall.pos,\n            maxDeviation: MAX_DEVIATION,\n            prefixLength: len,\n            targetPageIdx,\n        });\n    }\n\n    return -1;\n};\n\n/** Internal candidate for page start anchoring */\ninterface AnchorCandidate {\n    pos: number;\n    isNewline: boolean;\n}\n\n/** Finds all whitespace-preceded occurrences of a prefix within a search range */\nconst findAnchorCandidates = (content: string, prefix: string, start: number, end: number) => {\n    const candidates: AnchorCandidate[] = [];\n    let pos = content.indexOf(prefix, start);\n\n    while (pos !== -1 && pos <= end) {\n        if (pos > 0) {\n            const charBefore = content[pos - 1];\n            if (charBefore === '\\n') {\n                candidates.push({ isNewline: true, pos });\n            } else if (/\\s/.test(charBefore)) {\n                candidates.push({ isNewline: false, pos });\n            }\n        }\n        pos = content.indexOf(prefix, pos + 1);\n    }\n\n    return candidates;\n};\n\n/** Selects the best anchor candidate, prioritizing newlines then proximity to boundary */\nconst selectBestAnchor = (candidates: AnchorCandidate[], expectedBoundary: number) => {\n    const newlines = candidates.filter((c) => c.isNewline);\n    const pool = newlines.length > 0 ? newlines : candidates;\n\n    return pool.reduce((best, curr) =>\n        Math.abs(curr.pos - expectedBoundary) < Math.abs(best.pos - expectedBoundary) ? curr : best,\n    );\n};\n\n/**\n * Builds a boundary position map for pages within the given range.\n *\n * This function computes page boundaries once per segment and enables\n * O(log n) page lookups via binary search with `findPageIndexForPosition`.\n *\n * Boundaries are derived from segmentContent (post-structural-rules).\n * When the segment starts mid-page, an offset correction is applied to\n * keep boundary estimates aligned with the segment's actual content space.\n *\n * @param segmentContent - Full segment content (already processed by structural rules)\n * @param fromIdx - Starting page index\n * @param toIdx - Ending page index\n * @param pageIds - Array of all page IDs\n * @param normalizedPages - Map of page ID to normalized content\n * @param cumulativeOffsets - Cumulative character offsets (for estimates)\n * @param logger - Optional logger for debugging\n * @returns Array where boundaryPositions[i] = start position of page (fromIdx + i),\n *          with a sentinel boundary at segmentContent.length as the last element\n *\n * @example\n * // For a 3-page segment:\n * buildBoundaryPositions(content, 0, 2, pageIds, normalizedPages, offsets)\n * // → [0, 23, 45, 67] where 67 is content.length (sentinel)\n */\nexport const buildBoundaryPositions = (\n    segmentContent: string,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    logger?: Logger,\n) => {\n    const boundaryPositions: number[] = [0];\n    const pageCount = toIdx - fromIdx + 1;\n\n    // FAST PATH: For large segments (1000+ pages), use cumulative offsets directly.\n    // The expensive string-search verification is only useful when structural rules\n    // have stripped content causing offset drift. For large books with simple breakpoints,\n    // the precomputed offsets are accurate and O(n) vs O(n×m) string searching.\n    if (pageCount >= FAST_PATH_THRESHOLD) {\n        logger?.debug?.('[breakpoints] Using fast-path for large segment in buildBoundaryPositions', {\n            fromIdx,\n            pageCount,\n            toIdx,\n        });\n\n        const baseOffset = cumulativeOffsets[fromIdx] ?? 0;\n        for (let i = fromIdx + 1; i <= toIdx; i++) {\n            const offset = cumulativeOffsets[i];\n            if (offset !== undefined) {\n                const boundary = Math.max(0, offset - baseOffset);\n                const prevBoundary = boundaryPositions[boundaryPositions.length - 1];\n                // Ensure strictly increasing boundaries\n                boundaryPositions.push(Math.max(prevBoundary + 1, Math.min(boundary, segmentContent.length)));\n            }\n        }\n        boundaryPositions.push(segmentContent.length); // sentinel\n        return boundaryPositions;\n    }\n\n    // ACCURATE PATH: For smaller segments, verify boundaries with string search\n    // This handles cases where structural rules stripped markers causing offset drift\n    // WARNING: This path is O(n×m) - if this log appears for large pageCount, investigate!\n    logger?.debug?.('[breakpoints] buildBoundaryPositions: Using accurate string-search path', {\n        contentLength: segmentContent.length,\n        fromIdx,\n        pageCount,\n        toIdx,\n    });\n    const startOffsetInFromPage = estimateStartOffsetInCurrentPage(segmentContent, fromIdx, pageIds, normalizedPages);\n\n    for (let i = fromIdx + 1; i <= toIdx; i++) {\n        const expectedBoundary =\n            cumulativeOffsets[i] !== undefined && cumulativeOffsets[fromIdx] !== undefined\n                ? Math.max(0, cumulativeOffsets[i] - cumulativeOffsets[fromIdx] - startOffsetInFromPage)\n                : segmentContent.length;\n\n        const pos = findPageStartNearExpectedBoundary(\n            segmentContent,\n            i,\n            expectedBoundary,\n            pageIds,\n            normalizedPages,\n            logger,\n        );\n\n        const prevBoundary = boundaryPositions[boundaryPositions.length - 1];\n\n        // Strict > prevents duplicate boundaries when pages have identical content\n        const MAX_DEVIATION = 2000;\n        const isValidPosition = pos > 0 && pos > prevBoundary && Math.abs(pos - expectedBoundary) < MAX_DEVIATION;\n\n        if (isValidPosition) {\n            boundaryPositions.push(pos);\n        } else {\n            // Fallback for whitespace-only pages, identical content, or stripped markers.\n            // Ensure estimate is strictly > prevBoundary to prevent duplicate zero-length\n            // boundaries, which would break binary-search page-attribution logic.\n            const estimate = Math.max(prevBoundary + 1, expectedBoundary);\n            boundaryPositions.push(Math.min(estimate, segmentContent.length));\n        }\n    }\n\n    boundaryPositions.push(segmentContent.length); // sentinel\n    logger?.debug?.('[breakpoints] buildBoundaryPositions: Complete', { boundaryCount: boundaryPositions.length });\n    return boundaryPositions;\n};\n\n/**\n * Binary search to find which page a position falls within.\n * Uses \"largest i where boundaryPositions[i] <= position\" semantics.\n *\n * @param position - Character position in segmentContent\n * @param boundaryPositions - Precomputed boundary positions (from buildBoundaryPositions)\n * @param fromIdx - Base page index (boundaryPositions[0] corresponds to pageIds[fromIdx])\n * @returns Page index in pageIds array\n *\n * @example\n * // With boundaries [0, 20, 40, 60] and fromIdx=0:\n * findPageIndexForPosition(15, boundaries, 0) // → 0 (first page)\n * findPageIndexForPosition(25, boundaries, 0) // → 1 (second page)\n * findPageIndexForPosition(40, boundaries, 0) // → 2 (exactly on boundary = that page)\n */\nexport const findPageIndexForPosition = (position: number, boundaryPositions: number[], fromIdx: number) => {\n    // Handle edge cases\n    if (boundaryPositions.length <= 1) {\n        return fromIdx;\n    }\n\n    // Binary search for largest i where boundaryPositions[i] <= position\n    let left = 0;\n    let right = boundaryPositions.length - 2; // Exclude sentinel\n\n    while (left < right) {\n        const mid = Math.ceil((left + right) / 2);\n        if (boundaryPositions[mid] <= position) {\n            left = mid;\n        } else {\n            right = mid - 1;\n        }\n    }\n\n    return fromIdx + left;\n};\n/**\n * Finds the end position of a breakpoint window inside `remainingContent`.\n *\n * The window end is defined as the start of the page AFTER `windowEndIdx` (i.e. `windowEndIdx + 1`),\n * found within the actual `remainingContent` string being split. This avoids relying on raw page offsets\n * that can diverge when structural rules strip markers (e.g. `lineStartsAfter`).\n */\nexport const findBreakpointWindowEndPosition = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    logger?: Logger,\n) => {\n    // If the window already reaches the end of the segment, the window is the remaining content.\n    if (windowEndIdx >= toIdx) {\n        return remainingContent.length;\n    }\n\n    const desiredNextIdx = windowEndIdx + 1;\n    const minNextIdx = currentFromIdx + 1;\n    const maxNextIdx = Math.min(desiredNextIdx, toIdx);\n\n    const startOffsetInCurrentPage = estimateStartOffsetInCurrentPage(\n        remainingContent,\n        currentFromIdx,\n        pageIds,\n        normalizedPages,\n    );\n\n    // Track the best expected boundary for fallback\n    let bestExpectedBoundary = remainingContent.length;\n\n    // If we can't find the boundary for the desired next page, progressively fall back\n    // to earlier page boundaries (smaller window), which is conservative but still correct.\n    for (let nextIdx = maxNextIdx; nextIdx >= minNextIdx; nextIdx--) {\n        const expectedBoundary =\n            cumulativeOffsets[nextIdx] !== undefined && cumulativeOffsets[currentFromIdx] !== undefined\n                ? Math.max(0, cumulativeOffsets[nextIdx] - cumulativeOffsets[currentFromIdx] - startOffsetInCurrentPage)\n                : remainingContent.length;\n\n        // Keep track of the expected boundary for fallback\n        if (nextIdx === maxNextIdx) {\n            bestExpectedBoundary = expectedBoundary;\n        }\n\n        const pos = findPageStartNearExpectedBoundary(\n            remainingContent,\n            nextIdx,\n            expectedBoundary,\n            pageIds,\n            normalizedPages,\n            logger,\n        );\n        if (pos > 0) {\n            return pos;\n        }\n    }\n\n    // Fallback: Use the expected boundary from cumulative offsets.\n    // This is more accurate than returning remainingContent.length, which would\n    // merge all remaining pages into one segment.\n    return Math.min(bestExpectedBoundary, remainingContent.length);\n};\n\n/**\n * Finds exclusion-based break position using raw cumulative offsets.\n *\n * This is used to ensure pages excluded by breakpoints are never merged into the same output segment.\n * Returns a break position relative to the start of `remainingContent` (i.e. the currentFromIdx start).\n */\nexport const findExclusionBreakPosition = (\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    expandedBreakpoints: Array<{ excludeSet: Set<number> }>,\n    cumulativeOffsets: number[],\n) => {\n    const startingPageId = pageIds[currentFromIdx];\n    const startingPageExcluded = expandedBreakpoints.some((bp) => bp.excludeSet.has(startingPageId));\n    if (startingPageExcluded && currentFromIdx < toIdx) {\n        // Output just this one page as a segment (break at next page boundary)\n        return cumulativeOffsets[currentFromIdx + 1] - cumulativeOffsets[currentFromIdx];\n    }\n\n    // Find the first excluded page AFTER the starting page (within window) and split BEFORE it\n    for (let pageIdx = currentFromIdx + 1; pageIdx <= windowEndIdx; pageIdx++) {\n        const pageId = pageIds[pageIdx];\n        const isExcluded = expandedBreakpoints.some((bp) => bp.excludeSet.has(pageId));\n        if (isExcluded) {\n            return cumulativeOffsets[pageIdx] - cumulativeOffsets[currentFromIdx];\n        }\n    }\n    return -1;\n};\n\n/** Context required for finding break positions */\nexport type BreakpointContext = {\n    pageIds: number[];\n    normalizedPages: Map<number, NormalizedPage>;\n    expandedBreakpoints: ExpandedBreakpoint[];\n    prefer: 'longer' | 'shorter';\n};\n\n/**\n * Checks if any page in a range is excluded by the given exclude set.\n *\n * @param excludeSet - Set of excluded page IDs\n * @param pageIds - Array of page IDs\n * @param fromIdx - Start index (inclusive)\n * @param toIdx - End index (inclusive)\n * @returns True if any page in range is excluded\n */\nexport const hasExcludedPageInRange = (excludeSet: Set<number>, pageIds: number[], fromIdx: number, toIdx: number) => {\n    if (excludeSet.size === 0) {\n        return false;\n    }\n    for (let pageIdx = fromIdx; pageIdx <= toIdx; pageIdx++) {\n        if (excludeSet.has(pageIds[pageIdx])) {\n            return true;\n        }\n    }\n    return false;\n};\n\n/**\n * Finds the position of the next page content within remaining content.\n * Returns -1 if not found.\n *\n * @param remainingContent - Content to search in\n * @param nextPageData - Normalized data for the next page\n * @returns Position of next page content, or -1 if not found\n */\nexport const findNextPagePosition = (remainingContent: string, nextPageData: NormalizedPage) => {\n    const searchPrefix = nextPageData.content.trim().slice(0, Math.min(30, nextPageData.length));\n    if (searchPrefix.length === 0) {\n        return -1;\n    }\n    const pos = remainingContent.indexOf(searchPrefix);\n    return pos > 0 ? pos : -1;\n};\n\n/**\n * Finds matches within a window and returns the selected position based on preference and split mode.\n *\n * @param windowContent - Content to search\n * @param regex - Regex to match\n * @param prefer - 'longer' for last match, 'shorter' for first match\n * @param splitAt - If true, return position BEFORE match (at index). If false, return position AFTER match (at index + length).\n * @returns Break position, or -1 if no valid matches\n *\n * @remarks\n * - Matches with length 0 are skipped (prevents infinite loops with lookahead patterns)\n * - Matches that would result in position 0 are skipped (prevents empty first segments)\n * - For prefer:'shorter', returns immediately on first valid match (optimization)\n */\nexport const findPatternBreakPosition = (\n    windowContent: string,\n    regex: RegExp,\n    prefer: 'longer' | 'shorter',\n    splitAt = false,\n) => {\n    // Track last valid match for 'longer' preference\n    let last: { index: number; length: number } | undefined;\n\n    for (const m of windowContent.matchAll(regex)) {\n        const idx = m.index ?? -1;\n        const len = m[0]?.length ?? 0;\n\n        // Skip invalid matches: negative index, zero-length (lookahead)\n        if (idx < 0 || len === 0) {\n            continue;\n        }\n\n        // Compute break position based on split mode\n        const pos = splitAt ? idx : idx + len;\n\n        // Skip position 0 - would create empty first segment\n        if (pos === 0) {\n            continue;\n        }\n\n        last = { index: idx, length: len };\n\n        // Early return for 'shorter' (first valid match)\n        if (prefer === 'shorter') {\n            return pos;\n        }\n    }\n\n    if (!last) {\n        return -1;\n    }\n\n    // For 'longer', use last valid match\n    return splitAt ? last.index : last.index + last.length;\n};\n\n/**\n * Handles page boundary breakpoint (empty pattern).\n * Returns break position or -1 if no valid position found.\n */\nconst findStartOfNextPageInWindow = (\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    targetPos: number,\n) => {\n    const targetNextPageIdx = currentFromIdx + 1;\n\n    // Progressively try to find the boundary if detection fails (conservative fallback).\n    for (let nextIdx = targetNextPageIdx; nextIdx > currentFromIdx; nextIdx--) {\n        if (nextIdx <= toIdx) {\n            const nextPageData = normalizedPages.get(pageIds[nextIdx]);\n            if (nextPageData) {\n                const boundaryPos = findNextPagePosition(remainingContent, nextPageData);\n                if (boundaryPos > 0 && boundaryPos <= targetPos) {\n                    return boundaryPos;\n                }\n            }\n        }\n    }\n    return -1;\n};\nconst handlePageBoundaryBreak = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndPosition: number,\n    maxContentLength: number | undefined,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    // Page-boundary breakpoint (empty pattern '').\n    //\n    // Semantics: when no other breakpoint patterns match, break at the NEXT PAGE boundary\n    // (i.e. swallow the remainder of the current page), not at the end of the maxPages window.\n    //\n    // This ensures that with maxPages=0 each page stays isolated, and with maxPages>0\n    // we don't accidentally swallow the next page when no pattern matches.\n    const targetPos = Math.min(windowEndPosition, remainingContent.length);\n\n    // If the window is currently bounded by maxContentLength, do NOT force an early page-boundary break.\n    // In length-bounded mode, we want the best possible split *near* the length limit (using safe-break fallbacks),\n    // even if that spans a page boundary.\n    const isLengthBounded = maxContentLength !== undefined && windowEndPosition === maxContentLength;\n\n    if (!isLengthBounded) {\n        // Page-bounded window semantics: swallow the remainder of the CURRENT page.\n        // Even if the maxPages window could include additional pages, an empty breakpoint ('')\n        // must not consume into the next page when no real breakpoint patterns matched.\n        const boundaryPos = findStartOfNextPageInWindow(\n            remainingContent,\n            currentFromIdx,\n            toIdx,\n            pageIds,\n            normalizedPages,\n            targetPos,\n        );\n        if (boundaryPos > 0) {\n            return { pos: boundaryPos };\n        }\n    }\n\n    // If we couldn't reliably detect the boundary (or we're at the end), fall back to a safe split\n    // within the window to avoid mid-word / surrogate corruption.\n    if (targetPos < remainingContent.length) {\n        const safePos = findSafeBreakPosition(remainingContent, targetPos);\n        if (safePos !== -1) {\n            return {\n                pos: safePos,\n                splitReason: isLengthBounded ? ('whitespace' as const) : undefined,\n            };\n        }\n        return {\n            pos: adjustForUnicodeBoundary(remainingContent, targetPos),\n            splitReason: isLengthBounded ? ('unicode_boundary' as const) : undefined,\n        };\n    }\n    return { pos: targetPos };\n};\n\nconst checkBreakpointMatch = (\n    i: number,\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    windowEndIdx: number,\n    windowEndPosition: number,\n    ctx: BreakpointContext,\n    maxContentLength?: number,\n) => {\n    const { pageIds, normalizedPages, expandedBreakpoints, prefer } = ctx;\n    const bpCtx = expandedBreakpoints[i];\n    const { rule, regex, excludeSet, skipWhenRegex } = bpCtx;\n\n    // Check if this breakpoint applies to the current segment's starting page\n    if (!isInBreakpointRange(pageIds[currentFromIdx], rule)) {\n        return null;\n    }\n\n    // Check if ANY page in the current WINDOW is excluded (not the entire segment)\n    if (hasExcludedPageInRange(excludeSet, pageIds, currentFromIdx, windowEndIdx)) {\n        return null;\n    }\n\n    // Check if content matches skipWhen pattern (pre-compiled)\n    if (skipWhenRegex?.test(remainingContent)) {\n        return null;\n    }\n\n    // Handle page boundary (empty pattern)\n    if (regex === null) {\n        const result = handlePageBoundaryBreak(\n            remainingContent,\n            currentFromIdx,\n            windowEndPosition,\n            maxContentLength,\n            toIdx,\n            pageIds,\n            normalizedPages,\n        );\n        return {\n            breakPos: result.pos,\n            breakpointIndex: i,\n            contentLengthSplit:\n                result.splitReason && maxContentLength ? { maxContentLength, reason: result.splitReason } : undefined,\n            rule,\n        };\n    }\n\n    // Find matches within window\n    const windowContent = remainingContent.slice(0, Math.min(windowEndPosition, remainingContent.length));\n    const breakPos = findPatternBreakPosition(windowContent, regex, prefer, bpCtx.splitAt);\n    if (breakPos > 0) {\n        return { breakPos, breakpointIndex: i, rule };\n    }\n\n    return null;\n};\n\n/**\n * Tries to find a break position within the current window using breakpoint patterns.\n * Returns the break position or -1 if no suitable break was found.\n *\n * @param remainingContent - Content remaining to be segmented\n * @param currentFromIdx - Current starting page index\n * @param toIdx - Ending page index\n * @param windowEndIdx - Maximum window end index\n * @param ctx - Breakpoint context with page data and patterns\n * @returns Break position in the content, or -1 if no break found\n */\nexport const findBreakPosition = (\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    windowEndIdx: number,\n    windowEndPosition: number,\n    ctx: BreakpointContext,\n    maxContentLength?: number,\n) => {\n    const { expandedBreakpoints } = ctx;\n\n    for (let i = 0; i < expandedBreakpoints.length; i++) {\n        const match = checkBreakpointMatch(\n            i,\n            remainingContent,\n            currentFromIdx,\n            toIdx,\n            windowEndIdx,\n            windowEndPosition,\n            ctx,\n            maxContentLength,\n        );\n        if (match) {\n            return match;\n        }\n    }\n\n    return null;\n};\n\n/**\n * Searches backward from a target position to find a \"safe\" split point.\n * A safe split point is after whitespace or punctuation.\n *\n * @param content The text content\n * @param targetPosition The desired split position (hard limit)\n * @param lookbackChars How far back to search for a safe break\n * @returns The new split position (index), or -1 if no safe break found\n */\nexport const findSafeBreakPosition = (content: string, targetPosition: number, lookbackChars = 100) => {\n    // 1. Sanity check bounds\n    const startSearch = Math.max(0, targetPosition - lookbackChars);\n\n    // 2. Iterate backward\n    for (let i = targetPosition - 1; i >= startSearch; i--) {\n        const char = content[i];\n\n        // Check for safe delimiter: Whitespace or Punctuation\n        if (STOP_CHARACTERS.test(char)) {\n            return i + 1;\n        }\n    }\n    return -1;\n};\n\n/**\n * Ensures the position does not split a surrogate pair.\n * If position is between High and Low surrogate, returns position - 1.\n */\nexport const adjustForSurrogate = (content: string, position: number) => {\n    if (position <= 0 || position >= content.length) {\n        return position;\n    }\n\n    const high = content.charCodeAt(position - 1);\n    const low = content.charCodeAt(position);\n\n    // Check if previous char is High Surrogate (0xD800–0xDBFF)\n    // AND current char is Low Surrogate (0xDC00–0xDFFF)\n    if (high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) {\n        return position - 1;\n    }\n\n    return position;\n};\n","import type { BreakpointRule } from '@/types/breakpoints';\nimport { PATTERN_TYPE_KEYS, type SplitRule } from '@/types/rules.js';\n\nexport type DebugConfig = { includeBreakpoint: boolean; includeRule: boolean; metaKey: string } | null;\n\nexport const resolveDebugConfig = (debug: unknown) => {\n    if (debug === true) {\n        return { includeBreakpoint: true, includeRule: true, metaKey: '_flappa' };\n    }\n\n    if (!debug || typeof debug !== 'object') {\n        return null;\n    }\n\n    const { metaKey, include } = debug as any;\n    const includeRule = Array.isArray(include) ? include.includes('rule') : true;\n    const includeBreakpoint = Array.isArray(include) ? include.includes('breakpoint') : true;\n    return { includeBreakpoint, includeRule, metaKey: typeof metaKey === 'string' && metaKey ? metaKey : '_flappa' };\n};\n\nexport const getRulePatternType = (rule: SplitRule) => {\n    return PATTERN_TYPE_KEYS.find((key) => key in rule) ?? 'regex';\n};\n\nconst isPlainObject = (v: unknown): v is Record<string, unknown> =>\n    Boolean(v) && typeof v === 'object' && !Array.isArray(v);\n\nexport const mergeDebugIntoMeta = (\n    meta: Record<string, unknown> | undefined,\n    metaKey: string,\n    patch: Record<string, unknown>,\n) => {\n    const out = meta ? { ...meta } : {};\n    const existing = out[metaKey];\n    out[metaKey] = { ...(isPlainObject(existing) ? existing : {}), ...patch };\n    return out;\n};\n\nexport const buildRuleDebugPatch = (ruleIndex: number, rule: SplitRule) => ({\n    rule: { index: ruleIndex, patternType: getRulePatternType(rule) },\n});\n\nexport const buildBreakpointDebugPatch = (breakpointIndex: number, rule: BreakpointRule) => ({\n    breakpoint: {\n        index: breakpointIndex,\n        kind: rule.pattern === '' ? 'pageBoundary' : 'pattern',\n        pattern: rule.pattern ?? rule.regex,\n    },\n});\n\nexport type ContentLengthSplitReason = 'whitespace' | 'unicode_boundary' | 'grapheme_cluster';\n\nexport const buildContentLengthDebugPatch = (\n    maxContentLength: number,\n    actualLength: number,\n    splitReason: ContentLengthSplitReason = 'whitespace',\n) => ({\n    contentLengthSplit: {\n        actualLength,\n        maxContentLength,\n        splitReason,\n    },\n});\n","/**\n * Breakpoint post-processing engine extracted from segmenter.ts.\n *\n * This module is intentionally split into small helpers to reduce cognitive complexity\n * and allow unit testing of tricky edge cases (window sizing, next-page advancement, etc.).\n */\n\nimport type { Breakpoint, BreakpointRule } from '@/types/breakpoints.js';\nimport type { Page, Segment } from '@/types/index.js';\nimport type { Logger } from '@/types/options.js';\nimport { adjustForUnicodeBoundary } from '@/utils/textUtils.js';\nimport { FAST_PATH_THRESHOLD } from './breakpoint-constants.js';\nimport type { PatternProcessor } from './breakpoint-utils.js';\nimport {\n    applyPageJoinerBetweenPages,\n    type BreakpointContext,\n    buildBoundaryPositions,\n    createSegment,\n    expandBreakpoints,\n    findBreakPosition,\n    findBreakpointWindowEndPosition,\n    findExclusionBreakPosition,\n    findPageIndexForPosition,\n    findSafeBreakPosition,\n    hasExcludedPageInRange,\n    type NormalizedPage,\n} from './breakpoint-utils.js';\nimport { buildBreakpointDebugPatch, mergeDebugIntoMeta } from './debug-meta.js';\n\nconst buildPageIdToIndexMap = (pageIds: number[]) => new Map(pageIds.map((id, i) => [id, i]));\n\nconst buildNormalizedPagesMap = (pages: Page[], normalizedContent: string[]) => {\n    const normalizedPages = new Map<number, NormalizedPage>();\n    for (let i = 0; i < pages.length; i++) {\n        const content = normalizedContent[i];\n        normalizedPages.set(pages[i].id, { content, index: i, length: content.length });\n    }\n    return normalizedPages;\n};\n\nconst buildCumulativeOffsets = (pageIds: number[], normalizedPages: Map<number, NormalizedPage>) => {\n    const cumulativeOffsets: number[] = [0];\n    let totalOffset = 0;\n    for (let i = 0; i < pageIds.length; i++) {\n        const pageData = normalizedPages.get(pageIds[i]);\n        totalOffset += pageData?.length ?? 0;\n        if (i < pageIds.length - 1) {\n            totalOffset += 1;\n        }\n        cumulativeOffsets.push(totalOffset);\n    }\n    return cumulativeOffsets;\n};\n\nconst hasAnyExclusionsInRange = (\n    expandedBreakpoints: Array<{ excludeSet: Set<number> }>,\n    pageIds: number[],\n    fromIdx: number,\n    toIdx: number,\n) => expandedBreakpoints.some((bp) => hasExcludedPageInRange(bp.excludeSet, pageIds, fromIdx, toIdx));\n\nexport const computeWindowEndIdx = (currentFromIdx: number, toIdx: number, pageIds: number[], maxPages: number) => {\n    const maxWindowPageId = pageIds[currentFromIdx] + maxPages;\n    let windowEndIdx = currentFromIdx;\n    for (let i = currentFromIdx; i <= toIdx; i++) {\n        if (pageIds[i] <= maxWindowPageId) {\n            windowEndIdx = i;\n        } else {\n            break;\n        }\n    }\n    return windowEndIdx;\n};\n\nconst computeRemainingSpan = (currentFromIdx: number, toIdx: number, pageIds: number[]) =>\n    pageIds[toIdx] - pageIds[currentFromIdx];\n\nconst createFinalSegment = (\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    meta: Segment['meta'] | undefined,\n    includeMeta: boolean,\n) =>\n    createSegment(\n        remainingContent,\n        pageIds[currentFromIdx],\n        currentFromIdx !== toIdx ? pageIds[toIdx] : undefined,\n        includeMeta ? meta : undefined,\n    );\n\n/**\n * Computes the actual start and end page indices for a piece using\n * precomputed boundary positions and binary search.\n *\n * @param pieceStartPos - Start position of the piece in the full segment content\n * @param pieceEndPos - End position (exclusive) of the piece\n * @param boundaryPositions - Precomputed boundary positions from buildBoundaryPositions\n * @param baseFromIdx - Base page index (boundaryPositions[0] corresponds to pageIds[baseFromIdx])\n * @param toIdx - Maximum page index\n * @returns Object with actualStartIdx and actualEndIdx\n */\nconst computePiecePages = (\n    pieceStartPos: number,\n    pieceEndPos: number,\n    boundaryPositions: number[],\n    baseFromIdx: number,\n    toIdx: number,\n) => {\n    const actualStartIdx = findPageIndexForPosition(pieceStartPos, boundaryPositions, baseFromIdx);\n    const endPos = Math.max(pieceStartPos, pieceEndPos - 1);\n    const actualEndIdx = Math.min(findPageIndexForPosition(endPos, boundaryPositions, baseFromIdx), toIdx);\n    return { actualEndIdx, actualStartIdx };\n};\n\nexport const computeNextFromIdx = (\n    remainingContent: string,\n    actualEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    let nextFromIdx = actualEndIdx;\n    if (remainingContent && actualEndIdx + 1 <= toIdx) {\n        const nextPageData = normalizedPages.get(pageIds[actualEndIdx + 1]);\n        if (nextPageData) {\n            const nextPrefix = nextPageData.content.slice(0, 30);\n            const remainingPrefix = remainingContent.trimStart().slice(0, 30);\n            if (\n                nextPrefix &&\n                (remainingContent.startsWith(nextPrefix) || nextPageData.content.startsWith(remainingPrefix))\n            ) {\n                nextFromIdx = actualEndIdx + 1;\n            }\n        }\n    }\n    return nextFromIdx;\n};\n\nconst createPieceSegment = (\n    pieceContent: string,\n    actualStartIdx: number,\n    actualEndIdx: number,\n    pageIds: number[],\n    meta: Segment['meta'] | undefined,\n    includeMeta: boolean,\n): Segment | null =>\n    createSegment(\n        pieceContent,\n        pageIds[actualStartIdx],\n        actualEndIdx > actualStartIdx ? pageIds[actualEndIdx] : undefined,\n        includeMeta ? meta : undefined,\n    );\n\n/**\n * Finds the break offset within a window, trying exclusions first, then patterns.\n *\n * @returns Break offset relative to remainingContent, or windowEndPosition as fallback\n */\nconst findBreakOffsetForWindow = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    windowEndPosition: number,\n    pageIds: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    cumulativeOffsets: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    prefer: 'longer' | 'shorter',\n    maxContentLength?: number,\n) => {\n    const windowHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, windowEndIdx);\n\n    if (windowHasExclusions) {\n        const exclusionBreak = findExclusionBreakPosition(\n            currentFromIdx,\n            windowEndIdx,\n            toIdx,\n            pageIds,\n            expandedBreakpoints,\n            cumulativeOffsets,\n        );\n        if (exclusionBreak > 0) {\n            return { breakOffset: exclusionBreak };\n        }\n    }\n\n    const breakpointCtx: BreakpointContext = { expandedBreakpoints, normalizedPages, pageIds, prefer };\n    const patternMatch = findBreakPosition(\n        remainingContent,\n        currentFromIdx,\n        toIdx,\n        windowEndIdx,\n        windowEndPosition,\n        breakpointCtx,\n        maxContentLength,\n    );\n\n    if (patternMatch && patternMatch.breakPos > 0) {\n        return {\n            breakOffset: patternMatch.breakPos,\n            breakpointIndex: patternMatch.breakpointIndex,\n            breakpointRule: patternMatch.rule,\n            contentLengthSplit: patternMatch.contentLengthSplit,\n        };\n    }\n\n    // Fallback: Always try to find a safe break position (avoid mid-word splits)\n    if (windowEndPosition < remainingContent.length) {\n        const safeOffset = findSafeBreakPosition(remainingContent, windowEndPosition);\n        if (safeOffset !== -1) {\n            return {\n                breakOffset: safeOffset,\n                contentLengthSplit: maxContentLength ? { maxContentLength, reason: 'whitespace' as const } : undefined,\n            };\n        }\n        // If no safe break (whitespace) found, ensure we don't split a surrogate pair\n        const adjustedOffset = adjustForUnicodeBoundary(remainingContent, windowEndPosition);\n        return {\n            breakOffset: adjustedOffset,\n            contentLengthSplit: maxContentLength\n                ? { maxContentLength, reason: 'unicode_boundary' as const }\n                : undefined,\n        };\n    }\n\n    return { breakOffset: windowEndPosition };\n};\n\n/**\n * Advances cursor position past any leading whitespace.\n */\nconst skipWhitespace = (content: string, startPos: number) => {\n    let pos = startPos;\n    while (pos < content.length && /\\s/.test(content[pos])) {\n        pos++;\n    }\n    return pos;\n};\n\n/**\n * Validates that cumulative offsets match actual content length within a tolerance.\n * Required to detect if structural rules (like `lineStartsAfter`) have stripped content\n * which would make offset-based calculations inaccurate.\n */\nconst checkFastPathAlignment = (\n    cumulativeOffsets: number[],\n    fullContent: string,\n    fromIdx: number,\n    toIdx: number,\n    pageCount: number,\n    logger?: Logger,\n) => {\n    const expectedLength = (cumulativeOffsets[toIdx + 1] ?? fullContent.length) - (cumulativeOffsets[fromIdx] ?? 0);\n    const driftTolerance = Math.max(100, fullContent.length * 0.01);\n    const isAligned = Math.abs(expectedLength - fullContent.length) <= driftTolerance;\n\n    if (!isAligned && pageCount >= FAST_PATH_THRESHOLD) {\n        logger?.warn?.('[breakpoints] Offset drift detected in fast-path candidate, falling back to slow path', {\n            actualLength: fullContent.length,\n            drift: Math.abs(expectedLength - fullContent.length),\n            expectedLength,\n            pageCount,\n        });\n    }\n    return isAligned;\n};\n\n/**\n * Handles the special optimized case for maxPages=0 (1 page per segment).\n * This is O(n) and safer than offset arithmetic as it uses source pages directly.\n */\nconst processTrivialFastPath = (\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    pageCount: number,\n    originalMeta?: Segment['meta'],\n    debugMetaKey?: string,\n    logger?: Logger,\n) => {\n    logger?.debug?.('[breakpoints] Using trivial per-page fast-path (maxPages=0)', { fromIdx, pageCount, toIdx });\n    const result: Segment[] = [];\n    for (let i = fromIdx; i <= toIdx; i++) {\n        const pageData = normalizedPages.get(pageIds[i]);\n        if (pageData?.content.trim()) {\n            const isFirstPiece = i === fromIdx;\n            const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, null);\n            const seg = createSegment(pageData.content.trim(), pageIds[i], undefined, meta);\n            if (seg) {\n                result.push(seg);\n            }\n        }\n    }\n    return result;\n};\n\n/**\n * Handles fast-path segmentation for maxPages > 0 using cumulative offsets.\n * Avoids O(n²) string searching but requires accurate offsets.\n */\nconst buildFastPathRawContent = (\n    fullContent: string,\n    baseOffset: number,\n    cumulativeOffsets: number[],\n    segStart: number,\n    segEnd: number,\n    toIdx: number,\n) => {\n    const startOffset = Math.max(0, (cumulativeOffsets[segStart] ?? 0) - baseOffset);\n    const endOffset =\n        segEnd < toIdx\n            ? Math.max(0, (cumulativeOffsets[segEnd + 1] ?? fullContent.length) - baseOffset)\n            : fullContent.length;\n    return fullContent.slice(startOffset, endOffset).trim();\n};\n\nconst buildFastPathSegment = (\n    fullContent: string,\n    baseOffset: number,\n    cumulativeOffsets: number[],\n    segStart: number,\n    segEnd: number,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    originalMeta?: Segment['meta'],\n    debugMetaKey?: string,\n) => {\n    const rawContent = buildFastPathRawContent(fullContent, baseOffset, cumulativeOffsets, segStart, segEnd, toIdx);\n    if (!rawContent) {\n        return null;\n    }\n\n    const isFirstPiece = segStart === fromIdx;\n    const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, null);\n\n    const seg: Segment = {\n        content: rawContent,\n        from: pageIds[segStart],\n    };\n\n    if (segEnd > segStart) {\n        seg.to = pageIds[segEnd];\n    }\n    if (meta) {\n        seg.meta = meta;\n    }\n    return seg;\n};\n\nconst processOffsetFastPath = (\n    fullContent: string,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    cumulativeOffsets: number[],\n    maxPages: number,\n    originalMeta?: Segment['meta'],\n    debugMetaKey?: string,\n    logger?: Logger,\n) => {\n    const result: Segment[] = [];\n    const pageCount = toIdx - fromIdx + 1;\n\n    logger?.debug?.('[breakpoints] Using offset-based fast-path for large segment', {\n        fromIdx,\n        maxPages,\n        pageCount,\n        toIdx,\n    });\n\n    const baseOffset = cumulativeOffsets[fromIdx] ?? 0;\n\n    // IMPORTANT: This fast path is only valid when breakpoint behavior is effectively\n    // \"page boundary fallback\" (empty breakpoint ''), which breaks oversized segments\n    // at the NEXT page boundary (end of the current page) until the remaining span fits.\n    //\n    // That means the output shape is:\n    // - many single-page pieces, then\n    // - one final segment that includes the remaining pages (<= maxPages ID span).\n    //\n    // This mirrors the iterative breakpoint semantics and avoids \"threshold flips\" where\n    // results change at FAST_PATH_THRESHOLD.\n    let segStart = fromIdx;\n    const needsPeel = (startIdx: number) => pageIds[toIdx] - pageIds[startIdx] > maxPages;\n\n    for (; segStart <= toIdx && needsPeel(segStart); segStart++) {\n        const seg = buildFastPathSegment(\n            fullContent,\n            baseOffset,\n            cumulativeOffsets,\n            segStart,\n            segStart,\n            fromIdx,\n            toIdx,\n            pageIds,\n            originalMeta,\n            debugMetaKey,\n        );\n        if (seg) {\n            result.push(seg);\n        }\n    }\n\n    // Final remainder (fits maxPages by ID span)\n    if (segStart <= toIdx) {\n        const seg = buildFastPathSegment(\n            fullContent,\n            baseOffset,\n            cumulativeOffsets,\n            segStart,\n            toIdx,\n            fromIdx,\n            toIdx,\n            pageIds,\n            originalMeta,\n            debugMetaKey,\n        );\n        if (seg) {\n            result.push(seg);\n        }\n    }\n    return result;\n};\n\n/**\n * Checks if the remaining content fits within paged/length limits.\n * If so, pushes the final segment and returns true.\n */\nconst handleOversizedSegmentFit = (\n    remainingContent: string,\n    currentFromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    expandedBreakpoints: Array<{ excludeSet: Set<number> }>,\n    maxPages: number,\n    maxContentLength: number | undefined,\n    isFirstPiece: boolean,\n    debugMetaKey: string | undefined,\n    originalMeta: Segment['meta'] | undefined,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n    result: Segment[],\n) => {\n    const remainingSpan = computeRemainingSpan(currentFromIdx, toIdx, pageIds);\n    const remainingHasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, currentFromIdx, toIdx);\n\n    const fitsInPages = remainingSpan <= maxPages;\n    const fitsInLength = !maxContentLength || remainingContent.length <= maxContentLength;\n\n    if (fitsInPages && fitsInLength && !remainingHasExclusions) {\n        const includeMeta = isFirstPiece || Boolean(debugMetaKey);\n        const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint);\n        const finalSeg = createFinalSegment(remainingContent, currentFromIdx, toIdx, pageIds, meta, includeMeta);\n        if (finalSeg) {\n            result.push(finalSeg);\n        }\n        return true;\n    }\n    return false;\n};\n\n/**\n * Builds metadata for a segment piece, optionally including debug info.\n */\nconst getSegmentMetaWithDebug = (\n    isFirstPiece: boolean,\n    debugMetaKey: string | undefined,\n    originalMeta: Segment['meta'] | undefined,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n    contentLengthSplit?: { reason: 'whitespace' | 'unicode_boundary'; maxContentLength: number },\n) => {\n    const includeMeta = isFirstPiece || Boolean(debugMetaKey);\n    if (!includeMeta) {\n        return undefined;\n    }\n\n    let meta = isFirstPiece ? originalMeta : undefined;\n\n    if (debugMetaKey) {\n        if (lastBreakpoint) {\n            meta = mergeDebugIntoMeta(\n                meta,\n                debugMetaKey,\n                buildBreakpointDebugPatch(lastBreakpoint.breakpointIndex, lastBreakpoint.rule as any),\n            );\n        }\n        if (contentLengthSplit) {\n            meta = mergeDebugIntoMeta(meta, debugMetaKey, {\n                contentLengthSplit: {\n                    maxContentLength: contentLengthSplit.maxContentLength,\n                    splitReason: contentLengthSplit.reason,\n                },\n            });\n        }\n    }\n\n    return meta;\n};\n\n/**\n * Calculates window end position, capped by maxContentLength if present.\n */\nconst getWindowEndPosition = (\n    remainingContent: string,\n    currentFromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    maxContentLength: number | undefined,\n    logger?: Logger,\n) => {\n    const pos = findBreakpointWindowEndPosition(\n        remainingContent,\n        currentFromIdx,\n        windowEndIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        logger,\n    );\n    return maxContentLength ? Math.min(pos, maxContentLength) : pos;\n};\n\n/**\n * Advances cursorPos and currentFromIdx for the next iteration.\n */\nconst advanceCursorAndIndex = (\n    fullContent: string,\n    breakPos: number,\n    actualEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n) => {\n    const nextCursorPos = skipWhitespace(fullContent, breakPos);\n    const nextFromIdx = computeNextFromIdx(\n        fullContent.slice(nextCursorPos, nextCursorPos + 500),\n        actualEndIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n    );\n    return { currentFromIdx: nextFromIdx, cursorPos: nextCursorPos };\n};\n\nconst computeIterationWindow = (\n    fullContent: string,\n    cursorPos: number,\n    currentFromIdx: number,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    boundaryPositions: number[],\n    maxPages: number,\n    maxContentLength: number | undefined,\n) => {\n    const windowEndIdx = computeWindowEndIdx(currentFromIdx, toIdx, pageIds, maxPages);\n\n    // Optimization: slice only the active \"window\" plus a small padding.\n    // This avoids O(N^2) copying when maxContentLength is unset (e.g. debug mode forces iterative path).\n    const windowEndBoundaryIdx = windowEndIdx - fromIdx + 1; // boundaryPositions[0] is fromIdx start\n    const windowEndAbsPos = boundaryPositions[windowEndBoundaryIdx] ?? fullContent.length;\n    const sliceEndByPages = Math.min(fullContent.length, windowEndAbsPos + 4000);\n    const sliceEndByLength = maxContentLength\n        ? Math.min(fullContent.length, cursorPos + maxContentLength + 4000)\n        : fullContent.length;\n    const sliceEnd = Math.max(cursorPos + 1, Math.min(sliceEndByPages, sliceEndByLength));\n\n    const remainingContent = fullContent.slice(cursorPos, sliceEnd);\n    return { remainingContent, sliceEnd, windowEndIdx };\n};\n\nconst computeWindowEndPositionForIteration = (\n    remainingContent: string,\n    cursorPos: number,\n    currentFromIdx: number,\n    fromIdx: number,\n    windowEndIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    boundaryPositions: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    maxPages: number,\n    maxContentLength: number | undefined,\n    logger?: Logger,\n) => {\n    // When maxPages=0, the window MUST NOT extend beyond the current page boundary.\n    // Otherwise, breakpoint matching can \"see\" into the next page and create segments spanning pages,\n    // even though maxPages=0 semantically means each segment must stay within a single page.\n    if (maxPages === 0) {\n        const boundaryIdx = currentFromIdx - fromIdx + 1; // boundaryPositions[0] is fromIdx start\n        const nextPageStartPos = boundaryPositions[boundaryIdx] ?? Number.POSITIVE_INFINITY;\n        const remainingInCurrentPage = Math.max(0, nextPageStartPos - cursorPos);\n        const capped = maxContentLength ? Math.min(remainingInCurrentPage, maxContentLength) : remainingInCurrentPage;\n        return Math.min(capped, remainingContent.length);\n    }\n\n    const pos = getWindowEndPosition(\n        remainingContent,\n        currentFromIdx,\n        windowEndIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        maxContentLength,\n        logger,\n    );\n    return Math.min(pos, remainingContent.length);\n};\n\nconst ensureProgressingBreakOffset = (\n    foundBreakOffset: number,\n    remainingContent: string,\n    cursorPos: number,\n    maxContentLength: number | undefined,\n    logger?: Logger,\n) => {\n    if (foundBreakOffset > 0) {\n        return foundBreakOffset;\n    }\n\n    // Progress safeguard: Ensure we advance by at least one character to prevent infinite loops.\n    // This is critical if findBreakOffsetForWindow returns 0 (e.g. from an empty windowEndPosition).\n    const fallbackPos = maxContentLength ? Math.min(maxContentLength, remainingContent.length) : 1;\n    const breakOffset = Math.max(1, fallbackPos);\n    logger?.warn?.('[breakpoints] No progress from findBreakOffsetForWindow; forcing forward movement', {\n        breakOffset,\n        cursorPos,\n    });\n    return breakOffset;\n};\n\nconst updateLastBreakpointFromFound = (\n    found: ReturnType<typeof findBreakOffsetForWindow>,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n) => {\n    if (found.breakpointIndex !== undefined && found.breakpointRule) {\n        return { breakpointIndex: found.breakpointIndex, rule: found.breakpointRule };\n    }\n    return lastBreakpoint;\n};\n\nconst appendPieceAndAdvance = (\n    fullContent: string,\n    cursorPos: number,\n    breakPos: number,\n    pieceContent: string,\n    currentFromIdx: number,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    boundaryPositions: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    maxPages: number,\n    isFirstPiece: boolean,\n    debugMetaKey: string | undefined,\n    originalMeta: Segment['meta'] | undefined,\n    lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null,\n    result: Segment[],\n    logger?: Logger,\n    contentLengthSplit?: { reason: 'whitespace' | 'unicode_boundary'; maxContentLength: number },\n) => {\n    let { actualEndIdx, actualStartIdx } = computePiecePages(cursorPos, breakPos, boundaryPositions, fromIdx, toIdx);\n\n    // Safety: boundaryPositions can be slightly misaligned in rare cases for very large segments\n    // (e.g. if upstream content was trimmed/normalized). Never allow a piece to \"start\" before\n    // the current page cursor, as that can violate maxPages constraints by inflating from/to span.\n    if (actualStartIdx < currentFromIdx) {\n        logger?.warn?.('[breakpoints] Page attribution drift detected; clamping actualStartIdx', {\n            actualStartIdx,\n            currentFromIdx,\n        });\n        actualStartIdx = currentFromIdx;\n    }\n\n    // When maxPages=0, enforce that the piece cannot span beyond the current page.\n    // This is necessary because boundaryPositions-based page detection can be confused\n    // when pages have duplicate/overlapping content at boundaries.\n    if (maxPages === 0) {\n        actualEndIdx = Math.min(actualEndIdx, currentFromIdx);\n        actualStartIdx = Math.min(actualStartIdx, currentFromIdx);\n    } else if (maxPages > 0) {\n        // Enforce ID-span-based maxPages for page attribution too (handles drift).\n        const maxAllowedEndIdx = computeWindowEndIdx(actualStartIdx, toIdx, pageIds, maxPages);\n        actualEndIdx = Math.min(actualEndIdx, maxAllowedEndIdx);\n    }\n\n    const meta = getSegmentMetaWithDebug(isFirstPiece, debugMetaKey, originalMeta, lastBreakpoint, contentLengthSplit);\n    const pieceSeg = createPieceSegment(pieceContent, actualStartIdx, actualEndIdx, pageIds, meta, true);\n    if (pieceSeg) {\n        result.push(pieceSeg);\n    }\n\n    const next = advanceCursorAndIndex(fullContent, breakPos, actualEndIdx, toIdx, pageIds, normalizedPages);\n    let nextFromIdx = next.currentFromIdx;\n    if (maxPages === 0) {\n        // When maxPages=0, content-based detection can be confused by overlapping content; use positions.\n        nextFromIdx = findPageIndexForPosition(next.cursorPos, boundaryPositions, fromIdx);\n    }\n    return { currentFromIdx: nextFromIdx, cursorPos: next.cursorPos };\n};\n\nconst tryProcessOversizedSegmentFastPath = (\n    segment: Segment,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    maxPages: number,\n    logger?: Logger,\n    debugMetaKey?: string,\n    maxContentLength?: number,\n) => {\n    const fullContent = segment.content;\n    const pageCount = toIdx - fromIdx + 1;\n\n    const isAligned = checkFastPathAlignment(cumulativeOffsets, fullContent, fromIdx, toIdx, pageCount, logger);\n    const isPageBoundaryOnly = expandedBreakpoints.every(\n        (bp) => bp.regex === null && bp.excludeSet.size === 0 && bp.skipWhenRegex === undefined,\n    );\n    if (pageCount < FAST_PATH_THRESHOLD || !isAligned || !isPageBoundaryOnly || maxContentLength || debugMetaKey) {\n        return null;\n    }\n\n    if (maxPages === 0) {\n        return processTrivialFastPath(\n            fromIdx,\n            toIdx,\n            pageIds,\n            normalizedPages,\n            pageCount,\n            segment.meta,\n            debugMetaKey,\n            logger,\n        );\n    }\n\n    return processOffsetFastPath(\n        fullContent,\n        fromIdx,\n        toIdx,\n        pageIds,\n        cumulativeOffsets,\n        maxPages,\n        segment.meta,\n        debugMetaKey,\n        logger,\n    );\n};\n\nconst processOversizedSegmentIterative = (\n    segment: Segment,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    maxPages: number,\n    prefer: 'longer' | 'shorter',\n    logger?: Logger,\n    debugMetaKey?: string,\n    maxContentLength?: number,\n) => {\n    const result: Segment[] = [];\n    const fullContent = segment.content;\n    const pageCount = toIdx - fromIdx + 1;\n\n    // SLOW PATH: Iterative breakpoint processing\n    // WARNING: This path can be slow for large segments - if this log shows large pageCount, investigate!\n    logger?.debug?.('[breakpoints] processOversizedSegment: Using iterative path', {\n        contentLength: fullContent.length,\n        fromIdx,\n        maxContentLength,\n        maxPages,\n        pageCount,\n        toIdx,\n    });\n\n    let cursorPos = 0;\n    let currentFromIdx = fromIdx;\n    let isFirstPiece = true;\n    let lastBreakpoint: { breakpointIndex: number; rule: BreakpointRule } | null = null;\n\n    const boundaryPositions = buildBoundaryPositions(\n        fullContent,\n        fromIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        logger,\n    );\n\n    logger?.debug?.('[breakpoints] boundaryPositions built', {\n        boundaryPositions,\n        fromIdx,\n        fullContentLength: fullContent.length,\n        toIdx,\n    });\n\n    const MAX_SAFE_ITERATIONS = 100_000;\n    let didHitMaxIterations = true;\n\n    for (let i = 1; i <= MAX_SAFE_ITERATIONS; i++) {\n        if (cursorPos >= fullContent.length || currentFromIdx > toIdx) {\n            didHitMaxIterations = false;\n            break;\n        }\n\n        const { remainingContent, windowEndIdx } = computeIterationWindow(\n            fullContent,\n            cursorPos,\n            currentFromIdx,\n            fromIdx,\n            toIdx,\n            pageIds,\n            boundaryPositions,\n            maxPages,\n            maxContentLength,\n        );\n\n        if (!remainingContent.trim()) {\n            didHitMaxIterations = false;\n            break;\n        }\n\n        if (\n            handleOversizedSegmentFit(\n                remainingContent,\n                currentFromIdx,\n                toIdx,\n                pageIds,\n                expandedBreakpoints,\n                maxPages,\n                maxContentLength,\n                isFirstPiece,\n                debugMetaKey,\n                segment.meta,\n                lastBreakpoint,\n                result,\n            )\n        ) {\n            didHitMaxIterations = false;\n            break;\n        }\n\n        const windowEndPosition = computeWindowEndPositionForIteration(\n            remainingContent,\n            cursorPos,\n            currentFromIdx,\n            fromIdx,\n            windowEndIdx,\n            toIdx,\n            pageIds,\n            boundaryPositions,\n            normalizedPages,\n            cumulativeOffsets,\n            maxPages,\n            maxContentLength,\n            logger,\n        );\n\n        // Per-iteration log at trace level to avoid spam in debug mode\n        logger?.trace?.(`[breakpoints] iteration=${i}`, { currentFromIdx, cursorPos, windowEndIdx, windowEndPosition });\n\n        const found = findBreakOffsetForWindow(\n            remainingContent,\n            currentFromIdx,\n            windowEndIdx,\n            toIdx,\n            windowEndPosition,\n            pageIds,\n            expandedBreakpoints,\n            cumulativeOffsets,\n            normalizedPages,\n            prefer,\n            maxContentLength,\n        );\n\n        const breakOffset = ensureProgressingBreakOffset(\n            found.breakOffset,\n            remainingContent,\n            cursorPos,\n            maxContentLength,\n            logger,\n        );\n        lastBreakpoint = updateLastBreakpointFromFound(found, lastBreakpoint);\n\n        const breakPos = cursorPos + breakOffset;\n        const pieceContent = fullContent.slice(cursorPos, breakPos).trim();\n        if (!pieceContent) {\n            cursorPos = breakPos;\n            isFirstPiece = false;\n            continue;\n        }\n\n        const next = appendPieceAndAdvance(\n            fullContent,\n            cursorPos,\n            breakPos,\n            pieceContent,\n            currentFromIdx,\n            fromIdx,\n            toIdx,\n            pageIds,\n            boundaryPositions,\n            normalizedPages,\n            maxPages,\n            isFirstPiece,\n            debugMetaKey,\n            segment.meta,\n            lastBreakpoint,\n            result,\n            logger,\n            found.contentLengthSplit,\n        );\n        cursorPos = next.cursorPos;\n        currentFromIdx = next.currentFromIdx;\n        isFirstPiece = false;\n    }\n\n    if (didHitMaxIterations) {\n        logger?.error?.('[breakpoints] Stopped processing oversized segment: reached MAX_SAFE_ITERATIONS', {\n            cursorPos,\n            fullContentLength: fullContent.length,\n            iterations: MAX_SAFE_ITERATIONS,\n        });\n    }\n\n    logger?.debug?.('[breakpoints] processOversizedSegment: Complete', { resultCount: result.length });\n    return result;\n};\n\n/**\n * Applies breakpoints to oversized segments.\n *\n * Note: This is an internal engine used by `segmentPages()`.\n */\n/**\n * Processes an oversized segment by iterating through the content and\n * breaking it into smaller pieces that fit within maxPages constraints.\n *\n * Uses precomputed boundary positions for O(log n) page attribution lookups.\n */\nconst processOversizedSegment = (\n    segment: Segment,\n    fromIdx: number,\n    toIdx: number,\n    pageIds: number[],\n    normalizedPages: Map<number, NormalizedPage>,\n    cumulativeOffsets: number[],\n    expandedBreakpoints: ReturnType<typeof expandBreakpoints>,\n    maxPages: number,\n    prefer: 'longer' | 'shorter',\n    logger?: Logger,\n    debugMetaKey?: string,\n    maxContentLength?: number,\n) => {\n    const fast = tryProcessOversizedSegmentFastPath(\n        segment,\n        fromIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        expandedBreakpoints,\n        maxPages,\n        logger,\n        debugMetaKey,\n        maxContentLength,\n    );\n    if (fast) {\n        return fast;\n    }\n\n    return processOversizedSegmentIterative(\n        segment,\n        fromIdx,\n        toIdx,\n        pageIds,\n        normalizedPages,\n        cumulativeOffsets,\n        expandedBreakpoints,\n        maxPages,\n        prefer,\n        logger,\n        debugMetaKey,\n        maxContentLength,\n    );\n};\n\nexport const applyBreakpoints = (\n    segments: Segment[],\n    pages: Page[],\n    normalizedContent: string[],\n    maxPages: number,\n    breakpoints: Breakpoint[],\n    prefer: 'longer' | 'shorter',\n    patternProcessor: PatternProcessor,\n    logger?: Logger,\n    pageJoiner: 'space' | 'newline' = 'space',\n    debugMetaKey?: string,\n    maxContentLength?: number,\n    rawPatternProcessor?: PatternProcessor,\n) => {\n    const pageIds = pages.map((p) => p.id);\n    const pageIdToIndex = buildPageIdToIndexMap(pageIds);\n    const normalizedPages = buildNormalizedPagesMap(pages, normalizedContent);\n    const cumulativeOffsets = buildCumulativeOffsets(pageIds, normalizedPages);\n    const expandedBreakpoints = expandBreakpoints(breakpoints, patternProcessor, rawPatternProcessor);\n\n    const result: Segment[] = [];\n\n    logger?.info?.('Starting breakpoint processing', { maxPages, segmentCount: segments.length });\n\n    logger?.debug?.('[breakpoints] inputSegments', {\n        segmentCount: segments.length,\n        segments: segments.map((s) => ({ contentLength: s.content.length, from: s.from, to: s.to })),\n    });\n\n    for (const segment of segments) {\n        const fromIdx = pageIdToIndex.get(segment.from) ?? -1;\n        const toIdx = segment.to !== undefined ? (pageIdToIndex.get(segment.to) ?? fromIdx) : fromIdx;\n\n        const segmentSpan = (segment.to ?? segment.from) - segment.from;\n        const hasExclusions = hasAnyExclusionsInRange(expandedBreakpoints, pageIds, fromIdx, toIdx);\n\n        const fitsInPages = segmentSpan <= maxPages;\n        const fitsInLength = !maxContentLength || segment.content.length <= maxContentLength;\n\n        if (fitsInPages && fitsInLength && !hasExclusions) {\n            result.push(segment);\n            continue;\n        }\n\n        // Log details about why this segment needs breaking up\n        logger?.debug?.('[breakpoints] Processing oversized segment', {\n            contentLength: segment.content.length,\n            from: segment.from,\n            hasExclusions,\n            pageSpan: toIdx - fromIdx + 1,\n            reasonFitsInLength: fitsInLength,\n            reasonFitsInPages: fitsInPages,\n            to: segment.to,\n        });\n\n        const broken = processOversizedSegment(\n            segment,\n            fromIdx,\n            toIdx,\n            pageIds,\n            normalizedPages,\n            cumulativeOffsets,\n            expandedBreakpoints,\n            maxPages,\n            prefer,\n            logger,\n            debugMetaKey,\n            maxContentLength,\n        );\n\n        // Normalize page joins for breakpoint-created pieces\n        result.push(\n            ...broken.map((s) => {\n                const segFromIdx = pageIdToIndex.get(s.from) ?? -1;\n                const segToIdx = s.to !== undefined ? (pageIdToIndex.get(s.to) ?? segFromIdx) : segFromIdx;\n                if (segFromIdx >= 0 && segToIdx > segFromIdx) {\n                    return {\n                        ...s,\n                        content: applyPageJoinerBetweenPages(\n                            s.content,\n                            segFromIdx,\n                            segToIdx,\n                            pageIds,\n                            normalizedPages,\n                            pageJoiner,\n                        ),\n                    };\n                }\n                return s;\n            }),\n        );\n    }\n\n    logger?.info?.('Breakpoint processing completed', { resultCount: result.length });\n    return result;\n};\n","import type { SplitRule } from '@/types/rules.js';\nimport { isPageExcluded } from './breakpoint-utils.js';\n\n/**\n * Result of a regex match with position and optional capture information.\n *\n * Represents a single match found by the segmentation engine, including\n * its position in the concatenated content and any captured values.\n */\nexport type MatchResult = {\n    /**\n     * Start offset (inclusive) of the match in the content string.\n     */\n    start: number;\n\n    /**\n     * End offset (exclusive) of the match in the content string.\n     *\n     * The matched text is `content.slice(start, end)`.\n     */\n    end: number;\n\n    /**\n     * Content captured by `lineStartsAfter` patterns.\n     *\n     * For patterns like `^٦٦٩٦ - (.*)`, this contains the text\n     * matched by the `(.*)` group (the rest of the line after the marker).\n     */\n    captured?: string;\n\n    /**\n     * Named capture group values from `{{token:name}}` syntax.\n     *\n     * Keys are the capture names, values are the matched strings.\n     *\n     * @example\n     * // For pattern '{{raqms:num}} {{dash}}'\n     * { num: '٦٦٩٦' }\n     */\n    namedCaptures?: Record<string, string>;\n};\n\n/**\n * Extracts named capture groups from a regex match.\n *\n * Only includes groups that are in the `captureNames` list and have\n * defined values. This filters out positional captures and ensures\n * only explicitly requested named captures are returned.\n *\n * @param groups - The `match.groups` object from `RegExp.exec()`\n * @param captureNames - List of capture names to extract (from `{{token:name}}` syntax)\n * @returns Object with capture name → value pairs, or `undefined` if none found\n *\n * @example\n * const match = /(?<num>[٠-٩]+) -/.exec('٦٦٩٦ - text');\n * extractNamedCaptures(match.groups, ['num'])\n * // → { num: '٦٦٩٦' }\n *\n * @example\n * // No matching captures\n * extractNamedCaptures({}, ['num'])\n * // → undefined\n *\n * @example\n * // Undefined groups\n * extractNamedCaptures(undefined, ['num'])\n * // → undefined\n */\nexport const extractNamedCaptures = (groups: Record<string, string> | undefined, captureNames: string[]) => {\n    if (!groups || captureNames.length === 0) {\n        return undefined;\n    }\n    const namedCaptures: Record<string, string> = {};\n    for (const name of captureNames) {\n        if (groups[name] !== undefined) {\n            namedCaptures[name] = groups[name];\n        }\n    }\n    return Object.keys(namedCaptures).length > 0 ? namedCaptures : undefined;\n};\n\n/**\n * Gets the last defined positional capture group from a match array.\n *\n * Used for `lineStartsAfter` patterns where the content capture (`.*`)\n * is always at the end of the pattern. Named captures may shift the\n * positional indices, so we iterate backward to find the actual content.\n *\n * @param match - RegExp exec result array\n * @returns The last defined capture group value, or `undefined` if none\n *\n * @example\n * // Pattern: ^(?:(?<num>[٠-٩]+) - )(.*)\n * // Match array: ['٦٦٩٦ - content', '٦٦٩٦', 'content']\n * getLastPositionalCapture(match)\n * // → 'content'\n *\n * @example\n * // No captures\n * getLastPositionalCapture(['full match'])\n * // → undefined\n */\nexport const getLastPositionalCapture = (match: RegExpExecArray) => {\n    if (match.length <= 1) {\n        return undefined;\n    }\n    for (let i = match.length - 1; i >= 1; i--) {\n        if (match[i] !== undefined) {\n            return match[i];\n        }\n    }\n    return undefined;\n};\n\n/**\n * Filters matches to only include those within page ID constraints.\n *\n * Applies the `min`, `max`, and `exclude` constraints from a rule to filter out\n * matches that occur on pages outside the allowed range or explicitly excluded.\n *\n * @param matches - Array of match results to filter\n * @param rule - Rule containing `min`, `max`, and/or `exclude` page constraints\n * @param getId - Function that returns the page ID for a given offset\n * @returns Filtered array containing only matches within constraints\n *\n * @example\n * const matches = [\n *   { start: 0, end: 10 },   // Page 1\n *   { start: 100, end: 110 }, // Page 5\n *   { start: 200, end: 210 }, // Page 10\n * ];\n * filterByConstraints(matches, { min: 3, max: 8 }, getId)\n * // → [{ start: 100, end: 110 }] (only page 5 match)\n */\nexport const filterByConstraints = (\n    matches: MatchResult[],\n    rule: Pick<SplitRule, 'min' | 'max' | 'exclude'>,\n    getId: (offset: number) => number,\n) =>\n    matches.filter((m) => {\n        const id = getId(m.start);\n        return (\n            (rule.min === undefined || id >= rule.min) &&\n            (rule.max === undefined || id <= rule.max) &&\n            !isPageExcluded(id, rule.exclude)\n        );\n    });\n\n/**\n * Filters matches based on occurrence setting (first, last, or all).\n *\n * Applies occurrence-based selection to a list of matches:\n * - `'all'` or `undefined`: Return all matches (default)\n * - `'first'`: Return only the first match\n * - `'last'`: Return only the last match\n *\n * @param matches - Array of match results to filter\n * @param occurrence - Which occurrence(s) to keep\n * @returns Filtered array based on occurrence setting\n *\n * @example\n * const matches = [{ start: 0 }, { start: 10 }, { start: 20 }];\n *\n * filterByOccurrence(matches, 'first')\n * // → [{ start: 0 }]\n *\n * filterByOccurrence(matches, 'last')\n * // → [{ start: 20 }]\n *\n * filterByOccurrence(matches, 'all')\n * // → [{ start: 0 }, { start: 10 }, { start: 20 }]\n *\n * filterByOccurrence(matches, undefined)\n * // → [{ start: 0 }, { start: 10 }, { start: 20 }] (default: all)\n */\nexport const filterByOccurrence = (matches: MatchResult[], occurrence?: 'first' | 'last' | 'all') => {\n    if (!matches.length) {\n        return [];\n    }\n    if (occurrence === 'first') {\n        return [matches[0]];\n    }\n    if (occurrence === 'last') {\n        return [matches.at(-1)!];\n    }\n    return matches;\n};\n\n/**\n * Checks if any rule in the list allows the given page ID.\n *\n * A rule allows an ID if it falls within the rule's `min`/`max` constraints.\n * Rules without constraints allow all page IDs.\n *\n * This is used to determine whether to create a segment for content\n * that appears before any split points (the \"first segment\").\n *\n * @param rules - Array of rules with optional `min` and `max` constraints\n * @param pageId - Page ID to check\n * @returns `true` if at least one rule allows the page ID\n *\n * @example\n * const rules = [\n *   { min: 5, max: 10 },  // Allows pages 5-10\n *   { min: 20 },          // Allows pages 20+\n * ];\n *\n * anyRuleAllowsId(rules, 7)   // → true (first rule allows)\n * anyRuleAllowsId(rules, 3)   // → false (no rule allows)\n * anyRuleAllowsId(rules, 25)  // → true (second rule allows)\n *\n * @example\n * // Rules without constraints allow everything\n * anyRuleAllowsId([{}], 999) // → true\n */\nexport const anyRuleAllowsId = (rules: Pick<SplitRule, 'min' | 'max'>[], pageId: number) =>\n    rules.some((r) => (r.min === undefined || pageId >= r.min) && (r.max === undefined || pageId <= r.max));\n","/**\n * Fast-path fuzzy prefix matching for common Arabic line-start markers.\n *\n * This exists to avoid running expensive fuzzy-expanded regex alternations over\n * a giant concatenated string. Instead, we match only at known line-start\n * offsets and perform a small deterministic comparison:\n * - Skip Arabic diacritics in the CONTENT\n * - Treat common equivalence groups as equal (ا/آ/أ/إ, ة/ه, ى/ي)\n *\n * This module is intentionally conservative: it only supports \"literal\"\n * token patterns (plain text alternation via `|`), not general regex.\n */\n\nimport { getTokenPattern } from './tokens.js';\n\nexport type FastFuzzyTokenRule = {\n    token: string;\n    alternatives: string[];\n};\n\n// U+064B..U+0652 (tashkeel/harakat)\nconst isArabicDiacriticCode = (code: number) => code >= 0x064b && code <= 0x0652;\n\nconst equivKey = (ch: string) => {\n    switch (ch) {\n        case '\\u0622': // آ\n        case '\\u0623': // أ\n        case '\\u0625': // إ\n            return '\\u0627'; // ا\n        case '\\u0647': // ه\n            return '\\u0629'; // ة\n        case '\\u064a': // ي\n            return '\\u0649'; // ى\n        default:\n            return ch;\n    }\n};\n\nexport const matchFuzzyLiteralPrefixAt = (content: string, offset: number, literal: string) => {\n    let i = offset;\n    while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) {\n        i++;\n    }\n\n    for (let j = 0; j < literal.length; j++) {\n        const litCh = literal[j];\n        while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) {\n            i++;\n        }\n        if (i >= content.length || equivKey(content[i]) !== equivKey(litCh)) {\n            return null;\n        }\n        i++;\n    }\n\n    while (i < content.length && isArabicDiacriticCode(content.charCodeAt(i))) {\n        i++;\n    }\n    return i;\n};\n\nconst isLiteralOnly = (s: string) => !/[\\\\[\\]{}()^$.*+?]/.test(s);\n\nexport const compileLiteralAlternation = (pattern: string) => {\n    if (!pattern || !isLiteralOnly(pattern)) {\n        return null;\n    }\n    const alternatives = pattern\n        .split('|')\n        .map((s) => s.trim())\n        .filter(Boolean);\n    return alternatives.length ? { alternatives } : null;\n};\n\nexport const compileFastFuzzyTokenRule = (tokenTemplate: string) => {\n    const m = tokenTemplate.match(/^\\{\\{(\\w+)\\}\\}$/);\n    if (!m) {\n        return null;\n    }\n    const token = m[1];\n    const tokenPattern = getTokenPattern(token);\n    if (!tokenPattern) {\n        return null;\n    }\n    const compiled = compileLiteralAlternation(tokenPattern);\n    return compiled ? { alternatives: compiled.alternatives, token } : null;\n};\n\nexport const matchFastFuzzyTokenAt = (content: string, offset: number, compiled: FastFuzzyTokenRule) => {\n    for (const alt of compiled.alternatives) {\n        const end = matchFuzzyLiteralPrefixAt(content, offset, alt);\n        if (end !== null) {\n            return end;\n        }\n    }\n    return null;\n};\n","import type { SplitRule } from '@/types/rules.js';\nimport type { PageMap, SplitPoint } from '@/types/segmenter.js';\nimport { isPageExcluded } from './breakpoint-utils.js';\nimport { compileFastFuzzyTokenRule, type FastFuzzyTokenRule, matchFastFuzzyTokenAt } from './fast-fuzzy-prefix.js';\nimport { extractNamedCaptureNames, hasCapturingGroup, processPattern } from './rule-regex.js';\n\nexport type FastFuzzyRule = {\n    compiled: FastFuzzyTokenRule;\n    rule: SplitRule;\n    ruleIndex: number;\n    kind: 'startsWith' | 'startsAfter';\n};\n\nexport type PartitionedRules = {\n    combinableRules: Array<{ rule: SplitRule; prefix: string; index: number }>;\n    standaloneRules: SplitRule[];\n    fastFuzzyRules: FastFuzzyRule[];\n};\n\nexport const partitionRulesForMatching = (rules: SplitRule[]) => {\n    const combinableRules: { rule: SplitRule; prefix: string; index: number }[] = [];\n    const standaloneRules: SplitRule[] = [];\n    const fastFuzzyRules: FastFuzzyRule[] = [];\n\n    rules.forEach((rule, index) => {\n        const fuzzy = (rule as { fuzzy?: boolean }).fuzzy;\n        if (fuzzy) {\n            if ('lineStartsWith' in rule && rule.lineStartsWith.length === 1) {\n                const compiled = compileFastFuzzyTokenRule(rule.lineStartsWith[0]);\n                if (compiled) {\n                    return fastFuzzyRules.push({ compiled, kind: 'startsWith', rule, ruleIndex: index });\n                }\n            }\n            if ('lineStartsAfter' in rule && rule.lineStartsAfter.length === 1) {\n                const compiled = compileFastFuzzyTokenRule(rule.lineStartsAfter[0]);\n                if (compiled) {\n                    return fastFuzzyRules.push({ compiled, kind: 'startsAfter', rule, ruleIndex: index });\n                }\n            }\n        }\n\n        let isCombinable = true;\n        if ('regex' in rule && rule.regex) {\n            isCombinable =\n                extractNamedCaptureNames(rule.regex).length === 0 &&\n                !/\\\\[1-9]/.test(rule.regex) &&\n                !hasCapturingGroup(rule.regex);\n        }\n\n        if (isCombinable) {\n            combinableRules.push({ index, prefix: `r${index}_`, rule });\n        } else {\n            standaloneRules.push(rule);\n        }\n    });\n\n    return { combinableRules, fastFuzzyRules, standaloneRules };\n};\n\nexport type PageStartGuardChecker = (rule: SplitRule, ruleIndex: number, matchStart: number) => boolean;\n\nexport const createPageStartGuardChecker = (matchContent: string, pageMap: PageMap) => {\n    const pageStartToBoundaryIndex = new Map(pageMap.boundaries.map((b, i) => [b.start, i]));\n    const compiledPageStartPrev = new Map<number, RegExp | null>();\n\n    const getPageStartPrevRegex = (rule: SplitRule, ruleIndex: number) => {\n        if (compiledPageStartPrev.has(ruleIndex)) {\n            return compiledPageStartPrev.get(ruleIndex) ?? null;\n        }\n        const pattern = (rule as { pageStartGuard?: string }).pageStartGuard;\n        if (!pattern) {\n            compiledPageStartPrev.set(ruleIndex, null);\n            return null;\n        }\n        const re = new RegExp(`(?:${processPattern(pattern, false).pattern})$`, 'u');\n        compiledPageStartPrev.set(ruleIndex, re);\n        return re;\n    };\n\n    const getPrevPageLastNonWsChar = (boundaryIndex: number) => {\n        if (boundaryIndex <= 0) {\n            return '';\n        }\n        const prevBoundary = pageMap.boundaries[boundaryIndex - 1];\n        for (let i = prevBoundary.end - 1; i >= prevBoundary.start; i--) {\n            const ch = matchContent[i];\n            if (ch && !/\\s/u.test(ch)) {\n                return ch;\n            }\n        }\n        return '';\n    };\n\n    return (rule: SplitRule, ruleIndex: number, matchStart: number) => {\n        const boundaryIndex = pageStartToBoundaryIndex.get(matchStart);\n        if (boundaryIndex === undefined || boundaryIndex === 0) {\n            return true;\n        }\n        const prevReq = getPageStartPrevRegex(rule, ruleIndex);\n        if (!prevReq) {\n            return true;\n        }\n        const lastChar = getPrevPageLastNonWsChar(boundaryIndex);\n        return lastChar ? prevReq.test(lastChar) : false;\n    };\n};\n\n/**\n * Checks if a pageId matches the min/max/exclude constraints of a rule.\n */\nconst passesRuleConstraints = (rule: SplitRule, pageId: number) =>\n    (rule.min === undefined || pageId >= rule.min) &&\n    (rule.max === undefined || pageId <= rule.max) &&\n    !isPageExcluded(pageId, rule.exclude);\n\n/**\n * Records a split point for a specific rule.\n */\nconst recordSplitPointAt = (splitPointsByRule: Map<number, SplitPoint[]>, ruleIndex: number, sp: SplitPoint) => {\n    const arr = splitPointsByRule.get(ruleIndex);\n    if (!arr) {\n        splitPointsByRule.set(ruleIndex, [sp]);\n    } else {\n        arr.push(sp);\n    }\n};\n\n/**\n * Processes matches for all fast-fuzzy rules at a specific line start.\n */\nconst processFastFuzzyMatchesAt = (\n    matchContent: string,\n    lineStart: number,\n    pageId: number,\n    fastFuzzyRules: FastFuzzyRule[],\n    passesPageStartGuard: PageStartGuardChecker,\n    isPageStart: boolean,\n    splitPointsByRule: Map<number, SplitPoint[]>,\n) => {\n    for (const { compiled, kind, rule, ruleIndex } of fastFuzzyRules) {\n        if (!passesRuleConstraints(rule, pageId)) {\n            continue;\n        }\n\n        if (isPageStart && !passesPageStartGuard(rule, ruleIndex, lineStart)) {\n            continue;\n        }\n\n        const end = matchFastFuzzyTokenAt(matchContent, lineStart, compiled);\n        if (end === null) {\n            continue;\n        }\n\n        const splitIndex = (rule.split ?? 'at') === 'at' ? lineStart : end;\n        if (kind === 'startsWith') {\n            recordSplitPointAt(splitPointsByRule, ruleIndex, { index: splitIndex, meta: rule.meta });\n        } else {\n            const markerLength = end - lineStart;\n            recordSplitPointAt(splitPointsByRule, ruleIndex, {\n                contentStartOffset: (rule.split ?? 'at') === 'at' ? markerLength : undefined,\n                index: splitIndex,\n                meta: rule.meta,\n            });\n        }\n    }\n};\n\nexport const collectFastFuzzySplitPoints = (\n    matchContent: string,\n    pageMap: PageMap,\n    fastFuzzyRules: FastFuzzyRule[],\n    passesPageStartGuard: PageStartGuardChecker,\n) => {\n    const splitPointsByRule = new Map<number, SplitPoint[]>();\n    if (fastFuzzyRules.length === 0 || pageMap.boundaries.length === 0) {\n        return splitPointsByRule;\n    }\n\n    // Stream page boundary cursor to avoid O(log n) getId calls in hot loop.\n    let boundaryIdx = 0;\n    let currentBoundary = pageMap.boundaries[boundaryIdx];\n    const advanceBoundaryTo = (offset: number) => {\n        while (currentBoundary && offset > currentBoundary.end && boundaryIdx < pageMap.boundaries.length - 1) {\n            boundaryIdx++;\n            currentBoundary = pageMap.boundaries[boundaryIdx];\n        }\n    };\n\n    const isPageStart = (offset: number) => offset === currentBoundary?.start;\n\n    // Line starts are offset 0 and any char after '\\n'\n    for (let lineStart = 0; lineStart <= matchContent.length; ) {\n        advanceBoundaryTo(lineStart);\n        const pageId = currentBoundary?.id ?? 0;\n\n        if (lineStart >= matchContent.length) {\n            break;\n        }\n\n        processFastFuzzyMatchesAt(\n            matchContent,\n            lineStart,\n            pageId,\n            fastFuzzyRules,\n            passesPageStartGuard,\n            isPageStart(lineStart),\n            splitPointsByRule,\n        );\n\n        const nextNl = matchContent.indexOf('\\n', lineStart);\n        if (nextNl === -1) {\n            break;\n        }\n        lineStart = nextNl + 1;\n    }\n\n    return splitPointsByRule;\n};\n","/**\n * Helper module for collectSplitPointsFromRules to reduce complexity.\n * Handles combined regex matching and split point creation.\n */\n\nimport type { Logger } from '@/types/options.js';\nimport type { SplitRule } from '@/types/rules.js';\nimport type { PageMap, SplitPoint } from '../types/segmenter.js';\nimport { isPageExcluded } from './breakpoint-utils.js';\nimport { buildRuleDebugPatch, mergeDebugIntoMeta } from './debug-meta.js';\nimport {\n    extractNamedCaptures,\n    filterByConstraints,\n    getLastPositionalCapture,\n    type MatchResult,\n} from './match-utils.js';\nimport { buildRuleRegex, type RuleRegex } from './rule-regex.js';\n\n// Maximum iterations before throwing to prevent infinite loops\nconst MAX_REGEX_ITERATIONS = 100000;\n\ntype CombinableRule = { rule: SplitRule; prefix: string; index: number };\n\ntype RuleRegexInfo = RuleRegex & { prefix: string; source: string };\n\n// Combined regex matching\n\nconst extractNamedCapturesForRule = (\n    groups: Record<string, string> | undefined,\n    captureNames: string[],\n    prefix: string,\n) => {\n    const result: Record<string, string> = {};\n    if (!groups) {\n        return result;\n    }\n    for (const name of captureNames) {\n        if (groups[name] !== undefined) {\n            result[name.slice(prefix.length)] = groups[name];\n        }\n    }\n    return result;\n};\n\nconst buildContentOffsets = (\n    match: RegExpExecArray,\n    ruleInfo: RuleRegexInfo,\n): { capturedContent?: string; contentStartOffset?: number } => {\n    if (!ruleInfo.usesLineStartsAfter) {\n        return {};\n    }\n\n    const captured = match.groups?.[`${ruleInfo.prefix}__content`];\n    if (captured === undefined) {\n        return {};\n    }\n\n    const fullMatch = match.groups?.[ruleInfo.prefix] || match[0];\n    return { contentStartOffset: fullMatch.length - captured.length };\n};\n\nconst passesRuleConstraints = (rule: SplitRule, pageId: number) =>\n    (rule.min === undefined || pageId >= rule.min) &&\n    (rule.max === undefined || pageId <= rule.max) &&\n    !isPageExcluded(pageId, rule.exclude);\n\nconst createSplitPointFromMatch = (match: RegExpExecArray, rule: SplitRule, ruleInfo: RuleRegexInfo): SplitPoint => {\n    const namedCaptures = extractNamedCapturesForRule(match.groups, ruleInfo.captureNames, ruleInfo.prefix);\n    return {\n        capturedContent: undefined,\n        contentStartOffset: buildContentOffsets(match, ruleInfo).contentStartOffset,\n        index: (rule.split ?? 'at') === 'at' ? match.index : match.index + match[0].length,\n        meta: rule.meta,\n        namedCaptures: Object.keys(namedCaptures).length > 0 ? namedCaptures : undefined,\n    };\n};\n\nexport const processCombinedMatches = (\n    matchContent: string,\n    combinableRules: CombinableRule[],\n    ruleRegexes: RuleRegexInfo[],\n    pageMap: PageMap,\n    passesPageStartGuard: (rule: SplitRule, index: number, pos: number) => boolean,\n    splitPointsByRule: Map<number, SplitPoint[]>,\n    logger?: Logger,\n) => {\n    const combinedSource = ruleRegexes.map((r) => r.source).join('|');\n    const combinedRegex = new RegExp(combinedSource, 'gm');\n\n    logger?.debug?.('[segmenter] combined regex built', {\n        combinableRuleCount: combinableRules.length,\n        combinedSourceLength: combinedSource.length,\n    });\n\n    let m = combinedRegex.exec(matchContent);\n    let iterations = 0;\n\n    while (m !== null) {\n        if (++iterations > MAX_REGEX_ITERATIONS) {\n            throw new Error(\n                `[segmenter] Possible infinite loop: exceeded ${MAX_REGEX_ITERATIONS} iterations at position ${m.index}.`,\n            );\n        }\n        if (iterations % 10000 === 0) {\n            logger?.warn?.('[segmenter] high iteration count', { iterations, position: m.index });\n        }\n\n        const matchedIndex = combinableRules.findIndex(({ prefix }) => m?.groups?.[prefix] !== undefined);\n        if (matchedIndex !== -1) {\n            const { rule, index: originalIndex } = combinableRules[matchedIndex];\n            if (\n                passesRuleConstraints(rule, pageMap.getId(m.index)) &&\n                passesPageStartGuard(rule, originalIndex, m.index)\n            ) {\n                const arr = splitPointsByRule.get(originalIndex);\n                if (!arr) {\n                    splitPointsByRule.set(originalIndex, [\n                        createSplitPointFromMatch(m, rule, ruleRegexes[matchedIndex]),\n                    ]);\n                } else {\n                    arr.push(createSplitPointFromMatch(m, rule, ruleRegexes[matchedIndex]));\n                }\n            }\n        }\n        if (m[0].length === 0) {\n            combinedRegex.lastIndex++;\n        }\n        m = combinedRegex.exec(matchContent);\n    }\n};\n\nexport const buildRuleRegexes = (combinableRules: CombinableRule[]) =>\n    combinableRules.map(({ rule, prefix }) => {\n        const built = buildRuleRegex(rule, prefix);\n        return { ...built, prefix, source: `(?<${prefix}>${built.regex.source})` };\n    });\n\nexport const processStandaloneRule = (\n    rule: SplitRule,\n    ruleIndex: number,\n    matchContent: string,\n    pageMap: PageMap,\n    passesPageStartGuard: (rule: SplitRule, index: number, pos: number) => boolean,\n    splitPointsByRule: Map<number, SplitPoint[]>,\n) => {\n    const { regex, usesCapture, captureNames, usesLineStartsAfter } = buildRuleRegex(rule);\n    const allMatches = findMatchesInContent(matchContent, regex, usesCapture, captureNames);\n    const constrained = filterByConstraints(allMatches, rule, pageMap.getId);\n    const points = constrained\n        .filter((m) => passesPageStartGuard(rule, ruleIndex, m.start))\n        .map((m) => {\n            const isLSA = usesLineStartsAfter && m.captured !== undefined;\n            return {\n                capturedContent: isLSA ? undefined : m.captured,\n                contentStartOffset: isLSA ? m.end - m.captured!.length - m.start : undefined,\n                index: (rule.split ?? 'at') === 'at' ? m.start : m.end,\n                meta: rule.meta,\n                namedCaptures: m.namedCaptures,\n            };\n        });\n\n    const arr = splitPointsByRule.get(ruleIndex);\n    if (!arr) {\n        splitPointsByRule.set(ruleIndex, points);\n    } else {\n        arr.push(...points);\n    }\n};\n\nconst findMatchesInContent = (content: string, regex: RegExp, usesCapture: boolean, captureNames: string[]) => {\n    const matches: MatchResult[] = [];\n    let m = regex.exec(content);\n\n    while (m !== null) {\n        matches.push({\n            captured: usesCapture ? getLastPositionalCapture(m) : undefined,\n            end: m.index + m[0].length,\n            namedCaptures: extractNamedCaptures(m.groups, captureNames),\n            start: m.index,\n        });\n        if (m[0].length === 0) {\n            regex.lastIndex++;\n        }\n        m = regex.exec(content);\n    }\n\n    return matches;\n};\n\n// Occurrence filtering\n\nexport const applyOccurrenceFilter = (\n    rules: SplitRule[],\n    splitPointsByRule: Map<number, SplitPoint[]>,\n    debugMetaKey?: string,\n) => {\n    const result: SplitPoint[] = [];\n\n    rules.forEach((rule, index) => {\n        const points = splitPointsByRule.get(index);\n        if (!points?.length) {\n            return;\n        }\n\n        const filtered =\n            rule.occurrence === 'first' ? [points[0]] : rule.occurrence === 'last' ? [points.at(-1)!] : points;\n        const debugPatch = debugMetaKey ? buildRuleDebugPatch(index, rule) : null;\n\n        result.push(\n            ...filtered.map((p) => ({\n                ...p,\n                meta: debugMetaKey ? mergeDebugIntoMeta(p.meta, debugMetaKey, debugPatch!) : p.meta,\n                ruleIndex: index,\n            })),\n        );\n    });\n    return result;\n};\n","import type { Page, Segment } from '@/types';\nimport type { Logger, SegmentationOptions } from '@/types/options.js';\nimport type { SplitRule } from '@/types/rules.js';\nimport { normalizeLineEndings } from '@/utils/textUtils.js';\nimport type { PageBoundary, PageMap, SplitPoint } from '../types/segmenter.js';\nimport { applyBreakpoints } from './breakpoint-processor.js';\nimport { resolveDebugConfig } from './debug-meta.js';\nimport { anyRuleAllowsId } from './match-utils.js';\nimport { processBreakpointPattern, processPattern } from './rule-regex.js';\nimport {\n    collectFastFuzzySplitPoints,\n    createPageStartGuardChecker,\n    partitionRulesForMatching,\n} from './segmenter-rule-utils.js';\nimport {\n    applyOccurrenceFilter,\n    buildRuleRegexes,\n    processCombinedMatches,\n    processStandaloneRule,\n} from './split-point-helpers.js';\n\n/**\n * Builds a concatenated content string and page mapping from input pages.\n *\n * Pages are joined with newline characters, and a page map is created to\n * track which page each offset belongs to. This allows pattern matching\n * across page boundaries while preserving page reference information.\n *\n * @param pages - Array of input pages with id and content\n * @returns Concatenated content string and page mapping utilities\n *\n * @example\n * const pages = [\n *   { id: 1, content: 'Page 1 text' },\n *   { id: 2, content: 'Page 2 text' }\n * ];\n * const { content, pageMap } = buildPageMap(pages);\n * // content = 'Page 1 text\\nPage 2 text'\n * // pageMap.getId(0) = 1\n * // pageMap.getId(12) = 2\n */\nconst buildPageMap = (pages: Page[]) => {\n    const boundaries: PageBoundary[] = [];\n    const pageBreaks: number[] = [];\n    let offset = 0;\n    const parts: string[] = [];\n\n    for (let i = 0; i < pages.length; i++) {\n        const normalized = normalizeLineEndings(pages[i].content);\n        boundaries.push({ end: offset + normalized.length, id: pages[i].id, start: offset });\n        parts.push(normalized);\n        if (i < pages.length - 1) {\n            pageBreaks.push(offset + normalized.length);\n            offset += normalized.length + 1;\n        } else {\n            offset += normalized.length;\n        }\n    }\n\n    const findBoundary = (off: number) => {\n        let lo = 0,\n            hi = boundaries.length - 1;\n        while (lo <= hi) {\n            const mid = (lo + hi) >>> 1;\n            const b = boundaries[mid];\n            if (off < b.start) {\n                hi = mid - 1;\n            } else if (off > b.end) {\n                lo = mid + 1;\n            } else {\n                return b;\n            }\n        }\n        return boundaries.at(-1);\n    };\n\n    return {\n        content: parts.join('\\n'),\n        normalizedPages: parts,\n        pageMap: {\n            boundaries,\n            getId: (off: number) => findBoundary(off)?.id ?? 0,\n            pageBreaks,\n            pageIds: boundaries.map((b) => b.id),\n        },\n    };\n};\n\n/**\n * Deduplicate split points by index, preferring ones with more information.\n *\n * Preference rules (when same index):\n * - Prefer a split with `contentStartOffset` (needed for `lineStartsAfter` marker stripping)\n * - Otherwise prefer a split with `meta` over one without\n */\nexport const dedupeSplitPoints = (splitPoints: SplitPoint[]) => {\n    const byIndex = new Map<number, SplitPoint>();\n    for (const p of splitPoints) {\n        const existing = byIndex.get(p.index);\n        const hasMoreInfo =\n            !existing ||\n            (p.contentStartOffset !== undefined && existing.contentStartOffset === undefined) ||\n            (p.meta !== undefined && existing.meta === undefined);\n        if (hasMoreInfo) {\n            byIndex.set(p.index, p);\n        }\n    }\n    return [...byIndex.values()].sort((a, b) => a.index - b.index);\n};\n\n/**\n * If no structural rules produced segments, create a single segment spanning all pages.\n * This allows breakpoint processing to still run.\n */\nexport const ensureFallbackSegment = (\n    segments: Segment[],\n    pages: Page[],\n    normalizedContent: string[],\n    pageJoiner: 'space' | 'newline',\n) => {\n    if (segments.length > 0 || pages.length === 0) {\n        return segments;\n    }\n\n    const firstPage = pages[0];\n    const lastPage = pages.at(-1)!;\n    const joiner = pageJoiner === 'newline' ? '\\n' : ' ';\n    const joined = normalizedContent.join(joiner);\n    // Important: do NOT trimStart here.\n    // Trimming the leading content can desync cumulative offsets/boundary positions in breakpoint processing\n    // for very large fallback segments, causing incorrect page attribution and maxPages violations.\n    const allContent = joined.replace(/\\s+$/u, '');\n    if (!allContent.trim()) {\n        return segments;\n    }\n\n    const initialSeg: Segment = { content: allContent, from: firstPage.id };\n    if (lastPage.id !== firstPage.id) {\n        initialSeg.to = lastPage.id;\n    }\n    return [initialSeg];\n};\n\nconst collectSplitPointsFromRules = (\n    rules: SplitRule[],\n    matchContent: string,\n    pageMap: PageMap,\n    debugMetaKey: string | undefined,\n    logger?: Logger,\n) => {\n    logger?.debug?.('[segmenter] collecting split points from rules', {\n        contentLength: matchContent.length,\n        ruleCount: rules.length,\n    });\n\n    const passesPageStartGuard = createPageStartGuardChecker(matchContent, pageMap);\n    const { combinableRules, fastFuzzyRules, standaloneRules } = partitionRulesForMatching(rules);\n\n    logger?.debug?.('[segmenter] rules partitioned', {\n        combinableCount: combinableRules.length,\n        fastFuzzyCount: fastFuzzyRules.length,\n        standaloneCount: standaloneRules.length,\n    });\n\n    const splitPointsByRule = collectFastFuzzySplitPoints(matchContent, pageMap, fastFuzzyRules, passesPageStartGuard);\n\n    if (combinableRules.length > 0) {\n        processCombinedMatches(\n            matchContent,\n            combinableRules,\n            buildRuleRegexes(combinableRules),\n            pageMap,\n            passesPageStartGuard,\n            splitPointsByRule,\n            logger,\n        );\n    }\n\n    for (const rule of standaloneRules) {\n        processStandaloneRule(\n            rule,\n            rules.indexOf(rule),\n            matchContent,\n            pageMap,\n            passesPageStartGuard,\n            splitPointsByRule,\n        );\n    }\n\n    return applyOccurrenceFilter(rules, splitPointsByRule, debugMetaKey);\n};\n\n/**\n * Finds page breaks within a given offset range using binary search.\n * O(log n + k) where n = total breaks, k = breaks in range.\n *\n * @param startOffset - Start of range (inclusive)\n * @param endOffset - End of range (exclusive)\n * @param sortedBreaks - Sorted array of page break offsets\n * @returns Array of break offsets relative to startOffset\n */\nconst findBreaksInRange = (startOffset: number, endOffset: number, sortedBreaks: number[]) => {\n    if (sortedBreaks.length === 0) {\n        return [];\n    }\n\n    let lo = 0,\n        hi = sortedBreaks.length;\n    while (lo < hi) {\n        const mid = (lo + hi) >>> 1;\n        if (sortedBreaks[mid] < startOffset) {\n            lo = mid + 1;\n        } else {\n            hi = mid;\n        }\n    }\n\n    const result: number[] = [];\n    for (let i = lo; i < sortedBreaks.length && sortedBreaks[i] < endOffset; i++) {\n        result.push(sortedBreaks[i] - startOffset);\n    }\n    return result;\n};\n\n/**\n * Converts page-break newlines to spaces in segment content.\n *\n * When a segment spans multiple pages, the newline characters that were\n * inserted as page separators during concatenation are converted to spaces\n * for more natural reading.\n *\n * Uses binary search for O(log n + k) lookup instead of O(n) iteration.\n *\n * @param content - Segment content string\n * @param startOffset - Starting offset of this content in concatenated string\n * @param pageBreaks - Sorted array of page break offsets\n * @param pageJoiner - How to represent page boundaries in output (`space` vs `newline`)\n * @returns Content with page-break newlines converted to spaces (or left as-is for `newline`)\n */\nconst convertPageBreaks = (\n    content: string,\n    startOffset: number,\n    pageBreaks: number[],\n    pageJoiner: 'space' | 'newline',\n) => {\n    if (!content || !content.includes('\\n')) {\n        return content;\n    }\n\n    // If the caller wants newlines preserved between pages, no conversion is needed.\n    if (pageJoiner === 'newline') {\n        return content;\n    }\n\n    const breaksInRange = findBreaksInRange(startOffset, startOffset + content.length, pageBreaks);\n    if (breaksInRange.length === 0) {\n        return content;\n    }\n\n    const breakSet = new Set(breaksInRange);\n    return content.replace(/\\n/g, (match, offset: number) => (breakSet.has(offset) ? ' ' : match));\n};\n\n/**\n * Segments pages of content based on pattern-matching rules.\n *\n * This is the main entry point for the segmentation engine. It takes an array\n * of pages and applies the provided rules to identify split points, producing\n * an array of segments with content, page references, and metadata.\n *\n * @param pages - Array of pages with id and content\n * @param options - Segmentation options including splitting rules\n * @returns Array of segments with content, from/to page references, and optional metadata\n *\n * @example\n * // Split markdown by headers\n * const segments = segmentPages(pages, {\n *   rules: [\n *     { lineStartsWith: ['## '], split: 'at', meta: { type: 'chapter' } }\n *   ]\n * });\n *\n * @example\n * // Split Arabic hadith text with number extraction\n * const segments = segmentPages(pages, {\n *   rules: [\n *     {\n *       lineStartsAfter: ['{{raqms:hadithNum}} {{dash}} '],\n *       split: 'at',\n *       fuzzy: true,\n *       meta: { type: 'hadith' }\n *     }\n *   ]\n * });\n *\n * @example\n * // Multiple rules with page constraints\n * const segments = segmentPages(pages, {\n *   rules: [\n *     { lineStartsWith: ['{{kitab}}'], split: 'at', meta: { type: 'book' } },\n *     { lineStartsWith: ['{{bab}}'], split: 'at', min: 10, meta: { type: 'chapter' } },\n *     { regex: '^[٠-٩]+ - ', split: 'at', meta: { type: 'hadith' } }\n *   ]\n * });\n */\nexport const segmentPages = (pages: Page[], options: SegmentationOptions) => {\n    const { rules = [], breakpoints = [], prefer = 'longer', pageJoiner = 'space', logger, maxContentLength } = options;\n\n    if (maxContentLength && maxContentLength < 50) {\n        throw new Error(`maxContentLength must be at least 50 characters.`);\n    }\n\n    const maxPages = options.maxPages ?? Number.MAX_SAFE_INTEGER;\n    const hasLimits = options.maxPages !== undefined || maxContentLength !== undefined;\n    const debug = resolveDebugConfig((options as any).debug);\n    const debugMetaKey = debug?.includeRule ? debug.metaKey : undefined;\n\n    logger?.info?.('[segmenter] starting segmentation', {\n        breakpointCount: breakpoints.length,\n        maxContentLength,\n        maxPages,\n        pageCount: pages.length,\n        prefer,\n        ruleCount: rules.length,\n    });\n\n    const { content: matchContent, normalizedPages: normalizedContent, pageMap } = buildPageMap(pages);\n\n    logger?.debug?.('[segmenter] content built', { pageIds: pageMap.pageIds, totalContentLength: matchContent.length });\n\n    const splitPoints = collectSplitPointsFromRules(rules, matchContent, pageMap, debugMetaKey, logger);\n    const unique = dedupeSplitPoints(splitPoints);\n\n    logger?.debug?.('[segmenter] split points collected', {\n        rawSplitPoints: splitPoints.length,\n        uniqueSplitPoints: unique.length,\n    });\n\n    let segments = buildSegments(unique, matchContent, pageMap, rules, pageJoiner);\n    logger?.debug?.('[segmenter] structural segments built', { segmentCount: segments.length });\n\n    segments = ensureFallbackSegment(segments, pages, normalizedContent, pageJoiner);\n\n    if (hasLimits) {\n        logger?.debug?.('[segmenter] applying breakpoints to oversized segments');\n        const result = applyBreakpoints(\n            segments,\n            pages,\n            normalizedContent,\n            maxPages,\n            breakpoints,\n            prefer,\n            (p: string) => processPattern(p, false).pattern,\n            logger,\n            pageJoiner,\n            debug?.includeBreakpoint ? debug.metaKey : undefined,\n            maxContentLength,\n            processBreakpointPattern,\n        );\n        logger?.info?.('[segmenter] segmentation complete (with breakpoints)', { finalSegmentCount: result.length });\n        return result;\n    }\n    logger?.info?.('[segmenter] segmentation complete (structural only)', { finalSegmentCount: segments.length });\n    return segments;\n};\n\n/**\n * Creates segment objects from split points.\n *\n * Handles segment creation including:\n * - Content extraction (with captured content for `lineStartsAfter`)\n * - Page break conversion to spaces\n * - From/to page reference calculation\n * - Metadata merging (static + named captures)\n *\n * @param splitPoints - Sorted, unique split points\n * @param content - Full concatenated content string\n * @param pageMap - Page mapping utilities\n * @param rules - Original rules (for constraint checking on first segment)\n * @returns Array of segment objects\n */\nconst buildSegments = (\n    splitPoints: SplitPoint[],\n    content: string,\n    pageMap: PageMap,\n    rules: SplitRule[],\n    pageJoiner: 'space' | 'newline',\n) => {\n    /**\n     * Creates a single segment from a content range.\n     */\n    const createSegment = (\n        start: number,\n        end: number,\n        meta?: Record<string, unknown>,\n        capturedContent?: string,\n        namedCaptures?: Record<string, string>,\n        contentStartOffset?: number,\n    ) => {\n        const actualStart = start + (contentStartOffset ?? 0);\n        const sliced = content.slice(actualStart, end);\n        let text = capturedContent?.trim() ?? (contentStartOffset ? sliced.trim() : sliced.replace(/[\\s\\n]+$/, ''));\n        if (!text) {\n            return null;\n        }\n\n        if (!capturedContent) {\n            text = convertPageBreaks(text, actualStart, pageMap.pageBreaks, pageJoiner);\n        }\n        const from = pageMap.getId(actualStart);\n        const to = capturedContent ? pageMap.getId(end - 1) : pageMap.getId(actualStart + text.length - 1);\n        const seg: Segment = { content: text, from };\n        if (to !== from) {\n            seg.to = to;\n        }\n        if (meta || namedCaptures) {\n            seg.meta = { ...meta, ...namedCaptures };\n        }\n        return seg;\n    };\n\n    /**\n     * Creates segments from an array of split points.\n     */\n    const createSegmentsFromSplitPoints = () => {\n        const result: Segment[] = [];\n        for (let i = 0; i < splitPoints.length; i++) {\n            const sp = splitPoints[i];\n            const end = splitPoints[i + 1]?.index ?? content.length;\n            const s = createSegment(\n                sp.index,\n                end,\n                sp.meta,\n                sp.capturedContent,\n                sp.namedCaptures,\n                sp.contentStartOffset,\n            );\n            if (s) {\n                result.push(s);\n            }\n        }\n        return result;\n    };\n\n    const segments: Segment[] = [];\n\n    // Handle case with no split points\n    if (!splitPoints.length) {\n        const firstId = pageMap.getId(0);\n        if (anyRuleAllowsId(rules, firstId)) {\n            const s = createSegment(0, content.length);\n            if (s) {\n                segments.push(s);\n            }\n        }\n        return segments;\n    }\n\n    // Add first segment if there's content before first split\n    if (splitPoints[0].index > 0) {\n        const firstId = pageMap.getId(0);\n        if (anyRuleAllowsId(rules, firstId)) {\n            const s = createSegment(0, splitPoints[0].index);\n            if (s) {\n                segments.push(s);\n            }\n        }\n    }\n\n    // Create segments from split points using extracted utility\n    return [...segments, ...createSegmentsFromSplitPoints()];\n};\n","import type { Page, Segment } from '@/types/index.js';\nimport type { SegmentationOptions } from '@/types/options.js';\nimport type { SplitRule } from '@/types/rules.js';\nimport { buildRuleRegex } from './segmentation/rule-regex.js';\nimport { segmentPages } from './segmentation/segmenter.js';\nimport { normalizeLineEndings } from './utils/textUtils.js';\n\nexport type MarkerRecoverySelector =\n    | { type: 'rule_indices'; indices: number[] }\n    | { type: 'lineStartsAfter_patterns'; match?: 'exact' | 'normalized'; patterns: string[] }\n    | { type: 'predicate'; predicate: (rule: SplitRule, index: number) => boolean };\n\nexport type MarkerRecoveryRun = {\n    options: SegmentationOptions;\n    pages: Page[];\n    segments: Segment[];\n    selector: MarkerRecoverySelector;\n};\n\nexport type MarkerRecoveryReport = {\n    summary: {\n        mode: 'rerun_only' | 'best_effort_then_rerun';\n        recovered: number;\n        totalSegments: number;\n        unchanged: number;\n        unresolved: number;\n    };\n    byRun?: Array<{\n        recovered: number;\n        runIndex: number;\n        totalSegments: number;\n        unresolved: number;\n    }>;\n    details: Array<{\n        from: number;\n        originalStartPreview: string;\n        recoveredPrefixPreview?: string;\n        recoveredStartPreview?: string;\n        segmentIndex: number;\n        status: 'recovered' | 'skipped_idempotent' | 'unchanged' | 'unresolved_alignment' | 'unresolved_selector';\n        strategy: 'rerun' | 'stage1' | 'none';\n        to?: number;\n        notes?: string[];\n    }>;\n    errors: string[];\n    warnings: string[];\n};\n\ntype NormalizeCompareMode = 'none' | 'whitespace' | 'whitespace_and_nfkc';\n\nconst preview = (s: string, max = 40): string => (s.length <= max ? s : `${s.slice(0, max)}…`);\n\nconst normalizeForCompare = (s: string, mode: NormalizeCompareMode): string => {\n    if (mode === 'none') {\n        return s;\n    }\n    let out = s;\n    if (mode === 'whitespace_and_nfkc') {\n        // Use alternation (not a character class) to satisfy Biome's noMisleadingCharacterClass rule.\n        out = out.normalize('NFKC').replace(/(?:\\u200C|\\u200D|\\uFEFF)/gu, '');\n    }\n    // Collapse whitespace and normalize line endings\n    out = out.replace(/\\r\\n?/gu, '\\n').replace(/\\s+/gu, ' ').trim();\n    return out;\n};\n\nconst segmentRangeKey = (s: Pick<Segment, 'from' | 'to'>): string => `${s.from}|${s.to ?? s.from}`;\n\nconst buildFixedOptions = (options: SegmentationOptions, selectedRuleIndices: Set<number>): SegmentationOptions => {\n    const rules = options.rules ?? [];\n    const fixedRules: SplitRule[] = rules.map((r, idx) => {\n        if (!selectedRuleIndices.has(idx)) {\n            return r;\n        }\n        if (!('lineStartsAfter' in r) || !r.lineStartsAfter) {\n            return r;\n        }\n\n        // Convert: lineStartsAfter -> lineStartsWith, keep all other fields.\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        const { lineStartsAfter, ...rest } = r as SplitRule & { lineStartsAfter: string[] };\n        return { ...(rest as Omit<SplitRule, 'lineStartsAfter'>), lineStartsWith: lineStartsAfter };\n    });\n\n    return { ...options, rules: fixedRules };\n};\n\nconst buildPageIdToIndex = (pages: Page[]): Map<number, number> => new Map(pages.map((p, i) => [p.id, i]));\n\ntype RangeContent = {\n    matchContent: string;\n    outputContent: string;\n};\n\nconst buildRangeContent = (\n    processedPages: Page[],\n    fromIdx: number,\n    toIdx: number,\n    pageJoiner: 'space' | 'newline',\n): RangeContent => {\n    const parts: string[] = [];\n    for (let i = fromIdx; i <= toIdx; i++) {\n        parts.push(normalizeLineEndings(processedPages[i].content));\n    }\n    const matchContent = parts.join('\\n');\n    if (pageJoiner === 'newline') {\n        return { matchContent, outputContent: matchContent };\n    }\n    // Only convert the inserted page-boundary separators (exactly those join '\\n's) to spaces.\n    // In-page newlines remain as-is.\n    // Since we built matchContent by joining pages with '\\n', the separators are exactly between each part.\n    // Replacing all '\\n' would corrupt in-page newlines, so we rebuild outputContent explicitly.\n    const outputContent = parts.join(' ');\n    return { matchContent, outputContent };\n};\n\ntype CompiledMistakenRule = {\n    ruleIndex: number;\n    // A regex that matches the marker at a line start (equivalent to lineStartsWith).\n    startsWithRegex: RegExp;\n};\n\nconst compileMistakenRulesAsStartsWith = (\n    options: SegmentationOptions,\n    selectedRuleIndices: Set<number>,\n): CompiledMistakenRule[] => {\n    const rules = options.rules ?? [];\n    const compiled: CompiledMistakenRule[] = [];\n\n    for (const idx of selectedRuleIndices) {\n        const r = rules[idx];\n        if (!r || !('lineStartsAfter' in r) || !r.lineStartsAfter?.length) {\n            continue;\n        }\n        // Convert cleanly without using `delete` (keeps TS happy with discriminated unions).\n        const { lineStartsAfter, ...rest } = r as SplitRule & { lineStartsAfter: string[] };\n        const converted: SplitRule = {\n            ...(rest as Omit<SplitRule, 'lineStartsAfter'>),\n            lineStartsWith: lineStartsAfter,\n        };\n\n        const built = buildRuleRegex(converted);\n        // built.regex has flags gmu; we want a stable, non-global matcher.\n        compiled.push({ ruleIndex: idx, startsWithRegex: new RegExp(built.regex.source, 'mu') });\n    }\n\n    return compiled;\n};\n\ntype Stage1Result =\n    | { kind: 'recovered'; recoveredContent: string; recoveredPrefix: string }\n    | { kind: 'skipped_idempotent' }\n    | { kind: 'unresolved'; reason: string };\n\nconst findUniqueAnchorPos = (outputContent: string, segmentContent: string): number | null => {\n    const prefixLens = [80, 60, 40, 30, 20, 15] as const;\n\n    for (const len of prefixLens) {\n        const needle = segmentContent.slice(0, Math.min(len, segmentContent.length));\n        if (!needle.trim()) {\n            continue;\n        }\n\n        const first = outputContent.indexOf(needle);\n        if (first === -1) {\n            continue;\n        }\n        const second = outputContent.indexOf(needle, first + 1);\n        if (second === -1) {\n            return first;\n        }\n    }\n\n    return null;\n};\n\nconst findRecoveredPrefixAtLineStart = (\n    segmentContent: string,\n    matchContent: string,\n    lineStart: number,\n    anchorPos: number,\n    compiledMistaken: CompiledMistakenRule[],\n): { prefix: string } | { reason: string } => {\n    const line = matchContent.slice(lineStart);\n\n    for (const mr of compiledMistaken) {\n        mr.startsWithRegex.lastIndex = 0;\n        const m = mr.startsWithRegex.exec(line);\n        if (!m || m.index !== 0) {\n            continue;\n        }\n\n        const markerMatch = m[0];\n        const markerEnd = lineStart + markerMatch.length;\n        if (anchorPos < markerEnd) {\n            continue; // anchor is inside marker; unsafe\n        }\n\n        // If there is whitespace between the marker match and the anchored content (common when lineStartsAfter trims),\n        // include it in the recovered prefix.\n        const gap = matchContent.slice(markerEnd, anchorPos);\n        const recoveredPrefix = /^\\s*$/u.test(gap) ? `${markerMatch}${gap}` : markerMatch;\n\n        // Idempotency: if content already starts with the marker/prefix, don’t prepend.\n        if (segmentContent.startsWith(markerMatch) || segmentContent.startsWith(recoveredPrefix)) {\n            return { reason: 'content already starts with selected marker' };\n        }\n\n        return { prefix: recoveredPrefix };\n    }\n\n    return { reason: 'no selected marker pattern matched at anchored line start' };\n};\n\nconst tryBestEffortRecoverOneSegment = (\n    segment: Segment,\n    processedPages: Page[],\n    pageIdToIndex: Map<number, number>,\n    compiledMistaken: CompiledMistakenRule[],\n    pageJoiner: 'space' | 'newline',\n): Stage1Result => {\n    const fromIdx = pageIdToIndex.get(segment.from);\n    const toIdx = pageIdToIndex.get(segment.to ?? segment.from) ?? fromIdx;\n    if (fromIdx === undefined || toIdx === undefined || fromIdx < 0 || toIdx < fromIdx) {\n        return { kind: 'unresolved', reason: 'segment page range not found in pages' };\n    }\n\n    const { matchContent, outputContent } = buildRangeContent(processedPages, fromIdx, toIdx, pageJoiner);\n    if (!segment.content) {\n        return { kind: 'unresolved', reason: 'empty segment content' };\n    }\n\n    const anchorPos = findUniqueAnchorPos(outputContent, segment.content);\n    if (anchorPos === null) {\n        return { kind: 'unresolved', reason: 'could not uniquely anchor segment content in page range' };\n    }\n\n    // Find line start in matchContent. (Positions align because outputContent differs only by page-boundary joiner.)\n    const lineStart = matchContent.lastIndexOf('\\n', Math.max(0, anchorPos - 1)) + 1;\n    const found = findRecoveredPrefixAtLineStart(segment.content, matchContent, lineStart, anchorPos, compiledMistaken);\n    if ('reason' in found) {\n        return found.reason.includes('already starts')\n            ? { kind: 'skipped_idempotent' }\n            : { kind: 'unresolved', reason: found.reason };\n    }\n    return { kind: 'recovered', recoveredContent: `${found.prefix}${segment.content}`, recoveredPrefix: found.prefix };\n};\n\nconst resolveRuleIndicesSelector = (rules: SplitRule[], indicesIn: number[]) => {\n    const errors: string[] = [];\n    const indices = new Set<number>();\n    for (const idx of indicesIn) {\n        if (!Number.isInteger(idx) || idx < 0 || idx >= rules.length) {\n            errors.push(`Selector index out of range: ${idx}`);\n            continue;\n        }\n        const rule = rules[idx];\n        if (!rule || !('lineStartsAfter' in rule)) {\n            errors.push(`Selector index ${idx} is not a lineStartsAfter rule`);\n            continue;\n        }\n        indices.add(idx);\n    }\n    return { errors, indices, warnings: [] as string[] };\n};\n\nconst resolvePredicateSelector = (rules: SplitRule[], predicate: (rule: SplitRule, index: number) => boolean) => {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n    const indices = new Set<number>();\n\n    rules.forEach((r, i) => {\n        try {\n            if (!predicate(r, i)) {\n                return;\n            }\n            if ('lineStartsAfter' in r && r.lineStartsAfter?.length) {\n                indices.add(i);\n                return;\n            }\n            warnings.push(`Predicate selected rule ${i}, but it is not a lineStartsAfter rule; skipping`);\n        } catch (e) {\n            const msg = e instanceof Error ? e.message : String(e);\n            errors.push(`Predicate threw at rule ${i}: ${msg}`);\n        }\n    });\n\n    if (indices.size === 0) {\n        warnings.push('Predicate did not select any lineStartsAfter rules');\n    }\n\n    return { errors, indices, warnings };\n};\n\nconst resolvePatternsSelector = (\n    rules: SplitRule[],\n    patterns: string[],\n    matchMode: 'exact' | 'normalized' | undefined,\n): { errors: string[]; indices: Set<number>; warnings: string[] } => {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n    const indices = new Set<number>();\n\n    const normalizePattern = (p: string) =>\n        normalizeForCompare(p, (matchMode ?? 'exact') === 'normalized' ? 'whitespace_and_nfkc' : 'none');\n    const targets = patterns.map(normalizePattern);\n\n    for (let pi = 0; pi < patterns.length; pi++) {\n        const rawPattern = patterns[pi];\n        const pat = targets[pi];\n        const matched: number[] = [];\n\n        for (let i = 0; i < rules.length; i++) {\n            const r = rules[i];\n            if (!('lineStartsAfter' in r) || !r.lineStartsAfter?.length) {\n                continue;\n            }\n            if (r.lineStartsAfter.some((rp) => normalizePattern(rp) === pat)) {\n                matched.push(i);\n            }\n        }\n\n        if (matched.length === 0) {\n            errors.push(`Pattern \"${rawPattern}\" did not match any lineStartsAfter rule`);\n            continue;\n        }\n        if (matched.length > 1) {\n            warnings.push(`Pattern \"${rawPattern}\" matched multiple lineStartsAfter rules: [${matched.join(', ')}]`);\n        }\n        matched.forEach((i) => {\n            indices.add(i);\n        });\n    }\n\n    return { errors, indices, warnings };\n};\n\nconst resolveSelectorToRuleIndices = (options: SegmentationOptions, selector: MarkerRecoverySelector) => {\n    const rules = options.rules ?? [];\n    if (selector.type === 'rule_indices') {\n        return resolveRuleIndicesSelector(rules, selector.indices);\n    }\n    if (selector.type === 'predicate') {\n        return resolvePredicateSelector(rules, selector.predicate);\n    }\n    return resolvePatternsSelector(rules, selector.patterns, selector.match);\n};\n\ntype AlignmentCandidate = { fixedIndex: number; kind: 'exact' | 'exact_suffix' | 'normalized_suffix'; score: number };\n\nconst longestCommonSuffixLength = (a: string, b: string): number => {\n    const max = Math.min(a.length, b.length);\n    let i = 0;\n    while (i < max) {\n        if (a[a.length - 1 - i] !== b[b.length - 1 - i]) {\n            break;\n        }\n        i++;\n    }\n    return i;\n};\n\n// Minimum score difference required to confidently disambiguate between candidates.\n// If the gap between best and second-best is smaller, we consider the match ambiguous.\nconst AMBIGUITY_SCORE_GAP = 5;\n\nconst scoreCandidate = (\n    orig: Segment,\n    fixed: Segment,\n    normalizeMode: NormalizeCompareMode,\n): AlignmentCandidate | null => {\n    // Scoring hierarchy:\n    //   exact (100)           - Content is identical, no recovery needed\n    //   exact_suffix (90-120) - Fixed ends with original; fixed = marker + orig (most reliable)\n    //   normalized_suffix (70-90) - Suffix match after whitespace/NFKC normalization\n    // Higher scores indicate more confident alignment.\n\n    if (fixed.content === orig.content) {\n        return { fixedIndex: -1, kind: 'exact', score: 100 };\n    }\n\n    if (fixed.content.endsWith(orig.content)) {\n        // Most reliable case: fixed = marker + orig.\n        // Bonus points for longer markers (up to 30) to prefer substantive recovery.\n        const markerLen = fixed.content.length - orig.content.length;\n        const bonus = Math.min(30, markerLen);\n        return { fixedIndex: -1, kind: 'exact_suffix', score: 90 + bonus };\n    }\n\n    if (normalizeMode !== 'none') {\n        const normFixed = normalizeForCompare(fixed.content, normalizeMode);\n        const normOrig = normalizeForCompare(orig.content, normalizeMode);\n        if (normFixed.endsWith(normOrig) && normOrig.length > 0) {\n            // Base score 70, plus up to 20 bonus based on overlap ratio\n            const overlap = longestCommonSuffixLength(normFixed, normOrig) / normOrig.length;\n            return { fixedIndex: -1, kind: 'normalized_suffix', score: 70 + Math.floor(overlap * 20) };\n        }\n    }\n\n    return null;\n};\n\nconst buildNoSelectionResult = (\n    segments: Segment[],\n    reportBase: Omit<MarkerRecoveryReport, 'details' | 'summary'>,\n    mode: MarkerRecoveryReport['summary']['mode'],\n    selectorErrors: string[],\n): { report: MarkerRecoveryReport; segments: Segment[] } => {\n    const warnings = [...reportBase.warnings];\n    warnings.push('No lineStartsAfter rules selected for recovery; returning segments unchanged');\n\n    const details: MarkerRecoveryReport['details'] = segments.map((s, i) => {\n        const status: MarkerRecoveryReport['details'][number]['status'] = selectorErrors.length\n            ? 'unresolved_selector'\n            : 'unchanged';\n        return {\n            from: s.from,\n            notes: selectorErrors.length ? (['selector did not resolve'] as string[]) : undefined,\n            originalStartPreview: preview(s.content),\n            segmentIndex: i,\n            status,\n            strategy: 'none',\n            to: s.to,\n        };\n    });\n\n    return {\n        report: {\n            ...reportBase,\n            details,\n            summary: {\n                mode,\n                recovered: 0,\n                totalSegments: segments.length,\n                unchanged: segments.length,\n                unresolved: selectorErrors.length ? segments.length : 0,\n            },\n            warnings,\n        },\n        segments,\n    };\n};\n\nconst runStage1IfEnabled = (\n    pages: Page[],\n    segments: Segment[],\n    options: SegmentationOptions,\n    selectedRuleIndices: Set<number>,\n    mode: MarkerRecoveryReport['summary']['mode'],\n): {\n    recoveredAtIndex: Map<number, Segment>;\n    recoveredDetailAtIndex: Map<number, MarkerRecoveryReport['details'][number]>;\n} => {\n    const recoveredAtIndex = new Map<number, Segment>();\n    const recoveredDetailAtIndex = new Map<number, MarkerRecoveryReport['details'][number]>();\n\n    if (mode !== 'best_effort_then_rerun') {\n        return { recoveredAtIndex, recoveredDetailAtIndex };\n    }\n\n    const pageIdToIndex = buildPageIdToIndex(pages);\n    const pageJoiner = options.pageJoiner ?? 'space';\n    const compiledMistaken = compileMistakenRulesAsStartsWith(options, selectedRuleIndices);\n\n    for (let i = 0; i < segments.length; i++) {\n        const orig = segments[i];\n        const r = tryBestEffortRecoverOneSegment(orig, pages, pageIdToIndex, compiledMistaken, pageJoiner);\n        if (r.kind !== 'recovered') {\n            continue;\n        }\n\n        const seg: Segment = { ...orig, content: r.recoveredContent };\n        recoveredAtIndex.set(i, seg);\n        recoveredDetailAtIndex.set(i, {\n            from: orig.from,\n            originalStartPreview: preview(orig.content),\n            recoveredPrefixPreview: preview(r.recoveredPrefix),\n            recoveredStartPreview: preview(seg.content),\n            segmentIndex: i,\n            status: 'recovered',\n            strategy: 'stage1',\n            to: orig.to,\n        });\n    }\n\n    return { recoveredAtIndex, recoveredDetailAtIndex };\n};\n\nconst buildFixedBuckets = (fixedSegments: Segment[]): Map<string, number[]> => {\n    const buckets = new Map<string, number[]>();\n    for (let i = 0; i < fixedSegments.length; i++) {\n        const k = segmentRangeKey(fixedSegments[i]);\n        const arr = buckets.get(k);\n        if (!arr) {\n            buckets.set(k, [i]);\n        } else {\n            arr.push(i);\n        }\n    }\n    return buckets;\n};\n\ntype BestFixedMatch = { kind: 'none' } | { kind: 'ambiguous' } | { kind: 'match'; fixedIdx: number };\n\nconst findBestFixedMatch = (\n    orig: Segment,\n    candidates: number[],\n    fixedSegments: Segment[],\n    usedFixed: Set<number>,\n    normalizeCompare: NormalizeCompareMode,\n): BestFixedMatch => {\n    let best: { fixedIdx: number; score: number } | null = null;\n    let secondBestScore = -Infinity;\n\n    for (const fixedIdx of candidates) {\n        if (usedFixed.has(fixedIdx)) {\n            continue;\n        }\n        const fixed = fixedSegments[fixedIdx];\n        const scored = scoreCandidate(orig, fixed, normalizeCompare);\n        if (!scored) {\n            continue;\n        }\n        const candidateScore = scored.score;\n        if (!best || candidateScore > best.score) {\n            secondBestScore = best?.score ?? -Infinity;\n            best = { fixedIdx, score: candidateScore };\n        } else if (candidateScore > secondBestScore) {\n            secondBestScore = candidateScore;\n        }\n    }\n\n    if (!best) {\n        return { kind: 'none' };\n    }\n    if (best.score - secondBestScore < AMBIGUITY_SCORE_GAP && candidates.length > 1) {\n        return { kind: 'ambiguous' };\n    }\n    return { fixedIdx: best.fixedIdx, kind: 'match' };\n};\n\nconst detailUnresolved = (\n    orig: Segment,\n    segmentIndex: number,\n    notes: string[],\n): MarkerRecoveryReport['details'][number] => ({\n    from: orig.from,\n    notes,\n    originalStartPreview: preview(orig.content),\n    segmentIndex,\n    status: 'unresolved_alignment',\n    strategy: 'rerun',\n    to: orig.to,\n});\n\nconst detailSkippedIdempotent = (\n    orig: Segment,\n    segmentIndex: number,\n    notes: string[],\n): MarkerRecoveryReport['details'][number] => ({\n    from: orig.from,\n    notes,\n    originalStartPreview: preview(orig.content),\n    segmentIndex,\n    status: 'skipped_idempotent',\n    strategy: 'rerun',\n    to: orig.to,\n});\n\nconst detailRecoveredRerun = (\n    orig: Segment,\n    fixed: Segment,\n    segmentIndex: number,\n): MarkerRecoveryReport['details'][number] => {\n    let recoveredPrefixPreview: string | undefined;\n    if (fixed.content.endsWith(orig.content)) {\n        recoveredPrefixPreview = preview(fixed.content.slice(0, fixed.content.length - orig.content.length));\n    }\n    return {\n        from: orig.from,\n        originalStartPreview: preview(orig.content),\n        recoveredPrefixPreview,\n        recoveredStartPreview: preview(fixed.content),\n        segmentIndex,\n        status: 'recovered',\n        strategy: 'rerun',\n        to: orig.to,\n    };\n};\n\nconst mergeWithRerun = (params: {\n    fixedBuckets: Map<string, number[]>;\n    fixedSegments: Segment[];\n    normalizeCompare: NormalizeCompareMode;\n    originalSegments: Segment[];\n    recoveredDetailAtIndex: Map<number, MarkerRecoveryReport['details'][number]>;\n    stage1RecoveredAtIndex: Map<number, Segment>;\n}): {\n    details: MarkerRecoveryReport['details'];\n    segments: Segment[];\n    summary: Omit<MarkerRecoveryReport['summary'], 'mode' | 'totalSegments'>;\n} => {\n    const {\n        fixedBuckets,\n        fixedSegments,\n        normalizeCompare,\n        originalSegments,\n        stage1RecoveredAtIndex,\n        recoveredDetailAtIndex,\n    } = params;\n\n    const usedFixed = new Set<number>();\n    const out: Segment[] = [];\n    const details: MarkerRecoveryReport['details'] = [];\n    let recovered = 0;\n    let unresolved = 0;\n    let unchanged = 0;\n\n    for (let i = 0; i < originalSegments.length; i++) {\n        const stage1Recovered = stage1RecoveredAtIndex.get(i);\n        if (stage1Recovered) {\n            out.push(stage1Recovered);\n            recovered++;\n            details.push(\n                recoveredDetailAtIndex.get(i) ?? {\n                    from: stage1Recovered.from,\n                    originalStartPreview: preview(originalSegments[i].content),\n                    recoveredStartPreview: preview(stage1Recovered.content),\n                    segmentIndex: i,\n                    status: 'recovered',\n                    strategy: 'stage1',\n                    to: stage1Recovered.to,\n                },\n            );\n            continue;\n        }\n\n        const orig = originalSegments[i];\n        const candidates = fixedBuckets.get(segmentRangeKey(orig)) ?? [];\n\n        const best = findBestFixedMatch(orig, candidates, fixedSegments, usedFixed, normalizeCompare);\n        if (best.kind === 'none') {\n            out.push(orig);\n            unresolved++;\n            details.push(detailUnresolved(orig, i, ['no alignment candidate in rerun output for same (from,to)']));\n            continue;\n        }\n        if (best.kind === 'ambiguous') {\n            out.push(orig);\n            unresolved++;\n            details.push(detailUnresolved(orig, i, ['ambiguous alignment (score gap too small)']));\n            continue;\n        }\n\n        usedFixed.add(best.fixedIdx);\n        const fixed = fixedSegments[best.fixedIdx];\n\n        if (fixed.content === orig.content) {\n            out.push(orig);\n            unchanged++;\n            details.push(detailSkippedIdempotent(orig, i, ['content already matches rerun output']));\n            continue;\n        }\n\n        out.push({ ...orig, content: fixed.content });\n        recovered++;\n        details.push(detailRecoveredRerun(orig, fixed, i));\n    }\n\n    return { details, segments: out, summary: { recovered, unchanged, unresolved } };\n};\n\nexport function recoverMistakenLineStartsAfterMarkers(\n    pages: Page[],\n    segments: Segment[],\n    options: SegmentationOptions,\n    selector: MarkerRecoverySelector,\n    opts?: {\n        mode?: 'rerun_only' | 'best_effort_then_rerun';\n        normalizeCompare?: NormalizeCompareMode;\n    },\n): { report: MarkerRecoveryReport; segments: Segment[] } {\n    const mode = opts?.mode ?? 'rerun_only';\n    const normalizeCompare = opts?.normalizeCompare ?? 'whitespace';\n\n    const resolved = resolveSelectorToRuleIndices(options, selector);\n    const reportBase: Omit<MarkerRecoveryReport, 'details' | 'summary'> = {\n        byRun: undefined,\n        errors: resolved.errors,\n        warnings: resolved.warnings,\n    };\n\n    if (resolved.indices.size === 0) {\n        return buildNoSelectionResult(segments, reportBase, mode, resolved.errors);\n    }\n\n    const stage1 = runStage1IfEnabled(pages, segments, options, resolved.indices, mode);\n\n    const fixedOptions = buildFixedOptions(options, resolved.indices);\n    const fixedSegments = segmentPages(pages, fixedOptions);\n    const fixedBuckets = buildFixedBuckets(fixedSegments);\n    const merged = mergeWithRerun({\n        fixedBuckets,\n        fixedSegments,\n        normalizeCompare,\n        originalSegments: segments,\n        recoveredDetailAtIndex: stage1.recoveredDetailAtIndex,\n        stage1RecoveredAtIndex: stage1.recoveredAtIndex,\n    });\n\n    return {\n        report: {\n            ...reportBase,\n            details: merged.details,\n            summary: {\n                mode,\n                recovered: merged.summary.recovered,\n                totalSegments: segments.length,\n                unchanged: merged.summary.unchanged,\n                unresolved: merged.summary.unresolved,\n            },\n        },\n        segments: merged.segments,\n    };\n}\n\nexport function recoverMistakenMarkersForRuns(\n    runs: MarkerRecoveryRun[],\n    opts?: { mode?: 'rerun_only' | 'best_effort_then_rerun'; normalizeCompare?: NormalizeCompareMode },\n): { report: MarkerRecoveryReport; segments: Segment[] } {\n    const allSegments: Segment[] = [];\n    const byRun: NonNullable<MarkerRecoveryReport['byRun']> = [];\n    const details: MarkerRecoveryReport['details'] = [];\n    const warnings: string[] = [];\n    const errors: string[] = [];\n\n    let recovered = 0;\n    let unchanged = 0;\n    let unresolved = 0;\n    let offset = 0;\n\n    for (let i = 0; i < runs.length; i++) {\n        const run = runs[i];\n        const res = recoverMistakenLineStartsAfterMarkers(run.pages, run.segments, run.options, run.selector, opts);\n        allSegments.push(...res.segments);\n\n        // Adjust indices in details to be global\n        for (const d of res.report.details) {\n            details.push({ ...d, segmentIndex: d.segmentIndex + offset });\n        }\n        offset += run.segments.length;\n\n        recovered += res.report.summary.recovered;\n        unchanged += res.report.summary.unchanged;\n        unresolved += res.report.summary.unresolved;\n\n        warnings.push(...res.report.warnings);\n        errors.push(...res.report.errors);\n\n        byRun.push({\n            recovered: res.report.summary.recovered,\n            runIndex: i,\n            totalSegments: run.segments.length,\n            unresolved: res.report.summary.unresolved,\n        });\n    }\n\n    const report: MarkerRecoveryReport = {\n        byRun,\n        details,\n        errors,\n        summary: {\n            mode: opts?.mode ?? 'rerun_only',\n            recovered,\n            totalSegments: offset,\n            unchanged,\n            unresolved,\n        },\n        warnings,\n    };\n\n    return { report, segments: allSegments };\n}\n","/**\n * Pattern validation utilities for detecting common mistakes in rule patterns.\n *\n * These utilities help catch typos and issues early, before rules are used\n * for segmentation.\n */\n\nimport type { SplitRule } from '@/types/rules.js';\nimport { getAvailableTokens } from './tokens.js';\n\n/**\n * Types of validation issues that can be detected.\n */\nexport type ValidationIssueType = 'missing_braces' | 'unknown_token' | 'duplicate' | 'empty_pattern';\n\n/**\n * A validation issue found in a pattern.\n */\nexport type ValidationIssue = {\n    type: ValidationIssueType;\n    message: string;\n    suggestion?: string;\n    /** The token name involved in the issue (for unknown_token / missing_braces) */\n    token?: string;\n    /** The specific pattern involved (for duplicate) */\n    pattern?: string;\n};\n\n/**\n * Validation result for a single rule, with issues keyed by pattern type.\n * Arrays parallel the input pattern arrays - undefined means no issue.\n */\nexport type RuleValidationResult = {\n    lineStartsWith?: (ValidationIssue | undefined)[];\n    lineStartsAfter?: (ValidationIssue | undefined)[];\n    lineEndsWith?: (ValidationIssue | undefined)[];\n    template?: ValidationIssue;\n};\n\n// Known token names from the tokens module\nconst KNOWN_TOKENS = new Set(getAvailableTokens());\n\n// Regex to find tokens inside {{}} - both with and without capture syntax\nconst TOKEN_INSIDE_BRACES = /\\{\\{(\\w+)(?::\\w+)?\\}\\}/g;\n\n// Regex to find potential token names NOT inside {{}}\n// Matches word boundaries around known token names\nconst buildBareTokenRegex = () => {\n    const tokens = [...KNOWN_TOKENS].sort((a, b) => b.length - a.length);\n    return new RegExp(`(?<!\\\\{\\\\{)(${tokens.join('|')})(?::\\\\w+)?(?!\\\\}\\\\})`, 'g');\n};\n\n/**\n * Validates a single pattern for common issues.\n */\nconst validatePattern = (pattern: string, seenPatterns: Set<string>) => {\n    if (!pattern.trim()) {\n        return { message: 'Empty pattern is not allowed', type: 'empty_pattern' } as const;\n    }\n    if (seenPatterns.has(pattern)) {\n        return { message: `Duplicate pattern: \"${pattern}\"`, pattern, type: 'duplicate' } as const;\n    }\n    seenPatterns.add(pattern);\n\n    // TOKEN_INSIDE_BRACES is a global /g regex. Ensure lastIndex does not leak between calls.\n    TOKEN_INSIDE_BRACES.lastIndex = 0;\n    for (const match of pattern.matchAll(TOKEN_INSIDE_BRACES)) {\n        const name = match[1];\n        if (!KNOWN_TOKENS.has(name)) {\n            return {\n                message: `Unknown token: {{${name}}}. Available tokens: ${[...KNOWN_TOKENS].slice(0, 5).join(', ')}...`,\n                suggestion: 'Check spelling or use a known token',\n                token: name,\n                type: 'unknown_token',\n            } as const;\n        }\n    }\n\n    for (const match of pattern.matchAll(buildBareTokenRegex())) {\n        const [full, name] = match;\n        const idx = match.index!;\n        if (\n            pattern.slice(Math.max(0, idx - 2), idx) !== '{{' ||\n            pattern.slice(idx + full.length, idx + full.length + 2) !== '}}'\n        ) {\n            return {\n                message: `Token \"${name}\" appears to be missing {{}}. Did you mean \"{{${full}}}\"?`,\n                suggestion: `{{${full}}}`,\n                token: name,\n                type: 'missing_braces',\n            } as const;\n        }\n    }\n};\n\n/**\n * Validates an array of patterns, returning parallel array of issues.\n */\nconst validatePatternArray = (patterns: string[]) => {\n    const seen = new Set<string>();\n    const issues = patterns.map((p) => validatePattern(p, seen));\n    return issues.some(Boolean) ? issues : undefined;\n};\n\n/**\n * Validates split rules for common pattern issues.\n *\n * Checks for:\n * - Missing `{{}}` around known token names (e.g., `raqms:num` instead of `{{raqms:num}}`)\n * - Unknown token names inside `{{}}` (e.g., `{{nonexistent}}`)\n * - Duplicate patterns within the same rule\n *\n * @param rules - Array of split rules to validate\n * @returns Array parallel to input with validation results (undefined if no issues)\n *\n * @example\n * const issues = validateRules([\n *   { lineStartsAfter: ['raqms:num'] },  // Missing braces\n *   { lineStartsWith: ['{{unknown}}'] }, // Unknown token\n * ]);\n * // issues[0]?.lineStartsAfter?.[0]?.type === 'missing_braces'\n * // issues[1]?.lineStartsWith?.[0]?.type === 'unknown_token'\n */\nexport const validateRules = (rules: SplitRule[]) =>\n    rules.map((rule) => {\n        const result: RuleValidationResult = {};\n        let hasIssues = false;\n\n        for (const key of ['lineStartsWith', 'lineStartsAfter', 'lineEndsWith'] as const) {\n            if (key in rule && (rule as any)[key]) {\n                const issues = validatePatternArray((rule as any)[key]);\n                if (issues) {\n                    result[key] = issues;\n                    hasIssues = true;\n                }\n            }\n        }\n\n        if ('template' in rule && rule.template !== undefined) {\n            const issue = validatePattern(rule.template, new Set());\n            if (issue) {\n                result.template = issue;\n                hasIssues = true;\n            }\n        }\n\n        return hasIssues ? result : undefined;\n    });\n/**\n * Formats a validation result array into a list of human-readable error messages.\n *\n * Useful for displaying validation errors in UIs.\n *\n * @param results - The result array from `validateRules()`\n * @returns Array of formatted error strings\n *\n * @example\n * const issues = validateRules(rules);\n * const errors = formatValidationReport(issues);\n * // [\"Rule 1, lineStartsWith: Missing {{}} around token...\"]\n */\nexport const formatValidationReport = (results: (RuleValidationResult | undefined)[]) =>\n    results.flatMap((result, i) => {\n        if (!result) {\n            return [];\n        }\n        return Object.entries(result)\n            .flatMap(([type, issues]) =>\n                (Array.isArray(issues) ? issues : [issues]).map((issue) => {\n                    if (!issue) {\n                        return null;\n                    }\n                    const loc = `Rule ${i + 1}, ${type}`;\n                    if (issue.type === 'missing_braces') {\n                        return `${loc}: Missing {{}} around token \"${issue.token}\"`;\n                    }\n                    if (issue.type === 'unknown_token') {\n                        return `${loc}: Unknown token \"{{${issue.token}}}\"`;\n                    }\n                    if (issue.type === 'duplicate') {\n                        return `${loc}: Duplicate pattern \"${issue.pattern}\"`;\n                    }\n                    return `${loc}: ${issue.message || issue.type}`;\n                }),\n            )\n            .filter((msg): msg is string => msg !== null);\n    });\n"],"mappings":"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A,cACA,QAAQ,MACR,gBACA,OACH,EACH;AACE,yBAAsB;AACtB;;EAGJ,MAAM,oBAAoB,qCACtB,kBACA,WACA,gBACA,SACA,cACA,OACA,SACA,mBACA,iBACA,mBACA,UACA,kBACA,OACH;AAGD,UAAQ,QAAQ,2BAA2B,KAAK;GAAE;GAAgB;GAAW;GAAc;GAAmB,CAAC;EAE/G,MAAM,QAAQ,yBACV,kBACA,gBACA,cACA,OACA,mBACA,SACA,qBACA,mBACA,iBACA,QACA,iBACH;EAED,MAAM,cAAc,6BAChB,MAAM,aACN,kBACA,WACA,kBACA,OACH;AACD,mBAAiB,8BAA8B,OAAO,eAAe;EAErE,MAAM,WAAW,YAAY;EAC7B,MAAM,eAAe,YAAY,MAAM,WAAW,SAAS,CAAC,MAAM;AAClE,MAAI,CAAC,cAAc;AACf,eAAY;AACZ,kBAAe;AACf;;EAGJ,MAAM,OAAO,sBACT,aACA,WACA,UACA,cACA,gBACA,SACA,OACA,SACA,mBACA,iBACA,UACA,cACA,cACA,QAAQ,MACR,gBACA,QACA,QACA,MAAM,mBACT;AACD,cAAY,KAAK;AACjB,mBAAiB,KAAK;AACtB,iBAAe;;AAGnB,KAAI,oBACA,SAAQ,QAAQ,mFAAmF;EAC/F;EACA,mBAAmB,YAAY;EAC/B,YAAY;EACf,CAAC;AAGN,SAAQ,QAAQ,mDAAmD,EAAE,aAAa,OAAO,QAAQ,CAAC;AAClG,QAAO;;;;;;;;;;;;;AAcX,MAAM,2BACF,SACA,SACA,OACA,SACA,iBACA,mBACA,qBACA,UACA,QACA,QACA,cACA,qBACC;CACD,MAAM,OAAO,mCACT,SACA,SACA,OACA,SACA,iBACA,mBACA,qBACA,UACA,QACA,cACA,iBACH;AACD,KAAI,KACA,QAAO;AAGX,QAAO,iCACH,SACA,SACA,OACA,SACA,iBACA,mBACA,qBACA,UACA,QACA,QACA,cACA,iBACH;;AAGL,MAAa,oBACT,UACA,OACA,mBACA,UACA,aACA,QACA,kBACA,QACA,aAAkC,SAClC,cACA,kBACA,wBACC;CACD,MAAM,UAAU,MAAM,KAAK,MAAM,EAAE,GAAG;CACt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"}