css: emit @layer statements that precede @import before the imported files

scripts/css-layer-fuzz.ts

@@ -0,0 +1,67 @@
+// bun scripts/css-layer-fuzz.ts <bun> <graphs> [first seed] [baseline bun]
+//   [--cycles] [--anonymous] [--no-leading-statements] [--empty-blocks]
+// Runs test/bundler/css-layer-order.ts over many seeds against <bun> and prints the seeds where the bundle does not
+// have the cascade layers of its sources. `<graphs>` = 1 prints the files of that seed too. With a baseline binary it
+// also prints the seeds the baseline gets right and <bun> gets wrong, and how many are the other way round. It does
+// that twice: for the whole check, and for the rule that `.t` gets alone, which is what a page shows.
+import { resolve } from "node:path";
+import {
+  checkGraph,
+  generateGraph,
+  isWinnerProblem,
+  type GraphOptions,
+  type GraphResult,
+} from "../test/bundler/css-layer-order";
+
+const known = ["--cycles", "--anonymous", "--no-leading-statements", "--empty-blocks"];
+const flags = process.argv.slice(2).filter(arg => arg.startsWith("--"));
+const [bun, count = "100", first = "1", baseline] = process.argv.slice(2).filter(arg => !arg.startsWith("--"));
+if (!bun || flags.some(flag => !known.includes(flag))) {
+  console.error(
+    `usage: bun scripts/css-layer-fuzz.ts <bun> <graphs> [first seed] [baseline bun] [${known.join("] [")}]`,
+  );
+  process.exit(1);
+}
+const options: GraphOptions = {
+  cycles: flags.includes("--cycles"),
+  anonymous: flags.includes("--anonymous"),
+  leadingStatements: !flags.includes("--no-leading-statements"),
+  emptyBlocks: flags.includes("--empty-blocks"),
+};
+const locate = (binary: string) => Bun.which(binary) ?? resolve(binary);
+const [target, before] = [locate(bun), baseline && locate(baseline)];
+if (Number(count) === 1) {
+  for (const [name, css] of Object.entries(generateGraph(Number(first), options).files))
+    console.log(`/* ${name} */\n${css}`);
+}
+const tally = { ok: 0, wrong: 0, skipped: 0, wrongWinner: 0 };
+const wrongWinner = (result: GraphResult) => result.status === "wrong" && result.problems.some(isWinnerProblem);
+const regressed = { whole: [] as number[], winner: [] as number[] };
+const repaired = { whole: 0, winner: 0 };
+const parallel = 8;
+const end = Number(first) + Number(count);
+for (let seed = Number(first); seed < end; seed += parallel) {
+  const batch: Promise<[GraphResult, GraphResult | undefined]>[] = [];
+  for (let s = seed; s < Math.min(end, seed + parallel); s++) {
+    batch.push(Promise.all([checkGraph(target, s, options), before ? checkGraph(before, s, options) : undefined]));
+  }
+  for (const [result, old] of await Promise.all(batch)) {
+    tally[result.status]++;
+    if (wrongWinner(result)) tally.wrongWinner++;
+    if (result.status !== "ok")
+      console.log(`seed ${result.seed} ${result.status}:\n  ` + result.problems.slice(0, 6).join("\n  "));
+    if (!old || old.status === "skipped" || result.status === "skipped") continue;
+    if (old.status === "ok" && result.status === "wrong") regressed.whole.push(result.seed);
+    if (old.status === "wrong" && result.status === "ok") repaired.whole++;
+    if (!wrongWinner(old) && wrongWinner(result)) regressed.winner.push(result.seed);
+    if (wrongWinner(old) && !wrongWinner(result)) repaired.winner++;
+  }
+}
+if (before) {
+  const seeds = (list: number[]) => `${list.length} graphs` + (list.length ? ` (seeds ${list.join(", ")})` : "");
+  console.log(`right with the baseline, wrong with <bun>: ${seeds(regressed.whole)}`);
+  console.log(`wrong with the baseline, right with <bun>: ${repaired.whole} graphs`);
+  console.log(`.t gets the right rule with the baseline and another with <bun>: ${seeds(regressed.winner)}`);
+  console.log(`.t gets another rule with the baseline and the right one with <bun>: ${repaired.winner} graphs`);
+}
+console.log(JSON.stringify({ graphs: Number(count), firstSeed: Number(first), ...tally }));

