feat: implement code execution integration and serde prevention

- Add code execution to build pipeline with validation
- Integrate CodeExecutionResult tracking in SiteOutput
- Fail builds on code execution errors in production mode
- Add comprehensive error reporting with source locations
- Fix PlugResult return types in code execution plugin
- Update baseline crate to use Facet instead of serde
- Add clippy.toml to prevent serde usage across workspace
- Add graceful terminal cleanup before error display

Author: fasterthanlime

Cargo.lock

@@ -1,6 +1,8 @@
 [workspace]
 members = [".", "crates/gingembre", "crates/livereload-client", "crates/dodeca-devtools", "crates/dodeca-protocol", "crates/plugcard", "crates/plugcard-macros", "crates/dodeca-baseline", "crates/dodeca-webp", "crates/dodeca-jxl", "crates/dodeca-minify", "crates/dodeca-svgo", "crates/dodeca-sass", "crates/dodeca-css", "crates/dodeca-js", "crates/dodeca-pagefind", "crates/dodeca-image", "crates/dodeca-fonts", "crates/dodeca-linkcheck", "crates/dodeca-code-execution", "xtask"]
 
+
+
 [package]
 name = "dodeca"
 version = "0.2.12"
@@ -14,6 +16,8 @@ homepage = "https://dodeca.bearcove.eu/"
 keywords = ["static-site", "ssg", "incremental"]
 categories = ["command-line-utilities", "web-programming"]
 
+
+
 [package.metadata.wix]
 upgrade-guid = "F32CA0D7-4DDE-4333-A5EA-374211B0C136"
 path-guid = "68C82E46-C932-4CA9-BEE0-216F988EADF9"
@@ -91,6 +95,9 @@ postcard = { version = "1", features = ["alloc"] }  # Fast, compact binary seria
 # Devtools protocol (shared types between server and WASM client)
 dodeca-protocol = { path = "crates/dodeca-protocol" }
 
+# Code execution plugin types
+dodeca-code-execution = { path = "crates/dodeca-code-execution" }
+
 # Content-addressed storage
 rapidhash = "4"
 canopydb = "0.2.5"
@@ -112,6 +119,8 @@ lol_html = "2.7"        # Streaming HTML rewriter
 
 # Image processing is now handled entirely via plugins (dodeca-image, dodeca-webp, dodeca-jxl)
 
+# Code execution is handled via the dodeca-code-execution plugin
+
 # Plugin system for image encoding/decoding, minification, etc.
 plugcard = { path = "crates/plugcard" }
 

Cargo.toml

@@ -0,0 +1,13 @@
+# Clippy configuration for dodeca
+# Disallow serde usage - we use facet/postcard for serialization instead
+
+disallowed-types = [
+    { path = "serde::Serialize", reason = "Use facet::Facet for serialization instead" },
+    { path = "serde::Deserialize", reason = "Use facet::Facet for serialization instead" },
+    { path = "serde_json::Value", reason = "Use facet_postcard for serialization instead" },
+]
+
+disallowed-methods = [
+    { path = "serde_json::to_string", reason = "Use facet_postcard::to_allocvec for serialization instead" },
+    { path = "serde_json::from_str", reason = "Use facet_postcard::from_bytes for deserialization instead" },
+]

clippy.toml

@@ -16,12 +16,16 @@ pub fn add(a: i32, b: i32) -> i32 {
 
 #[cfg(test)]
 mod tests {
-    use plugcard::{list_methods, MethodCallData, MethodCallResult};
+    use plugcard::{MethodCallData, MethodCallResult, list_methods};
 
     #[test]
     fn test_methods_registered() {
         let methods = list_methods();
-        assert!(methods.len() >= 2, "Expected at least 2 methods, got {}", methods.len());
+        assert!(
+            methods.len() >= 2,
+            "Expected at least 2 methods, got {}",
+            methods.len()
+        );
 
         let names: Vec<_> = methods.iter().map(|m| m.name).collect();
         assert!(names.contains(&"reverse_string"), "Missing reverse_string");
@@ -34,12 +38,15 @@ mod tests {
         let reverse = methods.iter().find(|m| m.name == "reverse_string").unwrap();
 
         // Serialize input: { input: "hello" }
-        #[derive(plugcard::serde::Serialize)]
-        #[serde(crate = "plugcard::serde")]
-        struct Input { input: String }
+        #[derive(plugcard::facet::Facet)]
+        struct Input {
+            input: String,
+        }
 
-        let input = Input { input: "hello".to_string() };
-        let input_bytes = plugcard::postcard::to_allocvec(&input).unwrap();
+        let input = Input {
+            input: "hello".to_string(),
+        };
+        let input_bytes = plugcard::facet_postcard::to_allocvec(&input).unwrap();
 
         let mut output_buf = [0u8; 256];
         let mut data = MethodCallData {
@@ -58,26 +65,29 @@ mod tests {
         assert_eq!(data.result, MethodCallResult::Success);
 
         // Deserialize output
-        let output: String = plugcard::postcard::from_bytes(&output_buf[..data.output_len]).unwrap();
+        let output: String =
+            plugcard::facet_postcard::from_bytes(&output_buf[..data.output_len]).unwrap();
         assert_eq!(output, "olleh");
     }
 
     #[test]
     fn test_add_dispatch() {
         let methods = list_methods();
-        let add_method = methods.iter().find(|m| m.name == "add").unwrap();
+        let add = methods.iter().find(|m| m.name == "add").unwrap();
 
-        // Serialize input: { a: 2, b: 3 }
-        #[derive(plugcard::serde::Serialize)]
-        #[serde(crate = "plugcard::serde")]
-        struct Input { a: i32, b: i32 }
+        // Serialize input: { a: 5, b: 3 }
+        #[derive(plugcard::facet::Facet)]
+        struct Input {
+            a: i32,
+            b: i32,
+        }
 
-        let input = Input { a: 2, b: 3 };
-        let input_bytes = plugcard::postcard::to_allocvec(&input).unwrap();
+        let input = Input { a: 5, b: 3 };
+        let input_bytes = plugcard::facet_postcard::to_allocvec(&input).unwrap();
 
         let mut output_buf = [0u8; 256];
         let mut data = MethodCallData {
-            key: add_method.key,
+            key: add.key,
             input_ptr: input_bytes.as_ptr(),
             input_len: input_bytes.len(),
             output_ptr: output_buf.as_mut_ptr(),
@@ -87,12 +97,13 @@ mod tests {
         };
 
         // Call the method
-        unsafe { (add_method.call)(&mut data) };
+        unsafe { (add.call)(&mut data) };
 
         assert_eq!(data.result, MethodCallResult::Success);
 
         // Deserialize output
-        let output: i32 = plugcard::postcard::from_bytes(&output_buf[..data.output_len]).unwrap();
-        assert_eq!(output, 5);
+        let output: i32 =
+            plugcard::facet_postcard::from_bytes(&output_buf[..data.output_len]).unwrap();
+        assert_eq!(output, 8);
     }
 }