Merge branch 'next' into fix-optional

Author: elrrrrrrr

crates/pack-api/src/app.rs

@@ -252,15 +252,23 @@ impl AppEndpoint {
 
     #[turbo_tasks::function]
     pub async fn app_runtime_entries(self: Vc<Self>) -> Result<Vc<EvaluatableAssets>> {
+        let watch = self.project().await?.watch.enable;
         Ok(get_client_runtime_entries(
             self.project().project_path().owned().await?,
             self.project().mode(),
             self.project().config(),
             self.project().execution_context(),
             self.project().pack_path().owned().await?,
+            Vc::cell(watch),
             Vc::cell(
-                self.project().await?.watch.enable
-                    && *self.project().config().is_hmr_enabled().await?,
+                watch
+                    && self
+                        .project()
+                        .config()
+                        .dev_server()
+                        .await?
+                        .hot
+                        .unwrap_or_default(),
             ),
         )
         .resolve_entries(Vc::upcast(self.app_module_context())))

crates/pack-api/src/library.rs

@@ -170,6 +170,7 @@ impl LibraryEndpoint {
             self.project().pack_path().owned().await?,
             // Library project not support watch mode
             Vc::cell(false),
+            Vc::cell(false),
         )
         .resolve_entries(Vc::upcast(self.library_module_context())))
     }

crates/pack-core/src/client/context.rs

