@navecss/core 0.5.0 → 0.6.0

package/dist/vite.js

@@ -1,8 +1,8 @@
 import { formatFinding, findingsInText } from './chunk-ZNTNLGEC.js';
-import { assertOptions, resolveUsedOptions, keptAtoms, withRestorers, pruneAtomicLayer, atomsWrittenIn, applyEdits, compareText, inspectAtomicLayer, withoutRemoved, CX_SOURCE, toSourceMap, unprunedAtoms, isSecondHop, buildReport, atomOfClass, moduleReport, isListableReexport, CLASS_MAP_NOT_PARSED, isNode, readModule, combinedMapOf, placerFor, cxModulesArray, nodeAt, staticStringOf, pushAll, childrenOf, nodesAt, LINE_UNKNOWN_WITHOUT_MAP, LINE_UNKNOWN_UNMAPPED, exportNameOf, analyze, memberReadOf, patternDestructuring, stringAt, propertyNameOf } from './chunk-BCUK4M4P.js';
-import { validateExtendAtomsHostFree } from './chunk-63H2FLGU.js';
+import { assertOptions, resolveUsedOptions, keptAtoms, isStylesheetId, canHoldDirective, withRestorers, pruneAtomicLayer, atomsWrittenIn, applyEdits, forgetDeclared, filePathOf, compareText, isStylesheetPath, inspectAtomicLayer, fileOf, withoutRemoved, CX_SOURCE, decideReexports, isUnreadStylesheet, declaredModulesFor, isAboutListed, isDependencyId, toSourceMap, unprunedAtoms, judgeReexports, buildReport, specifiersOf, atomOfClass, isCssModuleId, moduleReport, specifiersIn, takesIn, UNREADABLE, CLASS_MAP_NOT_PARSED, isNode, recognisedKey, isListedFile, readModule, combinedMapOf, placerFor, isRelative, cxModulesArray, nodesAt, nodeAt, isNamingListed, staticStringOf, LINE_UNKNOWN_WITHOUT_MAP, LINE_UNKNOWN_UNMAPPED, isResolvingTo, resolveOrNull } from './chunk-EYMFWE3A.js';
+import { validateExtendAtomsHostFree } from './chunk-B5CWZIBK.js';
 import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
-import { snapshotExtendMap, expandText, foldLocated } from './chunk-MWHZ26S4.js';
+import { snapshotExtendMap, expandText, foldLocated } from './chunk-KDLLTOAM.js';
 import './chunk-UVHGEVMV.js';
 import { decodeIncomingMap, formatDiagnostic } from './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';
@@ -398,31 +398,6 @@ function captureStylesheets(context, plugins) {
   const { transform } = plugin;
   plugin.transform = typeof transform === "function" ? wrapped : { ...transform, handler: wrapped };
 }
-
-// src/vite-css-id.ts
-var STYLESHEET = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
-var SPECIAL_QUERY = /[?&](?:worker|sharedworker|raw|url)\b/;
-var CSS_MODULE = /\.module\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
-var TEXT_QUERY = /[?&](?:inline|direct|transform-only)\b/;
-function isStylesheetPath(id) {
-  return STYLESHEET.test(id);
-}
-function isStylesheetId(id) {
-  return STYLESHEET.test(id) && !SPECIAL_QUERY.test(id);
-}
-function isCssModuleId(id) {
-  return isStylesheetId(id) && CSS_MODULE.test(id) && !TEXT_QUERY.test(id);
-}
-function isUnreadStylesheet(id) {
-  return isStylesheetId(id) && !isCssModuleId(id);
-}
-function canHoldDirective(code) {
-  return /@[n\\]/i.test(code);
-}
-function filePathOf(id) {
-  const query = id.indexOf("?");
-  return query === -1 ? id : id.slice(0, query);
-}
 var NAVE_MODULE_DIRS = ["src", "dist"].map(
   (name) => `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", name).replaceAll("\\", "/")}/`
 );
@@ -433,9 +408,6 @@ function isNaveOwn(id) {
   const file = pathOfId(id);
   return NAVE_MODULE_DIRS.some((directory) => file.startsWith(directory));
 }
