introduce the virtual filesystem everywhere

this unfortunately means I had to cut some features (bye bye commit history! for now)
stuff's not quite 100% working just yet (like branch links, which were and are still broken)
we also don't have content_version impls just yet

crates/treehouse/src/import_map.rs

@@ -1,11 +1,9 @@
-use std::{ffi::OsStr, path::PathBuf};
+use std::ops::ControlFlow;
 
 use indexmap::IndexMap;
-use log::warn;
 use serde::{Deserialize, Serialize};
-use walkdir::WalkDir;
 
-use crate::static_urls::StaticUrls;
+use crate::vfs::{self, Dir, VPathBuf};
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ImportMap {
@@ -15,49 +13,30 @@ pub struct ImportMap {
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ImportRoot {
     pub name: String,
-    pub path: String,
+    pub path: VPathBuf,
 }
 
 impl ImportMap {
-    pub fn generate(base_url: String, import_roots: &[ImportRoot]) -> Self {
+    pub fn generate(site: &str, root: &dyn Dir, import_roots: &[ImportRoot]) -> Self {
         let mut import_map = ImportMap {
             imports: IndexMap::new(),
         };
 
-        for root in import_roots {
-            let static_urls = StaticUrls::new(
-                PathBuf::from(&root.path),
-                format!("{base_url}/{}", root.path),
-            );
-            for entry in WalkDir::new(&root.path) {
-                let entry = match entry {
-                    Ok(entry) => entry,
-                    Err(error) => {
-                        warn!("directory walk failed: {error}");
-                        continue;
-                    }
-                };
-
-                if !entry.file_type().is_dir() && entry.path().extension() == Some(OsStr::new("js"))
-                {
-                    let normalized_path = entry
-                        .path()
-                        .strip_prefix(&root.path)
-                        .unwrap_or(entry.path())
-                        .to_string_lossy()
-                        .replace('\\', "/");
-                    match static_urls.get(&normalized_path) {
-                        Ok(url) => {
-                            import_map
-                                .imports
-                                .insert(format!("{}/{normalized_path}", root.name), url);
-                        }
-                        Err(error) => {
-                            warn!("could not get static url for {normalized_path}: {error}")
-                        }
-                    }
+        for import_root in import_roots {
+            vfs::walk_dir_rec(root, &import_root.path, &mut |path| {
+                if path.extension() == Some("js") {
+                    import_map.imports.insert(
+                        format!(
+                            "{}/{}",
+                            import_root.name,
+                            path.strip_prefix(&import_root.path).unwrap_or(path)
+                        ),
+                        vfs::url(site, root, path)
+                            .expect("import directory is not anchored anywhere"),
+                    );
                 }
-            }
+                ControlFlow::Continue(())
+            });
         }
 
         import_map.imports.sort_unstable_keys();