@navecss/core 0.5.0 → 0.6.0

package/dist/{chunk-BCUK4M4P.js → chunk-EYMFWE3A.js}

@@ -383,6 +383,171 @@ function isImportingCx(program, sources) {
   });
 }
 
+// src/vite-cx-member.ts
+var READ_MEMBERS = /* @__PURE__ */ new Set(["dynamic", "raw"]);
+var CALL_MEMBERS = /* @__PURE__ */ new Set(["apply", "call"]);
+var LEFT_TARGETS = /* @__PURE__ */ new Set([
+  "AssignmentExpression",
+  "AssignmentPattern",
+  "ForInStatement",
+  "ForOfStatement"
+]);
+var WHOLE_TARGETS = /* @__PURE__ */ new Set([
+  "ArrayPattern",
+  "RestElement",
+  "UpdateExpression"
+]);
+function unwrapped(analysis, node) {
+  let current = node;
+  for (; ; ) {
+    const parent = analysis.parentOf.get(current);
+    if (!parent || wrappedBy(parent) !== current) return current;
+    current = parent;
+  }
+}
+function isMemberWrite(analysis, member) {
+  const top = unwrapped(analysis, member);
+  const parent = analysis.parentOf.get(top);
+  if (!parent) return false;
+  if (LEFT_TARGETS.has(parent.type)) return nodeAt(parent, "left") === top;
+  if (WHOLE_TARGETS.has(parent.type)) return true;
+  if (parent.type === "UnaryExpression") return parent.operator === "delete";
+  return parent.type === "Property" && nodeAt(parent, "value") === top && analysis.parentOf.get(parent)?.type === "ObjectPattern";
+}
+function isCallee(analysis, member) {
+  const top = unwrapped(analysis, member);
+  const parent = analysis.parentOf.get(top);
+  return parent?.type === "CallExpression" && nodeAt(parent, "callee") === top;
+}
+function memberRoleOf(analysis, member) {
+  if (member.computed === true || isMemberWrite(analysis, member)) return "unknown";
+  const name = propertyNameOf(nodeAt(member, "property"), false);
+  if (name !== void 0 && READ_MEMBERS.has(name)) return "read";
+  if (name === void 0 || !CALL_MEMBERS.has(name)) return "unknown";
+  return isCallee(analysis, member) ? "call" : "read";
+}
+
+// src/vite-cx-flow.ts
+var CALLED = { kind: "called" };
+var SAFE = { kind: "safe" };
+var UNBOUND = { kind: "unbound" };
+var HARMLESS_PARENTS = /* @__PURE__ */ new Set(["ExpressionStatement", "UnaryExpression"]);
+var TESTING_PARENTS = /* @__PURE__ */ new Set([
+  "ConditionalExpression",
+  "DoWhileStatement",
+  "ForStatement",
+  "IfStatement",
+  "WhileStatement"
+]);
+function ownExportOf(analysis, declarator) {
+  const declaration = analysis.parentOf.get(declarator);
+  const statement = declaration && analysis.parentOf.get(declaration);
+  if (statement?.type !== "ExportNamedDeclaration") return void 0;
+  const id = nodeAt(declarator, "id");
+  return id ? exportNameOf(id) : void 0;
+}
+function isMemberPattern(pattern) {
+  if (pattern.type !== "ObjectPattern") return false;
+  return nodesAt(pattern, "properties").every((property) => {
+    if (property.type !== "Property") return false;
+    if (property.computed === true) return false;
+    const name = propertyNameOf(nodeAt(property, "key"), false);
+    return name !== void 0 && READ_MEMBERS.has(name);
+  });
+}
+function declaredStep(analysis, declarator) {
+  const id = nodeAt(declarator, "id");
+  if (id?.type === "Identifier") {
+    const exportedAs = ownExportOf(analysis, declarator);
+    return { kind: "aliased", id, ...exportedAs !== void 0 && { exportedAs } };
+  }
+  return id && isMemberPattern(id) ? SAFE : UNBOUND;
+}
+function memberStep(analysis, node) {
+  const role = memberRoleOf(analysis, node);
+  if (role === "call") return CALLED;
+  return role === "read" ? SAFE : UNBOUND;
+}
+function exportStep(parent) {
+  if (parent.type === "ExportDefaultDeclaration") return { kind: "exported", name: "default" };
+  const name = exportNameOf(nodeAt(parent, "exported"));
+  return name === void 0 ? UNBOUND : { kind: "exported", name };
+}
+function isHarmlessOperation(analysis, top, parent) {
+  if (parent.type === "BinaryExpression") {
+    return !(parent.operator === "instanceof" && nodeAt(parent, "left") === top);
+  }
+  const tag = analysis.parentOf.get(parent);
+  return !(tag?.type === "TaggedTemplateExpression" && nodeAt(tag, "quasi") === parent);
+}
+function readingStep(analysis, top, parent) {
+  const { type } = parent;
+  if (TESTING_PARENTS.has(type)) return nodeAt(parent, "test") === top ? SAFE : UNBOUND;
+  if (type === "BinaryExpression" || type === "TemplateLiteral") {
+    return isHarmlessOperation(analysis, top, parent) ? SAFE : UNBOUND;
+  }
+  if (type === "SpreadElement" || HARMLESS_PARENTS.has(type)) return SAFE;
+  if (type !== "SequenceExpression") return UNBOUND;
+  return nodesAt(parent, "expressions").at(-1) === top ? stepOf(analysis, parent) : SAFE;
+}
+function stepAbove(analysis, top, parent) {
+  switch (parent.type) {
+    case "CallExpression": {
+      return nodeAt(parent, "callee") === top ? CALLED : UNBOUND;
+    }
+    case "ExportDefaultDeclaration":
+    case "ExportSpecifier": {
+      return exportStep(parent);
+    }
+    case "MemberExpression": {
+      return nodeAt(parent, "object") === top ? memberStep(analysis, parent) : SAFE;
+    }
+    case "VariableDeclarator": {
+      return nodeAt(parent, "init") === top ? declaredStep(analysis, parent) : SAFE;
+    }
+    default: {
+      return readingStep(analysis, top, parent);
+    }
+  }
+}
+function stepOf(analysis, node) {
+  const top = unwrapped(analysis, node);
+  const parent = analysis.parentOf.get(top);
+  return parent ? stepAbove(analysis, top, parent) : UNBOUND;
+}
+function usesOfAlias(analysis, id) {
+  const alias = analysis.bindingDeclaredBy(id);
+  if (!alias) return { isWritten: true, nodes: [] };
+  const uses = analysis.references.filter(({ binding }) => binding === alias);
+  return { isWritten: alias.writes > 0, nodes: uses.map(({ node }) => node) };
+}
+function flowOf(analysis, start) {
+  const names = /* @__PURE__ */ new Set();
+  const state = { isCalled: false, isUnbound: false };
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [start];
+  while (stack.length > 0 && !state.isUnbound) {
+    const node = stack.pop();
+    if (seen.has(node)) continue;
+    seen.add(node);
+    followStep(stepOf(analysis, node), { analysis, names, stack, state });
+  }
+  return { ...state, names };
+}
+function followStep(step, walk) {
+  const { analysis, names, stack, state } = walk;
+  if (step.kind === "aliased") {
+    if (step.exportedAs !== void 0) names.add(step.exportedAs);
+    const alias = usesOfAlias(analysis, step.id);
+    state.isUnbound = alias.isWritten;
+    pushAll(stack, alias.nodes);
+    return;
+  }
+  if (step.kind === "exported") names.add(step.name);
+  state.isCalled ||= step.kind === "called";
+  state.isUnbound ||= step.kind === "unbound";
+}
+
 // src/vite-cx-refuse.ts
 function textOf(reading, node) {
   return reading.code.slice(node.start, node.end);
@@ -431,8 +596,41 @@ function isRenamedReexportOf(reading, expression) {
   return parent?.type === "ExportSpecifier" && exportNameOf(nodeAt(parent, "exported")) !== "cx";
 }
 
+// src/vite-cx-hand-out.ts
+function reexportedAs(reading, expression) {
+  const name = reexportNameOf(reading, expression);
+  return name === void 0 ? void 0 : { exportedAs: [name] };
+}
+function unboundIn(reading, use) {
+  return reading.isDependency === true ? { ...use, isUnboundHandOut: true } : use;
+}
+function handOutOf(reading, expression) {
+  if (reading.isDependency !== true) return {};
+  const flow = flowOf(reading.analysis, expression);
+  if (flow.isUnbound) return { isUnboundHandOut: true };
+  if (flow.names.size === 0) return {};
+  return { exportedAs: [...flow.names], isRenamed: true };
+}
+
+// src/vite-cx-unref.ts
+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;
+  }
+}
+
 // src/vite-cx-reference.ts
