defold entrypoint

src/builds.rs

@@ -1,5 +1,6 @@
 use crate::auth::AuthManager;
-use crate::config::{self, WavedashConfig};
+use crate::config::{self, EngineKind, WavedashConfig};
+use crate::dev::entrypoint::{fetch_entrypoint_params, locate_html_entrypoint};
 use crate::file_staging::FileStaging;
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
@@ -124,7 +125,11 @@ async fn notify_upload_complete(
     Ok(result)
 }
 
-pub async fn handle_build_push(config_path: PathBuf, verbose: bool, message: Option<String>) -> Result<()> {
+pub async fn handle_build_push(
+    config_path: PathBuf,
+    verbose: bool,
+    message: Option<String>,
+) -> Result<()> {
     // Load wavedash.toml config
     let wavedash_config = WavedashConfig::load(&config_path)?;
 
@@ -157,14 +162,39 @@ pub async fn handle_build_push(config_path: PathBuf, verbose: bool, message: Opt
         anyhow::bail!("No files found in {}", upload_dir.display());
     }
 
-    // Get temporary R2 credentials (includes build size)
     let engine_kind = wavedash_config.engine_type()?;
+    let engine_version = wavedash_config.engine_version();
+    let entrypoint_params = match engine_kind {
+        Some(EngineKind::Defold) => {
+            let html_entrypoint = locate_html_entrypoint(&upload_dir);
+            let html_path = html_entrypoint.as_deref().ok_or_else(|| {
+                anyhow::anyhow!("No HTML file found in upload_dir; required for DEFOLD builds")
+            })?;
+            let ver = engine_version
+                .ok_or_else(|| anyhow::anyhow!("DEFOLD engine requires a version"))?;
+            let html_relative_path = html_path
+                .strip_prefix(&upload_dir)
+                .unwrap_or(html_path)
+                .to_string_lossy()
+                .replace('\\', "/");
+            Some(
+                fetch_entrypoint_params("DEFOLD", ver, html_path, Some(&html_relative_path))
+                    .await?,
+            )
+        }
+        Some(EngineKind::JsDos | EngineKind::Ruffle | EngineKind::RenPy) => {
+            wavedash_config.executable_entrypoint_params()
+        }
+        _ => None,
+    };
+
+    // Get temporary R2 credentials (includes build size)
     let creds = get_temp_credentials(
         &wavedash_config.game_id,
         engine_kind.map(|e| e.as_label()),
-        wavedash_config.engine_version(),
+        engine_version,
         wavedash_config.entrypoint(),
-        wavedash_config.executable_entrypoint_params(),
+        entrypoint_params,
         message.as_deref(),
         total_bytes,
         &api_key,
@@ -191,10 +221,7 @@ pub async fn handle_build_push(config_path: PathBuf, verbose: bool, message: Opt
 
     // Print the play URL
     let site_host = config::get("open_browser_website_host")?;
-    let play_url = format!(
-        "{}/playtest/{}/{}",
-        site_host, result.game_slug, creds.uuid
-    );
+    let play_url = format!("{}/playtest/{}/{}", site_host, result.game_slug, creds.uuid);
     println!("\n▶ Play at: {}", play_url);
 
     Ok(())

src/config.rs

@@ -8,8 +8,8 @@ use std::path::PathBuf;
 /// - Staging: ~/.wavedash-stg
 /// - Dev: ~/.wavedash-dev
 pub fn wavedash_dir() -> Result<PathBuf> {
-    let base_dirs = BaseDirs::new()
-        .ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
+    let base_dirs =
+        BaseDirs::new().ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
     Ok(base_dirs.home_dir().join(env!("CONFIG_DIR")))
 }
 
@@ -94,7 +94,9 @@ pub fn create_http_client() -> Result<reqwest::Client> {
         }
     }
 
-    Ok(reqwest::Client::builder().default_headers(headers).build()?)
+    Ok(reqwest::Client::builder()
+        .default_headers(headers)
+        .build()?)
 }
 
 /// Check an API response for errors and return a human-friendly message.
@@ -147,6 +149,11 @@ pub struct UnitySection {
     pub version: String,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct DefoldSection {
+    pub version: String,
+}
+
 /// Shape for engines whose runtime is fetched as a single executable file
 /// (plus an optional loader script). Used by JSDOS, Ruffle, and Ren'Py.
 #[derive(Debug, Deserialize)]
@@ -168,6 +175,9 @@ pub struct WavedashConfig {
     #[serde(rename = "unity")]
     pub unity: Option<UnitySection>,
 
+    #[serde(rename = "defold")]
+    pub defold: Option<DefoldSection>,
+
     #[serde(rename = "jsdos")]
     pub jsdos: Option<ExecutableEngineSection>,
 
@@ -182,6 +192,7 @@ pub struct WavedashConfig {
 pub enum EngineKind {
     Godot,
     Unity,
+    Defold,
     JsDos,
     Ruffle,
     RenPy,
@@ -192,6 +203,7 @@ impl EngineKind {
         match self {
             EngineKind::Godot => "GODOT",
             EngineKind::Unity => "UNITY",
+            EngineKind::Defold => "DEFOLD",
             EngineKind::JsDos => "JSDOS",
             EngineKind::Ruffle => "RUFFLE",
             EngineKind::RenPy => "RENPY",
@@ -236,6 +248,7 @@ impl WavedashConfig {
         let engines: Vec<EngineKind> = [
             self.godot.is_some().then_some(EngineKind::Godot),
             self.unity.is_some().then_some(EngineKind::Unity),
+            self.defold.is_some().then_some(EngineKind::Defold),
             self.jsdos.is_some().then_some(EngineKind::JsDos),
             self.ruffle.is_some().then_some(EngineKind::Ruffle),
             self.renpy.is_some().then_some(EngineKind::RenPy),
@@ -248,7 +261,7 @@ impl WavedashConfig {
             0 => Ok(None),
             1 => Ok(Some(engines[0])),
             _ => anyhow::bail!(
-                "Config must have at most one engine section: [godot], [unity], [jsdos], [ruffle], or [renpy]"
+                "Config must have at most one engine section: [godot], [unity], [defold], [jsdos], [ruffle], or [renpy]"
             ),
         }
     }
@@ -270,18 +283,17 @@ impl WavedashConfig {
         if let Some(unity) = &self.unity {
             return Some(&unity.version);
         }
+        if let Some(defold) = &self.defold {
+            return Some(&defold.version);
+        }
         self.executable_section().map(|s| s.version.as_str())
     }
 
     /// Returns the entrypoint when no engine block is present.
     /// Uses the user-specified value from the config, or defaults to "index.html".
     pub fn entrypoint(&self) -> Option<&str> {
         match self.engine_type() {
-            Ok(None) => Some(
-                self.entrypoint
-                    .as_deref()
-                    .unwrap_or("index.html"),
-            ),
+            Ok(None) => Some(self.entrypoint.as_deref().unwrap_or("index.html")),
             _ => None,
         }
     }

src/dev/entrypoint.rs

@@ -14,12 +14,16 @@ struct EntrypointParamsResponse {
     entrypoint_params: Value,
 }
 
+// Shared by the Godot/Unity/Defold dev and build flows. A root-level `index.html`
+// short-circuits, so single-HTML exports (Godot/Unity) keep their old behavior; the
+// mtime/architecture ranking below only matters for nested multi-HTML dists (Defold).
 pub fn locate_html_entrypoint(upload_dir: &Path) -> Option<PathBuf> {
     let default_index = upload_dir.join("index.html");
     if default_index.is_file() {
         return Some(default_index);
     }
 
+    let mut html_files: Vec<PathBuf> = Vec::new();
     for entry in WalkDir::new(upload_dir)
         .min_depth(1)
         .into_iter()
@@ -28,23 +32,54 @@ pub fn locate_html_entrypoint(upload_dir: &Path) -> Option<PathBuf> {
         if entry.file_type().is_file() {
             if let Some(ext) = entry.path().extension() {
                 if ext.eq_ignore_ascii_case("html") {
-                    return Some(entry.into_path());
+                    html_files.push(entry.into_path());
                 }
             }
         }
     }
 
-    None
+    html_files.sort_by(|a, b| {
+        let modified_a = a.metadata().and_then(|m| m.modified()).ok();
+        let modified_b = b.metadata().and_then(|m| m.modified()).ok();
+        let relative_a = a
+            .strip_prefix(upload_dir)
+            .unwrap_or(a)
+            .to_string_lossy()
+            .replace('\\', "/");
+        let relative_b = b
+            .strip_prefix(upload_dir)
+            .unwrap_or(b)
+            .to_string_lossy()
+            .replace('\\', "/");
+        let architecture_score = |relative: &str| {
+            if relative.starts_with("wasm-web/") {
+                0
+            } else if relative.starts_with("js-web/") {
+                1
+            } else {
+                2
+            }
+        };
+
+        modified_b
+            .cmp(&modified_a)
+            .then_with(|| architecture_score(&relative_a).cmp(&architecture_score(&relative_b)))
+            .then_with(|| relative_a.cmp(&relative_b))
+    });
+
+    html_files.into_iter().next()
 }
 
-pub async fn fetch_entrypoint_params(engine: &str, engine_version: &str, html_path: &Path) -> Result<Value> {
+pub async fn fetch_entrypoint_params(
+    engine: &str,
+    engine_version: &str,
+    html_path: &Path,
+    html_relative_path: Option<&str>,
+) -> Result<Value> {
     let html_content = fs::read_to_string(html_path)
         .with_context(|| format!("Failed to read {}", html_path.display()))?;
     let api_host = config::get("api_host")?;
-    let endpoint = format!(
-        "{}/cli/entrypoint-params",
-        api_host.trim_end_matches('/')
-    );
+    let endpoint = format!("{}/cli/entrypoint-params", api_host.trim_end_matches('/'));
 
     let client = config::create_http_client()?;
     let response = client
@@ -53,6 +88,7 @@ pub async fn fetch_entrypoint_params(engine: &str, engine_version: &str, html_pa
             "engine": engine,
             "engineVersion": engine_version,
             "htmlContent": html_content,
+            "htmlPath": html_relative_path,
         }))
         .send()
         .await

src/dev/mod.rs

@@ -9,7 +9,7 @@ use crate::config::{self, EngineKind, WavedashConfig};
 use crate::file_staging::FileStaging;
 
 mod dev_app;
-mod entrypoint;
+pub(crate) mod entrypoint;
 mod launcher;
 
 use dev_app::{ensure_dev_app, user_data_dir};
@@ -99,7 +99,10 @@ pub async fn handle_dev(config_path: Option<PathBuf>, verbose: bool) -> Result<(
     // pinned to the dev-app source dir, so a relative `./dist` would resolve
     // there (and serve the dev-app's own bundled `main.js`).
     let upload_dir = upload_dir.canonicalize().with_context(|| {
-        format!("Failed to canonicalize upload_dir: {}", upload_dir.display())
+        format!(
+            "Failed to canonicalize upload_dir: {}",
+            upload_dir.display()
+        )
     })?;
 
     let engine_kind = wavedash_config.engine_type()?;
@@ -111,7 +114,7 @@ pub async fn handle_dev(config_path: Option<PathBuf>, verbose: bool) -> Result<(
     let html_entrypoint = locate_html_entrypoint(&upload_dir);
     let engine_version = wavedash_config.engine_version();
     let entrypoint_params = match engine_kind {
-        Some(EngineKind::Godot | EngineKind::Unity) => {
+        Some(EngineKind::Godot | EngineKind::Unity | EngineKind::Defold) => {
             let engine_label = engine_kind.unwrap().as_label();
             let html_path = html_entrypoint.as_deref().ok_or_else(|| {
                 anyhow::anyhow!(
@@ -121,7 +124,15 @@ pub async fn handle_dev(config_path: Option<PathBuf>, verbose: bool) -> Result<(
             })?;
             let ver = engine_version
                 .ok_or_else(|| anyhow::anyhow!("{} engine requires a version", engine_label))?;
-            Some(fetch_entrypoint_params(engine_label, ver, html_path).await?)
+            let html_relative_path = html_path
+                .strip_prefix(&upload_dir)
+                .unwrap_or(html_path)
+                .to_string_lossy()
+                .replace('\\', "/");
+            Some(
+                fetch_entrypoint_params(engine_label, ver, html_path, Some(&html_relative_path))
+                    .await?,
+            )
         }
         Some(EngineKind::JsDos | EngineKind::Ruffle | EngineKind::RenPy) => {
             wavedash_config.executable_entrypoint_params()