implab/gradle-common Commit - r27:33c11dfc2c2e

Variants mutation guard after finalize

cin -

r27:33c11dfc2c2e default

parent child

Context file:

r27:33c11dfc2c2e

Collapse all files

common/src/main/java/org/implab/gradle/common/sources/LayerLink.java created 644 +7 0

@@ -0,0 +1,7
	1	package org.implab.gradle.common.sources;
	2
	3	/**
	4	* Directed relation between two layers within a variant.
	5	*/
	6	public record LayerLink(String from, String to, String kind) {
	7	}

common/readme.md +9 -9

             # Gradle Common Sources Model
             ## NAME
             `gradle-common/common` — набор плагинов для моделирования вариантов сборки,
-            материализации source sets и интеграции этой модели с toolchain-адаптерами.
+            регистрации source sets и интеграции этой модели с toolchain-адаптерами.
             ## SYNOPSIS
             ```groovy
             plugins {
                 id 'org.implab.gradle-variants-sources'
             }
             variants {
                 layer('mainBase')
                 layer('mainAmd')
                 variant('browser') {
                     role('main') { layers('mainBase', 'mainAmd') }
                     link('mainBase', 'mainAmd', 'ts:api')
                 }
             }
             variantSources {
                 bind('mainBase') {
                     configureSourceSet {
                         declareOutputs('compiled')
                     }
                 }
                 bind('mainAmd').sourceSetNamePattern = '{variant}{layerCap}'
                 whenRegistered { sourceSetName() }
                 whenBound { ctx ->
                     ctx.configureSourceSet {
                         declareOutputs('typings')
                     }
                 }
             }
             ```
             ## DESCRIPTION
             Модуль состоит из трех логических частей:
             - `variants` — декларативная доменная модель сборки;
-            - `sources` — модель физически материализуемых source sets;
+            - `sources` — модель физически регистрируемых source sets;
             - `variantSources` — адаптер, который связывает первые две модели.
             Ниже раскрытие каждой части.
             ### variants
             `variants` задает структуру пространства сборки: какие есть слои, какие роли
             используют эти слои в каждом варианте, какие направленные связи между слоями
             существуют. Модель не создает задачи и не привязана к TS/JS.
             Практический смысл:
             - формализовать архитектуру сборки;
             - централизовать валидацию связей;
             - дать адаптерам единый источник правды.
             ### sources
             `sources` описывает независимые source sets (`GenericSourceSet`) с именованными
             outputs. Это уже "физический" уровень, к которому удобно привязывать задачи,
             артефакты и task inputs/outputs.
             Практический смысл:
             - создать единый контракт по входам/выходам;
             - регистрировать результаты задач как outputs source set;
             - минимизировать ручные `dependsOn` за счет модели outputs.
             ### variantSources
-            `variantSources` материализует source sets на основе `variants`, применяет
+            `variantSources` регистрирует source sets на основе `variants`, применяет
             конфигурацию layer-bindings и отдает события (`whenRegistered`, `whenBound`) для
             адаптеров других плагинов.
             Практический смысл:
             - переводить логическую модель `variants` в executable-модель `sources`;
-            - навешивать политики toolchain на materialized source sets;
+            - навешивать политики toolchain на зарегистрированные source sets;
             - синхронизировать плагины через replayable callback-контракт.
             ## DOMAIN MODEL
             - `BuildLayer` — глобальный идентификатор слоя.
             - `BuildVariant` — агрегат ролей, связей, атрибутов, артефактных слотов.
             - `BuildRole` — роль внутри варианта, содержит ссылки на layer names.
-            - `BuildLink` — ориентированная связь `from -> to` в графе определенного `kind`.
+            - `LayerLink` — ориентированная связь `from -> to` в графе определенного `kind`.
-            - `GenericSourceSet` — materialized набор исходников и outputs.
+            - `GenericSourceSet` — зарегистрированный набор исходников и outputs.
-            - `BuildLayerBinding` — правила materialization source set для конкретного layer.
+            - `BuildLayerBinding` — правила registration source set для конкретного layer.
-            - `SourceSetContext` — контекст callback-событий materialization.
+            - `SourceSetContext` — контекст callback-событий registration.
             ## 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 ролей, links, attributes и artifact slots варианта.
             - `VariantsSourcesPlugin` — применяет `variants` + `sources` и запускает адаптер.
-            - `VariantSourcesExtension` — API bind/events materialization.
+            - `VariantSourcesExtension` — API bind/events registration.
             - `BuildLayerBinding` — слой-конкретный DSL для имени и конфигурации source set.
             - `SourceSetContext` — payload событий и sugar `configureSourceSet(...)`.
             ## 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/BuildRole.java +18 0

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.Objects;
             import javax.inject.Inject;
