Refactor rebuild policy into lifecycle plugin

Introduces a new `JarLifecycleListener` service hook in bndlib and wires `Project` to call listeners before/after JAR writes, replacing the in-core rebuild trigger policy logic. The old `Workspace` rebuild policy state and related `Constants` entries are removed, and the service package version is bumped to 4.11.0.

Bndtools now owns rebuild-trigger behavior via `RebuildTriggerPolicy` and `RebuildTriggerPolicyPlugin`, which are registered from `Central.applyRebuildTriggerPolicy()` based on preferences. Preference/UI/explorer code is updated to use the new policy constants, and tests that depended on `Workspace#setRebuildTriggerPolicy` are temporarily commented with TODO markers.

Add rebuild trigger policy plugin tests

Move content-hash/API-digest rebuild behavior tests out of `ProjectTest` into a new `bndtools.core` test suite that exercises `RebuildTriggerPolicyPlugin` with dedicated workspace testdata. Add `ProjectTest` coverage for `JarLifecycleListener` integration, verifying `beforeWrite`/`afterWrite` invocation and shared context data flow. Also wire `biz.aQute.bnd.test` into `bndtools.core` testpath and remove stale commented cleanup lines.

Signed-off-by: Christoph Rueger <chrisrueger@gmail.com>

Author: chrisrueger

biz.aQute.bndlib.tests/test/test/ProjectTest.java

@@ -18,7 +18,10 @@
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.jar.Manifest;
 import java.util.regex.Pattern;
 
@@ -39,6 +42,7 @@
 import aQute.bnd.osgi.Processor;
 import aQute.bnd.osgi.Resource;
 import aQute.bnd.osgi.eclipse.EclipseClasspath;
+import aQute.bnd.service.JarLifecycleListener;
 import aQute.bnd.service.RepositoryPlugin;
 import aQute.bnd.service.Strategy;
 import aQute.bnd.test.jupiter.InjectTemporaryDirectory;
@@ -547,181 +551,73 @@ private void stale(Project project, boolean b) throws Exception {
 	}
 
 	/**
-	 * Check that the content-hash optimization prevents unnecessary JAR
-	 * rewrites when the JAR content is unchanged between builds. This avoids
-	 * cascading rebuilds of dependent projects.
+	 * Verify that JarArtifactLifecycleListener plugins are called at the right
+	 * times.
 	 */
 	@Test
