fix ci

Author: ubugeeei

crates/vite_global_cli/src/commands/release/mod.rs

@@ -550,7 +550,11 @@ fn resolved_publish_tag<'a>(
     plan: &'a PackageReleasePlan,
     options: &'a ReleaseOptions,
 ) -> Option<&'a str> {
-    options.preid.as_deref().or(plan.publish_tag.as_deref())
+    options
+        .preid
+        .as_deref()
+        .or_else(|| prerelease_channel(&plan.next_version))
+        .or(plan.publish_tag.as_deref())
 }
 
 /// Resolves the effective provenance preference for a package release.

crates/vite_global_cli/src/commands/release/planning.rs

@@ -610,10 +610,11 @@ fn prerelease_with_number(prerelease_tag: &PrereleaseTag, number: u64) -> Result
 
 fn parse_repository_release_version(tag_name: &str) -> Option<Version> {
     let version = Version::parse(tag_name.strip_prefix(REPOSITORY_RELEASE_TAG_PREFIX)?).ok()?;
-    match prerelease_channel(&version) {
-        None | Some("alpha" | "beta" | "rc") => Some(version),
-        Some(_) => None,
+    if version.has_prerelease() && prerelease_number(&version).is_none() {
+        return None;
     }
+
+    Some(version)
 }
 
 fn release_queue_entry(package: &WorkspacePackage) -> ReleaseQueueEntry {

crates/vite_global_cli/src/commands/release/storage.rs

@@ -250,8 +250,6 @@ pub(super) async fn run_release_checks(
     output::raw("");
     output::info("Running release checks:");
 
-    let workspace_script_names: HashSet<&str> =
-        readiness_report.workspace_scripts.iter().map(String::as_str).collect();
     for script in &readiness_report.workspace_scripts {
         raw_progress_line!("workspace script `", script, '`');
         let status = package_manager
@@ -278,11 +276,7 @@ pub(super) async fn run_release_checks(
             continue;
         };
 
-        for script in readiness
-            .scripts
-            .iter()
-            .filter(|script| !workspace_script_names.contains(script.as_str()))
-        {
+        for script in &readiness.scripts {
             raw_progress_line!(&plan.name, " script `", script, '`');
             let status = package_manager
                 .run_script_command(
@@ -569,20 +563,33 @@ async fn publish_packages_inner(
     Ok((published_count, ExitStatus::default()))
 }
 
-fn apply_manifest_edits(
+pub(super) fn apply_manifest_edits(
     manifest_edits: &[ManifestEdit],
     restore_original: bool,
 ) -> Result<(), Error> {
+    let mut applied_edits = 0usize;
     for edit in manifest_edits {
         let contents =
             if restore_original { &edit.original_contents } else { &edit.updated_contents };
-        fs::write(&edit.path, contents).map_err(|error| {
+        if let Err(error) = fs::write(&edit.path, contents) {
+            let rollback_result =
+                rollback_manifest_edits(&manifest_edits[..applied_edits], !restore_original);
             let mut message = String::from("write release manifest for ");
             message.push_str(&edit.package);
             message.push_str(": ");
             push_display(&mut message, error);
-            Error::UserMessage(message.into())
-        })?;
+            match rollback_result {
+                Ok(()) => {
+                    message.push_str(". Previously written release manifests were rolled back.");
+                }
+                Err(rollback_error) => {
+                    message.push_str(" | rollback error: ");
+                    push_display(&mut message, rollback_error);
+                }
+            }
+            return Err(Error::UserMessage(message.into()));
+        }
+        applied_edits += 1;
     }
 
     Ok(())
@@ -598,6 +605,25 @@ fn write_release_artifact_edit(edit: &ReleaseArtifactEdit) -> Result<(), Error>
     })
 }
 
+fn rollback_manifest_edits(
+    manifest_edits: &[ManifestEdit],
+    restore_original: bool,
+) -> Result<(), Error> {
+    for edit in manifest_edits.iter().rev() {
+        let contents =
+            if restore_original { &edit.original_contents } else { &edit.updated_contents };
+        fs::write(&edit.path, contents).map_err(|error| {
+            let mut message = String::from("restore release manifest for ");
+            message.push_str(&edit.package);
+            message.push_str(": ");
+            push_display(&mut message, error);
+            Error::UserMessage(message.into())
+        })?;
+    }
+
+    Ok(())
+}
+
 fn rollback_applied_release_artifact_edits(edits: &[ReleaseArtifactEdit]) -> Result<(), Error> {
     for edit in edits.iter().rev() {
         restore_release_artifact_edit(edit)?;
@@ -653,12 +679,11 @@ fn build_updated_manifest_contents(
     plan: &PackageReleasePlan,
     release_versions: &HashMap<&str, &Version>,
 ) -> Result<String, Error> {
-    let current_version = plan.current_version.to_string();
     let next_version = plan.next_version.to_string();
     let mut updated = replace_top_level_string_property(
         &plan.manifest_contents,
         "version",
-        &current_version,
+        &plan.manifest.version,
         &next_version,
     )?;
 

crates/vite_global_cli/src/commands/release/tests.rs

@@ -394,6 +394,23 @@ fn resolved_publish_tag_falls_back_to_manifest_tag() {
     assert_eq!(resolved_publish_tag(&plan, &make_release_options()), Some("next"));
 }
 
+#[test]
+fn resolved_publish_tag_uses_prerelease_channel_from_target_version() {
+    let mut plan = make_release_plan("pkg-a", &[], &[]);
+    plan.next_version = Version::parse("1.0.1-beta.2").unwrap();
+    plan.publish_tag = Some("next".into());
+
+    assert_eq!(resolved_publish_tag(&plan, &make_release_options()), Some("beta"));
+}
+
+#[test]
+fn resolved_publish_tag_supports_custom_prerelease_channels() {
+    let mut plan = make_release_plan("pkg-a", &[], &[]);
+    plan.next_version = Version::parse("1.0.1-canary.0").unwrap();
+
+    assert_eq!(resolved_publish_tag(&plan, &make_release_options()), Some("canary"));
+}
+
 #[test]
 fn build_manifest_edits_updates_simple_internal_dependency_ranges() {
     let mut pkg_a = make_release_plan("pkg-a", &[], &[]);
@@ -445,6 +462,24 @@ fn build_manifest_edits_rejects_complex_internal_dependency_ranges() {
     assert!(error.to_string().contains("Use `workspace:` or a simple exact/^/~ version"));
 }
 
+#[test]
+fn build_manifest_edits_supports_tag_sourced_zero_versions() {
+    let mut plan = make_release_plan("pkg-a", &[], &[]);
+    plan.current_version = Version::parse("0.0.0-16aec32").unwrap();
+    plan.next_version = Version::parse("1.2.3").unwrap();
+    plan.manifest.version = "0.0.0".into();
+    plan.manifest_contents = r#"{
+  "name": "pkg-a",
+  "version": "0.0.0"
+}
+"#
+    .into();
+
+    let edits = build_manifest_edits(&[plan]).unwrap();
+    assert_eq!(edits.len(), 1);
+    assert!(edits[0].updated_contents.contains(r#""version": "1.2.3""#));
+}
+
 #[test]
 fn readiness_report_collects_workspace_and_package_scripts() {
     let workspace_manifest: PackageManifest = serde_json::from_str(
@@ -705,6 +740,64 @@ fn summarize_release_artifacts_counts_manifests_and_changelogs() {
     assert_eq!(summary.total_file_count(), 5);
 }
 
+#[test]
+fn apply_manifest_edits_rolls_back_partial_updates() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let workspace_root = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+    let good_path = workspace_root.join("packages/pkg-a/package.json");
+    std::fs::create_dir_all(good_path.as_path().parent().unwrap()).unwrap();
+    std::fs::write(&good_path, "{\"version\":\"1.0.0\"}").unwrap();
+
+    let bad_path = workspace_root.join("missing/pkg-b/package.json");
+    let edits = vec![
+        ManifestEdit {
+            package: "pkg-a".into(),
+            path: good_path.clone(),
+            original_contents: "{\"version\":\"1.0.0\"}".into(),
+            updated_contents: "{\"version\":\"1.0.1\"}".into(),
+        },
+        ManifestEdit {
+            package: "pkg-b".into(),
+            path: bad_path,
+            original_contents: "{\"version\":\"1.0.0\"}".into(),
+            updated_contents: "{\"version\":\"1.0.1\"}".into(),
+        },
+    ];
+
+    let error = apply_manifest_edits(&edits, false).unwrap_err();
+    assert!(error.to_string().contains("rolled back"));
+    assert_eq!(std::fs::read_to_string(&good_path).unwrap(), "{\"version\":\"1.0.0\"}");
+}
+
+#[test]
+fn apply_manifest_edits_rolls_back_partial_restore_to_updated_state() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let workspace_root = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+    let good_path = workspace_root.join("packages/pkg-a/package.json");
+    std::fs::create_dir_all(good_path.as_path().parent().unwrap()).unwrap();
+    std::fs::write(&good_path, "{\"version\":\"1.0.1\"}").unwrap();
+
+    let bad_path = workspace_root.join("missing/pkg-b/package.json");
+    let edits = vec![
+        ManifestEdit {
+            package: "pkg-a".into(),
+            path: good_path.clone(),
+            original_contents: "{\"version\":\"1.0.0\"}".into(),
+            updated_contents: "{\"version\":\"1.0.1\"}".into(),
+        },
+        ManifestEdit {
+            package: "pkg-b".into(),
+            path: bad_path,
+            original_contents: "{\"version\":\"1.0.0\"}".into(),
+            updated_contents: "{\"version\":\"1.0.1\"}".into(),
+        },
+    ];
+
+    let error = apply_manifest_edits(&edits, true).unwrap_err();
+    assert!(error.to_string().contains("rolled back"));
+    assert_eq!(std::fs::read_to_string(&good_path).unwrap(), "{\"version\":\"1.0.1\"}");
+}
+
 #[test]
 fn rollback_release_artifact_edits_restores_and_removes_files() {
     let temp_dir = tempfile::tempdir().unwrap();
@@ -923,7 +1016,7 @@ fn invalid_release_tags_are_ignored() {
 }
 
 #[test]
-fn repository_release_tags_accept_stable_and_standard_prereleases_only() {
+fn repository_release_tags_accept_stable_and_numbered_prereleases() {
     assert_eq!(
         parse_repository_release_tag_version_for_tests("v1.2.3").unwrap().to_string(),
         "1.2.3"
@@ -932,7 +1025,14 @@ fn repository_release_tags_accept_stable_and_standard_prereleases_only() {
         parse_repository_release_tag_version_for_tests("v1.2.4-alpha.1").unwrap().to_string(),
         "1.2.4-alpha.1"
     );
+    assert_eq!(
+        parse_repository_release_tag_version_for_tests("v1.2.5-canary.0").unwrap().to_string(),
+        "1.2.5-canary.0"
+    );
     assert!(parse_repository_release_tag_version_for_tests("v0.0.0-16aec32").is_none());
+    assert!(
+        parse_repository_release_tag_version_for_tests("v0.0.0-0bfcc90f.20260209-0731").is_none()
+    );
     assert!(parse_repository_release_tag_version_for_tests("release/pkg-a/v1.0.0").is_none());
 }