implab/gradle-common Commit - r61:9b11838beca6

Keep contribution-based assemblies on managed Sync tasks, register direct producers through ArtifactAssemblyRegistry, wire builtBy on outgoing artifacts, and cover the behavior with functional tests.

cin -

r61:9b11838beca6 default

parent child

Context file:

r61:9b11838beca6

Collapse all files

README.md +10 0

             # gradle-common
             Java 21 multi-project build with shared Gradle utilities and experimental
             variant-oriented Gradle plugins.
             The repository currently publishes to a local Ivy repository only. Maven Central
             and Gradle Plugin Portal publication are intentionally not configured yet.
             ## Modules
             - `common` - shared Gradle utilities, JSON helpers, shell execution helpers, and
               small core value/util classes.
             - `variants` - Gradle plugins for variant topology, source-set materialization,
               and outgoing artifact slots.
             ## Requirements
             - JDK 21.
             - Gradle Wrapper from this repository, currently Gradle 8.10.2.
             The produced bytecode targets Java 21.
             ## License
             This project is licensed under the BSD 2-Clause "Simplified" License
             (`BSD-2-Clause`). See [LICENSE](LICENSE).
             ## Local Build
             ```bash
             ./gradlew clean check javadoc jar sourcesJar javadocJar --rerun-tasks
             ```
             Configuration cache smoke check:
             ```bash
             ./gradlew check --configuration-cache
             ```
             ## Local Ivy Publication
             The current publication target is:
             ```text
             ${user.home}/ivy-repo
             ```
             Publish both modules locally:
             ```bash
             ./gradlew :common:publishIvyPublicationToIvyRepository \
                       :variants:publishIvyPublicationToIvyRepository
             ```
             or:
             ```bash
             ./gradlew publish
             ```
             The publication includes:
             - main jar
             - sources jar
             - javadoc jar
             - Ivy descriptor
             - Gradle module metadata
             ## Local Consumption
             Current plugin ids are packaged as classic Gradle plugin marker resources inside
             the `variants` jar:
             - `org.implab.gradle-variants`
             - `org.implab.gradle-sources`
             - `org.implab.gradle-variants-sources`
             - `org.implab.gradle-variants-artifacts`
             Until Gradle Plugin Portal marker artifacts are configured, consume the plugin
             through `buildscript` classpath:
             ```groovy
             buildscript {
                 repositories {
                     ivy {
                         url "${System.properties['user.home']}/ivy-repo"
                     }
                     mavenCentral()
                 }
                 dependencies {
                     classpath 'org.implab.gradle:variants:0.1.0'
                 }
             }
             apply plugin: 'org.implab.gradle-variants'
             apply plugin: 'org.implab.gradle-variants-sources'
             ```
             The `plugins { id(...) version(...) }` DSL is not part of the current local Ivy
             contract.
             ## Variants DSL
             `variants` defines the finalized build topology. It does not create compile
             tasks, source directories, or outgoing publications by itself.
             ```groovy
             apply plugin: 'org.implab.gradle-variants'
             variants.layers.create('main')
             variants.layers.create('test')
             variants.roles.create('main')
             variants.roles.create('test')
             variants.variant('browser') {
                 role('main') {
                     layers('main')
                 }
                 role('test') {
                     layers('main', 'test')
                 }
             }
             variants.whenFinalized { view ->
                 println view.entries.collect {
                     "${it.variant().name}:${it.role().name}:${it.layer().name}"
                 }.sort()
             }
             ```
             The finalized model exposes cheap identity objects: `Variant`, `Role`, `Layer`,
             and the normalized relation `(variant, role, layer)`.
             ## Sources DSL
             `sources` creates standalone `GenericSourceSet` objects. This is useful for
             fallback workflows that do not need variant topology.
             ```groovy
             apply plugin: 'org.implab.gradle-sources'
             sources.create('main') {
                 declareOutputs('js')
                 registerOutput('js', layout.projectDirectory.file('inputs/main.js'))
                 sets.create('ts') {
                     srcDir 'src/main/ts'
                 }
             }
             ```
             `SourcesPlugin` applies layout conventions:
             - `sourceSetDir = src/<sourceSet>`
             - `outputsDir = build/out/<sourceSet>`
             The base `GenericSourceSet` model itself is convention-free.
             ## Variant Sources DSL
             `variantSources` derives compile units from finalized `variants`.
             A compile unit is:
             ```text
             (variant, layer)
             ```
             Selectors configure materialized compile-unit source sets:
             ```groovy
             apply plugin: 'org.implab.gradle-variants-sources'
             variants.layers.create('main')
             variants.roles.create('main')
             variants.variant('browser') {
                 role('main') {
                     layers('main')
                 }
             }
             variantSources {
                 layer('main') {
                     sourceSet {
                         declareOutputs('js')
                         registerOutput('js', layout.projectDirectory.file('inputs/browser.js'))
                     }
                 }
                 configureEach {
                     println "sourceSet=${sourceSet.name}, variant=${variant.name}, layer=${layer.name}"
                 }
             }
             ```
             Selector order for future materialization is:
             ```text
             configureEach -> variant -> layer -> unit
             ```
             Late selector registration is controlled by:
             ```groovy
             variantSources {
                 lateConfigurationPolicy {
                     failOnLateConfiguration()
                 }
             }
             ```
             Compile-unit source set names are generated by default as:
             ```text
             <variant> + capitalize(<layer>)
             ```
             Name collisions fail by default and may be resolved deterministically:
             ```groovy
             variantSources {
                 namingPolicy {
                     resolveNameCollision()
                 }
             }
             ```
             ## Variant Artifacts DSL
             `variantArtifacts` is an experimental outgoing artifact layer over `variants`
             and `variantSources`.
             The current model maps:
             - `Variant` to a variant-level consumable outgoing configuration.
             - `Slot` to a Gradle outgoing artifact variant inside that configuration.
             - `primarySlot` to the primary artifact set of the outgoing configuration.
             ```groovy
             apply plugin: 'org.implab.gradle-variants-artifacts'
             variants.layers.create('main')
             variants.roles.create('main')
             variants.variant('browser') {
                 role('main') {
                     layers('main')
                 }
             }
             variantSources.layer('main') {
                 sourceSet {
                     declareOutputs('types', 'js')
                     registerOutput('types', layout.projectDirectory.file('inputs/index.d.ts'))
                     registerOutput('js', layout.projectDirectory.file('inputs/index.js'))
                 }
             }
             variantArtifacts {
                 variant('browser') {
                     primarySlot('typesPackage') {
                         fromVariant {
                             output('types')
                         }
                     }
                     slot('js') {
                         fromVariant {
                             output('js')
                         }
                     }
                 }
                 whenOutgoingConfiguration { publication ->
                     publication.configuration {
                         description = "Outgoing contract for ${publication.variant.name}"
                     }
                 }
                 whenOutgoingSlot { publication ->
                     println "slot=${publication.artifactSlot.slot.name}, primary=${publication.primary}"
                 }
             }
             ```
+            Slot bodies have two assembly modes:
+            - contribution-based assembly with `from(...)`, `fromVariant(...)`,
+              `fromRole(...)`, or `fromLayer(...)`; the plugin copies selected inputs into a
+              managed directory and publishes that directory;
+            - task-produced assembly with `producedBy(task) { outputFile }`; the mapped task
+              output file or directory is published directly.
+            These modes are mutually exclusive for one slot.
             The artifact API is still considered pre-1.0 and may change.
             ## Publication Status
             Current status:
             - local Ivy publication only
             - no Maven Central publication metadata
             - no signing
             - no Gradle Plugin Portal marker artifacts
             - BSD-2-Clause license committed
             Before external publication, see [RELEASE_CHECKLIST.md](RELEASE_CHECKLIST.md).

