fix: release Dever 0.1.6 with shared runtime assets and unbounded workers

test/dever-tests/fixtures/component_fixture.rs

@@ -135,13 +135,14 @@ fn handle_call(call: &Value, mode: &str, hello: &Value) -> Result<(), String> {
                 "payload": {},
             }))
         }
-        "timeout" => {
-            let cancel = read_json()?;
-            require_kind(&cancel, "cancel")?;
-            if field(&cancel, "id")? != id {
-                return Err("cancel id does not match timed out call".into());
-            }
-            write_json(&json!({"kind": "result", "id": id, "payload": {}}))
+        "delayed" => {
+            let delay = call
+                .pointer("/payload/value")
+                .and_then(Value::as_u64)
+                .filter(|delay| *delay <= 35_000)
+                .ok_or("invalid fixture delay")?;
+            std::thread::sleep(std::time::Duration::from_millis(delay));
+            write_json(&json!({"kind": "result", "id": id, "payload": field(call, "payload")?}))
         }
         "crash" => std::process::exit(7),
         "duplicate" => write_raw(&format!(

test/dever-tests/tests/external_command.rs

@@ -87,7 +87,7 @@ impl Fixture {
             capabilities: vec!["file".into(), "process".into()],
             operations: vec!["execute".into()],
             setting: None,
-            timeout_ms: 30_000,
+            protocol_timeout_ms: 30_000,
         })
         .await
     }

test/dever-tests/tests/external_component.rs

@@ -14,7 +14,7 @@ const OPERATIONS: &[&str] = &[
     "echo",
     "fail",
     "wait",
-    "timeout",
+    "delayed",
     "crash",
     "duplicate",
     "out_of_order",
@@ -23,6 +23,28 @@ const OPERATIONS: &[&str] = &[
     "truncated",
 ];
 
+#[test]
+fn component_call_can_run_longer_than_thirty_seconds() {
+    let fixture = install_fixture();
+    dever_runtime::task::run_entry(async {
+        fixture.prepare()?;
+        component::start(definition("long_call", fixture.entry, "normal", 2_000)).await?;
+        let result = tokio::time::timeout(
+            std::time::Duration::from_secs(40),
+            component::call("long_call", "delayed", &payload(31_000)),
+        )
+        .await
+        .map_err(|_| "long-call fixture did not finish")??;
+        match result {
+            Reply::Result(body) => assert_eq!(body, r#"{"value":31000}"#),
+            Reply::Error { .. } => return Err("long call returned an error".into()),
+        }
+        component::shutdown().await
+    })
+    .expect("long external invocation has no implicit execution deadline");
+    assert!(fixture.path.with_extension("shutdown").is_file());
+}
+
 #[test]
 fn component_protocol_and_lifecycle_are_bounded() {
     let fixture = install_fixture();
@@ -159,14 +181,20 @@ async fn normal_lifecycle(entry: &'static str) -> Result<(), String> {
         .await
         .map_err(|error| format!("cancel wait: {error}"))?;
 
-    let timeout = component::call("normal", "timeout", &payload(0))
-        .await
-        .expect_err("timeout operation must reach the deadline");
-    assert_eq!(timeout, "external Adapter call timed out");
+    match tokio::time::timeout(
+        std::time::Duration::from_secs(2),
+        component::call("normal", "delayed", &payload(150)),
+    )
+    .await
+    .expect("fixture call must finish")?
+    {
+        Reply::Result(body) => assert_eq!(body, r#"{"value":150}"#),
+        Reply::Error { .. } => return Err("delayed call returned a business error".into()),
+    }
     assert!(matches!(
         component::call("normal", "echo", &payload(3))
             .await
-            .map_err(|error| format!("echo after timeout: {error}"))?,
+            .map_err(|error| format!("echo after delayed call: {error}"))?,
         Reply::Result(_)
     ));
 
@@ -248,7 +276,7 @@ fn definition(
     key: &'static str,
     entry: &'static str,
     mode: &'static str,
-    timeout_ms: u64,
+    protocol_timeout_ms: u64,
 ) -> Definition {
     let (_, setting) = component::adapter_settings()
         .unwrap()
@@ -266,7 +294,7 @@ fn definition(
         capabilities: vec!["network".into(), "file".into()],
         operations: OPERATIONS.iter().map(|name| (*name).into()).collect(),
         setting: Some(setting.to_string()),
-        timeout_ms,
+        protocol_timeout_ms,
     }
 }