flappa-doormal 2.11.5 → 2.12.0

package/AGENTS.md

@@ -118,7 +118,7 @@ src/
    - `findNextPagePosition()` - Find next page content position
    - `findPatternBreakPosition()` - Find pattern match by preference
    - `findSafeBreakPosition()` - Search backward for a safe linguistic split point (whitespace/punctuation)
-   - `adjustForSurrogate()` - Ensure split position doesn't corrupt Unicode surrogate pairs
+   - `adjustForUnicodeBoundary()` - Ensure split position doesn't corrupt surrogate pairs, combining marks, ZWJ/ZWNJ, or variation selectors
 
 10. **`types.ts`** - Type definitions
    - `Logger` interface - Optional logging for debugging
@@ -230,9 +230,19 @@ interface SegmentationOptions {
   // - pageIds: []: apply to no pages (skip)
   replace?: Array<{ regex: string; replacement: string; flags?: string; pageIds?: number[] }>;
   maxPages?: number;           // Maximum pages a segment can span
-  breakpoints?: string[];      // Ordered array of regex patterns (supports token expansion)
+  breakpoints?: Breakpoint[];  // Ordered array of patterns (supports token expansion)
   prefer?: 'longer' | 'shorter'; // Select last or first match within window
 }
+
+// Breakpoint can be a string or object with split control
+type Breakpoint = string | BreakpointRule;
+interface BreakpointRule {
+  pattern: string;
+  split?: 'at' | 'after';  // Default: 'after'
+  min?: number;            // Minimum page ID for this breakpoint
+  max?: number;            // Maximum page ID for this breakpoint
+  exclude?: PageRange[];   // Pages to skip this breakpoint
+}
 ```
 
 **How it works:**
@@ -241,16 +251,24 @@ interface SegmentationOptions {
 3. Patterns are tried in order until one matches
 4. Empty string `''` means "fall back to page boundary"
 
+**Split behavior:**
+- **`split: 'after'` (default)**: Previous segment ends WITH the matched text
+- **`split: 'at'`**: Previous segment ends BEFORE the matched text (match starts next segment)
+
 **Example:**
 ```typescript
 segmentPages(pages, {
   rules: [
-    { lineStartsWith: ['{{basmalah}}'] },  // split defaults to 'at'
+    { lineStartsWith: ['{{basmalah}}'] },
     { lineStartsWith: ['{{bab}}'], meta: { type: 'chapter' } },
   ],
   maxPages: 2,
-  breakpoints: ['{{tarqim}}\\s*', '\\n', ''],  // Try: punctuation → newline → page boundary
-  prefer: 'longer',  // Greedy: make segments as large as possible
+  breakpoints: [
+    { pattern: '{{tarqim}}\\s*', split: 'after' }, // Punctuation ends current segment
+    { pattern: 'ولهذا', split: 'at' },             // Word starts next segment
+    '',                                            // Fall back to page boundary
+  ],
+  prefer: 'longer',
 });
 ```
 
@@ -259,6 +277,8 @@ segmentPages(pages, {
 - **`prefer: 'longer'`**: Finds LAST match in window (greedy)
 - **`prefer: 'shorter'`**: Finds FIRST match (conservative)
 - **Recursive**: If split result still exceeds `maxPages`, breakpoints runs again
+- **Lookahead patterns unsupported**: Zero-length matches are skipped; use `split: 'at'` instead
+- **Position 0 protection**: Matches at position 0 are skipped for `split: 'at'` to prevent empty segments
 
 > **Note**: Older per-rule span limiting approaches were removed in favor of post-processing `breakpoints`.
 
@@ -269,7 +289,7 @@ When using `maxContentLength`, the segmenter prevents text corruption through se
 **Algorithm:**
 1. **Windowed Pattern Match**: Attempt to find a user-provided `breakpoint` pattern within the character window.
 2. **Safe Fallback (Linguistic)**: If no pattern matches, use `findSafeBreakPosition()` to search backward (100 chars) for whitespace or punctuation `[\s\n.,;!?؛،۔]`.
-3. **Safe Fallback (Technical)**: If still no safe break found, use `adjustForSurrogate()` to ensure the split doesn't fall between a High and Low Unicode surrogate pair.
+3. **Safe Fallback (Technical)**: If still no safe break found, use `adjustForUnicodeBoundary()` to ensure the split doesn't corrupt surrogate pairs, combining marks, ZWJ/ZWNJ, or variation selectors.
 4. **Hard Split**: Only as a final resort is a character-exact split performed.
 
 **Progress Guarantee**:
@@ -333,6 +353,7 @@ The original `segmentPages` had complexity 37 (max: 15). Extraction:
 - **Unit tests**: Each utility function has dedicated tests
 - **Integration tests**: Full pipeline tests in `segmenter.test.ts`
 - **Real-world tests**: `segmenter.bukhari.test.ts` uses actual hadith data
+- **Style convention**: Prefer `it('should ...', () => { ... })` (Bun) for consistency across the suite
 - Run: `bun test`
 
 ## Code Quality Standards
@@ -433,7 +454,7 @@ bunx biome lint .
 
 11. **Safety Fallback (Search-back)**: When forced to split at a hard character limit, searching backward for whitespace/punctuation (`[\s\n.,;!?؛،۔]`) prevents word-chopping and improves readability significantly.
 
-12. **Unicode Boundary Safety (Surrogates + Graphemes)**: Multi-byte characters (like emojis) can be corrupted if split in the middle of a surrogate pair. Similarly, Arabic diacritics (combining marks), ZWJ/ZWNJ, and variation selectors can be orphaned if a hard split lands in the middle of a grapheme cluster. Use `adjustForUnicodeBoundary` (built on `adjustForSurrogate`) when forced to hard-split near a limit.
+12. **Unicode Boundary Safety (Surrogates + Graphemes)**: Multi-byte characters (like emojis) can be corrupted if split in the middle of a surrogate pair. Similarly, Arabic diacritics (combining marks), ZWJ/ZWNJ, and variation selectors can be orphaned if a hard split lands in the middle of a grapheme cluster. Use `adjustForUnicodeBoundary` when forced to hard-split near a limit.
 
 13. **Recursion/Iteration Safety**: Using a progress-based guard (comparing `cursorPos` before and after loop iteration) is safer than fixed iteration limits for supporting arbitrary-sized content without truncation risks.
 
@@ -483,8 +504,34 @@ bunx biome lint .
        - `advanceCursorAndIndex()` (progress)
        - `computeNextFromIdx()` (heuristic) **or** position-based override when `maxPages=0` (see #21)
 
-### Process Template (Multi-agent design review, TDD-first)
+25. **Page attribution can drift in large-document breakpoint processing**: For ≥`FAST_PATH_THRESHOLD` segments, boundary positions may be derived from cumulative offsets (fast path). If upstream content is modified (e.g. marker stripping or accidental leading-trim), binary-search attribution can classify a piece as starting **before** `currentFromIdx`, inflating `(to - from)` and violating `maxPages`. **Fix**: clamp `actualStartIdx >= currentFromIdx` and re-apply the `maxPages` window using the same ID-span logic as `computeWindowEndIdx(...)` before creating the piece segment.
+
+26. **Offset fast path must respect page-ID span semantics**: `maxPages` in this library is enforced as an **ID span** invariant (`(to ?? from) - from <= maxPages`). For large segments, the offset-based fast path must choose `segEnd` using the same ID-window logic as `computeWindowEndIdx(...)` (not “N pages by index”), otherwise gaps (e.g. `2216 → 2218`) produce illegal spans.
+
+27. **Never `trimStart()` huge fallback content**: `ensureFallbackSegment()` constructs “all pages as one segment” when there are no structural split rules. If this giant content is `trimStart()`’d, cumulative offsets and derived boundary positions become inconsistent, which can lead to incorrect `from/to` attribution and `maxPages` violations that only appear on very large books.
+
+28. **Always test both sides of the fast-path threshold**: Several breakpoint bugs only reproduce at or above `FAST_PATH_THRESHOLD` (1000). Add regressions at `threshold-1` and `threshold` to avoid “works in small unit tests, fails on full books” surprises.
+
+29. **Breakpoint `split` behavior**: The `split: 'at' | 'after'` option for breakpoints controls where the split happens relative to the matched text:
+   - `'after'` (default): Match is included in the previous segment
+   - `'at'`: Match starts the next segment
+   Key implementation details in `findPatternBreakPosition`:
+   - Position is calculated as `splitAt ? idx : idx + len`
+   - Matches at position 0 are skipped for `split:'at'` to prevent empty first segments
+   - Zero-length matches (lookaheads) are always skipped to prevent infinite loops
+   - Empty pattern `''` forces `splitAt=false` since page boundaries have no matched text
 
+30. **Unicode safety is the user's responsibility for patterns**: Unlike `findSafeBreakPosition` (which adjusts for grapheme boundaries), pattern-based breaks use the exact position where the user's regex matched. If a pattern matches mid-grapheme, that's a pattern authoring error, not a library bug. The library should NOT silently adjust pattern match positions.
+
+31. **Fast path doesn't affect split behavior**: The offset-based fast path only applies to empty pattern `''` breakpoints (page boundary fallback), and empty patterns force `splitAt=false`. Pattern-based breakpoints with `split:'at'` never engage the fast path.
+
+32. **Whitespace trimming affects split:'at' output**: `createSegment()` trims segment content. With `split:'at'`, if the matched text is whitespace-only, it will be trimmed from the start of the next segment. This is usually desirable for delimiter patterns.
+
+33. **`prefer` semantics with `split:'at'`**: With `prefer:'longer'` + `split:'at'`, the algorithm selects the LAST valid match, maximizing content in the previous segment. This is correct but can be counterintuitive since the resulting previous segment might appear "shorter" than with `split:'after'`.
+
+34. **Multi-agent review synthesis**: Getting implementation reviews from multiple AI models (Claude, GPT, Grok, Gemini) and synthesizing their feedback helps catch issues a single reviewer might miss. Key insight: when reviewers disagree on "critical" issues, investigate the codebase to verify claims before implementing fixes. Some "critical" issues are based on incorrect assumptions about how fast paths or downstream functions work.
+
+### Process Template (Multi-agent design review, TDD-first)
 
 If you want to repeat the “write a plan → get multiple AI critiques → synthesize → update plan → implement TDD-first” workflow, use:
 
@@ -503,27 +550,36 @@ If you want to repeat the “write a plan → get multiple AI critiques → synt
 
 ## Token Reference
 
-| Token | Pattern Description | Example Match |
-|-------|---------------------|---------------|
-| `{{tarqim}}` | Arabic punctuation (. , ; ? ! ( ) etc.) | `؛` `،` `.` |
-| `{{basmalah}}` | "بِسْمِ اللَّهِ" patterns | بِسْمِ اللَّهِ الرَّحْمَنِ |
-| `{{bab}}` | "باب" (chapter) | بَابُ الإيمان |
-| `{{fasl}}` | "فصل" (section) | فصل: في الطهارة |
-| `{{kitab}}` | "كتاب" (book) | كتاب الصلاة |
-| `{{raqm}}` | Single Arabic-Indic numeral | ٥ |
-| `{{raqms}}` | Multiple Arabic-Indic numerals | ٧٥٦٣ |
-| `{{num}}` | Single ASCII numeral | 5 |
-| `{{nums}}` | Multiple ASCII numerals | 123 |
-| `{{raqms:num}}` | Numerals with named capture | `meta.num = "٧٥٦٣"` |
-| `{{dash}}` | Various dash characters | - – — ـ |
-| `{{harfs}}` | Single-letter codes separated by spaces | `د ت س ي ق` |
-| `{{rumuz}}` | rijāl/takhrīj source abbreviations (matches blocks like `خت ٤`, `خ سي`, `دت عس ق`) | `خت ٤` |
-| `{{numbered}}` | Composite: `{{raqms}} {{dash}}` | ٧٥٦٣ - |
-
-**Named captures**: Add `:name` suffix to capture into `meta`:
+| Token | Constant | Pattern | Example |
+|-------|----------|---------|---------|
+| `{{tarqim}}` | `Token.TARQIM` | Arabic punctuation | `؛` `.` |
+| `{{basmalah}}` | `Token.BASMALAH` | "بسم الله" | بسم الله |
+| `{{bab}}` | `Token.BAB` | "باب" (chapter) | باب الإيمان |
+| `{{fasl}}` | `Token.FASL` | "فصل/مسألة" | فصل: |
+| `{{kitab}}` | `Token.KITAB` | "كتاب" (book) | كتاب الصلاة |
+| `{{naql}}` | `Token.NAQL` | Narrator phrases | حدثنا |
+| `{{raqm}}` | `Token.RAQM` | Single Arabic digit | ٥ |
+| `{{raqms}}` | `Token.RAQMS` | Multiple Arabic digits | ٧٥٦٣ |
+| `{{num}}` | `Token.NUM` | Single ASCII digit | 5 |
+| `{{nums}}` | `Token.NUMS` | Multiple ASCII digits | 123 |
+| `{{dash}}` | `Token.DASH` | Dash variants | - – — ـ |
+| `{{harf}}` | `Token.HARF` | Single Arabic letter | أ |
+| `{{harfs}}` | `Token.HARFS` | Spaced letters | د ت س |
+| `{{rumuz}}` | `Token.RUMUZ` | Source abbreviations | خت ٤ |
+| `{{bullet}}` | `Token.BULLET` | Bullet points | • * ° |
+| `{{numbered}}` | `Token.NUMBERED` | `{{raqms}} {{dash}} ` | ٧٥٦٣ - |
+
+### Token Constants (Better DX)
+
 ```typescript
