@@ -5,7 +5,6 @@ use std::fs::{File, OpenOptions};
 use std::io::{ErrorKind, Read, Write};
 use std::path::{Path, PathBuf};
 
-use crate::artifacts::constants::NEW_FILE_MODE;
 use crate::artifacts::errors::ArtifactError;
 use crate::artifacts::models::{Publication, WrittenArtifacts};
 
@@ -261,7 +260,9 @@ fn copy_new_file(source: &Path, path: &Path) -> std::io::Result<()> {
     #[cfg(unix)]
     {
         use std::os::unix::fs::PermissionsExt;
-        let _ = builder.permissions(std::fs::Permissions::from_mode(NEW_FILE_MODE));
+        let _ = builder.permissions(std::fs::Permissions::from_mode(
+            crate::artifacts::constants::NEW_FILE_MODE,
+        ));
     }
     let mut temporary = builder.tempfile_in(directory)?;
     temporary.write_all(&std::fs::read(source)?)?;
 
@@ -1,12 +1,15 @@
-//! `pathlib.PurePosixPath` spelling and ordering over raw path bytes.
+//! `pathlib` spelling, ordering and stat reads for startup stamps on each platform.
 
-use std::ffi::OsString;
-use std::os::unix::ffi::{OsStrExt, OsStringExt};
+use std::ffi::OsStr;
+use std::fs::Metadata;
 use std::path::{Path, PathBuf};
 
+use crate::startup_inputs::constants::PATH_FILE_SUFFIX;
+#[cfg(unix)]
 use crate::startup_inputs::constants::{CURRENT, SEPARATOR};
 
 /// The root a POSIX path keeps: two leading slashes stay two, more collapse to one.
+#[cfg(unix)]
 fn root(bytes: &[u8]) -> &[u8] {
     match bytes {
         [SEPARATOR, SEPARATOR, rest @ ..] if rest.first() != Some(&SEPARATOR) => &bytes[..2],
@@ -16,11 +19,14 @@ fn root(bytes: &[u8]) -> &[u8] {
 }
 
 /// `str(PurePosixPath(path, *children))`.
-pub(crate) fn pure(path: &Path, children: &[&[u8]]) -> PathBuf {
+#[cfg(unix)]
+pub(crate) fn pure(path: &Path, children: &[&OsStr]) -> PathBuf {
+    use std::os::unix::ffi::{OsStrExt, OsStringExt};
+
     let bytes: &[u8] = path.as_os_str().as_bytes();
     let mut text: Vec<u8> = root(bytes).to_vec();
     let parts = std::iter::once(bytes)
-        .chain(children.iter().copied())
+        .chain(children.iter().map(|child| child.as_bytes()))
         .flat_map(|segment| segment.split(|byte| *byte == SEPARATOR))
         .filter(|part| !part.is_empty() && *part != CURRENT);
     let mut first: bool = true;
@@ -34,22 +40,82 @@ pub(crate) fn pure(path: &Path, children: &[&[u8]]) -> PathBuf {
     if text.is_empty() {
         text.extend_from_slice(CURRENT);
     }
-    PathBuf::from(OsString::from_vec(text))
+    PathBuf::from(std::ffi::OsString::from_vec(text))
+}
+
+/// `str(PureWindowsPath(path, *children))` through the platform path rules.
+#[cfg(not(unix))]
+pub(crate) fn pure(path: &Path, children: &[&OsStr]) -> PathBuf {
+    let mut joined: PathBuf = path.components().collect();
+    for child in children {
+        joined.push(child);
+    }
+    joined
 }
 
 /// `str(Path(path).absolute())` against the working directory `cwd`.
 pub(crate) fn absolute(path: &Path, cwd: &Path) -> PathBuf {
-    if root(path.as_os_str().as_bytes()).is_empty() {
-        pure(cwd, &[path.as_os_str().as_bytes()])
-    } else {
+    if path.has_root() && (cfg!(unix) || path.is_absolute()) {
         pure(path, &[])
+    } else {
+        pure(cwd, &[path.as_os_str()])
     }
 }
 
 /// The `/`-separated parts `PurePosixPath` orders paths by.
-pub(crate) fn order_key(path: &Path) -> Vec<&[u8]> {
+#[cfg(unix)]
+pub(crate) fn order_key(path: &Path) -> Vec<Vec<u8>> {
+    use std::os::unix::ffi::OsStrExt;
+
     path.as_os_str()
         .as_bytes()
         .split(|byte| *byte == SEPARATOR)
+        .map(<[u8]>::to_vec)
+        .collect()
+}
+
+/// The case-folded parts `PureWindowsPath` orders paths by.
+#[cfg(not(unix))]
+pub(crate) fn order_key(path: &Path) -> Vec<Vec<u8>> {
+    path.components()
+        .map(|part| {
+            part.as_os_str()
+                .to_string_lossy()
+                .to_lowercase()
+                .into_bytes()
+        })
         .collect()
 }
+
+/// Whether `glob("*.pth")` matches a directory entry name on this platform.
+pub(crate) fn is_path_file(name: &OsStr) -> bool {
+    if cfg!(unix) {
+        name.as_encoded_bytes().ends_with(PATH_FILE_SUFFIX)
+    } else {
+        name.to_string_lossy()
+            .to_lowercase()
+            .as_bytes()
+            .ends_with(PATH_FILE_SUFFIX)
+    }
+}
+
+/// `os.stat(path).st_mtime_ns`.
+#[cfg(unix)]
+pub(crate) fn modified_ns(metadata: &Metadata) -> std::io::Result<i64> {
+    use std::os::unix::fs::MetadataExt;
+
+    Ok(metadata.mtime() * 1_000_000_000 + metadata.mtime_nsec())
+}
+
+/// `os.stat(path).st_mtime_ns` from the platform modification time, negative before 1970.
+#[cfg(not(unix))]
+pub(crate) fn modified_ns(metadata: &Metadata) -> std::io::Result<i64> {
+    let modified: std::time::SystemTime = metadata.modified()?;
+    let (nanos, sign): (u128, i64) = match modified.duration_since(std::time::UNIX_EPOCH) {
+        Ok(elapsed) => (elapsed.as_nanos(), 1),
+        Err(before) => (before.duration().as_nanos(), -1),
+    };
+    i64::try_from(nanos)
+        .map(|value| sign * value)
+        .map_err(std::io::Error::other)
+}
@@ -1,8 +1,10 @@
 //! Names the startup stamps read.
 
 /// The virtual-environment configuration file of an interpreter prefix.
-pub(crate) const VENV_CONFIG: &[u8] = b"pyvenv.cfg";
+pub(crate) const VENV_CONFIG: &str = "pyvenv.cfg";
 /// The suffix of the path configuration files `site` processes.
 pub(crate) const PATH_FILE_SUFFIX: &[u8] = b".pth";
+#[cfg(unix)]
 pub(crate) const SEPARATOR: u8 = b'/';
+#[cfg(unix)]
 pub(crate) const CURRENT: &[u8] = b".";
@@ -1,14 +1,14 @@
 //! Stamp every startup directory, its `.pth` files, the interpreter and its venv configuration.
 
 use std::collections::BTreeSet;
-use std::ffi::OsString;
+use std::ffi::{OsStr, OsString};
 use std::io;
-use std::os::unix::ffi::OsStrExt;
-use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
 
-use crate::startup_inputs::_helpers::pure_paths::{absolute, order_key, pure};
-use crate::startup_inputs::constants::{PATH_FILE_SUFFIX, VENV_CONFIG};
+use crate::startup_inputs::_helpers::pure_paths::{
+    absolute, is_path_file, modified_ns, order_key, pure,
+};
+use crate::startup_inputs::constants::VENV_CONFIG;
 use crate::startup_inputs::models::{StartupLocations, StartupStamp};
 
 /// Sorted stamps of the startup paths; missing paths are unstamped and other stat failures fail.
@@ -32,29 +32,33 @@ pub fn startup_stamps(
         locations
             .prefixes
             .iter()
-            .map(|prefix| pure(prefix, &[VENV_CONFIG]).into_os_string()),
+            .map(|prefix| pure(prefix, &[OsStr::new(VENV_CONFIG)]).into_os_string()),
     );
     for directory in &directories {
         let directory: &Path = Path::new(directory);
         let Ok(listing) = std::fs::read_dir(directory) else {
             continue;
         };
         for entry in listing.flatten() {
-            if entry.file_name().as_bytes().ends_with(PATH_FILE_SUFFIX) {
-                paths.insert(pure(directory, &[entry.file_name().as_bytes()]).into_os_string());
+            let name: OsString = entry.file_name();
+            if is_path_file(&name) {
+                paths.insert(pure(directory, &[name.as_os_str()]).into_os_string());
             }
         }
     }
     let mut ordered: Vec<PathBuf> = paths.into_iter().map(PathBuf::from).collect();
-    ordered.sort_by(|left, right| order_key(left).cmp(&order_key(right)));
+    ordered.sort_by_key(|path| order_key(path));
     ordered
         .into_iter()
         .map(|path| match std::fs::metadata(&path) {
-            Ok(metadata) => Ok(StartupStamp {
-                modified_ns: Some(metadata.mtime() * 1_000_000_000 + metadata.mtime_nsec()),
-                size: Some(metadata.len()),
-                path,
-            }),
+            Ok(metadata) => match modified_ns(&metadata) {
+                Ok(modified) => Ok(StartupStamp {
+                    modified_ns: Some(modified),
+                    size: Some(metadata.len()),
+                    path,
+                }),
+                Err(error) => Err((path, error)),
+            },
             Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(StartupStamp {
                 path,
                 modified_ns: None,