// We only merge if the found service is in the same namespace as the one we're trying to add
		copied := foundSvc.svc.DeepCopy()
		for _, p := range s.Ports {
			found := false
			for _, osp := range copied.Ports {
				if p.Port == osp.Port {
					found = true
					break
				}
			}
			if !found {
				copied.Ports = append(copied.Ports, p)
			}
		}

		} else if tt, found := gatewayClass.Labels[constants.AmbientWaypointForTrafficTypeLabel]; found {
			// Check for a declared traffic type that is allowed to pass through the Waypoint's GatewayClass
			trafficType = tt
		}

		// Check for a declared traffic type that is allowed to pass through the Waypoint
		if tt, found := gateway.Labels[constants.AmbientWaypointForTrafficTypeLabel]; found {

		if vo := xdstest.ExtractListener(model.VirtualOutboundListenerName, listeners); vo == nil {
			t.Fatalf("expect virtual listener, found %s", listeners[0].Name)
		}
		vi := xdstest.ExtractListener(model.VirtualInboundListenerName, listeners)
		if vi == nil {
			t.Fatalf("expect virtual inbound listener, found %s", listeners[0].Name)
		}

		byListenerName := map[string]int{}

		for _, fc := range vi.FilterChains {

	containers := p.Spec.InitContainers
	statuses := []v1.ContainerStatus{}
	for _, container := range containers {
		if status, found := statusMap[container.Name]; found {
			statuses = append(statuses, *status)
		}
	}
	return statuses
}

// Reservation represents reserved resources for non-pod components.
type Reservation struct {

// On MacOS only, also looks for gobjdump with least preference.
// Accepts a list of paths and returns:
// a string with path to the preferred objdump binary if found,
// or an empty string if not found;
// a boolean if any acceptable objdump was found;
// a boolean indicating if it is an LLVM objdump.
func findObjdump(paths []string) (string, bool, bool) {
	objdumpNames := []string{"llvm-objdump", "objdump"}

						listeners := buildListeners(t, proxy, port)
						found := hasListenerOrFilterChainForPort(listeners, port)
						if tc.expectListener {
							if !found {
								t.Fatalf("expected listener on port %d, but not found", port)
							}
						} else {
							if found {
								t.Fatalf("expected no listener on port %d, but found found one", port)
							}
						}
					}
				})
			}

		s.queue.Add(o)
	}))

	return s
}

// GetPodIfAmbient looks up a pod. It returns:
// * An error if the pod cannot be found
// * nil if the pod is found, but does not have ambient enabled
// * the pod, if it is found and ambient is enabled
func (s *InformerHandlers) GetPodIfAmbient(podName, podNamespace string) (*corev1.Pod, error) {
	ns := s.namespaces.Get(podNamespace, "")
	if ns == nil {

	}

	return listeners
}

// inboundVirtualListener builds the virtual inbound listener.
func (lb *ListenerBuilder) inboundVirtualListener(chains []*listener.FilterChain) *listener.Listener {
	actualWildcards, _ := getWildcardsAndLocalHost(lb.node.GetIPMode())

	// Build the "virtual" inbound listener. This will capture all inbound redirected traffic and contains:

	if !slices.Contains(signedHeaders, "host") {
		return nil, ErrUnsignedHeaders
	}
	extractedSignedHeaders := make(http.Header)
	for _, header := range signedHeaders {
		// `host` will not be found in the headers, can be found in r.Host.
		// but its always necessary that the list of signed headers containing host in it.
		val, ok := reqHeaders[http.CanonicalHeaderKey(header)]
		if !ok {
			// try to set headers from Query String

			clusters: map[string][]string{
				"inbound|8080||": nil,
				"inbound|8081||": nil,
				"inbound|8082||": nil,
				"inbound|8083||": nil,
			},
			telemetry: map[string][]string{
				"inbound|8080||": {string(service.Hostname)},
				"inbound|8081||": {string(service.Hostname)},
				"inbound|8082||": {string(serviceAlt.Hostname)},
				"inbound|8083||": {string(serviceAlt.Hostname)},
			},
		},
		{