@navecss/core 0.3.0 → 0.4.0

package/dist/collect.d.ts

@@ -0,0 +1,279 @@
+export { R as ResolvedUsedOptions, U as UsedAtomOptions, a as assertOptions, k as keptAtoms, r as resolveUsedOptions } from './vite-options-D1-hGA9L.js';
+import './atom-names-2OreuBx9.js';
+
+/**
+ * The few shapes of the ESTree `this.parse` returns that the collector reads, declared here
+ * rather than imported: the plugin takes no dependency, and a node is read through a handful of
+ * typed accessors instead of a full ESTree type package.
+ */
+interface AstNode {
+    readonly type: string;
+    readonly start: number;
+    readonly end: number;
+    readonly [key: string]: unknown;
+}
+
+/**
+ * One thing the collector could not read in a module, before it has a position or a path: what
+ * it is, where it starts (an offset into the module as the post-order half saw it), the
+ * construct as the plugin reads it, and the sentence that follows the construct in the report.
+ */
+/**
+ * The kinds a report groups its remedy lines by; the order here is the order the lines print.
+ */
+declare const PROBLEM_KINDS: readonly ["argument", "reference", "reexport", "declared", "concatenation", "dynamic", "unknown", "own", "unreadable"];
+type ProblemKind = (typeof PROBLEM_KINDS)[number];
+interface Problem {
+    readonly kind: ProblemKind;
+    readonly offset: number;
+    /**
+     * The construct, quoted as the plugin reads it, before it is cut for the report.
+     */
+    readonly construct: string;
+    /**
+     * The sentence after the construct.
+     */
+    readonly text: string;
+    /**
+     * For an unknown atom with no near candidate: the report closes with `Available:`.
+     */
+    readonly needsAvailable?: boolean;
+    /**
+     * For a re-export: whether listing the module in `cxModules` would clear it, which it does not
+     * when the module re-exports the `cx` of a module that is already listed (a second hop).
+     */
+    readonly isListable?: boolean;
+    /**
+     * For a re-export of Nave's `cx`: whether it gives `cx` under a name other than `cx`, as a default
+     * or inside a namespace. A listed module may not do that, so listing the module would only turn
+     * this problem into another one: no `cxModules` entry clears it.
+     */
+    readonly isRenamed?: boolean;
+    /**
+     * For a problem that gives Nave's `cx` out of its module, or a namespace holding it, or the `cx`
+     * of a module listed in `cxModules`: the names it is exported under (`default` for the default
+     * export), so a build-end check can tell whether an importer takes it.
+     */
+    readonly exportedAs?: readonly string[];
+    /**
+     * For a problem in a module listed in `cxModules`: whether the module also exports Nave's own
+     * `cx`. An importer's `cx` is then Nave's, so what the build says of its calls is not an echo of
+     * this problem and stays when the problem is reported.
+     */
+    readonly hasNaveCx?: boolean;
+}
+
+/**
+ * Replaces the text from `start` up to `end` of the module with `text`.
+ */
+interface Edit {
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+}
+
+/**
+ * What a compiled Vue component's script exposes to its template, and how a template reads it:
+ * `$setup.<name>`.
+ */
+
+type SetupExposure = {
+    readonly kind: 'cx';
+} | {
+    readonly kind: 'values';
+    readonly values: readonly string[];
+};
+type SetupExposures = ReadonlyMap<string, SetupExposure>;
+
+interface ReadOptions {
+    /**
+     * The import specifiers that bind Nave's `cx`: its own module, and every module listed in
+     * `cxModules` that this module imports.
+     */
+    readonly cxSources: ReadonlySet<string>;
+    /**
+     * The specifiers in `cxSources` that name a module listed in `cxModules`.
+     */
+    readonly declaredSources?: ReadonlySet<string>;
+    /**
+     * Whether this module is itself listed in `cxModules`, so its exports of `cx` are judged as a
+     * listed module's.
+     */
+    readonly isDeclared?: boolean;
+    /**
+     * The names of the consumer's own atoms, which have no class.
+     */
+    readonly ownAtoms: ReadonlySet<string>;
+    /**
+     * Whether this module belongs to a dependency, where a Nave class built from pieces is only
+     * refused if the module also imports `cx`.
+     */
+    readonly isDependency: boolean;
+    /**
+     * For a compiled Vue template: what its component's script exposes to it.
+     */
+    readonly setup?: SetupExposures | undefined;
+    /**
+     * Whether the module is a compiled Vue component's `<script setup>`.
+     */
+    readonly isVueScript?: boolean;
+    /**
+     * Set in a build: the reading also returns the edits that turn each call it read into the
+     * string the call returns, and `keep` is the map a `cx.dynamic()` call looks a name up in.
+     */
+    readonly rewrite?: {
+        readonly keep: Readonly<Record<string, string>>;
+    };
+}
+interface ModuleReading {
+    /**
+     * Built-in atoms named by a readable `cx()` call.
+     */
+    readonly atoms: Set<string>;
+    /**
+     * Built-in atoms whose class is written whole in the module.
+     */
+    readonly classes: Set<string>;
+    readonly problems: Problem[];
+    /**
+     * Where `cx.dynamic()` is called, and the call as the plugin reads it.
+     */
+    readonly dynamicCalls: {
+        readonly construct: string;
+        readonly offset: number;
+    }[];
+    /**
+     * For a compiled Vue `<script setup>`: what it exposes to its template.
+     */
+    readonly exposes: Map<string, SetupExposure>;
+    /**
+     * Whether the module imports from a `cx` source, whether or not it uses the import.
+     */
+    readonly usesCx: boolean;
+    /**
+     * With `rewrite` set: the edits that replace the calls the reading found, empty otherwise.
+     */
+    readonly edits: Edit[];
+}
+
+/**
+ * Reads one module for the atoms its `cx()` calls and written classes name, and for everything
+ * in it the build cannot read. Pure: it takes the parsed module and returns what it found, so the
+ * host (the post-order plugin) decides where the findings go.
+ */
+
+declare const CX_SOURCE = "@navecss/core/cx";
+
+/**
+ * Reads `program`, the parse of `code`.
+ */
+declare function readModule(code: string, program: AstNode, options: ReadOptions): ModuleReading;
+
+/**
+ * What an importer takes from a module that gives out Nave's `cx`: which of its `cx` exports it
+ * imports, re-exports or reads off a namespace. The test is by name, not by file: an importer that
+ * takes only `Button` from a module which also exports `cx` as `cn` takes no `cx` from it, so
+ * nothing of its own routes calls through `cn`. A take the parse cannot tell apart (a namespace
+ * passed on, a computed key, a rest element, an `import()` used any other way) counts as taken, and
+ * so does an importer whose text names the module in no way the build reads (a `require()`).
+ */
+
+/**
+ * How an importer takes the module: by the names it imports or re-exports, as a namespace, as
+ * `export *`, as an `import()`, or in a way the build cannot read.
+ */
+type TakeShape = 'dynamic-import' | 'names' | 'namespace' | 'star' | 'unreadable';
+interface Taken {
+    readonly shape: TakeShape;
+    /**
+     * The `cx` exports the importer takes by name; none when it takes the module whole.
+     */
+    readonly names: readonly string[];
+    /**
+     * Whether the importer only passes on what it takes: a named re-export, or an import that it
+     * then exports.
+     */
+    readonly isPassedOn?: boolean;
+    /**
+     * Whether the importer does nothing with what it takes but re-export it: `export ... from`, or an
+     * import that every use of is an export. A forward is followed to what takes it; it is not a
+     * take on the `cxModules` route.
+     */
+    readonly isForward?: boolean;
+    /**
+     * Whether the take comes from what an earlier server command left in the cache directory.
+     */
+    readonly isRecorded?: boolean;
+}
+interface Take extends Taken {
+    /**
+     * The importer's path, relative to the project root, with forward slashes.
+     */
+    readonly taker: string;
+    /**
+     * Whether the module taken from is reached through another module of its package, which
+     * re-exports the `cx` it gives out.
+     */
+    readonly isReached: boolean;
+}
+
+/**
+ * The report a build fails with when it meets a use it cannot read: a first line counting the
+ * problems and stating the cause, one line per problem with a 1-based, root-relative position,
+ * and the remedy block printed once, last. Under the default nobody set the option, so the first
+ * line never names it, and no remedy printed for application code is `atomic: 'all'`: an agent
+ * takes the first remedy that clears the error, and that one always does.
+ */
+
+interface LocatedProblem extends Problem {
+    /**
+     * The module's path, relative to the project root, with forward slashes.
+     */
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+    /**
+     * Set when the source map does not lead to the authored position: `line` and `column` are then
+     * zero and mean nothing, and this is the sentence that ends the problem's line.
+     */
+    readonly unknownLine?: string | undefined;
+    /**
+     * The package name when the module lies under `node_modules`.
+     */
+    readonly pkg?: string | undefined;
+    /**
+     * The id of the module the problem is in, for a problem the build-end check looks into the
+     * module graph for.
+     */
+    readonly moduleId?: string | undefined;
+    /**
+     * For a dependency's re-export of `cx`: the specifier that resolves from the project root to the
+     * module that holds it, when a `cxModules` entry can name it.
+     */
+    readonly specifier?: string | undefined;
+    /**
+     * For a dependency's listed module that exports a `cx` the build does not follow: the
+     * `cxModules` entries, as written, that name it.
+     */
+    readonly entries?: readonly string[] | undefined;
+    /**
+     * For a module of a package `keepFor` lists that gives `cx` out under another name: the
+     * application modules that take one of its `cx` exports, which `keepFor` does not clear.
+     */
+    readonly takes?: readonly Take[] | undefined;
+    /**
+     * For a dependency module that re-exports the `cx` of a module `cxModules` lists: the modules of
+     * other dependencies that call through it, root-relative, which only the package's `keepFor`
+     * entry can stand in for.
+     */
+    readonly callers?: readonly string[] | undefined;
+}
+declare const REPORT_CAUSE = "the build cannot tell which atoms these apply, and it ships only the atoms it can read.";
+/**
+ * The build report for every problem of an environment. `configured` is the `cxModules` list the
+ * remedies that print one extend, and `home` is how the host spells where the options are written,
+ * the call of its plugin or its wrapper: the one place the report names its host.
+ */
+declare function buildReport(problems: readonly LocatedProblem[], configured: readonly string[], home: string): string;
+
+export { type AstNode, CX_SOURCE, type LocatedProblem, type ModuleReading, type Problem, type ProblemKind, REPORT_CAUSE, type ReadOptions, buildReport, readModule };

