@navecss/core 0.4.0 → 0.6.0

package/dist/vite.js

@@ -1,17 +1,18 @@
-import { findingsInText, formatFinding } from './chunk-UANF3FGO.js';
-import { assertOptions, resolveUsedOptions, keptAtoms, atomsWrittenIn, applyEdits, compareText, withoutRemoved, CX_SOURCE, toSourceMap, isSecondHop, buildReport, moduleReport, isListableReexport, readModule, combinedMapOf, placerFor, cxModulesArray, nodeAt, staticStringOf, pushAll, childrenOf, nodesAt, LINE_UNKNOWN_WITHOUT_MAP, LINE_UNKNOWN_UNMAPPED, exportNameOf, atomOfClass, analyze, memberReadOf, patternDestructuring, stringAt, propertyNameOf } from './chunk-E5F6YF7A.js';
-import { validateExtendAtomsHostFree } from './chunk-LQSGQ2OA.js';
+import { formatFinding, findingsInText } from './chunk-ZNTNLGEC.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-LADFXRWQ.js';
-import { tokenize } from './chunk-NFS2REPQ.js';
+import { snapshotExtendMap, expandText, foldLocated } from './chunk-KDLLTOAM.js';
+import './chunk-UVHGEVMV.js';
 import { decodeIncomingMap, formatDiagnostic } from './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';
+import './chunk-2K5EBBF2.js';
 import { atomClassMap } from './chunk-GZL2VW7C.js';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, realpathSync, statSync } from 'fs';
 import { readFile } from 'fs/promises';
-import path2 from 'path';
+import path from 'path';
 import { fileURLToPath } from 'url';
 import { randomUUID } from 'crypto';
-import { mkdirSync, writeFileSync, readFileSync, existsSync, realpathSync, statSync } from 'fs';
 
 // src/vite-builds.ts
 function htmlPageOf(id) {
@@ -92,6 +93,14 @@ function secondHalf(pickers) {
     },
     buildEnd(error) {
       return pickers.forHook(this).collect.buildEnd.call(this, error);
+    },
+    // The same step as the first half's, ahead of every other plugin's: a plugin that inlines or
+    // renames a stylesheet in its own `generateBundle` has not yet done so.
+    generateBundle: {
+      order: "pre",
+      handler(options, bundle) {
+        pickers.forHook(this).collect.generateBundle.handler.call(this, options, bundle);
+      }
     }
   };
 }
@@ -147,134 +156,250 @@ function shareAcrossBuilds(assemble2) {
   return [firstHalf(pickers, configure), secondHalf(pickers)];
 }
 
