@ansonlai/docx-redline-js 0.2.0 → 0.4.0

package/scripts/prepare-superdoc-word-corpus.mjs

@@ -0,0 +1,284 @@
+import '../tests/setup-xml-provider.mjs';
+
+import assert from 'assert';
+import { mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+import { applyOperationsToDocumentXml } from '../services/standalone-operation-runner.js';
+import { applyRedlineToOxml } from '../index.js';
+import {
+    acceptTrackedChangesInOoxml,
+    rejectTrackedChangesInOoxml
+} from '../services/revision-comment-management.js';
+import { buildZip } from './lib/minimal-zip.mjs';
+import { unzipEntries } from './lib/zip-reader.mjs';
+import { loadCoverageCatalogue } from './lib/word-coverage-catalogue.mjs';
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = dirname(scriptDir);
+const manifest = JSON.parse(readFileSync(join(repoRoot, 'tests', 'corpus', 'superdoc-english-legal-administrative.json'), 'utf8'));
+const catalogue = JSON.parse(readFileSync(join(repoRoot, 'tests', 'corpus', 'superdoc-word-scenarios.json'), 'utf8'));
+function argumentPath(name, fallback) {
+    const index = process.argv.indexOf(name);
+    if (index < 0) return fallback;
+    if (!process.argv[index + 1]) throw new Error(`${name} requires a path`);
+    return resolve(process.cwd(), process.argv[index + 1]);
+}
+
+const inputDir = argumentPath('--input-dir', join(repoRoot, 'tmp', 'superdoc-corpus'));
+const outputDir = argumentPath('--output-dir', join(repoRoot, 'tmp', 'superdoc-word-fixtures'));
+const manifestById = new Map(manifest.documents.map(document => [document.id, document]));
+const normalizedCoverageById = new Map(loadCoverageCatalogue().cases
+    .filter(item => item.lane === 'superdoc')
+    .map(item => [item.identity.slice('superdoc:'.length), item.metadata]));
+
+mkdirSync(outputDir, { recursive: true });
+
+function packageWithPartXml(sourceEntries, partName, partXml) {
+    return buildZip(Array.from(sourceEntries, ([name, data]) => ({
+        name,
+        data: name === partName ? partXml : data
+    })));
+}
+
+function assertInsertionFormatting(scenario, trackedXml) {
+    const forbidden = scenario.formatExpectations?.insertionsForbidRunProperties || [];
+    const requiredValues = scenario.formatExpectations?.insertionsRequireRunPropertyValues || {};
+    if (forbidden.length === 0 && Object.keys(requiredValues).length === 0) return;
+
+    const xmlDoc = new DOMParser().parseFromString(trackedXml, 'application/xml');
+    const insertions = Array.from(xmlDoc.getElementsByTagName('*'))
+        .filter(node => node.localName === 'ins');
+    assert.ok(insertions.length > 0, `${scenario.key}: expected tracked insertions for format validation`);
+
+    for (const insertion of insertions) {
+        const runs = Array.from(insertion.getElementsByTagName('*'))
+            .filter(node => node.localName === 'r' && Array.from(node.childNodes)
+                .some(child => child.localName === 't'));
+        const runProperties = runs.flatMap(run => Array.from(run.childNodes)
+            .filter(node => node.localName === 'rPr'));
+        for (const propertyName of forbidden) {
+            const inherited = runProperties.some(rPr => Array.from(rPr.getElementsByTagName('*'))
+                .some(node => node.localName === propertyName));
+            assert.equal(inherited, false,
+                `${scenario.key}: inserted text unexpectedly inherited w:${propertyName}`);
+        }
+        for (const [propertyName, expectedValue] of Object.entries(requiredValues)) {
+            assert.ok(runs.length > 0, `${scenario.key}: expected inserted text runs for format validation`);
+            for (const run of runs) {
+                const rPr = Array.from(run.childNodes).find(node => node.localName === 'rPr');
+                const property = rPr && Array.from(rPr.childNodes)
+                    .find(node => node.localName === propertyName);
+                const actualValue = property?.getAttribute('w:val') || property?.getAttribute('val');
+                assert.equal(actualValue, String(expectedValue),
+                    `${scenario.key}: inserted text must retain w:${propertyName}=${expectedValue}`);
+            }
+        }
+    }
+}
+
+function countMatches(text, pattern) {
+    return Array.from(text.matchAll(pattern)).length;
+}
+
+function directWordChild(node, localName) {
+    return Array.from(node?.childNodes || []).find(child =>
+        child.nodeType === 1 && child.localName === localName
+    ) || null;
+}
+
+function wordAttribute(node, localName) {
+    return node?.getAttribute(`w:${localName}`) || node?.getAttribute(localName) || '';
+}
+
+function normalizedNodeText(node) {
+    return Array.from(node?.getElementsByTagName('*') || [])
+        .filter(child => child.localName === 't')
+        .map(child => child.textContent || '')
+        .join('')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+function assertSourceListStyle(scenario, sourceEntries, documentXml) {
+    const expected = scenario.listStyleExpectation;
+    if (!expected) return;
+
+    const numberingXml = sourceEntries.get('word/numbering.xml')?.toString('utf8');
+    assert.ok(numberingXml, `${scenario.key}: source has no word/numbering.xml`);
+
+    const target = String((scenario.operations || [scenario.operation])[0].target)
+        .replace(/\s+/g, ' ')
+        .trim();
+    const document = new DOMParser().parseFromString(documentXml, 'application/xml');
+    const matchingParagraphs = Array.from(document.getElementsByTagName('*'))
+        .filter(node => node.localName === 'p' && normalizedNodeText(node) === target);
+    assert.equal(matchingParagraphs.length, 1,
+        `${scenario.key}: expected one exact source list paragraph, found ${matchingParagraphs.length}`);
+
+    const pPr = directWordChild(matchingParagraphs[0], 'pPr');
+    const numPr = directWordChild(pPr, 'numPr');
+    const numId = wordAttribute(directWordChild(numPr, 'numId'), 'val');
+    const level = Number.parseInt(wordAttribute(directWordChild(numPr, 'ilvl'), 'val') || '0', 10);
+    assert.ok(numId, `${scenario.key}: target paragraph has no direct numbering binding`);
+    assert.equal(level, expected.level, `${scenario.key}: unexpected target list level`);
+
+    const numbering = new DOMParser().parseFromString(numberingXml, 'application/xml');
+    const num = Array.from(numbering.getElementsByTagName('*'))
+        .find(node => node.localName === 'num' && wordAttribute(node, 'numId') === numId);
+    const abstractNumId = wordAttribute(directWordChild(num, 'abstractNumId'), 'val');
+    const abstractNum = Array.from(numbering.getElementsByTagName('*'))
+        .find(node => node.localName === 'abstractNum'
+            && wordAttribute(node, 'abstractNumId') === abstractNumId);
+    const levelNode = Array.from(abstractNum?.childNodes || [])
+        .find(node => node.nodeType === 1 && node.localName === 'lvl'
+            && Number.parseInt(wordAttribute(node, 'ilvl') || '0', 10) === level);
+    const format = wordAttribute(directWordChild(levelNode, 'numFmt'), 'val');
+    const levelText = wordAttribute(directWordChild(levelNode, 'lvlText'), 'val');
+    assert.equal(format, expected.format, `${scenario.key}: unexpected source numbering format`);
+    if (expected.levelText !== undefined) {
+        assert.equal(levelText, expected.levelText, `${scenario.key}: unexpected source list marker text`);
+    }
+}
+
+function assertSourceComplexity(scenario, source, sourceEntries, documentXml) {
+    const expected = scenario.structuralExpectations;
+    if (!expected) return;
+
+    const observed = {
+        words: source.wordCount,
+        tables: countMatches(documentXml, /<w:tbl(?:\s|>)/g),
+        listParagraphs: countMatches(documentXml, /<w:numPr(?:\s|>)/g),
+        sections: countMatches(documentXml, /<w:sectPr(?:\s|>)/g),
+        headers: Array.from(sourceEntries.keys()).filter(name => /^word\/header\d+\.xml$/.test(name)).length,
+        footers: Array.from(sourceEntries.keys()).filter(name => /^word\/footer\d+\.xml$/.test(name)).length
+    };
+    for (const [label, minimum] of Object.entries({
+        words: expected.minWords,
+        tables: expected.minTables,
+        listParagraphs: expected.minListParagraphs,
+        sections: expected.minSections,
+        headers: expected.minHeaders,
+        footers: expected.minFooters
+    })) {
+        if (minimum === undefined) continue;
+        assert.ok(observed[label] >= minimum,
+            `${scenario.key}: expected at least ${minimum} ${label}, observed ${observed[label]}`);
+    }
+}
+
+const suite = {
+    generatedAt: new Date().toISOString(),
+    source: manifest.source,
+    attribution: manifest.attribution,
+    datasetLicense: manifest.datasetLicense,
+    cases: []
+};
+
+for (const [index, scenario] of catalogue.scenarios.entries()) {
+    const scenarioKey = scenario.key || scenario.id;
+    const sourceId = scenario.sourceId || scenario.id;
+    const operations = scenario.operations || [scenario.operation];
+    const revisionPart = scenario.part || 'word/document.xml';
+    const source = manifestById.get(sourceId);
+    assert.ok(source, `Scenario ${scenarioKey} is absent from the pinned manifest`);
+
+    const sourcePath = join(inputDir, `${sourceId}.docx`);
+    const sourceBytes = readFileSync(sourcePath);
+    const sourceEntries = unzipEntries(sourceBytes);
+    const sourcePartXml = sourceEntries.get(revisionPart)?.toString('utf8');
+    assert.ok(sourcePartXml, `${scenarioKey} has no ${revisionPart}`);
+    const documentXml = sourceEntries.get('word/document.xml')?.toString('utf8');
+    assert.ok(documentXml, `${scenarioKey} has no word/document.xml`);
+    assertSourceComplexity(scenario, source, sourceEntries, documentXml);
+    assertSourceListStyle(scenario, sourceEntries, documentXml);
+
+    let trackedXml;
+    if (revisionPart === 'word/document.xml') {
+        const result = await applyOperationsToDocumentXml(
+            sourcePartXml,
+            operations,
+            catalogue.author,
+            null,
+            { generateRedlines: true, existingRevisions: 'reject-input' }
+        );
+        assert.notEqual(result.status, 'error', `${scenarioKey}: ${result.error?.message || result.status}`);
+        assert.equal(result.hasChanges, true, `${scenarioKey}: operation was a no-op`);
+        trackedXml = result.documentXml;
+    } else {
+        assert.equal(operations.length, 1, `${scenarioKey}: related-part scenarios support one operation`);
+        const operation = operations[0];
+        const result = await applyRedlineToOxml(sourcePartXml, operation.target, operation.modified, {
+            generateRedlines: true,
+            author: catalogue.author,
+            existingRevisions: 'reject-input'
+        });
+        assert.equal(result.status, 'ok', `${scenarioKey}: ${result.error?.message || result.status}`);
+        assert.equal(result.hasChanges, true, `${scenarioKey}: operation was a no-op`);
+        trackedXml = result.oxml;
+    }
+
+    assert.ok(
+        trackedXml.includes('<w:ins') || trackedXml.includes('<w:del')
+        || trackedXml.includes('<w:rPrChange') || trackedXml.includes('<w:pPrChange'),
+        `${scenarioKey}: tracked revision markup missing`
+    );
+    assertInsertionFormatting(scenario, trackedXml);
+
+    const caseToken = scenario.key || sourceId.slice(0, 12);
+    const caseName = `${String(index + 1).padStart(2, '0')}-${source.type}-${caseToken}`;
+    const accepted = acceptTrackedChangesInOoxml(trackedXml, { allAuthors: true });
+    const rejected = rejectTrackedChangesInOoxml(trackedXml, { allAuthors: true });
+    assert.notEqual(accepted.status, 'error', `${scenarioKey}: accepting revisions failed`);
+    assert.notEqual(rejected.status, 'error', `${scenarioKey}: rejecting revisions failed`);
+
+    // Emit complete comparison packages for the dashboard. The Windows suite
+    // may independently repackage the tracked state before its hash checks.
+    writeFileSync(join(outputDir, `${caseName}.source.docx`), sourceBytes);
+    writeFileSync(join(outputDir, `${caseName}.docx`), packageWithPartXml(sourceEntries, revisionPart, trackedXml));
+    writeFileSync(join(outputDir, `${caseName}.accepted.docx`), packageWithPartXml(sourceEntries, revisionPart, accepted.oxml));
+    writeFileSync(join(outputDir, `${caseName}.rejected.docx`), packageWithPartXml(sourceEntries, revisionPart, rejected.oxml));
+    writeFileSync(join(outputDir, `${caseName}.document.xml`), trackedXml);
+    writeFileSync(join(outputDir, `${caseName}.expected.json`), `${JSON.stringify({
+        name: caseName,
+        scenarioKey,
+        sourceId,
+        revisionPart,
+        assertionScope: revisionPart.startsWith('word/header') ? 'headers' : 'document',
+        assertionMode: scenario.assertions ? 'contains' : 'word-source-exact',
+        ...(scenario.assertions ? {
+            expectedAcceptedContains: scenario.assertions.acceptedContains,
+            expectedAcceptedAbsent: scenario.assertions.acceptedAbsent,
+            expectedRejectedContains: scenario.assertions.rejectedContains,
+            expectedRejectedAbsent: scenario.assertions.rejectedAbsent
+        } : {}),
+        replacements: operations.map(operation => ({
+            originalTarget: operation.target,
+            modifiedTarget: operation.type === 'format' ? operation.target : operation.modified
+        })),
+        originalTarget: operations[0].target,
+        modifiedTarget: operations[0].type === 'format' ? operations[0].target : operations[0].modified,
+        sourceText: operations.map(operation => operation.target).join('\n'),
+        expectedAcceptedText: operations.map(operation =>
+            operation.type === 'format' ? operation.target : operation.modified
+        ).join('\n'),
+        expectedRejectedText: operations.map(operation => operation.target).join('\n'),
+        shape: scenario.shape,
+        coverage: scenario.coverage,
+        coverageMetadata: normalizedCoverageById.get(scenarioKey)
+    }, null, 2)}\n`);
+    suite.cases.push({
+        name: caseName,
+        scenarioKey,
+        sourceId,
+        revisionPart,
+        type: source.type,
+        shape: scenario.shape,
+        coverageMetadata: normalizedCoverageById.get(scenarioKey)
+    });
+    console.log(`Prepared ${caseName}`);
+}
+
+writeFileSync(join(outputDir, 'suite.json'), `${JSON.stringify(suite, null, 2)}\n`);
+console.log(`Prepared ${suite.cases.length} reviewed SuperDoc Word fixtures in ${outputDir}`);

package/scripts/prepare-word-review.mjs

@@ -0,0 +1,77 @@
+import { execFileSync } from 'child_process';
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+import { loadCoverageCatalogue } from './lib/word-coverage-catalogue.mjs';
+
+const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const cycleArg = process.argv.find(argument => argument.startsWith('--cycle='));
+const cycle = Number(cycleArg?.split('=')[1] ?? 0);
+if (!Number.isInteger(cycle) || cycle < 0) throw new Error('--cycle must be a non-negative integer');
+
+function changedFiles() {
+    try {
+        return execFileSync('git', [
+            'status', '--short', '--untracked-files=all', '--',
+            'tests/fixtures/word-task-cases.mjs',
+            'tests/fixtures/word-task-coverage.mjs',
+            'tests/corpus/superdoc-word-scenarios.json',
+            'tests/corpus/superdoc-word-coverage.json'
+        ], { cwd: repoRoot, encoding: 'utf8' });
+    } catch {
+        return '';
+    }
+}
+
+function rotate(items, count, offset) {
+    if (items.length === 0) return [];
+    return Array.from({ length: Math.min(count, items.length) }, (_, index) => items[(offset + index) % items.length]);
+}
+
+const { cases } = loadCoverageCatalogue();
+const synthetic = cases.filter(item => item.lane === 'synthetic');
+const corpus = cases.filter(item => item.lane === 'superdoc');
+const changes = changedFiles();
+const selected = new Map();
+const add = (item, reason) => {
+    const existing = selected.get(item.identity);
+    selected.set(item.identity, { ...item, reasons: [...new Set([...(existing?.reasons || []), reason])] });
+};
+
+if (/word-task-(?:cases|coverage)\.mjs/.test(changes)) {
+    for (const item of synthetic) add(item, 'Synthetic catalogue metadata or cases changed');
+}
+if (/superdoc-word-(?:scenarios|coverage)\.json/.test(changes)) {
+    for (const item of corpus) add(item, 'SuperDoc scenario catalogue changed');
+}
+
+const sampleSize = Math.ceil(synthetic.length * 0.2);
+for (const item of rotate(synthetic, sampleSize, (cycle * sampleSize) % synthetic.length)) {
+    add(item, `Rotating 20% synthetic sample, cycle ${cycle}`);
+}
+for (const category of ['legal', 'administrative']) {
+    const categoryCases = corpus.filter(item => item.category === category);
+    add(categoryCases[cycle % categoryCases.length], `Required ${category} SuperDoc sample`);
+}
+
+const manifest = {
+    schemaVersion: 1,
+    cycle,
+    humanSignOff: { status: 'pending', reviewer: null, wordBuild: null },
+    instructions: 'Inspect All Markup, Accept All, and Reject All. This manifest does not record a pass.',
+    cases: [...selected.values()].sort((a, b) => a.identity.localeCompare(b.identity)).map(item => ({
+        identity: item.identity,
+        lane: item.lane,
+        category: item.category,
+        task: item.metadata.task,
+        structures: item.metadata.structures,
+        reasons: item.reasons,
+        views: { allMarkup: 'pending', acceptAll: 'pending', rejectAll: 'pending' }
+    }))
+};
+const outputDir = join(repoRoot, 'tmp', 'word-manual-review');
+mkdirSync(outputDir, { recursive: true });
+const outputPath = join(outputDir, `review-manifest-cycle-${cycle}.json`);
+writeFileSync(outputPath, `${JSON.stringify(manifest, null, 2)}\n`);
+console.log(`Prepared ${manifest.cases.length} cases for human review: ${outputPath}`);

package/scripts/prepare-word-visual-review.mjs

@@ -0,0 +1,90 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+import { WORD_TASK_CASES } from '../tests/fixtures/word-task-cases.mjs';
+
+export const VISUAL_STRUCTURES = Object.freeze([
+    'formatted-runs',
+    'list',
+    'table',
+    'bookmark',
+    'hyperlink',
+    'content-control',
+    'tab-break',
+    'field',
+    'comment',
+    'note',
+    'header-footer',
+    'section-boundary'
+]);
+
+const VISUAL_STRUCTURE_SET = new Set(VISUAL_STRUCTURES);
+const VIEW_NAMES = Object.freeze(['allMarkup', 'acceptAll', 'rejectAll']);
+
+export function selectVisualReviewCases(cases = WORD_TASK_CASES, requestedNames = []) {
+    const requested = new Set(requestedNames);
+    if (requested.size > 0) {
+        const knownNames = new Set(cases.map(testCase => testCase.name));
+        const unknown = [...requested].filter(name => !knownNames.has(name));
+        if (unknown.length > 0) throw new Error(`Unknown visual-review case(s): ${unknown.join(', ')}`);
+    }
+
+    return cases
+        .filter(testCase => requested.size > 0
+            ? requested.has(testCase.name)
+            : testCase.coverageMetadata.structures.some(structure => VISUAL_STRUCTURE_SET.has(structure)))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function buildVisualReviewManifest(cases = WORD_TASK_CASES, requestedNames = []) {
+    const selected = selectVisualReviewCases(cases, requestedNames);
+    return {
+        schemaVersion: 1,
+        reviewType: 'render-only-visual-preflight',
+        certification: {
+            status: 'pending',
+            reviewer: null,
+            reviewedAt: null,
+            note: 'Rendering proves that Word produced inspectable evidence; it does not certify visual correctness.'
+        },
+        word: { version: null, build: null },
+        cases: selected.map(testCase => ({
+            identity: `synthetic:${testCase.name}`,
+            name: testCase.name,
+            category: testCase.category,
+            task: testCase.coverageMetadata.task,
+            structures: [...testCase.coverageMetadata.structures],
+            renderStatus: 'pending',
+            views: Object.fromEntries(VIEW_NAMES.map(view => [view, {
+                status: 'pending',
+                pdf: `${testCase.name}-${view}.pdf`,
+                pages: null,
+                bytes: null
+            }]))
+        }))
+    };
+}
+
+function parseArgs(argv) {
+    const requestedNames = argv
+        .filter(argument => argument.startsWith('--case='))
+        .map(argument => argument.slice('--case='.length))
+        .filter(Boolean);
+    const outputArgument = argv.find(argument => argument.startsWith('--output='));
+    return {
+        requestedNames,
+        outputPath: outputArgument
+            ? resolve(process.cwd(), outputArgument.slice('--output='.length))
+            : join(process.cwd(), 'tmp', 'word-visual-review', 'manifest.json')
+    };
+}
+
+const isCli = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isCli) {
+    const { requestedNames, outputPath } = parseArgs(process.argv.slice(2));
+    const manifest = buildVisualReviewManifest(WORD_TASK_CASES, requestedNames);
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    console.log(`Prepared ${manifest.cases.length} layout-sensitive cases for Word visual rendering: ${outputPath}`);
+}

package/scripts/render-agenda-multilevel.mjs

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+
+const baseName = '48-administrative-administrative-list-change-dash-agenda-child';
+const fixtureDir = 'tmp/superdoc-word-fixtures';
+const visualDir = 'tmp/multilevel-bullet-visual';
+
+const docxPath = `${fixtureDir}/${baseName}.docx`;
+const acceptedDocx = `${fixtureDir}/${baseName}.accepted.docx`;
+const rejectedDocx = `${fixtureDir}/${baseName}.rejected.docx`;
+
+const allMarkupPdf = `${visualDir}/${baseName}--allMarkup.pdf`;
+const acceptAllPdf = `${visualDir}/${baseName}--acceptAll.pdf`;
+const rejectAllPdf = `${visualDir}/${baseName}--rejectAll.pdf`;
+
+console.log('Rendering Word COM for', baseName);
+
+const psScript = `
+$ErrorActionPreference = 'Stop'
+$word = New-Object -ComObject Word.Application
+$word.Visible = $false
+$word.DisplayAlerts = 0
+try {
+    Write-Output 'Rendering allMarkup...'
+    $doc = $word.Documents.OpenNoRepairDialog((Resolve-Path '${docxPath}').Path)
+    $doc.ShowRevisions = $true
+    $doc.PrintRevisions = $true
+    $doc.ExportAsFixedFormat((Resolve-Path '${visualDir}').Path + '/${baseName}--allMarkup.pdf', 17, $false, 0, 0, 1, 1, 7, $true, $true, 0, $true, $true, $false)
+    $doc.Close(0)
+
+    Write-Output 'Rendering acceptAll...'
+    $docAcc = $word.Documents.OpenNoRepairDialog((Resolve-Path '${acceptedDocx}').Path)
+    $docAcc.ExportAsFixedFormat((Resolve-Path '${visualDir}').Path + '/${baseName}--acceptAll.pdf', 17, $false, 0, 0, 1, 1, 0, $true, $true, 0, $true, $true, $false)
+    $docAcc.Close(0)
+
+    Write-Output 'Rendering rejectAll...'
+    $docRej = $word.Documents.OpenNoRepairDialog((Resolve-Path '${rejectedDocx}').Path)
+    $docRej.ExportAsFixedFormat((Resolve-Path '${visualDir}').Path + '/${baseName}--rejectAll.pdf', 17, $false, 0, 0, 1, 1, 0, $true, $true, 0, $true, $true, $false)
+    $docRej.Close(0)
+    Write-Output 'SUCCESS: Rendered all 3 views.'
+} finally {
+    $word.Quit()
+}
+`;
+
+const psRes = spawnSync('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', psScript], { encoding: 'utf8' });
+console.log(psRes.stdout);
+if (psRes.stderr) console.error(psRes.stderr);
+
+// Render PDF pages to PNG using python pymupdf
+const pyScript = `
+import pymupdf
+views = ['allMarkup', 'acceptAll', 'rejectAll']
+base = '${baseName}'
+vis_dir = '${visualDir}'
+
+for v in views:
+    pdf_file = f"{vis_dir}/{base}--{v}.pdf"
+    doc = pymupdf.open(pdf_file)
+    print(f"{v} page count: {len(doc)}")
+    for i, page in enumerate(doc):
+        pix = page.get_pixmap(dpi=150)
+        out_png = f"{vis_dir}/{base}--{v}-p{i+1}.png"
+        pix.save(out_png)
+        print(f"  Rendered {out_png} ({pix.width}x{pix.height})")
+`;
+
+const pyRes = spawnSync('tmp/visual-qa-venv/Scripts/python.exe', ['-c', pyScript], { encoding: 'utf8' });
+console.log(pyRes.stdout);
+if (pyRes.stderr) console.error(pyRes.stderr);

package/scripts/render-case22.mjs

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+
+const baseName = '22-administrative-administrative-multi-bullet-board-agenda';
+const fixtureDir = 'tmp/superdoc-word-fixtures';
+const visualDir = 'tmp/multilevel-bullet-visual';
+const brainArtifactDir = 'C:/Users/Phara/.gemini/antigravity-ide/brain/ee12439b-cade-4f45-ab6e-a2a7b1bf1610';
+
+if (!fs.existsSync(visualDir)) {
+    fs.mkdirSync(visualDir, { recursive: true });
+}
+
+console.log('\n=== Rendering Word COM for', baseName, '===');
+const docxPath = `${fixtureDir}/${baseName}.docx`;
+const acceptedDocx = `${fixtureDir}/${baseName}.accepted.docx`;
+const rejectedDocx = `${fixtureDir}/${baseName}.rejected.docx`;
+
+const psScript = `
+$ErrorActionPreference = 'Stop'
+$word = New-Object -ComObject Word.Application
+$word.Visible = $false
+$word.DisplayAlerts = 0
+try {
+    Write-Output 'Rendering allMarkup...'
+    $doc = $word.Documents.OpenNoRepairDialog((Resolve-Path '${docxPath}').Path)
+    $doc.ShowRevisions = $true
+    $doc.PrintRevisions = $true
+    $doc.ExportAsFixedFormat((Resolve-Path '${visualDir}').Path + '/${baseName}--allMarkup.pdf', 17, $false, 0, 0, 1, 1, 7, $true, $true, 0, $true, $true, $false)
+    $doc.Close(0)
+
+    Write-Output 'Rendering acceptAll...'
+    $docAcc = $word.Documents.OpenNoRepairDialog((Resolve-Path '${acceptedDocx}').Path)
+    $docAcc.ExportAsFixedFormat((Resolve-Path '${visualDir}').Path + '/${baseName}--acceptAll.pdf', 17, $false, 0, 0, 1, 1, 0, $true, $true, 0, $true, $true, $false)
+    $docAcc.Close(0)
+
+    Write-Output 'Rendering rejectAll...'
+    $docRej = $word.Documents.OpenNoRepairDialog((Resolve-Path '${rejectedDocx}').Path)
+    $docRej.ExportAsFixedFormat((Resolve-Path '${visualDir}').Path + '/${baseName}--rejectAll.pdf', 17, $false, 0, 0, 1, 1, 0, $true, $true, 0, $true, $true, $false)
+    $docRej.Close(0)
+    Write-Output 'SUCCESS: Rendered all 3 views for ${baseName}.'
+} finally {
+    $word.Quit()
+}
+`;
+
+const psRes = spawnSync('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', psScript], { encoding: 'utf8' });
+console.log(psRes.stdout);
+if (psRes.stderr) console.error(psRes.stderr);
+
+const pyScript = `
+import pymupdf
+import shutil
+views = ['allMarkup', 'acceptAll', 'rejectAll']
+base = '${baseName}'
+vis_dir = '${visualDir}'
+art_dir = '${brainArtifactDir}'
+
+for v in views:
+    pdf_file = f"{vis_dir}/{base}--{v}.pdf"
+    doc = pymupdf.open(pdf_file)
+    print(f"{base} {v} page count: {len(doc)}")
+    for i, page in enumerate(doc):
+        pix = page.get_pixmap(dpi=150)
+        out_png = f"{vis_dir}/{base}--{v}-p{i+1}.png"
+        pix.save(out_png)
+        art_png = f"{art_dir}/{base}--{v}-p{i+1}.png"
+        shutil.copyfile(out_png, art_png)
+        print(f"  Rendered {out_png} -> {art_png}")
+`;
+
+const pyRes = spawnSync('tmp/visual-qa-venv/Scripts/python.exe', ['-c', pyScript], { encoding: 'utf8' });
+console.log(pyRes.stdout);
+if (pyRes.stderr) console.error(pyRes.stderr);

