implab/gradle-common Commit - r30:2dd3356774b2

Removed layer links from variants

cin -

r30:2dd3356774b2 default

parent child

Context file:

r30:2dd3356774b2

Collapse all files

common/readme.md +4 -7

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

             package org.implab.gradle.common.core.lang;
             import java.util.regex.Pattern;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.provider.Provider;
             @NonNullByDefault
             public class Strings {
                 private static final Pattern firstLetter = Pattern.compile("^\\w");
+                private static final Pattern INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
                 public static String capitalize(String string) {
                     return string == null ? null
                             : string.length() == 0 ? string
                                     : firstLetter.matcher(string).replaceFirst(m -> m.group().toUpperCase());
                 }
                 public static String toCamelCase(String name) {
                     if (name == null || name.isEmpty())
                         return name;
                     StringBuilder out = new StringBuilder(name.length());
                     boolean up = false;
                     boolean first = true;
                     for (int i = 0; i < name.length(); i++) {
                         char c = name.charAt(i);
                         switch (c) {
                             case '-', '_', ' ', '.' -> up = true;
                             default -> {
                                 out.append(
                                         first ? Character.toLowerCase(c)
                                                 : up ? Character.toUpperCase(c): c);
                                 up = false;
                                 first = false;
                             }
                         }
                     }
                     return out.toString();
                 }
                 public static void argumentNotNullOrEmpty(String value, String argumentName) {
                     if (value == null || value.length() == 0)
                         throw new IllegalArgumentException(String.format("Argument %s can't be null or empty", argumentName));
                 }
+                public static void argumentNotNullOrBlank(String value, String argumentName) {
+                    if (value == null || value.trim().length() == 0)
+                        throw new IllegalArgumentException(String.format("Argument %s can't be null or blank", argumentName));
+                }
+                public static String sanitizeName(String value) {
+                    return INVALID_NAME_CHAR.matcher(value).replaceAll("_");
+                }
                 public static String asString(Object value) {
                     if (value == null)
                         return null;
                     if (value instanceof Provider<?> provider)
                         return asString(provider.get());
                     else
                         return value.toString();
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/BuildVariant.java 0 -43

             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.List;
             import java.util.Optional;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.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 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 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 Optional<BuildRole> findRole(String name) {
                     return Optional.ofNullable(roles.get(name));
                 }
                 public BuildRole requireRole(String name) {
                     return findRole(name)
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant '" + this.name + "' doesn't define role '" + name + "'"));
                 }
-                public Collection<LayerLink> getLinks() {
-                    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 LayerLink link(String from, String to, String kind) {
-                    ensureMutable("add links");
-                    var link = new LayerLink(
-                            requireLinkValue("from", from),
-                            requireLinkValue("to", to),
-                            requireLinkValue("kind", kind));
-                    links.add(link);
-                    return link;
                 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 Optional<BuildArtifactSlot> findArtifactSlot(String name) {
                     return Optional.ofNullable(artifactSlots.get(name));
                 }
                 public BuildArtifactSlot requireArtifactSlot(String name) {
                     return findArtifactSlot(name)
                             .orElseThrow(() -> new InvalidUserDataException(
                                     "Variant '" + this.name + "' doesn't define artifact slot '" + name + "'"));
                 }
                 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 BuildArtifactSlot newArtifactSlot(String slotName) {
                     return objects.newInstance(BuildArtifactSlot.class, slotName);
                 }
                 private void ensureMutable(String operation) {
                     if (finalized)
                         throw new InvalidUserDataException("Variant '" + name + "' is finalized and cannot " + operation);
                 }
-                private static String requireLinkValue(String field, String value) {
-                    if (value == null || value.trim().isEmpty())
-                        throw new InvalidUserDataException("Link '" + field + "' must not be null or blank");
-                    return value.trim();
                 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 Optional<BuildRole> find(String name) {
                         return BuildVariant.this.findRole(name);
                     }
                     public BuildRole require(String name) {
                         return BuildVariant.this.requireRole(name);
                     }
                 }
-                public final class LinksSpec {
-                    public LayerLink link(String from, String to, String kind) {
-                        return BuildVariant.this.link(from, to, kind);
-                    public Collection<LayerLink> getAll() {
-                        return BuildVariant.this.getLinks();
                 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 Optional<BuildArtifactSlot> find(String name) {
                         return BuildVariant.this.findArtifactSlot(name);
                     }
                     public BuildArtifactSlot require(String name) {
                         return BuildVariant.this.requireArtifactSlot(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 +2 -91

             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.Optional;
-            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 Optional<BuildVariant> find(String name) {
                     return Optional.ofNullable(variants.findByName(name));
                 }
                 public BuildVariant require(String name) {
                     return find(name)
                             .orElseThrow(() -> new InvalidUserDataException("Variant '" + name + "' isn't defined"));
                 }
                 public void whenFinalized(Action<? super BuildVariantsExtension> action) {
                     if (finalized) {
                         action.execute(this);
                         return;
                     }
                     finalizedActions.add(action);
                 }
                 public void whenFinalized(Closure<?> configure) {
                     whenFinalized(Closures.action(configure));
                 }
                 public boolean isFinalized() {
                     return finalized;
                 }
                 public void finalizeModel() {
                     if (finalized)
                         return;
                     validate();
                     for (var variant : variants)
                         variant.finalizeModel();
                     finalized = true;
                     var actions = new ArrayList<>(finalizedActions);
                     finalizedActions.clear();
                     for (var action : actions)
                         action.execute(this);
                 }
                 public void validate() {
                     var errors = new ArrayList<String>();
                     var layersByName = new LinkedHashMap<String, BuildLayer>();
                     for (var layer : layers) {
                         var layerName = normalize(layer.getName());
                         if (layerName == null) {
                             errors.add("Layer name must not be blank");
                             continue;
                         }
                         var previous = layersByName.putIfAbsent(layerName, layer);
                         if (previous != null) {
                             errors.add("Layer '" + layerName + "' is declared more than once");
                         }
                     }
                     for (var variant : variants)
                         validateVariant(variant, layersByName, errors);
                     if (!errors.isEmpty()) {
                         var message = new StringBuilder("Invalid variants model:");
                         for (var error : errors)
                             message.append("\n - ").append(error);
                         throw new InvalidUserDataException(message.toString());
                     }
                 }
                 private static void validateVariant(BuildVariant variant, Map<String, BuildLayer> layersByName, List<String> errors) {
                     var variantName = normalize(variant.getName());
                     if (variantName == null) {
                         errors.add("Variant name must not be blank");
                         return;
                     }
                     validateRoleAndArtifactNames(variant, errors);
-                    var variantLayers = validateRoleMappings(variant, layersByName, errors);
+                    validateRoleMappings(variant, layersByName, errors);
-                    validateLinks(variant, variantLayers, errors);
                 }
                 private static void validateRoleAndArtifactNames(BuildVariant variant, List<String> errors) {
                     var roleNames = new LinkedHashSet<String>();
                     for (var role : variant.getRoles()) {
                         var roleName = normalize(role.getName());
                         if (roleName == null) {
                             errors.add("Variant '" + variant.getName() + "' contains blank role name");
                             continue;
                         }
                         if (!roleNames.add(roleName)) {
                             errors.add("Variant '" + variant.getName() + "' contains duplicated role name '" + roleName + "'");
                         }
                     }
                     var slotNames = new LinkedHashSet<String>();
                     for (var slot : variant.getArtifactSlots()) {
                         var slotName = normalize(slot.getName());
                         if (slotName == null) {
                             errors.add("Variant '" + variant.getName() + "' contains blank artifact slot name");
                             continue;
                         }
                         if (!slotNames.add(slotName)) {
                             errors.add("Variant '" + variant.getName() + "' contains duplicated artifact slot name '" + slotName + "'");
                         }
                     }
                 }
-                private static Set<String> validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
+                private static void validateRoleMappings(BuildVariant variant, Map<String, BuildLayer> layersByName,
                         List<String> errors) {
-                    var variantLayers = new LinkedHashSet<String>();
                     for (var role : variant.getRoles()) {
                         var seenLayers = new LinkedHashSet<String>();
                         for (var layerName : role.getLayers().getOrElse(List.of())) {
                             var normalizedLayerName = normalize(layerName);
                             if (normalizedLayerName == null) {
                                 errors.add("Variant '" + variant.getName() + "', role '" + role.getName() + "' contains blank layer name");
                                 continue;
                             }
                             var layer = layersByName.get(normalizedLayerName);
                             if (layer == null) {
                                 errors.add("Variant '" + variant.getName() + "' references unknown layer '" + normalizedLayerName + "'");
                                 continue;
                             }
                             if (!seenLayers.add(normalizedLayerName)) {
                                 errors.add("Variant '" + variant.getName() + "', role '" + role.getName()
                                         + "' contains duplicated layer reference '" + normalizedLayerName + "'");
-                                continue;
                             }
-                            variantLayers.add(normalizedLayerName);
                         }
                     }
-                    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.from());
-                        var to = normalize(link.to());
-                        var kind = normalize(link.kind());
-                        if (from == null || to == null || kind == null) {
-                            errors.add("Variant '" + variant.getName() + "' has incomplete link (from/to/kind are required)");
-                            continue;
-                        if (!variantLayers.contains(from)) {
-                            errors.add("Variant '" + variant.getName() + "' link references unknown source layer '"
-                                    + from + "'");
-                            continue;
-                        if (!variantLayers.contains(to)) {
-                            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/VariantSourcesExtension.java +13 -21

             package org.implab.gradle.common.sources;
             import java.util.ArrayList;
             import java.util.LinkedHashMap;
             import java.util.List;
             import java.util.regex.Matcher;
             import java.util.regex.Pattern;
             import java.util.stream.Stream;
             import javax.inject.Inject;
             import org.implab.gradle.common.core.lang.Closures;
             import org.implab.gradle.common.core.lang.Strings;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.eclipse.jdt.annotation.Nullable;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             import groovy.lang.Closure;
             import groovy.lang.DelegatesTo;
+            import static org.implab.gradle.common.core.lang.Strings.sanitizeName;
             /**
              * Adapter extension that registers source sets for variant/layer pairs.
              */
             @NonNullByDefault
             public abstract class VariantSourcesExtension {
                 private static final Logger logger = Logging.getLogger(VariantSourcesExtension.class);
-                private static final Pattern 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<>();
                 private boolean sourceSetsRegistered;
                 @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));
+                    return bindings.maybeCreate(normalize(layer, "Layer name must not be null or blank"));
                 }
                 /**
                  * Configures per-layer binding.
                  */
                 public BuildLayerBinding bind(String layer, Action<? super BuildLayerBinding> configure) {
                     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) {
                     if (sourceSetsRegistered) {
                         throw new InvalidUserDataException("variantSources source sets are already registered");
                     }
                     validateBindings(variants);
                     var usages = layerUsages(variants).toList();
                     var registeredBefore = registeredContexts.size();
                     var boundBefore = boundContexts.size();
                     logger.debug(
                             "Starting variant source-set registration (variants={}, layers={}, bindings={}, usages={})",
                             variants.getVariants().size(),
                             variants.getLayers().size(),
                             bindings.size(),
                             usages.size());
                     usages.forEach(usage -> registerLayerUsage(usage, sources));
                     logger.debug(
                             "Completed variant source-set registration (newSourceSets={}, newBounds={}, totalSourceSets={})",
                             registeredContexts.size() - registeredBefore,
                             boundContexts.size() - boundBefore,
                             sourceSetsByName.size());
                     sourceSetsRegistered = true;
                 }
                 private Stream<LayerUsage> layerUsages(BuildVariantsExtension variants) {
                     return variants.getVariants().stream()
                             .flatMap(variant -> variant.getRoles().stream()
                                     .flatMap(role -> role.getLayers().getOrElse(List.of()).stream()
                                             .map(layerName -> new LayerUsage(
                                                     variant.getName(),
                                                     role.getName(),
-                                                    normalize(layerName)))));
+                                                    normalize(layerName, "Layer name in variant '" + variant.getName() + "' and role '" + role.getName() + "' must not be null or blank")))));
                 }
                 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);
+                    var result = sanitizeName(resolved);
                     if (result.isEmpty())
                         throw new InvalidUserDataException("sourceSetNamePattern '" + pattern + "' resolved to empty source set name");
                     return result;
                 }
                 private static String resolveSourceSetNamePattern(String pattern, LayerUsage usage) {
                     var matcher = SOURCE_SET_NAME_TOKEN.matcher(pattern);
                     var output = new StringBuffer();
                     while (matcher.find()) {
                         var token = matcher.group(1);
                         matcher.appendReplacement(output, Matcher.quoteReplacement(tokenValue(token, usage)));
                     }
                     matcher.appendTail(output);
                     return output.toString();
                 }
                 private static String tokenValue(String token, LayerUsage usage) {
                     return switch (token) {
-                        case "variant" -> sanitize(usage.variantName());
+                        case "variant" -> sanitizeName(usage.variantName());
-                        case "variantCap" -> Strings.capitalize(sanitize(usage.variantName()));
+                        case "variantCap" -> Strings.capitalize(sanitizeName(usage.variantName()));
-                        case "role" -> sanitize(usage.roleName());
+                        case "role" -> sanitizeName(usage.roleName());
-                        case "roleCap" -> Strings.capitalize(sanitize(usage.roleName()));
+                        case "roleCap" -> Strings.capitalize(sanitizeName(usage.roleName()));
-                        case "layer" -> sanitize(usage.layerName());
+                        case "layer" -> sanitizeName(usage.layerName());
-                        case "layerCap" -> Strings.capitalize(sanitize(usage.layerName()));
+                        case "layerCap" -> Strings.capitalize(sanitizeName(usage.layerName()));
                         default -> throw new InvalidUserDataException(
                                 "sourceSetNamePattern contains unsupported token '{" + token + "}'");
                     };
                 }
-                private static String sanitize(String value) {
+                private static String normalize(@Nullable String value, String errorMessage) {
-                    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/test/java/org/implab/gradle/common/sources/VariantsPluginFunctionalTest.java 0 -110

             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.require('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('a', 'b', null)
-                        """, "Link 'kind' must not be null or blank");
-                @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('a', 'b', 'ts:api')
-                                link('a', 'b', '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('missing', 'a', '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('a', 'missing', 'ts:api')
-                        """, "references unknown target layer 'missing'");
-                @Test
                 void failsOnDuplicatedLayerReferenceInRole() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') {
                                     layers('a', 'a')
                                 }
                             }
                         }
                         """, "contains duplicated layer reference 'a'");
                 }
                 @Test
                 void failsOnLateLayerMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') { layers('a') }
                             }
                         }
                         afterEvaluate {
                             variants.layer('late')
                         }
                         """, "Variants model is finalized and cannot configure layers");
                 }
                 @Test
                 void failsOnLateVariantMutationAfterFinalize() throws Exception {
                     assertBuildFails("""
                         plugins {
                             id 'org.implab.gradle-variants'
                         }
                         variants {
                             layer('a')
                             variant('browser') {
                                 role('main') { layers('a') }
                             }
                         }
                         afterEvaluate {
                             variants.require('browser').role('late') { layers('a') }
                         }
                         """, "Variant 'browser' is finalized and cannot configure roles");
                 }
                 private GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withPluginClasspath(pluginClasspath())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 private void assertBuildFails(String buildScript, String expectedError) throws Exception {
                     writeFile(SETTINGS_FILE, ROOT_NAME);
                     writeFile(BUILD_FILE, buildScript);
                     var ex = assertThrows(UnexpectedBuildFailure.class, () -> runner("help").build());
                     var output = ex.getBuildResult().getOutput();
                     assertTrue(output.contains(expectedError), () -> "Expected [" + expectedError + "] in output:\n" + output);
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var classesDir = Path.of(BuildVariant.class
                                 .getProtectionDomain()
                                 .getCodeSource()
                                 .getLocation()
                                 .toURI());
                         var markerResource = VariantsPlugin.class.getClassLoader()
                                 .getResource("META-INF/gradle-plugins/org.implab.gradle-variants.properties");
                         assertNotNull(markerResource, "Plugin marker resource is missing from test classpath");
                         var markerPath = Path.of(markerResource.toURI());
                         var resourcesDir = markerPath.getParent().getParent().getParent();
                         return List.of(classesDir.toFile(), resourcesDir.toFile());
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
                 }
             }

common/variants-plugin.md +4 -22

             # 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.
+            Вариант агрегирует роли, атрибуты и 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` должны входить в слойную область варианта;
+            - имена artifact slots в варианте должны быть уникальны.
-            - 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()`, `find(name)`, `require(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` — модель роли.
-            - `LayerLink` — модель направленной связи.
             - `BuildArtifactSlot` — модель артефактного слота.
             - `VariantAttributes` — typed wrapper для variant attributes.
             ## NOTES
             - Модель `variants` intentionally agnostic к toolchain.
             - Интеграция с задачами выполняется через `variantSources` и адаптеры.

common/src/main/java/org/implab/gradle/common/sources/LayerLink.java removed 0 -7

	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