src/bundler/Chunk.rs

@@ -112,7 +112,7 @@ impl Default for Content<'_> {
 
 // SAFETY: `Chunk` is processed across the bundler thread pool (see
 // `computeCrossChunkDependencies`, `generateChunksInParallel`). Raw-pointer
-// fields (`Layers::Borrowed`, `ChunkRenamer` arena)
+// fields (`Layers::Borrowed`, `Layers::PreImport`, `ChunkRenamer` arena)
 // point into bundler-arena storage that outlives the
 // pool join and is only mutated by the owning task; this mirrors
 // `InputFile`'s blanket impls (bundle_v2.rs).
@@ -1397,6 +1397,7 @@ pub enum CssImportOrderKind<'a> {
     /// We don't want to redundantly print the rules of these redundant imports
     /// BUT, the imports may include layers.
     /// We'll just print layer name declarations so that the original ordering is preserved.
+    /// `Layers::PreImport` is the other producer: the statements a file has ahead of its first "@import".
     #[strum(serialize = "layers")]
     Layers(Layers),
     #[strum(serialize = "external_path")]
@@ -1414,13 +1415,15 @@ pub enum Layers {
     /// Borrowed from another `CssImportOrder`'s `Layers` or the parsed stylesheet.
     Borrowed(bun_ptr::BackRef<Vec<bun_css::LayerName>>),
     Owned(Vec<bun_css::LayerName>),
+    /// A stylesheet's `layers_pre_import`, borrowed. The order passes keep or remove this entry, and never change it.
+    PreImport(bun_ptr::BackRef<Vec<bun_css::LayerName>>),
 }
 
 impl Layers {
     #[inline]
     pub(crate) fn inner(&self) -> &Vec<bun_css::LayerName> {
         match self {
-            Layers::Borrowed(p) => p.get(),
+            Layers::Borrowed(p) | Layers::PreImport(p) => p.get(),
             Layers::Owned(b) => b,
         }
     }
@@ -1439,6 +1442,12 @@ impl Layers {
         Layers::Borrowed(bun_ptr::BackRef::from(p))
     }
 
+    /// `borrow()` for a stylesheet's `layers_pre_import`.
+    #[inline]
+    pub(crate) fn pre_import(p: core::ptr::NonNull<Vec<bun_css::LayerName>>) -> Self {
+        Layers::PreImport(bun_ptr::BackRef::from(p))
+    }
+
     /// Drop owned (arena-backed, so no-op) and
     /// install a fresh owned value.
     #[inline]
@@ -1449,17 +1458,34 @@ impl Layers {
     /// If borrowed, deep-clone into an owned
     /// list and return `&mut` to it; if already owned, return as-is.
     pub(crate) fn to_owned(&mut self) -> &mut Vec<bun_css::LayerName> {
-        if let Layers::Borrowed(p) = *self {
+        if let Layers::Borrowed(p) | Layers::PreImport(p) = *self {
             *self = Layers::Owned(p.deep_clone_with(|l| l.clone()));
         }
         match self {
             Layers::Owned(b) => b,
-            Layers::Borrowed(_) => unreachable!(),
+            Layers::Borrowed(_) | Layers::PreImport(_) => unreachable!(),
         }
     }
 }
 
 impl CssImportOrder<'_> {
+    /// Whether this entry prints only "@layer" statements, which may precede an "@import".
+    pub(crate) fn prints_as_layer_statements(&self) -> bool {
+        let CssImportOrderKind::Layers(layers) = &self.kind else {
+            return false;
+        };
+        match self.conditions.slice() {
+            [] => true,
+            [only] => {
+                layers.inner().is_empty()
+                    && only.layer.as_ref().is_some_and(|layer| layer.v.is_some())
+                    && only.supports.is_none()
+                    && only.media.media_queries.is_empty()
+            }
+            _ => false,
+        }
+    }
+
     pub(crate) fn hash<H: bun_core::Hasher + ?Sized>(&self, hasher: &mut H) {
         // TODO: conditions, condition_import_records