evolit 0.4.3 → 0.4.5

package/README.md

@@ -444,6 +444,17 @@ configuration therefore stays isolated per render, extracted SSR data is read
 before the scope closes, and integration response headers are included before
 the response is cached.
 
+The supported SSR combination is `evolit@0.4.5` or newer,
+`@litsx/core@1.0.0-next.8` or newer, and `@litsx/urql@0.4.2` or newer. Evolit
+resolves the server-conditioned URQL adapter from the application project and
+uses that same module instance for setup, request resources, route rendering,
+SSR extraction, and cleanup.
+
+The concurrent UnoCSS + URQL regression gate is validated with
+`evolit@0.4.5`, `@litsx/compiler@1.0.0-next.13`,
+`@litsx/ssr@1.0.0-next.5`, `@litsx/unocss@1.0.0-next.8`,
+`@litsx/urql@0.4.2`, and `unocss@66.8.1`.
+
 ## Extensions
 
 Optional integrations are configured explicitly in `evolit.config.js`. Core only coordinates their

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolit",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "A convention-driven application framework for LitSX and web components.",
   "type": "module",
   "packageManager": "yarn@4.10.3",
@@ -75,7 +75,7 @@
     "ws": "^8.18.3"
   },
   "peerDependencies": {
-    "@litsx/urql": "^0.4.0"
+    "@litsx/urql": "^0.4.2"
   },
   "peerDependenciesMeta": {
     "@litsx/urql": {
@@ -85,6 +85,7 @@
   "devDependencies": {
     "@litsx/tailwind": "1.0.0-next.8",
     "@litsx/unocss": "1.0.0-next.8",
+    "@litsx/urql": "^0.4.2",
     "@playwright/test": "^1.62.0",
     "@webcomponents/scoped-custom-element-registry": "^0.0.10",
     "unocss": "66.8.1",

package/src/build.js

@@ -606,7 +606,7 @@ export async function buildProject(projectRoot, options = {}) {
             urqlRequestContext,
           ),
         };
-      });
+      }, { projectRoot });
       if (!response) {
         continue;
       }

package/src/client-assets.js

@@ -581,7 +581,22 @@ function createSharedChunkGroup(id) {
     return "vendor-litsx";
   }
 
