Weave the model. The weaver rewrites Counter.class so that every write to a @Bind field calls a synthesized setter that notifies. It is one jar with no dependencies and a main that takes a directory of classes. The task needs the classes and everything they were compiled against, because it regenerates stack-map frames (Model weaving).

configurations { goldberryWeaver }
dependencies { goldberryWeaver 'dev.goldberry:goldberry-weaver' }

def weaveModels = tasks.register('weaveModels', JavaExec) {
    dependsOn tasks.compileJava
    def classes = tasks.compileJava.flatMap { it.destinationDirectory }
    classpath = files(configurations.goldberryWeaver, classes, sourceSets.main.compileClasspath)
    mainClass = 'dev.goldberry.weaver.WeaverMain'
    argumentProviders.add({ ['--models', classes.get().asFile.absolutePath] } as CommandLineArgumentProvider)
    inputs.dir(classes)
    outputs.file(layout.buildDirectory.file('tmp/weaveModels/stamp'))
    outputs.upToDateWhen { false }
    doLast { layout.buildDirectory.file('tmp/weaveModels/stamp').get().asFile.text = 'woven' }
}
tasks.named('jar') { mustRunAfter weaveModels }

The weaver’s version comes from the BOM, like every other artifact. The stamp file is deliberate: declaring the compiler’s own output directory as this task’s output makes Gradle recompile the whole module on every build (ADR-0398).

Declare your resources. The document and the stylesheet are read by name at run time, and a trace only records what one run happened to touch. Globs are finite (ADR-0160). The file goes in a directory the agent never writes to, so a new trace cannot overwrite it:

src/main/resources/META-INF/native-image/com.example/hello-manual/reachability-metadata.json

{
  "resources": [
    { "module": "com.example.hello", "glob": "com/example/hello/*.kdl" },
    { "module": "com.example.hello", "glob": "com/example/hello/*.css" },
    { "glob": "dev/goldberry/natives/**" }
  ]
}

The last line is the native library itself. It lives in the classifier jar, which the image carries as a class-path resource and unpacks to a temporary file on first use (ADR-0159).

Trace one run. What the toolkit’s jars cannot declare is what depends on your run: the service the widget catalogue is found through, the upcall stubs the native code calls back into, the JDK’s text resources, and whatever your logging configuration reflects over. GraalVM’s agent records them. Run the woven application once, headless, for a hundred frames, and keep the output under src/main/resources so it is reviewed in a diff (ADR-0156):

tasks.register('nativeImageMetadata', Exec) {
    dependsOn weaveModels, tasks.jar
    def output = layout.projectDirectory.dir('src/main/resources/META-INF/native-image/com.example/hello')
    doFirst {
        def split = splitPaths()
        def command = ["${System.getenv('GRAALVM_HOME')}/bin/java",
                '--enable-native-access=dev.goldberry.natives',
                "-agentlib:native-image-agent=config-output-dir=${output.asFile.absolutePath}",
                '-Dgoldberry.backend.videoDriver=dummy']
        if (System.getProperty('os.name').toLowerCase().contains('mac')) {
            command += '-XstartOnFirstThread'
        }
        command += ['--module-path', split.modules, '-cp', split.natives,
                '--module', 'com.example.hello/com.example.hello.Hello', '--frames=120']
        commandLine command
    }
}

splitPaths is a small helper, used by both tasks. The natives classifier jars hold no classes and no module descriptor, so they go on the class path rather than the module path, where four jars would derive one and the same automatic module name:

def splitPaths = {
    def jars = configurations.runtimeClasspath.files
    def natives = jars.findAll { it.name.startsWith('goldberry-natives-') && it.name =~ /-(linux|macos|windows)-/ }
    def modules = (jars - natives) + [tasks.jar.archiveFile.get().asFile]
    [modules: modules*.absolutePath.join(File.pathSeparator), natives: natives*.absolutePath.join(File.pathSeparator)]
}

The agent writes reachability-metadata.json beside your manual one. native-image reads every META-INF/native-image/** it finds, so the two are merged for the tool and kept apart for you.

Build the image.

tasks.register('nativeImage', Exec) {
    dependsOn weaveModels, tasks.jar
    def target = layout.buildDirectory.file('native/hello')
    doFirst {
        def split = splitPaths()
        commandLine "${System.getenv('GRAALVM_HOME')}/bin/native-image",
                '--module-path', split.modules,
                '-cp', split.natives,
                '--module', 'com.example.hello/com.example.hello.Hello',
                '-o', target.get().asFile.absolutePath,
                '--enable-native-access=dev.goldberry.natives',
                '-H:+ReportExceptionStackTraces'
    }
}

./gradlew nativeImageMetadata nativeImage
./build/native/hello

The result is one file. No launcher, no lib/ directory, nothing to set.