-'{{raqms:hadithNum}} {{dash}}' 
-// → segment.meta.hadithNum = "٧٥٦٣"
+import { Token, withCapture } from 'flappa-doormal';
+
+// Use constants instead of strings
+{ lineStartsWith: [Token.KITAB, Token.BAB] }
+
+// Named captures with withCapture helper
+const pattern = withCapture(Token.RAQMS, 'num') + ' ' + Token.DASH + ' ';
+// → '{{raqms:num}} {{dash}} '
 ```
 
 ## Page-start Guard (`pageStartGuard`)
@@ -614,68 +670,20 @@ See README.md for complete examples.
 
 ---
 
-## Debugging Page Boundary Detection (Added 2026-01-04)
+## Debugging Tips
 
-### The Problem: False Positives in Prefix Matching
+### Page Boundary Detection Issues
 
-When using `maxPages=0` with empty breakpoint `['']` (page boundary breaks), the segmenter can fail when:
-1. **Pages have identical prefixes** - All pages start with the same text
-2. **Duplicated content within pages** - The same phrase appears multiple times in a single page
-3. **Long content** - Pages are thousands of characters, putting false matches closer to expected boundaries
+If `maxPages=0` produces merged segments when pages have identical prefixes or duplicated content:
+- Check `buildCumulativeOffsets()` for correct positions
+- Trace `findPageStartNearExpectedBoundary` candidates
+- Verify matches are within `MAX_DEVIATION` (2000 chars) of expected boundary
 
-**Root cause**: The `findPageStartNearExpectedBoundary` function in `breakpoint-utils.ts` uses prefix matching to find page boundaries. When content is duplicated, it finds matches at incorrect positions within the current page instead of at the actual page boundary.
+Key functions: `applyBreakpoints()` → `processOversizedSegment()` → `findBreakpointWindowEndPosition()` → `handlePageBoundaryBreak()`
 
-### Key Functions in the Breakpoint Chain
+### General Debugging
 
-1. **`applyBreakpoints()`** - Entry point for breakpoint processing
-2. **`processOversizedSegment()`** - Iteratively breaks segments exceeding `maxPages`
-3. **`computeWindowEndIdx()`** - Calculates max page index for current window
-4. **`findBreakpointWindowEndPosition()`** - Finds the byte position where the window ends
-5. **`findPageStartNearExpectedBoundary()`** - Content-based search for page start position
-6. **`handlePageBoundaryBreak()`** - Handles empty pattern `''` (page boundary)
-7. **`buildCumulativeOffsets()`** - Pre-computes exact byte positions for each page
+- Pass `logger` with `debug`/`trace` methods to `segmentPages()` for detailed logs
+- Check `boundaryPositions built` log for page boundary byte offsets
+- Check `iteration=N` logs for `currentFromIdx`, `cursorPos`, `windowEndPosition` per loop
 
-### Debug Strategy
-
-1. **Check cumulative offsets first** - `buildCumulativeOffsets()` returns correct positions from `pages.join('\n')`
-2. **Trace `expectedBoundary`** - This is calculated correctly from cumulative offsets
-3. **Check `findPageStartNearExpectedBoundary` candidates** - The bug is usually here; it finds false matches
-4. **Verify the deviation check** - Matches must be within `MAX_DEVIATION` (2000 chars) of expected boundary
-
-### The Fix Applied
-
-Two changes in `breakpoint-utils.ts`:
-
-1. **`findPageStartNearExpectedBoundary`** - Added `MAX_DEVIATION` check to reject matches too far from expected boundary:
-   ```typescript
-   const MAX_DEVIATION = 2000;
-   if (bestDistance <= MAX_DEVIATION) {
-       return bestCandidate.pos;
-   }
-   // Continue trying shorter prefixes or return -1
-   ```
-
-2. **`findBreakpointWindowEndPosition`** - Changed fallback from `remainingContent.length` to `bestExpectedBoundary`:
-   ```typescript
-   // Before (bug): return remainingContent.length; // Merges all remaining pages!
-   // After (fix): return Math.min(bestExpectedBoundary, remainingContent.length);
-   ```
-
-### Test Case Pattern for This Bug
-
-```typescript
-it('should correctly split pages with identical prefixes and duplicated content', () => {
-    const sharedPrefix = 'SHARED PREFIX ';
-    const filler = 'Lorem ipsum. '.repeat(200); // ~6000 chars
-    const pages: Page[] = [
-        { content: sharedPrefix + 'start ' + filler + sharedPrefix + 'end', id: 0 },
-        { content: sharedPrefix + 'page1', id: 1 },
-        { content: sharedPrefix + 'page2', id: 2 },
-    ];
-    const result = segmentPages(pages, { breakpoints: [''], maxPages: 0 });
-    expect(result).toHaveLength(3); // Without fix: 2 or 1
-});
-```
-
----
-15. **Use Synthesized AI Reviews**: For complex safety features, getting reviews from multiple models (Claude, GPT, etc.) and synthesizing them into a single action plan (see `docs/reviews/max-content-length-review-synthesis.md`) revealed critical edge cases like Arabic diacritic corruption and surrogate pair safety that a single model might miss.

package/README.md

@@ -117,6 +117,29 @@ Replace regex with readable tokens:
 | `{{bab}}` | "باب" (chapter) | `باب` |
 | `{{basmalah}}` | "بسم الله" | `بسم الله` |
 
+#### Token Constants (TypeScript)
+
+For better IDE support, use the `Token` constants instead of raw strings:
+
+```typescript
+import { Token, withCapture } from 'flappa-doormal';
+
+// Instead of:
+{ lineStartsWith: ['{{kitab}}', '{{bab}}'] }
+
+// Use:
+{ lineStartsWith: [Token.KITAB, Token.BAB] }
+
+// With named captures:
+const pattern = withCapture(Token.RAQMS, 'hadithNum') + ' ' + Token.DASH + ' ';
+// Result: '{{raqms:hadithNum}} {{dash}} '
+
+{ lineStartsAfter: [pattern], split: 'at' }
+// segment.meta.hadithNum will contain the matched number
+```
+
+Available constants: `Token.BAB`, `Token.BASMALAH`, `Token.BULLET`, `Token.DASH`, `Token.FASL`, `Token.HARF`, `Token.HARFS`, `Token.KITAB`, `Token.NAQL`, `Token.NUM`, `Token.NUMS`, `Token.NUMBERED`, `Token.RAQM`, `Token.RAQMS`, `Token.RUMUZ`, `Token.TARQIM`
+
 ### 2. Named Capture Groups
 
 Extract metadata automatically with the `{{token:name}}` syntax:
@@ -324,6 +347,62 @@ When a segment exceeds `maxPages` or `maxContentLength`, breakpoints split it at
 }
 ```
 