variant_artifacts.md +14 -2

             # Variants and Variant Artifacts
             > Design note. The current user-facing DSL and local publication workflow are
             > documented in [README.md](README.md). Some snippets below are conceptual and
             > describe model direction rather than exact public API.
             ## Overview
             This document describes the artifact model built on top of `variants` and
             `variantSources`.
             The goal is to define:
             - a stable artifact-facing model for outgoing contracts;
             - a DSL for declaring slots and their inputs;
             - a resolver bridge between `variantArtifacts` and `variantSources`;
             - extension points for deduplication and similar policies;
             - a model that remains live during configuration and does not require an
               artificial freeze of slot content.
             The design follows the same split already used elsewhere:
             - `variants` defines the closed domain topology;
             - `variantSources` defines source materialization semantics over that topology;
             - `variantArtifacts` defines outgoing artifact contracts over that topology.
             ---
             ## Core idea
             `variantArtifacts` is not the owner of the variant model and not the owner of
             source-set materialization.
             Its purpose is narrower:
             - decide which variants participate in outgoing publication;
             - define artifact slots for those outgoing variants;
             - declare how each slot gathers its inputs.
             This makes `variantArtifacts` an outgoing-contract layer, not a compilation or
             source-materialization layer.
             ---
             ## Model boundaries
             ### What belongs to `variants`
             - identities: `Variant`, `Role`, `Layer`;
             - normalized topology relation `(variant, role, layer)`;
             - finalization of the core domain model;
             - `VariantsView` and derived topology views.
             ### What belongs to `variantSources`
             - compile units and role projections derived from finalized `variants`;
             - source-set naming policy;
             - source-set materialization;
             - lazy access to `GenericSourceSet` providers and their named outputs.
             ### What belongs to `variantArtifacts`
             - selection of outgoing variants;
             - slot identities inside an outgoing variant;
             - slot assembly declarations;
             - root outgoing configurations for outgoing variants;
             - slot-level assembly bodies;
             - publication-facing hooks.
             ### What does not belong to `variantArtifacts`
             - ownership of variant existence;
             - ownership of source-set naming;
             - direct mutation of source materialization internals;
             - compiler- or toolchain-specific logic;
             - eager flattening of source inputs into files during DSL declaration.
             ---
             ## Outgoing subset
             Not every declared `Variant` must become outgoing.
             `variantArtifacts` defines an outgoing subset of variants.
             For each outgoing variant there is one root outgoing aggregate:
             - one root consumable `Configuration`;
             - one or more artifact slots;
             - one primary slot;
             - optional secondary slots.
             This is why `OutgoingConfiguration` is a real model object and not merely a
             publication event payload.
             It represents a live build-facing aggregate:
             - it has its own attributes;
             - it is visible to other build logic as soon as registered;
             - it contains lazy handles rather than eagerly materialized state;
             - it is distinct from slot assembly state.
             ---
             ## Identity-first split
             The artifact model should preserve the same identity-first principle used for
             the rest of the project.
             ### Identity objects
             - `Variant`
             - `Slot`
             - `ArtifactSlot = (variant, slot)`
             These objects are:
             - cheap;
             - replayable;
             - suitable for discovery and selection.
             ### Stateful objects
             - `OutgoingConfiguration`
             - `ArtifactAssembly`
             These objects are:
             - build-facing;
             - allowed to contain Gradle lazy handles;
             - obtained through dedicated APIs rather than embedded into identity objects.
             ### Rule of thumb
             - slot identity is cheap and replayable;
             - inside one `OutgoingConfiguration`, `Slot` is the natural local identity;
             - `ArtifactSlot` is useful when slot identity must be referenced outside the
               parent outgoing configuration;
             - slot body is stateful and resolved separately;
             - outgoing configuration is a live aggregate, not a mere snapshot.
             ---
             ## Artifact model
             Conceptually:
             ```java
             interface VariantArtifactsContext {
                 VariantsView getVariants();
                 void all(Action<? super OutgoingConfiguration> action);
                 Optional<OutgoingConfiguration> findArtifacts(Variant variant);
                 OutgoingConfiguration requireArtifacts(Variant variant);
                 ArtifactAssemblies getAssemblies();
             }
             ```
             ```java
             interface OutgoingConfiguration {
                 Variant getVariant();
                 NamedDomainObjectProvider<Configuration> getOutgoingConfiguration();
                 NamedDomainObjectContainer<Slot> getSlots();
                 Property<Slot> getPrimarySlot();
             }
             ```
             ```java
             interface ArtifactAssemblies {
                 ArtifactAssembly resolveSlot(ArtifactSlot slot);
             }
             ```
             This intentionally uses a Gradle-style local slot container rather than a
             separate `ArtifactSlotsView`.
             The reason is simple:
             - inside one `OutgoingConfiguration`, slot identity is local and naturally
               expressed as `Slot`;
             - a dedicated `ArtifactSlotsView` would suggest a detached readonly projection
               without clearly owning mutation/configuration semantics;
             - `NamedDomainObjectContainer<Slot>` better matches the live configuration model
               and keeps the parent aggregate as the owner of slot structure.
             `ArtifactSlot` remains useful, but only as a fully qualified identity outside
             the parent aggregate:
             - resolver APIs;
             - global payloads;
             - cross-variant references.
             Important distinction:
             - `OutgoingConfiguration` describes outgoing publication structure;
             - `ArtifactAssembly` describes how one slot artifact is assembled.
             An `ArtifactAssembly` does not create the root outgoing configuration. It serves
             one already declared slot inside that configuration.
             ### Primary slot ownership
             Primary status belongs to the parent outgoing configuration, not to the slot
             itself.
             This is why the preferred container-level contract is:
             ```java
             Property<Slot> getPrimarySlot();
             ```
             and not a slot-local boolean or a derived `ArtifactSlot` reference.
             Reasons:
             - the primary role is assigned by the parent aggregate;
             - within one `OutgoingConfiguration`, the variant identity is already known, so
               `Slot` is sufficient and avoids redundant `(variant, slot)` duplication;
             - `Property` matches the rest of the Gradle-facing live model better than a
               custom `findPrimarySlot()` style API;
             - `Property` gives useful write/configure/finalize semantics without inventing a
               separate special lifecycle abstraction.
             Expected usage:
             - DSL or adapters may assign the primary slot through `set(...)`;
             - adapters that want to provide a default may use `convention(...)`;
             - the property may remain unset while the model is still incomplete;
             - at materialization time the property may be finalized;
             - if more than one slot exists and `primarySlot` is still unset at the
               materialization point, that is a model error.
             The model should still enforce that the selected primary slot belongs to the
             same `OutgoingConfiguration`.
             ### Proposed public shape
             With these constraints, the preferred public structure is:
             ```java
             interface VariantArtifactsContext {
                 VariantsView getVariants();
                 void all(Action<? super OutgoingConfiguration> action);
                 Optional<OutgoingConfiguration> findArtifacts(Variant variant);
                 OutgoingConfiguration requireArtifacts(Variant variant);
                 ArtifactAssemblies getAssemblies();
             }
             interface OutgoingConfiguration {
                 Variant getVariant();
                 NamedDomainObjectProvider<Configuration> getOutgoingConfiguration();
                 NamedDomainObjectContainer<Slot> getSlots();
                 Property<Slot> getPrimarySlot();
             }
             interface ArtifactAssemblies {
                 ArtifactAssembly resolveSlot(ArtifactSlot slot);
             }
             record ArtifactSlot(Variant variant, Slot slot) {}
             ```
             This gives:
             - one global registry of outgoing variants;
             - one local slot container per outgoing variant;
             - one fully qualified slot identity for resolver and cross-aggregate use;
             - one explicit service for slot assembly materialization.
             ### Minimal internal shape
             The preferred minimal internal structure is:
             ```java
             final class VariantArtifactsRegistry implements VariantArtifactsContext {
                 OutgoingConfiguration outgoingConfiguration(Variant variant);
                 ArtifactAssemblyRules slotRules(ArtifactSlot slot);
                 ArtifactAssemblies assemblies();
             }
             interface ArtifactAssemblyRules {
                 void from(Object input);
+                <T extends Task> void producedBy(
+                    TaskProvider<T> task,
+                    Function<? super T, ? extends Provider<? extends FileSystemLocation>> output);
                 void fromVariant(Action<? super OutputSelectionSpec> action);
                 void fromRole(String roleName, Action<? super OutputSelectionSpec> action);
                 void fromLayer(String layerName, Action<? super OutputSelectionSpec> action);
             }
             ```
             Responsibility split:
             - `VariantArtifactsRegistry` owns the whole artifact model;
             - `OutgoingConfiguration` owns only the structural variant-local aggregate;
             - `ArtifactAssemblyRules` owns the content declaration of one slot;
             - `ArtifactAssemblies` materializes `ArtifactAssembly` from
               `ArtifactSlot -> ArtifactAssemblyRules`.
             This keeps `OutgoingConfiguration` focused on structure and avoids overloading it
             with slot-content APIs such as `rules(slot)`.
             ### DSL binding
             The DSL should be connected through the registry, not by making
             `OutgoingConfiguration` responsible for content rules.
             Conceptually:
             ```java
             variantArtifacts.variant("browser", spec -> {
                 spec.slot("runtime", assembly -> {
                     assembly.fromRole("production", out -> out.output("js"));
                 });
             });
             ```
             Operationally this means:
 . registry creates or returns `OutgoingConfiguration` for the variant;
 . slot declaration creates or returns `Slot` inside that outgoing configuration;
 . registry forms `ArtifactSlot(variant, slot)`;
 . registry resolves `slotRules(artifactSlot)`;
 . bound `ArtifactAssemblySpec` writes into those rules.
             So the DSL writes:
             - structure into `OutgoingConfiguration`;
             - slot content into registry-owned `ArtifactAssemblyRules`.
             This is the intended bridge point between the public DSL and the internal
             resolver/materialization model.
             ---
             ## Live model and monotonic structure
             `variantArtifacts` should be treated as a live configuration model during the
             whole configuration phase.
             This means:
             - slot inputs remain live;
             - `from(...)`, `fromVariant(...)`, `fromRole(...)`, `fromLayer(...)` may keep
               contributing inputs until task execution;
