@adeu/core 1.20.0 → 1.22.0

package/src/index.ts

@@ -4,10 +4,11 @@ export function identifyEngine() {
 
 export { DocumentObject } from './docx/bridge.js';
 export { DocumentMapper, TextSpan } from './mapper.js';
-export { RedlineEngine, BatchValidationError } from './engine.js';
+export { RedlineEngine, BatchValidationError, validate_edit_strings, describe_illegal_control_chars } from './engine.js';
 export { generate_edits_from_text, trim_common_context, create_unified_diff, create_word_patch_diff } from './diff.js';
 export { apply_edits_to_markdown } from './markup.js';
 export { paginate, split_structural_appendix, PaginationResult, PageInfo } from './pagination.js';
 export { extract_outline, OutlineNode } from './outline.js';
 export { extractTextFromBuffer, _extractTextFromDoc } from './ingest.js';
-export { finalize_document, FinalizeOptions, FinalizeResult } from './sanitize/core.js';
+export { finalize_document, FinalizeOptions, FinalizeResult } from './sanitize/core.js';
+export { RegexTimeoutError, userFindAllMatches, userSearch, USER_PATTERN_TIMEOUT_MS } from './utils/safe-regex.js';

package/src/mapper.ts

@@ -2,6 +2,7 @@ import { DocumentObject } from "./docx/bridge.js";
 import { Paragraph, Table, Run, DocxEvent } from "./docx/primitives.js";
 import { findAllDescendants, findChild } from "./docx/dom.js";
 import { extract_comments_data } from "./comments.js";
+import { RegexTimeoutError, userFindAllMatches, userSearch } from "./utils/safe-regex.js";
 import {
   _get_style_cache,
   get_paragraph_prefix,
@@ -105,6 +106,12 @@ export function renumber_snapshot_ids(
   return [chg_remap, com_remap];
 }
 
+// Markdown style delimiters the projection emits as VIRTUAL spans around
+// formatted runs (see get_run_style_markers). Literal asterisks/underscores
+// typed in the document live inside real (run-backed) spans and are never
+// confused with these.
+const STYLE_MARKER_TEXTS = new Set(["**", "__", "*", "_"]);
+
 export class DocumentMapper {
   public doc: DocumentObject;
   public clean_view: boolean;
@@ -114,6 +121,7 @@ export class DocumentMapper {
   public spans: TextSpan[] = [];
   public appendix_start_index: number = -1;
   private _text_chunks: string[] = [];
+  private _plain_projection: [string, number[]] | null = null;
 
   constructor(
     doc: DocumentObject,
@@ -132,6 +140,7 @@ export class DocumentMapper {
     this.spans = [];
     this._text_chunks = [];
     this.full_text = "";
+    this._plain_projection = null;
 
     for (const part of iter_document_parts(this.doc)) {
       current_offset = this._map_blocks(part, current_offset);
@@ -800,16 +809,87 @@ export class DocumentMapper {
     return parts.join("");
   }
 
+  /**
+   * Returns [plain_text, offset_map] where plain_text is full_text with the
+   * VIRTUAL markdown style delimiters (bold/italic markers emitted around
+   * formatted runs) removed, and offset_map[i] is the full_text index of
+   * plain_text[i].
+   *
+   * Formatting run boundaries can fall mid-word (e.g. a paragraph projected
+   * as "**Al**pha"), where neither exact matching nor the whitespace-anchored
+   * fuzzy regex can find the plain target "Alpha". Matching against this
+   * projection and mapping the span back to full_text closes that gap (QA H2).
+   *
+   * Built lazily and invalidated by _build_map(): most batches never need it.
+   */
+  private _get_plain_projection(): [string, number[]] {
+    if (this._plain_projection === null) {
+      const chunks: string[] = [];
+      const offsets: number[] = [];
+      for (const s of this.spans) {
+        if (
+          s.run === null &&
+          s.paragraph !== null &&
+          STYLE_MARKER_TEXTS.has(s.text)
+        ) {
+          continue;
+        }
+        chunks.push(s.text);
+        for (let k = s.start; k < s.end; k++) offsets.push(k);
+      }
+      this._plain_projection = [chunks.join(""), offsets];
+    }
+    return this._plain_projection;
+  }
+
+  /**
+   * Matches a markdown-stripped target against the plain projection and maps
+   * each hit back to a [start, length] span in full_text. Interior style
+   * markers end up inside the returned span (so "Alpha" over "**Al**pha"
+   * resolves to the "Al**pha" range); markers just outside the matched
+   * characters are excluded.
+   */
+  private _find_plain_projection_matches(
+    target_text: string,
+  ): [number, number][] {
+    const [plain_text, offsets] = this._get_plain_projection();
+    if (plain_text.length === this.full_text.length) {
+      return []; // No virtual style markers anywhere; nothing new to find.
+    }
+    const norm_target = this._replace_smart_quotes(
+      this._strip_markdown_formatting(target_text),
+    );
+    if (!norm_target) return [];
+    const norm_plain = this._replace_smart_quotes(plain_text);
+    const results: [number, number][] = [];
+    let from = 0;
+    while (true) {
+      const p_start = norm_plain.indexOf(norm_target, from);
+      if (p_start === -1) break;
+      const p_end = p_start + norm_target.length;
+      const raw_start = offsets[p_start];
+      const raw_end = offsets[p_end - 1] + 1;
+      results.push([raw_start, raw_end - raw_start]);
+      from = p_end;
+    }
+    return results;
+  }
+
   public find_match_index(
     target_text: string,
     is_regex: boolean = false,
   ): [number, number] {
     if (is_regex) {
+      // User/LLM-supplied pattern: run it under a wall-clock budget so a
+      // catastrophic pattern cannot hang the event loop (QA 2026-07-17 F5).
+      // RegexTimeoutError propagates for a clean per-edit error; only
+      // invalid-pattern errors mean "no match" here.
       try {
-        const pattern = new RegExp(target_text);
-        const match = pattern.exec(this.full_text);
-        if (match) return [match.index, match[0].length];
-      } catch (e) {}
+        const match = userSearch(target_text, this.full_text);
+        if (match) return [match.start, match.end - match.start];
+      } catch (e) {
+        if (e instanceof RegexTimeoutError) throw e;
+      }
       return [-1, 0];
     }
 
@@ -827,6 +907,12 @@ export class DocumentMapper {
       return [start_idx, stripped_target.length];
     }
 
+    // 3.5 Plain-projection match: the target crosses a formatting run
+    // boundary (possibly mid-word), so the projection carries style markers
+    // the plain target doesn't have (QA H2).
+    const plain_first = this._find_plain_projection_matches(target_text);
+    if (plain_first.length > 0) return plain_first[0];
+
     try {
       const pattern = new RegExp(this._make_fuzzy_regex(target_text));
       const match = pattern.exec(this.full_text);
@@ -843,42 +929,56 @@ export class DocumentMapper {
     if (!target_text) return [];
 
     if (is_regex) {
+      // Budgeted like find_match_index above (QA 2026-07-17 F5).
       try {
-        const pattern = new RegExp(target_text, "g");
-        const matches = [...this.full_text.matchAll(pattern)];
-        if (matches.length > 0)
-          return matches.map((m) => [m.index!, m[0].length]);
-      } catch (e) {}
+        const matches = userFindAllMatches(target_text, this.full_text);
+        if (matches.length > 0) return matches.map((m) => [m.start, m.end - m.start]);
+      } catch (e) {
+        if (e instanceof RegexTimeoutError) throw e;
+      }
       return [];
     }
-    const escapeRegExp = (str: string) =>
-      str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Exact tiers use plain indexOf scans, NOT RegExp: building a RegExp from
+    // an arbitrarily long escaped target throws "regular expression too
+    // large" for oversized inputs, crashing validation instead of returning
+    // a clean not-found (QA C2 hardening).
+    const findAllLiteral = (
+      haystack: string,
+      needle: string,
+    ): [number, number][] => {
+      const out: [number, number][] = [];
+      if (!needle) return out;
+      let from = 0;
+      while (true) {
+        const idx = haystack.indexOf(needle, from);
+        if (idx === -1) break;
+        out.push([idx, needle.length]);
+        from = idx + needle.length;
+      }
+      return out;
+    };
 
-    let matches = [
-      ...this.full_text.matchAll(new RegExp(escapeRegExp(target_text), "g")),
-    ];
-    if (matches.length > 0) return matches.map((m) => [m.index!, m[0].length]);
+    let matches = findAllLiteral(this.full_text, target_text);
+    if (matches.length > 0) return matches;
 
     const norm_full = this._replace_smart_quotes(this.full_text);
     const norm_target = this._replace_smart_quotes(target_text);
-    matches = [
-      ...norm_full.matchAll(new RegExp(escapeRegExp(norm_target), "g")),
-    ];
-    if (matches.length > 0) return matches.map((m) => [m.index!, m[0].length]);
+    matches = findAllLiteral(norm_full, norm_target);
+    if (matches.length > 0) return matches;
 
     const stripped_target = this._strip_markdown_formatting(target_text);
-    matches = [
-      ...this.full_text.matchAll(
-        new RegExp(escapeRegExp(stripped_target), "g"),
-      ),
-    ];
-    if (matches.length > 0) return matches.map((m) => [m.index!, m[0].length]);
+    matches = findAllLiteral(this.full_text, stripped_target);
+    if (matches.length > 0) return matches;
+
+    // 3.5 Plain-projection match (target spans a bold/italic run boundary,
+    // possibly mid-word). See _find_plain_projection_matches (QA H2).
+    const plain_matches = this._find_plain_projection_matches(target_text);
+    if (plain_matches.length > 0) return plain_matches;
 
     try {
       const pattern = new RegExp(this._make_fuzzy_regex(target_text), "g");
-      matches = [...this.full_text.matchAll(pattern)];
-      if (matches.length > 0)
-        return matches.map((m) => [m.index!, m[0].length]);
+      const fuzzy = [...this.full_text.matchAll(pattern)];
+      if (fuzzy.length > 0) return fuzzy.map((m) => [m.index!, m[0].length]);
     } catch (e) {}
 
     return [];

package/src/markup.test.ts

@@ -115,7 +115,8 @@ describe('apply_edits_to_markdown', () => {
       { type: 'modify', target_text: 'C', new_text: 'Z' }
     ];
     const result = apply_edits_to_markdown(text, edits, true);
-    expect(result).toContain('[Edit:0]');
+    // 1-based, matching apply's "Edit N" reports (QA 2026-07-17 F10).
+    expect(result).toContain('[Edit:1]');
     expect(result.indexOf('{++X++}')).toBeLessThan(result.indexOf('{++Y++}'));
     expect(result.indexOf('{++Y++}')).toBeLessThan(result.indexOf('{++Z++}'));
   });
@@ -174,7 +175,7 @@ describe('format_ambiguity_error (Turn Loop Trap mitigation)', () => {
     expect(msg).toContain('FIRST occurrence');
 
     // The original "add more context" guidance is preserved as a third option.
-    expect(msg).toContain('Please provide more surrounding context');
+    expect(msg).toContain('Provide more surrounding context');
   });
 
   it('still throws for fewer than two matches', () => {

package/src/markup.ts

@@ -360,7 +360,9 @@ export function apply_edits_to_markdown(
       isolated_target,
       isolated_new,
       edit.comment,
-      orig_idx,
+      // 1-based, matching apply's "Edit N" reports and batch validation
+      // errors (QA 2026-07-17 F10; mirrors Python).
+      orig_idx + 1,
       include_index,
       highlight_only,
     );
@@ -424,17 +426,23 @@ export function format_ambiguity_error(
 
   // Tell the agent EXACTLY how to re-call. Without this, agents loop forever
   // refining target_text/regex because they never learn that match_mode is the
-  // built-in escape hatch for genuine ambiguity.
+  // built-in escape hatch for genuine ambiguity. The safe strategy (more
+  // context) comes first: blindly switching to "first"/"all" has silently
+  // modified unrelated occurrences — dates, section numbers — in real use
+  // (QA C1), so those options carry an explicit verification warning.
+  // Wording mirrors the Python engine's format_ambiguity_error.
   lines.push("  To resolve, re-send this edit using ONE of these strategies:");
   lines.push(
-    `    1. Set "match_mode": "all" to modify ALL ${total} occurrences (same target_text).`,
+    "    1. RECOMMENDED: Provide more surrounding context in your target_text to uniquely " +
+      'identify a single location (keep the default "match_mode": "strict").',
   );
   lines.push(
-    '    2. Set "match_mode": "first" to modify only the FIRST occurrence (same target_text).',
+    `    2. Set "match_mode": "all" to modify ALL ${total} occurrences — only after verifying ` +
+      "from the occurrence list above that EVERY occurrence should change.",
   );
   lines.push(
-    '    3. Please provide more surrounding context in your target_text to uniquely ' +
-      'identify a single location (keep the default "match_mode": "strict").',
+    '    3. Set "match_mode": "first" to modify only the FIRST occurrence — only after verifying ' +
+      "the first occurrence above is the one you intend to change.",
   );
 
   return lines.join("\n");

package/src/repro_qa_report_v3.test.ts

@@ -172,10 +172,16 @@ describe("QA Report V3 Defects Reproductions", () => {
       } as any,
     ], true);
 
-    expect(res.edits_applied).toBe(1);
-    expect(res.edits_skipped).toBe(1);
+    // Dry-run mirrors the real run's transactional semantics (QA 2026-07-17
+    // M1 parity): a batch with any invalid edit applies nothing. The valid
+    // edit is reported as blocked by the batch, the invalid one keeps its own
+    // error.
+    expect(res.edits_applied).toBe(0);
+    expect(res.edits_skipped).toBe(2);
+    expect(res.edits[0].status).toBe("failed");
+    expect(res.edits[0].error).toContain("transactional");
     expect(res.edits[1].status).toBe("failed");
-    
+
     // Assert that the error message correctly labels it as Edit 2.
     // The buggy unpatched codebase says "Edit 1 Failed:" inside the error message for Edit 2.
     const errorMsg = res.edits[1].error;