diff --git a/services/ws-modules/pydata1/pkg/et_ws_pydata1.js b/services/ws-modules/pydata1/pkg/et_ws_pydata1.js
index a1278b4..cf7a944 100644
--- a/services/ws-modules/pydata1/pkg/et_ws_pydata1.js
+++ b/services/ws-modules/pydata1/pkg/et_ws_pydata1.js
@@ -2,6 +2,9 @@
 // Interface: default(wasmUrl), metadata(), run()
 
 const PYODIDE_BASE_PATH = "/modules/pyodide/";
+// ES-module entry used by the Deno / non-browser `import()` path below (its named export is `loadPyodide`);
+// the browser path loads the UMD `pyodide.js` via a <script> tag instead.
+const PYODIDE_CDN = `${PYODIDE_BASE_PATH}pyodide.mjs`;
 
 let pyodide = null;
 let pyMod = null;
diff --git a/services/ws/src/lib.rs b/services/ws/src/lib.rs
index 1691ad5..7bd3748 100644
--- a/services/ws/src/lib.rs
+++ b/services/ws/src/lib.rs
@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 use std::time::{Duration, Instant};
 
 use actix_web::{Error, HttpRequest, HttpResponse, web};
@@ -108,7 +108,7 @@ const fn default_connection_timeout() -> Option<Duration> {
 #[non_exhaustive]
 pub enum SessionMessage {
     Json(ServerMessage),
-    Text(String),
+    Text(Arc<str>),
     Binary(Bytes),
 }
 
@@ -242,8 +242,8 @@ impl Connection {
         }
     }
 
-    async fn send_text(&mut self, text: String) {
-        if let Err(err) = self.session.text(text).await {
+    async fn send_text(&mut self, text: Arc<str>) {
+        if let Err(err) = self.session.text(text.as_ref()).await {
             warn!("Failed to forward text to {}: {:?}", self.current_agent_id(), err);
         }
     }
@@ -366,8 +366,10 @@ impl Connection {
             from_agent_id,
             recipients.len()
         );
+        // Allocate the payload once; each session gets a cheap Arc clone instead of a per-recipient String.
+        let payload: Arc<str> = Arc::from(text);
         for (_, recipient) in recipients {
-            let _sent = recipient.send(SessionMessage::Text(text.to_string()));
+            let _sent = recipient.send(SessionMessage::Text(Arc::clone(&payload)));
         }
     }
 
diff --git a/utilities/int-gen/src/lib.rs b/utilities/int-gen/src/lib.rs
index c83dafa..824b2db 100644
--- a/utilities/int-gen/src/lib.rs
+++ b/utilities/int-gen/src/lib.rs
@@ -85,6 +85,8 @@ pub enum Error {
     UnsupportedSchemaType(String),
     #[error("enum value not a string in `{0}`")]
     EnumValueNotString(String),
+    #[error("conflicting schema definitions for `$defs/{0}` between client and server schemas")]
+    ConflictingDefs(String),
     #[error("progenitor codegen: {0}")]
     Progenitor(String),
     #[error("zig codegen: {0}")]
diff --git a/utilities/int-gen/src/wit/messages.rs b/utilities/int-gen/src/wit/messages.rs
index ff4ccc9..f4105ae 100644
--- a/utilities/int-gen/src/wit/messages.rs
+++ b/utilities/int-gen/src/wit/messages.rs
@@ -46,7 +46,7 @@ type EnumSet = HashSet<String>;
 pub fn render(client_schema: &Schema, server_schema: &Schema) -> Result<String, Error> {
     let client_root = client_schema.as_value();
     let server_root = server_schema.as_value();
-    let merged_root = merge_defs(client_root, server_root);
+    let merged_root = merge_defs(client_root, server_root)?;
     let mut interface = Interface::new("messages");
     interface.set_docs(Some(WS_DESCRIPTION));
 
@@ -77,11 +77,19 @@ pub fn render(client_schema: &Schema, server_schema: &Schema) -> Result<String,
     clippy::single_call_fn,
     reason = "named helper called once by render(); kept separate for the dedup logic"
 )]
-fn merge_defs(client_root: &serde_json::Value, server_root: &serde_json::Value) -> serde_json::Value {
+fn merge_defs(client_root: &serde_json::Value, server_root: &serde_json::Value) -> Result<serde_json::Value, Error> {
     let mut merged = serde_json::Map::new();
     for root in [client_root, server_root] {
         if let Some(defs) = root.get("$defs").and_then(|val| val.as_object()) {
             for (name, def) in defs {
+                // A `$defs` name shared by both schemas must resolve to the same definition; a mismatch means
+                // the client and server disagree on a shared type, which would silently pick one arbitrarily.
+                if let Some(previous) = merged.get(name) {
+                    if previous != def {
+                        return Err(Error::ConflictingDefs(name.clone()));
+                    }
+                    continue;
+                }
                 let _previous: Option<serde_json::Value> = merged.insert(name.clone(), def.clone());
             }
         }
@@ -90,7 +98,7 @@ fn merge_defs(client_root: &serde_json::Value, server_root: &serde_json::Value)
     if !merged.is_empty() {
         let _previous: Option<serde_json::Value> = root.insert("$defs".to_string(), serde_json::Value::Object(merged));
     }
-    serde_json::Value::Object(root)
+    Ok(serde_json::Value::Object(root))
 }
 
 #[expect(