@adeu/core 1.10.1 → 1.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adeu/core",
-  "version": "1.10.1",
+  "version": "1.12.0",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/engine.bugs.test.ts

@@ -251,14 +251,14 @@ describe("Resolved Bugs Core Engine Verification", () => {
     const p = addParagraph(doc, "Short heading");
 
     const fakeCache = {
-      CustomHeading: { name: "Custom Heading", outline_level: 2, bold: true },
+      Heading3: { name: "Heading 3", outline_level: 2, bold: true },
     };
     (doc.pkg as any)._adeu_style_cache = [fakeCache, "Normal"];
 
     const docEl = p.ownerDocument!;
     const pPr = docEl.createElement("w:pPr");
     const pStyle = docEl.createElement("w:pStyle");
-    pStyle.setAttribute("w:val", "CustomHeading");
+    pStyle.setAttribute("w:val", "Heading3");
     pPr.appendChild(pStyle);
     p.insertBefore(pPr, p.firstChild);
 

package/src/engine.ts

@@ -221,6 +221,7 @@ export class RedlineEngine {
   public mapper: DocumentMapper;
   public comments_manager: CommentsManager;
   public clean_mapper: DocumentMapper | null = null;
+  public original_mapper: DocumentMapper | null = null;
   public skipped_details: string[] = [];
 
   constructor(doc: DocumentObject, author: string = "Adeu AI (TS)") {
@@ -1195,12 +1196,16 @@ export class RedlineEngine {
 
       let matches = this.mapper.find_all_match_indices(edit.target_text);
       let activeText = this.mapper.full_text;
+      let target_mapper = this.mapper;
 
       if (matches.length === 0) {
         if (!this.clean_mapper)
           this.clean_mapper = new DocumentMapper(this.doc, true);
         matches = this.clean_mapper.find_all_match_indices(edit.target_text);
-        if (matches.length > 0) activeText = this.clean_mapper.full_text;
+        if (matches.length > 0) {
+          activeText = this.clean_mapper.full_text;
+          target_mapper = this.clean_mapper;
+        }
       }
 
       // BUG-23-5: a copy of the target that lives entirely inside a tracked
@@ -1208,7 +1213,7 @@ export class RedlineEngine {
       // count toward ambiguity. Drop matches whose overlapping real text is
       // exclusively deleted. Only applies to the raw mapper (the clean mapper
       // already omits deleted text).
-      if (activeText === this.mapper.full_text && matches.length > 1) {
+      if (activeText === this.mapper.full_text && matches.length > 0) {
         const liveMatches = matches.filter(([start, length]) => {
           const realSpans = this.mapper.spans.filter(
             (s) => s.run !== null && s.end > start && s.start < start + length,
@@ -1218,13 +1223,55 @@ export class RedlineEngine {
           // part of a tracked deletion).
           return realSpans.some((s) => !s.del_id);
         });
-        if (liveMatches.length > 0) matches = liveMatches;
+        matches = liveMatches;
       }
 
+      let is_deleted_text = false;
+      const deleted_authors = new Set<string>();
+
       if (matches.length === 0) {
-        errors.push(
-          `- Edit ${i + 1} Failed: Target text not found in document:\n  "${edit.target_text}"`,
-        );
+        if (!this.original_mapper) {
+          this.original_mapper = new DocumentMapper(this.doc, false, true);
+        }
+        const orig_matches = this.original_mapper.find_all_match_indices(edit.target_text);
+        if (orig_matches.length > 0) {
+          is_deleted_text = true;
+          for (const [start, length] of orig_matches) {
+            const spans = this.original_mapper.spans.filter(
+              (s) => s.end > start && s.start < start + length,
+            );
+            for (const s of spans) {
+              if (s.run !== null) {
+                let parent = s.run._element as Node | null;
+                while (parent) {
+                  if (parent.nodeType === 1 && (parent as Element).tagName === "w:del") {
+                    const auth = (parent as Element).getAttribute("w:author");
+                    if (auth) {
+                      deleted_authors.add(auth);
+                    }
+                    break;
+                  }
+                  parent = parent.parentNode;
+                }
+              }
+            }
+          }
+        }
+      }
+
+      if (matches.length === 0) {
+        if (is_deleted_text) {
+          const author_phrase = deleted_authors.size > 0
+            ? `by ${Array.from(deleted_authors).sort().join(", ")}`
+            : "by an existing revision";
+          errors.push(
+            `- Edit ${i + 1} Failed: Target text matches text inside a tracked deletion ${author_phrase}. Reject/accept that change first or target the active replacement text instead.`,
+          );
+        } else {
+          errors.push(
+            `- Edit ${i + 1} Failed: Target text not found in document:\n  "${edit.target_text}"`,
+          );
+        }
       } else if (matches.length > 1) {
         const positions: [number, number][] = matches.map(([start, length]) => [
           start,

package/src/index.ts

@@ -9,5 +9,5 @@ export { generate_edits_from_text, trim_common_context, create_unified_diff, cre
 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 } from './ingest.js';
+export { extractTextFromBuffer, _extractTextFromDoc } from './ingest.js';
 export { finalize_document, FinalizeOptions, FinalizeResult } from './sanitize/core.js';

package/src/ingest.ts

@@ -11,18 +11,24 @@ import { extract_comments_data } from './comments.js';
 
 export async function extractTextFromBuffer(buffer: Buffer, cleanView = false): Promise<string> {
   const doc = await DocumentObject.load(buffer);
-  return _extractTextFromDoc(doc, cleanView);
+  return _extractTextFromDoc(doc, cleanView) as string;
 }
 
-export function _extractTextFromDoc(doc: DocumentObject, cleanView = false, includeAppendix = true): string {
+export function _extractTextFromDoc(
+  doc: DocumentObject,
+  cleanView = false,
+  includeAppendix = true,
+  return_paragraph_offsets = false,
+): string | { text: string; paragraph_offsets: Map<any, [number, number]> } {
   const comments_map = extract_comments_data(doc.pkg);
 
   const full_text: string[] = [];
+  const paragraph_offsets = new Map<any, [number, number]>();
   let cursor = 0;
 
   for (const part of iter_document_parts(doc)) {
     const part_cursor = full_text.length > 0 ? cursor + 2 : cursor;
-    const part_text = _extract_blocks(part, comments_map, cleanView, part_cursor);
+    const part_text = _extract_blocks(part, comments_map, cleanView, part_cursor, return_paragraph_offsets ? paragraph_offsets : undefined);
     if (part_text) {
       if (full_text.length > 0) cursor += 2;
       full_text.push(part_text);
@@ -37,10 +43,19 @@ export function _extractTextFromDoc(doc: DocumentObject, cleanView = false, incl
     if (appendix) base_text += appendix;
   }
 
+  if (return_paragraph_offsets) {
+    return { text: base_text, paragraph_offsets };
+  }
   return base_text;
 }
 
-function _extract_blocks(container: any, comments_map: any, cleanView: boolean, cursor: number): string {
+function _extract_blocks(
+  container: any,
+  comments_map: any,
+  cleanView: boolean,
+  cursor: number,
+  paragraph_offsets?: Map<any, [number, number]>
+): string {
   const part = container.part || container;
   const [style_cache, default_pstyle] = _get_style_cache(part);
 
@@ -62,7 +77,7 @@ function _extract_blocks(container: any, comments_map: any, cleanView: boolean,
     const block_start = local_cursor;
 
     if (item.constructor.name === 'FootnoteItem') {
-      const fn_text = _extract_blocks(item, comments_map, cleanView, block_start);
+      const fn_text = _extract_blocks(item, comments_map, cleanView, block_start, paragraph_offsets);
       if (fn_text) {
         blocks.push(fn_text);
         local_cursor = block_start + fn_text.length;
@@ -78,11 +93,14 @@ function _extract_blocks(container: any, comments_map: any, cleanView: boolean,
       const p_text = build_paragraph_text(item, comments_map, cleanView, style_cache, default_pstyle);
       const full_block = prefix + p_text;
       blocks.push(full_block);
+      if (paragraph_offsets) {
+        paragraph_offsets.set(item._element, [block_start, full_block.length]);
+      }
       local_cursor = block_start + full_block.length;
       is_first_para = false;
       is_first_block = false;
     } else if (item instanceof Table) {
-      const table_text = extract_table(item, comments_map, cleanView, block_start);
+      const table_text = extract_table(item, comments_map, cleanView, block_start, paragraph_offsets);
       if (table_text) {
         blocks.push(table_text);
         local_cursor = block_start + table_text.length;
@@ -97,7 +115,13 @@ function _extract_blocks(container: any, comments_map: any, cleanView: boolean,
   return blocks.join('\n\n');
 }
 
-export function extract_table(table: Table, comments_map: any, cleanView: boolean, cursor: number): string {
+export function extract_table(
+  table: Table,
+  comments_map: any,
+  cleanView: boolean,
+  cursor: number,
+  paragraph_offsets?: Map<any, [number, number]>
+): string {
   const rows_text: string[] = [];
   let rows_processed = 0;
   let local_cursor = cursor;
@@ -124,7 +148,7 @@ export function extract_table(table: Table, comments_map: any, cleanView: boolea
 
       if (!first_cell) cell_cursor += 3;
       
-      const cell_content = _extract_blocks(cell, comments_map, cleanView, cell_cursor);
+      const cell_content = _extract_blocks(cell, comments_map, cleanView, cell_cursor, paragraph_offsets);
       cell_texts.push(cell_content);
       cell_cursor += cell_content.length;
       first_cell = false;

package/src/mapper.ts

@@ -95,15 +95,17 @@ export function renumber_snapshot_ids(doc: DocumentObject): [Record<string, stri
 export class DocumentMapper {
   public doc: DocumentObject;
   public clean_view: boolean;
+  public original_view: boolean;
   public comments_map: Record<string, any>;
   public full_text: string = '';
   public spans: TextSpan[] = [];
   public appendix_start_index: number = -1;
   private _text_chunks: string[] = [];
 
-  constructor(doc: DocumentObject, clean_view: boolean = false) {
+  constructor(doc: DocumentObject, clean_view: boolean = false, original_view: boolean = false) {
     this.doc = doc;
     this.clean_view = clean_view;
+    this.original_view = original_view;
     this.comments_map = extract_comments_data(doc.pkg);
     this._build_map();
   }
@@ -200,16 +202,17 @@ export class DocumentMapper {
       const del_node = trPr ? findChild(trPr, 'w:del') : null;
 
       if (this.clean_view && del_node) continue;
+      if (this.original_view && ins) continue;
 
       if (rows_processed > 0) {
         this._add_virtual_text('\n', current, null);
         current += 1;
       }
 
-      if (ins && !this.clean_view) {
+      if (ins && !this.clean_view && !this.original_view) {
         this._add_virtual_text('{++ ', current, null);
         current += 4;
-      } else if (del_node && !this.clean_view) {
+      } else if (del_node && !this.clean_view && !this.original_view) {
         this._add_virtual_text('{-- ', current, null);
         current += 4;
       }
@@ -230,11 +233,11 @@ export class DocumentMapper {
         cells_processed += 1;
       }
 
-      if (ins && !this.clean_view) {
+      if (ins && !this.clean_view && !this.original_view) {
         const suffix = ` |Chg:${ins.getAttribute('w:id')}++}`;
         this._add_virtual_text(suffix, current, null);
         current += suffix.length;
-      } else if (del_node && !this.clean_view) {
+      } else if (del_node && !this.clean_view && !this.original_view) {
         const suffix = ` |Chg:${del_node.getAttribute('w:id')}--}`;
         this._add_virtual_text(suffix, current, null);
         current += suffix.length;
@@ -343,13 +346,16 @@ export class DocumentMapper {
         if (this.clean_view && Object.keys(active_del).length > 0) {
           // pass
         }
+        if (this.original_view && Object.keys(active_ins).length > 0) {
+          // pass
+        }
 
         const full_seg_text = run_parts.map(x => x[1]).join('');
         const curr_ins_id = Object.keys(active_ins).pop() || null;
         const curr_del_id = Object.keys(active_del).pop() || null;
 
-        if (full_seg_text && !(this.clean_view && curr_del_id)) {
-          const new_wrappers = this.clean_view ? ['', ''] as [string, string] : this._get_wrappers(curr_ins_id, curr_del_id, active_ids, active_fmt);
+        if (full_seg_text && !(this.clean_view && curr_del_id) && !(this.original_view && curr_ins_id)) {
+          const new_wrappers = (this.clean_view || this.original_view) ? ['', ''] as [string, string] : this._get_wrappers(curr_ins_id, curr_del_id, active_ids, active_fmt);
           const new_style: [string, string] = [prefix, suffix];
 
           if (pending_runs.length > 0 && new_wrappers[0] === current_wrappers[0] && new_wrappers[1] === current_wrappers[1]) {
@@ -379,7 +385,7 @@ export class DocumentMapper {
           }
         }
 
-        if (!this.clean_view) {
+        if (!this.clean_view && !this.original_view) {
           const has_meta = Object.keys(active_ins).length > 0 || Object.keys(active_del).length > 0 || active_ids.size > 0 || Object.keys(active_fmt).length > 0;
           if (has_meta) {
             deferred_meta_states.push([{...active_ins}, {...active_del}, new Set(active_ids), {...active_fmt}]);

package/src/outline.ts

@@ -40,12 +40,16 @@ export function extract_outline(
   projected_body: string,
   body_pages: string[],
   body_page_offsets: number[],
-  paragraph_offsets: Record<string, [number, number]> | null = null,
+  paragraph_offsets: Record<string, [number, number]> | Map<any, [number, number]> | null = null,
 ): OutlineNode[] {
   if (body_pages.length !== body_page_offsets.length) {
     throw new Error("body_pages and body_page_offsets length mismatch");
   }
 
+  if (paragraph_offsets) {
+    return _extract_outline_fast(doc, projected_body, body_page_offsets, paragraph_offsets);
+  }
+
   const comments_map = extract_comments_data(doc.pkg);
   const block_records = _walk_doc_body(doc, comments_map);
 
@@ -397,6 +401,7 @@ function _determine_heading_style(paragraph: Paragraph): string {
   }
 
   let outline_level: number | null = null;
+  let outline_level_from_style = false;
   if (pPr) {
     const oLvl = findChild(pPr, "w:outlineLvl");
     if (oLvl && /^\d+$/.test(oLvl.getAttribute("w:val") || "")) {
@@ -406,6 +411,7 @@ function _determine_heading_style(paragraph: Paragraph): string {
   
   if (outline_level === null && style_id && style_cache && style_cache[style_id]) {
     outline_level = style_cache[style_id].outline_level;
+    outline_level_from_style = true;
   }
 
   const style_name =
@@ -422,6 +428,15 @@ function _determine_heading_style(paragraph: Paragraph): string {
     }
   }
 
+  if (outline_level_from_style && outline_level !== null) {
+    const is_heading_or_title =
+      normalized_style_name &&
+      (normalized_style_name.startsWith("Heading") || normalized_style_name === "Title");
+    if (!is_heading_or_title) {
+      outline_level = null;
+    }
+  }
+
   if (outline_level !== null && outline_level >= 0 && outline_level <= 8) {
     if (normalized_style_name && (normalized_style_name.startsWith("Heading") || normalized_style_name === "Title")) {
       return normalized_style_name;
@@ -505,3 +520,183 @@ function _offset_to_page(offset: number, body_page_offsets: number[]): number {
   }
   return page;
 }
+
+function _extract_outline_fast(
+  doc: DocumentObject,
+  projected_body: string,
+  body_page_offsets: number[],
+  paragraph_offsets: Map<any, [number, number]> | Record<string, [number, number]>,
+): OutlineNode[] {
+  const paragraphs_and_tables: ["p" | "t", any][] = [];
+  const seen_cells = new Set<any>();
+
+  function walk(container: any) {
+    for (const item of iter_block_items(container)) {
+      const i_type = item.constructor.name;
+      if (i_type === "FootnoteItem") {
+        walk(item);
+      } else if (item instanceof Paragraph) {
+        paragraphs_and_tables.push(["p", item]);
+      } else if (item instanceof Table) {
+        paragraphs_and_tables.push(["t", item]);
+        for (const row of item.rows) {
+          for (const cell of row.cells) {
+            if (seen_cells.has(cell._element)) {
+              continue;
+            }
+            seen_cells.add(cell._element);
+            walk(cell);
+          }
+        }
+      }
+    }
+  }
+
+  walk(doc);
+
+  const heading_indices: number[] = [];
+  for (let idx = 0; idx < paragraphs_and_tables.length; idx++) {
+    const [kind, item] = paragraphs_and_tables[idx];
+    if (kind !== "p") continue;
+
+    let hasOffset = false;
+    if (paragraph_offsets instanceof Map) {
+      hasOffset = paragraph_offsets.has(item._element);
+    } else {
+      hasOffset = item._element in (paragraph_offsets as any);
+    }
+    if (!hasOffset) {
+      continue;
+    }
+
+    if (!_is_heading(item)) continue;
+    if (!_heading_passes_quality_filter_fast(item, projected_body, paragraph_offsets)) continue;
+
+    heading_indices.push(idx);
+  }
+
+  if (heading_indices.length === 0) return [];
+
+  const nodes: OutlineNode[] = [];
+  for (let h_pos = 0; h_pos < heading_indices.length; h_pos++) {
+    const item_idx = heading_indices[h_pos];
+    const paragraph = paragraphs_and_tables[item_idx][1] as Paragraph;
+    const level = _heading_level(paragraph);
+    const text = _heading_text_fast(paragraph, projected_body, paragraph_offsets);
+    const style = _determine_heading_style(paragraph);
+
+    // Owned range: items strictly between this heading and the next equal-or-higher heading.
+    let owned_end = item_idx;
+    for (let next_h_pos = h_pos + 1; next_h_pos < heading_indices.length; next_h_pos++) {
+      const next_idx = heading_indices[next_h_pos];
+      const next_paragraph = paragraphs_and_tables[next_idx][1] as Paragraph;
+      if (_heading_level(next_paragraph) <= level) {
+        owned_end = next_idx;
+        break;
+      }
+    }
+    if (owned_end === item_idx) {
+      owned_end = paragraphs_and_tables.length;
+    }
+
+    const owned = paragraphs_and_tables.slice(item_idx + 1, owned_end);
+
+    // has_table: nearest-claim semantics (no bubbling to ancestors).
+    let has_table = false;
+    for (const [kind2, item2] of owned) {
+      if (kind2 === "p" && _is_heading(item2)) {
+        break;
+      }
+      if (kind2 === "t") {
+        has_table = true;
+        break;
+      }
+    }
+
+    // Footnote IDs in document order, deduped.
+    const footnote_ids = _collect_footnote_ids_fast(owned);
+
+    // Page resolution from the paragraph's known offset.
+    let para_offset: [number, number] | undefined;
+    if (paragraph_offsets instanceof Map) {
+      para_offset = paragraph_offsets.get(paragraph._element);
+    } else {
+      para_offset = paragraph_offsets[paragraph._element as any];
+    }
+
+    let page_num = 1;
+    if (para_offset !== undefined) {
+      const [start_offset] = para_offset;
+      page_num = _offset_to_page(start_offset, body_page_offsets);
+    }
+
+    nodes.push({
+      level,
+      text,
+      page: page_num,
+      style,
+      has_table,
+      footnote_ids,
+    });
+  }
+
+  return nodes;
+}
+
+function _heading_passes_quality_filter_fast(
+  paragraph: Paragraph,
+  projected_body: string,
+  paragraph_offsets: Map<any, [number, number]> | Record<string, [number, number]>,
+): boolean {
+  const style = _determine_heading_style(paragraph);
+  if (style !== "(heuristic)") return true;
+
+  const text = _heading_text_fast(paragraph, projected_body, paragraph_offsets);
+  if (!text) return false;
+  const words = text.match(/\w+/g) || [];
+  return words.length >= _HEURISTIC_MIN_WORDS;
+}
+
+function _heading_text_fast(
+  paragraph: Paragraph,
+  projected_body: string,
+  paragraph_offsets: Map<any, [number, number]> | Record<string, [number, number]>,
+): string {
+  let offset: [number, number] | undefined;
+  if (paragraph_offsets instanceof Map) {
+    offset = paragraph_offsets.get(paragraph._element);
+  } else {
+    offset = paragraph_offsets[paragraph._element as any];
+  }
+
+  if (offset === undefined) {
+    return "";
+  }
+  const [start, length] = offset;
+  const raw = projected_body.substring(start, start + length);
+  let cleaned = _strip_critic_markup(raw);
+  cleaned = _strip_inline_formatting(cleaned);
+  cleaned = cleaned.replace(/^#+\s+/, "");
+  return cleaned.trim();
+}
+
+function _collect_footnote_ids_fast(owned_items: ["p" | "t", any][]): string[] {
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+  for (const [kind, item] of owned_items) {
+    if (kind !== "p") continue;
+    for (const event of iter_paragraph_content(item)) {
+      if (!("type" in event)) continue;
+      let fn_id = "";
+      if (event.type === "footnote") fn_id = `fn-${event.id}`;
+      else if (event.type === "endnote") fn_id = `en-${event.id}`;
+      else continue;
+
+      if (!seen.has(fn_id)) {
+        seen.add(fn_id);
+        ordered.push(fn_id);
+      }
+    }
+  }
+  return ordered;
+}

package/src/parity_gaps.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { createTestDocument } from './test-utils.js';
+import { RedlineEngine } from './engine.js';
+import { DocumentMapper } from './mapper.js';
+import { extract_outline } from './outline.js';
+import { _extractTextFromDoc } from './ingest.js';
+import { paginate } from './pagination.js';
+
+describe('Parity Gaps (TDD)', () => {
+  it('GAP 2: original_view maps deleted text and validate_edits throws actionable deletion error', async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+    
+    // Create a paragraph with a tracked deletion: <w:p><w:del w:id="1" w:author="Test Negotiator"><w:r><w:t>Deleted sentence.</w:t></w:r></w:del></w:p>
+    const p = xmlDoc.createElement('w:p');
+    const del = xmlDoc.createElement('w:del');
+    del.setAttribute('w:id', '1');
+    del.setAttribute('w:author', 'Test Negotiator');
+    
+    const r = xmlDoc.createElement('w:r');
+    const t = xmlDoc.createElement('w:t');
+    t.textContent = 'Deleted sentence.';
+    
+    r.appendChild(t);
+    del.appendChild(r);
+    p.appendChild(del);
+    doc.element.appendChild(p);
+
+    // 1. Verify original_view mapping
+    const mapperOrig = new DocumentMapper(doc, false, true);
+    expect(mapperOrig.full_text).toContain('Deleted sentence.');
+
+    const mapperRaw = new DocumentMapper(doc, false, false);
+    expect(mapperRaw.full_text).toContain('{--Deleted sentence.--}');
+
+    // 2. Validate modification targetting deleted text
+    const engine = new RedlineEngine(doc);
+    const errors = engine.validate_edits([
+      {
+        target_text: 'Deleted sentence.',
+        new_text: 'Active replacement text.',
+      }
+    ]);
+
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('Target text matches text inside a tracked deletion by Test Negotiator.');
+    expect(errors[0]).toContain('Reject/accept that change first or target the active replacement text instead.');
+  });
+
+  it('GAP 1: heading inside a deleted region is filtered out when using paragraph_offsets', async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+
+    const p1 = xmlDoc.createElement('w:p');
+    const p1Pr = xmlDoc.createElement('w:pPr');
+    const p1Style = xmlDoc.createElement('w:pStyle');
+    p1Style.setAttribute('w:val', 'Heading1');
+    p1Pr.appendChild(p1Style);
+    p1.appendChild(p1Pr);
+    const r1 = xmlDoc.createElement('w:r');
+    const t1 = xmlDoc.createElement('w:t');
+    t1.textContent = 'Active Heading';
+    r1.appendChild(t1);
+    p1.appendChild(r1);
+    doc.element.appendChild(p1);
+
+    const p2 = xmlDoc.createElement('w:p');
+    const p2Pr = xmlDoc.createElement('w:pPr');
+    const p2Style = xmlDoc.createElement('w:pStyle');
+    p2Style.setAttribute('w:val', 'Heading1');
+    p2Pr.appendChild(p2Style);
+    p2.appendChild(p2Pr);
+    const r2 = xmlDoc.createElement('w:r');
+    const t2 = xmlDoc.createElement('w:t');
+    t2.textContent = 'Deleted Heading';
+    r2.appendChild(t2);
+    p2.appendChild(r2);
+    doc.element.appendChild(p2);
+
+    const extract_res = _extractTextFromDoc(doc, false, false, true) as { text: string; paragraph_offsets: Map<any, [number, number]> };
+    
+    // Simulate deletion/skipping of p2 during projection
+    extract_res.paragraph_offsets.delete(p2);
+
+    const pages = paginate(extract_res.text, '');
+    const nodes = extract_outline(
+      doc,
+      extract_res.text,
+      pages.body_pages,
+      pages.body_page_offsets,
+      extract_res.paragraph_offsets as any,
+    );
+
+    // Only Active Heading should be in the outline, Deleted Heading must be skipped because it is not in paragraph_offsets!
+    expect(nodes.length).toBe(1);
+    expect(nodes[0].text).toBe('Active Heading');
+  });
+});