@navecss/core 0.2.0 → 0.4.0

package/dist/vite.js

@@ -0,0 +1,3318 @@
+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 { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
+import { snapshotExtendMap, expandText, foldLocated } from './chunk-LADFXRWQ.js';
+import { tokenize } from './chunk-NFS2REPQ.js';
+import { decodeIncomingMap, formatDiagnostic } from './chunk-SYNQJNVB.js';
+import './chunk-CUL5PLPI.js';
+import { atomClassMap } from './chunk-GZL2VW7C.js';
+import { readFile } from 'fs/promises';
+import path2 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) {
+  return !id.includes("?") && id.toLowerCase().endsWith(".html") ? id : void 0;
+}
+function firstHalf(pickers, configure) {
+  const workerPlugin = {
+    name: "nave:collect-worker",
+    enforce: "post",
+    transform(code, id, meta) {
+      const [plugin] = pickers.forHook(this).nave.config()?.worker.plugins() ?? [];
+      return plugin?.transform.call(this, code, id, meta) ?? Promise.resolve(void 0);
+    },
+    buildEnd(error) {
+      const [plugin] = pickers.forHook(this).nave.config()?.worker.plugins() ?? [];
+      return plugin?.buildEnd.call(this, error) ?? Promise.resolve();
+    }
+  };
+  return {
+    name: "nave",
+    config(userConfig, env) {
+      const config = pickers.latest().nave.config(userConfig, env);
+      return config && { ...config, worker: { plugins: () => [workerPlugin] } };
+    },
+    configEnvironment: (name, options) => pickers.latest().nave.configEnvironment(name, options),
+    configResolved(config) {
+      configure(config).nave.configResolved(config);
+    },
+    configureServer(server) {
+      pickers.latest().nave.configureServer(server);
+    },
+    closeBundle() {
+      pickers.latest().nave.closeBundle.call(this);
+    },
+    buildApp: {
+      order: "post",
+      handler(builder) {
+        return pickers.latest().nave.buildApp.handler.call(this, builder);
+      }
+    },
+    transform(code, id) {
+      const page = htmlPageOf(id);
+      if (page !== void 0) pickers.notePage(page, this, code);
+      return pickers.forHook(this).nave.transform.call(this, code, id);
+    },
+    hotUpdate(options) {
+      return pickers.forHook(this).nave.hotUpdate.call(this, options);
+    },
+    renderChunk(code, chunk) {
+      return pickers.forHook(this).nave.renderChunk.call(this, code, chunk);
+    },
+    generateBundle: {
+      order: "post",
+      handler(options, bundle) {
+        pickers.forHook(this).nave.generateBundle.handler.call(this, options, bundle);
+      }
+    }
+  };
+}
+function secondHalf(pickers) {
+  return {
+    name: "nave:collect",
+    enforce: "post",
+    transform(code, id, meta) {
+      return pickers.forHook(this).collect.transform.call(this, code, id, meta);
+    },
+    transformIndexHtml: {
+      order: "pre",
+      handler(html, page) {
+        for (const build of pickers.forPage(page.filename, html)) {
+          build.collect.transformIndexHtml.handler(html, page);
+        }
+        return;
+      }
+    },
+    buildStart() {
+      return pickers.forHook(this).collect.buildStart.call(this);
+    },
+    buildEnd(error) {
+      return pickers.forHook(this).collect.buildEnd.call(this, error);
+    }
+  };
+}
+function isInside(root, file) {
+  const base = root.endsWith("/") ? root : `${root}/`;
+  return file.startsWith(base);
+}
+function registry(assemble2) {
+  const byInvocation = /* @__PURE__ */ new WeakMap();
+  const roots = /* @__PURE__ */ new Map();
+  const pages = /* @__PURE__ */ new Map();
+  let latest = assemble2();
+  const find = (host) => {
+    const config = host.environment?.config;
+    if (config?.inlineConfig === void 0) return void 0;
+    return byInvocation.get(config.inlineConfig)?.get(config.command ?? "build");
+  };
+  const pickers = {
+    latest: () => latest,
+    forHook: (host) => find(host) ?? latest,
+    notePage(filename, host, code) {
+      const compiling = pages.get(filename) ?? /* @__PURE__ */ new Map();
+      const build = find(host) ?? latest;
+      compiling.delete(build);
+      pages.set(filename, compiling.set(build, code));
+    },
+    forPage(filename, html) {
+      if (filename === void 0) return [latest];
+      const compiling = pages.get(filename);
+      if (compiling && compiling.size > 0) {
+        const owner = [...compiling].find(([, code]) => code === html)?.[0] ?? compiling.keys().next().value;
+        compiling.delete(owner);
+        return [owner];
+      }
+      const holding = [...roots].filter(([, root]) => isInside(root, filename)).map(([b]) => b);
+      return holding.length > 0 ? holding : [latest];
+    }
+  };
+  const configure = (config) => {
+    const key = config.inlineConfig ?? config;
+    const commands = byInvocation.get(key) ?? /* @__PURE__ */ new Map();
+    byInvocation.set(key, commands);
+    const build = commands.get(config.command) ?? assemble2();
+    commands.set(config.command, build);
+    roots.set(build, config.root);
+    latest = build;
+    return build;
+  };
+  return { pickers, configure };
+}
+function shareAcrossBuilds(assemble2) {
+  const { pickers, configure } = registry(assemble2);
+  return [firstHalf(pickers, configure), secondHalf(pickers)];
+}
+
+// src/vite-css-id.ts
+var STYLESHEET = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+var SPECIAL_QUERY = /[?&](?:worker|sharedworker|raw|url)\b/;
+function isStylesheetPath(id) {
+  return STYLESHEET.test(id);
+}
+function isStylesheetId(id) {
+  return STYLESHEET.test(id) && !SPECIAL_QUERY.test(id);
+}
+function canHoldDirective(code) {
+  return /@[n\\]/i.test(code);
+}
+function filePathOf(id) {
+  const query = id.indexOf("?");
+  return query === -1 ? id : id.slice(0, query);
+}
+
+// src/vite-cx-text-test.ts
+function literalPattern(text) {
+  return text.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
+}
+var INSIDE = String.raw`[^\n'"\x60\\]{0,512}`;
+var EXTENSION = String.raw`\.[^\n'"\x60\\/?#.]*`;
+var QUOTE = String.raw`['"\x60]`;
+function textTestOf(names) {
+  if (names.size === 0) return void 0;
+  const listed = [...names].map((name) => literalPattern(name)).join("|");
+  const named = `${QUOTE}(?:${INSIDE}/)?(?:${listed})(?:${EXTENSION})?/*(?:[?#]${INSIDE})?${QUOTE}`;
+  const directory = String.raw`(?:\bfrom|\bimport)\s*(?:\(\s*)?${QUOTE}\.{1,2}(?:/\.{1,2})*/?${QUOTE}`;
+  return new RegExp(names.has("index") ? `${named}|${directory}` : named);
+}
+
+// src/vite-cx-modules.ts
+function isRelative(text) {
+  const cut = text.search(/[#?]/);
+  const path10 = cut === -1 ? text : text.slice(0, cut);
+  return path10 === "." || path10 === ".." || path10.startsWith("./") || path10.startsWith("../");
+}
+function fileOf(id) {
+  return filePathOf(id).replaceAll("\\", "/");
+}
+function namesOf(file) {
+  const name = path2.basename(file, path2.extname(file));
+  return name === "index" ? [name, path2.basename(path2.dirname(file))] : [name];
+}
+function entriesNaming(declared, id) {
+  const file = fileOf(id);
+  return declared.ids.entries().filter(([, resolved]) => fileOf(resolved) === file).map(([entry]) => entry).toArray();
+}
+async function declaredModulesFor(context, resolver, environment) {
+  const { cxModules } = context.options;
+  if (cxModules.length === 0) return void 0;
+  const known = context.state.declared.get(environment);
+  if (known) return known;
+  const made = resolveEntries(context, resolver);
+  context.state.declared.set(environment, made);
+  return made;
+}
+async function resolveOrNull(resolver, source, importer) {
+  try {
+    return await resolver.resolve?.(source, importer) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveEntries(context, resolver) {
+  const from = path2.join(context.root, "index.html");
+  const nave = await resolveOrNull(resolver, CX_SOURCE, from);
+  const naveFile = nave === void 0 ? void 0 : fileOf(nave.id);
+  const resolved = await Promise.all(
+    context.options.cxModules.map(async (entry) => {
+      const found = await resolveOrNull(resolver, entry, from);
+      return [entry, found?.id];
+    })
+  );
+  const kept = resolved.filter(
+    ([entry, id]) => entry !== CX_SOURCE && (id === void 0 || fileOf(id) !== naveFile)
+  );
+  const ids = new Map(kept.filter((pair) => pair[1] !== void 0));
+  const files = new Set(ids.values().map((id) => fileOf(id)));
+  const names = new Set(files.values().flatMap((file) => namesOf(file)));
+  return {
+    entries: new Set(kept.map(([entry]) => entry).filter((entry) => !isRelative(entry))),
+    ids,
+    files,
+    names,
+    textTest: textTestOf(names)
+  };
+}
+function forgetDeclared(state, environment) {
+  state.declared.delete(environment);
+  const prefix = `${environment}\0`;
+  for (const key of state.recognised.keys())
+    if (key.startsWith(prefix)) state.recognised.delete(key);
+}
+function withoutTrailingSlashes(text) {
+  let end = text.length;
+  while (end > 0 && text[end - 1] === "/") end -= 1;
+  return text.slice(0, end);
+}
+function lastSegmentOf(specifier) {
+  const cut = specifier.slice(1).search(/[#?]/);
+  const bare = withoutTrailingSlashes(cut === -1 ? specifier : specifier.slice(0, cut + 1));
+  const segment = bare.slice(bare.lastIndexOf("/") + 1);
+  return segment === "." || segment === ".." ? "index" : segment;
+}
+function isNamingListed(specifier, declared) {
+  const segment = lastSegmentOf(specifier);
+  if (declared.names.has(segment)) return true;
+  const extension = path2.extname(segment);
+  return extension !== "" && declared.names.has(segment.slice(0, -extension.length));
+}
+function isAboutListed(input, declared) {
+  if (!declared) return false;
+  return isListedFile(declared, input.id) || isMentioningDeclared(input.code, declared);
+}
+function isListedFile(declared, id) {
+  return declared.files.has(fileOf(id));
+}
+function isMentioningDeclared(code, declared) {
+  for (const entry of declared.entries) if (code.includes(entry)) return true;
+  return declared.textTest?.test(code) ?? false;
+}
+function recognisedKey(environment, file, importer) {
+  return `${environment}\0${file}\0${importer}`;
+}
+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 ?? []])];
+}
+async function isStoodInFor(context, id) {
+  if (!isDependencyId(id)) return false;
+  const pkg = await packageNameOf(filePathOf(id), context.packageNames);
+  return pkg !== void 0 && Object.hasOwn(context.options.keepFor, pkg);
+}
+async function candidateOf(ctx, context, id) {
+  const code = ctx.getModuleInfo?.(id)?.code;
+  if (code === null || code === void 0 || isNaveOwn(id)) return void 0;
+  return await isStoodInFor(context, id) ? void 0 : { id, code };
+}
+function specifiersIn(program) {
+  const found = /* @__PURE__ */ new Map();
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const where = nodeAt(node, "source");
+    const source = staticStringOf(where);
+    if (where !== void 0 && source !== void 0) {
+      found.set(source, Math.min(found.get(source) ?? Infinity, where.start));
+    }
+    pushAll(stack, childrenOf(node));
+  }
+  return [...found].toSorted(([, a], [, b]) => a - b).map(([source]) => source);
+}
+function specifiersOf(ctx, importer) {
+  try {
+    return specifiersIn(ctx.parse?.(importer.code));
+  } catch {
+    return void 0;
+  }
+}
+async function isResolvingToCx(ctx, specifier, importer, known) {
+  if (specifier === CX_SOURCE) return false;
+  const key = `${importer.id}\0${specifier}`;
+  const answered = known.answers.get(key);
+  if (answered !== void 0) return answered;
+  const resolved = await ctx.resolve?.(specifier, importer.id);
+  const isCx = resolved?.id === known.cxId;
+  known.answers.set(key, isCx);
+  return isCx;
+}
+function lineFor(label, specifiers) {
+  if (specifiers.length === 0) {
+    return `${label}: imports cx through a specifier the build does not read.`;
+  }
+  return `${label}: imports cx from ${specifiers.map((specifier) => `'${specifier}'`).join(", ")}.`;
+}
+async function lineOf(ctx, context, importer, known) {
+  const written = specifiersOf(ctx, importer);
+  const unread = [];
+  const specifiers = written ?? [];
+  for (const specifier of specifiers) {
+    if (await isResolvingToCx(ctx, specifier, importer, known)) unread.push(specifier);
+  }
+  const label = moduleLabel(context.root, importer.id);
+  if (unread.length > 0) return lineFor(label, unread);
+  const isRead = written?.includes(CX_SOURCE) ?? importer.code.includes(CX_SOURCE);
+  return isRead ? void 0 : lineFor(label, []);
+}
+async function checkCxImporters(ctx, context) {
+  const resolved = await ctx.resolve?.(CX_SOURCE, path2.join(context.root, "index.html"));
+  if (!resolved) return;
+  const known = { cxId: resolved.id, answers: /* @__PURE__ */ new Map() };
+  const lines = [];
+  for (const id of importerIdsOf(ctx, resolved.id)) {
+    const importer = await candidateOf(ctx, context, id);
+    const line = importer && await lineOf(ctx, context, importer, known);
+    if (line) lines.push(line);
+  }
+  if (lines.length === 0) return;
+  const count = lines.length === 1 ? "1 module imports" : `${lines.length} modules import`;
+  ctx.error(
+    [
+      `${count} cx through a specifier the build does not follow, so the atoms its calls name would not ship:`,
+      ...lines.toSorted(compareText),
+      "Import cx from '@navecss/core/cx' directly where it is called."
+    ].join("\n")
+  );
+}
+
+// src/vite-cx-reading.ts
+async function declaredReadingOf(context, resolver, declared, input) {
+  const { environment, module } = input;
+  const declaredSources = /* @__PURE__ */ new Set();
+  if (!declared) return { declaredSources, isDeclared: false, onlyVia: void 0 };
+  const files = /* @__PURE__ */ new Set();
+  let isOnlyListed = true;
+  for (const source of specifiersIn(module.program)) {
+    if (source === CX_SOURCE) {
+      isOnlyListed = false;
+      continue;
+    }
+    const found = await listedFileOf(resolver, declared, source, module.id);
+    if (!found) continue;
+    declaredSources.add(source);
+    if (found.file === void 0) {
+      isOnlyListed = false;
+      continue;
+    }
+    files.add(found.file);
+    const key = recognisedKey(environment, found.file, module.id);
+    context.state.recognised.set(
+      key,
+      /* @__PURE__ */ new Set([...context.state.recognised.get(key) ?? [], source])
+    );
+  }
+  return {
+    declaredSources,
+    isDeclared: isListedFile(declared, module.id),
+    onlyVia: isOnlyListed && files.size > 0 ? files : void 0
+  };
+}
+async function listedFileFrom(resolver, declared, source, importer) {
+  const resolved = await resolveOrNull(resolver, source, importer);
+  const file = resolved ? fileOf(resolved.id) : void 0;
+  return file !== void 0 && declared.files.has(file) ? file : void 0;
+}
+async function listedFileOf(resolver, declared, source, importer) {
+  if (declared.entries.has(source)) {
+    const id = source.startsWith("#") ? void 0 : declared.ids.get(source);
+    if (id !== void 0) return { file: fileOf(id) };
+    const file2 = await listedFileFrom(resolver, declared, source, importer);
+    return file2 === void 0 && source.startsWith("#") ? void 0 : { file: file2 };
+  }
+  if (!isNamingListed(source, declared)) return void 0;
+  const file = await listedFileFrom(resolver, declared, source, importer);
+  return file === void 0 ? void 0 : { file };
+}
+
+// src/vite-dev-keep.ts
+var KEEP_CONSTANT = "__NAVE_KEEP_CLASSES__";
+function keepMap(kept) {
+  return Object.fromEntries(
+    kept.filter((atom) => Object.hasOwn(atomClassMap, atom)).map((atom) => [atom, atomClassMap[atom]])
+  );
+}
+function devKeepMap(map, atoms) {
+  return new Proxy(map, {
+    getOwnPropertyDescriptor(target, key) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+      if (descriptor === void 0 && typeof key === "string") {
+        const quoted2 = JSON.stringify(key);
+        console.error(
+          atoms.includes(key) ? `[nave] cx.dynamic(${quoted2}) applied no class: ${quoted2} is not in keep or in a keepFor list, and navePlugin() gives cx.dynamic() only the atoms in those lists, in a build as in dev. Add ${quoted2} to keep in navePlugin(), or, when a dependency makes the call, to its list in keepFor.` : `[nave] cx.dynamic(${quoted2}) applied no class: ${quoted2} is not a Nave atom.`
+        );
+      }
+      return descriptor;
+    }
+  });
+}
+function devKeepExpression(map, atoms) {
+  return `(${devKeepMap.toString()})(${JSON.stringify(map)}, ${JSON.stringify(atoms)})`;
+}
+var installs = [];
+var baseline = { held: false, value: void 0 };
+function publish() {
+  const newest = installs.at(-1);
+  if (newest !== void 0) Object.assign(globalThis, { [KEEP_CONSTANT]: newest.map });
+  else if (baseline.held) Object.assign(globalThis, { [KEEP_CONSTANT]: baseline.value });
+  else Reflect.deleteProperty(globalThis, KEEP_CONSTANT);
+}
+function installServerKeepMap(context, owner) {
+  if (context.options.atomic !== "used") return;
+  const map = devKeepMap(keepMap(context.kept), Object.keys(atomClassMap));
+  if (installs.length === 0) {
+    baseline.held = Object.hasOwn(globalThis, KEEP_CONSTANT);
+    baseline.value = globalThis[KEEP_CONSTANT];
+  }
+  installs.push({ owner, map });
+  publish();
+}
+function removeServerKeepMap(owner) {
+  const index = installs.findIndex((install) => install.owner === owner);
+  if (index === -1) return;
+  installs.splice(index, 1);
+  publish();
+}
+
+// src/vite-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-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-used.ts
+function createUsedContext(options, extend) {
+  return {
+    options,
+    extend,
+    kept: keptAtoms(options),
+    packageNames: /* @__PURE__ */ new Map(),
+    root: process.cwd(),
+    command: "build",
+    cacheDir: "",
+    buildSourcemap: false,
+    inProcess: false,
+    isLibrary: false,
+    logger: void 0,
+    state: stateFor("", {})
+  };
+}
+function configureUsed(context, config) {
+  context.root = config.root;
+  context.command = config.command;
+  context.cacheDir = config.cacheDir ?? "";
+  context.buildSourcemap = Boolean(config.build?.sourcemap);
+  context.inProcess = config.builder !== void 0;
+  context.isLibrary = Boolean(config.build?.lib);
+  context.logger = config.logger;
+  context.state = stateFor(config.root, config);
+}
+function isUsed(context) {
+  return context.options.atomic === "used";
+}
+function ignoreWatch() {
+}
+async function ownAtomNames(context, watch = ignoreWatch) {
+  try {
+    const atoms = await context.extend.current(watch);
+    return new Set(Object.keys(atoms).filter((name) => atoms[name]));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+
+// src/vite-collect-module.ts
+var ESCAPED_SPECIFIER = /(?:\bfrom|\bimport)[\s(]*(?:'[^'\\\n]*\\|"[^"\\\n]*\\|`[^`\\\n]*\\)/;
+function isMentioningAtoms(code) {
+  return code.includes(CX_SOURCE) || code.includes("nave-") || code.includes("$setup") || code.includes("vue&type=") || ESCAPED_SPECIFIER.test(code);
+}
+var NO_PLACE = { line: 0, column: 0 };
+function isInlineScript(id) {
+  return /[?&]html-proxy\b/.test(id);
+}
+function lineUnknownNote(context, id) {
+  const isBuildWithoutMaps = context.command === "build" && !context.buildSourcemap;
+  return isBuildWithoutMaps && !isInlineScript(id) ? LINE_UNKNOWN_WITHOUT_MAP : LINE_UNKNOWN_UNMAPPED;
+}
+function locate(problems, placing) {
+  return problems.map((problem) => {
+    const place = placing.place(problem.offset);
+    const where = place ?? { ...NO_PLACE, unknownLine: placing.unknownLine };
+    return { ...problem, file: placing.file, pkg: placing.pkg, moduleId: placing.id, ...where };
+  });
+}
+function locateDynamic(reading, placing) {
+  return reading.dynamicCalls.map(({ offset, construct }) => {
+    const place = placing.place(offset);
+    return {
+      file: placing.file,
+      construct,
+      ...place ?? { ...NO_PLACE, unknownLine: placing.unknownLine }
+    };
+  });
+}
+var COMPILED_LANGS = /* @__PURE__ */ new Map([
+  ["jsx", "jsx"],
+  ["ts", "ts"],
+  ["tsx", "tsx"]
+]);
+function parseOrUndefined(ctx, code, moduleType) {
+  try {
+    const lang = moduleType === void 0 ? void 0 : COMPILED_LANGS.get(moduleType);
+    return ctx.parse(code, lang && { lang });
+  } catch {
+    return void 0;
+  }
+}
+async function authoredTextOf(id) {
+  try {
+    return await readFile(filePathOf(id), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function recordOf(context, ctx, input, reading) {
+  const { code, id, pkg } = input;
+  const hasPlaces = reading.problems.length + reading.dynamicCalls.length > 0;
+  const map = hasPlaces ? combinedMapOf(ctx) : void 0;
+  const authored = map ? await authoredTextOf(id) : void 0;
+  const placing = {
+    code,
+    id,
+    file: moduleLabel(context.root, id),
+    pkg,
+    place: placerFor(code, map, authored),
+    unknownLine: lineUnknownNote(context, id)
+  };
+  const isStandingIn = isListed(context, pkg);
+  return {
+    atoms: /* @__PURE__ */ new Set([...reading.atoms, ...reading.classes]),
+    problems: isStandingIn ? [] : locate(reading.problems, placing),
+    suppressed: isStandingIn ? locate(reading.problems, placing) : [],
+    dynamicCalls: locateDynamic(reading, placing),
+    pkg,
+    file: placing.file,
+    ...reading.edits.length > 0 && { edits: reading.edits }
+  };
+}
+function readOrUndefined(code, program, options) {
+  try {
+    return readModule(code, program, options);
+  } catch (error) {
+    if (error instanceof RangeError) return void 0;
+    throw error;
+  }
+}
+async function recordParsed(context, ctx, input, key) {
+  const { code, id, pkg, program, declared } = input;
+  const { declaredSources, isDeclared, onlyVia } = await declaredReadingOf(context, ctx, declared, {
+    environment: ctx.environment?.name ?? "client",
+    module: { code, id, program }
+  });
+  const reading = readOrUndefined(code, program, {
+    cxSources: /* @__PURE__ */ new Set([CX_SOURCE, ...declaredSources]),
+    declaredSources,
+    isDeclared,
+    ownAtoms: await ownAtomNames(context, (file) => {
+      ctx.addWatchFile(file);
+    }),
+    isDependency: isDependencyId(id),
+    isVueScript: /\.vue(?:$|\?)/.test(id),
+    setup: await setupExposuresFor(context, ctx, { program, code, id }),
+    // A build turns each call into the string it returns; the dev server keeps the functions.
+    ...context.command === "build" && { rewrite: { keep: keepMap(context.kept) } }
+  });
+  if (!reading) {
+    context.state.exposures.delete(key);
+    return unreadableRecord(context, { code, id, pkg }, TOO_DEEP);
+  }
+  if (reading.exposes.size > 0) context.state.exposures.set(key, reading.exposes);
+  else context.state.exposures.delete(key);
+  if (pkg !== void 0 && reading.usesCx) context.state.packages.add(pkg);
+  const record = await recordOf(context, ctx, { code, id, pkg }, reading);
+  return onlyVia === void 0 ? record : { ...record, onlyVia };
+}
+async function recordModule(context, ctx, module) {
+  const { code, id, moduleType } = module;
+  const environment = ctx.environment?.name ?? "client";
+  const key = moduleKey(environment, id);
+  const declared = await declaredModulesFor(context, ctx, environment);
+  if (!isMentioningAtoms(code) && !isAboutListed({ code, id }, declared)) {
+    context.state.modules.delete(key);
+    return void 0;
+  }
+  const isDependency = isDependencyId(id);
+  const pkg = isDependency ? await packageNameOf(filePathOf(id), context.packageNames) : void 0;
+  if (moduleType !== void 0 && !SOURCE_TYPES.has(moduleType)) {
+    context.state.exposures.delete(key);
+    const record2 = textRecord(context, { code, id, moduleType, pkg });
+    context.state.modules.set(key, record2);
+    return record2;
+  }
+  const program = parseOrUndefined(ctx, code, moduleType);
+  const record = program ? await recordParsed(context, ctx, { code, id, pkg, program, declared }, key) : unreadableRecord(context, { code, id, pkg }, NOT_PARSED);
+  if (!program) context.state.exposures.delete(key);
+  context.state.modules.set(key, record);
+  return record;
+}
+
+// src/vite-collect-problems.ts
+function listedAtomsOf(record, context) {
+  if (record.pkg === void 0) return context.options.keep;
+  const { keepFor } = context.options;
+  return Object.hasOwn(keepFor, record.pkg) ? keepFor[record.pkg] : [];
+}
+function dynamicProblems(record, context) {
+  const isCovered = listedAtomsOf(record, context).length > 0;
+  if (isCovered) return [];
+  return record.dynamicCalls.map((call) => ({
+    kind: "dynamic",
+    offset: 0,
+    construct: call.construct,
+    text: "",
+    file: call.file,
+    line: call.line,
+    column: call.column,
+    pkg: record.pkg,
+    ...call.unknownLine !== void 0 && { unknownLine: call.unknownLine }
+  }));
+}
+function problemsOf(record, context) {
+  return [...record.problems, ...dynamicProblems(record, context)];
+}
+function failModule(ctx, context, input) {
+  const { home, id, problems } = input;
+  const message = moduleReport(problems, context.options.cxModules, home);
+  const first = problems[0];
+  return ctx.error({
+    message,
+    id,
+    loc: { file: id, line: Math.max(first.line, 1), column: Math.max(first.column - 1, 0) }
+  });
+}
+function failDevModule(ctx, context, input) {
+  const { home, id, record } = input;
+  if (context.command !== "serve" || record.pkg !== void 0) return;
+  const problems = problemsOf(record, context);
+  if (problems.length > 0) failModule(ctx, context, { home, id, problems });
+}
+
+// src/vite-cx-module-lines.ts
+function quoted(specifiers) {
+  return specifiers.map((specifier) => `'${specifier}'`).join(", ");
+}
+function applicationLinesOf(item) {
+  const entry = `'${item.entry}'`;
+  const relative = item.specifiers.filter((specifier) => isRelative(specifier));
+  const other = item.specifiers.filter((specifier) => !isRelative(specifier));
+  const place = relative.length === 1 ? "its" : "their";
+  return {
+    relative: relative.length === 0 ? [] : [
+      `${item.label}: imports ${entry} as ${quoted(relative)}. Write '${item.replacement}' in ${place} place.`
+    ],
+    other: other.length === 0 ? [] : [`${item.label}: imports ${entry} as ${quoted(other)}.`],
+    none: item.specifiers.length > 0 ? [] : [
+      `${item.label}: imports ${entry} through a specifier the build could not find in the file.`
+    ]
+  };
+}
+function dependencyLineOf(item) {
+  const entry = `'${item.entry}'`;
+  const found = item.specifiers.length === 0 ? `imports ${entry} through a specifier the build could not find in the file.` : `imports ${entry} as ${quoted(item.specifiers)}.`;
+  return `${item.label}: ${found} The file is in ${item.pkg}, a dependency, so it is not yours to change.`;
+}
+var RELATIVE_REMEDY = "Adding a relative specifier to cxModules would not clear this: a relative entry is read from the project root. Instead of the rewrite";
+var TYPESCRIPT_CONDITION = "Where a rewrite ends in .ts, .tsx, .mts or .cts, TypeScript accepts it only if your tsconfig sets allowImportingTsExtensions or rewriteRelativeImportExtensions; if it sets neither, use the alias the line above describes instead.";
+var NO_SPECIFIER_REMEDY = "Where the build could not find the specifier, import the module there by a specifier ending in the listed file's name, or by an alias or package name added to cxModules.";
+function applicationRemedyOf(items, lines, input) {
+  const remedy = [];
+  const relativeCount = lines.reduce((count, line) => count + line.relative.length, 0);
+  if (relativeCount === 1) {
+    remedy.push(
+      `${RELATIVE_REMEDY} its line gives, the file can import the module through an alias for it, added to cxModules.`
+    );
+  } else if (relativeCount > 1) {
+    remedy.push(
+      `${RELATIVE_REMEDY} each line gives, a file can import the module through an alias for it, added to cxModules.`
+    );
+  }
+  const hasTypeScriptRewrite = items.some(
+    (item) => item.specifiers.some((specifier) => isRelative(specifier)) && /\.(?:ts|tsx|mts|cts)$/.test(item.replacement)
+  );
+  if (hasTypeScriptRewrite) remedy.push(TYPESCRIPT_CONDITION);
+  if (lines.some((line) => line.none.length > 0)) remedy.push(NO_SPECIFIER_REMEDY);
+  const added = [
+    ...new Set(
+      items.flatMap((item) => item.specifiers.filter((specifier) => !isRelative(specifier)))
+    )
+  ];
+  const array = cxModulesArray(input.configured, added);
+  if (array !== void 0) {
+    const each = added.length === 1 ? "the specifier" : "each specifier";
+    remedy.push(`Add ${each}, as written, to cxModules in ${input.home}: cxModules: ${array}.`);
+  }
+  return remedy;
+}
+var LASTING_FIX_HERE = "The lasting fix there is the package's: import the module by a specifier ending in the listed file's name.";
+function packageRemedyOf(pkg, files, input) {
+  if (input.hasKeepFor) {
+    const file = files === 1 ? "a file" : "files";
+    return `${pkg} also imports a module listed in cxModules in ${file} the build did not read; the keepFor entry above clears that too. ${LASTING_FIX_HERE}`;
+  }
+  return `For ${pkg}, list the atoms its calls can produce, from its documentation, under its name in ${input.home}: keepFor: { '${pkg}': ['<atom>'] }. Once the package is listed, its files no longer fail the build here, and the atoms you list stand in for the calls the build did not read. The lasting fix is the package's: import the module by a specifier ending in the listed file's name.`;
+}
+function importerErrorOf(found, input) {
+  const application = found.filter((item) => item.pkg === void 0);
+  const dependencies = found.filter((item) => item.pkg !== void 0);
+  const count = new Set(found.map((item) => item.importer)).size;
+  const first = count === 1 ? "1 file imports a module listed in cxModules through a specifier the build does not recognise, so the build did not read the cx() calls made through it." : `${count} files import a module listed in cxModules through a specifier the build does not recognise, so the build did not read the cx() calls made through those specifiers.`;
+  const lines = application.map((item) => applicationLinesOf(item));
+  const byPackage = Map.groupBy(dependencies, (item) => item.pkg);
+  const packages = byPackage.keys().toArray().toSorted(compareText);
+  return [
+    first,
+    ...lines.flatMap((line) => [...line.relative, ...line.other, ...line.none]).toSorted(compareText),
+    ...dependencies.map((item) => dependencyLineOf(item)).toSorted(compareText),
+    ...applicationRemedyOf(application, lines, input),
+    ...packages.map(
+      (pkg) => packageRemedyOf(pkg, new Set(byPackage.get(pkg).map((item) => item.importer)).size, {
+        hasKeepFor: input.report?.includes(`keepFor: { '${pkg}'`) ?? false,
+        home: input.home
+      })
+    )
+  ].join("\n");
+}
+async function isResolvingTo(ctx, input) {
+  try {
+    const resolved = await ctx.resolve?.(input.specifier, input.from);
+    return resolved !== null && resolved !== void 0 && fileOf(resolved.id) === input.file;
+  } catch {
+    return false;
+  }
+}
+function importersOf(ctx, id) {
+  const info = ctx.getModuleInfo?.(id);
+  return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
+}
+async function specifiersWritten(ctx, input) {
+  const { file, importer } = input;
+  const code = ctx.getModuleInfo?.(importer)?.code;
+  if (code === null || code === void 0) return [];
+  const written = specifiersOf(ctx, { id: importer, code }) ?? [];
+  const found = [];
+  for (const specifier of written) {
+    if (await isResolvingTo(ctx, { file, from: importer, specifier })) found.push(specifier);
+  }
+  return found;
+}
+async function specifiersInto(ctx, context, input) {
+  const found = /* @__PURE__ */ new Set();
+  for (const importer of importersOf(ctx, input.id)) {
+    const owner = isDependencyId(importer) ? await packageNameOf(filePathOf(importer), context.packageNames) : void 0;
+    if (owner === input.pkg) continue;
+    const written = await specifiersWritten(ctx, { file: fileOf(input.id), importer });
+    for (const specifier of written) found.add(specifier);
+  }
+  return found.values().toArray().toSorted(compareText);
+}
+async function clearingSpecifier(ctx, context, input) {
+  const from = path2.join(context.root, "index.html");
+  const file = fileOf(input.id);
+  if (await isResolvingTo(ctx, { file, from, specifier: input.pkg })) return input.pkg;
+  const specifiers = await specifiersInto(ctx, context, input);
+  for (const specifier of specifiers) {
+    if (await isResolvingTo(ctx, { file, from, specifier })) return specifier;
+  }
+  return void 0;
+}
+async function withClearingSpecifiers(ctx, context, problems) {
+  const asked = /* @__PURE__ */ new Map();
+  const clearing = (pkg, id) => {
+    const known = asked.get(id);
+    if (known) return known;
+    const answer = clearingSpecifier(ctx, context, { id, pkg });
+    asked.set(id, answer);
+    return answer;
+  };
+  const entriesOf = async (id) => {
+    const declared = await declaredModulesFor(context, ctx, ctx.environment.name);
+    return declared ? entriesNaming(declared, id) : [];
+  };
+  const renamed = new Set(
+    problems.flatMap(
+      (problem) => problem.isRenamed === true && problem.moduleId !== void 0 ? [problem.moduleId] : []
+    )
+  );
+  return await Promise.all(
+    problems.map(async (problem) => {
+      const { moduleId, pkg } = problem;
+      if (pkg === void 0 || moduleId === void 0) return problem;
+      if (problem.kind === "declared") return { ...problem, entries: await entriesOf(moduleId) };
+      if (!isListableReexport(problem)) return problem;
+      if (renamed.has(moduleId)) return { ...problem, isRenamed: true };
+      const specifier = await clearing(pkg, moduleId);
+      return specifier === void 0 ? problem : { ...problem, specifier };
+    })
+  );
+}
+
+// src/vite-cx-module-importers.ts
+var RESOLVED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".json",
+  ".jsx",
+  ".mjs",
+  ".mts",
+  ".ts",
+  ".tsx"
+]);
+function entryOf(declared, id) {
+  const file = fileOf(id);
+  for (const [entry, resolved] of declared.ids) if (fileOf(resolved) === file) return entry;
+  return id;
+}
+async function replacementFor(ctx, input) {
+  const file = fileOf(input.id);
+  const extension = path2.posix.extname(file);
+  const relativeTo = (target) => {
+    const relative = path2.posix.relative(path2.posix.dirname(fileOf(input.importer)), target);
+    return relative.startsWith("../") ? relative : `./${relative}`;
+  };
+  if (!RESOLVED_EXTENSIONS.has(extension)) return relativeTo(file);
+  const short = relativeTo(file.slice(0, -extension.length));
+  const isLanding = await isResolvingTo(ctx, { file, from: input.importer, specifier: short });
+  return isLanding ? short : relativeTo(file);
+}
+async function unrecognisedSpecifiers(ctx, input) {
+  const { answers, id, importer, recognised } = input;
+  const known = { cxId: id, answers };
+  const found = [];
+  const unread = (specifiersOf(ctx, importer) ?? []).filter((text) => !recognised?.has(text));
+  for (const specifier of unread) {
+    if (await isResolvingToCx(ctx, specifier, importer, known)) found.push(specifier);
+  }
+  return found;
+}
+async function unrecognisedOf(ctx, context, input) {
+  const { answers, declared, id } = input;
+  const importer = await candidateOf(ctx, context, input.importer);
+  if (!importer) return void 0;
+  const recognised = context.state.recognised.get(
+    recognisedKey(ctx.environment.name, fileOf(id), importer.id)
+  );
+  const specifiers = await unrecognisedSpecifiers(ctx, { answers, id, importer, recognised });
+  if (recognised !== void 0 && specifiers.length === 0) return void 0;
+  const pkg = isDependencyId(importer.id) ? await packageNameOf(filePathOf(importer.id), context.packageNames) : void 0;
+  return {
+    importer: importer.id,
+    label: moduleLabel(context.root, importer.id),
+    entry: entryOf(declared, id),
+    specifiers,
+    replacement: pkg === void 0 ? await replacementFor(ctx, { id, importer: importer.id }) : "",
+    pkg
+  };
+}
+function listedIdsIn(ctx, declared) {
+  const ids = new Set(declared.ids.values());
+  const graph = ctx.getModuleIds?.() ?? [];
+  for (const id of graph) {
+    if (declared.files.has(fileOf(id))) ids.add(id);
+  }
+  return ids;
+}
+function merged(found, item, id) {
+  const key = `${item.importer}\0${fileOf(id)}`;
+  const specifiers = /* @__PURE__ */ new Set([...found.get(key)?.specifiers ?? [], ...item.specifiers]);
+  return [key, { ...item, specifiers: [...specifiers] }];
+}
+async function unrecognisedImporters(ctx, context, declared) {
+  const found = /* @__PURE__ */ new Map();
+  for (const id of listedIdsIn(ctx, declared)) {
+    const answers = /* @__PURE__ */ new Map();
+    for (const importer of importerIdsOf(ctx, id)) {
+      const item = await unrecognisedOf(ctx, context, { answers, declared, id, importer });
+      if (item) found.set(...merged(found, item, id));
+    }
+  }
+  return found.values().toArray();
+}
+async function declaredImporterError(ctx, context, input) {
+  const declared = await declaredModulesFor(context, ctx, ctx.environment.name);
+  if (!declared) return void 0;
+  const found = await unrecognisedImporters(ctx, context, declared);
+  return found.length === 0 ? void 0 : importerErrorOf(found, input);
+}
+
+// src/vite-declared-echoes.ts
+var ECHO_KINDS = /* @__PURE__ */ new Set([
+  "argument",
+  "dynamic",
+  "own",
+  "reference",
+  "unknown"
+]);
+function withoutEchoes(modules) {
+  const broken = new Set(
+    modules.flatMap(
+      (module) => module.problems.flatMap(
+        (problem) => problem.kind === "declared" && problem.moduleId !== void 0 && !problem.hasNaveCx ? [fileOf(problem.moduleId)] : []
+      )
+    )
+  );
+  const isEcho = (module) => module.onlyVia !== void 0 && [...module.onlyVia].every((file) => broken.has(file));
+  return modules.flatMap(
+    (module) => isEcho(module) ? module.problems.filter((problem) => !ECHO_KINDS.has(problem.kind)) : module.problems
+  );
+}
+
+// src/vite-markup.ts
+var MARKUP_WARNING = `navePlugin(): Nave read no HTML page and no server render, so your pages are likely rendered where it cannot see them, such as in a backend's own templates. A Nave class written there has no rule, in dev or in the build, unless its atom is listed in keep; if most of your Nave classes are written there, set atomic: 'all' to ship every atom. See "Which atoms the build ships" in node_modules/@navecss/core/README.md.`;
+function isMarkupCase(context) {
+  const { state } = context;
+  return context.options.keep.length === 0 && collectedAtoms(state, []).size === 0 && !state.directiveExpanded && !state.htmlRead && !state.serverTransformed && !context.isLibrary;
+}
+function judgeMarkup(context, warn) {
+  const { state } = context;
+  if (!isUsed(context) || state.markupJudged) return;
+  state.markupJudged = true;
+  if (isMarkupCase(context)) warn(MARKUP_WARNING);
+}
+function expectBuilds(context, builder, warn) {
+  if (Object.values(builder.environments).some((environment) => environment.isBuilt)) {
+    judgeMarkup(context, warn);
+    return;
+  }
+  context.state.expectedEnvironments = new Set(Object.keys(builder.environments));
+}
+function judgeAfterLastEnvironment(context, environment, warn) {
+  const { builtEnvironments, expectedEnvironments } = context.state;
+  builtEnvironments.add(environment.name);
+  const isLast = expectedEnvironments ? [...expectedEnvironments].every((name) => builtEnvironments.has(name)) : !context.inProcess && environment.config.consumer === "client";
+  if (isLast) judgeMarkup(context, warn);
+}
+
+// src/vite-dev-judge.ts
+function isServedAsStylesheet(id) {
+  return isStylesheetId(id) && !/[?&]inline\b/.test(id);
+}
+function judge(context) {
+  judgeMarkup(context, (message) => context.logger?.warn(message));
+}
+function judgeWhenServed(context, id) {
+  const { state } = context;
+  if (!state.warmedUp || state.requested.has(filePathOf(id))) judge(context);
+}
+function stylesheetUrl(request, base) {
+  const url = request.url;
+  if (url === void 0 || !isServedAsStylesheet(url)) return void 0;
+  return base !== "/" && url.startsWith(base) ? `/${url.slice(base.length)}` : url;
+}
+async function noteRequest(context, environment, url) {
+  const { state } = context;
+  try {
+    const resolved = await environment.pluginContainer.resolveId(decodeURI(url));
+    if (resolved === null) return;
+    const file = filePathOf(resolved.id);
+    state.requested.add(file);
+    if (state.served.keys().some((id) => filePathOf(id) === file)) judge(context);
+  } catch {
+  }
+}
+function noteStylesheetRequests(context, server) {
+  const { state } = context;
+  const environment = server.environments.client;
+  state.warmedUp = environment.config.dev.warmup.length > 0;
+  if (!state.warmedUp) return;
+  server.middlewares.use(async (request, _response, next) => {
+    const url = stylesheetUrl(request, server.config.base);
+    if (url !== void 0 && !state.markupJudged) await noteRequest(context, environment, url);
+    next();
+  });
+}
+
+// src/vite-dev-read.ts
+function graphRoots(environment) {
+  return environment.moduleGraph.idToModuleMap.values().filter(
+    (module) => module.importers.size === 0 && (module.id === null || !isStylesheetId(module.id))
+  ).toArray();
+}
+async function transformQuietly(environment, url) {
+  try {
+    await environment.transformRequest(url);
+  } catch {
+  }
+}
+async function transformReachable(environment, roots) {
+  const seen = new Set(roots);
+  let level = [...roots];
+  while (level.length > 0) {
+    const next = [];
+    await Promise.all(
+      level.map(async (module) => {
+        if (module.id !== null && isStylesheetId(module.id)) return;
+        await transformQuietly(environment, module.url);
+        for (const imported of module.importedModules) {
+          if (seen.has(imported)) continue;
+          seen.add(imported);
+          next.push(imported);
+        }
+      })
+    );
+    level = next;
+  }
+}
+
+// src/vite-dev-update.ts
+function readerOf(environment) {
+  return {
+    transformRequest: (url) => environment.transformRequest?.(url) ?? Promise.resolve()
+  };
+}
+async function readAhead(context, environment, scripts) {
+  const { state } = context;
+  const reader = readerOf(environment);
+  state.readAhead += 1;
+  try {
+    for (const module of scripts) {
+      const known = new Set(module.importedModules);
+      environment.moduleGraph.invalidateModule(module);
+      await transformQuietly(reader, module.url);
+      const added = [...module.importedModules.difference(known)];
+      await transformReachable(reader, added);
+    }
+  } finally {
+    state.readAhead -= 1;
+  }
+}
+function takeStaleModules(context, environment) {
+  const { state } = context;
+  const ids = [...state.stale];
+  state.stale.clear();
+  clearTimeout(state.reloadTimer);
+  state.reloadTimer = void 0;
+  const sheets = [];
+  for (const id of ids) {
+    const module = environment.moduleGraph.getModuleById(id);
+    if (!module) continue;
+    noteReloadSent(state, id);
+    sheets.push(module);
+  }
+  return sheets;
+}
+async function modulesWithGrownStylesheets(context, ctx, hot) {
+  const { environment } = ctx;
+  if (environment.config?.consumer !== "client" || context.state.served.size === 0) return;
+  const scripts = (hot.modules ?? []).filter((m) => m.id !== null && !isStylesheetId(m.id));
+  if (scripts.length === 0) return;
+  await readAhead(context, environment, scripts);
+  const sheets = takeStaleModules(context, environment);
+  return sheets.length === 0 ? void 0 : [...hot.modules ?? [], ...sheets];
+}
+
+// src/vite-css-blocks.ts
+function matchBraces(tokens) {
+  const matches = /* @__PURE__ */ new Map();
+  const open = [];
+  for (const [index, token] of tokens.entries()) {
+    if (token.type === "{-token") open.push(index);
+    else if (token.type === "}-token" && open.length > 0) matches.set(open.pop(), index);
+  }
+  return matches;
+}
+function isBlank(tokens, from, to) {
+  for (let index = from; index < to; index += 1) {
+    const type = tokens[index].type;
+    if (type !== "whitespace-token" && type !== "comment") return false;
+  }
+  return true;
+}
+var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token"]);
+function readSheet(css) {
+  const tokens = tokenize(css);
+  const matches = matchBraces(tokens);
+  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: "" });
+var DIRECT = /[?&]direct\b/;
+function isInlinedInHtml(module) {
+  return module.id !== null && /[?&]html-proxy\b/.test(module.id);
+}
+async function reloadQuietly(environment, module) {
+  try {
+    if (isInlinedInHtml(module)) environment.hot.send({ type: "full-reload", path: "*" });
+    else await environment.reloadModule(module);
+  } catch {
+  }
+}
+function reloadStale(context) {
+  const { state } = context;
+  state.reloadTimer = void 0;
+  const ids = [...state.stale];
+  state.stale.clear();
+  for (const id of ids) {
+    const sheet = state.served.get(id);
+    const module = sheet?.environment.moduleGraph.getModuleById(id);
+    if (!sheet || !module) continue;
+    noteReloadSent(state, id);
+    void reloadQuietly(sheet.environment, module);
+  }
+}
+function isReloading(context, id) {
+  const sent = context.state.reloading.get(id);
+  return sent !== void 0 && Date.now() - sent < RELOAD_ANSWER_MS;
+}
+function reloadOutgrown(context, ids) {
+  const { state } = context;
+  const atoms = servedAtoms(state, context.kept);
+  for (const id of ids) {
+    const sheet = state.served.get(id);
+    if (sheet && !atoms.isSubsetOf(sheet.atoms) && !isReloading(context, id)) state.stale.add(id);
+  }
+  if (state.stale.size > 0 && state.reloadTimer === void 0 && state.readAhead === 0) {
+    state.reloadTimer = setTimeout(() => {
+      reloadStale(context);
+    }, 0);
+    state.reloadTimer.unref();
+  }
+}
+var devServing = {
+  modulesWithGrown: modulesWithGrownStylesheets,
+  async hold(environment, id) {
+    const module = environment.moduleGraph.getModuleById(id);
+    if (!module) return;
+    if (module.importers.size === 0 && DIRECT.test(id)) return;
+    await environment.waitForRequestsIdle(id);
+    await transformReachable(environment, graphRoots(environment));
+  },
+  notePages(context) {
+    const { state } = context;
+    const atoms = servedAtoms(state, context.kept);
+    for (const sheet of state.served) {
+      const [id, { atoms: served, environment }] = sheet;
+      if (atoms.isSubsetOf(served)) continue;
+      const module = environment.moduleGraph.getModuleById(id);
+      if (module) environment.moduleGraph.invalidateModule(module);
+    }
+    devServing.noteGrowth(context);
+  },
+  noteConnect(context) {
+    const { state } = context;
+    state.listening += 1;
+    if (state.unheard.size === 0) return;
+    const ids = [...state.unheard];
+    state.unheard.clear();
+    for (const id of ids) state.reloading.delete(id);
+    reloadOutgrown(context, ids);
+  },
+  noteDisconnect(context) {
+    const { state } = context;
+    state.listening = Math.max(0, state.listening - 1);
+  },
+  noteGrowth(context) {
+    if (context.state.served.size === 0) return;
+    reloadOutgrown(context, context.state.served.keys());
+  }
+};
+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);
+  }
+}
+
+// src/vite-cx-reexported.ts
+function declaredNames(pattern) {
+  const found = [];
+  const stack = pattern ? [pattern] : [];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "Identifier") {
+      found.push(stringAt(node, "name") ?? "");
+    } else if (node.type === "AssignmentPattern") {
+      pushAll(
+        stack,
+        [nodeAt(node, "left")].filter((part) => part !== void 0)
+      );
+    } else {
+      const single = ["argument", "value"].map((key) => nodeAt(node, key));
+      const lists = ["properties", "elements"].flatMap((key) => nodesAt(node, key));
+      pushAll(
+        stack,
+        single.filter((part) => part !== void 0)
+      );
+      pushAll(stack, lists);
+    }
+  }
+  return found;
+}
+function ownExports(program) {
+  const found = /* @__PURE__ */ new Set();
+  for (const statement of nodesAt(program, "body")) {
+    const namespace = statement.type === "ExportAllDeclaration" ? exportNameOf(nodeAt(statement, "exported")) : void 0;
+    if (namespace !== void 0) found.add(namespace);
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    const declaration = nodeAt(statement, "declaration");
+    const declared = nodesAt(declaration ?? statement, "declarations").flatMap(
+      (declarator) => declaredNames(nodeAt(declarator, "id"))
+    );
+    for (const name of [...declared, ...declaredNames(declaration && nodeAt(declaration, "id"))]) {
+      found.add(name);
+    }
+    for (const specifier of nodesAt(statement, "specifiers")) {
+      const name = exportNameOf(nodeAt(specifier, "exported"));
+      if (name !== void 0) found.add(name);
+    }
+  }
+  return found;
+}
+function exportedBy(node, source, own) {
+  const from = staticStringOf(nodeAt(node, "source"));
+  if (from === void 0 || !source.reaches.has(from)) return [];
+  if (node.type === "ExportAllDeclaration") {
+    const namespace = exportNameOf(nodeAt(node, "exported"));
+    if (namespace !== void 0) return [namespace];
+    return source.names.values().filter((name) => name !== "default" && !own.has(name) && !source.rivals.has(name)).toArray();
+  }
+  return nodesAt(node, "specifiers").flatMap((specifier) => {
+    const local = exportNameOf(nodeAt(specifier, "local"));
+    const exported = exportNameOf(nodeAt(specifier, "exported"));
+    return local !== void 0 && exported !== void 0 && source.names.has(local) ? [exported] : [];
+  });
+}
+function isImportedFrom(binding, source) {
+  if (binding?.kind !== "import" || binding.source === void 0) return false;
+  if (!source.reaches.has(binding.source)) return false;
+  return binding.imported === "*" || source.names.has(binding.imported ?? "");
+}
+function exportedAs(analysis, reference) {
+  const parent = analysis.parentOf.get(reference.node);
+  if (parent?.type === "ExportDefaultDeclaration") return "default";
+  return parent?.type === "ExportSpecifier" ? exportNameOf(nodeAt(parent, "exported")) : void 0;
+}
+function starSources(program) {
+  return nodesAt(program, "body").flatMap((statement) => {
+    const source = staticStringOf(nodeAt(statement, "source"));
+    const isStar = statement.type === "ExportAllDeclaration" && !nodeAt(statement, "exported");
+    return isStar && source !== void 0 ? [source] : [];
+  });
+}
+function reexportedNames(program, source) {
+  const found = /* @__PURE__ */ new Set();
+  const own = ownExports(program);
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
+      for (const name of exportedBy(node, source, own)) found.add(name);
+    }
+    pushAll(stack, childrenOf(node));
+  }
+  const analysis = analyze(program);
+  for (const reference of analysis.references) {
+    const name = isImportedFrom(reference.binding, source) ? exportedAs(analysis, reference) : void 0;
+    if (name !== void 0) found.add(name);
+  }
+  return [...found];
+}
+
+// src/vite-cx-star-exports.ts
+function resolvedFile(ctx, resolutions, input) {
+  const key = `${input.id}\0${input.specifier}`;
+  const known = resolutions.get(key);
+  if (known) return known;
+  const asked = (async () => {
+    try {
+      const resolved = await ctx.resolve?.(input.specifier, input.id);
+      return resolved ? fileOf(resolved.id) : void 0;
+    } catch {
+      return void 0;
+    }
+  })();
+  resolutions.set(key, asked);
+  return asked;
+}
+function ownNamesOf(program, file, cxExports) {
+  const found = { names: ownExports(program), cx: /* @__PURE__ */ new Set() };
+  for (const name of found.names) {
+    if (cxExports.get(file)?.has(name)) found.cx.add(name);
+  }
+  return found;
+}
+function unreadProgram(ctx, input) {
+  const { file, seen } = input;
+  const code = ctx.getModuleInfo?.(file)?.code;
+  const isUnread = !seen.has(file) && typeof code === "string";
+  seen.add(file);
+  return isUnread ? ctx.parse?.(code) : void 0;
+}
+async function addStars(ctx, input) {
+  const { found, file, program, walk } = input;
+  for (const specifier of starSources(program)) {
+    const star = await resolvedFile(ctx, walk.resolutions, { id: file, specifier });
+    const below = star ? await exportsOf(ctx, { file: star, walk }) : void 0;
+    const names = below ? [...below.names] : [];
+    for (const name of names) {
+      found.names.add(name);
+      if (below?.cx.has(name)) found.cx.add(name);
+    }
+  }
+}
+async function exportsOf(ctx, input) {
+  const { file, walk } = input;
+  const program = unreadProgram(ctx, { file, seen: walk.seen });
+  if (!program) return { names: /* @__PURE__ */ new Set(), cx: /* @__PURE__ */ new Set() };
+  const found = ownNamesOf(program, file, walk.cxExports);
+  await addStars(ctx, { found, file, program, walk });
+  return found;
+}
+async function rivalsOf(ctx, input) {
+  const { cxExports, id, program, reaches, resolutions } = input;
+  const rivals = /* @__PURE__ */ new Set();
+  const others = starSources(program).filter((text) => !reaches.has(text));
+  for (const specifier of others) {
+    const file = await resolvedFile(ctx, resolutions, { id, specifier });
+    const walk = { cxExports, resolutions, seen: /* @__PURE__ */ new Set() };
+    const exported = file ? await exportsOf(ctx, { file, walk }) : void 0;
+    const names = exported ? [...exported.names] : [];
+    const own = names.filter((text) => !exported?.cx.has(text));
+    for (const name of own) rivals.add(name);
+  }
+  return rivals;
+}
+
+// src/vite-listed-holders.ts
+async function reachingSpecifiers(ctx, input) {
+  const { code, file, id, resolutions } = input;
+  const program = ctx.parse?.(code);
+  if (!program) return void 0;
+  const reaches = /* @__PURE__ */ new Set();
+  for (const specifier of specifiersIn(program)) {
+    if (await resolvedFile(ctx, resolutions, { id, specifier }) === file) reaches.add(specifier);
+  }
+  return { program, reaches };
+}
+async function reexportedBy(ctx, input) {
+  const code = ctx.getModuleInfo?.(input.id)?.code;
+  if (code === null || code === void 0) return [];
+  try {
+    const read = await reachingSpecifiers(ctx, { ...input, code });
+    if (!read || read.reaches.size === 0) return [];
+    const { program, reaches } = read;
+    const rivals = await rivalsOf(ctx, { ...input, program, reaches });
+    return reexportedNames(program, { names: input.names, reaches, rivals });
+  } catch {
+    return [];
+  }
+}
+async function reexportsOf(ctx, input) {
+  const importers = importersOf(ctx, input.id).filter((importer) => isDependencyId(importer));
+  const found = /* @__PURE__ */ new Map();
+  for (const importer of importers) {
+    const added = await reexportedBy(ctx, { ...input, file: fileOf(input.id), id: importer });
+    if (added.length > 0) found.set(importer, added);
+  }
+  return found;
+}
+async function holdersOf(ctx, origin) {
+  const held = /* @__PURE__ */ new Map([[origin.id, origin.names]]);
+  const queue = [origin.id];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    const reexports = await reexportsOf(ctx, {
+      cxExports: origin.cxExports,
+      id,
+      names: held.get(id),
+      resolutions: origin.resolutions
+    });
+    for (const [importer, added] of reexports) {
+      const known = held.get(importer) ?? /* @__PURE__ */ new Set();
+      const isNew = importer !== origin.id && added.some((name) => !known.has(name));
+      if (isNew) {
+        held.set(importer, /* @__PURE__ */ new Set([...known, ...added]));
+        queue.push(importer);
+      }
+    }
+  }
+  return held.entries().map(([id, names]) => ({ id, names, isReached: id !== origin.id })).toArray();
+}
+
+// src/vite-cx-take-keys.ts
+function isCxName(names, name) {
+  return names === void 0 || names.has(name);
+}
+function patternKeys(pattern, names) {
+  const taken = [];
+  for (const property of nodesAt(pattern, "properties")) {
+    const key = property.type === "Property" ? propertyNameOf(nodeAt(property, "key"), property.computed === true) : void 0;
+    if (key === void 0) return void 0;
+    if (isCxName(names, key)) taken.push(key);
+  }
+  return taken;
+}
+function referenceTakes(analysis, node, names) {
+  const read = memberReadOf({ analysis }, node);
+  if (read) {
+    if (read.key === void 0) return void 0;
+    return isCxName(names, read.key) ? [read.key] : [];
+  }
+  const pattern = patternDestructuring({ analysis }, node);
+  return pattern?.type === "ObjectPattern" ? patternKeys(pattern, names) : void 0;
+}
+function outermost(analysis, node) {
+  let current = node;
+  let parent = analysis.parentOf.get(current);
+  while (parent?.type === "ParenthesizedExpression") {
+    current = parent;
+    parent = analysis.parentOf.get(current);
+  }
+  return current;
+}
+function thenCall(analysis, node) {
+  const member = analysis.parentOf.get(node);
+  if (member?.type !== "MemberExpression" || nodeAt(member, "object") !== node) return void 0;
+  const key = propertyNameOf(nodeAt(member, "property"), member.computed === true);
+  const call = analysis.parentOf.get(member);
+  return key === "then" && call?.type === "CallExpression" && nodeAt(call, "callee") === member ? call : void 0;
+}
+function thenCallback(analysis, node) {
+  const call = thenCall(analysis, node);
+  const callback = call && nodesAt(call, "arguments")[0];
+  const isInline = callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression";
+  return isInline ? callback : void 0;
+}
+function referencesToParameter(analysis, owner, name) {
+  return analysis.references.filter(
+    ({ binding }) => binding?.kind === "param" && binding.owner === owner && binding.name === name
+  );
+}
+function parameterTakes(analysis, callback, names) {
+  const parameter = nodesAt(callback, "params")[0];
+  if (parameter === void 0) return [];
+  if (parameter.type === "ObjectPattern") return patternKeys(parameter, names);
+  const name = parameter.type === "Identifier" ? stringAt(parameter, "name") : void 0;
+  if (name === void 0) return void 0;
+  const found = [];
+  for (const { binding, node } of referencesToParameter(analysis, callback, name)) {
+    const taken = binding?.writes === 0 ? referenceTakes(analysis, node, names) : void 0;
+    if (taken === void 0) return void 0;
+    pushAll(found, taken);
+  }
+  return found;
+}
+function variableTakes(analysis, init, names) {
+  const declarator = analysis.parentOf.get(init);
+  const declaration = declarator && analysis.parentOf.get(declarator);
+  if (declaration && analysis.parentOf.get(declaration)?.type === "ExportNamedDeclaration") {
+    return void 0;
+  }
+  const found = [];
+  for (const { binding, node } of analysis.references) {
+    if (binding?.init !== init) continue;
+    const taken = binding.writes === 0 ? referenceTakes(analysis, node, names) : void 0;
+    if (taken === void 0) return void 0;
+    pushAll(found, taken);
+  }
+  return found;
+}
+function awaitedKeys(analysis, awaited, names) {
+  const declarator = analysis.parentOf.get(awaited);
+  const isVariable = declarator?.type === "VariableDeclarator" && nodeAt(declarator, "init") === awaited && nodeAt(declarator, "id")?.type === "Identifier";
+  return isVariable ? variableTakes(analysis, awaited, names) : referenceTakes(analysis, awaited, names);
+}
+function dynamicKeys(analysis, node, names) {
+  const awaited = analysis.parentOf.get(node);
+  if (awaited?.type === "AwaitExpression") {
+    return awaitedKeys(analysis, outermost(analysis, awaited), names);
+  }
+  const callback = thenCallback(analysis, node);
+  return callback && parameterTakes(analysis, callback, names);
+}
+
+// src/vite-cx-takes.ts
+var UNREADABLE = { shape: "unreadable", names: [] };
+function namespaceTakes(analysis, references, names) {
+  const found = /* @__PURE__ */ new Set();
+  for (const reference of references) {
+    const taken = referenceTakes(analysis, reference.node, names);
+    if (taken === void 0) return { shape: "namespace", names: [] };
+    for (const name of taken) found.add(name);
+  }
+  return found.size === 0 ? void 0 : { shape: "namespace", names: [...found] };
+}
+function referencesTo(analysis, source, specifier) {
+  const local = exportNameOf(nodeAt(specifier, "local"));
+  return analysis.references.filter(({ binding }) => {
+    return binding?.kind === "import" && binding.imported === "*" && binding.source === source && binding.name === local;
+  });
+}
+function usesOf(analysis, source, specifier) {
+  const local = exportNameOf(nodeAt(specifier, "local"));
+  return analysis.references.filter(
+    ({ binding }) => binding?.kind === "import" && binding.source === source && binding.name === local
+  );
+}
+function isExportOf(analysis, reference) {
+  const parent = analysis.parentOf.get(reference.node);
+  return parent?.type === "ExportSpecifier" || parent?.type === "ExportDefaultDeclaration";
+}
+function passingOf(analysis, source, specifier) {
+  const uses = usesOf(analysis, source, specifier);
+  const exported = uses.filter((use) => isExportOf(analysis, use));
+  if (exported.length === 0) return {};
+  return exported.length === uses.length ? { isForward: true, isPassedOn: true } : { isPassedOn: true };
+}
+function importTakes(node, source, scan) {
+  const found = [];
+  for (const specifier of nodesAt(node, "specifiers")) {
+    if (specifier.type === "ImportNamespaceSpecifier") {
+      const references = referencesTo(scan.analysis(), source, specifier);
+      const taken = namespaceTakes(scan.analysis(), references, scan.names);
+      const isForward = passingOf(scan.analysis(), source, specifier).isForward;
+      if (taken) found.push({ ...taken, ...isForward && { isForward } });
+      continue;
+    }
+    const imported = specifier.type === "ImportDefaultSpecifier" ? "default" : exportNameOf(nodeAt(specifier, "imported"));
+    if (imported !== void 0 && isCxName(scan.names, imported)) {
+      const passing = passingOf(scan.analysis(), source, specifier);
+      found.push({ shape: "names", names: [imported], ...passing });
+    }
+  }
+  return found;
+}
+function exportTakes(node, scan) {
+  if (node.type === "ExportAllDeclaration") {
+    if (nodeAt(node, "exported") !== void 0) {
+      return [{ shape: "namespace", names: [], isForward: true }];
+    }
+    const hasNamed = scan.names === void 0 || scan.names.keys().some((name) => name !== "default");
+    return hasNamed ? [{ shape: "star", names: [], isForward: true }] : [];
+  }
+  const re = nodesAt(node, "specifiers").map((specifier) => exportNameOf(nodeAt(specifier, "local"))).filter((name) => name !== void 0 && isCxName(scan.names, name));
+  return re.length === 0 ? [] : [{ shape: "names", names: re, isPassedOn: true, isForward: true }];
+}
+function dynamicTakes(node, scan) {
+  const keys = dynamicKeys(scan.analysis(), node, scan.names);
+  if (keys === void 0) return [{ shape: "dynamic-import", names: [] }];
+  return keys.length === 0 ? [] : [{ shape: "dynamic-import", names: keys }];
+}
+function takesOf(node, scan) {
+  const source = staticStringOf(nodeAt(node, "source"));
+  if (source === void 0 || !scan.reaches.has(source)) return [];
+  if (node.type === "ImportDeclaration") return importTakes(node, source, scan);
+  if (node.type === "ImportExpression") return dynamicTakes(node, scan);
+  return exportTakes(node, scan);
+}
+function takesIn(program, input) {
+  let analysis;
+  const scan = {
+    ...input,
+    analysis: () => analysis ??= analyze(program)
+  };
+  const found = [];
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    pushAll(found, takesOf(node, scan));
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+
+// src/vite-listed-routes.ts
+async function takenBy(ctx, input) {
+  const { file, id, names, resolutions } = input;
+  const code = ctx.getModuleInfo?.(id)?.code;
+  try {
+    const read = code === null || code === void 0 ? void 0 : await reachingSpecifiers(ctx, { code, file, id, resolutions });
+    if (!read || read.reaches.size === 0) return [UNREADABLE];
+    return takesIn(read.program, { names, reaches: read.reaches });
+  } catch {
+    return [UNREADABLE];
+  }
+}
+function merged2(takes) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const take of takes) {
+    const key = `${take.taker}\0${take.shape}`;
+    const known = byKey.get(key);
+    const names = /* @__PURE__ */ new Set([...known?.names ?? [], ...take.names]);
+    const isReached = take.isReached || known?.isReached === true;
+    const isPassedOn = take.isPassedOn === true || known?.isPassedOn === true;
+    byKey.set(key, { ...take, isPassedOn, isReached, names: [...names].toSorted(compareText) });
+  }
+  return byKey.values().toArray();
+}
+async function isCounted(context, input) {
+  const { importer, isEntry, pkg, wantCalls } = input;
+  if (wantCalls || !isDependencyId(importer)) return true;
+  if (!isEntry) return false;
+  return await packageNameOf(filePathOf(importer), context.packageNames) !== pkg;
+}
+async function routesOf(ctx, context, input) {
+  const { holder, importer, isEntry, resolutions, wantCalls } = input;
+  const isDependency = isDependencyId(importer);
+  const taker = moduleLabel(context.root, importer);
+  const taken = await takenBy(ctx, {
+    file: fileOf(holder.id),
+    id: importer,
+    names: holder.names,
+    resolutions
+  });
+  const takes = taken.map((take) => ({ ...take, taker, isReached: holder.isReached }));
+  if (isDependency) {
+    const calls = takes.filter((take) => take.isForward !== true);
+    return { entry: isEntry ? calls : [], told: [], calls: wantCalls ? calls : [] };
+  }
+  const isCleared = (take) => isEntry && take.shape !== "unreadable";
+  return {
+    entry: takes.filter((take) => isCleared(take)),
+    told: takes.filter((take) => !isCleared(take)),
+    calls: []
+  };
+}
+function serverTakesOf(found, holder) {
+  const takes = [];
+  for (const taken of found.takes) {
+    const names = taken.names.filter((name) => holder.names.has(name));
+    const isWhole = taken.names.length === 0;
+    const hasNamed = holder.names.keys().some((name) => name !== "default");
+    const isTaken = taken.shape === "star" ? hasNamed : isWhole || names.length > 0;
+    if (isTaken) {
+      const kept = isWhole ? taken.names : names;
+      takes.push({
+        ...taken,
+        names: kept,
+        taker: found.taker,
+        isReached: holder.isReached,
+        ...found.isRecorded === true && { isRecorded: true }
+      });
+    }
+  }
+  return takes;
+}
+async function takesFrom(ctx, context, input) {
+  const { holder, isEntry, pkg, resolutions, wantCalls } = input;
+  const importers = importersOf(ctx, holder.id);
+  const entry = [];
+  const told = [];
+  const calls = [];
+  for (const importer of importers) {
+    if (!await isCounted(context, { importer, isEntry, pkg, wantCalls })) {
+      continue;
+    }
+    const routes = await routesOf(ctx, context, {
+      holder,
+      importer,
+      isEntry,
+      resolutions,
+      wantCalls
+    });
+    pushAll(entry, routes.entry);
+    pushAll(told, routes.told);
+    pushAll(calls, routes.calls);
+  }
+  return { entry: merged2(entry), told: merged2(told), calls: merged2(calls) };
+}
+function serverRoutes(holder, input) {
+  const file = fileOf(holder.id);
+  const fromServer = input.serverImports.filter((one) => one.file === file);
+  const takes = fromServer.flatMap((found) => serverTakesOf(found, holder));
+  const isCleared = (take) => input.isEntry && take.shape !== "unreadable";
+  return {
+    entry: takes.filter((take) => isCleared(take)),
+    told: takes.filter((take) => !isCleared(take))
+  };
+}
+
+// src/vite-listed-takes.ts
+async function prepareOne(ctx, context, input) {
+  const { isHop, problems, walk } = input;
+  const first = problems[0];
+  const pkg = first.pkg;
+  const names = new Set(problems.flatMap((problem) => problem.exportedAs ?? []));
+  const hasEntry = !isHop && problems.some((problem) => problem.specifier !== void 0);
+  const holders = await holdersOf(ctx, { ...walk, id: first.moduleId, names });
+  const routed = await Promise.all(
+    holders.map(
+      (holder) => takesFrom(ctx, context, {
+        holder,
+        isEntry: hasEntry && !holder.isReached,
+        pkg,
+        resolutions: walk.resolutions,
+        wantCalls: isHop
+      })
+    )
+  );
+  const isListed2 = Object.hasOwn(context.options.keepFor, pkg);
+  return { hasEntry, holders, isHop, isListed: isListed2, problems, routed };
+}
+function decideOne(prepared, serverImports) {
+  const { hasEntry, holders, isHop, isListed: isListed2, problems, routed } = prepared;
+  const fromServer = holders.map(
+    (holder) => serverRoutes(holder, { isEntry: hasEntry && !holder.isReached, serverImports })
+  );
+  const entry = [...routed.flatMap((route) => route.entry), ...fromServer.flatMap((r) => r.entry)];
+  if (entry.length > 0) return problems.filter((problem) => problem.specifier !== void 0);
+  const told = merged2([
+    ...routed.flatMap((route) => route.told),
+    ...fromServer.flatMap((route) => route.told)
+  ]);
+  const callers = isHop && !isListed2 ? callersOf(routed) : [];
+  if (told.length === 0 && callers.length === 0) return [];
+  return problems.map((problem) => ({
+    ...problem,
+    ...told.length > 0 && { takes: told },
+    ...callers.length > 0 && { callers }
+  }));
+}
+function callersOf(routed) {
+  const callers = new Set(routed.flatMap((route) => route.calls.map((call) => call.taker)));
+  return [...callers].toSorted(compareText);
+}
+async function prepareReexports(ctx, context, standingIn) {
+  const exporting = standingIn.filter((problem) => problem.exportedAs !== void 0);
+  const located = await withClearingSpecifiers(ctx, context, exporting);
+  const byModule = /* @__PURE__ */ new Map();
+  const hops = /* @__PURE__ */ new Map();
+  for (const problem of located) {
+    if (problem.moduleId === void 0 || problem.pkg === void 0) continue;
+    const group = isSecondHop(problem) ? hops : byModule;
+    group.set(problem.moduleId, [...group.get(problem.moduleId) ?? [], problem]);
+  }
+  const cxExports = new Map(
+    [...byModule.values(), ...hops.values()].map((problems) => [
+      fileOf(problems[0].moduleId),
+      new Set(problems.flatMap((problem) => problem.exportedAs ?? []))
+    ])
+  );
+  const walk = { cxExports, resolutions: /* @__PURE__ */ new Map() };
+  return await Promise.all([
+    ...byModule.values().map((problems) => prepareOne(ctx, context, { isHop: false, problems, walk })),
+    ...hops.values().map((problems) => prepareOne(ctx, context, { isHop: true, problems, walk }))
+  ]);
+}
+function decideReexports(prepared, serverImports) {
+  return prepared.flatMap((one) => decideOne(one, serverImports));
+}
+
+// src/vite-order.ts
+function checkEnvironmentOrder(ctx, context) {
+  const { emitted } = context.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 (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")
+  );
+}
+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;
+  }
+}
+function targetFile(target, input) {
+  if (typeof target === "string") return target.split("*").join(input.match);
+  if (Array.isArray(target)) {
+    return target.map((item) => targetFile(item, input)).find((file) => file !== void 0);
+  }
+  if (target === null || typeof target !== "object") return void 0;
+  const entries = Object.entries(target);
+  const key = entries.find(([name]) => input.conditions.has(name) || name === "default");
+  return key === void 0 ? void 0 : targetFile(key[1], input);
+}
+function exportsEntry(exported, subpath) {
+  const isMap = exported !== null && typeof exported === "object" && !Array.isArray(exported) && Object.keys(exported).every((key) => key.startsWith("."));
+  if (!isMap) return subpath === "." ? { match: "", target: exported } : void 0;
+  const map = exported;
+  if (Object.hasOwn(map, subpath)) return { match: "", target: map[subpath] };
+  const patterns = Object.keys(map).filter((key) => key.includes("*") && subpath.startsWith(key.slice(0, key.indexOf("*")))).toSorted((a, b) => b.indexOf("*") - a.indexOf("*") || b.length - a.length);
+  const pattern = patterns.find((key) => subpath.endsWith(key.slice(key.indexOf("*") + 1)));
+  if (pattern === void 0) return void 0;
+  const [head, tail] = pattern.split("*");
+  return { match: subpath.slice(head.length, subpath.length - tail.length), target: map[pattern] };
+}
+function existingFile(base) {
+  return EXTENSIONS.map((extension) => `${base}${extension}`).find(
+    (candidate) => existsSync(candidate) && statSync(candidate).isFile()
+  );
+}
+function manifestOf(directory) {
+  try {
+    return JSON.parse(readFileSync(path2.join(directory, "package.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function relativeTarget(manifest, input) {
+  const { conditions, subpath } = input;
+  if (manifest.exports === void 0) {
+    return subpath === "." ? manifest.main ?? "index.js" : subpath;
+  }
+  const entry = exportsEntry(manifest.exports, subpath);
+  return entry ? targetFile(entry.target, { conditions, match: entry.match }) : void 0;
+}
+function serverFileOf(input) {
+  const parts = PACKAGE_NAME.exec(input.specifier);
+  const directory = parts && packageDirectory(path2.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));
+  return file === void 0 ? void 0 : realpathSync(file);
+}
+var PACKAGE_NAME2 = /^(@[^/]+\/[^/]+|[^./@][^/]*)/;
+function packageOfSpecifier(specifier) {
+  if (specifier.startsWith("node:") || specifier.startsWith("\0")) return void 0;
+  return PACKAGE_NAME2.exec(specifier)?.[1];
+}
+function isDeclaringCore(root, name) {
+  for (let directory = root; ; directory = path2.dirname(directory)) {
+    try {
+      const manifest = JSON.parse(
+        readFileSync(path2.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;
+    }
+  }
+}
+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 judgeExternals(ctx, context) {
+  const { state } = context;
+  for (const name of state.externals) {
+    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));
+  }
+  state.externals.clear();
+}
+function noteServerExternals(ctx, context) {
+  const ids = ctx.getModuleIds?.() ?? [];
+  for (const id of ids) {
+    const name = packageOfSpecifier(id);
+    if (name !== void 0 && isDeclaringCore(context.root, name)) context.state.externals.add(name);
+  }
+  if (!context.inProcess || context.state.clientEnded) judgeExternals(ctx, context);
+}
+function noteClientEnded(ctx, context) {
+  context.state.clientEnded = true;
+  judgeExternals(ctx, context);
+}
+
+// src/vite-server-takes.ts
+var SERVER_TAKES_FILE = "nave-used-server-takes.json";
+function parsed(ctx, id) {
+  const code = ctx.getModuleInfo?.(id)?.code;
+  try {
+    return code === null || code === void 0 ? void 0 : ctx.parse?.(code);
+  } catch {
+    return void 0;
+  }
+}
+function formatOf(ctx) {
+  const build = ctx.environment.config.build;
+  const output = build?.rolldownOptions?.output ?? build?.rollupOptions?.output;
+  const first = Array.isArray(output) ? output[0] : output;
+  return first?.format;
+}
+function conditionsOf(ctx) {
+  return ["node", formatOf(ctx) === "cjs" ? "require" : "import", "module-sync", "default"];
+}
+function importsOf(ctx, input) {
+  const { externals, id, root } = input;
+  const program = parsed(ctx, id);
+  const taker = path2.relative(root, filePathOf(id)).replaceAll("\\", "/");
+  const conditions = conditionsOf(ctx);
+  const named = program ? specifiersIn(program).filter((one) => externals.has(one)) : [];
+  const info = ctx.getModuleInfo?.(id);
+  const shown = [...info?.importedIds ?? [], ...info?.dynamicallyImportedIds ?? []];
+  const unread = shown.filter((one) => externals.has(one) && !named.includes(one));
+  const read = named.map((specifier) => ({
+    specifier,
+    takes: program ? takesIn(program, { names: void 0, reaches: /* @__PURE__ */ new Set([specifier]) }) : [],
+    taker
+  }));
+  const imports = [
+    ...read.filter((found) => found.takes.length > 0),
+    ...unread.map((specifier) => ({
+      isUnreadable: true,
+      specifier,
+      takes: [UNREADABLE],
+      taker
+    }))
+  ];
+  return imports.map((found) => {
+    const file = serverFileOf({
+      conditions,
+      from: filePathOf(id),
+      specifier: found.specifier
+    });
+    return { ...found, ...file !== void 0 && { file } };
+  });
+}
+function serverImportsOf(ctx, context) {
+  const ids = [...ctx.getModuleIds?.() ?? []];
+  const isListed2 = (id) => {
+    const name = packageOfSpecifier(id);
+    return name !== void 0 && Object.hasOwn(context.options.keepFor, name);
+  };
+  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 }));
+}
+function buildKeyOf(ctx) {
+  const build = ctx.environment.config.build;
+  return `${ctx.environment.name}\0${JSON.stringify(build?.rolldownOptions?.input ?? build?.ssr ?? "")}`;
+}
+function readEntries(context) {
+  try {
+    const parsedFile = JSON.parse(
+      readFileSync(path2.join(context.cacheDir, SERVER_TAKES_FILE), "utf8")
+    );
+    const isEntries = typeof parsedFile === "object" && parsedFile !== null && !Array.isArray(parsedFile);
+    return isEntries ? parsedFile : {};
+  } catch {
+    return {};
+  }
+}
+function writeServerImports(ctx, context, imports) {
+  if (context.cacheDir === "") return;
+  const file = path2.join(context.cacheDir, SERVER_TAKES_FILE);
+  try {
+    mkdirSync(context.cacheDir, { recursive: true });
+    const entries = { ...readEntries(context), [buildKeyOf(ctx)]: imports };
+    writeFileSync(file, `${JSON.stringify(entries, void 0, 2)}
+`);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    ctx.warn(
+      `navePlugin(): could not write ${file} (${reason}), so a build of the client run as another process cannot check what your server code takes from a package keepFor lists.`
+    );
+  }
+}
+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 }));
+}
+function graphOf(ctx) {
+  return new Set([...ctx.getModuleIds?.() ?? []].map((id) => fileOf(id)));
+}
+function judgeable(graph, imports) {
+  const known = [];
+  const unknown = [];
+  for (const found of imports) {
+    const { file } = found;
+    if (file !== void 0 && found.isUnreadable !== true && graph.has(fileOf(file))) {
+      known.push({ ...found, file });
+    } else {
+      unknown.push(found);
+    }
+  }
+  return { known, unknown };
+}
+function recordedSentence(takers) {
+  const named = [...new Set(takers)].toSorted(compareText).join(", ");
+  if (named === "") return void 0;
+  return new Set(takers).size === 1 ? `${named} was read by an earlier server build, not by this one, so what this message says of its imports comes from the record that build left in Vite's cache directory; if the file has changed since, run that server build again to refresh the record, or, if you no longer run that build, delete nave-used-server-takes.json there and run each server build you do.` : `${named} were read by earlier server builds, not by this one, so what this message says of their imports comes from the records those builds left in Vite's cache directory; if one of those files has changed since, run the server build that read it again to refresh its record, or, if you no longer run that build, delete nave-used-server-takes.json there and run each server build you do.`;
+}
+function recordedTakers(imports) {
+  return imports.filter((found) => found.isRecorded === true).map((found) => found.taker);
+}
+function warningFor2(pkg, input) {
+  const { found, root } = input;
+  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("\\", "/");
+    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.`;
+  return note === void 0 ? warning : `${warning} ${note}`;
+}
+function warnUnknown(ctx, context, unknown) {
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const found of unknown) {
+    const pkg = packageOfSpecifier(found.specifier);
+    if (pkg === void 0 || context.state.warned.has(pkg)) continue;
+    byPackage.set(pkg, [...byPackage.get(pkg) ?? [], found]);
+  }
+  for (const [pkg, imports] of byPackage) {
+    context.state.warned.add(pkg);
+    ctx.warn(warningFor2(pkg, { found: imports, root: context.root }));
+  }
+}
+
+// src/vite-collect-plugin.ts
+var OPTIONS_HOME = "navePlugin()";
+function isReadable(context, id) {
+  return isUsed(context) && !isStylesheetId(id) && !isNaveOwn(id);
+}
+async function problemsOfBuild(ctx, context, serverImports) {
+  const records = recordsOf(context.state, ctx.environment.name);
+  const kept = await withClearingSpecifiers(
+    ctx,
+    context,
+    withoutEchoes(
+      records.map((record) => ({
+        onlyVia: record.onlyVia,
+        problems: [
+          ...problemsOf(record, context),
+          ...record.suppressed.filter((problem) => problem.kind === "declared")
+        ]
+      }))
+    )
+  );
+  const standingIn = [
+    ...records.flatMap((record) => record.suppressed),
+    ...kept.filter((problem) => isSecondHop(problem))
+  ];
+  const rest = kept.filter((problem) => !isSecondHop(problem));
+  const prepared = await prepareReexports(ctx, context, standingIn);
+  return { problems: [...rest, ...decideReexports(prepared, serverImports)], prepared };
+}
+function reportOf(context, problems) {
+  const report = buildReport(problems, context.options.cxModules, OPTIONS_HOME);
+  const recorded = problems.flatMap((problem) => problem.takes ?? []).filter((take) => take.isRecorded === true).map((take) => take.taker);
+  const note = recordedSentence(recorded);
+  return note === void 0 ? report : `${report}
+${note}`;
+}
+async function failuresOf(ctx, context, serverImports) {
+  const { problems, prepared } = await problemsOfBuild(ctx, context, serverImports);
+  const report = problems.length > 0 ? reportOf(context, problems) : void 0;
+  const importers = await declaredImporterError(ctx, context, {
+    configured: withoutRemoved(problems, context.options.cxModules),
+    home: OPTIONS_HOME,
+    report
+  });
+  return { failures: [report, importers].filter((failure) => failure !== void 0), prepared };
+}
+function serverImportsForClient(ctx, context, graph) {
+  if (ctx.environment.config.consumer !== "client") return { known: [], unknown: [] };
+  const imports = context.inProcess ? context.state.serverImports : readServerImports(context);
+  return judgeable(graph, imports);
+}
+function noteServerImports(ctx, context) {
+  const imports = serverImportsOf(ctx, context);
+  if (!context.inProcess) {
+    writeServerImports(ctx, context, imports);
+    return;
+  }
+  context.state.serverImports.push(...imports);
+  const { client } = context.state;
+  if (client === void 0 || imports.length === 0) return;
+  const { known, unknown } = judgeable(client.graph, imports);
+  const problems = decideReexports(client.prepared, known);
+  if (problems.length > 0) ctx.error(reportOf(context, problems));
+  warnUnknown(ctx, context, unknown);
+}
+function createCollectPlugin(context) {
+  const plugin = {
+    name: "nave:collect",
+    enforce: "post",
+    async buildStart() {
+      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;
+    },
+    async transform(code, id, meta) {
+      if (!isReadable(context, id)) return;
+      if (this.environment?.config.consumer === "server") context.state.serverTransformed = true;
+      const record = await recordModule(context, this, { code, id, moduleType: meta?.moduleType });
+      if (context.command === "serve") devServing.noteGrowth(context);
+      if (record?.edits) return applyEdits(code, id, record.edits);
+      if (record) failDevModule(this, context, { home: OPTIONS_HOME, id, record });
+    },
+    transformIndexHtml: {
+      order: "pre",
+      handler(html, { filename }) {
+        if (!isUsed(context)) return;
+        context.state.htmlRead = true;
+        if (filename === void 0 || !isMentioningAtoms(html)) return;
+        context.state.pages.set(filename, atomsWrittenIn(html));
+        if (context.command === "serve") devServing.notePages(context);
+      }
+    },
+    async buildEnd(error) {
+      if (error || !isUsed(context) || context.command !== "build") return;
+      const graph = graphOf(this);
+      const server = serverImportsForClient(this, context, graph);
+      const { failures, prepared } = await failuresOf(this, context, server.known);
+      if (failures.length > 0) this.error(failures.join("\n\n"));
+      await checkCxImporters(this, context);
+      checkEnvironmentOrder(this, context);
+      if (this.environment.config.consumer === "server") {
+        checkServerInvocation(this, context);
+        noteServerExternals(this, context);
+        noteServerImports(this, context);
+      } else {
+        noteClientEnded(this, context);
+        warnUnknown(this, context, server.unknown);
+        context.state.client = { graph, prepared };
+      }
+      judgeAfterLastEnvironment(context, this.environment, (message) => this.warn(message));
+    }
+  };
+  return plugin;
+}
+
+// src/vite-worker-collect.ts
+function workerCollectPlugins(context) {
+  const plugin = {
+    name: "nave:collect-worker",
+    enforce: "post",
+    async transform(code, id, meta) {
+      if (!isReadable(context, id)) return;
+      const record = await recordModule(context, this, { code, id, moduleType: meta?.moduleType });
+      if (record?.edits) return applyEdits(code, id, record.edits);
+    },
+    async buildEnd(error) {
+      if (error || !isUsed(context) || context.command !== "build") return;
+      await checkCxImporters(this, context);
+    }
+  };
+  return () => context.command === "build" ? [plugin] : [];
+}
+
+// src/vite-config-hooks.ts
+function usedConfig(context, command) {
+  if (context.options.atomic !== "used") return void 0;
+  const map = keepMap(context.kept);
+  return {
+    define: {
+      [KEEP_CONSTANT]: command === "serve" ? devKeepExpression(map, Object.keys(atomClassMap)) : JSON.stringify(map)
+    },
+    optimizeDeps: { exclude: ["@navecss/core"] },
+    worker: { plugins: workerCollectPlugins(context) }
+  };
+}
+function isServerEnvironment(name, options) {
+  return (options.consumer ?? (name === "client" ? "client" : "server")) === "server";
+}
+function usedEnvironmentConfig(context, name, options) {
+  if (context.options.atomic !== "used" || !isServerEnvironment(name, options)) return void 0;
+  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);
+  validateExtendAtomsHostFree(snapshot);
+  return snapshot;
+}
+function objectSource(extend) {
+  const snapshot = snapshotAndValidate(extend);
+  return {
+    current: () => Promise.resolve(snapshot)
+  };
+}
+function moduleSource(specifier) {
+  const cache = /* @__PURE__ */ new Map();
+  let root = process.cwd();
+  let file;
+  return {
+    configure(directory) {
+      root = directory;
+      file = resolveExtendSpecifier(specifier, root);
+    },
+    file: () => file,
+    async current(watch) {
+      file ??= resolveExtendSpecifier(specifier, root);
+      watch(file);
+      let loaded = {};
+      await applyExtendModule(file, cache, (value) => {
+        loaded = snapshotAndValidate(value);
+      });
+      return loaded;
+    }
+  };
+}
+function createExtendSource(option) {
+  if (typeof option === "string") return moduleSource(option);
+  return objectSource(option ?? {});
+}
+
+// src/vite-logger.ts
+var ANSI_ESCAPE = new RegExp(String.raw`\u001B\[[\d;]*m`, "g");
+var UNKNOWN_NAVE_RULE = /Unknown at rule: @nave(?![\w-]|[^\p{ASCII}])/iu;
+function isUnknownNaveRuleWarning(message) {
+  return typeof message === "string" && UNKNOWN_NAVE_RULE.test(message.replaceAll(ANSI_ESCAPE, ""));
+}
+var wrappers = /* @__PURE__ */ new WeakMap();
+function dropLightningNaveWarning(logger) {
+  if (wrappers.get(logger) === logger.warn) return;
+  const original = logger.warn.bind(logger);
+  const wrapper = function warn(message, options) {
+    if (isUnknownNaveRuleWarning(message)) return;
+    original(message, options);
+  };
+  logger.warn = wrapper;
+  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) => {
+    ctx.warn(message);
+  };
+}
+function serverHooks(context) {
+  return {
+    configureServer(server) {
+      const devServer = server;
+      const owner = devServer.environments.client;
+      installServerKeepMap(context, owner);
+      const close = devServer.close.bind(devServer);
+      const noteConnect = () => {
+        devServing.noteConnect(context);
+      };
+      const noteDisconnect = () => {
+        devServing.noteDisconnect(context);
+      };
+      owner.hot.on("vite:client:connect", noteConnect);
+      owner.hot.on("vite:client:disconnect", noteDisconnect);
+      devServer.close = () => {
+        removeServerKeepMap(owner);
+        owner.hot.off("vite:client:connect", noteConnect);
+        owner.hot.off("vite:client:disconnect", noteDisconnect);
+        return close();
+      };
+      noteStylesheetRequests(context, devServer);
+    },
+    closeBundle() {
+      removeServerKeepMap(this.environment);
+    },
+    buildApp: {
+      order: "post",
+      handler(builder) {
+        if (context.command === "build") expectBuilds(context, builder, warnThrough(this));
+        return Promise.resolve();
+      }
+    }
+  };
+}
+
+// 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;
+  const map = input.ctx.getCombinedSourcemap();
+  return map.mappings === "" ? void 0 : toSourceMap(map);
+}
+function transformStylesheet(input) {
+  const file = filePathOf(input.id);
+  const inputSourceMap = incomingMapOf(input);
+  const result = expandText(input.code, {
+    extend: input.extend,
+    onUnknown: input.onUnknown,
+    from: file,
+    inputSourceMap
+  });
+  reportDiagnostics({
+    ctx: input.ctx,
+    diagnostics: result.diagnostics,
+    extend: input.extend,
+    id: input.id,
+    file,
+    incoming: inputSourceMap && decodeIncomingMap(inputSourceMap),
+    onUnknown: input.onUnknown
+  });
+  return { code: result.css, map: result.map };
+}
+
+// src/vite-stylesheets.ts
+function hasStylesheetMapsFor(config) {
+  return config.command === "serve" ? config.css?.devSourcemap === true : Boolean(config.build?.sourcemap);
+}
+function withForwardSlashes(file) {
+  return file.replaceAll("\\", "/");
+}
+function createStylesheets(extend, onUnknown) {
+  let hasStylesheetMaps = false;
+  const failed = /* @__PURE__ */ new Map();
+  async function expand(ctx, code, id) {
+    const environment = ctx.environment?.name ?? "client";
+    let atoms;
+    try {
+      atoms = await extend.current((file) => {
+        ctx.addWatchFile(file);
+      });
+    } catch (error) {
+      failed.set(environment, (failed.get(environment) ?? /* @__PURE__ */ new Set()).add(id));
+      throw error;
+    }
+    failed.get(environment)?.delete(id);
+    return transformStylesheet({ ctx, code, id, extend: atoms, onUnknown, hasStylesheetMaps });
+  }
+  return {
+    configure(config) {
+      hasStylesheetMaps = hasStylesheetMapsFor(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;
+    },
+    hotUpdate(ctx, hot) {
+      const ids = failed.get(ctx.environment.name);
+      const file = extend.file?.();
+      if (!ids || file === void 0 || ids.size === 0) return;
+      if (hot.file !== withForwardSlashes(file)) return;
+      const { moduleGraph } = ctx.environment;
+      for (const id of ids) {
+        const module = moduleGraph.getModuleById(id);
+        if (module) moduleGraph.invalidateModule(module);
+      }
+      ids.clear();
+      ctx.environment.hot.send({ type: "full-reload" });
+      return [];
+    }
+  };
+}
+
+// src/vite.ts
+function assemble(options, extend) {
+  const context = createUsedContext(resolveUsedOptions(options), extend);
+  const stylesheets = createStylesheets(extend, options.onUnknown ?? "error");
+  const nave = {
+    name: "nave",
+    config: (_config, env) => usedConfig(context, env?.command),
+    configEnvironment: (name, environmentOptions) => usedEnvironmentConfig(context, name, environmentOptions),
+    configResolved(config) {
+      extend.configure?.(config.root);
+      configureUsed(context, config);
+      stylesheets.configure(config);
+      if (context.command === "build" && isUsed(context))
+        captureStylesheets(context, config.plugins);
+      if (config.css?.transformer === "lightningcss") dropLightningNaveWarning(config.logger);
+    },
+    ...serverHooks(context),
+    async transform(code, id) {
+      const expanded = await stylesheets.transform(this, code, id);
+      if (expanded !== void 0 && expanded.code !== code) context.state.directiveExpanded = true;
+      if (context.command !== "serve" || !isUsed(context)) return expanded;
+      const served = await serveStylesheet(context, this, { css: expanded?.code ?? code, id });
+      return served ?? expanded;
+    },
+    hotUpdate(hot) {
+      const handled = stylesheets.hotUpdate(this, hot);
+      if (handled || context.command !== "serve" || !isUsed(context)) return handled;
+      return devServing.modulesWithGrown(context, this, hot);
+    },
+    async renderChunk(_code, chunk) {
+      if (!isUsed(context) || this.environment.config.consumer !== "client") return;
+      const emitted = emittedSet(context, this.environment, (message) => {
+        this.warn(message);
+      });
+      await refeedChunkStylesheets(this, chunk, 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);
+      }
+    }
+  };
+  return { nave, collect: createCollectPlugin(context) };
+}
+function navePlugin(options = {}) {
+  const ownAtoms = typeof options.extend === "object" ? options.extend : void 0;
+  const own = typeof options.extend === "string" ? void 0 : new Set(Object.keys(ownAtoms ?? {}));
+  assertOptions(options, own);
+  const inline = typeof options.extend === "string" ? void 0 : createExtendSource(options.extend);
+  return shareAcrossBuilds(() => assemble(options, inline ?? createExtendSource(options.extend)));
+}
+var vite_default = navePlugin;
+
+export { vite_default as default, navePlugin };