Move domain negotiation to HTTP middleware for early domain_config overrides

Move domain negotiation into HTTP middleware

Problem

Domain negotiation currently runs as a KernelEvents::REQUEST event subscriber at priority 256. Any HTTP middleware that reads Drupal config — such as CleanTalk at priority 210 — does so before the active domain is set, because event subscribers only fire after the full middleware stack has executed. This means DomainConfigFactoryOverride returns default config instead of domain-specific overrides for those middlewares.

Approach

Add a new DomainNegotiationMiddleware (http_middleware, priority 220) that negotiates the active domain early in the middleware stack. Priority 220 places it:

• After ReverseProxy (300) — so HTTP_HOST is already corrected from proxy headers
• Before CleanTalk (210) — so domain_config overrides are active when CleanTalk reads config

The middleware:

1. Pushes the request onto RequestStack so DomainNegotiator reads the proxy-corrected hostname (not raw $_SERVER)
2. Calls DomainNegotiator::getActiveDomain() to negotiate
3. Pops the request to avoid a double entry when HttpKernel pushes it again later

DomainSubscriber is unchanged — getActiveDomain() checks isNegotiated() and returns the cached domain, so the event subscriber's negotiation call becomes a no-op while its redirect/access logic runs as before.

Execution flow after the change

Module loading and Drupal version handling

Domain negotiation triggers entity type discovery via EntityTypeManager::getStorage('domain') and hook dispatch via ModuleHandler::alter('domain_request', ...). The middleware handles this differently depending on Drupal version:

• Before Drupal 11.1: #[LegacyHook] procedural functions are the registered hook implementations. The middleware calls ModuleHandler::loadAll() unconditionally before negotiation so that .module files are available (e.g. domain_alias_domain_request_alter()). This is idempotent — the later KernelPreHandle call is a no-op.
• From Drupal 11.1+: OOP hooks are dispatched directly via the container without needing .module files. The middleware attempts negotiation without loadAll(). On a warm entity type cache (99.9% of requests), this means zero overhead. On a cold cache (e.g. during update.php), entity type discovery needs procedural hook_entity_type_build implementations — the middleware catches the failure, calls loadAll(), and retries.

Changes

• New: domain/src/StackMiddleware/DomainNegotiationMiddleware.php
• Modified: domain/domain.services.yml — added the middleware service definition
• Unchanged: DomainSubscriber, DomainNegotiator

New domain_early_negotiation submodule

Moved the early domain negotiation middleware from the domain module into a standalone submodule in domain_extras. Enabling the module = enabling the feature — no separate config toggle needed.

Files

Key design decisions

• No enabled config flag — installing the module is the toggle. This eliminates the container parameter overhead when the feature is not wanted.
• Priority is compiled into a container parameter via DomainEarlyNegotiationServiceProvider, so there is zero runtime config read overhead.
• The module's settings config is excluded from Domain Config UI overrides via hook_domain_config_ui_disallowed_configurations_alter() — middleware priority must be the same across all domains.