@navecss/core 0.4.0 → 0.6.0

package/dist/{chunk-2A7IUZBH.js → chunk-R6R5DSTT.js}

@@ -1,16 +1,16 @@
-import { foldLocated } from './chunk-LADFXRWQ.js';
+import { foldLocated } from './chunk-KDLLTOAM.js';
 import { formatDiagnostic } from './chunk-SYNQJNVB.js';
 
-// src/byte-order-mark.ts
-var BYTE_ORDER_MARK = "\uFEFF";
-function splitByteOrderMark(raw) {
-  return raw.startsWith(BYTE_ORDER_MARK) ? { bom: BYTE_ORDER_MARK, text: raw.slice(BYTE_ORDER_MARK.length) } : { bom: "", text: raw };
-}
-
 // src/directive/report-text.ts
 function inSourceOrder(diagnostics) {
   return diagnostics.toSorted((a, b) => a.offset - b.offset);
 }
+function framedText(file, line, column, text) {
+  return `${file}:${line}:${column}: ${text}`;
+}
+function orderWarningTexts(warnings, file) {
+  return warnings.map((warning) => framedText(file, warning.line, warning.column, warning.text));
+}
 function warningTexts(diagnostics, file, extend) {
   return inSourceOrder(diagnostics).map(
     (diagnostic) => `${file}:${diagnostic.line}:${diagnostic.column}: ${formatDiagnostic(diagnostic, { extend })}`
@@ -28,4 +28,4 @@ function foldedText(diagnostics, file, extend) {
   return `${file}:${first.line}:${first.column}: ${foldLocated(located)}`;
 }
 
-export { foldedText, splitByteOrderMark, warningTexts };
+export { foldedText, framedText, orderWarningTexts, warningTexts };

package/dist/chunk-UVHGEVMV.js

@@ -0,0 +1,204 @@
+// src/directive/expand-text-diagnostics.ts
+function lineStartOffsets(text) {
+  const starts = [0];
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "\r") {
+      i++;
+      if (text[i] === "\n") i++;
+      starts.push(i);
+      continue;
+    }
+    if (c === "\n" || c === "\f") {
+      i++;
+      starts.push(i);
+      continue;
+    }
+    i++;
+  }
+  return starts;
+}
+function lastAtOrBefore(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (starts[mid] <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+function createPositionFinder(text) {
+  const starts = lineStartOffsets(text);
+  return (offset) => {
+    const line = lastAtOrBefore(starts, offset);
+    return { line: line + 1, column: offset - starts[line] };
+  };
+}
+function reportDiagnostics(diagnostics, css, options) {
+  const onUnknown = options.onUnknown ?? "error";
+  if (onUnknown === "ignore") return [];
+  const severity = onUnknown === "warn" ? "warning" : "error";
+  const positionAt = createPositionFinder(css);
+  return diagnostics.map((diagnostic) => {
+    const position = positionAt(diagnostic.offset);
+    return {
+      ...diagnostic,
+      severity,
+      ...options.from !== void 0 && { file: options.from },
+      line: position.line,
+      column: position.column + 1
+    };
+  });
+}
+function positionWarnings(warnings, css, file) {
+  const positionAt = createPositionFinder(css);
+  return warnings.toSorted((a, b) => a.offset - b.offset).map(({ offset, text }) => {
+    const position = positionAt(offset);
+    return {
+      text,
+      offset,
+      line: position.line,
+      column: position.column + 1,
+      ...file !== void 0 && { file }
+    };
+  });
+}
+
+// src/directive/bracket-match.ts
+var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+function isMirrorCloser(openerType, closerType) {
+  if (closerType === ")-token") return openerType === "(-token" || openerType === "function-token";
+  if (closerType === "]-token") return openerType === "[-token";
+  return openerType === "{-token";
+}
+function matchBrackets(tokens) {
+  const closerFor = new Int32Array(tokens.length).fill(-1);
+  const opens = [];
+  for (const [i, token] of tokens.entries()) {
+    const { type } = token;
+    if (OPENERS.has(type)) {
+      opens.push(i);
+      continue;
+    }
+    if (!CLOSERS.has(type)) continue;
+    const openIndex = opens.at(-1);
+    if (openIndex === void 0 || !isMirrorCloser(tokens[openIndex].type, type)) continue;
+    opens.pop();
+    closerFor[openIndex] = i;
+  }
+  return closerFor;
+}
+function matchedCloseWithin(closerFor, openIndex, limit) {
+  const closeIndex = closerFor[openIndex];
+  return closeIndex !== -1 && closeIndex < limit ? closeIndex : void 0;
+}
+
+// src/directive/block-reader.ts
+function scanItem(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      if (type === "{-token") {
+        return {
+          end: closeIndex === void 0 ? limit : closeIndex + 1,
+          consumedSemicolon: false,
+          trailingBlock: { openIndex: i, closeIndex }
+        };
+      }
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (CLOSERS.has(type)) {
+      if (i === start) return { end: i + 1, consumedSemicolon: false };
+      i++;
+      continue;
+    }
+    if (type === "semicolon-token") return { end: i + 1, consumedSemicolon: true };
+    i++;
+  }
+  return { end: i, consumedSemicolon: false };
+}
+function scanCustomPropertyValue(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (type === "semicolon-token") return i + 1;
+    i++;
+  }
+  return i;
+}
+function isColonSoonAfter(tokens, i, limit) {
+  let j = i;
+  while (j < limit && (tokens[j].type === "whitespace-token" || tokens[j].type === "comment")) j++;
+  return tokens[j]?.type === "colon-token";
+}
+function isCustomPropertyName(token) {
+  return token.type === "ident-token" && (token.structured?.value).startsWith("--");
+}
+function atKeywordName(token) {
+  return (token.structured?.value).toLowerCase();
+}
+function toDeclarationItem(start, end) {
+  return { kind: "declaration", start, end };
+}
+function preludeEndOffset(tokens, start, scan, preludeStart) {
+  if (scan.trailingBlock) return tokens[scan.trailingBlock.openIndex].startIndex;
+  const lastContentIndex = scan.consumedSemicolon ? scan.end - 2 : scan.end - 1;
+  return lastContentIndex >= start ? tokens[lastContentIndex].endIndex : preludeStart;
+}
+function toAtRuleItem(tokens, start, scan) {
+  const nameToken = tokens[start];
+  const preludeStart = tokens[start + 1]?.startIndex ?? nameToken.endIndex;
+  return {
+    kind: "at-rule",
+    start,
+    end: scan.end,
+    atKeyword: atKeywordName(nameToken),
+    preludeOffset: preludeStart,
+    preludeEndOffset: preludeEndOffset(tokens, start + 1, scan, preludeStart),
+    ...scan.trailingBlock && {
+      blockStart: scan.trailingBlock.openIndex + 1,
+      blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+    }
+  };
+}
+function toRuleOrInvalidItem(start, scan) {
+  if (!scan.trailingBlock) return { kind: "invalid", start, end: scan.end };
+  return {
+    kind: "rule",
+    start,
+    end: scan.end,
+    blockStart: scan.trailingBlock.openIndex + 1,
+    blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+  };
+}
+function readItem(tokens, start, limit, closerFor) {
+  const first = tokens[start];
+  if (first.type === "at-keyword-token") {
+    return toAtRuleItem(tokens, start, scanItem(tokens, start + 1, limit, closerFor));
+  }
+  if (first.type === "ident-token" && isColonSoonAfter(tokens, start + 1, limit)) {
+    if (isCustomPropertyName(first)) {
+      return toDeclarationItem(start, scanCustomPropertyValue(tokens, start + 1, limit, closerFor));
+    }
+    const scan = scanItem(tokens, start + 1, limit, closerFor);
+    if (!scan.trailingBlock) return toDeclarationItem(start, scan.end);
+    return toRuleOrInvalidItem(start, scan);
+  }
+  return toRuleOrInvalidItem(start, scanItem(tokens, start, limit, closerFor));
+}
+function isNaveAtKeyword(token) {
+  return token.type === "at-keyword-token" && atKeywordName(token) === "nave";
+}
+
+export { OPENERS, atKeywordName, createPositionFinder, isNaveAtKeyword, matchBrackets, positionWarnings, readItem, reportDiagnostics };