+            - `producedBy(...)` publishes an existing task output directly and does not
+              create the managed copy assembly for that slot;
             - `ArtifactAssembly` may expose live `FileCollection`, `Provider`, and task
               wiring;
             - external task outputs remain outside the control of this model and must be
               accepted as live inputs.
             The model should therefore avoid a mandatory freeze phase for slot content.
             Instead, it should follow a monotonic rule:
             - outgoing variant existence may grow;
             - slot existence may grow;
             - slot content may grow;
             - publication-visible identity should not be retroactively redefined.
             In practice this means:
             - slot names are stable once declared;
             - primary slot designation is structural;
             - slot input content remains live.
             This also means that the model does not need a dedicated freeze phase for slot
             content merely because the root outgoing configuration was registered earlier.
             Early registration of the root `Configuration` and live evolution of slot input
             content are compatible concerns.
             ---
             ## DSL principles
             The DSL should remain declarative and symbolic.
             It should describe:
             - which variant is outgoing;
             - which slots exist;
             - which slot is primary;
             - which selectors contribute inputs to each slot.
             It should not directly expose:
             - `GenericSourceSet`;
             - `FileCollection`;
             - concrete resolved files from `variantSources`;
             - internal resolver state.
             ### DSL shape
             Conceptually:
             ```groovy
             variantArtifacts {
                 variant("browser") {
                     primarySlot("runtime") {
                         fromRole("production") {
                             output("js")
                             output("resources")
                         }
                     }
                     slot("types") {
                         fromVariant {
                             output("dts")
                         }
                     }
                     slot("sources") {
                         fromLayer("main") {
                             output("sources")
                         }
                     }
                     slot("bundleMetadata") {
-                        from(someTask)
+                        producedBy(writePackageMetadata) {
-                        from(layout.buildDirectory.file("generated/meta.json"))
+                            outputFile
+                        }
                     }
                 }
             }
             ```
             ### Meaning of contribution forms
             - `from(Object)` adds a direct input independent from `variantSources`;
             - `fromVariant { output(...) }` selects named outputs from all compile units of
               the current variant;
             - `fromRole(role) { output(...) }` selects named outputs from compile units that
               belong to the given role projection;
             - `fromLayer(layer) { output(...) }` selects named outputs from the compile unit
               of the current variant and the given layer, if such unit exists.
+            - `producedBy(task) { outputFile }` maps an existing producing task to the single
+              file or directory published for the slot.
+            Contribution forms and `producedBy(...)` are mutually exclusive for one slot.
             The DSL stores declarations, not resolved file collections.
             ---
             ## Contribution model
             Internally the DSL should compile to slot contributions.
             Conceptually:
             - `DirectContribution`
             - `VariantOutputContribution`
             - `RoleOutputContribution`
             - `LayerOutputContribution`
             These contributions should remain symbolic for as long as possible.
             They should not resolve source sets or files at declaration time.
             Each contribution is expected to provide:
             - its selection scope;
             - the requested output names;
             - enough symbolic identity for later validation and resolver policies.
             ---
             ## Resolver bridge between `variantSources` and `variantArtifacts`
             This is the central integration point.
             `variantArtifacts` should not access mutable internals of `variantSources`.
             Instead, it should resolve slot inputs through the public finalized
             `VariantSourcesContext`.
             ### Bridge responsibilities
             The bridge:
             - takes slot contribution declarations;
             - expands them against finalized variant topology;
             - maps logical selectors to compile units and role projections;
             - obtains source sets lazily through `VariantSourcesContext`;
             - resolves named outputs from those source sets;
             - builds the live input model for an `ArtifactAssembly`.
             ### Bridge input
             - current outgoing variant identity;
             - slot contribution declarations;
             - `VariantSourcesContext`.
             ### Bridge output
             - a live collection of logical slot inputs;
             - later adapted to `FileCollection` or other assembly-facing input models.
             ### Resolution semantics
             For one outgoing variant:
             - `fromVariant { output(x) }`
               - expands to all `CompileUnit` of that variant;
             - `fromRole(role) { output(x) }`
               - expands to `RoleProjection(variant, role)` and then to its compile units;
             - `fromLayer(layer) { output(x) }`
               - expands to one compile unit `(variant, layer)` when it exists;
             - `from(Object)`
               - bypasses `variantSources` completely.