package/dist/collect.js

@@ -0,0 +1,4 @@
+export { CX_SOURCE, REPORT_CAUSE, assertOptions, buildReport, keptAtoms, readModule, resolveUsedOptions } from './chunk-E5F6YF7A.js';
+import './chunk-SYNQJNVB.js';
+import './chunk-CUL5PLPI.js';
+import './chunk-GZL2VW7C.js';

package/dist/cx.d.ts

@@ -1,4 +1,4 @@
-import { AtomName } from './atoms.js';
+import { A as AtomName } from './atom-names-2OreuBx9.js';
 
 /**
  * cx — typed atomic class composer for Nave.

package/dist/cx.js

@@ -1,12 +1,25 @@
-import { atomClassMap } from './chunk-LIUB4EES.js';
+import { atomClassMap } from './chunk-GZL2VW7C.js';
 
 // src/cx.ts
+var decodedKeep = /* @__PURE__ */ new Map();
+function decodedMap(text) {
+  let map = decodedKeep.get(text);
+  if (map === void 0) {
+    map = JSON.parse(text);
+    decodedKeep.set(text, map);
+  }
+  return map;
+}
 var cx = (...args) => args.filter(Boolean).map(
   (arg) => Object.hasOwn(atomClassMap, arg) ? atomClassMap[arg] : arg
 ).join(" ");
 cx.raw = (...args) => args.filter(Boolean).join(" ");
 cx.dynamic = (name) => {
   if (!name) return "";
+  if (typeof __NAVE_KEEP_CLASSES__ === "string") {
+    const decoded = decodedMap(__NAVE_KEEP_CLASSES__);
+    return Object.hasOwn(decoded, name) ? decoded[name] ?? "" : "";
+  }
   const map = typeof __NAVE_KEEP_CLASSES__ === "undefined" ? atomClassMap : __NAVE_KEEP_CLASSES__;
   return Object.hasOwn(map, name) ? map[name] : "";
 };