-function isCallee(parent, node) {
+function isCallee2(parent, node) {
   return parent?.type === "CallExpression" && nodeAt(parent, "callee") === node;
 }
 function isOnlyRaw(pattern) {
@@ -447,38 +645,37 @@ function 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 };
+  if (isAlias || isCallee2(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 use = namedMemberUse(reading, member, local);
+  const isUnbound = member.computed === true || isMemberWrite(reading.analysis, member);
+  if (!isUnbound || reading.isDependency !== true) return use;
+  return unboundIn(
+    reading,
+    use.kind === "refused" ? use : refused(member, local, `${local} is read with a computed member`)
+  );
+}
+function namedMemberUse(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 };
+    if (parent && isCallee2(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";
+  return otherMemberUse(reading, member, { local, name, isComputed });
 }
-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 otherMemberUse(reading, member, read) {
+  const { isComputed, local, name } = read;
+  const phrase = isComputed ? `${local} is read with a computed member` : `${local}.${name ?? "?"} is not a member the build reads`;
+  const use = refused(member, local, phrase);
+  return unboundIn(reading, use);
 }
 function ancestor(reading, node, levels) {
   let current = node;
@@ -506,7 +703,7 @@ function rawDestructuring(parent, expression, 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 (isCallee2(parent, expression)) return { kind: "call", node: parent, local };
   if (parent.type === "MemberExpression" && nodeAt(parent, "object") === expression) {
     return memberUse(reading, parent, local);
   }
@@ -518,21 +715,16 @@ function useOfExpression(reading, start, 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 exportedAs = reexportedAs(reading, expression);
   return {
-    ...refused(expression, local, phrase),
+    ...refused(expression, local, phraseFor(reading, expression, local)),
     isReexport,
     ...isRenamed && { isRenamed },
-    ...exportedAs
+    ...reexportedAs(reading, expression),
+    ...!isReexport && handOutOf(reading, expression)
   };
 }
-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);
@@ -569,7 +761,9 @@ function namespaceUse(reading, expression, cx) {
   if (isListed && isOtherExport) return void 0;
   const use = refused(expression, local, `${local} is used other than as ${local}.cx`);
   const exportedAs = reexportedAs(reading, expression);
-  return exportedAs ? { ...use, ...exportedAs, isRenamed: true } : use;
+  if (exportedAs) return { ...use, ...exportedAs, isRenamed: true };
+  if (patternDestructuring(reading, expression)) return unboundIn(reading, use);
+  return { ...use, ...handOutOf(reading, expression) };
 }
 function useOf(reading, reference2, cx) {
   if (cx.isNamespace) return namespaceUse(reading, reference2.node, cx);
@@ -580,6 +774,407 @@ function useOf(reading, reference2, cx) {
   return { ...use, isListable: !isDeclaredSource };
 }
 
+// src/vite-cx-take-keys.ts
+var CX_ONLY = /* @__PURE__ */ new Set(["cx"]);
+function isCxName(names, name) {
+  return names === void 0 || names.has(name);
+}
+function patternKeys(pattern, names) {
+  const taken = [];
+  for (const property of nodesAt(pattern, "properties")) {
+    const key = property.type === "Property" ? propertyNameOf(nodeAt(property, "key"), property.computed === true) : void 0;
+    if (key === void 0) return void 0;
+    if (isCxName(names, key)) taken.push(key);
+  }
+  return taken;
+}
+function referenceTakes(analysis, node, names) {
+  const read = memberReadOf({ analysis }, node);
+  if (read) {
+    if (read.key === void 0) return void 0;
+    return isCxName(names, read.key) ? [read.key] : [];
+  }
+  const pattern = patternDestructuring({ analysis }, node);
+  return pattern?.type === "ObjectPattern" ? patternKeys(pattern, names) : void 0;
+}
+function outermost(analysis, node) {
+  let current = node;
+  let parent = analysis.parentOf.get(current);
+  while (parent?.type === "ParenthesizedExpression") {
+    current = parent;
+    parent = analysis.parentOf.get(current);
+  }
+  return current;
+}
+function thenCall(analysis, node) {
+  const member = analysis.parentOf.get(node);
+  if (member?.type !== "MemberExpression" || nodeAt(member, "object") !== node) return void 0;
+  const key = propertyNameOf(nodeAt(member, "property"), member.computed === true);
+  const call = analysis.parentOf.get(member);
+  return key === "then" && call?.type === "CallExpression" && nodeAt(call, "callee") === member ? call : void 0;
+}
+function thenCallback(analysis, node) {
+  const call = thenCall(analysis, node);
+  const callback = call && nodesAt(call, "arguments")[0];
+  const isInline = callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression";
+  return isInline ? callback : void 0;
+}
+function referencesToParameter(analysis, owner, name) {
+  return analysis.references.filter(
+    ({ binding }) => binding?.kind === "param" && binding.owner === owner && binding.name === name
+  );
+}
+function parameterTakes(analysis, callback, names) {
+  const parameter = nodesAt(callback, "params")[0];
+  if (parameter === void 0) return [];
+  if (parameter.type === "ObjectPattern") return patternKeys(parameter, names);
+  const name = parameter.type === "Identifier" ? stringAt(parameter, "name") : void 0;
+  if (name === void 0) return void 0;
+  const found = [];
+  for (const { binding, node } of referencesToParameter(analysis, callback, name)) {
+    const taken = binding?.writes === 0 ? referenceTakes(analysis, node, names) : void 0;
+    if (taken === void 0) return void 0;
+    pushAll(found, taken);
+  }
+  return found;
+}
+function variableTakes(analysis, init, names) {
+  const declarator = analysis.parentOf.get(init);
+  const declaration = declarator && analysis.parentOf.get(declarator);
+  if (declaration && analysis.parentOf.get(declaration)?.type === "ExportNamedDeclaration") {
+    return void 0;
+  }
+  const found = [];
+  for (const { binding, node } of analysis.references) {
+    if (binding?.init !== init) continue;
+    const taken = binding.writes === 0 ? referenceTakes(analysis, node, names) : void 0;
+    if (taken === void 0) return void 0;
+    pushAll(found, taken);
+  }
+  return found;
+}
+function awaitedKeys(analysis, awaited, names) {
+  const declarator = analysis.parentOf.get(awaited);
+  const isVariable = declarator?.type === "VariableDeclarator" && nodeAt(declarator, "init") === awaited && nodeAt(declarator, "id")?.type === "Identifier";
+  return isVariable ? variableTakes(analysis, awaited, names) : referenceTakes(analysis, awaited, names);
+}
+function dynamicKeys(analysis, node, names) {
+  const awaited = analysis.parentOf.get(node);
+  if (awaited?.type === "AwaitExpression") {
+    return awaitedKeys(analysis, outermost(analysis, awaited), names);
+  }
+  const callback = thenCallback(analysis, node);
+  return callback && parameterTakes(analysis, callback, names);
+}
+
+// src/vite-commonjs-exports.ts
+function isName(node, name) {
+  return node?.type === "Identifier" && node.name === name;
+}
+function isModuleExports(node) {
+  if (node?.type !== "MemberExpression" || node.computed === true) return false;
+  return isName(nodeAt(node, "object"), "module") && isName(nodeAt(node, "property"), "exports");
+}
+function isExportsObject(node) {
+  return isName(node, "exports") || isModuleExports(node);
+}
+function memberOf(node) {
+  if (node?.type !== "MemberExpression" || node.computed === true) return void 0;
+  const object = nodeAt(node, "object");
+  const name = exportNameOf(nodeAt(node, "property"));
+  return object === void 0 || name === void 0 ? void 0 : { name, object };
+}
+function exportsMemberOf(node) {
+  const member = memberOf(node);
+  if (!member) return void 0;
+  return isExportsObject(member.object) ? member.name : void 0;
+}
+function statementCallOf(statement) {
+  if (statement.type !== "ExpressionStatement") return void 0;
+  const expression = nodeAt(statement, "expression");
+  return expression?.type === "CallExpression" ? expression : void 0;
+}
+function definePropertyOf(statement) {
+  const call = statementCallOf(statement);
+  const callee = call && memberOf(nodeAt(call, "callee"));
+  if (!call || callee?.name !== "defineProperty" || !isName(callee.object, "Object")) {
+    return void 0;
+  }
+  const [target, key, descriptor] = nodesAt(call, "arguments");
+  return { as: staticStringOf(key), descriptor, target };
+}
+
+// src/vite-commonjs-emits.ts
+function initOf(analysis, name) {
+  const binding = analysis.referenceOf(name)?.binding;
+  return binding?.writes === 0 ? binding.init : void 0;
+}
+function isOwnHelperRead(node) {
+  const member = memberOf(node);
+  return member?.name === "__exportStar" && member.object.type === "ThisExpression";
+}
+function isThisGuard(node) {
+  if (node?.type !== "LogicalExpression" || node.operator !== "&&") return false;
+  return nodeAt(node, "left")?.type === "ThisExpression" && isOwnHelperRead(nodeAt(node, "right"));
+}
+function isOwnHelper(node) {
+  if (node?.type !== "LogicalExpression" || node.operator !== "||") return false;
+  return isThisGuard(nodeAt(node, "left")) && nodeAt(node, "right")?.type === "FunctionExpression";
+}
+function isTslibRequire(node) {
+  if (node?.type !== "CallExpression" || !isName(nodeAt(node, "callee"), "require")) return false;
+  const args = nodesAt(node, "arguments");
+  return args.length === 1 && staticStringOf(args[0]) === "tslib";
+}
+function isTslibMember(callee, analysis) {
+  const member = memberOf(callee);
+  if (member?.object.type !== "Identifier") return false;
+  return isTslibRequire(initOf(analysis, member.object));
+}
+function isExportStarCallee(callee, analysis) {
+  if (isName(callee, "__exportStar")) return isOwnHelper(initOf(analysis, callee));
+  return memberOf(callee)?.name === "__exportStar" && isTslibMember(callee, analysis);
+}
+function exportStarOf(statement, input) {
+  const call = statementCallOf(statement);
+  if (!call) return void 0;
+  const [required, target] = nodesAt(call, "arguments");
+  if (required === void 0 || !input.requires.has(required) || !isExportsObject(target)) {
+    return void 0;
+  }
+  const analysis = input.analysis();
+  const isHelper = !analysis.hasDirectEval && isExportStarCallee(nodeAt(call, "callee"), analysis);
+  return isHelper ? required : void 0;
+}
+function starForwardOf(statement, input) {
+  const required = exportStarOf(statement, input);
+  if (required === void 0) return void 0;
+  const named = input.names?.values().filter((name) => name !== "default").toArray();
+  const takes = named?.length === 0 ? [] : [{ shape: "star", names: [], isForward: true }];
+  return { given: named ?? [], require: required, takes };
+}
+function returnOf(block) {
+  const statements = nodesAt(block, "body");
+  const only = statements.length === 1 ? statements[0] : void 0;
+  return only?.type === "ReturnStatement" ? nodeAt(only, "argument") : void 0;
+}
+function returnedBy(getter) {
+  const isArrow = getter?.type === "ArrowFunctionExpression";
+  if (!getter || !isArrow && getter.type !== "FunctionExpression") return void 0;
+  const body = nodeAt(getter, "body");
+  if (body?.type === "BlockStatement") return returnOf(body);
+  return isArrow ? body : void 0;
+}
+function getterOf(descriptor) {
+  if (descriptor?.type !== "ObjectExpression") return void 0;
+  const property = nodesAt(descriptor, "properties").find((node) => {
+    const isGet = propertyNameOf(nodeAt(node, "key"), node.computed === true) === "get";
+    return node.type === "Property" && isGet;
+  });
+  return property && nodeAt(property, "value");
+}
+function getterReadOf(statement) {
+  const define = definePropertyOf(statement);
+  if (define?.as === void 0 || !isExportsObject(define.target)) return void 0;
+  const member = memberOf(returnedBy(getterOf(define.descriptor)));
+  if (member?.object.type !== "Identifier") return void 0;
+  return { as: define.as, name: member.name, object: member.object };
+}
+function boundForwardOf(require2, reads, context) {
+  const uses = context.analysis.references.filter(({ binding: binding2 }) => binding2?.init === require2);
+  const binding = uses[0]?.binding;
+  if (!binding || binding.writes > 0) return void 0;
+  const read = uses.map(({ node }) => reads.get(node));
+  if (read.includes(void 0)) return void 0;
+  const cx = read.filter((getter) => getter !== void 0 && isCxName(context.names, getter.name));
+  const names = [...new Set(cx.map((getter) => getter.name))];
+  const takes = names.length === 0 ? [] : [{ shape: "names", names, isPassedOn: true, isForward: true }];
+  return { given: cx.map((getter) => getter.as), require: require2, takes };
+}
+function boundForwardsOf(program, input) {
+  const reads = /* @__PURE__ */ new Map();
+  for (const statement of nodesAt(program, "body")) {
+    const read = getterReadOf(statement);
+    if (read) reads.set(read.object, read);
+  }
+  if (reads.size === 0) return [];
+  const analysis = input.analysis();
+  if (analysis.hasDirectEval) return [];
+  const context = { analysis, names: input.names };
+  return [...input.requires].flatMap((require2) => {
+    const forward = boundForwardOf(require2, reads, context);
+    return forward ? [forward] : [];
+  });
+}
+
+// src/vite-require-interop.ts
+var INTEROP_HELPERS = /* @__PURE__ */ new Set([
+  "__importDefault",
+  "__importStar",
+  "__toESM",
+  "_interop_require_default",
+  "_interop_require_wildcard",
+  "_interopRequireDefault",
+  "_interopRequireWildcard"
+]);
+function isInteropCallee(analysis, callee) {
+  if (callee?.type === "Identifier") {
+    const binding = analysis.referenceOf(callee)?.binding;
+    const isDeclared = binding !== void 0 && binding.kind !== "import" && binding.kind !== "param";
+    return INTEROP_HELPERS.has(callee.name) && isDeclared;
+  }
+  const member = memberOf(callee);
+  return member !== void 0 && INTEROP_HELPERS.has(member.name) && isTslibMember(callee, analysis);
+}
+function unwrappedFromInterop(analysis, node) {
+  let current = node;
+  for (; ; ) {
+    const parent = analysis.parentOf.get(current);
+    if (parent?.type === "AwaitExpression") {
+      current = parent;
+      continue;
+    }
+    const args = parent ? nodesAt(parent, "arguments") : [];
+    const isFirstArgument = parent?.type === "CallExpression" && args[0] === current;
+    if (!parent || !isFirstArgument || !isInteropCallee(analysis, nodeAt(parent, "callee"))) {
+      return current;
+    }
+    current = parent;
+  }
+}
+
+// src/vite-require-uses.ts
+var INHERITED_NAMES = /* @__PURE__ */ new Set([
+  ...Object.getOwnPropertyNames(Object.prototype),
+  ...Object.getOwnPropertyNames(Function.prototype)
+]);
+function isExportKey(key) {
+  return key !== void 0 && !INHERITED_NAMES.has(key);
+}
+function isCalled(analysis, node) {
+  const parent = analysis.parentOf.get(node);
+  if (parent?.type === "CallExpression") return nodeAt(parent, "callee") === node;
+  if (parent?.type !== "SequenceExpression") return false;
+  return nodesAt(parent, "expressions").at(-1) === node && isCalled(analysis, parent);
+}
+function isCalledWithReceiver(analysis, member) {
+  return analysis.parentOf.get(member)?.type === "CallExpression";
+}
+function isMemberCall(analysis, node, cxNames) {
+  const member = analysis.parentOf.get(node);
+  if (member?.type !== "MemberExpression" || nodeAt(member, "object") !== node) return false;
+  const key = propertyNameOf(nodeAt(member, "property"), member.computed === true);
+  if (!isExportKey(key) || !isCalled(analysis, member)) return false;
+  return isCxName(cxNames, key) || !isCalledWithReceiver(analysis, member);
+}
+function destructuredNames(pattern) {
+  if (pattern.type !== "ObjectPattern") return void 0;
+  const names = [];
+  for (const property of nodesAt(pattern, "properties")) {
+    const value = nodeAt(property, "value");
+    const key = propertyNameOf(nodeAt(property, "key"), property.computed === true);
+    if (!isExportKey(key) || property.type !== "Property" || value?.type !== "Identifier") {
+      return void 0;
+    }
+    names.push(value.name);
+  }
+  return names;
+}
+function isOnlyUsedAs(analysis, names, isUse) {
+  const matching = analysis.references.filter(
+    ({ binding }) => binding !== void 0 && binding.kind !== "param" && names.includes(binding.name)
+  );
+  return matching.every(({ binding, node }) => binding.writes === 0 && isUse(node));
+}
+function isBoundAndCalled(analysis, input, isUsedAs) {
+  const { cxNames, pattern } = input;
+  if (pattern?.type === "Identifier") {
+    return isUsedAs([pattern.name], (node) => isMemberCall(analysis, node, cxNames));
+  }
+  const names = pattern && destructuredNames(pattern);
+  return names !== void 0 && isUsedAs(names, (node) => isCalled(analysis, node));
+}
+function isExportedDeclarator(analysis, declarator) {
+  const declaration = analysis.parentOf.get(declarator);
+  return declaration !== void 0 && analysis.parentOf.get(declaration)?.type === "ExportNamedDeclaration";
+}
+function isDeclaredAndCalled(analysis, declarator, input) {
+  if (nodeAt(declarator, "init") !== input.top || isExportedDeclarator(analysis, declarator)) {
+    return false;
+  }
+  return isBoundAndCalled(
+    analysis,
+    { cxNames: input.cxNames, pattern: nodeAt(declarator, "id") },
+    (names, isUse) => isOnlyUsedAs(analysis, names, isUse)
+  );
+}
+function isMemberDeclaredAndCalled(analysis, member) {
+  const name = propertyNameOf(nodeAt(member, "property"), member.computed === true);
+  const declarator = analysis.parentOf.get(member);
+  if (!isExportKey(name) || declarator?.type !== "VariableDeclarator") return false;
+  if (isExportedDeclarator(analysis, declarator)) return false;
+  const id = nodeAt(declarator, "id");
+  if (nodeAt(declarator, "init") !== member || id?.type !== "Identifier") return false;
+  return isOnlyUsedAs(analysis, [id.name], (node) => isCalled(analysis, node));
+}
+function isCallbackCalledOnly(analysis, callback, cxNames) {
+  if (callback?.type !== "ArrowFunctionExpression") return false;
+  const parameter = nodesAt(callback, "params")[0];
+  if (!parameter) return true;
+  const isInside = (node) => node.start >= callback.start && node.end <= callback.end;
+  return isBoundAndCalled(
+    analysis,
+    { cxNames, pattern: parameter },
+    (names, isUse) => analysis.references.filter(({ node }) => isInside(node) && names.includes(node.name)).every(({ node }) => isUse(node))
+  );
+}
+function isPromiseUsedAsCallsOnly(analysis, promise, cxNames) {
+  const member = analysis.parentOf.get(promise);
+  if (member?.type === "ExpressionStatement") return true;
+  if (member?.type !== "MemberExpression" || nodeAt(member, "object") !== promise) return false;
+  const name = propertyNameOf(nodeAt(member, "property"), member.computed === true);
+  const call = analysis.parentOf.get(member);
+  if (name !== "then" || call?.type !== "CallExpression" || nodeAt(call, "callee") !== member) {
+    return false;
+  }
+  return isCallbackCalledOnly(analysis, nodesAt(call, "arguments")[0], cxNames);
+}
+function isAwaitedUpTo(analysis, node, top) {
+  let current = node;
+  while (current && current !== top) {
+    current = analysis.parentOf.get(current);
+    if (current?.type === "AwaitExpression") return true;
+  }
+  return false;
+}
+function isResultUsedAsCallsOnly(analysis, top, cxNames) {
+  const parent = analysis.parentOf.get(top);
+  if (parent?.type === "ExpressionStatement") return true;
+  if (parent?.type === "MemberExpression") {
+    return isMemberCall(analysis, top, cxNames) || isMemberDeclaredAndCalled(analysis, parent);
+  }
+  return parent?.type === "VariableDeclarator" && isDeclaredAndCalled(analysis, parent, { cxNames, top });
+}
+function isEqualsDeclaredAndCalled(analysis, declaration, cxNames) {
+  if (analysis.parentOf.get(declaration)?.type === "ExportNamedDeclaration") return false;
+  return isBoundAndCalled(
+    analysis,
+    { cxNames, pattern: nodeAt(declaration, "id") },
+    (names, isUse) => isOnlyUsedAs(analysis, names, isUse)
+  );
+}
+function isUsedAsCallsOnly(analysis, require2, cxNames) {
+  if (analysis.hasDirectEval) return false;
+  if (require2.type === "TSImportEqualsDeclaration") {
+    return isEqualsDeclaredAndCalled(analysis, require2, cxNames);
+  }
+  const top = unwrappedFromInterop(analysis, require2);
+  if (require2.type === "ImportExpression" && !isAwaitedUpTo(analysis, require2, top)) {
+    return isPromiseUsedAsCallsOnly(analysis, top, cxNames);
+  }
+  return isResultUsedAsCallsOnly(analysis, top, cxNames);
+}
+
 // 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.";
@@ -615,23 +1210,31 @@ function reexportProblem(code, node, isListed) {
     exportedAs: exportedNamesOf(node)
   };
 }
-function sourceFormProblem(code, node, options) {
+function dynamicImportProblem(code, node, options, analysis) {
+  const isHandedOut2 = options.isDependency === true && !isUsedAsCallsOnly(analysis, node, CX_ONLY);
+  return {
+    kind: "reference",
+    offset: node.start,
+    construct: code.slice(node.start, node.end),
+    text: DYNAMIC_IMPORT_TEXT,
+    ...isHandedOut2 && { isUnboundHandOut: true }
+  };
+}
+function sourceFormProblem(code, node, options, analysis) {
   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 (isTypeOnly(node) || 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 };
+  return node.type === "ImportExpression" ? dynamicImportProblem(code, node, options, analysis) : void 0;
 }
-function sourceFormProblems(code, program, options) {
+function sourceFormProblems(code, program, options, analysis) {
   const problems = [];
   const stack = [program];
   while (stack.length > 0) {
     const node = stack.pop();
-    const problem2 = sourceFormProblem(code, node, options);
+    const problem2 = sourceFormProblem(code, node, options, analysis);
     if (problem2) problems.push(problem2);
     pushAll(stack, childrenOf(node));
   }
@@ -1525,6 +2128,7 @@ function declarePattern(pattern, spec, scope, walker) {
     if (spec.owner) binding.owner = spec.owner;
     const declared = declare(into, binding, isAssigning);
     if (spec.init) declared.init = spec.init;
+    walker.declarations.set(pattern, declared);
     return;
   }
   DECLARE[pattern.type]?.(pattern, spec, scope, walker);
@@ -1758,6 +2362,10 @@ var HANDLERS = {
   ImportDeclaration: (node, scope) => {
     declareImport(node, scope);
   },
+  TSImportEqualsDeclaration: (node, scope, walker) => {
+    if (!isTypeOnly(node)) declarePattern(nodeAt(node, "id"), { kind: "const" }, scope, walker);
+    visitKeys(node, ["moduleReference"], scope, walker);
+  },
   ExportNamedDeclaration: visitExport,
   VariableDeclaration: visitDeclaration,
   FunctionDeclaration: (node, scope, walker) => {
@@ -1833,6 +2441,7 @@ function analyze(program) {
   const walker = {
     references: [],
     parentOf: /* @__PURE__ */ new Map(),
+    declarations: /* @__PURE__ */ new Map(),
     evalScopes: [],
     visit: (node, scope) => {
       visit(node, scope, walker);
@@ -1854,7 +2463,8 @@ function analyze(program) {
     hasDirectEval: evalScopes.length > 0,
     references: walker.references,
     parentOf: walker.parentOf,
-    referenceOf: (node) => byNode.get(node)
+    referenceOf: (node) => byNode.get(node),
+    bindingDeclaredBy: (node) => walker.declarations.get(node)
   };
 }
 
@@ -1977,7 +2587,8 @@ function refusedProblem(reading, use) {
     text: `${use.phrase ?? ""}.`,
     ...use.isReexport && { isListable: use.isListable },
     ...use.isRenamed === true && { isRenamed: true },
-    ...use.exportedAs && { exportedAs: use.exportedAs }
+    ...use.exportedAs && { exportedAs: use.exportedAs },
+    ...use.isUnboundHandOut === true && { isUnboundHandOut: true }
   };
 }
 function readUse(reading, use, analysis) {
@@ -2018,7 +2629,8 @@ function readUses(reading, program) {
     analysis,
     code,
     allowsExposure: options.isVueScript === true,
-    declaredSources: options.declaredSources
+    declaredSources: options.declaredSources,
+    isDependency: options.isDependency
   };
   for (const reference2 of analysis.references) {
     const cx = reference2.binding && bindings.get(reference2.binding);
@@ -2060,7 +2672,7 @@ function readModule(code, program, options) {
     cxSources: options.cxSources,
     declaredSources: options.declaredSources ?? /* @__PURE__ */ new Set()
   }) : [];
-  for (const problem2 of [...sourceFormProblems(code, program, options), ...listed]) {
+  for (const problem2 of [...sourceFormProblems(code, program, options, analysis), ...listed]) {
     report(reading, problem2);
   }
   for (const atom of atomsWrittenIn(code)) result.classes.add(atom);
@@ -2437,10 +3049,198 @@ function unprunedAtoms(css, emitted) {
   return [...atoms].toSorted((a, b) => a.localeCompare(b));
 }
 
-// src/vite-restorers.ts
-function withRestorers(atoms) {
-  if (atoms.has("srOnly")) atoms.add("srOnlyFocusable");
-  return atoms;
+// src/vite-css-id.ts
+var STYLESHEET = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+var SPECIAL_QUERY = /[?&](?:worker|sharedworker|raw|url)\b/;
+var CSS_MODULE = /\.module\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+var TEXT_QUERY = /[?&](?:inline|direct|transform-only)\b/;
+function isStylesheetPath(id) {
+  return STYLESHEET.test(id);
+}
+function isStylesheetId(id) {
+  return STYLESHEET.test(id) && !SPECIAL_QUERY.test(id);
+}
+function isCssModuleId(id) {
+  return isStylesheetId(id) && CSS_MODULE.test(id) && !TEXT_QUERY.test(id);
+}
+function isUnreadStylesheet(id) {
+  return isStylesheetId(id) && !isCssModuleId(id);
+}
+function canHoldDirective(code) {
+  return /@[n\\]/i.test(code);
+}
+function filePathOf(id) {
+  const query = id.indexOf("?");
+  return query === -1 ? id : id.slice(0, query);
+}
+
+// src/vite-cx-text-test.ts
+function literalPattern(text) {
+  return text.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
+}
+var INSIDE = String.raw`[^\n'"\x60\\]{0,512}`;
+var EXTENSION = String.raw`\.[^\n'"\x60\\/?#.]*`;
+var QUOTE = String.raw`['"\x60]`;
+function textTestOf(names) {
+  if (names.size === 0) return void 0;
+  const listed = [...names].map((name) => literalPattern(name)).join("|");
+  const named = `${QUOTE}(?:${INSIDE}/)?(?:${listed})(?:${EXTENSION})?/*(?:[?#]${INSIDE})?${QUOTE}`;
+  const directory = String.raw`(?:\bfrom|\bimport)\s*(?:\(\s*)?${QUOTE}\.{1,2}(?:/\.{1,2})*/?${QUOTE}`;
+  return new RegExp(names.has("index") ? `${named}|${directory}` : named);
+}
+
+// src/vite-path-text.ts
+function baseNameOf(file) {
+  let end = file.length;
+  while (end > 1 && file[end - 1] === "/") end -= 1;
+  const start = file.lastIndexOf("/", end - 1) + 1;
+  return file.slice(start, end);
+}
+function extensionOf(file) {
+  const segment = baseNameOf(file);
+  const dot = segment.lastIndexOf(".");
+  return segment === ".." || dot <= 0 ? "" : segment.slice(dot);
+}
+function stemOf(file) {
+  const segment = baseNameOf(file);
+  const extension = extensionOf(file);
+  return extension === "" || extension === segment ? segment : segment.slice(0, -extension.length);
+}
+function directoryOf(file) {
+  let end = file.length;
+  while (end > 1 && file[end - 1] === "/") end -= 1;
+  const slash = file.lastIndexOf("/", end - 1);
+  if (slash === -1) return ".";
+  let cut2 = slash;
+  while (cut2 > 1 && file[cut2 - 1] === "/") cut2 -= 1;
+  return file.slice(0, cut2 === 0 ? 1 : cut2);
+}
+function rootEntryOf(root) {
+  let end = root.length;
+  while (end > 0 && (root[end - 1] === "/" || root[end - 1] === "\\")) end -= 1;
+  return `${root.slice(0, end)}/index.html`;
+}
+
+// src/vite-cx-modules.ts
+function isRelative(text) {
+  const cut2 = text.search(/[#?]/);
+  const path = cut2 === -1 ? text : text.slice(0, cut2);
+  return path === "." || path === ".." || path.startsWith("./") || path.startsWith("../");
+}
+function fileOf(id) {
+  return filePathOf(id).replaceAll("\\", "/");
+}
+function namesOf(file) {
+  const name = stemOf(file);
+  return name === "index" ? [name, baseNameOf(directoryOf(file))] : [name];
+}
+function entriesNaming(declared, id) {
+  const file = fileOf(id);
+  return declared.ids.entries().filter(([, resolved]) => fileOf(resolved) === file).map(([entry]) => entry).toArray();
+}
+async function declaredModulesFor(context, resolver, environment) {
+  const { cxModules } = context.options;
+  if (cxModules.length === 0) return void 0;
+  const known = context.state.declared.get(environment);
+  if (known) return known;
+  const made = resolveEntries(context, resolver);
+  context.state.declared.set(environment, made);
+  return made;
+}
+async function resolveOrNull(resolver, source, importer) {
+  try {
+    return await resolver.resolve?.(source, importer) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveEntries(context, resolver) {
+  const from = rootEntryOf(context.root);
+  const nave = await resolveOrNull(resolver, CX_SOURCE, from);
+  const naveFile = nave === void 0 ? void 0 : fileOf(nave.id);
+  const resolved = await Promise.all(
+    context.options.cxModules.map(async (entry) => {
+      const found = await resolveOrNull(resolver, entry, from);
+      return [entry, found?.id];
+    })
+  );
+  const kept = resolved.filter(
+    ([entry, id]) => entry !== CX_SOURCE && (id === void 0 || fileOf(id) !== naveFile)
+  );
+  const ids = new Map(kept.filter((pair) => pair[1] !== void 0));
+  const files = new Set(ids.values().map((id) => fileOf(id)));
+  const names = new Set(files.values().flatMap((file) => namesOf(file)));
+  return {
+    entries: new Set(kept.map(([entry]) => entry).filter((entry) => !isRelative(entry))),
+    ids,
+    files,
+    names,
+    textTest: textTestOf(names)
+  };
+}
+function forgetDeclared(state, environment) {
+  state.declared.delete(environment);
+  const prefix = `${environment}\0`;
+  for (const key of state.recognised.keys())
+    if (key.startsWith(prefix)) state.recognised.delete(key);
+}
+function withoutTrailingSlashes(text) {
+  let end = text.length;
+  while (end > 0 && text[end - 1] === "/") end -= 1;
+  return text.slice(0, end);
+}
+function lastSegmentOf(specifier) {
+  const cut2 = specifier.slice(1).search(/[#?]/);
+  const bare = withoutTrailingSlashes(cut2 === -1 ? specifier : specifier.slice(0, cut2 + 1));
+  const segment = bare.slice(bare.lastIndexOf("/") + 1);
+  return segment === "." || segment === ".." ? "index" : segment;
+}
+function isNamingListed(specifier, declared) {
+  const segment = lastSegmentOf(specifier);
+  if (declared.names.has(segment)) return true;
+  const extension = extensionOf(segment);
+  return extension !== "" && declared.names.has(segment.slice(0, -extension.length));
+}
+function isAboutListed(input, declared) {
+  if (!declared) return false;
+  return isListedFile(declared, input.id) || isMentioningDeclared(input.code, declared);
+}
+function isListedFile(declared, id) {
+  return declared.files.has(fileOf(id));
+}
+function isMentioningDeclared(code, declared) {
+  for (const entry of declared.entries) if (code.includes(entry)) return true;
+  return declared.textTest?.test(code) ?? false;
+}
+function recognisedKey(environment, file, importer) {
+  return `${environment}\0${file}\0${importer}`;
+}
+
+// src/vite-declared-echoes.ts
+var ECHO_KINDS = /* @__PURE__ */ new Set([
+  "argument",
+  "dynamic",
+  "own",
+  "reference",
+  "unknown"
+]);
+function withoutEchoes(modules) {
+  const broken = new Set(
+    modules.flatMap(
+      (module) => module.problems.flatMap(
+        (problem2) => problem2.kind === "declared" && problem2.moduleId !== void 0 && !problem2.hasNaveCx ? [fileOf(problem2.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
+  );
+}
+
+// src/vite-module-id.ts
+function isDependencyId(id) {
+  return filePathOf(id).replaceAll("\\", "/").includes("/node_modules/");
 }
 
 // src/vite-problems.ts
@@ -2469,6 +3269,43 @@ function cut(text, limit = 40) {
   return oneLine.length > limit ? `${oneLine.slice(0, limit)}...` : oneLine;
 }
 
+// src/vite-takes-host.ts
+function parseOf(host, code, id) {
+  return host.parseModule ? host.parseModule(code, id) : host.parse?.(code);
+}
+async function resolvedIds(host, source, importer) {
+  if (host.resolveAll) return await host.resolveAll(source, importer);
+  const resolved = await host.resolve?.(source, importer);
+  return resolved ? [resolved.id] : [];
+}
+
+// src/vite-specifiers.ts
+function isTypeOnlyDeclaration(node) {
+  if (isTypeOnly(node)) return true;
+  return nodesAt(node, "specifiers").length > 0 && valueSpecifiersOf(node).length === 0;
+}
+function specifiersIn(program) {
+  const found = /* @__PURE__ */ new Map();
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const where = isTypeOnlyDeclaration(node) ? void 0 : nodeAt(node, "source");
+    const source = staticStringOf(where);
+    if (where !== void 0 && source !== void 0) {
+      found.set(source, Math.min(found.get(source) ?? Infinity, where.start));
+    }
+    pushAll(stack, childrenOf(node));
+  }
+  return [...found].toSorted(([, a], [, b]) => a - b).map(([source]) => source);
+}
+function specifiersOf(host, importer) {
+  try {
+    return specifiersIn(parseOf(host, importer.code, importer.id));
+  } catch {
+    return void 0;
+  }
+}
+
 // src/vite-class-map-message.ts
 var CLASS_MAP_NOT_PARSED = "the module could not be read, so the atoms it names would not ship: it is a CSS Module, and the JavaScript Vite wrote for its class map did not parse. A plugin that runs after Vite's CSS step has changed that JavaScript: have that plugin leave a CSS Module's JavaScript valid.";
 
@@ -2513,10 +3350,11 @@ function clausesOf(takes) {
   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) {
+function takenLine(pkg, takes, input) {
   const { files, listed, whole } = clausesOf(takes);
+  const { hasPackageFix, rootName } = input;
   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}`;
+  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 ${rootName}, 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);
@@ -2537,6 +3375,12 @@ function isRenamedOrReached(problem2) {
 function isSecondHop(problem2) {
   return problem2.kind === "reexport" && problem2.isListable === false && problem2.pkg !== void 0;
 }
+function isHandedOut(problem2) {
+  return problem2.kind === "reference" && problem2.isRenamed === true && problem2.exportedAs !== void 0;
+}
+function handedOutClause(pkg) {
+  return ` ${pkg} also gives cx out under another name, and the build does not read calls made through it: where your code imports it from ${pkg} or one of its subpaths, import cx from @navecss/core/cx instead and call cx in its place.`;
+}
 function callsLine(pkg, problems, entry) {
   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.`;
@@ -2547,8 +3391,20 @@ function callsLine(pkg, problems, entry) {
     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 ${entry}.`;
   }
-  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 ${entry}. The lasting fix is the package's: names chosen at run time go through cx.dynamic().`;
+  const handedOut = problems.some((problem2) => isHandedOut(problem2)) ? handedOutClause(pkg) : "";
+  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 ${entry}. The lasting fix is the package's: names chosen at run time go through cx.dynamic().${handedOut}`;
+}
+function heldLine(pkg, held2, everyAtom) {
+  const formOf = (problem2) => {
+    const sentence = problem2.text.replace(/\.(\s.*)?$/su, "");
+    return problem2.construct === "" ? sentence : `${cut(problem2.construct)}: ${sentence}`;
+  };
+  const places = [
+    ...new Set(held2.map((problem2) => `${problem2.file} (${formOf(problem2)})`))
+  ].toSorted(compareText);
+  return `${pkg} uses cx in ${places.join(", ")}. From there the build cannot tell whether a call of your code goes through it, and the keepFor entry does not stand in for that, so the build fails whenever these files are part of it, whatever your code takes from ${pkg}. The fix is the package's, in a release of it or a patched copy: export it by name from an ES module, as in export { cx as cn } from '@navecss/core/cx', which the build then checks wherever your code takes it. Until then, ship every atom: ${everyAtom}`;
 }
+var EVERY_ATOM = 'see "Which atoms the build ships" in node_modules/@navecss/core/README.md.';
 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, home) {
   const array = cxModulesArray(configured, specifiers);
@@ -2596,7 +3452,8 @@ function takeLines(pkg, all, home) {
   const lines = [];
   if (takes.length > 0) {
     const hasPackageFix = plain.some((problem2) => isRenamedOrReached(problem2)) || takes.some((take) => take.isReached);
-    lines.push(takenLine(pkg, takes, hasPackageFix));
+    const rootName = plain.find((problem2) => problem2.rootName !== void 0)?.rootName;
+    lines.push(takenLine(pkg, takes, { hasPackageFix, rootName: rootName ?? "the project root" }));
   }
   if (hops.length > 0)
     lines.push(
@@ -2610,9 +3467,12 @@ function takeLines(pkg, all, home) {
     lines.push(callsThroughLine(pkg, [...new Set(callers)].toSorted(compareText), home));
   return lines;
 }
-function packageLines(pkg, all, configured, home) {
+function packageLines(pkg, all, configured, places) {
+  const { home, everyAtom } = places;
   const isTaken = (problem2) => (problem2.takes?.length ?? 0) > 0;
-  const problems = all.filter((problem2) => !isTaken(problem2) && problem2.callers === void 0);
+  const kept = all.filter((problem2) => !isTaken(problem2) && problem2.callers === void 0);
+  const held2 = kept.filter((problem2) => problem2.isHeld === true);
+  const problems = kept.filter((problem2) => problem2.isHeld !== true);
   const entry = `${home}: keepFor: { '${pkg}': ['<atom>'] }`;
   const reexports = problems.filter((problem2) => isListableReexport(problem2));
   const internal = reexports.filter(
@@ -2632,6 +3492,7 @@ function packageLines(pkg, all, configured, home) {
     lines.push(declaredLine(pkg, entries.toSorted(compareText), internal.length > 0, home));
   }
   if (rest.length > 0) lines.push(callsLine(pkg, rest, entry));
+  if (held2.length > 0) lines.push(heldLine(pkg, held2, everyAtom));
   const listed = named.length > 0 ? listedLine(pkg, named, configured, home) : void 0;
   if (listed !== void 0) lines.push(listed);
   if (internal.length > 0) {
@@ -2647,6 +3508,951 @@ function packageLines(pkg, all, configured, home) {
   return lines;
 }
 
+// src/vite-dependency-reexports.ts
+async function isResolvingTo(ctx, input) {
+  try {
+    const resolved = await resolvedIds(ctx, input.specifier, input.from);
+    return resolved.some((id) => fileOf(id) === input.file);
+  } catch {
+    return false;
+  }
+}
+function importersOf(ctx, id) {
+  const info = ctx.getModuleInfo?.(id);
+  return [.../* @__PURE__ */ new Set([...info?.importers ?? [], ...info?.dynamicImporters ?? []])];
+}
+async function specifiersWritten(ctx, input) {
+  const { file, importer } = input;
+  const code = ctx.getModuleInfo?.(importer)?.code;
+  if (code === null || code === void 0) return [];
+  const written = specifiersOf(ctx, { id: importer, code }) ?? [];
+  const found = [];
+  for (const specifier of written) {
+    if (await isResolvingTo(ctx, { file, from: importer, specifier })) found.push(specifier);
+  }
+  return found;
+}
+async function specifiersInto(ctx, context, input) {
+  const found = /* @__PURE__ */ new Set();
+  for (const importer of importersOf(ctx, input.id)) {
+    const owner = isDependencyId(importer) ? await context.packageOf(importer) : void 0;
+    if (owner === input.pkg) continue;
+    const written = await specifiersWritten(ctx, { file: fileOf(input.id), importer });
+    for (const specifier of written) found.add(specifier);
+  }
+  return found.values().toArray().toSorted(compareText);
+}
+async function clearingSpecifier(ctx, context, input) {
+  const from = rootEntryOf(context.root);
+  const file = fileOf(input.id);
+  if (await isResolvingTo(ctx, { file, from, specifier: input.pkg })) return input.pkg;
+  const specifiers = await specifiersInto(ctx, context, input);
+  for (const specifier of specifiers) {
+    if (await isResolvingTo(ctx, { file, from, specifier })) return specifier;
+  }
+  return void 0;
+}
+async function withClearingSpecifiers(ctx, context, problems) {
+  const asked = /* @__PURE__ */ new Map();
+  const clearing = (pkg, id) => {
+    const known = asked.get(id);
+    if (known) return known;
+    const answer = clearingSpecifier(ctx, context, { id, pkg });
+    asked.set(id, answer);
+    return answer;
+  };
+  const entriesOf = async (id) => {
+    const declared = await declaredModulesFor(context, ctx, ctx.environment.name);
+    return declared ? entriesNaming(declared, id) : [];
+  };
+  const renamed = new Set(
+    problems.flatMap(
+      (problem2) => problem2.isRenamed === true && problem2.moduleId !== void 0 ? [problem2.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 };
+      const specifier = await clearing(pkg, moduleId);
+      return specifier === void 0 ? problem2 : { ...problem2, specifier };
+    })
+  );
+}
+
+// src/vite-cx-reexported.ts
+function declaredNames2(pattern) {
+  const found = [];
+  const stack = pattern ? [pattern] : [];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "Identifier") {
+      found.push(stringAt(node, "name") ?? "");
+    } else if (node.type === "AssignmentPattern") {
+      pushAll(
+        stack,
+        [nodeAt(node, "left")].filter((part) => part !== void 0)
+      );
+    } else {
+      const single = ["argument", "value"].map((key) => nodeAt(node, key));
+      const lists = ["properties", "elements"].flatMap((key) => nodesAt(node, key));
+      pushAll(
+        stack,
+        single.filter((part) => part !== void 0)
+      );
+      pushAll(stack, lists);
+    }
+  }
+  return found;
+}
+function ownExports(program) {
+  const found = /* @__PURE__ */ new Set();
+  for (const statement of nodesAt(program, "body")) {
+    const namespace = statement.type === "ExportAllDeclaration" ? exportNameOf(nodeAt(statement, "exported")) : void 0;
+    if (namespace !== void 0) found.add(namespace);
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    const declaration = nodeAt(statement, "declaration");
+    const declared = nodesAt(declaration ?? statement, "declarations").flatMap(
+      (declarator) => declaredNames2(nodeAt(declarator, "id"))
+    );
+    for (const name of [...declared, ...declaredNames2(declaration && nodeAt(declaration, "id"))]) {
+      found.add(name);
+    }
+    for (const specifier of nodesAt(statement, "specifiers")) {
+      const name = exportNameOf(nodeAt(specifier, "exported"));
+      if (name !== void 0) found.add(name);
+    }
+  }
+  return found;
+}
+function exportedBy(node, source, own) {
+  const from = staticStringOf(nodeAt(node, "source"));
+  if (from === void 0 || !source.reaches.has(from)) return [];
+  if (node.type === "ExportAllDeclaration") {
+    const namespace = exportNameOf(nodeAt(node, "exported"));
+    if (namespace !== void 0) return [namespace];
+    return source.names.values().filter((name) => name !== "default" && !own.has(name) && !source.rivals.has(name)).toArray();
+  }
+  return nodesAt(node, "specifiers").flatMap((specifier) => {
+    const local = exportNameOf(nodeAt(specifier, "local"));
+    const exported = exportNameOf(nodeAt(specifier, "exported"));
+    return local !== void 0 && exported !== void 0 && source.names.has(local) ? [exported] : [];
+  });
+}
+function isImportedFrom(binding, source) {
+  if (binding?.kind !== "import" || binding.source === void 0) return false;
+  if (!source.reaches.has(binding.source)) return false;
+  return binding.imported === "*" || source.names.has(binding.imported ?? "");
+}
+function starSources(program) {
+  return nodesAt(program, "body").flatMap((statement) => {
+    const source = staticStringOf(nodeAt(statement, "source"));
+    const isStar = statement.type === "ExportAllDeclaration" && !nodeAt(statement, "exported");
+    return isStar && source !== void 0 ? [source] : [];
+  });
+}
+function reexportedNames(program, source) {
+  const found = /* @__PURE__ */ new Set();
+  const own = ownExports(program);
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
+      for (const name of exportedBy(node, source, own)) found.add(name);
+    }
+    pushAll(stack, childrenOf(node));
+  }
+  const analysis = analyze(program);
+  for (const reference2 of analysis.references) {
+    if (!isImportedFrom(reference2.binding, source)) continue;
+    for (const name of flowOf(analysis, reference2.node).names) found.add(name);
+  }
+  return [...found];
+}
+
+// src/vite-cx-star-exports.ts
+function resolvedFiles(ctx, resolutions, input) {
+  const key = `${input.id}\0${input.specifier}`;
+  const known = resolutions.get(key);
+  if (known) return known;
+  const asked = (async () => {
+    try {
+      const ids = await resolvedIds(ctx, input.specifier, input.id);
+      return ids.map((id) => fileOf(id));
+    } catch {
+      return [];
+    }
+  })();
+  resolutions.set(key, asked);
+  return asked;
+}
+function ownNamesOf(program, file, cxExports) {
+  const found = { names: ownExports(program), cx: /* @__PURE__ */ new Set() };
+  for (const name of found.names) {
+    if (cxExports.get(file)?.has(name)) found.cx.add(name);
+  }
+  return found;
+}
+function unreadProgram(ctx, input) {
+  const { file, seen } = input;
+  const code = ctx.getModuleInfo?.(file)?.code;
+  const isUnread = !seen.has(file) && typeof code === "string";
+  seen.add(file);
+  return isUnread ? parseOf(ctx, code, file) : void 0;
+}
+function addBelow(found, belows) {
+  for (const below of belows) {
+    for (const name of below.cx) {
+      found.names.add(name);
+      found.cx.add(name);
+    }
+  }
+  const first2 = belows.at(0)?.names ?? /* @__PURE__ */ new Set();
+  for (const name of first2) {
+    if (belows.every((below) => below.names.has(name))) found.names.add(name);
+  }
+}
+function rivalsIn(exported) {
+  return new Set([...exported.names].filter((name) => !exported.cx.has(name)));
+}
+async function addStars(ctx, input) {
+  const { found, file, program, walk } = input;
+  for (const specifier of starSources(program)) {
+    const stars = await resolvedFiles(ctx, walk.resolutions, { id: file, specifier });
+    const belows = [];
+    for (const star of stars) {
+      const branch = stars.length > 1 ? { ...walk, seen: new Set(walk.seen) } : walk;
+      belows.push(await exportsOf(ctx, { file: star, walk: branch }));
+    }
+    addBelow(found, belows);
+  }
+}
+async function exportsOf(ctx, input) {
+  const { file, walk } = input;
+  const program = unreadProgram(ctx, { file, seen: walk.seen });
+  if (!program) return { names: /* @__PURE__ */ new Set(), cx: /* @__PURE__ */ new Set() };
+  const found = ownNamesOf(program, file, walk.cxExports);
+  await addStars(ctx, { found, file, program, walk });
+  return found;
+}
+async function rivalsOf(ctx, input) {
+  const { cxExports, id, program, reaches, resolutions } = input;
+  const rivals = /* @__PURE__ */ new Set();
+  const others = starSources(program).filter((text) => !reaches.has(text));
+  for (const specifier of others) {
+    const files = await resolvedFiles(ctx, resolutions, { id, specifier });
+    const rivalsPerFile = [];
+    for (const file of files) {
+      const walk = { cxExports, resolutions, seen: /* @__PURE__ */ new Set() };
+      rivalsPerFile.push(rivalsIn(await exportsOf(ctx, { file, walk })));
+    }
+    const [first2 = /* @__PURE__ */ new Set()] = rivalsPerFile;
+    for (const name of first2) {
+      if (rivalsPerFile.every((found) => found.has(name))) rivals.add(name);
+    }
+  }
+  return rivals;
+}
+
+// src/vite-require-takes.ts
+var WHOLE = { shape: "unreadable", names: [] };
+function held(specifier) {
+  return {
+    ...WHOLE,
+    isHeld: true,
+    form: `requires ${specifier} and uses what it returns where the build cannot follow it`
+  };
+}
+function isCreateRequireCall(node) {
+  if (node?.type !== "CallExpression") return false;
+  const callee = nodeAt(node, "callee");
+  if (isName(callee, "createRequire")) return true;
+  return callee?.type === "MemberExpression" && isName(nodeAt(callee, "property"), "createRequire");
+}
+function nodesIn(program) {
+  const found = [];
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    found.push(node);
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+function requireNamesIn(nodes) {
+  const names = /* @__PURE__ */ new Set(["require"]);
+  for (const node of nodes) {
+    const id = nodeAt(node, "id");
+    if (node.type !== "VariableDeclarator" || id?.type !== "Identifier") continue;
+    if (isCreateRequireCall(nodeAt(node, "init"))) names.add(id.name);
+  }
+  return names;
+}
+function equalsSpecifierOf(node) {
+  const reference2 = nodeAt(node, "moduleReference");
+  if (node.importKind === "type" || reference2?.type !== "TSExternalModuleReference") {
+    return void 0;
+  }
+  return staticStringOf(nodeAt(reference2, "expression"));
+}
+function isRequireCallee(callee, requireNames) {
+  if (callee?.type === "Identifier") return requireNames.has(callee.name);
+  return isCreateRequireCall(callee);
+}
+function requiredBy(node, requireNames) {
+  if (node.type === "TSImportEqualsDeclaration") return equalsSpecifierOf(node);
+  if (node.type !== "CallExpression") return void 0;
+  const args = nodesAt(node, "arguments");
+  const isRequire = isRequireCallee(nodeAt(node, "callee"), requireNames);
+  return isRequire && args.length === 1 ? staticStringOf(args[0]) : void 0;
+}
+function requireCallsOf(program) {
+  const nodes = nodesIn(program);
+  const requireNames = requireNamesIn(nodes);
+  return nodes.flatMap((node) => {
+    const specifier = requiredBy(node, requireNames);
+    return specifier === void 0 ? [] : [{ node, specifier }];
+  });
+}
+function requireSpecifiersIn(program) {
+  return [...new Set(requireCallsOf(program).map(({ specifier }) => specifier))];
+}
+function assignmentOf(statement) {
+  if (statement.type !== "ExpressionStatement") return void 0;
+  const expression = nodeAt(statement, "expression");
+  if (expression?.type !== "AssignmentExpression" || expression.operator !== "=") return void 0;
+  return { left: nodeAt(expression, "left"), right: nodeAt(expression, "right") };
+}
+function wholeForwardOf(left, right, input) {
+  if (right === void 0 || !input.requires.has(right) || !isModuleExports(left)) return void 0;
+  const given = input.names === void 0 ? [] : input.names.values().toArray();
+  return { given, require: right, takes: [{ shape: "star", names: [], isForward: true }] };
+}
+function memberForwardOf(left, right, input) {
+  const as = exportsMemberOf(left);
+  const member = memberOf(right);
+  if (as === void 0 || !member || !input.requires.has(member.object)) return void 0;
+  if (!isCxName(input.names, member.name)) return void 0;
+  const taken = { shape: "names", names: [member.name], isPassedOn: true, isForward: true };
+  return { given: [as], require: member.object, takes: [taken] };
+}
+function forwardOf(statement, input) {
+  const assignment = assignmentOf(statement);
+  if (!assignment) return starForwardOf(statement, input);
+  const { left, right } = assignment;
+  return wholeForwardOf(left, right, input) ?? memberForwardOf(left, right, input);
+}
+function isMarkerWrite(statement) {
+  const assignment = assignmentOf(statement);
+  if (assignment) return exportsMemberOf(assignment.left) === "__esModule";
+  const define = definePropertyOf(statement);
+  return define !== void 0 && isExportsObject(define.target) && define.as === "__esModule";
+}
+function isMarkedEsModule(program) {
+  return nodesAt(program, "body").some((statement) => isMarkerWrite(statement));
+}
+function forwardsIn(program, input) {
+  const written = nodesAt(program, "body").flatMap((statement) => {
+    const forward = forwardOf(statement, input);
+    return forward ? [forward] : [];
+  });
+  return [...written, ...boundForwardsOf(program, input)];
+}
+function requireTakesIn(program, input) {
+  const requires = requireCallsOf(program).filter(({ specifier }) => input.reaches.has(specifier));
+  if (requires.length === 0) return { given: [], takes: [] };
+  let analysis;
+  const forwardInput = {
+    analysis: () => analysis ??= analyze(program),
+    names: input.names,
+    requires: new Set(requires.map(({ node }) => node))
+  };
+  const forwards = input.readsForwards ? forwardsIn(program, forwardInput) : [];
+  const forwarded = new Set(forwards.map((forward) => forward.require));
+  const takes = forwards.flatMap((forward) => forward.takes);
+  const others = requires.filter(({ node }) => !forwarded.has(node));
+  if (input.readsForwards) {
+    const analysisOf = forwardInput.analysis();
+    for (const { node, specifier } of others) {
+      takes.push(isUsedAsCallsOnly(analysisOf, node, input.names) ? WHOLE : held(specifier));
+    }
+  } else if (others.length > 0) takes.push(WHOLE);
+  const given = new Set(forwards.flatMap((forward) => forward.given));
+  if (given.size > 0 && !isMarkedEsModule(program)) given.add("default");
+  return { given: [...given], takes };
+}
+
+// src/vite-listed-holders.ts
+async function reachingSpecifiers(ctx, input) {
+  const { code, file, id, resolutions } = input;
+  const program = parseOf(ctx, code, id);
+  if (!program) return void 0;
+  const reachingOf = async (specifiers) => {
+    const reaching = /* @__PURE__ */ new Set();
+    for (const specifier of specifiers) {
+      const files = await resolvedFiles(ctx, resolutions, { id, specifier });
+      if (files.includes(file)) reaching.add(specifier);
+    }
+    return reaching;
+  };
+  const reaches = await reachingOf(specifiersIn(program));
+  const requires = await reachingOf(requireSpecifiersIn(program));
+  return { program, reaches, requires };
+}
+async function reexportedBy(ctx, input) {
+  const code = ctx.getModuleInfo?.(input.id)?.code;
+  if (code === null || code === void 0) return [];
+  try {
+    const read = await reachingSpecifiers(ctx, { ...input, code });
+    if (!read) return [];
+    const { program, reaches, requires } = read;
+    const forwarded = requires.size === 0 ? [] : requireTakesIn(program, { names: input.names, reaches: requires, readsForwards: true }).given;
+    if (reaches.size === 0) return forwarded;
+    const rivals = await rivalsOf(ctx, { ...input, program, reaches });
+    const reexported2 = reexportedNames(program, { names: input.names, reaches, rivals });
+    return [.../* @__PURE__ */ new Set([...reexported2, ...forwarded])];
+  } catch {
+    return [];
+  }
+}
+async function reexportsOf(ctx, input) {
+  const importers = importersOf(ctx, input.id).filter((importer) => isDependencyId(importer));
+  const found = /* @__PURE__ */ new Map();
+  for (const importer of importers) {
+    const added = await reexportedBy(ctx, { ...input, file: fileOf(input.id), id: importer });
+    if (added.length > 0) found.set(importer, added);
+  }
+  return found;
+}
+async function holdersOf(ctx, origin) {
+  const held2 = /* @__PURE__ */ new Map([[origin.id, origin.names]]);
+  const queue = [origin.id];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    const reexports = await reexportsOf(ctx, {
+      cxExports: origin.cxExports,
+      id,
+      names: held2.get(id),
+      resolutions: origin.resolutions
+    });
+    for (const [importer, added] of reexports) {
+      const known = held2.get(importer) ?? /* @__PURE__ */ new Set();
+      const isNew = importer !== origin.id && added.some((name) => !known.has(name));
+      if (isNew) {
+        held2.set(importer, /* @__PURE__ */ new Set([...known, ...added]));
+        queue.push(importer);
+      }
+    }
+  }
+  return held2.entries().map(([id, names]) => ({ id, names, isReached: id !== origin.id })).toArray();
+}
+
+// src/vite-cx-reference-names.ts
+function leftmostName(node) {
+  let current = node;
+  while (current?.type === "TSQualifiedName") current = nodeAt(current, "left");
+  return current?.type === "Identifier" ? current.name : void 0;
+}
+function typeNameOf(node) {
+  if (node.type === "TSTypeQuery") return leftmostName(nodeAt(node, "exprName"));
+  return node.type === "TSTypeReference" ? leftmostName(nodeAt(node, "typeName")) : void 0;
+}
+function jsxNameOf(node) {
+  if (node.type !== "JSXOpeningElement") return void 0;
+  let current = nodeAt(node, "name");
+  while (current?.type === "JSXMemberExpression") current = nodeAt(current, "object");
+  return current?.type === "JSXIdentifier" ? current.name : void 0;
+}
+function jsxMemberOf(node) {
+  if (node.type !== "JSXOpeningElement") return void 0;
+  let current = nodeAt(node, "name");
+  while (current?.type === "JSXMemberExpression") {
+    const object = nodeAt(current, "object");
+    if (object?.type === "JSXIdentifier") {
+      const member = nodeAt(current, "property")?.name;
+      return typeof member === "string" ? { member, name: object.name } : void 0;
+    }
+    current = object;
+  }
+  return void 0;
+}
+function jsxMembersIn(program) {
+  const found = /* @__PURE__ */ new Map();
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const read = jsxMemberOf(node);
+    if (read) found.set(read.name, (found.get(read.name) ?? /* @__PURE__ */ new Set()).add(read.member));
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+function namesIn(program, nameOf) {
+  const found = /* @__PURE__ */ new Set();
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const name = nameOf(node);
+    if (name !== void 0) found.add(name);
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+
+// src/vite-cx-take-passing.ts
+function usesOf(analysis, source, specifier) {
+  const local = exportNameOf(nodeAt(specifier, "local"));
+  return analysis.references.filter(
+    ({ binding }) => binding?.kind === "import" && binding.source === source && binding.name === local
+  );
+}
+function isPure(flow) {
+  return flow.names.size > 0 && !flow.isCalled && !flow.isUnbound;
+}
+function passingOf(analysis, source, specifier) {
+  const flows = usesOf(analysis, source, specifier).map((use) => flowOf(analysis, use.node));
+  if (flows.every((flow) => flow.names.size === 0)) return {};
+  return flows.every((flow) => isPure(flow)) ? { isForward: true, isPassedOn: true } : { isPassedOn: true };
+}
+function isCarriedOn(analysis, source, specifier) {
+  return usesOf(analysis, source, specifier).some((use) => flowOf(analysis, use.node).isUnbound);
+}
+function isValueCarried(analysis, node) {
+  const flow = flowOf(analysis, node);
+  return flow.isUnbound || flow.names.size > 0;
+}
+function isExportedDeclarator2(analysis, declarator) {
+  const declaration = analysis.parentOf.get(declarator);
+  const statement = declaration && analysis.parentOf.get(declaration);
+  return statement?.type === "ExportNamedDeclaration";
+}
+function isBoundNameCarried(analysis, property) {
+  const value = nodeAt(property, "value");
+  const declarator = analysis.parentOf.get(analysis.parentOf.get(property) ?? property);
+  const alias = value?.type === "Identifier" ? analysis.bindingDeclaredBy(value) : void 0;
+  if (!alias || declarator?.type !== "VariableDeclarator" || isExportedDeclarator2(analysis, declarator)) {
+    return true;
+  }
+  return analysis.references.some(
+    (use) => use.binding === alias && isValueCarried(analysis, use.node)
+  );
+}
+function isPatternCarried(analysis, pattern, names) {
+  return nodesAt(pattern, "properties").some((property) => {
+    const key = propertyNameOf(nodeAt(property, "key"), property.computed === true);
+    if (key === void 0) return false;
+    if (INHERITED_NAMES.has(key)) return true;
+    return isCxName(names, key) && isBoundNameCarried(analysis, property);
+  });
+}
+function isCalledWithReceiver2(analysis, member) {
+  let top = unwrapped(analysis, member);
+  let parent = analysis.parentOf.get(top);
+  while (parent?.type === "ChainExpression") {
+    top = unwrapped(analysis, parent);
+    parent = analysis.parentOf.get(top);
+  }
+  if (parent?.type === "CallExpression") return nodeAt(parent, "callee") === top;
+  return parent?.type === "TaggedTemplateExpression" && nodeAt(parent, "tag") === top;
+}
+function isUseCarried(analysis, node, names) {
+  const read = memberReadOf({ analysis }, node);
+  if (read) {
+    if (read.key === void 0) return isCalledWithReceiver2(analysis, read.member);
+    if (INHERITED_NAMES.has(read.key)) return true;
+    if (!isCxName(names, read.key)) return isCalledWithReceiver2(analysis, read.member);
+    return isValueCarried(analysis, read.member);
+  }
+  const pattern = patternDestructuring({ analysis }, node);
+  return pattern?.type === "ObjectPattern" && isPatternCarried(analysis, pattern, names);
+}
+function heldNamespace(analysis, references, names, source) {
+  const isCarried = references.some(({ node }) => isUseCarried(analysis, node, names));
+  return isCarried ? withHeld({ shape: "namespace", names: [] }, source) : void 0;
+}
+function withHeld(taken, source) {
+  const isWhole = taken.names.length === 0 && taken.isForward !== true;
+  if (!isWhole || taken.shape === "names" || taken.shape === "star") return taken;
+  const form = taken.shape === "namespace" ? `uses the namespace of ${source} where the build cannot follow it` : `imports ${source} and uses it where the build cannot follow it`;
+  return { ...taken, isHeld: true, form };
+}
+
+// src/vite-cx-takes.ts
+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);
+    if (taken === void 0) return { shape: "namespace", names: [] };
+    for (const name of taken) found.add(name);
+  }
+  return found.size === 0 ? void 0 : { shape: "namespace", names: [...found] };
+}
+function referencesTo(analysis, source, specifier) {
+  const local = exportNameOf(nodeAt(specifier, "local"));
+  return analysis.references.filter(({ binding }) => {
+    return binding?.kind === "import" && binding.imported === "*" && binding.source === source && binding.name === local;
+  });
+}
+function isTypeUseOnly(scan, source, specifier) {
+  const local = exportNameOf(nodeAt(specifier, "local"));
+  if (local === void 0 || !scan.typeNames().has(local) || scan.jsxNames().has(local)) {
+    return false;
+  }
+  return usesOf(scan.analysis(), source, specifier).length === 0;
+}
+function namespaceTakesOf(scan, source, specifier) {
+  const references = referencesTo(scan.analysis(), source, specifier);
+  const taken = namespaceTakes(scan.analysis(), references, scan.names);
+  if (taken?.names.length === 0) return taken;
+  const local = exportNameOf(nodeAt(specifier, "local"));
+  const tags = local === void 0 ? [] : [...scan.jsxMembers(local)];
+  const names = /* @__PURE__ */ new Set([
+    ...taken?.names ?? [],
+    ...tags.filter((name) => isCxName(scan.names, name))
+  ]);
+  return names.size === 0 ? void 0 : { shape: "namespace", names: [...names] };
+}
+function namespaceTake(scan, source, specifier) {
+  const references = referencesTo(scan.analysis(), source, specifier);
+  const held2 = scan.isDependency && heldNamespace(scan.analysis(), references, scan.names, source);
+  if (held2) return held2;
+  const taken = namespaceTakesOf(scan, source, specifier);
+  const isForward = passingOf(scan.analysis(), source, specifier).isForward;
+  const forwarded = taken && { ...taken, ...isForward && { isForward } };
+  return forwarded && scan.isDependency ? withHeld(forwarded, source) : forwarded;
+}
+function namedTake(scan, source, specifier) {
+  const imported = specifier.type === "ImportDefaultSpecifier" ? "default" : exportNameOf(nodeAt(specifier, "imported"));
+  if (imported === void 0 || !isCxName(scan.names, imported)) return void 0;
+  if (isTypeUseOnly(scan, source, specifier)) return void 0;
+  const isHeld = scan.isDependency && isCarriedOn(scan.analysis(), source, specifier);
+  const form = `uses ${imported} from ${source} where the build cannot follow it`;
+  return {
+    shape: "names",
+    names: [imported],
+    ...passingOf(scan.analysis(), source, specifier),
+    ...isHeld && { isHeld: true, form }
+  };
+}
+function importTakes(node, source, scan) {
+  return valueSpecifiersOf(node).flatMap((specifier) => {
+    const taken = specifier.type === "ImportNamespaceSpecifier" ? namespaceTake(scan, source, specifier) : namedTake(scan, source, specifier);
+    return taken ? [taken] : [];
+  });
+}
+function exportTakes(node, scan) {
+  if (node.type === "ExportAllDeclaration") {
+    if (nodeAt(node, "exported") !== void 0) {
+      return [{ shape: "namespace", names: [], isForward: true }];
+    }
+    const hasNamed = scan.names === void 0 || scan.names.keys().some((name) => name !== "default");
+    return hasNamed ? [{ shape: "star", names: [], isForward: true }] : [];
+  }
+  const re = valueSpecifiersOf(node).map((specifier) => exportNameOf(nodeAt(specifier, "local"))).filter((name) => name !== void 0 && isCxName(scan.names, name));
+  return re.length === 0 ? [] : [{ shape: "names", names: re, isPassedOn: true, isForward: true }];
+}
+function dynamicTakes(node, scan) {
+  const keys = dynamicKeys(scan.analysis(), node, scan.names);
+  if (keys === void 0) return [{ shape: "dynamic-import", names: [] }];
+  return keys.length === 0 ? [] : [{ shape: "dynamic-import", names: keys }];
+}
+function takesOf(node, scan) {
+  const source = staticStringOf(nodeAt(node, "source"));
+  if (source === void 0 || !scan.reaches.has(source)) return [];
+  if (isTypeOnly(node)) return [];
+  if (node.type === "ImportDeclaration") return importTakes(node, source, scan);
+  if (node.type === "ImportExpression") {
+    if (!scan.isDependency) return dynamicTakes(node, scan);
+    const taken = isUsedAsCallsOnly(scan.analysis(), node, scan.names) ? dynamicTakes(node, scan) : [{ shape: "dynamic-import", names: [] }];
+    return taken.map((one) => withHeld(one, source));
+  }
+  return exportTakes(node, scan);
+}
+function takesIn(program, input) {
+  let analysis;
+  let typeNames;
+  let jsxNames;
+  let jsxMembers;
+  const scan = {
+    ...input,
+    isDependency: input.isDependency === true,
+    analysis: () => analysis ??= analyze(program),
+    typeNames: () => typeNames ??= namesIn(program, typeNameOf),
+    jsxNames: () => jsxNames ??= namesIn(program, jsxNameOf),
+    jsxMembers: (local) => (jsxMembers ??= jsxMembersIn(program)).get(local) ?? /* @__PURE__ */ new Set()
+  };
+  const found = [];
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    pushAll(found, takesOf(node, scan));
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+
+// src/vite-listed-routes.ts
+function importTakesOf(program, input) {
+  return input.reaches.size === 0 ? [] : takesIn(program, input);
+}
+function unreadableFor(id, module) {
+  return isDependencyId(id) ? { ...UNREADABLE, isHeld: true, form: `takes ${module} in a way the build cannot read` } : UNREADABLE;
+}
+function requireTakesOf(program, input) {
+  if (input.requires.size === 0) return [];
+  return requireTakesIn(program, {
+    names: input.names,
+    reaches: input.requires,
+    readsForwards: isDependencyId(input.id)
+  }).takes;
+}
+async function takenBy(ctx, input) {
+  const { file, id, label, names, resolutions } = input;
+  const unreadable = () => unreadableFor(id, label);
+  const code = ctx.getModuleInfo?.(id)?.code;
+  try {
+    const read = code === null || code === void 0 ? void 0 : await reachingSpecifiers(ctx, { code, file, id, resolutions });
+    if (!read) return [unreadable()];
+    const { program, reaches, requires } = read;
+    if (reaches.size === 0 && requires.size === 0) return [unreadable()];
+    return [
+      ...importTakesOf(program, { isDependency: isDependencyId(id), names, reaches }),
+      ...requireTakesOf(program, { id, names, requires })
+    ];
+  } catch {
+    return [unreadable()];
+  }
+}
+function merged(takes) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const take of takes) {
+    const key = `${take.taker}\0${take.shape}`;
+    const known = byKey.get(key);
+    const names = /* @__PURE__ */ new Set([...known?.names ?? [], ...take.names]);
+    const isReached = take.isReached || known?.isReached === true;
+    const isPassedOn = take.isPassedOn === true || known?.isPassedOn === true;
+    byKey.set(key, { ...take, isPassedOn, isReached, names: [...names].toSorted(compareText) });
+  }
+  return byKey.values().toArray();
+}
+async function isCounted(context, input) {
+  const { importer, isEntry, pkg, wantCalls } = input;
+  if (wantCalls || !isDependencyId(importer)) return true;
+  if (!isEntry) return false;
+  return await context.packageOf(importer) !== pkg;
+}
+async function routesOf(ctx, context, input) {
+  const { holder, importer, isEntry, resolutions, wantCalls } = input;
+  const isDependency = isDependencyId(importer);
+  const taker = context.labelOf(importer);
+  const taken = await takenBy(ctx, {
+    file: fileOf(holder.id),
+    id: importer,
+    label: context.labelOf(fileOf(holder.id)),
+    names: holder.names,
+    resolutions
+  });
+  const takes = taken.map((take) => ({ ...take, taker, isReached: holder.isReached }));
+  if (isDependency) {
+    const pkg = await context.packageOf(importer) ?? taker;
+    const held2 = takes.filter((take) => take.isHeld === true).map((take) => ({ form: take.form ?? "", importer, pkg, taker }));
+    const calls = takes.filter((take) => take.isForward !== true && take.isHeld !== true);
+    return { entry: isEntry ? calls : [], told: [], calls: wantCalls ? calls : [], held: held2 };
+  }
+  const isCleared = (take) => isEntry && take.shape !== "unreadable";
+  return {
+    entry: takes.filter((take) => isCleared(take)),
+    told: takes.filter((take) => !isCleared(take)),
+    calls: [],
+    held: []
+  };
+}
+function serverTakesOf(found, holder) {
+  const takes = [];
+  for (const taken of found.takes) {
+    const names = taken.names.filter((name) => holder.names.has(name));
+    const isWhole = taken.names.length === 0;
+    const hasNamed = holder.names.keys().some((name) => name !== "default");
+    const isTaken = taken.shape === "star" ? hasNamed : isWhole || names.length > 0;
+    if (isTaken) {
+      const kept = isWhole ? taken.names : names;
+      takes.push({
+        ...taken,
+        names: kept,
+        taker: found.taker,
+        isReached: holder.isReached,
+        ...found.isRecorded === true && { isRecorded: true }
+      });
+    }
+  }
+  return takes;
+}
+async function takesFrom(ctx, context, input) {
+  const { holder, isEntry, pkg, resolutions, wantCalls } = input;
+  const importers = importersOf(ctx, holder.id);
+  const entry = [];
+  const told = [];
+  const calls = [];
+  const held2 = [];
+  for (const importer of importers) {
+    const routes = await routesOf(ctx, context, {
+      holder,
+      importer,
+      isEntry,
+      resolutions,
+      wantCalls
+    });
+    pushAll(held2, routes.held);
+    if (!await isCounted(context, { importer, isEntry, pkg, wantCalls })) continue;
+    pushAll(entry, routes.entry);
+    pushAll(told, routes.told);
+    pushAll(calls, routes.calls);
+  }
+  return { entry: merged(entry), told: merged(told), calls: merged(calls), held: held2 };
+}
+function serverRoutes(holder, input) {
+  const file = fileOf(holder.id);
+  const fromServer = input.serverImports.filter((one) => one.file === file);
+  const takes = fromServer.flatMap((found) => serverTakesOf(found, holder));
+  const isCleared = (take) => input.isEntry && take.shape !== "unreadable";
+  return {
+    entry: takes.filter((take) => isCleared(take)),
+    told: takes.filter((take) => !isCleared(take))
+  };
+}
+
+// src/vite-listed-takes.ts
+async function prepareOne(ctx, context, input) {
+  const { isHop, problems, walk } = input;
+  const 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 routed = await Promise.all(
+    holders.map(
+      (holder) => takesFrom(ctx, context, {
+        holder,
+        isEntry: hasEntry && !holder.isReached,
+        pkg,
+        resolutions: walk.resolutions,
+        wantCalls: isHop
+      })
+    )
+  );
+  const isListed = Object.hasOwn(context.options.keepFor, pkg);
+  return { hasEntry, holders, isHop, isListed, problems, rootName: context.rootName, routed };
+}
+function heldProblemsOf(routed) {
+  const byKey = /* @__PURE__ */ new Map();
+  const all = routed.flatMap((route) => route.held);
+  for (const held2 of all) byKey.set(`${held2.importer}\0${held2.form}`, held2);
+  return byKey.values().map((held2) => ({
+    kind: "reference",
+    offset: 0,
+    construct: "",
+    text: `${held2.form}.`,
+    file: held2.taker,
+    line: 0,
+    column: 0,
+    unknownLine: "",
+    pkg: held2.pkg,
+    moduleId: held2.importer,
+    isHeld: true
+  })).toArray();
+}
+function decideOne(prepared, serverImports) {
+  return [...heldProblemsOf(prepared.routed), ...decidedByTakes(prepared, serverImports)];
+}
+function decidedByTakes(prepared, serverImports) {
+  const { hasEntry, holders, isHop, isListed, problems, rootName, routed } = prepared;
+  const fromServer = holders.map(
+    (holder) => serverRoutes(holder, { isEntry: hasEntry && !holder.isReached, serverImports })
+  );
+  const entry = [...routed.flatMap((route) => route.entry), ...fromServer.flatMap((r) => r.entry)];
+  if (entry.length > 0) return problems.filter((problem2) => problem2.specifier !== void 0);
+  const told = merged([
+    ...routed.flatMap((route) => route.told),
+    ...fromServer.flatMap((route) => route.told)
+  ]);
+  const callers = isHop && !isListed ? callersOf(routed) : [];
+  if (told.length === 0 && callers.length === 0) return [];
+  return problems.map((problem2) => ({
+    ...problem2,
+    ...told.length > 0 && { takes: told, rootName },
+    ...callers.length > 0 && { callers }
+  }));
+}
+function callersOf(routed) {
+  const callers = new Set(routed.flatMap((route) => route.calls.map((call) => call.taker)));
+  return [...callers].toSorted(compareText);
+}
+async function prepareReexports(ctx, context, standingIn) {
+  const exporting = standingIn.filter((problem2) => problem2.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]);
+  }
+  const cxExports = new Map(
+    [...byModule.values(), ...hops.values()].map((problems) => [
+      fileOf(problems[0].moduleId),
+      new Set(problems.flatMap((problem2) => problem2.exportedAs ?? []))
+    ])
+  );
+  const walk = { cxExports, resolutions: /* @__PURE__ */ new Map() };
+  return await Promise.all([
+    ...byModule.values().map((problems) => prepareOne(ctx, context, { isHop: false, problems, walk })),
+    ...hops.values().map((problems) => prepareOne(ctx, context, { isHop: true, problems, walk }))
+  ]);
+}
+function decideReexports(prepared, serverImports) {
+  const decided = prepared.flatMap((one) => decideOne(one, serverImports));
+  const isFirst = (problem2, index) => problem2.isHeld !== true || decided.findIndex(
+    (other) => other.isHeld === true && other.moduleId === problem2.moduleId && other.text === problem2.text
+  ) === index;
+  return decided.filter((problem2, index) => isFirst(problem2, index));
+}
+
+// src/vite-reexport-judge.ts
+async function judgeReexports(host, context, modules, serverImports = []) {
+  const kept = await withClearingSpecifiers(
+    host,
+    context,
+    withoutEchoes(
+      modules.map((module) => ({
+        onlyVia: module.onlyVia,
+        problems: [
+          ...module.problems,
+          ...module.suppressed.filter((problem2) => problem2.kind === "declared")
+        ]
+      }))
+    )
+  );
+  const suppressed = modules.flatMap((module) => module.suppressed);
+  const held2 = suppressed.filter((problem2) => problem2.isUnboundHandOut === true).map((problem2) => ({ ...problem2, isHeld: true }));
+  const standingIn = [
+    ...suppressed.filter((problem2) => problem2.isUnboundHandOut !== true),
+    ...kept.filter((problem2) => isSecondHop(problem2))
+  ];
+  const rest = kept.filter((problem2) => !isSecondHop(problem2));
+  const prepared = await prepareReexports(host, context, standingIn);
+  return { problems: [...rest, ...held2, ...decideReexports(prepared, serverImports)], prepared };
+}
+
+// src/vite-restorers.ts
+function withRestorers(atoms) {
+  if (atoms.has("srOnly")) atoms.add("srOnlyFocusable");
+  return atoms;
+}
+
 // 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)";
@@ -2704,11 +4510,11 @@ function applicationLines(application, configured, home) {
   }
   return lines;
 }
-function remedyBlock(problems, listed, home, hostRemedies) {
+function remedyBlock(problems, listed, places, hostRemedies) {
   const configured = withoutRemoved(problems, listed);
   const application = problems.filter((problem2) => problem2.pkg === void 0);
   const lines = [
-    ...applicationLines(application, configured, home),
+    ...applicationLines(application, configured, places.home),
     ...hostRemedies?.(application) ?? []
   ];
   const byPackage = /* @__PURE__ */ new Map();
@@ -2717,7 +4523,7 @@ function remedyBlock(problems, listed, home, hostRemedies) {
       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, home));
+    lines.push(...packageLines(pkg, byPackage.get(pkg), configured, places));
   }
   if (application.some((problem2) => problem2.needsAvailable)) lines.push(availableLine());
   return lines;
@@ -2749,17 +4555,21 @@ function problemLines(problems) {
 function noun(count, word) {
   return `${count} ${word}${count === 1 ? "" : "s"}`;
 }
-function buildReport(problems, configured, home, hostRemedies) {
+function buildReport(problems, configured, home, host) {
+  const { remedies: hostRemedies, everyAtom = EVERY_ATOM } = typeof host === "function" ? { remedies: host } : host ?? {};
   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, home, hostRemedies)
+    ...remedyBlock(problems, configured, { home, everyAtom }, hostRemedies)
   ].join("\n");
 }
 function moduleReport(problems, configured, home) {
-  return [...problemLines(problems), ...remedyBlock(problems, configured, home)].join("\n");
+  return [
+    ...problemLines(problems),
+    ...remedyBlock(problems, configured, { home, everyAtom: EVERY_ATOM })
+  ].join("\n");
 }
 
-export { CLASS_MAP_NOT_PARSED, CX_SOURCE, LINE_UNKNOWN_UNMAPPED, LINE_UNKNOWN_WITHOUT_MAP, REPORT_CAUSE, analyze, applyEdits, assertOptions, atomOfClass, atomsWrittenIn, buildReport, childrenOf, combinedMapOf, compareText, cxModulesArray, exportNameOf, inspectAtomicLayer, isListableReexport, isNode, isSecondHop, keptAtoms, memberReadOf, moduleReport, nodeAt, nodesAt, patternDestructuring, placerFor, propertyNameOf, pruneAtomicLayer, pushAll, readModule, resolveUsedOptions, staticStringOf, stringAt, toSourceMap, unprunedAtoms, withRestorers, withoutRemoved };
+export { CLASS_MAP_NOT_PARSED, CX_ONLY, CX_SOURCE, LINE_UNKNOWN_UNMAPPED, LINE_UNKNOWN_WITHOUT_MAP, REPORT_CAUSE, UNREADABLE, analyze, applyEdits, assertOptions, atomOfClass, atomsWrittenIn, buildReport, canHoldDirective, childrenOf, combinedMapOf, compareText, cxModulesArray, decideReexports, declaredModulesFor, fileOf, filePathOf, flowOf, forgetDeclared, inspectAtomicLayer, isAboutListed, isCssModuleId, isDependencyId, isListedFile, isNamingListed, isNode, isRelative, isResolvingTo, isStylesheetId, isStylesheetPath, isUnreadStylesheet, isUsedAsCallsOnly, judgeReexports, keptAtoms, moduleReport, nodeAt, nodesAt, placerFor, pruneAtomicLayer, pushAll, readModule, recognisedKey, resolveOrNull, resolveUsedOptions, specifiersIn, specifiersOf, staticStringOf, takesIn, toSourceMap, unprunedAtoms, withRestorers, withoutRemoved };