-// src/vite-css-id.ts
-var STYLESHEET = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
-var SPECIAL_QUERY = /[?&](?:worker|sharedworker|raw|url)\b/;
-function isStylesheetPath(id) {
-  return STYLESHEET.test(id);
+// src/vite-dev-reloads.ts
+function freshReloads() {
+  return {
+    stale: /* @__PURE__ */ new Set(),
+    reloading: /* @__PURE__ */ new Map(),
+    listening: 0,
+    unheard: /* @__PURE__ */ new Set(),
+    reloadTimer: void 0,
+    readAhead: 0
+  };
 }
-function isStylesheetId(id) {
-  return STYLESHEET.test(id) && !SPECIAL_QUERY.test(id);
+function noteReloadSent(state, id) {
+  state.reloading.set(id, Date.now());
+  if (state.listening === 0) state.unheard.add(id);
 }
-function canHoldDirective(code) {
-  return /@[n\\]/i.test(code);
+
+// src/vite-report.ts
+function withSourceRoot(source, sourceRoot) {
+  if (!sourceRoot || /^(?:[a-z][a-z\d+.-]*:|\/)/i.test(source)) return source;
+  return `${sourceRoot.replace(/\/$/, "")}/${source}`;
 }
-function filePathOf(id) {
-  const query = id.indexOf("?");
-  return query === -1 ? id : id.slice(0, query);
+function locateAt(position, text, input) {
+  const origin = input.incoming?.originalPositionFor({
+    line: position.line,
+    column: position.column - 1
+  });
+  if (origin === void 0) {
+    return {
+      text,
+      file: input.file,
+      isProcessed: true,
+      line: position.line,
+      column: position.column
+    };
+  }
+  return {
+    text,
+    file: withSourceRoot(origin.source, input.incoming?.sourceRoot),
+    isProcessed: false,
+    line: origin.line,
+    column: origin.column + 1
+  };
 }
-
-// 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);
+function locate(diagnostic, input) {
+  return locateAt(diagnostic, formatDiagnostic(diagnostic, { extend: input.extend }), input);
 }
-
-// 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 withNoMapNote(body, input, at) {
+  if (!at.isProcessed) return body;
+  const reason = input.incoming === void 0 ? "no source map" : "the source map does not cover it";
+  const note = `(position in ${input.file} as processed; ${reason})`;
+  const lines = body.split("\n");
+  const hasAvailable = lines.at(-1)?.startsWith("Available: ") === true;
+  lines.splice(hasAvailable ? -1 : lines.length, 0, note);
+  return lines.join("\n");
 }
-function fileOf(id) {
-  return filePathOf(id).replaceAll("\\", "/");
+function logFor(message, input, at) {
+  return {
+    message,
+    id: input.id,
+    loc: { file: at.file, line: at.line, column: at.column - 1 }
+  };
 }
-function namesOf(file) {
-  const name = path2.basename(file, path2.extname(file));
-  return name === "index" ? [name, path2.basename(path2.dirname(file))] : [name];
+function frame(at) {
+  return `${at.file}:${at.line}:${at.column}: `;
 }
-function entriesNaming(declared, id) {
-  const file = fileOf(id);
-  return declared.ids.entries().filter(([, resolved]) => fileOf(resolved) === file).map(([entry]) => entry).toArray();
+function reportDiagnostics(input) {
+  if (input.onUnknown === "ignore" || input.diagnostics.length === 0) return;
+  const inSourceOrder = input.diagnostics.toSorted((a, b) => a.offset - b.offset);
+  const located = inSourceOrder.map((diagnostic) => locate(diagnostic, input));
+  if (input.onUnknown === "warn") {
+    for (const at of located) {
+      const message2 = withNoMapNote(`${frame(at)}${at.text}`, input, at);
+      input.ctx.warn(logFor(message2, input, at));
+    }
+    return;
+  }
+  const first = located[0];
+  const message = withNoMapNote(`${frame(first)}${foldLocated(located)}`, input, first);
+  input.ctx.error(logFor(message, input, first));
 }
-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;
+function placeOrderWarnings(input) {
+  return input.warnings.map((warning) => {
+    const at = locateAt(warning, warning.text, input);
+    const message = withNoMapNote(`${frame(at)}${at.text}`, input, at);
+    return {
+      key: `${at.file}\0${at.line}\0${at.column}\0${at.text}`,
+      print: () => {
+        input.ctx.warn(logFor(message, input, at));
+      }
+    };
+  });
 }
-async function resolveOrNull(resolver, source, importer) {
-  try {
-    return await resolver.resolve?.(source, importer) ?? void 0;
-  } catch {
-    return void 0;
+
+// src/vite-order-warnings.ts
+function freshWarningMemory() {
+  return { printed: /* @__PURE__ */ new Set(), lastSets: /* @__PURE__ */ new Map() };
+}
+function noteNoDirective(memory, id) {
+  memory.lastSets.delete(id);
+}
+function reportOrderWarnings(input, memory, command) {
+  const placed = placeOrderWarnings(input);
+  if (command === "serve") {
+    const set = placed.map((warning) => warning.key).join("\n");
+    if (memory.lastSets.get(input.id) === set) return;
+    memory.lastSets.set(input.id, set);
+    for (const warning of placed) warning.print();
+    return;
+  }
+  for (const warning of placed) {
+    if (memory.printed.has(warning.key)) continue;
+    memory.printed.add(warning.key);
+    warning.print();
   }
 }
-async function resolveEntries(context, resolver) {
-  const from = path2.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)));
+
+// src/vite-writers.ts
+function freshWriters() {
   return {
-    entries: new Set(kept.map(([entry]) => entry).filter((entry) => !isRelative(entry))),
-    ids,
-    files,
-    names,
-    textTest: textTestOf(names)
+    emittedBy: void 0,
+    firstWriter: void 0,
+    fixed: /* @__PURE__ */ new Map(),
+    writers: /* @__PURE__ */ new Map(),
+    whole: /* @__PURE__ */ new Set(),
+    wholeAssets: /* @__PURE__ */ new Set()
   };
 }
-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 hasStylesheet(state, name) {
+  const prefix = `${name}\0`;
+  return state.sheets.keys().some((key) => key.startsWith(prefix));
+}
+function forgetWriters(state) {
+  state.emitted = void 0;
+  state.emittedBy = void 0;
+  state.firstWriter = void 0;
+  state.fixed.clear();
+  state.writers.clear();
+  state.whole.clear();
+  state.wholeAssets.clear();
+}
+
+// src/vite-state.ts
+var byConfig = /* @__PURE__ */ new WeakMap();
+var byBuild = /* @__PURE__ */ new WeakMap();
+function buildOf(config) {
+  return config.command === "build" ? config.inlineConfig : void 0;
+}
+function mapOf(registry2, owner) {
+  const found = registry2.get(owner) ?? /* @__PURE__ */ new Map();
+  registry2.set(owner, found);
+  return found;
+}
+function freshState() {
+  return {
+    started: false,
+    modules: /* @__PURE__ */ new Map(),
+    exposures: /* @__PURE__ */ new Map(),
+    templateLinks: /* @__PURE__ */ new Map(),
+    packages: /* @__PURE__ */ new Set(),
+    declared: /* @__PURE__ */ new Map(),
+    recognised: /* @__PURE__ */ new Map(),
+    sheets: /* @__PURE__ */ new Map(),
+    pages: /* @__PURE__ */ new Map(),
+    emitted: void 0,
+    ...freshWriters(),
+    externals: /* @__PURE__ */ new Set(),
+    clientEnded: false,
+    serverImports: [],
+    client: void 0,
+    expectedEnvironments: void 0,
+    builtEnvironments: /* @__PURE__ */ new Set(),
+    warned: /* @__PURE__ */ new Set(),
+    served: /* @__PURE__ */ new Map(),
+    ...freshReloads(),
+    htmlRead: false,
+    serverTransformed: false,
+    directiveExpanded: false,
+    markupJudged: false,
+    warmedUp: false,
+    requested: /* @__PURE__ */ new Set(),
+    orderWarnings: freshWarningMemory()
+  };
+}
+function stateFor(root, config) {
+  const known = byConfig.get(config)?.get(root);
+  if (known) return known;
+  const build = buildOf(config);
+  const shared = build && byBuild.get(build)?.get(root);
+  const state = shared && !shared.started ? shared : freshState();
+  mapOf(byConfig, config).set(root, state);
+  if (build) mapOf(byBuild, build).set(root, state);
+  return state;
+}
+function moduleKey(environment, id) {
+  return `${environment}\0${id}`;
 }
-function withoutTrailingSlashes(text) {
-  let end = text.length;
-  while (end > 0 && text[end - 1] === "/") end -= 1;
-  return text.slice(0, end);
+function collectedAtoms(state, kept) {
+  const atoms = new Set(kept);
+  for (const record of state.modules.values()) for (const atom of record.atoms) atoms.add(atom);
+  for (const page of state.pages.values()) for (const atom of page) atoms.add(atom);
+  return atoms;
 }
-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 servedAtoms(state, kept) {
+  return withRestorers(collectedAtoms(state, kept));
 }
-function isNamingListed(specifier, declared) {
-  const segment = lastSegmentOf(specifier);
-  if (declared.names.has(segment)) return true;
-  const extension = path2.extname(segment);
-  return extension !== "" && declared.names.has(segment.slice(0, -extension.length));
+function recordsOf(state, environment) {
+  const prefix = `${environment}\0`;
+  return [...state.modules].filter(([key]) => key.startsWith(prefix)).map(([, record]) => record);
 }
-function isAboutListed(input, declared) {
-  if (!declared) return false;
-  return isListedFile(declared, input.id) || isMentioningDeclared(input.code, declared);
+
+// src/vite-css-capture.ts
+var originals = /* @__PURE__ */ new WeakMap();
+function transformHandler(plugin) {
+  const { transform } = plugin;
+  if (typeof transform === "function") return transform;
+  const handler = transform?.handler;
+  return typeof handler === "function" ? handler : void 0;
 }
-function isListedFile(declared, id) {
-  return declared.files.has(fileOf(id));
+function unwrapped(handler) {
+  let current = handler;
+  for (let next = originals.get(current); next; next = originals.get(current)) current = next;
+  return current;
 }
-function isMentioningDeclared(code, declared) {
-  for (const entry of declared.entries) if (code.includes(entry)) return true;
-  return declared.textTest?.test(code) ?? false;
+function remember(context, environment, id, css) {
+  const key = moduleKey(environment, id);
+  const isPossible = css.includes("\\") || /layer/i.test(css);
+  if (isPossible && inspectAtomicLayer(css).hasLayer) context.state.sheets.set(key, css);
+  else context.state.sheets.delete(key);
 }
-function recognisedKey(environment, file, importer) {
-  return `${environment}\0${file}\0${importer}`;
+function captureStylesheets(context, plugins) {
+  const plugin = plugins?.find((candidate) => candidate.name === "vite:css-post");
+  const original = plugin && transformHandler(plugin);
+  if (!plugin || !original) return;
+  const wrapped = function(css, id) {
+    const environment = this.environment?.name ?? "client";
+    remember(context, environment, id, css);
+    return original.call(this, css, id);
+  };
+  originals.set(wrapped, original);
+  const { transform } = plugin;
+  plugin.transform = typeof transform === "function" ? wrapped : { ...transform, handler: wrapped };
 }
 var NAVE_MODULE_DIRS = ["src", "dist"].map(
-  (name) => `${path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", name).replaceAll("\\", "/")}/`
+  (name) => `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", name).replaceAll("\\", "/")}/`
 );
 function pathOfId(id) {
   return filePathOf(id).replaceAll("\\", "/");
@@ -283,11 +408,8 @@ 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 = path2.dirname(file);
+  const directory = path.dirname(file);
   const cached = cache.get(directory);
   if (cached) return cached;
   const found = nameAbove(directory, cache);
@@ -296,13 +418,13 @@ async function packageNameOf(file, cache) {
 }
 async function nameAbove(directory, cache) {
   const name = await readName(directory);
-  const parent = path2.dirname(directory);
+  const parent = path.dirname(directory);
   if (name !== void 0 || parent === directory) return name;
   return packageNameOf(directory, cache);
 }
 async function readName(directory) {
   try {
-    const manifest = JSON.parse(await readFile(path2.join(directory, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile(path.join(directory, "package.json"), "utf8"));
     return typeof manifest.name === "string" ? manifest.name : void 0;
   } catch {
     return void 0;
@@ -311,310 +433,408 @@ async function readName(directory) {
 function moduleLabel(root, id) {
   const file = filePathOf(id);
   if (file.startsWith("\0")) return String.raw`\0${file.slice(1)}`;
-  if (!path2.isAbsolute(file)) return file;
-  return path2.relative(root, file).replaceAll("\\", "/");
+  if (!path.isAbsolute(file)) return file;
+  return path.relative(root, file).replaceAll("\\", "/");
 }
 
-// src/vite-cx-importers.ts
-function importerIdsOf(ctx, cxId) {
-  const info = ctx.getModuleInfo?.(cxId);
-  return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
+// src/vite-emit.ts
+var decoder = new TextDecoder();
+async function refeed(ctx, css, id) {
+  const plugin = ctx.environment.plugins.find((candidate) => candidate.name === "vite:css-post");
+  const handler = plugin && transformHandler(plugin);
+  if (!handler) {
+    ctx.error(
+      "nave: this version of Vite has no CSS step the plugin knows how to hand a stylesheet back to, so it cannot remove the unused atoms. Ship every atom with atomic: 'all' in navePlugin() until the plugin supports this version of Vite."
+    );
+  }
+  await unwrapped(handler).call(ctx, css, id);
 }
-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);
+var fedPages = /* @__PURE__ */ new WeakMap();
+var warnedText = /* @__PURE__ */ new WeakMap();
+function bookFor(book, emitted) {
+  const ids = book.get(emitted) ?? /* @__PURE__ */ new Set();
+  book.set(emitted, ids);
+  return ids;
 }
-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 isPageStylesheet(id) {
+  return /[?&]html-proxy\b/.test(id);
 }
-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 pageStylesheets(ctx, state, emitted) {
+  const prefix = `${ctx.environment.name}\0`;
+  const fed = bookFor(fedPages, emitted);
+  const ids = state.sheets.keys().filter((key) => key.startsWith(prefix) && isPageStylesheet(key)).map((key) => key.slice(prefix.length)).filter((id) => !fed.has(id)).toArray();
+  for (const id of ids) fed.add(id);
+  return ids;
+}
+function isInlineImport(id) {
+  return /[?&]inline\b/.test(id) && !isPageStylesheet(id);
+}
+function isRawImport(id) {
+  return /[?&]raw\b/.test(id) && isStylesheetPath(id);
 }
-function specifiersOf(ctx, importer) {
+function isLayerFile(id) {
   try {
-    return specifiersIn(ctx.parse?.(importer.code));
+    return inspectAtomicLayer(readFileSync(filePathOf(id), "utf8")).hasLayer;
   } catch {
-    return void 0;
+    return false;
   }
 }
-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.`;
+async function refeedChunkStylesheets(ctx, chunk, state, emitted) {
+  const prefix = `${ctx.environment.name}\0`;
+  for (const id of [...Object.keys(chunk.modules), ...pageStylesheets(ctx, state, emitted)]) {
+    const css = state.sheets.get(`${prefix}${id}`);
+    if (css === void 0 || isInlineImport(id)) continue;
+    await refeed(ctx, pruneAtomicLayer(css, emitted), id);
   }
-  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, []);
+function warnTextImports(ctx, chunk, context, emitted) {
+  const prefix = `${ctx.environment.name}\0`;
+  const warned = bookFor(warnedText, emitted);
+  for (const id of Object.keys(chunk.modules)) {
+    if (warned.has(id)) continue;
+    const isInline = isInlineImport(id) && context.state.sheets.has(`${prefix}${id}`);
+    const isRaw = !isInline && isRawImport(id) && isLayerFile(id);
+    if (!isInline && !isRaw) continue;
+    warned.add(id);
+    const query = isInline ? "?inline" : "?raw";
+    ctx.warn(
+      `${moduleLabel(context.root, id)} is imported with ${query}, so its stylesheet is text in the JavaScript, which the plugin does not filter: every atom in its atomic layer ships, not only the atoms this build emits. Import it without ${query} to have the layer filtered.`
+    );
+  }
 }
-async function checkCxImporters(ctx, context) {
-  const resolved = await ctx.resolve?.(CX_SOURCE, path2.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);
+function textOf(entry) {
+  const { source } = entry;
+  if (source === void 0) return "";
+  return typeof source === "string" ? source : decoder.decode(source);
+}
+function readLayers(bundle, emitted) {
+  const reading = /* @__PURE__ */ new Map();
+  const assets = Object.values(bundle).filter((entry) => entry.type === "asset" && entry.fileName.toLowerCase().endsWith(".css")).map((entry) => ({ fileName: entry.fileName, css: textOf(entry) }));
+  for (const { fileName, css } of assets) {
+    const seen = inspectAtomicLayer(css);
+    if (!seen.hasLayer) continue;
+    const extra = unprunedAtoms(css, emitted);
+    reading.set(fileName, {
+      seen: new Set(seen.atoms),
+      extra: extra.length > 0 ? `${fileName}: the atomic layer holds a rule for ${extra.join(", ")}, which the build did not emit.` : void 0
+    });
   }
-  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")
-  );
+  return reading;
 }
-
-// src/vite-cx-reading.ts
-async function declaredReadingOf(context, resolver, declared, input) {
-  const { environment, module } = input;
-  const declaredSources = /* @__PURE__ */ new Set();
-  if (!declared) return { declaredSources, isDeclared: false, onlyVia: void 0 };
-  const files = /* @__PURE__ */ new Set();
-  let isOnlyListed = true;
-  for (const source of specifiersIn(module.program)) {
-    if (source === CX_SOURCE) {
-      isOnlyListed = false;
-      continue;
-    }
-    const found = await listedFileOf(resolver, declared, source, module.id);
-    if (!found) continue;
-    declaredSources.add(source);
-    if (found.file === void 0) {
-      isOnlyListed = false;
-      continue;
-    }
-    files.add(found.file);
-    const key = recognisedKey(environment, found.file, module.id);
-    context.state.recognised.set(
-      key,
-      /* @__PURE__ */ new Set([...context.state.recognised.get(key) ?? [], source])
-    );
+function mismatchLines(reading, emitted) {
+  const assets = reading.values().toArray();
+  const lines = assets.flatMap((asset) => asset.extra ? [asset.extra] : []);
+  const seenAnywhere = new Set(assets.flatMap((asset) => [...asset.seen]));
+  const missing = [...emitted.difference(seenAnywhere)];
+  if (reading.size > 0 && missing.length > 0) {
+    lines.push(`the atomic layers hold no rule for ${missing.join(", ")}, which the build emitted.`);
   }
-  return {
-    declaredSources,
-    isDeclared: isListedFile(declared, module.id),
-    onlyVia: isOnlyListed && files.size > 0 ? files : void 0
-  };
+  return lines;
 }
-async function listedFileFrom(resolver, declared, source, importer) {
-  const resolved = await resolveOrNull(resolver, source, importer);
-  const file = resolved ? fileOf(resolved.id) : void 0;
-  return file !== void 0 && declared.files.has(file) ? file : void 0;
+function layerMessage(lines) {
+  return [
+    "nave: the built CSS does not hold exactly the atoms the build emitted, so the plugin could not remove the unused ones on this version of Vite.",
+    ...lines,
+    "Ship every atom with atomic: 'all' in navePlugin() until the plugin supports this version of Vite."
+  ].join("\n");
 }
-async function listedFileOf(resolver, declared, source, importer) {
-  if (declared.entries.has(source)) {
-    const id = source.startsWith("#") ? void 0 : declared.ids.get(source);
-    if (id !== void 0) return { file: fileOf(id) };
-    const file2 = await listedFileFrom(resolver, declared, source, importer);
-    return file2 === void 0 && source.startsWith("#") ? void 0 : { file: file2 };
+var HANDSHAKE_FILE = "nave-used-atoms.json";
+function handshakePath(cacheDir) {
+  return path.join(cacheDir, HANDSHAKE_FILE);
+}
+function readHandshake(cacheDir) {
+  if (cacheDir === "") return void 0;
+  try {
+    const parsed2 = JSON.parse(readFileSync(handshakePath(cacheDir), "utf8"));
+    return Array.isArray(parsed2.emitted) && typeof parsed2.writer === "string" ? parsed2 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeHandshake(cacheDir, fields, warn) {
+  if (cacheDir === "") return;
+  const handshake = {
+    ...fields,
+    emitted: [...fields.emitted].toSorted(compareText),
+    writtenAt: fields.writtenAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    build: fields.build ?? randomUUID()
+  };
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(handshakePath(cacheDir), `${JSON.stringify(handshake, void 0, 2)}
+`);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    warn?.(
+      `navePlugin(): could not write ${handshakePath(cacheDir)} (${reason}), so a build of the client and a build of the server run as two processes cannot share their atoms.`
+    );
   }
-  if (!isNamingListed(source, declared)) return void 0;
-  const file = await listedFileFrom(resolver, declared, source, importer);
-  return file === void 0 ? void 0 : { file };
 }
 
-// src/vite-dev-keep.ts
-var KEEP_CONSTANT = "__NAVE_KEEP_CLASSES__";
-function keepMap(kept) {
-  return Object.fromEntries(
-    kept.filter((atom) => Object.hasOwn(atomClassMap, atom)).map((atom) => [atom, atomClassMap[atom]])
-  );
+// src/vite-emitted.ts
+function positionText(place) {
+  return place.line === 0 ? place.file : `${place.file}:${place.line}:${place.column}`;
 }
-function devKeepMap(map, atoms) {
-  return new Proxy(map, {
-    getOwnPropertyDescriptor(target, key) {
-      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-      if (descriptor === void 0 && typeof key === "string") {
-        const quoted2 = JSON.stringify(key);
-        console.error(
-          atoms.includes(key) ? `[nave] cx.dynamic(${quoted2}) applied no class: ${quoted2} is not in keep or in a keepFor list, and navePlugin() gives cx.dynamic() only the atoms in those lists, in a build as in dev. Add ${quoted2} to keep in navePlugin(), or, when a dependency makes the call, to its list in keepFor.` : `[nave] cx.dynamic(${quoted2}) applied no class: ${quoted2} is not a Nave atom.`
-        );
-      }
-      return descriptor;
-    }
-  });
+function packageRecords(context) {
+  const records = {};
+  for (const pkg of Object.keys(context.options.keepFor)) {
+    const modules = context.state.modules.values().filter((record) => record.pkg === pkg).toArray();
+    const places = modules.flatMap((record) => [...record.suppressed, ...record.dynamicCalls]);
+    records[pkg] = {
+      collected: [...new Set(modules.flatMap((record) => [...record.atoms]))].toSorted(compareText),
+      unreadable: places.map((place) => positionText(place))
+    };
+  }
+  return records;
 }
-function devKeepExpression(map, atoms) {
-  return `(${devKeepMap.toString()})(${JSON.stringify(map)}, ${JSON.stringify(atoms)})`;
+function unmatchedKeys(context) {
+  const transformed = new Set(context.state.modules.values().map((record) => record.pkg));
+  return Object.keys(context.options.keepFor).filter((pkg) => !transformed.has(pkg));
 }
-var installs = [];
-var baseline = { held: false, value: void 0 };
-function publish() {
-  const newest = installs.at(-1);
-  if (newest !== void 0) Object.assign(globalThis, { [KEEP_CONSTANT]: newest.map });
-  else if (baseline.held) Object.assign(globalThis, { [KEEP_CONSTANT]: baseline.value });
-  else Reflect.deleteProperty(globalThis, KEEP_CONSTANT);
+function takenFromCache(context) {
+  const file = context.inProcess ? void 0 : readHandshake(context.cacheDir);
+  if (file === void 0) return { atoms: [], took: false };
+  if (file.writer !== "client") return { atoms: file.emitted, took: true };
+  const pending = file.pending ?? [];
+  return { atoms: pending, took: pending.length > 0 };
 }
-function installServerKeepMap(context, owner) {
-  if (context.options.atomic !== "used") return;
-  const map = devKeepMap(keepMap(context.kept), Object.keys(atomClassMap));
-  if (installs.length === 0) {
-    baseline.held = Object.hasOwn(globalThis, KEEP_CONSTANT);
-    baseline.value = globalThis[KEEP_CONSTANT];
+function canWriteStylesheets(context, environment) {
+  const { state } = context;
+  if (environment.config.consumer === "client")
+    return state.firstWriter !== "server" || hasStylesheet(state, environment.name);
+  if (!context.inProcess || state.firstWriter === "client") return false;
+  return environment.config.build?.emitAssets === true;
+}
+function emittedSet(context, environment, warn) {
+  const { state } = context;
+  const known = state.fixed.get(environment.name);
+  if (known) return known;
+  const atoms = collectedAtoms(state, context.kept);
+  const taken = takenFromCache(context);
+  for (const atom of taken.atoms) atoms.add(atom);
+  withRestorers(atoms);
+  state.fixed.set(environment.name, atoms);
+  if (state.emitted === void 0) {
+    state.emitted = atoms;
+    state.emittedBy = environment.name;
+    state.firstWriter = environment.config.consumer === "client" ? "client" : "server";
   }
-  installs.push({ owner, map });
-  publish();
+  writeHandshake(
+    context.cacheDir,
+    {
+      emitted: [...atoms],
+      writer: environment.config.consumer === "client" ? "client" : environment.name,
+      consumed: taken.took,
+      keepFor: packageRecords(context),
+      unmatchedKeepFor: unmatchedKeys(context)
+    },
+    warn
+  );
+  return atoms;
 }
-function removeServerKeepMap(owner) {
-  const index = installs.findIndex((install) => install.owner === owner);
-  if (index === -1) return;
-  installs.splice(index, 1);
-  publish();
+function namingLines(ctx, context, atoms) {
+  return recordsOf(context.state, ctx.environment.name).flatMap(
+    (record) => atoms.filter((atom) => record.atoms.has(atom)).map((atom) => `${record.file}: names ${atom}.`)
+  );
 }
-
-// src/vite-dev-reloads.ts
-function freshReloads() {
-  return {
-    stale: /* @__PURE__ */ new Set(),
-    reloading: /* @__PURE__ */ new Map(),
-    listening: 0,
-    unheard: /* @__PURE__ */ new Set(),
-    reloadTimer: void 0,
-    readAhead: 0
-  };
+function missingFromClient(ctx, context, missing) {
+  return [
+    "The client build already wrote its CSS without atoms this server build names, so their rules are missing from it:",
+    ...namingLines(ctx, context, missing),
+    `They are recorded in ${handshakePath(context.cacheDir)} for the next client build. List the atoms in keep in navePlugin(), or build the client again, then the server (vite build, then vite build --ssr). To keep this from recurring, build the server first, then the client (vite build --ssr, then vite build).`
+  ].join("\n");
 }
-function noteReloadSent(state, id) {
-  state.reloading.set(id, Date.now());
-  if (state.listening === 0) state.unheard.add(id);
+function notInLastClient(ctx, context, missing) {
+  return [
+    `${handshakePath(context.cacheDir)} was written by a client build that was already used, so this server build could not be checked against the CSS. These atoms it names are not in that client build's set:`,
+    ...namingLines(ctx, context, missing),
+    "They are recorded in that file for a client build that runs next; to have them in the CSS, build the server first, then the client (vite build --ssr, then vite build)."
+  ].join("\n");
+}
+function recordForNextClient(ctx, context, atoms, held) {
+  writeHandshake(
+    context.cacheDir,
+    { emitted: [...withRestorers(new Set(atoms))], writer: ctx.environment.name, consumed: false },
+    (message) => ctx.warn(message)
+  );
+  const missing = [...atoms].filter((atom) => !held.includes(atom)).toSorted(compareText);
+  if (missing.length > 0) ctx.warn(notInLastClient(ctx, context, missing));
+}
+function checkWaitingClient(ctx, context, atoms, file) {
+  const missing = [...atoms].filter((atom) => !file.emitted.includes(atom)).toSorted(compareText);
+  if (missing.length === 0) {
+    writeHandshake(context.cacheDir, { ...file, consumed: true, pending: [] }, (message) => {
+      ctx.warn(message);
+    });
+    return;
+  }
+  const pending = [.../* @__PURE__ */ new Set([...file.pending ?? [], ...withRestorers(new Set(atoms))])];
+  writeHandshake(context.cacheDir, { ...file, pending }, (message) => ctx.warn(message));
+  ctx.error(missingFromClient(ctx, context, missing));
+}
+function checkServerInvocation(ctx, context) {
+  if (context.cacheDir === "" || context.inProcess || context.state.emitted) return;
+  const atoms = new Set(recordsOf(context.state, ctx.environment.name).flatMap((r) => [...r.atoms]));
+  const file = readHandshake(context.cacheDir);
+  if (file?.writer !== "client") {
+    const emitted = [...withRestorers(/* @__PURE__ */ new Set([...atoms, ...file?.emitted ?? []]))];
+    writeHandshake(
+      context.cacheDir,
+      { emitted, writer: ctx.environment.name, consumed: false },
+      (message) => ctx.warn(message)
+    );
+  } else if (file.consumed) {
+    recordForNextClient(ctx, context, atoms, file.emitted);
+  } else {
+    checkWaitingClient(ctx, context, atoms, file);
+  }
 }
 
-// src/vite-state.ts
-var byConfig = /* @__PURE__ */ new WeakMap();
-var byBuild = /* @__PURE__ */ new WeakMap();
-function buildOf(config) {
-  return config.command === "build" ? config.inlineConfig : void 0;
+// src/vite-scan.ts
+var decoder2 = new TextDecoder();
+function isCssAsset(entry) {
+  return entry.type === "asset" && entry.fileName.toLowerCase().endsWith(".css");
 }
-function mapOf(registry2, owner) {
-  const found = registry2.get(owner) ?? /* @__PURE__ */ new Map();
-  registry2.set(owner, found);
-  return found;
+function textOf2(entry) {
+  const { source } = entry;
+  if (source === void 0) return "";
+  return typeof source === "string" ? source : decoder2.decode(source);
 }
-function freshState() {
+function scanMessage(findings, assetCount) {
+  const noun = assetCount === 1 ? "asset" : "assets";
+  return [
+    "@nave survived into the built CSS:",
+    ...findings.map((finding) => formatFinding(finding)),
+    `Scanned ${assetCount} CSS ${noun} this build wrote.`
+  ].join("\n");
+}
+function scanAssets(bundle) {
+  const assets = Object.values(bundle).filter((entry) => isCssAsset(entry));
   return {
-    started: false,
-    modules: /* @__PURE__ */ new Map(),
-    exposures: /* @__PURE__ */ new Map(),
-    templateLinks: /* @__PURE__ */ new Map(),
-    packages: /* @__PURE__ */ new Set(),
-    declared: /* @__PURE__ */ new Map(),
-    recognised: /* @__PURE__ */ new Map(),
-    sheets: /* @__PURE__ */ new Map(),
-    pages: /* @__PURE__ */ new Map(),
-    emitted: void 0,
-    externals: /* @__PURE__ */ new Set(),
-    clientEnded: false,
-    serverImports: [],
-    client: void 0,
-    expectedEnvironments: void 0,
-    builtEnvironments: /* @__PURE__ */ new Set(),
-    warned: /* @__PURE__ */ new Set(),
-    served: /* @__PURE__ */ new Map(),
-    ...freshReloads(),
-    htmlRead: false,
-    serverTransformed: false,
-    directiveExpanded: false,
-    markupJudged: false,
-    warmedUp: false,
-    requested: /* @__PURE__ */ new Set()
+    findings: assets.flatMap((asset) => findingsInText(asset.fileName, textOf2(asset))),
+    names: assets.map((asset) => asset.fileName)
   };
 }
-function stateFor(root, config) {
-  const known = byConfig.get(config)?.get(root);
-  if (known) return known;
-  const build = buildOf(config);
-  const shared = build && byBuild.get(build)?.get(root);
-  const state = shared && !shared.started ? shared : freshState();
-  mapOf(byConfig, config).set(root, state);
-  if (build) mapOf(byBuild, build).set(root, state);
-  return state;
-}
-function moduleKey(environment, id) {
-  return `${environment}\0${id}`;
+
+// src/vite-whole.ts
+function stylesheetsLeftWhole(context, environment, chunk) {
+  const { state } = context;
+  const whole = /* @__PURE__ */ new Set();
+  if (state.firstWriter !== "server" || environment.config.consumer !== "server") return whole;
+  const earlier = [...state.writers].filter(([name, consumer]) => name !== environment.name && consumer === "server").map(([name]) => name);
+  const ids = Object.keys(chunk.modules);
+  for (const id of ids) {
+    if (earlier.every((name) => !state.sheets.has(moduleKey(name, id)))) continue;
+    whole.add(id);
+    state.whole.add(moduleKey(environment.name, id));
+  }
+  return whole;
 }
-function collectedAtoms(state, kept) {
-  const atoms = new Set(kept);
-  for (const record of state.modules.values()) for (const atom of record.atoms) atoms.add(atom);
-  for (const page of state.pages.values()) for (const atom of page) atoms.add(atom);
-  return atoms;
+function withoutWhole(chunk, whole) {
+  if (whole.size === 0) return chunk;
+  return {
+    modules: Object.fromEntries(Object.entries(chunk.modules).filter(([id]) => !whole.has(id)))
+  };
 }
-function withRestorers(atoms) {
-  if (atoms.has("srOnly")) atoms.add("srOnlyFocusable");
-  return atoms;
+function assetKey(environment, entry) {
+  return `${environment}|${(entry.names ?? []).join(",")}|${(entry.originalFileNames ?? []).join(",")}`;
 }
-function servedAtoms(state, kept) {
-  return withRestorers(collectedAtoms(state, kept));
+function noteWholeAssets(context, environment, bundle) {
+  const { state } = context;
+  if (state.whole.size === 0) return;
+  const chunks = Object.values(bundle).filter((entry) => entry.type === "chunk");
+  for (const entry of chunks) {
+    const ids = Object.keys(entry.modules ?? {});
+    if (ids.every((id) => !state.whole.has(moduleKey(environment.name, id)))) continue;
+    const files = entry.viteMetadata?.importedCss ?? /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const asset = bundle[file];
+      if (asset) state.wholeAssets.add(assetKey(environment.name, asset));
+    }
+  }
 }
-function recordsOf(state, environment) {
-  const prefix = `${environment}\0`;
-  return [...state.modules].filter(([key]) => key.startsWith(prefix)).map(([, record]) => record);
+function withoutWholeAssets(context, environment, bundle) {
+  const { wholeAssets } = context.state;
+  if (wholeAssets.size === 0) return { ...bundle };
+  return Object.fromEntries(
+    Object.entries(bundle).filter(
+      ([, entry]) => !(entry.type === "asset" && wholeAssets.has(assetKey(environment.name, entry)))
+    )
+  );
 }
 
-// src/vite-setup-link.ts
-function importsContaining(program, marker) {
-  const sources = nodesAt(program, "body").map(
-    (node) => node.type === "ImportDeclaration" ? staticStringOf(nodeAt(node, "source")) : void 0
+// src/vite-bundle.ts
+var reads = /* @__PURE__ */ new WeakMap();
+function sourceText(entry) {
+  return typeof entry.source === "string" ? entry.source : new TextDecoder().decode(entry.source);
+}
+function hasLayerAsset(bundle) {
+  return Object.values(bundle).some(
+    (entry) => entry.type === "asset" && entry.fileName.toLowerCase().endsWith(".css") && /@layer\s+atomic\b/.test(sourceText(entry))
   );
-  return sources.filter((source) => source?.includes(marker) === true);
 }
-async function resolveId(ctx, source, importer) {
-  const resolved = await ctx.resolve?.(source, importer);
-  return resolved?.id;
+function didWrite(context, environment, step) {
+  const { state } = context;
+  if (reads.get(step.output)?.wrote === true || hasLayerAsset(step.bundle)) {
+    state.writers.set(environment.name, environment.config.consumer);
+    return true;
+  }
+  if (state.emittedBy === environment.name && environment.config.consumer !== "client") {
+    state.emitted = void 0;
+    state.emittedBy = void 0;
+    state.firstWriter = void 0;
+    state.fixed.delete(environment.name);
+  }
+  return false;
+}
+function accumulate(step, layer, isWriter) {
+  const { bundle, output } = step;
+  const before = reads.get(output) ?? {
+    layer: /* @__PURE__ */ new Map(),
+    findings: /* @__PURE__ */ new Map(),
+    assets: /* @__PURE__ */ new Set(),
+    wrote: false
+  };
+  reads.set(output, before);
+  before.wrote ||= isWriter;
+  if (layer) for (const [name, asset] of layer) before.layer.set(name, asset);
+  const scanned = scanAssets(bundle);
+  for (const finding of scanned.findings) before.findings.set(formatFinding(finding), finding);
+  for (const name of scanned.names) before.assets.add(name);
+  return before;
+}
+function readWritten(ctx, context, step) {
+  const { environment } = ctx;
+  if (environment === void 0 || context.options.atomic !== "used") return void 0;
+  if (!canWriteStylesheets(context, environment)) return void 0;
+  if (!didWrite(context, environment, step)) return void 0;
+  noteWholeAssets(context, environment, step.bundle);
+  const emitted = emittedSet(context, environment, (message) => {
+    ctx.warn(message);
+  });
+  return {
+    emitted,
+    layer: readLayers(withoutWholeAssets(context, environment, step.bundle), emitted)
+  };
+}
+function failOnMismatch(ctx, lines) {
+  if (lines.length > 0) ctx.error({ message: layerMessage(lines) });
 }
-async function linkTemplates(context, ctx, input, scriptId) {
-  const environment = ctx.environment?.name ?? "client";
-  for (const template of importsContaining(input.program, "type=template")) {
-    const templateId = await resolveId(ctx, template, input.id);
-    if (templateId !== void 0) {
-      context.state.templateLinks.set(moduleKey(environment, templateId), scriptId);
-    }
-  }
+function failOnFindings(ctx, read) {
+  if (read.findings.size === 0) return;
+  ctx.error({ message: scanMessage(read.findings.values().toArray(), read.assets.size) });
 }
-async function setupExposuresFor(context, ctx, input) {
-  const environment = ctx.environment?.name ?? "client";
-  const [script] = importsContaining(input.program, "type=script");
-  const scriptId = script === void 0 ? void 0 : await resolveId(ctx, script, input.id);
-  await linkTemplates(context, ctx, input, scriptId ?? input.id);
-  if (!input.code.includes("$setup")) return void 0;
-  const owner = scriptId ?? context.state.templateLinks.get(moduleKey(environment, input.id));
-  if (owner === void 0) return void 0;
-  await ctx.load?.({ id: owner });
-  return context.state.exposures.get(moduleKey(environment, owner));
+function raise(ctx, seen) {
+  reads.delete(seen.output);
+  if (seen.emitted) failOnMismatch(ctx, mismatchLines(seen.read.layer, seen.emitted));
+  failOnFindings(ctx, seen.read);
+}
+function checkBundle(ctx, context, step) {
+  const { bundle, options, pass } = step;
+  const output = typeof options === "object" && options !== null ? options : bundle;
+  const written = readWritten(ctx, context, { bundle, output });
+  const read = accumulate({ bundle, output }, written?.layer, written !== void 0);
+  if (pass === "post") raise(ctx, { emitted: written?.emitted, output, read });
 }
 
 // src/vite-unread-record.ts
@@ -681,1781 +901,1009 @@ function textRecord(context, input) {
     problems: [],
     suppressed: [],
     dynamicCalls: [],
-    pkg,
-    file: moduleLabel(context.root, id)
-  };
-}
-
-// src/vite-used.ts
-function createUsedContext(options, extend) {
-  return {
-    options,
-    extend,
-    kept: keptAtoms(options),
-    packageNames: /* @__PURE__ */ new Map(),
-    root: process.cwd(),
-    command: "build",
-    cacheDir: "",
-    buildSourcemap: false,
-    inProcess: false,
-    isLibrary: false,
-    logger: void 0,
-    state: stateFor("", {})
-  };
-}
-function configureUsed(context, config) {
-  context.root = config.root;
-  context.command = config.command;
-  context.cacheDir = config.cacheDir ?? "";
-  context.buildSourcemap = Boolean(config.build?.sourcemap);
-  context.inProcess = config.builder !== void 0;
-  context.isLibrary = Boolean(config.build?.lib);
-  context.logger = config.logger;
-  context.state = stateFor(config.root, config);
-}
-function isUsed(context) {
-  return context.options.atomic === "used";
-}
-function ignoreWatch() {
-}
-async function ownAtomNames(context, watch = ignoreWatch) {
-  try {
-    const atoms = await context.extend.current(watch);
-    return new Set(Object.keys(atoms).filter((name) => atoms[name]));
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-
-// src/vite-collect-module.ts
-var ESCAPED_SPECIFIER = /(?:\bfrom|\bimport)[\s(]*(?:'[^'\\\n]*\\|"[^"\\\n]*\\|`[^`\\\n]*\\)/;
-function isMentioningAtoms(code) {
-  return code.includes(CX_SOURCE) || code.includes("nave-") || code.includes("$setup") || code.includes("vue&type=") || ESCAPED_SPECIFIER.test(code);
-}
-var NO_PLACE = { line: 0, column: 0 };
-function isInlineScript(id) {
-  return /[?&]html-proxy\b/.test(id);
-}
-function lineUnknownNote(context, id) {
-  const isBuildWithoutMaps = context.command === "build" && !context.buildSourcemap;
-  return isBuildWithoutMaps && !isInlineScript(id) ? LINE_UNKNOWN_WITHOUT_MAP : LINE_UNKNOWN_UNMAPPED;
-}
-function locate(problems, placing) {
-  return problems.map((problem) => {
-    const place = placing.place(problem.offset);
-    const where = place ?? { ...NO_PLACE, unknownLine: placing.unknownLine };
-    return { ...problem, file: placing.file, pkg: placing.pkg, moduleId: placing.id, ...where };
-  });
-}
-function locateDynamic(reading, placing) {
-  return reading.dynamicCalls.map(({ offset, construct }) => {
-    const place = placing.place(offset);
-    return {
-      file: placing.file,
-      construct,
-      ...place ?? { ...NO_PLACE, unknownLine: placing.unknownLine }
-    };
-  });
-}
-var COMPILED_LANGS = /* @__PURE__ */ new Map([
-  ["jsx", "jsx"],
-  ["ts", "ts"],
-  ["tsx", "tsx"]
-]);
-function parseOrUndefined(ctx, code, moduleType) {
-  try {
-    const lang = moduleType === void 0 ? void 0 : COMPILED_LANGS.get(moduleType);
-    return ctx.parse(code, lang && { lang });
-  } catch {
-    return void 0;
-  }
-}
-async function authoredTextOf(id) {
-  try {
-    return await readFile(filePathOf(id), "utf8");
-  } catch {
-    return void 0;
-  }
-}
-async function recordOf(context, ctx, input, reading) {
-  const { code, id, pkg } = input;
-  const hasPlaces = reading.problems.length + reading.dynamicCalls.length > 0;
-  const map = hasPlaces ? combinedMapOf(ctx) : void 0;
-  const authored = map ? await authoredTextOf(id) : void 0;
-  const placing = {
-    code,
-    id,
-    file: moduleLabel(context.root, id),
-    pkg,
-    place: placerFor(code, map, authored),
-    unknownLine: lineUnknownNote(context, id)
-  };
-  const isStandingIn = isListed(context, pkg);
-  return {
-    atoms: /* @__PURE__ */ new Set([...reading.atoms, ...reading.classes]),
-    problems: isStandingIn ? [] : locate(reading.problems, placing),
-    suppressed: isStandingIn ? locate(reading.problems, placing) : [],
-    dynamicCalls: locateDynamic(reading, placing),
-    pkg,
-    file: placing.file,
-    ...reading.edits.length > 0 && { edits: reading.edits }
-  };
-}
-function readOrUndefined(code, program, options) {
-  try {
-    return readModule(code, program, options);
-  } catch (error) {
-    if (error instanceof RangeError) return void 0;
-    throw error;
-  }
-}
-async function recordParsed(context, ctx, input, key) {
-  const { code, id, pkg, program, declared } = input;
-  const { declaredSources, isDeclared, onlyVia } = await declaredReadingOf(context, ctx, declared, {
-    environment: ctx.environment?.name ?? "client",
-    module: { code, id, program }
-  });
-  const reading = readOrUndefined(code, program, {
-    cxSources: /* @__PURE__ */ new Set([CX_SOURCE, ...declaredSources]),
-    declaredSources,
-    isDeclared,
-    ownAtoms: await ownAtomNames(context, (file) => {
-      ctx.addWatchFile(file);
-    }),
-    isDependency: isDependencyId(id),
-    isVueScript: /\.vue(?:$|\?)/.test(id),
-    setup: await setupExposuresFor(context, ctx, { program, code, id }),
-    // A build turns each call into the string it returns; the dev server keeps the functions.
-    ...context.command === "build" && { rewrite: { keep: keepMap(context.kept) } }
-  });
-  if (!reading) {
-    context.state.exposures.delete(key);
-    return unreadableRecord(context, { code, id, pkg }, TOO_DEEP);
-  }
-  if (reading.exposes.size > 0) context.state.exposures.set(key, reading.exposes);
-  else context.state.exposures.delete(key);
-  if (pkg !== void 0 && reading.usesCx) context.state.packages.add(pkg);
-  const record = await recordOf(context, ctx, { code, id, pkg }, reading);
-  return onlyVia === void 0 ? record : { ...record, onlyVia };
-}
-async function recordModule(context, ctx, module) {
-  const { code, id, moduleType } = module;
-  const environment = ctx.environment?.name ?? "client";
-  const key = moduleKey(environment, id);
-  const declared = await declaredModulesFor(context, ctx, environment);
-  if (!isMentioningAtoms(code) && !isAboutListed({ code, id }, declared)) {
-    context.state.modules.delete(key);
-    return void 0;
-  }
-  const isDependency = isDependencyId(id);
-  const pkg = isDependency ? await packageNameOf(filePathOf(id), context.packageNames) : void 0;
-  if (moduleType !== void 0 && !SOURCE_TYPES.has(moduleType)) {
-    context.state.exposures.delete(key);
-    const record2 = textRecord(context, { code, id, moduleType, pkg });
-    context.state.modules.set(key, record2);
-    return record2;
-  }
-  const program = parseOrUndefined(ctx, code, moduleType);
-  const record = program ? await recordParsed(context, ctx, { code, id, pkg, program, declared }, key) : unreadableRecord(context, { code, id, pkg }, NOT_PARSED);
-  if (!program) context.state.exposures.delete(key);
-  context.state.modules.set(key, record);
-  return record;
-}
-
-// src/vite-collect-problems.ts
-function listedAtomsOf(record, context) {
-  if (record.pkg === void 0) return context.options.keep;
-  const { keepFor } = context.options;
-  return Object.hasOwn(keepFor, record.pkg) ? keepFor[record.pkg] : [];
-}
-function dynamicProblems(record, context) {
-  const isCovered = listedAtomsOf(record, context).length > 0;
-  if (isCovered) return [];
-  return record.dynamicCalls.map((call) => ({
-    kind: "dynamic",
-    offset: 0,
-    construct: call.construct,
-    text: "",
-    file: call.file,
-    line: call.line,
-    column: call.column,
-    pkg: record.pkg,
-    ...call.unknownLine !== void 0 && { unknownLine: call.unknownLine }
-  }));
-}
-function problemsOf(record, context) {
-  return [...record.problems, ...dynamicProblems(record, context)];
-}
-function failModule(ctx, context, input) {
-  const { home, id, problems } = input;
-  const message = moduleReport(problems, context.options.cxModules, home);
-  const first = problems[0];
-  return ctx.error({
-    message,
-    id,
-    loc: { file: id, line: Math.max(first.line, 1), column: Math.max(first.column - 1, 0) }
-  });
-}
-function failDevModule(ctx, context, input) {
-  const { home, id, record } = input;
-  if (context.command !== "serve" || record.pkg !== void 0) return;
-  const problems = problemsOf(record, context);
-  if (problems.length > 0) failModule(ctx, context, { home, id, problems });
-}
-
-// src/vite-cx-module-lines.ts
-function quoted(specifiers) {
-  return specifiers.map((specifier) => `'${specifier}'`).join(", ");
-}
-function applicationLinesOf(item) {
-  const entry = `'${item.entry}'`;
-  const relative = item.specifiers.filter((specifier) => isRelative(specifier));
-  const other = item.specifiers.filter((specifier) => !isRelative(specifier));
-  const place = relative.length === 1 ? "its" : "their";
-  return {
-    relative: relative.length === 0 ? [] : [
-      `${item.label}: imports ${entry} as ${quoted(relative)}. Write '${item.replacement}' in ${place} place.`
-    ],
-    other: other.length === 0 ? [] : [`${item.label}: imports ${entry} as ${quoted(other)}.`],
-    none: item.specifiers.length > 0 ? [] : [
-      `${item.label}: imports ${entry} through a specifier the build could not find in the file.`
-    ]
+    pkg,
+    file: moduleLabel(context.root, id)
   };
 }
-function dependencyLineOf(item) {
-  const entry = `'${item.entry}'`;
-  const found = item.specifiers.length === 0 ? `imports ${entry} through a specifier the build could not find in the file.` : `imports ${entry} as ${quoted(item.specifiers)}.`;
-  return `${item.label}: ${found} The file is in ${item.pkg}, a dependency, so it is not yours to change.`;
+
+// src/vite-css-module-record.ts
+function stringOf(node) {
+  return node?.type === "Literal" && typeof node.value === "string" ? node.value : void 0;
 }
-var RELATIVE_REMEDY = "Adding a relative specifier to cxModules would not clear this: a relative entry is read from the project root. Instead of the rewrite";
-var TYPESCRIPT_CONDITION = "Where a rewrite ends in .ts, .tsx, .mts or .cts, TypeScript accepts it only if your tsconfig sets allowImportingTsExtensions or rewriteRelativeImportExtensions; if it sets neither, use the alias the line above describes instead.";
-var NO_SPECIFIER_REMEDY = "Where the build could not find the specifier, import the module there by a specifier ending in the listed file's name, or by an alias or package name added to cxModules.";
-function applicationRemedyOf(items, lines, input) {
-  const remedy = [];
-  const relativeCount = lines.reduce((count, line) => count + line.relative.length, 0);
-  if (relativeCount === 1) {
-    remedy.push(
-      `${RELATIVE_REMEDY} its line gives, the file can import the module through an alias for it, added to cxModules.`
-    );
-  } else if (relativeCount > 1) {
-    remedy.push(
-      `${RELATIVE_REMEDY} each line gives, a file can import the module through an alias for it, added to cxModules.`
-    );
-  }
-  const hasTypeScriptRewrite = items.some(
-    (item) => item.specifiers.some((specifier) => isRelative(specifier)) && /\.(?:ts|tsx|mts|cts)$/.test(item.replacement)
+function namedStrings(declaration) {
+  return nodesAt(declaration, "declarations").map(
+    (declarator) => stringOf(nodeAt(declarator, "init")) ?? ""
   );
-  if (hasTypeScriptRewrite) remedy.push(TYPESCRIPT_CONDITION);
-  if (lines.some((line) => line.none.length > 0)) remedy.push(NO_SPECIFIER_REMEDY);
-  const added = [
-    ...new Set(
-      items.flatMap((item) => item.specifiers.filter((specifier) => !isRelative(specifier)))
-    )
-  ];
-  const array = cxModulesArray(input.configured, added);
-  if (array !== void 0) {
-    const each = added.length === 1 ? "the specifier" : "each specifier";
-    remedy.push(`Add ${each}, as written, to cxModules in ${input.home}: cxModules: ${array}.`);
-  }
-  return remedy;
 }
-var LASTING_FIX_HERE = "The lasting fix there is the package's: import the module by a specifier ending in the listed file's name.";
-function packageRemedyOf(pkg, files, input) {
-  if (input.hasKeepFor) {
-    const file = files === 1 ? "a file" : "files";
-    return `${pkg} also imports a module listed in cxModules in ${file} the build did not read; the keepFor entry above clears that too. ${LASTING_FIX_HERE}`;
-  }
-  return `For ${pkg}, list the atoms its calls can produce, from its documentation, under its name in ${input.home}: keepFor: { '${pkg}': ['<atom>'] }. Once the package is listed, its files no longer fail the build here, and the atoms you list stand in for the calls the build did not read. The lasting fix is the package's: import the module by a specifier ending in the listed file's name.`;
+function defaultStrings(declaration) {
+  return nodesAt(declaration, "properties").map(
+    (property) => stringOf(nodeAt(property, "value")) ?? ""
+  );
 }
-function importerErrorOf(found, input) {
-  const application = found.filter((item) => item.pkg === void 0);
-  const dependencies = found.filter((item) => item.pkg !== void 0);
-  const count = new Set(found.map((item) => item.importer)).size;
-  const first = count === 1 ? "1 file imports a module listed in cxModules through a specifier the build does not recognise, so the build did not read the cx() calls made through it." : `${count} files import a module listed in cxModules through a specifier the build does not recognise, so the build did not read the cx() calls made through those specifiers.`;
-  const lines = application.map((item) => applicationLinesOf(item));
-  const byPackage = Map.groupBy(dependencies, (item) => item.pkg);
-  const packages = byPackage.keys().toArray().toSorted(compareText);
-  return [
-    first,
-    ...lines.flatMap((line) => [...line.relative, ...line.other, ...line.none]).toSorted(compareText),
-    ...dependencies.map((item) => dependencyLineOf(item)).toSorted(compareText),
-    ...applicationRemedyOf(application, lines, input),
-    ...packages.map(
-      (pkg) => packageRemedyOf(pkg, new Set(byPackage.get(pkg).map((item) => item.importer)).size, {
-        hasKeepFor: input.report?.includes(`keepFor: { '${pkg}'`) ?? false,
-        home: input.home
-      })
-    )
-  ].join("\n");
+function exportedStrings(program) {
+  const strings = nodesAt(program, "body").flatMap((statement) => {
+    const declaration = nodeAt(statement, "declaration");
+    if (declaration === void 0) return [];
+    if (statement.type === "ExportNamedDeclaration" && declaration.type === "VariableDeclaration") {
+      return namedStrings(declaration);
+    }
+    if (statement.type === "ExportDefaultDeclaration" && declaration.type === "ObjectExpression") {
+      return defaultStrings(declaration);
+    }
+    return [];
+  });
+  return strings.filter((text) => text !== "");
 }
-async function isResolvingTo(ctx, input) {
+function cssModuleRecord(context, ctx, input) {
+  const { code, id, pkg } = input;
+  let program;
   try {
-    const resolved = await ctx.resolve?.(input.specifier, input.from);
-    return resolved !== null && resolved !== void 0 && fileOf(resolved.id) === input.file;
+    program = ctx.parse(code);
   } 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);
+    const unreadable = unreadableRecord(context, { code: "", id, pkg }, CLASS_MAP_NOT_PARSED);
+    return {
+      ...unreadable,
+      problems: [...unreadable.problems, ...unreadable.suppressed],
+      suppressed: []
+    };
   }
-  return found.values().toArray().toSorted(compareText);
+  const strings = isNode(program) ? exportedStrings(program) : [];
+  return textRecord(context, { code: strings.join("\n"), id, pkg });
 }
-async function clearingSpecifier(ctx, context, input) {
-  const from = path2.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;
-  }
+function recordWithoutCalls(context, ctx, module) {
+  if (isCssModuleId(module.id)) return cssModuleRecord(context, ctx, module);
+  const { moduleType } = module;
+  if (moduleType !== void 0 && !SOURCE_TYPES.has(moduleType)) return textRecord(context, module);
   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([
-  ".js",
-  ".json",
-  ".jsx",
-  ".mjs",
-  ".mts",
-  ".ts",
-  ".tsx"
-]);
-function entryOf(declared, id) {
-  const file = fileOf(id);
-  for (const [entry, resolved] of declared.ids) if (fileOf(resolved) === file) return entry;
-  return id;
-}
-async function replacementFor(ctx, input) {
-  const file = fileOf(input.id);
-  const extension = path2.posix.extname(file);
-  const relativeTo = (target) => {
-    const relative = path2.posix.relative(path2.posix.dirname(fileOf(input.importer)), target);
-    return relative.startsWith("../") ? relative : `./${relative}`;
-  };
-  if (!RESOLVED_EXTENSIONS.has(extension)) return relativeTo(file);
-  const short = relativeTo(file.slice(0, -extension.length));
-  const isLanding = await isResolvingTo(ctx, { file, from: input.importer, specifier: short });
-  return isLanding ? short : relativeTo(file);
-}
-async function unrecognisedSpecifiers(ctx, input) {
-  const { answers, id, importer, recognised } = input;
-  const known = { cxId: id, answers };
-  const found = [];
-  const unread = (specifiersOf(ctx, importer) ?? []).filter((text) => !recognised?.has(text));
-  for (const specifier of unread) {
-    if (await isResolvingToCx(ctx, specifier, importer, known)) found.push(specifier);
+// src/vite-cx-reading.ts
+async function declaredReadingOf(context, resolver, declared, input) {
+  const { environment, module } = input;
+  const declaredSources = /* @__PURE__ */ new Set();
+  if (!declared) return { declaredSources, isDeclared: false, onlyVia: void 0 };
+  const files = /* @__PURE__ */ new Set();
+  let isOnlyListed = true;
+  for (const source of specifiersIn(module.program)) {
+    if (source === CX_SOURCE) {
+      isOnlyListed = false;
+      continue;
+    }
+    const found = await listedFileOf(resolver, declared, source, module.id);
+    if (!found) continue;
+    declaredSources.add(source);
+    if (found.file === void 0) {
+      isOnlyListed = false;
+      continue;
+    }
+    files.add(found.file);
+    const key = recognisedKey(environment, found.file, module.id);
+    context.state.recognised.set(
+      key,
+      /* @__PURE__ */ new Set([...context.state.recognised.get(key) ?? [], source])
+    );
   }
-  return found;
-}
-async function unrecognisedOf(ctx, context, input) {
-  const { answers, declared, id } = input;
-  const importer = await candidateOf(ctx, context, input.importer);
-  if (!importer) return void 0;
-  const recognised = context.state.recognised.get(
-    recognisedKey(ctx.environment.name, fileOf(id), importer.id)
-  );
-  const specifiers = await unrecognisedSpecifiers(ctx, { answers, id, importer, recognised });
-  if (recognised !== void 0 && specifiers.length === 0) return void 0;
-  const pkg = isDependencyId(importer.id) ? await packageNameOf(filePathOf(importer.id), context.packageNames) : void 0;
   return {
-    importer: importer.id,
-    label: moduleLabel(context.root, importer.id),
-    entry: entryOf(declared, id),
-    specifiers,
-    replacement: pkg === void 0 ? await replacementFor(ctx, { id, importer: importer.id }) : "",
-    pkg
+    declaredSources,
+    isDeclared: isListedFile(declared, module.id),
+    onlyVia: isOnlyListed && files.size > 0 ? files : void 0
   };
 }
-function listedIdsIn(ctx, declared) {
-  const ids = new Set(declared.ids.values());
-  const graph = ctx.getModuleIds?.() ?? [];
-  for (const id of graph) {
-    if (declared.files.has(fileOf(id))) ids.add(id);
+async function listedFileFrom(resolver, declared, source, importer) {
+  const resolved = await resolveOrNull(resolver, source, importer);
+  const file = resolved ? fileOf(resolved.id) : void 0;
+  return file !== void 0 && declared.files.has(file) ? file : void 0;
+}
+async function listedFileOf(resolver, declared, source, importer) {
+  if (declared.entries.has(source)) {
+    const id = source.startsWith("#") ? void 0 : declared.ids.get(source);
+    if (id !== void 0) return { file: fileOf(id) };
+    const file2 = await listedFileFrom(resolver, declared, source, importer);
+    return file2 === void 0 && source.startsWith("#") ? void 0 : { file: file2 };
   }
-  return ids;
+  if (!isNamingListed(source, declared)) return void 0;
+  const file = await listedFileFrom(resolver, declared, source, importer);
+  return file === void 0 ? void 0 : { file };
 }
-function merged(found, item, id) {
-  const key = `${item.importer}\0${fileOf(id)}`;
-  const specifiers = /* @__PURE__ */ new Set([...found.get(key)?.specifiers ?? [], ...item.specifiers]);
-  return [key, { ...item, specifiers: [...specifiers] }];
+
+// src/vite-dev-keep.ts
+var KEEP_CONSTANT = "__NAVE_KEEP_CLASSES__";
+function keepMap(kept) {
+  return Object.fromEntries(
+    kept.filter((atom) => Object.hasOwn(atomClassMap, atom)).map((atom) => [atom, atomClassMap[atom]])
+  );
 }
-async function unrecognisedImporters(ctx, context, declared) {
-  const found = /* @__PURE__ */ new Map();
-  for (const id of listedIdsIn(ctx, declared)) {
-    const answers = /* @__PURE__ */ new Map();
-    for (const importer of importerIdsOf(ctx, id)) {
-      const item = await unrecognisedOf(ctx, context, { answers, declared, id, importer });
-      if (item) found.set(...merged(found, item, id));
+function devKeepMap(map, atoms) {
+  return new Proxy(map, {
+    getOwnPropertyDescriptor(target, key) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+      if (descriptor === void 0 && typeof key === "string") {
+        const quoted2 = JSON.stringify(key);
+        console.error(
+          atoms.includes(key) ? `[nave] cx.dynamic(${quoted2}) applied no class: ${quoted2} is not in keep or in a keepFor list, and navePlugin() gives cx.dynamic() only the atoms in those lists, in a build as in dev. Add ${quoted2} to keep in navePlugin(), or, when a dependency makes the call, to its list in keepFor.` : `[nave] cx.dynamic(${quoted2}) applied no class: ${quoted2} is not a Nave atom.`
+        );
+      }
+      return descriptor;
     }
-  }
-  return found.values().toArray();
+  });
 }
-async function declaredImporterError(ctx, context, input) {
-  const declared = await declaredModulesFor(context, ctx, ctx.environment.name);
-  if (!declared) return void 0;
-  const found = await unrecognisedImporters(ctx, context, declared);
-  return found.length === 0 ? void 0 : importerErrorOf(found, input);
+function devKeepExpression(map, atoms) {
+  return `(${devKeepMap.toString()})(${JSON.stringify(map)}, ${JSON.stringify(atoms)})`;
 }
-
-// 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
-  );
+var installs = [];
+var baseline = { held: false, value: void 0 };
+function publish() {
+  const newest = installs.at(-1);
+  if (newest !== void 0) Object.assign(globalThis, { [KEEP_CONSTANT]: newest.map });
+  else if (baseline.held) Object.assign(globalThis, { [KEEP_CONSTANT]: baseline.value });
+  else Reflect.deleteProperty(globalThis, KEEP_CONSTANT);
+}
+function installServerKeepMap(context, owner) {
+  if (context.options.atomic !== "used") return;
+  const map = devKeepMap(keepMap(context.kept), Object.keys(atomClassMap));
+  if (installs.length === 0) {
+    baseline.held = Object.hasOwn(globalThis, KEEP_CONSTANT);
+    baseline.value = globalThis[KEEP_CONSTANT];
+  }
+  installs.push({ owner, map });
+  publish();
+}
+function removeServerKeepMap(owner) {
+  const index = installs.findIndex((install) => install.owner === owner);
+  if (index === -1) return;
+  installs.splice(index, 1);
+  publish();
 }
 
-// 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) {
-  const { state } = context;
-  return context.options.keep.length === 0 && collectedAtoms(state, []).size === 0 && !state.directiveExpanded && !state.htmlRead && !state.serverTransformed && !context.isLibrary;
+// src/vite-serialised-css.ts
+var IDENTIFIER = /^[\w-]+/;
+var SELECTOR_REST = /^(?:[^{};'"`\\]|\\[nrt])*\{/;
+function isSerialisedStylesheet(code) {
+  let mentions = 0;
+  for (let at = code.indexOf("nave-"); at !== -1; at = code.indexOf("nave-", at + 5)) {
+    const before = code[at - 1];
+    if (before !== void 0 && /[\w-]/.test(before)) continue;
+    const name = IDENTIFIER.exec(code.slice(at, at + 64))?.[0];
+    if (name === void 0 || atomOfClass(name) === void 0) continue;
+    mentions += 1;
+    if (before !== "." || !SELECTOR_REST.test(code.slice(at + name.length, at + name.length + 600)))
+      return false;
+  }
+  return mentions > 0;
 }
-function judgeMarkup(context, warn) {
-  const { state } = context;
-  if (!isUsed(context) || state.markupJudged) return;
-  state.markupJudged = true;
-  if (isMarkupCase(context)) warn(MARKUP_WARNING);
+
+// src/vite-setup-link.ts
+function importsContaining(program, marker) {
+  const sources = nodesAt(program, "body").map(
+    (node) => node.type === "ImportDeclaration" ? staticStringOf(nodeAt(node, "source")) : void 0
+  );
+  return sources.filter((source) => source?.includes(marker) === true);
 }
-function expectBuilds(context, builder, warn) {
-  if (Object.values(builder.environments).some((environment) => environment.isBuilt)) {
-    judgeMarkup(context, warn);
-    return;
+async function resolveId(ctx, source, importer) {
+  const resolved = await ctx.resolve?.(source, importer);
+  return resolved?.id;
+}
+async function linkTemplates(context, ctx, input, scriptId) {
+  const environment = ctx.environment?.name ?? "client";
+  for (const template of importsContaining(input.program, "type=template")) {
+    const templateId = await resolveId(ctx, template, input.id);
+    if (templateId !== void 0) {
+      context.state.templateLinks.set(moduleKey(environment, templateId), scriptId);
+    }
   }
-  context.state.expectedEnvironments = new Set(Object.keys(builder.environments));
 }
-function judgeAfterLastEnvironment(context, environment, warn) {
-  const { builtEnvironments, expectedEnvironments } = context.state;
-  builtEnvironments.add(environment.name);
-  const isLast = expectedEnvironments ? [...expectedEnvironments].every((name) => builtEnvironments.has(name)) : !context.inProcess && environment.config.consumer === "client";
-  if (isLast) judgeMarkup(context, warn);
+async function setupExposuresFor(context, ctx, input) {
+  const environment = ctx.environment?.name ?? "client";
+  const [script] = importsContaining(input.program, "type=script");
+  const scriptId = script === void 0 ? void 0 : await resolveId(ctx, script, input.id);
+  await linkTemplates(context, ctx, input, scriptId ?? input.id);
+  if (!input.code.includes("$setup")) return void 0;
+  const owner = scriptId ?? context.state.templateLinks.get(moduleKey(environment, input.id));
+  if (owner === void 0) return void 0;
+  await ctx.load?.({ id: owner });
+  return context.state.exposures.get(moduleKey(environment, owner));
 }
 
-// src/vite-dev-judge.ts
-function isServedAsStylesheet(id) {
-  return isStylesheetId(id) && !/[?&]inline\b/.test(id);
+// src/vite-used.ts
+function createUsedContext(options, extend) {
+  return {
+    options,
+    extend,
+    kept: keptAtoms(options),
+    packageNames: /* @__PURE__ */ new Map(),
+    root: process.cwd(),
+    command: "build",
+    cacheDir: "",
+    buildSourcemap: false,
+    inProcess: false,
+    isLibrary: false,
+    logger: void 0,
+    state: stateFor("", {})
+  };
 }
-function judge(context) {
-  judgeMarkup(context, (message) => context.logger?.warn(message));
+function configureUsed(context, config) {
+  context.root = config.root;
+  context.command = config.command;
+  context.cacheDir = config.cacheDir ?? "";
+  context.buildSourcemap = Boolean(config.build?.sourcemap);
+  context.inProcess = config.builder !== void 0;
+  context.isLibrary = Boolean(config.build?.lib);
+  context.logger = config.logger;
+  context.state = stateFor(config.root, config);
 }
-function judgeWhenServed(context, id) {
-  const { state } = context;
-  if (!state.warmedUp || state.requested.has(filePathOf(id))) judge(context);
+function isUsed(context) {
+  return context.options.atomic === "used";
 }
-function stylesheetUrl(request, base) {
-  const url = request.url;
-  if (url === void 0 || !isServedAsStylesheet(url)) return void 0;
-  return base !== "/" && url.startsWith(base) ? `/${url.slice(base.length)}` : url;
+function ignoreWatch() {
 }
-async function noteRequest(context, environment, url) {
-  const { state } = context;
+async function ownAtomNames(context, watch = ignoreWatch) {
   try {
-    const resolved = await environment.pluginContainer.resolveId(decodeURI(url));
-    if (resolved === null) return;
-    const file = filePathOf(resolved.id);
-    state.requested.add(file);
-    if (state.served.keys().some((id) => filePathOf(id) === file)) judge(context);
+    const atoms = await context.extend.current(watch);
+    return new Set(Object.keys(atoms).filter((name) => atoms[name]));
   } catch {
+    return /* @__PURE__ */ new Set();
   }
 }
-function noteStylesheetRequests(context, server) {
-  const { state } = context;
-  const environment = server.environments.client;
-  state.warmedUp = environment.config.dev.warmup.length > 0;
-  if (!state.warmedUp) return;
-  server.middlewares.use(async (request, _response, next) => {
-    const url = stylesheetUrl(request, server.config.base);
-    if (url !== void 0 && !state.markupJudged) await noteRequest(context, environment, url);
-    next();
-  });
-}
 
-// src/vite-dev-read.ts
-function graphRoots(environment) {
-  return environment.moduleGraph.idToModuleMap.values().filter(
-    (module) => module.importers.size === 0 && (module.id === null || !isStylesheetId(module.id))
-  ).toArray();
+// src/vite-collect-module.ts
+var ESCAPED_SPECIFIER = /(?:\bfrom|\bimport)[\s(]*(?:'[^'\\\n]*\\|"[^"\\\n]*\\|`[^`\\\n]*\\)/;
+function isMentioningAtoms(code) {
+  if (code.includes(CX_SOURCE) || ESCAPED_SPECIFIER.test(code)) return true;
+  if (isSerialisedStylesheet(code)) return false;
+  return ["nave-", "&#", "$setup", "vue&type="].some((mention) => code.includes(mention));
 }
-async function transformQuietly(environment, url) {
-  try {
-    await environment.transformRequest(url);
-  } catch {
-  }
+var NO_PLACE = { line: 0, column: 0 };
+function isInlineScript(id) {
+  return /[?&]html-proxy\b/.test(id);
 }
-async function transformReachable(environment, roots) {
-  const seen = new Set(roots);
-  let level = [...roots];
-  while (level.length > 0) {
-    const next = [];
-    await Promise.all(
-      level.map(async (module) => {
-        if (module.id !== null && isStylesheetId(module.id)) return;
-        await transformQuietly(environment, module.url);
-        for (const imported of module.importedModules) {
-          if (seen.has(imported)) continue;
-          seen.add(imported);
-          next.push(imported);
-        }
-      })
-    );
-    level = next;
-  }
+function lineUnknownNote(context, id) {
+  const isBuildWithoutMaps = context.command === "build" && !context.buildSourcemap;
+  return isBuildWithoutMaps && !isInlineScript(id) ? LINE_UNKNOWN_WITHOUT_MAP : LINE_UNKNOWN_UNMAPPED;
 }
-
-// src/vite-dev-update.ts
-function readerOf(environment) {
-  return {
-    transformRequest: (url) => environment.transformRequest?.(url) ?? Promise.resolve()
-  };
+function locate2(problems, placing) {
+  return problems.map((problem) => {
+    const place = placing.place(problem.offset);
+    const where = place ?? { ...NO_PLACE, unknownLine: placing.unknownLine };
+    return { ...problem, file: placing.file, pkg: placing.pkg, moduleId: placing.id, ...where };
+  });
 }
-async function readAhead(context, environment, scripts) {
-  const { state } = context;
-  const reader = readerOf(environment);
-  state.readAhead += 1;
+function locateDynamic(reading, placing) {
+  return reading.dynamicCalls.map(({ offset, construct }) => {
+    const place = placing.place(offset);
+    return {
+      file: placing.file,
+      construct,
+      ...place ?? { ...NO_PLACE, unknownLine: placing.unknownLine }
+    };
+  });
+}
+var COMPILED_LANGS = /* @__PURE__ */ new Map([
+  ["jsx", "jsx"],
+  ["ts", "ts"],
+  ["tsx", "tsx"]
+]);
+function parseOrUndefined(ctx, code, moduleType) {
   try {
-    for (const module of scripts) {
-      const known = new Set(module.importedModules);
-      environment.moduleGraph.invalidateModule(module);
-      await transformQuietly(reader, module.url);
-      const added = [...module.importedModules.difference(known)];
-      await transformReachable(reader, added);
-    }
-  } finally {
-    state.readAhead -= 1;
+    const lang = moduleType === void 0 ? void 0 : COMPILED_LANGS.get(moduleType);
+    return ctx.parse(code, lang && { lang });
+  } catch {
+    return void 0;
   }
 }
-function takeStaleModules(context, environment) {
-  const { state } = context;
-  const ids = [...state.stale];
-  state.stale.clear();
-  clearTimeout(state.reloadTimer);
-  state.reloadTimer = void 0;
-  const sheets = [];
-  for (const id of ids) {
-    const module = environment.moduleGraph.getModuleById(id);
-    if (!module) continue;
-    noteReloadSent(state, id);
-    sheets.push(module);
+async function authoredTextOf(id) {
+  try {
+    return await readFile(filePathOf(id), "utf8");
+  } catch {
+    return void 0;
   }
-  return sheets;
-}
-async function modulesWithGrownStylesheets(context, ctx, hot) {
-  const { environment } = ctx;
-  if (environment.config?.consumer !== "client" || context.state.served.size === 0) return;
-  const scripts = (hot.modules ?? []).filter((m) => m.id !== null && !isStylesheetId(m.id));
-  if (scripts.length === 0) return;
-  await readAhead(context, environment, scripts);
-  const sheets = takeStaleModules(context, environment);
-  return sheets.length === 0 ? void 0 : [...hot.modules ?? [], ...sheets];
 }
-
-// src/vite-css-blocks.ts
-function matchBraces(tokens) {
-  const matches = /* @__PURE__ */ new Map();
-  const open = [];
-  for (const [index, token] of tokens.entries()) {
-    if (token.type === "{-token") open.push(index);
-    else if (token.type === "}-token" && open.length > 0) matches.set(open.pop(), index);
-  }
-  return matches;
-}
-function isBlank(tokens, from, to) {
-  for (let index = from; index < to; index += 1) {
-    const type = tokens[index].type;
-    if (type !== "whitespace-token" && type !== "comment") return false;
-  }
-  return true;
-}
-var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token"]);
-var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token"]);
-function readSheet(css) {
-  const tokens = tokenize(css);
-  const matches = matchBraces(tokens);
+async function recordOf(context, ctx, input, reading) {
+  const { code, id, pkg } = input;
+  const hasPlaces = reading.problems.length + reading.dynamicCalls.length > 0;
+  const map = hasPlaces ? combinedMapOf(ctx) : void 0;
+  const authored = map ? await authoredTextOf(id) : void 0;
+  const placing = {
+    code,
+    id,
+    file: moduleLabel(context.root, id),
+    pkg,
+    place: placerFor(code, map, authored),
+    unknownLine: lineUnknownNote(context, id)
+  };
+  const isStandingIn = isListed(context, pkg);
   return {
-    tokens,
-    slice: (from, to) => css.slice(tokens[from]?.startIndex ?? css.length, tokens[to - 1]?.endIndex ?? 0),
-    statements(from, to) {
-      const found = [];
-      let start = from;
-      let index = from;
-      let depth = 0;
-      while (index < to) {
-        const type = tokens[index].type;
-        if (OPENERS.has(type)) depth += 1;
-        else if (CLOSERS.has(type)) depth = Math.max(0, depth - 1);
-        const close = type === "{-token" && depth === 0 ? matches.get(index) : void 0;
-        if (close !== void 0 && close < to) {
-          found.push({ from: start, to: close + 1, open: index, close });
-          index = close + 1;
-          start = index;
-        } else if (type === "semicolon-token") {
-          found.push({ from: start, to: index + 1 });
-          index += 1;
-          start = index;
-        } else {
-          index += 1;
-        }
-      }
-      if (!isBlank(tokens, start, to)) found.push({ from: start, to });
-      return found;
-    }
+    atoms: /* @__PURE__ */ new Set([...reading.atoms, ...reading.classes]),
+    problems: isStandingIn ? [] : locate2(reading.problems, placing),
+    suppressed: isStandingIn ? locate2(reading.problems, placing) : [],
+    dynamicCalls: locateDynamic(reading, placing),
+    pkg,
+    file: placing.file,
+    ...reading.edits.length > 0 && { edits: reading.edits }
   };
 }
-function firstSignificant(tokens, from, to) {
-  let index = from;
-  while (index < to && isBlank(tokens, index, index + 1)) index += 1;
-  return index;
-}
-
-// src/vite-selector-atoms.ts
-var OPENERS2 = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token"]);
-var CLOSERS2 = /* @__PURE__ */ new Set([")-token", "]-token"]);
-function membersOf(sheet, from, to) {
-  const members = [];
-  let start = from;
-  let depth = 0;
-  for (let index = from; index < to; index += 1) {
-    const type = sheet.tokens[index].type;
-    if (OPENERS2.has(type)) depth += 1;
-    else if (CLOSERS2.has(type)) depth -= 1;
-    else if (type === "comma-token" && depth === 0) {
-      members.push([start, index]);
-      start = index + 1;
-    }
-  }
-  members.push([start, to]);
-  return members;
-}
-var closings = /* @__PURE__ */ new WeakMap();
-function closesOf(sheet) {
-  const known = closings.get(sheet);
-  if (known) return known;
-  const closes = /* @__PURE__ */ new Map();
-  const open = [];
-  for (const [index, token] of sheet.tokens.entries()) {
-    if (OPENERS2.has(token.type)) open.push(index);
-    else if (CLOSERS2.has(token.type) && open.length > 0) closes.set(open.pop(), index);
-  }
-  closings.set(sheet, closes);
-  return closes;
-}
-function afterGroup(sheet, index, to) {
-  return Math.min((closesOf(sheet).get(index) ?? to - 1) + 1, to);
-}
-function isTransparentList(sheet, index) {
-  const token = sheet.tokens[index];
-  if (token.type !== "function-token" || sheet.tokens[index - 1]?.type !== "colon-token") {
-    return false;
-  }
-  const name = token.structured.value.toLowerCase();
-  return name === "is" || name === "where";
-}
-function atomAt(sheet, index, to) {
-  const name = sheet.tokens[index + 1];
-  if (index + 1 >= to || name?.type !== "ident-token") return void 0;
-  const dot = sheet.tokens[index];
-  if (dot.type !== "delim-token" || dot.raw !== ".") return void 0;
-  return atomOfClass(name.structured.value);
-}
-function atomsNamedBy(sheet, from, to) {
-  const atoms = [];
-  let index = from;
-  while (index < to) {
-    const isGroup = OPENERS2.has(sheet.tokens[index].type);
-    if (isGroup && !isTransparentList(sheet, index)) {
-      index = afterGroup(sheet, index, to);
-      continue;
-    }
-    const atom = isGroup ? void 0 : atomAt(sheet, index, to);
-    if (atom) atoms.push(atom);
-    index += 1;
+function readOrUndefined(code, program, options) {
+  try {
+    return readModule(code, program, options);
+  } catch (error) {
+    if (error instanceof RangeError) return void 0;
+    throw error;
   }
-  return atoms;
 }
-var newNeeds = () => ({ parts: [], size: 0 });
-var newList = () => ({ finished: [], current: newNeeds() });
-function closeList(done, parent) {
-  const all = [...done.finished, done.current];
-  if (all.some((needs) => needs.size === 0)) return;
-  for (const needs of all) {
-    parent.current.parts.push(needs.parts);
-    parent.current.size += needs.size;
+async function recordParsed(context, ctx, input, key) {
+  const { code, id, pkg, program, declared } = input;
+  const { declaredSources, isDeclared, onlyVia } = await declaredReadingOf(context, ctx, declared, {
+    environment: ctx.environment?.name ?? "client",
+    module: { code, id, program }
+  });
+  const reading = readOrUndefined(code, program, {
+    cxSources: /* @__PURE__ */ new Set([CX_SOURCE, ...declaredSources]),
+    declaredSources,
+    isDeclared,
+    ownAtoms: await ownAtomNames(context, (file) => {
+      ctx.addWatchFile(file);
+    }),
+    isDependency: isDependencyId(id),
+    isVueScript: /\.vue(?:$|\?)/.test(id),
+    setup: await setupExposuresFor(context, ctx, { program, code, id }),
+    // A build turns each call into the string it returns; the dev server keeps the functions.
+    ...context.command === "build" && { rewrite: { keep: keepMap(context.kept) } }
+  });
+  if (!reading) {
+    context.state.exposures.delete(key);
+    return unreadableRecord(context, { code, id, pkg }, TOO_DEEP);
   }
+  if (reading.exposes.size > 0) context.state.exposures.set(key, reading.exposes);
+  else context.state.exposures.delete(key);
+  if (pkg !== void 0 && reading.usesCx) context.state.packages.add(pkg);
+  const record = await recordOf(context, ctx, { code, id, pkg }, reading);
+  return onlyVia === void 0 ? record : { ...record, onlyVia };
 }
-function flatten(parts) {
-  const atoms = [];
-  const stack = [parts];
-  while (stack.length > 0) {
-    const part = stack.pop();
-    if (typeof part === "string") atoms.push(part);
-    else for (let index = part.length - 1; index >= 0; index -= 1) stack.push(part[index]);
+async function recordModule(context, ctx, module) {
+  const { code, id, moduleType } = module;
+  const environment = ctx.environment?.name ?? "client";
+  const key = moduleKey(environment, id);
+  const declared = await declaredModulesFor(context, ctx, environment);
+  if (!isMentioningAtoms(code) && !isAboutListed({ code, id }, declared)) {
+    context.state.modules.delete(key);
+    return void 0;
   }
-  return atoms;
-}
-function readToken(sheet, index, limit, lists) {
-  const type = sheet.tokens[index].type;
-  const list = lists.at(-1);
-  const isNested = lists.length > 1;
-  if (OPENERS2.has(type)) {
-    if (!isTransparentList(sheet, index)) return afterGroup(sheet, index, limit.to);
-    lists.push(newList());
-  } else if (isNested && type === ")-token") {
-    closeList(lists.pop(), lists.at(-1));
-  } else if (isNested && type === "comma-token") {
-    list.finished.push(list.current);
-    list.current = newNeeds();
-  } else {
-    const atom = atomAt(sheet, index, limit.to);
-    if (atom && !limit.emitted.has(atom)) {
-      list.current.parts.push(atom);
-      list.current.size += 1;
-    }
+  const isDependency = isDependencyId(id);
+  const pkg = isDependency ? await packageNameOf(filePathOf(id), context.packageNames) : void 0;
+  const unparsed = recordWithoutCalls(context, ctx, { code, id, moduleType, pkg });
+  if (unparsed) {
+    context.state.exposures.delete(key);
+    context.state.modules.set(key, unparsed);
+    return unparsed;
   }
-  return index + 1;
-}
-function blockersOf(sheet, from, to, emitted) {
-  const lists = [newList()];
-  let index = from;
-  while (index < to) index = readToken(sheet, index, { emitted, to }, lists);
-  while (lists.length > 1) closeList(lists.pop(), lists.at(-1));
-  return flatten(lists[0].current.parts);
+  const program = parseOrUndefined(ctx, code, moduleType);
+  const record = program ? await recordParsed(context, ctx, { code, id, pkg, program, declared }, key) : unreadableRecord(context, { code, id, pkg }, NOT_PARSED);
+  if (!program) context.state.exposures.delete(key);
+  context.state.modules.set(key, record);
+  return record;
 }
 
-// src/vite-prune.ts
-var GROUPS = /* @__PURE__ */ new Set([
-  "container",
-  "document",
-  "layer",
-  "media",
-  "scope",
-  "starting-style",
-  "supports"
-]);
-function atKeywordAt(sheet, index) {
-  const token = sheet.tokens[index];
-  if (token?.type !== "at-keyword-token") return void 0;
-  return token.structured.value.toLowerCase();
-}
-function isAtomicLayer(sheet, statement) {
-  if (statement.open === void 0) return false;
-  const significant = [];
-  for (let index = statement.from; index < statement.open; index += 1) {
-    const type = sheet.tokens[index].type;
-    if (type !== "whitespace-token" && type !== "comment") significant.push(index);
-  }
-  const name = sheet.tokens[significant[1] ?? -1];
-  return significant.length === 2 && atKeywordAt(sheet, significant[0]) === "layer" && name?.type === "ident-token" && name.structured.value === "atomic";
-}
-var CONDITIONALS = /* @__PURE__ */ new Set(["container", "document", "media", "scope", "supports"]);
-function layerBlocks(sheet, from, to) {
-  const found = [];
-  for (const statement of sheet.statements(from, to)) {
-    const { open, close } = statement;
-    if (open === void 0 || close === void 0) continue;
-    if (isAtomicLayer(sheet, statement)) found.push(statement);
-    else {
-      const keyword = atKeywordAt(sheet, firstSignificant(sheet.tokens, statement.from, open));
-      if (keyword !== void 0 && CONDITIONALS.has(keyword)) {
-        found.push(...layerBlocks(sheet, open + 1, close));
-      }
-    }
-  }
-  return found;
+// src/vite-collect-problems.ts
+function listedAtomsOf(record, context) {
+  if (record.pkg === void 0) return context.options.keep;
+  const { keepFor } = context.options;
+  return Object.hasOwn(keepFor, record.pkg) ? keepFor[record.pkg] : [];
 }
-function isEmptyRegion(sheet, from, to) {
-  return sheet.statements(from, to).length === 0;
-}
-function pruneRule(sheet, statement, emitted) {
-  const { from, open, close } = statement;
-  const first = firstSignificant(sheet.tokens, from, open);
-  const members = membersOf(sheet, first, open);
-  const kept = members.filter(([start, end]) => blockersOf(sheet, start, end, emitted).length === 0);
-  if (kept.length === members.length) return sheet.slice(from, close + 1);
-  if (kept.length === 0) return "";
-  let trailing = open;
-  while (trailing > first && firstSignificant(sheet.tokens, trailing - 1, trailing) === trailing) {
-    trailing -= 1;
-  }
-  const list = sheet.slice(first, trailing);
-  const separator = /,\s/.test(list) ? ", " : ",";
-  const text = kept.map(([start, end]) => sheet.slice(start, end).trim()).join(separator);
-  return `${sheet.slice(from, first)}${text}${sheet.slice(trailing, open)}${sheet.slice(open, close + 1)}`;
-}
-function pruneRegion(sheet, from, to, emitted) {
-  const statements = sheet.statements(from, to);
-  let out = "";
-  for (const statement of statements) out += pruneStatement(sheet, statement, emitted);
-  const last = statements.at(-1);
-  return last ? out + sheet.slice(last.to, to) : sheet.slice(from, to);
-}
-function pruneStatement(sheet, statement, emitted) {
-  const { open, close } = statement;
-  if (open === void 0 || close === void 0) return sheet.slice(statement.from, statement.to);
-  const first = firstSignificant(sheet.tokens, statement.from, open);
-  const keyword = atKeywordAt(sheet, first);
-  if (keyword === void 0) return pruneRule(sheet, statement, emitted);
-  if (!GROUPS.has(keyword)) return sheet.slice(statement.from, close + 1);
-  if (isEmptyRegion(sheet, open + 1, close)) return sheet.slice(statement.from, close + 1);
-  const inner = pruneRegion(sheet, open + 1, close, emitted);
-  if (inner.trim() === "") return "";
-  return `${sheet.slice(statement.from, open + 1)}${inner}}`;
-}
-function pruneAtomicLayer(css, emitted) {
-  if (!css.includes("@")) return css;
-  const sheet = readSheet(css);
-  let out = "";
-  let cursor = 0;
-  for (const statement of layerBlocks(sheet, 0, sheet.tokens.length)) {
-    const { open, close } = statement;
-    out += sheet.slice(cursor, open + 1) + pruneRegion(sheet, open + 1, close, emitted);
-    cursor = close;
-  }
-  return cursor === 0 ? css : out + sheet.slice(cursor, sheet.tokens.length);
-}
-function visitMembers(sheet, from, to, visit) {
-  for (const statement of sheet.statements(from, to)) {
-    const { open, close } = statement;
-    if (open === void 0 || close === void 0) continue;
-    const first = firstSignificant(sheet.tokens, statement.from, open);
-    const keyword = atKeywordAt(sheet, first);
-    if (keyword === void 0) {
-      for (const [start, end] of membersOf(sheet, first, open)) visit(start, end);
-    } else if (GROUPS.has(keyword)) {
-      visitMembers(sheet, open + 1, close, visit);
-    }
-  }
+function dynamicProblems(record, context) {
+  const isCovered = listedAtomsOf(record, context).length > 0;
+  if (isCovered) return [];
+  return record.dynamicCalls.map((call) => ({
+    kind: "dynamic",
+    offset: 0,
+    construct: call.construct,
+    text: "",
+    file: call.file,
+    line: call.line,
+    column: call.column,
+    pkg: record.pkg,
+    ...call.unknownLine !== void 0 && { unknownLine: call.unknownLine }
+  }));
 }
-function inspectAtomicLayer(css) {
-  const atoms = /* @__PURE__ */ new Set();
-  if (!css.includes("@")) return { hasLayer: false, atoms };
-  const sheet = readSheet(css);
-  const blocks = layerBlocks(sheet, 0, sheet.tokens.length);
-  for (const { open, close } of blocks) {
-    visitMembers(sheet, open + 1, close, (start, end) => {
-      for (const atom of atomsNamedBy(sheet, start, end)) atoms.add(atom);
-    });
-  }
-  return { hasLayer: blocks.length > 0, atoms };
+function problemsOf(record, context) {
+  return [...record.problems, ...dynamicProblems(record, context)];
 }
-function unprunedAtoms(css, emitted) {
-  if (!css.includes("@")) return [];
-  const atoms = /* @__PURE__ */ new Set();
-  const sheet = readSheet(css);
-  for (const { open, close } of layerBlocks(sheet, 0, sheet.tokens.length)) {
-    visitMembers(sheet, open + 1, close, (start, end) => {
-      for (const atom of blockersOf(sheet, start, end, emitted)) atoms.add(atom);
-    });
-  }
-  return [...atoms].toSorted((a, b) => a.localeCompare(b));
+function failModule(ctx, context, input) {
+  const { home, id, problems } = input;
+  const message = moduleReport(problems, context.options.cxModules, home);
+  const first = problems[0];
+  return ctx.error({
+    message,
+    id,
+    loc: { file: id, line: Math.max(first.line, 1), column: Math.max(first.column - 1, 0) }
+  });
 }
-
-// src/vite-dev.ts
-var RELOAD_ANSWER_MS = 2e3;
-var NO_MAP = JSON.stringify({ mappings: "" });
-var DIRECT = /[?&]direct\b/;
-function isInlinedInHtml(module) {
-  return module.id !== null && /[?&]html-proxy\b/.test(module.id);
+function failDevModule(ctx, context, input) {
+  const { home, id, record } = input;
+  if (context.command !== "serve" || record.pkg !== void 0) return;
+  const problems = problemsOf(record, context);
+  if (problems.length > 0) failModule(ctx, context, { home, id, problems });
 }
-async function reloadQuietly(environment, module) {
-  try {
-    if (isInlinedInHtml(module)) environment.hot.send({ type: "full-reload", path: "*" });
-    else await environment.reloadModule(module);
-  } catch {
-  }
+function importerIdsOf(ctx, cxId) {
+  const info = ctx.getModuleInfo?.(cxId);
+  return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
 }
-function reloadStale(context) {
-  const { state } = context;
-  state.reloadTimer = void 0;
-  const ids = [...state.stale];
-  state.stale.clear();
-  for (const id of ids) {
-    const sheet = state.served.get(id);
-    const module = sheet?.environment.moduleGraph.getModuleById(id);
-    if (!sheet || !module) continue;
-    noteReloadSent(state, id);
-    void reloadQuietly(sheet.environment, module);
-  }
+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);
 }
-function isReloading(context, id) {
-  const sent = context.state.reloading.get(id);
-  return sent !== void 0 && Date.now() - sent < RELOAD_ANSWER_MS;
+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 reloadOutgrown(context, ids) {
-  const { state } = context;
-  const atoms = servedAtoms(state, context.kept);
-  for (const id of ids) {
-    const sheet = state.served.get(id);
-    if (sheet && !atoms.isSubsetOf(sheet.atoms) && !isReloading(context, id)) state.stale.add(id);
-  }
-  if (state.stale.size > 0 && state.reloadTimer === void 0 && state.readAhead === 0) {
-    state.reloadTimer = setTimeout(() => {
-      reloadStale(context);
-    }, 0);
-    state.reloadTimer.unref();
-  }
+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;
 }
-var devServing = {
-  modulesWithGrown: modulesWithGrownStylesheets,
-  async hold(environment, id) {
-    const module = environment.moduleGraph.getModuleById(id);
-    if (!module) return;
-    if (module.importers.size === 0 && DIRECT.test(id)) return;
-    await environment.waitForRequestsIdle(id);
-    await transformReachable(environment, graphRoots(environment));
-  },
-  notePages(context) {
-    const { state } = context;
-    const atoms = servedAtoms(state, context.kept);
-    for (const sheet of state.served) {
-      const [id, { atoms: served, environment }] = sheet;
-      if (atoms.isSubsetOf(served)) continue;
-      const module = environment.moduleGraph.getModuleById(id);
-      if (module) environment.moduleGraph.invalidateModule(module);
-    }
-    devServing.noteGrowth(context);
-  },
-  noteConnect(context) {
-    const { state } = context;
-    state.listening += 1;
-    if (state.unheard.size === 0) return;
-    const ids = [...state.unheard];
-    state.unheard.clear();
-    for (const id of ids) state.reloading.delete(id);
-    reloadOutgrown(context, ids);
-  },
-  noteDisconnect(context) {
-    const { state } = context;
-    state.listening = Math.max(0, state.listening - 1);
-  },
-  noteGrowth(context) {
-    if (context.state.served.size === 0) return;
-    reloadOutgrown(context, context.state.served.keys());
+function lineFor(label, specifiers) {
+  if (specifiers.length === 0) {
+    return `${label}: imports cx through a specifier the build does not read.`;
   }
-};
-async function serveStylesheet(context, ctx, stylesheet) {
-  const { css, id } = stylesheet;
-  const { environment } = ctx;
-  if (!environment || !isServedAsStylesheet(id)) return void 0;
-  const isPossible = css.includes("\\") || /layer/i.test(css);
-  if (!isPossible || !inspectAtomicLayer(css).hasLayer) return void 0;
-  const dev = environment;
-  if (environment.config.consumer === "client") await devServing.hold(dev, id);
-  judgeWhenServed(context, id);
-  if (environment.config.consumer !== "client") return void 0;
-  const atoms = servedAtoms(context.state, context.kept);
-  context.state.served.set(id, { environment: dev, atoms });
-  context.state.reloading.delete(id);
-  return { code: pruneAtomicLayer(css, atoms), map: NO_MAP };
-}
-var HANDSHAKE_FILE = "nave-used-atoms.json";
-function handshakePath(cacheDir) {
-  return path2.join(cacheDir, HANDSHAKE_FILE);
+  return `${label}: imports cx from ${specifiers.map((specifier) => `'${specifier}'`).join(", ")}.`;
 }
-function readHandshake(cacheDir) {
-  if (cacheDir === "") return void 0;
-  try {
-    const parsed2 = JSON.parse(readFileSync(handshakePath(cacheDir), "utf8"));
-    return Array.isArray(parsed2.emitted) && typeof parsed2.writer === "string" ? parsed2 : void 0;
-  } catch {
-    return void 0;
+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, []);
 }
-function writeHandshake(cacheDir, fields, warn) {
-  if (cacheDir === "") return;
-  const handshake = {
-    ...fields,
-    emitted: [...fields.emitted].toSorted(compareText),
-    writtenAt: fields.writtenAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    build: fields.build ?? randomUUID()
-  };
-  try {
-    mkdirSync(cacheDir, { recursive: true });
-    writeFileSync(handshakePath(cacheDir), `${JSON.stringify(handshake, void 0, 2)}
-`);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    warn?.(
-      `navePlugin(): could not write ${handshakePath(cacheDir)} (${reason}), so a build of the client and a build of the server run as two processes cannot share their atoms.`
-    );
+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-emitted.ts
-function positionText(place) {
-  return place.line === 0 ? place.file : `${place.file}:${place.line}:${place.column}`;
-}
-function packageRecords(context) {
-  const records = {};
-  for (const pkg of Object.keys(context.options.keepFor)) {
-    const modules = context.state.modules.values().filter((record) => record.pkg === pkg).toArray();
-    const places = modules.flatMap((record) => [...record.suppressed, ...record.dynamicCalls]);
-    records[pkg] = {
-      collected: [...new Set(modules.flatMap((record) => [...record.atoms]))].toSorted(compareText),
-      unreadable: places.map((place) => positionText(place))
-    };
-  }
-  return records;
-}
-function unmatchedKeys(context) {
-  const transformed = new Set(context.state.modules.values().map((record) => record.pkg));
-  return Object.keys(context.options.keepFor).filter((pkg) => !transformed.has(pkg));
+// src/vite-cx-module-lines.ts
+function quoted(specifiers) {
+  return specifiers.map((specifier) => `'${specifier}'`).join(", ");
 }
-function takenFromCache(context) {
-  const file = context.inProcess ? void 0 : readHandshake(context.cacheDir);
-  if (file === void 0) return { atoms: [], took: false };
-  if (file.writer !== "client") return { atoms: file.emitted, took: true };
-  const pending = file.pending ?? [];
-  return { atoms: pending, took: pending.length > 0 };
+function applicationLinesOf(item) {
+  const entry = `'${item.entry}'`;
+  const relative = item.specifiers.filter((specifier) => isRelative(specifier));
+  const other = item.specifiers.filter((specifier) => !isRelative(specifier));
+  const place = relative.length === 1 ? "its" : "their";
+  return {
+    relative: relative.length === 0 ? [] : [
+      `${item.label}: imports ${entry} as ${quoted(relative)}. Write '${item.replacement}' in ${place} place.`
+    ],
+    other: other.length === 0 ? [] : [`${item.label}: imports ${entry} as ${quoted(other)}.`],
+    none: item.specifiers.length > 0 ? [] : [
+      `${item.label}: imports ${entry} through a specifier the build could not find in the file.`
+    ]
+  };
 }
-function emittedSet(context, environment, warn) {
-  const { state } = context;
-  if (state.emitted) return state.emitted;
-  const atoms = collectedAtoms(state, context.kept);
-  if (environment.config.consumer !== "client") return atoms;
-  const taken = takenFromCache(context);
-  for (const atom of taken.atoms) atoms.add(atom);
-  withRestorers(atoms);
-  state.emitted = atoms;
-  writeHandshake(
-    context.cacheDir,
-    {
-      emitted: [...atoms],
-      writer: "client",
-      consumed: taken.took,
-      keepFor: packageRecords(context),
-      unmatchedKeepFor: unmatchedKeys(context)
-    },
-    warn
-  );
-  return atoms;
+function dependencyLineOf(item) {
+  const entry = `'${item.entry}'`;
+  const found = item.specifiers.length === 0 ? `imports ${entry} through a specifier the build could not find in the file.` : `imports ${entry} as ${quoted(item.specifiers)}.`;
+  return `${item.label}: ${found} The file is in ${item.pkg}, a dependency, so it is not yours to change.`;
 }
-function namingLines(ctx, context, atoms) {
-  return recordsOf(context.state, ctx.environment.name).flatMap(
-    (record) => atoms.filter((atom) => record.atoms.has(atom)).map((atom) => `${record.file}: names ${atom}.`)
+var RELATIVE_REMEDY = "Adding a relative specifier to cxModules would not clear this: a relative entry is read from the project root. Instead of the rewrite";
+var TYPESCRIPT_CONDITION = "Where a rewrite ends in .ts, .tsx, .mts or .cts, TypeScript accepts it only if your tsconfig sets allowImportingTsExtensions or rewriteRelativeImportExtensions; if it sets neither, use the alias the line above describes instead.";
+var NO_SPECIFIER_REMEDY = "Where the build could not find the specifier, import the module there by a specifier ending in the listed file's name, or by an alias or package name added to cxModules.";
+function applicationRemedyOf(items, lines, input) {
+  const remedy = [];
+  const relativeCount = lines.reduce((count, line) => count + line.relative.length, 0);
+  if (relativeCount === 1) {
+    remedy.push(
+      `${RELATIVE_REMEDY} its line gives, the file can import the module through an alias for it, added to cxModules.`
+    );
+  } else if (relativeCount > 1) {
+    remedy.push(
+      `${RELATIVE_REMEDY} each line gives, a file can import the module through an alias for it, added to cxModules.`
+    );
+  }
+  const hasTypeScriptRewrite = items.some(
+    (item) => item.specifiers.some((specifier) => isRelative(specifier)) && /\.(?:ts|tsx|mts|cts)$/.test(item.replacement)
   );
+  if (hasTypeScriptRewrite) remedy.push(TYPESCRIPT_CONDITION);
+  if (lines.some((line) => line.none.length > 0)) remedy.push(NO_SPECIFIER_REMEDY);
+  const added = [
+    ...new Set(
+      items.flatMap((item) => item.specifiers.filter((specifier) => !isRelative(specifier)))
+    )
+  ];
+  const array = cxModulesArray(input.configured, added);
+  if (array !== void 0) {
+    const each = added.length === 1 ? "the specifier" : "each specifier";
+    remedy.push(`Add ${each}, as written, to cxModules in ${input.home}: cxModules: ${array}.`);
+  }
+  return remedy;
 }
-function missingFromClient(ctx, context, missing) {
-  return [
-    "The client build already wrote its CSS without atoms this server build names, so their rules are missing from it:",
-    ...namingLines(ctx, context, missing),
-    `They are recorded in ${handshakePath(context.cacheDir)} for the next client build. List the atoms in keep in navePlugin(), or build the client again, then the server (vite build, then vite build --ssr). To keep this from recurring, build the server first, then the client (vite build --ssr, then vite build).`
-  ].join("\n");
+var LASTING_FIX_HERE = "The lasting fix there is the package's: import the module by a specifier ending in the listed file's name.";
+function packageRemedyOf(pkg, files, input) {
+  if (input.hasKeepFor) {
+    const file = files === 1 ? "a file" : "files";
+    return `${pkg} also imports a module listed in cxModules in ${file} the build did not read; the keepFor entry above clears that too. ${LASTING_FIX_HERE}`;
+  }
+  return `For ${pkg}, list the atoms its calls can produce, from its documentation, under its name in ${input.home}: keepFor: { '${pkg}': ['<atom>'] }. Once the package is listed, its files no longer fail the build here, and the atoms you list stand in for the calls the build did not read. The lasting fix is the package's: import the module by a specifier ending in the listed file's name.`;
 }
-function notInLastClient(ctx, context, missing) {
+function importerErrorOf(found, input) {
+  const application = found.filter((item) => item.pkg === void 0);
+  const dependencies = found.filter((item) => item.pkg !== void 0);
+  const count = new Set(found.map((item) => item.importer)).size;
+  const first = count === 1 ? "1 file imports a module listed in cxModules through a specifier the build does not recognise, so the build did not read the cx() calls made through it." : `${count} files import a module listed in cxModules through a specifier the build does not recognise, so the build did not read the cx() calls made through those specifiers.`;
+  const lines = application.map((item) => applicationLinesOf(item));
+  const byPackage = Map.groupBy(dependencies, (item) => item.pkg);
+  const packages = byPackage.keys().toArray().toSorted(compareText);
   return [
-    `${handshakePath(context.cacheDir)} was written by a client build that was already used, so this server build could not be checked against the CSS. These atoms it names are not in that client build's set:`,
-    ...namingLines(ctx, context, missing),
-    "They are recorded in that file for a client build that runs next; to have them in the CSS, build the server first, then the client (vite build --ssr, then vite build)."
+    first,
+    ...lines.flatMap((line) => [...line.relative, ...line.other, ...line.none]).toSorted(compareText),
+    ...dependencies.map((item) => dependencyLineOf(item)).toSorted(compareText),
+    ...applicationRemedyOf(application, lines, input),
+    ...packages.map(
+      (pkg) => packageRemedyOf(pkg, new Set(byPackage.get(pkg).map((item) => item.importer)).size, {
+        hasKeepFor: input.report?.includes(`keepFor: { '${pkg}'`) ?? false,
+        home: input.home
+      })
+    )
   ].join("\n");
 }
-function recordForNextClient(ctx, context, atoms, held) {
-  writeHandshake(
-    context.cacheDir,
-    { emitted: [...withRestorers(new Set(atoms))], writer: ctx.environment.name, consumed: false },
-    (message) => ctx.warn(message)
-  );
-  const missing = [...atoms].filter((atom) => !held.includes(atom)).toSorted(compareText);
-  if (missing.length > 0) ctx.warn(notInLastClient(ctx, context, missing));
-}
-function checkWaitingClient(ctx, context, atoms, file) {
-  const missing = [...atoms].filter((atom) => !file.emitted.includes(atom)).toSorted(compareText);
-  if (missing.length === 0) {
-    writeHandshake(context.cacheDir, { ...file, consumed: true, pending: [] }, (message) => {
-      ctx.warn(message);
-    });
-    return;
-  }
-  const pending = [.../* @__PURE__ */ new Set([...file.pending ?? [], ...withRestorers(new Set(atoms))])];
-  writeHandshake(context.cacheDir, { ...file, pending }, (message) => ctx.warn(message));
-  ctx.error(missingFromClient(ctx, context, missing));
+
+// src/vite-cx-module-importers.ts
+var RESOLVED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".json",
+  ".jsx",
+  ".mjs",
+  ".mts",
+  ".ts",
+  ".tsx"
+]);
+function entryOf(declared, id) {
+  const file = fileOf(id);
+  for (const [entry, resolved] of declared.ids) if (fileOf(resolved) === file) return entry;
+  return id;
 }
-function checkServerInvocation(ctx, context) {
-  if (context.cacheDir === "" || context.inProcess || context.state.emitted) return;
-  const atoms = new Set(recordsOf(context.state, ctx.environment.name).flatMap((r) => [...r.atoms]));
-  const file = readHandshake(context.cacheDir);
-  if (file?.writer !== "client") {
-    const emitted = [...withRestorers(/* @__PURE__ */ new Set([...atoms, ...file?.emitted ?? []]))];
-    writeHandshake(
-      context.cacheDir,
-      { emitted, writer: ctx.environment.name, consumed: false },
-      (message) => ctx.warn(message)
-    );
-  } else if (file.consumed) {
-    recordForNextClient(ctx, context, atoms, file.emitted);
-  } else {
-    checkWaitingClient(ctx, context, atoms, file);
-  }
+async function replacementFor(ctx, input) {
+  const file = fileOf(input.id);
+  const extension = path.posix.extname(file);
+  const relativeTo = (target) => {
+    const relative = path.posix.relative(path.posix.dirname(fileOf(input.importer)), target);
+    return relative.startsWith("../") ? relative : `./${relative}`;
+  };
+  if (!RESOLVED_EXTENSIONS.has(extension)) return relativeTo(file);
+  const short = relativeTo(file.slice(0, -extension.length));
+  const isLanding = await isResolvingTo(ctx, { file, from: input.importer, specifier: short });
+  return isLanding ? short : relativeTo(file);
 }
-
-// src/vite-cx-reexported.ts
-function declaredNames(pattern) {
+async function unrecognisedSpecifiers(ctx, input) {
+  const { answers, id, importer, recognised } = input;
+  const known = { cxId: id, answers };
   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);
-    }
+  const unread = (specifiersOf(ctx, importer) ?? []).filter((text) => !recognised?.has(text));
+  for (const specifier of unread) {
+    if (await isResolvingToCx(ctx, specifier, importer, known)) found.push(specifier);
   }
   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;
+async function unrecognisedOf(ctx, context, input) {
+  const { answers, declared, id } = input;
+  const importer = await candidateOf(ctx, context, input.importer);
+  if (!importer) return void 0;
+  const recognised = context.state.recognised.get(
+    recognisedKey(ctx.environment.name, fileOf(id), importer.id)
+  );
+  const specifiers = await unrecognisedSpecifiers(ctx, { answers, id, importer, recognised });
+  if (recognised !== void 0 && specifiers.length === 0) return void 0;
+  const pkg = isDependencyId(importer.id) ? await packageNameOf(filePathOf(importer.id), context.packageNames) : void 0;
+  return {
+    importer: importer.id,
+    label: moduleLabel(context.root, importer.id),
+    entry: entryOf(declared, id),
+    specifiers,
+    replacement: pkg === void 0 ? await replacementFor(ctx, { id, importer: importer.id }) : "",
+    pkg
+  };
 }
-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 listedIdsIn(ctx, declared) {
+  const ids = new Set(declared.ids.values());
+  const graph = ctx.getModuleIds?.() ?? [];
+  for (const id of graph) {
+    if (declared.files.has(fileOf(id))) ids.add(id);
+  }
+  return ids;
 }
-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 merged(found, item, id) {
+  const key = `${item.importer}\0${fileOf(id)}`;
+  const specifiers = /* @__PURE__ */ new Set([...found.get(key)?.specifiers ?? [], ...item.specifiers]);
+  return [key, { ...item, specifiers: [...specifiers] }];
 }
-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);
+async function unrecognisedImporters(ctx, context, declared) {
+  const found = /* @__PURE__ */ new Map();
+  for (const id of listedIdsIn(ctx, declared)) {
+    const answers = /* @__PURE__ */ new Map();
+    for (const importer of importerIdsOf(ctx, id)) {
+      const item = await unrecognisedOf(ctx, context, { answers, declared, id, importer });
+      if (item) found.set(...merged(found, item, id));
     }
-    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];
+  return found.values().toArray();
+}
+async function declaredImporterError(ctx, context, input) {
+  const declared = await declaredModulesFor(context, ctx, ctx.environment.name);
+  if (!declared) return void 0;
+  const found = await unrecognisedImporters(ctx, context, declared);
+  return found.length === 0 ? void 0 : importerErrorOf(found, input);
 }
 
-// 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;
+// 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) {
+  const { state } = context;
+  return context.options.keep.length === 0 && collectedAtoms(state, []).size === 0 && !state.directiveExpanded && !state.htmlRead && !state.serverTransformed && !context.isLibrary;
 }
-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 judgeMarkup(context, warn) {
+  const { state } = context;
+  if (!isUsed(context) || state.markupJudged) return;
+  state.markupJudged = true;
+  if (isMarkupCase(context)) warn(MARKUP_WARNING);
 }
-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);
-    }
+function expectBuilds(context, builder, warn) {
+  if (Object.values(builder.environments).some((environment) => environment.isBuilt)) {
+    judgeMarkup(context, warn);
+    return;
   }
+  context.state.expectedEnvironments = new Set(Object.keys(builder.environments));
 }
-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;
+function judgeAfterLastEnvironment(context, environment, warn) {
+  const { builtEnvironments, expectedEnvironments } = context.state;
+  builtEnvironments.add(environment.name);
+  const isLast = expectedEnvironments ? [...expectedEnvironments].every((name) => builtEnvironments.has(name)) : !context.inProcess && environment.config.consumer === "client";
+  if (isLast) judgeMarkup(context, warn);
 }
 
-// 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 [];
+// src/vite-dev-judge.ts
+function isServedAsStylesheet(id) {
+  return isStylesheetId(id) && !/[?&]inline\b/.test(id);
+}
+function judge(context) {
+  judgeMarkup(context, (message) => context.logger?.warn(message));
+}
+function judgeWhenServed(context, id) {
+  const { state } = context;
+  if (!state.warmedUp || state.requested.has(filePathOf(id))) judge(context);
+}
+function stylesheetUrl(request, base) {
+  const url = request.url;
+  if (url === void 0 || !isServedAsStylesheet(url)) return void 0;
+  return base !== "/" && url.startsWith(base) ? `/${url.slice(base.length)}` : url;
+}
+async function noteRequest(context, environment, url) {
+  const { state } = context;
   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 });
+    const resolved = await environment.pluginContainer.resolveId(decodeURI(url));
+    if (resolved === null) return;
+    const file = filePathOf(resolved.id);
+    state.requested.add(file);
+    if (state.served.keys().some((id) => filePathOf(id) === file)) judge(context);
   } 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();
+function noteStylesheetRequests(context, server) {
+  const { state } = context;
+  const environment = server.environments.client;
+  state.warmedUp = environment.config.dev.warmup.length > 0;
+  if (!state.warmedUp) return;
+  server.middlewares.use(async (request, _response, next) => {
+    const url = stylesheetUrl(request, server.config.base);
+    if (url !== void 0 && !state.markupJudged) await noteRequest(context, environment, url);
+    next();
+  });
 }
 
-// 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;
+// src/vite-dev-read.ts
+function graphRoots(environment) {
+  return environment.moduleGraph.idToModuleMap.values().filter(
+    (module) => module.importers.size === 0 && (module.id === null || !isStylesheetId(module.id))
+  ).toArray();
 }
-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
-  );
+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);
+    }
+  };
 }
-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;
+async function waitForStartedRequests(environment) {
+  const open = started.get(environment);
+  if (open) await Promise.allSettled(open);
 }
-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);
+async function transformQuietly(environment, url) {
+  try {
+    await environment.transformRequest(url);
+  } catch {
   }
-  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 isEndOfRead(module) {
+  return module.id !== null && isCssModuleId(module.id);
 }
-function dynamicKeys(analysis, node, names) {
-  const awaited = analysis.parentOf.get(node);
-  if (awaited?.type === "AwaitExpression") {
-    return awaitedKeys(analysis, outermost(analysis, awaited), names);
+async function transformReachable(environment, roots) {
+  const seen = new Set(roots);
+  let level = [...roots];
+  while (level.length > 0) {
+    const next = [];
+    await Promise.all(
+      level.map(async (module) => {
+        if (module.id !== null && isUnreadStylesheet(module.id)) return;
+        await transformQuietly(environment, module.url);
+        if (isEndOfRead(module)) return;
+        for (const imported of module.importedModules) {
+          if (seen.has(imported)) continue;
+          seen.add(imported);
+          next.push(imported);
+        }
+      })
+    );
+    level = next;
   }
-  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 };
+// src/vite-dev-update.ts
+function readerOf(environment) {
+  return {
+    transformRequest: (url) => environment.transformRequest?.(url) ?? Promise.resolve()
+  };
 }
-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 });
+async function readAhead(context, environment, scripts) {
+  const { state } = context;
+  const reader = readerOf(environment);
+  state.readAhead += 1;
+  try {
+    for (const module of scripts) {
+      const known = new Set(module.importedModules);
+      environment.moduleGraph.invalidateModule(module);
+      await transformQuietly(reader, module.url);
+      if (isEndOfRead(module)) continue;
+      const added = [...module.importedModules.difference(known)];
+      await transformReachable(reader, added);
     }
+  } finally {
+    state.readAhead -= 1;
   }
-  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));
+function takeStaleModules(context, environment) {
+  const { state } = context;
+  const ids = [...state.stale];
+  state.stale.clear();
+  clearTimeout(state.reloadTimer);
+  state.reloadTimer = void 0;
+  const sheets = [];
+  for (const id of ids) {
+    const module = environment.moduleGraph.getModuleById(id);
+    if (!module) continue;
+    noteReloadSent(state, id);
+    sheets.push(module);
   }
-  return found;
+  return sheets;
+}
+async function modulesWithGrownStylesheets(context, ctx, hot) {
+  const { environment } = ctx;
+  if (environment.config?.consumer !== "client" || context.state.served.size === 0) return;
+  const scripts = (hot.modules ?? []).filter((m) => m.id !== null && !isUnreadStylesheet(m.id));
+  if (scripts.length === 0) return;
+  await readAhead(context, environment, scripts);
+  const sheets = takeStaleModules(context, environment);
+  return sheets.length === 0 ? void 0 : [...hot.modules ?? [], ...sheets];
 }
 
-// src/vite-listed-routes.ts
-async function takenBy(ctx, input) {
-  const { file, id, names, resolutions } = input;
-  const code = ctx.getModuleInfo?.(id)?.code;
+// src/vite-dev.ts
+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.test(module.id);
+}
+async function reloadQuietly(environment, module) {
   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 });
+    if (isInlinedInHtml(module)) environment.hot.send({ type: "full-reload", path: "*" });
+    else await environment.reloadModule(module);
   } 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 }
-      });
-    }
+function reloadStale(context) {
+  const { state } = context;
+  state.reloadTimer = void 0;
+  const ids = [...state.stale];
+  state.stale.clear();
+  for (const id of ids) {
+    const sheet = state.served.get(id);
+    const module = sheet?.environment.moduleGraph.getModuleById(id);
+    if (!sheet || !module) continue;
+    noteReloadSent(state, id);
+    void reloadQuietly(sheet.environment, module);
   }
-  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;
+function isReloading(context, id) {
+  const sent = context.state.reloading.get(id);
+  return sent !== void 0 && Date.now() - sent < RELOAD_ANSWER_MS;
+}
+function reloadOutgrown(context, ids) {
+  const { state } = context;
+  const atoms = servedAtoms(state, context.kept);
+  for (const id of ids) {
+    const sheet = state.served.get(id);
+    if (sheet && !atoms.isSubsetOf(sheet.atoms) && !isReloading(context, id)) state.stale.add(id);
+  }
+  if (state.stale.size > 0 && state.reloadTimer === void 0 && state.readAhead === 0) {
+    state.reloadTimer = setTimeout(() => {
+      reloadStale(context);
+    }, 0);
+    state.reloadTimer.unref();
+  }
+}
+var devServing = {
+  modulesWithGrown: modulesWithGrownStylesheets,
+  async hold(environment, id) {
+    const module = environment.moduleGraph.getModuleById(id);
+    if (!module) 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);
+    for (const sheet of state.served) {
+      const [id, { atoms: served, environment }] = sheet;
+      if (atoms.isSubsetOf(served)) continue;
+      const module = environment.moduleGraph.getModuleById(id);
+      if (module) environment.moduleGraph.invalidateModule(module);
     }
-    const routes = await routesOf(ctx, context, {
-      holder,
-      importer,
-      isEntry,
-      resolutions,
-      wantCalls
-    });
-    pushAll(entry, routes.entry);
-    pushAll(told, routes.told);
-    pushAll(calls, routes.calls);
+    devServing.noteGrowth(context);
+  },
+  noteConnect(context) {
+    const { state } = context;
+    state.listening += 1;
+    if (state.unheard.size === 0) return;
+    const ids = [...state.unheard];
+    state.unheard.clear();
+    for (const id of ids) state.reloading.delete(id);
+    reloadOutgrown(context, ids);
+  },
+  noteDisconnect(context) {
+    const { state } = context;
+    state.listening = Math.max(0, state.listening - 1);
+  },
+  noteGrowth(context) {
+    if (context.state.served.size === 0) return;
+    reloadOutgrown(context, context.state.served.keys());
+  }
+};
+async function serveStylesheet(context, ctx, stylesheet) {
+  const { css, id } = stylesheet;
+  const { environment } = ctx;
+  if (!environment || !isServedAsStylesheet(id)) return void 0;
+  const isPossible = css.includes("\\") || /layer/i.test(css);
+  if (!isPossible || !inspectAtomicLayer(css).hasLayer) return void 0;
+  const dev = environment;
+  if (environment.config.consumer === "client" && !isCssModuleId(id)) {
+    await devServing.hold(dev, id);
   }
-  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))
-  };
+  judgeWhenServed(context, id);
+  if (environment.config.consumer !== "client") return void 0;
+  const atoms = servedAtoms(context.state, context.kept);
+  context.state.served.set(id, { environment: dev, atoms });
+  context.state.reloading.delete(id);
+  return { code: pruneAtomicLayer(css, atoms), map: NO_MAP };
 }
 
-// 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 };
+// src/vite-order.ts
+var MISSING = "which the CSS already written does not hold.";
+function packageOfPath(file) {
+  const marker = "node_modules/";
+  const at = file.lastIndexOf(marker);
+  if (at === -1) return void 0;
+  const parts = file.slice(at + marker.length).split("/");
+  return parts[0]?.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function missLines(record, emitted) {
+  return [...record.atoms].toSorted(compareText).filter((atom) => !emitted.has(atom)).map((atom) => `${record.file}: names ${atom}, ${MISSING}`);
+}
+function clientFirstMessage(lines) {
+  return [
+    "The build read atoms after it wrote the CSS, so their rules are missing from it:",
+    ...lines,
+    "List the atoms in keep in navePlugin(), or build the server environments first with builder.buildApp in your Vite config."
+  ].join("\n");
 }
-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 serverFirstMessage(records, emitted) {
+  const missing = records.filter((record) => missLines(record, emitted).length > 0);
+  const packages = [
+    ...new Set(
+      missing.map((record) => packageOfPath(record.file)).filter((name) => name !== void 0)
+    )
+  ].toSorted(compareText);
+  return [
+    "The build read atoms after it wrote the CSS, so their rules are missing from it:",
+    ...missing.flatMap((record) => missLines(record, emitted)).toSorted(compareText),
+    "A server build wrote the CSS, and only a build after it read these modules, such as code only the browser runs (an Astro client:only component, or a <script> in an .astro file).",
+    "List the atoms in keep in navePlugin(), or have the server render that code too (a hydrated island rather than client:only).",
+    ...packages.map(
+      (name) => `${name} is a dependency the server build left external: add it to resolve.noExternal in your Vite config (on Astro, under vite in astro.config) so the server build reads it.`
+    )
+  ].join("\n");
 }
-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 readByWriters(state) {
+  const read = /* @__PURE__ */ new Set();
+  for (const key of state.modules.keys()) {
+    const at = key.indexOf("\0");
+    if (state.writers.has(key.slice(0, at))) read.add(key.slice(at + 1));
+  }
+  return read;
 }
-function decideReexports(prepared, serverImports) {
-  return prepared.flatMap((one) => decideOne(one, serverImports));
+function lateRecords(ctx, state) {
+  const read = readByWriters(state);
+  const prefix = `${ctx.environment.name}\0`;
+  return [...state.modules].filter(([key]) => key.startsWith(prefix) && !read.has(key.slice(prefix.length))).map(([, record]) => record);
 }
-
-// src/vite-order.ts
 function checkEnvironmentOrder(ctx, context) {
-  const { emitted } = context.state;
+  const { state } = context;
+  const { emitted } = state;
   if (emitted === void 0) return;
-  const lines = [];
-  for (const record of recordsOf(context.state, ctx.environment.name)) {
-    for (const atom of [...record.atoms].toSorted(compareText)) {
-      if (!emitted.has(atom)) {
-        lines.push(`${record.file}: names ${atom}, which the CSS already written does not hold.`);
-      }
-    }
+  if (state.firstWriter === "server") {
+    if (state.writers.has(ctx.environment.name) || hasStylesheet(state, ctx.environment.name))
+      return;
+    const late = lateRecords(ctx, state);
+    if (late.some((record) => missLines(record, emitted).length > 0))
+      ctx.error(serverFirstMessage(late, emitted));
+    return;
   }
-  if (lines.length === 0) return;
-  ctx.error(
-    [
-      `The build read atoms after it wrote the CSS, so their rules are missing from it:`,
-      ...lines,
-      "List the atoms in keep in navePlugin(), or build the server environments first with builder.buildApp in your Vite config."
-    ].join("\n")
+  const lines = recordsOf(state, ctx.environment.name).flatMap(
+    (record) => missLines(record, emitted)
   );
+  if (lines.length > 0) ctx.error(clientFirstMessage(lines));
 }
 var PACKAGE_NAME = /^(@[^/]+\/[^/]+|[^./@][^/]*)(\/.*)?$/;
 var EXTENSIONS = ["", ".js", ".mjs", ".cjs", "/index.js", "/index.mjs", "/index.cjs"];
 function packageDirectory(directory, name) {
-  for (let current = directory; ; current = path2.dirname(current)) {
-    const found = path2.join(current, "node_modules", name);
-    if (existsSync(path2.join(found, "package.json"))) return found;
-    if (path2.dirname(current) === current) return void 0;
+  for (let current = directory; ; current = path.dirname(current)) {
+    const found = path.join(current, "node_modules", name);
+    if (existsSync(path.join(found, "package.json"))) return found;
+    if (path.dirname(current) === current) return void 0;
   }
 }
 function targetFile(target, input) {
@@ -2486,7 +1934,7 @@ function existingFile(base) {
 }
 function manifestOf(directory) {
   try {
-    return JSON.parse(readFileSync(path2.join(directory, "package.json"), "utf8"));
+    return JSON.parse(readFileSync(path.join(directory, "package.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -2501,12 +1949,12 @@ function relativeTarget(manifest, input) {
 }
 function serverFileOf(input) {
   const parts = PACKAGE_NAME.exec(input.specifier);
-  const directory = parts && packageDirectory(path2.dirname(input.from), parts[1]);
+  const directory = parts && packageDirectory(path.dirname(input.from), parts[1]);
   const manifest = directory ? manifestOf(directory) : void 0;
   if (!parts || !directory || !manifest) return void 0;
   const subpath = parts[2] === void 0 ? "." : `.${parts[2]}`;
   const relative = relativeTarget(manifest, { conditions: new Set(input.conditions), subpath });
-  const file = relative === void 0 ? void 0 : existingFile(path2.join(directory, relative));
+  const file = relative === void 0 ? void 0 : existingFile(path.join(directory, relative));
   return file === void 0 ? void 0 : realpathSync(file);
 }
 var PACKAGE_NAME2 = /^(@[^/]+\/[^/]+|[^./@][^/]*)/;
@@ -2515,21 +1963,24 @@ function packageOfSpecifier(specifier) {
   return PACKAGE_NAME2.exec(specifier)?.[1];
 }
 function isDeclaringCore(root, name) {
-  for (let directory = root; ; directory = path2.dirname(directory)) {
+  for (let directory = root; ; directory = path.dirname(directory)) {
     try {
       const manifest = JSON.parse(
-        readFileSync(path2.join(directory, "node_modules", name, "package.json"), "utf8")
+        readFileSync(path.join(directory, "node_modules", name, "package.json"), "utf8")
       );
       return ["dependencies", "peerDependencies", "optionalDependencies"].some(
         (field) => manifest[field]?.["@navecss/core"] !== void 0
       );
     } catch {
-      if (path2.dirname(directory) === directory) return false;
+      if (path.dirname(directory) === directory) return false;
     }
   }
 }
-function warningFor(name) {
-  return `${name} depends on @navecss/core, but no environment of this build transforms it, so the atoms its cx() calls name are not read. Add it to ssr.noExternal in your Vite config so the build reads it, or list the atoms its calls can produce under its name in keepFor in navePlugin().`;
+function noExternalKey(firstWriter) {
+  return firstWriter === "server" ? "resolve.noExternal in your Vite config (on Astro, under vite in astro.config)" : "ssr.noExternal in your Vite config";
+}
+function warningFor(name, firstWriter) {
+  return `${name} depends on @navecss/core, but no environment of this build transforms it, so the atoms its cx() calls name are not read. Add it to ${noExternalKey(firstWriter)} so the build reads it, or list the atoms its calls can produce under its name in keepFor in navePlugin().`;
 }
 function judgeExternals(ctx, context) {
   const { state } = context;
@@ -2537,7 +1988,7 @@ function judgeExternals(ctx, context) {
     if (state.packages.has(name) || state.warned.has(name)) continue;
     if (Object.hasOwn(context.options.keepFor, name)) continue;
     state.warned.add(name);
-    ctx.warn(warningFor(name));
+    ctx.warn(warningFor(name, state.firstWriter));
   }
   state.externals.clear();
 }
@@ -2576,7 +2027,7 @@ function conditionsOf(ctx) {
 function importsOf(ctx, input) {
   const { externals, id, root } = input;
   const program = parsed(ctx, id);
-  const taker = path2.relative(root, filePathOf(id)).replaceAll("\\", "/");
+  const taker = path.relative(root, filePathOf(id)).replaceAll("\\", "/");
   const conditions = conditionsOf(ctx);
   const named = program ? specifiersIn(program).filter((one) => externals.has(one)) : [];
   const info = ctx.getModuleInfo?.(id);
@@ -2613,7 +2064,7 @@ function serverImportsOf(ctx, context) {
   };
   const externals = new Set(ids.filter((id) => isListed2(id)));
   if (externals.size === 0) return [];
-  return ids.filter((id) => path2.isAbsolute(filePathOf(id)) && !isDependencyId(id) && !isNaveOwn(id)).flatMap((id) => importsOf(ctx, { externals, id, root: context.root }));
+  return ids.filter((id) => path.isAbsolute(filePathOf(id)) && !isDependencyId(id) && !isNaveOwn(id)).flatMap((id) => importsOf(ctx, { externals, id, root: context.root }));
 }
 function buildKeyOf(ctx) {
   const build = ctx.environment.config.build;
@@ -2622,7 +2073,7 @@ function buildKeyOf(ctx) {
 function readEntries(context) {
   try {
     const parsedFile = JSON.parse(
-      readFileSync(path2.join(context.cacheDir, SERVER_TAKES_FILE), "utf8")
+      readFileSync(path.join(context.cacheDir, SERVER_TAKES_FILE), "utf8")
     );
     const isEntries = typeof parsedFile === "object" && parsedFile !== null && !Array.isArray(parsedFile);
     return isEntries ? parsedFile : {};
@@ -2632,7 +2083,7 @@ function readEntries(context) {
 }
 function writeServerImports(ctx, context, imports) {
   if (context.cacheDir === "") return;
-  const file = path2.join(context.cacheDir, SERVER_TAKES_FILE);
+  const file = path.join(context.cacheDir, SERVER_TAKES_FILE);
   try {
     mkdirSync(context.cacheDir, { recursive: true });
     const entries = { ...readEntries(context), [buildKeyOf(ctx)]: imports };
@@ -2647,7 +2098,7 @@ function writeServerImports(ctx, context, imports) {
 }
 function readServerImports(context) {
   if (context.cacheDir === "") return [];
-  return Object.values(readEntries(context)).flat().filter((found) => existsSync(path2.resolve(context.root, found.taker))).map((found) => ({ ...found, isRecorded: true }));
+  return Object.values(readEntries(context)).flat().filter((found) => existsSync(path.resolve(context.root, found.taker))).map((found) => ({ ...found, isRecorded: true }));
 }
 function graphOf(ctx) {
   return new Set([...ctx.getModuleIds?.() ?? []].map((id) => fileOf(id)));
@@ -2673,18 +2124,19 @@ function recordedSentence(takers) {
 function recordedTakers(imports) {
   return imports.filter((found) => found.isRecorded === true).map((found) => found.taker);
 }
-function warningFor2(pkg, input) {
-  const { found, root } = input;
+function warningFor2(pkg, found, context) {
+  const { root } = context;
+  const { firstWriter } = context.state;
   const listed = found.map((one) => {
     if (one.isUnreadable === true)
       return `${one.taker} loads '${one.specifier}' in a way the build cannot read as a take, such as a require() or a # import`;
     if (one.file === void 0)
       return `${one.taker} imports '${one.specifier}', and the build cannot tell which file the server loads for it`;
-    const file = path2.relative(root, one.file).replaceAll("\\", "/");
+    const file = path.relative(root, one.file).replaceAll("\\", "/");
     return `${one.taker} imports '${one.specifier}', which the server loads as ${file}, a file no environment of this build transforms`;
   }).toSorted(compareText).join("; ");
   const note = recordedSentence(recordedTakers(found));
-  const warning = `${pkg}, which keepFor lists, is imported by your server code where the build cannot tell whether that code takes cx from it: ${listed}. Add ${pkg} to ssr.noExternal in your Vite config so the build reads the package and checks what your server code takes; where a file takes cx from it, import cx from @navecss/core/cx there instead.`;
+  const warning = `${pkg}, which keepFor lists, is imported by your server code where the build cannot tell whether that code takes cx from it: ${listed}. Add ${pkg} to ${noExternalKey(firstWriter)} so the build reads the package and checks what your server code takes; where a file takes cx from it, import cx from @navecss/core/cx there instead.`;
   return note === void 0 ? warning : `${warning} ${note}`;
 }
 function warnUnknown(ctx, context, unknown) {
@@ -2696,37 +2148,37 @@ function warnUnknown(ctx, context, unknown) {
   }
   for (const [pkg, imports] of byPackage) {
     context.state.warned.add(pkg);
-    ctx.warn(warningFor2(pkg, { found: imports, root: context.root }));
+    ctx.warn(warningFor2(pkg, imports, context));
   }
 }
 
 // src/vite-collect-plugin.ts
 var OPTIONS_HOME = "navePlugin()";
 function isReadable(context, id) {
-  return isUsed(context) && !isStylesheetId(id) && !isNaveOwn(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);
@@ -2772,9 +2224,9 @@ function createCollectPlugin(context) {
       context.state.started = true;
       assertOptions(context.options, await ownAtomNames(context));
       forgetDeclared(context.state, this.environment.name);
-      if (this.environment.config.consumer !== "client") return;
-      context.state.emitted = void 0;
-      context.state.clientEnded = false;
+      if (this.environment.config.consumer === "client") context.state.clientEnded = false;
+      const isWriter = context.inProcess ? context.state.emittedBy === this.environment.name : this.environment.config.consumer === "client";
+      if (isWriter) forgetWriters(context.state);
     },
     async transform(code, id, meta) {
       if (!isReadable(context, id)) return;
@@ -2794,6 +2246,12 @@ function createCollectPlugin(context) {
         if (context.command === "serve") devServing.notePages(context);
       }
     },
+    generateBundle: {
+      order: "pre",
+      handler(options, bundle) {
+        checkBundle(this, context, { bundle, options, pass: "pre" });
+      }
+    },
     async buildEnd(error) {
       if (error || !isUsed(context) || context.command !== "build") return;
       const graph = graphOf(this);
@@ -2855,142 +2313,6 @@ function usedEnvironmentConfig(context, name, options) {
   return { resolve: { noExternal: ["@navecss/core"] } };
 }
 
-// src/vite-css-capture.ts
-var originals = /* @__PURE__ */ new WeakMap();
-function transformHandler(plugin) {
-  const { transform } = plugin;
-  if (typeof transform === "function") return transform;
-  const handler = transform?.handler;
-  return typeof handler === "function" ? handler : void 0;
-}
-function unwrapped(handler) {
-  let current = handler;
-  for (let next = originals.get(current); next; next = originals.get(current)) current = next;
-  return current;
-}
-function remember(context, environment, id, css) {
-  const key = moduleKey(environment, id);
-  const isPossible = css.includes("\\") || /layer/i.test(css);
-  if (isPossible && inspectAtomicLayer(css).hasLayer) context.state.sheets.set(key, css);
-  else context.state.sheets.delete(key);
-}
-function captureStylesheets(context, plugins) {
-  const plugin = plugins?.find((candidate) => candidate.name === "vite:css-post");
-  const original = plugin && transformHandler(plugin);
-  if (!plugin || !original) return;
-  const wrapped = function(css, id) {
-    const environment = this.environment?.name ?? "client";
-    remember(context, environment, id, css);
-    return original.call(this, css, id);
-  };
-  originals.set(wrapped, original);
-  const { transform } = plugin;
-  plugin.transform = typeof transform === "function" ? wrapped : { ...transform, handler: wrapped };
-}
-var decoder = new TextDecoder();
-async function refeed(ctx, css, id) {
-  const plugin = ctx.environment.plugins.find((candidate) => candidate.name === "vite:css-post");
-  const handler = plugin && transformHandler(plugin);
-  if (!handler) {
-    ctx.error(
-      "nave: this version of Vite has no CSS step the plugin knows how to hand a stylesheet back to, so it cannot remove the unused atoms. Ship every atom with atomic: 'all' in navePlugin() until the plugin supports this version of Vite."
-    );
-  }
-  await unwrapped(handler).call(ctx, css, id);
-}
-var fedPages = /* @__PURE__ */ new WeakMap();
-var warnedText = /* @__PURE__ */ new WeakMap();
-function bookFor(book, emitted) {
-  const ids = book.get(emitted) ?? /* @__PURE__ */ new Set();
-  book.set(emitted, ids);
-  return ids;
-}
-function isPageStylesheet(id) {
-  return /[?&]html-proxy\b/.test(id);
-}
-function pageStylesheets(ctx, state, emitted) {
-  const prefix = `${ctx.environment.name}\0`;
-  const fed = bookFor(fedPages, emitted);
-  const ids = state.sheets.keys().filter((key) => key.startsWith(prefix) && isPageStylesheet(key)).map((key) => key.slice(prefix.length)).filter((id) => !fed.has(id)).toArray();
-  for (const id of ids) fed.add(id);
-  return ids;
-}
-function isInlineImport(id) {
-  return /[?&]inline\b/.test(id) && !isPageStylesheet(id);
-}
-function isRawImport(id) {
-  return /[?&]raw\b/.test(id) && isStylesheetPath(id);
-}
-function isLayerFile(id) {
-  try {
-    return inspectAtomicLayer(readFileSync(filePathOf(id), "utf8")).hasLayer;
-  } catch {
-    return false;
-  }
-}
-async function refeedChunkStylesheets(ctx, chunk, state, emitted) {
-  const prefix = `${ctx.environment.name}\0`;
-  for (const id of [...Object.keys(chunk.modules), ...pageStylesheets(ctx, state, emitted)]) {
-    const css = state.sheets.get(`${prefix}${id}`);
-    if (css === void 0 || isInlineImport(id)) continue;
-    await refeed(ctx, pruneAtomicLayer(css, emitted), id);
-  }
-}
-function warnTextImports(ctx, chunk, context, emitted) {
-  const prefix = `${ctx.environment.name}\0`;
-  const warned = bookFor(warnedText, emitted);
-  for (const id of Object.keys(chunk.modules)) {
-    if (warned.has(id)) continue;
-    const isInline = isInlineImport(id) && context.state.sheets.has(`${prefix}${id}`);
-    const isRaw = !isInline && isRawImport(id) && isLayerFile(id);
-    if (!isInline && !isRaw) continue;
-    warned.add(id);
-    const query = isInline ? "?inline" : "?raw";
-    ctx.warn(
-      `${moduleLabel(context.root, id)} is imported with ${query}, so its stylesheet is text in the JavaScript, which the plugin does not filter: every atom in its atomic layer ships, not only the atoms this build emits. Import it without ${query} to have the layer filtered.`
-    );
-  }
-}
-function textOf(entry) {
-  const { source } = entry;
-  if (source === void 0) return "";
-  return typeof source === "string" ? source : decoder.decode(source);
-}
-function mismatchLines(assets, emitted) {
-  const lines = [];
-  const seenAnywhere = /* @__PURE__ */ new Set();
-  let hasLayer = false;
-  for (const { fileName, css } of assets) {
-    const seen = inspectAtomicLayer(css);
-    if (!seen.hasLayer) continue;
-    hasLayer = true;
-    for (const atom of seen.atoms) seenAnywhere.add(atom);
-    const extra = unprunedAtoms(css, emitted);
-    if (extra.length > 0) {
-      lines.push(
-        `${fileName}: the atomic layer holds a rule for ${extra.join(", ")}, which the build did not emit.`
-      );
-    }
-  }
-  const missing = [...emitted.difference(seenAnywhere)];
-  if (hasLayer && missing.length > 0) {
-    lines.push(`the atomic layers hold no rule for ${missing.join(", ")}, which the build emitted.`);
-  }
-  return lines;
-}
-function checkAtomicLayers(ctx, bundle, emitted) {
-  const assets = Object.values(bundle).filter((entry) => entry.type === "asset" && entry.fileName.toLowerCase().endsWith(".css")).map((entry) => ({ fileName: entry.fileName, css: textOf(entry) }));
-  const lines = mismatchLines(assets, emitted);
-  if (lines.length === 0) return;
-  ctx.error({
-    message: [
-      "nave: the built CSS does not hold exactly the atoms the build emitted, so the plugin could not remove the unused ones on this version of Vite.",
-      ...lines,
-      "Ship every atom with atomic: 'all' in navePlugin() until the plugin supports this version of Vite."
-    ].join("\n")
-  });
-}
-
 // src/vite-extend.ts
 function snapshotAndValidate(value) {
   const snapshot = snapshotExtendMap(value);
@@ -3047,30 +2369,6 @@ function dropLightningNaveWarning(logger) {
   wrappers.set(logger, wrapper);
 }
 
-// src/vite-scan.ts
-var decoder2 = new TextDecoder();
-function isCssAsset(entry) {
-  return entry.type === "asset" && entry.fileName.toLowerCase().endsWith(".css");
-}
-function textOf2(entry) {
-  const { source } = entry;
-  if (source === void 0) return "";
-  return typeof source === "string" ? source : decoder2.decode(source);
-}
-function messageFor(findings, assetCount) {
-  const noun = assetCount === 1 ? "asset" : "assets";
-  return [
-    "@nave survived into the built CSS:",
-    ...findings.map((finding) => formatFinding(finding)),
-    `Scanned ${assetCount} CSS ${noun} this build wrote.`
-  ].join("\n");
-}
-function scanBundle(ctx, bundle) {
-  const assets = Object.values(bundle).filter((entry) => isCssAsset(entry));
-  const findings = assets.flatMap((asset) => findingsInText(asset.fileName, textOf2(asset)));
-  if (findings.length > 0) ctx.error({ message: messageFor(findings, assets.length) });
-}
-
 // src/vite-server-hooks.ts
 function warnThrough(ctx) {
   return (message) => {
@@ -3083,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);
@@ -3113,64 +2412,6 @@ function serverHooks(context) {
   };
 }
 
-// src/vite-report.ts
-function withSourceRoot(source, sourceRoot) {
-  if (!sourceRoot || /^(?:[a-z][a-z\d+.-]*:|\/)/i.test(source)) return source;
-  return `${sourceRoot.replace(/\/$/, "")}/${source}`;
-}
-function locate2(diagnostic, input) {
-  const text = formatDiagnostic(diagnostic, { extend: input.extend });
-  const origin = input.incoming?.originalPositionFor({
-    line: diagnostic.line,
-    column: diagnostic.column - 1
-  });
-  if (origin === void 0) {
-    const position = { line: diagnostic.line, column: diagnostic.column };
-    return { text, file: input.file, isProcessed: true, ...position };
-  }
-  return {
-    text,
-    file: withSourceRoot(origin.source, input.incoming?.sourceRoot),
-    isProcessed: false,
-    line: origin.line,
-    column: origin.column + 1
-  };
-}
-function withNoMapNote(body, input, at) {
-  if (!at.isProcessed) return body;
-  const reason = input.incoming === void 0 ? "no source map" : "the source map does not cover it";
-  const note = `(position in ${input.file} as processed; ${reason})`;
-  const lines = body.split("\n");
-  const hasAvailable = lines.at(-1)?.startsWith("Available: ") === true;
-  lines.splice(hasAvailable ? -1 : lines.length, 0, note);
-  return lines.join("\n");
-}
-function logFor(message, input, at) {
-  return {
-    message,
-    id: input.id,
-    loc: { file: at.file, line: at.line, column: at.column - 1 }
-  };
-}
-function frame(at) {
-  return `${at.file}:${at.line}:${at.column}: `;
-}
-function reportDiagnostics(input) {
-  if (input.onUnknown === "ignore" || input.diagnostics.length === 0) return;
-  const inSourceOrder = input.diagnostics.toSorted((a, b) => a.offset - b.offset);
-  const located = inSourceOrder.map((diagnostic) => locate2(diagnostic, input));
-  if (input.onUnknown === "warn") {
-    for (const at of located) {
-      const message2 = withNoMapNote(`${frame(at)}${at.text}`, input, at);
-      input.ctx.warn(logFor(message2, input, at));
-    }
-    return;
-  }
-  const first = located[0];
-  const message = withNoMapNote(`${frame(first)}${foldLocated(located)}`, input, first);
-  input.ctx.error(logFor(message, input, first));
-}
-
 // src/vite-transform.ts
 function incomingMapOf(input) {
   if (!input.hasStylesheetMaps) return void 0;
@@ -3184,15 +2425,22 @@ function transformStylesheet(input) {
     extend: input.extend,
     onUnknown: input.onUnknown,
     from: file,
-    inputSourceMap
+    inputSourceMap,
+    reportStaleMarkers: input.reportStaleMarkers
   });
+  const incoming = inputSourceMap && decodeIncomingMap(inputSourceMap);
+  reportOrderWarnings(
+    { ctx: input.ctx, id: input.id, file, incoming, warnings: result.warnings },
+    input.warnings.memory,
+    input.warnings.command
+  );
   reportDiagnostics({
     ctx: input.ctx,
     diagnostics: result.diagnostics,
     extend: input.extend,
     id: input.id,
     file,
-    incoming: inputSourceMap && decodeIncomingMap(inputSourceMap),
+    incoming,
     onUnknown: input.onUnknown
   });
   return { code: result.css, map: result.map };
@@ -3205,8 +2453,18 @@ function hasStylesheetMapsFor(config) {
 function withForwardSlashes(file) {
   return file.replaceAll("\\", "/");
 }
-function createStylesheets(extend, onUnknown) {
-  let hasStylesheetMaps = false;
+function settingsOf(config) {
+  if (config === void 0) return { hasStylesheetMaps: false, reportStaleMarkers: true };
+  return {
+    hasStylesheetMaps: hasStylesheetMapsFor(config),
+    reportStaleMarkers: config.css?.transformer !== "lightningcss"
+  };
+}
+function warningsOf(context) {
+  return { command: context.command, memory: context.state.orderWarnings };
+}
+function createStylesheets(extend, onUnknown, context) {
+  let settings = settingsOf(void 0);
   const failed = /* @__PURE__ */ new Map();
   async function expand(ctx, code, id) {
     const environment = ctx.environment?.name ?? "client";
@@ -3220,19 +2478,26 @@ function createStylesheets(extend, onUnknown) {
       throw error;
     }
     failed.get(environment)?.delete(id);
-    return transformStylesheet({ ctx, code, id, extend: atoms, onUnknown, hasStylesheetMaps });
+    return transformStylesheet({
+      ctx,
+      code,
+      id,
+      extend: atoms,
+      onUnknown,
+      ...settings,
+      warnings: warningsOf(context)
+    });
   }
   return {
     configure(config) {
-      hasStylesheetMaps = hasStylesheetMapsFor(config);
+      settings = settingsOf(config);
     },
     async transform(ctx, code, id) {
       if (!isStylesheetId(id)) return;
       const environment = ctx.environment?.name ?? "client";
-      const hasDirective = canHoldDirective(code);
-      if (!hasDirective) failed.get(environment)?.delete(id);
-      const result = hasDirective ? await expand(ctx, code, id) : void 0;
-      return result;
+      if (canHoldDirective(code)) return expand(ctx, code, id);
+      failed.get(environment)?.delete(id);
+      noteNoDirective(context.state.orderWarnings, id);
     },
     hotUpdate(ctx, hot) {
       const ids = failed.get(ctx.environment.name);
@@ -3254,7 +2519,7 @@ function createStylesheets(extend, onUnknown) {
 // src/vite.ts
 function assemble(options, extend) {
   const context = createUsedContext(resolveUsedOptions(options), extend);
-  const stylesheets = createStylesheets(extend, options.onUnknown ?? "error");
+  const stylesheets = createStylesheets(extend, options.onUnknown ?? "error", context);
   const nave = {
     name: "nave",
     config: (_config, env) => usedConfig(context, env?.command),
@@ -3281,26 +2546,18 @@ function assemble(options, extend) {
       return devServing.modulesWithGrown(context, this, hot);
     },
     async renderChunk(_code, chunk) {
-      if (!isUsed(context) || this.environment.config.consumer !== "client") return;
+      if (!isUsed(context) || !canWriteStylesheets(context, this.environment)) return;
       const emitted = emittedSet(context, this.environment, (message) => {
         this.warn(message);
       });
-      await refeedChunkStylesheets(this, chunk, context.state, emitted);
+      const fed = withoutWhole(chunk, stylesheetsLeftWhole(context, this.environment, chunk));
+      await refeedChunkStylesheets(this, fed, context.state, emitted);
       warnTextImports(this, chunk, context, emitted);
     },
     generateBundle: {
       order: "post",
-      handler(_options, bundle) {
-        if (isUsed(context) && this.environment?.config.consumer === "client") {
-          checkAtomicLayers(
-            this,
-            bundle,
-            emittedSet(context, this.environment, (message) => {
-              this.warn(message);
-            })
-          );
-        }
-        scanBundle(this, bundle);
+      handler(options2, bundle) {
+        checkBundle(this, context, { bundle, options: options2, pass: "post" });
       }
     }
   };