@navecss/core 0.3.0 → 0.4.0

package/dist/vite.js

@@ -1,9 +1,12 @@
 import { findingsInText, formatFinding } from './chunk-UANF3FGO.js';
-import { validateExtendAtomsHostFree } from './chunk-R6JJZGXC.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, formatDiagnostic, expandText, decodeIncomingMap, foldLocated } from './chunk-S7DZUVV3.js';
+import { snapshotExtendMap, expandText, foldLocated } from './chunk-LADFXRWQ.js';
 import { tokenize } from './chunk-NFS2REPQ.js';
-import { atomClassMap } from './chunk-LIUB4EES.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';
@@ -144,1544 +147,6 @@ function shareAcrossBuilds(assemble2) {
   return [firstHalf(pickers, configure), secondHalf(pickers)];
 }
 
-// src/vite-ast.ts
-function isNode(value) {
-  return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-function nodeAt(node, key) {
-  const value = node[key];
-  return isNode(value) ? value : void 0;
-}
-function nodesAt(node, key) {
-  const value = node[key];
-  return Array.isArray(value) ? value.filter((item) => isNode(item)) : [];
-}
-function stringAt(node, key) {
-  const value = node[key];
-  return typeof value === "string" ? value : void 0;
-}
-function childrenOf(node) {
-  return Object.values(node).flatMap((value) => {
-    if (Array.isArray(value)) return value.filter((item) => isNode(item));
-    return isNode(value) ? [value] : [];
-  });
-}
-function staticStringOf(node) {
-  if (!node) return void 0;
-  if (node.type === "Literal") {
-    return typeof node.value === "string" ? node.value : void 0;
-  }
-  if (node.type !== "TemplateLiteral" || nodesAt(node, "expressions").length > 0) return void 0;
-  const quasi = nodesAt(node, "quasis")[0];
-  const value = quasi?.value;
-  if (typeof value !== "object" || value === null) return void 0;
-  const cooked = value.cooked;
-  return typeof cooked === "string" ? cooked : void 0;
-}
-function exportNameOf(node) {
-  if (!node) return void 0;
-  return node.type === "Identifier" ? stringAt(node, "name") : staticStringOf(node);
-}
-function propertyNameOf(key, isComputed) {
-  if (!key) return void 0;
-  if (!isComputed && key.type === "Identifier") return stringAt(key, "name");
-  return staticStringOf(key);
-}
-
-// src/vite-atom-check.ts
-function isBuiltInAtom(name) {
-  return Object.hasOwn(atomClassMap, name);
-}
-function hintFor(name) {
-  const text = formatDiagnostic({ code: "unknown-atom", name, offset: 0, endOffset: 0 });
-  const hint = text.slice(`@nave: unknown atom "${name}". `.length);
-  return hint.startsWith("Did you mean") ? hint : void 0;
-}
-function literal(text) {
-  return `'${text.replaceAll("\\", "\\\\").replaceAll("'", String.raw`\'`)}'`;
-}
-function whitespaceText(value) {
-  const names = value.split(/\s+/).filter(Boolean);
-  if (names.length < 2) {
-    return `"${value}" has whitespace around the atom name. Write it without: cx(${literal(names[0] ?? "")}).`;
-  }
-  const count = names.length === 2 ? "two" : String(names.length);
-  const call = names.map((name) => literal(name)).join(", ");
-  return `"${value}" is ${count} atom names in one string. Pass one per argument: cx(${call}).`;
-}
-function unknownText(name) {
-  return `unknown atom "${name}". cx() takes Nave atoms only; for a class of your own, use a CSS Module class or cx.raw(${literal(name)}).`;
-}
-function judgeAtom(value, own) {
-  if (/\s/.test(value)) return { kind: "whitespace", text: whitespaceText(value) };
-  if (isBuiltInAtom(value)) return { kind: "atom" };
-  if (own.has(value)) return { kind: "own" };
-  const hint = hintFor(value);
-  if (hint) return { kind: "unknown", text: `unknown atom "${value}". ${hint}`, hasHint: true };
-  return { kind: "unknown", text: unknownText(value), hasHint: false };
-}
-function availableLine() {
-  return `Available: ${Object.keys(atomClassMap).join(", ")}`;
-}
-
-// src/vite-setup-member.ts
-function setupMemberName(node) {
-  if (node.type !== "MemberExpression") return void 0;
-  const object = nodeAt(node, "object");
-  if (object?.type !== "Identifier" || stringAt(object, "name") !== "$setup") return void 0;
-  return propertyNameOf(nodeAt(node, "property"), node.computed === true);
-}
-var FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  "ArrowFunctionExpression",
-  "FunctionDeclaration",
-  "FunctionExpression"
-]);
-function isOutsideFunctions(node, parentOf) {
-  for (let current = parentOf.get(node); current; current = parentOf.get(current)) {
-    if (FUNCTION_TYPES.has(current.type)) return false;
-  }
-  return true;
-}
-var SETUP_PARAMETER_POSITIONS = [3, 5];
-function isSetupParameter(analysis, identifier) {
-  const binding = analysis.referenceOf(identifier)?.binding;
-  const owner = binding?.owner;
-  if (!owner || binding.kind !== "param" || binding.name !== "$setup") return false;
-  if (!isOutsideFunctions(owner, analysis.parentOf)) return false;
-  const params = nodesAt(owner, "params");
-  return SETUP_PARAMETER_POSITIONS.some((position) => {
-    const parameter = params[position];
-    return parameter?.type === "Identifier" && stringAt(parameter, "name") === binding.name;
-  });
-}
-function isSetupMethod(setup, parentOf) {
-  const property = setup && parentOf.get(setup);
-  if (setup?.type !== "FunctionExpression" || property?.type !== "Property") return false;
-  return propertyNameOf(nodeAt(property, "key"), property.computed === true) === "setup";
-}
-function isSetupReturn(declarator, parentOf) {
-  if (declarator?.type !== "VariableDeclarator") return false;
-  if (stringAt(nodeAt(declarator, "id") ?? declarator, "name") !== "__returned__") return false;
-  const declaration = parentOf.get(declarator);
-  const block = declaration && parentOf.get(declaration);
-  return block?.type === "BlockStatement" && isSetupMethod(parentOf.get(block), parentOf);
-}
-function mergedExposures(linked, own) {
-  if (own.size === 0) return linked;
-  return new Map([...own, ...linked ?? []]);
-}
-
-// src/vite-cx-args.ts
-function literalValue(node) {
-  const value = node.value;
-  if (value === null && node.raw === "null") return [];
-  return value === false ? [] : void 0;
-}
-function unaryValue(node) {
-  const argument = nodeAt(node, "argument");
-  const isNumber = (value) => argument?.type === "Literal" && argument.value === value;
-  const isFalse = node.operator === "!" && isNumber(1);
-  const isUndefined = node.operator === "void" && isNumber(0);
-  return isFalse || isUndefined ? [] : void 0;
-}
-function soleInitialiserBinding(binding) {
-  const isPlain = binding && ["const", "let", "var"].includes(binding.kind);
-  return isPlain && binding.init && binding.writes === 0 ? binding : void 0;
-}
-function operandOf(node) {
-  if (node?.type !== "Literal") return void 0;
-  const { value } = node;
-  return { isFalsy: !value, isNullish: value === null };
-}
-function setupValue(node, context) {
-  const object = nodeAt(node, "object");
-  if (!object || !isSetupParameter(context.analysis, object)) return void 0;
-  const name = setupMemberName(node);
-  const exposure = name === void 0 ? void 0 : context.setup?.get(name);
-  if (exposure?.kind !== "values") return void 0;
-  return exposure.values.filter((value) => value !== "").map((value) => ({ value, node }));
-}
-var RESOLVED = /* @__PURE__ */ new WeakMap();
-function resolvedFor(analysis, setup) {
-  if (setup) return /* @__PURE__ */ new Map();
-  const found = RESOLVED.get(analysis) ?? /* @__PURE__ */ new Map();
-  RESOLVED.set(analysis, found);
-  return found;
-}
-function unionOf(parts) {
-  if (parts.includes(void 0)) return void 0;
-  const seen = /* @__PURE__ */ new Map();
-  const isNew = (possible) => {
-    const values = seen.get(possible.node) ?? /* @__PURE__ */ new Set();
-    seen.set(possible.node, values);
-    const before = values.size;
-    values.add(possible.value);
-    return values.size > before;
-  };
-  return parts.flatMap((part) => part.filter((possible) => isNew(possible)));
-}
-var first = (done) => done[0];
-var leaf = (result) => ({ deps: [], combine: () => result });
-function planOfName(node, context) {
-  const reference2 = context.analysis.referenceOf(node);
-  if (!reference2?.binding) return leaf(stringAt(node, "name") === "undefined" ? [] : void 0);
-  const binding = soleInitialiserBinding(reference2.binding);
-  if (!binding) return leaf(void 0);
-  if (context.resolved.has(binding)) return leaf(context.resolved.get(binding));
-  if (context.resolving.has(binding)) return leaf(void 0);
-  context.resolving.add(binding);
-  return {
-    deps: [binding.init],
-    combine: first,
-    finish(result) {
-      context.resolving.delete(binding);
-      context.resolved.set(binding, result);
-    }
-  };
-}
-function planOfLogical(node) {
-  const left = nodeAt(node, "left");
-  const right = nodeAt(node, "right");
-  const operand = operandOf(left);
-  if (node.operator === "&&") {
-    return operand?.isFalsy ? leaf([]) : { deps: [right], combine: first };
-  }
-  const isDecided = node.operator === "||" ? operand?.isFalsy : operand?.isNullish;
-  if (isDecided === false) return { deps: [left], combine: first };
-  return { deps: [left, right], combine: unionOf };
-}
-function planOf(node, context) {
-  const text = staticStringOf(node);
-  if (text !== void 0) return leaf(text === "" ? [] : [{ value: text, node }]);
-  switch (node.type) {
-    case "ConditionalExpression": {
-      return {
-        deps: [nodeAt(node, "consequent"), nodeAt(node, "alternate")],
-        combine: unionOf
-      };
-    }
-    case "Identifier": {
-      return planOfName(node, context);
-    }
-    case "Literal": {
-      return leaf(literalValue(node));
-    }
-    case "LogicalExpression": {
-      return planOfLogical(node);
-    }
-    case "MemberExpression": {
-      return leaf(setupValue(node, context));
-    }
-    case "ParenthesizedExpression": {
-      return { deps: [nodeAt(node, "expression")], combine: first };
-    }
-    case "UnaryExpression": {
-      return leaf(unaryValue(node));
-    }
-    default: {
-      return leaf(void 0);
-    }
-  }
-}
-function possibles(root, context) {
-  if (!root) return void 0;
-  const stack = [{ plan: planOf(root, context), done: [] }];
-  let result;
-  while (stack.length > 0) {
-    const top = stack.at(-1);
-    const next = top.plan.deps[top.done.length];
-    if (top.done.length < top.plan.deps.length) {
-      if (next) stack.push({ plan: planOf(next, context), done: [] });
-      else top.done.push(void 0);
-      continue;
-    }
-    result = top.plan.combine(top.done);
-    top.plan.finish?.(result);
-    stack.pop();
-    stack.at(-1)?.done.push(result);
-  }
-  return result;
-}
-function resolveArgument(node, analysis, setup) {
-  const resolved = resolvedFor(analysis, setup);
-  return possibles(node, { analysis, resolving: /* @__PURE__ */ new Set(), resolved, setup });
-}
-
-// src/vite-cx-bindings.ts
-function cxBindingsOf(analysis, sources) {
-  const found = /* @__PURE__ */ new Map();
-  for (const { binding } of analysis.references) {
-    if (binding?.kind !== "import" || !binding.source || !sources.has(binding.source)) continue;
-    if (binding.imported === "cx") found.set(binding, { binding, isNamespace: false });
-    else if (binding.imported === "*") found.set(binding, { binding, isNamespace: true });
-  }
-  return found;
-}
-function isImportingCx(program, sources) {
-  return nodesAt(program, "body").some((node) => {
-    const source = staticStringOf(nodeAt(node, "source"));
-    return node.type === "ImportDeclaration" && source !== void 0 && sources.has(source);
-  });
-}
-
-// src/vite-cx-refuse.ts
-function textOf(reading, node) {
-  return reading.code.slice(node.start, node.end);
-}
-function calleeName(reading, call) {
-  const callee = nodeAt(call, "callee");
-  if (!callee) return "a function";
-  if (callee.type === "Identifier") return stringAt(callee, "name") ?? "a function";
-  const isPlainMember = callee.type === "MemberExpression" && callee.computed !== true;
-  const property = isPlainMember ? nodeAt(callee, "property") : void 0;
-  return stringAt(property ?? callee, "name") ?? textOf(reading, callee);
-}
-var assignedTo = (reading, parent, local) => {
-  const target = nodeAt(parent, "id") ?? nodeAt(parent, "left") ?? parent;
-  return `${local} is assigned to ${textOf(reading, target)}`;
-};
-var reexported = (reading, parent, local) => `${textOf(reading, parent)}: a re-export of ${local}, which the build follows only from a module listed in cxModules`;
-var PHRASES = {
-  VariableDeclarator: assignedTo,
-  AssignmentExpression: assignedTo,
-  CallExpression: (reading, parent, local) => `${local} is passed to ${calleeName(reading, parent)}() as a value instead of being called`,
-  SpreadElement: (_reading, _parent, local) => `${local} is spread`,
-  ExportSpecifier: reexported,
-  ExportDefaultDeclaration: reexported
-};
-function phraseFor(reading, expression, local) {
-  const parent = reading.analysis.parentOf.get(expression);
-  const phrase = parent && PHRASES[parent.type];
-  return phrase && parent ? phrase(reading, parent, local) : `${local} is used as a value instead of being called`;
-}
-function isReexportOf(reading, expression) {
-  const parent = reading.analysis.parentOf.get(expression);
-  return parent?.type === "ExportSpecifier" || parent?.type === "ExportDefaultDeclaration";
-}
-function reexportNameOf(reading, expression) {
-  const parent = reading.analysis.parentOf.get(expression);
-  if (parent?.type === "ExportDefaultDeclaration") return "default";
-  return parent?.type === "ExportSpecifier" ? exportNameOf(nodeAt(parent, "exported")) : void 0;
-}
-function isRenamedReexportOf(reading, expression) {
-  const parent = reading.analysis.parentOf.get(expression);
-  if (parent?.type === "ExportDefaultDeclaration") return true;
-  return parent?.type === "ExportSpecifier" && exportNameOf(nodeAt(parent, "exported")) !== "cx";
-}
-
-// src/vite-cx-reference.ts
-function isCallee(parent, node) {
-  return parent?.type === "CallExpression" && nodeAt(parent, "callee") === node;
-}
-function isOnlyRaw(pattern) {
-  const properties = nodesAt(pattern, "properties");
-  const only = properties[0];
-  if (properties.length !== 1 || only?.type !== "Property") return false;
-  const name = propertyNameOf(nodeAt(only, "key"), only.computed === true);
-  return name === "raw" && nodeAt(only, "value")?.type === "Identifier";
-}
-function refused(node, local, phrase) {
-  return { kind: "refused", node, local, phrase };
-}
-function rawMemberUse(parent, member, local) {
-  const isAlias = parent?.type === "VariableDeclarator" && nodeAt(parent, "init") === member && nodeAt(parent, "id")?.type === "Identifier";
-  if (isAlias || isCallee(parent, member)) return { kind: "raw", node: member, local };
-  return refused(member, local, `${local}.raw is used other than by calling it`);
-}
-function memberUse(reading, member, local) {
-  const parent = reading.analysis.parentOf.get(member);
-  const isComputed = member.computed === true;
-  const name = propertyNameOf(nodeAt(member, "property"), isComputed);
-  if (name === "raw") return rawMemberUse(parent, member, local);
-  if (name === "dynamic" && !isComputed) {
-    if (parent && isCallee(parent, member)) return { kind: "dynamic", node: parent, local };
-    return refused(member, local, `${local}.dynamic is referenced other than by a direct call`);
-  }
-  if (name === "call" || name === "apply") {
-    return refused(member, local, `${local} is called through .${name}()`);
-  }
-  if (isComputed) return refused(member, local, `${local} is read with a computed member`);
-  return refused(member, local, `${local}.${name ?? "?"} is not a member the build reads`);
-}
-function isVueUnref(reading, callee) {
-  if (callee?.type !== "Identifier") return false;
-  const binding = reading.analysis.referenceOf(callee)?.binding;
-  return binding?.kind === "import" && binding.source === "vue" && binding.imported === "unref";
-}
-function throughUnref(reading, expression) {
-  let current = expression;
-  for (; ; ) {
-    const call = reading.analysis.parentOf.get(current);
-    const args = call ? nodesAt(call, "arguments") : [];
-    const isUnref = call?.type === "CallExpression" && args.length === 1 && args[0] === current && isVueUnref(reading, nodeAt(call, "callee"));
-    if (!isUnref) return current;
-    current = call;
-  }
-}
-function ancestor(reading, node, levels) {
-  let current = node;
-  for (let level = 0; current && level < levels; level += 1) {
-    current = reading.analysis.parentOf.get(current);
-  }
-  return current;
-}
-function exposureName(reading, expression) {
-  if (reading.allowsExposure !== true) return void 0;
-  const getter = ancestor(reading, expression, 4);
-  const isGetter = getter?.type === "Property" && getter.kind === "get";
-  const isReturn = ancestor(reading, expression, 1)?.type === "ReturnStatement";
-  if (!isGetter || !isReturn || !isSetupReturn(ancestor(reading, expression, 6), reading.analysis.parentOf))
-    return void 0;
-  return propertyNameOf(nodeAt(getter, "key"), getter.computed === true);
-}
-function rawDestructuring(parent, expression, local) {
-  if (parent.type !== "VariableDeclarator" || nodeAt(parent, "init") !== expression)
-    return void 0;
-  const id = nodeAt(parent, "id");
-  if (id?.type !== "ObjectPattern" || !isOnlyRaw(id)) return void 0;
-  return { kind: "raw", node: id, local };
-}
-function readableUse(reading, expression, local) {
-  const parent = reading.analysis.parentOf.get(expression);
-  if (!parent) return void 0;
-  if (isCallee(parent, expression)) return { kind: "call", node: parent, local };
-  if (parent.type === "MemberExpression" && nodeAt(parent, "object") === expression) {
-    return memberUse(reading, parent, local);
-  }
-  return rawDestructuring(parent, expression, local);
-}
-function useOfExpression(reading, start, local) {
-  const expression = throughUnref(reading, start);
-  const readable = readableUse(reading, expression, local);
-  if (readable) return readable;
-  const exposedAs = exposureName(reading, expression);
-  if (exposedAs !== void 0) return { kind: "exposure", node: expression, local, exposedAs };
-  const phrase = phraseFor(reading, expression, local);
-  const isReexport = isReexportOf(reading, expression);
-  const isRenamed = isReexport && isRenamedReexportOf(reading, expression);
-  const exportedAs2 = reexportedAs(reading, expression);
-  return {
-    ...refused(expression, local, phrase),
-    isReexport,
-    ...isRenamed && { isRenamed },
-    ...exportedAs2
-  };
-}
-function reexportedAs(reading, expression) {
-  const name = reexportNameOf(reading, expression);
-  return name === void 0 ? void 0 : { exportedAs: [name] };
-}
-function isOtherKey(property) {
-  if (property.type !== "Property") return false;
-  const name = propertyNameOf(nodeAt(property, "key"), property.computed === true);
-  return name !== void 0 && name !== "cx";
-}
-function isPatternAssignment(reading, node) {
-  if (node?.type === "AssignmentPattern") return true;
-  return node?.type === "AssignmentExpression" && node.operator === "=" && reading.analysis.parentOf.get(node)?.type === "ExpressionStatement";
-}
-function patternDestructuring(reading, expression) {
-  const parent = reading.analysis.parentOf.get(expression);
-  if (parent?.type === "VariableDeclarator" && nodeAt(parent, "init") === expression) {
-    return nodeAt(parent, "id");
-  }
-  return isPatternAssignment(reading, parent) && nodeAt(parent, "right") === expression ? nodeAt(parent, "left") : void 0;
-}
-function isOtherKeysDestructuring(reading, expression) {
-  const pattern = patternDestructuring(reading, expression);
-  return pattern?.type === "ObjectPattern" && nodesAt(pattern, "properties").every((p) => isOtherKey(p));
-}
-function memberReadOf(reading, expression) {
-  const member = reading.analysis.parentOf.get(expression);
-  if (member?.type !== "MemberExpression" || nodeAt(member, "object") !== expression) {
-    return void 0;
-  }
-  return { member, key: propertyNameOf(nodeAt(member, "property"), member.computed === true) };
-}
-function namespaceUse(reading, expression, cx) {
-  const local = cx.binding.name;
-  const read = memberReadOf(reading, expression);
-  if (read?.key === "cx") return useOfExpression(reading, read.member, `${local}.cx`);
-  const isListed2 = reading.declaredSources?.has(cx.binding.source ?? "") === true;
-  const isOtherExport = read ? read.key !== void 0 : isOtherKeysDestructuring(reading, expression);
-  if (isListed2 && isOtherExport) return void 0;
-  const use = refused(expression, local, `${local} is used other than as ${local}.cx`);
-  const exportedAs2 = reexportedAs(reading, expression);
-  return exportedAs2 ? { ...use, ...exportedAs2, isRenamed: true } : use;
-}
-function useOf(reading, reference2, cx) {
-  if (cx.isNamespace) return namespaceUse(reading, reference2.node, cx);
-  const local = cx.binding.name;
-  const use = useOfExpression(reading, reference2.node, local);
-  if (!use.isReexport) return use;
-  const isDeclaredSource = reading.declaredSources?.has(cx.binding.source ?? "") === true;
-  return { ...use, isListable: !isDeclaredSource };
-}
-
-// src/vite-cx-source-forms.ts
-var REEXPORT_TEXT = "a re-export of cx, which the build follows only from a module listed in cxModules.";
-var SECOND_HOP_TEXT = "a re-export of the cx of a module listed in cxModules, which the build follows one step only.";
-var DYNAMIC_IMPORT_TEXT = "a dynamic import of cx, which the build cannot follow. Import it at the top of the module.";
-function isExportingCx(node) {
-  if (node.type === "ExportAllDeclaration") return true;
-  return nodesAt(node, "specifiers").some((specifier) => {
-    const local = nodeAt(specifier, "local");
-    return (local?.type === "Identifier" ? stringAt(local, "name") : staticStringOf(local)) === "cx";
-  });
-}
-function isExportingRenamed(node) {
-  if (node.type === "ExportAllDeclaration") return nodeAt(node, "exported") !== void 0;
-  return nodesAt(node, "specifiers").some(
-    (specifier) => exportNameOf(nodeAt(specifier, "local")) === "cx" && exportNameOf(nodeAt(specifier, "exported")) !== "cx"
-  );
-}
-function exportedNamesOf(node) {
-  if (node.type === "ExportAllDeclaration") {
-    return [exportNameOf(nodeAt(node, "exported")) ?? "cx"];
-  }
-  return nodesAt(node, "specifiers").filter((specifier) => exportNameOf(nodeAt(specifier, "local")) === "cx").flatMap((specifier) => exportNameOf(nodeAt(specifier, "exported")) ?? []);
-}
-function reexportProblem(code, node, isListed2) {
-  if (isListed2 && !isExportingCx(node)) return void 0;
-  return {
-    kind: "reexport",
-    offset: node.start,
-    construct: code.slice(node.start, node.end),
-    text: isListed2 ? SECOND_HOP_TEXT : REEXPORT_TEXT,
-    isListable: !isListed2,
-    ...!isListed2 && isExportingRenamed(node) && { isRenamed: true },
-    exportedAs: exportedNamesOf(node)
-  };
-}
-function sourceFormProblem(code, node, options) {
-  const source = staticStringOf(nodeAt(node, "source"));
-  if (source === void 0 || !options.cxSources.has(source)) return void 0;
-  if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
-    if (options.isDeclared === true) return void 0;
-    return reexportProblem(code, node, options.declaredSources?.has(source) === true);
-  }
-  if (node.type !== "ImportExpression") return void 0;
-  const construct = code.slice(node.start, node.end);
-  return { kind: "reference", offset: node.start, construct, text: DYNAMIC_IMPORT_TEXT };
-}
-function sourceFormProblems(code, program, options) {
-  const problems = [];
-  const stack = [program];
-  while (stack.length > 0) {
-    const node = stack.pop();
-    const problem2 = sourceFormProblem(code, node, options);
-    if (problem2) problems.push(problem2);
-    stack.push(...childrenOf(node));
-  }
-  return problems;
-}
-
-// src/vite-declared-exports.ts
-var DECLARED_TEXT = "listed in cxModules, but this export can give it a cx the build does not follow: the build follows a listed module one step, to Nave's cx re-exported from @navecss/core/cx under the name cx.";
-function innerPatterns(pattern) {
-  switch (pattern.type) {
-    case "ArrayPattern": {
-      return nodesAt(pattern, "elements");
-    }
-    case "AssignmentPattern": {
-      return [nodeAt(pattern, "left")].filter((inner) => inner !== void 0);
-    }
-    case "ObjectPattern": {
-      return nodesAt(pattern, "properties").flatMap(
-        (property) => [nodeAt(property, property.type === "Property" ? "value" : "argument")].filter(
-          (inner) => inner !== void 0
-        )
-      );
-    }
-    case "RestElement": {
-      return [nodeAt(pattern, "argument")].filter((inner) => inner !== void 0);
-    }
-    default: {
-      return [];
-    }
-  }
-}
-function patternNames(pattern) {
-  const names = [];
-  const stack = pattern ? [pattern] : [];
-  while (stack.length > 0) {
-    const next = stack.pop();
-    if (next.type === "Identifier") names.push(stringAt(next, "name") ?? "");
-    stack.push(...innerPatterns(next));
-  }
-  return names;
-}
-function declaredNames(declaration) {
-  if (declaration.type !== "VariableDeclaration") {
-    return patternNames(nodeAt(declaration, "id"));
-  }
-  return nodesAt(declaration, "declarations").flatMap(
-    (declarator) => patternNames(nodeAt(declarator, "id"))
-  );
-}
-function problem(node) {
-  return { kind: "declared", offset: node.start, construct: "", text: DECLARED_TEXT };
-}
-function isPlainReExport(local, exported) {
-  return local === "cx" && exported === "cx";
-}
-function fromSourceProblems(node, source, input) {
-  const isNave = input.cxSources.has(source) && !input.declaredSources.has(source);
-  const isListed2 = input.declaredSources.has(source);
-  const isBad = nodesAt(node, "specifiers").some((specifier) => {
-    const local = exportNameOf(nodeAt(specifier, "local"));
-    const exported = exportNameOf(nodeAt(specifier, "exported"));
-    if (isNave) return !isPlainReExport(local, exported);
-    return exported === "cx" || isListed2 && local === "cx";
-  });
-  return isBad ? [problem(node)] : [];
-}
-function localProblems(node, input) {
-  const isBad = nodesAt(node, "specifiers").some((specifier) => {
-    const local = nodeAt(specifier, "local");
-    const binding = local && input.analysis.referenceOf(local)?.binding;
-    const cx = binding ? input.bindings.get(binding) : void 0;
-    if (exportNameOf(nodeAt(specifier, "exported")) !== "cx") return cx !== void 0;
-    const isNaves = cx !== void 0 && !cx.isNamespace && !input.declaredSources.has(binding?.source ?? "");
-    return !isNaves;
-  });
-  return isBad ? [problem(node)] : [];
-}
-function namedExportProblems(node, input) {
-  const declaration = nodeAt(node, "declaration");
-  if (declaration) return declaredNames(declaration).includes("cx") ? [problem(node)] : [];
-  const source = staticStringOf(nodeAt(node, "source"));
-  return source === void 0 ? localProblems(node, input) : fromSourceProblems(node, source, input);
-}
-function starExportProblems(node, input, hasNaveCx) {
-  const source = staticStringOf(nodeAt(node, "source"));
-  if (source === void 0) return [];
-  const exported = nodeAt(node, "exported");
-  if (!input.cxSources.has(source)) {
-    return exportNameOf(exported) === "cx" ? [problem(node)] : [];
-  }
-  if (exported !== void 0) return [problem(node)];
-  return !hasNaveCx && input.declaredSources.has(source) ? [problem(node)] : [];
-}
-function isNaveSource(source, input) {
-  return source !== void 0 && input.cxSources.has(source) && !input.declaredSources.has(source);
-}
-function isNaveLocalExport(local, exported, input) {
-  const binding = local && input.analysis.referenceOf(local)?.binding;
-  const cx = binding ? input.bindings.get(binding) : void 0;
-  const isListed2 = input.declaredSources.has(binding?.source ?? "");
-  return exported === "cx" && cx !== void 0 && !cx.isNamespace && !isListed2;
-}
-function isNaveSpecifier(specifier, source, input) {
-  const local = nodeAt(specifier, "local");
-  const exported = exportNameOf(nodeAt(specifier, "exported"));
-  if (source === void 0) return isNaveLocalExport(local, exported, input);
-  return isNaveSource(source, input) && isPlainReExport(exportNameOf(local), exported);
-}
-function isNaveCxExport(node, input) {
-  const source = staticStringOf(nodeAt(node, "source"));
-  if (node.type === "ExportAllDeclaration") {
-    return isNaveSource(source, input) && nodeAt(node, "exported") === void 0;
-  }
-  if (node.type !== "ExportNamedDeclaration" || nodeAt(node, "declaration")) return false;
-  return nodesAt(node, "specifiers").some((specifier) => isNaveSpecifier(specifier, source, input));
-}
-function unfollowedStarProblems(body, input) {
-  if (body.some((node) => isNaveCxExport(node, input))) return [];
-  const star = body.find((node) => {
-    const source = staticStringOf(nodeAt(node, "source"));
-    const isPlainStar = node.type === "ExportAllDeclaration" && nodeAt(node, "exported") === void 0;
-    return isPlainStar && source !== void 0 && !input.cxSources.has(source);
-  });
-  return star ? [problem(star)] : [];
-}
-function defaultExportProblems(node, input) {
-  const declaration = nodeAt(node, "declaration");
-  const binding = declaration && input.analysis.referenceOf(declaration)?.binding;
-  return binding && input.bindings.has(binding) ? [problem(node)] : [];
-}
-var EXPORT_PROBLEMS = {
-  ExportDefaultDeclaration: defaultExportProblems,
-  ExportNamedDeclaration: namedExportProblems
-};
-function declaredExportProblems(input) {
-  const body = nodesAt(input.program, "body");
-  const hasNaveCx = body.some((node) => isNaveCxExport(node, input));
-  const problems = [
-    ...body.flatMap(
-      (node) => node.type === "ExportAllDeclaration" ? starExportProblems(node, input, hasNaveCx) : EXPORT_PROBLEMS[node.type]?.(node, input) ?? []
-    ),
-    ...unfollowedStarProblems(body, input)
-  ];
-  return hasNaveCx ? problems.map((found) => ({ ...found, hasNaveCx })) : problems;
-}
-
-// src/vite-class-pieces.ts
-function isIdentChar(char) {
-  if (char === void 0) return false;
-  return /[\w-]/.test(char) || char.codePointAt(0) >= 128;
-}
-function pieceOfText(node, text) {
-  let start = text.length;
-  while (start > 0 && isIdentChar(text[start - 1])) start -= 1;
-  return { node, head: text.slice(start, start + 5), isOpen: start === 0 };
-}
-function leafPiece(node) {
-  const whole = staticStringOf(node);
-  if (whole !== void 0) return pieceOfText(node, whole);
-  if (node.type !== "TemplateLiteral") return void 0;
-  const cooked = nodesAt(node, "quasis").at(-1)?.value?.cooked;
-  return cooked === void 0 ? void 0 : pieceOfText(node, cooked);
-}
-function isPlus(node) {
-  return node?.type === "BinaryExpression" && node.operator === "+";
-}
-function edgePiece(start, memo) {
-  const path10 = [];
-  let node = start;
-  while (isPlus(node) && !memo.edges.has(node)) {
-    path10.push(node);
-    node = nodeAt(node, "right");
-  }
-  let found;
-  if (node !== void 0) found = memo.edges.has(node) ? memo.edges.get(node) : leafPiece(node);
-  for (const visited of path10) memo.edges.set(visited, found);
-  return found;
-}
-function joinPieces(before, last) {
-  if (!last.isOpen) return { node: before.node, head: last.head, isOpen: false };
-  return {
-    node: before.node,
-    head: (before.head + last.head).slice(0, 5),
-    isOpen: before.isOpen
-  };
-}
-function pieceOfPlus(link, before, last) {
-  if (last === void 0) return void 0;
-  const isAdjacent = before !== void 0 && nodeAt(link, "right") === last.node;
-  return isAdjacent ? joinPieces(before, last) : last;
-}
-function rightmostPiece(start, memo) {
-  const spine = [];
-  let node = start;
-  while (isPlus(node) && !memo.rightmost.has(node)) {
-    spine.push(node);
-    node = nodeAt(node, "left");
-  }
-  let before;
-  if (node !== void 0) {
-    before = memo.rightmost.has(node) ? memo.rightmost.get(node) : edgePiece(node, memo);
-  }
-  for (const link of spine.toReversed()) {
-    before = pieceOfPlus(link, before, edgePiece(link, memo));
-    memo.rightmost.set(link, before);
-  }
-  return before;
-}
-
-// src/vite-string-values.ts
-var none = () => [];
-var leaf2 = (values) => ({ deps: none, combine: () => values });
-function unionOf2(parts) {
-  if (parts.includes(void 0)) return void 0;
-  return [...new Set(parts.flat())];
-}
-function planOfFallback(node) {
-  const left = nodeAt(node, "left");
-  const right = nodeAt(node, "right");
-  const isOr = node.operator === "||";
-  return {
-    deps: (done) => {
-      if (done.length === 0) return [left];
-      const known = done[0];
-      return known && isOr && known.includes("") ? [left, right] : [left];
-    },
-    combine: (done) => {
-      const [known, other] = done;
-      if (!known || !isOr || !known.includes("")) return known;
-      return other && unionOf2([known.filter((value) => value !== ""), other]);
-    }
-  };
-}
-function planOfName2(node, analysis) {
-  const init = soleInitialiserBinding(analysis.referenceOf(node)?.binding)?.init;
-  if (!init) return leaf2(void 0);
-  return { deps: () => [init], combine: ([only]) => only };
-}
-function planOf2(node, analysis) {
-  const text = staticStringOf(node);
-  if (text !== void 0) return leaf2([text]);
-  switch (node.type) {
-    case "ConditionalExpression": {
-      const parts = [nodeAt(node, "consequent"), nodeAt(node, "alternate")];
-      return { deps: () => parts, combine: unionOf2 };
-    }
-    case "Identifier": {
-      return planOfName2(node, analysis);
-    }
-    case "LogicalExpression": {
-      return node.operator === "&&" ? leaf2(void 0) : planOfFallback(node);
-    }
-    case "ParenthesizedExpression": {
-      const inner = nodeAt(node, "expression");
-      return { deps: () => [inner], combine: ([only]) => only };
-    }
-    default: {
-      return leaf2(void 0);
-    }
-  }
-}
-function stringValues(root, analysis) {
-  if (!root) return void 0;
-  const memo = /* @__PURE__ */ new Map();
-  const active = /* @__PURE__ */ new Set([root]);
-  const stack = [{ node: root, plan: planOf2(root, analysis), done: [] }];
-  let result;
-  while (stack.length > 0) {
-    const top = stack.at(-1);
-    const deps = top.plan.deps(top.done);
-    if (top.done.length < deps.length) {
-      const child = deps[top.done.length];
-      if (!child) top.done.push(void 0);
-      else if (memo.has(child)) top.done.push(memo.get(child));
-      else if (active.has(child)) top.done.push(void 0);
-      else {
-        active.add(child);
-        stack.push({ node: child, plan: planOf2(child, analysis), done: [] });
-      }
-      continue;
-    }
-    result = top.plan.combine(top.done);
-    memo.set(top.node, result);
-    active.delete(top.node);
-    stack.pop();
-    stack.at(-1)?.done.push(result);
-  }
-  return result;
-}
-
-// src/vite-class-endings.ts
-function isEndingValue(value) {
-  return !(isIdentChar(value[0]) || value.startsWith("\\"));
-}
-function operandsOf(element) {
-  if (typeof element === "string") return void 0;
-  const inner = unwrap(element);
-  if (inner.type !== "BinaryExpression" || inner.operator !== "+") return void 0;
-  const left = nodeAt(inner, "left");
-  const right = nodeAt(inner, "right");
-  return left && right ? [left, right] : void 0;
-}
-function* sequenceOf(first2, rest) {
-  const pending = first2.toReversed();
-  for (; ; ) {
-    let element = pending.pop();
-    if (element === void 0) return;
-    const operands = operandsOf(element);
-    if (operands) pending.push(operands[1], operands[0]);
-    else yield element;
-  }
-}
-function verdictOf(elements, analysis) {
-  for (const element of elements) {
-    const values = typeof element === "string" ? [element] : stringValues(element, analysis);
-    if (!values?.every((value) => value === "" || isEndingValue(value))) return false;
-    if (!values.includes("")) return true;
-  }
-  return void 0;
-}
-function isEndingAfter(start, analysis, memo) {
-  const walked = [];
-  let link = start;
-  let verdict;
-  while (verdict === void 0) {
-    if (!link) {
-      verdict = true;
-    } else if (memo.has(link)) {
-      verdict = memo.get(link);
-    } else {
-      walked.push(link);
-      verdict = verdictOf(sequenceOf([link.node]), analysis);
-      link = link.next;
-    }
-  }
-  for (const walkedLink of walked) memo.set(walkedLink, verdict);
-  return verdict;
-}
-function isEndingTheClass(first2, rest, analysis, memo) {
-  return verdictOf(sequenceOf(first2), analysis) ?? isEndingAfter(rest, analysis, memo);
-}
-function unwrap(node) {
-  let current = node;
-  while (current.type === "ParenthesizedExpression")
-    current = nodeAt(current, "expression") ?? current;
-  return current;
-}
-
-// src/vite-literal-classes.ts
-var ATOM_OF_CLASS = new Map(
-  Object.entries(atomClassMap).map(([atom, className]) => [className, atom])
-);
-function atomOfClass(className) {
-  return ATOM_OF_CLASS.get(className);
-}
-function isBoundary(code, index) {
-  if (index === 0 || !isIdentChar(code[index - 1])) return true;
-  return code[index - 2] === "\\" && /[bfnrtv0]/.test(code[index - 1]);
-}
-function identifierAt(code, index) {
-  let end = index;
-  while (isIdentChar(code[end])) end += 1;
-  return code.slice(index, end);
-}
-function atomsWrittenIn(code) {
-  const found = /* @__PURE__ */ new Set();
-  let index = code.indexOf("nave-");
-  while (index !== -1) {
-    if (isBoundary(code, index)) {
-      const atom = ATOM_OF_CLASS.get(identifierAt(code, index));
-      if (atom) found.add(atom);
-    }
-    index = code.indexOf("nave-", index + 5);
-  }
-  return found;
-}
-function isEndingInNavePrefix(text) {
-  let start = text.length;
-  while (start > 0 && isIdentChar(text[start - 1])) start -= 1;
-  return text.slice(start).startsWith("nave-");
-}
-function isBreakingOut(node, analysis, ending) {
-  if (node.type !== "TemplateLiteral") return false;
-  const quasis = nodesAt(node, "quasis");
-  const substitutions = nodesAt(node, "expressions");
-  return quasis.slice(0, -1).some((quasi, index) => {
-    const cooked = quasi.value?.cooked;
-    if (cooked === void 0 || !isEndingInNavePrefix(cooked)) return false;
-    const following = substitutions.slice(index).flatMap((substitution, offset) => {
-      const next = quasis[index + 1 + offset];
-      const text = next?.value?.cooked;
-      return [substitution, ...next ? [text ?? next] : []];
-    });
-    return !isEndingTheClass(following, ending.after, analysis, ending.memo);
-  });
-}
-function concatenatedPiece(node, memo, analysis, ending) {
-  if (!isPlus(node)) return void 0;
-  const piece = rightmostPiece(nodeAt(node, "left"), memo);
-  if (piece?.head !== "nave-") return void 0;
-  const right = nodeAt(node, "right");
-  return isEndingTheClass(right ? [right] : [], ending.after, analysis, ending.memo) ? void 0 : piece;
-}
-function escapedText(node) {
-  if (node.type === "Literal" && typeof node.value === "string") {
-    return { raw: String(node.raw), decoded: node.value };
-  }
-  if (node.type !== "TemplateElement") return void 0;
-  const { raw, cooked } = node.value;
-  if (!cooked || !raw?.includes("\\")) return void 0;
-  return { raw, decoded: cooked };
-}
-function atomsInEscapedStrings(program) {
-  const found = /* @__PURE__ */ new Set();
-  const stack = [program];
-  while (stack.length > 0) {
-    const node = stack.pop();
-    const text = escapedText(node);
-    if (text?.raw.includes("\\")) {
-      for (const atom of atomsWrittenIn(text.decoded)) found.add(atom);
-    }
-    stack.push(...childrenOf(node));
-  }
-  return found;
-}
-var SENTENCE = "a Nave class built from pieces is invisible to the build, so its atom would not ship.";
-function concatenationProblems(program, code, analysis) {
-  const problems = [];
-  const memo = { edges: /* @__PURE__ */ new Map(), rightmost: /* @__PURE__ */ new Map() };
-  const ends = /* @__PURE__ */ new Map();
-  const stack = [{ node: program, after: void 0 }];
-  while (stack.length > 0) {
-    const { node, after } = stack.pop();
-    const offset = concatenatedPiece(node, memo, analysis, { after, memo: ends })?.node.start ?? (isBreakingOut(node, analysis, { after, memo: ends }) ? node.start : -1);
-    if (offset !== -1) {
-      problems.push({
-        kind: "concatenation",
-        offset,
-        construct: code.slice(node.start, node.end),
-        text: SENTENCE
-      });
-    }
-    stack.push(...childrenWithAfter(node, after));
-  }
-  return problems.toSorted((a, b) => a.offset - b.offset);
-}
-function childrenWithAfter(node, after) {
-  const isOperands = node.type === "BinaryExpression" && node.operator === "+";
-  if (isOperands) {
-    const left = nodeAt(node, "left");
-    const right = nodeAt(node, "right");
-    return [
-      ...left ? [{ node: left, after: right ? { node: right, next: after } : after }] : [],
-      ...right ? [{ node: right, after }] : []
-    ];
-  }
-  const isWrapper = node.type === "ParenthesizedExpression";
-  return childrenOf(node).map((child) => ({ node: child, after: isWrapper ? after : void 0 }));
-}
-
-// src/vite-scope-types.ts
-function newScope(parent, isFunction) {
-  return { parent, isFunction, bindings: /* @__PURE__ */ new Map() };
-}
-function functionScopeOf(scope) {
-  let current = scope;
-  while (!current.isFunction && current.parent) current = current.parent;
-  return current;
-}
-function declare(scope, binding, isAssigning = true) {
-  const existing = scope.bindings.get(binding.name);
-  if (existing) {
-    if (isAssigning) existing.writes += 1;
-    return existing;
-  }
-  scope.bindings.set(binding.name, binding);
-  return binding;
-}
-function reference(walker, node, scope, isWrite = false) {
-  walker.references.push({ node, scope, isWrite, binding: void 0 });
-}
-
-// src/vite-scope-pattern.ts
-function partsOf(pattern) {
-  return nodesAt(pattern, pattern.type === "ArrayPattern" ? "elements" : "properties");
-}
-function targetOf(part) {
-  return part.type === "Property" ? nodeAt(part, "value") : part;
-}
-function functionScopeOrHere(spec, scope) {
-  return spec.kind === "var" ? functionScopeOf(scope) : scope;
-}
-function declarePattern(pattern, spec, scope, walker) {
-  if (!pattern) return;
-  const name = stringAt(pattern, "name");
-  if (name !== void 0 && pattern.type === "Identifier") {
-    const into = functionScopeOrHere(spec, scope);
-    const isAssigning = spec.kind !== "var" || spec.init !== void 0 || spec.isAssigned === true;
-    const binding = { name, kind: spec.kind, writes: 0 };
-    if (spec.owner) binding.owner = spec.owner;
-    const declared = declare(into, binding, isAssigning);
-    if (spec.init) declared.init = spec.init;
-    return;
-  }
-  DECLARE[pattern.type]?.(pattern, spec, scope, walker);
-}
-var DECLARE = {
-  AssignmentPattern: (pattern, spec, scope, walker) => {
-    declarePattern(nodeAt(pattern, "left"), spec, scope, walker);
-    const right = nodeAt(pattern, "right");
-    if (right) walker.parentOf.set(right, pattern);
-    walker.visit(right, scope);
-  },
-  RestElement: (pattern, spec, scope, walker) => {
-    declarePattern(nodeAt(pattern, "argument"), spec, scope, walker);
-  },
-  ArrayPattern: (pattern, spec, scope, walker) => {
-    for (const part of partsOf(pattern)) declarePattern(part, spec, scope, walker);
-  },
-  ObjectPattern: (pattern, spec, scope, walker) => {
-    for (const part of partsOf(pattern)) {
-      if (part.computed === true) walker.visit(nodeAt(part, "key"), scope);
-      declarePattern(targetOf(part), spec, scope, walker);
-    }
-  }
-};
-function writeTargets(target, scope, walker) {
-  if (!target) return;
-  if (target.type === "Identifier") {
-    reference(walker, target, scope, true);
-    return;
-  }
-  const write = WRITE[target.type];
-  if (write) write(target, void 0, scope, walker);
-  else walker.visit(target, scope);
-}
-var WRITE = {
-  ArrayPattern: (target, _result, scope, walker) => {
-    for (const part of partsOf(target)) writeTargets(part, scope, walker);
-  },
-  ObjectPattern: (target, _result, scope, walker) => {
-    for (const part of partsOf(target)) {
-      if (part.computed === true) walker.visit(nodeAt(part, "key"), scope);
-      writeTargets(targetOf(part), scope, walker);
-    }
-  },
-  AssignmentPattern: (target, _result, scope, walker) => {
-    writeTargets(nodeAt(target, "left"), scope, walker);
-    walker.visit(nodeAt(target, "right"), scope);
-  },
-  RestElement: (target, _result, scope, walker) => {
-    writeTargets(nodeAt(target, "argument"), scope, walker);
-  }
-};
-
-// src/vite-scope-walk.ts
-function visit(node, scope, walker) {
-  if (!node) return;
-  const handler = HANDLERS[node.type];
-  if (handler) handler(node, scope, walker);
-  else visitChildren(node, scope, walker);
-}
-function visitChildren(node, scope, walker) {
-  for (const child of childrenOf(node)) {
-    walker.parentOf.set(child, node);
-    visit(child, scope, walker);
-  }
-}
-function visitKeys(node, keys, scope, walker) {
-  const children = keys.flatMap((key) => {
-    const value = node[key];
-    return (Array.isArray(value) ? value : [value]).filter((child) => isNode(child));
-  });
-  for (const child of children) {
-    walker.parentOf.set(child, node);
-    visit(child, scope, walker);
-  }
-}
-function expressionKeys(node, others) {
-  return node.computed === true ? ["key", ...others] : [...others];
-}
-function visitLoop(node, scope, walker) {
-  const inner = newScope(scope, false);
-  const left = nodeAt(node, "left");
-  if (left?.type === "VariableDeclaration") {
-    const kind = left.kind === "var" ? "var" : "loop";
-    for (const declarator of nodesAt(left, "declarations")) {
-      declarePattern(nodeAt(declarator, "id"), { kind, isAssigned: true }, inner, walker);
-    }
-  } else {
-    writeTargets(left, inner, walker);
-  }
-  visitKeys(node, ["right"], scope, walker);
-  visitKeys(node, ["body"], inner, walker);
-}
-function visitFunction(node, scope, walker) {
-  let outer = scope;
-  const id = nodeAt(node, "id");
-  if (id && node.type === "FunctionExpression") {
-    outer = newScope(scope, false);
-    declare(outer, { name: stringAt(id, "name") ?? "", kind: "function", writes: 0 });
-  }
-  const parameters = newScope(outer, true);
-  for (const param of nodesAt(node, "params")) {
-    declarePattern(param, { kind: "param", owner: node }, parameters, walker);
-  }
-  const body = nodeAt(node, "body");
-  if (body?.type === "BlockStatement") {
-    walker.parentOf.set(body, node);
-    visitChildren(body, newScope(parameters, true), walker);
-  } else {
-    visitKeys(node, ["body"], parameters, walker);
-  }
-}
-function visitClass(node, scope, walker) {
-  const inner = newScope(scope, false);
-  const name = stringAt(nodeAt(node, "id") ?? node, "name");
-  if (name !== void 0) declare(inner, { name, kind: "class", writes: 0 });
-  visitKeys(node, ["superClass", "body"], inner, walker);
-}
-function importedName(specifier) {
-  if (specifier.type === "ImportNamespaceSpecifier") return "*";
-  if (specifier.type !== "ImportSpecifier") return "default";
-  const imported = nodeAt(specifier, "imported");
-  return stringAt(imported ?? specifier, "name") ?? String(imported?.value);
-}
-function declareImport(node, scope) {
-  const source = String(nodeAt(node, "source")?.value);
-  for (const specifier of nodesAt(node, "specifiers")) {
-    const local = stringAt(nodeAt(specifier, "local") ?? specifier, "name");
-    if (local === void 0) continue;
-    const imported = importedName(specifier);
-    scope.bindings.set(local, { name: local, kind: "import", writes: 0, source, imported });
-  }
-}
-function visitDeclaration(node, scope, walker) {
-  const kind = node.kind;
-  for (const declarator of nodesAt(node, "declarations")) {
-    walker.parentOf.set(declarator, node);
-    const id = nodeAt(declarator, "id");
-    const init = nodeAt(declarator, "init");
-    const hasPlainInit = id?.type === "Identifier" && init !== void 0;
-    const spec = hasPlainInit ? { kind, init } : { kind, isAssigned: init !== void 0 };
-    declarePattern(id, spec, scope, walker);
-    if (id) walker.parentOf.set(id, declarator);
-    visit(init, scope, walker);
-    if (init) walker.parentOf.set(init, declarator);
-  }
-}
-function visitExport(node, scope, walker) {
-  if (node.source) return;
-  visitKeys(node, ["declaration"], scope, walker);
-  for (const specifier of nodesAt(node, "specifiers")) {
-    const local = nodeAt(specifier, "local");
-    if (!local) continue;
-    walker.parentOf.set(specifier, node);
-    walker.parentOf.set(local, specifier);
-    reference(walker, local, scope);
-  }
-}
-function leaf3() {
-}
-function isDirectEval(node) {
-  let callee = nodeAt(node, "callee");
-  while (callee?.type === "ParenthesizedExpression") callee = nodeAt(callee, "expression");
-  return callee?.type === "Identifier" && stringAt(callee, "name") === "eval";
-}
-function visitChain(node, scope, walker) {
-  const spine = [];
-  let current = node;
-  while (current?.type === "BinaryExpression" || current?.type === "LogicalExpression") {
-    spine.push(current);
-    current = nodeAt(current, "left");
-  }
-  const links = [...spine, ...current ? [current] : []];
-  for (let index = 1; index < links.length; index += 1) {
-    walker.parentOf.set(links[index], links[index - 1]);
-  }
-  visit(current, scope, walker);
-  for (const link of spine.toReversed()) visitKeys(link, ["right"], scope, walker);
-}
-var MEMBER_LIKE = (node, scope, walker) => {
-  visitKeys(node, expressionKeys(node, ["value"]), scope, walker);
-};
-var HANDLERS = {
-  Identifier: (node, scope, walker) => {
-    reference(walker, node, scope);
-  },
-  MemberExpression: (node, scope, walker) => {
-    visitKeys(node, node.computed === true ? ["object", "property"] : ["object"], scope, walker);
-  },
-  Property: MEMBER_LIKE,
-  MethodDefinition: MEMBER_LIKE,
-  PropertyDefinition: MEMBER_LIKE,
-  LabeledStatement: (node, scope, walker) => {
-    visitKeys(node, ["body"], scope, walker);
-  },
-  BreakStatement: leaf3,
-  ContinueStatement: leaf3,
-  MetaProperty: leaf3,
-  ExportAllDeclaration: leaf3,
-  CallExpression: (node, scope, walker) => {
-    if (isDirectEval(node)) walker.evalScopes.push(scope);
-    visitChildren(node, scope, walker);
-  },
-  BinaryExpression: visitChain,
-  LogicalExpression: visitChain,
-  AssignmentExpression: (node, scope, walker) => {
-    writeTargets(nodeAt(node, "left"), scope, walker);
-    visitKeys(node, ["right"], scope, walker);
-  },
-  UpdateExpression: (node, scope, walker) => {
-    writeTargets(nodeAt(node, "argument"), scope, walker);
-  },
-  ImportDeclaration: (node, scope) => {
-    declareImport(node, scope);
-  },
-  ExportNamedDeclaration: visitExport,
-  VariableDeclaration: visitDeclaration,
-  FunctionDeclaration: (node, scope, walker) => {
-    const name = stringAt(nodeAt(node, "id") ?? node, "name");
-    if (name !== void 0) declare(scope, { name, kind: "function", writes: 0 });
-    visitFunction(node, scope, walker);
-  },
-  FunctionExpression: visitFunction,
-  ArrowFunctionExpression: visitFunction,
-  ClassDeclaration: (node, scope, walker) => {
-    const name = stringAt(nodeAt(node, "id") ?? node, "name");
-    if (name !== void 0) declare(scope, { name, kind: "class", writes: 0 });
-    visitClass(node, scope, walker);
-  },
-  ClassExpression: visitClass,
-  StaticBlock: (node, scope, walker) => {
-    visitChildren(node, newScope(scope, true), walker);
-  },
-  BlockStatement: (node, scope, walker) => {
-    visitChildren(node, newScope(scope, false), walker);
-  },
-  SwitchStatement: (node, scope, walker) => {
-    visitKeys(node, ["discriminant"], scope, walker);
-    visitKeys(node, ["cases"], newScope(scope, false), walker);
-  },
-  CatchClause: (node, scope, walker) => {
-    const inner = newScope(scope, false);
-    declarePattern(nodeAt(node, "param"), { kind: "catch" }, inner, walker);
-    visitKeys(node, ["body"], inner, walker);
-  },
-  ForStatement: (node, scope, walker) => {
-    visitChildren(node, newScope(scope, false), walker);
-  },
-  ForInStatement: visitLoop,
-  ForOfStatement: visitLoop
-};
-
-// src/vite-scope.ts
-function lookup(scope, name) {
-  for (let current = scope; current; current = current.parent) {
-    const found = current.bindings.get(name);
-    if (found) return found;
-  }
-  return void 0;
-}
-function resolve(reference2) {
-  const name = stringAt(reference2.node, "name");
-  reference2.binding = name === void 0 ? void 0 : lookup(reference2.scope, name);
-  if (reference2.binding && reference2.isWrite) reference2.binding.writes += 1;
-}
-var ASSIGNABLE = /* @__PURE__ */ new Set([
-  "catch",
-  "class",
-  "function",
-  "let",
-  "loop",
-  "param",
-  "var"
-]);
-function assignable(scope) {
-  return scope.bindings.values().filter((binding) => ASSIGNABLE.has(binding.kind)).toArray();
-}
-function markEvalWrites(scopes) {
-  const marked = /* @__PURE__ */ new Set();
-  for (const start of scopes) {
-    for (let scope = start; scope && !marked.has(scope); scope = scope.parent) {
-      marked.add(scope);
-      for (const binding of assignable(scope)) binding.writes += 1;
-    }
-  }
-}
-function analyze(program) {
-  const walker = {
-    references: [],
-    parentOf: /* @__PURE__ */ new Map(),
-    evalScopes: [],
-    visit: (node, scope) => {
-      visit(node, scope, walker);
-    }
-  };
-  const module = newScope(void 0, true);
-  for (const statement of nodesAt(program, "body")) {
-    walker.parentOf.set(statement, program);
-    visit(statement, module, walker);
-  }
-  const byNode = /* @__PURE__ */ new Map();
-  for (const reference2 of walker.references) {
-    resolve(reference2);
-    byNode.set(reference2.node, reference2);
-  }
-  markEvalWrites(walker.evalScopes.filter((scope) => !lookup(scope, "eval")));
-  return {
-    references: walker.references,
-    parentOf: walker.parentOf,
-    referenceOf: (node) => byNode.get(node)
-  };
-}
-
-// src/vite-vue-setup.ts
-function returnedObject(analysis) {
-  for (const [node] of analysis.parentOf) {
-    if (!isSetupReturn(node, analysis.parentOf)) continue;
-    const init = nodeAt(node, "init");
-    if (init?.type === "ObjectExpression") return init;
-  }
-  return void 0;
-}
-function stringExposures(analysis) {
-  const exposures = /* @__PURE__ */ new Map();
-  const object = returnedObject(analysis);
-  const properties = object ? nodesAt(object, "properties") : [];
-  for (const property of properties) {
-    const value = nodeAt(property, "value");
-    const name = propertyNameOf(nodeAt(property, "key"), property.computed === true);
-    if (name === void 0 || value?.type !== "Identifier" || property.kind === "get") continue;
-    const possibles2 = resolveArgument(value, analysis);
-    if (possibles2) exposures.set(name, { kind: "values", values: possibles2.map((p) => p.value) });
-  }
-  return exposures;
-}
-function cxReadsOnSetup(analysis, exposures) {
-  const reads = [];
-  for (const reference2 of analysis.references) {
-    if (!isSetupParameter(analysis, reference2.node)) continue;
-    const member = analysis.parentOf.get(reference2.node);
-    const name = member && setupMemberName(member);
-    if (member && name !== void 0 && exposures.get(name)?.kind === "cx") reads.push(member);
-  }
-  return reads;
-}
-
-// src/vite-collect.ts
-var CX_SOURCE = "@navecss/core/cx";
-function report(reading, problem2) {
-  const key = `${problem2.kind}:${problem2.offset}`;
-  if (reading.seen.has(key)) return;
-  reading.seen.add(key);
-  reading.result.problems.push(problem2);
-}
-var COMPILER_PREFIX = /\$setup\.|\$\$props\./g;
-function quoteCall(reading, use, args, callee = use.local) {
-  const first2 = args[0];
-  const last = args.at(-1);
-  const inner = first2 && last ? reading.code.slice(first2.start, last.end) : "";
-  return `${callee}(${inner.replaceAll(COMPILER_PREFIX, "")})`;
-}
-function judgeString(reading, use, value, node) {
-  const verdict = judgeAtom(value, reading.options.ownAtoms);
-  switch (verdict.kind) {
-    case "atom": {
-      reading.result.atoms.add(value);
-      break;
-    }
-    case "own": {
-      report(reading, {
-        kind: "own",
-        offset: node.start,
-        construct: `${use.local}()`,
-        text: `"${value}" is an atom of your own, which has no class. Use @nave ${value} in a CSS rule instead.`
-      });
-      break;
-    }
-    case "whitespace": {
-      report(reading, {
-        kind: "argument",
-        offset: node.start,
-        construct: `${use.local}()`,
-        text: verdict.text
-      });
-      break;
-    }
-    default: {
-      report(reading, {
-        kind: "unknown",
-        offset: node.start,
-        construct: `${use.local}()`,
-        text: verdict.text,
-        needsAvailable: !verdict.hasHint
-      });
-    }
-  }
-}
-function readCall(reading, use, analysis) {
-  const args = nodesAt(use.node, "arguments");
-  for (const arg of args) {
-    if (arg.type === "SpreadElement") {
-      report(reading, {
-        kind: "argument",
-        offset: arg.start,
-        construct: quoteCall(reading, use, args),
-        text: "a spread argument."
-      });
-      continue;
-    }
-    const possibles2 = resolveArgument(arg, analysis, reading.options.setup);
-    if (!possibles2) {
-      report(reading, {
-        kind: "argument",
-        offset: arg.start,
-        construct: quoteCall(reading, use, args),
-        text: "the argument is not a literal atom name."
-      });
-      continue;
-    }
-    for (const { value, node } of possibles2) judgeString(reading, use, value, node);
-  }
-}
-function refusedProblem(reading, use) {
-  if (use.isReexport && reading.options.isDeclared === true) return void 0;
-  return {
-    kind: use.isReexport ? "reexport" : "reference",
-    offset: use.node.start,
-    construct: "",
-    text: `${use.phrase ?? ""}.`,
-    ...use.isReexport && { isListable: use.isListable },
-    ...use.isRenamed === true && { isRenamed: true },
-    ...use.exportedAs && { exportedAs: use.exportedAs }
-  };
-}
-function readUse(reading, use, analysis) {
-  switch (use.kind) {
-    case "call": {
-      readCall(reading, use, analysis);
-      break;
-    }
-    case "dynamic": {
-      const args = nodesAt(use.node, "arguments");
-      const construct = quoteCall(reading, use, args, `${use.local}.dynamic`);
-      reading.result.dynamicCalls.push({ offset: use.node.start, construct });
-      break;
-    }
-    case "exposure": {
-      reading.result.exposes.set(use.exposedAs ?? use.local, { kind: "cx" });
-      break;
-    }
-    case "refused": {
-      const problem2 = refusedProblem(reading, use);
-      if (problem2) report(reading, problem2);
-      break;
-    }
-  }
-}
-function readUses(reading, program) {
-  const { code, options, result } = reading;
-  const analysis = analyze(program);
-  const bindings = cxBindingsOf(analysis, options.cxSources);
-  const frame2 = {
-    analysis,
-    code,
-    allowsExposure: options.isVueScript === true,
-    declaredSources: options.declaredSources
-  };
-  for (const reference2 of analysis.references) {
-    const cx = reference2.binding && bindings.get(reference2.binding);
-    const use = cx && useOf(frame2, reference2, cx);
-    if (use) readUse(reading, use, analysis);
-  }
-  for (const [name, exposure] of stringExposures(analysis)) result.exposes.set(name, exposure);
-  const setup = mergedExposures(options.setup, result.exposes);
-  const members = setup ? cxReadsOnSetup(analysis, setup) : [];
-  const withSetup = { ...reading, options: { ...options, setup } };
-  for (const member of members) {
-    readUse(withSetup, useOfExpression(frame2, member, setupMemberName(member) ?? "cx"), analysis);
-  }
-  return { analysis, bindings };
-}
-function readModule(code, program, options) {
-  const result = {
-    atoms: /* @__PURE__ */ new Set(),
-    classes: /* @__PURE__ */ new Set(),
-    problems: [],
-    dynamicCalls: [],
-    exposes: /* @__PURE__ */ new Map(),
-    usesCx: isImportingCx(program, options.cxSources)
-  };
-  const reading = { code, options, result, seen: /* @__PURE__ */ new Set() };
-  const { analysis, bindings } = readUses(reading, program);
-  const listed = options.isDeclared === true ? declaredExportProblems({
-    program,
-    analysis,
-    bindings,
-    cxSources: options.cxSources,
-    declaredSources: options.declaredSources ?? /* @__PURE__ */ new Set()
-  }) : [];
-  for (const problem2 of [...sourceFormProblems(code, program, options), ...listed]) {
-    report(reading, problem2);
-  }
-  for (const atom of atomsWrittenIn(code)) result.classes.add(atom);
-  for (const atom of atomsInEscapedStrings(program)) result.classes.add(atom);
-  if (result.usesCx || !options.isDependency) {
-    for (const problem2 of concatenationProblems(program, code, analysis)) report(reading, problem2);
-  }
-  return result;
-}
-
 // src/vite-css-id.ts
 var STYLESHEET = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
 var SPECIAL_QUERY = /[?&](?:worker|sharedworker|raw|url)\b/;
@@ -1716,8 +181,8 @@ function textTestOf(names) {
 
 // src/vite-cx-modules.ts
 function isRelative(text) {
-  const cut2 = text.search(/[#?]/);
-  const path10 = cut2 === -1 ? text : text.slice(0, cut2);
+  const cut = text.search(/[#?]/);
+  const path10 = cut === -1 ? text : text.slice(0, cut);
   return path10 === "." || path10 === ".." || path10.startsWith("./") || path10.startsWith("../");
 }
 function fileOf(id) {
@@ -1783,8 +248,8 @@ function withoutTrailingSlashes(text) {
   return text.slice(0, end);
 }
 function lastSegmentOf(specifier) {
-  const cut2 = specifier.slice(1).search(/[#?]/);
-  const bare = withoutTrailingSlashes(cut2 === -1 ? specifier : specifier.slice(0, cut2 + 1));
+  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;
 }
@@ -1850,32 +315,6 @@ function moduleLabel(root, id) {
   return path2.relative(root, file).replaceAll("\\", "/");
 }
 
-// src/vite-problems.ts
-var PROBLEM_KINDS = [
-  "argument",
-  "reference",
-  "reexport",
-  "declared",
-  "concatenation",
-  "dynamic",
-  "unknown",
-  "own",
-  "unreadable"
-];
-function compareText(a, b) {
-  if (a === b) return 0;
-  return a < b ? -1 : 1;
-}
-function cxModulesArray(configured, added) {
-  const extra = [...new Set(added)].filter((entry) => !configured.includes(entry)).toSorted(compareText);
-  if (extra.length === 0) return void 0;
-  return `[${[...configured, ...extra].map((entry) => `'${entry}'`).join(", ")}]`;
-}
-function cut(text, limit = 40) {
-  const oneLine = text.replaceAll(/\s+/g, " ");
-  return oneLine.length > limit ? `${oneLine.slice(0, limit)}...` : oneLine;
-}
-
 // src/vite-cx-importers.ts
 function importerIdsOf(ctx, cxId) {
   const info = ctx.getModuleInfo?.(cxId);
@@ -1901,7 +340,7 @@ function specifiersIn(program) {
     if (where !== void 0 && source !== void 0) {
       found.set(source, Math.min(found.get(source) ?? Infinity, where.start));
     }
-    stack.push(...childrenOf(node));
+    pushAll(stack, childrenOf(node));
   }
   return [...found].toSorted(([, a], [, b]) => a - b).map(([source]) => source);
 }
@@ -1988,26 +427,91 @@ async function declaredReadingOf(context, resolver, declared, input) {
     );
   }
   return {
-    declaredSources,
-    isDeclared: isListedFile(declared, module.id),
-    onlyVia: isOnlyListed && files.size > 0 ? files : void 0
+    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
   };
 }
-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 };
+function noteReloadSent(state, id) {
+  state.reloading.set(id, Date.now());
+  if (state.listening === 0) state.unheard.add(id);
 }
 
 // src/vite-state.ts
@@ -2041,10 +545,7 @@ function freshState() {
     builtEnvironments: /* @__PURE__ */ new Set(),
     warned: /* @__PURE__ */ new Set(),
     served: /* @__PURE__ */ new Map(),
-    stale: /* @__PURE__ */ new Set(),
-    reloading: /* @__PURE__ */ new Map(),
-    reloadTimer: void 0,
-    readAhead: 0,
+    ...freshReloads(),
     htmlRead: false,
     serverTransformed: false,
     directiveExpanded: false,
@@ -2116,61 +617,6 @@ async function setupExposuresFor(context, ctx, input) {
   return context.state.exposures.get(moduleKey(environment, owner));
 }
 
-// src/vite-source-map.ts
-function toSourceMap(map) {
-  return {
-    version: 3,
-    sources: map.sources,
-    names: map.names ?? [],
-    mappings: map.mappings,
-    ...map.sourceRoot !== void 0 && { sourceRoot: map.sourceRoot },
-    ...map.sourcesContent !== void 0 && { sourcesContent: map.sourcesContent }
-  };
-}
-function combinedMapOf(ctx) {
-  const map = ctx.getCombinedSourcemap();
-  return map.mappings === "" ? void 0 : decodeIncomingMap(toSourceMap(map));
-}
-var LINE_TERMINATOR = /\r\n|[\n\r\u{2028}\u{2029}]/gu;
-function lineStartsOf(code) {
-  const starts = [0];
-  for (const match of code.matchAll(LINE_TERMINATOR)) starts.push(match.index + match[0].length);
-  return starts;
-}
-function lineIndexOf(starts, offset) {
-  let low = 0;
-  let high = starts.length - 1;
-  while (low < high) {
-    const middle = Math.ceil((low + high) / 2);
-    if (starts[middle] <= offset) low = middle;
-    else high = middle - 1;
-  }
-  return low;
-}
-function positionIn(code) {
-  let starts;
-  return (offset) => {
-    starts ??= lineStartsOf(code);
-    const index = lineIndexOf(starts, offset);
-    return { line: index + 1, column: offset - starts[index] + 1 };
-  };
-}
-function normalized(text) {
-  return text.replace(/^\u{FEFF}/u, "").replaceAll("\r\n", "\n");
-}
-function placerFor(code, map, authored) {
-  const position = positionIn(code);
-  const isAuthored = (index) => {
-    const source = map?.sourcesContent?.[index];
-    return authored === void 0 || typeof source !== "string" ? true : normalized(source) === normalized(authored);
-  };
-  return (offset) => {
-    const generated = position(offset);
-    const origin = map?.originalPositionFor({ line: generated.line, column: generated.column - 1 });
-    return origin && isAuthored(origin.sourceIndex) ? { line: origin.line, column: origin.column + 1 } : void 0;
-  };
-}
-
 // src/vite-unread-record.ts
 function isListed(context, pkg) {
   return pkg !== void 0 && Object.hasOwn(context.options.keepFor, pkg);
@@ -2180,7 +626,7 @@ var TOO_DEEP = "the module could not be read, so the atoms it names would not sh
 function unreadableRecord(context, input, text) {
   const { code, id, pkg } = input;
   const file = moduleLabel(context.root, id);
-  const problem2 = {
+  const problem = {
     kind: "unreadable",
     offset: 0,
     construct: "",
@@ -2194,8 +640,8 @@ function unreadableRecord(context, input, text) {
   return {
     // The classes written whole need no parse to be found.
     atoms: atomsWrittenIn(code),
-    problems: isStandingIn ? [] : [problem2],
-    suppressed: isStandingIn ? [problem2] : [],
+    problems: isStandingIn ? [] : [problem],
+    suppressed: isStandingIn ? [problem] : [],
     dynamicCalls: [],
     pkg,
     file
@@ -2240,348 +686,6 @@ function textRecord(context, input) {
   };
 }
 
-// src/vite-used-take-lines.ts
-var IDENTIFIER = /^[$\p{ID_Start}_][$\p{ID_Continue}]*$/u;
-function takenName(name) {
-  if (name === "default") return "the default export";
-  if (IDENTIFIER.test(name)) return name;
-  return `'${name.replaceAll("\\", String.raw`\\`).replaceAll("'", String.raw`\'`)}'`;
-}
-function takeWhat(take) {
-  const names = take.names.map((name) => takenName(name)).join(", ");
-  switch (take.shape) {
-    case "dynamic-import": {
-      return names === "" ? "import()" : `import() reading ${names}`;
-    }
-    case "names": {
-      return names;
-    }
-    case "namespace": {
-      return names === "" ? "a namespace import" : `a namespace import reading ${names}`;
-    }
-    case "star": {
-      return "export *";
-    }
-    case "unreadable": {
-      return "a require() or other import the build cannot read";
-    }
-  }
-}
-var FIX = " The lasting fix is upstream: import cx from @navecss/core/cx where it is called, and re-export it from there, only under the name cx, in each module that gives it out.";
-function clausesOf(takes) {
-  const entries = takes.map((take) => ({
-    taker: take.taker,
-    text: `${take.taker} (${takeWhat(take)})`,
-    shape: take.shape
-  })).toSorted((a, b) => compareText(a.taker, b.taker) || compareText(a.text, b.text));
-  const listed = [...new Set(entries.map((entry) => entry.text))].join(", ");
-  const files = new Set(entries.map((entry) => entry.taker)).size === 1 ? "in that file" : "in each of those files";
-  const isWhole = entries.some((entry) => entry.shape !== "names");
-  const wholeClause = isWhole ? "; where a file takes a module whole (a namespace import, export *, import() or an import the build cannot read), import by name what it uses from that module, and cx from @navecss/core/cx" : "";
-  const passedOn = takes.some((take) => take.isPassedOn === true) ? "; where a file re-exports what it takes, import cx from @navecss/core/cx in the files that call it, call cx there in its place, and drop the re-export" : "";
-  return { files, listed, whole: `${wholeClause}${passedOn}` };
-}
-function takenLine(pkg, takes, hasPackageFix) {
-  const { files, listed, whole } = clausesOf(takes);
-  const fix = hasPackageFix ? FIX : "";
-  return `${pkg} re-exports cx, and your code takes that cx, from the package or through another package that re-exports it, in ${listed}. The build does not read calls made through what your code takes there, and the keepFor entry stands in only for the package's own calls: ${files}, import cx from @navecss/core/cx instead and call cx in its place${whole}. The build prints no cxModules entry for this, since it found none of these takes made, by an import it can read and a specifier that resolves from Vite's root, from a module that re-exports cx from @navecss/core/cx itself and only under the name cx. Once your code makes none of these takes, the keepFor entry clears this.${fix}`;
-}
-function forwardLine(pkg, takes) {
-  const { files, listed, whole } = clausesOf(takes);
-  return `${pkg} re-exports the cx of a module listed in cxModules, and your code takes that cx, from ${pkg} or through another package that re-exports it, in ${listed}. The build follows a listed module one step, so it does not read calls made through what your code takes there: ${files}, import cx from @navecss/core/cx instead and call cx in its place${whole}.${FIX}`;
-}
-function callsThroughLine(pkg, callers) {
-  const [make, owner, its] = callers.length === 1 ? ["makes", "a dependency's", "its"] : ["make", "dependencies'", "their"];
-  return `${pkg} re-exports the cx of a module listed in cxModules, and the build follows a listed module one step, so it does not read the calls that ${callers.join(", ")} ${make} through that re-export. That code is ${owner}, not yours to change: list the atoms those calls can produce, from ${its} documentation, under the name of ${pkg}, which holds the re-export, in navePlugin(): keepFor: { '${pkg}': ['<atom>'] }. The lasting fix is upstream: ${pkg} can re-export cx from @navecss/core/cx itself, or the code that calls through it can import cx from there.`;
-}
-
-// src/vite-used-package-lines.ts
-function isListableReexport(problem2) {
-  return problem2.kind === "reexport" && problem2.isListable !== false;
-}
-function isRenamedOrReached(problem2) {
-  return problem2.isRenamed === true || problem2.kind === "reexport" && !isListableReexport(problem2);
-}
-function isSecondHop(problem2) {
-  return problem2.kind === "reexport" && problem2.isListable === false && problem2.pkg !== void 0;
-}
-function callsLine(pkg, problems, keepFor) {
-  if (problems.every((problem2) => problem2.kind === "own")) {
-    return `${pkg} names atoms of your own, which have no class, so a keepFor entry cannot make its calls produce a Nave class. The fix is the package's: it must name atoms Nave ships.`;
-  }
-  const isOnlyDynamic = problems.every((problem2) => problem2.kind === "dynamic");
-  if (isOnlyDynamic) {
-    const count = problems.length;
-    const places = count === 1 ? "1 place" : `${count} places`;
-    return `${pkg} calls cx.dynamic() in ${places}, and keepFor lists no atoms for it, so none of them applies a class. List the atoms those calls can take, from its documentation, under its name in navePlugin(): ${keepFor}.`;
-  }
-  return `${pkg} is a dependency, so its code is not yours to change. List the atoms its calls can produce, from its documentation, under its name in navePlugin(): ${keepFor}. The lasting fix is the package's: names chosen at run time go through cx.dynamic().`;
-}
-var LASTING_FIX = "The lasting fix is the package's: import cx from @navecss/core/cx where it is called, or re-export it from the package's entry.";
-function listedLine(pkg, specifiers, configured) {
-  const array = cxModulesArray(configured, specifiers);
-  const named = specifiers.map((specifier) => `'${specifier}'`).join(", ");
-  const it = specifiers.length === 1 ? "it" : "them";
-  return array === void 0 ? void 0 : `${pkg} re-exports cx in ${named}. List ${it} in navePlugin(): cxModules: ${array}.`;
-}
-function internalLine(pkg, count, keepFor, hasKeepFor) {
-  if (hasKeepFor) {
-    return `${pkg} also re-exports cx in a file that only the package itself imports; the keepFor entry above clears that too. The build does not read calls made through that cx: where your code imports cx from ${pkg} or one of its subpaths, import it from @navecss/core/cx instead. The lasting fix there is the package's: import cx from @navecss/core/cx where it is called, or re-export it from the package's entry.`;
-  }
-  const [file, them] = count === 1 ? ["a file that only", "it"] : ["files that only", "them"];
-  return `${pkg} re-exports cx in ${file} the package itself imports, so your code has no specifier for ${them} to list in cxModules, and the build does not read calls made through that cx. Where your code imports cx from ${pkg} or one of its subpaths, import it from @navecss/core/cx instead. For the package's own calls, list the atoms they can produce, from its documentation, under its name in navePlugin(): ${keepFor}. ${LASTING_FIX}`;
-}
-var RENAMED_FIX = "import cx from @navecss/core/cx where it is called, and re-export it only under the name cx.";
-var RENAMED_FORM = "other than under the name cx (renamed, as a default or inside a namespace)";
-function renamedLine(pkg, count, keepFor, hasKeepFor) {
-  const [those, them, its] = count === 1 ? ["that export", "it", "its"] : ["those exports", "them", "their"];
-  const act = `import cx from @navecss/core/cx instead and call cx in ${its} place`;
-  if (hasKeepFor) {
-    return `${pkg} also re-exports cx ${RENAMED_FORM}, and no cxModules entry clears an export of cx from a module that does, under the name cx or another; the keepFor entry above clears ${those} too. The build does not read calls made through ${them}: where your code imports ${them} from ${pkg} or one of its subpaths, ${act}. The lasting fix there is the package's: ${RENAMED_FIX}`;
-  }
-  return `${pkg} re-exports cx ${RENAMED_FORM}, which the build does not follow even from a module listed in cxModules. Listing a module that does fails the build, so no entry there clears an export of cx from it, under the name cx or another, and the build does not read calls made through ${those}. Where your code imports ${those} from ${pkg} or one of its subpaths, ${act}. For the package's own calls, list the atoms they can produce, from its documentation, under its name in navePlugin(): ${keepFor}. The lasting fix is the package's: ${RENAMED_FIX}`;
-}
-function declaredLine(pkg, entries, hasInternal) {
-  const named = entries.map((entry) => `'${entry}'`).join(", ");
-  const [is, it, module] = entries.length === 1 ? ["is", "it", "the module"] : ["are", "them", "each module"];
-  const reader = hasInternal ? "" : `, and where your code imports cx from ${it}, import cx from @navecss/core/cx instead`;
-  return `${pkg} exports a cx the build does not follow from ${named}, which ${is} listed in cxModules. Remove ${it} from cxModules in navePlugin()${reader}. The lasting fix is the package's: make export { cx } from '@navecss/core/cx' the only export of cx in ${module} you list.`;
-}
-function withoutRemoved(problems, configured) {
-  const removed = new Set(
-    problems.flatMap(
-      (problem2) => problem2.pkg !== void 0 && problem2.kind === "declared" ? problem2.entries ?? [] : []
-    )
-  );
-  return configured.filter((entry) => !removed.has(entry));
-}
-function takeLines(pkg, all) {
-  const isTaken = (problem2) => (problem2.takes?.length ?? 0) > 0;
-  const taken = all.filter((problem2) => isTaken(problem2));
-  const plain = taken.filter((problem2) => !isSecondHop(problem2));
-  const hops = taken.filter((problem2) => isSecondHop(problem2));
-  const takes = plain.flatMap((problem2) => problem2.takes);
-  const lines = [];
-  if (takes.length > 0) {
-    const hasPackageFix = plain.some((problem2) => isRenamedOrReached(problem2)) || takes.some((take) => take.isReached);
-    lines.push(takenLine(pkg, takes, hasPackageFix));
-  }
-  if (hops.length > 0)
-    lines.push(
-      forwardLine(
-        pkg,
-        hops.flatMap((problem2) => problem2.takes)
-      )
-    );
-  const callers = all.flatMap((problem2) => problem2.callers ?? []);
-  if (callers.length > 0)
-    lines.push(callsThroughLine(pkg, [...new Set(callers)].toSorted(compareText)));
-  return lines;
-}
-function packageLines(pkg, all, configured) {
-  const isTaken = (problem2) => (problem2.takes?.length ?? 0) > 0;
-  const problems = all.filter((problem2) => !isTaken(problem2) && problem2.callers === void 0);
-  const keepFor = `keepFor: { '${pkg}': ['<atom>'] }`;
-  const reexports = problems.filter((problem2) => isListableReexport(problem2));
-  const internal = reexports.filter(
-    (problem2) => problem2.specifier === void 0 && problem2.isRenamed !== true
-  );
-  const renamed = reexports.filter((problem2) => problem2.isRenamed === true);
-  const declared = problems.filter((problem2) => problem2.kind === "declared");
-  const rest = problems.filter(
-    (problem2) => !isListableReexport(problem2) && problem2.kind !== "declared"
-  );
-  const named = [...new Set(reexports.flatMap((problem2) => problem2.specifier ?? []))].toSorted(
-    compareText
-  );
-  const lines = [];
-  if (declared.length > 0) {
-    const entries = [...new Set(declared.flatMap((problem2) => problem2.entries ?? []))];
-    lines.push(declaredLine(pkg, entries.toSorted(compareText), internal.length > 0));
-  }
-  if (rest.length > 0) lines.push(callsLine(pkg, rest, keepFor));
-  const listed = named.length > 0 ? listedLine(pkg, named, configured) : void 0;
-  if (listed !== void 0) lines.push(listed);
-  if (internal.length > 0) {
-    const files = new Set(internal.map((problem2) => problem2.file)).size;
-    const hasKeepFor = rest.some((problem2) => problem2.kind !== "own");
-    lines.push(internalLine(pkg, files, keepFor, hasKeepFor));
-  }
-  if (renamed.length > 0) {
-    const hasKeepFor = rest.some((problem2) => problem2.kind !== "own") || internal.length > 0;
-    lines.push(renamedLine(pkg, renamed.length, keepFor, hasKeepFor));
-  }
-  lines.push(...takeLines(pkg, all));
-  return lines;
-}
-
-// src/vite-used-report.ts
-var LINE_UNKNOWN_WITHOUT_MAP = " (line unknown: this file's compiled code has no source map in this build; with build.sourcemap set in the Vite config, the report gives the line if the source maps then lead back to it)";
-var LINE_UNKNOWN_UNMAPPED = " (line unknown: no source map leads from the compiled code to this file)";
-var REPORT_CAUSE = "the build cannot tell which atoms these apply, and it ships only the atoms it can read.";
-var REMEDIES = {
-  argument: [
-    "Name the atoms at the call: a string literal, a const in the same file, or a condition choosing between them, as in cx(on ? 'flex' : 'grid').",
-    "To choose by a value, call cx() once per case and pick between the results: ({ row: cx('flex'), grid: cx('grid') })[variant].",
-    "If the name comes from data the build never sees, write cx.dynamic(name) and list every atom it can take in keep in navePlugin()."
-  ],
-  reference: [
-    "Call cx() where the classes are applied, with the atom names as its arguments: the build reads calls, not a cx that is assigned, passed or spread."
-  ],
-  // Printed by `reexportRemedy`, which names the modules a `cxModules` entry would clear.
-  reexport: [],
-  declared: [
-    "In a module listed in cxModules, make export { cx } from '@navecss/core/cx' its only export of cx, or remove the module from cxModules and import cx from @navecss/core/cx where it is called."
-  ],
-  concatenation: [
-    "Write cx() with the atom name, or cx.dynamic() with keep for a name chosen at run time."
-  ],
-  dynamic: ["List the atoms those calls can take in keep in navePlugin()."],
-  unknown: [],
-  own: [],
-  unreadable: []
-};
-function problemLine(problem2) {
-  const where = problem2.unknownLine === void 0 ? `${problem2.file}:${problem2.line}:${problem2.column}: ` : `${problem2.file}: `;
-  const ending = problem2.unknownLine ?? "";
-  if (problem2.construct === "") return `${where}${problem2.text}${ending}`;
-  const construct = cut(problem2.construct);
-  return problem2.text === "" ? `${where}${construct}${ending}` : `${where}${construct}: ${problem2.text}${ending}`;
-}
-function reexportRemedy(problems, configured) {
-  const modules = problems.filter((problem2) => isListableReexport(problem2)).map((problem2) => problem2.file.startsWith(".") ? problem2.file : `./${problem2.file}`);
-  const array = cxModulesArray(configured, modules);
-  const lines = array === void 0 ? [] : [
-    `To keep a module that re-exports cx, list it in navePlugin() by its path from the project root: cxModules: ${array}. Files that import cx from it are then read as if they imported it from @navecss/core/cx. Or import cx from @navecss/core/cx directly where it is called.`
-  ];
-  if (problems.some((problem2) => problem2.kind === "reexport" && !isListableReexport(problem2))) {
-    lines.push(
-      "Import cx where it is called, from @navecss/core/cx or from a module listed in cxModules, instead of re-exporting the cx of a listed module."
-    );
-  }
-  return lines;
-}
-function remedyBlock(problems, listed) {
-  const configured = withoutRemoved(problems, listed);
-  const application = problems.filter((problem2) => problem2.pkg === void 0);
-  const lines = [];
-  for (const kind of PROBLEM_KINDS) {
-    if (application.every((problem2) => problem2.kind !== kind)) continue;
-    lines.push(...kind === "reexport" ? reexportRemedy(application, configured) : REMEDIES[kind]);
-  }
-  const byPackage = /* @__PURE__ */ new Map();
-  for (const problem2 of problems) {
-    if (problem2.pkg !== void 0)
-      byPackage.set(problem2.pkg, [...byPackage.get(problem2.pkg) ?? [], problem2]);
-  }
-  for (const pkg of byPackage.keys().toArray().toSorted(compareText)) {
-    lines.push(...packageLines(pkg, byPackage.get(pkg), configured));
-  }
-  if (application.some((problem2) => problem2.needsAvailable)) lines.push(availableLine());
-  return lines;
-}
-function inReportOrder(problems) {
-  const rank = (problem2) => problem2.pkg === void 0 ? 0 : 1;
-  return problems.toSorted(
-    (a, b) => rank(a) - rank(b) || compareText(a.file, b.file) || Number(a.unknownLine !== void 0) - Number(b.unknownLine !== void 0) || a.line - b.line || a.column - b.column
-  );
-}
-function problemLines(problems) {
-  const ordered = inReportOrder(problems);
-  const isApplicationDynamic = (problem2) => problem2.kind === "dynamic" && problem2.pkg === void 0;
-  const application = ordered.filter(
-    (problem2) => problem2.pkg === void 0 && !isApplicationDynamic(problem2)
-  );
-  const dynamic = ordered.filter((problem2) => isApplicationDynamic(problem2));
-  const dependencies = ordered.filter((problem2) => problem2.pkg !== void 0);
-  const lines = application.map((problem2) => problemLine(problem2));
-  if (dynamic.length > 0) {
-    const places = dynamic.length === 1 ? "1 place" : `${dynamic.length} places`;
-    lines.push(
-      `cx.dynamic() is called in ${places} in your code, but keep is empty, so none of them applies a class.`,
-      ...dynamic.map((problem2) => problemLine(problem2))
-    );
-  }
-  return [...lines, ...dependencies.map((problem2) => problemLine(problem2))];
-}
-function noun(count, word) {
-  return `${count} ${word}${count === 1 ? "" : "s"}`;
-}
-function buildReport(problems, configured = []) {
-  const files = new Set(problems.map((problem2) => problem2.file)).size;
-  const first2 = `${noun(problems.length, "problem")} in ${noun(files, "file")}: ${REPORT_CAUSE}`;
-  return [first2, ...problemLines(problems), ...remedyBlock(problems, configured)].join("\n");
-}
-function moduleReport(problems, configured = []) {
-  return [...problemLines(problems), ...remedyBlock(problems, configured)].join("\n");
-}
-
-// src/vite-options.ts
-function unknownAtomText(name) {
-  const hint = hintFor(name);
-  return hint ? ` ${hint}` : "";
-}
-function problemWithName(where, name, own) {
-  if (typeof name === "string" && isBuiltInAtom(name)) return void 0;
-  if (typeof name === "string" && own === void 0) return void 0;
-  if (typeof name === "string" && own?.has(name)) {
-    return `navePlugin(): ${where} names "${name}", an atom of your own; those have no class, so there is nothing to keep.`;
-  }
-  const spelled = typeof name === "string" ? name : String(name);
-  return `navePlugin(): ${where} names an unknown atom "${spelled}".${unknownAtomText(spelled)}`;
-}
-function problemsInList(where, list, own) {
-  if (!Array.isArray(list)) return [`navePlugin(): ${where} must be an array of atom names.`];
-  return Array.from(list, (name) => problemWithName(where, name, own) ?? []).flat();
-}
-function problemsInKeepFor(keepFor, own) {
-  if (typeof keepFor !== "object" || keepFor === null || Array.isArray(keepFor)) {
-    return ["navePlugin(): keepFor must be an object from package names to arrays of atom names."];
-  }
-  const problems = [];
-  for (const [pkg, list] of Object.entries(keepFor)) {
-    problems.push(...problemsInList(`keepFor["${pkg}"]`, list, own));
-  }
-  return problems;
-}
-function problemsInCxModules(cxModules) {
-  if (!Array.isArray(cxModules)) {
-    return ["navePlugin(): cxModules must be an array of module paths or specifiers."];
-  }
-  return Array.from(
-    cxModules,
-    (entry, index) => typeof entry === "string" ? [] : `navePlugin(): cxModules[${index}] must be a string: a module path or a specifier.`
-  ).flat();
-}
-function problemsInOptions(options, own) {
-  const problems = [];
-  const { atomic, keep, keepFor, cxModules } = options;
-  if (atomic !== void 0 && atomic !== "all" && atomic !== "used") {
-    problems.push("navePlugin(): atomic must be 'used' or 'all'.");
-  }
-  if (keep !== void 0) problems.push(...problemsInList("keep", keep, own));
-  if (keepFor !== void 0) problems.push(...problemsInKeepFor(keepFor, own));
-  if (cxModules !== void 0) problems.push(...problemsInCxModules(cxModules));
-  return problems;
-}
-function assertOptions(options, own) {
-  const [first2] = problemsInOptions(options, own);
-  if (first2 !== void 0) throw new Error(first2);
-}
-function resolveUsedOptions(options) {
-  return {
-    atomic: options.atomic ?? "used",
-    keep: [...options.keep ?? []],
-    keepFor: Object.fromEntries(
-      Object.entries(options.keepFor ?? {}).map(([pkg, list]) => [pkg, [...list]])
-    ),
-    cxModules: [...options.cxModules ?? []]
-  };
-}
-function keptAtoms(options) {
-  return [.../* @__PURE__ */ new Set([...options.keep, ...Object.values(options.keepFor).flat()])];
-}
-
 // src/vite-used.ts
 function createUsedContext(options, extend) {
   return {
@@ -2637,10 +741,10 @@ function lineUnknownNote(context, id) {
   return isBuildWithoutMaps && !isInlineScript(id) ? LINE_UNKNOWN_WITHOUT_MAP : LINE_UNKNOWN_UNMAPPED;
 }
 function locate(problems, placing) {
-  return problems.map((problem2) => {
-    const place = placing.place(problem2.offset);
+  return problems.map((problem) => {
+    const place = placing.place(problem.offset);
     const where = place ?? { ...NO_PLACE, unknownLine: placing.unknownLine };
-    return { ...problem2, file: placing.file, pkg: placing.pkg, moduleId: placing.id, ...where };
+    return { ...problem, file: placing.file, pkg: placing.pkg, moduleId: placing.id, ...where };
   });
 }
 function locateDynamic(reading, placing) {
@@ -2693,7 +797,8 @@ async function recordOf(context, ctx, input, reading) {
     suppressed: isStandingIn ? locate(reading.problems, placing) : [],
     dynamicCalls: locateDynamic(reading, placing),
     pkg,
-    file: placing.file
+    file: placing.file,
+    ...reading.edits.length > 0 && { edits: reading.edits }
   };
 }
 function readOrUndefined(code, program, options) {
@@ -2719,7 +824,9 @@ async function recordParsed(context, ctx, input, key) {
     }),
     isDependency: isDependencyId(id),
     isVueScript: /\.vue(?:$|\?)/.test(id),
-    setup: await setupExposuresFor(context, ctx, { program, code, 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);
@@ -2755,6 +862,47 @@ async function recordModule(context, ctx, module) {
   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(", ");
@@ -2782,7 +930,7 @@ function dependencyLineOf(item) {
 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, configured) {
+function applicationRemedyOf(items, lines, input) {
   const remedy = [];
   const relativeCount = lines.reduce((count, line) => count + line.relative.length, 0);
   if (relativeCount === 1) {
@@ -2804,40 +952,39 @@ function applicationRemedyOf(items, lines, configured) {
       items.flatMap((item) => item.specifiers.filter((specifier) => !isRelative(specifier)))
     )
   ];
-  const array = cxModulesArray(configured, added);
+  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 navePlugin(): cxModules: ${array}.`);
+    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, hasKeepFor) {
-  if (hasKeepFor) {
+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 navePlugin(): 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.`;
+  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 first2 = 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 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 [
-    first2,
+    first,
     ...lines.flatMap((line) => [...line.relative, ...line.other, ...line.none]).toSorted(compareText),
     ...dependencies.map((item) => dependencyLineOf(item)).toSorted(compareText),
-    ...applicationRemedyOf(application, lines, input.configured),
+    ...applicationRemedyOf(application, lines, input),
     ...packages.map(
-      (pkg) => packageRemedyOf(
-        pkg,
-        new Set(byPackage.get(pkg).map((item) => item.importer)).size,
-        input.report?.includes(`keepFor: { '${pkg}'`) ?? false
-      )
+      (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");
 }
@@ -2899,18 +1046,18 @@ async function withClearingSpecifiers(ctx, context, problems) {
   };
   const renamed = new Set(
     problems.flatMap(
-      (problem2) => problem2.isRenamed === true && problem2.moduleId !== void 0 ? [problem2.moduleId] : []
+      (problem) => problem.isRenamed === true && problem.moduleId !== void 0 ? [problem.moduleId] : []
     )
   );
   return await Promise.all(
-    problems.map(async (problem2) => {
-      const { moduleId, pkg } = problem2;
-      if (pkg === void 0 || moduleId === void 0) return problem2;
-      if (problem2.kind === "declared") return { ...problem2, entries: await entriesOf(moduleId) };
-      if (!isListableReexport(problem2)) return problem2;
-      if (renamed.has(moduleId)) return { ...problem2, isRenamed: true };
+    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 ? problem2 : { ...problem2, specifier };
+      return specifier === void 0 ? problem : { ...problem, specifier };
     })
   );
 }
@@ -3014,13 +1161,13 @@ function withoutEchoes(modules) {
   const broken = new Set(
     modules.flatMap(
       (module) => module.problems.flatMap(
-        (problem2) => problem2.kind === "declared" && problem2.moduleId !== void 0 && !problem2.hasNaveCx ? [fileOf(problem2.moduleId)] : []
+        (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((problem2) => !ECHO_KINDS.has(problem2.kind)) : module.problems
+    (module) => isEcho(module) ? module.problems.filter((problem) => !ECHO_KINDS.has(problem.kind)) : module.problems
   );
 }
 
@@ -3153,7 +1300,7 @@ function takeStaleModules(context, environment) {
   for (const id of ids) {
     const module = environment.moduleGraph.getModuleById(id);
     if (!module) continue;
-    state.reloading.set(id, Date.now());
+    noteReloadSent(state, id);
     sheets.push(module);
   }
   return sheets;
@@ -3386,19 +1533,19 @@ function isEmptyRegion(sheet, from, to) {
 }
 function pruneRule(sheet, statement, emitted) {
   const { from, open, close } = statement;
-  const first2 = firstSignificant(sheet.tokens, from, open);
-  const members = membersOf(sheet, first2, open);
+  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 > first2 && firstSignificant(sheet.tokens, trailing - 1, trailing) === trailing) {
+  while (trailing > first && firstSignificant(sheet.tokens, trailing - 1, trailing) === trailing) {
     trailing -= 1;
   }
-  const list = sheet.slice(first2, trailing);
+  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, first2)}${text}${sheet.slice(trailing, open)}${sheet.slice(open, close + 1)}`;
+  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);
@@ -3410,8 +1557,8 @@ function pruneRegion(sheet, from, to, emitted) {
 function pruneStatement(sheet, statement, emitted) {
   const { open, close } = statement;
   if (open === void 0 || close === void 0) return sheet.slice(statement.from, statement.to);
-  const first2 = firstSignificant(sheet.tokens, statement.from, open);
-  const keyword = atKeywordAt(sheet, first2);
+  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);
@@ -3431,16 +1578,16 @@ function pruneAtomicLayer(css, emitted) {
   }
   return cursor === 0 ? css : out + sheet.slice(cursor, sheet.tokens.length);
 }
-function visitMembers(sheet, from, to, visit2) {
+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 first2 = firstSignificant(sheet.tokens, statement.from, open);
-    const keyword = atKeywordAt(sheet, first2);
+    const first = firstSignificant(sheet.tokens, statement.from, open);
+    const keyword = atKeywordAt(sheet, first);
     if (keyword === void 0) {
-      for (const [start, end] of membersOf(sheet, first2, open)) visit2(start, end);
+      for (const [start, end] of membersOf(sheet, first, open)) visit(start, end);
     } else if (GROUPS.has(keyword)) {
-      visitMembers(sheet, open + 1, close, visit2);
+      visitMembers(sheet, open + 1, close, visit);
     }
   }
 }
@@ -3471,9 +1618,14 @@ function unprunedAtoms(css, emitted) {
 // 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 {
-    await environment.reloadModule(module);
+    if (isInlinedInHtml(module)) environment.hot.send({ type: "full-reload", path: "*" });
+    else await environment.reloadModule(module);
   } catch {
   }
 }
@@ -3486,7 +1638,7 @@ function reloadStale(context) {
     const sheet = state.served.get(id);
     const module = sheet?.environment.moduleGraph.getModuleById(id);
     if (!sheet || !module) continue;
-    state.reloading.set(id, Date.now());
+    noteReloadSent(state, id);
     void reloadQuietly(sheet.environment, module);
   }
 }
@@ -3494,12 +1646,26 @@ 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) return;
+    if (module.importers.size === 0 && DIRECT.test(id)) return;
     await environment.waitForRequestsIdle(id);
     await transformReachable(environment, graphRoots(environment));
   },
@@ -3514,19 +1680,22 @@ var devServing = {
     }
     devServing.noteGrowth(context);
   },
-  noteGrowth(context) {
+  noteConnect(context) {
     const { state } = context;
-    if (state.served.size === 0) return;
-    const atoms = servedAtoms(state, context.kept);
-    for (const [id, sheet] of state.served) {
-      if (!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();
-    }
+    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) {
@@ -3685,7 +1854,7 @@ function checkServerInvocation(ctx, context) {
 }
 
 // src/vite-cx-reexported.ts
-function declaredNames2(pattern) {
+function declaredNames(pattern) {
   const found = [];
   const stack = pattern ? [pattern] : [];
   while (stack.length > 0) {
@@ -3693,11 +1862,18 @@ function declaredNames2(pattern) {
     if (node.type === "Identifier") {
       found.push(stringAt(node, "name") ?? "");
     } else if (node.type === "AssignmentPattern") {
-      stack.push(...[nodeAt(node, "left")].filter((part) => part !== void 0));
+      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));
-      stack.push(...single.filter((part) => part !== void 0), ...lists);
+      pushAll(
+        stack,
+        single.filter((part) => part !== void 0)
+      );
+      pushAll(stack, lists);
     }
   }
   return found;
@@ -3710,9 +1886,9 @@ function ownExports(program) {
     if (statement.type !== "ExportNamedDeclaration") continue;
     const declaration = nodeAt(statement, "declaration");
     const declared = nodesAt(declaration ?? statement, "declarations").flatMap(
-      (declarator) => declaredNames2(nodeAt(declarator, "id"))
+      (declarator) => declaredNames(nodeAt(declarator, "id"))
     );
-    for (const name of [...declared, ...declaredNames2(declaration && nodeAt(declaration, "id"))]) {
+    for (const name of [...declared, ...declaredNames(declaration && nodeAt(declaration, "id"))]) {
       found.add(name);
     }
     for (const specifier of nodesAt(statement, "specifiers")) {
@@ -3741,8 +1917,8 @@ function isImportedFrom(binding, source) {
   if (!source.reaches.has(binding.source)) return false;
   return binding.imported === "*" || source.names.has(binding.imported ?? "");
 }
-function exportedAs(analysis, reference2) {
-  const parent = analysis.parentOf.get(reference2.node);
+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;
 }
@@ -3762,11 +1938,11 @@ function reexportedNames(program, source) {
     if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
       for (const name of exportedBy(node, source, own)) found.add(name);
     }
-    stack.push(...childrenOf(node));
+    pushAll(stack, childrenOf(node));
   }
   const analysis = analyze(program);
-  for (const reference2 of analysis.references) {
-    const name = isImportedFrom(reference2.binding, source) ? exportedAs(analysis, reference2) : void 0;
+  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];
@@ -3952,7 +2128,7 @@ function parameterTakes(analysis, callback, names) {
   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;
-    found.push(...taken);
+    pushAll(found, taken);
   }
   return found;
 }
@@ -3967,7 +2143,7 @@ function variableTakes(analysis, init, names) {
     if (binding?.init !== init) continue;
     const taken = binding.writes === 0 ? referenceTakes(analysis, node, names) : void 0;
     if (taken === void 0) return void 0;
-    found.push(...taken);
+    pushAll(found, taken);
   }
   return found;
 }
@@ -3989,8 +2165,8 @@ function dynamicKeys(analysis, node, names) {
 var UNREADABLE = { shape: "unreadable", names: [] };
 function namespaceTakes(analysis, references, names) {
   const found = /* @__PURE__ */ new Set();
-  for (const reference2 of references) {
-    const taken = referenceTakes(analysis, reference2.node, names);
+  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);
   }
@@ -4008,8 +2184,8 @@ function usesOf(analysis, source, specifier) {
     ({ binding }) => binding?.kind === "import" && binding.source === source && binding.name === local
   );
 }
-function isExportOf(analysis, reference2) {
-  const parent = analysis.parentOf.get(reference2.node);
+function isExportOf(analysis, reference) {
+  const parent = analysis.parentOf.get(reference.node);
   return parent?.type === "ExportSpecifier" || parent?.type === "ExportDefaultDeclaration";
 }
 function passingOf(analysis, source, specifier) {
@@ -4069,8 +2245,8 @@ function takesIn(program, input) {
   const stack = [program];
   while (stack.length > 0) {
     const node = stack.pop();
-    found.push(...takesOf(node, scan));
-    stack.push(...childrenOf(node));
+    pushAll(found, takesOf(node, scan));
+    pushAll(stack, childrenOf(node));
   }
   return found;
 }
@@ -4164,9 +2340,9 @@ async function takesFrom(ctx, context, input) {
       resolutions,
       wantCalls
     });
-    entry.push(...routes.entry);
-    told.push(...routes.told);
-    calls.push(...routes.calls);
+    pushAll(entry, routes.entry);
+    pushAll(told, routes.told);
+    pushAll(calls, routes.calls);
   }
   return { entry: merged2(entry), told: merged2(told), calls: merged2(calls) };
 }
@@ -4184,11 +2360,11 @@ function serverRoutes(holder, input) {
 // src/vite-listed-takes.ts
 async function prepareOne(ctx, context, input) {
   const { isHop, problems, walk } = input;
-  const first2 = problems[0];
-  const pkg = first2.pkg;
-  const names = new Set(problems.flatMap((problem2) => problem2.exportedAs ?? []));
-  const hasEntry = !isHop && problems.some((problem2) => problem2.specifier !== void 0);
-  const holders = await holdersOf(ctx, { ...walk, id: first2.moduleId, names });
+  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, {
@@ -4209,15 +2385,15 @@ function decideOne(prepared, serverImports) {
     (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((problem2) => problem2.specifier !== void 0);
+  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((problem2) => ({
-    ...problem2,
+  return problems.map((problem) => ({
+    ...problem,
     ...told.length > 0 && { takes: told },
     ...callers.length > 0 && { callers }
   }));
@@ -4227,19 +2403,19 @@ function callersOf(routed) {
   return [...callers].toSorted(compareText);
 }
 async function prepareReexports(ctx, context, standingIn) {
-  const exporting = standingIn.filter((problem2) => problem2.exportedAs !== void 0);
+  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 problem2 of located) {
-    if (problem2.moduleId === void 0 || problem2.pkg === void 0) continue;
-    const group = isSecondHop(problem2) ? hops : byModule;
-    group.set(problem2.moduleId, [...group.get(problem2.moduleId) ?? [], problem2]);
+  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((problem2) => problem2.exportedAs ?? []))
+      new Set(problems.flatMap((problem) => problem.exportedAs ?? []))
     ])
   );
   const walk = { cxExports, resolutions: /* @__PURE__ */ new Map() };
@@ -4391,8 +2567,8 @@ function parsed(ctx, id) {
 function formatOf(ctx) {
   const build = ctx.environment.config.build;
   const output = build?.rolldownOptions?.output ?? build?.rollupOptions?.output;
-  const first2 = Array.isArray(output) ? output[0] : output;
-  return first2?.format;
+  const first = Array.isArray(output) ? output[0] : output;
+  return first?.format;
 }
 function conditionsOf(ctx) {
   return ["node", formatOf(ctx) === "cjs" ? "require" : "import", "module-sync", "default"];
@@ -4525,39 +2701,7 @@ function warnUnknown(ctx, context, unknown) {
 }
 
 // src/vite-collect-plugin.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 { id, problems } = input;
-  const message = moduleReport(problems, context.options.cxModules);
-  const first2 = problems[0];
-  return ctx.error({
-    message,
-    id,
-    loc: { file: id, line: Math.max(first2.line, 1), column: Math.max(first2.column - 1, 0) }
-  });
-}
+var OPTIONS_HOME = "navePlugin()";
 function isReadable(context, id) {
   return isUsed(context) && !isStylesheetId(id) && !isNaveOwn(id);
 }
@@ -4571,34 +2715,35 @@ async function problemsOfBuild(ctx, context, serverImports) {
         onlyVia: record.onlyVia,
         problems: [
           ...problemsOf(record, context),
-          ...record.suppressed.filter((problem2) => problem2.kind === "declared")
+          ...record.suppressed.filter((problem) => problem.kind === "declared")
         ]
       }))
     )
   );
   const standingIn = [
     ...records.flatMap((record) => record.suppressed),
-    ...kept.filter((problem2) => isSecondHop(problem2))
+    ...kept.filter((problem) => isSecondHop(problem))
   ];
-  const rest = kept.filter((problem2) => !isSecondHop(problem2));
+  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 report2 = buildReport(problems, context.options.cxModules);
-  const recorded = problems.flatMap((problem2) => problem2.takes ?? []).filter((take) => take.isRecorded === true).map((take) => take.taker);
+  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 ? report2 : `${report2}
+  return note === void 0 ? report : `${report}
 ${note}`;
 }
 async function failuresOf(ctx, context, serverImports) {
   const { problems, prepared } = await problemsOfBuild(ctx, context, serverImports);
-  const report2 = problems.length > 0 ? reportOf(context, problems) : void 0;
+  const report = problems.length > 0 ? reportOf(context, problems) : void 0;
   const importers = await declaredImporterError(ctx, context, {
     configured: withoutRemoved(problems, context.options.cxModules),
-    report: report2
+    home: OPTIONS_HOME,
+    report
   });
-  return { failures: [report2, importers].filter((failure) => failure !== void 0), prepared };
+  return { failures: [report, importers].filter((failure) => failure !== void 0), prepared };
 }
 function serverImportsForClient(ctx, context, graph) {
   if (ctx.environment.config.consumer !== "client") return { known: [], unknown: [] };
@@ -4636,9 +2781,8 @@ function createCollectPlugin(context) {
       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 || context.command !== "serve" || record.pkg !== void 0) return;
-      const problems = problemsOf(record, context);
-      if (problems.length > 0) failModule(this, context, { id, problems });
+      if (record?.edits) return applyEdits(code, id, record.edits);
+      if (record) failDevModule(this, context, { home: OPTIONS_HOME, id, record });
     },
     transformIndexHtml: {
       order: "pre",
@@ -4673,55 +2817,6 @@ function createCollectPlugin(context) {
   return plugin;
 }
 
-// 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-worker-collect.ts
 function workerCollectPlugins(context) {
   const plugin = {
@@ -4729,7 +2824,8 @@ function workerCollectPlugins(context) {
     enforce: "post",
     async transform(code, id, meta) {
       if (!isReadable(context, id)) return;
-      await recordModule(context, this, { code, id, moduleType: meta?.moduleType });
+      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;
@@ -4855,7 +2951,7 @@ function warnTextImports(ctx, chunk, context, emitted) {
     );
   }
 }
-function textOf2(entry) {
+function textOf(entry) {
   const { source } = entry;
   if (source === void 0) return "";
   return typeof source === "string" ? source : decoder.decode(source);
@@ -4883,7 +2979,7 @@ function mismatchLines(assets, 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: textOf2(entry) }));
+  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({
@@ -4956,22 +3052,22 @@ var decoder2 = new TextDecoder();
 function isCssAsset(entry) {
   return entry.type === "asset" && entry.fileName.toLowerCase().endsWith(".css");
 }
-function textOf3(entry) {
+function textOf2(entry) {
   const { source } = entry;
   if (source === void 0) return "";
   return typeof source === "string" ? source : decoder2.decode(source);
 }
 function messageFor(findings, assetCount) {
-  const noun2 = assetCount === 1 ? "asset" : "assets";
+  const noun = assetCount === 1 ? "asset" : "assets";
   return [
     "@nave survived into the built CSS:",
     ...findings.map((finding) => formatFinding(finding)),
-    `Scanned ${assetCount} CSS ${noun2} this build wrote.`
+    `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, textOf3(asset)));
+  const findings = assets.flatMap((asset) => findingsInText(asset.fileName, textOf2(asset)));
   if (findings.length > 0) ctx.error({ message: messageFor(findings, assets.length) });
 }
 
@@ -4988,8 +3084,18 @@ function serverHooks(context) {
       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);
@@ -5060,9 +3166,9 @@ function reportDiagnostics(input) {
     }
     return;
   }
-  const first2 = located[0];
-  const message = withNoMapNote(`${frame(first2)}${foldLocated(located)}`, input, first2);
-  input.ctx.error(logFor(message, input, first2));
+  const first = located[0];
+  const message = withNoMapNote(`${frame(first)}${foldLocated(located)}`, input, first);
+  input.ctx.error(logFor(message, input, first));
 }
 
 // src/vite-transform.ts