weapp-tailwindcss 4.9.8 → 4.10.0-beta.1

package/dist/{chunk-N75TUIFJ.mjs → chunk-3B2AYJZI.mjs}

@@ -12,20 +12,20 @@ import {
 } from "./chunk-RRHPTTCP.mjs";
 import {
   setupPatchRecorder
-} from "./chunk-W3JRVMJD.mjs";
+} from "./chunk-P5UFIGA6.mjs";
 import {
   collectRuntimeClassSet,
   createAttributeMatcher,
   createDebug,
   generateCode,
   getCompilerContext,
+  getRuntimeClassSetSignature,
   refreshTailwindRuntimeState,
   replaceWxml,
   toCustomAttributesEntities,
   vitePluginName
-} from "./chunk-77PO4QLM.mjs";
+} from "./chunk-RQPZ5Q2B.mjs";
 import {
-  getGroupedEntries,
   resolveUniUtsPlatform
 } from "./chunk-OOHJLO5M.mjs";
 
@@ -352,6 +352,7 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
   return async () => {
     const {
       cache,
+      hashKey,
       createHandlerOptions,
       debug: debug2,
       jsHandler,
@@ -361,10 +362,13 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
     } = options;
     const absoluteFile = toAbsoluteOutputPath(file, outDir);
     const rawSource = originalSource.source.toString();
+    const rawHashSource = options.hashSalt ? `${rawSource}
+/*${options.hashSalt}*/` : rawSource;
     await processCachedTask({
       cache,
       cacheKey: file,
-      rawSource,
+      hashKey,
+      rawSource: rawHashSource,
       applyResult(source) {
         originalSource.source = source;
       },
@@ -465,8 +469,210 @@ function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
   }
 }
 
+// src/bundlers/vite/js-precheck.ts
+var FAST_JS_TRANSFORM_HINT_RE = /className\b|class\s*=|classList\.|\b(?:twMerge|clsx|classnames|cn|cva)\b|\[["'`]class["'`]\]|text-\[|bg-\[|\b(?:[whpm]|px|py|mx|my|rounded|flex|grid|gap)-/;
+var DEPENDENCY_HINT_RE = /\bimport\s*[("'`{*]|\brequire\s*\(|\bexport\s+\*\s+from\s+["'`]|\bexport\s*\{[^}]*\}\s*from\s+["'`]/;
+function shouldSkipViteJsTransform(rawSource, options) {
+  if (!rawSource) {
+    return true;
+  }
+  if (options?.alwaysEscape) {
+    return false;
+  }
+  if (options?.moduleSpecifierReplacements && Object.keys(options.moduleSpecifierReplacements).length > 0) {
+    return false;
+  }
+  if (options?.wrapExpression) {
+    return false;
+  }
+  if (DEPENDENCY_HINT_RE.test(rawSource)) {
+    return false;
+  }
+  return !FAST_JS_TRANSFORM_HINT_RE.test(rawSource);
+}
+
 // src/bundlers/vite/generate-bundle.ts
+function createEmptyMetric() {
+  return {
+    total: 0,
+    transformed: 0,
+    cacheHits: 0,
+    elapsed: 0
+  };
+}
+function createEmptyMetrics() {
+  return {
+    runtimeSet: 0,
+    html: createEmptyMetric(),
+    js: createEmptyMetric(),
+    css: createEmptyMetric()
+  };
+}
+function classifyEntry(file, opts) {
+  if (opts.cssMatcher(file)) {
+    return "css";
+  }
+  if (opts.htmlMatcher(file)) {
+    return "html";
+  }
+  if (opts.jsMatcher(file) || opts.wxsMatcher(file)) {
+    return "js";
+  }
+  return "other";
+}
+function readEntrySource(output) {
+  if (output.type === "chunk") {
+    return output.code;
+  }
+  return output.source.toString();
+}
+function toJsAbsoluteFilename(file, outDir) {
+  return toAbsoluteOutputPath(file, outDir);
+}
+function computeDirtyEntries(entries, opts, state) {
+  const nextSourceHashByFile = /* @__PURE__ */ new Map();
+  const changedByType = {
+    html: /* @__PURE__ */ new Set(),
+    js: /* @__PURE__ */ new Set(),
+    css: /* @__PURE__ */ new Set(),
+    other: /* @__PURE__ */ new Set()
+  };
+  for (const [file, output] of entries) {
+    const type = classifyEntry(file, opts);
+    const source = readEntrySource(output);
+    const hash = opts.cache.computeHash(source);
+    nextSourceHashByFile.set(file, hash);
+    const previousHash = state.previousSourceHashByFile.get(file);
+    if (previousHash == null || previousHash !== hash) {
+      changedByType[type].add(file);
+    }
+  }
+  return {
+    sourceHashByFile: nextSourceHashByFile,
+    changedByType
+  };
+}
+function buildProcessSets(entries, opts, changedByType, previousLinkedByEntry, forceAll = false) {
+  const processFiles = {
+    html: /* @__PURE__ */ new Set(),
+    js: /* @__PURE__ */ new Set(),
+    css: /* @__PURE__ */ new Set()
+  };
+  const linkedImpactsByEntry = /* @__PURE__ */ new Map();
+  if (forceAll) {
+    for (const [file] of entries) {
+      const type = classifyEntry(file, opts);
+      if (type === "html" || type === "js" || type === "css") {
+        processFiles[type].add(file);
+      }
+    }
+    return {
+      files: processFiles,
+      linkedImpactsByEntry
+    };
+  }
+  const firstRun = previousLinkedByEntry.size === 0;
+  if (firstRun) {
+    for (const [file] of entries) {
+      const type = classifyEntry(file, opts);
+      if (type === "html" || type === "js" || type === "css") {
+        processFiles[type].add(file);
+      }
+    }
+    return {
+      files: processFiles,
+      linkedImpactsByEntry
+    };
+  }
+  for (const file of changedByType.html) {
+    processFiles.html.add(file);
+  }
+  for (const file of changedByType.css) {
+    processFiles.css.add(file);
+  }
+  for (const file of changedByType.js) {
+    processFiles.js.add(file);
+  }
+  for (const changedFile of changedByType.js) {
+    for (const [entryFile, linkedFiles] of previousLinkedByEntry.entries()) {
+      if (linkedFiles.has(changedFile)) {
+        processFiles.js.add(entryFile);
+        let impacts = linkedImpactsByEntry.get(entryFile);
+        if (!impacts) {
+          impacts = /* @__PURE__ */ new Set();
+          linkedImpactsByEntry.set(entryFile, impacts);
+        }
+        impacts.add(changedFile);
+      }
+    }
+  }
+  return {
+    files: processFiles,
+    linkedImpactsByEntry
+  };
+}
+function measureElapsed(start) {
+  return performance.now() - start;
+}
+function formatCacheHitRate(metric) {
+  if (metric.total === 0) {
+    return "0.00%";
+  }
+  return `${(metric.cacheHits / metric.total * 100).toFixed(2)}%`;
+}
+function formatMs(value) {
+  return value.toFixed(2);
+}
+function summarizeStringDiff(previous, next) {
+  if (previous === next) {
+    return "same";
+  }
+  const previousLength = previous.length;
+  const nextLength = next.length;
+  const minLength = Math.min(previousLength, nextLength);
+  let prefixLength = 0;
+  while (prefixLength < minLength && previous.charCodeAt(prefixLength) === next.charCodeAt(prefixLength)) {
+    prefixLength += 1;
+  }
+  let previousSuffixCursor = previousLength - 1;
+  let nextSuffixCursor = nextLength - 1;
+  while (previousSuffixCursor >= prefixLength && nextSuffixCursor >= prefixLength && previous.charCodeAt(previousSuffixCursor) === next.charCodeAt(nextSuffixCursor)) {
+    previousSuffixCursor -= 1;
+    nextSuffixCursor -= 1;
+  }
+  const previousChangedLength = previousSuffixCursor >= prefixLength ? previousSuffixCursor - prefixLength + 1 : 0;
+  const nextChangedLength = nextSuffixCursor >= prefixLength ? nextSuffixCursor - prefixLength + 1 : 0;
+  return `changed@${prefixLength} old=${previousChangedLength} new=${nextChangedLength} len=${previousLength}->${nextLength}`;
+}
+function createLinkedImpactSignature(entry, linkedImpactsByEntry, sourceHashByFile) {
+  const changedLinkedFiles = linkedImpactsByEntry.get(entry);
+  if (!changedLinkedFiles || changedLinkedFiles.size === 0) {
+    return void 0;
+  }
+  const parts = [...changedLinkedFiles].sort().map((file) => {
+    const hash = sourceHashByFile.get(file) ?? "missing";
+    return `${file}:${hash}`;
+  });
+  return parts.join(",");
+}
+function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
+  if (!linkedImpactSignature) {
+    return runtimeSignature;
+  }
+  return `${runtimeSignature}:linked:${linkedImpactSignature}`;
+}
 function createGenerateBundleHook(context) {
+  const state = {
+    iteration: 0,
+    previousSourceHashByFile: /* @__PURE__ */ new Map(),
+    previousLinkedByEntry: /* @__PURE__ */ new Map(),
+    changedByType: {
+      html: /* @__PURE__ */ new Set(),
+      js: /* @__PURE__ */ new Set(),
+      css: /* @__PURE__ */ new Set(),
+      other: /* @__PURE__ */ new Set()
+    }
+  };
   return async function generateBundle(_opt, bundle) {
     const {
       opts,
@@ -490,7 +696,15 @@ function createGenerateBundleHook(context) {
     await runtimeState.patchPromise;
     debug2("start");
     onStart();
+    const metrics = createEmptyMetrics();
+    const forceRuntimeRefresh = process2.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+    const disableDirtyOptimization = process2.env.WEAPP_TW_VITE_DISABLE_DIRTY === "1";
+    const disableJsPrecheck = process2.env.WEAPP_TW_VITE_DISABLE_JS_PRECHECK === "1";
+    const debugCssDiff = process2.env.WEAPP_TW_VITE_DEBUG_CSS_DIFF === "1";
     const entries = Object.entries(bundle);
+    const dirtyEntries = computeDirtyEntries(entries, opts, state);
+    const processSets = buildProcessSets(entries, opts, dirtyEntries.changedByType, state.previousLinkedByEntry, disableDirtyOptimization);
+    const processFiles = processSets.files;
     const resolvedConfig = getResolvedConfig();
     const rootDir = resolvedConfig?.root ? path2.resolve(resolvedConfig.root) : process2.cwd();
     const outDir = resolvedConfig?.build?.outDir ? path2.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
@@ -498,14 +712,16 @@ function createGenerateBundleHook(context) {
     for (const [fileName, output] of entries) {
       const entry = { fileName, output };
       if (isJavaScriptEntry(entry)) {
-        const absolute = toAbsoluteOutputPath(fileName, outDir);
+        const absolute = toJsAbsoluteFilename(fileName, outDir);
         jsEntries.set(absolute, entry);
       }
     }
     const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
-    const groupedEntries = getGroupedEntries(entries, opts);
-    const runtime = await ensureRuntimeClassSet(true);
+    const runtimeStart = performance.now();
+    const runtime = await ensureRuntimeClassSet(forceRuntimeRefresh);
+    metrics.runtimeSet = measureElapsed(runtimeStart);
     debug2("get runtimeSet, class count: %d", runtime.size);
+    const runtimeSignature = getRuntimeClassSetSignature(runtimeState.twPatcher) ?? "runtime:missing";
     const handleLinkedUpdate = (fileName, previous, next) => {
       onUpdate(fileName, previous, next);
       debug2("js linked handle: %s", fileName);
@@ -532,25 +748,37 @@ function createGenerateBundleHook(context) {
         sourceFilename: absoluteFilename
       }
     });
+    const linkedByEntry = /* @__PURE__ */ new Map();
     const tasks = [];
-    if (Array.isArray(groupedEntries.html)) {
-      for (const [file, originalSource] of groupedEntries.html) {
+    const jsTaskFactories = [];
+    for (const [file, originalSource] of entries) {
+      const type = classifyEntry(file, opts);
+      if (type === "html" && originalSource.type === "asset") {
+        metrics.html.total++;
+        if (!processFiles.html.has(file)) {
+          continue;
+        }
         const rawSource = originalSource.source.toString();
         tasks.push(
           processCachedTask({
             cache,
             cacheKey: file,
             rawSource,
+            hashKey: `${file}:html:${runtimeSignature}`,
             applyResult(source) {
               originalSource.source = source;
             },
             onCacheHit() {
+              metrics.html.cacheHits++;
               debug2("html cache hit: %s", file);
             },
             async transform() {
+              const start = performance.now();
               const transformed = await templateHandler(rawSource, {
                 runtimeSet: runtime
               });
+              metrics.html.elapsed += measureElapsed(start);
+              metrics.html.transformed++;
               onUpdate(file, rawSource, transformed);
               debug2("html handle: %s", file);
               return {
@@ -559,73 +787,29 @@ function createGenerateBundleHook(context) {
             }
           })
         );
+        continue;
       }
-    }
-    const jsTaskFactories = [];
-    if (Array.isArray(groupedEntries.js)) {
-      for (const [file, originalSource] of groupedEntries.js) {
-        if (originalSource.type === "chunk") {
-          const absoluteFile = toAbsoluteOutputPath(file, outDir);
-          const initialRawSource = originalSource.code;
-          jsTaskFactories.push(async () => {
-            await processCachedTask({
-              cache,
-              cacheKey: file,
-              rawSource: initialRawSource,
-              applyResult(source) {
-                originalSource.code = source;
-              },
-              onCacheHit() {
-                debug2("js cache hit: %s", file);
-              },
-              async transform() {
-                const rawSource = originalSource.code;
-                const { code, linked } = await jsHandler(rawSource, runtime, createHandlerOptions(absoluteFile));
-                onUpdate(file, rawSource, code);
-                debug2("js handle: %s", file);
-                applyLinkedUpdates(linked);
-                return {
-                  result: code
-                };
-              }
-            });
-          });
-        } else if (uniAppX && originalSource.type === "asset") {
-          jsTaskFactories.push(
-            createUniAppXAssetTask(
-              file,
-              originalSource,
-              outDir,
-              {
-                cache,
-                createHandlerOptions,
-                debug: debug2,
-                jsHandler,
-                onUpdate,
-                runtimeSet: runtime,
-                applyLinkedResults: applyLinkedUpdates,
-                uniAppX
-              }
-            )
-          );
+      if (type === "css" && originalSource.type === "asset") {
+        metrics.css.total++;
+        if (!processFiles.css.has(file)) {
+          continue;
         }
-      }
-    }
-    if (Array.isArray(groupedEntries.css)) {
-      for (const [file, originalSource] of groupedEntries.css) {
         const rawSource = originalSource.source.toString();
         tasks.push(
           processCachedTask({
             cache,
             cacheKey: file,
             rawSource,
+            hashKey: `${file}:css:${runtimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`,
             applyResult(source) {
               originalSource.source = source;
             },
             onCacheHit() {
+              metrics.css.cacheHits++;
               debug2("css cache hit: %s", file);
             },
             async transform() {
+              const start = performance.now();
               await runtimeState.patchPromise;
               const { css } = await styleHandler(rawSource, {
                 isMainChunk: mainCssChunkMatcher(originalSource.fileName, appType),
@@ -636,6 +820,11 @@ function createGenerateBundleHook(context) {
                 },
                 majorVersion: runtimeState.twPatcher.majorVersion
               });
+              if (debugCssDiff) {
+                debug2("css diff %s: %s", file, summarizeStringDiff(rawSource, css));
+              }
+              metrics.css.elapsed += measureElapsed(start);
+              metrics.css.transformed++;
               onUpdate(file, rawSource, css);
               debug2("css handle: %s", file);
               return {
@@ -644,6 +833,130 @@ function createGenerateBundleHook(context) {
             }
           })
         );
+        continue;
+      }
+      if (type !== "js") {
+        continue;
+      }
+      metrics.js.total++;
+      if (!processFiles.js.has(file)) {
+        continue;
+      }
+      if (originalSource.type === "chunk") {
+        const absoluteFile = toJsAbsoluteFilename(file, outDir);
+        const initialRawSource = originalSource.code;
+        const linkedSet = /* @__PURE__ */ new Set();
+        linkedByEntry.set(file, linkedSet);
+        jsTaskFactories.push(async () => {
+          const linkedImpactSignature = createLinkedImpactSignature(
+            file,
+            processSets.linkedImpactsByEntry,
+            dirtyEntries.sourceHashByFile
+          );
+          const hashSalt = createJsHashSalt(runtimeSignature, linkedImpactSignature);
+          await processCachedTask({
+            cache,
+            cacheKey: file,
+            hashKey: `${file}:js`,
+            rawSource: `${initialRawSource}
+/*${hashSalt}*/`,
+            applyResult(source) {
+              originalSource.code = source;
+            },
+            onCacheHit() {
+              metrics.js.cacheHits++;
+              debug2("js cache hit: %s", file);
+            },
+            async transform() {
+              const start = performance.now();
+              const rawSource = originalSource.code;
+              const handlerOptions = createHandlerOptions(absoluteFile);
+              if (!disableJsPrecheck && shouldSkipViteJsTransform(rawSource, handlerOptions)) {
+                metrics.js.elapsed += measureElapsed(start);
+                metrics.js.transformed++;
+                return {
+                  result: rawSource
+                };
+              }
+              const { code, linked } = await jsHandler(rawSource, runtime, handlerOptions);
+              metrics.js.elapsed += measureElapsed(start);
+              metrics.js.transformed++;
+              onUpdate(file, rawSource, code);
+              debug2("js handle: %s", file);
+              if (linked) {
+                for (const id of Object.keys(linked)) {
+                  const linkedEntry = jsEntries.get(id);
+                  if (linkedEntry) {
+                    linkedSet.add(linkedEntry.fileName);
+                  }
+                }
+              }
+              applyLinkedUpdates(linked);
+              return {
+                result: code
+              };
+            }
+          });
+        });
+      } else if (uniAppX && originalSource.type === "asset") {
+        const linkedSet = /* @__PURE__ */ new Set();
+        linkedByEntry.set(file, linkedSet);
+        const baseApplyLinkedUpdates = applyLinkedUpdates;
+        const wrappedApplyLinkedUpdates = (linked) => {
+          if (linked) {
+            for (const id of Object.keys(linked)) {
+              const linkedEntry = jsEntries.get(id);
+              if (linkedEntry) {
+                linkedSet.add(linkedEntry.fileName);
+              }
+            }
+          }
+          baseApplyLinkedUpdates(linked);
+        };
+        const factory = createUniAppXAssetTask(
+          file,
+          originalSource,
+          outDir,
+          {
+            cache,
+            hashKey: `${file}:js`,
+            hashSalt: createJsHashSalt(
+              runtimeSignature,
+              createLinkedImpactSignature(
+                file,
+                processSets.linkedImpactsByEntry,
+                dirtyEntries.sourceHashByFile
+              )
+            ),
+            createHandlerOptions,
+            debug: debug2,
+            jsHandler,
+            onUpdate,
+            runtimeSet: runtime,
+            applyLinkedResults: wrappedApplyLinkedUpdates,
+            uniAppX
+          }
+        );
+        jsTaskFactories.push(async () => {
+          const start = performance.now();
+          const currentSource = originalSource.source.toString();
+          const absoluteFile = toJsAbsoluteFilename(file, outDir);
+          const precheckOptions = createHandlerOptions(absoluteFile, {
+            uniAppX: uniAppX ?? true,
+            babelParserOptions: {
+              plugins: ["typescript"],
+              sourceType: "unambiguous"
+            }
+          });
+          if (!disableJsPrecheck && shouldSkipViteJsTransform(currentSource, precheckOptions)) {
+            metrics.js.elapsed += measureElapsed(start);
+            metrics.js.transformed++;
+            return;
+          }
+          await factory();
+          metrics.js.elapsed += measureElapsed(start);
+          metrics.js.transformed++;
+        });
       }
     }
     pushConcurrentTaskFactories(tasks, jsTaskFactories);
@@ -651,6 +964,44 @@ function createGenerateBundleHook(context) {
     for (const apply of pendingLinkedUpdates) {
       apply();
     }
+    state.iteration += 1;
+    const finalSourceHashByFile = /* @__PURE__ */ new Map();
+    for (const [fileName, output] of entries) {
+      finalSourceHashByFile.set(fileName, opts.cache.computeHash(readEntrySource(output)));
+    }
+    state.previousSourceHashByFile = finalSourceHashByFile;
+    state.changedByType = dirtyEntries.changedByType;
+    const nextLinkedByEntry = new Map(state.previousLinkedByEntry);
+    for (const [entryFile, linkedFiles] of linkedByEntry.entries()) {
+      nextLinkedByEntry.set(entryFile, linkedFiles);
+    }
+    for (const entryFile of [...nextLinkedByEntry.keys()]) {
+      const exists = entries.some(([fileName]) => fileName === entryFile);
+      if (!exists) {
+        nextLinkedByEntry.delete(entryFile);
+      }
+    }
+    state.previousLinkedByEntry = nextLinkedByEntry;
+    debug2(
+      "metrics iteration=%d runtime=%sms html(total=%d transform=%d hit=%d rate=%s elapsed=%sms) js(total=%d transform=%d hit=%d rate=%s elapsed=%sms) css(total=%d transform=%d hit=%d rate=%s elapsed=%sms)",
+      state.iteration,
+      formatMs(metrics.runtimeSet),
+      metrics.html.total,
+      metrics.html.transformed,
+      metrics.html.cacheHits,
+      formatCacheHitRate(metrics.html),
+      formatMs(metrics.html.elapsed),
+      metrics.js.total,
+      metrics.js.transformed,
+      metrics.js.cacheHits,
+      formatCacheHitRate(metrics.js),
+      formatMs(metrics.js.elapsed),
+      metrics.css.total,
+      metrics.css.transformed,
+      metrics.css.cacheHits,
+      formatCacheHitRate(metrics.css),
+      formatMs(metrics.css.elapsed)
+    );
     onEnd();
     debug2("end");
   };
@@ -763,23 +1114,56 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   let runtimeSet;
   let runtimeSetPromise;
   let resolvedConfig;
+  let runtimeRefreshSignature;
+  let runtimeRefreshOptionsKey;
+  function resolveRuntimeRefreshOptions() {
+    const configPath = runtimeState.twPatcher.options?.tailwind?.config;
+    const signature = getRuntimeClassSetSignature(runtimeState.twPatcher);
+    const optionsKey = JSON.stringify({
+      appType,
+      uniAppX: Boolean(uniAppX),
+      customAttributesEntities,
+      disabledDefaultTemplateHandler,
+      configPath,
+      rewriteCssImports: shouldRewriteCssImports
+    });
+    const changed = signature !== runtimeRefreshSignature || optionsKey !== runtimeRefreshOptionsKey;
+    runtimeRefreshSignature = signature;
+    runtimeRefreshOptionsKey = optionsKey;
+    return {
+      changed,
+      signature,
+      optionsKey
+    };
+  }
   async function refreshRuntimeState(force) {
-    const refreshed = await refreshTailwindRuntimeState(runtimeState, force);
+    const invalidation = resolveRuntimeRefreshOptions();
+    const shouldRefresh = force || invalidation.changed;
+    const refreshed = await refreshTailwindRuntimeState(runtimeState, {
+      force: shouldRefresh,
+      clearCache: force || invalidation.changed
+    });
+    if (invalidation.changed) {
+      debug("runtime signature changed, refresh triggered. signature: %s", invalidation.signature);
+    }
     if (refreshed) {
       runtimeSet = void 0;
       runtimeSetPromise = void 0;
     }
   }
   async function ensureRuntimeClassSet(force = false) {
+    const forceRuntimeRefresh = force || process3.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
     await refreshRuntimeState(force);
     await runtimeState.patchPromise;
-    if (!force && runtimeSet) {
+    if (!forceRuntimeRefresh && runtimeSet) {
       return runtimeSet;
     }
-    if (force || !runtimeSetPromise) {
+    if (forceRuntimeRefresh || !runtimeSetPromise) {
+      const invalidation = resolveRuntimeRefreshOptions();
       const task2 = collectRuntimeClassSet(runtimeState.twPatcher, {
-        force: force || !runtimeSet,
-        skipRefresh: force
+        force: forceRuntimeRefresh || invalidation.changed,
+        skipRefresh: forceRuntimeRefresh,
+        clearCache: forceRuntimeRefresh || invalidation.changed
       });
       runtimeSetPromise = task2;
     }