package/scripts/render-case40.ps1

@@ -0,0 +1,35 @@
+$ErrorActionPreference = 'Stop'
+$fixtureDir = (Resolve-Path 'tmp/superdoc-word-fixtures').Path
+$visualDir = (Resolve-Path 'tmp/multilevel-bullet-visual').Path
+$baseName = '40-administrative-administrative-list-change-ppg-agenda-addition'
+
+function Export-Docx([string]$docxName, [string]$pdfName, [bool]$isMarkup) {
+    Write-Output "Exporting $docxName to $pdfName..."
+    $word = New-Object -ComObject Word.Application
+    $word.Visible = $false
+    $word.DisplayAlerts = 0
+    try {
+        $doc = $word.Documents.Open("$fixtureDir/$docxName")
+        if ($isMarkup) {
+            $doc.ShowRevisions = $true
+            $doc.PrintRevisions = $true
+            $doc.ExportAsFixedFormat("$visualDir/$pdfName", 17, $false, 0, 0, 1, 1, 7, $true, $true, 0, $true, $true, $false)
+        } else {
+            $doc.ExportAsFixedFormat("$visualDir/$pdfName", 17, $false, 0, 0, 1, 1, 0, $true, $true, 0, $true, $true, $false)
+        }
+        Start-Sleep -Milliseconds 800
+        try { $doc.Close(0) } catch {}
+    } finally {
+        try { $word.Quit(0) } catch {}
+        [System.Runtime.InteropServices.Marshal]::ReleaseComObject($word) | Out-Null
+    }
+}
+
+if (!(Test-Path "$visualDir/$baseName--allMarkup.pdf")) {
+    Export-Docx "$baseName.docx" "$baseName--allMarkup.pdf" $true
+    Start-Sleep -Seconds 1
+}
+Export-Docx "$baseName.accepted.docx" "$baseName--acceptAll.pdf" $false
+Start-Sleep -Seconds 1
+Export-Docx "$baseName.rejected.docx" "$baseName--rejectAll.pdf" $false
+Write-Output 'All views exported successfully!'