-	public void testContentHashSkipsBuildWhenUnchanged() throws Exception {
+	public void testJarArtifactLifecycleListenerIntegration() throws Exception {
 		Workspace ws = getWorkspace(IO.getFile("testresources/ws"));
-		ws.setRebuildTriggerPolicy("api");
 		Project project = ws.getProject("p-stale");
 		assertNotNull(project);
 
-		// First build - should create JAR and digest files
-		File[] firstBuild = project.build();
-		assertNotNull(firstBuild);
-		assertTrue(firstBuild.length > 0);
-
-		File jarFile = firstBuild[0];
-		assertTrue(jarFile.isFile());
-		long firstTimestamp = jarFile.lastModified();
-
-		// Verify digest file was created
-		File digestFile = getDigestFile(jarFile);
-		assertTrue(digestFile.isFile(), "Digest file should be created after build");
-		String firstDigest = IO.collect(digestFile)
-			.trim();
-		assertFalse(firstDigest.isEmpty(), "Digest should not be empty");
-
-		// Simulate time passing by adjusting the JAR timestamp backward,
-		// then mark the project as changed. If the optimization works
-		// correctly, the JAR's timestamp will be restored to this value
-		// since the content hasn't changed.
-		long adjustedTimestamp = firstTimestamp - 10000;
-		jarFile.setLastModified(adjustedTimestamp);
-
-		// Mark project as changed so it rebuilds
-		project.setChanged();
-		project.refresh();
-
-		// Second build - content is unchanged, JAR timestamp should be
-		// preserved
-		File[] secondBuild = project.build();
-		assertNotNull(secondBuild);
-		assertTrue(secondBuild.length > 0);
-
-		File jarFile2 = secondBuild[0];
-		assertTrue(jarFile2.isFile());
-
-		// The JAR timestamp should be preserved since content didn't change
-		assertEquals(adjustedTimestamp, jarFile2.lastModified(),
-			"JAR timestamp should be preserved when content is unchanged");
-
-		// Digest file should still exist with the same content
-		assertTrue(digestFile.isFile());
-		String secondDigest = IO.collect(digestFile)
-			.trim();
-		assertEquals(firstDigest, secondDigest, "Digest should be unchanged");
-	}
+		// Register a mock listener to verify it's called
+		AtomicBoolean beforeCalled = new AtomicBoolean();
+		AtomicBoolean afterCalled = new AtomicBoolean();
 
-	/**
-	 * Check that when JAR content actually changes, the JAR is rewritten and
-	 * the digest is updated.
-	 */
-	@Test
-	public void testContentHashRewritesWhenChanged() throws Exception {
-		Workspace ws = getWorkspace(IO.getFile("testresources/ws"));
-		ws.setRebuildTriggerPolicy("api");
-		Project project = ws.getProject("p-stale");
-		assertNotNull(project);
+		JarLifecycleListener mockListener = new JarLifecycleListener() {
+			@Override
+			public void beforeWrite(Project p, Jar jar, File outputFile, Map<String, Object> context) {
+				beforeCalled.set(true);
+			}
 
-		// First build
-		File[] firstBuild = project.build();
-		assertNotNull(firstBuild);
-		File jarFile = firstBuild[0];
-		File digestFile = getDigestFile(jarFile);
-		assertTrue(digestFile.isFile());
-		String firstDigest = IO.collect(digestFile)
-			.trim();
-
-		// Change the project content so the JAR will be different
-		project.setChanged();
-		project.refresh();
-		project.setProperty("Include-Resource", "p;literal=\"changed content\"");
-
-		// Second build - content changed, JAR should be rewritten
-		File[] secondBuild = project.build();
-		assertNotNull(secondBuild);
-		File jarFile2 = secondBuild[0];
-
-		// Digest should have changed
-		assertTrue(digestFile.isFile());
-		String secondDigest = IO.collect(digestFile)
-			.trim();
-		assertThat(secondDigest).as("Digest should change when content changes")
-			.isNotEqualTo(firstDigest);
-	}
+			@Override
+			public void afterWrite(Project p, File outputFile, Jar jar, Map<String, Object> context) {
+				afterCalled.set(true);
+			}
+		};
 
-	private static File getDigestFile(File jarFile) {
-		return new File(jarFile.getParentFile(), jarFile.getName() + ".digest");
+		ws.addBasicPlugin(mockListener);
+
+		// Build
+		File[] built = project.build();
+		assertNotNull(built);
+		assertThat(built.length).isGreaterThan(0);
+
+		// Verify listeners were called
+		assertThat(beforeCalled).isTrue();
+		assertThat(afterCalled).isTrue();
 	}
 
 	/**
-	 * Check that the JAR timestamp is preserved when the content changes
-	 * Verify that the JAR's timestamp is preserved when the JAR content
-	 * changes but the exported API surface remains identical. The
-	 * optimization works by comparing a stored API-digest sidecar file
-	 * with the newly computed API digest during build. When they match,
-	 * the old file timestamp is kept so that downstream timestamp-based
-	 * staleness checks don't trigger unnecessary cascade rebuilds.
-	 * <p>
-	 * Since the p-stale test project is {@code -resourceonly} (no
-	 * exported packages), this test simulates the mechanism directly:
-	 * we write a known API digest, change the project content so the
-	 * full content digest changes, and verify that timestamp
-	 * preservation still engages via the API digest fallback.
+	 * Verify that WriteContext is passed correctly and allows data exchange.
 	 */
 	@Test
-	public void testApiDigestPreservesTimestampWhenApiUnchanged() throws Exception {
+	public void testJarArtifactWriteContextDataExchange() throws Exception {
 		Workspace ws = getWorkspace(IO.getFile("testresources/ws"));
-		ws.setRebuildTriggerPolicy("api");
 		Project project = ws.getProject("p-stale");
-		assertNotNull(project);
 
-		// First build — establishes the baseline JAR and digest files
-		File[] firstBuild = project.build();
-		assertNotNull(firstBuild);
-		assertTrue(firstBuild.length > 0);
-
-		File jarFile = firstBuild[0];
-		assertTrue(jarFile.isFile());
-
-		// Record the old timestamp and adjust it to simulate time
-		long adjustedTimestamp = jarFile.lastModified() - 10000;
-		jarFile.setLastModified(adjustedTimestamp);
-
-		// The content digest from the first build
-		File digestFile = getDigestFile(jarFile);
-		assertTrue(digestFile.isFile(), "Content digest file should exist after build");
-
-		// Write a fake API digest sidecar. The next build will produce
-		// the same resource-only bundle (no Export-Package), so
-		// calcApiDigest() returns null. However, when we change the
-		// project content the content digest will differ. To simulate
-		// the API-digest-unchanged path, we need a non-null API digest.
-		// We'll change the content, then verify the mechanism by
-		// checking the timestamp. Since calcApiDigest returns null for
-		// resource-only bundles, the API digest path won't engage here,
-		// but we can verify the infrastructure is correctly wired:
-		// the API digest file should remain from the first build if no
-		// new one is computed.
-		File apiDigestFile = new File(jarFile.getParentFile(), jarFile.getName() + ".api-digest");
-
-		// Change the project content so the JAR will differ
-		project.setChanged();
-		project.refresh();
-		project.setProperty("Include-Resource", "p;literal=\"changed content\"");
-
-		// Rebuild — content changed so content digest differs, and
-		// calcApiDigest returns null for resource-only bundles. The
-		// timestamp should NOT be preserved (no API digest fallback).
-		File[] secondBuild = project.build();
-		assertNotNull(secondBuild);
-
-		File jarFile2 = secondBuild[0];
-		// Content changed so the digest should differ
-		String newDigest = IO.collect(digestFile).trim();
-		// The JAR should have a new timestamp since both content and
-		// API digests indicate a change (or API digest is absent)
-		assertThat(jarFile2.lastModified())
-			.as("Timestamp should NOT be preserved when content changes and no API digest exists")
-			.isNotEqualTo(adjustedTimestamp);
-
-		// The content digest file should still exist
-		assertTrue(digestFile.isFile(), "Content digest file should exist after rebuild");
+		AtomicReference<String> beforeData = new AtomicReference<>();
+		AtomicReference<String> afterData = new AtomicReference<>();
+
+		JarLifecycleListener testListener = new JarLifecycleListener() {
+			@Override
+			public void beforeWrite(Project p, Jar jar, File outputFile, Map<String, Object> context) {
+				context.put("testKey", "testValue");
+			}
+
+			@Override
+			public void afterWrite(Project p, File outputFile, Jar jar, Map<String, Object> context) {
+				afterData.set((String) context.get("testKey"));
+			}
+		};
+
+		ws.addBasicPlugin(testListener);
+		project.build();
+
+		assertThat(afterData.get()).isEqualTo("testValue");
 	}
 
+
 	/**
 	 * Check multiple repos
 	 *