A package keeps taking effect on the next request, instead of twenty seconds later.

The previous commit made server-side composition wait for the compiled client stylesheet,
so that a package could never be live on one renderer and not the other. That broke
misc/PATCH-settings-package-import.sh, which declares an ldh:import and asserts the
package's marker on the very next response - and the test is right. Its own comment, and
the 5.10.0 changelog that introduced declarative imports, state the contract: effective on
the next request, no restart. Holding the server back silently converted that into
"effective in about twenty seconds", which is a different product.

The second consequence was worse than the interleaving it was meant to prevent. The
Dockerfile always sets SEF_COMPILER, so the service is always constructed and the
"no compiler configured" fallback never fires in a real deployment - an instance whose
compiler container was missing or unreachable would have lost package rendering entirely
rather than degrading to the behaviour it had before any of this existed.

So composition is never withheld. Packages compose server-side on every request, exactly
as they did; the compiled SEF is an addition the client picks up once it exists. The window
where the server has the package and the client does not is precisely the behaviour that
shipped in 5.10.0 and has been permanent ever since - it is now bounded to one compile
after an install or a platform upgrade, which is the improvement this branch is for.

One thing this costs, recorded because it is a real change in observability: a compile
failure is no longer visible in the rendered page, since the server still composes. It
surfaces in the build's exceptionally handler and in the compiler's verbatim stderr, and
nowhere else.

Known and not addressed here: while a key is unpublished, every render submits a build.
computeIfAbsent deduplicates concurrent ones, but a failing compiler clears the entry on
completion, so a persistently unreachable compiler means one attempt per request. Cheap to
bound with a negative cache; out of scope for restoring the contract.

Verified: mvn compile clean. The assertion sequence the test drives now holds by
construction - no import, stock; import, composed on the next request; import removed,
stock again.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BSRUJBNKKjdgJeP3qRZTPd

Author: namedgraph

src/main/java/com/atomgraph/linkeddatahub/server/filter/response/XsltExecutableFilter.java

@@ -103,26 +103,21 @@ public void filter(ContainerRequestContext req, ContainerResponseContext resp) t
                 ClientStylesheetService stylesheetService = getSystem().getClientStylesheetService();
 
                 if (packages.isEmpty()) req.setProperty(AC.stylesheet.getURI(), getXsltExecutable(stylesheet));
-                else if (stylesheetService == null)
-                    // no compiler configured: compose server-side only, which is how packages behaved
-                    // before client-side composition existed
-                    req.setProperty(AC.stylesheet.getURI(), getXsltExecutable(getApplication().get(), stylesheet, packages));
                 else
                 {
-                    String key = stylesheetService.getKey(packages);
+                    // server-side composition is never withheld: a declarative import takes effect on the
+                    // next request, and it is the only rendering an instance whose compiler is unreachable
+                    // will ever get
+                    req.setProperty(AC.stylesheet.getURI(), getXsltExecutable(getApplication().get(), stylesheet, packages));
 
-                    if (stylesheetService.isPublished(key))
+                    if (stylesheetService != null)
                     {
-                        req.setProperty(LDH.clientStylesheet.getURI(), stylesheetService.getPublicPath(key));
-                        req.setProperty(AC.stylesheet.getURI(), getXsltExecutable(getApplication().get(), stylesheet, packages));
-                    }
-                    else
-                    {
-                        // both renderers stay on the uncomposed stylesheet until the compiled one exists.
-                        // Composing server-side while the client cannot is what makes a package's rules
-                        // appear on load and vanish on the first client-side navigation
-                        stylesheetService.buildAsync(key, getStylesheets(packages));
-                        req.setProperty(AC.stylesheet.getURI(), getXsltExecutable(stylesheet));
+                        String key = stylesheetService.getKey(packages);
+
+                        // until the composed stylesheet exists the client renders without the package, as it
+                        // always has; compiling one closes that window rather than opening it
+                        if (stylesheetService.isPublished(key)) req.setProperty(LDH.clientStylesheet.getURI(), stylesheetService.getPublicPath(key));
+                        else stylesheetService.buildAsync(key, getStylesheets(packages));
                     }
                 }
             }