pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>tech.streamfusion</groupId>
    <artifactId>StreamFusion</artifactId>
    <version>${revision}</version>
    <packaging>pom</packaging>

    <name>StreamFusion</name>
    <description>Native Rust and Apache Arrow/DataFusion acceleration for Apache Flink SQL.</description>
    <url>https://streamfusion.tech/</url>

    <modules>
        <module>streamfusion-runtime</module>
        <module>streamfusion-core</module>
        <module>streamfusion-kafka</module>
        <module>streamfusion-json</module>
        <module>streamfusion-csv</module>
        <module>streamfusion-raw</module>
        <module>streamfusion-avro</module>
        <module>streamfusion-avro-confluent-registry</module>
        <module>streamfusion-protobuf</module>
        <module>streamfusion-fluss</module>
        <module>streamfusion-parquet</module>
        <module>streamfusion-loader</module>
    </modules>

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

    <developers>
        <developer>
            <name>Jordan Epstein</name>
            <email>32082339+jordepic@users.noreply.github.com</email>
            <organization>datafusion-contrib</organization>
            <organizationUrl>https://github.com/datafusion-contrib</organizationUrl>
        </developer>
    </developers>

    <scm>
        <connection>scm:git:https://github.com/datafusion-contrib/StreamFusion.git</connection>
        <developerConnection>scm:git:ssh://git@github.com/datafusion-contrib/StreamFusion.git</developerConnection>
        <url>https://github.com/datafusion-contrib/StreamFusion</url>
        <tag>HEAD</tag>
    </scm>

    <properties>
        <revision>0.1.0-rc1</revision>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit.version>5.10.2</junit.version>
        <arrow.version>18.3.0</arrow.version>
        <flink.version>2.2.1</flink.version>
        <!-- Keep the runtime Kafka client aligned with flink-connector-kafka 5.0.0-2.2. A direct
             dependency is necessary for source compilation, but pinning an older version here
             silently overrides the connector's transitive client and changes producer semantics. -->
        <kafka.clients.version>4.2.0</kafka.clients.version>
        <scala.binary.version>2.12</scala.binary.version>
        <fluss.version>0.9.1-incubating</fluss.version>
        <zookeeper.version>3.8.3</zookeeper.version>
        <!-- Matches the protobuf runtime Flink's protobuf format generates code against. -->
        <protobuf.version>4.32.1</protobuf.version>
        <delta.version>4.4.0-SNAPSHOT</delta.version>
        <!-- Native build: debug by default for a fast correctness loop. The `bench` profile flips
             both of these to a release build, which benchmarks must use (debug Rust is far slower). -->
        <native.profile>debug</native.profile>
        <!-- The full Java test suite exercises Kafka. Fluss source tests are optional local-cluster
             integration tests, enabled explicitly by adding the fluss feature to native.cargo.args.
             Deployment packaging builds a
             connector-free core and feature-specific extension DSOs separately in
             bin/build-release.sh. -->
        <native.cargo.args>build --features kafka,parquet,json,csv,raw,avro,protobuf,rocksdb-state</native.cargo.args>
        <native.build.skip>false</native.build.skip>
        <native.test.resource.skip>false</native.test.resource.skip>
        <native.resource.directory>${project.basedir}/../native/target/${native.profile}</native.resource.directory>
        <!-- Extra JVM args appended to the Surefire fork's argLine; empty by default. Used to attach a
             sampler to a profile-loop test, e.g. -Dsf.extraJvmArgs=-agentpath:.../libasyncProfiler.dylib=... -->
        <sf.extraJvmArgs></sf.extraJvmArgs>
        <sf.benchmarkJvmArgs></sf.benchmarkJvmArgs>
        <!-- Test JVM forks per core fraction: the suite is ~140 independent test classes run
             sequentially by default; class-level fork parallelism cuts wall time ~linearly.
             MiniClusters bind random ports, temp dirs come from JUnit/Files.createTempDirectory,
             and the native library loads per fork, so classes are isolated across JVMs. The
             bench profile pins this to 1: timing measurements must not share the machine. -->
        <sf.testForks>0.5C</sf.testForks>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- Arrow on the JVM is the marshalling glue this library owns: it fills the C Data
             Interface structs handed to native code and reads results back, so it ships with the
             library rather than being provided by the host. -->
        <dependency>
            <groupId>org.apache.arrow</groupId>
            <artifactId>arrow-vector</artifactId>
            <version>${arrow.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.arrow</groupId>
            <artifactId>arrow-c-data</artifactId>
            <version>${arrow.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.arrow</groupId>
            <artifactId>arrow-memory-unsafe</artifactId>
            <version>${arrow.version}</version>
            <scope>runtime</scope>
        </dependency>
        <!-- The host engine supplies coordination and SQL planning; this library plugs into a
             Flink the user already runs, so Flink is provided rather than bundled. Provided
             dependencies remain on the test classpath, so the harness still executes SQL. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- The operator test harness ships in the runtime's test artifact, which leans on shared
             test utilities from the core test artifact. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-runtime</artifactId>
            <version>${flink.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-test-utils-junit</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- StreamFusion consumes Flink's public RocksDB configuration keys and delegates JVM
             fallback state to Flink's backend. The distribution provides this artifact. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-statebackend-rocksdb</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- Provides the JUnit5 MiniClusterExtension: the SQL harness tests share one Flink mini-cluster
             per test class (redirecting getExecutionEnvironment to it) instead of booting and tearing
             down a fresh local cluster on every executeSql().collect() — the suite's dominant cost. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-test-utils</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- The native file sources plug into Flink's file source for enumeration/split assignment/
             checkpointing, so the connector is a compile-time dependency (provided at runtime by the
             Flink distribution, which bundles it). The format jars and Hadoop below stay test-only,
             used to write the baselines the native readers/writer are compared against. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-files</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- Flink owns Kafka consumption and production; StreamFusion wraps its byte-array source
             and sink with native format operators. The 5.0.0-2.2 release targets Flink 2.2.x and
             is provided at runtime by the deployment. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka</artifactId>
            <version>5.0.0-2.2</version>
            <scope>provided</scope>
        </dependency>
        <!-- The JSON format factory. Flink instantiates the original kafka+json table source during SQL
             validation (the native node replaces it only at physical-plan time), and the shallow
             fallback uses it at runtime. Provided at runtime by the Flink distribution. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-json</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- Avro format: the Confluent-Avro benchmark's row-materializing baseline
             (AvroRowDataDeserializationSchema) and its AvroSchemaConverter + Avro writer for generating
             the test data. Provided at runtime by the Flink distribution. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-avro</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- Confluent-registry Avro format: the host baseline the native avro-confluent decode is
             compared against, and the format factory Flink needs to validate an avro-confluent table
             at DDL time. Test-only — the native path fetches registry schemas over plain HTTP, so the
             shipped jar has no Confluent client dependency. Its registry client resolves from the
             Confluent repository below. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-avro-confluent-registry</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- CSV format factory. Flink validates+builds the kafka+csv table source during SQL validation
             (the native decode node replaces it at physical-plan time); the format factory must be on
             the classpath for that, like flink-json. Provided at runtime by the Flink distribution. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-csv</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-parquet</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- Flink's protobuf format: the host baseline the native protobuf decode is compared against,
             and its protoc (below) generates the message class a protobuf table names. It needs
             protobuf-java 4.x on the test classpath. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-protobuf</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>${protobuf.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- Hadoop is the filesystem/IO layer Flink's Parquet format reads and writes through; the
             Parquet baseline tests need it at runtime. (Hadoop 3.3.4 runs fine on protobuf-java 4.x.) -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>3.3.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-core</artifactId>
            <version>3.3.4</version>
            <scope>test</scope>
        </dependency>
        <!-- Kafka client classes (TopicPartition etc.) referenced by the native source's split reader.
             Provided at runtime by the Flink Kafka connector distribution, like flink-connector-kafka
             above; also used by the opt-in ingest benchmark and integration tests. -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>${kafka.clients.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>kafka</artifactId>
            <version>1.21.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>minio</artifactId>
            <version>1.21.4</version>
            <scope>test</scope>
        </dependency>
        <!-- The remote-filesystem sink test writes through Flink's own s3 filesystem (the native sink
             only encodes bytes). Discovered from the test classpath via ServiceLoader, standing in for
             the plugins/ directory of a real deployment. -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-s3-fs-hadoop</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- Apache Fluss connector classes. Main code references the public split types for the native
             proof seam; the dependency stays provided so StreamFusion does not bundle Fluss at runtime. -->
        <dependency>
            <groupId>org.apache.fluss</groupId>
            <artifactId>fluss-flink-2.2</artifactId>
            <version>${fluss.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.fluss</groupId>
            <artifactId>fluss-server</artifactId>
            <version>${fluss.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.fluss</groupId>
            <artifactId>fluss-server</artifactId>
            <version>${fluss.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.fluss</groupId>
            <artifactId>fluss-common</artifactId>
            <version>${fluss.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.fluss</groupId>
            <artifactId>fluss-rpc</artifactId>
            <version>${fluss.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.fluss</groupId>
            <artifactId>fluss-test-utils</artifactId>
            <version>${fluss.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-test</artifactId>
            <version>5.4.0</version>
            <scope>test</scope>
            <exclusions>
                <!-- Fluss 0.9.1 runs its ZooKeeper client stack at 3.8.3. Hadoop's test-only
                     transitive otherwise wins with 3.5.6 and the embedded server drops Fluss's
                     shaded client during coordinator startup. -->
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>${zookeeper.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper-jute</artifactId>
            <version>${zookeeper.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <repositories>
        <!-- Hosts io.confluent:kafka-schema-registry-client, the transitive of the test-only
             flink-avro-confluent-registry baseline above (the shipped jar doesn't touch it). -->
        <repository>
            <id>confluent</id>
            <url>https://packages.confluent.io/maven/</url>
        </repository>
    </repositories>

    <build>
        <resources>
            <resource>
                <directory>${project.basedir}/../src/main/resources</directory>
            </resource>
            <!-- The build stamp: the project version filtered into a classpath resource, compared
                 against the loaded native library's own stamp so a stale library on
                 java.library.path fails loudly instead of silently shadowing the bundled one. -->
            <resource>
                <directory>${project.basedir}/../src/main/resources-filtered</directory>
                <filtering>true</filtering>
            </resource>
            <!-- The local-development resource. The universal release profile replaces this with
                 its OS/architecture tree, while Native keeps this location as a development fallback. -->
            <resource>
                <directory>${native.resource.directory}</directory>
                <targetPath>tech/streamfusion/native</targetPath>
                <includes>
                    <include>libstreamfusion.so</include>
                    <include>libstreamfusion.dylib</include>
                </includes>
            </resource>
        </resources>
        <extensions>
            <!-- Resolves the OS classifier for the protoc binary artifact below. -->
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.7.1</version>
            </extension>
        </extensions>
        <pluginManagement>
        <plugins>
            <!-- Generates the protobuf message class a `protobuf`-format table names (and that the host
                 baseline parses with), from a test .proto, using the same protoc Flink's format uses. -->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
                </configuration>
                <executions>
                    <execution>
                        <id>generate-test-protobuf</id>
                        <phase>generate-test-sources</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- Keep normal Java edit/compile loops free of Cargo. Native code is built only
                 for test execution, while the explicit release script builds the portable
                 optimized payloads. -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.2.0</version>
                <executions>
                    <execution>
                        <id>build-native</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <configuration>
                            <skip>${native.build.skip}</skip>
                            <executable>cargo</executable>
                            <workingDirectory>${project.basedir}/../native</workingDirectory>
                            <commandlineArgs>${native.cargo.args}</commandlineArgs>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- test-compile builds the debug DSO after Maven's normal resource phase. Copy it only
                 then, so `mvn compile` stays Java-only while tests exercise the same bundled fallback
                 that a packaged debug artifact will contain. -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.3.1</version>
                <executions>
                    <execution>
                        <id>copy-test-native-resource</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>copy-resources</goal>
                        </goals>
                        <configuration>
                            <skip>${native.test.resource.skip}</skip>
                            <outputDirectory>${project.build.outputDirectory}</outputDirectory>
                            <resources>
                                <resource>
                                    <directory>${native.resource.directory}</directory>
                                    <targetPath>tech/streamfusion/native</targetPath>
                                    <includes>
                                        <include>libstreamfusion.so</include>
                                        <include>libstreamfusion.dylib</include>
                                    </includes>
                                </resource>
                            </resources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- Tests load the library by name, so point the loader at cargo's output dir
                 rather than packaging it into a jar at this stage. -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.2.5</version>
                <configuration>
                    <!-- Arrow's off-heap allocator and Flink's runtime both reach into JDK
                         internals that are sealed by default on JDK 17.
                         arrow.enable_unsafe_memory_access / enable_null_check_for_get turn off
                         Arrow's per-accessor bounds + refcount checks (Comet/Spark run with these):
                         profiling the row<->Arrow transpose showed ~1/3 of native CPU was those
                         checks (ArrowBuf.checkIndex/ensureAccessible/refCnt on every setSafe). -->
                    <forkCount>${sf.testForks}</forkCount>
                    <reuseForks>true</reuseForks>
                    <argLine>-Xmx8g -Djava.library.path=${project.basedir}/../native/target/${native.profile} -Dstreamfusion.native.development=true -Darrow.enable_unsafe_memory_access=true -Darrow.enable_null_check_for_get=false --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED ${sf.extraJvmArgs} ${sf.benchmarkJvmArgs}</argLine>
                </configuration>
            </plugin>
            <!-- The thin artifact remains useful to applications that manage dependencies themselves.
                 The attached runtime artifact is the self-contained payload embedded by the Flink loader. -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.3</version>
                <executions>
                    <execution>
                        <id>attach-runtime-payload</id>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <shadedArtifactAttached>true</shadedArtifactAttached>
                            <shadedClassifierName>runtime</shadedClassifierName>
                            <createDependencyReducedPom>false</createDependencyReducedPom>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
        </pluginManagement>
    </build>

    <profiles>
        <!-- Central releases are deliberately opt-in. The tag-driven release workflow activates
             this profile after assembling the universal native payload. -->
        <profile>
            <id>release</id>
            <properties>
                <!-- A dry-run tag overrides these defaults so Central validates the identical
                     signed bundle but leaves it unpublished. -->
                <central.autoPublish>true</central.autoPublish>
                <central.waitUntil>published</central.waitUntil>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>flatten-maven-plugin</artifactId>
                        <version>1.6.0</version>
                        <configuration>
                            <flattenMode>resolveCiFriendliesOnly</flattenMode>
                            <updatePomFile>true</updatePomFile>
                        </configuration>
                        <executions>
                            <execution>
                                <id>flatten-release-pom</id>
                                <phase>process-resources</phase>
                                <goals><goal>flatten</goal></goals>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-source-plugin</artifactId>
                        <version>3.3.1</version>
                        <configuration>
                            <!-- Native libraries belong only in the executable JARs. Maven otherwise
                                 copies the universal resource tree into every sources attachment. -->
                            <excludeResources>true</excludeResources>
                        </configuration>
                        <executions>
                            <execution>
                                <id>attach-sources</id>
                                <goals><goal>jar-no-fork</goal></goals>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-javadoc-plugin</artifactId>
                        <version>3.11.2</version>
                        <configuration>
                            <doclint>none</doclint>
                            <quiet>true</quiet>
                        </configuration>
                        <executions>
                            <execution>
                                <id>attach-javadocs</id>
                                <goals><goal>jar</goal></goals>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-gpg-plugin</artifactId>
                        <version>3.2.8</version>
                        <configuration>
                            <gpgArguments>
                                <arg>--pinentry-mode</arg>
                                <arg>loopback</arg>
                            </gpgArguments>
                        </configuration>
                        <executions>
                            <execution>
                                <id>sign-release-artifacts</id>
                                <phase>verify</phase>
                                <goals><goal>sign</goal></goals>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.sonatype.central</groupId>
                        <artifactId>central-publishing-maven-plugin</artifactId>
                        <version>0.11.0</version>
                        <extensions>true</extensions>
                        <configuration>
                            <publishingServerId>central</publishingServerId>
                            <autoPublish>${central.autoPublish}</autoPublish>
                            <waitUntil>${central.waitUntil}</waitUntil>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <!--
          Flink's source tree compiles the table planner against unshaded Calcite, while the
          published planner artifact bundles Calcite under relocated package names. The upstream
          suite harness replaces only that planner artifact in an isolated Maven repository and
          activates this profile so StreamFusion is compiled against the same source-tree ABI.
        -->
        <profile>
            <id>flink-source-suite</id>
            <activation>
                <property>
                    <name>streamfusion.flink-source-suite</name>
                </property>
            </activation>
            <dependencies>
                <!-- Flink's parser carries its patched Calcite classes (for example VARIANT).
                     Keep it before vanilla calcite-core on the source-suite classpath. -->
                <dependency>
                    <groupId>org.apache.flink</groupId>
                    <artifactId>flink-sql-parser</artifactId>
                    <version>${flink.version}</version>
                    <scope>provided</scope>
                </dependency>
                <dependency>
                    <groupId>org.apache.flink</groupId>
                    <artifactId>flink-table-calcite-bridge</artifactId>
                    <version>${flink.version}</version>
                    <scope>provided</scope>
                </dependency>
                <dependency>
                    <groupId>org.apache.calcite</groupId>
                    <artifactId>calcite-core</artifactId>
                    <version>1.36.0</version>
                    <scope>provided</scope>
                </dependency>
            </dependencies>
            <build>
                <plugins>
                    <!-- The source-suite harness installs StreamFusion into an isolated Maven
                         repository, then resolves it from a standalone classpath POM. Publish
                         resolved CI-friendly versions there so ${revision} does not leak into
                         the installed parent relationship. -->
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>flatten-maven-plugin</artifactId>
                        <version>1.6.0</version>
                        <configuration>
                            <flattenMode>resolveCiFriendliesOnly</flattenMode>
                            <updatePomFile>true</updatePomFile>
                        </configuration>
                        <executions>
                            <execution>
                                <id>flatten-flink-source-suite-pom</id>
                                <phase>process-resources</phase>
                                <goals>
                                    <goal>flatten</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <!-- Build and load the production native library. The allocator feature is part of the
             measured default: it removes the cross-thread allocation bottleneck in the native
             Kafka path and also reduces native state churn. -->
        <profile>
            <id>bench</id>
            <properties>
                <sf.testForks>1</sf.testForks>
                <!-- Model a deployable shuffle: Flink serializes records even across a local
                     network edge, so StreamFusion must pay Arrow IPC rather than replacing the
                     record with a same-JVM process-global handle. -->
                <sf.benchmarkJvmArgs>-Dstreamfusion.exchange.zeroCopyLocal=false</sf.benchmarkJvmArgs>
                <native.profile>release</native.profile>
                <native.cargo.args>build --release --features mimalloc,kafka,parquet,json,csv,raw,avro,protobuf,rocksdb-state</native.cargo.args>
            </properties>
        </profile>
        <!-- Produces the deployable, performance-oriented runtime payload. Callers may override
             native.cargo.args for a deliberately smaller development build or to add test features. -->
        <profile>
            <id>dist</id>
            <properties>
                <native.profile>release</native.profile>
                <native.cargo.args>build --release --no-default-features --features mimalloc,rocksdb-state</native.cargo.args>
            </properties>
        </profile>
        <!-- Packages the resource tree staged by bin/build-release.sh. It deliberately does not
             invoke cargo: the script has already built each supported target in its own environment. -->
        <profile>
            <id>universal</id>
            <properties>
                <native.build.skip>true</native.build.skip>
                <native.resource.directory>${project.basedir}/../native/target/no-local-payload</native.resource.directory>
            </properties>
            <build>
                <resources>
                    <resource>
                        <directory>${project.basedir}/../native/target/universal</directory>
                        <targetPath>tech/streamfusion/native</targetPath>
                        <includes>
                            <include>**/libstreamfusion.so</include>
                            <include>**/libstreamfusion.dylib</include>
                        </includes>
                    </resource>
                </resources>
            </build>
        </profile>
        <!-- The image test creates Docker containers, so keep its fixture module out of the normal
             unit-test reactor. It is selected explicitly with -Pimage-it. -->
        <profile>
            <id>image-it</id>
            <modules>
                <module>streamfusion-image-it</module>
            </modules>
        </profile>
        <!-- Delta's Flink connector is still an unpublished private build. Keep its optional
             acceleration module out of the default reactor until the normal connector artifact is
             publicly resolvable; local Delta development enables it with -Pdelta after publishM2. -->
        <profile>
            <id>delta</id>
            <modules>
                <module>streamfusion-delta</module>
            </modules>
        </profile>
    </profiles>

</project>