crates/cli/src/main_tests.rs

GitHub
use super::*;
use std::time::{Duration, SystemTime, UNIX_EPOCH};

#[test]
fn parses_extract_without_js_input() {
    let cli = Cli::try_parse_from(["wakaru", "extract", "input.js.map", "-o", "src"])
        .expect("extract command should parse");

    match cli.command {
        Some(Command::Extract(args)) => {
            assert_eq!(args.map, PathBuf::from("input.js.map"));
            assert_eq!(args.output, PathBuf::from("src"));
        }
        other => panic!("expected extract command, got {other:?}"),
    }
}

#[test]
fn rejects_legacy_extract_flag() {
    assert!(Cli::try_parse_from([
        "wakaru",
        "input.js",
        "--extract",
        "-m",
        "input.js.map",
        "-o",
        "src"
    ])
    .is_err());
}

#[test]
fn parses_debug_trace_command() {
    let cli = Cli::try_parse_from([
        "wakaru",
        "debug",
        "trace",
        "input.js",
        "--from",
        "UnEsm",
        "--until",
        "SmartInline",
        "--all",
    ])
    .expect("debug trace command should parse");

    match cli.command {
        Some(Command::Debug(DebugArgs {
            command: DebugCommand::Trace(args),
        })) => {
            assert_eq!(args.input, PathBuf::from("input.js"));
            assert_eq!(args.from.as_deref(), Some("UnEsm"));
            assert_eq!(args.until.as_deref(), Some("SmartInline"));
            assert!(args.all);
        }
        other => panic!("expected debug trace command, got {other:?}"),
    }
}

#[test]
fn parses_debug_normalize_command() {
    let cli = Cli::try_parse_from(["wakaru", "debug", "normalize", "input.js", "--rename"])
        .expect("debug normalize command should parse");

    match cli.command {
        Some(Command::Debug(DebugArgs {
            command: DebugCommand::Normalize(args),
        })) => {
            assert_eq!(args.input, Some(PathBuf::from("input.js")));
            assert!(args.rename);
            assert!(!args.format);
        }
        other => panic!("expected debug normalize command, got {other:?}"),
    }
}

#[test]
fn normalize_rename_then_format_canonicalizes_mangling() {
    // Mirrors run_normalize's pipeline: alpha-rename via core, then format.
    let opts = NormalizeOptions {
        rename_bindings: true,
        filename: "input.js".to_string(),
    };
    let fmt = |code: String| format_cli_output(code, "input.js", selected_formatter(true));
    let original = fmt(normalize("function load(app_id){return get(app_id)}", &opts).unwrap());
    let mangled = fmt(normalize("function l(e){return get(e)}", &opts).unwrap());
    assert_eq!(
        original, mangled,
        "mangled output should normalize identically"
    );
    assert!(original.contains("get"), "global preserved: {original}");
}

#[test]
fn parses_formatter_option() {
    let cli = Cli::try_parse_from(["wakaru", "input.js", "--formatter"])
        .expect("formatter option should parse");
    assert!(cli.formatter);
}

#[test]
fn parses_vue_sfc_option() {
    let cli = Cli::try_parse_from(["wakaru", "input.js", "--vue-sfc"]).expect("vue option parses");
    assert!(cli.vue_sfc);
}

#[test]
fn rejects_vue_sfc_with_raw_unpack() {
    let cli = Cli::try_parse_from([
        "wakaru",
        "bundle.js",
        "--unpack",
        "--raw",
        "--vue-sfc",
        "-o",
        "out",
    ])
    .expect("raw vue unpack args should parse before runtime validation");

    let err = run_default(cli).expect_err("raw vue output should be rejected");
    assert!(
        err.to_string()
            .contains("--vue-sfc cannot be combined with --raw"),
        "unexpected error: {err}"
    );
}

#[test]
fn vue_output_filename_replaces_known_extension() {
    assert_eq!(vue_output_filename("module-1.js"), "module-1.vue");
    assert_eq!(
        vue_output_filename("src/App.render.mjs"),
        "src/App.render.vue"
    );
    assert_eq!(vue_output_filename("module-plain"), "module-plain.vue");
}

#[test]
fn vue_js_output_filename_avoids_vue_artifact_collision() {
    assert_eq!(vue_js_output_filename("src/App.vue"), "src/App.vue.js");
    assert_eq!(vue_js_output_filename("src/App.js"), "src/App.js");
    assert_eq!(vue_js_output_filename("module-plain"), "module-plain");
}

#[test]
fn vue_output_filename_for_component_disambiguates_multi_sfc_modules() {
    assert_eq!(
        vue_output_filename_for_component("entry.js", Some("HelloWorld"), true),
        "entry.HelloWorld.vue"
    );
    assert_eq!(
        vue_output_filename_for_component("src/entry.js", Some("App"), true),
        "src/entry.App.vue"
    );
    assert_eq!(
        vue_output_filename_for_component("entry.js", Some("../App"), true),
        "entry.___App.vue"
    );
    assert_eq!(
        vue_output_filename_for_component("entry.js", Some("App"), false),
        "entry.vue"
    );
}

