flappa-doormal 2.20.0 → 2.21.0

package/AGENTS.md

@@ -32,6 +32,11 @@ src/
 │   └── segmenter.ts            # Internal segmenter types
 ├── dictionary/                 # Dictionary-specific compiler, runtime, profiles, diagnostics
 │   ├── arabic-dictionary-rule.ts
+│   ├── constants.ts
+│   ├── dictionary-blockers.ts
+│   ├── dictionary-candidates.ts
+│   ├── dictionary-diagnostics.ts
+│   ├── dictionary-zones.ts
 │   ├── heading-classifier.ts
 │   ├── profile.ts
 │   ├── profiles.ts
@@ -122,6 +127,24 @@ scripts/
     - `options.ts`: Comprehensive `SegmentationOptions` and `Logger` definitions
     - `index.ts`: Public API types for consumers
 
+### Dictionary Blocker Notes
+
+- `previousWord.scope` defaults to `'samePage'` and only checks the same page's
+  preceding Arabic word unless you opt into cross-page behavior.
+- `previousWord.scope: 'pageStart'` only runs for page-start candidates and
+  compares against the previous page's last Arabic word, skipping the check when
+  the previous page ends with strong sentence punctuation.
+- `previousWord.scope: 'any'` combines the page-start cross-page check with the
+  usual same-page check for non-page-start candidates.
+- `pageContinuation.authorityPrecision` defaults to `'high'`; set it to
+  `'aggressive'` when page-start continuation blocking should treat
+  authority-like prefixes more conservatively.
+- `qualifierTail` and `structuralLeak` are intentionally non-configurable global
+  safety checks. They run before zone blockers and appear in diagnostics as
+  rejection reasons.
+- `diagnoseDictionaryProfile()` now reports `rejectionReasons` rather than
+  the former `blockerHits`.
+
 11. **`textUtils.ts`** - Low-level helpers (`src/utils/textUtils.ts`)
     - `makeDiacriticInsensitive()`: Arabic-aware regex generation
     - `adjustForUnicodeBoundary()`: Prevents invalid splits across multi-character clusters

package/README.md

@@ -390,6 +390,18 @@ Why this is preferred:
 - compatible with diagnostics tooling via `diagnoseDictionaryProfile()`
 - first-class validation via `validateDictionaryProfile()`
 
+Blocker authoring notes:
+- `previousWord.scope` defaults to `'samePage'`
+- set `scope: 'pageStart'` to compare only against the previous page's last
+  Arabic word for page-start candidates
+- set `scope: 'any'` to combine the page-start cross-page check with the normal
+  same-page check
+- `pageContinuation.authorityPrecision` defaults to `'high'`; use
+  `'aggressive'` when page-start continuation filtering should treat
+  authority-like prefixes more conservatively
+- `qualifierTail` and `structuralLeak` are always-on global safety checks and
+  show up in diagnostics even though they are not zone-declared blockers
+
 The production dictionary implementation now lives under `src/dictionary/`
 inside the repo, separate from the generic segmentation internals.
 
@@ -418,7 +430,7 @@ Prefer the top-level `dictionary` profile when:
 - segmenting an entire dictionary book
 - persisting JSON config for a corpus
 - the book changes layout in different sections
-- you need diagnostics, blocker hit rates, or book-specific profile tuning
+- you need diagnostics, rejection-reason rates, or book-specific profile tuning
 
 Decision guide:
 
@@ -582,7 +594,7 @@ const diagnostics = diagnoseDictionaryProfile(pages, profile, {
   sampleLimit: 25,
 });
 
-console.log(diagnostics.blockerHits);
+console.log(diagnostics.rejectionReasons);
 console.log(diagnostics.rejectedLemmas.slice(0, 10));
 ```
 
@@ -590,10 +602,15 @@ Returned diagnostics include:
 - accepted vs rejected candidate counts
 - accepted counts by `kind`
 - accepted/rejected counts by family and zone
-- blocker hit counts (`intro`, `stopLemma`, `pageContinuation`, etc.)
+- rejection-reason counts (`intro`, `stopLemma`, `pageContinuation`,
+  `qualifierTail`, `structuralLeak`, etc.)
 - top rejected lemmas
 - sampled accepted/rejected candidates for quick inspection
 
+`diagnoseDictionaryProfile()` is primarily a tuning API for profile authoring,
+so consumers should treat its output shape as less stable than the segmentation
+API itself.
+
 Validate profiles before persisting them or shipping them to an editor/CI step:
 
 ```typescript
