flappa-doormal 2.18.0 → 2.19.0

package/README.md

@@ -285,6 +285,7 @@ const rules = [{
 | `lineEndsWith` | ✅ Included | Match patterns at end of line |
 | `template` | Depends | Custom pattern with full control |
 | `regex` | Depends | Raw regex for complex cases |
+| `dictionaryEntry` | ✅ Included | Serializable Arabic dictionary headword rule |
 
 #### Building UIs with Pattern Type Keys
 
@@ -293,7 +294,7 @@ The library exports `PATTERN_TYPE_KEYS` (a const array) and `PatternTypeKey` (a
 ```typescript
 import { PATTERN_TYPE_KEYS, type PatternTypeKey } from 'flappa-doormal';
 
-// PATTERN_TYPE_KEYS = ['lineStartsWith', 'lineStartsAfter', 'lineEndsWith', 'template', 'regex']
+// PATTERN_TYPE_KEYS = ['lineStartsWith', 'lineStartsAfter', 'lineEndsWith', 'template', 'regex', 'dictionaryEntry']
 
 // Build a dropdown/select
 PATTERN_TYPE_KEYS.map(key => <option value={key}>{key}</option>)
@@ -351,7 +352,9 @@ the stoplist guard is skipped and the page-start match is allowed.
 #### Arabic Dictionary Helper
 
 Use `createArabicDictionaryEntryRule()` to build a conservative rule for Arabic
-dictionaries with lemma capture, stopword filtering, and page-wrap protection:
+dictionaries with lemma capture, stopword filtering, and page-wrap protection.
+The helper now returns a serializable native `dictionaryEntry` rule rather than
+an eagerly-compiled regex blob:
 
 ```typescript
 import { createArabicDictionaryEntryRule, segmentPages } from 'flappa-doormal';
@@ -364,16 +367,35 @@ const rule = createArabicDictionaryEntryRule({
   allowParenthesized: true,         // e.g. (عنبر) :
   allowWhitespaceBeforeColon: true, // e.g. عنبر :
   allowCommaSeparated: true,        // e.g. سبد، دبس:
+  midLineSubentries: false,         // line/page starts only
 });
 
 const segments = segmentPages(pages, { rules: [rule] });
 ```
 
+Equivalent direct JSON-authored rule:
+
+```typescript
+const rule = {
+  dictionaryEntry: {
+    stopWords: ['وقيل', 'ويقال', 'قال', 'العجاج', 'أخاك'],
+    allowParenthesized: true,
+    allowWhitespaceBeforeColon: true,
+    allowCommaSeparated: true,
+    midLineSubentries: false,
+  },
+  pageStartPrevWordStoplist: ['قال', 'وقيل', 'ويقال'],
+  samePagePrevWordStoplist: ['جل'],
+  meta: { type: 'entry' },
+};
+```
+
 Behavior:
 - Keeps the lemma marker in `segment.content`
 - Stores the matched lemma in `segment.meta.lemma`
 - Matches root entries at true line/page starts like `عز:` and `لع:`
 - Matches mid-line subentries conservatively when they begin with `و`
+- Supports disabling mid-line subentries entirely with `midLineSubentries: false`
 - Can match parenthesized headwords like `(عنبر) :` when enabled
 - Can match comma-separated headword lists like `سبد، دبس:` when enabled
 - Can suppress same-page false positives like `جلّ وعزّ:` with `samePagePrevWordStoplist`

package/dist/index.d.mts

@@ -259,6 +259,73 @@ type LineStartsAfterPattern = {
 type LineEndsWithPattern = {
   /** Array of patterns that mark line endings. Brackets `()[]` are auto-escaped. */lineEndsWith: string[];
 };
+/**
+ * Dictionary entry pattern options for Arabic lexicon-style headword matching.
+ *
+ * This captures authoring intent in a serializable shape and is compiled into
+ * a regex internally by the rule compiler.
+ */
+interface DictionaryEntryPatternOptions {
+  /**
+   * Words that should never be treated as lemmas when followed by a colon.
+   *
+   * Matching is Arabic-normalized, diacritic-insensitive, and exact. Callers
+   * should provide canonical forms only; vocalized variants do not need to be
+   * listed separately.
+   */
+  stopWords: string[];
+  /**
+   * Allow balanced parenthesized headwords like `(عنبر):` or `(عنبر) :`.
+   * @default false
+   */
+  allowParenthesized?: boolean;
+  /**
+   * Allow optional whitespace before the trailing colon.
+   * @default false
+   */
+  allowWhitespaceBeforeColon?: boolean;
+  /**
+   * Allow comma-separated headword lists like `سبد، دبس:`.
+   * @default false
+   */
+  allowCommaSeparated?: boolean;
+  /**
+   * Allow conservative mid-line subentries that begin with `و`.
+   * Disable this when the rule should only split true line/page starts.
+   * @default true
+   */
+  midLineSubentries?: boolean;
+  /**
+   * Named capture key for the matched lemma metadata.
+   * @default 'lemma'
+   */
+  captureName?: string;
+  /**
+   * Minimum number of Arabic base letters in a lemma.
+   * @default 2
+   */
+  minLetters?: number;
+  /**
+   * Maximum number of Arabic base letters in a lemma.
+   * @default 10
+   */
+  maxLetters?: number;
+}
+/**
+ * Arabic dictionary entry pattern rule - serializable headword matcher compiled internally.
+ *
+ * @example
+ * {
+ *   dictionaryEntry: {
+ *     stopWords: ['قال', 'وقيل'],
+ *     allowCommaSeparated: true,
+ *   },
+ *   meta: { type: 'entry' }
+ * }
+ */
+type DictionaryEntryPattern = {
+  dictionaryEntry: DictionaryEntryPatternOptions;
+};
 /**
  * Union of all pattern types for split rules.
  *
@@ -268,8 +335,9 @@ type LineEndsWithPattern = {
  * - `lineStartsWith` - Match line beginnings (marker included)
  * - `lineStartsAfter` - Match line beginnings (marker excluded)
  * - `lineEndsWith` - Match line endings
+ * - `dictionaryEntry` - Arabic dictionary headword matching
  */
-type PatternType = RegexPattern | TemplatePattern | LineStartsWithPattern | LineStartsAfterPattern | LineEndsWithPattern;
+type PatternType = RegexPattern | TemplatePattern | LineStartsWithPattern | LineStartsAfterPattern | LineEndsWithPattern | DictionaryEntryPattern;
 /**
  * Pattern type key names for split rules.
  *
@@ -285,7 +353,7 @@ type PatternType = RegexPattern | TemplatePattern | LineStartsWithPattern | Line
  * const validateKey = (k: string): k is PatternTypeKey =>
  *   (PATTERN_TYPE_KEYS as readonly string[]).includes(k);
  */
-declare const PATTERN_TYPE_KEYS: readonly ["lineStartsWith", "lineStartsAfter", "lineEndsWith", "template", "regex"];
+declare const PATTERN_TYPE_KEYS: readonly ["lineStartsWith", "lineStartsAfter", "lineEndsWith", "template", "regex", "dictionaryEntry"];
 /**
  * String union of pattern type key names.
  *
@@ -417,7 +485,7 @@ type RuleConstraints = PageRangeConstraintWithExclude & {
  *
  * Each rule must specify:
  * - **Pattern** (exactly one): `regex`, `template`, `lineStartsWith`,
- *   `lineStartsAfter`, or `lineEndsWith`
+ *   `lineStartsAfter`, `lineEndsWith`, or `dictionaryEntry`
  * - **Split behavior**: `split` (optional, defaults to `'at'`), `occurrence`, `fuzzy`
  * - **Constraints** (optional): `min`, `max`, `meta`
  *
@@ -1122,30 +1190,7 @@ declare const fixTrailingWaw: (text: string) => string;
 declare const applyPreprocessToPage: (content: string, pageId: number, transforms: PreprocessTransform[]) => string;
 //#endregion
 //#region src/segmentation/arabic-dictionary-rule.d.ts
-interface ArabicDictionaryEntryRuleOptions {
-  /**
-   * Words that should never be treated as lemmas when followed by a colon.
-   *
-   * Matching is Arabic-normalized, diacritic-insensitive, and exact. Callers
-   * should provide canonical forms only; vocalized variants do not need to be
-   * listed separately.
-   */
-  stopWords: string[];
-  /**
-   * Allow balanced parenthesized headwords like `(عنبر):` or `(عنبر) :`.
-   * @default false
-   */
-  allowParenthesized?: boolean;
-  /**
-   * Allow optional whitespace before the trailing colon.
-   * @default false
-   */
-  allowWhitespaceBeforeColon?: boolean;
-  /**
-   * Allow comma-separated headword lists like `سبد، دبس:`.
-   * @default false
-   */
-  allowCommaSeparated?: boolean;
+interface ArabicDictionaryEntryRuleOptions extends DictionaryEntryPatternOptions {
   /**
    * Suppress page-start matches when the previous page's last Arabic word
    * is in this stoplist, unless that page ends with strong sentence punctuation.
@@ -1156,21 +1201,6 @@ interface ArabicDictionaryEntryRuleOptions {
    * on the same page is in this stoplist.
    */
   samePagePrevWordStoplist?: string[];
-  /**
-   * Named capture key for the matched lemma.
-   * @default 'lemma'
-   */
-  captureName?: string;
-  /**
-   * Minimum number of Arabic base letters in a lemma.
-   * @default 2
-   */
-  minLetters?: number;
-  /**
-   * Maximum number of Arabic base letters in a lemma.
-   * @default 10
-   */
-  maxLetters?: number;
   /**
    * Static metadata merged into matching segments.
    */
@@ -1179,13 +1209,9 @@ interface ArabicDictionaryEntryRuleOptions {
 /**
  * Creates a reusable split rule for Arabic dictionary entries.
  *
- * The generated rule:
- * - keeps the lemma marker in `segment.content`
- * - stores the lemma in `segment.meta[captureName]`
- * - matches root entries at true line/page starts
- * - matches mid-line subentries conservatively when they begin with `و`
- * - can optionally support parenthesized headwords like `(عنبر) :`
- * - can optionally support comma-separated headword lists like `سبد، دبس:`
+ * The returned rule preserves authoring intent as a serializable
+ * `{ dictionaryEntry: ... }` pattern rather than eagerly compiling to a raw
+ * regex string.
  *
  * @example
  * createArabicDictionaryEntryRule({
@@ -1208,6 +1234,7 @@ declare const createArabicDictionaryEntryRule: ({
   captureName,
   maxLetters,
   meta,
+  midLineSubentries,
   minLetters,
   pageStartPrevWordStoplist,
   samePagePrevWordStoplist,
@@ -1269,7 +1296,7 @@ declare const getSegmentDebugReason: (segment: Segment, options?: DebugReasonOpt
 /**
  * Types of validation issues that can be detected.
  */
-type ValidationIssueType = 'missing_braces' | 'unknown_token' | 'duplicate' | 'empty_pattern' | 'invalid_regex';
+type ValidationIssueType = 'missing_braces' | 'unknown_token' | 'duplicate' | 'empty_pattern' | 'invalid_regex' | 'invalid_option';
 /**
  * A validation issue found in a pattern.
  */
@@ -1290,6 +1317,7 @@ type RuleValidationResult = {
   lineEndsWith?: (ValidationIssue | undefined)[];
   template?: ValidationIssue;
   regex?: ValidationIssue;
+  dictionaryEntry?: Partial<Record<keyof DictionaryEntryPatternOptions, ValidationIssue>>;
 };
 /**
  * Validates split rules for common pattern issues.
@@ -1756,5 +1784,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 Breakpoint, type BreakpointRule, type CommonLineStartPattern, type CondenseEllipsisRule, type DetectedPattern, 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, analyzeRepeatingSequences, analyzeTextForRule, applyPreprocessToPage, applyTokenMappings, condenseEllipsis, containsTokens, createArabicDictionaryEntryRule, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, escapeWordsOutsideTokens, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, fixTrailingWaw, formatValidationReport, generateTemplateFromText, getAvailableTokens, getDebugReason, getSegmentDebugReason, getTokenPattern, makeDiacriticInsensitive, normalizeArabicForComparison, optimizeRules, removeZeroWidth, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, templateToRegex, validateRules, validateSegments, withCapture };
+export { ARABIC_BASE_LETTER_CLASS, ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN, ARABIC_MARKS_CLASS, ARABIC_WORD_WITH_OPTIONAL_MARKS_PATTERN, type ArabicDictionaryEntryRuleOptions, type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type CondenseEllipsisRule, type DetectedPattern, type DictionaryEntryPatternOptions, 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, analyzeRepeatingSequences, analyzeTextForRule, applyPreprocessToPage, applyTokenMappings, condenseEllipsis, containsTokens, createArabicDictionaryEntryRule, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, escapeWordsOutsideTokens, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, fixTrailingWaw, formatValidationReport, generateTemplateFromText, getAvailableTokens, getDebugReason, getSegmentDebugReason, getTokenPattern, makeDiacriticInsensitive, normalizeArabicForComparison, optimizeRules, removeZeroWidth, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, templateToRegex, validateRules, validateSegments, withCapture };
 //# 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/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/optimization/optimize-rules.ts","../src/preprocessing/transforms.ts","../src/segmentation/arabic-dictionary-rule.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/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/optimization/optimize-rules.ts","../src/preprocessing/transforms.ts","../src/segmentation/arabic-dictionary-rule.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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"}

package/dist/index.mjs

@@ -1300,7 +1300,8 @@ const PATTERN_TYPE_KEYS = [
 	"lineStartsAfter",
 	"lineEndsWith",
 	"template",
-	"regex"
+	"regex",
+	"dictionaryEntry"
 ];
 //#endregion
 //#region src/optimization/optimize-rules.ts
@@ -1319,11 +1320,17 @@ const getPatternArray = (rule, key) => {
 };
 const getPatternString = (rule, key) => {
 	const value = rule[key];
-	return typeof value === "string" ? value : Array.isArray(value) ? value.join("\n") : "";
+	return typeof value === "string" ? value : Array.isArray(value) ? value.join("\n") : value ? JSON.stringify(value) : "";
 };
 const normalizePatterns = (patterns) => [...new Set(patterns)].sort((a, b) => b.length - a.length || a.localeCompare(b));
+const getDictionaryEntrySpecificityScore = (rule) => {
+	if (!("dictionaryEntry" in rule)) return 0;
+	const { allowCommaSeparated = false, allowParenthesized = false, allowWhitespaceBeforeColon = false, maxLetters = 10, midLineSubentries = true, minLetters = 2, stopWords } = rule.dictionaryEntry;
+	return minLetters * 20 + maxLetters + (allowCommaSeparated ? 0 : 120) + (allowParenthesized ? 0 : 60) + (allowWhitespaceBeforeColon ? 0 : 20) + (midLineSubentries ? 0 : 160) + Math.min(stopWords.length, 25);
+};
 const getSpecificityScore = (rule) => {
 	const key = getPatternKey(rule);
+	if (key === "dictionaryEntry") return getDictionaryEntrySpecificityScore(rule);
 	return MERGEABLE_KEYS.has(key) ? getPatternArray(rule, key).reduce((max, p) => Math.max(max, p.length), 0) : getPatternString(rule, key).length;
 };
 const createMergeKey = (rule) => {
@@ -1470,21 +1477,21 @@ const applyPreprocessToPage = (content, pageId, transforms) => {
 };
 //#endregion
 //#region src/segmentation/arabic-dictionary-rule.ts
-const uniqueNormalizedWords = (words) => {
+const uniqueCanonicalWords = (words) => {
 	const seen = /* @__PURE__ */ new Set();
 	const result = [];
 	for (const word of words) {
 		const normalized = normalizeArabicForComparison(word);
 		if (!normalized || seen.has(normalized)) continue;
 		seen.add(normalized);
-		result.push(normalized);
+		result.push(word);
 	}
 	return result;
 };
 const buildStopAlternation = (stopWords) => {
-	const unique = uniqueNormalizedWords(stopWords);
+	const unique = uniqueCanonicalWords(stopWords);
 	if (unique.length === 0) return "";
-	return unique.map((word) => makeDiacriticInsensitive(word)).join("|");
+	return unique.map((word) => makeDiacriticInsensitive(normalizeArabicForComparison(word))).join("|");
 };
 const buildHeadwordBody = ({ allowCommaSeparated, colonPattern, stopAlternation, stopwordBody, unit }) => {
 	if (!stopAlternation) return allowCommaSeparated ? `${unit}(?:\\s*[،,]\\s*${unit})*` : unit;
@@ -1493,20 +1500,53 @@ const buildHeadwordBody = ({ allowCommaSeparated, colonPattern, stopAlternation,
 };
 const buildBalancedMarker = ({ allowParenthesized, allowWhitespaceBeforeColon, captureName, headwordBody }) => {
 	const colon = allowWhitespaceBeforeColon ? "\\s*:" : ":";
-	const withCapture = captureName ? `(?<${captureName}>${headwordBody})` : `(?:${headwordBody})`;
+	const withCapture = `(?<${captureName}>${headwordBody})`;
 	if (!allowParenthesized) return `${withCapture}${colon}`;
 	return `(?:\\(\\s*${withCapture}\\s*\\)|${withCapture})${colon}`;
 };
+const validateDictionaryEntryOptions = ({ captureName = "lemma", maxLetters = 10, minLetters = 2 }) => {
+	if (!Number.isInteger(minLetters) || minLetters < 1) throw new Error(`createArabicDictionaryEntryRule: minLetters must be an integer >= 1, got ${minLetters}`);
+	if (!Number.isInteger(maxLetters) || maxLetters < minLetters) throw new Error(`createArabicDictionaryEntryRule: maxLetters must be an integer >= minLetters, got ${maxLetters}`);
+	if (!captureName.match(/^[A-Za-z_]\w*$/)) throw new Error(`createArabicDictionaryEntryRule: invalid captureName "${captureName}"`);
+};
+const buildArabicDictionaryEntryRegexSource = ({ allowCommaSeparated = false, allowParenthesized = false, allowWhitespaceBeforeColon = false, captureName = "lemma", maxLetters = 10, midLineSubentries = true, minLetters = 2, stopWords }, capturePrefix) => {
+	validateDictionaryEntryOptions({
+		captureName,
+		maxLetters,
+		minLetters
+	});
+	const zeroWidthPrefix = "[\\u200E\\u200F\\u061C\\u200B\\u200C\\u200D\\uFEFF]*";
+	const wawWithMarks = `و${ARABIC_MARKS_CLASS}*`;
+	const alWithMarks = `ا${ARABIC_MARKS_CLASS}*ل${ARABIC_MARKS_CLASS}*`;
+	const lemmaUnit = `(?:${wawWithMarks})?(?:${alWithMarks})?${`${ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN}(?:${ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN}){${minLetters - 1},${maxLetters - 1}}`}`;
+	const stopAlternation = buildStopAlternation(stopWords);
+	const lemmaBody = buildHeadwordBody({
+		allowCommaSeparated,
+		colonPattern: allowWhitespaceBeforeColon ? "\\s*:" : ":",
+		stopAlternation,
+		stopwordBody: stopAlternation ? `(?:${wawWithMarks})?(?:${stopAlternation})` : "",
+		unit: lemmaUnit
+	});
+	const lineStartBoundary = `(?:(?<=^)|(?<=\\n))${zeroWidthPrefix}`;
+	const midLineTrigger = allowParenthesized ? `(?<=\\s)(?=(?:\\(\\s*)?${wawWithMarks}(?:${alWithMarks})?)` : `(?<=\\s)(?=${wawWithMarks}(?:${alWithMarks})?)`;
+	const prefixedCaptureName = capturePrefix ? `${capturePrefix}${captureName}` : captureName;
+	const regex = `(?:${lineStartBoundary}${midLineSubentries ? `|${midLineTrigger}` : ""})` + buildBalancedMarker({
+		allowParenthesized,
+		allowWhitespaceBeforeColon,
+		captureName: prefixedCaptureName,
+		headwordBody: lemmaBody
+	});
+	return {
+		captureNames: [prefixedCaptureName],
+		regex
+	};
+};
 /**
 * Creates a reusable split rule for Arabic dictionary entries.
 *
-* The generated rule:
-* - keeps the lemma marker in `segment.content`
-* - stores the lemma in `segment.meta[captureName]`
-* - matches root entries at true line/page starts
-* - matches mid-line subentries conservatively when they begin with `و`
-* - can optionally support parenthesized headwords like `(عنبر) :`
-* - can optionally support comma-separated headword lists like `سبد، دبس:`
+* The returned rule preserves authoring intent as a serializable
+* `{ dictionaryEntry: ... }` pattern rather than eagerly compiling to a raw
+* regex string.
 *
 * @example
 * createArabicDictionaryEntryRule({
@@ -1522,33 +1562,26 @@ const buildBalancedMarker = ({ allowParenthesized, allowWhitespaceBeforeColon, c
 *   stopWords: ['الليث', 'العجاج'],
 * })
 */
-const createArabicDictionaryEntryRule = ({ allowCommaSeparated = false, allowParenthesized = false, allowWhitespaceBeforeColon = false, captureName = "lemma", maxLetters = 10, meta, minLetters = 2, pageStartPrevWordStoplist, samePagePrevWordStoplist, stopWords }) => {
-	if (!Number.isInteger(minLetters) || minLetters < 1) throw new Error(`createArabicDictionaryEntryRule: minLetters must be an integer >= 1, got ${minLetters}`);
-	if (!Number.isInteger(maxLetters) || maxLetters < minLetters) throw new Error(`createArabicDictionaryEntryRule: maxLetters must be an integer >= minLetters, got ${maxLetters}`);
-	if (!captureName.match(/^[A-Za-z_]\w*$/)) throw new Error(`createArabicDictionaryEntryRule: invalid captureName "${captureName}"`);
-	const zeroWidthPrefix = "[\\u200E\\u200F\\u061C\\u200B\\u200C\\u200D\\uFEFF]*";
-	const wawWithMarks = `و${ARABIC_MARKS_CLASS}*`;
-	const alWithMarks = `ا${ARABIC_MARKS_CLASS}*ل${ARABIC_MARKS_CLASS}*`;
-	const lemmaUnit = `(?:${wawWithMarks})?(?:${alWithMarks})?${`${ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN}(?:${ARABIC_LETTER_WITH_OPTIONAL_MARKS_PATTERN}){${minLetters - 1},${maxLetters - 1}}`}`;
-	const stopAlternation = buildStopAlternation(stopWords);
-	const lemmaBody = buildHeadwordBody({
-		allowCommaSeparated,
-		colonPattern: allowWhitespaceBeforeColon ? "\\s*:" : ":",
-		stopAlternation,
-		stopwordBody: stopAlternation ? `(?:${wawWithMarks})?(?:${stopAlternation})` : "",
-		unit: lemmaUnit
+const createArabicDictionaryEntryRule = ({ allowCommaSeparated = false, allowParenthesized = false, allowWhitespaceBeforeColon = false, captureName = "lemma", maxLetters = 10, meta, midLineSubentries = true, minLetters = 2, pageStartPrevWordStoplist, samePagePrevWordStoplist, stopWords }) => {
+	validateDictionaryEntryOptions({
+		captureName,
+		maxLetters,
+		minLetters
 	});
 	return {
-		meta,
-		pageStartPrevWordStoplist,
-		regex: `(?:${`(?:(?<=^)|(?<=\\n))${zeroWidthPrefix}`}|${allowParenthesized ? `(?<=\\s)(?=(?:\\(\\s*)?${wawWithMarks}(?:${alWithMarks})?)` : `(?<=\\s)(?=${wawWithMarks}(?:${alWithMarks})?)`})` + buildBalancedMarker({
+		dictionaryEntry: {
+			allowCommaSeparated,
 			allowParenthesized,
 			allowWhitespaceBeforeColon,
 			captureName,
-			headwordBody: lemmaBody
-		}),
-		samePagePrevWordStoplist,
-		split: "at"
+			maxLetters,
+			midLineSubentries,
+			minLetters,
+			stopWords: uniqueCanonicalWords(stopWords)
+		},
+		meta,
+		pageStartPrevWordStoplist,
+		samePagePrevWordStoplist
 	};
 };
 const WINDOW_PREFIX_LENGTHS = [
@@ -2636,6 +2669,26 @@ const validateRegexRule = (rule, result) => {
 		return true;
 	}
 };
+const invalidDictionaryEntryIssue = (message) => ({
+	message,
+	type: "invalid_option"
+});
+const validateDictionaryEntryRule = (rule, result) => {
+	if (!("dictionaryEntry" in rule) || !rule.dictionaryEntry) return false;
+	const issues = {};
+	const { allowCommaSeparated, allowParenthesized, allowWhitespaceBeforeColon, captureName, maxLetters, midLineSubentries, minLetters, stopWords } = rule.dictionaryEntry;
+	if (!Array.isArray(stopWords) || stopWords.some((word) => typeof word !== "string" || !word.trim())) issues.stopWords = invalidDictionaryEntryIssue("stopWords must be a string[] with non-empty entries");
+	if (allowCommaSeparated !== void 0 && typeof allowCommaSeparated !== "boolean") issues.allowCommaSeparated = invalidDictionaryEntryIssue("allowCommaSeparated must be a boolean");
+	if (allowParenthesized !== void 0 && typeof allowParenthesized !== "boolean") issues.allowParenthesized = invalidDictionaryEntryIssue("allowParenthesized must be a boolean");
+	if (allowWhitespaceBeforeColon !== void 0 && typeof allowWhitespaceBeforeColon !== "boolean") issues.allowWhitespaceBeforeColon = invalidDictionaryEntryIssue("allowWhitespaceBeforeColon must be a boolean");
+	if (midLineSubentries !== void 0 && typeof midLineSubentries !== "boolean") issues.midLineSubentries = invalidDictionaryEntryIssue("midLineSubentries must be a boolean");
+	if (captureName !== void 0 && !captureName.match(/^[A-Za-z_]\w*$/)) issues.captureName = invalidDictionaryEntryIssue(`captureName must match /^[A-Za-z_]\\w*$/, got "${captureName}"`);
+	if (minLetters !== void 0 && (!Number.isInteger(minLetters) || minLetters < 1)) issues.minLetters = invalidDictionaryEntryIssue("minLetters must be an integer >= 1");
+	if (maxLetters !== void 0 && (!Number.isInteger(maxLetters) || maxLetters < (minLetters ?? 2))) issues.maxLetters = invalidDictionaryEntryIssue(`maxLetters must be an integer >= ${minLetters ?? 2}`);
+	if (Object.keys(issues).length === 0) return false;
+	result.dictionaryEntry = issues;
+	return true;
+};
 const formatValidationIssue = (_type, issue, loc) => {
 	if (!issue) return null;
 	if (issue.type === "missing_braces") return `${loc}: Missing {{}} around token "${issue.token}"`;
@@ -2670,7 +2723,8 @@ const validateRules = (rules) => rules.map((rule) => {
 	const endsWithIssues = applyRulePatternValidation(result, "lineEndsWith", rule.lineEndsWith);
 	const templateIssues = validateTemplateRule(rule, result);
 	const regexIssues = validateRegexRule(rule, result);
-	return startsWithIssues || startsAfterIssues || endsWithIssues || templateIssues || regexIssues ? result : void 0;
+	const dictionaryEntryIssues = validateDictionaryEntryRule(rule, result);
+	return startsWithIssues || startsAfterIssues || endsWithIssues || templateIssues || regexIssues || dictionaryEntryIssues ? result : void 0;
 });
 /**
 * Formats a validation result array into a list of human-readable error messages.
@@ -2687,8 +2741,12 @@ const validateRules = (rules) => rules.map((rule) => {
 */
 const formatValidationReport = (results) => results.flatMap((result, i) => {
 	if (!result) return [];
-	return Object.entries(result).flatMap(([type, issues]) => (Array.isArray(issues) ? issues : [issues]).map((issue) => formatValidationIssue(type, issue, `Rule ${i + 1}, ${type}`)).filter((msg) => msg !== null));
+	return Object.entries(result).flatMap(([type, issues]) => formatValidationIssues(type, issues, i + 1));
 });
+const formatValidationIssues = (type, issues, ruleNumber) => {
+	if (type === "dictionaryEntry" && issues && typeof issues === "object" && !Array.isArray(issues)) return Object.entries(issues).map(([field, issue]) => formatValidationIssue(type, issue, `Rule ${ruleNumber}, ${type}.${field}`)).filter((msg) => msg !== null);
+	return (Array.isArray(issues) ? issues : [issues]).map((issue) => formatValidationIssue(type, issue, `Rule ${ruleNumber}, ${type}`)).filter((msg) => msg !== null);
+};
 //#endregion
 //#region src/segmentation/breakpoint-processor.ts
 const buildPageIdToIndexMap = (pageIds) => new Map(pageIds.map((id, i) => [id, i]));
@@ -3336,6 +3394,7 @@ const buildLineBasedRuleRegex = (rule, fuzzy, capturePrefix) => {
 	if ("lineStartsWith" in rule && Array.isArray(rule.lineStartsWith) && rule.lineStartsWith.length > 0) return buildLineStartsWithRegexSource(rule.lineStartsWith, fuzzy, capturePrefix);
 	if ("lineEndsWith" in rule && Array.isArray(rule.lineEndsWith) && rule.lineEndsWith.length > 0) return buildLineEndsWithRegexSource(rule.lineEndsWith, fuzzy, capturePrefix);
 	if ("template" in rule && typeof rule.template === "string") return buildTemplateRegexSource(rule.template, capturePrefix);
+	if ("dictionaryEntry" in rule && rule.dictionaryEntry) return buildArabicDictionaryEntryRegexSource(rule.dictionaryEntry, capturePrefix);
 	return null;
 };
 /**
@@ -3358,7 +3417,7 @@ const buildRuleRegex = (rule, capturePrefix) => {
 	let finalRegex = ruleRegexSource?.regex;
 	let allCaptureNames = ruleRegexSource?.captureNames ?? [];
 	if (!finalRegex && "regex" in rule && typeof rule.regex === "string") finalRegex = rule.regex;
-	if (!finalRegex) throw new Error("Rule must specify exactly one pattern type: regex, template, lineStartsWith, lineStartsAfter, or lineEndsWith");
+	if (!finalRegex) throw new Error("Rule must specify exactly one pattern type: regex, template, lineStartsWith, lineStartsAfter, lineEndsWith, or dictionaryEntry");
 	if (allCaptureNames.length === 0) allCaptureNames = extractNamedCaptureNames(finalRegex);
 	return {
 		captureNames: allCaptureNames,