#[test]
fn vue_sfc_writes_recovered_single_file_component() {
    let dir = temp_test_dir("vue-sfc-output");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("render.js");
    let output_path = dir.join("App.vue");
    fs::write(&input_path, vue_render_module_source()).expect("write vue render input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    run_default(cli).expect("vue sfc decompile should succeed");

    assert_eq!(
        fs::read_to_string(&output_path).expect("read vue sfc output"),
        "<script>\nexport default {\n    props: {\n        msg: String\n    }\n}\n</script>\n\n<template>\n  <div>{{ msg }}</div>\n</template>\n"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_writes_recovered_vite_setup_component() {
    let dir = temp_test_dir("vue-sfc-vite-setup");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("PanelWrapper.js");
    let output_path = dir.join("PanelWrapper.vue");
    fs::write(&input_path, vite_setup_component_module_source())
        .expect("write vite setup component input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    run_default(cli).expect("vue sfc decompile should succeed");

    assert_eq!(
        fs::read_to_string(&output_path).expect("read vue sfc output"),
        "<script setup>\nimport { computed } from \"vue\";\nimport { P as Panel_1 } from \"./Panel.vue\";\n\nconst Panel = computed(()=>createPanelState({\n        title: \"Ready\",\n        enabled: true,\n        rank: 1,\n        group: \"main\"\n    }));\n</script>\n\n<template>\n  <Panel_1 :state=\"Panel\" />\n</template>\n"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_single_file_js_primary_output_writes_vue_sidecar_from_input_name() {
    let dir = temp_test_dir("vue-sfc-js-primary-output");
    let input_dir = dir.join("custom");
    let output_dir = dir.join("out");
    fs::create_dir_all(&input_dir).expect("create input dir");
    fs::create_dir_all(&output_dir).expect("create output dir");
    let input_path = input_dir.join("target.min.mjs");
    let output_path = output_dir.join("renamed.mjs");
    let sidecar_path = output_dir.join("target.min.vue");
    fs::write(&input_path, vue_render_module_source()).expect("write vue render input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "--formatter",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    let output_filename = input_path.to_string_lossy().into_owned();
    let unformatted = decompile(
        vue_render_module_source(),
        DecompileOptions {
            filename: output_filename.clone(),
            ..Default::default()
        },
    )
    .expect("fixture should decompile")
    .code;
    let formatted = format_cli_output(
        unformatted.clone(),
        &output_filename,
        selected_formatter(true),
    );
    assert_ne!(
        formatted, unformatted,
        "fixture must expose whether --formatter ran"
    );

    run_default(cli).expect("vue sfc decompile should succeed");

    let js = fs::read_to_string(&output_path).expect("read js primary output");
    assert_eq!(
        js, formatted,
        "JS-primary --vue-sfc output should still run the formatter"
    );
    assert!(
        js.contains("export function render"),
        "primary output should remain JavaScript:\n{js}"
    );
    assert_eq!(
        fs::read_to_string(&sidecar_path).expect("read vue sidecar output"),
        "<script>\nexport default {\n    props: {\n        msg: String\n    }\n}\n</script>\n\n<template>\n  <div>{{ msg }}</div>\n</template>\n"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_sidecar_refuses_to_overwrite_input_under_force() {
    let dir = temp_test_dir("vue-sfc-sidecar-input-collision");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("App.vue");
    let output_path = dir.join("App.js");
    fs::write(&input_path, vue_render_module_source()).expect("write vue render input");
    let original_input = fs::read_to_string(&input_path).expect("read input before run");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
        "--force",
    ])
    .expect("vue sfc cli should parse");
    let err = run_default(cli).expect_err("sidecar must not overwrite input");
    assert!(
        err.to_string()
            .contains("refusing to write Vue sidecar over input file"),
        "unexpected error: {err}"
    );
    assert_eq!(
        fs::read_to_string(&input_path).expect("read input after run"),
        original_input
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_single_file_vue_only_output_errors_when_not_recovered() {
    let dir = temp_test_dir("vue-sfc-vue-only-miss");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("plain.js");
    let output_path = dir.join("Plain.vue");
    fs::write(&input_path, "const value = 1;").expect("write plain input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    let err = run_default(cli).expect_err("vue-only output should require recovered SFC");
    assert!(
        err.to_string()
            .contains("--vue-sfc did not recover a Vue SFC"),
        "unexpected error: {err}"
    );
    assert!(
        !output_path.exists(),
        "vue-only miss should not write fallback JavaScript to .vue"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_single_file_does_not_write_source_map_for_recovered_sfc() {
    let dir = temp_test_dir("vue-sfc-output-map");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("render.js");
    let output_path = dir.join("App.vue");
    fs::write(&input_path, vue_render_module_source()).expect("write vue render input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "--emit-source-map",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    run_default(cli).expect("vue sfc decompile should succeed");

    assert!(output_path.exists(), "recovered vue sfc should be written");
    assert!(
        !append_map_extension(&output_path).exists(),
        "recovered vue sfc must not get a stale JS source map"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_single_file_js_primary_output_writes_source_map_only_for_js() {
    let dir = temp_test_dir("vue-sfc-js-primary-output-map");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("App.js");
    let output_path = dir.join("custom.jsx");
    let sidecar_path = dir.join("App.vue");
    fs::write(&input_path, vue_render_module_source()).expect("write vue render input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "--emit-source-map",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    run_default(cli).expect("vue sfc decompile should succeed");

    assert!(output_path.exists(), "primary JS output should be written");
    assert!(
        sidecar_path.exists(),
        "recovered Vue sidecar should be written"
    );
    assert!(
        append_map_extension(&output_path).exists(),
        "primary JS output should get the source map"
    );
    assert!(
        !append_map_extension(&sidecar_path).exists(),
        "recovered Vue sidecar must not get a stale JS source map"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_relative_import_resolver_ignores_stdin_base() {
    assert_eq!(read_relative_import_source("<stdin>", "./main.js"), None);
}

#[test]
fn vue_sfc_relative_import_resolver_reads_extensionless_and_query_paths() {
    let dir = temp_test_dir("vue-sfc-relative-import-resolver");
    let components_dir = dir.join("components");
    fs::create_dir_all(&components_dir).expect("create temp dir");
    let input_path = dir.join("App.js");
    fs::write(&input_path, "export default {};").expect("write input");
    fs::write(components_dir.join("Child.vue"), "export default {};").expect("write component");
    fs::write(components_dir.join("Panel.js"), "export default {};").expect("write js module");
    fs::create_dir_all(components_dir.join("Dialog")).expect("create index dir");
    fs::write(
        components_dir.join("Dialog").join("index.vue"),
        "export default {};",
    )
    .expect("write index component");

    assert_eq!(
        read_relative_import_source(
            input_path.to_str().expect("input path should be utf8"),
            "./components/Child.vue?vue&type=script"
        ),
        Some("export default {};".to_string())
    );
    assert_eq!(
        read_relative_import_source(
            input_path.to_str().expect("input path should be utf8"),
            "./components/Child?vue&type=script"
        ),
        Some("export default {};".to_string())
    );
    assert_eq!(
        read_relative_import_source(
            input_path.to_str().expect("input path should be utf8"),
            "./components/Panel"
        ),
        Some("export default {};".to_string())
    );
    assert_eq!(
        read_relative_import_source(
            input_path.to_str().expect("input path should be utf8"),
            "./components/Dialog"
        ),
        Some("export default {};".to_string())
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_unpack_import_resolver_reads_root_relative_module_source() {
    let module_sources = HashMap::from([(
        "src/components/ChildPanel.vue".to_string(),
        "export default {};".to_string(),
    )]);

    assert_eq!(
        resolve_unpack_import_source(
            &module_sources,
            "src/App.vue",
            "./src/components/ChildPanel.vue"
        ),
        Some("export default {};".to_string())
    );
}

#[test]
fn vue_sfc_unpack_import_resolver_reads_module_relative_source() {
    let module_sources = HashMap::from([(
        "src/components/ChildPanel.vue".to_string(),
        "export default {};".to_string(),
    )]);

    assert_eq!(
        resolve_unpack_import_source(
            &module_sources,
            "src/App.vue",
            "./components/ChildPanel.vue"
        ),
        Some("export default {};".to_string())
    );
}

#[test]
fn vue_sfc_unpack_import_resolver_prefers_module_relative_over_root_collision() {
    let module_sources = HashMap::from([
        (
            "components/ChildPanel.vue".to_string(),
            "export default { name: 'RootChild' };".to_string(),
        ),
        (
            "src/components/ChildPanel.vue".to_string(),
            "export default { name: 'ScopedChild' };".to_string(),
        ),
    ]);

    assert_eq!(
        resolve_unpack_import_source(
            &module_sources,
            "src/App.vue",
            "./components/ChildPanel.vue"
        ),
        Some("export default { name: 'ScopedChild' };".to_string())
    );
}

#[test]
fn vue_sfc_unpack_import_resolver_reads_extensionless_query_and_index_sources() {
    let module_sources = HashMap::from([
        (
            "src/components/ChildPanel.vue".to_string(),
            "export default {};".to_string(),
        ),
        (
            "src/components/Panel.js".to_string(),
            "export const panel = true;".to_string(),
        ),
        (
            "src/components/Dialog/index.vue".to_string(),
            "export const dialog = true;".to_string(),
        ),
    ]);

    assert_eq!(
        resolve_unpack_import_source(
            &module_sources,
            "src/App.vue",
            "./components/ChildPanel.vue?vue&type=script"
        ),
        Some("export default {};".to_string())
    );
    assert_eq!(
        resolve_unpack_import_source(
            &module_sources,
            "src/App.vue",
            "./components/ChildPanel?vue&type=script"
        ),
        Some("export default {};".to_string())
    );
    assert_eq!(
        resolve_unpack_import_source(&module_sources, "src/App.vue", "./components/Panel"),
        Some("export const panel = true;".to_string())
    );
    assert_eq!(
        resolve_unpack_import_source(&module_sources, "src/App.vue", "./components/Dialog"),
        Some("export const dialog = true;".to_string())
    );
}

#[test]
fn vue_sfc_unpack_import_resolver_reads_parent_relative_sources() {
    let module_sources = HashMap::from([(
        "src/components/ChildPanel.vue".to_string(),
        "export default {};".to_string(),
    )]);

    assert_eq!(
        resolve_unpack_import_source(
            &module_sources,
            "src/views/App.vue",
            "../components/ChildPanel"
        ),
        Some("export default {};".to_string())
    );
}

#[test]
fn vue_sfc_recovers_single_system_register_module() {
    let dir = temp_test_dir("vue-sfc-system-register");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("legacy.js");
    let output_path = dir.join("Recovered.vue");
    fs::write(
        &input_path,
        r#"
System.register(["./vendor-vue.js"], function (exports) {
  "use strict";
  var defineComponent, openBlock, createElementBlock;
  return {
    setters: [
      function (module) {
        defineComponent = module.d, openBlock = module.q, createElementBlock = module.X;
      }
    ],
    execute: function () {
      exports("_", defineComponent({
        __name: "LegacyGreeting",
        setup: function () {
          return function () {
            return openBlock(), createElementBlock("p", null, "Legacy");
          };
        }
      }));
    }
  };
});
"#,
    )
    .expect("write vue system register input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    run_default(cli).expect("vue sfc decompile should succeed");

    assert_eq!(
        fs::read_to_string(&output_path).expect("read vue sfc output"),
        "<template>\n  <p>Legacy</p>\n</template>\n"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_resolves_relative_component_export_alias() {
    let dir = temp_test_dir("vue-sfc-relative-component");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("render.js");
    let shared_path = dir.join("main.js");
    let output_path = dir.join("Recovered.vue");
    fs::write(
        &input_path,
        r#"
import { q as ob, aa as cb, _ as rd } from "./vendor-vue.js";
import { B as B_1 } from "./main.js";
export function render(_ctx, _cache) {
  return ob(), cb(rd(B_1), { text: "Details" }, null, 8, ["text"]);
}
"#,
    )
    .expect("write vue render input");
    fs::write(
        &shared_path,
        r#"
import { defineComponent } from "vue";
const YP = defineComponent({
  name: "VTooltip",
  props: { text: String }
});
export { YP as B };
"#,
    )
    .expect("write shared component input");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--vue-sfc",
        "-o",
        output_path.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc cli should parse");
    run_default(cli).expect("vue sfc decompile should succeed");

    assert_eq!(
        fs::read_to_string(&output_path).expect("read vue sfc output"),
        "<script setup>\nimport { B as VTooltip } from \"./main.js\";\n</script>\n\n<template>\n  <VTooltip text=\"Details\" />\n</template>\n"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_unpack_recovers_webpack_namespace_component() {
    let dir = temp_test_dir("vue-sfc-webpack");
    let out_dir = dir.join("out");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("bundle.js");
    fs::write(&input_path, webpack5_vue_sfc_bundle_source()).expect("write webpack vue bundle");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--unpack",
        "--vue-sfc",
        "-o",
        out_dir.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc unpack cli should parse");
    run_default(cli).expect("vue sfc webpack unpack should succeed");

    assert!(
        out_dir.join("src/App.vue.js").exists(),
        "decompiled JS should remain next to the recovered SFC"
    );
    assert_eq!(
        fs::read_to_string(out_dir.join("src/App.vue")).expect("read recovered vue sfc"),
        "<script>\nexport default {\n    name: \"WebpackPanel\",\n    props: {\n        message: String\n    }\n}\n</script>\n\n<script setup>\nimport ChildPanel from \"./components/ChildPanel.vue\";\n</script>\n\n<template>\n  <section class=\"notice\">\n    <ChildPanel :label=\"message\" />\n    <span>{{ message }}</span>\n  </section>\n</template>\n"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_unpack_writes_multiple_recovered_components_from_one_module() {
    let dir = temp_test_dir("vue-sfc-webpack-multi");
    let out_dir = dir.join("out");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("bundle.js");
    fs::write(&input_path, webpack5_multi_vue_sfc_bundle_source())
        .expect("write webpack vue bundle");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--unpack",
        "--vue-sfc",
        "-o",
        out_dir.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc unpack cli should parse");
    run_default(cli).expect("vue sfc webpack unpack should succeed");

    assert!(
        out_dir.join("src/entry.js").exists(),
        "decompiled JS should remain next to recovered SFCs"
    );
    assert_eq!(
        fs::read_to_string(out_dir.join("src/entry.Child.vue")).expect("read child sfc"),
        "<script setup>\nconst props = defineProps({\n    msg: String\n});\nconst { msg } = props;\n</script>\n\n<template>\n  <span>{{ msg }}</span>\n</template>\n"
    );
    assert_eq!(
        fs::read_to_string(out_dir.join("src/entry.App.vue")).expect("read app sfc"),
        "<template>\n  <main>\n    <Child msg=\"Hi\" />\n  </main>\n</template>\n"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn vue_sfc_unpack_writes_source_maps_only_for_js_artifacts() {
    let dir = temp_test_dir("vue-sfc-webpack-map");
    let out_dir = dir.join("out");
    fs::create_dir_all(&dir).expect("create temp dir");
    let input_path = dir.join("bundle.js");
    fs::write(&input_path, webpack5_vue_sfc_bundle_source()).expect("write webpack vue bundle");

    let cli = Cli::try_parse_from([
        "wakaru",
        input_path.to_str().expect("input path should be utf8"),
        "--unpack",
        "--vue-sfc",
        "--emit-source-map",
        "-o",
        out_dir.to_str().expect("output path should be utf8"),
    ])
    .expect("vue sfc unpack cli should parse");
    run_default(cli).expect("vue sfc webpack unpack should succeed");

    assert!(
        out_dir.join("src/App.vue").exists(),
        "recovered vue sfc should be written"
    );
    assert!(
        out_dir.join("src/App.vue.js").exists(),
        "decompiled JS should be written"
    );
    assert!(
        out_dir.join("src/App.vue.js.map").exists(),
        "decompiled JS should keep its source map"
    );
    assert!(
        !out_dir.join("src/App.vue.map").exists(),
        "recovered vue sfc must not get a stale JS source map"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn parses_json_flag() {
    let cli =
        Cli::try_parse_from(["wakaru", "input.js", "--json"]).expect("json flag should parse");
    assert!(cli.json);
}

#[test]
fn parses_json_with_unpack() {
    let cli = Cli::try_parse_from(["wakaru", "bundle.js", "--unpack", "--json", "-o", "out"])
        .expect("json with unpack should parse");
    assert!(cli.json);
    assert!(cli.unpack.is_some());
}

#[test]
fn json_modules_describe_vue_sfc_artifact_roles() {
    let modules = vec![
        json_module_for_artifact(&CliOutputArtifact {
            filename: "src/plain.js".to_string(),
            code: "export {};".to_string(),
            kind: JsonModuleKind::JavaScript,
            status: JsonModuleStatus::Decompiled,
            source_filename: None,
            source_map_filename: Some("src/plain.js".to_string()),
        }),
        json_module_for_artifact(&CliOutputArtifact {
            filename: "src/App.vue.js".to_string(),
            code: "export {};".to_string(),
            kind: JsonModuleKind::JavaScript,
            status: JsonModuleStatus::VueSfcSourceJs,
            source_filename: Some("src/App.vue".to_string()),
            source_map_filename: Some("src/App.vue".to_string()),
        }),
        json_module_for_artifact(&CliOutputArtifact {
            filename: "src/App.vue".to_string(),
            code: "<template />".to_string(),
            kind: JsonModuleKind::VueSfc,
            status: JsonModuleStatus::RecoveredVueSfc,
            source_filename: Some("src/App.vue".to_string()),
            source_map_filename: None,
        }),
        json_module_for_artifact(&CliOutputArtifact {
            filename: "src/Broken.vue.js".to_string(),
            code: "export {};".to_string(),
            kind: JsonModuleKind::JavaScript,
            status: JsonModuleStatus::VueSfcFallbackJs,
            source_filename: None,
            source_map_filename: Some("src/Broken.vue".to_string()),
        }),
    ];

    assert_eq!(
        serde_json::to_value(modules).expect("serialize modules"),
        serde_json::json!([
            {
                "filename": "src/plain.js",
                "kind": "javascript",
                "status": "decompiled"
            },
            {
                "filename": "src/App.vue.js",
                "kind": "javascript",
                "status": "vue_sfc_source_js",
                "source_filename": "src/App.vue"
            },
            {
                "filename": "src/App.vue",
                "kind": "vue_sfc",
                "status": "recovered_vue_sfc",
                "source_filename": "src/App.vue"
            },
            {
                "filename": "src/Broken.vue.js",
                "kind": "javascript",
                "status": "vue_sfc_fallback_js"
            }
        ])
    );
}

#[test]
fn json_unpack_total_counts_input_modules_not_artifacts() {
    let artifacts = vec![
        CliOutputArtifact {
            filename: "src/App.vue.js".to_string(),
            code: "export {};".to_string(),
            kind: JsonModuleKind::JavaScript,
            status: JsonModuleStatus::VueSfcSourceJs,
            source_filename: Some("src/App.vue".to_string()),
            source_map_filename: Some("src/App.vue".to_string()),
        },
        CliOutputArtifact {
            filename: "src/App.vue".to_string(),
            code: "<template />".to_string(),
            kind: JsonModuleKind::VueSfc,
            status: JsonModuleStatus::RecoveredVueSfc,
            source_filename: Some("src/App.vue".to_string()),
            source_map_filename: None,
        },
    ];

    let json =
        json_unpack_output_for_artifacts(&[], &artifacts, &[], 1, 0, Duration::from_millis(12));

    assert_eq!(json.total, 1);
    assert_eq!(json.modules.len(), 2);
    assert_eq!(json.elapsed_ms, 12);
}

#[test]
fn single_file_vue_metadata_describes_recovered_sfc_output() {
    let output = decompile_vue_sfc(
        vue_render_module_source(),
        VueSfcDecompileOptions {
            decompile: DecompileOptions {
                filename: "src/App.vue".to_string(),
                ..Default::default()
            },
            recovery: VueSfcRecoveryOptions::default(),
        },
    )
    .expect("vue sfc decompile should succeed");

    let metadata = single_file_vue_metadata(
        true,
        output.recovered_sfc,
        false,
        &output.output.code,
        "src/App.vue",
        None,
    )
    .expect("vue metadata should be emitted");

    assert!(output.recovered_sfc);
    assert_eq!(metadata.kind, JsonModuleKind::VueSfc);
    assert_eq!(metadata.status, JsonModuleStatus::RecoveredVueSfc);
    assert_eq!(metadata.source_filename.as_deref(), Some("src/App.vue"));
    assert_eq!(metadata.vue_sidecar_filename, None);
}

#[test]
fn single_file_vue_metadata_describes_js_primary_sidecar_output() {
    let output = decompile(
        vue_render_module_source(),
        DecompileOptions {
            filename: "src/App.vue".to_string(),
            ..Default::default()
        },
    )
    .expect("decompile should succeed");
    let sidecar = recover_single_file_vue_sidecar(&output.code, "src/App.vue");
    let sidecar_path = PathBuf::from("dist/App.vue");

    let metadata = single_file_vue_metadata(
        true,
        sidecar.is_some(),
        true,
        &output.code,
        "src/App.vue",
        Some(&sidecar_path),
    )
    .expect("vue metadata should be emitted");

    assert!(sidecar.is_some());
    assert_eq!(metadata.kind, JsonModuleKind::JavaScript);
    assert_eq!(metadata.status, JsonModuleStatus::VueSfcSourceJs);
    assert_eq!(metadata.source_filename.as_deref(), Some("src/App.vue"));
    assert_eq!(
        metadata.vue_sidecar_filename.as_deref(),
        Some("dist/App.vue")
    );
}

#[test]
fn single_file_vue_metadata_describes_plain_js_output() {
    let output = decompile(
        "export const value = 1;",
        DecompileOptions {
            filename: "src/plain.js".to_string(),
            ..Default::default()
        },
    )
    .expect("decompile should succeed");

    let metadata = single_file_vue_metadata(true, false, false, &output.code, "src/plain.js", None)
        .expect("vue metadata should be emitted under --vue-sfc");

    assert_eq!(metadata.kind, JsonModuleKind::JavaScript);
    assert_eq!(metadata.status, JsonModuleStatus::Decompiled);
    assert_eq!(metadata.source_filename, None);
    assert_eq!(metadata.vue_sidecar_filename, None);
}

#[test]
fn single_file_vue_metadata_describes_likely_vue_fallback_output() {
    let output = decompile(
        r#"
import { openBlock, createElementBlock } from "vue";
export function render(_ctx, _cache) {
  return openBlock(), createElementBlock("div", null, "Hi");
}
"#,
        DecompileOptions {
            filename: "src/Broken.vue".to_string(),
            ..Default::default()
        },
    )
    .expect("decompile should succeed");

    let metadata =
        single_file_vue_metadata(true, false, false, &output.code, "src/Broken.vue", None)
            .expect("vue metadata should be emitted under --vue-sfc");

    assert_eq!(metadata.kind, JsonModuleKind::JavaScript);
    assert_eq!(metadata.status, JsonModuleStatus::VueSfcFallbackJs);
    assert_eq!(metadata.source_filename.as_deref(), Some("src/Broken.vue"));
    assert_eq!(metadata.vue_sidecar_filename, None);
}

#[test]
fn json_decompile_omits_vue_fields_for_plain_js() {
    let json = JsonDecompileOutput {
        code: Some("export {};".to_string()),
        source_map: None,
        kind: None,
        status: None,
        source_filename: None,
        vue_sidecar_filename: None,
        warnings: Vec::new(),
        elapsed_ms: 3,
    };

    assert_eq!(
        serde_json::to_value(json).expect("serialize decompile json"),
        serde_json::json!({
            "code": "export {};",
            "warnings": [],
            "elapsed_ms": 3
        })
    );
}

#[test]
fn vue_sidecar_recovery_errors_fall_back_to_js_primary_output() {
    assert!(recover_single_file_vue_sidecar("function {", "src/App.js").is_none());
}

#[test]
fn provenance_names_ignore_interleaved_vue_sfc_sidecars() {
    let out_dir = PathBuf::from("/tmp/wakaru-out");
    let artifacts = vec![
        CliOutputArtifact {
            filename: "src/App.vue.js".to_string(),
            code: "export {};".to_string(),
            kind: JsonModuleKind::JavaScript,
            status: JsonModuleStatus::VueSfcSourceJs,
            source_filename: Some("src/App.vue".to_string()),
            source_map_filename: Some("src/App.vue".to_string()),
        },
        CliOutputArtifact {
            filename: "src/App.vue".to_string(),
            code: "<template />".to_string(),
            kind: JsonModuleKind::VueSfc,
            status: JsonModuleStatus::RecoveredVueSfc,
            source_filename: Some("src/App.vue".to_string()),
            source_map_filename: None,
        },
        CliOutputArtifact {
            filename: "src/after.js".to_string(),
            code: "export {};".to_string(),
            kind: JsonModuleKind::JavaScript,
            status: JsonModuleStatus::Decompiled,
            source_filename: None,
            source_map_filename: Some("src/after.js".to_string()),
        },
    ];
    let resolved = vec![
        (out_dir.join("src/App.vue.js"), artifacts[0].code.as_str()),
        (out_dir.join("src/App.vue"), artifacts[1].code.as_str()),
        (out_dir.join("src/after.js"), artifacts[2].code.as_str()),
    ];

    let final_names = provenance_final_names(&artifacts, &resolved, &out_dir);

    assert_eq!(
        final_names.get("src/App.vue").map(String::as_str),
        Some("src/App.vue.js")
    );
    assert_eq!(
        final_names.get("src/after.js").map(String::as_str),
        Some("src/after.js")
    );
}

#[test]
fn vue_sfc_js_artifact_status_marks_only_likely_vue_fallbacks() {
    assert_eq!(
        vue_sfc_js_artifact_status(false, false),
        JsonModuleStatus::Decompiled
    );
    assert_eq!(
        vue_sfc_js_artifact_status(false, true),
        JsonModuleStatus::VueSfcFallbackJs
    );
    assert_eq!(
        vue_sfc_js_artifact_status(true, true),
        JsonModuleStatus::VueSfcSourceJs
    );
}

#[test]
fn vue_sfc_artifact_summary_counts_recovered_and_fallback_modules() {
    let artifacts = vec![
        test_cli_artifact(JsonModuleStatus::VueSfcSourceJs),
        test_cli_artifact(JsonModuleStatus::RecoveredVueSfc),
        test_cli_artifact(JsonModuleStatus::VueSfcFallbackJs),
        test_cli_artifact(JsonModuleStatus::Decompiled),
    ];

    let summary = vue_sfc_artifact_summary(&artifacts);
    assert_eq!(
        summary,
        Some(VueSfcArtifactSummary {
            recovered: 1,
            fallback: 1
        })
    );
    assert_eq!(
        format_vue_sfc_artifact_summary(summary.expect("summary")),
        "vue-sfc: 1 recovered, 1 fallback"
    );
}

#[test]
fn vue_sfc_artifact_summary_ignores_plain_js_modules() {
    let artifacts = vec![test_cli_artifact(JsonModuleStatus::Decompiled)];

    assert_eq!(vue_sfc_artifact_summary(&artifacts), None);
}

#[test]
fn format_elapsed_uses_seconds_for_long_durations() {
    let d = Duration::from_millis(1234);
    assert_eq!(format_elapsed(d), "1.23s");
}

#[test]
fn format_elapsed_uses_millis_for_short_durations() {
    let d = Duration::from_millis(456);
    assert_eq!(format_elapsed(d), "456ms");
}

#[test]
fn format_elapsed_zero() {
    let d = Duration::from_millis(0);
    assert_eq!(format_elapsed(d), "0ms");
}

#[test]
fn parses_formatter_with_raw_unpack() {
    let cli = Cli::try_parse_from([
        "wakaru",
        "bundle.js",
        "--unpack",
        "--raw",
        "--formatter",
        "-o",
        "out",
    ])
    .expect("formatter with raw should parse");

    assert!(cli.raw);
    assert!(cli.formatter);
}

#[test]
fn parses_multiple_unpack_inputs() {
    let cli = Cli::try_parse_from([
        "wakaru",
        "--unpack",
        "-o",
        "out",
        "bundle.js",
        "src_greet_js.bundle.js",
    ])
    .expect("multi-file unpack should parse");

    assert!(cli.unpack.is_some());
    assert_eq!(
        cli.inputs,
        vec![
            PathBuf::from("bundle.js"),
            PathBuf::from("src_greet_js.bundle.js")
        ]
    );
}

#[test]
fn parses_profile_flag() {
    let cli = Cli::try_parse_from(["wakaru", "input.js", "--profile", "profile.json"])
        .expect("--profile should parse");
    assert_eq!(cli.profile, Some(PathBuf::from("profile.json")));
    assert!(!cli.profile_rules);
}

#[test]
fn parses_profile_rules_flag() {
    let cli = Cli::try_parse_from([
        "wakaru",
        "input.js",
        "--profile",
        "profile.json",
        "--profile-rules",
    ])
    .expect("--profile-rules should parse with --profile");
    assert!(cli.profile_rules);
}

#[test]
fn rejects_profile_rules_without_profile() {
    assert!(Cli::try_parse_from(["wakaru", "input.js", "--profile-rules"]).is_err());
}

#[test]
fn parses_source_map_aliases() {
    let cli = Cli::try_parse_from(["wakaru", "input.js", "--source-map", "input.js.map"])
        .expect("--source-map should parse");
    assert_eq!(cli.sourcemap, Some(PathBuf::from("input.js.map")));

    let cli = Cli::try_parse_from(["wakaru", "input.js", "--sourcemap", "input.js.map"])
        .expect("--sourcemap alias should parse");
    assert_eq!(cli.sourcemap, Some(PathBuf::from("input.js.map")));
}

#[test]
fn unpack_rejects_input_source_map() {
    let cli = Cli::try_parse_from([
        "wakaru",
        "bundle.js",
        "--unpack",
        "--source-map",
        "bundle.js.map",
        "-o",
        "out",
    ])
    .expect("arguments should parse");
    let error = run_default(cli).expect_err("unpack input source maps must be rejected");
    assert!(
        error
            .to_string()
            .contains("--source-map is not supported with --unpack"),
        "unexpected error: {error}"
    );
}

#[test]
fn decompile_rejects_directory_input() {
    let dir = temp_test_dir("decompile-dir");
    fs::create_dir_all(&dir).expect("create temp dir");

    let cli = Cli::try_parse_from(["wakaru", dir.to_str().expect("temp path should be utf8")])
        .expect("directory input should parse");
    let err = run_default(cli).expect_err("decompile should reject directory input");
    assert!(
        err.to_string()
            .contains("cannot decompile a directory. Pass a JavaScript file or use --unpack"),
        "unexpected error: {err}"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn unpack_directory_inputs_are_recursive_detected_js_files_only() {
    let dir = temp_test_dir("unpack-dir");
    let nested = dir.join("nested");
    let hidden = dir.join(".hidden");
    let node_modules = dir.join("node_modules");
    fs::create_dir_all(&nested).expect("create nested dir");
    fs::create_dir_all(&hidden).expect("create hidden dir");
    fs::create_dir_all(&node_modules).expect("create node_modules dir");

    fs::write(dir.join("plain.js"), "const value = 1;").expect("write plain file");
    fs::write(dir.join("runtime-like.js"), runtime_like_plain_source())
        .expect("write runtime-like plain file");
    fs::write(nested.join("chunk.js"), webpack5_chunk_source()).expect("write chunk");
    fs::write(dir.join("runtime.js"), webpack5_runtime_entry_source())
        .expect("write runtime entry");
    fs::write(hidden.join("hidden.js"), webpack5_chunk_source()).expect("write hidden chunk");
    fs::write(node_modules.join("vendor.js"), webpack5_chunk_source())
        .expect("write node_modules chunk");
    fs::write(dir.join("chunk.js.map"), webpack5_chunk_source()).expect("write sourcemap");

    let input_set =
        read_unpack_inputs(std::slice::from_ref(&dir), false).expect("read directory inputs");
    assert_eq!(
        input_set.scan_stats,
        Some(DirectoryScanStats {
            scanned: 4,
            detected: 2,
            skipped: 2,
        })
    );
    assert_eq!(
        input_set.inputs.len(),
        2,
        "expected visible chunk and runtime entry"
    );
    assert!(
        input_set
            .inputs
            .iter()
            .any(|input| input.filename.ends_with("nested\\chunk.js")
                || input.filename.ends_with("nested/chunk.js")),
        "missing detected chunk input: {:?}",
        input_set.inputs
    );
    assert!(
        input_set
            .inputs
            .iter()
            .any(|input| input.filename.ends_with("runtime.js")),
        "missing detected runtime input: {:?}",
        input_set.inputs
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn unpack_directory_without_detected_files_errors() {
    let dir = temp_test_dir("unpack-dir-empty");
    fs::create_dir_all(&dir).expect("create temp dir");
    fs::write(dir.join("plain.js"), "const value = 1;").expect("write plain file");

    let err = read_unpack_inputs(std::slice::from_ref(&dir), false)
        .expect_err("directory with no detected bundles should error");
    assert!(
        err.to_string()
            .contains("no bundle or chunk files detected in directory input"),
        "unexpected error: {err}"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn output_file_requires_force_to_overwrite() {
    let dir = temp_test_dir("output-file");
    fs::create_dir_all(&dir).expect("create temp dir");
    let path = dir.join("out.js");
    fs::write(&path, "old").expect("write temp file");

    assert!(ensure_output_file(&path, false).is_err());
    assert!(ensure_output_file(&path, true).is_ok());

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn output_dir_requires_force_when_non_empty() {
    let dir = temp_test_dir("output-dir");
    fs::create_dir_all(&dir).expect("create temp dir");
    fs::write(dir.join("entry.js"), "old").expect("write temp file");

    assert!(ensure_output_dir(&dir, false).is_err());
    assert!(ensure_output_dir(&dir, true).expect("force should allow non-empty dir"));

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn unpack_cli_does_not_write_overlapping_dot_payload_outside_output_dir() {
    let dir = temp_test_dir("unpack-cli-overlap");
    let out_dir = dir.join("out");
    let bundle_path = dir.join("bundle.js");
    let outside_target = dir.join("node_modules/@wakaru/cli/bin/wakaru");
    fs::create_dir_all(outside_target.parent().expect("outside target parent"))
        .expect("create outside target parent");
    fs::write(&outside_target, "original").expect("write outside marker");
    fs::write(&bundle_path, overlapping_dot_webpack5_bundle()).expect("write bundle");

    let cli = Cli::try_parse_from([
        "wakaru",
        bundle_path.to_str().expect("bundle path should be utf8"),
        "--unpack",
        "-o",
        out_dir.to_str().expect("output path should be utf8"),
    ])
    .expect("cli should parse");
    run_default(cli).expect("unpack should succeed");

    assert_eq!(
        fs::read_to_string(&outside_target).expect("read outside marker"),
        "original",
        "outside marker must not be overwritten"
    );
    assert!(
        out_dir
            .join("..../node_modules/@wakaru/cli/bin/wakaru")
            .exists(),
        "payload should be written under the output directory"
    );

    fs::remove_dir_all(&dir).expect("remove temp dir");
}

#[test]
fn output_dir_reports_when_existing_writes_need_checks() {
    let empty_dir = temp_test_dir("output-dir-empty");
    fs::create_dir_all(&empty_dir).expect("create temp dir");
    assert!(
        !ensure_output_dir(&empty_dir, false).expect("empty dir should be accepted"),
        "empty directories can write directly without checking existing files"
    );
    fs::remove_dir_all(&empty_dir).expect("remove empty temp dir");

    let new_dir = temp_test_dir("output-dir-new");
    assert!(
        !ensure_output_dir(&new_dir, false).expect("new dir should be created"),
        "new directories can write directly without checking existing files"
    );
    fs::remove_dir_all(&new_dir).expect("remove new temp dir");

    let non_empty_dir = temp_test_dir("output-dir-non-empty");
    fs::create_dir_all(&non_empty_dir).expect("create temp dir");
    fs::write(non_empty_dir.join("entry.js"), "old").expect("write temp file");
    assert!(
        ensure_output_dir(&non_empty_dir, true).expect("force should allow non-empty dir"),
        "non-empty forced directories should preserve write-if-changed checks"
    );
    fs::remove_dir_all(&non_empty_dir).expect("remove non-empty temp dir");
}

fn temp_test_dir(name: &str) -> PathBuf {
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system time should be after epoch")
        .as_nanos();
    std::env::temp_dir().join(format!("wakaru-cli-test-{name}-{nanos}"))
}

fn test_cli_artifact(status: JsonModuleStatus) -> CliOutputArtifact {
    CliOutputArtifact {
        filename: "module.js".to_string(),
        code: "export {};".to_string(),
        kind: JsonModuleKind::JavaScript,
        status,
        source_filename: None,
        source_map_filename: None,
    }
}

fn vue_render_module_source() -> &'static str {
    r#"
import { toDisplayString as _toDisplayString, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
const __sfc__ = { props: { msg: String } };
export function render(_ctx, _cache) {
  return (_openBlock(), _createElementBlock("div", null, _toDisplayString(_ctx.msg), 1));
}
__sfc__.render = render;
export default __sfc__;
"#
}

fn vite_setup_component_module_source() -> &'static str {
    r#"
import { defineComponent, computed, openBlock, createVNode } from "vue";
import { P } from "./Panel.vue";
export default defineComponent({
  __name: "PanelWrapper",
  setup() {
    const Panel = computed(() => createPanelState({
      title: "Ready",
      enabled: true,
      rank: 1,
      group: "main"
    }));
    return () => (
      openBlock(), createVNode(P, { state: Panel.value }, null, 8, ["state"])
    );
  }
});
"#
}

fn webpack5_chunk_source() -> &'static str {
    r#"
(self.webpackChunk = self.webpackChunk || []).push([
  [1],
  {
    100: function(module, exports, require) {
      "use strict";
      require.r(exports);
      exports.default = 1;
    }
  }
]);
"#
}

fn webpack5_runtime_entry_source() -> &'static str {
    r#"
(() => {
  var modules = {};
  function require(id) { return {}; }
  require.m = modules;
  require.f = {};
  require.e = function(id) { return Promise.resolve(id); };
  require.u = function(id) { return id + ".bundle.js"; };
  require.t = function(value) { return value; };
  require.e(529).then(require.t.bind(require, 529, 19));
})();
"#
}

fn webpack5_vue_sfc_bundle_source() -> &'static str {
    r#"
(() => {
  var __webpack_modules__ = ({
    "./node_modules/vue/index.js": ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
      __webpack_require__.r(__webpack_exports__);
      __webpack_require__.d(__webpack_exports__, {
        createElementBlock: () => createElementBlock,
        createVNode: () => createVNode,
        defineComponent: () => defineComponent,
        openBlock: () => openBlock,
        toDisplayString: () => toDisplayString
      });
      function createElementBlock() {}
      function createVNode() {}
      function defineComponent(options) { return options; }
      function openBlock() {}
      function toDisplayString(value) { return String(value); }
    }),
    "./src/components/ChildPanel.vue": ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
      __webpack_require__.r(__webpack_exports__);
      __webpack_require__.d(__webpack_exports__, { default: () => __WEBPACK_DEFAULT_EXPORT__ });
      var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./node_modules/vue/index.js");
      const __WEBPACK_DEFAULT_EXPORT__ = (0, vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
        name: "ChildPanel",
        props: { label: String }
      });
    }),
    "./src/App.vue": ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
      __webpack_require__.r(__webpack_exports__);
      __webpack_require__.d(__webpack_exports__, { default: () => __WEBPACK_DEFAULT_EXPORT__ });
      var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./node_modules/vue/index.js");
      var _components_ChildPanel_vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/components/ChildPanel.vue");
      const _hoisted_1 = { class: "notice" };
      function render(_ctx, _cache) {
        return (0, vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0, vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("section", _hoisted_1, [
          (0, vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(_components_ChildPanel_vue__WEBPACK_IMPORTED_MODULE_1__["default"], { label: _ctx.message }, null, 8, ["label"]),
          (0, vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", null, (0, vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(_ctx.message), 1)
        ]);
      }
      const __WEBPACK_DEFAULT_EXPORT__ = (0, vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
        name: "WebpackPanel",
        props: { message: String },
        render
      });
    })
  });
  var __webpack_module_cache__ = {};
  function __webpack_require__(moduleId) {
    var cachedModule = __webpack_module_cache__[moduleId];
    if (cachedModule !== undefined) return cachedModule.exports;
    var module = __webpack_module_cache__[moduleId] = { exports: {} };
    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
    return module.exports;
  }
  __webpack_require__.d = (exports, definition) => {
    for (var key in definition) {
      if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
        Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
      }
    }
  };
  __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
  __webpack_require__.r = (exports) => {
    if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
      Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
    }
    Object.defineProperty(exports, "__esModule", { value: true });
  };
  __webpack_require__("./src/App.vue");
})();
"#
}

fn webpack5_multi_vue_sfc_bundle_source() -> &'static str {
    r#"
(() => {
  var __webpack_modules__ = ({
    "./node_modules/vue/index.js": ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
      __webpack_require__.r(__webpack_exports__);
      __webpack_require__.d(__webpack_exports__, {
        createElementBlock: () => createElementBlock,
        createVNode: () => createVNode,
        defineComponent: () => defineComponent,
        openBlock: () => openBlock,
        toDisplayString: () => toDisplayString
      });
      function createElementBlock() {}
      function createVNode() {}
      function defineComponent(options) { return options; }
      function openBlock() {}
      function toDisplayString(value) { return String(value); }
    }),
    "./src/entry.js": ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
      __webpack_require__.r(__webpack_exports__);
      var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./node_modules/vue/index.js");
      const Child = (0, vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
        __name: "Child",
        props: { msg: String },
        setup(props) {
          return (_ctx, _cache) => ((0, vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0, vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", null, props.msg, 1));
        }
      });
      const App = (0, vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
        __name: "App",
        setup() {
          return (_ctx, _cache) => ((0, vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0, vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("main", null, [
            (0, vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Child, { msg: "Hi" })
          ]));
        }
      });
    })
  });
  var __webpack_module_cache__ = {};
  function __webpack_require__(moduleId) {
    var cachedModule = __webpack_module_cache__[moduleId];
    if (cachedModule !== undefined) return cachedModule.exports;
    var module = __webpack_module_cache__[moduleId] = { exports: {} };
    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
    return module.exports;
  }
  __webpack_require__.d = (exports, definition) => {
    for (var key in definition) {
      if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
        Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
      }
    }
  };
  __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
  __webpack_require__.r = (exports) => {
    if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
      Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
    }
    Object.defineProperty(exports, "__esModule", { value: true });
  };
  __webpack_require__("./src/entry.js");
})();
"#
}

fn runtime_like_plain_source() -> &'static str {
    r#"
(() => {
  const api = {};
  api.e = 1;
  api.u = 2;
  api.t = 3;
  api.m = 4;
})();
"#
}

fn overlapping_dot_webpack5_bundle() -> &'static str {
    r#"
(() => {
  var __webpack_modules__ = ({
    "....//node_modules/@wakaru/cli/bin/wakaru": ((module) => {
      module.exports = "pwned";
    })
  });
  var __webpack_module_cache__ = {};
  function __webpack_require__(moduleId) {
    var module = __webpack_module_cache__[moduleId] = { exports: {} };
    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
    return module.exports;
  }
  console.log(__webpack_require__("....//node_modules/@wakaru/cli/bin/wakaru"));
})();
"#
}

#[test]
fn renders_provenance_json_with_final_names_and_default_input() {
    let provenance = vec![
        wakaru_core::ModuleProvenance {
            filename: "b.js".to_string(),
            input: String::new(),
            ranges: vec![(10, 20), (30, 40)],
        },
        wakaru_core::ModuleProvenance {
            filename: "a \"quoted\".js".to_string(),
            input: "chunk-1.js".to_string(),
            ranges: vec![(0, 5)],
        },
        wakaru_core::ModuleProvenance {
            filename: "module-1/chunk_a.js".to_string(),
            input: String::new(),
            ranges: vec![(50, 60)],
        },
    ];
    let mut final_names = HashMap::new();
    // CLI-side dedup renamed b.js on disk.
    final_names.insert("b.js", "b_2.js".to_string());

    let json = render_provenance_json(
        &provenance,
        &final_names,
        "bundle.js",
        &[wakaru_core::BundleFormat::Webpack5],
    );

    assert!(
        json.contains(r#""format": "webpack5""#),
        "format metadata missing:\n{json}"
    );
    assert!(
        json.contains(r#""strategy": "mixed""#),
        "strategy metadata missing:\n{json}"
    );
    assert!(
        json.contains(r#""b_2.js": {"input": "bundle.js", "ranges": [[10,20],[30,40]], "extraction": "structural"}"#),
        "renamed module with default input missing:\n{json}"
    );
    assert!(
        json.contains(r#""a \"quoted\".js": {"input": "chunk-1.js", "ranges": [[0,5]], "extraction": "structural"}"#),
        "escaped filename with explicit input missing:\n{json}"
    );
    assert!(
        json.contains(r#""module-1/chunk_a.js": {"input": "bundle.js", "ranges": [[50,60]], "extraction": "heuristic"}"#),
        "nested heuristic module metadata missing:\n{json}"
    );
    // Must be alphabetically sorted and valid JSON shape.
    assert!(json.find("a \\\"quoted\\\"").unwrap() < json.find("b_2.js").unwrap());
    assert!(json.starts_with(
        "{\n  \"format\": \"webpack5\",\n  \"strategy\": \"mixed\",\n  \"modules\": {\n"
    ));
    assert!(json.ends_with("  }\n}\n"));
}