-function isDependencyId(id) {
-  return pathOfId(id).includes("/node_modules/");
-}
 async function packageNameOf(file, cache) {
   const directory = path.dirname(file);
   const cached = cache.get(directory);
@@ -985,199 +957,6 @@ function recordWithoutCalls(context, ctx, module) {
   return void 0;
 }
 
-// src/vite-cx-text-test.ts
-function literalPattern(text) {
-  return text.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
-}
-var INSIDE = String.raw`[^\n'"\x60\\]{0,512}`;
-var EXTENSION = String.raw`\.[^\n'"\x60\\/?#.]*`;
-var QUOTE = String.raw`['"\x60]`;
-function textTestOf(names) {
-  if (names.size === 0) return void 0;
-  const listed = [...names].map((name) => literalPattern(name)).join("|");
-  const named = `${QUOTE}(?:${INSIDE}/)?(?:${listed})(?:${EXTENSION})?/*(?:[?#]${INSIDE})?${QUOTE}`;
-  const directory = String.raw`(?:\bfrom|\bimport)\s*(?:\(\s*)?${QUOTE}\.{1,2}(?:/\.{1,2})*/?${QUOTE}`;
-  return new RegExp(names.has("index") ? `${named}|${directory}` : named);
-}
-
-// src/vite-cx-modules.ts
-function isRelative(text) {
-  const cut = text.search(/[#?]/);
-  const path10 = cut === -1 ? text : text.slice(0, cut);
-  return path10 === "." || path10 === ".." || path10.startsWith("./") || path10.startsWith("../");
-}
-function fileOf(id) {
-  return filePathOf(id).replaceAll("\\", "/");
-}
-function namesOf(file) {
-  const name = path.basename(file, path.extname(file));
-  return name === "index" ? [name, path.basename(path.dirname(file))] : [name];
-}
-function entriesNaming(declared, id) {
-  const file = fileOf(id);
-  return declared.ids.entries().filter(([, resolved]) => fileOf(resolved) === file).map(([entry]) => entry).toArray();
-}
-async function declaredModulesFor(context, resolver, environment) {
-  const { cxModules } = context.options;
-  if (cxModules.length === 0) return void 0;
-  const known = context.state.declared.get(environment);
-  if (known) return known;
-  const made = resolveEntries(context, resolver);
-  context.state.declared.set(environment, made);
-  return made;
-}
-async function resolveOrNull(resolver, source, importer) {
-  try {
-    return await resolver.resolve?.(source, importer) ?? void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function resolveEntries(context, resolver) {
-  const from = path.join(context.root, "index.html");
-  const nave = await resolveOrNull(resolver, CX_SOURCE, from);
-  const naveFile = nave === void 0 ? void 0 : fileOf(nave.id);
-  const resolved = await Promise.all(
-    context.options.cxModules.map(async (entry) => {
-      const found = await resolveOrNull(resolver, entry, from);
-      return [entry, found?.id];
-    })
-  );
-  const kept = resolved.filter(
-    ([entry, id]) => entry !== CX_SOURCE && (id === void 0 || fileOf(id) !== naveFile)
-  );
-  const ids = new Map(kept.filter((pair) => pair[1] !== void 0));
-  const files = new Set(ids.values().map((id) => fileOf(id)));
-  const names = new Set(files.values().flatMap((file) => namesOf(file)));
-  return {
-    entries: new Set(kept.map(([entry]) => entry).filter((entry) => !isRelative(entry))),
-    ids,
-    files,
-    names,
-    textTest: textTestOf(names)
-  };
-}
-function forgetDeclared(state, environment) {
-  state.declared.delete(environment);
-  const prefix = `${environment}\0`;
-  for (const key of state.recognised.keys())
-    if (key.startsWith(prefix)) state.recognised.delete(key);
-}
-function withoutTrailingSlashes(text) {
-  let end = text.length;
-  while (end > 0 && text[end - 1] === "/") end -= 1;
-  return text.slice(0, end);
-}
-function lastSegmentOf(specifier) {
-  const cut = specifier.slice(1).search(/[#?]/);
-  const bare = withoutTrailingSlashes(cut === -1 ? specifier : specifier.slice(0, cut + 1));
-  const segment = bare.slice(bare.lastIndexOf("/") + 1);
-  return segment === "." || segment === ".." ? "index" : segment;
-}
-function isNamingListed(specifier, declared) {
-  const segment = lastSegmentOf(specifier);
-  if (declared.names.has(segment)) return true;
-  const extension = path.extname(segment);
-  return extension !== "" && declared.names.has(segment.slice(0, -extension.length));
-}
-function isAboutListed(input, declared) {
-  if (!declared) return false;
-  return isListedFile(declared, input.id) || isMentioningDeclared(input.code, declared);
-}
-function isListedFile(declared, id) {
-  return declared.files.has(fileOf(id));
-}
-function isMentioningDeclared(code, declared) {
-  for (const entry of declared.entries) if (code.includes(entry)) return true;
-  return declared.textTest?.test(code) ?? false;
-}
-function recognisedKey(environment, file, importer) {
-  return `${environment}\0${file}\0${importer}`;
-}
-function importerIdsOf(ctx, cxId) {
-  const info = ctx.getModuleInfo?.(cxId);
-  return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
-}
-async function isStoodInFor(context, id) {
-  if (!isDependencyId(id)) return false;
-  const pkg = await packageNameOf(filePathOf(id), context.packageNames);
-  return pkg !== void 0 && Object.hasOwn(context.options.keepFor, pkg);
-}
-async function candidateOf(ctx, context, id) {
-  const code = ctx.getModuleInfo?.(id)?.code;
-  if (code === null || code === void 0 || isNaveOwn(id)) return void 0;
-  return await isStoodInFor(context, id) ? void 0 : { id, code };
-}
-function specifiersIn(program) {
-  const found = /* @__PURE__ */ new Map();
-  const stack = [program];
-  while (stack.length > 0) {
-    const node = stack.pop();
-    const where = nodeAt(node, "source");
-    const source = staticStringOf(where);
-    if (where !== void 0 && source !== void 0) {
-      found.set(source, Math.min(found.get(source) ?? Infinity, where.start));
-    }
-    pushAll(stack, childrenOf(node));
-  }
-  return [...found].toSorted(([, a], [, b]) => a - b).map(([source]) => source);
-}
-function specifiersOf(ctx, importer) {
-  try {
-    return specifiersIn(ctx.parse?.(importer.code));
-  } catch {
-    return void 0;
-  }
-}
-async function isResolvingToCx(ctx, specifier, importer, known) {
-  if (specifier === CX_SOURCE) return false;
-  const key = `${importer.id}\0${specifier}`;
-  const answered = known.answers.get(key);
-  if (answered !== void 0) return answered;
-  const resolved = await ctx.resolve?.(specifier, importer.id);
-  const isCx = resolved?.id === known.cxId;
-  known.answers.set(key, isCx);
-  return isCx;
-}
-function lineFor(label, specifiers) {
-  if (specifiers.length === 0) {
-    return `${label}: imports cx through a specifier the build does not read.`;
-  }
-  return `${label}: imports cx from ${specifiers.map((specifier) => `'${specifier}'`).join(", ")}.`;
-}
-async function lineOf(ctx, context, importer, known) {
-  const written = specifiersOf(ctx, importer);
-  const unread = [];
-  const specifiers = written ?? [];
-  for (const specifier of specifiers) {
-    if (await isResolvingToCx(ctx, specifier, importer, known)) unread.push(specifier);
-  }
-  const label = moduleLabel(context.root, importer.id);
-  if (unread.length > 0) return lineFor(label, unread);
-  const isRead = written?.includes(CX_SOURCE) ?? importer.code.includes(CX_SOURCE);
-  return isRead ? void 0 : lineFor(label, []);
-}
-async function checkCxImporters(ctx, context) {
-  const resolved = await ctx.resolve?.(CX_SOURCE, path.join(context.root, "index.html"));
-  if (!resolved) return;
-  const known = { cxId: resolved.id, answers: /* @__PURE__ */ new Map() };
-  const lines = [];
-  for (const id of importerIdsOf(ctx, resolved.id)) {
-    const importer = await candidateOf(ctx, context, id);
-    const line = importer && await lineOf(ctx, context, importer, known);
-    if (line) lines.push(line);
-  }
-  if (lines.length === 0) return;
-  const count = lines.length === 1 ? "1 module imports" : `${lines.length} modules import`;
-  ctx.error(
-    [
-      `${count} cx through a specifier the build does not follow, so the atoms its calls name would not ship:`,
-      ...lines.toSorted(compareText),
-      "Import cx from '@navecss/core/cx' directly where it is called."
-    ].join("\n")
-  );
-}
-
 // src/vite-cx-reading.ts
 async function declaredReadingOf(context, resolver, declared, input) {
   const { environment, module } = input;
@@ -1543,6 +1322,68 @@ function failDevModule(ctx, context, input) {
   const problems = problemsOf(record, context);
   if (problems.length > 0) failModule(ctx, context, { home, id, problems });
 }
+function importerIdsOf(ctx, cxId) {
+  const info = ctx.getModuleInfo?.(cxId);
+  return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
+}
+async function isStoodInFor(context, id) {
+  if (!isDependencyId(id)) return false;
+  const pkg = await packageNameOf(filePathOf(id), context.packageNames);
+  return pkg !== void 0 && Object.hasOwn(context.options.keepFor, pkg);
+}
+async function candidateOf(ctx, context, id) {
+  const code = ctx.getModuleInfo?.(id)?.code;
+  if (code === null || code === void 0 || isNaveOwn(id)) return void 0;
+  return await isStoodInFor(context, id) ? void 0 : { id, code };
+}
+async function isResolvingToCx(ctx, specifier, importer, known) {
+  if (specifier === CX_SOURCE) return false;
+  const key = `${importer.id}\0${specifier}`;
+  const answered = known.answers.get(key);
+  if (answered !== void 0) return answered;
+  const resolved = await ctx.resolve?.(specifier, importer.id);
+  const isCx = resolved?.id === known.cxId;
+  known.answers.set(key, isCx);
+  return isCx;
+}
+function lineFor(label, specifiers) {
+  if (specifiers.length === 0) {
+    return `${label}: imports cx through a specifier the build does not read.`;
+  }
+  return `${label}: imports cx from ${specifiers.map((specifier) => `'${specifier}'`).join(", ")}.`;
+}
+async function lineOf(ctx, context, importer, known) {
+  const written = specifiersOf(ctx, importer);
+  const unread = [];
+  const specifiers = written ?? [];
+  for (const specifier of specifiers) {
+    if (await isResolvingToCx(ctx, specifier, importer, known)) unread.push(specifier);
+  }
+  const label = moduleLabel(context.root, importer.id);
+  if (unread.length > 0) return lineFor(label, unread);
+  const isRead = written?.includes(CX_SOURCE) ?? importer.code.includes(CX_SOURCE);
+  return isRead ? void 0 : lineFor(label, []);
+}
+async function checkCxImporters(ctx, context) {
+  const resolved = await ctx.resolve?.(CX_SOURCE, path.join(context.root, "index.html"));
+  if (!resolved) return;
+  const known = { cxId: resolved.id, answers: /* @__PURE__ */ new Map() };
+  const lines = [];
+  for (const id of importerIdsOf(ctx, resolved.id)) {
+    const importer = await candidateOf(ctx, context, id);
+    const line = importer && await lineOf(ctx, context, importer, known);
+    if (line) lines.push(line);
+  }
+  if (lines.length === 0) return;
+  const count = lines.length === 1 ? "1 module imports" : `${lines.length} modules import`;
+  ctx.error(
+    [
+      `${count} cx through a specifier the build does not follow, so the atoms its calls name would not ship:`,
+      ...lines.toSorted(compareText),
+      "Import cx from '@navecss/core/cx' directly where it is called."
+    ].join("\n")
+  );
+}
 
 // src/vite-cx-module-lines.ts
 function quoted(specifiers) {
@@ -1629,79 +1470,6 @@ function importerErrorOf(found, input) {
     )
   ].join("\n");
 }
-async function isResolvingTo(ctx, input) {
-  try {
-    const resolved = await ctx.resolve?.(input.specifier, input.from);
-    return resolved !== null && resolved !== void 0 && fileOf(resolved.id) === input.file;
-  } catch {
-    return false;
-  }
-}
-function importersOf(ctx, id) {
-  const info = ctx.getModuleInfo?.(id);
-  return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
-}
-async function specifiersWritten(ctx, input) {
-  const { file, importer } = input;
-  const code = ctx.getModuleInfo?.(importer)?.code;
-  if (code === null || code === void 0) return [];
-  const written = specifiersOf(ctx, { id: importer, code }) ?? [];
-  const found = [];
-  for (const specifier of written) {
-    if (await isResolvingTo(ctx, { file, from: importer, specifier })) found.push(specifier);
-  }
-  return found;
-}
-async function specifiersInto(ctx, context, input) {
-  const found = /* @__PURE__ */ new Set();
-  for (const importer of importersOf(ctx, input.id)) {
-    const owner = isDependencyId(importer) ? await packageNameOf(filePathOf(importer), context.packageNames) : void 0;
-    if (owner === input.pkg) continue;
-    const written = await specifiersWritten(ctx, { file: fileOf(input.id), importer });
-    for (const specifier of written) found.add(specifier);
-  }
-  return found.values().toArray().toSorted(compareText);
-}
-async function clearingSpecifier(ctx, context, input) {
-  const from = path.join(context.root, "index.html");
-  const file = fileOf(input.id);
-  if (await isResolvingTo(ctx, { file, from, specifier: input.pkg })) return input.pkg;
-  const specifiers = await specifiersInto(ctx, context, input);
-  for (const specifier of specifiers) {
-    if (await isResolvingTo(ctx, { file, from, specifier })) return specifier;
-  }
-  return void 0;
-}
-async function withClearingSpecifiers(ctx, context, problems) {
-  const asked = /* @__PURE__ */ new Map();
-  const clearing = (pkg, id) => {
-    const known = asked.get(id);
-    if (known) return known;
-    const answer = clearingSpecifier(ctx, context, { id, pkg });
-    asked.set(id, answer);
-    return answer;
-  };
-  const entriesOf = async (id) => {
-    const declared = await declaredModulesFor(context, ctx, ctx.environment.name);
-    return declared ? entriesNaming(declared, id) : [];
-  };
-  const renamed = new Set(
-    problems.flatMap(
-      (problem) => problem.isRenamed === true && problem.moduleId !== void 0 ? [problem.moduleId] : []
-    )
-  );
-  return await Promise.all(
-    problems.map(async (problem) => {
-      const { moduleId, pkg } = problem;
-      if (pkg === void 0 || moduleId === void 0) return problem;
-      if (problem.kind === "declared") return { ...problem, entries: await entriesOf(moduleId) };
-      if (!isListableReexport(problem)) return problem;
-      if (renamed.has(moduleId)) return { ...problem, isRenamed: true };
-      const specifier = await clearing(pkg, moduleId);
-      return specifier === void 0 ? problem : { ...problem, specifier };
-    })
-  );
-}
 
 // src/vite-cx-module-importers.ts
 var RESOLVED_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -1790,28 +1558,6 @@ async function declaredImporterError(ctx, context, input) {
   return found.length === 0 ? void 0 : importerErrorOf(found, input);
 }
 
-// src/vite-declared-echoes.ts
-var ECHO_KINDS = /* @__PURE__ */ new Set([
-  "argument",
-  "dynamic",
-  "own",
-  "reference",
-  "unknown"
-]);
-function withoutEchoes(modules) {
-  const broken = new Set(
-    modules.flatMap(
-      (module) => module.problems.flatMap(
-        (problem) => problem.kind === "declared" && problem.moduleId !== void 0 && !problem.hasNaveCx ? [fileOf(problem.moduleId)] : []
-      )
-    )
-  );
-  const isEcho = (module) => module.onlyVia !== void 0 && [...module.onlyVia].every((file) => broken.has(file));
-  return modules.flatMap(
-    (module) => isEcho(module) ? module.problems.filter((problem) => !ECHO_KINDS.has(problem.kind)) : module.problems
-  );
-}
-
 // src/vite-markup.ts
 var MARKUP_WARNING = `navePlugin(): Nave read no HTML page and no server render, so your pages are likely rendered where it cannot see them, such as in a backend's own templates. A Nave class written there has no rule, in dev or in the build, unless its atom is listed in keep; if most of your Nave classes are written there, set atomic: 'all' to ship every atom. See "Which atoms the build ships" in node_modules/@navecss/core/README.md.`;
 function isMarkupCase(context) {
@@ -1883,6 +1629,26 @@ function graphRoots(environment) {
     (module) => module.importers.size === 0 && (module.id === null || !isStylesheetId(module.id))
   ).toArray();
 }
+var started = /* @__PURE__ */ new WeakMap();
+function noteStartedRequests(environment) {
+  if (started.has(environment)) return;
+  const open = /* @__PURE__ */ new Set();
+  started.set(environment, open);
+  const warmup = environment.warmupRequest.bind(environment);
+  environment.warmupRequest = async (url) => {
+    const request = warmup(url);
+    open.add(request);
+    try {
+      await request;
+    } finally {
+      open.delete(request);
+    }
+  };
+}
+async function waitForStartedRequests(environment) {
+  const open = started.get(environment);
+  if (open) await Promise.allSettled(open);
+}
 async function transformQuietly(environment, url) {
   try {
     await environment.transformRequest(url);
@@ -1965,8 +1731,9 @@ async function modulesWithGrownStylesheets(context, ctx, hot) {
 var RELOAD_ANSWER_MS = 2e3;
 var NO_MAP = JSON.stringify({ mappings: "" });
 var DIRECT = /[?&]direct\b/;
+var HTML_PROXY = /[?&]html-proxy\b/;
 function isInlinedInHtml(module) {
-  return module.id !== null && /[?&]html-proxy\b/.test(module.id);
+  return module.id !== null && HTML_PROXY.test(module.id);
 }
 async function reloadQuietly(environment, module) {
   try {
@@ -2011,10 +1778,12 @@ var devServing = {
   async hold(environment, id) {
     const module = environment.moduleGraph.getModuleById(id);
     if (!module) return;
-    if (module.importers.size === 0 && DIRECT.test(id)) return;
+    if (module.importers.size === 0 && DIRECT.test(id) && !HTML_PROXY.test(id)) return;
+    if (HTML_PROXY.test(id)) await devServing.startedRequests(environment);
     await environment.waitForRequestsIdle(id);
     await transformReachable(environment, graphRoots(environment));
   },
+  startedRequests: waitForStartedRequests,
   notePages(context) {
     const { state } = context;
     const atoms = servedAtoms(state, context.kept);
@@ -2062,581 +1831,6 @@ async function serveStylesheet(context, ctx, stylesheet) {
   return { code: pruneAtomicLayer(css, atoms), map: NO_MAP };
 }
 
-// src/vite-cx-reexported.ts
-function declaredNames(pattern) {
-  const found = [];
-  const stack = pattern ? [pattern] : [];
-  while (stack.length > 0) {
-    const node = stack.pop();
-    if (node.type === "Identifier") {
-      found.push(stringAt(node, "name") ?? "");
-    } else if (node.type === "AssignmentPattern") {
-      pushAll(
-        stack,
-        [nodeAt(node, "left")].filter((part) => part !== void 0)
-      );
-    } else {
-      const single = ["argument", "value"].map((key) => nodeAt(node, key));
-      const lists = ["properties", "elements"].flatMap((key) => nodesAt(node, key));
-      pushAll(
-        stack,
-        single.filter((part) => part !== void 0)
-      );
-      pushAll(stack, lists);
-    }
-  }
-  return found;
-}
-function ownExports(program) {
-  const found = /* @__PURE__ */ new Set();
-  for (const statement of nodesAt(program, "body")) {
-    const namespace = statement.type === "ExportAllDeclaration" ? exportNameOf(nodeAt(statement, "exported")) : void 0;
-    if (namespace !== void 0) found.add(namespace);
-    if (statement.type !== "ExportNamedDeclaration") continue;
-    const declaration = nodeAt(statement, "declaration");
-    const declared = nodesAt(declaration ?? statement, "declarations").flatMap(
-      (declarator) => declaredNames(nodeAt(declarator, "id"))
-    );
-    for (const name of [...declared, ...declaredNames(declaration && nodeAt(declaration, "id"))]) {
-      found.add(name);
-    }
-    for (const specifier of nodesAt(statement, "specifiers")) {
-      const name = exportNameOf(nodeAt(specifier, "exported"));
-      if (name !== void 0) found.add(name);
-    }
-  }
-  return found;
-}
-function exportedBy(node, source, own) {
-  const from = staticStringOf(nodeAt(node, "source"));
-  if (from === void 0 || !source.reaches.has(from)) return [];
-  if (node.type === "ExportAllDeclaration") {
-    const namespace = exportNameOf(nodeAt(node, "exported"));
-    if (namespace !== void 0) return [namespace];
-    return source.names.values().filter((name) => name !== "default" && !own.has(name) && !source.rivals.has(name)).toArray();
-  }
-  return nodesAt(node, "specifiers").flatMap((specifier) => {
-    const local = exportNameOf(nodeAt(specifier, "local"));
-    const exported = exportNameOf(nodeAt(specifier, "exported"));
-    return local !== void 0 && exported !== void 0 && source.names.has(local) ? [exported] : [];
-  });
-}
-function isImportedFrom(binding, source) {
-  if (binding?.kind !== "import" || binding.source === void 0) return false;
-  if (!source.reaches.has(binding.source)) return false;
-  return binding.imported === "*" || source.names.has(binding.imported ?? "");
-}
-function exportedAs(analysis, reference) {
-  const parent = analysis.parentOf.get(reference.node);
-  if (parent?.type === "ExportDefaultDeclaration") return "default";
-  return parent?.type === "ExportSpecifier" ? exportNameOf(nodeAt(parent, "exported")) : void 0;
-}
-function starSources(program) {
-  return nodesAt(program, "body").flatMap((statement) => {
-    const source = staticStringOf(nodeAt(statement, "source"));
-    const isStar = statement.type === "ExportAllDeclaration" && !nodeAt(statement, "exported");
-    return isStar && source !== void 0 ? [source] : [];
-  });
-}
-function reexportedNames(program, source) {
-  const found = /* @__PURE__ */ new Set();
-  const own = ownExports(program);
-  const stack = [program];
-  while (stack.length > 0) {
-    const node = stack.pop();
-    if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
-      for (const name of exportedBy(node, source, own)) found.add(name);
-    }
-    pushAll(stack, childrenOf(node));
-  }
-  const analysis = analyze(program);
-  for (const reference of analysis.references) {
-    const name = isImportedFrom(reference.binding, source) ? exportedAs(analysis, reference) : void 0;
-    if (name !== void 0) found.add(name);
-  }
-  return [...found];
-}
-
-// src/vite-cx-star-exports.ts
-function resolvedFile(ctx, resolutions, input) {
-  const key = `${input.id}\0${input.specifier}`;
-  const known = resolutions.get(key);
-  if (known) return known;
-  const asked = (async () => {
-    try {
-      const resolved = await ctx.resolve?.(input.specifier, input.id);
-      return resolved ? fileOf(resolved.id) : void 0;
-    } catch {
-      return void 0;
-    }
-  })();
-  resolutions.set(key, asked);
-  return asked;
-}
-function ownNamesOf(program, file, cxExports) {
-  const found = { names: ownExports(program), cx: /* @__PURE__ */ new Set() };
-  for (const name of found.names) {
-    if (cxExports.get(file)?.has(name)) found.cx.add(name);
-  }
-  return found;
-}
-function unreadProgram(ctx, input) {
-  const { file, seen } = input;
-  const code = ctx.getModuleInfo?.(file)?.code;
-  const isUnread = !seen.has(file) && typeof code === "string";
-  seen.add(file);
-  return isUnread ? ctx.parse?.(code) : void 0;
-}
-async function addStars(ctx, input) {
-  const { found, file, program, walk } = input;
-  for (const specifier of starSources(program)) {
-    const star = await resolvedFile(ctx, walk.resolutions, { id: file, specifier });
-    const below = star ? await exportsOf(ctx, { file: star, walk }) : void 0;
-    const names = below ? [...below.names] : [];
-    for (const name of names) {
-      found.names.add(name);
-      if (below?.cx.has(name)) found.cx.add(name);
-    }
-  }
-}
-async function exportsOf(ctx, input) {
-  const { file, walk } = input;
-  const program = unreadProgram(ctx, { file, seen: walk.seen });
-  if (!program) return { names: /* @__PURE__ */ new Set(), cx: /* @__PURE__ */ new Set() };
-  const found = ownNamesOf(program, file, walk.cxExports);
-  await addStars(ctx, { found, file, program, walk });
-  return found;
-}
-async function rivalsOf(ctx, input) {
-  const { cxExports, id, program, reaches, resolutions } = input;
-  const rivals = /* @__PURE__ */ new Set();
-  const others = starSources(program).filter((text) => !reaches.has(text));
-  for (const specifier of others) {
-    const file = await resolvedFile(ctx, resolutions, { id, specifier });
-    const walk = { cxExports, resolutions, seen: /* @__PURE__ */ new Set() };
-    const exported = file ? await exportsOf(ctx, { file, walk }) : void 0;
-    const names = exported ? [...exported.names] : [];
-    const own = names.filter((text) => !exported?.cx.has(text));
-    for (const name of own) rivals.add(name);
-  }
-  return rivals;
-}
-
-// src/vite-listed-holders.ts
-async function reachingSpecifiers(ctx, input) {
-  const { code, file, id, resolutions } = input;
-  const program = ctx.parse?.(code);
-  if (!program) return void 0;
-  const reaches = /* @__PURE__ */ new Set();
-  for (const specifier of specifiersIn(program)) {
-    if (await resolvedFile(ctx, resolutions, { id, specifier }) === file) reaches.add(specifier);
-  }
-  return { program, reaches };
-}
-async function reexportedBy(ctx, input) {
-  const code = ctx.getModuleInfo?.(input.id)?.code;
-  if (code === null || code === void 0) return [];
-  try {
-    const read = await reachingSpecifiers(ctx, { ...input, code });
-    if (!read || read.reaches.size === 0) return [];
-    const { program, reaches } = read;
-    const rivals = await rivalsOf(ctx, { ...input, program, reaches });
-    return reexportedNames(program, { names: input.names, reaches, rivals });
-  } catch {
-    return [];
-  }
-}
-async function reexportsOf(ctx, input) {
-  const importers = importersOf(ctx, input.id).filter((importer) => isDependencyId(importer));
-  const found = /* @__PURE__ */ new Map();
-  for (const importer of importers) {
-    const added = await reexportedBy(ctx, { ...input, file: fileOf(input.id), id: importer });
-    if (added.length > 0) found.set(importer, added);
-  }
-  return found;
-}
-async function holdersOf(ctx, origin) {
-  const held = /* @__PURE__ */ new Map([[origin.id, origin.names]]);
-  const queue = [origin.id];
-  while (queue.length > 0) {
-    const id = queue.shift();
-    const reexports = await reexportsOf(ctx, {
-      cxExports: origin.cxExports,
-      id,
-      names: held.get(id),
-      resolutions: origin.resolutions
-    });
-    for (const [importer, added] of reexports) {
-      const known = held.get(importer) ?? /* @__PURE__ */ new Set();
-      const isNew = importer !== origin.id && added.some((name) => !known.has(name));
-      if (isNew) {
-        held.set(importer, /* @__PURE__ */ new Set([...known, ...added]));
-        queue.push(importer);
-      }
-    }
-  }
-  return held.entries().map(([id, names]) => ({ id, names, isReached: id !== origin.id })).toArray();
-}
-
-// src/vite-cx-take-keys.ts
-function isCxName(names, name) {
-  return names === void 0 || names.has(name);
-}
-function patternKeys(pattern, names) {
-  const taken = [];
-  for (const property of nodesAt(pattern, "properties")) {
-    const key = property.type === "Property" ? propertyNameOf(nodeAt(property, "key"), property.computed === true) : void 0;
-    if (key === void 0) return void 0;
-    if (isCxName(names, key)) taken.push(key);
-  }
-  return taken;
-}
-function referenceTakes(analysis, node, names) {
-  const read = memberReadOf({ analysis }, node);
-  if (read) {
-    if (read.key === void 0) return void 0;
-    return isCxName(names, read.key) ? [read.key] : [];
-  }
-  const pattern = patternDestructuring({ analysis }, node);
-  return pattern?.type === "ObjectPattern" ? patternKeys(pattern, names) : void 0;
-}
-function outermost(analysis, node) {
-  let current = node;
-  let parent = analysis.parentOf.get(current);
-  while (parent?.type === "ParenthesizedExpression") {
-    current = parent;
-    parent = analysis.parentOf.get(current);
-  }
-  return current;
-}
-function thenCall(analysis, node) {
-  const member = analysis.parentOf.get(node);
-  if (member?.type !== "MemberExpression" || nodeAt(member, "object") !== node) return void 0;
-  const key = propertyNameOf(nodeAt(member, "property"), member.computed === true);
-  const call = analysis.parentOf.get(member);
-  return key === "then" && call?.type === "CallExpression" && nodeAt(call, "callee") === member ? call : void 0;
-}
-function thenCallback(analysis, node) {
-  const call = thenCall(analysis, node);
-  const callback = call && nodesAt(call, "arguments")[0];
-  const isInline = callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression";
-  return isInline ? callback : void 0;
-}
-function referencesToParameter(analysis, owner, name) {
-  return analysis.references.filter(
-    ({ binding }) => binding?.kind === "param" && binding.owner === owner && binding.name === name
-  );
-}
-function parameterTakes(analysis, callback, names) {
-  const parameter = nodesAt(callback, "params")[0];
-  if (parameter === void 0) return [];
-  if (parameter.type === "ObjectPattern") return patternKeys(parameter, names);
-  const name = parameter.type === "Identifier" ? stringAt(parameter, "name") : void 0;
-  if (name === void 0) return void 0;
-  const found = [];
-  for (const { binding, node } of referencesToParameter(analysis, callback, name)) {
-    const taken = binding?.writes === 0 ? referenceTakes(analysis, node, names) : void 0;
-    if (taken === void 0) return void 0;
-    pushAll(found, taken);
-  }
-  return found;
-}
-function variableTakes(analysis, init, names) {
-  const declarator = analysis.parentOf.get(init);
-  const declaration = declarator && analysis.parentOf.get(declarator);
-  if (declaration && analysis.parentOf.get(declaration)?.type === "ExportNamedDeclaration") {
-    return void 0;
-  }
-  const found = [];
-  for (const { binding, node } of analysis.references) {
-    if (binding?.init !== init) continue;
-    const taken = binding.writes === 0 ? referenceTakes(analysis, node, names) : void 0;
-    if (taken === void 0) return void 0;
-    pushAll(found, taken);
-  }
-  return found;
-}
-function awaitedKeys(analysis, awaited, names) {
-  const declarator = analysis.parentOf.get(awaited);
-  const isVariable = declarator?.type === "VariableDeclarator" && nodeAt(declarator, "init") === awaited && nodeAt(declarator, "id")?.type === "Identifier";
-  return isVariable ? variableTakes(analysis, awaited, names) : referenceTakes(analysis, awaited, names);
-}
-function dynamicKeys(analysis, node, names) {
-  const awaited = analysis.parentOf.get(node);
-  if (awaited?.type === "AwaitExpression") {
-    return awaitedKeys(analysis, outermost(analysis, awaited), names);
-  }
-  const callback = thenCallback(analysis, node);
-  return callback && parameterTakes(analysis, callback, names);
-}
-
-// src/vite-cx-takes.ts
-var UNREADABLE = { shape: "unreadable", names: [] };
-function namespaceTakes(analysis, references, names) {
-  const found = /* @__PURE__ */ new Set();
-  for (const reference of references) {
-    const taken = referenceTakes(analysis, reference.node, names);
-    if (taken === void 0) return { shape: "namespace", names: [] };
-    for (const name of taken) found.add(name);
-  }
-  return found.size === 0 ? void 0 : { shape: "namespace", names: [...found] };
-}
-function referencesTo(analysis, source, specifier) {
-  const local = exportNameOf(nodeAt(specifier, "local"));
-  return analysis.references.filter(({ binding }) => {
-    return binding?.kind === "import" && binding.imported === "*" && binding.source === source && binding.name === local;
-  });
-}
-function usesOf(analysis, source, specifier) {
-  const local = exportNameOf(nodeAt(specifier, "local"));
-  return analysis.references.filter(
-    ({ binding }) => binding?.kind === "import" && binding.source === source && binding.name === local
-  );
-}
-function isExportOf(analysis, reference) {
-  const parent = analysis.parentOf.get(reference.node);
-  return parent?.type === "ExportSpecifier" || parent?.type === "ExportDefaultDeclaration";
-}
-function passingOf(analysis, source, specifier) {
-  const uses = usesOf(analysis, source, specifier);
-  const exported = uses.filter((use) => isExportOf(analysis, use));
-  if (exported.length === 0) return {};
-  return exported.length === uses.length ? { isForward: true, isPassedOn: true } : { isPassedOn: true };
-}
-function importTakes(node, source, scan) {
-  const found = [];
-  for (const specifier of nodesAt(node, "specifiers")) {
-    if (specifier.type === "ImportNamespaceSpecifier") {
-      const references = referencesTo(scan.analysis(), source, specifier);
-      const taken = namespaceTakes(scan.analysis(), references, scan.names);
-      const isForward = passingOf(scan.analysis(), source, specifier).isForward;
-      if (taken) found.push({ ...taken, ...isForward && { isForward } });
-      continue;
-    }
-    const imported = specifier.type === "ImportDefaultSpecifier" ? "default" : exportNameOf(nodeAt(specifier, "imported"));
-    if (imported !== void 0 && isCxName(scan.names, imported)) {
-      const passing = passingOf(scan.analysis(), source, specifier);
-      found.push({ shape: "names", names: [imported], ...passing });
-    }
-  }
-  return found;
-}
-function exportTakes(node, scan) {
-  if (node.type === "ExportAllDeclaration") {
-    if (nodeAt(node, "exported") !== void 0) {
-      return [{ shape: "namespace", names: [], isForward: true }];
-    }
-    const hasNamed = scan.names === void 0 || scan.names.keys().some((name) => name !== "default");
-    return hasNamed ? [{ shape: "star", names: [], isForward: true }] : [];
-  }
-  const re = nodesAt(node, "specifiers").map((specifier) => exportNameOf(nodeAt(specifier, "local"))).filter((name) => name !== void 0 && isCxName(scan.names, name));
-  return re.length === 0 ? [] : [{ shape: "names", names: re, isPassedOn: true, isForward: true }];
-}
-function dynamicTakes(node, scan) {
-  const keys = dynamicKeys(scan.analysis(), node, scan.names);
-  if (keys === void 0) return [{ shape: "dynamic-import", names: [] }];
-  return keys.length === 0 ? [] : [{ shape: "dynamic-import", names: keys }];
-}
-function takesOf(node, scan) {
-  const source = staticStringOf(nodeAt(node, "source"));
-  if (source === void 0 || !scan.reaches.has(source)) return [];
-  if (node.type === "ImportDeclaration") return importTakes(node, source, scan);
-  if (node.type === "ImportExpression") return dynamicTakes(node, scan);
-  return exportTakes(node, scan);
-}
-function takesIn(program, input) {
-  let analysis;
-  const scan = {
-    ...input,
-    analysis: () => analysis ??= analyze(program)
-  };
-  const found = [];
-  const stack = [program];
-  while (stack.length > 0) {
-    const node = stack.pop();
-    pushAll(found, takesOf(node, scan));
-    pushAll(stack, childrenOf(node));
-  }
-  return found;
-}
-
-// src/vite-listed-routes.ts
-async function takenBy(ctx, input) {
-  const { file, id, names, resolutions } = input;
-  const code = ctx.getModuleInfo?.(id)?.code;
-  try {
-    const read = code === null || code === void 0 ? void 0 : await reachingSpecifiers(ctx, { code, file, id, resolutions });
-    if (!read || read.reaches.size === 0) return [UNREADABLE];
-    return takesIn(read.program, { names, reaches: read.reaches });
-  } catch {
-    return [UNREADABLE];
-  }
-}
-function merged2(takes) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const take of takes) {
-    const key = `${take.taker}\0${take.shape}`;
-    const known = byKey.get(key);
-    const names = /* @__PURE__ */ new Set([...known?.names ?? [], ...take.names]);
-    const isReached = take.isReached || known?.isReached === true;
-    const isPassedOn = take.isPassedOn === true || known?.isPassedOn === true;
-    byKey.set(key, { ...take, isPassedOn, isReached, names: [...names].toSorted(compareText) });
-  }
-  return byKey.values().toArray();
-}
-async function isCounted(context, input) {
-  const { importer, isEntry, pkg, wantCalls } = input;
-  if (wantCalls || !isDependencyId(importer)) return true;
-  if (!isEntry) return false;
-  return await packageNameOf(filePathOf(importer), context.packageNames) !== pkg;
-}
-async function routesOf(ctx, context, input) {
-  const { holder, importer, isEntry, resolutions, wantCalls } = input;
-  const isDependency = isDependencyId(importer);
-  const taker = moduleLabel(context.root, importer);
-  const taken = await takenBy(ctx, {
-    file: fileOf(holder.id),
-    id: importer,
-    names: holder.names,
-    resolutions
-  });
-  const takes = taken.map((take) => ({ ...take, taker, isReached: holder.isReached }));
-  if (isDependency) {
-    const calls = takes.filter((take) => take.isForward !== true);
-    return { entry: isEntry ? calls : [], told: [], calls: wantCalls ? calls : [] };
-  }
-  const isCleared = (take) => isEntry && take.shape !== "unreadable";
-  return {
-    entry: takes.filter((take) => isCleared(take)),
-    told: takes.filter((take) => !isCleared(take)),
-    calls: []
-  };
-}
-function serverTakesOf(found, holder) {
-  const takes = [];
-  for (const taken of found.takes) {
-    const names = taken.names.filter((name) => holder.names.has(name));
-    const isWhole = taken.names.length === 0;
-    const hasNamed = holder.names.keys().some((name) => name !== "default");
-    const isTaken = taken.shape === "star" ? hasNamed : isWhole || names.length > 0;
-    if (isTaken) {
-      const kept = isWhole ? taken.names : names;
-      takes.push({
-        ...taken,
-        names: kept,
-        taker: found.taker,
-        isReached: holder.isReached,
-        ...found.isRecorded === true && { isRecorded: true }
-      });
-    }
-  }
-  return takes;
-}
-async function takesFrom(ctx, context, input) {
-  const { holder, isEntry, pkg, resolutions, wantCalls } = input;
-  const importers = importersOf(ctx, holder.id);
-  const entry = [];
-  const told = [];
-  const calls = [];
-  for (const importer of importers) {
-    if (!await isCounted(context, { importer, isEntry, pkg, wantCalls })) {
-      continue;
-    }
-    const routes = await routesOf(ctx, context, {
-      holder,
-      importer,
-      isEntry,
-      resolutions,
-      wantCalls
-    });
-    pushAll(entry, routes.entry);
-    pushAll(told, routes.told);
-    pushAll(calls, routes.calls);
-  }
-  return { entry: merged2(entry), told: merged2(told), calls: merged2(calls) };
-}
-function serverRoutes(holder, input) {
-  const file = fileOf(holder.id);
-  const fromServer = input.serverImports.filter((one) => one.file === file);
-  const takes = fromServer.flatMap((found) => serverTakesOf(found, holder));
-  const isCleared = (take) => input.isEntry && take.shape !== "unreadable";
-  return {
-    entry: takes.filter((take) => isCleared(take)),
-    told: takes.filter((take) => !isCleared(take))
-  };
-}
-
-// src/vite-listed-takes.ts
-async function prepareOne(ctx, context, input) {
-  const { isHop, problems, walk } = input;
-  const first = problems[0];
-  const pkg = first.pkg;
-  const names = new Set(problems.flatMap((problem) => problem.exportedAs ?? []));
-  const hasEntry = !isHop && problems.some((problem) => problem.specifier !== void 0);
-  const holders = await holdersOf(ctx, { ...walk, id: first.moduleId, names });
-  const routed = await Promise.all(
-    holders.map(
-      (holder) => takesFrom(ctx, context, {
-        holder,
-        isEntry: hasEntry && !holder.isReached,
-        pkg,
-        resolutions: walk.resolutions,
-        wantCalls: isHop
-      })
-    )
-  );
-  const isListed2 = Object.hasOwn(context.options.keepFor, pkg);
-  return { hasEntry, holders, isHop, isListed: isListed2, problems, routed };
-}
-function decideOne(prepared, serverImports) {
-  const { hasEntry, holders, isHop, isListed: isListed2, problems, routed } = prepared;
-  const fromServer = holders.map(
-    (holder) => serverRoutes(holder, { isEntry: hasEntry && !holder.isReached, serverImports })
-  );
-  const entry = [...routed.flatMap((route) => route.entry), ...fromServer.flatMap((r) => r.entry)];
-  if (entry.length > 0) return problems.filter((problem) => problem.specifier !== void 0);
-  const told = merged2([
-    ...routed.flatMap((route) => route.told),
-    ...fromServer.flatMap((route) => route.told)
-  ]);
-  const callers = isHop && !isListed2 ? callersOf(routed) : [];
-  if (told.length === 0 && callers.length === 0) return [];
-  return problems.map((problem) => ({
-    ...problem,
-    ...told.length > 0 && { takes: told },
-    ...callers.length > 0 && { callers }
-  }));
-}
-function callersOf(routed) {
-  const callers = new Set(routed.flatMap((route) => route.calls.map((call) => call.taker)));
-  return [...callers].toSorted(compareText);
-}
-async function prepareReexports(ctx, context, standingIn) {
-  const exporting = standingIn.filter((problem) => problem.exportedAs !== void 0);
-  const located = await withClearingSpecifiers(ctx, context, exporting);
-  const byModule = /* @__PURE__ */ new Map();
-  const hops = /* @__PURE__ */ new Map();
-  for (const problem of located) {
-    if (problem.moduleId === void 0 || problem.pkg === void 0) continue;
-    const group = isSecondHop(problem) ? hops : byModule;
-    group.set(problem.moduleId, [...group.get(problem.moduleId) ?? [], problem]);
-  }
-  const cxExports = new Map(
-    [...byModule.values(), ...hops.values()].map((problems) => [
-      fileOf(problems[0].moduleId),
-      new Set(problems.flatMap((problem) => problem.exportedAs ?? []))
-    ])
-  );
-  const walk = { cxExports, resolutions: /* @__PURE__ */ new Map() };
-  return await Promise.all([
-    ...byModule.values().map((problems) => prepareOne(ctx, context, { isHop: false, problems, walk })),
-    ...hops.values().map((problems) => prepareOne(ctx, context, { isHop: true, problems, walk }))
-  ]);
-}
-function decideReexports(prepared, serverImports) {
-  return prepared.flatMap((one) => decideOne(one, serverImports));
-}
-
 // src/vite-order.ts
 var MISSING = "which the CSS already written does not hold.";
 function packageOfPath(file) {
@@ -2963,28 +2157,28 @@ var OPTIONS_HOME = "navePlugin()";
 function isReadable(context, id) {
   return isUsed(context) && !isUnreadStylesheet(id) && !isNaveOwn(id);
 }
+function takesContextOf(context) {
+  return {
+    root: context.root,
+    rootName: "Vite's root",
+    options: context.options,
+    state: context.state,
+    packageOf: (id) => packageNameOf(filePathOf(id), context.packageNames),
+    labelOf: (id) => moduleLabel(context.root, id)
+  };
+}
 async function problemsOfBuild(ctx, context, serverImports) {
   const records = recordsOf(context.state, ctx.environment.name);
-  const kept = await withClearingSpecifiers(
+  return await judgeReexports(
     ctx,
-    context,
-    withoutEchoes(
-      records.map((record) => ({
-        onlyVia: record.onlyVia,
-        problems: [
-          ...problemsOf(record, context),
-          ...record.suppressed.filter((problem) => problem.kind === "declared")
-        ]
-      }))
-    )
+    takesContextOf(context),
+    records.map((record) => ({
+      onlyVia: record.onlyVia,
+      problems: problemsOf(record, context),
+      suppressed: record.suppressed
+    })),
+    serverImports
   );
-  const standingIn = [
-    ...records.flatMap((record) => record.suppressed),
-    ...kept.filter((problem) => isSecondHop(problem))
-  ];
-  const rest = kept.filter((problem) => !isSecondHop(problem));
-  const prepared = await prepareReexports(ctx, context, standingIn);
-  return { problems: [...rest, ...decideReexports(prepared, serverImports)], prepared };
 }
 function reportOf(context, problems) {
   const report = buildReport(problems, context.options.cxModules, OPTIONS_HOME);
@@ -3187,6 +2381,7 @@ function serverHooks(context) {
       const devServer = server;
       const owner = devServer.environments.client;
       installServerKeepMap(context, owner);
+      noteStartedRequests(owner);
       const close = devServer.close.bind(devServer);
       const noteConnect = () => {
         devServing.noteConnect(context);