+#### Breakpoint Pattern Behavior
+
+When a breakpoint pattern matches, the split position is controlled by the `split` option:
+
+```typescript
+{
+  breakpoints: [
+    // Default: split AFTER the match (match included in previous segment)
+    { pattern: '{{tarqim}}' },  // or { pattern: '{{tarqim}}', split: 'after' }
+    
+    // Alternative: split AT the match (match starts next segment)
+    { pattern: 'ولهذا', split: 'at' },
+  ],
+}
+```
+
+**`split: 'after'` (default)**
+- Previous segment **ENDS WITH** the matched text
+- New segment **STARTS AFTER** the matched text
+
+```typescript
+// Pattern "ولهذا" with split: 'after' on "النص الأول ولهذا النص الثاني"
+// - Segment 1: "النص الأول ولهذا"  (ends WITH match)
+// - Segment 2: "النص الثاني"        (starts AFTER match)
+```
+
+**`split: 'at'`**
+- Previous segment **ENDS BEFORE** the matched text
+- New segment **STARTS WITH** the matched text
+
+```typescript
+// Pattern "ولهذا" with split: 'at' on "النص الأول ولهذا النص الثاني"
+// - Segment 1: "النص الأول"         (ends BEFORE match)
+// - Segment 2: "ولهذا النص الثاني"  (starts WITH match)
+```
+
+> **Note**: For empty pattern `''` (page boundary fallback), `split` is ignored since there is no matched text to include/exclude.
+
+**Pattern order matters** - the first matching pattern wins:
+
+```typescript
+{
+  // Patterns are tried in order
+  breakpoints: [
+    '\\.\\s*',    // Try punctuation first
+    'ولهذا',      // Then try specific word
+    '',           // Finally, fall back to page boundary
+  ],
+}
+// If punctuation is found, "ولهذا" is never tried
+```
+
+> **Note on lookahead patterns**: Zero-length patterns like `(?=X)` are not supported for breakpoints because they can cause non-progress scenarios. Use `{ pattern: 'X', split: 'at' }` instead to achieve "split before X" behavior.
+
+> **Note on whitespace**: Segments are trimmed by default. With `split:'at'`, if the match consists only of whitespace, it will be trimmed from the start of the next segment. This is usually desirable for delimiter patterns.
+
 **Security note (ReDoS)**: Breakpoints (and raw `regex` rules) compile user-provided regular expressions. **Do not accept untrusted patterns** (e.g. from end users) without validation/sandboxing; some regexes can trigger catastrophic backtracking and hang the process.
 
 ### 12. Occurrence Filtering