+            import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.provider.ListProperty;
             /**
              * Role binding inside a variant, points to layer names.
              */
             public abstract class BuildRole implements Named {
                 private final String name;
+                private boolean finalized;
                 @Inject
                 public BuildRole(String name) {
                     this.name = name;
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 public abstract ListProperty<String> getLayers();
                 /**
                  * Binds this role to one or more declared layers.
                  */
                 public void layers(String layer, String... extra) {
+                    ensureMutable("add role layers");
                     var values = new ArrayList<String>(1 + extra.length);
                     values.add(Objects.requireNonNull(layer, "Layer name is required"));
                     for (var item : extra)
                         values.add(Objects.requireNonNull(item, "Layer name is required"));
                     getLayers().addAll(values);
                 }
+                void finalizeModel() {
+                    if (finalized)
+                        return;
+                    getLayers().finalizeValue();
+                    getLayers().disallowChanges();
+                    finalized = true;
+                }
+                private void ensureMutable(String operation) {
+                    if (finalized)
+                        throw new InvalidUserDataException("Role '" + name + "' is finalized and cannot " + operation);
+                }
             }

common/src/main/java/org/implab/gradle/common/sources/BuildVariant.java +35 -59

             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.Set;
-            import java.util.regex.Pattern;
             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.Named;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.provider.ProviderFactory;
             import org.gradle.api.attributes.Attribute;
             import groovy.lang.Closure;
             public abstract class BuildVariant implements Named {
-                private static final Pattern INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
                 private final String name;
                 private final ObjectFactory objects;
+                private boolean finalized;
                 /**
                  * Variant aggregate parts.
                  */
                 private final VariantAttributes attributes;
                 private final LinkedHashMap<String, BuildRole> roles = new LinkedHashMap<>();
-                private final LinkedHashMap<String, BuildLink> links = new LinkedHashMap<>();
+                private final List<LayerLink> links = new ArrayList<>();
                 private final LinkedHashMap<String, BuildArtifactSlot> artifactSlots = new LinkedHashMap<>();
                 @Inject
                 public BuildVariant(String name, ObjectFactory objects, ProviderFactory providers) {
                     this.name = name;
                     this.objects = objects;
                     attributes = new VariantAttributes(providers);
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
                 /**
                  * Generic variant attributes interpreted by adapters.
                  */
                 public VariantAttributes getAttributes() {
                     return attributes;
                 }
                 public void attributes(Action<? super AttributesSpec> action) {
+                    ensureMutable("configure attributes");
                     action.execute(new AttributesSpec(attributes));
                 }
                 public void attributes(Closure<?> configure) {
                     attributes(Closures.action(configure));
                 }
                 public <T> void attribute(Attribute<T> key, T value) {
+                    ensureMutable("set attributes");
                     attributes.attribute(key, value);
                 }
                 public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
+                    ensureMutable("set attributes");
                     attributes.attributeProvider(key, value);
                 }
                 public Collection<BuildRole> getRoles() {
                     return Collections.unmodifiableCollection(roles.values());
                 }
                 public void roles(Action<? super RolesSpec> action) {
+                    ensureMutable("configure roles");
                     action.execute(new RolesSpec());
                 }
                 public void roles(Closure<?> configure) {
                     roles(Closures.action(configure));
                 }
                 public BuildRole role(String name, Action<? super BuildRole> configure) {
+                    ensureMutable("configure roles");
                     var role = roles.computeIfAbsent(name, this::newRole);
                     configure.execute(role);
                     return role;
                 }
                 public BuildRole role(String name, Closure<?> configure) {
                     return role(name, Closures.action(configure));
                 }
                 public BuildRole role(String name) {
                     return role(name, r -> {
                     });
                 }
                 public BuildRole getRoleByName(String name) {
                     return roles.get(name);
                 }
-                public Collection<BuildLink> getLinks() {
+                public Collection<LayerLink> getLinks() {
-                    return Collections.unmodifiableCollection(links.values());
+                    return Collections.unmodifiableList(links);
                 }
                 public void links(Action<? super LinksSpec> action) {
+                    ensureMutable("configure links");
                     action.execute(new LinksSpec());
                 }
                 public void links(Closure<?> configure) {
                     links(Closures.action(configure));
                 }
-                public BuildLink link(String from, String to, String kind, Action<? super BuildLink> configure) {
+                public LayerLink link(String from, String to, String kind) {
-                    return link(defaultLinkName(from, to, kind), link -> {
+                    ensureMutable("add links");
-                        link.from(from);
+                    var link = new LayerLink(from, to, kind);
-                        link.to(to);
+                    links.add(link);
-                        link.kind(kind);
-                        configure.execute(link);
-                    });
-                public BuildLink link(String from, String to, String kind, Closure<?> configure) {
-                    return link(from, to, kind, Closures.action(configure));
-                public BuildLink link(String from, String to, String kind) {
-                    return link(from, to, kind, it -> {
-                    });
-                public BuildLink link(String name, Action<? super BuildLink> configure) {
-                    var link = links.computeIfAbsent(name, this::newLink);
-                    configure.execute(link);
                     return link;
                 }
-                public BuildLink link(String name, Closure<?> configure) {
-                    return link(name, Closures.action(configure));
-                public BuildLink getLinkByName(String name) {
-                    return links.get(name);
                 public Collection<BuildArtifactSlot> getArtifactSlots() {
                     return Collections.unmodifiableCollection(artifactSlots.values());
                 }
                 public void artifactSlots(Action<? super ArtifactSlotsSpec> action) {
+                    ensureMutable("configure artifact slots");
                     action.execute(new ArtifactSlotsSpec());
                 }
                 public void artifactSlots(Closure<?> configure) {
                     artifactSlots(Closures.action(configure));
                 }
                 public BuildArtifactSlot artifactSlot(String name) {
                     return artifactSlot(name, it -> {
                     });
                 }
                 public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
+                    ensureMutable("configure artifact slots");
                     var slot = artifactSlots.computeIfAbsent(name, this::newArtifactSlot);
                     configure.execute(slot);
                     return slot;
                 }
                 public BuildArtifactSlot artifactSlot(String name, Closure<?> configure) {
                     return artifactSlot(name, Closures.action(configure));
                 }
                 public BuildArtifactSlot getArtifactSlotByName(String name) {
                     return artifactSlots.get(name);
                 }
                 Set<String> declaredLayerNames() {
                     var result = new LinkedHashSet<String>();
                     for (var role : roles.values())
                         result.addAll(role.getLayers().getOrElse(java.util.List.of()));
                     return result;
                 }
+                void finalizeModel() {
+                    if (finalized)
+                        return;
+                    for (var role : roles.values())
+                        role.finalizeModel();
+                    attributes.finalizeModel();
+                    finalized = true;
+                }
                 private BuildRole newRole(String roleName) {
                     return objects.newInstance(BuildRole.class, roleName);
                 }
-                private BuildLink newLink(String linkName) {
-                    return objects.newInstance(BuildLink.class, linkName);
                 private BuildArtifactSlot newArtifactSlot(String slotName) {
                     return objects.newInstance(BuildArtifactSlot.class, slotName);
                 }
-                private static String defaultLinkName(String from, String to, String kind) {
+                private void ensureMutable(String operation) {
-                    return "link_" + sanitize(from) + "__" + sanitize(to) + "__" + sanitize(kind);
+                    if (finalized)
+                        throw new InvalidUserDataException("Variant '" + name + "' is finalized and cannot " + operation);
-                private static String sanitize(String value) {
-                    return INVALID_NAME_CHAR.matcher(String.valueOf(value)).replaceAll("_");
                 }
                 public final class RolesSpec {
                     public BuildRole role(String name, Action<? super BuildRole> configure) {
                         return BuildVariant.this.role(name, configure);
                     }
                     public BuildRole role(String name, Closure<?> configure) {
                         return BuildVariant.this.role(name, configure);
                     }
                     public BuildRole role(String name) {
                         return BuildVariant.this.role(name);
                     }
                     public Collection<BuildRole> getAll() {
                         return BuildVariant.this.getRoles();
                     }
                     public BuildRole getByName(String name) {
                         return BuildVariant.this.getRoleByName(name);
                     }
                 }
                 public final class LinksSpec {
-                    public BuildLink link(String from, String to, String kind, Action<? super BuildLink> configure) {
+                    public LayerLink link(String from, String to, String kind) {
-                        return BuildVariant.this.link(from, to, kind, configure);
-                    public BuildLink link(String from, String to, String kind, Closure<?> configure) {
-                        return BuildVariant.this.link(from, to, kind, configure);
-                    public BuildLink link(String from, String to, String kind) {
                         return BuildVariant.this.link(from, to, kind);
                     }
-                    public Collection<BuildLink> getAll() {
+                    public Collection<LayerLink> getAll() {
                         return BuildVariant.this.getLinks();
                     }
-                    public BuildLink getByName(String name) {
-                        return BuildVariant.this.getLinkByName(name);
                 }
                 public final class ArtifactSlotsSpec {
                     public BuildArtifactSlot artifactSlot(String name, Action<? super BuildArtifactSlot> configure) {
                         return BuildVariant.this.artifactSlot(name, configure);
                     }
                     public BuildArtifactSlot artifactSlot(String name, Closure<?> configure) {
                         return BuildVariant.this.artifactSlot(name, configure);
                     }
                     public BuildArtifactSlot artifactSlot(String name) {
                         return BuildVariant.this.artifactSlot(name);
                     }
                     public Collection<BuildArtifactSlot> getAll() {
                         return BuildVariant.this.getArtifactSlots();
                     }
                     public BuildArtifactSlot getByName(String name) {
                         return BuildVariant.this.getArtifactSlotByName(name);
                     }
                 }
                 public static final class AttributesSpec {
                     private final VariantAttributes attributes;
                     AttributesSpec(VariantAttributes attributes) {
                         this.attributes = attributes;
                     }
                     public <T> void attribute(Attribute<T> key, T value) {
                         attributes.attribute(key, value);
                     }
                     public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
                         attributes.attributeProvider(key, value);
                     }
                     public void string(String name, String value) {
                         attribute(Attribute.of(name, String.class), value);
                     }
                     public void string(String name, Provider<? extends String> value) {
                         attributeProvider(Attribute.of(name, String.class), value);
                     }
                     public void bool(String name, boolean value) {
                         attribute(Attribute.of(name, Boolean.class), value);
                     }
                     public void bool(String name, Provider<? extends Boolean> value) {
                         attributeProvider(Attribute.of(name, Boolean.class), value);
                     }
                     public void integer(String name, int value) {
                         attribute(Attribute.of(name, Integer.class), value);
                     }
                     public void integer(String name, Provider<? extends Integer> value) {
                         attributeProvider(Attribute.of(name, Integer.class), value);
                     }
                     public VariantAttributes asAttributes() {
                         return attributes;
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/BuildVariantsExtension.java +31 -7

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.Collection;
             import java.util.Collections;
             import java.util.HashMap;
             import java.util.HashSet;
             import java.util.LinkedHashMap;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.Map;
             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.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 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);
                     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() {
                     return layers;
                 }
                 public NamedDomainObjectContainer<BuildVariant> getVariants() {
                     return variants;
                 }
                 public void layers(Action<? super NamedDomainObjectContainer<BuildLayer>> action) {
+                    ensureMutable("configure layers");
                     action.execute(layers);
                 }
                 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) {
                     return layer(name, Closures.action(configure));
                 }
                 public BuildLayer 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 BuildVariant getByName(String name) {
                     return variants.findByName(name);
                 }
                 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)
                         layersByName.put(layer.getName(), layer);
                     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) {
                     var variantLayers = validateRoleMappings(variant, layersByName, errors);
                     validateLinks(variant, variantLayers, errors);
                 }
                 private static Set<String> validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
                         List<String> errors) {
                     var variantLayers = new LinkedHashSet<String>();
                     for (var role : variant.getRoles()) {
                         for (var layerName : role.getLayers().getOrElse(List.of())) {
                             if (isBlank(layerName)) {
                                 errors.add("Variant '" + variant.getName() + "', role '" + role.getName() + "' contains blank layer name");
                                 continue;
                             }
                             var layer = layersByName.get(layerName);
                             if (layer == null) {
                                 errors.add("Variant '" + variant.getName() + "' references unknown layer '" + layerName + "'");
                                 continue;
                             }
                             variantLayers.add(layerName);
                         }
                     }
                     return variantLayers;
                 }
                 private static void validateLinks(BuildVariant variant, Set<String> variantLayers, List<String> errors) {
                     var seenLinks = new HashSet<String>();
                     var edgesByKind = new HashMap<String, Map<String, Set<String>>>();
                     for (var link : variant.getLinks()) {
-                        var from = normalize(link.getFrom().getOrNull());
+                        var from = normalize(link.from());
-                        var to = normalize(link.getTo().getOrNull());
+                        var to = normalize(link.to());
-                        var kind = normalize(link.getKind().getOrNull());
+                        var kind = normalize(link.kind());
                         if (from == null || to == null || kind == null) {
-                            errors.add("Variant '" + variant.getName() + "' has incomplete link '" + link.getName()
+                            errors.add("Variant '" + variant.getName() + "' has incomplete link (from/to/kind are required)");
-                                    + "' (from/to/kind are required)");
                             continue;
                         }
                         if (!variantLayers.contains(from)) {
-                            errors.add("Variant '" + variant.getName() + "' link '" + link.getName() + "' references unknown source layer '"
+                            errors.add("Variant '" + variant.getName() + "' link references unknown source layer '"
                                     + from + "'");
                             continue;
                         }
                         if (!variantLayers.contains(to)) {
-                            errors.add("Variant '" + variant.getName() + "' link '" + link.getName() + "' references unknown target layer '"
+                            errors.add("Variant '" + variant.getName() + "' link references unknown target layer '"
                                     + to + "'");
                             continue;
                         }
                         var linkKey = from + "\u0000" + to + "\u0000" + kind;
                         if (!seenLinks.add(linkKey)) {
                             errors.add("Variant '" + variant.getName() + "' has duplicated link tuple (from='" + from
                                     + "', to='" + to + "', kind='" + kind + "')");
                         }
                         edgesByKind
                                 .computeIfAbsent(kind, x -> new LinkedHashMap<>())
                                 .computeIfAbsent(from, x -> new LinkedHashSet<>())
                                 .add(to);
                     }
                     for (var entry : edgesByKind.entrySet()) {
                         if (hasCycle(variantLayers, entry.getValue())) {
                             errors.add("Variant '" + variant.getName() + "' contains cycle in links with kind '" + entry.getKey() + "'");
                         }
                     }
                 }
                 private static boolean hasCycle(Set<String> nodes, Map<String, Set<String>> edges) {
                     var state = new HashMap<String, Integer>();
                     for (var node : nodes) {
                         if (dfs(node, state, edges))
                             return true;
                     }
                     return false;
                 }
                 private static boolean dfs(String node, Map<String, Integer> state, Map<String, Set<String>> edges) {
                     var current = state.getOrDefault(node, 0);
                     if (current == 1)
                         return true;
                     if (current == 2)
                         return false;
                     state.put(node, 1);
                     for (var next : edges.getOrDefault(node, Set.of())) {
                         if (dfs(next, state, edges))
                             return true;
                     }
                     state.put(node, 2);
                     return false;
                 }
                 private static String normalize(String value) {
                     if (value == null)
                         return null;
                     var trimmed = value.trim();
                     return trimmed.isEmpty() ? null : trimmed;
                 }
                 private static boolean isBlank(String value) {
                     return normalize(value) == null;
                 }
+                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/SourcesPlugin.java +6 -2

             package org.implab.gradle.common.sources;
             import org.gradle.api.GradleException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             /**
              * This plugin creates a {@code sources} extension which is
              * a container for {@link GenericSourceSet}.
              *
              */
             public abstract class SourcesPlugin implements Plugin<Project> {
                 private static final Logger logger = Logging.getLogger(SourcesPlugin.class);
                 private static final String SOURCES_EXTENSION_NAME = "sources";
                 @Override
                 public void apply(Project target) {
+                    logger.debug("Registering '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                     var sources = target.getObjects().domainObjectContainer(GenericSourceSet.class);
                     target.getExtensions().add(SOURCES_EXTENSION_NAME, sources);
                 }
                 public static NamedDomainObjectContainer<GenericSourceSet> getSourcesExtension(Project target) {
                     var extensions = target.getExtensions();
                     @SuppressWarnings("unchecked")
-                    var extension = (NamedDomainObjectContainer<GenericSourceSet>)extensions.getByName(SOURCES_EXTENSION_NAME);
+                    var extension = (NamedDomainObjectContainer<GenericSourceSet>) extensions.findByName(SOURCES_EXTENSION_NAME);
-                    if (extension == null)
+                    if (extension == null) {
+                        logger.error("Sources extension '{}' isn't found on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                         throw new GradleException("Sources extension isn't found");
+                    }
+                    logger.debug("Resolved '{}' extension on project '{}'", SOURCES_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantAttributes.java +13 0

             package org.implab.gradle.common.sources;
             import java.util.Collections;
             import java.util.LinkedHashMap;
             import java.util.Map;
+            import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.attributes.Attribute;
             import org.gradle.api.provider.ProviderFactory;
             import org.gradle.api.provider.Provider;
             /**
              * Typed attribute storage used by build variants.
              */
             public final class VariantAttributes {
                 private final ProviderFactory providers;
                 private final LinkedHashMap<Attribute<?>, Provider<?>> values = new LinkedHashMap<>();
+                private boolean finalized;
                 VariantAttributes(ProviderFactory providers) {
                     this.providers = providers;
                 }
                 public <T> void attribute(Attribute<T> key, T value) {
+                    ensureMutable("set attribute '" + key.getName() + "'");
                     attributeProvider(key, providers.provider(() -> value));
                 }
                 public <T> void attributeProvider(Attribute<T> key, Provider<? extends T> value) {
+                    ensureMutable("set attribute provider '" + key.getName() + "'");
                     values.put(key, value);
                 }
                 @SuppressWarnings("unchecked")
                 public <T> Provider<T> get(Attribute<T> key) {
                     return (Provider<T>) values.get(key);
                 }
                 public boolean contains(Attribute<?> key) {
                     return values.containsKey(key);
                 }
                 public int size() {
                     return values.size();
                 }
                 public Map<Attribute<?>, Provider<?>> asMap() {
                     return Collections.unmodifiableMap(values);
                 }
+                void finalizeModel() {
+                    finalized = true;
+                }
+                private void ensureMutable(String operation) {
+                    if (finalized)
+                        throw new InvalidUserDataException("Variant attributes are finalized and cannot " + operation);
+                }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantSourcesExtension.java +24 -3

             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.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             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;
             /**
-             * Adapter extension that materializes source sets for variant/layer pairs.
+             * 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 INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
                 private static final Pattern SOURCE_SET_NAME_TOKEN = Pattern.compile("\\{([A-Za-z][A-Za-z0-9]*)\\}");
                 private final ObjectFactory objects;
                 private final NamedDomainObjectContainer<BuildLayerBinding> bindings;
                 private final List<Action<? super SourceSetContext>> registeredActions = new ArrayList<>();
                 private final List<Action<? super SourceSetContext>> boundActions = new ArrayList<>();
                 private final List<SourceSetContext> registeredContexts = new ArrayList<>();
                 private final List<SourceSetContext> boundContexts = new ArrayList<>();
                 private final LinkedHashMap<String, NamedDomainObjectProvider<GenericSourceSet>> sourceSetsByName = new LinkedHashMap<>();
                 private final LinkedHashMap<String, String> sourceSetLayersByName = new LinkedHashMap<>();
                 @Inject
                 public VariantSourcesExtension(ObjectFactory objects) {
                     this.objects = objects;
                     bindings = objects.domainObjectContainer(BuildLayerBinding.class);
                 }
                 public NamedDomainObjectContainer<BuildLayerBinding> getBindings() {
                     return bindings;
                 }
                 public void bindings(Action<? super NamedDomainObjectContainer<BuildLayerBinding>> action) {
                     action.execute(bindings);
                 }
                 public void bindings(
                         @DelegatesTo(value = NamedDomainObjectContainer.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     bindings(Closures.action(action));
                 }
                 public BuildLayerBinding bind(String layer) {
                     return bindings.maybeCreate(normalize(layer));
                 }
                 /**
                  * Configures per-layer binding.
                  */
                 public BuildLayerBinding bind(String layer, Action<? super BuildLayerBinding> configure) {
                     var binding = bind(layer);
                     configure.execute(binding);
                     return binding;
                 }
                 public BuildLayerBinding bind(String layer,
                         @DelegatesTo(value = BuildLayerBinding.class, strategy = Closure.DELEGATE_FIRST) Closure<?> configure) {
                     return bind(layer, Closures.action(configure));
                 }
                 /**
                  * Global callback fired for each registered source-set context.
                  * Already emitted contexts 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 SourceSetContext> action) {
                     registeredActions.add(action);
                     for (var context : registeredContexts)
                         action.execute(context);
                 }
                 public void whenRegistered(
                         @DelegatesTo(value = SourceSetContext.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenRegistered(Closures.action(action));
                 }
                 public void whenRegistered(String variantName, Action<? super SourceSetContext> action) {
                     var normalizedVariantName = normalize(variantName, "variantName must not be null or blank");
                     whenRegistered(filterByVariant(normalizedVariantName, action));
                 }
                 public void whenRegistered(String variantName,
                         @DelegatesTo(value = SourceSetContext.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenRegistered(variantName, Closures.action(action));
                 }
                 /**
                  * Global callback fired for every resolved variant/role/layer usage.
                  * Already emitted contexts 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 SourceSetContext> action) {
                     boundActions.add(action);
                     for (var context : boundContexts)
                         action.execute(context);
                 }
                 public void whenBound(
                         @DelegatesTo(value = SourceSetContext.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenBound(Closures.action(action));
                 }
                 public void whenBound(String variantName, Action<? super SourceSetContext> action) {
                     var normalizedVariantName = normalize(variantName, "variantName must not be null or blank");
                     whenBound(filterByVariant(normalizedVariantName, action));
                 }
                 public void whenBound(String variantName,
                         @DelegatesTo(value = SourceSetContext.class, strategy = Closure.DELEGATE_FIRST) Closure<?> action) {
                     whenBound(variantName, Closures.action(action));
                 }
                 void registerSourceSets(BuildVariantsExtension variants, NamedDomainObjectContainer<GenericSourceSet> sources) {
                     validateBindings(variants);
-                    layerUsages(variants).forEach(usage -> materializeLayerUsage(usage, sources));
+                    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(),
+                            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());
                 }
                 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)))));
                 }
-                private void materializeLayerUsage(LayerUsage usage, NamedDomainObjectContainer<GenericSourceSet> sources) {
+                private void registerLayerUsage(LayerUsage usage, NamedDomainObjectContainer<GenericSourceSet> sources) {
                     var resolvedBinding = bind(usage.layerName());
                     var sourceSetNamePattern = resolvedBinding.getSourceSetNamePattern();
                     sourceSetNamePattern.finalizeValueOnRead();
                     var sourceSetName = sourceSetName(usage, sourceSetNamePattern.get());
                     ensureSourceSetNameBoundToSingleLayer(sourceSetName, usage.layerName());
                     var isNewSourceSet = !sourceSetsByName.containsKey(sourceSetName);
                     var sourceSet = sourceSetsByName.computeIfAbsent(sourceSetName,
                             name -> sources.register(name));
                     var context = new SourceSetContext(
                             usage.variantName(),
                             usage.roleName(),
                             usage.layerName(),
                             sourceSetName,
                             sourceSet);
                     if (isNewSourceSet) {
                         resolvedBinding.notifyRegistered(context);
                         notifyRegistered(context);
                     }
                     resolvedBinding.notifyBound(context);
                     notifyBound(context);
                 }
                 private void notifyRegistered(SourceSetContext context) {
                     registeredContexts.add(context);
                     for (var action : registeredActions)
                         action.execute(context);
                 }
                 private void notifyBound(SourceSetContext context) {
                     boundContexts.add(context);
                     for (var action : boundActions)
                         action.execute(context);
                 }
                 private static Action<? super SourceSetContext> filterByVariant(String variantName,
                         Action<? super SourceSetContext> action) {
                     return context -> {
                         if (variantName.equals(context.variantName()))
                             action.execute(context);
                     };
                 }
                 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) {
                     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) {
                         if (!knownLayerNames.contains(binding.getName())) {
                             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 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 = sanitize(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" -> sanitize(usage.variantName());
                         case "variantCap" -> Strings.capitalize(sanitize(usage.variantName()));
                         case "role" -> sanitize(usage.roleName());
                         case "roleCap" -> Strings.capitalize(sanitize(usage.roleName()));
                         case "layer" -> sanitize(usage.layerName());
                         case "layerCap" -> Strings.capitalize(sanitize(usage.layerName()));
                         default -> throw new InvalidUserDataException(
                                 "sourceSetNamePattern contains unsupported token '{" + token + "}'");
                     };
                 }
                 private static String sanitize(String value) {
                     return INVALID_NAME_CHAR.matcher(value).replaceAll("_");
                 }
                 private static String normalize(String value) {
                     return normalize(value, "Value must not be null or blank");
                 }
                 private static String normalize(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) {
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantsPlugin.java +14 -2

             package org.implab.gradle.common.sources;
             import org.gradle.api.GradleException;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
+            import org.gradle.api.logging.Logger;
+            import org.gradle.api.logging.Logging;
             /**
              * Registers {@code variants} extension for build-variant modeling.
              */
             public abstract class VariantsPlugin implements Plugin<Project> {
+                private static final Logger logger = Logging.getLogger(VariantsPlugin.class);
                 public static final String VARIANTS_EXTENSION_NAME = "variants";
                 @Override
                 public void apply(Project target) {
+                    logger.debug("Registering '{}' extension on project '{}'", VARIANTS_EXTENSION_NAME, target.getPath());
                     var variants = target.getExtensions().create(VARIANTS_EXTENSION_NAME, BuildVariantsExtension.class);
-                    target.afterEvaluate(project -> variants.finalizeModel());
+                    target.afterEvaluate(project -> {
+                        logger.debug("Finalizing variants model on project '{}'", project.getPath());
+                        variants.finalizeModel();
+                        logger.debug("Variants model finalized on project '{}'", project.getPath());
+                    });
                 }
                 public static BuildVariantsExtension getVariantsExtension(Project target) {
                     var extension = target.getExtensions().findByType(BuildVariantsExtension.class);
-                    if (extension == null)
+                    if (extension == null) {
+                        logger.error("Variants extension '{}' isn't found on project '{}'", VARIANTS_EXTENSION_NAME, target.getPath());
                         throw new GradleException("Variants extension isn't found");
+                    }
+                    logger.debug("Resolved '{}' extension on project '{}'", VARIANTS_EXTENSION_NAME, target.getPath());
                     return extension;
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/VariantsSourcesPlugin.java +10 -2

             package org.implab.gradle.common.sources;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
+            import org.gradle.api.logging.Logger;
+            import org.gradle.api.logging.Logging;
             /**
-             * Binds variant layers to materialized source sets.
+             * Binds variant layers to registered source sets.
              */
             public abstract class VariantsSourcesPlugin implements Plugin<Project> {
+                private static final Logger logger = Logging.getLogger(VariantsSourcesPlugin.class);
                 public static final String VARIANT_SOURCES_EXTENSION_NAME = "variantSources";
                 @Override
                 public void apply(Project target) {
+                    logger.debug("Applying variant-sources plugin on project '{}'", target.getPath());
                     target.getPluginManager().apply(VariantsPlugin.class);
                     target.getPluginManager().apply(SourcesPlugin.class);
                     var variants = VariantsPlugin.getVariantsExtension(target);
                     var sources = SourcesPlugin.getSourcesExtension(target);
                     var variantSources = target.getExtensions()
                             .create(VARIANT_SOURCES_EXTENSION_NAME, VariantSourcesExtension.class);
-                    variants.whenFinalized(model -> variantSources.registerSourceSets(model, sources));
+                    variants.whenFinalized(model -> {
+                        logger.debug("Registering source sets for variants on project '{}'", target.getPath());
+                        variantSources.registerSourceSets(model, sources);
+                        logger.debug("Registered source sets on project '{}'", target.getPath());
+                    });
                 }
             }

common/src/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java +46 -25

             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') {
                                 attributes {
                                     string('jsRuntime', 'browser')
                                     string('jsModule', 'amd')
                                 }
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                                 link('mainBase', 'mainAmd', 'ts:api')
                                 artifactSlot('mainCompiled')
                             }
                         }
                         tasks.register('probe') {
                             doLast {
                                 def browser = variants.getByName('browser')
                                 println('attributes=' + browser.attributes.size())
                                 println('roles=' + browser.roles.size())
                                 println('links=' + browser.links.size())
                                 println('slots=' + browser.artifactSlots.size())
                             }
                         }
                         """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("attributes=2"));
                     assertTrue(result.getOutput().contains("roles=1"));
                     assertTrue(result.getOutput().contains("links=1"));
                     assertTrue(result.getOutput().contains("slots=1"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @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 failsOnCycleInLinksByKind() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             layer('b')
                             variant('browser') {
                                 role('main') {
                                     layers('a', 'b')
                                 }
                                 link('a', 'b', 'ts:api')
                                 link('b', 'a', 'ts:api')
                             }
                         }
                         """, "contains cycle in links with kind 'ts:api'");
                 }
                 @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 failsOnIncompleteLink() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             layer('b')
                             variant('browser') {
                                 role('main') {
                                     layers('a', 'b')
                                 }
-                                link('l1') {
+                                link('a', 'b', null)
-                                    from('a')
-                                    to('b')
                             }
                         }
-                        """, "has incomplete link 'l1'");
+                        """, "has incomplete link (from/to/kind are required)");
                 }
                 @Test
                 void failsOnDuplicatedLinkTuple() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             layer('b')
                             variant('browser') {
                                 role('main') {
                                     layers('a', 'b')
                                 }
-                                link('first') {
+                                link('a', 'b', 'ts:api')
-                                    from('a')
+                                link('a', 'b', 'ts:api')
-                                    to('b')
-                                    kind('ts:api')
-                                link('second') {
-                                    from('a')
-                                    to('b')
-                                    kind('ts:api')
                             }
                         }
                         """, "has duplicated link tuple (from='a', to='b', kind='ts:api')");
                 }
                 @Test
                 void failsOnUnknownSourceLayerInLink() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a') {
                             }
                             variant('browser') {
                                 role('main') {
                                     layers('a')
                                 }
-                                link('l1') {
+                                link('missing', 'a', 'ts:api')
-                                    from('missing')
-                                    to('a')
-                                    kind('ts:api')
                             }
                         }
                         """, "references unknown source layer 'missing'");
                 }
                 @Test
                 void failsOnUnknownTargetLayerInLink() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a') {
                             }
                             variant('browser') {
                                 role('main') {
                                     layers('a')
                                 }
-                                link('l1') {
+                                link('a', 'missing', 'ts:api')
-                                    from('a')
-                                    to('missing')
-                                    kind('ts:api')
                             }
                         }
                         """, "references unknown target layer 'missing'");
                 }
+                @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.getByName('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 +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 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 materializesVariantSourceSetsAndFiresCallbacks() throws Exception {
+                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.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenRegistered { ctx ->
                                     events << "${ctx.variantName()}:${ctx.roleName()}:${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=browser:main:mainAmd:browserMainAmd|browser:main:mainBase:browserMainBase|node:main:mainBase:nodeMainBase"));
                     assertTrue(result.getOutput().contains("local=browser:main: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 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 exposesProviderInSourceSetRegisteredContext() 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 replaysLateBindingsAndCallbacksAfterMaterialization() throws Exception {
+                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 browserRegisteredEvents = []
                             def boundEvents = []
                             def browserBoundEvents = []
                             def localBoundEvents = []
                             variantSources {
                                 bind('main').sourceSetNamePattern = '{layer}'
                                 bind('main') {
                                     configureSourceSet {
                                         declareOutputs('compiled')
                                     }
                                 }
                                 bind('main') {
                                     whenBound {
                                         localBoundEvents << "${variantName()}:${roleName()}:${layerName()}:${sourceSetName()}"
                                     }
                                 }
                                 whenRegistered { ctx ->
                                     registeredEvents << "${ctx.variantName()}:${ctx.roleName()}:${ctx.layerName()}:${ctx.sourceSetName()}"
                                 }
                                 whenRegistered('browser') { ctx ->
                                     browserRegisteredEvents << "${ctx.variantName()}:${ctx.roleName()}:${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("browserRegistered=" + browserRegisteredEvents.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=browser:main:main:main"));
                     assertTrue(result.getOutput().contains("browserRegistered=browser:main: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 +5 -5

             # 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`.
+            регистрирует source sets из модели `variants`.
-            Точка запуска materialization:
+            Точка запуска registration:
             - `variants.whenFinalized(model -> registerSourceSets(...))`
-            ### materialization
+            ### registration
             Для каждой usage-связки `variant/role/layer` вычисляется имя source set,
             регистрируется `GenericSourceSet` (если он еще не существует), затем
             вызываются callbacks.
             ### binding
             `bind('<layer>')` возвращает `BuildLayerBinding` и задает policy для этого
             слоя:
             - как именовать source set;
             - как конфигурировать source set;
             - какие callbacks вызвать на registration/binding.
             ### sourceSetNamePattern
-            `sourceSetNamePattern` определяет naming policy materialized source set.
+            `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
             Глобальные callbacks поддерживают фильтр по варианту:
             - `whenRegistered(String variantName, ...)`
             - `whenBound(String variantName, ...)`
             ## SOURCE SET CONTEXT
             `SourceSetContext` содержит:
             - `variantName`, `roleName`, `layerName`, `sourceSetName`;
             - `sourceSet` (`NamedDomainObjectProvider<GenericSourceSet>`).
             Sugar:
             - `configureSourceSet(Action|Closure)`.
             ## API
             ### VariantSourcesExtension
             - `bind(String)` — получить/создать binding по имени слоя.
             - `bind(String, Action|Closure)` — сконфигурировать binding.
             - `bindings(Action|Closure)` — контейнерная конфигурация bindings.
             - `whenRegistered(...)` — глобальные callbacks регистрации source set.
             - `whenBound(...)` — глобальные callbacks usage-binding.
             ### BuildLayerBinding
             - `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.
             - `SourceSetContext` — payload callbacks и sugar-конфигурирование.
             ## NOTES
-            - `sourceSetNamePattern` фиксируется при первом чтении в materialization
+            - `sourceSetNamePattern` фиксируется при первом чтении в registration
               (`finalizeValueOnRead`).
             - Closure callbacks используют delegate-first.
             - Для вложенных closure лучше явный параметр (`ctx -> ...`).

common/variants-plugin.md +2 -1

             # 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')
                     }
                     link('mainBase', 'mainAmd', 'ts:api')
                     artifactSlot('mainCompiled')
                 }
             }
             ```
             ## DESCRIPTION
             `VariantsPlugin` задает доменную модель сборки и ее валидацию. Плагин не
             регистрирует compile/copy/bundle задачи напрямую.
             ### layers
             Глобальные логические слои. Служат единым словарем имен, на которые затем
             ссылаются роли и связи.
             ### variants
             Именованные варианты исполнения/пакетирования (`browser`, `node`, и т.д.).
             Вариант агрегирует роли, связи, атрибуты и artifact slots.
             ### roles
             Роль описывает набор слоев в пределах варианта (`main`, `test`, `tools`).
             Одна роль может ссылаться на несколько слоев.
             ### links
             `link(from, to, kind)` — ориентированная связь между слоями внутри варианта.
             `kind` задает независимый тип графа (например `ts:api`, `bundle:runtime`). Это
             позволяет вести несколько параллельных графов зависимостей над теми же слоями.
             Практические сценарии использования `link` в адаптерах:
             - расчет topological order по выбранному `kind`;
             - wiring task inputs/outputs между слоями;
             - проверка допустимости дополнительных pipeline-зависимостей.
             ### attributes
             Typed-атрибуты (`Attribute<T> -> Provider<T>`) для передачи параметров в
             адаптеры и публикацию артефактов.
             ### artifact slots
             Именованные слоты ожидаемых артефактов варианта. Используются как контракт
             между моделью варианта и плагинами, создающими/публикующими результаты.
             ## VALIDATION
             В `finalizeModel()` выполняется проверка:
             - роль не может ссылаться на неизвестный layer;
             - пустые имена layer запрещены;
             - у link обязательны `from`, `to`, `kind`;
             - `from`/`to` должны входить в слойную область варианта;
             - tuple `(from, to, kind)` должен быть уникален;
             - циклы в графе одного `kind` запрещены.
             ## LIFECYCLE
             - `VariantsPlugin` вызывает `variants.finalizeModel()` на `afterEvaluate`.
+            - после `finalizeModel()` мутации модели запрещены.
             - `whenFinalized(...)` replayable.
             ## API
             ### BuildVariantsExtension
             - `layer(...)` — объявление или конфигурация `BuildLayer`.
             - `variant(...)` — объявление или конфигурация `BuildVariant`.
             - `layers { ... }`, `variants { ... }` — контейнерный DSL.
             - `all(...)` — callback для всех вариантов.
             - `getAll()`, `getByName(name)` — доступ к вариантам.
             - `validate()` — явный запуск валидации.
             - `finalizeModel()` — валидация + финализация модели.
             - `whenFinalized(...)` — callback по завершенной модели (replayable).
             ### BuildVariant
             - `attributes { ... }` — атрибуты варианта (+ sugar `string/bool/integer`).
             - `role(...)`, `roles { ... }` — роли варианта.
             - `link(...)`, `links { ... }` — связи слоев внутри варианта.
             - `artifactSlot(...)`, `artifactSlots { ... }` — артефактные слоты.
             ## KEY CLASSES
             - `VariantsPlugin` — точка входа плагина.
             - `BuildVariantsExtension` — root extension и lifecycle.
             - `BuildVariant` — агрегатная модель варианта.
             - `BuildLayer` — модель слоя.
             - `BuildRole` — модель роли.
-            - `BuildLink` — модель направленной связи.
+            - `LayerLink` — модель направленной связи.
             - `BuildArtifactSlot` — модель артефактного слота.
             - `VariantAttributes` — typed wrapper для variant attributes.
             ## NOTES
             - Модель `variants` intentionally agnostic к toolchain.
             - Интеграция с задачами выполняется через `variantSources` и адаптеры.

common/src/main/java/org/implab/gradle/common/sources/BuildLink.java removed 0 -41

	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