-  return "vendor-misc";
+  return undefined;
+}
+
+function createBrowserEnvironmentPlugin(mode) {
+  const nodeEnvironment = mode === "production" ? "production" : "development";
+  const replacement = JSON.stringify(nodeEnvironment);
+  return {
+    name: "evolit-browser-environment",
+    transform(code) {
+      if (!code.includes("process.env.NODE_ENV")) return null;
+      return {
+        code: code.replaceAll("process.env.NODE_ENV", replacement),
+        map: null,
+      };
+    },
+  };
 }
 
 function isClientAssetStubModule(relativePath) {
@@ -746,6 +761,7 @@ export async function buildSharedVendorRuntime(
         .map((group) => buildSharedVendorRuntime(projectRoot, mode, {
           ...options,
           additionalEntrySpecifiers: group.specifiers,
+          externalSpecifiers: developmentGroups.baseSpecifiers,
           vendorGroup: group.vendorGroup,
           includeBase: false,
         })),
@@ -790,9 +806,16 @@ export async function buildSharedVendorRuntime(
     const specifierByEntryName = new Map(
       specifiers.map((specifier) => [createSharedEntryName(specifier), specifier]),
     );
+    const externalSpecifiers = new Set(
+      Array.isArray(options.externalSpecifiers) ? options.externalSpecifiers : [],
+    );
     const bundle = await rollup({
       input: inputEntries,
+      external(source) {
+        return externalSpecifiers.has(source);
+      },
       plugins: [
+        createBrowserEnvironmentPlugin(mode),
         {
           name: "evolit-browser-exports",
           resolveId(source) {
@@ -814,10 +837,6 @@ export async function buildSharedVendorRuntime(
       ],
       preserveEntrySignatures: "strict",
       onwarn(warning, warn) {
-        if (warning.code === "CIRCULAR_DEPENDENCY") {
-          return;
-        }
-
         warn(warning);
       },
     });
@@ -836,6 +855,10 @@ export async function buildSharedVendorRuntime(
         manualChunks(id) {
           return createSharedChunkGroup(id);
         },
+        paths(id) {
+          if (!externalSpecifiers.has(id)) return id;
+          return `/_evolit/shared/base/${createSharedEntryName(id)}.mjs`;
+        },
       });
 
       const imports = {};

package/src/compiler.js

@@ -28,6 +28,7 @@ const RESOLVABLE_IMPORT_EXTENSIONS = [
 const developmentGraphCache = new Map();
 const developmentGraphDependencies = new Map();
 const developmentModuleNamespaceCache = new Map();
+const productionModuleNamespaceCache = new Map();
 const developmentGraphVersions = new Map();
 const developmentUnmanagedImportWarnings = new Set();
 const projectPathAliasesCache = new Map();
@@ -1785,34 +1786,34 @@ export async function emitClientStaticAssets(assetPaths, options = {}) {
 
 export async function importCompiledModule(entryPath, options = {}) {
   const mode = options.mode ?? "development";
-  const normalizedOptions = mode === "development"
-    ? { ...options, projectRoot: path.resolve(options.projectRoot ?? process.cwd()) }
-    : options;
-  const cacheKey = mode === "development"
-    ? getDevelopmentGraphCacheKey(path.resolve(entryPath), normalizedOptions)
-    : null;
-  const cachedModule = cacheKey ? developmentModuleNamespaceCache.get(cacheKey) : null;
+  const normalizedOptions = {
+    ...options,
+    projectRoot: path.resolve(options.projectRoot ?? process.cwd()),
+  };
+  const cacheKey = getDevelopmentGraphCacheKey(path.resolve(entryPath), normalizedOptions);
+  const moduleCache = mode === "development"
+    ? developmentModuleNamespaceCache
+    : productionModuleNamespaceCache;
+  const cachedModule = moduleCache.get(cacheKey);
   if (cachedModule) {
     return cachedModule;
   }
 
-  const { entrypoint } = await compileModuleGraph(entryPath, normalizedOptions);
-  const moduleUrl = new URL(pathToFileURL(entrypoint).href);
-
-  if (mode === "development") {
-    moduleUrl.searchParams.set("t", String(developmentGraphVersions.get(cacheKey) ?? 0));
-  }
-
-  const pendingModule = import(moduleUrl.href);
-  if (cacheKey) {
-    developmentModuleNamespaceCache.set(cacheKey, pendingModule);
-  }
+  const pendingModule = (async () => {
+    const { entrypoint } = await compileModuleGraph(entryPath, normalizedOptions);
+    const moduleUrl = new URL(pathToFileURL(entrypoint).href);
+    if (mode === "development") {
+      moduleUrl.searchParams.set("t", String(developmentGraphVersions.get(cacheKey) ?? 0));
+    }
+    return import(moduleUrl.href);
+  })();
+  moduleCache.set(cacheKey, pendingModule);
 
   try {
     return await pendingModule;
   } catch (error) {
-    if (developmentModuleNamespaceCache.get(cacheKey) === pendingModule) {
-      developmentModuleNamespaceCache.delete(cacheKey);
+    if (moduleCache.get(cacheKey) === pendingModule) {
+      moduleCache.delete(cacheKey);
     }
     throw error;
   }

package/src/deployment-runtime.js

@@ -930,7 +930,7 @@ export async function createRequestRenderer({
           routeResult,
           response,
         };
-      });
+      }, { projectRoot });
     },
     get assetManifest() {
       return currentAssetManifest;

package/src/litsx-pipeline.js

@@ -206,8 +206,13 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
   const instances = [];
   const names = new Set();
   let disposed = false;
+  let closing = false;
   let generation = 0;
   let finalizedGeneration = -1;
+  let finalizationFlight = null;
+  let invalidationFlight = null;
+  let queuedFinalization = null;
+  let disposalPromise = null;
   const dependencies = new Set();
   const processedModules = new Set();
   const moduleDependencies = new Map();
@@ -288,7 +293,7 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
   }
 
   function assertActive() {
-    if (disposed) throw new Error("This LitSX pipeline has already been disposed.");
+    if (closing || disposed) throw new Error("This LitSX pipeline has already been disposed.");
   }
 
   function recordContribution(integrationName, moduleId, contribution) {
@@ -496,16 +501,43 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
         evolitDependencies: [...(moduleDependencies.get(moduleId) ?? [])].sort(),
       };
     },
-    async finalize(context = {}) {
+    finalize(context = {}) {
       assertActive();
-      if (finalizedGeneration === generation) return null;
+      if (invalidationFlight) {
+        if (queuedFinalization) return queuedFinalization.promise;
+        const awaitedInvalidation = invalidationFlight.promise;
+        const promise = awaitedInvalidation.then(() => {
+          if (queuedFinalization?.promise === promise) queuedFinalization = null;
+          return pipeline.finalize(context);
+        });
+        queuedFinalization = { promise };
+        promise.then(
+          () => {
+            if (queuedFinalization?.promise === promise) queuedFinalization = null;
+          },
+          () => {
+            if (queuedFinalization?.promise === promise) queuedFinalization = null;
+          },
+        );
+        return promise;
+      }
+      if (finalizedGeneration === generation) return Promise.resolve(null);
+      if (finalizationFlight?.generation === generation) return finalizationFlight.promise;
+      if (finalizationFlight) {
+        return finalizationFlight.promise.then(
+          () => pipeline.finalize(context),
+          () => pipeline.finalize(context),
+        );
+      }
+      const targetGeneration = generation;
+      const publishGeneration = async () => {
       if (moduleDependencies.delete("<graph>")) rebuildDependencies();
       removeOwnedContributions("<graph>");
       for (const { descriptor, instance } of instances) {
         if (typeof instance.finalize !== "function") continue;
         try {
           const contribution = normalizeContribution(
-            await instance.finalize(Object.freeze({ ...context, generation, mode })),
+            await instance.finalize(Object.freeze({ ...context, generation: targetGeneration, mode })),
             descriptor.name,
             resolvedProjectRoot,
           );
@@ -539,6 +571,7 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
             hadPreviousRoot: false,
             installed: false,
           };
+          rootOperations.push(operation);
           if (outputs.length > 0) {
             operation.stagingRoot = `${root}.staging-${randomUUID()}`;
             await ensureDirectory(operation.stagingRoot);
@@ -558,7 +591,6 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
               if (output.kind === "style" && output.document) manifest.documentStyles.push(record);
             }
           }
-          rootOperations.push(operation);
         }
 
         for (const { output, integrationName } of pendingOutputs.values()) {
@@ -634,10 +666,22 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
         if (operation.stagingRoot) publishedRoots.set(operation.integrationName, operation.root);
         else publishedRoots.delete(operation.integrationName);
       }
-      finalizedGeneration = generation;
+      finalizedGeneration = targetGeneration;
       return manifest;
+      };
+      const promise = publishGeneration();
+      finalizationFlight = { generation: targetGeneration, promise };
+      promise.then(
+        () => {
+          if (finalizationFlight?.promise === promise) finalizationFlight = null;
+        },
+        () => {
+          if (finalizationFlight?.promise === promise) finalizationFlight = null;
+        },
+      );
+      return promise;
     },
-    async invalidate(changedPaths = null) {
+    invalidate(changedPaths = null) {
       assertActive();
       const paths = Array.isArray(changedPaths)
         ? changedPaths.map((entry) => canonicalDependency(resolvedProjectRoot, entry))
@@ -645,6 +689,26 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
       const affected = paths == null || paths.some((entry) => (
         dependencies.has(entry) || processedModules.has(entry)
       ));
+      const previousInvalidation = invalidationFlight?.promise ?? null;
+      const activeFinalization = finalizationFlight?.promise ?? null;
+      const promise = (async () => {
+      if (previousInvalidation) {
+        try {
+          await previousInvalidation;
+        } catch {
+          // A later invalidation is allowed to recover from an earlier failure.
+        }
+      }
+      if (activeFinalization) {
+        try {
+          await activeFinalization;
+        } catch {
+          // Failed finalization leaves the generation retryable before invalidation.
+        }
+      }
+      if (closing || disposed) {
+        throw new Error("This LitSX pipeline has already been disposed.");
+      }
       for (const { descriptor, instance } of instances) {
         if (typeof instance.invalidate !== "function") continue;
         try {
@@ -661,6 +725,17 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
         }
       }
       return affected;
+      })();
+      invalidationFlight = { promise };
+      promise.then(
+        () => {
+          if (invalidationFlight?.promise === promise) invalidationFlight = null;
+        },
+        () => {
+          if (invalidationFlight?.promise === promise) invalidationFlight = null;
+        },
+      );
+      return promise;
     },
     async forget(moduleId) {
       assertActive();
@@ -683,8 +758,19 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
         await removePath(virtualModule);
       }
     },
-    async dispose() {
-      if (disposed) return;
+    dispose() {
+      if (disposalPromise) return disposalPromise;
+      if (disposed) return Promise.resolve();
+      closing = true;
+      disposalPromise = (async () => {
+      for (const flight of [queuedFinalization, invalidationFlight, finalizationFlight]) {
+        if (!flight) continue;
+        try {
+          await flight.promise;
+        } catch {
+          // The original caller owns a lifecycle error; disposal still completes.
+        }
+      }
       disposed = true;
       let firstError = null;
       for (const { descriptor, instance } of [...instances].reverse()) {
@@ -696,6 +782,8 @@ export async function createLitsxPipeline({ projectRoot, mode, config } = {}) {
       }
       await removePath(virtualRoot);
       if (firstError) throw firstError;
+      })();
+      return disposalPromise;
     },
   };
 

package/src/urql-ssr.js

@@ -1,13 +1,18 @@
-let adapterPromise = null;
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const adapterPromisesByModuleUrl = new Map();
 
 function isMissingUrqlAdapter(error) {
-  return error?.code === "ERR_MODULE_NOT_FOUND"
+  return (error?.code === "ERR_MODULE_NOT_FOUND" || error?.code === "MODULE_NOT_FOUND")
     && String(error.message).includes("@litsx/urql");
 }
 
-async function loadSsrUrqlAdapter() {
+function resolveSsrUrqlAdapterUrl(projectRoot) {
   try {
-    return await import("@litsx/urql");
+    const requireFromProject = createRequire(path.join(path.resolve(projectRoot), "package.json"));
+    return pathToFileURL(requireFromProject.resolve("@litsx/urql")).href;
   } catch (error) {
     if (isMissingUrqlAdapter(error)) {
       return null;
@@ -16,9 +21,22 @@ async function loadSsrUrqlAdapter() {
   }
 }
 
-export async function getSsrUrqlAdapter() {
-  adapterPromise ??= loadSsrUrqlAdapter();
-  return adapterPromise;
+export async function getSsrUrqlAdapter(projectRoot = process.cwd()) {
+  const moduleUrl = resolveSsrUrqlAdapterUrl(projectRoot);
+  if (!moduleUrl) return null;
+  let adapterPromise = adapterPromisesByModuleUrl.get(moduleUrl);
+  if (!adapterPromise) {
+    adapterPromise = import(moduleUrl);
+    adapterPromisesByModuleUrl.set(moduleUrl, adapterPromise);
+  }
+  try {
+    return await adapterPromise;
+  } catch (error) {
+    if (adapterPromisesByModuleUrl.get(moduleUrl) === adapterPromise) {
+      adapterPromisesByModuleUrl.delete(moduleUrl);
+    }
+    throw error;
+  }
 }
 
 /**
@@ -40,7 +58,7 @@ export async function runWithOptionalSsrUrqlScope(
   }
   const adapter = Object.hasOwn(options, "adapter")
     ? options.adapter
-    : await getSsrUrqlAdapter();
+    : await getSsrUrqlAdapter(options.projectRoot);
   if (!adapter) {
     return callback(null);
   }