Channel closing before all items are processed by other goroutines

Is defer closing the initial data channel causing this code to end early?

The output is

adding function
adding function
generate a
generate b
running a
running b
generate c <- last item generated so defer close closes this channel
running a  
running b 
running c <- why is 'c' is only run once ?
received data a <- why only received 'a' ? ... didn't receive 'b' or 'c'
done

In the code snippet there is an initial "data" channel that takes in string and passing them to other functions but not all of the items sent into the "data" channel are processed by the two function calls. Closing the "data" channel shouldn't cause any items still in the channel to not be read?

https://go.dev/play/p/2TRUpBlWONd

package main
import (
"fmt"
)
func run(data chan string, fn func(x string) (string, error)) (chan string, chan error) {
outCh := make(chan string)
errCh := make(chan error)
go func() {
defer close(outCh)
for d := range data {
fmt.Println("running", d)
out, err := fn(d)
if err != nil {
errCh <- err
continue
}
outCh <- out
}
}()
return outCh, errCh
}
func generate(data chan string) {
// Close the data channel to signal other goroutines that
// we are done sending data into the channel.
defer close(data)
for _, x := range []string{"a", "b", "c"} {
fmt.Println("generate", x)
data <- x
}
}
func main() {
// Number of functions to run
N := 2
// Channel to stream data into the functions
data := make(chan string)
// Channel to catch errors from the functions
errCh := make(chan error)
// Create a slice of functions that take a string and
// return a string value and an error value.
functions := []func(x string) (string, error){}
// Generate the data to stream into the data channel.
// This data feeds the functions.
go generate(data)
// Generate N number of functions to process stuff from the data channel.
for i := 0; i < N; i++ {
fmt.Println("adding function")
functions = append(functions, func(x string) (string, error) {
return fmt.Sprintf(x), nil
})
}
// run each of the functions on the items in the data channel
// and return the data or an error
for i := 0; i < N; i++ {
data, errCh = run(data, functions[i])
}
select {
case x := <-data:
fmt.Println("received data", x)
case err := <-errCh:
fmt.Println("received error", err)
}
fmt.Println("done")
}

In the last step, you are receiving only one message from the channel. You need to put that into a loop until the channel is closed:

for {
select {
case x,ok := <-data:
if !ok {
return // Done
}
fmt.Println("received data", x)
case err := <-errCh:
fmt.Println("received error", err)
}
}