Description

<dependency>
    <groupId>net.ladenthin</groupId>
    <artifactId>bitcoinaddressfinder</artifactId>
    <version>1.7.0</version>
</dependency>

<!--
SPDX-FileCopyrightText: 2017-2026 Bernard Ladenthin <[email protected]>

SPDX-License-Identifier: Apache-2.0
-->

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>net.ladenthin</groupId>
    <artifactId>bitcoinaddressfinder</artifactId>
    <version>1.7.0</version>
    <packaging>jar</packaging>

    <name>bitcoinaddressfinder</name>
    <description>Free high performance tool for fast scanning random Bitcoin, Bitcoin Cash, Bitcoin SV, Litecoin, Dogecoin, Dash, Zcash (and many more) private keys and finding addresses with balance.</description>
    <url>https://github.com/bernardladenthin/bitcoinaddressfinder</url>

    <licenses>
        <license>
            <name>The Apache Software License, Version 2.0</name>
            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
            <distribution>repo</distribution>
        </license>
    </licenses>

    <developers>
        <developer>
            <name>Bernard Ladenthin</name>
            <email>[email protected]</email>
            <organizationUrl>https://github.com/bernardladenthin</organizationUrl>
        </developer>
    </developers>

    <scm>
        <connection>scm:git:https://github.com/bernardladenthin/bitcoinaddressfinder.git</connection>
        <developerConnection>scm:git:https://github.com/bernardladenthin/bitcoinaddressfinder.git</developerConnection>
        <url>https://github.com/bernardladenthin/bitcoinaddressfinder</url>
    </scm>

    <properties>
        <sonar.organization>bernardladenthin</sonar.organization>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <slf4j.version>2.0.18</slf4j.version>
        <logback.version>1.5.38</logback.version>
        <project.build.outputTimestamp>${git.commit.time}</project.build.outputTimestamp>
        <!-- Test JVM heap: -Xmx2g cap, no eager -Xms. With reuseForks=false a fresh JVM is
             spawned per test class (~180 sequential spawns); an eager -Xms1g committed 1 GB up
             front in every short-lived fork, inflating the spawn-time footprint and occasionally
             tripping Surefire's "Error occurred in starting fork" (an OS-level spawn failure, NOT
             a timeout) on the memory-heavy pocl OpenCL job. Letting the heap grow lazily keeps the
             cap but drops the baseline. The add-opens / add-exports flags that follow must stay
             byte-for-byte identical to .mvn/jvm.config (enforced by JvmModuleFlagConsistencyTest). -->
        <argLine>-Xmx2g --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/jdk.internal.misc=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=jdk.management/com.sun.management.internal=ALL-UNNAMED --add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED --add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED --add-exports=java.base/java.lang=ALL-UNNAMED --add-exports=java.base/java.io=ALL-UNNAMED --add-exports=java.base/java.nio=ALL-UNNAMED --add-exports=java.base/jdk.internal.ref=ALL-UNNAMED --add-exports=java.base/jdk.internal.misc=ALL-UNNAMED --add-exports=java.base/sun.nio.ch=ALL-UNNAMED --add-exports=jdk.management/com.sun.management.internal=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=. -XX:ErrorFile=hs_err_pid%p.log</argLine>
        <jcstress.version>0.16</jcstress.version>
        <lincheck.version>3.6</lincheck.version>
        <vmlens.version>1.2.28</vmlens.version>
        <!-- DO NOT UPGRADE jqwik past 1.9.3. jqwik 1.10.0 added a deliberate
             anti-AI prompt-injection string to test stdout; the 1.10.1 user
             guide states the library "is not meant to be used by any 'AI'
             coding agents at all." 1.9.3 is the last pre-disclosure release
             and is the pinned version for this repo. Any CI / Dependabot /
             contributor PR that bumps this MUST be rejected. See CLAUDE.md
             section "jqwik prompt-injection in test output" for full context. -->
        <jqwik.version>1.9.3</jqwik.version>
        <archunit.version>1.4.2</archunit.version>
        <spotbugs.version>4.10.3.0</spotbugs.version>
        <fb-contrib.version>7.7.4</fb-contrib.version>
        <findsecbugs.version>1.14.0</findsecbugs.version>
        <errorprone.version>2.50.0</errorprone.version>
        <nullaway.version>0.13.8</nullaway.version>
        <checker.version>4.2.1</checker.version>
        <java-websocket.version>1.6.0</java-websocket.version>
        <jeromq.version>0.6.0</jeromq.version>
        <jspecify.version>1.0.0</jspecify.version>
        <lombok.version>1.18.46</lombok.version>
        <bitcoinj.version>0.17.1</bitcoinj.version>
        <bcprov.version>1.85.1</bcprov.version>
        <protobuf.version>4.35.1</protobuf.version>
        <jsr305.version>3.0.2</jsr305.version>
        <jcip-annotations.version>1.0</jcip-annotations.version>
        <guava.version>33.6.0-jre</guava.version>
        <jackson.version>2.22.1</jackson.version>
        <lmdbjava.version>0.9.3</lmdbjava.version>
        <jocl.version>2.0.6</jocl.version>
        <commons-io.version>2.22.0</commons-io.version>
        <commons-codec.version>1.22.0</commons-codec.version>
        <maven-artifact.version>3.9.16</maven-artifact.version>
        <junit.version>6.1.2</junit.version>
        <hamcrest.version>3.0</hamcrest.version>
        <mockito.version>5.23.0</mockito.version>
        <logcaptor.version>2.12.6</logcaptor.version>
        <jmh.version>1.37</jmh.version>
        <spotless.version>3.8.0</spotless.version>
        <palantir-java-format.version>2.96.0</palantir-java-format.version>
    </properties>

    <!--
        Pin transitively-conflicting versions so maven-enforcer's
        dependencyConvergence rule passes. Each entry below resolves a real
        version mismatch surfaced by the rule (the direct dep version we
        declare in <dependencies> must always win over the older one a
        transitive dep brings in).
    -->
    <dependencyManagement>
        <dependencies>
            <!-- slf4j-api: bitcoinj brings 2.0.16, Java-WebSocket brings 2.0.13,
                 logback-classic brings 2.0.17; we declare 2.0.18 directly. -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <!-- guava: bitcoinj brings 33.4.0-android; we declare ${guava.version} directly. -->
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>${guava.version}</version>
            </dependency>
            <!-- protobuf-javalite: bitcoinj brings 4.33.4; we declare ${protobuf.version} directly. -->
            <dependency>
                <groupId>com.google.protobuf</groupId>
                <artifactId>protobuf-javalite</artifactId>
                <version>${protobuf.version}</version>
            </dependency>
            <!-- bouncycastle: bitcoinj brings 1.83; we declare ${bcprov.version} directly. -->
            <dependency>
                <groupId>org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15to18</artifactId>
                <version>${bcprov.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <distributionManagement>
        <snapshotRepository>
            <id>central</id>
            <url>https://central.sonatype.com/repository/maven-snapshots/</url>
        </snapshotRepository>
    </distributionManagement>

    <repositories>
        <repository>
          <id>jitpack.io</id>
          <url>https://jitpack.io</url>
        </repository>
      </repositories>

    <build>
        <resources>
            <resource>
                <directory>${basedir}/src/main/resources</directory>
            </resource>
        </resources>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>com.diffplug.spotless</groupId>
                    <artifactId>spotless-maven-plugin</artifactId>
                    <version>${spotless.version}</version>
                </plugin>
                <plugin>
                    <groupId>com.github.spotbugs</groupId>
                    <artifactId>spotbugs-maven-plugin</artifactId>
                    <version>${spotbugs.version}</version>
                </plugin>
                <plugin>
                    <groupId>com.vmlens</groupId>
                    <artifactId>vmlens-maven-plugin</artifactId>
                    <version>${vmlens.version}</version>
                </plugin>
                <plugin>
                    <groupId>io.github.git-commit-id</groupId>
                    <artifactId>git-commit-id-maven-plugin</artifactId>
                    <version>10.0.0</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.15.0</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-enforcer-plugin</artifactId>
                    <version>3.6.3</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-gpg-plugin</artifactId>
                    <version>3.2.8</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.5.0</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-javadoc-plugin</artifactId>
                    <version>3.12.0</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-source-plugin</artifactId>
                    <version>3.4.0</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>3.5.6</version>
                    <configuration>
                        <!--
                            Tests in the `vmlens` package are meaningful only under the vmlens
                            agent (the `vmlens` profile / CI job). Without the agent an
                            AllInterleavings loop body never executes (a vacuous pass that also
                            prints an "agent not configured" warning), so exclude the whole
                            package from the ordinary surefire run. The vmlens job re-includes
                            them with `-Dtest=...`, which overrides this exclude. Merged with
                            the main surefire <argLine>/fork config below via pluginManagement.
                        -->
                        <excludes>
                            <exclude>**/vmlens/*.java</exclude>
                        </excludes>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>3.6.3</version>
                </plugin>
                <plugin>
                    <groupId>org.jacoco</groupId>
                    <artifactId>jacoco-maven-plugin</artifactId>
                    <version>0.8.15</version>
                </plugin>
                <plugin>
                    <groupId>org.pitest</groupId>
                    <artifactId>pitest-maven</artifactId>
                    <version>1.25.8</version>
                </plugin>
                <plugin>
                    <groupId>org.sonatype.central</groupId>
                    <artifactId>central-publishing-maven-plugin</artifactId>
                    <version>0.11.0</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>io.github.git-commit-id</groupId>
                <artifactId>git-commit-id-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>get-git-properties</id>
                        <goals>
                            <goal>revision</goal>
                        </goals>
                        <phase>initialize</phase>
                    </execution>
                </executions>
                <configuration>
                    <dateFormat>yyyy-MM-dd'T'HH:mm:ss'Z'</dateFormat>
                    <dateFormatTimeZone>UTC</dateFormatTimeZone>
                    <generateGitPropertiesFile>false</generateGitPropertiesFile>
                    <failOnNoGitDirectory>false</failOnNoGitDirectory>
                </configuration>
            </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-enforcer-plugin</artifactId>
            <executions>
              <execution>
                <id>enforce-maven</id>
                <goals>
                  <goal>enforce</goal>
                </goals>
                <configuration>
                  <rules>
                    <requireMavenVersion>
                      <version>[3.6.3,)</version>
                    </requireMavenVersion>
                    <requireJavaVersion>
                      <version>[21,)</version>
                    </requireJavaVersion>
                    <dependencyConvergence/>
                    <bannedDependencies>
                      <excludes>
                        <!-- Use SLF4J directly; never commons-logging. -->
                        <exclude>commons-logging:commons-logging</exclude>
                        <!-- Legacy / EoL logging frameworks. -->
                        <exclude>log4j:log4j</exclude>
                        <!-- Old hamcrest split artifacts; use hamcrest:hamcrest 2.x+. -->
                        <exclude>org.hamcrest:hamcrest-core</exclude>
                        <exclude>org.hamcrest:hamcrest-library</exclude>
                        <exclude>org.hamcrest:hamcrest-all</exclude>
                        <!-- Legacy JUnit 3 / 4; we use Jupiter (junit:junit-jupiter). -->
                        <exclude>junit:junit</exclude>
                        <exclude>junit:junit-dep</exclude>
                      </excludes>
                    </bannedDependencies>
                  </rules>
                </configuration>
              </execution>
            </executions>
          </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>prepare-agent</id>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>test</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <!-- Declared BEFORE maven-compiler-plugin on purpose. The attach-javadocs
                     execution below and the compiler's module-info-compile execution are both
                     bound to prepare-package, and Maven runs same-phase executions in plugin
                     declaration order. Javadoc must run first — while target/classes/ still has
                     no module-info.class — so it stays in classpath mode. Module mode is
                     unusable here: the module declares no `requires`, so in module mode javadoc
                     cannot see classpath dependencies (bitcoinj, jspecify, slf4j) and also
                     mis-stages module-source-path because module-info.java lives off the source
                     path in src/main/java9. See the module-info-compile execution for details. -->
                <configuration>
                    <source>21</source>
                    <failOnError>true</failOnError>
                    <failOnWarnings>true</failOnWarnings>
                    <doclint>all</doclint>
                    <additionalJOptions>
                        <additionalJOption>--add-opens=java.base/java.lang=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=java.base/java.io=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=java.base/java.nio=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=java.base/jdk.internal.ref=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=java.base/jdk.internal.misc=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=java.base/sun.nio.ch=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=jdk.management/com.sun.management.internal=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=java.base/java.lang=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=java.base/java.io=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=java.base/java.nio=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=java.base/jdk.internal.ref=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=java.base/sun.nio.ch=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.management/com.sun.management.internal=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</additionalJOption>
                        <additionalJOption>--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</additionalJOption>
                    </additionalJOptions>
                </configuration>
                <executions>
                    <execution>
                        <id>attach-javadocs</id>
                        <!-- Run at prepare-package (after test, before the package phase that
                             compiles module-info.class) instead of the default package phase.
                             At prepare-package, target/classes/ holds no module-info.class, so
                             maven-javadoc-plugin sees a non-modular project and runs javadoc in
                             classpath mode. If it ran in the package phase it would detect the
                             freshly compiled descriptor and switch into JPMS module mode, which
                             — because module-info.java lives in src/main/java9 (off javadoc's
                             source path) — stages an inconsistent module-source-path and
                             fails with "No source files for package net.ladenthin...". See the
                             module-info-compile execution above for the full rationale.
                             prepare-package is after test in the lifecycle, so `mvn test` (which
                             does not pass -Dmaven.javadoc.skip) still never triggers javadoc. -->
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>

                    <release>21</release>
                    <parameters>true</parameters>

                    <compilerArgs>
                        <!--
                          -Xlint:all surfaces every category of javac warning at compile time.
                          -Werror promotes every warning to a compile-time error. Pre-flip
                          history: the original 6-item warning list (deprecated Thread.getId,
                          deprecated jocl CL_DEVICE_QUEUE_PROPERTIES, two 'this' escapes in
                          KeyProducerJavaSocket/Zmq, Closeable.close declaring
                          InterruptedException, explicit close on auto-closeable in
                          OpenClTask) was cleared in commit 6eadc6f; 14 Checker Framework
                          [type.anno.before.modifier] warnings were cleared in commit f37f162;
                          the last 5 sun.misc.Unsafe proprietary-API warnings were eliminated
                          by deleting ByteBufferUtility#freeByteBuffer entirely — direct
                          ByteBuffers are now reclaimed by the JVM's built-in Cleaner when
                          they become unreachable, which already was the fallback for
                          OpenJ9 / GraalVM Native Image / Android.

                          -Xlint exclusion list:
                            -serial   : Serializable without serialVersionUID is not the
                                        concern of this hot-path / value-object codebase.
                            -options  : Suppresses release/target informational notes.
                            -classfile: Suppresses classfile-format notes from third-party deps.
                            -processing: Suppresses "No processor claimed any of these
                                         annotations" AP-emitted notes.
                        -->
                        <arg>-Xlint:all,-serial,-options,-classfile,-processing</arg>
                        <arg>-Werror</arg>
                        <!--
                          Checker Framework Nullness Checker runs as a second nullness pass
                          alongside NullAway. CF is generics-aware and stricter than NullAway,
                          so it acts as a second-opinion verifier on the same JSpecify
                          annotations.
                        -->
                        <!-- Lombok's two AP classes must be listed alongside the Checker Framework
                             processor so javac runs all three. Without naming the Lombok processors
                             here they are silently skipped because the explicit -processor arg
                             overrides SPI-registered processors. -->
                        <arg>-processor</arg>
                        <arg>lombok.launch.AnnotationProcessorHider$AnnotationProcessor,lombok.launch.AnnotationProcessorHider$ClaimingProcessor,org.checkerframework.checker.nullness.NullnessChecker</arg>
                        <!--
                          Override CF 4.1.0's incorrect Objects.requireNonNull stub. The shipped
                          stub annotates obj as @NonNull, the opposite of the JDK contract.
                        -->
                        <arg>-Astubs=src/etc/checker/objects.astub</arg>
                        <arg>-XDaddTypeAnnotationsToSymbol=true</arg>
                        <arg>-XDcompilePolicy=simple</arg>
                        <arg>--should-stop=ifError=FLOW</arg>
                        <arg>-Xplugin:ErrorProne -Xep:NullAway:ERROR -XepOpt:NullAway:OnlyNullMarked=true -XepOpt:NullAway:JSpecifyMode=true -XepOpt:NullAway:CheckOptionalEmptiness=true -XepOpt:NullAway:AcknowledgeRestrictiveAnnotations=true -XepOpt:NullAway:AcknowledgeAndroidRecent=true -XepOpt:NullAway:AssertsEnabled=true -Xep:BoxedPrimitiveEquality:ERROR -Xep:EqualsHashCode:ERROR -Xep:EqualsIncompatibleType:ERROR -Xep:IdentityBinaryExpression:ERROR -Xep:SelfAssignment:ERROR -Xep:SelfComparison:ERROR -Xep:SelfEquals:ERROR -Xep:DeadException:ERROR -Xep:FormatString:ERROR -Xep:InvalidPatternSyntax:ERROR -Xep:OptionalEquality:ERROR -Xep:ImpossibleNullComparison:ERROR</arg>

                        <!-- For ErrorProne, DO NOT TOUCH, documented here: https://errorprone.info/docs/installation#jdk-16 -->
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
                        <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
                        <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
                        <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>

                        <!-- Runtime system-module access lives in argLine / .mvn/jvm.config /
                             examples/*.bat. It is intentionally NOT duplicated into compilerArgs:
                             system-module add-exports/add-opens are forbidden under release
                             (JEP 247/261) and the main compile no longer needs them. Production
                             code imports no internal-JDK package — the only former user,
                             ByteBufferUtility#freeByteBuffer, was deleted (direct buffers are now
                             reclaimed by the JVM's built-in Cleaner). The runtime flags survive in
                             <argLine> for lmdbjava, whose off-heap ByteBufferProxy reflectively
                             reaches sun.nio.ch.DirectBuffer / jdk.internal.ref.Cleaner. -->
                    </compilerArgs>

                    <annotationProcessorPaths>
                        <!-- Lombok must run FIRST so the equals/hashCode/toString
                             methods it generates exist when Error Prone, NullAway,
                             and Checker Framework analyze the compilation unit.
                             Without this, Lombok annotations are silently ignored
                             and the methods fall back to java.lang.Object defaults. -->
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                        <path>
                            <groupId>com.google.errorprone</groupId>
                            <artifactId>error_prone_core</artifactId>
                            <version>${errorprone.version}</version>
                        </path>
                        <path>
                            <groupId>com.uber.nullaway</groupId>
                            <artifactId>nullaway</artifactId>
                            <version>${nullaway.version}</version>
                        </path>
                        <path>
                            <groupId>org.checkerframework</groupId>
                            <artifactId>checker</artifactId>
                            <version>${checker.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
                <executions>
                    <execution>
                        <id>module-info-compile</id>
                        <!-- Bind to prepare-package (after test-compile/test, before package) so
                             module-info.class is not present in target/classes/ while the test
                             sources compile or run. If it were, Surefire would see a module
                             descriptor and run the tests in JPMS module mode (main code as the
                             named module net.ladenthin.bitcoinaddressfinder on the module path)
                             instead of on the classpath as the unnamed module. The test JVM's
                             `add-opens java.base/{sun.nio.ch,jdk.internal.ref,java.nio}=ALL-UNNAMED`
                             flags (see argLine) open those internal packages to the UNNAMED
                             module only — lmdbjava's off-heap ByteBufferProxy reflectively reaches
                             sun.nio.ch.DirectBuffer / jdk.internal.ref.Cleaner — so in module mode
                             they no longer apply and LMDB tests fail with IllegalAccessError on
                             sun.nio.ch.DirectBuffer. (This is NOT about project code: the only
                             former internal-JDK user, ByteBufferUtility#freeByteBuffer, was
                             deleted — direct buffers are reclaimed by the JVM's built-in Cleaner.)
                             By the time
                             maven-jar-plugin runs in the package phase the descriptor is in
                             place and ends up at the jar root as expected (binding it to
                             package itself is NOT reliable: the jar packaging's default-jar
                             execution runs before an explicitly-declared package-phase
                             execution, so the descriptor would miss the jar).

                             Ordering vs. javadoc: the maven-javadoc-plugin attach-javadocs
                             execution is ALSO bound to prepare-package and MUST run before this
                             execution, so that javadoc sees a module-info-free target/classes
                             and stays in classpath mode (see that execution's comment for why
                             module mode breaks here). Same-phase ordering follows plugin
                             declaration order in <build><plugins>, so the maven-javadoc-plugin
                             block is declared before this maven-compiler-plugin block.

                             Local-dev caveat: running `mvn test` AFTER `mvn package` without
                             an intervening `mvn clean` will fail with IllegalAccessError on
                             sun.nio.ch.DirectBuffer because the package phase leaves
                             module-info.class in target/classes/. CI is unaffected because
                             the Build and Test jobs run in separate runners with fresh
                             checkouts. Run `mvn clean test` to reset. -->
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                        <configuration>
                            <!-- module-info.java lives in src/main/java9 so the default-compile
                                 pass cannot see it (BAF compiles at source/target 21 which
                                 supports modules; if javac sees module-info anywhere on its
                                 source path it auto-activates module mode and rejects every
                                 ordinary import as "package is not visible in unnamed module").
                                 This dedicated execution compiles the descriptor alone at
                                 release 9 without the Error Prone / NullAway / Checker
                                 Framework processors. BAF runs as a fat-jar (assembly profile)
                                 on the classpath and tests run on the classpath as well, so
                                 the module descriptor is informational — it gives module-path
                                 consumers a deterministic module name and the documented
                                 Jackson opens directive, but never gates any build or runtime
                                 resolution. -->
                            <release>9</release>
                            <compileSourceRoots>
                                <compileSourceRoot>${project.basedir}/src/main/java9</compileSourceRoot>
                            </compileSourceRoots>
                            <compilerArgs combine.self="override"/>
                            <annotationProcessorPaths combine.self="override"/>
                        </configuration>
                    </execution>
                    <execution>
                        <id>default-testCompile</id>
                        <configuration>
                            <!--
                                JMH annotation processor generates harness classes in net.ladenthin.*,
                                which NullAway would then analyze and fail (generated code lacks @NonNull
                                annotations). Turn NullAway OFF for test compilation; hand-written test
                                code is still checked via the default-compile phase on the main sources.

                                Also drop -parameters here so JMH / jcstress reflection doesn't pick up
                                parameter names from MethodParameters.

                                Override the parent release=21 back to source/target=21: this test
                                compile passes the shared "master" system-module add-exports /
                                add-opens list below (java.base/* and jdk.compiler/* — the latter
                                required for Error Prone to reach com.sun.tools.javac internals on
                                JDK 16+), and release mode rejects add-exports/add-opens to system
                                modules (JEP 247/261). The main default-compile keeps release 21
                                because it does NOT pass those bare flags (its Error Prone access uses
                                `-J`-prefixed JVM args, which are unaffected by release mode). Note: no
                                project source actually imports jdk.internal.ref / sun.nio.ch — those
                                packages are only opened at RUNTIME for lmdbjava (see argLine).
                            -->
                            <release combine.self="override"></release>
                            <source>21</source>
                            <target>21</target>
                            <parameters>false</parameters>
                            <compilerArgs combine.self="override">
                                <arg>-XDaddTypeAnnotationsToSymbol=true</arg>
                                <arg>-XDcompilePolicy=simple</arg>
                                <arg>--should-stop=ifError=FLOW</arg>
                                <arg>-Xplugin:ErrorProne -Xep:NullAway:OFF -Xep:GuardedBy:OFF</arg>

                                <!-- For ErrorProne, DO NOT TOUCH, documented here: https://errorprone.info/docs/installation#jdk-16 -->
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
                                <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
                                <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>

                                <!-- Master JVM-flag list: keep identical (same set + same order) across pom.xml (this list + <argLine> + the javadoc additionalJOptions), .mvn/jvm.config, examples/*.bat, examples/*.sh, and the JMH @Fork jvmArgsAppend in src/test/.../benchmark/*.java. Enforced by JvmModuleFlagConsistencyTest (fails the build on any drift). -->
                                <arg>--add-opens</arg><arg>java.base/java.lang=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>java.base/java.io=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>java.base/java.nio=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>java.base/jdk.internal.ref=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>java.base/jdk.internal.misc=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>java.base/sun.nio.ch=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>jdk.management/com.sun.management.internal=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
                                <arg>--add-opens</arg><arg>jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>java.base/java.lang=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>java.base/java.io=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>java.base/java.nio=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>java.base/jdk.internal.ref=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>java.base/jdk.internal.misc=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>java.base/sun.nio.ch=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.management/com.sun.management.internal=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
                                <arg>--add-exports</arg><arg>jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
                            </compilerArgs>
                            <annotationProcessorPaths combine.children="append">
                                <path>
                                    <groupId>org.openjdk.jcstress</groupId>
                                    <artifactId>jcstress-core</artifactId>
                                    <version>${jcstress.version}</version>
                                </path>
                                <path>
                                    <groupId>org.openjdk.jmh</groupId>
                                    <artifactId>jmh-generator-annprocess</artifactId>
                                    <version>${jmh.version}</version>
                                </path>
                            </annotationProcessorPaths>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <!-- Default Surefire plugin config (forking enabled) -->
                <configuration>
                        <!-- Fork just one JVM for test isolation -->
                        <forkCount>1</forkCount>
                        <reuseForks>false</reuseForks>
                        <!-- -XX:+EnableDynamicAgentLoading: silences the JDK 21 byte-buddy self-attach agent warning that intermittently corrupts Surefire's fork channel ("Corrupted channel ..." / bogus "timeout in the fork"). See workspace policy ci-test-diagnostics.md section 2.1: https://github.com/bernardladenthin/workspace/blob/main/policies/ci-test-diagnostics.md - root cause: https://github.com/raphw/byte-buddy/issues/1639 -->
                        <argLine>@{argLine} -XX:+EnableDynamicAgentLoading</argLine>
                        <!-- Whole-fork budget: with reuseForks=false this must cover JVM
                             startup + EVERY method of one test class + JVM shutdown.
                             60s was sporadically exceeded by socket-heavy classes
                             (e.g. KeyProducerJavaZmqTest) on loaded Windows runners, so it
                             was raised to 180s; 180s was in turn occasionally exceeded on
                             slow/overloaded CI runners (a ~2x-slow run plus the
                             Lincheck/jcstress concurrency forks), killing the fork with
                             "There was a timeout in the fork" even though all tests passed
                             — hence 240s. -->
                        <forkedProcessTimeoutInSeconds>240</forkedProcessTimeoutInSeconds>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>net.ladenthin.bitcoinaddressfinder.cli.Main</mainClass>
                            <packageName>net.ladenthin.bitcoinaddressfinder</packageName>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>net.ladenthin.bitcoinaddressfinder.cli.Main</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>com.diffplug.spotless</groupId>
                <artifactId>spotless-maven-plugin</artifactId>
                <configuration>
                    <java>
                        <includes>
                            <include>src/main/java/**/*.java</include>
                            <include>src/test/java/**/*.java</include>
                        </includes>
                        <palantirJavaFormat>
                            <version>${palantir-java-format.version}</version>
                        </palantirJavaFormat>
                        <removeUnusedImports/>
                        <trimTrailingWhitespace/>
                        <endWithNewline/>
                    </java>
                </configuration>
                <executions>
                    <execution>
                        <id>spotless-check</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>check</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>com.github.spotbugs</groupId>
                <artifactId>spotbugs-maven-plugin</artifactId>
                <configuration>
                    <effort>Max</effort>
                    <threshold>Low</threshold>
                    <failOnError>true</failOnError>
                    <includeTests>false</includeTests>
                    <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                    <plugins>
                        <plugin>
                            <groupId>com.mebigfatguy.fb-contrib</groupId>
                            <artifactId>fb-contrib</artifactId>
                            <version>${fb-contrib.version}</version>
                        </plugin>
                        <plugin>
                            <groupId>com.h3xstream.findsecbugs</groupId>
                            <artifactId>findsecbugs-plugin</artifactId>
                            <version>${findsecbugs.version}</version>
                        </plugin>
                    </plugins>
                </configuration>
                <executions>
                    <execution>
                        <id>spotbugs-check</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>check</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>org.openjdk.jmh.Main</mainClass>
                    <classpathScope>test</classpathScope>
                </configuration>
            </plugin>
            <plugin>
                <!--
                  Generic PIT policy (version, 100% gate, invocation, expansion rule):
                  see ../workspace/policies/pit-mutation-testing.md.
                  Repo-specific: the gated classes are covered by fast, pure-Java unit
                  tests (no LMDB / OpenCL / GPU needed), kept in lock-step in targetTests.
                  BAF-specific timing: running PIT right after test-compile (not a later
                  phase) keeps the prepare-package-bound module-info-compile execution from
                  firing, so module-info.class stays out of target/classes/ and the forked
                  PIT JVMs run in classpath mode (consistent with the rest of the test suite).
                -->
                <groupId>org.pitest</groupId>
                <artifactId>pitest-maven</artifactId>
                <dependencies>
                    <dependency>
                        <groupId>org.pitest</groupId>
                        <artifactId>pitest-junit5-plugin</artifactId>
                        <version>1.2.3</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <targetClasses>
                        <!-- Classes verified at 100% PIT mutation parity. Expand as more reach it. -->
                        <param>net.ladenthin.bitcoinaddressfinder.util.BitHelper</param>
                        <param>net.ladenthin.bitcoinaddressfinder.util.PrivateKeyTooLargeException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.PublicKeyBytes</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.AddressToCoin</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.AddressType</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.Hash160</param>
                        <param>net.ladenthin.bitcoinaddressfinder.io.AddressFormatNotAcceptedException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.core.InterruptedRuntimeException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.keyproducer.KeyProducerIdIsNotUniqueException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.keyproducer.KeyProducerIdNullException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.keyproducer.KeyProducerIdUnknownException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.secret.NoMoreSecretsAvailableException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.configuration.UnknownSecretFormatException</param>
                        <param>net.ladenthin.bitcoinaddressfinder.configuration.CKeyProducerJavaIncremental</param>
                        <param>net.ladenthin.bitcoinaddressfinder.statistics.Statistics</param>
                        <param>net.ladenthin.bitcoinaddressfinder.statistics.ReadStatistic</param>
                    </targetClasses>
                    <targetTests>
                        <param>net.ladenthin.bitcoinaddressfinder.util.BitHelperTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.util.PrivateKeyTooLargeExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.PublicKeyBytesTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.AddressToCoinTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.AddressTypeTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.model.Hash160Test</param>
                        <param>net.ladenthin.bitcoinaddressfinder.io.AddressFormatNotAcceptedExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.core.InterruptedRuntimeExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.keyproducer.KeyProducerIdIsNotUniqueExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.keyproducer.KeyProducerIdNullExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.keyproducer.KeyProducerIdUnknownExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.secret.NoMoreSecretsAvailableExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.configuration.UnknownSecretFormatExceptionTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.configuration.CKeyProducerJavaIncrementalTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.statistics.StatisticsTest</param>
                        <param>net.ladenthin.bitcoinaddressfinder.statistics.ReadStatisticTest</param>
                    </targetTests>
                    <mutationThreshold>100</mutationThreshold>
                    <timeoutConstant>30000</timeoutConstant>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.java-websocket</groupId>
            <artifactId>Java-WebSocket</artifactId>
            <version>${java-websocket.version}</version>
          </dependency>
        <dependency>
            <groupId>org.zeromq</groupId>
            <artifactId>jeromq</artifactId>
            <version>${jeromq.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jspecify</groupId>
            <artifactId>jspecify</artifactId>
            <version>${jspecify.version}</version>
        </dependency>
        <dependency>
            <groupId>org.checkerframework</groupId>
            <artifactId>checker-qual</artifactId>
            <version>${checker.version}</version>
        </dependency>
        <dependency>
            <groupId>org.bitcoinj</groupId>
            <artifactId>bitcoinj-core</artifactId>
            <version>${bitcoinj.version}</version>
        </dependency>
        <!-- Required by bitcoinj-core (transitive). Pinned here to keep on the latest secure version. -->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15to18</artifactId>
            <version>${bcprov.version}</version>
        </dependency>
        <!-- Required by bitcoinj-core (transitive). Pinned here to keep on the latest secure version. -->
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-javalite</artifactId>
            <version>${protobuf.version}</version>
        </dependency>
        <!-- Required by bitcoinj-core (transitive, runtime). Pinned here to keep on the latest version. -->
        <dependency>
            <groupId>com.google.code.findbugs</groupId>
            <artifactId>jsr305</artifactId>
            <version>${jsr305.version}</version>
            <scope>runtime</scope>
        </dependency>
        <!-- Required by bitcoinj-core (transitive, runtime). Pinned here to keep on the latest version. -->
        <dependency>
            <groupId>net.jcip</groupId>
            <artifactId>jcip-annotations</artifactId>
            <version>${jcip-annotations.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${logback.version}</version>
        </dependency>

        <dependency>
            <groupId>org.lmdbjava</groupId>
            <artifactId>lmdbjava</artifactId>
            <version>${lmdbjava.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jocl</groupId>
            <artifactId>jocl</artifactId>
            <version>${jocl.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>${commons-io.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>${commons-codec.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-artifact</artifactId>
            <version>${maven-artifact.version}</version>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest</artifactId>
            <version>${hamcrest.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>${mockito.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.github.hakky54</groupId>
            <artifactId>logcaptor</artifactId>
            <version>${logcaptor.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>net.jqwik</groupId>
            <artifactId>jqwik</artifactId>
            <version>${jqwik.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.tngtech.archunit</groupId>
            <artifactId>archunit-junit5</artifactId>
            <version>${archunit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-core</artifactId>
            <version>${jmh.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>${jmh.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jcstress</groupId>
            <artifactId>jcstress-core</artifactId>
            <version>${jcstress.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.lincheck</groupId>
            <artifactId>lincheck</artifactId>
            <version>${lincheck.version}</version>
            <scope>test</scope>
        </dependency>
        <!--
            vmlens interleaving-analysis API. Test-scoped and transitive-dependency-free
            (its own deps are all test-scope, hence not propagated), so it is safe on the
            default test classpath under dependencyConvergence. Needed so the
            VmlensInterleavingSmoke* test compiles in every build; it is only *executed*
            under the `vmlens` profile (see that profile + the vmlens CI job). The default
            surefire run excludes it (managed surefire <excludes> below) so the vmlens
            agent's JDK 9 API class is never loaded outside the agent-driven run.
        -->
        <dependency>
            <groupId>com.vmlens</groupId>
            <artifactId>api</artifactId>
            <version>${vmlens.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <profiles>
        <profile>
            <id>release</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-gpg-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>sign-artifacts</id>
                                <phase>verify</phase>
                                <goals><goal>sign</goal></goals>
                                <configuration>
                                    <keyname>${gpg.keyname}</keyname>
                                    <gpgArguments>
                                        <arg>--pinentry-mode</arg>
                                        <arg>loopback</arg>
                                    </gpgArguments>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>

                    <plugin>
                        <groupId>org.sonatype.central</groupId>
                        <artifactId>central-publishing-maven-plugin</artifactId>
                        <extensions>true</extensions>
                        <configuration>
                            <publishingServerId>central</publishingServerId>
                            <autoPublish>true</autoPublish>
                            <!-- validated: wait only for portal validation (where real errors surface), not the slow server-side publish; autoPublish completes it -->
                            <waitUntil>validated</waitUntil>
                            <!-- seconds; generous headroom for the validation poll (default 1800) -->
                            <waitMaxTime>21600</waitMaxTime>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <id>vmlens</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.vmlens</groupId>
                        <artifactId>vmlens-maven-plugin</artifactId>
                        <configuration>
                            <!--
                                Run vmlens interleaving analysis over the whole `vmlens` test
                                package: the smoke test plus the real interleaving tests (e.g.
                                KeyProducerQueueBufferedInterleavingTest). The `com.vmlens:api`
                                test dependency lives in the main <dependencies> block. Add new
                                interleaving tests to the `vmlens` package and they are picked
                                up automatically.
                            -->
                            <includes>
                                <include>**/vmlens/*.java</include>
                            </includes>
                        </configuration>
                        <executions>
                            <execution>
                                <id>vmlens-test</id>
                                <goals>
                                    <goal>test</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <id>jcstress</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>exec-maven-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>jcstress</id>
                                <phase>test</phase>
                                <goals><goal>exec</goal></goals>
                                <configuration>
                                    <executable>${java.home}/bin/java</executable>
                                    <classpathScope>test</classpathScope>
                                    <arguments>
                                        <argument>-classpath</argument>
                                        <classpath/>
                                        <argument>org.openjdk.jcstress.Main</argument>
                                        <argument>-v</argument>
                                        <argument>-m</argument>
                                        <argument>default</argument>
                                    </arguments>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <!--
                Builds the fat (jar-with-dependencies) jar for shipping the CLI.
                Off by default because the assembly step is expensive and only
                needed when packaging a runnable artifact, not during inner-loop
                builds. Documented in CLAUDE.md "Build Commands" as
                `./mvnw package -P assembly`.
            -->
            <id>assembly</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-assembly-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>build-fat-jar</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>single</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>