package/dist/{chunk-UANF3FGO.js → chunk-ZNTNLGEC.js}

@@ -1,4 +1,5 @@
-import { createPositionFinder, tokenize, matchBrackets, readItem, isNaveAtKeyword } from './chunk-NFS2REPQ.js';
+import { createPositionFinder, matchBrackets, readItem, isNaveAtKeyword } from './chunk-UVHGEVMV.js';
+import { tokenize } from './chunk-2K5EBBF2.js';
 
 // src/directive/find-survivors.ts
 var NATURAL_STOP_CHARS = /* @__PURE__ */ new Set(["\n", ";", "}"]);

package/dist/collect.d.ts

@@ -1,5 +1,5 @@
-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';
+export { R as ResolvedUsedOptions, U as UsedAtomOptions, a as assertOptions, k as keptAtoms, r as resolveUsedOptions } from './vite-options-sOCeGn9B.js';
+import './atom-names-B8Ud-7zD.js';
 
 /**
  * The few shapes of the ESTree `this.parse` returns that the collector reads, declared here
@@ -55,6 +55,13 @@ interface Problem {
      * export), so a build-end check can tell whether an importer takes it.
      */
     readonly exportedAs?: readonly string[];
+    /**
+     * For a use in a dependency that hands Nave's `cx` out of its module where the build cannot
+     * follow it to an export (it is assigned to something other than a name of the module, passed
+     * as a value, bound, or imported in a form the build does not read). A hand-out the build can
+     * follow carries `exportedAs` instead.
+     */
+    readonly isUnboundHandOut?: boolean;
     /**
      * 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
@@ -169,13 +176,40 @@ declare const CX_SOURCE = "@navecss/core/cx";
  */
 declare function readModule(code: string, program: AstNode, options: ReadOptions): ModuleReading;
 