package/dist/lightningcss.d.ts

@@ -1,4 +1,5 @@
 import { AtomDefinition } from './atoms.js';
+import './atom-names-2OreuBx9.js';
 
 interface NaveLightningOptions {
     /**

package/dist/lightningcss.js

@@ -1,8 +1,10 @@
-import { splitByteOrderMark, warningTexts, foldedText } from './chunk-IZQLFUQU.js';
-import { validateExtendAtomsHostFree } from './chunk-R6JJZGXC.js';
-import { snapshotExtendMap, expandText } from './chunk-S7DZUVV3.js';
+import { splitByteOrderMark, warningTexts, foldedText } from './chunk-2A7IUZBH.js';
+import { validateExtendAtomsHostFree } from './chunk-LQSGQ2OA.js';
+import { snapshotExtendMap, expandText } from './chunk-LADFXRWQ.js';
 import './chunk-NFS2REPQ.js';
-import './chunk-LIUB4EES.js';
+import './chunk-SYNQJNVB.js';
+import './chunk-CUL5PLPI.js';
+import './chunk-GZL2VW7C.js';
 import { readFileSync } from 'fs';
 
 function report(diagnostics, file, extend, onUnknown) {

package/dist/postcss.d.ts

@@ -1,5 +1,6 @@
 import { Plugin } from 'postcss';
 import { AtomDefinition } from './atoms.js';
+import './atom-names-2OreuBx9.js';
 
 /**
  * Nave PostCSS plugin — resolves @nave directives.

package/dist/postcss.js

@@ -1,7 +1,9 @@
 import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
-import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, formatDiagnostic, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-S7DZUVV3.js';
+import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-LADFXRWQ.js';
 import { tokenize } from './chunk-NFS2REPQ.js';
-import './chunk-LIUB4EES.js';
+import { formatDiagnostic } from './chunk-SYNQJNVB.js';
+import './chunk-CUL5PLPI.js';
+import './chunk-GZL2VW7C.js';
 import postcss from 'postcss';
 
 // src/postcss-nested-builders.ts

package/dist/standalone.css

@@ -475,6 +475,7 @@
     --nave-color-action-primary-active: light-dark(oklch(0.27 0.0398 186.17), oklch(0.94 0.0574 186.17));
     --nave-color-on-action-primary: light-dark(oklch(from var(--nave-color-tint) 1 0 h / 1), oklch(from var(--nave-color-tint) 0.18 0.0067 h / 1));
     --nave-color-action-secondary: light-dark(oklch(from var(--nave-color-tint) 0.965 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.27 0.0067 h / 1));
+    --nave-color-action-highlight: light-dark(oklch(from var(--nave-color-tint) 0.965 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.37 0.0067 h / 1));
     --nave-color-feedback-danger: light-dark(oklch(0.47 0.1455 15.02), oklch(0.835 0.0661 15.02));
     --nave-color-feedback-danger-foreground: light-dark(oklch(0.47 0.1455 15.02), oklch(0.835 0.0661 15.02));
     --nave-color-on-feedback-danger: light-dark(oklch(from var(--nave-color-tint) 1 0 h / 1), oklch(from var(--nave-color-tint) 0.18 0.0067 h / 1));
@@ -488,6 +489,7 @@
     --nave-color-feedback-info: light-dark(oklch(from var(--nave-color-tint) 0.47 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.835 0.0067 h / 1));
     --nave-color-feedback-info-foreground: light-dark(oklch(from var(--nave-color-tint) 0.47 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.835 0.0067 h / 1));
     --nave-color-on-feedback-info: light-dark(oklch(from var(--nave-color-tint) 1 0 h / 1), oklch(from var(--nave-color-tint) 0.18 0.0067 h / 1));
+    --nave-color-backdrop-modal: light-dark(oklch(from var(--nave-color-tint) 0.12 0.0067 h / 0.3), oklch(from var(--nave-color-tint) 0.12 0.0067 h / 0.6));
   }
 }
 

package/dist/vite-options-D1-hGA9L.d.ts

@@ -0,0 +1,86 @@
+import { A as AtomName } from './atom-names-2OreuBx9.js';
+
+/**
+ * The options that choose which atoms the Vite plugin ships, and their validation. A value a
+ * type would refuse in TypeScript is refused here too, so a JavaScript config gets the same
+ * answer; every text opens `navePlugin(): `, the prefix of the plugin's config-level messages.
+ */
+
+interface UsedAtomOptions {
+    /**
+     * Which atoms the build ships. `'used'` (the default): the atoms your `cx()` calls and your
+     * written Nave classes name, plus those in `keep` and `keepFor`. Under the default the build
+     * filters the atomic layer of every stylesheet it can reach, and the dev server serves the same
+     * set as far as it has read; a stylesheet imported with `?inline` or `?raw` ships every atom
+     * with a warning; a `cx()` call whose atoms the build cannot read fails the build, and is an
+     * error in the dev server. In a build, each `cx()` call the plugin read also becomes the class
+     * string it returns.
+     * `'all'`: every atom, and no `cx()` call is read or rewritten, as with the PostCSS plugin.
+     */
+    atomic?: 'all' | 'used';
+    /**
+     * Atoms always shipped, whether or not the build reads a use of them: every atom your own
+     * `cx.dynamic()` calls can take, and the atom of each Nave class written where the build cannot
+     * read it, such as in a server template or in CMS text.
+     */
+    keep?: readonly AtomName[];
+    /**
+     * By package name: the atoms a dependency's own `cx()` calls can produce, for a package whose
+     * calls the build cannot read. They ship as if they were in `keep`, beside the atoms of the
+     * package's calls the build does read. The calls it cannot read are not changed, so any other
+     * atom they apply has no rule unless the build ships it for another reason. An empty list is
+     * accepted: it says those calls produce no atom, so the list adds none, and a `cx.dynamic()` call
+     * in the package still fails the build, as it does with no entry. A package in your own workspace
+     * is your code, not a dependency. The entry stands in for the package's own calls only: a
+     * re-export of `cx` in the package that the build reads and a module of yours takes (imports,
+     * re-exports or reads off a namespace, directly or through re-exports of it that the build reads,
+     * as `export ... from` or an import exported unchanged, in this package or another) still fails
+     * the build, because the calls your module makes through it would ship with no rule, and the
+     * message says how to clear it. Listing here a package that only re-exports it does not clear a
+     * take of yours, since a re-export is not a call. A server build that leaves the package external
+     * does not read it, so a take only your server code makes is judged by what the client build
+     * read: it fails the build as above when the client build read the re-export it takes and the
+     * build can read the take, and gets a warning naming `ssr.noExternal` when the build cannot tell,
+     * because no environment read the file the server loads, or your file reaches the package in a
+     * way the build cannot read as a take (a `require()`, say, or a `#` import); with separate client
+     * and server commands, the next client command judges what the last build of each server recorded
+     * of server files that still exist.
+     */
+    keepFor?: Readonly<Record<string, readonly AtomName[]>>;
+    /**
+     * Modules that re-export `cx` from `@navecss/core/cx` unchanged, as
+     * `export { cx } from '@navecss/core/cx'`, in your code or in a dependency: a file that imports
+     * `cx` from one is read as if it imported it from `@navecss/core/cx`. The build follows a listed
+     * module one step. A relative entry (`'./src/ui/index.ts'`) is a path from Vite's `root`. A
+     * package name or subpath, an alias or an absolute path matches an import written the same way.
+     * A `#` entry matches an import written the same way only where that import resolves to a listed
+     * file, since a `#` import resolves through the `package.json` nearest the file that writes it.
+     * Every entry also matches an import that resolves to its file through a specifier naming that
+     * file or, for an `index` file, its directory; in your code, an import that reaches the file
+     * through any other specifier fails the build instead. A relative entry that resolves to no file
+     * is ignored, and so is an entry naming `@navecss/core/cx`, which the build always reads. The
+     * same setting, with the same entries, as `@navecss/eslint-plugin`'s `cxModules`, which reads a
+     * relative entry from the working directory instead of Vite's `root`.
+     */
+    cxModules?: readonly string[];
+}
+interface ResolvedUsedOptions {
+    readonly atomic: 'all' | 'used';
+    readonly keep: readonly string[];
+    readonly keepFor: Readonly<Record<string, readonly string[]>>;
+    readonly cxModules: readonly string[];
+}
+/**
+ * Throws the first problem in the options, if there is one.
+ */
+declare function assertOptions(options: UsedAtomOptions | ResolvedUsedOptions, own: ReadonlySet<string> | undefined): void;
+/**
+ * The options with their defaults filled in.
+ */
+declare function resolveUsedOptions(options: UsedAtomOptions): ResolvedUsedOptions;
+/**
+ * Every atom the options always ship: `keep` and every `keepFor` list.
+ */
+declare function keptAtoms(options: ResolvedUsedOptions): string[];
+
+export { type ResolvedUsedOptions as R, type UsedAtomOptions as U, assertOptions as a, keptAtoms as k, resolveUsedOptions as r };

package/dist/vite.d.ts

@@ -1,4 +1,6 @@
-import { AtomName, AtomDefinition } from './atoms.js';
+import { AtomDefinition } from './atoms.js';
+import { U as UsedAtomOptions } from './vite-options-D1-hGA9L.js';
+import './atom-names-2OreuBx9.js';
 
 /**
  * The few shapes of Vite's (and Rollup's) own objects the plugin touches, declared here rather
@@ -219,70 +221,6 @@ interface TransformResultLike {
     readonly map: string;
 }
 
-/**
- * The options that choose which atoms the Vite plugin ships, and their validation. A value a
- * type would refuse in TypeScript is refused here too, so a JavaScript config gets the same
- * answer; every text opens `navePlugin(): `, the prefix of the plugin's config-level messages.
- */
-
-interface UsedAtomOptions {
-    /**
-     * Which atoms the build ships. `'used'` (the default): the atoms your `cx()` calls and your
-     * written Nave classes name, plus those in `keep` and `keepFor`. Under the default the build
-     * filters the atomic layer of every stylesheet it can reach, and the dev server serves the same
-     * set as far as it has read; a stylesheet imported with `?inline` or `?raw` ships every atom
-     * with a warning; a `cx()` call whose atoms the build cannot read fails the build, and is an
-     * error in the dev server.
-     * `'all'`: every atom, and no `cx()` call is read, as with the PostCSS plugin.
-     */
-    atomic?: 'all' | 'used';
-    /**
-     * Atoms always shipped, whether or not the build reads a use of them: every atom your own
-     * `cx.dynamic()` calls can take, and the atom of each Nave class written where the build cannot
-     * read it, such as in a server template or in CMS text.
-     */
-    keep?: readonly AtomName[];
-    /**
-     * By package name: the atoms a dependency's own `cx()` calls can produce, for a package whose
-     * calls the build cannot read. They ship as if they were in `keep`, beside the atoms of the
-     * package's calls the build does read. The calls it cannot read are not changed, so any other
-     * atom they apply has no rule unless the build ships it for another reason. An empty list is
-     * accepted: it says those calls produce no atom, so the list adds none, and a `cx.dynamic()` call
-     * in the package still fails the build, as it does with no entry. A package in your own workspace
-     * is your code, not a dependency. The entry stands in for the package's own calls only: a
-     * re-export of `cx` in the package that the build reads and a module of yours takes (imports,
-     * re-exports or reads off a namespace, directly or through re-exports of it that the build reads,
-     * as `export ... from` or an import exported unchanged, in this package or another) still fails
-     * the build, because the calls your module makes through it would ship with no rule, and the
-     * message says how to clear it. Listing here a package that only re-exports it does not clear a
-     * take of yours, since a re-export is not a call. A server build that leaves the package external
-     * does not read it, so a take only your server code makes is judged by what the client build
-     * read: it fails the build as above when the client build read the re-export it takes and the
-     * build can read the take, and gets a warning naming `ssr.noExternal` when the build cannot tell,
-     * because no environment read the file the server loads, or your file reaches the package in a
-     * way the build cannot read as a take (a `require()`, say, or a `#` import); with separate client
-     * and server commands, the next client command judges what the last build of each server recorded
-     * of server files that still exist.
-     */
-    keepFor?: Readonly<Record<string, readonly AtomName[]>>;
-    /**
-     * Modules that re-export `cx` from `@navecss/core/cx` unchanged, as
-     * `export { cx } from '@navecss/core/cx'`, in your code or in a dependency: a file that imports
-     * `cx` from one is read as if it imported it from `@navecss/core/cx`. The build follows a listed
-     * module one step. A relative entry (`'./src/ui/index.ts'`) is a path from Vite's `root`. A
-     * package name or subpath, an alias or an absolute path matches an import written the same way.
-     * A `#` entry matches an import written the same way only where that import resolves to a listed
-     * file, since a `#` import resolves through the `package.json` nearest the file that writes it.
-     * Every entry also matches an import that resolves to its file through a specifier naming that
-     * file or, for an `index` file, its directory; in your code, an import that reaches the file
-     * through any other specifier fails the build instead. A relative entry that resolves to no file
-     * is ignored, and so is an entry naming `@navecss/core/cx`, which the build always reads. The
-     * same setting, with the same entries, as `@navecss/eslint-plugin`'s `cxModules`, which reads a
-     * relative entry from the working directory instead of Vite's `root`.
-     */
-    cxModules?: readonly string[];
-}
-
 interface HtmlHook {
     readonly order: 'pre';
     handler(html: string, context: {
@@ -292,7 +230,7 @@ interface HtmlHook {
 interface NaveCollectPlugin {
     readonly name: 'nave:collect';
     readonly enforce: 'post';
-    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<undefined>;
+    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<TransformResultLike | undefined>;
     readonly transformIndexHtml: HtmlHook;
     buildStart(this: RenderContext): Promise<void>;
     buildEnd(this: RenderContext, error?: unknown): Promise<void>;
@@ -310,7 +248,7 @@ interface NaveCollectPlugin {
 interface NaveWorkerPlugin {
     readonly name: 'nave:collect-worker';
     readonly enforce: 'post';
-    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<undefined>;
+    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<TransformResultLike | undefined>;
     buildEnd(this: RenderContext, error?: unknown): Promise<void>;
 }