docrev 0.9.6 → 0.9.11

package/dev_notes/stresstest_drift_compare.ts

@@ -0,0 +1,43 @@
+// Compare pristine vs drifted verify-anchors output
+import * as fs from 'fs';
+
+const a = JSON.parse(fs.readFileSync('C:/GillesC/tmp/docrev-stress/pristine.json', 'utf-8'));
+const b = JSON.parse(fs.readFileSync('C:/GillesC/tmp/docrev-stress/drifted.json', 'utf-8'));
+
+console.log('Summary deltas:');
+const keys = Array.from(new Set([...Object.keys(a.summary), ...Object.keys(b.summary)]));
+for (const k of keys) {
+  const av = a.summary[k] ?? 0;
+  const bv = b.summary[k] ?? 0;
+  const delta = bv - av;
+  console.log(`  ${k.padEnd(15)} ${String(av).padStart(4)} -> ${String(bv).padStart(4)}  (delta ${delta >= 0 ? '+' : ''}${delta})`);
+}
+console.log();
+
+// Show comments whose quality changed (especially those that moved to a worse bucket)
+const aMap = new Map(a.comments.map((c: any) => [c.id, c]));
+console.log('Quality changes:');
+let regressions = 0;
+let improvements = 0;
+for (const c of b.comments) {
+  const prev = aMap.get(c.id) as any;
+  if (!prev) continue;
+  if (prev.quality !== c.quality) {
+    const dir = qualityRank(c.quality) > qualityRank(prev.quality) ? '⬇' : '⬆';
+    if (dir === '⬇') regressions++; else improvements++;
+    console.log(`  ${dir} #${c.id} [${c.section || '—'}] ${prev.quality}/${prev.strategy} -> ${c.quality}/${c.strategy}  anchor="${(c.anchor || '').slice(0, 35)}"`);
+  }
+}
+console.log();
+console.log(`regressions: ${regressions}  improvements: ${improvements}`);
+
+function qualityRank(q: string): number {
+  switch (q) {
+    case 'clean': return 0;
+    case 'drift': return 1;
+    case 'context-only': return 2;
+    case 'ambiguous': return 1; // ambiguous is sideways, not strictly worse
+    case 'unmatched': return 3;
+    default: return 4;
+  }
+}

package/dev_notes/stresstest_drift_v2.ts

@@ -0,0 +1,54 @@
+// Apply drift edits that actually intersect real comment anchors
+import * as fs from 'fs';
+
+const dir = 'C:/GillesC/tmp/docrev-stress/project-drifted';
+
+function edit(file: string, edits: Array<[string, string]>) {
+  const p = `${dir}/${file}`;
+  let t = fs.readFileSync(p, 'utf-8');
+  for (const [from, to] of edits) {
+    if (!t.includes(from)) {
+      console.error(`!! ${file}: pattern not found: "${from.slice(0, 60)}"`);
+      continue;
+    }
+    t = t.replace(from, to);
+    console.log(`OK ${file}: replaced "${from.slice(0, 60)}..."`);
+  }
+  fs.writeFileSync(p, t);
+}
+
+// Each of these intersects real anchors; expected effect noted.
+edit('abstract.md', [
+  // Title: 3 anchors are 'Patterns of habitat niche expansion' (full title) — but title isn't in abstract.md, it's in YAML frontmatter, so probably already failing
+  // 'overrepresented' is the most common anchor (6 comments). Replace it everywhere.
+  // After this, the word 'overrepresented' is gone → all those comments should go to context-only or unmatched
+  ['overrepresented in more than one habitat type', 'preferentially distributed across habitat types'],
+  // 'undisturbed' appears in 'undisturbed habitat types' → 2 comments
+  ['undisturbed habitat types', 'pristine vegetation communities'],
+  // 'human economies' (3 anchors)
+  ['human economies', 'economic activity'],
+  // 'nutrient-rich'
+  ['nutrient-rich, disturbed habitats', 'anthropic, modified environments'],
+  // 'when residence time was prolonged.' — long anchor, should go to drift / partial-start
+  ['when residence time was prolonged.', 'as residence time increased.'],
+  // 'pervasive' (1 anchor)
+  ['Invasion debt in terms of habitat niche breadth is pervasive', 'Invasion debt in terms of habitat niche breadth is widespread'],
+  // 'alpine habitats' (1 anchor)
+  ['alpine habitats', 'high-altitude environments'],
+  // 'semi-natural vegetation' (2 anchors)
+  ['semi-natural vegetation', 'natural plant communities'],
+  // 'Man-made habitats function as gateways' (1 anchor)
+  ['Man-made habitats function as gateways', 'Anthropogenic environments serve as entry routes'],
+  // 'Invasion debt in terms of habitat niche breadth' (2 anchors)
+  // Already mutated above (pervasive→widespread keeps anchor matchable). Add another small change to test partial-start
+  // 'habitat niche expansion' — anchor for #27
+  ['habitat niche expansion', 'ecological niche broadening'],
+  // ', yet' anchor for #19
+  [', yet', ', however'],
+  // '44' — short numeric anchor
+  ['44%', '53%'],
+  // '17 habitats'
+  ['17 habitats', '18 habitats'],
+]);
+
+console.log('---done');

