refactor(worker-runtime): route by WorkerRef and reconcile owned execution cleanup

crates/workspace-server/src/hosts.rs

@@ -6869,7 +6869,7 @@ mod tests {
 
         fn dispatch_input(
             &self,
-            _handle: &worker_runtime::execution::WorkerExecutionHandle,
+            _worker_ref: &EmbeddedWorkerRef,
             _input: EmbeddedWorkerInput,
         ) -> worker_runtime::execution::WorkerExecutionResult {
             worker_runtime::execution::WorkerExecutionResult::rejected(
@@ -6898,7 +6898,7 @@ mod tests {
 
         fn dispatch_input(
             &self,
-            _handle: &worker_runtime::execution::WorkerExecutionHandle,
+            _worker_ref: &EmbeddedWorkerRef,
             _input: EmbeddedWorkerInput,
         ) -> worker_runtime::execution::WorkerExecutionResult {
             unreachable!("Repository observation test does not dispatch Worker input")
@@ -6978,10 +6978,6 @@ mod tests {
                 .unwrap()
                 .insert(request.worker_ref.clone(), request.context);
             worker_runtime::execution::WorkerExecutionSpawnResult::Connected {
-                handle: worker_runtime::execution::WorkerExecutionHandle::new(
-                    request.worker_ref,
-                    self.backend_id(),
-                ),
                 worker_state: protocol::WorkerStateSnapshot {
                     ..protocol::WorkerStatus::Idle.into()
                 },
@@ -7000,15 +6996,10 @@ mod tests {
 
         fn dispatch_input(
             &self,
-            handle: &worker_runtime::execution::WorkerExecutionHandle,
+            worker_ref: &EmbeddedWorkerRef,
             input: EmbeddedWorkerInput,
         ) -> worker_runtime::execution::WorkerExecutionResult {
-            let context = self
-                .contexts
-                .lock()
-                .unwrap()
-                .get(handle.worker_ref())
-                .cloned();
+            let context = self.contexts.lock().unwrap().get(worker_ref).cloned();
             let Some(context) = context else {
                 return worker_runtime::execution::WorkerExecutionResult::rejected(
                     worker_runtime::execution::WorkerExecutionOperation::Input,

crates/workspace-server/src/runtime_subscription_tests.rs

@@ -3,10 +3,10 @@ use protocol::subscription::{SubscriptionWorkerIds, SubscriptionWorkerState};
 use worker_runtime::Runtime;
 use worker_runtime::catalog::{CreateWorkerRequest, ProfileSelector, ProfileSourceArchiveSource};
 use worker_runtime::execution::{
-    WorkerExecutionBackend, WorkerExecutionHandle, WorkerExecutionOperation, WorkerExecutionResult,
+    WorkerExecutionBackend, WorkerExecutionOperation, WorkerExecutionResult,
     WorkerExecutionSpawnRequest, WorkerExecutionSpawnResult,
 };
-use worker_runtime::identity::WorkerId;
+use worker_runtime::identity::{WorkerId, WorkerRef};
 
 #[derive(Debug)]
 struct TestExecutionBackend;
@@ -16,9 +16,8 @@ impl WorkerExecutionBackend for TestExecutionBackend {
         "runtime-subscription-test"
     }
 
-    fn spawn_worker(&self, request: WorkerExecutionSpawnRequest) -> WorkerExecutionSpawnResult {
+    fn spawn_worker(&self, _request: WorkerExecutionSpawnRequest) -> WorkerExecutionSpawnResult {
         WorkerExecutionSpawnResult::connected(
-            WorkerExecutionHandle::new(request.worker_ref, self.backend_id()),
             protocol::WorkerStateSnapshot {
                 ..protocol::WorkerStatus::Idle.into()
             },
@@ -28,7 +27,7 @@ impl WorkerExecutionBackend for TestExecutionBackend {
 
     fn dispatch_input(
         &self,
-        _handle: &WorkerExecutionHandle,
+        _worker_ref: &WorkerRef,
         input: worker_runtime::interaction::WorkerInput,
     ) -> WorkerExecutionResult {
         if let Some(submission_request_id) = input.submission_request_id {
@@ -43,7 +42,7 @@ impl WorkerExecutionBackend for TestExecutionBackend {
         }
     }
 
-    fn stop_worker(&self, _handle: &WorkerExecutionHandle) -> WorkerExecutionResult {
+    fn stop_worker(&self, _worker_ref: &WorkerRef) -> WorkerExecutionResult {
         WorkerExecutionResult::accepted(WorkerExecutionOperation::Stop)
     }
 }