@@ -1380,6 +1397,80 @@ const segments = segmentPages(pages, { rules });
 // ]
 ```
 
+## Agent Advisor Workflow
+
+If you want an AI agent to start from raw pages and get to a draft configuration with less hand-written glue, use `suggestSegmentationOptions()`:
+
+```typescript
+import { suggestSegmentationOptions } from 'flappa-doormal';
+
+const report = suggestSegmentationOptions(pages, {
+  maxRules: 4,
+  topLineStarts: 12,
+  topRepeatingSequences: 8,
+});
+
+console.log(report.assessment);
+console.log(report.recommendedOptions);
+console.log(report.ruleSuggestions.slice(0, 5));
+```
+
+The report includes:
+
+- preprocess cleanup hints (`removeZeroWidth`, `condenseEllipsis`, `fixTrailingWaw`)
+- an assessment of whether the book looks `structured`, `continuous`, or `mixed`
+- draft `SplitRule[]` suggestions with examples and confidence
+- a ready-to-run `recommendedOptions` object
+- rule validation output
+- self-evaluation of the generated segmentation draft
+- optional breakpoint suggestions when the draft still produces very large segments
+
+For local JSON files, you can run the bundled script:
+
+```bash
+bun run segment:advise -- --input ./pages.json
+bun run segment:advise -- --input ./book.json --format markdown --out ./segmentation-report.md
+```
+
+Input can be either:
+
+- `Page[]`
+- `{ pages: Page[] }`
+
+## MCP Server
+
+The repo now includes a stdio MCP server wrapper for agent workflows:
+
+```bash
+bun run mcp:serve
+```
+
+When packaged, the server binary is:
+
+```bash
+flappa-doormal-mcp
+```
+
+Exposed MCP tools:
+
+- `inspect_book`
+  Input: `{ pages, advisorOptions? }`
+  Returns preprocess detections, line-start analysis, repeating sequences, and draft rule suggestions.
+- `suggest_segmentation_options`
+  Input: `{ pages, advisorOptions? }`
+  Returns the full advisor report, including `recommendedOptions`.
+- `preview_segmentation`
+  Input: `{ pages, options, sampleSegments? }`
+  Runs segmentation and returns segments, samples, and validation.
+- `validate_segmentation`
+  Input: `{ pages, options, segments }`
+  Validates caller-provided segments against the source book.
+- `score_candidate_options`
+  Input: `{ pages, candidates, sampleSegments? }`
+  Ranks multiple `SegmentationOptions` candidates using validation and segment-shape heuristics.
+
+All tool results are returned as JSON-friendly objects so agents can iterate without scraping prose output.
+
 ## Advanced: Metadata Extraction & Data Migration
 
 If you already have pre-segmented data (e.g., records from a database or JSON file) and want to use **flappa-doormal's** token system to extract metadata and clean the content without further splitting, you can use the **Metadata Extraction** pattern.

package/dist/index.d.mts

@@ -145,7 +145,7 @@ type DictionaryGate = {
   use: 'headingToken';
   token: 'bab' | 'fasl' | 'kitab';
 };
-type DictionaryProfileValidationIssueCode = 'invalid_version' | 'missing_zones' | 'duplicate_zone_name' | 'empty_zone_name' | 'empty_zone_families' | 'invalid_zone_page_range' | 'empty_heading_classes' | 'inert_heading_family' | 'empty_inline_prefixes' | 'invalid_gate_match' | 'invalid_gate_fuzzy' | 'duplicate_activate_after_gate' | 'invalid_stop_words' | 'invalid_previous_words' | 'invalid_previous_chars';
+type DictionaryProfileValidationIssueCode = 'invalid_version' | 'missing_zones' | 'duplicate_zone_name' | 'empty_zone_name' | 'empty_zone_families' | 'invalid_zone_page_range' | 'empty_heading_classes' | 'inert_heading_family' | 'empty_inline_prefixes' | 'invalid_gate_match' | 'invalid_gate_fuzzy' | 'duplicate_activate_after_gate' | 'invalid_stop_words' | 'invalid_previous_words' | 'invalid_previous_chars' | 'invalid_previous_word_scope' | 'invalid_authority_intro_precision' | 'invalid_continuation_precision';
 type DictionaryProfileValidationIssue = {
   code: DictionaryProfileValidationIssueCode;
   message: string;
@@ -187,6 +187,7 @@ type DictionaryFamily = HeadingFamily | LineEntryFamily | InlineSubentryFamily |
 type PageContinuationBlocker = {
   use: 'pageContinuation';
   appliesTo?: DictionaryFamily['use'][];
+  authorityPrecision?: 'high' | 'aggressive';
 };
 type IntroBlocker = {
   use: 'intro';
@@ -206,6 +207,7 @@ type PreviousWordBlocker = {
   use: 'previousWord';
   appliesTo?: DictionaryFamily['use'][];
   words: string[];
+  scope?: 'samePage' | 'pageStart' | 'any';
 };
 type PreviousCharBlocker = {
   use: 'previousChar';
@@ -248,7 +250,7 @@ type DictionaryProfileDiagnosticsOptions = {
 type DictionaryProfileDiagnostics = {
   acceptedCount: number;
   acceptedKinds: Record<DictionarySegmentKind, number>;
-  blockerHits: Record<DictionaryDiagnosticReason, number>;
+  rejectionReasons: Record<DictionaryDiagnosticReason, number>;
   familyCounts: Record<DictionaryFamilyUse, {
     accepted: number;
     rejected: number;
@@ -1216,6 +1218,147 @@ type RepeatingSequencePattern = {
  */
 declare const analyzeRepeatingSequences: (pages: Page[], options?: RepeatingSequenceOptions) => RepeatingSequencePattern[];
 //#endregion
+//#region src/segmentation/pattern-validator.d.ts
+/**
+ * Types of validation issues that can be detected.
+ */
+type ValidationIssueType = 'missing_braces' | 'unknown_token' | 'duplicate' | 'empty_pattern' | 'invalid_regex' | 'invalid_option';
+/**
+ * A validation issue found in a pattern.
+ */
+type ValidationIssue = {
+  type: ValidationIssueType;
+  message: string;
+  suggestion?: string; /** The token name involved in the issue (for unknown_token / missing_braces) */
+  token?: string; /** The specific pattern involved (for duplicate) */
+  pattern?: string;
+};
+/**
+ * Validation result for a single rule, with issues keyed by pattern type.
+ * Arrays parallel the input pattern arrays - undefined means no issue.
+ */
+type RuleValidationResult = {
+  lineStartsWith?: (ValidationIssue | undefined)[];
+  lineStartsAfter?: (ValidationIssue | undefined)[];
+  lineEndsWith?: (ValidationIssue | undefined)[];
+  template?: ValidationIssue;
+  regex?: ValidationIssue;
+  dictionaryEntry?: Partial<Record<keyof DictionaryEntryPatternOptions, ValidationIssue>>;
+};
+/**
+ * Validates split rules for common pattern issues.
+ *
+ * Checks for:
+ * - Missing `{{}}` around known token names (e.g., `raqms:num` instead of `{{raqms:num}}`)
+ * - Unknown token names inside `{{}}` (e.g., `{{nonexistent}}`)
+ * - Duplicate patterns within the same rule
+ *
+ * @param rules - Array of split rules to validate
+ * @returns Array parallel to input with validation results (undefined if no issues)
+ *
+ * @example
+ * const issues = validateRules([
+ *   { lineStartsAfter: ['raqms:num'] },  // Missing braces
+ *   { lineStartsWith: ['{{unknown}}'] }, // Unknown token
+ * ]);
+ * // issues[0]?.lineStartsAfter?.[0]?.type === 'missing_braces'
+ * // issues[1]?.lineStartsWith?.[0]?.type === 'unknown_token'
+ */
+declare const validateRules: (rules: SplitRule[]) => (RuleValidationResult | undefined)[];
+/**
+ * Formats a validation result array into a list of human-readable error messages.
+ *
+ * Useful for displaying validation errors in UIs.
+ *
+ * @param results - The result array from `validateRules()`
+ * @returns Array of formatted error strings
+ *
+ * @example
+ * const issues = validateRules(rules);
+ * const errors = formatValidationReport(issues);
+ * // ["Rule 1, lineStartsWith: Missing {{}} around token..."]
+ */
+declare const formatValidationReport: (results: (RuleValidationResult | undefined)[]) => string[];
+//#endregion
+//#region src/analysis/segmentation-advisor.d.ts
+type SegmentationAdvisorMode = 'structured' | 'continuous' | 'mixed';
+type SegmentationAdvisorOptions = {
+  topLineStarts?: number;
+  topRepeatingSequences?: number;
+  minLineStartCount?: number;
+  minRepeatingCount?: number;
+  maxRules?: number;
+  sampleSegments?: number;
+};
+type PreprocessDetections = {
+  ellipsisCount: number;
+  trailingWawCount: number;
+  zeroWidthCount: number;
+};
+type PreprocessSuggestion = {
+  count: number;
+  reason: string;
+  transform: PreprocessTransform;
+};
+type RuleSuggestionSource = 'line-start' | 'repeating-sequence';
+type RuleSuggestionConfidence = 'high' | 'medium' | 'low';
+type SuggestedRule = {
+  confidence: RuleSuggestionConfidence;
+  count: number;
+  example: {
+    pageId: number;
+    text: string;
+  };
+  pattern: string;
+  reason: string;
+  rule: SplitRule;
+  source: RuleSuggestionSource;
+};
+type BreakpointSuggestion = {
+  breakpoints: Breakpoint[];
+  maxPages: number;
+  prefer: 'longer' | 'shorter';
+  reason: string;
+};
+type SegmentationEvaluation = {
+  averageSegmentLength: number;
+  maxSegmentLength: number;
+  multiPageSegments: number;
+  segmentCount: number;
+  validation: SegmentValidationReport;
+};
+type SegmentationSuggestionReport = {
+  assessment: {
+    mode: SegmentationAdvisorMode;
+    reason: string;
+  };
+  breakpointSuggestions: BreakpointSuggestion[];
+  evaluation?: SegmentationEvaluation;
+  lineStarts: CommonLineStartPattern[];
+  optimization: {
+    mergedCount: number;
+    optimizedRuleCount: number;
+    originalRuleCount: number;
+  };
+  preprocess: {
+    detections: PreprocessDetections;
+    suggestions: PreprocessSuggestion[];
+  };
+  recommendedOptions: SegmentationOptions;
+  repeatingSequences: RepeatingSequencePattern[];
+  ruleSuggestions: SuggestedRule[];
+  ruleValidation: RuleValidationResult[];
+  ruleValidationErrors: string[];
+  segmentSamples: Segment[];
+};
+/**
+ * Generate a machine-readable draft segmentation report for AI agents.
+ *
+ * This helper is intentionally deterministic: it inspects pages, drafts
+ * candidate rules, validates them, and evaluates its own recommendation.
+ */
+declare const suggestSegmentationOptions: (pages: Page[], options?: SegmentationAdvisorOptions) => SegmentationSuggestionReport;
+//#endregion
 //#region src/detection.d.ts
 /**
  * Result of detecting a token pattern in text
@@ -1378,9 +1521,11 @@ declare class DictionaryProfileValidationError extends Error {
  */
 declare const validateDictionaryProfile: (profile: ArabicDictionaryProfile) => DictionaryProfileValidationIssue[];
 //#endregion
-//#region src/dictionary/runtime.d.ts
+//#region src/dictionary/dictionary-diagnostics.d.ts
 /**
- * Collects authoring diagnostics for a dictionary profile without creating segments.
+ * Collects tuning-oriented diagnostics for a dictionary profile without creating
+ * segments. This output is intended for profile authoring workflows rather than
+ * long-term compatibility guarantees.
  *
  * This is useful when tuning blockers and family choices for a new dictionary.
  */
@@ -1491,68 +1636,6 @@ declare const getDebugReason: (meta: Record<string, any> | undefined, options?:
  */
 declare const getSegmentDebugReason: (segment: Segment, options?: DebugReasonOptions) => string;
 //#endregion
-//#region src/segmentation/pattern-validator.d.ts
-/**
- * Types of validation issues that can be detected.
- */
-type ValidationIssueType = 'missing_braces' | 'unknown_token' | 'duplicate' | 'empty_pattern' | 'invalid_regex' | 'invalid_option';
-/**
- * A validation issue found in a pattern.
- */
-type ValidationIssue = {
-  type: ValidationIssueType;
-  message: string;
-  suggestion?: string; /** The token name involved in the issue (for unknown_token / missing_braces) */
-  token?: string; /** The specific pattern involved (for duplicate) */
-  pattern?: string;
-};
-/**
- * Validation result for a single rule, with issues keyed by pattern type.
- * Arrays parallel the input pattern arrays - undefined means no issue.
- */
-type RuleValidationResult = {
-  lineStartsWith?: (ValidationIssue | undefined)[];
-  lineStartsAfter?: (ValidationIssue | undefined)[];
-  lineEndsWith?: (ValidationIssue | undefined)[];
-  template?: ValidationIssue;
-  regex?: ValidationIssue;
-  dictionaryEntry?: Partial<Record<keyof DictionaryEntryPatternOptions, ValidationIssue>>;
-};
-/**
- * Validates split rules for common pattern issues.
- *
- * Checks for:
- * - Missing `{{}}` around known token names (e.g., `raqms:num` instead of `{{raqms:num}}`)
- * - Unknown token names inside `{{}}` (e.g., `{{nonexistent}}`)
- * - Duplicate patterns within the same rule
- *
- * @param rules - Array of split rules to validate
- * @returns Array parallel to input with validation results (undefined if no issues)
- *
- * @example
- * const issues = validateRules([
- *   { lineStartsAfter: ['raqms:num'] },  // Missing braces
- *   { lineStartsWith: ['{{unknown}}'] }, // Unknown token
- * ]);
- * // issues[0]?.lineStartsAfter?.[0]?.type === 'missing_braces'
- * // issues[1]?.lineStartsWith?.[0]?.type === 'unknown_token'
- */
-declare const validateRules: (rules: SplitRule[]) => (RuleValidationResult | undefined)[];
-/**
- * Formats a validation result array into a list of human-readable error messages.
- *
- * Useful for displaying validation errors in UIs.
- *
- * @param results - The result array from `validateRules()`
- * @returns Array of formatted error strings
- *
- * @example
- * const issues = validateRules(rules);
- * const errors = formatValidationReport(issues);
- * // ["Rule 1, lineStartsWith: Missing {{}} around token..."]
- */
-declare const formatValidationReport: (results: (RuleValidationResult | undefined)[]) => string[];
-//#endregion
 //#region src/segmentation/segmenter.d.ts
 /**
  * Segments pages of content based on pattern-matching rules.
@@ -2009,5 +2092,5 @@ type ValidationOptions = {
  */
 declare const validateSegments: (pages: Page[], options: SegmentationOptions, segments: Segment[], validationOptions?: ValidationOptions) => SegmentValidationReport;
 //#endregion
-export { ARABIC_BASE_LETTER_CLASS, ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN, ARABIC_MARKS_CLASS, ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN, type ArabicDictionaryEntryRuleOptions, type ArabicDictionaryProfile, type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type CondenseEllipsisRule, type DetectedPattern, type DictionaryBlocker, type DictionaryDiagnosticReason, type DictionaryDiagnosticSample, type DictionaryEntryPatternOptions, type DictionaryFamily, type DictionaryFamilyUse, type DictionaryGate, type DictionaryHeadingClass, type DictionaryHeadingScanClass, type DictionaryMarkdownPage, type DictionaryProfileDiagnostics, type DictionaryProfileDiagnosticsOptions, DictionaryProfileValidationError, type DictionaryProfileValidationIssue, type DictionaryProfileValidationIssueCode, type DictionarySegmentKind, type DictionarySegmentMeta, type DictionarySurfaceKind, type DictionarySurfaceMatch, type DictionarySurfaceReport, type DictionaryZone, type ExpandResult, type FixTrailingWawRule, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type OptimizeResult, PATTERN_TYPE_KEYS, type Page, type PageRange, type PageRangeConstraint, type PageRangeConstraintWithExclude, type PatternProcessor, type PatternTypeKey, type PreprocessTransform, type RemoveZeroWidthRule, type RepeatingSequenceExample, type RepeatingSequenceOptions, type RepeatingSequencePattern, type RuleValidationResult, type Segment, type SegmentValidationIssue, type SegmentValidationIssueSeverity, type SegmentValidationIssueType, type SegmentValidationReport, type SegmentationOptions, type SplitRule, TOKEN_PATTERNS, Token, type TokenKey, type TokenMapping, type TokenPatternName, type ValidationIssue, type ValidationIssueType, type ValidationOptions, analyzeCommonLineStarts, analyzeDictionaryMarkdownPages, analyzeRepeatingSequences, analyzeTextForRule, applyPreprocessToPage, applyTokenMappings, classifyDictionaryHeading, condenseEllipsis, containsTokens, createArabicDictionaryEntryRule, detectTokenPatterns, diagnoseDictionaryProfile, escapeRegex, escapeTemplateBrackets, escapeWordsOutsideTokens, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, fixTrailingWaw, formatValidationReport, generateTemplateFromText, getAvailableTokens, getDebugReason, getSegmentDebugReason, getTokenPattern, makeDiacriticInsensitive, normalizeArabicForComparison, optimizeRules, removeZeroWidth, scanDictionaryMarkdownPage, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, templateToRegex, validateDictionaryProfile, validateRules, validateSegments, withCapture };
+export { ARABIC_BASE_LETTER_CLASS, ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN, ARABIC_MARKS_CLASS, ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN, type ArabicDictionaryEntryRuleOptions, type ArabicDictionaryProfile, type Breakpoint, type BreakpointRule, type BreakpointSuggestion, type CommonLineStartPattern, type CondenseEllipsisRule, type DetectedPattern, type DictionaryBlocker, type DictionaryDiagnosticReason, type DictionaryDiagnosticSample, type DictionaryEntryPatternOptions, type DictionaryFamily, type DictionaryFamilyUse, type DictionaryGate, type DictionaryHeadingClass, type DictionaryHeadingScanClass, type DictionaryMarkdownPage, type DictionaryProfileDiagnostics, type DictionaryProfileDiagnosticsOptions, DictionaryProfileValidationError, type DictionaryProfileValidationIssue, type DictionaryProfileValidationIssueCode, type DictionarySegmentKind, type DictionarySegmentMeta, type DictionarySurfaceKind, type DictionarySurfaceMatch, type DictionarySurfaceReport, type DictionaryZone, type ExpandResult, type FixTrailingWawRule, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type OptimizeResult, PATTERN_TYPE_KEYS, type Page, type PageRange, type PageRangeConstraint, type PageRangeConstraintWithExclude, type PatternProcessor, type PatternTypeKey, type PreprocessDetections, type PreprocessSuggestion, type PreprocessTransform, type RemoveZeroWidthRule, type RepeatingSequenceExample, type RepeatingSequenceOptions, type RepeatingSequencePattern, type RuleSuggestionConfidence, type RuleSuggestionSource, type RuleValidationResult, type Segment, type SegmentValidationIssue, type SegmentValidationIssueSeverity, type SegmentValidationIssueType, type SegmentValidationReport, type SegmentationAdvisorMode, type SegmentationAdvisorOptions, type SegmentationEvaluation, type SegmentationOptions, type SegmentationSuggestionReport, type SplitRule, type SuggestedRule, TOKEN_PATTERNS, Token, type TokenKey, type TokenMapping, type TokenPatternName, type ValidationIssue, type ValidationIssueType, type ValidationOptions, analyzeCommonLineStarts, analyzeDictionaryMarkdownPages, analyzeRepeatingSequences, analyzeTextForRule, applyPreprocessToPage, applyTokenMappings, classifyDictionaryHeading, condenseEllipsis, containsTokens, createArabicDictionaryEntryRule, detectTokenPatterns, diagnoseDictionaryProfile, escapeRegex, escapeTemplateBrackets, escapeWordsOutsideTokens, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, fixTrailingWaw, formatValidationReport, generateTemplateFromText, getAvailableTokens, getDebugReason, getSegmentDebugReason, getTokenPattern, makeDiacriticInsensitive, normalizeArabicForComparison, optimizeRules, removeZeroWidth, scanDictionaryMarkdownPage, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, suggestSegmentationOptions, templateToRegex, validateDictionaryProfile, validateRules, validateSegments, withCapture };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/breakpoints.ts","../src/types/dictionary.ts","../src/types/rules.ts","../src/types/options.ts","../src/types/validation.ts","../src/types/index.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/detection.ts","../src/dictionary/arabic-dictionary-rule.ts","../src/dictionary/heading-classifier.ts","../src/dictionary/profile.ts","../src/dictionary/runtime.ts","../src/optimization/optimize-rules.ts","../src/preprocessing/transforms.ts","../src/segmentation/breakpoint-utils.ts","../src/segmentation/debug-meta.ts","../src/segmentation/pattern-validator.ts","../src/segmentation/segmenter.ts","../src/segmentation/tokens.ts","../src/utils/textUtils.ts","../src/validation/validate-segments.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/breakpoints.ts","../src/types/dictionary.ts","../src/types/rules.ts","../src/types/options.ts","../src/types/validation.ts","../src/types/index.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/segmentation/pattern-validator.ts","../src/analysis/segmentation-advisor.ts","../src/detection.ts","../src/dictionary/arabic-dictionary-rule.ts","../src/dictionary/heading-classifier.ts","../src/dictionary/profile.ts","../src/dictionary/dictionary-diagnostics.ts","../src/optimization/optimize-rules.ts","../src/preprocessing/transforms.ts","../src/segmentation/breakpoint-utils.ts","../src/segmentation/debug-meta.ts","../src/segmentation/segmenter.ts","../src/segmentation/tokens.ts","../src/utils/textUtils.ts","../src/validation/validate-segments.ts"],"mappings":"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"}