+            - `producedBy(task)`
+              - bypasses contribution resolution and registers the task output as the slot
+                artifact directly.
             After compile units are known, the bridge asks
             `ctx.getSourceSets().getSourceSet(unit)` for each selected unit and resolves the
             requested named output.
             This keeps `variantArtifacts` independent from source-set naming internals and
             other materialization details.
             ---
             ## Validation
             Validation should be structural and symbolic.
             It should validate:
             - outgoing variant refers to an existing `Variant`;
             - referenced `Role` exists in that variant projection space;
             - referenced `Layer` exists in that variant compile-unit space;
             - primary slot is defined when needed;
             - primary slot refers to a slot declared in the same outgoing configuration.
             Validation should not require eager materialization of source sets or eager
             resolution of files.
             ---
             ## Deduplication and policy extension points
             Deduplication is important, but it should not be baked into the DSL itself.
             The correct place for it is the resolver bridge, after symbolic contributions
             have been expanded to logical inputs but before they are finally adapted to
             assembly-facing file collections.
             ### Why not in the DSL
             At declaration time it is still unknown whether selectors overlap:
             - `fromVariant`
             - `fromRole`
             - `fromLayer`
             may all describe the same logical source output.
             ### Why not rely only on `FileCollection`
             `FileCollection` may still provide useful physical deduplication, but it is too
             late and too file-oriented to serve as the only semantic mechanism.
             The artifact model should first deduplicate logical inputs, then let Gradle
             perform any additional physical deduplication.
             ### Default expectation
             The default resolver should support:
             - deduplication of topology-aware inputs by logical identity;
             - no implicit deduplication of direct `from(Object)` inputs.
             Logical identity should be based on domain meaning, for example:
             - `(CompileUnit, outputName)`
             and not on projected source-set names.
             This is important because source-set naming policy belongs to `variantSources`
             and must not silently redefine artifact semantics.
             ### Extension points
             The model should provide explicit internal extension points for:
             - deduplication policy;
             - logical input identity;
             - adaptation of resolved logical inputs to assembly-facing objects.
             Conceptually:
             ```java
             interface SlotInputDedupPolicy { ... }
             interface LogicalSlotInputIdentity { ... }
             interface SlotInputAdapter { ... }
             ```
             The default implementation may remain simple, but these seams should exist from
             the start.
             ---
             ## Publication hooks
             Publication hooks remain useful, but they should observe the live structural
             model rather than define it.
             Examples:
             - `whenOutgoingConfiguration(...)`
             - `whenOutgoingSlot(...)`
             These hooks are adapter-facing customization points over already declared
             outgoing structure:
             - root configuration attributes;
             - slot artifact attributes;
             - assembly task tweaks.
             The recommended way to connect publication-facing `Spec` objects to the
             structural model is by backlink, not by moving slot rules into publication
             types.
             Conceptually:
             ```java
             interface OutgoingConfigurationSpec {
                 OutgoingConfiguration getOutgoingArtifacts();
                 Variant getVariant();
                 Configuration getConfiguration();
             }
             interface OutgoingArtifactSlotSpec {
                 ArtifactSlot getArtifactSlot();
                 ArtifactAssembly getAssembly();
                 boolean isPrimary();
             }
             ```
             In this arrangement:
             - `OutgoingConfigurationSpec` remains a publication-facing facade;
             - `OutgoingConfigurationSpec` may expose the structural aggregate when an
               adapter needs it;
             - slot rules still belong to `VariantArtifactsRegistry`;
             - publication specs do not become owners of declaration or resolver state.
             They should not become the primary structural API for the artifact model.
             This is why a separate phase-oriented `OutgoingPublicationsContext` is not
             required.
             The live `OutgoingConfiguration` aggregate is sufficient.
             ---
             ## Design principles
             ### 1. Keep topology ownership in `variants`
             `variantArtifacts` selects from the topology model. It does not own it.
             ### 2. Keep source ownership in `variantSources`
             `variantArtifacts` consumes source materialization through a resolver bridge. It
             does not own source-set semantics.
             ### 3. Keep the DSL symbolic
             The DSL declares intent and selection rules, not materialized files.
             ### 4. Keep slot content live
             Do not introduce an artificial finalize phase for slot content unless a real
             semantic need appears.
             ### 5. Fix only structural identity
             Slot name, primary designation, and outgoing shape are structural. Slot inputs
             remain live.
             ### 6. Resolve through dedicated bridges
             Cross-model integration belongs in a resolver service, not in DSL classes.
             ### 7. Add policy seams early
             Deduplication and similar concerns should have extension points from the start,
             even if the initial implementation is conservative.
             ---
             ## Summary
             `variantArtifacts` should be modeled as a live outgoing-contract layer over
             `variants`, with source input resolution delegated to a dedicated bridge over
             `variantSources`.
             The resulting shape is:
             - `variants` owns topology;
             - `variantSources` owns source materialization;
             - `variantArtifacts` owns outgoing contract structure;
             - a resolver bridge connects symbolic slot declarations to live source-derived
               inputs;
             - deduplication and similar concerns are policies of that bridge, not of the
               DSL itself;
             - slot content stays live during configuration;
             - only publication-visible structure is treated as stable identity.

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblySpec.java +46 0

             package org.implab.gradle.variants.artifacts;
+            import java.util.function.Function;
             import org.gradle.api.Action;