package/dev_notes/stresstest_inspect.ts

@@ -0,0 +1,54 @@
+import { extractWordComments, extractCommentAnchors } from '../lib/import.js';
+
+const docx = 'C:/GillesC/tmp/docrev-stress/reviewed.docx';
+
+const comments = await extractWordComments(docx);
+const { anchors, fullDocText } = await extractCommentAnchors(docx);
+
+console.log(`comments: ${comments.length}`);
+console.log(`anchors:  ${anchors.size}`);
+console.log(`docText:  ${fullDocText.length} chars`);
+console.log();
+
+const byAuthor: Record<string, number> = {};
+for (const c of comments) byAuthor[c.author] = (byAuthor[c.author] || 0) + 1;
+console.log('by author:', byAuthor);
+console.log();
+
+console.log('first 5 comments:');
+for (const c of comments.slice(0, 5)) {
+  const a = anchors.get(c.id);
+  const pos = a?.docPosition ?? -1;
+  const anchor = (a?.anchor || '').slice(0, 60);
+  const text = c.text.replace(/\s+/g, ' ').slice(0, 80);
+  console.log(`  #${c.id} [${c.author}] pos=${pos} anchor="${anchor}" text="${text}"`);
+}
+console.log();
+console.log('last 3 comments:');
+for (const c of comments.slice(-3)) {
+  const a = anchors.get(c.id);
+  const pos = a?.docPosition ?? -1;
+  const anchor = (a?.anchor || '').slice(0, 60);
+  const text = c.text.replace(/\s+/g, ' ').slice(0, 80);
+  console.log(`  #${c.id} [${c.author}] pos=${pos} anchor="${anchor}" text="${text}"`);
+}
+console.log();
+
+const sectionKeywords = ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion', 'Conclusion', 'References', 'Acknowledgements', 'Data Availability', 'Author Contributions'];
+console.log('candidate headings:');
+for (const kw of sectionKeywords) {
+  const idx = fullDocText.indexOf(kw);
+  if (idx >= 0) {
+    const context = fullDocText.slice(idx, idx + 80).replace(/\s+/g, ' ');
+    console.log(`  ${kw} @ ${idx}: "${context}"`);
+  }
+}
+
+// Check anchor distribution to understand section spans
+const positions = [...anchors.values()].map(a => a.docPosition).sort((a, b) => a - b);
+console.log();
+console.log(`anchor positions: min=${positions[0]} max=${positions[positions.length-1]} median=${positions[Math.floor(positions.length/2)]}`);
+
+// Check for empty anchors
+const empty = [...anchors.values()].filter(a => a.isEmpty).length;
+console.log(`empty anchors: ${empty}`);

