evolit 0.4.4 → 0.4.5

package/README.md

@@ -444,12 +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.4` or newer,
+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.4",
+  "version": "0.4.5",
   "description": "A convention-driven application framework for LitSX and web components.",
   "type": "module",
   "packageManager": "yarn@4.10.3",

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/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;
     },
   };