+interface LayerReading {
+    /**
+     * Whether the stylesheet holds an `@layer atomic { ... }` block.
+     */
+    readonly hasLayer: boolean;
+    /**
+     * The built-in atoms whose class a rule in the layer selects.
+     */
+    readonly atoms: Set<string>;
+}
+/**
+ * `css` with every rule in an `@layer atomic` block that needs an atom outside `emitted` removed.
+ */
+declare function pruneAtomicLayer(css: string, emitted: ReadonlySet<string>): string;
+/**
+ * What the `@layer atomic` blocks of `css` hold.
+ */
+declare function inspectAtomicLayer(css: string): LayerReading;
+/**
+ * The atoms outside `emitted` that a rule left in the `@layer atomic` blocks of `css` still needs
+ * an element of: what a pruning to `emitted` would still remove, sorted.
+ */
+declare function unprunedAtoms(css: string, emitted: ReadonlySet<string>): string[];
+
 /**
  * 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()`).
+ * so does an importer whose text names the module in no way the build reads (a `require()`). A
+ * declaration written for the types only (`import type`, `export type`, a `type` specifier), and a
+ * named import that is referenced only in type positions, take nothing: TypeScript leaves them out
+ * of the compiled module.
  */
 
 /**
@@ -204,6 +238,12 @@ interface Taken {
      * Whether the take comes from what an earlier server command left in the cache directory.
      */
     readonly isRecorded?: boolean;
