fix: Maven Toolchains grows unexpectedly (#534)

* fix: Maven Toolchains grows unexpectedly On self-hosted runners toolchains.xml may survive multiple runs and unexpectedly grow as a result of the toolchains setup simply appending the JDK definition even if one with the same `type` and `provides.id` already exists. Restructuring the parsing step and filtering the potentially existing list of toolchain definitions prevents this and also fixes toolchain.xml files that already contain duplicates. Fixes #530 * fix: guard toolchain dedup and preserve existing root attributes Address reviewer feedback on the Maven toolchains dedup logic: - Treat jdk toolchains without a string `provides.id` as non-deduplicatable and use optional access when comparing ids, so partially-formed or nonstandard toolchains.xml files no longer crash setup. - Preserve the existing `<toolchains>` root attributes (xmlns, schemaLocation, …) when present, falling back to the 1.1.0 defaults only for attributes the existing file is missing. This avoids silently rewriting user-managed metadata or changing the effective namespace. Adds tests covering custom root attributes and id-less jdk toolchains, and rebuilds dist/. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --------- Co-authored-by: Bruno Borges <brborges@microsoft.com> Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
2026-07-08 14:21:50 +00:00 · 2026-07-07 06:01:31 +02:00 · 2026-07-07 06:01:31 +02:00 · 77ee41d00e
commit 77ee41d00e
parent 0765b158bf
3 changed files with 757 additions and 74 deletions
--- a/tests/toolchains.test.ts
+++ b/tests/toolchains.test.ts
@ -143,7 +143,310 @@ describe('toolchains tests', () => {
        </toolchain>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
-<toolchains>
+<toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>1.6</version>
      <vendor>Sun</vendor>
      <id>sun_1.6</id>
    </provides>
    <configuration>
      <jdkHome>/opt/jdk/sun/1.6</jdkHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('does not discard custom elements in existing toolchain definitions', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = `<toolchains>
        <toolchain>
          <type>jdk</type>
          <provides>
            <version>1.6</version>
            <vendor>Sun</vendor>
            <id>sun_1.6</id>
            <custom>foo</custom>
          </provides>
          <configuration>
            <jdkHome>/opt/jdk/sun/1.6</jdkHome>
            <fooHome>/usr/local/bin/bash</fooHome>
          </configuration>
        </toolchain>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>1.6</version>
      <vendor>Sun</vendor>
      <id>sun_1.6</id>
      <custom>foo</custom>
    </provides>
    <configuration>
      <jdkHome>/opt/jdk/sun/1.6</jdkHome>
      <fooHome>/usr/local/bin/bash</fooHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('does not discard existing, custom toolchain definitions', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = `<toolchains>
        <toolchain>
            <type>foo</type>
            <provides>
                <custom>baz</custom>
            </provides>
            <configuration>
                <fooHome>/usr/local/bin/foo</fooHome>
            </configuration>
        </toolchain>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
  <toolchain>
    <type>foo</type>
    <provides>
      <custom>baz</custom>
    </provides>
    <configuration>
      <fooHome>/usr/local/bin/foo</fooHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('does not duplicate existing toolchain definitions', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = `<toolchains>
      <toolchain>
        <type>jdk</type>
        <provides>
          <version>17</version>
          <vendor>Eclipse Temurin</vendor>
          <id>temurin_17</id>
        </provides>
        <configuration>
          <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
        </configuration>
      </toolchain>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('does not duplicate existing toolchain definitions if multiple exist', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = `<toolchains>
        <toolchain>
          <type>jdk</type>
          <provides>
@ -166,6 +469,316 @@ describe('toolchains tests', () => {
          <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
        </configuration>
      </toolchain>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>1.6</version>
      <vendor>Sun</vendor>
      <id>sun_1.6</id>
    </provides>
    <configuration>
      <jdkHome>/opt/jdk/sun/1.6</jdkHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('handles an empty list of existing toolchains correctly', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = `<toolchains>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('handles an empty existing toolchains.xml correctly', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = ``;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('preserves custom root attributes on existing toolchains.xml', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = `<toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.0.0 http://maven.apache.org/xsd/toolchains-1.0.0.xsd">
        <toolchain>
          <type>jdk</type>
          <provides>
            <version>1.6</version>
            <vendor>Sun</vendor>
            <id>sun_1.6</id>
          </provides>
          <configuration>
            <jdkHome>/opt/jdk/sun/1.6</jdkHome>
          </configuration>
        </toolchain>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.0.0 http://maven.apache.org/xsd/toolchains-1.0.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>1.6</version>
      <vendor>Sun</vendor>
      <id>sun_1.6</id>
    </provides>
    <configuration>
      <jdkHome>/opt/jdk/sun/1.6</jdkHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
    fs.writeFileSync(toolchainsFile, originalFile);
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    await toolchains.createToolchainsSettings({
      jdkInfo,
      settingsDirectory: m2Dir,
      overwriteSettings: true
    });
    expect(fs.existsSync(m2Dir)).toBe(true);
    expect(fs.existsSync(toolchainsFile)).toBe(true);
    expect(fs.readFileSync(toolchainsFile, 'utf-8')).toEqual(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    );
    expect(
      toolchains.generateToolchainDefinition(
        originalFile,
        jdkInfo.version,
        jdkInfo.vendor,
        jdkInfo.id,
        jdkInfo.jdkHome
      )
    ).toEqual(result);
  }, 100000);
  it('keeps partially-formed jdk toolchains without an id instead of crashing', async () => {
    const jdkInfo = {
      version: '17',
      vendor: 'Eclipse Temurin',
      id: 'temurin_17',
      jdkHome: '/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64'
    };
    const originalFile = `<toolchains>
        <toolchain>
          <type>jdk</type>
          <provides>
            <version>1.6</version>
            <vendor>Sun</vendor>
          </provides>
          <configuration>
            <jdkHome>/opt/jdk/sun/1.6</jdkHome>
          </configuration>
        </toolchain>
      </toolchains>`;
    const result = `<?xml version="1.0"?>
 <toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd">
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>17</version>
      <vendor>Eclipse Temurin</vendor>
      <id>temurin_17</id>
    </provides>
    <configuration>
      <jdkHome>/opt/hostedtoolcache/Java_Temurin-Hotspot_jdk/17.0.1-12/x64</jdkHome>
    </configuration>
  </toolchain>
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>1.6</version>
      <vendor>Sun</vendor>
    </provides>
    <configuration>
      <jdkHome>/opt/jdk/sun/1.6</jdkHome>
    </configuration>
  </toolchain>
 </toolchains>`;
    fs.mkdirSync(m2Dir, {recursive: true});
--- a/dist/setup/index.js
+++ b/dist/setup/index.js
@ -81506,31 +81506,7 @@ function createToolchainsSettings({ jdkInfo, settingsDirectory, overwriteSetting
 exports.createToolchainsSettings = createToolchainsSettings;
 // only exported for testing purposes
 function generateToolchainDefinition(original, version, vendor, id, jdkHome) {
-    let xmlObj;
+    let jsToolchains = [
    if (original === null || original === void 0 ? void 0 : original.length) {
        xmlObj = (0, xmlbuilder2_1.create)(original)
            .root()
            .ele({
            toolchain: {
                type: 'jdk',
                provides: {
                    version: `${version}`,
                    vendor: `${vendor}`,
                    id: `${id}`
                },
                configuration: {
                    jdkHome: `${jdkHome}`
                }
            }
        });
    }
    else
        xmlObj = (0, xmlbuilder2_1.create)({
            toolchains: {
                '@xmlns': 'http://maven.apache.org/TOOLCHAINS/1.1.0',
                '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
                '@xsi:schemaLocation': 'http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd',
                toolchain: [
        {
            type: 'jdk',
            provides: {
@ -81542,10 +81518,54 @@ function generateToolchainDefinition(original, version, vendor, id, jdkHome) {
                jdkHome: `${jdkHome}`
            }
        }
-                ]
+    ];
    // default root attributes, used when the existing file does not declare its own
    let rootAttributes = {
        '@xmlns': 'http://maven.apache.org/TOOLCHAINS/1.1.0',
        '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
        '@xsi:schemaLocation': 'http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd'
    };
    if (original === null || original === void 0 ? void 0 : original.length) {
        // convert existing toolchains into TS native objects for better handling
        // xmlbuilder2 will convert the document into a `{toolchains: { toolchain: [] | {} }}` structure
        // instead of the desired `toolchains: [{}]` one or simply `[{}]`
        const jsObj = (0, xmlbuilder2_1.create)(original)
            .root()
            .toObject();
        if (jsObj.toolchains) {
            // preserve the existing root attributes (xmlns, schemaLocation, …) so we don't
            // silently rewrite user-managed metadata or change the effective XML namespace;
            // xmlbuilder2 exposes attributes as `@`-prefixed keys on the element object
            const existingAttributes = Object.fromEntries(Object.entries(jsObj.toolchains).filter(([key]) => key.startsWith('@')));
            // fall back to the defaults only for attributes the existing file is missing
            rootAttributes = Object.assign(Object.assign({}, rootAttributes), existingAttributes);
            if (jsObj.toolchains.toolchain) {
                // in case only a single child exists xmlbuilder2 will not create an array and using verbose = true equally doesn't work here
                // See https://oozcitak.github.io/xmlbuilder2/serialization.html#js-object-and-map-serializers for details
                if (Array.isArray(jsObj.toolchains.toolchain)) {
                    jsToolchains.push(...jsObj.toolchains.toolchain);
                }
                else {
                    jsToolchains.push(jsObj.toolchains.toolchain);
                }
            }
        }
        // remove potential duplicates based on type & id (which should be a unique combination);
        // self.findIndex will only return the first occurrence, ensuring duplicates are skipped
        jsToolchains = jsToolchains.filter((value, index, self) => {
            var _a;
            // ensure non-jdk toolchains are kept in the results, we must not touch them because they belong to the user
            return value.type !== 'jdk' ||
                // keep toolchains that lack a usable string id (e.g. partially-formed user files);
                // we cannot safely deduplicate them and must not crash while reading them
                typeof ((_a = value.provides) === null || _a === void 0 ? void 0 : _a.id) !== 'string' ||
                index ===
                    self.findIndex(t => { var _a, _b; return t.type === value.type && ((_a = t.provides) === null || _a === void 0 ? void 0 : _a.id) === ((_b = value.provides) === null || _b === void 0 ? void 0 : _b.id); });
        });
-    return xmlObj.end({
+    }
    return (0, xmlbuilder2_1.create)({
        toolchains: Object.assign(Object.assign({}, rootAttributes), { toolchain: jsToolchains })
    }).end({
        format: 'xml',
        wellFormed: false,
        headless: false,
--- a/src/toolchains.ts
+++ b/src/toolchains.ts
@ -83,31 +83,7 @@ export function generateToolchainDefinition(
  id: string,
  jdkHome: string
 ) {
-  let xmlObj;
+  let jsToolchains: Toolchain[] = [
  if (original?.length) {
    xmlObj = xmlCreate(original)
      .root()
      .ele({
        toolchain: {
          type: 'jdk',
          provides: {
            version: `${version}`,
            vendor: `${vendor}`,
            id: `${id}`
          },
          configuration: {
            jdkHome: `${jdkHome}`
          }
        }
      });
  } else
    xmlObj = xmlCreate({
      toolchains: {
        '@xmlns': 'http://maven.apache.org/TOOLCHAINS/1.1.0',
        '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
        '@xsi:schemaLocation':
          'http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd',
        toolchain: [
    {
      type: 'jdk',
      provides: {
@ -119,11 +95,64 @@ export function generateToolchainDefinition(
        jdkHome: `${jdkHome}`
      }
    }
-        ]
+  ];
-      }
+  // default root attributes, used when the existing file does not declare its own
-    });
+  let rootAttributes: Record<string, string> = {
    '@xmlns': 'http://maven.apache.org/TOOLCHAINS/1.1.0',
    '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
    '@xsi:schemaLocation':
      'http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd'
  };
  if (original?.length) {
    // convert existing toolchains into TS native objects for better handling
    // xmlbuilder2 will convert the document into a `{toolchains: { toolchain: [] | {} }}` structure
    // instead of the desired `toolchains: [{}]` one or simply `[{}]`
    const jsObj = xmlCreate(original)
      .root()
      .toObject() as unknown as ExtractedToolchains;
    if (jsObj.toolchains) {
      // preserve the existing root attributes (xmlns, schemaLocation, …) so we don't
      // silently rewrite user-managed metadata or change the effective XML namespace;
      // xmlbuilder2 exposes attributes as `@`-prefixed keys on the element object
      const existingAttributes = Object.fromEntries(
        Object.entries(jsObj.toolchains).filter(([key]) => key.startsWith('@'))
      ) as Record<string, string>;
      // fall back to the defaults only for attributes the existing file is missing
      rootAttributes = {...rootAttributes, ...existingAttributes};
-  return xmlObj.end({
+      if (jsObj.toolchains.toolchain) {
        // in case only a single child exists xmlbuilder2 will not create an array and using verbose = true equally doesn't work here
        // See https://oozcitak.github.io/xmlbuilder2/serialization.html#js-object-and-map-serializers for details
        if (Array.isArray(jsObj.toolchains.toolchain)) {
          jsToolchains.push(...jsObj.toolchains.toolchain);
        } else {
          jsToolchains.push(jsObj.toolchains.toolchain);
        }
      }
    }
    // remove potential duplicates based on type & id (which should be a unique combination);
    // self.findIndex will only return the first occurrence, ensuring duplicates are skipped
    jsToolchains = jsToolchains.filter(
      (value, index, self) =>
        // ensure non-jdk toolchains are kept in the results, we must not touch them because they belong to the user
        value.type !== 'jdk' ||
        // keep toolchains that lack a usable string id (e.g. partially-formed user files);
        // we cannot safely deduplicate them and must not crash while reading them
        typeof value.provides?.id !== 'string' ||
        index ===
          self.findIndex(
            t => t.type === value.type && t.provides?.id === value.provides?.id
          )
    );
  }
  return xmlCreate({
    toolchains: {
      ...rootAttributes,
      toolchain: jsToolchains
    }
  }).end({
    format: 'xml',
    wellFormed: false,
    headless: false,
@ -166,3 +195,24 @@ async function writeToolchainsFileToDisk(
    flag: 'w'
  });
 }
 interface ExtractedToolchains {
  toolchains: {
    // root attributes such as xmlns / schemaLocation are exposed as `@`-prefixed keys
    [attribute: `@${string}`]: string;
    toolchain?: Toolchain[] | Toolchain;
  };
 }
 // Toolchain type definition according to Maven Toolchains XSD 1.1.0
 interface Toolchain {
  type: string;
  provides:
    | {
        version: string;
        vendor: string;
        id: string;
      }
    | any;
  configuration: any;
 }