netrun-sim 0.1.0__tar.gz → 0.1.1__tar.gz

{netrun_sim-0.1.0 → netrun_sim-0.1.1}/Cargo.lock

@@ -90,12 +90,6 @@ dependencies = [
  "rustversion",
 ]
 
-[[package]]
-name = "itoa"
-version = "1.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ee5b5339afb4c41626dde77b7a611bd4f2c202b897852b4bcf5d03eddc61010"
-
 [[package]]
 name = "js-sys"
 version = "0.3.83"
@@ -118,12 +112,6 @@ version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
-[[package]]
-name = "memchr"
-version = "2.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
-
 [[package]]
 name = "memoffset"
 version = "0.9.1"
@@ -138,8 +126,6 @@ name = "netrun-sim"
 version = "0.1.0"
 dependencies = [
  "indexmap",
- "serde",
- "serde_json",
  "thiserror",
  "ulid",
  "utcnow",
@@ -151,7 +137,6 @@ version = "0.1.0"
 dependencies = [
  "netrun-sim",
  "pyo3",
- "serde_json",
  "ulid",
 ]
 
@@ -306,49 +291,6 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
-[[package]]
-name = "serde"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
-dependencies = [
- "serde_core",
- "serde_derive",
-]
-
-[[package]]
-name = "serde_core"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.147"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6af14725505314343e673e9ecb7cd7e8a36aa9791eb936235a3567cc31447ae4"
-dependencies = [
- "itoa",
- "memchr",
- "serde",
- "serde_core",
- "zmij",
-]
-
 [[package]]
 name = "syn"
 version = "2.0.111"
@@ -604,9 +546,3 @@ dependencies = [
  "quote",
  "syn",
 ]
-
-[[package]]
-name = "zmij"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1dccf46b25b205e4bebe1d5258a991df1cc17801017a845cb5b3fe0269781aa"

{netrun_sim-0.1.0 → netrun_sim-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netrun-sim
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: python-ulid>=1.0

{netrun_sim-0.1.0 → netrun_sim-0.1.1}/core/Cargo.toml

@@ -1,14 +1,13 @@
 [package]
 name = "netrun-sim"
+description = "A flow-based development (FBD) simulation engine."
 version = "0.1.0"
 edition = "2024"
+license-file = "../../LICENSE"
+repository = "https://github.com/lukastk/netrun/"
 
 [dependencies]
 indexmap = "2.12.1"
-serde = { version = "1.0", features = ["derive"] }
 thiserror = "2.0"
 ulid = "=1.1.0"
 utcnow = "0.2.7"
-
-[dev-dependencies]
-serde_json = "1.0"

{netrun_sim-0.1.0 → netrun_sim-0.1.1}/core/examples/diamond_flow.rs

@@ -13,7 +13,7 @@
 //! - Synchronization: D's epoch only triggers when both inputs are present
 
 use netrun_sim::graph::{
-    Edge, EdgeRef, Graph, Node, Port, PortRef, PortSlotSpec, PortState, PortType,
+    Edge, Graph, Node, Port, PortRef, PortSlotSpec, PortState, PortType,
     SalvoCondition, SalvoConditionTerm,
 };
 use netrun_sim::net::{
@@ -190,26 +190,23 @@ fn create_simple_node(name: &str) -> Node {
     }
 }
 
-fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> (EdgeRef, Edge) {
-    (
-        EdgeRef {
-            source: PortRef {
-                node_name: src_node.to_string(),
-                port_type: PortType::Output,
-                port_name: src_port.to_string(),
-            },
-            target: PortRef {
-                node_name: tgt_node.to_string(),
-                port_type: PortType::Input,
-                port_name: tgt_port.to_string(),
-            },
+fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> Edge {
+    Edge {
+        source: PortRef {
+            node_name: src_node.to_string(),
+            port_type: PortType::Output,
+            port_name: src_port.to_string(),
         },
-        Edge {},
-    )
+        target: PortRef {
+            node_name: tgt_node.to_string(),
+            port_type: PortType::Input,
+            port_name: tgt_port.to_string(),
+        },
+    }
 }
 
 fn edge_location(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> PacketLocation {
-    PacketLocation::Edge(EdgeRef {
+    PacketLocation::Edge(Edge {
         source: PortRef {
             node_name: src_node.to_string(),
             port_type: PortType::Output,

{netrun_sim-0.1.0 → netrun_sim-0.1.1}/core/examples/linear_flow.rs

@@ -8,7 +8,7 @@
 //! - Sending output salvos to continue flow
 
 use netrun_sim::graph::{
-    Edge, EdgeRef, Graph, Node, Port, PortRef, PortSlotSpec, PortState, PortType,
+    Edge, Graph, Node, Port, PortRef, PortSlotSpec, PortState, PortType,
     SalvoCondition, SalvoConditionTerm,
 };
 use netrun_sim::net::{
@@ -34,7 +34,7 @@ fn main() {
     };
 
     // Transport packet to the edge A -> B
-    let edge_a_b = PacketLocation::Edge(EdgeRef {
+    let edge_a_b = PacketLocation::Edge(Edge {
         source: PortRef {
             node_name: "A".to_string(),
             port_type: PortType::Output,
@@ -174,20 +174,17 @@ fn create_node(name: &str, in_ports: Vec<&str>, out_ports: Vec<&str>) -> Node {
     }
 }
 
-fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> (EdgeRef, Edge) {
-    (
-        EdgeRef {
-            source: PortRef {
-                node_name: src_node.to_string(),
-                port_type: PortType::Output,
-                port_name: src_port.to_string(),
-            },
-            target: PortRef {
-                node_name: tgt_node.to_string(),
-                port_type: PortType::Input,
-                port_name: tgt_port.to_string(),
-            },
+fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> Edge {
+    Edge {
+        source: PortRef {
+            node_name: src_node.to_string(),
+            port_type: PortType::Output,
+            port_name: src_port.to_string(),
         },
-        Edge {},
-    )
+        target: PortRef {
+            node_name: tgt_node.to_string(),
+            port_type: PortType::Input,
+            port_name: tgt_port.to_string(),
+        },
+    }
 }

{netrun_sim-0.1.0 → netrun_sim-0.1.1}/core/src/graph.rs

@@ -3,14 +3,13 @@
 //! This module defines the static structure of a network: nodes, ports, edges,
 //! and the conditions that govern packet flow (salvo conditions).
 
-use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 
 /// The name of a port on a node.
 pub type PortName = String;
 
 /// Specifies the capacity of a port (how many packets it can hold).
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub enum PortSlotSpec {
     /// Port can hold unlimited packets.
     Infinite,
@@ -19,7 +18,7 @@ pub enum PortSlotSpec {
 }
 
 /// A port on a node where packets can enter or exit.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Port {
     /// The capacity specification for this port.
     pub slots_spec: PortSlotSpec,
@@ -29,7 +28,7 @@ pub struct Port {
 ///
 /// These predicates test the current packet count at a port against
 /// various conditions like empty, full, or numeric comparisons.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub enum PortState {
     /// Port has zero packets.
     Empty,
@@ -55,7 +54,7 @@ pub enum PortState {
 ///
 /// This forms a simple expression tree that can combine port state checks
 /// with logical operators (And, Or, Not).
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub enum SalvoConditionTerm {
     /// Check if a specific port matches a state predicate.
     Port { port_name: String, state: PortState },
@@ -130,7 +129,7 @@ pub type SalvoConditionName = String;
 /// Salvo conditions are attached to nodes and control the flow of packets:
 /// - **Input salvo conditions**: Define when packets at input ports can trigger a new epoch
 /// - **Output salvo conditions**: Define when packets at output ports can be sent out
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub struct SalvoCondition {
     /// Maximum number of times this condition can trigger per epoch.
     /// For input salvo conditions, this must be 1.
@@ -160,7 +159,7 @@ fn collect_ports_from_term(term: &SalvoConditionTerm, ports: &mut HashSet<PortNa
 }
 
 /// Errors that can occur during graph validation
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, thiserror::Error)]
+#[derive(Debug, Clone, PartialEq, thiserror::Error)]
 pub enum GraphValidationError {
     /// Edge references a node that doesn't exist
     #[error("edge {edge_source} -> {edge_target} references non-existent node '{missing_node}'")]
@@ -230,7 +229,7 @@ pub type NodeName = String;
 /// - Output ports where packets are sent
 /// - Input salvo conditions that define when arriving packets trigger an epoch
 /// - Output salvo conditions that define when output packets can be sent
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Node {
     /// The unique name of this node.
     pub name: NodeName,
@@ -245,7 +244,7 @@ pub struct Node {
 }
 
 /// Whether a port is for input or output.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum PortType {
     /// An input port (packets flow into the node).
     Input,
@@ -254,7 +253,7 @@ pub enum PortType {
 }
 
 /// A reference to a specific port on a specific node.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PortRef {
     /// The name of the node containing this port.
     pub node_name: NodeName,
@@ -277,22 +276,16 @@ impl std::fmt::Display for PortRef {
 /// A connection between two ports in the graph.
 ///
 /// Edges connect output ports to input ports, allowing packets to flow
-/// between nodes. Currently edges have no additional properties beyond
-/// their endpoints.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+/// between nodes.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Edge {
-}
-
-/// A reference to an edge, identified by its source and target ports.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct EdgeRef {
     /// The output port where this edge originates.
     pub source: PortRef,
     /// The input port where this edge terminates.
     pub target: PortRef,
 }
 
-impl std::fmt::Display for EdgeRef {
+impl std::fmt::Display for Edge {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{} -> {}", self.source, self.target)
     }
@@ -307,7 +300,7 @@ impl std::fmt::Display for EdgeRef {
 /// # Example
 ///
 /// ```
-/// use netrun_sim::graph::{Graph, Node, Edge, EdgeRef, PortRef, PortType, Port, PortSlotSpec};
+/// use netrun_sim::graph::{Graph, Node, Edge, PortRef, PortType, Port, PortSlotSpec};
 /// use std::collections::HashMap;
 ///
 /// // Create a simple A -> B graph
@@ -326,74 +319,45 @@ impl std::fmt::Display for EdgeRef {
 ///     out_salvo_conditions: HashMap::new(),
 /// };
 ///
-/// let edge = (
-///     EdgeRef {
-///         source: PortRef { node_name: "A".to_string(), port_type: PortType::Output, port_name: "out".to_string() },
-///         target: PortRef { node_name: "B".to_string(), port_type: PortType::Input, port_name: "in".to_string() },
-///     },
-///     Edge {},
-/// );
+/// let edge = Edge {
+///     source: PortRef { node_name: "A".to_string(), port_type: PortType::Output, port_name: "out".to_string() },
+///     target: PortRef { node_name: "B".to_string(), port_type: PortType::Input, port_name: "in".to_string() },
+/// };
 ///
 /// let graph = Graph::new(vec![node_a, node_b], vec![edge]);
 /// assert!(graph.validate().is_empty());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(from = "GraphData", into = "GraphData")]
+#[derive(Debug, Clone)]
 pub struct Graph {
     nodes: HashMap<NodeName, Node>,
-    edges: HashMap<EdgeRef, Edge>,
-
-    #[serde(skip)]
-    edges_by_tail: HashMap<PortRef, EdgeRef>,
-    #[serde(skip)]
-    edges_by_head: HashMap<PortRef, EdgeRef>,
-}
-
-/// Helper struct for serializing/deserializing Graph without the indexes
-#[derive(Serialize, Deserialize)]
-struct GraphData {
-    nodes: Vec<Node>,
-    edges: Vec<(EdgeRef, Edge)>,
-}
-
-impl From<GraphData> for Graph {
-    fn from(data: GraphData) -> Self {
-        Graph::new(data.nodes, data.edges)
-    }
-}
-
-impl From<Graph> for GraphData {
-    fn from(graph: Graph) -> Self {
-        GraphData {
-            nodes: graph.nodes.into_values().collect(),
-            edges: graph.edges.into_iter().collect(),
-        }
-    }
+    edges: HashSet<Edge>,
+    edges_by_tail: HashMap<PortRef, Edge>,
+    edges_by_head: HashMap<PortRef, Edge>,
 }
 
 impl Graph {
     /// Creates a new Graph from a list of nodes and edges.
     ///
     /// Builds internal indexes for efficient edge lookups by source (tail) and target (head) ports.
-    pub fn new(nodes: Vec<Node>, edges: Vec<(EdgeRef, Edge)>) -> Self {
+    pub fn new(nodes: Vec<Node>, edges: Vec<Edge>) -> Self {
         let nodes_map: HashMap<NodeName, Node> = nodes
             .into_iter()
             .map(|node| (node.name.clone(), node))
             .collect();
 
-        let mut edges_map: HashMap<EdgeRef, Edge> = HashMap::new();
-        let mut edges_by_tail: HashMap<PortRef, EdgeRef> = HashMap::new();
-        let mut edges_by_head: HashMap<PortRef, EdgeRef> = HashMap::new();
+        let mut edges_set: HashSet<Edge> = HashSet::new();
+        let mut edges_by_tail: HashMap<PortRef, Edge> = HashMap::new();
+        let mut edges_by_head: HashMap<PortRef, Edge> = HashMap::new();
 
-        for (edge_ref, edge) in edges {
-            edges_by_tail.insert(edge_ref.source.clone(), edge_ref.clone());
-            edges_by_head.insert(edge_ref.target.clone(), edge_ref.clone());
-            edges_map.insert(edge_ref, edge);
+        for edge in edges {
+            edges_by_tail.insert(edge.source.clone(), edge.clone());
+            edges_by_head.insert(edge.target.clone(), edge.clone());
+            edges_set.insert(edge);
         }
 
         Graph {
             nodes: nodes_map,
-            edges: edges_map,
+            edges: edges_set,
             edges_by_tail,
             edges_by_head,
         }
@@ -402,16 +366,16 @@ impl Graph {
     /// Returns a reference to all nodes in the graph, keyed by name.
     pub fn nodes(&self) -> &HashMap<NodeName, Node> { &self.nodes }
 
-    /// Returns a reference to all edges in the graph, keyed by their endpoints.
-    pub fn edges(&self) -> &HashMap<EdgeRef, Edge> { &self.edges }
+    /// Returns a reference to all edges in the graph.
+    pub fn edges(&self) -> &HashSet<Edge> { &self.edges }
 
     /// Returns the edge that has the given output port as its source (tail).
-    pub fn get_edge_by_tail(&self, output_port_ref: &PortRef) -> Option<&EdgeRef> {
+    pub fn get_edge_by_tail(&self, output_port_ref: &PortRef) -> Option<&Edge> {
         self.edges_by_tail.get(output_port_ref)
     }
 
     /// Returns the edge that has the given input port as its target (head).
-    pub fn get_edge_by_head(&self, input_port_ref: &PortRef) -> Option<&EdgeRef> {
+    pub fn get_edge_by_head(&self, input_port_ref: &PortRef) -> Option<&Edge> {
         self.edges_by_head.get(input_port_ref)
     }
 
@@ -425,9 +389,9 @@ impl Graph {
         let mut seen_edges: HashSet<(&PortRef, &PortRef)> = HashSet::new();
 
         // Validate edges
-        for edge_ref in self.edges.keys() {
-            let source = &edge_ref.source;
-            let target = &edge_ref.target;
+        for edge in &self.edges {
+            let source = &edge.source;
+            let target = &edge.target;
 
             // Check for duplicate edges
             if !seen_edges.insert((source, target)) {
@@ -611,22 +575,19 @@ mod tests {
         }
     }
 
-    fn edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> (EdgeRef, Edge) {
-        (
-            EdgeRef {
-                source: PortRef {
-                    node_name: src_node.to_string(),
-                    port_type: PortType::Output,
-                    port_name: src_port.to_string(),
-                },
-                target: PortRef {
-                    node_name: tgt_node.to_string(),
-                    port_type: PortType::Input,
-                    port_name: tgt_port.to_string(),
-                },
+    fn edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> Edge {
+        Edge {
+            source: PortRef {
+                node_name: src_node.to_string(),
+                port_type: PortType::Output,
+                port_name: src_port.to_string(),
+            },
+            target: PortRef {
+                node_name: tgt_node.to_string(),
+                port_type: PortType::Input,
+                port_name: tgt_port.to_string(),
             },
-            Edge {},
-        )
+        }
     }
 
     #[test]
@@ -727,21 +688,18 @@ mod tests {
             simple_node("B", vec!["in"], vec![]),
         ];
         // Edge from input port (wrong type)
-        let edges = vec![(
-            EdgeRef {
-                source: PortRef {
-                    node_name: "A".to_string(),
-                    port_type: PortType::Input, // Wrong!
-                    port_name: "in".to_string(),
-                },
-                target: PortRef {
-                    node_name: "B".to_string(),
-                    port_type: PortType::Input,
-                    port_name: "in".to_string(),
-                },
+        let edges = vec![Edge {
+            source: PortRef {
+                node_name: "A".to_string(),
+                port_type: PortType::Input, // Wrong!
+                port_name: "in".to_string(),
             },
-            Edge {},
-        )];
+            target: PortRef {
+                node_name: "B".to_string(),
+                port_type: PortType::Input,
+                port_name: "in".to_string(),
+            },
+        }];
         let graph = Graph::new(nodes, edges);
 
         let errors = graph.validate();
@@ -755,21 +713,18 @@ mod tests {
             simple_node("B", vec!["in"], vec!["out"]),
         ];
         // Edge to output port (wrong type)
-        let edges = vec![(
-            EdgeRef {
-                source: PortRef {
-                    node_name: "A".to_string(),
-                    port_type: PortType::Output,
-                    port_name: "out".to_string(),
-                },
-                target: PortRef {
-                    node_name: "B".to_string(),
-                    port_type: PortType::Output, // Wrong!
-                    port_name: "out".to_string(),
-                },
+        let edges = vec![Edge {
+            source: PortRef {
+                node_name: "A".to_string(),
+                port_type: PortType::Output,
+                port_name: "out".to_string(),
+            },
+            target: PortRef {
+                node_name: "B".to_string(),
+                port_type: PortType::Output, // Wrong!
+                port_name: "out".to_string(),
             },
-            Edge {},
-        )];
+        }];
         let graph = Graph::new(nodes, edges);
 
         let errors = graph.validate();

{netrun_sim-0.1.0 → netrun_sim-0.1.1}/core/src/net.rs

@@ -7,7 +7,7 @@
 //! [`NetAction`] and returns a [`NetActionResponse`] containing any events that occurred.
 
 use crate::_utils::get_utc_now;
-use crate::graph::{EdgeRef, Graph, NodeName, Port, PortSlotSpec, PortName, PortType, PortRef, SalvoConditionName, SalvoConditionTerm, evaluate_salvo_condition};
+use crate::graph::{Edge, Graph, NodeName, Port, PortSlotSpec, PortName, PortType, PortRef, SalvoConditionName, SalvoConditionTerm, evaluate_salvo_condition};
 use indexmap::IndexSet;
 use std::collections::{HashMap, HashSet};
 use ulid::Ulid;
@@ -34,7 +34,7 @@ pub enum PacketLocation {
     /// Loaded into an epoch's output port, ready to be sent.
     OutputPort(EpochID, PortName),
     /// In transit on an edge between nodes.
-    Edge(EdgeRef),
+    Edge(Edge),
     /// External to the network (not yet injected or already extracted).
     OutsideNet,
 }
@@ -211,8 +211,8 @@ pub enum NetActionError {
     CannotMovePacketIntoRunningEpoch { packet_id: PacketID, epoch_id: EpochID },
 
     /// Edge does not exist in the graph
-    #[error("edge not found: {edge_ref}")]
-    EdgeNotFound { edge_ref: EdgeRef },
+    #[error("edge not found: {edge}")]
+    EdgeNotFound { edge: Edge },
 }
 
 /// An event that occurred during a network action.
@@ -292,8 +292,8 @@ impl Net {
         let mut packets_by_location: HashMap<PacketLocation, IndexSet<PacketID>> = HashMap::new();
 
         // Initialize empty packet sets for all edges
-        for edge_ref in graph.edges().keys() {
-            packets_by_location.insert(PacketLocation::Edge(edge_ref.clone()), IndexSet::new());
+        for edge in graph.edges() {
+            packets_by_location.insert(PacketLocation::Edge(edge.clone()), IndexSet::new());
         }
 
         // Initialize empty packet sets for all input ports
@@ -1051,11 +1051,11 @@ impl Net {
                     });
                 }
             }
-            PacketLocation::Edge(edge_ref) => {
+            PacketLocation::Edge(edge) => {
                 // Check edge exists in graph
-                if !self.graph.edges().contains_key(edge_ref) {
+                if !self.graph.edges().contains(edge) {
                     return NetActionResponse::Error(NetActionError::EdgeNotFound {
-                        edge_ref: edge_ref.clone(),
+                        edge: edge.clone(),
                     });
                 }
             }
@@ -1224,7 +1224,7 @@ mod tests {
         let packet_id = get_packet_id(&response);
 
         // Manually place packet on edge (simulating it came from node A)
-        let edge_location = PacketLocation::Edge(EdgeRef {
+        let edge_location = PacketLocation::Edge(Edge {
             source: PortRef {
                 node_name: "A".to_string(),
                 port_type: PortType::Output,
@@ -1341,7 +1341,7 @@ mod tests {
 
         // Create packet on edge A->B
         let packet_id = get_packet_id(&net.do_action(&NetAction::CreatePacket(None)));
-        let edge_location = PacketLocation::Edge(EdgeRef {
+        let edge_location = PacketLocation::Edge(Edge {
             source: PortRef {
                 node_name: "A".to_string(),
                 port_type: PortType::Output,
@@ -1391,7 +1391,7 @@ mod tests {
         let mut net = Net::new(graph);
 
         // Create two packets on edge A->B
-        let edge_location = PacketLocation::Edge(EdgeRef {
+        let edge_location = PacketLocation::Edge(Edge {
             source: PortRef {
                 node_name: "A".to_string(),
                 port_type: PortType::Output,
@@ -1431,7 +1431,7 @@ mod tests {
         let graph = linear_graph_3();
         let mut net = Net::new(graph);
 
-        let edge_location = PacketLocation::Edge(EdgeRef {
+        let edge_location = PacketLocation::Edge(Edge {
             source: PortRef {
                 node_name: "A".to_string(),
                 port_type: PortType::Output,
@@ -1541,7 +1541,7 @@ mod tests {
         assert!(matches!(response, NetActionResponse::Success(NetActionResponseData::None, _)));
 
         // Packet should now be on edge B->C
-        let edge_loc = PacketLocation::Edge(EdgeRef {
+        let edge_loc = PacketLocation::Edge(Edge {
             source: PortRef {
                 node_name: "B".to_string(),
                 port_type: PortType::Output,