+    /**
+     * For a dependency's take: whether the build reads it neither as calls only nor as a forward, so
+     * it cannot tell where what is taken goes. `form` says what the dependency does, in words.
+     */
+    readonly isHeld?: boolean;
+    readonly form?: string;
 }
 interface Take extends Taken {
     /**
@@ -217,6 +257,46 @@ interface Take extends Taken {
     readonly isReached: boolean;
 }
 
+/**
+ * `cxModules`: the modules a consumer lists as re-exporting Nave's `cx`, and what the post-order
+ * half does with them. An import is from a listed module when its specifier resolves, from the
+ * importing module, to a listed module's file, or, for an entry that is not relative, when it
+ * equals the entry as written (a relative specifier names a file relative to the module that
+ * writes it, so its text alone names nothing). An entry that is, or resolves to, Nave's own `cx`
+ * module is no entry: that module is always followed. A module is parsed only when its text can
+ * name a listed one (a text test, so an application of thousands of modules parses the importers
+ * and no more), and a build-end check compares the importers it recognised with the module
+ * graph's, so an import through a spelling the text test cannot see fails the build instead of
+ * shipping every call made through it with no rule.
+ */
+
+interface DeclaredModules {
+    /**
+     * The entries a specifier may equal as written: every entry but a relative one.
+     */
+    readonly entries: ReadonlySet<string>;
+    /**
+     * The module id each entry resolves to from the project root; an entry that resolves to nothing
+     * has none.
+     */
+    readonly ids: ReadonlyMap<string, string>;
+    /**
+     * The files the entries resolve to.
+     */
+    readonly files: ReadonlySet<string>;
+    /**
+     * The names a specifier's last segment may carry to name a listed file: its name without its
+     * extension, and its directory's when it is an `index` file.
+     */
+    readonly names: ReadonlySet<string>;
+    /**
+     * Finds, in a module's text, a quoted specifier that can name a listed file: one whose last
+     * segment is one of `names`, or a directory specifier that writes no name when a listed file
+     * is an `index` file. `undefined` when no listed file resolved.
+     */
+    readonly textTest: RegExp | undefined;
+}
+
 /**
  * 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,
@@ -261,19 +341,273 @@ interface LocatedProblem extends Problem {
      * application modules that take one of its `cx` exports, which `keepFor` does not clear.
      */
     readonly takes?: readonly Take[] | undefined;
+    /**
+     * For a problem with `takes`: how the host names the root a `cxModules` specifier resolves from,
+     * in the words the remedy line for those takes uses.
+     */
+    readonly rootName?: string | 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;
+    /**
+     * For a dependency's problem that stays an error whatever the application imports, and that no
+     * `keepFor` entry clears: a hand-out of `cx` the build cannot follow to an export, or a take of a
+     * module that gives `cx` out that the build reads neither as calls only nor as a forward.
+     */
+    readonly isHeld?: boolean;
 }
 declare const REPORT_CAUSE = "the build cannot tell which atoms these apply, and it ships only the atoms it can read.";