@@ -196,7 +196,8 @@ pub async fn get_client_runtime_entries(
     config: Vc<Config>,
     execution_context: Vc<ExecutionContext>,
     pack_path: FileSystemPath,
-    hmr: Vc<bool>,
+    watch: Vc<bool>,
+    hot: Vc<bool>,
 ) -> Result<Vc<RuntimeEntries>> {
     let mut runtime_entries = vec![];
     let resolve_options_context = get_client_resolve_options_context(
@@ -207,9 +208,11 @@ pub async fn get_client_runtime_entries(
         pack_path,
     );
 
-    let hmr = *hmr.await?;
+    let is_development = mode.await?.is_development();
+    let watch = *watch.await?;
+    let hot = *hot.await?;
 
-    if hmr && mode.await?.is_development() {
+    if is_development && watch {
         let enable_react_refresh =
             assert_can_resolve_react_refresh(project_root.clone(), resolve_options_context)
                 .await?
@@ -224,7 +227,9 @@ pub async fn get_client_runtime_entries(
                     .resolved_cell(),
             )
         };
+    }
 
+    if is_development && watch && hot {
         runtime_entries.push(
             RuntimeEntry::Source(ResolvedVc::upcast(
                 FileSource::new(embed_file_path(rcstr!("hmr/bootstrap.ts")).owned().await?)

crates/pack-core/src/config.rs

@@ -98,19 +98,8 @@ pub struct LibraryOptions {
 #[turbo_tasks::value(transparent)]
 pub struct Entries(Vec<EntryOptions>);
 
-#[derive(
-    Clone,
-    Debug,
-    Eq,
-    Default,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    ValueDebugFormat,
-    NonLocalValue,
-    OperationValue,
-)]
+#[turbo_tasks::value(eq = "manual")]
+#[derive(Clone, Debug, PartialEq, Default, OperationValue)]
 #[serde(rename_all = "camelCase")]
 pub struct DevServer {
     pub hot: Option<bool>,
@@ -1025,13 +1014,8 @@ impl Config {
     }
 
     #[turbo_tasks::function]
-    pub fn is_hmr_enabled(&self) -> Vc<bool> {
-        Vc::cell(
-            self.dev_server
-                .as_ref()
-                .and_then(|ds| ds.hot)
-                .unwrap_or_default(),
-        )
+    pub fn dev_server(&self) -> Vc<DevServer> {
+        self.dev_server.clone().unwrap_or_default().cell()
     }
 
     #[turbo_tasks::function]

crates/utoo-wasm/src/project.rs

@@ -58,9 +58,14 @@ impl Project {
     /// Calculate MD5 hash of byte content (async for better thread scheduling)
     #[wasm_bindgen(js_name = sigMd5)]
     pub async fn sig_md5(content: Vec<u8>) -> Result<String, JsError> {
-        let result = tokio::task::spawn_blocking(move || opfs_project::pack::sig_md5(&content))
+        let rt = TOKIO_RUNTIME
+            .get()
+            .ok_or_else(|| JsError::new("tokio runtime not initialized"))?;
+
+        let result = rt
+            .spawn_blocking(move || opfs_project::pack::sig_md5(&content))
             .await
-            .map_err(|e| JsError::new(&format!("Task failed: {}", e)))?;
+            .map_err(to_js_error)?;
         Ok(result)
     }
 
@@ -85,9 +90,13 @@ impl Project {
             .map(|f| PackFile::new(f.path, f.content))
             .collect();
 
-        let bytes = tokio::task::spawn_blocking(move || opfs_project::pack::gzip(&pack_files))
-            .await
-            .map_err(|e| JsError::new(&format!("Task failed: {}", e)))?
+        let rt = TOKIO_RUNTIME
+            .get()
+            .ok_or_else(|| JsError::new("tokio runtime not initialized"))?;
+
+        let bytes = rt
+            .spawn_blocking(move || opfs_project::pack::gzip(&pack_files))
+            .await?
             .map_err(to_js_error)?;
         Ok(js_sys::Uint8Array::from(&bytes[..]))
     }
@@ -143,12 +152,11 @@ impl Project {
             None => return Err(JsError::new("invalid pack project")),
         };
 
-        TOKIO_RUNTIME
-            .with(|rt| {
-                rt.get()
-                    .expect("tokio runtime not found")
-                    .spawn(async move { pack_project.build().await })
-            })
+        let rt = TOKIO_RUNTIME
+            .get()
+            .ok_or_else(|| JsError::new("tokio runtime not initialized"))?;
+
+        rt.spawn(async move { pack_project.build().await })
             .await
             .map_err(to_js_error)?
             .map_or_else(
@@ -206,12 +214,11 @@ impl Project {
                 ..Default::default()
             };
 
-            let pack_context = TOKIO_RUNTIME
-                .with(|rt| {
-                    rt.get()
-                        .expect("tokio runtime not found")
-                        .spawn(PackProject::initialize(options))
-                })
+            let rt = TOKIO_RUNTIME
+                .get()
+                .ok_or_else(|| anyhow::anyhow!("tokio runtime not initialized"))?;
+            let pack_context = rt
+                .spawn(PackProject::initialize(options))
                 .await
                 .context("fail to initialize pack project")??;
 

crates/utoo-wasm/src/tokio_runtime.rs

@@ -2,35 +2,26 @@ use std::{
     cell::OnceCell,
     sync::{
         atomic::{AtomicUsize, Ordering},
-        LazyLock,
+        OnceLock,
     },
     time::Duration,
 };
 
 use tokio::runtime;
 
-thread_local! {
-    pub static TOKIO_RUNTIME: OnceCell<runtime::Runtime> = const { OnceCell::new() };
-}
+pub static TOKIO_RUNTIME: OnceLock<runtime::Runtime> = OnceLock::new();
 
 pub fn init_tokio_runtime(worker_url: String) {
-    TOKIO_RUNTIME.with(|ctx| {
-        ctx.get_or_init(|| {
-            runtime::Builder::new_multi_thread()
-                /* *
-                 * The default dlmalloc is a single global allocator,
-                 * it will block threads scheduling,
-                 * see https://web.dev/articles/scaling-multithreaded-webassembly-applications#heap_management_mallocfree
-                 */
-                .disable_lifo_slot()
-                .thread_name_fn(|| {
-                    static ATOMIC_ID: AtomicUsize = AtomicUsize::new(1);
-                    let id = ATOMIC_ID.fetch_add(1, Ordering::SeqCst);
-                    format!("tokio-runtime-worker-{id}")
-                })
-                .wasm_bindgen_shim_url(worker_url.clone())
-                .build()
-                .unwrap()
-        });
-    })
+    TOKIO_RUNTIME.get_or_init(|| {
+        runtime::Builder::new_multi_thread()
+            .disable_lifo_slot()
+            .thread_name_fn(|| {
+                static ATOMIC_ID: AtomicUsize = AtomicUsize::new(1);
+                let id = ATOMIC_ID.fetch_add(1, Ordering::SeqCst);
+                format!("tokio-runtime-worker-{id}")
+            })
+            .wasm_bindgen_shim_url(worker_url.clone())
+            .build()
+            .expect("Failed to build tokio runtime")
+    });
 }

packages/pack-shared/src/config.ts

@@ -178,7 +178,12 @@ export interface ConfigComplete {
   stats?: boolean;
   persistentCaching?: boolean;
   nodePolyfill?: boolean;
-  devServer?: { hot?: boolean; port?: number; host?: string; https?: boolean };
+  devServer?: {
+    hot?: boolean;
+    port?: number;
+    host?: string;
+    https?: boolean;
+  };
   cacheHandler?: string;
   experimental?: ExperimentalConfig;
 }

packages/pack/src/commands/dev.ts

@@ -76,7 +76,10 @@ async function serveInternal(
       ...options,
       config: {
         ...options.config,
-        devServer: { ...(options.config.devServer || {}), hot: true },
+        devServer: {
+          ...(options.config.devServer || {}),
+          hot: true,
+        },
       },
       packPath: getPackPath(),
     },

packages/utoo-web/src/project/InternalProject.ts

@@ -77,9 +77,7 @@ class InternalEndpoint implements ProjectEndpoint {
     if (encoding === "utf8") {
       ret = await ProjectInternal.readToString(path);
     } else {
-      ret = await ProjectInternal.read(path);
-      const copied = ret.slice(0);
-      return comlink.transfer(copied, [copied.buffer]);
+      return await ProjectInternal.read(path);
     }
     return ret as any;
   }
@@ -162,9 +160,7 @@ class InternalEndpoint implements ProjectEndpoint {
 
   async gzip(files: PackFile[]) {
     await this.wasmInit!;
-    const ret = await ProjectInternal.gzip(files);
-    const copied = ret.slice(0);
-    return comlink.transfer(copied, [copied.buffer]);
+    return await ProjectInternal.gzip(files);
   }
 
   async sigMd5(content: Uint8Array) {

packages/utoo-web/src/project/Project.ts

@@ -126,11 +126,7 @@ export class Project implements ProjectEndpoint {
   ) {
     await this.#mount;
     if (content instanceof Uint8Array) {
-      return await this.remote.writeFile(
-        path,
-        comlink.transfer(content, [content.buffer]),
-        encoding,
-      );
+      return await this.remote.writeFile(path, content, encoding);
     }
     return await this.remote.writeFile(path, content, encoding);
   }
@@ -175,15 +171,12 @@ export class Project implements ProjectEndpoint {
 
   public async gzip(files: PackFile[]): Promise<Uint8Array> {
     await this.#mount;
-    const buffers = files.map((f) => f.content.buffer);
-    return await this.remote.gzip(comlink.transfer(files, buffers));
+    return await this.remote.gzip(files);
   }
 
   public async sigMd5(content: Uint8Array): Promise<string> {
     await this.#mount;
-    return await this.remote.sigMd5(
-      comlink.transfer(content, [content.buffer]),
-    );
+    return await this.remote.sigMd5(content);
   }
 
   public static fork(