package/dev_notes/stresstest_pstyle.ts

@@ -0,0 +1,55 @@
+// Inspect the document.xml paragraph styles to find true headings.
+import AdmZip from 'adm-zip';
+import * as fs from 'fs';
+
+const docx = 'C:/GillesC/tmp/docrev-stress/reviewed.docx';
+const zip = new AdmZip(docx);
+const xml = zip.getEntry('word/document.xml')!.getData().toString('utf8');
+
+// Build text-position map from <w:t> runs the same way extractCommentAnchors does
+const textNodePattern = /<w:t[^>]*>([^<]*)<\/w:t>/g;
+const textNodes: Array<{ xmlStart: number; xmlEnd: number; textStart: number; textEnd: number; text: string }> = [];
+let textPosition = 0;
+let m;
+function decode(s: string): string {
+  return s.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+}
+while ((m = textNodePattern.exec(xml)) !== null) {
+  const decoded = decode(m[1]);
+  textNodes.push({ xmlStart: m.index, xmlEnd: m.index + m[0].length, textStart: textPosition, textEnd: textPosition + decoded.length, text: decoded });
+  textPosition += decoded.length;
+}
+
+function xmlToText(xmlPos: number): number {
+  for (const n of textNodes) {
+    if (xmlPos >= n.xmlStart && xmlPos < n.xmlEnd) return n.textStart;
+    if (xmlPos < n.xmlStart) return n.textStart;
+  }
+  return textNodes.length ? textNodes[textNodes.length - 1].textEnd : 0;
+}
+
+// Now walk paragraphs; each <w:p ...>...</w:p>. Inside, find <w:pStyle w:val="..."/> if present, and concatenate text runs.
+const paraPattern = /<w:p\b[^>]*>([\s\S]*?)<\/w:p>/g;
+const headings: Array<{ style: string; text: string; xmlStart: number; textPos: number }> = [];
+let pm;
+while ((pm = paraPattern.exec(xml)) !== null) {
+  const inner = pm[1];
+  const styleMatch = inner.match(/<w:pStyle[^>]*w:val="([^"]+)"/);
+  if (!styleMatch) continue;
+  const style = styleMatch[1];
+  if (!/heading/i.test(style)) continue;
+  // Extract text from runs
+  const textInRange = /<w:t[^>]*>([^<]*)<\/w:t>/g;
+  let txt = '';
+  let tm;
+  while ((tm = textInRange.exec(inner)) !== null) txt += decode(tm[1]);
+  if (!txt.trim()) continue;
+  const xmlStart = pm.index;
+  const textPos = xmlToText(xmlStart);
+  headings.push({ style, text: txt.trim(), xmlStart, textPos });
+}
+
+console.log(`Found ${headings.length} heading paragraphs:`);
+for (const h of headings) {
+  console.log(`  [${h.style.padEnd(8)}] textPos=${String(h.textPos).padStart(6)} "${h.text.slice(0, 60)}"`);
+}

package/dev_notes/stresstest_section_debug.ts

@@ -0,0 +1,23 @@
+import { extractCommentAnchors } from '../lib/import.js';
+
+const docx = 'C:/GillesC/tmp/docrev-stress/reviewed.docx';
+const { fullDocText } = await extractCommentAnchors(docx);
+
+const keywords = ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion', 'Conclusion', 'References'];
+for (const kw of keywords) {
+  const lower = fullDocText.toLowerCase();
+  const needle = kw.toLowerCase();
+  const occ: Array<{ idx: number; ctx: string; afterChar: string }> = [];
+  let idx = 0;
+  while ((idx = lower.indexOf(needle, idx)) !== -1) {
+    const ctx = fullDocText.slice(Math.max(0, idx - 20), idx + needle.length + 20).replace(/\s+/g, ' ');
+    const afterChar = fullDocText.slice(idx + needle.length, idx + needle.length + 1);
+    occ.push({ idx, ctx, afterChar });
+    idx++;
+  }
+  console.log(`\n--- ${kw} (${occ.length} occurrences) ---`);
+  for (const o of occ.slice(0, 6)) {
+    console.log(`  @${o.idx} after="${o.afterChar}" ctx: ...${o.ctx}...`);
+  }
+  if (occ.length > 6) console.log(`  ... and ${occ.length - 6} more`);
+}