+            import org.gradle.api.InvalidUserDataException;
+            import org.gradle.api.Task;
+            import org.gradle.api.file.FileSystemLocation;
+            import org.gradle.api.provider.Provider;
+            import org.gradle.api.tasks.TaskProvider;
             import groovy.lang.Closure;
             import org.implab.gradle.common.core.lang.Closures;
             /**
              * DSL model describing how a slot artifact is assembled.
              *
              * <p>Selection rules declared here may refer to internal build topology such as roles, layers or units.
              * Those selectors influence slot assembly only and do not become part of published artifact identity.
              *
              * <p>Regardless of the number of declared inputs, a slot is expected to materialize to a single published
              * artifact.
              */
             public interface ArtifactAssemblySpec {
                 /**
                  * Contributes direct input material to the slot assembly.
                  *
                  * <p>The resulting slot still represents one published artifact.
                  *
                  * @param artifact direct input notation understood by the implementation
                  */
                 void from(Object artifact);
                 /**
+                 * Registers a task that directly produces the published slot artifact.
+                 *
+                 * <p>Use this method when the slot is produced as one file or directory by an
+                 * existing task, for example generated package metadata. Unlike {@link #from(Object)}
+                 * and topology-aware selectors, this does not copy inputs into a managed assembly
+                 * directory. The mapped task output becomes the published artifact itself.
+                 *
+                 * <p>This mode is mutually exclusive with contribution-based assembly methods
+                 * such as {@link #from(Object)}, {@link #fromVariant(Action)}, {@link #fromRole(String, Action)},
+                 * and {@link #fromLayer(String, Action)} for the same slot.
+                 *
+                 * @param <T> task type
+                 * @param task task provider producing the artifact
+                 * @param artifact maps the producing task to its output file or directory provider
+                 */
+                <T extends Task> void producedBy(
+                        TaskProvider<T> task,
+                        Function<? super T, ? extends Provider<? extends FileSystemLocation>> artifact);
+                default <T extends Task> void producedBy(TaskProvider<T> task, Closure<?> closure) {
+                    producedBy(task, taskInstance -> producedArtifact(closure, taskInstance));
+                }
+                @SuppressWarnings("unchecked")
+                private static Provider<? extends FileSystemLocation> producedArtifact(Closure<?> closure, Task task) {
+                    var c = (Closure<?>) closure.clone();
+                    c.setResolveStrategy(Closure.DELEGATE_FIRST);
+                    c.setDelegate(task);
+                    var artifact = c.call(task);
+                    if (artifact instanceof Provider<?>) {
+                        return (Provider<? extends FileSystemLocation>) artifact;
+                    }
+                    throw new InvalidUserDataException("Produced artifact mapper for task '" + task.getName()
+                            + "' must return Provider<? extends FileSystemLocation>");
+                }
+                /**
                  * Selects outputs from the whole variant scope.
                  *
                  * @param action output selection rule
                  */
                 void fromVariant(Action<? super OutputSelectionSpec> action);
                 default void fromVariant(Closure<?> closure) {
                     fromVariant(Closures.action(closure));
                 }
                 /**
                  * Selects outputs from a role inside the current variant.
                  *
                  * @param roleName role name used only for assembly-time selection
                  * @param action output selection rule
                  */
                 void fromRole(String roleName, Action<? super OutputSelectionSpec> action);
                 default void fromRole(String roleName, Closure<?> closure) {
                     fromRole(roleName, Closures.action(closure));
                 }
                 /**
                  * Selects outputs from a layer inside the current variant.
                  *
                  * @param layerName layer name used only for assembly-time selection
                  * @param action output selection rule
                  */
                 void fromLayer(String layerName, Action<? super OutputSelectionSpec> action);
                 default void fromLayer(String layerName, Closure<?> closure) {
                     fromLayer(layerName, Closures.action(closure));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyBinder.java +6 -2

             package org.implab.gradle.variants.artifacts.internal;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             /**
              * Binds materialized slot assemblies to Gradle outgoing publications.
              */
             @NonNullByDefault
             public class ArtifactAssemblyBinder implements Action<OutgoingVariant> {
                 private final ArtifactAssemblies resolver;
                 public ArtifactAssemblyBinder(ArtifactAssemblies resolver) {
                     this.resolver = resolver;
                 }
                 @Override
                 public void execute(OutgoingVariant outgoingVariant) {
                     var slots = outgoingVariant.getSlots();
                     var primarySlotProvider = outgoingVariant.getPrimarySlot();
                     var variant = outgoingVariant.getVariant();
                     // Bind publication state when the owning configuration is materialized.
                     outgoingVariant.configureOutgoing(configuration -> {
                         var primarySlot = primarySlotProvider.get();
                         var outgoing = configuration.getOutgoing();
                         // Bind the primary artifact set to the root outgoing configuration.
                         resolver.when(
                                 new ArtifactSlot(variant, primarySlot),
-                                assembly -> outgoing.artifact(assembly.getArtifact()));
+                                assembly -> outgoing.artifact(
+                                        assembly.getArtifact(),
+                                        artifact -> artifact.builtBy(assembly.getAssemblyTask())));
                         // Bind non-primary slots to Gradle secondary artifact variants.
                         slots.all(slot -> {
                             if (slot.equals(primarySlot))
                                 return;
                             resolver.when(
                                     new ArtifactSlot(variant, slot),
                                     // Gradle artifact variants must be created while the owning
                                     // configuration is being materialized. Lazy registration may
                                     // otherwise be realized only after dependency resolution starts.
                                     assembly -> outgoing.getVariants()
                                             .create(slot.getName())
-                                            .artifact(assembly.getArtifact()));
+                                            .artifact(
+                                                    assembly.getArtifact(),
+                                                    artifact -> artifact.builtBy(assembly.getAssemblyTask())));
                         });
                     });
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyHandler.java +132 -13

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.HashMap;
             import java.util.HashSet;
             import java.util.Map;
             import java.util.Set;
+            import java.util.function.Function;
+            import java.util.stream.Stream;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
+            import org.gradle.api.InvalidUserDataException;
+            import org.gradle.api.Task;
             import org.gradle.api.file.ConfigurableFileCollection;
             import org.gradle.api.file.Directory;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.FileCollection;
+            import org.gradle.api.file.FileSystemLocation;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.Sync;
             import org.gradle.api.tasks.TaskContainer;
+            import org.gradle.api.tasks.TaskProvider;
             import org.gradle.language.base.plugins.LifecycleBasePlugin;
             import org.implab.gradle.common.core.lang.FilePaths;
+            import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.artifacts.ArtifactAssembly;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
+            import org.implab.gradle.variants.artifacts.OutputSelectionSpec;
+            import org.implab.gradle.variants.core.Layer;
+            import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.CompileUnitsView;
             import org.implab.gradle.variants.sources.RoleProjectionsView;
             import org.implab.gradle.variants.sources.SourceSetMaterializer;
             /**
-             * Adapts slot contribution declarations to materialized {@link ArtifactAssembly}
+             * Adapts slot contribution declarations to materialized
+             * {@link ArtifactAssembly}
              * handles.
              *
-             * <p>The handler creates one {@link Sync} task per {@link ArtifactSlot}. The task
+             * <p>
-             * copies all collected slot inputs into a single output directory. That output
+             * Contribution-based assemblies create one {@link Sync} task per
-             * directory is then registered in {@link ArtifactAssemblyRegistry} as the
+             * {@link ArtifactSlot}. The task copies all collected slot inputs into a single
-             * published artifact for the slot.
+             * output directory. That output directory is then registered in
+             * {@link ArtifactAssemblyRegistry} as the published artifact for the slot.
              *
-             * <p>Input collection uses {@link SlotContributionVisitor}. Each contribution is
+             * <p>
-             * converted to a {@link SlotInputKey}; duplicate keys are ignored so that repeated
+             * Task-produced assemblies bypass the managed copy task. The producer task is
+             * registered directly in {@link ArtifactAssemblyRegistry}, and its mapped output
+             * file or directory becomes the published slot artifact.
+             *
+             * <p>
+             * Input collection uses {@link SlotContributionVisitor}. Each contribution is
+             * converted to a {@link SlotInputKey}; duplicate keys are ignored so that
+             * repeated
              * topology-based selections do not add the same input twice.
              */
             @NonNullByDefault
             public class ArtifactAssemblyHandler {
                 private final ObjectFactory objects;
                 private final ArtifactAssemblyRegistry assemblyRegistry;
                 private final DirectoryProperty assembliesDirectory;
                 private final TaskContainer tasks;
                 private final CompileUnitsView compileUnitsView;
                 private final RoleProjectionsView roleProjectionsView;
                 private final SourceSetMaterializer sourceSetMaterializer;
                 private final Map<ArtifactSlot, SlotAssembly> slotInputs = new HashMap<>();
+                private final Map<ArtifactSlot, AssemblyMode> assemblyModes = new HashMap<>();
                 public ArtifactAssemblyHandler(
                         ObjectFactory objects,
                         TaskContainer tasks,
                         ArtifactAssemblyRegistry assemblyRegistry,
                         CompileUnitsView compileUnitsView,
                         RoleProjectionsView roleProjectionsView,
                         SourceSetMaterializer sourceSetMaterializer) {
                     this.objects = objects;
                     this.tasks = tasks;
                     this.assemblyRegistry = assemblyRegistry;
                     this.compileUnitsView = compileUnitsView;
                     this.roleProjectionsView = roleProjectionsView;
                     this.sourceSetMaterializer = sourceSetMaterializer;
                     assembliesDirectory = objects.directoryProperty();
                 }
                 public DirectoryProperty getAssembliesDirectory() {
                     return assembliesDirectory;
                 }
                 public void configureAssembly(ArtifactSlot artifactSlot, Action<? super ArtifactAssemblySpec> action) {
-                    var visitor = contributionVisitor(artifactSlot);
+                    var spec = new DefaultArtifactAssemblySpec(artifactSlot);
-                    var spec = new DefaultArtifactAssemblySpec(objects, c -> c.accept(visitor));
                     action.execute(spec);
                 }
-                public SlotContributionVisitor contributionVisitor(ArtifactSlot artifactSlot) {
+                private void useAssemblyMode(ArtifactSlot artifactSlot, AssemblyMode mode) {
-                    var assembly = slotInputs.computeIfAbsent(artifactSlot, this::createSlotAssembly);
+                    var previous = assemblyModes.putIfAbsent(artifactSlot, mode);
-                    return new ContributionVisitor(artifactSlot, assembly);
+                    if (previous != null && previous != mode) {
+                        throw new InvalidUserDataException("Artifact slot '" + artifactSlot
+                                + "' cannot mix task-produced artifact and contribution-based assembly");
+                    }
                 }
                 /**
-                 * Creates the assembly task for the given slot and registers its output artifact.
+                 * Creates the assembly task for the given slot and registers its output
+                 * artifact.
                  */
                 private SlotAssembly createSlotAssembly(ArtifactSlot artifactSlot) {
                     var assembly = new SlotAssembly();
                     var fileCollection = assembly.inputs();
                     var outputDirectory = outputDirectory(artifactSlot);
                     var task = tasks.register(assembleTaskName(artifactSlot), Sync.class, copy -> {
                         copy.setGroup(LifecycleBasePlugin.BUILD_GROUP);
                         copy.into(outputDirectory);
                         copy.from(fileCollection);
                     });
                     assemblyRegistry.register(artifactSlot, task, t -> outputDirectory);
                     return assembly;
                 }
                 private String assembleTaskName(ArtifactSlot artifactSlot) {
                     var variantName = artifactSlot.variant().getName();
                     var slotName = artifactSlot.slot().getName();
                     return "assembleVariantArtifactSlot"
                             + "_v" + variantName.length() + "_" + variantName
                             + "_s" + slotName.length() + "_" + slotName;
                 }
                 private Provider<Directory> outputDirectory(ArtifactSlot artifactSlot) {
                     return assembliesDirectory.dir(
                             FilePaths.cat(
                                     artifactSlot.variant().getName(),
                                     artifactSlot.slot().getName()));
                 }
                 /**
                  * Collects slot contributions into one {@link ConfigurableFileCollection}.
                  */
                 private class ContributionVisitor implements SlotContributionVisitor {
                     // artifact slot for this assembly
                     private final ArtifactSlot artifactSlot;
                     // seen inputs, used for deduplication
                     private final SlotAssembly assembly;
                     ContributionVisitor(ArtifactSlot artifactSlot, SlotAssembly assembly) {
                         this.artifactSlot = artifactSlot;
                         this.assembly = assembly;
                     }
                     @Override
                     public void visit(DirectContribution contribution) {
                         contribute(
                                 SlotInputKey.newUniqueKey("Direct input for " + artifactSlot),
                                 contribution.input());
                     }
                     @Override
                     public void visit(VariantOutputsContribution contribution) {
                         var units = compileUnitsView.getUnitsForVariant(artifactSlot.variant());
                         contributeCompileUnits(units, contribution.outputs());
                     }
                     @Override
                     public void visit(RoleOutputsContribution contribution) {
                         var roleProjection = roleProjectionsView.requireProjection(artifactSlot.variant(),
                                 contribution.role());
                         var units = roleProjectionsView.getUnits(roleProjection);
                         contributeCompileUnits(units, contribution.outputs());
                     }
                     @Override
                     public void visit(LayerOutputsContribution contribution) {
                         var unit = compileUnitsView.requireUnit(artifactSlot.variant(), contribution.layer());
                         contributeCompileUnits(Set.of(unit), contribution.outputs());
                     }
                     private void contributeCompileUnits(Set<CompileUnit> units, Set<String> outputs) {
                         units.stream()
                                 // expand variant compile units, make (compileUnit, outputName) pairs
                                 .flatMap(unit -> outputs.stream()
                                         .map(output -> new CompileUnitOutputKey(unit, output)))
                                 .forEach(key -> contribute(
                                         key,
                                         sourceSetMaterializer.getSourceSet(key.unit())
                                                 .map(s -> s.output(key.outputName()))));
                     }
                     private void contribute(SlotInputKey key, Object resolvedInput) {
                         assembly.addSlotInput(key, resolvedInput);
                     }
                 }
                 /** Mutable input state for one slot assembly. */
                 class SlotAssembly {
                     private final ConfigurableFileCollection inputs = objects.fileCollection();
                     private final Set<SlotInputKey> seen = new HashSet<>();
                     public void addSlotInput(SlotInputKey key, Object input) {
                         if (!seen.add(key))
                             return;
                         inputs.from(input);
                     }
                     public FileCollection inputs() {
                         return inputs;
                     }
                 }
+                private enum AssemblyMode {
+                    CONTRIBUTIONS,
+                    TASK_PRODUCER
                 }
+                /**
+                 * Default DSL facade for collecting {@link SlotContribution} declarations.
+                 *
+                 * <p>
+                 * The spec does not validate topology references immediately. It translates DSL
+                 * calls to contribution objects and passes them to the supplied consumer;
+                 * semantic
+                 * validation happens later when the assembly handler resolves contributions
+                 * against the finalized source model.
+                 */
+                class DefaultArtifactAssemblySpec implements ArtifactAssemblySpec {
+                    private final ArtifactSlot artifactSlot;
+                    DefaultArtifactAssemblySpec(ArtifactSlot artifactSlot) {
+                        this.artifactSlot = artifactSlot;
+                    }
+                    @Override
+                    public void from(Object artifact) {
+                        contribute(new DirectContribution(artifact));
+                    }
+                    @Override
+                    public <T extends Task> void producedBy(
+                            TaskProvider<T> task,
+                            Function<? super T, ? extends Provider<? extends FileSystemLocation>> artifact) {
+                        registerProducedArtifact(task, artifact);
+                    }
+                    @Override
+                    public void fromVariant(Action<? super OutputSelectionSpec> action) {
+                        contribute(new VariantOutputsContribution(outputs(action)));
+                    }
+                    @Override
+                    public void fromRole(String roleName, Action<? super OutputSelectionSpec> action) {
+                        contribute(new RoleOutputsContribution(
+                                objects.named(Role.class, roleName),
+                                outputs(action)));
+                    }
+                    @Override
+                    public void fromLayer(String layerName, Action<? super OutputSelectionSpec> action) {
+                        contribute(new LayerOutputsContribution(
+                                objects.named(Layer.class, layerName),
+                                outputs(action)));
+                    }
+                    private static Set<String> outputs(Action<? super OutputSelectionSpec> action) {
+                        var spec = new OutputsSetSpec();
+                        action.execute(spec);
+                        return spec.outputs();
+                    }
+                    void contribute(SlotContribution contribution) {
+                        useAssemblyMode(artifactSlot, AssemblyMode.CONTRIBUTIONS);
+                        var assembly = slotInputs.computeIfAbsent(artifactSlot, ArtifactAssemblyHandler.this::createSlotAssembly);
+                        var contributionVisitor = new ContributionVisitor(artifactSlot, assembly);
+                        contribution.accept(contributionVisitor);
+                    }
+                    <T extends Task> void registerProducedArtifact(
+                            TaskProvider<T> task,
+                            Function<? super T, ? extends Provider<? extends FileSystemLocation>> artifact) {
+                        useAssemblyMode(artifactSlot, AssemblyMode.TASK_PRODUCER);
+                        assemblyRegistry.register(artifactSlot, task, artifact);
+                    }
+                }
+                /** Simple implementation of {@link OutputSelectionSpec}. */
+                static class OutputsSetSpec implements OutputSelectionSpec {
+                    private final Set<String> outputs = new HashSet<>();
+                    @Override
+                    public void output(String name, String... extra) {
+                        Stream.concat(Stream.of(name), Stream.of(extra))
+                                .map(Strings::requireNonBlank)
+                                .forEach(outputs::add);
+                    }
+                    Set<String> outputs() {
+                        return Set.copyOf(outputs);
+                    }
+                }
+            }

variants/src/test/java/org/implab/gradle/variants/VariantArtifactsPluginFunctionalTest.java +164 0

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.junit.jupiter.api.Test;
             class VariantArtifactsPluginFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void gradleReferenceLazyOutgoingConfigurationAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'gradle-reference-outgoing-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/typesPackage", "types\n");
                     writeFile("producer/inputs/js", "js\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             project(':producer') {
                                 def browserElements = configurations.consumable('browserElements')
                                 println('reference: registered browserElements provider')
                                 browserElements.configure { configuration ->
                                     println('reference: configuring browserElements')
                                     configuration.attributes.attribute(variantAttr, 'browser')
                                     configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
                                     configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
                                     configuration.outgoing.variants.create('js') { secondary ->
                                         println('reference: creating js outgoing variant')
                                         secondary.attributes.attribute(slotAttr, 'js')
                                         secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         println('reference: resolving primary files')
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         println('reference: resolving secondary files')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     var output = result.getOutput();
                     var registered = output.indexOf("reference: registered browserElements provider");
                     var resolvingPrimary = output.indexOf("reference: resolving primary files");
                     var configuring = output.indexOf("reference: configuring browserElements");
                     var creatingSecondary = output.indexOf("reference: creating js outgoing variant");
                     var resolvingSecondary = output.indexOf("reference: resolving secondary files");
                     assertTrue(registered >= 0);
                     assertTrue(resolvingPrimary >= 0);
                     assertTrue(configuring >= 0);
                     assertTrue(creatingSecondary >= 0);
                     assertTrue(resolvingSecondary >= 0);
                     assertTrue(registered < resolvingPrimary);
                     assertTrue(resolvingPrimary < configuring);
                     assertTrue(configuring < creatingSecondary);
                     assertTrue(creatingSecondary < resolvingSecondary);
                     assertTrue(output.contains("compileFiles=typesPackage"));
                     assertTrue(output.contains("jsFiles=js"));
                 }
                 @Test
                 void gradleReferenceRegisteredSecondaryArtifactVariantIsNotRealizedBeforeResolution() throws Exception {
                     // Gradle issue: https://github.com/gradle/gradle/issues/27441
                     // Registered outgoing artifact variants are not realized before dependency resolution.
                     writeFile("settings.gradle", """
                             rootProject.name = 'gradle-reference-registered-secondary-variant'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/typesPackage", "types\n");
                     writeFile("producer/inputs/js", "js\n");
                     writeFile("build.gradle", """
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             project(':producer') {
                                 def browserElements = configurations.consumable('browserElements')
                                 browserElements.configure { configuration ->
                                     configuration.attributes.attribute(variantAttr, 'browser')
                                     configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
                                     configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
                                     configuration.outgoing.variants.register('js') { secondary ->
                                         secondary.attributes.attribute(slotAttr, 'js')
                                         secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Cannot create variant 'js' after dependency configuration ':producer:browserElements' has been resolved",
                             ":consumer:probe");
                 }
                 @Test
                 void materializesPrimaryAndSecondarySlotsAndInvokesOutgoingHooks() throws Exception {
                     writeSettings("variant-artifacts-slots");
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/amd.js", "console.log('amd')\n");
                     writeFile("inputs/mainJs.txt", "mainJs marker\n");
                     writeFile("inputs/amdJs.txt", "amdJs marker\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             variants.layers.create('mainBase')
                             variants.layers.create('mainAmd')
                             variants.roles.create('main')
                             variants.roles.create('test')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                             }
                             variantSources {
                                 layer('mainBase') {
                                     sourceSet {
                                         declareOutputs('js')
                                         registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                     }
                                 }
                                 layer('mainAmd') {
                                     sourceSet {
                                         declareOutputs('js')
                                         registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
                                     }
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('mainJs') {
                                         fromRole('main') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/mainJs.txt'))
                                     }
                                     slot('amdJs') {
                                         fromLayer('mainAmd') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/amdJs.txt'))
                                     }
                                 }
                                 whenOutgoingConfiguration { publication ->
                                     publication.configuration {
                                         attributes.attribute(variantAttr, publication.variant.name)
                                     }
                                 }
                                 whenOutgoingSlot { publication ->
                                     def slotName = publication.artifactSlot.slot.name
                                     publication.artifactAttributes {
                                         attribute(slotAttr, slotName)
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_mainJs'
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s5_amdJs'
                                 doLast {
                                     def mainDir = layout.buildDirectory.dir('variant-assemblies/browser/mainJs').get().asFile
                                     def amdDir = layout.buildDirectory.dir('variant-assemblies/browser/amdJs').get().asFile
                                     assert new File(mainDir, 'base.js').exists()
                                     assert new File(mainDir, 'amd.js').exists()
                                     assert new File(mainDir, 'mainJs.txt').exists()
                                     assert !new File(amdDir, 'base.js').exists()
                                     assert new File(amdDir, 'amd.js').exists()
                                     assert new File(amdDir, 'amdJs.txt').exists()
                                     def elements = configurations.getByName('browserElements')
                                     def amdVariant = elements.outgoing.variants.getByName('amdJs')
                                     println('variantAttr=' + elements.attributes.getAttribute(variantAttr))
                                     println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
                                     println('amdSlotAttr=' + amdVariant.attributes.getAttribute(slotAttr))
                                     println('configurations=' + configurations.matching { it.name == 'browserElements' }.collect { it.name }.join(','))
                                     println('secondaryVariants=' + elements.outgoing.variants.collect { it.name }.sort().join(','))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("variantAttr=browser"));
                     assertTrue(result.getOutput().contains("primarySlotAttr=mainJs"));
                     assertTrue(result.getOutput().contains("amdSlotAttr=amdJs"));
                     assertTrue(result.getOutput().contains("configurations=browserElements"));
                     assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void outgoingSlotHookFollowsMaterializedGradleArtifactVariants() throws Exception {
                     writeSettings("variant-artifacts-materialized-gradle-variant");
                     writeFile("inputs/typesPackage", "types\n");
                     writeFile("inputs/js", "js\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             def slotAttr = Attribute.of('test.slot', String)
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('typesPackage') {
                                         from(layout.projectDirectory.file('inputs/typesPackage'))
                                     }
                                 }
                                 whenOutgoingConfiguration { publication ->
                                     publication.configuration {
                                         outgoing.variants.create('js') { secondary ->
                                             secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                         }
                                     }
                                 }
                                 whenOutgoingSlot { publication ->
                                     publication.artifactAttributes {
                                         attribute(slotAttr, publication.artifactSlot.slot.name)
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def elements = configurations.getByName('browserElements')
                                     def jsVariant = elements.outgoing.variants.getByName('js')
                                     println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
                                     println('jsSlotAttr=' + jsVariant.attributes.getAttribute(slotAttr))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primarySlotAttr=typesPackage"));
                     assertTrue(result.getOutput().contains("jsSlotAttr=js"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
                     writeSettings("variant-artifacts-single-slot");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 sourceSet {
                                     declareOutputs('types')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         println('primary=' + ctx.findOutgoing(browser).get().primarySlot.get().name)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=typesPackage"));
                 }
                 @Test
                 void materializesDirectSlotInputsWithoutVariantSourceBindings() throws Exception {
                     writeSettings("variant-artifacts-direct-input");
                     writeFile("inputs/bundle.js", "console.log('bundle')\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('bundle') {
                                         from(layout.projectDirectory.file('inputs/bundle.js'))
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
                                     assert new File(bundleDir, 'bundle.js').exists()
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
+                void publishesTaskProducedFileArtifactDirectly() throws Exception {
+                    writeFile("settings.gradle", """
+                            rootProject.name = 'variant-artifacts-task-produced-file'
+                            include 'producer', 'consumer'
+                            """);
+                    writeBuildFile("""
+                            import org.gradle.api.DefaultTask
+                            import org.gradle.api.attributes.Attribute
+                            import org.gradle.api.file.RegularFileProperty
+                            import org.gradle.api.tasks.OutputFile
+                            import org.gradle.api.tasks.TaskAction
+                            def variantAttr = Attribute.of('test.variant', String)
+                            def slotAttr = Attribute.of('test.slot', String)
+                            abstract class WritePackageMetadata extends DefaultTask {
+                                @OutputFile
+                                abstract RegularFileProperty getOutputFile()
+                                @TaskAction
+                                void write() {
+                                    def file = outputFile.get().asFile
+                                    file.parentFile.mkdirs()
+                                    file.text = '{"name":"demo"}\\n'
+                                }
+                            }
+                            project(':producer') {
+                                apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
+                                variants.layers.create('main')
+                                variants.roles.create('main')
+                                variants.variant('browser') {
+                                    role('main') {
+                                        layers('main')
+                                    }
+                                }
+                                def writePackageMetadata = tasks.register('writePackageMetadata', WritePackageMetadata) {
+                                    outputFile.set(layout.buildDirectory.file('generated/package.json'))
+                                }
+                                variantArtifacts {
+                                    variant('browser') {
+                                        primarySlot('packageMetadata') {
+                                            producedBy(writePackageMetadata) {
+                                                outputFile
+                                            }
+                                        }
+                                    }
+                                    whenOutgoingConfiguration { publication ->
+                                        publication.configuration {
+                                            attributes.attribute(variantAttr, publication.variant.name)
+                                        }
+                                    }
+                                    whenOutgoingSlot { publication ->
+                                        publication.artifactAttributes {
+                                            attribute(slotAttr, publication.artifactSlot.slot.name)
+                                        }
+                                    }
+                                }
+                                tasks.register('checkNoManagedAssembly') {
+                                    doLast {
+                                        def assemblyTasks = tasks.names
+                                            .findAll { it.startsWith('assembleVariantArtifactSlot') }
+                                            .sort()
+                                        println('producerAssemblyTasks=' + assemblyTasks.join(','))
+                                        assert assemblyTasks.empty
+                                    }
+                                }
+                            }
+                            project(':consumer') {
+                                configurations {
+                                    compileView {
+                                        canBeResolved = true
+                                        canBeConsumed = false
+                                        canBeDeclared = true
+                                        attributes {
+                                            attribute(variantAttr, 'browser')
+                                            attribute(slotAttr, 'packageMetadata')
+                                        }
+                                    }
+                                }
+                                dependencies {
+                                    compileView project(':producer')
+                                }
+                                tasks.register('probe') {
+                                    dependsOn configurations.compileView
+                                    dependsOn ':producer:checkNoManagedAssembly'
+                                    doLast {
+                                        def files = configurations.compileView.files
+                                        println('resolvedFiles=' + files.collect { it.name }.sort().join(','))
+                                        println('metadata=' + files.iterator().next().text.trim())
+                                    }
+                                }
+                            }
+                            """);
+                    BuildResult result = runner(":consumer:probe").build();
+                    assertTrue(result.getOutput().contains("producerAssemblyTasks="));
+                    assertTrue(result.getOutput().contains("resolvedFiles=package.json"));
+                    assertTrue(result.getOutput().contains("metadata={\"name\":\"demo\"}"));
+                    assertTrue(result.task(":producer:writePackageMetadata").getOutcome() == TaskOutcome.SUCCESS);
+                    assertTrue(result.task(":consumer:probe").getOutcome() == TaskOutcome.SUCCESS);
+                }
+                @Test
+                void failsWhenTaskProducedArtifactIsMixedWithContributionAssembly() throws Exception {
+                    writeSettings("variant-artifacts-mixed-assembly-mode");
+                    writeFile("inputs/marker.txt", "marker\n");
+                    writeBuildFile("""
+                            import org.gradle.api.DefaultTask
+                            import org.gradle.api.file.RegularFileProperty
+                            import org.gradle.api.tasks.OutputFile
+                            import org.gradle.api.tasks.TaskAction
+                            apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
+                            abstract class WritePackageMetadata extends DefaultTask {
+                                @OutputFile
+                                abstract RegularFileProperty getOutputFile()
+                                @TaskAction
+                                void write() {
+                                    outputFile.get().asFile.text = '{}\\n'
+                                }
+                            }
+                            variants.layers.create('main')
+                            variants.roles.create('main')
+                            variants.variant('browser') {
+                                role('main') {
+                                    layers('main')
+                                }
+                            }
+                            def writePackageMetadata = tasks.register('writePackageMetadata', WritePackageMetadata) {
+                                outputFile.set(layout.buildDirectory.file('generated/package.json'))
+                            }
+                            variantArtifacts {
+                                variant('browser') {
+                                    primarySlot('packageMetadata') {
+                                        producedBy(writePackageMetadata) {
+                                            outputFile
+                                        }
+                                        from(layout.projectDirectory.file('inputs/marker.txt'))
+                                    }
+                                }
+                            }
+                            """);
+                    assertBuildFails("cannot mix task-produced artifact and contribution-based assembly", "help");
+                }
+                @Test
                 void combinesDirectAndTopologyAwareSlotInputs() throws Exception {
                     writeSettings("variant-artifacts-combined-inputs");
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/marker.txt", "marker\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 sourceSet {
                                     declareOutputs('js')
                                     registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('bundle') {
                                         fromVariant {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/marker.txt'))
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
                                     assert new File(bundleDir, 'base.js').exists()
                                     assert new File(bundleDir, 'marker.txt').exists()
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void failsOnUnknownVariantReference() throws Exception {
                     writeSettings("variant-artifacts-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownRoleReference() throws Exception {
                     writeSettings("variant-artifacts-missing-role");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromRole('test') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Role projection for variant 'browser' and role 'test' not found", "help");
                 }
                 @Test
                 void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
                     writeSettings("variant-artifacts-missing-primary");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 sourceSet {
                                     declareOutputs('types', 'js')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                     slot('js') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         ctx.findOutgoing(browser).get().primarySlot.get()
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Multiple slots declared for browser, please specify primary slot explicitly", "probe");
                 }
                 @Test
                 void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
                     writeSettings("variant-artifacts-layer-outside-topology");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('mainBase')
                             variants.layers.create('extra')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('extraJs') {
                                         fromLayer('extra') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Compile unit for variant 'browser' and layer 'extra' not found", "help");
                 }
                 @Test
                 void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'variant-artifacts-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
                     writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             subprojects {
                                 apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             }
                             project(':producer') {
                                 variants.layers.create('main')
                                 variants.roles.create('main')
                                 variants.variant('browser') {
                                     role('main') {
                                         layers('main')
                                     }
                                 }
                                 variantSources.layer('main') {
                                     sourceSet {
                                         declareOutputs('types', 'js')
                                         registerOutput('types', layout.projectDirectory.file('inputs/types.d.ts'))
                                         registerOutput('js', layout.projectDirectory.file('inputs/index.js'))
                                     }
                                 }
                                 variantArtifacts {
                                     variant('browser') {
                                         primarySlot('typesPackage') {
                                             fromVariant {
                                                 output('types')
                                             }
                                         }
                                         slot('js') {
                                             fromVariant {
                                                 output('js')
                                             }
                                         }
                                     }
                                     whenOutgoingConfiguration { publication ->
                                         publication.configuration {
                                             attributes.attribute(variantAttr, publication.variant.name)
                                         }
                                     }
                                     whenOutgoingSlot { publication ->
                                         publication.artifactAttributes {
                                             attribute(slotAttr, publication.artifactSlot.slot.name)
                                         }
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
                     assertTrue(result.getOutput().contains("jsFiles=js"));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultArtifactAssemblySpec.java removed 0 -81

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages