@navecss/core 0.4.0 → 0.5.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, withRestorers, pruneAtomicLayer, atomsWrittenIn, applyEdits, compareText, inspectAtomicLayer, withoutRemoved, CX_SOURCE, toSourceMap, unprunedAtoms, isSecondHop, buildReport, atomOfClass, moduleReport, isListableReexport, CLASS_MAP_NOT_PARSED, isNode, readModule, combinedMapOf, placerFor, cxModulesArray, nodeAt, staticStringOf, pushAll, childrenOf, nodesAt, LINE_UNKNOWN_WITHOUT_MAP, LINE_UNKNOWN_UNMAPPED, exportNameOf, analyze, memberReadOf, patternDestructuring, stringAt, propertyNameOf } from './chunk-BCUK4M4P.js';
+import { validateExtendAtomsHostFree } from './chunk-63H2FLGU.js';
 import { 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-MWHZ26S4.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);
+      }
     }
   };
 }
@@ -142,26 +151,838 @@ function registry(assemble2) {
   };
   return { pickers, configure };
 }
-function shareAcrossBuilds(assemble2) {
-  const { pickers, configure } = registry(assemble2);
-  return [firstHalf(pickers, configure), secondHalf(pickers)];
+function shareAcrossBuilds(assemble2) {
+  const { pickers, configure } = registry(assemble2);
+  return [firstHalf(pickers, configure), secondHalf(pickers)];
+}
+
+// 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 noteReloadSent(state, id) {
+  state.reloading.set(id, Date.now());
+  if (state.listening === 0) state.unheard.add(id);
+}
+
+// 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 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
+  };
+}
+function locate(diagnostic, input) {
+  return locateAt(diagnostic, formatDiagnostic(diagnostic, { extend: input.extend }), input);
+}
+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) => 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));
+}
+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));
+      }
+    };
+  });
+}
+
+// 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();
+  }
+}
+
+// src/vite-writers.ts
+function freshWriters() {
+  return {
+    emittedBy: void 0,
+    firstWriter: void 0,
+    fixed: /* @__PURE__ */ new Map(),
+    writers: /* @__PURE__ */ new Map(),
+    whole: /* @__PURE__ */ new Set(),
+    wholeAssets: /* @__PURE__ */ new Set()
+  };
+}
+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 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 servedAtoms(state, kept) {
+  return withRestorers(collectedAtoms(state, kept));
+}
+function recordsOf(state, environment) {
+  const prefix = `${environment}\0`;
+  return [...state.modules].filter(([key]) => key.startsWith(prefix)).map(([, record]) => record);
+}
+
+// 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 };
+}
+
+// src/vite-css-id.ts
+var STYLESHEET = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+var SPECIAL_QUERY = /[?&](?:worker|sharedworker|raw|url)\b/;
+var CSS_MODULE = /\.module\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+var TEXT_QUERY = /[?&](?:inline|direct|transform-only)\b/;
+function isStylesheetPath(id) {
+  return STYLESHEET.test(id);
+}
+function isStylesheetId(id) {
+  return STYLESHEET.test(id) && !SPECIAL_QUERY.test(id);
+}
+function isCssModuleId(id) {
+  return isStylesheetId(id) && CSS_MODULE.test(id) && !TEXT_QUERY.test(id);
+}
+function isUnreadStylesheet(id) {
+  return isStylesheetId(id) && !isCssModuleId(id);
+}
+function canHoldDirective(code) {
+  return /@[n\\]/i.test(code);
+}
+function filePathOf(id) {
+  const query = id.indexOf("?");
+  return query === -1 ? id : id.slice(0, query);
+}
+var NAVE_MODULE_DIRS = ["src", "dist"].map(
+  (name) => `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", name).replaceAll("\\", "/")}/`
+);
+function pathOfId(id) {
+  return filePathOf(id).replaceAll("\\", "/");
+}
+function isNaveOwn(id) {
+  const file = pathOfId(id);
+  return NAVE_MODULE_DIRS.some((directory) => file.startsWith(directory));
+}
+function isDependencyId(id) {
+  return pathOfId(id).includes("/node_modules/");
+}
+async function packageNameOf(file, cache) {
+  const directory = path.dirname(file);
+  const cached = cache.get(directory);
+  if (cached) return cached;
+  const found = nameAbove(directory, cache);
+  cache.set(directory, found);
+  return found;
+}
+async function nameAbove(directory, cache) {
+  const name = await readName(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(path.join(directory, "package.json"), "utf8"));
+    return typeof manifest.name === "string" ? manifest.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function moduleLabel(root, id) {
+  const file = filePathOf(id);
+  if (file.startsWith("\0")) return String.raw`\0${file.slice(1)}`;
+  if (!path.isAbsolute(file)) return file;
+  return path.relative(root, file).replaceAll("\\", "/");
+}
+
+// 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);
+}
+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 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
+    });
+  }
+  return reading;
+}
+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 lines;
+}
+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");
+}
+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.`
+    );
+  }
+}
+
+// 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));
+}
+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 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";
+  }
+  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 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}.`)
+  );
+}
+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 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-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 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 {
+    findings: assets.flatMap((asset) => findingsInText(asset.fileName, textOf2(asset))),
+    names: assets.map((asset) => asset.fileName)
+  };
+}
+
+// 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 withoutWhole(chunk, whole) {
+  if (whole.size === 0) return chunk;
+  return {
+    modules: Object.fromEntries(Object.entries(chunk.modules).filter(([id]) => !whole.has(id)))
+  };
+}
+function assetKey(environment, entry) {
+  return `${environment}|${(entry.names ?? []).join(",")}|${(entry.originalFileNames ?? []).join(",")}`;
+}
+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 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-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))
+  );
+}
+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) });
+}
+function failOnFindings(ctx, read) {
+  if (read.findings.size === 0) return;
+  ctx.error({ message: scanMessage(read.findings.values().toArray(), read.assets.size) });
+}
+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
+function isListed(context, pkg) {
+  return pkg !== void 0 && Object.hasOwn(context.options.keepFor, pkg);
+}
+var NOT_PARSED = "the module could not be read, so the atoms it names would not ship: it did not parse as JavaScript. TypeScript and JSX must be compiled by Vite's own transform first, so leave oxc on for this file.";
+var TOO_DEEP = "the module could not be read, so the atoms it names would not ship: it is nested too deeply.";
+function unreadableRecord(context, input, text) {
+  const { code, id, pkg } = input;
+  const file = moduleLabel(context.root, id);
+  const problem = {
+    kind: "unreadable",
+    offset: 0,
+    construct: "",
+    text,
+    file,
+    pkg,
+    line: 1,
+    column: 1
+  };
+  const isStandingIn = isListed(context, pkg);
+  return {
+    // The classes written whole need no parse to be found.
+    atoms: atomsWrittenIn(code),
+    problems: isStandingIn ? [] : [problem],
+    suppressed: isStandingIn ? [problem] : [],
+    dynamicCalls: [],
+    pkg,
+    file
+  };
+}
+var SOURCE_TYPES = /* @__PURE__ */ new Set(["js", "jsx", "ts", "tsx"]);
+function jsonStrings(code) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(code);
+  } catch {
+    return [];
+  }
+  const strings = [];
+  const stack = [parsed2];
+  while (stack.length > 0) {
+    const value = stack.pop();
+    if (typeof value === "string") strings.push(value);
+    else if (Array.isArray(value)) {
+      for (const item of value) stack.push(item);
+    } else if (typeof value === "object" && value !== null) {
+      for (const key of Object.keys(value)) strings.push(key);
+      for (const item of Object.values(value)) stack.push(item);
+    }
+  }
+  return strings;
+}
+function textRecord(context, input) {
+  const { code, id, moduleType, pkg } = input;
+  const decoded = moduleType === "json" ? jsonStrings(code) : [];
+  return {
+    atoms: new Set(
+      [atomsWrittenIn(code), ...decoded.map((text) => atomsWrittenIn(text))].flatMap((found) => [
+        ...found
+      ])
+    ),
+    problems: [],
+    suppressed: [],
+    dynamicCalls: [],
+    pkg,
+    file: moduleLabel(context.root, id)
+  };
 }
 
-// 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-css-module-record.ts
+function stringOf(node) {
+  return node?.type === "Literal" && typeof node.value === "string" ? node.value : void 0;
 }
-function isStylesheetId(id) {
-  return STYLESHEET.test(id) && !SPECIAL_QUERY.test(id);
+function namedStrings(declaration) {
+  return nodesAt(declaration, "declarations").map(
+    (declarator) => stringOf(nodeAt(declarator, "init")) ?? ""
+  );
 }
-function canHoldDirective(code) {
-  return /@[n\\]/i.test(code);
+function defaultStrings(declaration) {
+  return nodesAt(declaration, "properties").map(
+    (property) => stringOf(nodeAt(property, "value")) ?? ""
+  );
 }
-function filePathOf(id) {
-  const query = id.indexOf("?");
-  return query === -1 ? id : id.slice(0, query);
+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 !== "");
+}
+function cssModuleRecord(context, ctx, input) {
+  const { code, id, pkg } = input;
+  let program;
+  try {
+    program = ctx.parse(code);
+  } catch {
+    const unreadable = unreadableRecord(context, { code: "", id, pkg }, CLASS_MAP_NOT_PARSED);
+    return {
+      ...unreadable,
+      problems: [...unreadable.problems, ...unreadable.suppressed],
+      suppressed: []
+    };
+  }
+  const strings = isNode(program) ? exportedStrings(program) : [];
+  return textRecord(context, { code: strings.join("\n"), id, pkg });
+}
+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;
 }
 
 // src/vite-cx-text-test.ts
@@ -189,8 +1010,8 @@ function fileOf(id) {
   return filePathOf(id).replaceAll("\\", "/");
 }
 function namesOf(file) {
-  const name = path2.basename(file, path2.extname(file));
-  return name === "index" ? [name, path2.basename(path2.dirname(file))] : [name];
+  const name = path.basename(file, path.extname(file));
+  return name === "index" ? [name, path.basename(path.dirname(file))] : [name];
 }
 function entriesNaming(declared, id) {
   const file = fileOf(id);
@@ -213,7 +1034,7 @@ async function resolveOrNull(resolver, source, importer) {
   }
 }
 async function resolveEntries(context, resolver) {
-  const from = path2.join(context.root, "index.html");
+  const from = path.join(context.root, "index.html");
   const nave = await resolveOrNull(resolver, CX_SOURCE, from);
   const naveFile = nave === void 0 ? void 0 : fileOf(nave.id);
   const resolved = await Promise.all(
@@ -256,7 +1077,7 @@ function lastSegmentOf(specifier) {
 function isNamingListed(specifier, declared) {
   const segment = lastSegmentOf(specifier);
   if (declared.names.has(segment)) return true;
-  const extension = path2.extname(segment);
+  const extension = path.extname(segment);
   return extension !== "" && declared.names.has(segment.slice(0, -extension.length));
 }
 function isAboutListed(input, declared) {
@@ -273,49 +1094,6 @@ function isMentioningDeclared(code, declared) {
 function recognisedKey(environment, file, importer) {
   return `${environment}\0${file}\0${importer}`;
 }
-var NAVE_MODULE_DIRS = ["src", "dist"].map(
-  (name) => `${path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", name).replaceAll("\\", "/")}/`
-);
-function pathOfId(id) {
-  return filePathOf(id).replaceAll("\\", "/");
-}
-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 cached = cache.get(directory);
-  if (cached) return cached;
-  const found = nameAbove(directory, cache);
-  cache.set(directory, found);
-  return found;
-}
-async function nameAbove(directory, cache) {
-  const name = await readName(directory);
-  const parent = path2.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"));
-    return typeof manifest.name === "string" ? manifest.name : void 0;
-  } catch {
-    return void 0;
-  }
-}
-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("\\", "/");
-}
-
-// src/vite-cx-importers.ts
 function importerIdsOf(ctx, cxId) {
   const info = ctx.getModuleInfo?.(cxId);
   return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
@@ -380,7 +1158,7 @@ async function lineOf(ctx, context, importer, known) {
   return isRead ? void 0 : lineFor(label, []);
 }
 async function checkCxImporters(ctx, context) {
-  const resolved = await ctx.resolve?.(CX_SOURCE, path2.join(context.root, "index.html"));
+  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 = [];
@@ -498,192 +1276,53 @@ function removeServerKeepMap(owner) {
   publish();
 }
 
-// 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 noteReloadSent(state, id) {
-  state.reloading.set(id, Date.now());
-  if (state.listening === 0) state.unheard.add(id);
-}
-
-// 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,
-    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()
-  };
-}
-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 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 withRestorers(atoms) {
-  if (atoms.has("srOnly")) atoms.add("srOnlyFocusable");
-  return atoms;
-}
-function servedAtoms(state, kept) {
-  return withRestorers(collectedAtoms(state, kept));
-}
-function recordsOf(state, environment) {
-  const prefix = `${environment}\0`;
-  return [...state.modules].filter(([key]) => key.startsWith(prefix)).map(([, record]) => record);
-}
-
-// 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);
-}
-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);
-    }
-  }
-}
-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-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;
 }
 
-// src/vite-unread-record.ts
-function isListed(context, pkg) {
-  return pkg !== void 0 && Object.hasOwn(context.options.keepFor, pkg);
-}
-var NOT_PARSED = "the module could not be read, so the atoms it names would not ship: it did not parse as JavaScript. TypeScript and JSX must be compiled by Vite's own transform first, so leave oxc on for this file.";
-var TOO_DEEP = "the module could not be read, so the atoms it names would not ship: it is nested too deeply.";
-function unreadableRecord(context, input, text) {
-  const { code, id, pkg } = input;
-  const file = moduleLabel(context.root, id);
-  const problem = {
-    kind: "unreadable",
-    offset: 0,
-    construct: "",
-    text,
-    file,
-    pkg,
-    line: 1,
-    column: 1
-  };
-  const isStandingIn = isListed(context, pkg);
-  return {
-    // The classes written whole need no parse to be found.
-    atoms: atomsWrittenIn(code),
-    problems: isStandingIn ? [] : [problem],
-    suppressed: isStandingIn ? [problem] : [],
-    dynamicCalls: [],
-    pkg,
-    file
-  };
-}
-var SOURCE_TYPES = /* @__PURE__ */ new Set(["js", "jsx", "ts", "tsx"]);
-function jsonStrings(code) {
-  let parsed2;
-  try {
-    parsed2 = JSON.parse(code);
-  } catch {
-    return [];
-  }
-  const strings = [];
-  const stack = [parsed2];
-  while (stack.length > 0) {
-    const value = stack.pop();
-    if (typeof value === "string") strings.push(value);
-    else if (Array.isArray(value)) {
-      for (const item of value) stack.push(item);
-    } else if (typeof value === "object" && value !== null) {
-      for (const key of Object.keys(value)) strings.push(key);
-      for (const item of Object.values(value)) stack.push(item);
+// 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);
+}
+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);
     }
   }
-  return strings;
 }
-function textRecord(context, input) {
-  const { code, id, moduleType, pkg } = input;
-  const decoded = moduleType === "json" ? jsonStrings(code) : [];
-  return {
-    atoms: new Set(
-      [atomsWrittenIn(code), ...decoded.map((text) => atomsWrittenIn(text))].flatMap((found) => [
-        ...found
-      ])
-    ),
-    problems: [],
-    suppressed: [],
-    dynamicCalls: [],
-    pkg,
-    file: moduleLabel(context.root, id)
-  };
+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-used.ts
@@ -730,7 +1369,9 @@ async function ownAtomNames(context, watch = ignoreWatch) {
 // 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);
+  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));
 }
 var NO_PLACE = { line: 0, column: 0 };
 function isInlineScript(id) {
@@ -740,7 +1381,7 @@ 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) {
+function locate2(problems, placing) {
   return problems.map((problem) => {
     const place = placing.place(problem.offset);
     const where = place ?? { ...NO_PLACE, unknownLine: placing.unknownLine };
@@ -793,8 +1434,8 @@ async function recordOf(context, ctx, input, reading) {
   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) : [],
+    problems: isStandingIn ? [] : locate2(reading.problems, placing),
+    suppressed: isStandingIn ? locate2(reading.problems, placing) : [],
     dynamicCalls: locateDynamic(reading, placing),
     pkg,
     file: placing.file,
@@ -849,11 +1490,11 @@ async function recordModule(context, ctx, module) {
   }
   const isDependency = isDependencyId(id);
   const pkg = isDependency ? await packageNameOf(filePathOf(id), context.packageNames) : void 0;
-  if (moduleType !== void 0 && !SOURCE_TYPES.has(moduleType)) {
+  const unparsed = recordWithoutCalls(context, ctx, { code, id, moduleType, pkg });
+  if (unparsed) {
     context.state.exposures.delete(key);
-    const record2 = textRecord(context, { code, id, moduleType, pkg });
-    context.state.modules.set(key, record2);
-    return record2;
+    context.state.modules.set(key, unparsed);
+    return unparsed;
   }
   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);
@@ -1022,7 +1663,7 @@ async function specifiersInto(ctx, context, input) {
   return found.values().toArray().toSorted(compareText);
 }
 async function clearingSpecifier(ctx, context, input) {
-  const from = path2.join(context.root, "index.html");
+  const from = path.join(context.root, "index.html");
   const file = fileOf(input.id);
   if (await isResolvingTo(ctx, { file, from, specifier: input.pkg })) return input.pkg;
   const specifiers = await specifiersInto(ctx, context, input);
@@ -1079,9 +1720,9 @@ function entryOf(declared, id) {
 }
 async function replacementFor(ctx, input) {
   const file = fileOf(input.id);
-  const extension = path2.posix.extname(file);
+  const extension = path.posix.extname(file);
   const relativeTo = (target) => {
-    const relative = path2.posix.relative(path2.posix.dirname(fileOf(input.importer)), 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);
@@ -1248,6 +1889,9 @@ async function transformQuietly(environment, url) {
   } catch {
   }
 }
+function isEndOfRead(module) {
+  return module.id !== null && isCssModuleId(module.id);
+}
 async function transformReachable(environment, roots) {
   const seen = new Set(roots);
   let level = [...roots];
@@ -1255,8 +1899,9 @@ async function transformReachable(environment, roots) {
     const next = [];
     await Promise.all(
       level.map(async (module) => {
-        if (module.id !== null && isStylesheetId(module.id)) return;
+        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);
@@ -1283,6 +1928,7 @@ async function readAhead(context, environment, 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);
     }
@@ -1308,313 +1954,13 @@ function takeStaleModules(context, environment) {
 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));
+  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-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);
-  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;
-    }
-  };
-}
-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;
-  }
-  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;
-  }
-}
-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]);
-  }
-  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;
-    }
-  }
-  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);
-}
-
-// 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;
-}
-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 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 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));
-}
-
 // src/vite-dev.ts
 var RELOAD_ANSWER_MS = 2e3;
 var NO_MAP = JSON.stringify({ mappings: "" });
@@ -1683,174 +2029,37 @@ var devServing = {
   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") 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);
-}
-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.`
-    );
-  }
-}
-
-// 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));
-}
-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 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 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}.`)
-  );
-}
-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 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);
+    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);
   }
+  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-cx-reexported.ts
@@ -2429,33 +2638,78 @@ function decideReexports(prepared, serverImports) {
 }
 
 // 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 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 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 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);
+}
 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 +2740,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 +2755,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 +2769,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 +2794,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 +2833,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 +2870,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 +2879,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 +2889,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 +2904,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 +2930,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,14 +2954,14 @@ 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);
 }
 async function problemsOfBuild(ctx, context, serverImports) {
   const records = recordsOf(context.state, ctx.environment.name);
@@ -2772,9 +3030,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 +3052,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 +3119,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 +3175,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) => {
@@ -3113,64 +3217,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 +3230,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 +3258,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 +3283,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 +3324,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 +3351,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" });
       }
     }
   };