modwire 2.2.0__tar.gz → 2.3.0__tar.gz

{modwire-2.2.0 → modwire-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 2.2.0
+Version: 2.3.0
 Summary: Extract source-code dependencies and build dependency graphs.
 Author: Tomasz Szpak
 License-Expression: MIT
@@ -136,6 +136,7 @@ from modwire import extract_code
 from modwire.architecture import (
     ArchitectureBoundaryRule,
     ArchitectureConfig,
+    ArchitectureFlowRealm,
     ArchitectureFlowRules,
     ArchitecturePolicyEvaluator,
     ArchitectureRules,
@@ -176,6 +177,41 @@ violations = ArchitecturePolicyEvaluator().evaluate(code_map.graph, config)
 print(render_violations(tuple(violations)))
 ```
 
+For repositories with more than one module ladder, configure flow realms and run
+the same analyzers across each module tag:
+
+```python
+config = ArchitectureConfig(
+    language="python",
+    architecture_root="src",
+    rules=ArchitectureRules(
+        tags=(
+            ArchitectureTagRule(name="backend_module", match="features/*"),
+            ArchitectureTagRule(name="gui_page", match="app/pages/*"),
+            ArchitectureTagRule(name="domain", match="features/*/domain"),
+            ArchitectureTagRule(name="application", match="features/*/application"),
+        ),
+        flow=ArchitectureFlowRules(
+            realms=(
+                ArchitectureFlowRealm(
+                    name="backend",
+                    module_tag="backend_module",
+                    layers=("domain", "application"),
+                ),
+                ArchitectureFlowRealm(
+                    name="gui",
+                    module_tag="gui_page",
+                ),
+            ),
+            analyzers=("backward-flow", "no-cycles"),
+        ),
+    ),
+)
+```
+
+`backward-flow` evaluates realms with layers and skips layerless realms; scoped
+analyzers such as `no-cycles` evaluate every configured realm.
+
 Architecture insight helpers summarize ownership and graph pressure:
 
 ```python

{modwire-2.2.0 → modwire-2.3.0}/README.md

@@ -103,6 +103,7 @@ from modwire import extract_code
 from modwire.architecture import (
     ArchitectureBoundaryRule,
     ArchitectureConfig,
+    ArchitectureFlowRealm,
     ArchitectureFlowRules,
     ArchitecturePolicyEvaluator,
     ArchitectureRules,
@@ -143,6 +144,41 @@ violations = ArchitecturePolicyEvaluator().evaluate(code_map.graph, config)
 print(render_violations(tuple(violations)))
 ```
 
+For repositories with more than one module ladder, configure flow realms and run
+the same analyzers across each module tag:
+
+```python
+config = ArchitectureConfig(
+    language="python",
+    architecture_root="src",
+    rules=ArchitectureRules(
+        tags=(
+            ArchitectureTagRule(name="backend_module", match="features/*"),
+            ArchitectureTagRule(name="gui_page", match="app/pages/*"),
+            ArchitectureTagRule(name="domain", match="features/*/domain"),
+            ArchitectureTagRule(name="application", match="features/*/application"),
+        ),
+        flow=ArchitectureFlowRules(
+            realms=(
+                ArchitectureFlowRealm(
+                    name="backend",
+                    module_tag="backend_module",
+                    layers=("domain", "application"),
+                ),
+                ArchitectureFlowRealm(
+                    name="gui",
+                    module_tag="gui_page",
+                ),
+            ),
+            analyzers=("backward-flow", "no-cycles"),
+        ),
+    ),
+)
+```
+
+`backward-flow` evaluates realms with layers and skips layerless realms; scoped
+analyzers such as `no-cycles` evaluate every configured realm.
+
 Architecture insight helpers summarize ownership and graph pressure:
 
 ```python

{modwire-2.2.0 → modwire-2.3.0}/src/modwire/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.0'
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = '2.3.0'
+__version_tuple__ = version_tuple = (2, 3, 0)
 
-__commit_id__ = commit_id = 'gc116aabfa'
+__commit_id__ = commit_id = 'gdb0b34253'

{modwire-2.2.0 → modwire-2.3.0}/src/modwire/architecture/__init__.py

@@ -4,6 +4,7 @@ from .config import (
     ArchitectureConfig,
     ArchitectureConfigError,
     ArchitectureConfigIssue,
+    ArchitectureFlowRealm,
     ArchitectureFlowRules,
     ArchitectureRules,
     ArchitectureTagRule,
@@ -32,6 +33,7 @@ __all__ = [
     "ArchitectureConfig",
     "ArchitectureConfigError",
     "ArchitectureConfigIssue",
+    "ArchitectureFlowRealm",
     "ArchitectureFlowRules",
     "ArchitectureMap",
     "ArchitecturePolicyEvaluator",

{modwire-2.2.0 → modwire-2.3.0}/src/modwire/architecture/analyzers.py

@@ -40,9 +40,9 @@ def analyzer_title(name: str) -> str:
     return _ANALYZERS[name].title
 
 
-def run_analyzer(name: str, graph, tags, config):
+def run_analyzer(name: str, graph, tags, config, realm=None):
     analyzer = _ANALYZERS[name]
-    return analyzer.run(analyzer.name, graph, tags, config)
+    return analyzer.run(analyzer.name, graph, tags, config, realm)
 
 
 def _roots(graph):
@@ -65,12 +65,18 @@ def _dedupe(violations):
     return unique
 
 
-def _flow(name, path, index, message):
-    return FlowViolation(name, tuple(path), index, f"analyzer:{name}", message)
+def _flow(name, path, index, message, realm=None):
+    realm_name = "" if realm is None else getattr(realm, "name", "") or getattr(
+        realm,
+        "module_tag",
+        "",
+    )
+    rule_name = f"analyzer:{realm_name}:{name}" if realm_name else f"analyzer:{name}"
+    return FlowViolation(name, tuple(path), index, rule_name, message)
 
 
-def _backward_flow(name, graph, tags, config):
-    layers = config.rules.flow.layers
+def _backward_flow(name, graph, tags, config, realm):
+    layers = realm.layers if realm is not None else config.rules.flow.layers
 
     def layer(node):
         return next((i for i, layer_name in enumerate(layers) if layer_name in tags.get(node, set())), None)
@@ -85,7 +91,7 @@ def _backward_flow(name, graph, tags, config):
         for edge in graph.outgoing(node):
             next_layer = layer(edge.to_id)
             if current_layer is not None and next_layer is not None and next_layer < current_layer:
-                violations.append(_flow(name, [*path, edge.to_id], len(path), "layer order violated"))
+                violations.append(_flow(name, [*path, edge.to_id], len(path), "layer order violated", realm))
                 continue
             walk(edge.to_id, current_layer if next_layer is None else next_layer, [*path, edge.to_id])
 
@@ -94,8 +100,8 @@ def _backward_flow(name, graph, tags, config):
     return _dedupe(violations)
 
 
-def _no_reentry(name, graph, tags, config):
-    module_tag = config.rules.flow.module_tag
+def _no_reentry(name, graph, tags, config, realm):
+    module_tag = realm.module_tag if realm is not None else config.rules.flow.module_tag
     violations = []
     seen = set()
 
@@ -107,7 +113,7 @@ def _no_reentry(name, graph, tags, config):
             inside = module_tag in tags.get(edge.to_id, set())
             next_state = 1 if state == 0 and inside else 2 if state == 1 and not inside else state
             if state == 2 and inside:
-                violations.append(_flow(name, [*path, edge.to_id], len(path), "module layer re-entered after exit"))
+                violations.append(_flow(name, [*path, edge.to_id], len(path), "module layer re-entered after exit", realm))
                 continue
             walk(edge.to_id, next_state, [*path, edge.to_id])
 
@@ -116,8 +122,9 @@ def _no_reentry(name, graph, tags, config):
     return _dedupe(violations)
 
 
-def _no_cycles(name, graph, tags, config):
-    scoped = {node for node, node_tags in tags.items() if config.rules.flow.module_tag in node_tags}
+def _no_cycles(name, graph, tags, config, realm):
+    module_tag = realm.module_tag if realm is not None else config.rules.flow.module_tag
+    scoped = {node for node, node_tags in tags.items() if module_tag in node_tags}
     seen, stack, index, emitted, violations = set(), [], {}, set(), []
 
     def canonical(cycle):
@@ -137,7 +144,7 @@ def _no_cycles(name, graph, tags, config):
                 key = canonical(cycle)
                 if key not in emitted:
                     emitted.add(key)
-                    violations.append(_flow(name, cycle, len(cycle) - 1, "module cycle detected"))
+                    violations.append(_flow(name, cycle, len(cycle) - 1, "module cycle detected", realm))
             elif edge.to_id not in seen:
                 dfs(edge.to_id)
         stack.pop()

{modwire-2.2.0 → modwire-2.3.0}/src/modwire/architecture/config.py

@@ -31,11 +31,20 @@ class ArchitectureBoundaryRule(BaseModel):
     allow_same_match: bool = False
 
 
+class ArchitectureFlowRealm(BaseModel):
+    model_config = ConfigDict(frozen=True, from_attributes=True)
+
+    name: str = ""
+    module_tag: str = ""
+    layers: tuple[str, ...] = ()
+
+
 class ArchitectureFlowRules(BaseModel):
     model_config = ConfigDict(frozen=True, from_attributes=True)
 
     layers: tuple[str, ...] = ()
     module_tag: str = ""
+    realms: tuple[ArchitectureFlowRealm, ...] = ()
     analyzers: tuple[str, ...] = ()
 
     @field_validator("analyzers")
@@ -50,6 +59,28 @@ class ArchitectureFlowRules(BaseModel):
 
     @model_validator(mode="after")
     def analyzers_have_required_config(self) -> ArchitectureFlowRules:
+        if self.realms:
+            if "backward-flow" in self.analyzers and not any(
+                realm.layers for realm in self.realms
+            ):
+                raise ValueError(
+                    "backward-flow requires at least one rules.flow.realms entry "
+                    "with layers"
+                )
+            scoped_analyzers = {"no-reentry", "no-cycles"}.intersection(
+                self.analyzers
+            )
+            missing_module_tag = tuple(
+                index for index, realm in enumerate(self.realms) if not realm.module_tag
+            )
+            if scoped_analyzers and missing_module_tag:
+                names = ", ".join(sorted(scoped_analyzers))
+                indexes = ", ".join(str(index) for index in missing_module_tag)
+                raise ValueError(
+                    f"{names} require rules.flow.realms module_tag values "
+                    f"(missing at indexes: {indexes})"
+                )
+            return self
         if "backward-flow" in self.analyzers and not self.layers:
             raise ValueError("backward-flow requires rules.flow.layers")
         scoped_analyzers = {"no-reentry", "no-cycles"}.intersection(self.analyzers)
@@ -114,13 +145,26 @@ def validate_policy_config(config) -> ArchitectureConfig:
         ) from error
 
 
+def flow_realms(flow: ArchitectureFlowRules) -> tuple[ArchitectureFlowRealm, ...]:
+    if flow.realms:
+        return flow.realms
+    return (
+        ArchitectureFlowRealm(
+            module_tag=flow.module_tag,
+            layers=flow.layers,
+        ),
+    )
+
+
 __all__ = [
     "ArchitectureBoundaryRule",
     "ArchitectureConfig",
     "ArchitectureConfigError",
     "ArchitectureConfigIssue",
+    "ArchitectureFlowRealm",
     "ArchitectureFlowRules",
     "ArchitectureRules",
     "ArchitectureTagRule",
+    "flow_realms",
     "validate_policy_config",
 ]

{modwire-2.2.0 → modwire-2.3.0}/src/modwire/architecture/matching.py

@@ -43,14 +43,31 @@ class TagMatcher:
         self.tags = tuple(getattr(config.rules, "tags", ()))
 
     def match(self, node_id: str, name: str, *, scope: bool = True) -> TagMatch | None:
-        tag = self._tag(name)
-        pattern = tag.match if tag is not None else name
+        matches = self.matches(node_id, name, scope=scope)
+        if matches:
+            return matches[0]
+        if self._has_tag(name):
+            return None
+        pattern = name
         return self.match_pattern(
             node_id,
             pattern,
             name=name,
             scope=scope,
-            exclude=() if tag is None else tag.excluded_patterns,
+        )
+
+    def matches(
+        self,
+        node_id: str,
+        name: str,
+        *,
+        scope: bool = True,
+    ) -> tuple[TagMatch, ...]:
+        return tuple(
+            match
+            for tag in self.tags
+            if tag.name == name
+            if (match := self._match_tag(node_id, tag, scope=scope)) is not None
         )
 
     def match_pattern(
@@ -80,9 +97,19 @@ class TagMatcher:
                 )
         return None
 
-    def first_match(self, node_id: str, names: tuple[str, ...]) -> TagMatch | None:
+    def first_match(
+        self,
+        node_id: str,
+        names: tuple[str, ...],
+        *,
+        scope: bool = True,
+    ) -> TagMatch | None:
         return next(
-            (match for name in names if (match := self.match(node_id, name)) is not None),
+            (
+                tag_match
+                for name in names
+                if (tag_match := self.match(node_id, name, scope=scope)) is not None
+            ),
             None,
         )
 
@@ -90,7 +117,7 @@ class TagMatcher:
         return tuple(
             match
             for tag in self.tags
-            if (match := self.match(node_id, tag.name)) is not None
+            if (match := self._match_tag(node_id, tag)) is not None
         )
 
     def map_code_map(self, code_map) -> TagMap:
@@ -111,8 +138,17 @@ class TagMatcher:
             return path[len(architecture_root) + 1 :]
         return path
 
-    def _tag(self, name: str):
-        return next((tag for tag in self.tags if tag.name == name), None)
+    def _match_tag(self, node_id: str, tag, *, scope: bool = True) -> TagMatch | None:
+        return self.match_pattern(
+            node_id,
+            tag.match,
+            name=tag.name,
+            scope=scope,
+            exclude=tag.excluded_patterns,
+        )
+
+    def _has_tag(self, name: str) -> bool:
+        return any(tag.name == name for tag in self.tags)
 
 
 def _normalized_patterns(language, pattern, config):

{modwire-2.2.0 → modwire-2.3.0}/src/modwire/architecture/policy.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from modwire.graph import DependencyGraph
 
 from .analyzers import run_analyzer
-from .config import validate_policy_config
+from .config import flow_realms, validate_policy_config
 from .matching import TagMatcher
 from .violations import EdgeRuleViolation, FlowViolation
 
@@ -14,7 +14,13 @@ class ArchitecturePolicyEvaluator:
         tags = _tags(graph.node_ids(), config)
         violations: list[EdgeRuleViolation | FlowViolation] = _edge_violations(graph, config)
         for analyzer_name in config.rules.flow.analyzers:
-            violations.extend(run_analyzer(analyzer_name, graph, tags, config))
+            for realm in flow_realms(config.rules.flow):
+                if analyzer_name == "backward-flow" and not realm.layers:
+                    continue
+                analyzer_realm = realm if config.rules.flow.realms else None
+                violations.extend(
+                    run_analyzer(analyzer_name, graph, tags, config, analyzer_realm)
+                )
         return violations
 
 

{modwire-2.2.0 → modwire-2.3.0}/src/modwire.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 2.2.0
+Version: 2.3.0
 Summary: Extract source-code dependencies and build dependency graphs.
 Author: Tomasz Szpak
 License-Expression: MIT
@@ -136,6 +136,7 @@ from modwire import extract_code
 from modwire.architecture import (
     ArchitectureBoundaryRule,
     ArchitectureConfig,
+    ArchitectureFlowRealm,
     ArchitectureFlowRules,
     ArchitecturePolicyEvaluator,
     ArchitectureRules,
@@ -176,6 +177,41 @@ violations = ArchitecturePolicyEvaluator().evaluate(code_map.graph, config)
 print(render_violations(tuple(violations)))
 ```
 
+For repositories with more than one module ladder, configure flow realms and run
+the same analyzers across each module tag:
+
+```python
+config = ArchitectureConfig(
+    language="python",
+    architecture_root="src",
+    rules=ArchitectureRules(
+        tags=(
+            ArchitectureTagRule(name="backend_module", match="features/*"),
+            ArchitectureTagRule(name="gui_page", match="app/pages/*"),
+            ArchitectureTagRule(name="domain", match="features/*/domain"),
+            ArchitectureTagRule(name="application", match="features/*/application"),
+        ),
+        flow=ArchitectureFlowRules(
+            realms=(
+                ArchitectureFlowRealm(
+                    name="backend",
+                    module_tag="backend_module",
+                    layers=("domain", "application"),
+                ),
+                ArchitectureFlowRealm(
+                    name="gui",
+                    module_tag="gui_page",
+                ),
+            ),
+            analyzers=("backward-flow", "no-cycles"),
+        ),
+    ),
+)
+```
+
+`backward-flow` evaluates realms with layers and skips layerless realms; scoped
+analyzers such as `no-cycles` evaluate every configured realm.
+
 Architecture insight helpers summarize ownership and graph pressure:
 
 ```python

{modwire-2.2.0 → modwire-2.3.0}/src/modwire.egg-info/SOURCES.txt

@@ -27,6 +27,8 @@ src/modwire.egg-info/PKG-INFO
 src/modwire.egg-info/SOURCES.txt
 src/modwire.egg-info/dependency_links.txt
 src/modwire.egg-info/requires.txt
+src/modwire.egg-info/scm_file_list.json
+src/modwire.egg-info/scm_version.json
 src/modwire.egg-info/top_level.txt
 src/modwire/architecture/__init__.py
 src/modwire/architecture/analyzers.py

modwire-2.3.0/src/modwire.egg-info/scm_file_list.json

@@ -0,0 +1,85 @@
+{
+  "files": [
+    "README.md",
+    "uv.lock",
+    "LICENSE",
+    "pyproject.toml",
+    "show_test_source_files.py",
+    "CONTRIBUTING.md",
+    ".gitignore",
+    "docs/wiki/Reporting-bugs.md",
+    "docs/wiki/Development-checks.md",
+    "docs/wiki/Home.md",
+    "docs/wiki/Requesting-features.md",
+    "src/modwire/__init__.py",
+    "src/modwire/definitions.py",
+    "src/modwire/graph.py",
+    "src/modwire/metadata.py",
+    "src/modwire/exports.py",
+    "src/modwire/callables.py",
+    "src/modwire/extractors/__init__.py",
+    "src/modwire/extractors/typescript.py",
+    "src/modwire/extractors/resources.py",
+    "src/modwire/extractors/loader.py",
+    "src/modwire/extractors/php.py",
+    "src/modwire/extractors/python.py",
+    "src/modwire/extractors/base.py",
+    "src/modwire/extractors/scripts/python_extractor.py",
+    "src/modwire/extractors/scripts/__init__.py",
+    "src/modwire/extractors/scripts/php_extractor.php",
+    "src/modwire/extractors/scripts/typescript_extractor.js",
+    "src/modwire/architecture/__init__.py",
+    "src/modwire/architecture/violations.py",
+    "src/modwire/architecture/config.py",
+    "src/modwire/architecture/analyzers.py",
+    "src/modwire/architecture/render.py",
+    "src/modwire/architecture/insights.py",
+    "src/modwire/architecture/matching.py",
+    "src/modwire/architecture/policy.py",
+    "src/modwire/extraction/roots.py",
+    "src/modwire/extraction/__init__.py",
+    "src/modwire/extraction/models.py",
+    "src/modwire/extraction/serialization.py",
+    "src/modwire/extraction/manifest.py",
+    "src/modwire/extraction/cache.py",
+    "src/modwire/extraction/service.py",
+    "src/modwire/shape/rules.py",
+    "src/modwire/shape/__init__.py",
+    "src/modwire/shape/violations.py",
+    "src/modwire/shape/config.py",
+    "src/modwire/shape/evaluator.py",
+    "src/modwire/testing/__init__.py",
+    "src/modwire/testing/factories.py",
+    "tests/test_api.py",
+    "tests/test_standalone.py",
+    "tests/test_architecture_api.py",
+    "tests/large_projects/README.md",
+    "tests/large_projects/run_large_project_fixtures.py",
+    "tests/large_projects/fixtures.json",
+    "tests/apps/python/src/domain/model/user.py",
+    "tests/apps/python/src/domain/services/policy.py",
+    "tests/apps/python/src/interfaces/http/controller.py",
+    "tests/apps/python/src/application/use_cases/activate.py",
+    "tests/apps/python/ignored/generated.py",
+    "tests/apps/php/src/domain/model/user.php",
+    "tests/apps/php/src/domain/services/policy.php",
+    "tests/apps/php/src/interfaces/http/controller.php",
+    "tests/apps/php/src/application/use_cases/activate.php",
+    "tests/apps/php/ignored/generated.php",
+    "tests/apps/typescript/src/domain/model/user.ts",
+    "tests/apps/typescript/src/domain/model/profile.tsx",
+    "tests/apps/typescript/src/domain/services/policy.ts",
+    "tests/apps/typescript/src/domain/services/audit.js",
+    "tests/apps/typescript/src/interfaces/http/controller.ts",
+    "tests/apps/typescript/src/interfaces/http/view.jsx",
+    "tests/apps/typescript/src/application/use_cases/activate.ts",
+    "tests/apps/typescript/ignored/generated.ts",
+    ".github/PULL_REQUEST_TEMPLATE.md",
+    ".github/ISSUE_TEMPLATE/bug_report.yml",
+    ".github/ISSUE_TEMPLATE/config.yml",
+    ".github/ISSUE_TEMPLATE/feature_request.yml",
+    ".github/workflows/release.yml",
+    ".github/workflows/large-repo-fixtures.yml",
+    ".github/workflows/ci.yml"
+  ]
+}

modwire-2.3.0/src/modwire.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.3.0",
+  "distance": 0,
+  "node": "gdb0b34253d73c2613cd3738350c5ec308b8e4f13",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-06-22"
+}

{modwire-2.2.0 → modwire-2.3.0}/tests/test_architecture_api.py

@@ -11,6 +11,7 @@ from modwire.architecture import (
     ArchitectureConfig,
     ArchitectureConfigError,
     ArchitectureFlowRules,
+    ArchitectureFlowRealm,
     ArchitectureMap,
     ArchitecturePolicyEvaluator,
     ArchitectureRules,
@@ -120,6 +121,36 @@ class ArchitectureApiTest(unittest.TestCase):
             "src/features/billing",
         )
 
+    def test_tag_matcher_exposes_duplicate_name_matches_explicitly(self) -> None:
+        matcher = TagMatcher(
+            ArchitectureConfig(
+                language="python",
+                architecture_root="src",
+                rules=ArchitectureRules(
+                    tags=(
+                        ArchitectureTagRule(name="module", match="features/*"),
+                        ArchitectureTagRule(name="module", match="features/*/domain"),
+                    ),
+                ),
+            )
+        )
+
+        matches = matcher.matches("src/features/billing/domain", "module")
+        tag_matches = matcher.tags_for("src/features/billing/domain")
+
+        self.assertEqual(
+            [match.pattern for match in matches],
+            ["features/*", "features/*/domain"],
+        )
+        self.assertEqual(
+            [match.pattern for match in tag_matches],
+            ["features/*", "features/*/domain"],
+        )
+        self.assertEqual(
+            matcher.match("src/features/billing/domain", "module").pattern,
+            "features/*",
+        )
+
     def test_architecture_config_models_validate_and_evaluate_policy(self) -> None:
         graph = DependencyGraph()
         graph.add_edge("src/features/billing/ui", "src/features/billing/domain")
@@ -217,6 +248,70 @@ class ArchitectureApiTest(unittest.TestCase):
 
                 self.assertIn(expected_message, context.exception.to_dict()["issues"][0]["message"])
 
+    def test_legacy_flow_module_tag_still_evaluates_without_realm_rule_names(self) -> None:
+        graph = DependencyGraph()
+        graph.add_edge("src/features/billing", "src/features/orders")
+        graph.add_edge("src/features/orders", "src/features/billing")
+        config = ArchitectureConfig(
+            language="python",
+            architecture_root="src",
+            rules=ArchitectureRules(
+                tags=(ArchitectureTagRule(name="module", match="features/*"),),
+                flow=ArchitectureFlowRules(
+                    module_tag="module",
+                    analyzers=("no-cycles",),
+                ),
+            ),
+        )
+
+        violations = ArchitecturePolicyEvaluator().evaluate(graph, config)
+
+        self.assertEqual(len(violations), 1)
+        self.assertEqual(violations[0].violation_type, "no-cycles")
+        self.assertEqual(violations[0].rule_name, "analyzer:no-cycles")
+
+    def test_flow_realms_evaluate_each_module_tag_independently(self) -> None:
+        graph = DependencyGraph()
+        graph.add_edge("src/features/billing", "src/features/orders")
+        graph.add_edge("src/features/orders", "src/features/billing")
+        graph.add_edge("src/app/pages/home", "src/app/pages/settings")
+        graph.add_edge("src/app/pages/settings", "src/app/pages/home")
+        config = ArchitectureConfig(
+            language="python",
+            architecture_root="src",
+            rules=ArchitectureRules(
+                tags=(
+                    ArchitectureTagRule(name="backend_module", match="features/*"),
+                    ArchitectureTagRule(name="gui_page", match="app/pages/*"),
+                ),
+                flow=ArchitectureFlowRules(
+                    realms=(
+                        ArchitectureFlowRealm(
+                            name="backend",
+                            module_tag="backend_module",
+                            layers=("domain", "application"),
+                        ),
+                        ArchitectureFlowRealm(
+                            name="gui",
+                            module_tag="gui_page",
+                            layers=(),
+                        ),
+                    ),
+                    analyzers=("backward-flow", "no-cycles"),
+                ),
+            ),
+        )
+
+        violations = ArchitecturePolicyEvaluator().evaluate(graph, config)
+
+        self.assertEqual(
+            [(violation.violation_type, violation.rule_name) for violation in violations],
+            [
+                ("no-cycles", "analyzer:backend:no-cycles"),
+                ("no-cycles", "analyzer:gui:no-cycles"),
+            ],
+        )
+
     def test_flow_violations_have_stable_dict_shape(self) -> None:
         violation = FlowViolation(
             violation_type="backward-flow",