package/dev_notes/stresstest_split.ts

@@ -0,0 +1,70 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+const ROOT = 'C:/GillesC/tmp/docrev-stress/project';
+fs.mkdirSync(ROOT, { recursive: true });
+
+const full = fs.readFileSync('C:/GillesC/tmp/docrev-stress/full.md', 'utf-8');
+const lines = full.split(/\r?\n/);
+
+interface Section { file: string; header: string; lines: string[]; }
+
+const sections: Section[] = [];
+
+// Map H1 heading text to section file
+const headerToFile: Record<string, string> = {
+  'Abstract': 'abstract.md',
+  'Introduction': 'introduction.md',
+  'Methods': 'methods.md',
+  'Results': 'results.md',
+  'Discussion': 'discussion.md',
+  'Conclusion': 'conclusion.md',
+  'References': 'references.md',
+  'Supplementary Materials': 'supplement.md',
+};
+
+let current: Section | null = null;
+const preambleLines: string[] = [];
+
+for (const line of lines) {
+  const m = line.match(/^# (.+)$/);
+  if (m && headerToFile[m[1].trim()]) {
+    if (current) sections.push(current);
+    current = { file: headerToFile[m[1].trim()], header: m[1].trim(), lines: [line] };
+  } else if (current) {
+    current.lines.push(line);
+  } else {
+    preambleLines.push(line);
+  }
+}
+if (current) sections.push(current);
+
+// Write sections
+for (const s of sections) {
+  const out = path.join(ROOT, s.file);
+  fs.writeFileSync(out, s.lines.join('\n'), 'utf-8');
+  console.log(`wrote ${out} (${s.lines.length} lines)`);
+}
+
+// Write sections.yaml
+const yaml: string[] = ['version: 1', 'sections:'];
+for (const s of sections) {
+  yaml.push(`  ${s.file}:`);
+  yaml.push(`    header: "${s.header}"`);
+  yaml.push(`    aliases: []`);
+}
+fs.writeFileSync(path.join(ROOT, 'sections.yaml'), yaml.join('\n') + '\n', 'utf-8');
+console.log(`wrote sections.yaml`);
+
+// Minimal rev.yaml so commands that look for project root don't choke
+const revYaml = `title: "Stress Test"
+authors:
+  - name: Gilles Colling
+output:
+  docx: {}
+  pdf: {}
+`;
+fs.writeFileSync(path.join(ROOT, 'rev.yaml'), revYaml, 'utf-8');
+
+console.log();
+console.log(`section files: ${sections.length}`);

package/dev_notes/stresstest_trace.ts

@@ -0,0 +1,19 @@
+import { extractCommentAnchors } from '../lib/import.js';
+
+const docx = 'C:/GillesC/tmp/docrev-stress/reviewed.docx';
+const { fullDocText } = await extractCommentAnchors(docx);
+
+const needle = 'methods';
+const lower = fullDocText.toLowerCase();
+let idx = 0;
+const trace: Array<{idx:number, after:string, skipped:boolean}> = [];
+while ((idx = lower.indexOf(needle, idx)) !== -1 && trace.length < 10) {
+  const after = fullDocText.slice(idx + needle.length, idx + needle.length + 5);
+  const skip = after.startsWith(':') || after.startsWith(' :');
+  trace.push({ idx, after, skipped: skip });
+  if (!skip) break;
+  idx++;
+}
+for (const t of trace) console.log(`idx=${t.idx} after="${t.after}" skipped=${t.skipped}`);
+console.log();
+console.log(`first non-:-prefixed Methods idx = ${trace.find(t => !t.skipped)?.idx ?? -1}`);

package/dev_notes/stresstest_verify_no_overwrite.ts

@@ -0,0 +1,40 @@
+// Verify sync --comments-only didn't touch existing prose, only inserted comments.
+import * as fs from 'fs';
+import { stripCriticMarkup } from '../lib/anchor-match.js';
+
+const original = 'C:/GillesC/tmp/docrev-stress/project';
+const synced = 'C:/GillesC/tmp/docrev-stress/project-sync';
+const files = ['abstract.md', 'introduction.md', 'methods.md', 'results.md', 'discussion.md', 'conclusion.md', 'references.md', 'supplement.md'];
+
+let totalComments = 0;
+let mismatches = 0;
+for (const f of files) {
+  const orig = fs.readFileSync(`${original}/${f}`, 'utf-8');
+  const synd = fs.readFileSync(`${synced}/${f}`, 'utf-8');
+
+  // Count comments inserted
+  const commentMatches = synd.match(/\{>>.*?<<\}/gs) || [];
+  totalComments += commentMatches.length;
+
+  // The originals may already contain CriticMarkup (Word highlights -> [X]{.mark}),
+  // so strip both sides to compare just the underlying prose.
+  const synStripped = stripCriticMarkup(synd);
+  const origNorm = stripCriticMarkup(orig);
+
+  if (synStripped !== origNorm) {
+    // Find first difference
+    let i = 0;
+    while (i < origNorm.length && i < synStripped.length && origNorm[i] === synStripped[i]) i++;
+    const ctxOrig = origNorm.slice(Math.max(0, i - 30), i + 50).replace(/\n/g, '\\n');
+    const ctxSyn = synStripped.slice(Math.max(0, i - 30), i + 50).replace(/\n/g, '\\n');
+    console.log(`✗ ${f}: prose differs at byte ${i} (lengths orig=${origNorm.length} stripped=${synStripped.length})`);
+    console.log(`    orig: ${ctxOrig}`);
+    console.log(`    syn:  ${ctxSyn}`);
+    mismatches++;
+  } else {
+    console.log(`✓ ${f}: prose preserved (${commentMatches.length} comments inserted)`);
+  }
+}
+console.log();
+console.log(`total comments inserted: ${totalComments}`);
+console.log(`prose mismatches:        ${mismatches}/${files.length}`);

package/dist/lib/anchor-match.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Anchor matching primitives shared between sync (insertion) and
+ * verify-anchors (drift reporting). The functions are pure: given an
+ * anchor string and surrounding context, locate candidate positions in
+ * a target text using progressively looser strategies.
+ */
+export type AnchorStrategy = 'direct' | 'normalized' | 'stripped' | 'partial-start' | 'partial-start-stripped' | 'context-both' | 'context-before' | 'context-after' | 'split-match' | 'empty-anchor' | 'failed';
+export interface AnchorSearchResult {
+    occurrences: number[];
+    matchedAnchor: string | null;
+    strategy: AnchorStrategy;
+    stripped?: boolean;
+}
+/**
+ * Strip CriticMarkup so the matcher sees plain prose instead of
+ * `{++inserted++}`/`{--deleted--}`/etc. Used when an anchor lives
+ * underneath previously imported track changes.
+ */
+export declare function stripCriticMarkup(text: string): string;
+/**
+ * Return every starting index where `needle` occurs in `haystack`.
+ * Empty needles return no occurrences (empty matches are not useful
+ * for anchor placement).
+ */
+/**
+ * Score how well the docx-side `before` / `after` context matches the
+ * surroundings of a candidate position in the target text. Used by
+ * `verify-anchors` to tell apart "multiple hits but context picks one
+ * cleanly" (sync will place it correctly) from "multiple hits, context
+ * doesn't help" (truly ambiguous, needs human placement).
+ *
+ * Returns 0 if no context was provided.
+ */
+export declare function scoreContextAt(pos: number, text: string, before: string, after: string, anchorLen: number): number;
+export declare function findAllOccurrences(haystack: string, needle: string): number[];
+/**
+ * Find candidate positions for `anchor` in `text`, falling back through
+ * progressively looser strategies (whitespace normalization, stripped
+ * CriticMarkup, partial-prefix, surrounding context, word splitting).
+ *
+ * The returned `strategy` lets callers distinguish a clean direct hit
+ * from a fuzzy approximation — useful for drift reporting.
+ */
+export declare function findAnchorInText(anchor: string, text: string, before?: string, after?: string): AnchorSearchResult;
+/**
+ * Classify a strategy as a clean hit, a fuzzy/drifted hit, or no hit.
+ * Used by `verify-anchors` to summarize per-comment match quality.
+ */
+export type AnchorMatchQuality = 'clean' | 'drift' | 'context-only' | 'unmatched';
+export declare function classifyStrategy(strategy: AnchorStrategy, occurrences: number): AnchorMatchQuality;
+//# sourceMappingURL=anchor-match.d.ts.map

package/dist/lib/anchor-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor-match.d.ts","sourceRoot":"","sources":["../../lib/anchor-match.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,eAAe,GACf,wBAAwB,GACxB,cAAc,GACd,gBAAgB,GAChB,eAAe,GACf,aAAa,GACb,cAAc,GACd,QAAQ,CAAC;AAEb,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED;;;;GAIG;AACH;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,MAAM,CAqBR;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAS7E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,MAAW,EACnB,KAAK,GAAE,MAAW,GACjB,kBAAkB,CA2IpB;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,OAAO,GAAG,cAAc,GAAG,WAAW,CAAC;AAElF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,GAAG,kBAAkB,CAoBlG"}

package/dist/lib/anchor-match.js

@@ -0,0 +1,227 @@
+/**
+ * Anchor matching primitives shared between sync (insertion) and
+ * verify-anchors (drift reporting). The functions are pure: given an
+ * anchor string and surrounding context, locate candidate positions in
+ * a target text using progressively looser strategies.
+ */
+/**
+ * Strip CriticMarkup so the matcher sees plain prose instead of
+ * `{++inserted++}`/`{--deleted--}`/etc. Used when an anchor lives
+ * underneath previously imported track changes.
+ */
+export function stripCriticMarkup(text) {
+    return text
+        .replace(/\{\+\+([^+]*)\+\+\}/g, '$1') // insertions: keep new text
+        .replace(/\{--([^-]*)--\}/g, '') // deletions: remove old text
+        .replace(/\{~~([^~]*)~>([^~]*)~~\}/g, '$2') // substitutions: keep new text
+        .replace(/\{>>[\s\S]*?<<\}/g, '') // comments: remove (non-greedy; comment text may contain '<')
+        .replace(/\[([^\]]*)\]\{\.mark\}/g, '$1'); // marked text: keep text
+}
+/**
+ * Return every starting index where `needle` occurs in `haystack`.
+ * Empty needles return no occurrences (empty matches are not useful
+ * for anchor placement).
+ */
+/**
+ * Score how well the docx-side `before` / `after` context matches the
+ * surroundings of a candidate position in the target text. Used by
+ * `verify-anchors` to tell apart "multiple hits but context picks one
+ * cleanly" (sync will place it correctly) from "multiple hits, context
+ * doesn't help" (truly ambiguous, needs human placement).
+ *
+ * Returns 0 if no context was provided.
+ */
+export function scoreContextAt(pos, text, before, after, anchorLen) {
+    let score = 0;
+    if (before) {
+        const contextBefore = text.slice(Math.max(0, pos - before.length - 20), pos).toLowerCase();
+        const beforeLower = before.toLowerCase();
+        const beforeWords = beforeLower.split(/\s+/).filter(w => w.length > 3);
+        for (const word of beforeWords) {
+            if (contextBefore.includes(word))
+                score += 2;
+        }
+        if (contextBefore.includes(beforeLower.slice(-30)))
+            score += 5;
+    }
+    if (after) {
+        const contextAfter = text.slice(pos + anchorLen, pos + anchorLen + after.length + 20).toLowerCase();
+        const afterLower = after.toLowerCase();
+        const afterWords = afterLower.split(/\s+/).filter(w => w.length > 3);
+        for (const word of afterWords) {
+            if (contextAfter.includes(word))
+                score += 2;
+        }
+        if (contextAfter.includes(afterLower.slice(0, 30)))
+            score += 5;
+    }
+    return score;
+}
+export function findAllOccurrences(haystack, needle) {
+    if (!needle || needle.length === 0)
+        return [];
+    const occurrences = [];
+    let idx = 0;
+    while ((idx = haystack.indexOf(needle, idx)) !== -1) {
+        occurrences.push(idx);
+        idx += 1;
+    }
+    return occurrences;
+}
+/**
+ * Find candidate positions for `anchor` in `text`, falling back through
+ * progressively looser strategies (whitespace normalization, stripped
+ * CriticMarkup, partial-prefix, surrounding context, word splitting).
+ *
+ * The returned `strategy` lets callers distinguish a clean direct hit
+ * from a fuzzy approximation — useful for drift reporting.
+ */
+export function findAnchorInText(anchor, text, before = '', after = '') {
+    // Empty anchor: skip directly to context-based matching
+    if (!anchor || anchor.trim().length === 0) {
+        if (before || after) {
+            const beforeLower = (before || '').toLowerCase();
+            const afterLower = (after || '').toLowerCase();
+            const textLower = text.toLowerCase();
+            if (before && after) {
+                const beforeIdx = textLower.indexOf(beforeLower.slice(-50));
+                if (beforeIdx !== -1) {
+                    const searchStart = beforeIdx + beforeLower.slice(-50).length;
+                    const afterIdx = textLower.indexOf(afterLower.slice(0, 50), searchStart);
+                    if (afterIdx !== -1 && afterIdx - searchStart < 500) {
+                        return { occurrences: [searchStart], matchedAnchor: null, strategy: 'context-both' };
+                    }
+                }
+            }
+            if (before) {
+                const beforeIdx = textLower.lastIndexOf(beforeLower.slice(-30));
+                if (beforeIdx !== -1) {
+                    return {
+                        occurrences: [beforeIdx + beforeLower.slice(-30).length],
+                        matchedAnchor: null,
+                        strategy: 'context-before',
+                    };
+                }
+            }
+            if (after) {
+                const afterIdx = textLower.indexOf(afterLower.slice(0, 30));
+                if (afterIdx !== -1) {
+                    return { occurrences: [afterIdx], matchedAnchor: null, strategy: 'context-after' };
+                }
+            }
+        }
+        return { occurrences: [], matchedAnchor: null, strategy: 'empty-anchor' };
+    }
+    const anchorLower = anchor.toLowerCase();
+    const textLower = text.toLowerCase();
+    // Strategy 1: direct match
+    let occurrences = findAllOccurrences(textLower, anchorLower);
+    if (occurrences.length > 0) {
+        return { occurrences, matchedAnchor: anchor, strategy: 'direct' };
+    }
+    // Strategy 2: normalized whitespace
+    const normalizedAnchor = anchor.replace(/\s+/g, ' ').toLowerCase();
+    const normalizedText = text.replace(/\s+/g, ' ').toLowerCase();
+    const idx = normalizedText.indexOf(normalizedAnchor);
+    if (idx !== -1) {
+        return { occurrences: [idx], matchedAnchor: anchor, strategy: 'normalized' };
+    }
+    // Strategy 3: match in stripped CriticMarkup version
+    const strippedText = stripCriticMarkup(text);
+    const strippedLower = strippedText.toLowerCase();
+    occurrences = findAllOccurrences(strippedLower, anchorLower);
+    if (occurrences.length > 0) {
+        return { occurrences, matchedAnchor: anchor, strategy: 'stripped', stripped: true };
+    }
+    // Strategy 4: first N words of anchor (long anchors)
+    const words = anchor.split(/\s+/);
+    if (words.length > 3) {
+        for (let n = Math.min(6, words.length); n >= 3; n--) {
+            const partialAnchor = words.slice(0, n).join(' ').toLowerCase();
+            if (partialAnchor.length >= 15) {
+                occurrences = findAllOccurrences(textLower, partialAnchor);
+                if (occurrences.length > 0) {
+                    return { occurrences, matchedAnchor: words.slice(0, n).join(' '), strategy: 'partial-start' };
+                }
+                occurrences = findAllOccurrences(strippedLower, partialAnchor);
+                if (occurrences.length > 0) {
+                    return {
+                        occurrences,
+                        matchedAnchor: words.slice(0, n).join(' '),
+                        strategy: 'partial-start-stripped',
+                        stripped: true,
+                    };
+                }
+            }
+        }
+    }
+    // Strategy 5: context (before/after) only
+    if (before || after) {
+        const beforeLower = before.toLowerCase();
+        const afterLower = after.toLowerCase();
+        if (before && after) {
+            const beforeIdx = textLower.indexOf(beforeLower.slice(-50));
+            if (beforeIdx !== -1) {
+                const searchStart = beforeIdx + beforeLower.slice(-50).length;
+                const afterIdx = textLower.indexOf(afterLower.slice(0, 50), searchStart);
+                if (afterIdx !== -1 && afterIdx - searchStart < 500) {
+                    return { occurrences: [searchStart], matchedAnchor: null, strategy: 'context-both' };
+                }
+            }
+        }
+        if (before) {
+            const beforeIdx = textLower.lastIndexOf(beforeLower.slice(-30));
+            if (beforeIdx !== -1) {
+                return {
+                    occurrences: [beforeIdx + beforeLower.slice(-30).length],
+                    matchedAnchor: null,
+                    strategy: 'context-before',
+                };
+            }
+        }
+        if (after) {
+            const afterIdx = textLower.indexOf(afterLower.slice(0, 30));
+            if (afterIdx !== -1) {
+                return { occurrences: [afterIdx], matchedAnchor: null, strategy: 'context-after' };
+            }
+        }
+    }
+    // Strategy 6: split anchor on transition characters
+    const splitPatterns = [' ', ', ', '. ', ' - ', ' – '];
+    for (const sep of splitPatterns) {
+        if (anchor.includes(sep)) {
+            const parts = anchor.split(sep).filter(p => p.length >= 4);
+            for (const part of parts) {
+                const partLower = part.toLowerCase();
+                occurrences = findAllOccurrences(textLower, partLower);
+                if (occurrences.length > 0 && occurrences.length < 5) {
+                    return { occurrences, matchedAnchor: part, strategy: 'split-match' };
+                }
+            }
+        }
+    }
+    return { occurrences: [], matchedAnchor: null, strategy: 'failed' };
+}
+export function classifyStrategy(strategy, occurrences) {
+    if (occurrences === 0)
+        return 'unmatched';
+    switch (strategy) {
+        case 'direct':
+        case 'normalized':
+            return 'clean';
+        case 'stripped':
+        case 'partial-start':
+        case 'partial-start-stripped':
+        case 'split-match':
+            return 'drift';
+        case 'context-both':
+        case 'context-before':
+        case 'context-after':
+            return 'context-only';
+        case 'empty-anchor':
+        case 'failed':
+        default:
+            return 'unmatched';
+    }
+}
+//# sourceMappingURL=anchor-match.js.map