implab/gradle-common Commit - r38:87d6128f0bc8

Working on separating variants as standalone plugin

cin -

r38:87d6128f0bc8 default

parent child

Context file:

r38:87d6128f0bc8

Expand all files

common/src/main/java/org/implab/gradle/common/sources/LayerBindingSpec.java created 644 +41 0

@@ -0,0 +1,41
	1	package org.implab.gradle.common.sources;
	2
	3	import org.implab.gradle.common.core.lang.Closures;
	4	import org.gradle.api.Action;
	5	import org.gradle.api.Named;
	6	import org.gradle.api.provider.Property;
	7
	8	import groovy.lang.Closure;
	9	import groovy.lang.DelegatesTo;
	10
	11	/**
	12	* Public DSL contract for per-layer source-set policy and callbacks.
	13	*/
	14	public interface LayerBindingSpec extends Named {
	15	Property<String> getSourceSetNamePattern();
	16
	17	default void setSourceSetNamePattern(String pattern) {
	18	getSourceSetNamePattern().set(pattern);
	19	}
	20
	21	void configureSourceSet(Action<? super GenericSourceSet> configure);
	22
	23	default void configureSourceSet(
	24	@DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
	25	configureSourceSet(Closures.action(configure));
	26	}
	27
	28	void whenRegistered(Action<? super SourceSetRegistration> action);
	29
	30	default void whenRegistered(
	31	@DelegatesTo(value = SourceSetRegistration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	32	whenRegistered(Closures.action(action));
	33	}
	34
	35	void whenBound(Action<? super SourceSetUsageBinding> action);
	36
	37	default void whenBound(
	38	@DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
	39	whenBound(Closures.action(action));
	40	}
	41	}

variants/build.gradle created 644 +53 0

@@ -0,0 +1,53
	1	plugins {
	2	id "java-library"
	3	id "ivy-publish"
	4	}
	5
	6	java {
	7	withJavadocJar()
	8	withSourcesJar()
	9	toolchain {
	10	languageVersion = JavaLanguageVersion.of(21)
	11	}
	12	}
	13
	14	dependencies {
	15	compileOnly libs.jdt.annotations
	16
	17	api gradleApi(),
	18	libs.bundles.jackson
	19
	20	implementation project(":common")
	21
	22	testImplementation gradleTestKit()
	23	testImplementation "org.junit.jupiter:junit-jupiter-api:5.11.4"
	24	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.11.4"
	25	testRuntimeOnly "org.junit.platform:junit-platform-launcher:1.11.4"
	26	}
	27
	28	task printVersion{
	29	doLast {
	30	println "project: $project.group:$project.name:$project.version"
	31	println "jar: ${->jar.archiveFileName.get()}"
	32	}
	33	}
	34
	35	test {
	36	useJUnitPlatform()
	37	}
	38
	39	publishing {
	40	repositories {
	41	ivy {
	42	url "${System.properties["user.home"]}/ivy-repo"
	43	}
	44	}
	45	publications {
	46	ivy(IvyPublication) {
	47	from components.java
	48	descriptor.description {
	49	text = providers.provider({ description })
	50	}
	51	}
	52	}
	53	}

variants/src/main/java/org/implab/gradle/variants/VariantsPlugin.java created 644 +17 0

@@ -0,0 +1,17
	1	package org.implab.gradle.variants;
	2
	3	import org.gradle.api.Plugin;
	4	import org.gradle.api.Project;
	5	import org.implab.gradle.variants.model.VariantsExtension;
	6
	7	public abstract class VariantsPlugin implements Plugin<Project> {
	8	@Override
	9	public void apply(Project target) {
	10	var extension = target.getExtensions().create("variants", VariantsExtension.class);
	11
	12	target.afterEvaluate(project -> {
	13
	14	});
	15
	16	}
	17	}

variants/src/main/java/org/implab/gradle/variants/model/Layer.java created 644 +9 0

@@ -0,0 +1,9
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Named;
	4
	5	/**
	6	* Identity-only domain object.
	7	*/
	8	public interface Layer extends Named {
	9	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/Role.java created 644 +9 0

@@ -0,0 +1,9
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Named;
	4
	5	/**
	6	* Identity-only domain object.
	7	*/
	8	public interface Role extends Named {
	9	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/RoleBinding.java created 644 +35 0

@@ -0,0 +1,35
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Named;
	4	import org.gradle.api.provider.SetProperty;
	5
	6	/**
	7	* Binds a role to a set of layers inside a particular variant.
	8	*
	9	* The binding name is the role name, e.g. "production", "test", "tool".
	10	*/
	11	public interface RoleBinding extends Named {
	12
	13	/**
	14	* Layer names participating in this (variant, role) selection.
	15	*
	16	* Core model keeps names here deliberately:
	17	* source/materialization semantics live elsewhere.
	18	*/
	19	SetProperty<String> getLayerNames();
	20
	21	/**
	22	* Adds one layer to this binding.
	23	*/
	24	void layer(String name);
	25
	26	/**
	27	* Adds several layers to this binding.
	28	*/
	29	void layers(String... names);
	30
	31	/**
	32	* Adds several layers to this binding.
	33	*/
	34	void layers(Iterable<String> names);
	35	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/Variant.java created 644 +44 0

@@ -0,0 +1,44
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.Named;
	5	import org.gradle.api.NamedDomainObjectContainer;
	6	import org.implab.gradle.common.core.lang.Closures;
	7
	8	import groovy.lang.Closure;
	9
	10	/**
	11	* A named variant, e.g. "browser", "electron".
	12	*
	13	* A variant does not "have a role" directly.
	14	* It owns a set of role bindings.
	15	*/
	16	public interface Variant extends Named {
	17
	18	/**
	19	* Role bindings declared inside this variant.
	20	*
	21	* The binding name is the role name.
	22	*/
	23	NamedDomainObjectContainer<RoleBinding> getRoleBindings();
	24
	25	/**
	26	* Creates or returns an existing role binding and configures it.
	27	*/
	28	default RoleBinding role(String name) {
	29	return getRoleBindings().maybeCreate(name);
	30	}
	31
	32	/**
	33	* Creates or returns an existing role binding and configures it.
	34	*/
	35	default RoleBinding role(String name, Action<? super RoleBinding> action) {
	36	var role = role(name);
	37	action.execute(role);
	38	return role;
	39	}
	40
	41	default RoleBinding role(String name, Closure<?> closure) {
	42	return role(name, Closures.action(closure));
	43	}
	44	} No newline at end of file

variants/src/main/java/org/implab/gradle/variants/model/VariantsExtension.java created 644 +59 0

@@ -0,0 +1,59
	1	package org.implab.gradle.variants.model;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.NamedDomainObjectContainer;
	5	import org.implab.gradle.common.core.lang.Closures;
	6
	7	import groovy.lang.Closure;
	8
	9	/**
	10	* Root extension:
	11	*
	12	* variants {
	13	* layers { ... }
	14	* roles { ... }
	15	*
	16	* variant("browser") {
	17	* role("production") {
	18	* layers("main", "generated", "mainRjs")
	19	* }
	20	* }
	21	* }
	22	*/
	23	public interface VariantsExtension {
	24
	25	/**
	26	* Domain of layers.
	27	*/
	28	NamedDomainObjectContainer<Layer> getLayers();
	29
	30	/**
	31	* Domain of roles.
	32	*/
	33	NamedDomainObjectContainer<Role> getRoles();
	34
	35	/**
	36	* Declared variants.
	37	*/
	38	NamedDomainObjectContainer<Variant> getVariantDefinitions();
	39
	40	/**
	41	* Creates or returns an existing variant and configures it.
	42	*/
	43	default Variant variant(String name) {
	44	return getVariantDefinitions().maybeCreate(name);
	45	}
	46
	47	/**
	48	* Creates or returns an existing variant and configures it.
	49	*/
	50	default Variant variant(String name, Action<? super Variant> action) {
	51	var variant = variant(name);
	52	action.execute(variant);
	53	return variant;
	54	}
	55
	56	default Variant variant(String name, Closure<?> closure) {
	57	return variant(name, Closures.action(closure));
	58	}
	59	} No newline at end of file

common/readme.md +4 -4

             # Gradle Common Sources Model
             ## NAME
             `gradle-common/common` — набор плагинов для моделирования вариантов сборки,
             регистрации source sets и интеграции этой модели с toolchain-адаптерами.
             ## SYNOPSIS
             ```groovy
             plugins {
                 id 'org.implab.gradle-variants-sources'
             }
             variants {
                 layer('mainBase')
                 layer('mainAmd')
                 variant('browser') {
                     role('main') { layers('mainBase', 'mainAmd') }
                 }
             }
             variantSources {
                 bind('mainBase') {
                     configureSourceSet {
                         declareOutputs('compiled')
                     }
                 }
                 bind('mainAmd').sourceSetNamePattern = '{variant}{layerCap}'
                 whenRegistered { sourceSetName() }
                 whenBound { ctx ->
                     ctx.configureSourceSet {
                         declareOutputs('typings')
                     }
                 }
             }
             ```
             ## DESCRIPTION
             Модуль состоит из трех логических частей:
             - `variants` — декларативная доменная модель сборки;
             - `sources` — модель физически регистрируемых source sets;
             - `variantSources` — адаптер, который связывает первые две модели.
             Ниже раскрытие каждой части.
             ### variants
             `variants` задает структуру пространства сборки: какие есть слои, какие роли
             используют эти слои в каждом варианте, какие есть атрибуты и artifact slots.
             Модель не создает задачи и не привязана к TS/JS.
             Практический смысл:
             - формализовать архитектуру сборки;
             - дать адаптерам единый источник правды.
             ### sources
             `sources` описывает независимые source sets (`GenericSourceSet`) с именованными
             outputs. Это уже "физический" уровень, к которому удобно привязывать задачи,
             артефакты и task inputs/outputs.
             Практический смысл:
             - создать единый контракт по входам/выходам;
             - регистрировать результаты задач как outputs source set;
             - минимизировать ручные `dependsOn` за счет модели outputs.
             ### variantSources
             `variantSources` регистрирует source sets на основе `variants`, применяет
             конфигурацию layer-bindings и отдает события (`whenRegistered`, `whenBound`) для
             адаптеров других плагинов.
             Практический смысл:
             - переводить логическую модель `variants` в executable-модель `sources`;
             - навешивать политики toolchain на зарегистрированные source sets;
             - синхронизировать плагины через replayable callback-контракт.
             ## DOMAIN MODEL
-            - `BuildLayer` — глобальный идентификатор слоя.
+            - `BuildLayer` — canonical identity-model объявленного слоя.
             - `BuildVariant` — агрегат ролей, атрибутов, артефактных слотов.
-            - `BuildRole` — роль внутри варианта, содержит ссылки на layer names.
+            - `BuildRole` — роль внутри варианта, содержит ссылки на declared layer names.
             - `GenericSourceSet` — зарегистрированный набор исходников и outputs.
-            - `BuildLayerBinding` — правила registration source set для конкретного layer.
+            - `LayerBindingSpec` — публичный DSL-contract adapter policy/callbacks для слоя.
             - `SourceSetRegistration` — payload события регистрации source set.
             - `SourceSetUsageBinding` — payload события usage-binding.
             ## EVENT CONTRACT
             - `whenRegistered`:
               - событие нового уникального source set name;
               - replayable.
             - `whenBound`:
               - событие каждой usage-связки `variant/role/layer`;
               - replayable.
             Closure callbacks работают в delegate-first режиме (`@DelegatesTo`). Для
             вложенных closure рекомендуется явный параметр (`ctx -> ...`).
             ## KEY CLASSES
             - `SourcesPlugin` — регистрирует extension `sources`.
             - `GenericSourceSet` — модель источников/outputs для конкретного имени.
             - `VariantsPlugin` — регистрирует extension `variants` и lifecycle finalize.
             - `BuildVariantsExtension` — корневой API модели вариантов.
             - `BuildVariant` — API ролей, attributes и artifact slots варианта.
             - `VariantsSourcesPlugin` — применяет `variants` + `sources` и запускает адаптер.
             - `VariantSourcesExtension` — API bind/events registration.
-            - `BuildLayerBinding` — слой-конкретный DSL для имени и конфигурации source set.
+            - `LayerBindingSpec` — слой-конкретный DSL для policy/configuration source set.
             - `SourceSetRegistration` — payload `whenRegistered(...)`.
             - `SourceSetUsageBinding` — payload `whenBound(...)`.
             ## NOTES
             - Marker ids:
               - `org.implab.gradle-variants`
               - `org.implab.gradle-variants-sources`
             - `SourcesPlugin` пока class-only (без marker id).
             ## SEE ALSO
             - `sources-plugin.md`
             - `variants-plugin.md`
             - `variant-sources-plugin.md`

common/src/main/java/org/implab/gradle/common/sources/BuildVariantsExtension.java +32 -48

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.Collection;
             import java.util.Collections;
             import java.util.LinkedHashMap;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Map;
             import java.util.Optional;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.model.ObjectFactory;
             import groovy.lang.Closure;
             public abstract class BuildVariantsExtension {
-                private final NamedDomainObjectContainer<BuildLayer> layers;
+                private final ObjectFactory objects;
+                private final LinkedHashMap<String, LayoutLayer> layersByName = new LinkedHashMap<>();
                 private final NamedDomainObjectContainer<BuildVariant> variants;
                 private final List<Action<? super BuildVariantsExtension>> finalizedActions = new ArrayList<>();
                 private boolean finalized;
                 @Inject
                 public BuildVariantsExtension(ObjectFactory objects) {
-                    layers = objects.domainObjectContainer(BuildLayer.class);
+                    this.objects = objects;
                     variants = objects.domainObjectContainer(BuildVariant.class);
-                    layers.all(layer -> {
-                        if (finalized)
-                            throw new InvalidUserDataException(
-                                    "Variants model is finalized and cannot add layer '" + layer.getName() + "'");
-                    });
                     variants.all(variant -> {
                         if (finalized)
                             throw new InvalidUserDataException(
                                     "Variants model is finalized and cannot add variant '" + variant.getName() + "'");
                     });
                 }
-                public NamedDomainObjectContainer<BuildLayer> getLayers() {
+                public Collection<LayoutLayer> getLayers() {
-                    return layers;
+                    return Collections.unmodifiableCollection(layersByName.values());
                 }
                 public NamedDomainObjectContainer<BuildVariant> getVariants() {
                     return variants;
                 }
-                public void layers(Action<? super NamedDomainObjectContainer<BuildLayer>> action) {
+                public LayoutLayer layer(String name, Action<? super LayoutLayer> configure) {
                     ensureMutable("configure layers");
-                    action.execute(layers);
+                    var layer = layersByName.computeIfAbsent(requireName(name, "Layer name must not be null or blank"), this::newLayer);
-                public void layers(Closure<?> configure) {
-                    layers(Closures.action(configure));
-                public void variants(Action<? super NamedDomainObjectContainer<BuildVariant>> action) {
-                    ensureMutable("configure variants");
-                    action.execute(variants);
-                public void variants(Closure<?> configure) {
-                    variants(Closures.action(configure));
-                public BuildLayer layer(String name, Action<? super BuildLayer> configure) {
-                    ensureMutable("configure layers");
-                    var layer = layers.maybeCreate(name);
                     configure.execute(layer);
                     return layer;
                 }
-                public BuildLayer layer(String name, Closure<?> configure) {
+                public LayoutLayer layer(String name, Closure<?> configure) {
                     return layer(name, Closures.action(configure));
                 }
-                public BuildLayer layer(String name) {
+                public LayoutLayer layer(String name) {
                     return layer(name, it -> {
                     });
                 }
                 public BuildVariant variant(String name, Action<? super BuildVariant> configure) {
                     ensureMutable("configure variants");
                     var variant = variants.maybeCreate(name);
                     configure.execute(variant);
                     return variant;
                 }
                 public BuildVariant variant(String name, Closure<?> configure) {
                     return variant(name, Closures.action(configure));
                 }
                 public BuildVariant variant(String name) {
                     return variant(name, it -> {
                     });
                 }
                 public void all(Action<? super BuildVariant> action) {
                     variants.all(action);
                 }
                 public void all(Closure<?> configure) {
                     all(Closures.action(configure));
                 }
                 public Collection<BuildVariant> getAll() {
                     var all = new ArrayList<BuildVariant>();
                     variants.forEach(all::add);
                     return Collections.unmodifiableList(all);
                 }
+                public Optional<LayoutLayer> findLayer(String name) {
+                    var normalizedName = normalize(name);
+                    return normalizedName == null ? Optional.empty() : Optional.ofNullable(layersByName.get(normalizedName));
+                }
+                public LayoutLayer requireLayer(String name) {
+                    return findLayer(name)
+                            .orElseThrow(() -> new InvalidUserDataException("Layer '" + name + "' isn't defined"));
+                }
                 public Optional<BuildVariant> find(String name) {
                     return Optional.ofNullable(variants.findByName(name));
                 }
                 public BuildVariant require(String name) {
                     return find(name)
                             .orElseThrow(() -> new InvalidUserDataException("Variant '" + name + "' isn't defined"));
                 }
                 public void whenFinalized(Action<? super BuildVariantsExtension> action) {
                     if (finalized) {
                         action.execute(this);
                         return;
                     }
                     finalizedActions.add(action);
                 }
                 public void whenFinalized(Closure<?> configure) {
                     whenFinalized(Closures.action(configure));
                 }
                 public boolean isFinalized() {
                     return finalized;
                 }
                 public void finalizeModel() {
                     if (finalized)
                         return;
                     validate();
                     for (var variant : variants)
                         variant.finalizeModel();
                     finalized = true;
                     var actions = new ArrayList<>(finalizedActions);
                     finalizedActions.clear();
                     for (var action : actions)
                         action.execute(this);
                 }
                 public void validate() {
                     var errors = new ArrayList<String>();
-                    var layersByName = new LinkedHashMap<String, BuildLayer>();
-                    for (var layer : layers) {
-                        var layerName = normalize(layer.getName());
-                        if (layerName == null) {
-                            errors.add("Layer name must not be blank");
-                            continue;
-                        var previous = layersByName.putIfAbsent(layerName, layer);
-                        if (previous != null) {
-                            errors.add("Layer '" + layerName + "' is declared more than once");
                     for (var variant : variants)
                         validateVariant(variant, layersByName, errors);
                     if (!errors.isEmpty()) {
                         var message = new StringBuilder("Invalid variants model:");
                         for (var error : errors)
                             message.append("\n - ").append(error);
                         throw new InvalidUserDataException(message.toString());
                     }
                 }
-                private static void validateVariant(BuildVariant variant, Map<String, BuildLayer> layersByName, List<String> errors) {
+                private static void validateVariant(BuildVariant variant, Map<String, LayoutLayer> layersByName, List<String> errors) {
                     var variantName = normalize(variant.getName());
                     if (variantName == null) {
                         errors.add("Variant name must not be blank");
                         return;
                     }
                     validateRoleNames(variant, errors);
                     validateRoleMappings(variant, layersByName, errors);
                 }
                 private static void validateRoleNames(BuildVariant variant, List<String> errors) {
                     var roleNames = new LinkedHashSet<String>();
                     for (var role : variant.getRoles()) {
                         var roleName = normalize(role.getName());
                         if (roleName == null) {
                             errors.add("Variant '" + variant.getName() + "' contains blank role name");
                             continue;
                         }
                         if (!roleNames.add(roleName)) {
                             errors.add("Variant '" + variant.getName() + "' contains duplicated role name '" + roleName + "'");
                         }
                     }
                 }
-                private static void validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
+                private static void validateRoleMappings(BuildVariant variant, Map<String, LayoutLayer> layersByName,
                         List<String> errors) {
                     for (var role : variant.getRoles()) {
                         var seenLayers = new LinkedHashSet<String>();
                         for (var layerName : role.getLayers().getOrElse(List.of())) {
                             var normalizedLayerName = normalize(layerName);
                             if (normalizedLayerName == null) {
                                 errors.add("Variant '" + variant.getName() + "', role '" + role.getName() + "' contains blank layer name");
                                 continue;
                             }
                             var layer = layersByName.get(normalizedLayerName);
                             if (layer == null) {
                                 errors.add("Variant '" + variant.getName() + "' references unknown layer '" + normalizedLayerName + "'");
                                 continue;
                             }
                             if (!seenLayers.add(normalizedLayerName)) {
                                 errors.add("Variant '" + variant.getName() + "', role '" + role.getName()
                                         + "' contains duplicated layer reference '" + normalizedLayerName + "'");
                             }
                         }
                     }
                 }
                 private static String normalize(String value) {
                     if (value == null)
                         return null;
                     var trimmed = value.trim();
                     return trimmed.isEmpty() ? null : trimmed;
                 }
+                private static String requireName(String value, String errorMessage) {
+                    var normalized = normalize(value);
+                    if (normalized == null)
+                        throw new InvalidUserDataException(errorMessage);
+                    return normalized;
+                }
+                private LayoutLayer newLayer(String name) {
+                    return objects.newInstance(LayoutLayer.class, name);
+                }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("Variants model is finalized and cannot " + operation);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/LayerBinding.java ~~common/src/main/java/org/implab/gradle/common/sources/BuildLayerBinding.java~~ renamed +14 -51

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Set;
-            import javax.inject.Inject;
-            import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
-            import org.gradle.api.Named;
             import org.gradle.api.NamedDomainObjectProvider;
+            import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Property;
-            import groovy.lang.Closure;
+            final class LayerBinding implements LayerBindingSpec {
-            import groovy.lang.DelegatesTo;
+                static final String DEFAULT_SOURCE_SET_NAME_PATTERN = "{variant}{layerCap}";
-            /**
-             * Maps a logical layer to per-source-set hooks.
-             */
-            public abstract class BuildLayerBinding implements Named {
-                public static final String DEFAULT_SOURCE_SET_NAME_PATTERN = "{variant}{layerCap}";
                 private final String name;
+                private final Property<String> sourceSetNamePattern;
                 private final List<Action<? super GenericSourceSet>> sourceSetConfigureActions = new ArrayList<>();
                 private final List<Action<? super SourceSetRegistration>> registeredActions = new ArrayList<>();
                 private final List<Action<? super SourceSetUsageBinding>> boundActions = new ArrayList<>();
                 private final List<NamedDomainObjectProvider<GenericSourceSet>> registeredSourceSets = new ArrayList<>();
                 private final List<SourceSetRegistration> registeredContexts = new ArrayList<>();
                 private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
                 private final Set<String> registeredSourceSetNames = new LinkedHashSet<>();
-                @Inject
+                LayerBinding(String name, ObjectFactory objects) {
-                public BuildLayerBinding(String name) {
                     this.name = name;
-                    getSourceSetNamePattern().convention(DEFAULT_SOURCE_SET_NAME_PATTERN);
+                    sourceSetNamePattern = objects.property(String.class);
+                    sourceSetNamePattern.convention(DEFAULT_SOURCE_SET_NAME_PATTERN);
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
-                public abstract Property<String> getSourceSetNamePattern();
+                @Override
+                public Property<String> getSourceSetNamePattern() {
+                    return sourceSetNamePattern;
+                }
-                /**
+                @Override
-                 * Action applied to every registered source set for this layer.
-                 * Already registered source sets are configured immediately (replay).
-                 */
                 public void configureSourceSet(Action<? super GenericSourceSet> configure) {
                     sourceSetConfigureActions.add(configure);
                     for (var sourceSet : registeredSourceSets)
                         sourceSet.configure(configure);
                 }
-                public void configureSourceSet(
+                @Override
-                        @DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
-                    configureSourceSet(Closures.action(configure));
-                /**
-                 * Layer-local callback fired after source-set registration.
-                 * Already emitted registrations are delivered immediately (replay).
-                 * For simple callbacks you can use delegate-only style
-                 * (for example {@code whenRegistered { sourceSetName() }}).
-                 * For nested closures prefer explicit parameter
-                 * ({@code whenRegistered { ctx -> ... }}).
-                 */
                 public void whenRegistered(Action<? super SourceSetRegistration> action) {
                     registeredActions.add(action);
                     for (var context : registeredContexts)
                         action.execute(context);
                 }
-                public void whenRegistered(
+                @Override
-                        @DelegatesTo(value = SourceSetRegistration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
-                    whenRegistered(Closures.action(action));
-                /**
-                 * Layer-local callback fired for every resolved variant/role/layer usage.
-                 * Already emitted usage bindings are delivered immediately (replay).
-                 * For simple callbacks you can use delegate-only style
-                 * (for example {@code whenBound { variantName() }}).
-                 * For nested closures prefer explicit parameter
-                 * ({@code whenBound { ctx -> ... }}).
-                 */
                 public void whenBound(Action<? super SourceSetUsageBinding> action) {
                     boundActions.add(action);
                     for (var context : boundContexts)
                         action.execute(context);
                 }
-                public void whenBound(
-                        @DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
-                    whenBound(Closures.action(action));
                 void notifyRegistered(SourceSetRegistration registration) {
                     if (registeredSourceSetNames.add(registration.sourceSetName())) {
                         var sourceSet = registration.sourceSet();
                         registeredSourceSets.add(sourceSet);
                         for (var action : sourceSetConfigureActions)
                             sourceSet.configure(action);
                     }
                     registeredContexts.add(registration);
                     for (var action : registeredActions)
                         action.execute(registration);
                 }
                 void notifyBound(SourceSetUsageBinding binding) {
                     boundContexts.add(binding);
                     for (var action : boundActions)
                         action.execute(binding);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/LayoutLayer.java ~~common/src/main/java/org/implab/gradle/common/sources/BuildLayer.java~~ renamed +3 -3

             package org.implab.gradle.common.sources;
             import javax.inject.Inject;
             import org.gradle.api.Named;
             /**
-             * Global layer declaration used by build variants.
+             * Canonical identity model for a declared layout layer.
              */
-            public abstract class BuildLayer implements Named {
+            public abstract class LayoutLayer implements Named {
                 private final String name;
                 @Inject
-                public BuildLayer(String name) {
+                public LayoutLayer(String name) {
                     this.name = name;
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/SourceSetRegistration.java +1 -1

             package org.implab.gradle.common.sources;
             import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectProvider;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             /**
              * Immutable payload for a newly registered {@link GenericSourceSet}.
              *
              * <p>Used as callback payload for
              * {@link VariantSourcesExtension#whenRegistered(org.gradle.api.Action)} and
-             * {@link BuildLayerBinding#whenRegistered(org.gradle.api.Action)}.
+             * {@link LayerBindingSpec#whenRegistered(org.gradle.api.Action)}.
              *
              * @param layerName normalized layer name that owns the registration
              * @param sourceSetName source-set name registered in the container
              * @param sourceSet provider of the registered source set (realized later by Gradle on demand)
              */
             public record SourceSetRegistration(
                     String layerName,
                     String sourceSetName,
                     NamedDomainObjectProvider<GenericSourceSet> sourceSet) {
                 public void configureSourceSet(Action<? super GenericSourceSet> action) {
                     sourceSet.configure(action);
                 }
                 public void configureSourceSet(
                         @DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     configureSourceSet(Closures.action(action));
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/SourceSetUsageBinding.java +1 -1

             package org.implab.gradle.common.sources;
             import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectProvider;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             /**
              * Immutable payload for a resolved variant/role/layer usage bound to a source set.
              *
              * <p>Used as callback payload for
              * {@link VariantSourcesExtension#whenBound(org.gradle.api.Action)} and
-             * {@link BuildLayerBinding#whenBound(org.gradle.api.Action)}.
+             * {@link LayerBindingSpec#whenBound(org.gradle.api.Action)}.
              *
              * @param variantName variant name from the build-variants model
              * @param roleName role name inside the resolved variant
              * @param layerName normalized layer name used to resolve the source set
              * @param sourceSetName source-set name registered in the container
              * @param sourceSet provider of the registered source set (realized later by Gradle on demand)
              */
             public record SourceSetUsageBinding(
                     String variantName,
                     String roleName,
                     String layerName,
                     String sourceSetName,
                     NamedDomainObjectProvider<GenericSourceSet> sourceSet) {
                 public void configureSourceSet(Action<? super GenericSourceSet> action) {
                     sourceSet.configure(action);
                 }
                 public void configureSourceSet(
                         @DelegatesTo(value = GenericSourceSet.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     configureSourceSet(Closures.action(action));
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactSlot.java +4 0

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.Collection;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Set;
             import java.util.function.Consumer;
             import java.util.function.Predicate;
             import java.util.stream.Stream;
             import javax.inject.Inject;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             /**
              * One artifact representation slot inside {@link VariantArtifact}.
              *
              * <p>
              * The DSL exposed by this type is topology-aware sugar over an internal
              * contribution model:
              * <ul>
              * <li>{@link #from(Object)} adds one direct contribution that does not depend
              * on {@link VariantSourcesExtension} bindings;</li>
              * <li>{@link #fromVariant(Action)}, {@link #fromRole(String, Action)} and
              * {@link #fromLayer(String, Action)} define where a contribution is active in
              * the variant/role/layer topology;</li>
              * <li>{@link OutputSelectionSpec#output(String)} defines which named output of
              * the matched {@link GenericSourceSet} should be added to the slot.</li>
              * </ul>
              *
              * <p>
              * Internally the slot stores contribution resolvers rather than raw output
              * names. Each contribution can later materialize itself against the
              * variant-specific source-set bindings and return:
              * <ul>
              * <li>a file notation object suitable for {@code files.from(...)}</li>
              * <li>a {@link BindingKey} used to deduplicate repeated logical inputs during
              * materialization</li>
              * </ul>
              *
              * <p>
              * Validation is intentionally separated from materialization: the slot keeps
              * topology references in {@link #referencedRoleNames()} and
              * {@link #referencedLayerNames()}, while the actual contribution pipeline is
              * exposed through {@link #bindings()}.
              */
             @NonNullByDefault
             public class VariantArtifactSlot implements Named {
                 private final String name;
                 private final List<BindingResolver> bindings = new ArrayList<>();
                 private final Set<String> referencedRoleNames = new LinkedHashSet<>();
                 private final Set<String> referencedLayerNames = new LinkedHashSet<>();
                 private boolean finalized;
                 @Inject
                 public VariantArtifactSlot(String name) {
                     this.name = VariantArtifact.normalize(name, "slot name must not be null or blank");
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 public void fromVariant(Action<? super OutputSelectionSpec> configure) {
                     addContributions(context -> true, configure);
                 }
                 public void fromVariant(
                         @DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     fromVariant(Closures.action(configure));
                 }
                 public void fromRole(String roleName, Action<? super OutputSelectionSpec> configure) {
                     var normalizedRoleName = VariantArtifact.normalize(roleName, "role name must not be null or blank");
                     addContributions(context -> context.roleName().equals(normalizedRoleName), configure);
                     referencedRoleNames.add(normalizedRoleName);
                 }
                 public void fromRole(
                         String roleName,
                         @DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     fromRole(roleName, Closures.action(configure));
                 }
                 public void fromLayer(String layerName, Action<? super OutputSelectionSpec> configure) {
                     var normalizedLayerName = VariantArtifact.normalize(layerName, "layer name must not be null or blank");
                     addContributions(context -> context.layerName().equals(normalizedLayerName), configure);
                     referencedLayerNames.add(normalizedLayerName);
                 }
                 public void fromLayer(
                         String layerName,
                         @DelegatesTo(value = OutputSelectionSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     fromLayer(layerName, Closures.action(configure));
                 }
                 /**
                  * Adds one direct slot contribution.
                  *
                  * <p>The supplied object is forwarded as-is to {@code files.from(...)}
                  * during slot materialization and does not depend on
                  * {@link VariantSourcesExtension#whenBound(Action)} callbacks.
                  */
                 public void from(Object files) {
                     ensureMutable("configure sources");
                     if (files == null)
                         throw new InvalidUserDataException("slot source must not be null");
                     var key = BindingKey.newUniqueKey("direct slot input for '" + name + "'");
                     bindings.add((contexts, consumer) -> consumer.accept(new ResolvedBinding(key, files)));
                 }
                 List<BindingResolver> bindings() {
                     return List.copyOf(bindings);
                 }
+                void acceptBindings(Consumer<? super BindingResolver> consumer) {
+                    bindings.forEach(consumer);
+                }
                 Set<String> referencedRoleNames() {
                     return Set.copyOf(referencedRoleNames);
                 }
                 Set<String> referencedLayerNames() {
                     return Set.copyOf(referencedLayerNames);
                 }
                 void finalizeModel() {
                     finalized = true;
                 }
                 private void addContributions(
                         Predicate<SourceSetUsageBinding> selector,
                         Action<? super OutputSelectionSpec> configure) {
                     ensureMutable("configure sources");
                     var spec = new OutputSelectionSpec(selector);
                     configure.execute(spec);
                     spec.accept(bindings::add);
                 }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException(
                                 "Variant artifact slot '" + name + "' is finalized and cannot " + operation);
                 }
                 /**
                  * Local DSL buffer for one {@code fromVariant/fromRole/fromLayer} block.
                  *
                  * <p>
                  * The spec accumulates contributions locally and flushes them to the
                  * owning slot only after the outer configure block completes successfully.
                  */
                 public final class OutputSelectionSpec {
                     private final Predicate<SourceSetUsageBinding> selector;
                     private final List<BindingResolver> bindings = new ArrayList<>();
                     private OutputSelectionSpec(Predicate<SourceSetUsageBinding> selector) {
                         this.selector = selector;
                     }
                     public void output(String name) {
                         var outputName = VariantArtifact.normalize(name, "output name must not be null or blank");
                         bindings.add((contexts, consumer) -> contexts.stream()
                                 .filter(selector)
                                 .map(context -> resolveOutput(context, outputName))
                                 .forEach(consumer));
                     }
                     public void output(String name, String... extra) {
                         Stream.concat(Stream.of(name), Stream.of(extra))
                                 .forEach(this::output);
                     }
                     private ResolvedBinding resolveOutput(SourceSetUsageBinding context, String outputName) {
                         var key = new SourceSetOutputKey(context.sourceSetName(), outputName);
                         var files = context.sourceSet().map(sourceSet -> sourceSet.output(outputName));
                         return new ResolvedBinding(key, files);
                     }
                     void accept(Consumer<? super BindingResolver> consumer) {
                         bindings.forEach(consumer);
                     }
                 }
                 @FunctionalInterface
                 interface BindingResolver {
                     void resolve(Collection<SourceSetUsageBinding> contexts, Consumer<? super ResolvedBinding> consumer);
                 }
                 /**
                  * Materialized slot contribution for one concrete source-set binding.
                  */
                 record ResolvedBinding(BindingKey key, Object files) {
                 }
                 /**
                  * Marker key for deduplicating logical slot inputs during materialization.
                  *
                  * <p>
                  * Semantic keys such as {@link SourceSetOutputKey} collapse repeated
                  * references to the same logical output. Identity keys created via
                  * {@link #newUniqueKey()} or {@link #newUniqueKey(String)} can be used by contributions
                  * that must flow through the same pipeline but should never be merged.
                  */
                 interface BindingKey {
                     static BindingKey newUniqueKey(String hint) {
                         return new BindingKey() {
                             @Override
                             public String toString() {
                                 return hint;
                             }
                         };
                     }
                     static BindingKey newUniqueKey() {
                         return newUniqueKey("unnamed");
                     }
                 }
                 /**
                  * Stable dedupe key for one named output of one resolved source set.
                  */
                 record SourceSetOutputKey(String sourceSetName, String outputName) implements BindingKey {
                     @Override
                     public String toString() {
                         return "sourceSet '" + sourceSetName + "' output '" + outputName + "'";
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsPlugin.java +7 -4

             package org.implab.gradle.common.sources;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.ArrayList;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import org.gradle.api.GradleException;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.artifacts.ConfigurationPublications;
             import org.gradle.api.artifacts.ConfigurationVariant;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             import org.implab.gradle.common.core.lang.Strings;
             public abstract class VariantArtifactsPlugin implements Plugin<Project> {
                 private static final Logger logger = Logging.getLogger(VariantArtifactsPlugin.class);
                 public static final String VARIANT_ARTIFACTS_EXTENSION_NAME = "variantArtifacts";
                 @Override
                 public void apply(Project target) {
                     logger.debug("Registering '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
                     target.getPluginManager().apply(VariantsSourcesPlugin.class);
                     var variants = VariantsPlugin.getVariantsExtension(target);
                     var variantSources = target.getExtensions().getByType(VariantSourcesExtension.class);
                     var variantArtifacts = target.getExtensions()
                             .create(VARIANT_ARTIFACTS_EXTENSION_NAME, VariantArtifactsExtension.class);
                     var variantArtifactsResolver = new VariantArtifactsResolver(target.getObjects());
                     var artifactAssemblies = new ArtifactAssemblyRegistry(target.getObjects(), target.getTasks());
-                    // Bind variant artifacts resolution to variant sources registration, so that artifact resolution can be performed
+                    // Bind variant artifacts resolution to variant sources registration, so that
+                    // artifact resolution can be performed
                     variantSources.whenBound(variantArtifactsResolver::recordBinding);
                     variants.whenFinalized(model -> {
                         logger.debug("Finalizing variantArtifacts model on project '{}'", target.getPath());
                         variantArtifacts.finalizeModel(model);
                         materializeOutgoingVariants(target, model, variantArtifacts, variantArtifactsResolver, artifactAssemblies);
                         logger.debug("variantArtifacts model finalized on project '{}'", target.getPath());
                     });
                 }
                 public static VariantArtifactsExtension getVariantArtifactsExtension(Project target) {
                     var extension = target.getExtensions().findByType(VariantArtifactsExtension.class);
                     if (extension == null) {
                         logger.error("variantArtifacts extension '{}' isn't found on project '{}'",
                                 VARIANT_ARTIFACTS_EXTENSION_NAME,
                                 target.getPath());
                         throw new GradleException("variantArtifacts extension isn't found");
                     }
                     logger.debug("Resolved '{}' extension on project '{}'", VARIANT_ARTIFACTS_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
                 private static void materializeOutgoingVariants(
                         Project project,
                         BuildVariantsExtension topology,
                         VariantArtifactsExtension variantArtifacts,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies) {
                     variantArtifacts.getVariants().stream()
                             .filter(variantArtifact -> !variantArtifact.getSlots().isEmpty())
                             .forEach(variantArtifact -> materializeOutgoingVariant(
                                     project,
                                     topology.require(variantArtifact.getName()),
                                     variantArtifact,
                                     variantArtifactsResolver,
                                     artifactAssemblies,
                                     variantArtifacts));
                 }
                 private static void materializeOutgoingVariant(
                         Project project,
                         BuildVariant topologyVariant,
                         VariantArtifact variantArtifact,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies,
                         VariantArtifactsExtension variantArtifacts) {
                     var assemblies = variantArtifact.getSlots().stream()
                             .collect(Collectors.toMap(
                                     VariantArtifactSlot::getName,
-                                    slot -> registerAssembly(project, variantArtifactsResolver, artifactAssemblies, variantArtifact, slot),
+                                    slot -> registerAssembly(project, variantArtifactsResolver, artifactAssemblies, variantArtifact,
+                                            slot),
                                     (left, right) -> left,
                                     LinkedHashMap::new));
                     var primarySlot = variantArtifact.requirePrimarySlot();
                     var configuration = createOutgoingConfiguration(project, variantArtifact.getName(), primarySlot.getName());
                     var primaryAssembly = assemblies.get(primarySlot.getName());
                     publishPrimaryArtifact(configuration, primaryAssembly);
                     var primaryPublication = new OutgoingArtifactSlotPublication(
                             primarySlot.getName(),
                             true,
                             primarySlot,
                             primaryAssembly,
                             configuration);
                     var secondarySlots = variantArtifact.getSlots().stream()
                             .filter(slot -> !slot.getName().equals(primarySlot.getName()))
                             .map(slot -> new SecondarySlot(slot, assemblies.get(slot.getName())))
                             .toList();
                     var secondaryPublications = new ArrayList<OutgoingArtifactSlotPublication>(secondarySlots.size());
                     secondarySlots.forEach(secondarySlot -> {
                         var secondaryVariant = configuration.getOutgoing().getVariants().create(secondarySlot.slot().getName());
                         publishSecondaryArtifact(secondaryVariant, secondarySlot.assembly());
                         secondaryPublications.add(new OutgoingArtifactSlotPublication(
                                 secondarySlot.slot().getName(),
                                 false,
                                 secondarySlot.slot(),
                                 secondarySlot.assembly(),
                                 secondaryVariant));
                     });
                     var slotPublications = Stream.concat(
                             Stream.of(primaryPublication),
                             secondaryPublications.stream())
                             .toList();
                     variantArtifacts.notifyOutgoingVariant(new OutgoingVariantPublication(
                             variantArtifact.getName(),
                             topologyVariant,
                             variantArtifact,
                             configuration,
                             primaryPublication,
                             slotPublications));
                 }
                 private static ArtifactAssembly registerAssembly(
                         Project project,
                         VariantArtifactsResolver variantArtifactsResolver,
                         ArtifactAssemblyRegistry artifactAssemblies,
                         VariantArtifact variantArtifact,
                         VariantArtifactSlot slot) {
+                    String assemblyName = variantArtifact.getName() + Strings.capitalize(slot.getName());
                     return artifactAssemblies.register(
-                            variantArtifact.getName() + Strings.capitalize(slot.getName()),
+                            assemblyName,
-                            "process" + Strings.capitalize(variantArtifact.getName()) + Strings.capitalize(slot.getName()),
+                            "process" + Strings.capitalize(assemblyName),
                             project.getLayout().getBuildDirectory()
                                     .dir("variant-artifacts/" + variantArtifact.getName() + "/" + slot.getName()),
                             files -> files.from(variantArtifactsResolver.files(variantArtifact.getName(), slot)));
                 }
                 private static Configuration createOutgoingConfiguration(
                         Project project,
                         String variantName,
                         String primarySlotName) {
                     var configName = variantName + "Elements";
                     return project.getConfigurations().consumable(configName, config -> {
                         config.setVisible(true);
                         config.setDescription("Consumable assembled artifacts for variant '" + variantName
                                 + "' with primary slot '" + primarySlotName + "'");
                     }).get();
                 }
                 private static void publishPrimaryArtifact(Configuration configuration, ArtifactAssembly assembly) {
                     publishArtifact(configuration.getOutgoing(), assembly);
                 }
                 private static void publishSecondaryArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
                     publishArtifact(variant, assembly);
                 }
                 private static void publishArtifact(ConfigurationPublications outgoing, ArtifactAssembly assembly) {
                     outgoing.artifact(assembly.output().getSingleFile(), published -> {
                         published.builtBy(assembly.output().getBuildDependencies());
                     });
                 }
                 private static void publishArtifact(ConfigurationVariant variant, ArtifactAssembly assembly) {
                     variant.artifact(assembly.output().getSingleFile(), published -> {
                         published.builtBy(assembly.output().getBuildDependencies());
                     });
                 }
                 private record SecondarySlot(VariantArtifactSlot slot, ArtifactAssembly assembly) {
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantArtifactsResolver.java +10 -5

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
+            import java.util.Collection;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Set;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.file.ConfigurableFileCollection;
             import org.gradle.api.file.FileCollection;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.sources.VariantArtifactSlot.BindingKey;
             /**
              * Resolves artifact-slot inputs from already bound variant source-set usages.
              *
              * <p>This type is the bridge between two models:
              * <ul>
              * <li>{@link VariantSourcesExtension}, which emits resolved
              * {@link SourceSetUsageBinding variant/role/layer -> source-set} bindings;</li>
              * <li>{@link VariantArtifactSlot}, which exposes a DSL over slot contributions
              * and stores the resulting {@link VariantArtifactSlot.BindingResolver
              * contribution resolvers}.</li>
              * </ul>
              *
              * <p>The resolver records each emitted {@link SourceSetUsageBinding} and later
              * materializes a {@link FileCollection} for one concrete variant/slot pair.
              * For each variant/slot pair it asks the slot to materialize its contributions,
              * passes in the resolved source-set bindings for that variant, and
              * deduplicates resulting inputs by {@link BindingKey}. Contributions that do
              * not depend on topology bindings can still emit direct inputs even when that
              * binding collection is empty. The returned files are then typically wired into
              * an {@link ArtifactAssembly} as its sources.
              *
              * <p>Direct clients are infrastructure code rather than build scripts. The
              * typical usage pattern is:
              * <ol>
              * <li>create one resolver per project;</li>
              * <li>subscribe {@link #recordBinding(SourceSetUsageBinding)} to
              * {@link VariantSourcesExtension#whenBound(org.gradle.api.Action)};</li>
              * <li>call {@link #files(String, VariantArtifactSlot)} while registering an
              * {@link ArtifactAssembly} or another consumer that needs the slot inputs.</li>
              * </ol>
              *
              * <p>Build-script users normally do not instantiate this class directly. They
              * configure {@code variantArtifacts}, and {@link VariantArtifactsPlugin} uses
              * this resolver internally to turn slot rules into assembly inputs.
              */
             @NonNullByDefault
             public final class VariantArtifactsResolver {
                 private final ObjectFactory objects;
                 private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
                 public VariantArtifactsResolver(ObjectFactory objects) {
                     this.objects = objects;
                 }
                 /**
                  * Records one resolved variant source-set usage.
                  *
                  * <p>Intended to be used as a callback target for
                  * {@link VariantSourcesExtension#whenBound(org.gradle.api.Action)}.
                  *
                  * @param context resolved variant/role/layer usage bound to a source set
                  */
                 public void recordBinding(SourceSetUsageBinding context) {
                     boundContexts.add(context);
                 }
                 /**
                  * Returns all source-set outputs selected by the given slot for the given
                  * variant.
                  *
                  * <p>The result is built from recorded {@link SourceSetUsageBinding}
                  * instances whose {@link SourceSetUsageBinding#variantName()} matches
                  * {@code variantName}. Each matching binding is then fed into the slot
                  * contribution pipeline; if multiple contributions resolve to the same
                  * {@link BindingKey}, that source is included only once.
                  *
                  * <p>This method does not validate the model; validation is expected to be
                  * performed earlier by {@link VariantArtifactsExtension}. Unknown variants
                  * or slots with no matching rules simply produce an empty collection.
                  *
                  * @param variantName variant whose bound source-set usages should be scanned
                  * @param slot slot definition that selects which outputs should be included
                  * @return lazily wired file collection for the selected outputs
                  */
                 public FileCollection files(String variantName, VariantArtifactSlot slot) {
-                    var builder = new FileCollectionBuilder();
                     var contexts = boundContexts.stream()
                             .filter(context -> variantName.equals(context.variantName()))
                             .toList();
+                    var builder = new FileCollectionBuilder(contexts);
-                    slot.bindings().forEach(binding -> binding.resolve(contexts, builder::addOutput));
+                    slot.acceptBindings(builder::visitBinding);
                     return builder.build();
                 }
                 /**
                  * Local materialization helper for one {@link #files(String, VariantArtifactSlot)}
                  * call.
                  */
                 class FileCollectionBuilder {
                     private final ConfigurableFileCollection files;
                     private final Set<BindingKey> boundOutputs = new LinkedHashSet<>();
+                    private final Collection<SourceSetUsageBinding> contexts;
-                    FileCollectionBuilder() {
+                    FileCollectionBuilder(Collection<SourceSetUsageBinding> contexts) {
                         this.files = objects.fileCollection();
+                        this.contexts = contexts;
                     }
                     FileCollection build() {
                         return files;
                     }
                     void addOutput(VariantArtifactSlot.ResolvedBinding binding) {
                         if (boundOutputs.add(binding.key()))
                             files.from(binding.files());
                     }
+                    void visitBinding(VariantArtifactSlot.BindingResolver resolver) {
+                        resolver.resolve(contexts, this::addOutput);
+                    }
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java +47 -38

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.regex.Matcher;
             import java.util.regex.Pattern;
             import java.util.stream.Stream;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.implab.gradle.common.core.lang.Strings;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.eclipse.jdt.annotation.Nullable;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
-            import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
             import static org.implab.gradle.common.core.lang.Strings.sanitizeName;
             /**
              * Adapter extension that registers source sets for variant/layer pairs.
              */
             @NonNullByDefault
             public abstract class VariantSourcesExtension {
                 private static final Logger logger = Logging.getLogger(VariantSourcesExtension.class);
                 private static final Pattern SOURCE_SET_NAME_TOKEN = Pattern.compile("\\{([A-Za-z][A-Za-z0-9]*)\\}");
+                private final ObjectFactory objects;
                 private final ProjectLayout layout;
-                private final NamedDomainObjectContainer<BuildLayerBinding> bindings;
+                private final LinkedHashMap<String, LayerBinding> bindingsByName = new LinkedHashMap<>();
                 private final List<Action<? super SourceSetRegistration>> registeredActions = new ArrayList<>();
                 private final List<Action<? super SourceSetUsageBinding>> boundActions = new ArrayList<>();
                 private final List<SourceSetRegistration> registeredContexts = new ArrayList<>();
                 private final List<SourceSetUsageBinding> boundContexts = new ArrayList<>();
                 private final LinkedHashMap<String, NamedDomainObjectProvider<GenericSourceSet>> sourceSetsByName = new LinkedHashMap<>();
                 private final LinkedHashMap<String, String> sourceSetLayersByName = new LinkedHashMap<>();
                 private boolean sourceSetsRegistered;
                 @Inject
                 public VariantSourcesExtension(ObjectFactory objects, ProjectLayout layout) {
+                    this.objects = objects;
                     this.layout = layout;
-                    bindings = objects.domainObjectContainer(BuildLayerBinding.class);
                 }
-                public NamedDomainObjectContainer<BuildLayerBinding> getBindings() {
+                public List<LayerBindingSpec> getBindings() {
-                    return bindings;
+                    return bindingsByName.values().stream().map(x -> (LayerBindingSpec)x).toList();
                 }
-                public void bindings(Action<? super NamedDomainObjectContainer<BuildLayerBinding>> action) {
+                public LayerBindingSpec bind(String layer) {
-                    action.execute(bindings);
+                    return bindingsByName.computeIfAbsent(
+                            normalize(layer, "Layer name must not be null or blank"),
+                            name -> new LayerBinding(name, objects));
                 }
-                public void bindings(
+                public LayerBindingSpec bind(LayoutLayer layer) {
-                        @DelegatesTo(value = NamedDomainObjectContainer.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
+                    return bind(layer.getName());
-                    bindings(Closures.action(action));
-                public BuildLayerBinding bind(String layer) {
-                    return bindings.maybeCreate(normalize(layer, "Layer name must not be null or blank"));
                 }
                 /**
                  * Configures per-layer binding.
                  */
-                public BuildLayerBinding bind(String layer, Action<? super BuildLayerBinding> configure) {
+                public LayerBindingSpec bind(String layer, Action<? super LayerBindingSpec> configure) {
                     var binding = bind(layer);
                     configure.execute(binding);
                     return binding;
                 }
-                public BuildLayerBinding bind(String layer,
+                public LayerBindingSpec bind(LayoutLayer layer, Action<? super LayerBindingSpec> configure) {
-                        @DelegatesTo(value = BuildLayerBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
+                    var binding = bind(layer);
+                    configure.execute(binding);
+                    return binding;
+                }
+                public LayerBindingSpec bind(String layer,
+                        @DelegatesTo(value = LayerBindingSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
+                    return bind(layer, Closures.action(configure));
+                }
+                public LayerBindingSpec bind(LayoutLayer layer,
+                        @DelegatesTo(value = LayerBindingSpec.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return bind(layer, Closures.action(configure));
                 }
                 /**
                  * Global callback fired for each registered source set.
                  * Already emitted registrations are delivered immediately (replay).
                  * For simple callbacks you can use delegate-only style
                  * (for example {@code whenRegistered { sourceSetName() }}).
                  * For nested closures prefer explicit parameter
                  * ({@code whenRegistered { ctx -> ... }}).
                  */
                 public void whenRegistered(Action<? super SourceSetRegistration> action) {
                     registeredActions.add(action);
                     for (var context : registeredContexts)
                         action.execute(context);
                 }
                 public void whenRegistered(
                         @DelegatesTo(value = SourceSetRegistration.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenRegistered(Closures.action(action));
                 }
                 /**
                  * Global callback fired for every resolved variant/role/layer usage.
                  * Already emitted usage bindings are delivered immediately (replay).
                  * For simple callbacks you can use delegate-only style
                  * (for example {@code whenBound { variantName() }}).
                  * For nested closures prefer explicit parameter
                  * ({@code whenBound { ctx -> ... }}).
                  */
                 public void whenBound(Action<? super SourceSetUsageBinding> action) {
                     boundActions.add(action);
                     for (var context : boundContexts)
                         action.execute(context);
                 }
                 public void whenBound(
                         @DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenBound(Closures.action(action));
                 }
                 public void whenBound(String variantName, Action<? super SourceSetUsageBinding> action) {
                     var normalizedVariantName = normalize(variantName, "variantName must not be null or blank");
                     whenBound(filterByVariant(normalizedVariantName, action));
                 }
                 public void whenBound(String variantName,
                         @DelegatesTo(value = SourceSetUsageBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenBound(variantName, Closures.action(action));
                 }
-                void registerSourceSets(BuildVariantsExtension variants, NamedDomainObjectContainer<GenericSourceSet> sources) {
+                void registerSourceSets(BuildVariantsExtension variants, org.gradle.api.NamedDomainObjectContainer<GenericSourceSet> sources) {
                     if (sourceSetsRegistered) {
                         throw new InvalidUserDataException("variantSources source sets are already registered");
                     }
-                    validateBindings(variants);
+                    resolveBindings(variants);
                     var usages = layerUsages(variants).toList();
                     var registeredBefore = registeredContexts.size();
                     var boundBefore = boundContexts.size();
                     logger.debug(
                             "Starting variant source-set registration (variants={}, layers={}, bindings={}, usages={})",
                             variants.getVariants().size(),
                             variants.getLayers().size(),
-                            bindings.size(),
+                            bindingsByName.size(),
                             usages.size());
                     usages.forEach(usage -> registerLayerUsage(usage, sources));
                     logger.debug(
                             "Completed variant source-set registration (newSourceSets={}, newBounds={}, totalSourceSets={})",
                             registeredContexts.size() - registeredBefore,
                             boundContexts.size() - boundBefore,
                             sourceSetsByName.size());
                     sourceSetsRegistered = true;
                 }
                 private Stream<LayerUsage> layerUsages(BuildVariantsExtension variants) {
                     return variants.getVariants().stream()
                             .flatMap(variant -> variant.getRoles().stream()
                                     .flatMap(role -> role.getLayers().getOrElse(List.of()).stream()
                                             .map(layerName -> new LayerUsage(
                                                     variant.getName(),
                                                     role.getName(),
-                                                    normalize(layerName, "Layer name in variant '" + variant.getName()
+                                                    variants.requireLayer(normalize(layerName, "Layer name in variant '"
-                                                            + "' and role '" + role.getName() + "' must not be null or blank")))));
+                                                            + variant.getName() + "' and role '" + role.getName()
+                                                            + "' must not be null or blank"))))));
                 }
-                private void registerLayerUsage(LayerUsage usage, NamedDomainObjectContainer<GenericSourceSet> sources) {
+                private void registerLayerUsage(LayerUsage usage, org.gradle.api.NamedDomainObjectContainer<GenericSourceSet> sources) {
-                    var resolvedBinding = bind(usage.layerName());
+                    var resolvedBinding = binding(usage.layer().getName());
                     var sourceSetNamePattern = resolvedBinding.getSourceSetNamePattern();
                     sourceSetNamePattern.finalizeValueOnRead();
                     var sourceSetName = sourceSetName(usage, sourceSetNamePattern.get());
-                    ensureSourceSetNameBoundToSingleLayer(sourceSetName, usage.layerName());
+                    ensureSourceSetNameBoundToSingleLayer(sourceSetName, usage.layer().getName());
                     var isNewSourceSet = !sourceSetsByName.containsKey(sourceSetName);
                     var sourceSet = sourceSetsByName.computeIfAbsent(sourceSetName,
                             name -> {
                                 var ssp = sources.register(name);
                                 ssp.configure(x -> {
-                                    x.getSourceSetDir().set(layout.getProjectDirectory().dir("src/" + usage.layerName()));
+                                    x.getSourceSetDir().set(layout.getProjectDirectory().dir("src/" + usage.layer().getName()));
                                 });
                                 return ssp;
                             });
                     var binding = new SourceSetUsageBinding(
                             usage.variantName(),
                             usage.roleName(),
-                            usage.layerName(),
+                            usage.layer().getName(),
                             sourceSetName,
                             sourceSet);
                     if (isNewSourceSet) {
                         var registration = new SourceSetRegistration(
-                                usage.layerName(),
+                                usage.layer().getName(),
                                 sourceSetName,
                                 sourceSet);
                         resolvedBinding.notifyRegistered(registration);
                         notifyRegistered(registration);
                     }
                     resolvedBinding.notifyBound(binding);
                     notifyBound(binding);
                 }
                 private void notifyRegistered(SourceSetRegistration registration) {
                     registeredContexts.add(registration);
                     for (var action : registeredActions)
                         action.execute(registration);
                 }
                 private void notifyBound(SourceSetUsageBinding binding) {
                     boundContexts.add(binding);
                     for (var action : boundActions)
                         action.execute(binding);
                 }
                 private static Action<? super SourceSetUsageBinding> filterByVariant(String variantName,
                         Action<? super SourceSetUsageBinding> action) {
                     return binding -> {
                         if (variantName.equals(binding.variantName()))
                             action.execute(binding);
                     };
                 }
                 private void ensureSourceSetNameBoundToSingleLayer(String sourceSetName, String layerName) {
                     var existingLayer = sourceSetLayersByName.putIfAbsent(sourceSetName, layerName);
                     if (existingLayer != null && !existingLayer.equals(layerName)) {
                         throw new InvalidUserDataException("Source set '" + sourceSetName + "' is resolved from multiple layers: '"
                                 + existingLayer + "' and '" + layerName + "'");
                     }
                 }
-                private void validateBindings(BuildVariantsExtension variants) {
+                private void resolveBindings(BuildVariantsExtension variants) {
-                    var knownLayerNames = new java.util.LinkedHashSet<String>();
-                    for (var layer : variants.getLayers())
-                        knownLayerNames.add(layer.getName());
                     var errors = new ArrayList<String>();
-                    for (var binding : bindings) {
+                    for (var binding : bindingsByName.values()) {
-                        if (!knownLayerNames.contains(binding.getName())) {
+                        if (variants.findLayer(binding.getName()).isEmpty()) {
                             errors.add("Layer binding '" + binding.getName() + "' references unknown layer");
                         }
                     }
                     if (!errors.isEmpty()) {
                         var message = new StringBuilder("Invalid variantSources model:");
                         for (var error : errors)
                             message.append("\n - ").append(error);
                         throw new InvalidUserDataException(message.toString());
                     }
                 }
+                private LayerBinding binding(String layerName) {
+                    return bindingsByName.computeIfAbsent(layerName, name -> new LayerBinding(name, objects));
+                }
                 private static String sourceSetName(LayerUsage usage, String pattern) {
                     var normalizedPattern = normalize(pattern, "sourceSetNamePattern must not be null or blank");
                     var resolved = resolveSourceSetNamePattern(normalizedPattern, usage);
                     var result = sanitizeName(resolved);
                     if (result.isEmpty())
                         throw new InvalidUserDataException(
                                 "sourceSetNamePattern '" + pattern + "' resolved to empty source set name");
                     return result;
                 }
                 private static String resolveSourceSetNamePattern(String pattern, LayerUsage usage) {
                     var matcher = SOURCE_SET_NAME_TOKEN.matcher(pattern);
                     var output = new StringBuffer();
                     while (matcher.find()) {
                         var token = matcher.group(1);
                         matcher.appendReplacement(output, Matcher.quoteReplacement(tokenValue(token, usage)));
                     }
                     matcher.appendTail(output);
                     return output.toString();
                 }
                 private static String tokenValue(String token, LayerUsage usage) {
                     return switch (token) {
                         case "variant" -> sanitizeName(usage.variantName());
                         case "variantCap" -> Strings.capitalize(sanitizeName(usage.variantName()));
                         case "role" -> sanitizeName(usage.roleName());
                         case "roleCap" -> Strings.capitalize(sanitizeName(usage.roleName()));
-                        case "layer" -> sanitizeName(usage.layerName());
+                        case "layer" -> sanitizeName(usage.layer().getName());
-                        case "layerCap" -> Strings.capitalize(sanitizeName(usage.layerName()));
+                        case "layerCap" -> Strings.capitalize(sanitizeName(usage.layer().getName()));
                         default -> throw new InvalidUserDataException(
                                 "sourceSetNamePattern contains unsupported token '{" + token + "}'");
                     };
                 }
                 private static String normalize(@Nullable String value, String errorMessage) {
                     if (value == null)
                         throw new InvalidUserDataException(errorMessage);
                     var trimmed = value.trim();
                     if (trimmed.isEmpty())
                         throw new InvalidUserDataException(errorMessage);
                     return trimmed;
                 }
-                private record LayerUsage(String variantName, String roleName, String layerName) {
+                private record LayerUsage(String variantName, String roleName, LayoutLayer layer) {
                 }
             }

common/src/test/java/org/implab/gradle/common/sources/VariantsArtifactsPluginFunctionalTest.java +2 -2

             package org.implab.gradle.common.sources;
             import static org.junit.jupiter.api.Assertions.assertNotNull;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.io.File;
             import java.io.IOException;
             import java.nio.file.Files;
             import java.nio.file.Path;
             import java.util.List;
             import java.util.stream.Collectors;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.GradleRunner;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.gradle.testkit.runner.UnexpectedBuildFailure;
             import org.junit.jupiter.api.Test;
             import org.junit.jupiter.api.io.TempDir;
             class VariantsArtifactsPluginFunctionalTest {
                 private static final String SETTINGS_FILE = "settings.gradle";
                 private static final String BUILD_FILE = "build.gradle";
                 private static final String ROOT_NAME = "rootProject.name = 'variants-artifacts-fixture'\n";
                 @TempDir
                 Path testProjectDir;
                 @Test
                 void materializesVariantArtifactsAndInvokesOutgoingHooks() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     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");
                     writeFile(BUILD_FILE, """
                         import org.gradle.api.attributes.Attribute
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
-                            layer('mainBase')
+                            layers('mainBase', 'mainAmd')
-                            layer('mainAmd')
+                            roles('main', 'test')
                             variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                             }
                         }
                         variantSources {
                             bind('mainBase') {
                                 configureSourceSet {
                                     declareOutputs('js')
                                 }
                             }
                             bind('mainAmd') {
                                 configureSourceSet {
                                     declareOutputs('js')
                                 }
                             }
                             whenBound { ctx ->
                                 if (ctx.sourceSetName() == 'browserMainBase') {
                                     ctx.configureSourceSet {
                                         registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                     }
                                 }
                                 if (ctx.sourceSetName() == 'browserMainAmd') {
                                     ctx.configureSourceSet {
                                         registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
                                     }
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 primarySlot('mainJs') {
                                     fromRole('main') {
                                         output('js')
                                     }
                                 }
                                 slot('amdJs') {
                                     fromLayer('mainAmd') {
                                         output('js')
                                     }
                                 }
                             }
                             whenOutgoingVariant { publication ->
                                 publication.slots().each { slotPublication ->
                                     slotPublication.configureTask {
                                         from(layout.projectDirectory.file("inputs/${slotPublication.slotName()}.txt"))
                                     }
                                     slotPublication.configureArtifactAttributes {
                                         attribute(Attribute.of('test.slot', String), slotPublication.slotName())
                                     }
                                 }
                             }
                         }
                         tasks.register('probe') {
                             dependsOn 'processBrowserMainJs', 'processBrowserAmdJs'
                             doLast {
                                 def mainDir = layout.buildDirectory.dir('variant-artifacts/browser/mainJs').get().asFile
                                 def amdDir = layout.buildDirectory.dir('variant-artifacts/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 primaryAttr = elements.attributes.getAttribute(Attribute.of('test.slot', String))
                                 def amdVariant = elements.outgoing.variants.getByName('amdJs')
                                 def amdAttr = amdVariant.attributes.getAttribute(Attribute.of('test.slot', String))
                                 println('primarySlot=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
                                 println('primaryAttr=' + primaryAttr)
                                 println('amdAttr=' + amdAttr)
                                 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("primarySlot=mainJs"));
                     assertTrue(result.getOutput().contains("primaryAttr=mainJs"));
                     assertTrue(result.getOutput().contains("amdAttr=amdJs"));
                     assertTrue(result.getOutput().contains("configurations=browserElements"));
                     assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('typesPackage') {
                                     fromVariant {
                                         output('types')
                                     }
                                 }
                             }
                         }
                         tasks.register('probe') {
                             doLast {
                                 println('primary=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=typesPackage"));
                 }
                 @Test
                 void materializesDirectSlotInputsWithoutVariantSourceBindings() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile("inputs/bundle.js", "console.log('bundle')\n");
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 primarySlot('bundle') {
                                     from(layout.projectDirectory.file('inputs/bundle.js'))
                                 }
                             }
                         }
                         tasks.register('probe') {
                             dependsOn 'processBrowserBundle'
                             doLast {
                                 def bundleDir = layout.buildDirectory.dir('variant-artifacts/browser/bundle').get().asFile
                                 assert new File(bundleDir, 'bundle.js').exists()
                                 println('primary=' + variantArtifacts.requireVariant('browser').requirePrimarySlotName())
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=bundle"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void combinesDirectAndTopologyAwareSlotInputs() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/marker.txt", "marker\n");
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantSources {
                             bind('main') {
                                 configureSourceSet {
                                     declareOutputs('js')
                                 }
                             }
                             whenBound { ctx ->
                                 ctx.configureSourceSet {
                                     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 'processBrowserBundle'
                             doLast {
                                 def bundleDir = layout.buildDirectory.dir('variant-artifacts/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 {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('mainJs') {
                                     fromVariant {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser' references unknown variant 'browser'");
                 }
                 @Test
                 void failsOnUnknownRoleReference() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('mainJs') {
                                     fromRole('test') {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser', slot 'mainJs' references unknown role 'test'");
                 }
                 @Test
                 void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('typesPackage') {
                                     fromVariant {
                                         output('types')
                                     }
                                 }
                                 slot('js') {
                                     fromVariant {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser' must declare primary slot because it has multiple slots");
                 }
                 @Test
                 void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('mainBase')
                             layer('extra')
                             variant('browser') {
                                 role('main') {
                                     layers('mainBase')
                                 }
                             }
                         }
                         variantArtifacts {
                             variant('browser') {
                                 slot('extraJs') {
                                     fromLayer('extra') {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "Variant artifact 'browser', slot 'extraJs' references unknown layer 'extra'");
                 }
                 @Test
                 void failsOnLateMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants-artifacts'
                         }
                         variants {
                             layer('main')
                             variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                         }
                         afterEvaluate {
                             variantArtifacts.variant('late') {
                                 slot('js') {
                                     fromVariant {
                                         output('js')
                                     }
                                 }
                             }
                         }
                         """, "variantArtifacts model is finalized and cannot configure variants");
                 }
                 @Test
                 void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile(SETTINGS_FILE, """
                         rootProject.name = 'variants-artifacts-fixture'
                         include 'producer', 'consumer'
                         """);
                     writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
                     writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
                     var buildscriptClasspath = pluginClasspath().stream()
                             .map(File::getAbsolutePath)
                             .map(path -> "'" + path.replace("\\", "\\\\") + "'")
                             .collect(Collectors.joining(", "));
                     writeFile(BUILD_FILE, """
                         buildscript {
                             dependencies {
                                 classpath files(%s)
                             }
                         }
                         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-artifacts'
                         }
                         project(':producer') {
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') {
                                         layers('main')
                                     }
                                 }
                             }
                             variantSources {
                                 bind('main') {
                                     configureSourceSet {
                                         declareOutputs('types', 'js')
                                     }
                                 }
                                 whenBound { ctx ->
                                     ctx.configureSourceSet {
                                         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')
                                         }
                                     }
                                 }
                                 whenOutgoingVariant { publication ->
                                     publication.configureConfiguration {
                                         attributes.attribute(variantAttr, publication.variantName())
                                     }
                                     publication.primarySlot().configureArtifactAttributes {
                                         attribute(slotAttr, publication.primarySlot().slotName())
                                     }
                                     publication.requireSlot('js').configureArtifactAttributes {
                                         attribute(slotAttr, '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)
                                 }
                             }
                         }
                         """.formatted(buildscriptClasspath));
                     BuildResult result = runner(":consumer:probe").build();
                     assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
                     assertTrue(result.getOutput().contains("jsFiles=js"));
                 }
                 private GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withPluginClasspath(pluginClasspath())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 private void assertBuildFails(String buildScript, String expectedError) throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, buildScript);
                     var ex = assertThrows(UnexpectedBuildFailure.class, () -> runner("help").build());
                     var output = ex.getBuildResult().getOutput();
                     assertTrue(output.contains(expectedError), () -> "Expected [" + expectedError + "] in output:\n" + output);
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var classesDir = Path.of(VariantArtifactsPlugin.class
                                 .getProtectionDomain()
                                 .getCodeSource()
                                 .getLocation()
                                 .toURI());
                         var markerResource = VariantArtifactsPlugin.class.getClassLoader()
                                 .getResource("META-INF/gradle-plugins/org.implab.gradle-variants-artifacts.properties");
                         assertNotNull(markerResource, "Plugin marker resource is missing from test classpath");
                         var markerPath = Path.of(markerResource.toURI());
                         var resourcesDir = markerPath.getParent().getParent().getParent();
                         return List.of(classesDir.toFile(), resourcesDir.toFile());
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
                 }
             }

common/src/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java +35 0

             package org.implab.gradle.common.sources;
             import static org.junit.jupiter.api.Assertions.assertNotNull;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.io.File;
             import java.io.IOException;
             import java.nio.file.Files;
             import java.nio.file.Path;
             import java.util.List;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.GradleRunner;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.gradle.testkit.runner.UnexpectedBuildFailure;
             import org.junit.jupiter.api.Test;
             import org.junit.jupiter.api.io.TempDir;
             class VariantsPluginFunctionalTest {
                 private static final String SETTINGS_FILE = "settings.gradle";
                 private static final String BUILD_FILE = "build.gradle";
                 private static final String ROOT_NAME = "rootProject.name = 'variants-fixture'\n";
                 @TempDir
                 Path testProjectDir;
                 @Test
                 void configuresVariantModelWithDsl() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('mainBase') {
                             }
                             layer('mainAmd') {
                             }
                             variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                             }
                         }
                             tasks.register('probe') {
                                 doLast {
                                 def browser = variants.require('browser')
                                 println('roles=' + browser.roles.size())
                                 println('roleLayers=' + browser.requireRole('main').layers.get().join(','))
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("roles=1"));
                     assertTrue(result.getOutput().contains("roleLayers=mainBase,mainAmd"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
+                void supportsLayerRegistryDslAndLookupApi() throws Exception {
+                    writeFile(SETTINGS_FILE, ROOT_NAME);
+                    writeFile(BUILD_FILE, """
+                        plugins {
+                            id 'org.implab.gradle-variants'
+                        }
+                        variants {
+                            layer('mainBase')
+                            layer('mainAmd')
+                            variant('browser') {
+                                role('main') {
+                                    layers('mainBase', 'mainAmd')
+                                }
+                            }
+                        }
+                        tasks.register('probe') {
+                            doLast {
+                                println('layers=' + variants.layers.collect { it.name }.sort().join(','))
+                                println('requireLayer=' + variants.requireLayer('mainBase').name)
+                                println('findLayer=' + variants.findLayer('missing').isPresent())
+                            }
+                        }
+                        """);
+                    BuildResult result = runner("probe").build();
+                    assertTrue(result.getOutput().contains("layers=mainAmd,mainBase"));
+                    assertTrue(result.getOutput().contains("requireLayer=mainBase"));
+                    assertTrue(result.getOutput().contains("findLayer=false"));
+                }
+                @Test
                 void failsOnUnknownLayerReference() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('mainBase') {
                             }
                             variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'missingLayer')
                                 }
                             }
                         }
                         """, "references unknown layer 'missingLayer'");
                 }
                 @Test
                 void allowsUsingLayerFromDifferentVariantRole() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('mainBase')
                             variant('browser') {
                                 role('test') {
                                     layers('mainBase')
                                 }
                             }
                         }
                         """);
                     BuildResult result = runner("help").build();
                     assertTrue(result.getOutput().contains("BUILD SUCCESSFUL"));
                 }
                 @Test
                 void failsOnDuplicatedLayerReferenceInRole() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') {
                                     layers('a', 'a')
                                 }
                             }
                         }
                         """, "contains duplicated layer reference 'a'");
                 }
                 @Test
                 void failsOnLateLayerMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') { layers('a') }
                             }
                         }
                         afterEvaluate {
                             variants.layer('late')
                         }
                         """, "Variants model is finalized and cannot configure layers");
                 }
                 @Test
                 void failsOnLateVariantMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') { layers('a') }
                             }
                         }
                         afterEvaluate {
                             variants.require('browser').role('late') { layers('a') }
                         }
                         """, "Variant 'browser' is finalized and cannot configure roles");
                 }
                 private GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withPluginClasspath(pluginClasspath())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 private void assertBuildFails(String buildScript, String expectedError) throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, buildScript);
                     var ex = assertThrows(UnexpectedBuildFailure.class, () -> runner("help").build());
                     var output = ex.getBuildResult().getOutput();
                     assertTrue(output.contains(expectedError), () -> "Expected [" + expectedError + "] in output:\n" + output);
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var classesDir = Path.of(BuildVariant.class
                                 .getProtectionDomain()
                                 .getCodeSource()
                                 .getLocation()
                                 .toURI());
                         var markerResource = VariantsPlugin.class.getClassLoader()
                                 .getResource("META-INF/gradle-plugins/org.implab.gradle-variants.properties");
                         assertNotNull(markerResource, "Plugin marker resource is missing from test classpath");
                         var markerPath = Path.of(markerResource.toURI());
                         var resourcesDir = markerPath.getParent().getParent().getParent();
                         return List.of(classesDir.toFile(), resourcesDir.toFile());
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
                 }
             }

common/src/test/java/org/implab/gradle/common/sources/VariantsSourcesPluginFunctionalTest.java +77 0

             package org.implab.gradle.common.sources;
             import static org.junit.jupiter.api.Assertions.assertNotNull;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.io.File;
             import java.io.IOException;
             import java.nio.file.Files;
             import java.nio.file.Path;
             import java.util.List;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.GradleRunner;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.gradle.testkit.runner.UnexpectedBuildFailure;
             import org.junit.jupiter.api.Test;
             import org.junit.jupiter.api.io.TempDir;
             class VariantsSourcesPluginFunctionalTest {
                 private static final String SETTINGS_FILE = "settings.gradle";
                 private static final String BUILD_FILE = "build.gradle";
                 private static final String ROOT_NAME = "rootProject.name = 'variants-sources-fixture'\n";
                 @TempDir
                 Path testProjectDir;
                 @Test
                 void registersVariantSourceSetsAndFiresCallbacks() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('mainBase')
                                 layer('mainAmd')
                                 variant('browser') {
                                     role('main') { layers('mainBase', 'mainAmd') }
                                 }
                                 variant('node') {
                                     role('main') { layers('mainBase') }
                                 }
                             }
                             def events = []
                             def localEvents = []
                             variantSources {
                                 bind('mainBase') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                                 bind('mainAmd') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                                 bind('mainAmd').whenRegistered { ctx ->
                                     localEvents << "${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenRegistered { ctx ->
                                     events << "${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     println("sources=" + sources.collect { it.name }.sort().join(','))
                                     println("events=" + events.sort().join('|'))
                                     println("local=" + localEvents.sort().join('|'))
                                     def base = sources.getByName('browserMainBase')
                                     def amd = sources.getByName('browserMainAmd')
                                     def nodeBase = sources.getByName('nodeMainBase')
                                     base.output('compiled')
                                     amd.output('compiled')
                                     nodeBase.output('compiled')
                                     println('outputs=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("sources=browserMainAmd,browserMainBase,nodeMainBase"));
                     assertTrue(result.getOutput().contains("events=mainAmd:browserMainAmd|mainBase:browserMainBase|mainBase:nodeMainBase"));
                     assertTrue(result.getOutput().contains("local=mainAmd:browserMainAmd"));
                     assertTrue(result.getOutput().contains("outputs=ok"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void supportsTrailingClosureOnBind() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             variantSources {
                                 bind('main') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def ss = sources.getByName('browserMain')
                                     ss.output('compiled')
                                     println('bindClosure=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("bindClosure=ok"));
                 }
                 @Test
+                void supportsBindingByBuildLayerIdentity() throws Exception {
+                    writeFile(SETTINGS_FILE, ROOT_NAME);
+                    writeFile(BUILD_FILE, """
+                            plugins {
+                                id 'org.implab.gradle-variants-sources'
+                            }
+                            variants {
+                                layer('main')
+                                variant('browser') {
+                                    role('main') { layers('main') }
+                                }
+                            }
+                            variantSources {
+                                bind(variants.requireLayer('main')) {
+                                    configureSourceSet {
+                                        declareOutputs('compiled')
+                                    }
+                                }
+                            }
+                            tasks.register('probe') {
+                                doLast {
+                                    def ss = sources.getByName('browserMain')
+                                    ss.output('compiled')
+                                    println('bindLayerIdentity=ok')
+                                }
+                            }
+                            """);
+                    BuildResult result = runner("probe").build();
+                    assertTrue(result.getOutput().contains("bindLayerIdentity=ok"));
+                }
+                @Test
+                void exposesBindingsSnapshot() throws Exception {
+                    writeFile(SETTINGS_FILE, ROOT_NAME);
+                    writeFile(BUILD_FILE, """
+                            plugins {
+                                id 'org.implab.gradle-variants-sources'
+                            }
+                            variants {
+                                layer('main')
+                                layer('extra')
+                                variant('browser') {
+                                    role('main') { layers('main') }
+                                }
+                            }
+                            variantSources {
+                                bind('main') {
+                                    sourceSetNamePattern = '{layer}'
+                                    configureSourceSet {
+                                        declareOutputs('compiled')
+                                    }
+                                }
+                                bind('extra')
+                            }
+                            tasks.register('probe') {
+                                doLast {
+                                    def ss = sources.getByName('main')
+                                    ss.output('compiled')
+                                    println("bindings=" + variantSources.bindings.collect { it.name }.sort().join(','))
+                                    println('bindingsSnapshot=ok')
+                                }
+                            }
+                            """);
+                    BuildResult result = runner("probe").build();
+                    assertTrue(result.getOutput().contains("bindings=extra,main"));
+                    assertTrue(result.getOutput().contains("bindingsSnapshot=ok"));
+                }
+                @Test
                 void failsOnUnknownLayerBinding() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             variantSources {
                                 bind('missing')
                             }
                             """);
                     var ex = assertThrows(UnexpectedBuildFailure.class, () -> runner("help").build());
                     assertTrue(ex.getBuildResult().getOutput().contains("Layer binding 'missing' references unknown layer"));
                 }
                 @Test
                 void exposesProviderInSourceSetRegistration() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             variantSources {
                                 whenRegistered {
                                     configureSourceSet {
                                         declareOutputs('generated')
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def ss = sources.getByName('browserMain')
                                     ss.output('generated')
                                     println('contextProvider=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("contextProvider=ok"));
                 }
                 @Test
                 void replaysLateBindingsAndCallbacksAfterRegistration() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                             }
                             def events = []
                             afterEvaluate {
                                 variantSources {
                                     bind('main') {
                                         configureSourceSet {
                                             declareOutputs('late')
                                         }
                                     }
                                     bind('main').whenRegistered { ctx ->
                                         events << "layer:${ctx.sourceSetName()}"
                                     }
                                     whenRegistered { ctx ->
                                         events << "global:${ctx.sourceSetName()}"
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def ss = sources.getByName('browserMain')
                                     ss.output('late')
                                     println("events=" + events.sort().join('|'))
                                     println('lateReplay=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("events=global:browserMain|layer:browserMain"));
                     assertTrue(result.getOutput().contains("lateReplay=ok"));
                 }
                 @Test
                 void supportsSourceSetNamePatternAndSharedRegistration() throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, """
                             plugins {
                                 id 'org.implab.gradle-variants-sources'
                             }
                             variants {
                                 layer('main')
                                 variant('browser') {
                                     role('main') { layers('main') }
                                 }
                                 variant('node') {
                                     role('main') { layers('main') }
                                 }
                             }
                             def registeredEvents = []
                             def boundEvents = []
                             def browserBoundEvents = []
                             def localRegisteredEvents = []
                             def localBoundEvents = []
                             variantSources {
                                 bind('main').sourceSetNamePattern = '{layer}'
                                 bind('main') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                                 bind('main') {
                                     whenRegistered {
                                         localRegisteredEvents << "${layerName()}:${sourceSetName()}"
                                     }
                                 }
                                 bind('main') {
                                     whenBound {
                                         localBoundEvents << "${variantName()}:${roleName()}:${layerName()}:${sourceSetName()}"
                                     }
                                 }
                                 whenRegistered { ctx ->
                                     registeredEvents << "${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenBound { ctx ->
                                     boundEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenBound('browser') { ctx ->
                                     browserBoundEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     println("sources=" + sources.collect { it.name }.sort().join(','))
                                     def main = sources.getByName('main')
                                     main.output('compiled')
                                     println("registered=" + registeredEvents.sort().join('|'))
                                     println("localRegistered=" + localRegisteredEvents.sort().join('|'))
                                     println("bound=" + boundEvents.sort().join('|'))
                                     println("browserBound=" + browserBoundEvents.sort().join('|'))
                                     println("localBound=" + localBoundEvents.sort().join('|'))
                                     println('sharedPattern=ok')
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("sources=main"));
                     assertTrue(result.getOutput().contains("registered=main:main"));
                     assertTrue(result.getOutput().contains("localRegistered=main:main"));
                     assertTrue(result.getOutput().contains("bound=browser:main:main:main|node:main:main:main"));
                     assertTrue(result.getOutput().contains("browserBound=browser:main:main:main"));
                     assertTrue(result.getOutput().contains("localBound=browser:main:main:main|node:main:main:main"));
                     assertTrue(result.getOutput().contains("sharedPattern=ok"));
                 }
                 private GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withPluginClasspath(pluginClasspath())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var classesDir = Path.of(VariantsSourcesPlugin.class
                                 .getProtectionDomain()
                                 .getCodeSource()
                                 .getLocation()
                                 .toURI());
                         var markerResource = VariantsSourcesPlugin.class.getClassLoader()
                                 .getResource("META-INF/gradle-plugins/org.implab.gradle-variants-sources.properties");
                         assertNotNull(markerResource, "Plugin marker resource is missing from test classpath");
                         var markerPath = Path.of(markerResource.toURI());
                         var resourcesDir = markerPath.getParent().getParent().getParent();
                         return List.of(classesDir.toFile(), resourcesDir.toFile());
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
                 }
             }

common/variant-sources-plugin.md +8 -4

             # Variant Sources Plugin
             ## NAME
             `VariantsSourcesPlugin` и extension `variantSources`.
             ## SYNOPSIS
             ```groovy
             plugins {
                 id 'org.implab.gradle-variants-sources'
             }
             variants {
                 layer('main')
                 variant('browser') {
                     role('main') { layers('main') }
                 }
                 variant('node') {
                     role('main') { layers('main') }
                 }
             }
             variantSources {
                 bind('main').sourceSetNamePattern = '{layer}'
                 bind('main') {
                     configureSourceSet {
                         declareOutputs('compiled')
                     }
                 }
                 whenRegistered { sourceSetName() }
                 whenBound('browser') { roleName() }
             }
             ```
             ## DESCRIPTION
             `VariantsSourcesPlugin` применяет `VariantsPlugin` и `SourcesPlugin`, затем
             регистрирует source sets из модели `variants`.
             Точка запуска registration:
             - `variants.whenFinalized(model -> registerSourceSets(...))`
             ### registration
             Для каждой usage-связки `variant/role/layer` вычисляется имя source set,
             регистрируется `GenericSourceSet` (если он еще не существует), затем
             вызываются callbacks.
             ### binding
-            `bind('<layer>')` возвращает `BuildLayerBinding` и задает policy для этого
+            `bind('<layer>')` возвращает `LayerBindingSpec` и задает policy для этого
             слоя:
             - как именовать source set;
             - как конфигурировать source set;
             - какие callbacks вызвать на registration/binding.
             ### sourceSetNamePattern
             `sourceSetNamePattern` определяет naming policy зарегистрированного source set.
             Default:
             - `{variant}{layerCap}`
             Tokens:
             - `{variant}`, `{variantCap}`
             - `{role}`, `{roleCap}`
             - `{layer}`, `{layerCap}`
             Имя санитизируется (`[^A-Za-z0-9_.-] -> _`).
             Ограничение:
             - один `sourceSetName` не может быть порожден разными слоями.
             ## EVENTS
             ### whenRegistered
             - callback на новый уникальный source set;
             - replayable;
             - при shared source set срабатывает один раз.
             ### whenBound
             - callback на каждую usage-связку `variant/role/layer`;
             - replayable;
             - подходит для per-usage логики.
             ### variant filter
             Фильтр по варианту поддерживает только usage-binding:
             - `whenBound(String variantName, ...)`
             ## PAYLOAD TYPES
             `SourceSetRegistration` содержит:
             - `layerName`, `sourceSetName`;
             - `sourceSet` (`NamedDomainObjectProvider<GenericSourceSet>`).
             Sugar:
             - `configureSourceSet(Action|Closure)`.
             `SourceSetUsageBinding` содержит:
             - `variantName`, `roleName`, `layerName`, `sourceSetName`;
             - `sourceSet` (`NamedDomainObjectProvider<GenericSourceSet>`).
             Sugar:
             - `configureSourceSet(Action|Closure)`.
             ## API
             ### VariantSourcesExtension
+            - `bind(BuildLayer)` — получить/создать binding для canonical layer identity.
             - `bind(String)` — получить/создать binding по имени слоя.
             - `bind(String, Action|Closure)` — сконфигурировать binding.
-            - `bindings(Action|Closure)` — контейнерная конфигурация bindings.
+            - `bind(BuildLayer, Action|Closure)` — сконфигурировать binding по `BuildLayer`.
+            - `getBindings()` — read-only snapshot текущих bindings.
             - `whenRegistered(...)` — глобальные callbacks регистрации source set.
             - `whenBound(...)` — глобальные callbacks usage-binding.
             - `whenBound(String variantName, ...)` — usage-binding callbacks с variant-filter.
-            ### BuildLayerBinding
+            ### LayerBindingSpec
             - `sourceSetNamePattern` — naming policy для source set слоя.
             - `configureSourceSet(...)` — слойная конфигурация `GenericSourceSet`.
             - `whenRegistered(...)` — callbacks регистрации в рамках слоя.
             - `whenBound(...)` — callbacks usage-binding в рамках слоя.
             ## KEY CLASSES
             - `VariantsSourcesPlugin` — точка входа plugin adapter.
             - `VariantSourcesExtension` — глобальный DSL bind/events.
-            - `BuildLayerBinding` — layer-local policy и callbacks.
+            - `LayerBindingSpec` — публичный DSL-contract layer-local policy/callbacks.
             - `SourceSetRegistration` — payload регистрации source set.
             - `SourceSetUsageBinding` — payload usage-binding.
             ## NOTES
             - `sourceSetNamePattern` фиксируется при первом чтении в registration
               (`finalizeValueOnRead`).
+            - runtime state bindings скрыт внутри adapter implementation (`LayerBinding`).
+            - name-based bindings резолвятся к canonical `BuildLayer` через registry `variants`.
             - Closure callbacks используют delegate-first.
             - Для вложенных closure лучше явный параметр (`ctx -> ...`).

common/variants-plugin.md +4 -2

             # Variants Plugin
             ## NAME
             `VariantsPlugin` и extension `variants`.
             ## SYNOPSIS
             ```groovy
             plugins {
                 id 'org.implab.gradle-variants'
             }
             variants {
                 layer('mainBase')
                 layer('mainAmd')
                 variant('browser') {
                     attributes {
                         string('jsRuntime', 'browser')
                         string('jsModule', 'amd')
                     }
                     role('main') {
                         layers('mainBase', 'mainAmd')
                     }
                     artifactSlot('mainCompiled')
                 }
             }
             ```
             ## DESCRIPTION
             `VariantsPlugin` задает доменную модель сборки и ее валидацию. Плагин не
             регистрирует compile/copy/bundle задачи напрямую.
             ### layers
             Глобальные логические слои. Служат единым словарем имен, на которые затем
             ссылаются роли.
             ### variants
             Именованные варианты исполнения/пакетирования (`browser`, `node`, и т.д.).
             Вариант агрегирует роли, атрибуты и artifact slots.
             ### roles
             Роль описывает набор слоев в пределах варианта (`main`, `test`, `tools`).
             Одна роль может ссылаться на несколько слоев.
             ### attributes
             Typed-атрибуты (`Attribute<T> -> Provider<T>`) для передачи параметров в
             адаптеры и публикацию артефактов.
             ### artifact slots
             Именованные слоты ожидаемых артефактов варианта. Используются как контракт
             между моделью варианта и плагинами, создающими/публикующими результаты.
             ## VALIDATION
             В `finalizeModel()` выполняется проверка:
             - роль не может ссылаться на неизвестный layer;
             - пустые имена layer запрещены;
             - имена ролей в варианте должны быть уникальны;
             - имена artifact slots в варианте должны быть уникальны.
             ## LIFECYCLE
             - `VariantsPlugin` вызывает `variants.finalizeModel()` на `afterEvaluate`.
             - после `finalizeModel()` мутации модели запрещены.
             - `whenFinalized(...)` replayable.
             ## API
             ### BuildVariantsExtension
             - `layer(...)` — объявление или конфигурация `BuildLayer`.
             - `variant(...)` — объявление или конфигурация `BuildVariant`.
-            - `layers { ... }`, `variants { ... }` — контейнерный DSL.
+            - `layers { layer(...) }`, `variants { ... }` — grouped DSL без публикации container API наружу.
             - `all(...)` — callback для всех вариантов.
+            - `findLayer(name)`, `requireLayer(name)`, `getAllLayers()` — доступ к registry слоев.
             - `getAll()`, `find(name)`, `require(name)` — доступ к вариантам.
             - `validate()` — явный запуск валидации.
             - `finalizeModel()` — валидация + финализация модели.
             - `whenFinalized(...)` — callback по завершенной модели (replayable).
             ### BuildVariant
             - `attributes { ... }` — атрибуты варианта (+ sugar `string/bool/integer`).
             - `role(...)`, `roles { ... }` — роли варианта.
             - `artifactSlot(...)`, `artifactSlots { ... }` — артефактные слоты.
             ## KEY CLASSES
             - `VariantsPlugin` — точка входа плагина.
             - `BuildVariantsExtension` — root extension и lifecycle.
             - `BuildVariant` — агрегатная модель варианта.
-            - `BuildLayer` — модель слоя.
+            - `BuildLayer` — canonical identity-model слоя.
             - `BuildRole` — модель роли.
             - `BuildArtifactSlot` — модель артефактного слота.
             - `VariantAttributes` — typed wrapper для variant attributes.
             ## NOTES
             - Модель `variants` intentionally agnostic к toolchain.
+            - Layer registry хранится как явная identity-map, а не как публичный `NamedDomainObjectContainer`.
             - Интеграция с задачами выполняется через `variantSources` и адаптеры.

settings.gradle +1 0

             /*
              * This settings file was generated by the Gradle 'init' task.
              *
              * The settings file is used to specify which projects to include in your build.
              * In a single project build this file can be empty or even removed.
              *
              * Detailed information about configuring a multi-project build in Gradle can be found
              * in the user guide at https://docs.gradle.org/3.5/userguide/multi_project_builds.html
              */
             dependencyResolutionManagement {
                 repositories {
                     mavenCentral()
                     mavenLocal()
                     ivy {
                         url "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
             }
             rootProject.name = 'gradle-common'
             include 'common'
+            include 'variants'

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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