package/dist/index.d.mts

@@ -409,6 +409,17 @@ type BreakpointRule = {
    * Empty string `''` means fall back to page boundary.
    */
   pattern: string;
+  /**
+   * Where to split relative to the match.
+   * - `'at'`: New segment starts AT the match (previous segment does NOT include match)
+   * - `'after'`: New segment starts AFTER the match (previous segment ENDS WITH match)
+   *
+   * **Note**: For empty pattern `''`, `split` is ignored (page boundary).
+   * Invalid values are treated as `'after'`.
+   *
+   * @default 'after'
+   */
+  split?: 'at' | 'after';
   /**
    * Minimum page ID for this breakpoint to apply.
    * Segments starting before this page skip this pattern.
@@ -945,6 +956,84 @@ declare const segmentPages: (pages: Page[], options: SegmentationOptions) => Seg
  * // → '{{harf}}' (unchanged - no brackets outside tokens)
  */
 declare const escapeTemplateBrackets: (pattern: string) => string;
+/**
+ * Pre-defined token constants for use in patterns.
+ *
+ * Using these constants instead of raw `{{token}}` strings provides:
+ * - Autocompletion in IDEs
+ * - Compile-time typo detection
+ * - Easier refactoring
+ *
+ * @example
+ * // Instead of:
+ * { lineStartsWith: ['{{kitab}}', '{{bab}}'] }
+ *
+ * // Use:
+ * import { Token } from 'flappa-doormal';
+ * { lineStartsWith: [Token.KITAB, Token.BAB] }
+ *
+ * @example
+ * // With named captures - use the helper function:
+ * import { Token, withCapture } from 'flappa-doormal';
+ * { lineStartsAfter: [withCapture(Token.RAQMS, 'num') + ' ' + Token.DASH + ' '] }
+ */
+declare const Token: {
+  /** Chapter marker - باب */
+  readonly BAB: "{{bab}}";
+  /** Basmala - بسم الله */
+  readonly BASMALAH: "{{basmalah}}";
+  /** Bullet point variants */
+  readonly BULLET: "{{bullet}}";
+  /** Dash variants (hyphen, en-dash, em-dash, tatweel) */
+  readonly DASH: "{{dash}}";
+  /** Section marker - فصل / مسألة */
+  readonly FASL: "{{fasl}}";
+  /** Single Arabic letter */
+  readonly HARF: "{{harf}}";
+  /** Multiple Arabic letters separated by spaces */
+  readonly HARFS: "{{harfs}}";
+  /** Book marker - كتاب */
+  readonly KITAB: "{{kitab}}";
+  /** Hadith transmission phrases */
+  readonly NAQL: "{{naql}}";
+  /** Single ASCII digit */
+  readonly NUM: "{{num}}";
+  /** Composite: {{raqms}} {{dash}} (space) */
+  readonly NUMBERED: "{{numbered}}";
+  /** One or more ASCII digits */
+  readonly NUMS: "{{nums}}";
+  /** Single Arabic-Indic digit */
+  readonly RAQM: "{{raqm}}";
+  /** One or more Arabic-Indic digits */
+  readonly RAQMS: "{{raqms}}";
+  /** Source abbreviations (rijāl/takhrīj) */
+  readonly RUMUZ: "{{rumuz}}";
+  /** Punctuation marks */
+  readonly TARQIM: "{{tarqim}}";
+};
+/**
+ * Type representing valid token constant keys.
+ */
+type TokenKey = keyof typeof Token;
+/**
+ * Wraps a token with a named capture.
+ *
+ * @param token - Token constant (e.g., Token.RAQMS)
+ * @param name - Capture name for metadata extraction
+ * @returns Token string with capture syntax (e.g., '{{raqms:num}}')
+ *
+ * @example
+ * import { Token, withCapture } from 'flappa-doormal';
+ *
+ * // Create a pattern that captures the hadith number
+ * const pattern = withCapture(Token.RAQMS, 'hadithNum') + ' ' + Token.DASH + ' ';
+ * // Result: '{{raqms:hadithNum}} {{dash}} '
+ *
+ * // Use in a rule
+ * { lineStartsAfter: [pattern], split: 'at' }
+ * // segment.meta.hadithNum will contain the matched number
+ */
+declare const withCapture: (token: string, name: string) => string;
 /**
  * Expands any *composite* tokens (like `{{numbered}}`) into their underlying template form
  * (like `{{raqms}} {{dash}} `).
@@ -1394,5 +1483,5 @@ declare function recoverMistakenMarkersForRuns(runs: MarkerRecoveryRun[], opts?:
   segments: Segment[];
 };
 //#endregion
-export { type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type DetectedPattern, type ExpandResult, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type MarkerRecoveryReport, type MarkerRecoveryRun, type MarkerRecoverySelector, type OptimizeResult, PATTERN_TYPE_KEYS, type Page, type PageRange, type PatternTypeKey, type RepeatingSequenceExample, type RepeatingSequenceOptions, type RepeatingSequencePattern, type ReplaceRule, type RuleValidationResult, type Segment, type SegmentationOptions, type SplitRule, TOKEN_PATTERNS, type TokenMapping, type ValidationIssue, type ValidationIssueType, analyzeCommonLineStarts, analyzeRepeatingSequences, analyzeTextForRule, applyReplacements, applyTokenMappings, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, formatValidationReport, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, optimizeRules, recoverMistakenLineStartsAfterMarkers, recoverMistakenMarkersForRuns, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, templateToRegex, validateRules };
+export { type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type DetectedPattern, type ExpandResult, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type MarkerRecoveryReport, type MarkerRecoveryRun, type MarkerRecoverySelector, type OptimizeResult, PATTERN_TYPE_KEYS, type Page, type PageRange, type PatternTypeKey, type RepeatingSequenceExample, type RepeatingSequenceOptions, type RepeatingSequencePattern, type ReplaceRule, type RuleValidationResult, type Segment, type SegmentationOptions, type SplitRule, TOKEN_PATTERNS, Token, type TokenKey, type TokenMapping, type ValidationIssue, type ValidationIssueType, analyzeCommonLineStarts, analyzeRepeatingSequences, analyzeTextForRule, applyReplacements, applyTokenMappings, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, formatValidationReport, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, optimizeRules, recoverMistakenLineStartsAfterMarkers, recoverMistakenMarkersForRuns, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, templateToRegex, validateRules, withCapture };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/segmentation/fuzzy.ts","../src/segmentation/types.ts","../src/segmentation/optimize-rules.ts","../src/segmentation/pattern-validator.ts","../src/segmentation/replace.ts","../src/segmentation/segmenter.ts","../src/segmentation/tokens.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/detection.ts","../src/recovery.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/segmentation/fuzzy.ts","../src/segmentation/types.ts","../src/segmentation/optimize-rules.ts","../src/segmentation/pattern-validator.ts","../src/segmentation/replace.ts","../src/segmentation/segmenter.ts","../src/segmentation/tokens.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/detection.ts","../src/recovery.ts"],"sourcesContent":[],"mappings":"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"}