+/**
+ * The remedy lines only a host can write, given the application's problems: they print after the
+ * lines of the application's kinds and before any package's line.
+ */
+type HostRemedies = (application: readonly LocatedProblem[]) => readonly string[];
+/**
+ * What a host adds to the report besides where its options are written: the remedy lines only it
+ * can write, and where its own documentation says how to ship every atom, which is the Vite
+ * plugin's README section when it names none.
+ */
+interface ReportHost {
+    readonly remedies?: HostRemedies;
+    readonly everyAtom?: string;
+}
 /**
  * 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.
+ * the call of its plugin or its wrapper: the one place the report names its host. `host` adds
+ * what only the host can write, given as a {@link ReportHost} or, as before, as its remedy lines
+ * alone.
+ */
+declare function buildReport(problems: readonly LocatedProblem[], configured: readonly string[], home: string, host?: HostRemedies | ReportHost): string;
+
+/**
+ * One import a server module of the consumer's makes of a listed package: the module, root
+ * relative, the specifier it writes, what it takes from it (any name counting as a `cx` export),
+ * and the file the server loads for it when that is known.
+ */
+interface ServerImport {
+    readonly file?: string;
+    /**
+     * Whether the module imports the package in a way the build cannot read, such as `require()`.
+     */
+    readonly isUnreadable?: boolean;
+    /**
+     * Whether an earlier server command recorded it, not a server environment of this process.
+     */
+    readonly isRecorded?: boolean;
+    readonly specifier: string;
+    readonly takes: readonly Taken[];
+    readonly taker: string;
+}
+/**
+ * A server import whose target the client graph holds: the file it resolves to.
+ */
+interface ResolvedServerImport extends ServerImport {
+    readonly file: string;
+}
+
+/**
+ * What the build-end read of who takes a `cx` that a dependency gives out needs of its host: the
+ * module graph (who imports a module, the text of a module, what a specifier resolves to, how to
+ * parse a module) and a few lookups that need the file system, which a host supplies so this
+ * code imports no Node module. The Vite plugin supplies them from its `RenderContext` and
+ * `UsedContext`; another host supplies them from its own graph.
+ */
+
+/**
+ * What a host's module graph holds about one module.
+ */
+interface ModuleInfo {
+    readonly code: string | null;
+    readonly importers: readonly string[];
+    readonly dynamicImporters: readonly string[];
+}
+/**
+ * The module graph of a build, as the read of the takes asks it.
+ */
+interface ModuleHost {
+    /**
+     * The environment the build-end read runs for, which keys what it resolves once.
+     */
+    readonly environment: {
+        readonly name: string;
+    };
+    /**
+     * What the graph holds about the module `id`, or `null` when it holds none.
+     */
+    getModuleInfo?(id: string): ModuleInfo | null;
+    /**
+     * Resolves `source` as imported from `importer`.
+     */
+    resolve?(source: string, importer?: string): Promise<{
+        readonly id: string;
+    } | null>;
+    /**
+     * Every file id the host's build may resolve `source` to, for a host whose build resolves one
+     * specifier to different files (by condition, or by mode). Used instead of `resolve`, which
+     * answers one of them, wherever a resolution is compared to a file.
+     */
+    resolveAll?(source: string, importer?: string): Promise<readonly string[]>;
+    /**
+     * The host's parse of `code`, an ESTree.
+     */
+    parse?(code: string): unknown;
+    /**
+     * The host's parse of the module `id` whose text is `code`, for a host that reads authored
+     * sources whose language follows from the file. Used instead of `parse` when the host has it.
+     */
+    parseModule?(code: string, id: string): unknown;
+}
+/**
+ * What the read of the takes needs of the build: the project root, the options that decide which
+ * packages are listed, the modules `cxModules` lists (resolved once per environment and kept in
+ * `state.declared`), and the two lookups that need the file system.
+ */
+interface TakesContext {
+    readonly root: string;
+    /**
+     * How the host's messages name `root`, completing the phrase a specifier that resolves from
+     * <rootName>.
+     */
+    readonly rootName: string;
+    readonly options: {
+        readonly cxModules: readonly string[];
+        readonly keepFor: Readonly<Record<string, readonly string[]>>;
+    };
+    readonly state: {
+        readonly declared: Map<string, Promise<DeclaredModules>>;
+    };
+    /**
+     * The name of the package the module `id` belongs to, when it lies under `node_modules`.
+     */
+    packageOf(id: string): Promise<string | undefined>;
+    /**
+     * The path a message names the module `id` by: relative to the project root, forward slashes.
+     */
+    labelOf(id: string): string;
+}
+
+/**
+ * The modules that give out `cx` through one of its `cx` exports: the module that exports Nave's
+ * `cx`, and every module of a dependency, of the same package or of another, that only re-exports
+ * one of those exports (a forward, by `export ... from` or by one of the CommonJS forms
+ * `vite-require-takes.ts` reads), however many modules away. A module that takes `cx` from any of
+ * them takes it from the first. A dependency's other takes (a call, an assignment, a wrapper, a
+ * take the build cannot read) end the walk: they are the package's own calls.
+ */
+
+/**
+ * A module that gives out `cx`: the `cx` exports it holds, and whether it holds them by forwarding
+ * another module's rather than by exporting Nave's itself.
+ */
+interface Holder {
+    readonly id: string;
+    readonly names: ReadonlySet<string>;
+    readonly isReached: boolean;
+}
+
+/**
+ * A dependency's take of a module that gives out `cx` that the build reads neither as calls only
+ * nor as a forward: the importer's module, the package it belongs to and what it does, in words.
+ */
+interface Held {
+    readonly form: string;
+    readonly importer: string;
+    readonly pkg: string;
+    readonly taker: string;
+}
+interface Routes {
+    readonly entry: Take[];
+    readonly told: Take[];
+    /**
+     * The takes a dependency makes of the module that do more than re-export it: its calls.
+     */
+    readonly calls: Take[];
+    /**
+     * The takes a dependency makes of the module that the build reads neither as calls only nor as a
+     * forward, whatever the dependency is: they stay errors whatever the application imports.
+     */
+    readonly held: Held[];
+}
+
+/**
+ * One module that gives out `cx` with what the build read of its takes: the holders of its `cx`
+ * exports and the takes the importers of the build make of each. The imports a server environment
+ * makes are added when they are known, which can be after the environment that read the rest has
+ * ended.
+ */
+interface Prepared {
+    readonly holders: readonly Holder[];
+    readonly isHop: boolean;
+    readonly isListed: boolean;
+    /**
+     * Whether the module has a clearing specifier: a take of the module itself by an application
+     * module or a calling dependency is then on the `cxModules` route.
+     */
+    readonly hasEntry: boolean;
+    readonly problems: readonly LocatedProblem[];
+    /**
+     * How the host names its root, for the remedy line of the takes.
+     */
+    readonly rootName: string;
+    readonly routed: readonly Routes[];
+}
+
+/**
+ * The build-end judgement of the re-exports of `cx` that a package `keepFor` lists gives out: which
+ * of them stay errors because a module of the consumer takes a `cx` export through them, with the
+ * line that clears each. The Vite plugin calls it at build end, and a host with another module
+ * graph (see `ModuleHost`) calls it over its own, so both say the same thing about the same code.
+ */
+
+/**
+ * What reading one module found: its problems, those a `keepFor` entry stands in for set aside
+ * (`suppressed`), and the listed files it reads a `cx` from when it reads no other (`onlyVia`).
+ */
+interface ModuleOutcome {
+    readonly onlyVia?: ReadonlySet<string> | undefined;
+    readonly problems: readonly LocatedProblem[];
+    readonly suppressed: readonly LocatedProblem[];
+}
+/**
+ * The problems the build fails with, given what each module's reading found: those of a package
+ * `keepFor` lists are only the ones its listing does not stand in for, a listed module that
+ * exports a `cx` the build does not follow and a `cx` export that a module the consumer can
+ * change takes. `serverImports` are the imports a server environment makes of a listed package it
+ * leaves external, when the host has such environments.
+ * @param host The module graph of the build.
+ * @param context The project root, the options, and the lookups that need the file system.
+ * @param modules What each module's reading found.
+ * @param serverImports What the server environments imported of a listed package.
+ * @returns The problems to report, and what was read of the takes of each re-exporting module.
+ */
+declare function judgeReexports(host: ModuleHost, context: TakesContext, modules: readonly ModuleOutcome[], serverImports?: readonly ResolvedServerImport[]): Promise<{
+    prepared: Prepared[];
+    problems: LocatedProblem[];
+}>;
+
+/**
+ * Whether a module of a dependency hands out the Nave `cx` it imports in a form the build does not
+ * bind: see `isImportedCxHandedOut`.
+ */
+
+/**
+ * Whether a module of a dependency hands out the Nave `cx` it imports in a form the build does not
+ * bind (a `require()`, a dynamic import, or a specifier other than the package's own), the string
+ * naming it starting at `offset`: its result is used for more than calls, or the build cannot find
+ * the import. A `cx` that is only called is the package's own call.
+ */
+declare function isImportedCxHandedOut(program: AstNode, offset: number): boolean;
+
+/**
+ * `atoms` with the atoms added that restore what an atom in it removes: `srOnlyFocusable` shows
+ * again on focus what `srOnly` hides, so a set that holds `srOnly` holds it too. This adds to the
+ * emitted set only, not to `keep` or to what `cx.dynamic()` accepts.
  */
-declare function buildReport(problems: readonly LocatedProblem[], configured: readonly string[], home: string): string;
+declare function withRestorers(atoms: Set<string>): Set<string>;
 
-export { type AstNode, CX_SOURCE, type LocatedProblem, type ModuleReading, type Problem, type ProblemKind, REPORT_CAUSE, type ReadOptions, buildReport, readModule };
+export { CX_SOURCE, REPORT_CAUSE, buildReport, inspectAtomicLayer, isImportedCxHandedOut, judgeReexports, pruneAtomicLayer, readModule, unprunedAtoms, withRestorers };
+export type { AstNode, HostRemedies, LayerReading, LocatedProblem, ModuleHost, ModuleInfo, ModuleOutcome, ModuleReading, Problem, ProblemKind, ReadOptions, ReportHost, TakesContext };

package/dist/collect.js

@@ -1,4 +1,41 @@
-export { CX_SOURCE, REPORT_CAUSE, assertOptions, buildReport, keptAtoms, readModule, resolveUsedOptions } from './chunk-E5F6YF7A.js';
+import { analyze, isUsedAsCallsOnly, CX_ONLY, nodesAt, nodeAt, pushAll, childrenOf, staticStringOf, flowOf } from './chunk-EYMFWE3A.js';
+export { CX_SOURCE, REPORT_CAUSE, assertOptions, buildReport, inspectAtomicLayer, judgeReexports, keptAtoms, pruneAtomicLayer, readModule, resolveUsedOptions, unprunedAtoms, withRestorers } from './chunk-EYMFWE3A.js';
 import './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';
+import './chunk-2K5EBBF2.js';
 import './chunk-GZL2VW7C.js';
+
+// src/vite-require-handed-out.ts
+function allNodes(program) {
+  const found = [];
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    found.push(node);
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+function importAt(nodes, offset) {
+  return nodes.find((node) => {
+    const literal = node.type === "CallExpression" ? nodesAt(node, "arguments")[0] : nodeAt(node, "source") ?? nodeAt(nodeAt(node, "moduleReference") ?? node, "expression");
+    return literal?.start === offset && node.type !== "Literal";
+  });
+}
+function isDeclarationHandedOut(analysis, declaration) {
+  const source = staticStringOf(nodeAt(declaration, "source"));
+  return analysis.references.filter(({ binding }) => binding?.kind === "import" && binding.source === source).some(({ node }) => {
+    const flow = flowOf(analysis, node);
+    return flow.isUnbound || flow.names.size > 0;
+  });
+}
+function isImportedCxHandedOut(program, offset) {
+  const analysis = analyze(program);
+  const node = importAt(allNodes(program), offset);
+  if (!node) return true;
+  if (node.type === "ImportDeclaration") return isDeclarationHandedOut(analysis, node);
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") return true;
+  return !isUsedAsCallsOnly(analysis, node, CX_ONLY);
+}
+
+export { isImportedCxHandedOut };

package/dist/css.d.ts

@@ -0,0 +1 @@
+export {}