Merge pull request #11 from jwetzell/feat/raw-framing-default

use RAW framer if no framer specified

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+# These are supported funding model platforms
+github: [jwetzell]

.github/labeler.yml

@@ -0,0 +1,23 @@
+config:
+  - changed-files:
+      - any-glob-to-any-file: 'internal/config/**'
+
+framer:
+  - changed-files:
+      - any-glob-to-any-file: 'internal/framer/**'
+
+module:
+  - changed-files:
+      - any-glob-to-any-file: 'internal/module/**'
+
+processor:
+  - changed-files:
+      - any-glob-to-any-file: 'internal/processor/**'
+
+route:
+  - changed-files:
+      - any-glob-to-any-file: 'internal/route/**'
+
+cli:
+  - changed-files:
+      - any-glob-to-any-file: 'cmd/showbridge/**'

.github/release.yml

@@ -0,0 +1,28 @@
+changelog:
+  exclude:
+    authors:
+      - dependabot
+    labels:
+      - dependencies
+  categories:
+    - title: Config ⚙️
+      labels:
+        - config
+    - title: Framer 🖼️
+      labels:
+        - framer
+    - title: Module 📦
+      labels:
+        - module
+    - title: Processor 🏭
+      labels:
+        - processor
+    - title: Route 🛣️
+      labels:
+        - route
+    - title: CLI ⌨️
+      labels:
+        - cmd
+    - title: Other Changes
+      labels:
+        - '*'

.github/workflows/label-pr.yaml

@@ -0,0 +1,18 @@
+# Taken from https://github.com/go-gitea/gitea
+name: Add labels to PR
+on:
+  pull_request_target:
+    types: [opened, synchronize, reopened]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+jobs:
+  labeler:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/labeler@634933edcd8ababfe52f92936142cc22ac488b1b # v6.0.1
+        with:
+          sync-labels: true

.github/workflows/release-showbridge.yaml

@@ -17,7 +17,7 @@ jobs:
         with:
           fetch-depth: 0
       - name: setup go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version-file: 'go.mod'
       - name: release

README.md

@@ -0,0 +1,29 @@
+<div align="center">
+
+  # showbridge (go edition)
+
+Simple protocol router _/s_
+
+</div>
+
+### Supported Protocols
+- HTTP
+  - client
+  - server
+- UDP
+  - client
+  - server
+- TCP
+  - client
+  - server
+- [MQTT](https://mqtt.org/)
+  - client
+- [NATS](https://nats.io/)
+  - client
+- [PosiStageNet](https://posistage.net/)
+  - client
+- MIDI
+  - client (not included in pre-built binaries yet)
+
+  
+  

cmd/showbridge/.goreleaser.yaml

@@ -24,6 +24,7 @@ archives:
 
 changelog:
   sort: asc
+  use: github-native
 
 release:
   draft: true

cmd/showbridge/main.go

@@ -8,6 +8,7 @@ import (
 	"os/signal"
 
 	"github.com/jwetzell/showbridge-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 	"github.com/urfave/cli/v3"
 	"sigs.k8s.io/yaml"
 )
@@ -54,19 +55,19 @@ func main() {
 
 }
 
-func readConfig(configPath string) (showbridge.Config, error) {
+func readConfig(configPath string) (config.Config, error) {
+	cfg := config.Config{}
+
 	configBytes, err := os.ReadFile(configPath)
 
 	if err != nil {
-		return showbridge.Config{}, err
+		return config.Config{}, err
 	}
 
-	config := showbridge.Config{}
-
-	err = yaml.Unmarshal(configBytes, &config)
+	err = yaml.Unmarshal(configBytes, &cfg)
 	if err != nil {
-		return showbridge.Config{}, err
+		return config.Config{}, err
 	}
 
-	return config, nil
+	return cfg, nil
 }

config.go

@@ -1,6 +0,0 @@
-package showbridge
-
-type Config struct {
-	Modules []ModuleConfig `json:"modules"`
-	Routes  []RouteConfig  `json:"routes"`
-}

go.mod

@@ -7,21 +7,28 @@ require (
 	github.com/expr-lang/expr v1.17.6
 	github.com/jwetzell/free-d-go v0.1.0
 	github.com/jwetzell/osc-go v0.1.0
-	github.com/jwetzell/psn-go v0.2.1
+	github.com/jwetzell/psn-go v0.3.0
+	github.com/nats-io/nats.go v1.47.0
 	github.com/urfave/cli/v3 v3.6.1
 	gitlab.com/gomidi/midi/v2 v2.3.16
+	go.bug.st/serial v1.6.4
 	modernc.org/quickjs v0.17.0
 	sigs.k8s.io/yaml v1.6.0
 )
 
 require (
+	github.com/creack/goselect v0.1.2 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/nats-io/nkeys v0.4.11 // indirect
+	github.com/nats-io/nuid v1.0.1 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
+	golang.org/x/crypto v0.42.0 // indirect
 	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect
 	golang.org/x/net v0.44.0 // indirect
 	golang.org/x/sync v0.17.0 // indirect

go.sum

@@ -1,3 +1,5 @@
+github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
+github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
@@ -18,10 +20,18 @@ github.com/jwetzell/free-d-go v0.1.0 h1:xHt6dvyit98X+OC3jVzV0aLidxbyzi3vI9QiYkte
 github.com/jwetzell/free-d-go v0.1.0/go.mod h1:KmrkooRARRaxJTBSPvwt/6IMAIaHH1R8bSA8cwbbELw=
 github.com/jwetzell/osc-go v0.1.0 h1:EXxup5VWBErHot2Ri4MFToPf6KCzLDTbCt2x6GLfw8I=
 github.com/jwetzell/osc-go v0.1.0/go.mod h1:xLz0jTwebSxtx1TkKN1YVdeRqvpFNweDhTut5TE393A=
-github.com/jwetzell/psn-go v0.2.1 h1:pNG6XNfVRTb4qctH6pJjRJ1ReYGnGgNRA4H7tNbmzRU=
-github.com/jwetzell/psn-go v0.2.1/go.mod h1:bcEAeti4sQM375buujb3mIfmUstD4Aby18gq3ENb6+o=
+github.com/jwetzell/psn-go v0.3.0 h1:WVpCEmExYE8a+I5hQak5jNJJp2x35VdGX/VuMUKPmhY=
+github.com/jwetzell/psn-go v0.3.0/go.mod h1:bcEAeti4sQM375buujb3mIfmUstD4Aby18gq3ENb6+o=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/nats-io/nats.go v1.47.0 h1:YQdADw6J/UfGUd2Oy6tn4Hq6YHxCaJrVKayxxFqYrgM=
+github.com/nats-io/nats.go v1.47.0/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g=
+github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0=
+github.com/nats-io/nkeys v0.4.11/go.mod h1:szDimtgmfOi9n25JpfIdGw12tZFYXqhGxjhVxsatHVE=
+github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -34,10 +44,14 @@ github.com/urfave/cli/v3 v3.6.1 h1:j8Qq8NyUawj/7rTYdBGrxcH7A/j7/G8Q5LhWEW4G3Mo=
 github.com/urfave/cli/v3 v3.6.1/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
 gitlab.com/gomidi/midi/v2 v2.3.16 h1:yufWSENyjnJ4LFQa9BerzUm4E4aLfTyzw5nmnCteO0c=
 gitlab.com/gomidi/midi/v2 v2.3.16/go.mod h1:jDpP4O4skYi+7iVwt6Zyp18bd2M4hkjtMuw2cmgKgfw=
+go.bug.st/serial v1.6.4 h1:7FmqNPgVp3pu2Jz5PoPtbZ9jJO5gnEnZIvnI1lzve8A=
+go.bug.st/serial v1.6.4/go.mod h1:nofMJxTeNVny/m6+KaafC6vJGj3miwQZ6vW4BZUGJPI=
 go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
 go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
 go.yaml.in/yaml/v3 v3.0.3 h1:bXOww4E/J3f66rav3pX3m8w6jDE4knZjGOw8b5Y6iNE=
 go.yaml.in/yaml/v3 v3.0.3/go.mod h1:tBHosrYAkRZjRAOREWbDnBXUf08JOwYq++0QNwQiWzI=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
 golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
 golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
 golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=

internal/config/config.go

@@ -0,0 +1,23 @@
+package config
+
+type Config struct {
+	Modules []ModuleConfig `json:"modules"`
+	Routes  []RouteConfig  `json:"routes"`
+}
+
+type ModuleConfig struct {
+	Id     string         `json:"id"`
+	Type   string         `json:"type"`
+	Params map[string]any `json:"params"`
+}
+
+type RouteConfig struct {
+	Input      string            `json:"input"`
+	Processors []ProcessorConfig `json:"processors"`
+	Output     string            `json:"output"`
+}
+
+type ProcessorConfig struct {
+	Type   string         `json:"type"`
+	Params map[string]any `json:"params"`
+}

internal/framer/framer.go

@@ -0,0 +1,29 @@
+package framer
+
+import (
+	"fmt"
+)
+
+type Framer interface {
+	Decode([]byte) [][]byte
+	Encode([]byte) []byte
+	Clear()
+	Buffer() []byte
+}
+
+func GetFramer(framingType string) (Framer, error) {
+	switch framingType {
+	case "CR":
+		return NewByteSeparatorFramer([]byte{'\r'}), nil
+	case "LF":
+		return NewByteSeparatorFramer([]byte{'\n'}), nil
+	case "CRLF":
+		return NewByteSeparatorFramer([]byte{'\r', '\n'}), nil
+	case "SLIP":
+		return NewSlipFramer(), nil
+	case "RAW":
+		return NewRawFramer(), nil
+	default:
+		return nil, fmt.Errorf("unknown framing method: %s", framingType)
+	}
+}

internal/framer/raw.go

@@ -0,0 +1,23 @@
+package framer
+
+type RawFramer struct{}
+
+func NewRawFramer() *RawFramer {
+	return &RawFramer{}
+}
+
+func (rf *RawFramer) Decode(data []byte) [][]byte {
+	return [][]byte{data}
+}
+
+func (rf *RawFramer) Encode(data []byte) []byte {
+	return data
+}
+
+func (rf *RawFramer) Clear() {
+	// NOTE(jwetzell): no internal state to clear
+}
+
+func (rf *RawFramer) Buffer() []byte {
+	return []byte{}
+}

internal/framer/separator.go

@@ -1,4 +1,4 @@
-package framing
+package framer
 
 import (
 	"bytes"
@@ -35,3 +35,7 @@ func (bsf *ByteSeparatorFramer) Encode(data []byte) []byte {
 func (bsf *ByteSeparatorFramer) Clear() {
 	bsf.buffer = []byte{}
 }
+
+func (bsf *ByteSeparatorFramer) Buffer() []byte {
+	return bsf.buffer
+}

internal/framer/separator_test.go

@@ -0,0 +1,69 @@
+package framer_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/framer"
+)
+
+func TestGoodSeparatorFramer(t *testing.T) {
+	tests := []struct {
+		name     string
+		framer   framer.Framer
+		input    []byte
+		expected [][]byte
+		buffer   []byte
+	}{
+		{
+			name:   "new line separator",
+			framer: framer.NewByteSeparatorFramer([]byte{0x0a}),
+			input:  []byte("Hello\nWorld\nThis is a test\n"),
+			expected: [][]byte{
+				[]byte("Hello"),
+				[]byte("World"),
+				[]byte("This is a test"),
+			},
+			buffer: []byte{},
+		},
+		{
+			name:   "CRLF separator",
+			framer: framer.NewByteSeparatorFramer([]byte{0x0d, 0x0a}),
+			input:  []byte("Hello\r\nWorld\r\nThis is a test\r\n"),
+			expected: [][]byte{
+				[]byte("Hello"),
+				[]byte("World"),
+				[]byte("This is a test"),
+			},
+			buffer: []byte{},
+		},
+		{
+			name:   "extra data after separator",
+			framer: framer.NewByteSeparatorFramer([]byte{0x0d, 0x0a}),
+			input:  []byte("Hello\r\nWorld\r\nThis is a test\r\nextra"),
+			expected: [][]byte{
+				[]byte("Hello"),
+				[]byte("World"),
+				[]byte("This is a test"),
+			},
+			buffer: []byte("extra"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			frames := test.framer.Decode(test.input)
+			if len(frames) != len(test.expected) {
+				t.Errorf("separator framer got %d frames, expected %d", len(frames), len(test.expected))
+			}
+			for i, frame := range frames {
+				if !slices.Equal(frame, test.expected[i]) {
+					t.Errorf("separator framer frame %d got %s, expected %s", i, frame, test.expected[i])
+				}
+			}
+			if !slices.Equal(test.framer.Buffer(), test.buffer) {
+				t.Errorf("separator framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
+			}
+		})
+	}
+}

internal/framer/slip.go

@@ -1,4 +1,4 @@
-package framing
+package framer
 
 type SlipFramer struct {
 	buffer []byte
@@ -74,3 +74,7 @@ func (sf *SlipFramer) Encode(data []byte) []byte {
 func (sf *SlipFramer) Clear() {
 	sf.buffer = []byte{}
 }
+
+func (sf *SlipFramer) Buffer() []byte {
+	return sf.buffer
+}

internal/framer/slip_test.go

@@ -0,0 +1,45 @@
+package framer_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/framer"
+)
+
+func TestGoodSLIPFramer(t *testing.T) {
+	tests := []struct {
+		name     string
+		framer   framer.Framer
+		input    []byte
+		expected [][]byte
+		buffer   []byte
+	}{
+		{
+			name:   "OSC SLIP messages",
+			framer: framer.NewSlipFramer(),
+			input:  []byte{0xc0, 0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0xc0},
+			expected: [][]byte{
+				{0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00},
+			},
+			buffer: []byte{},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			frames := test.framer.Decode(test.input)
+			if len(frames) != len(test.expected) {
+				t.Errorf("SLIP framer got %d frames, expected %d", len(frames), len(test.expected))
+			}
+			for i, frame := range frames {
+				if !slices.Equal(frame, test.expected[i]) {
+					t.Errorf("SLIP framer frame %d got %s, expected %s", i, frame, test.expected[i])
+				}
+			}
+			if !slices.Equal(test.framer.Buffer(), test.buffer) {
+				t.Errorf("SLIP framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
+			}
+		})
+	}
+}

internal/framing/framer.go

@@ -1,7 +0,0 @@
-package framing
-
-type Framer interface {
-	Decode([]byte) [][]byte
-	Encode([]byte) []byte
-	Clear()
-}

internal/module/http-client.go

@@ -1,24 +1,29 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 	"net/http"
 	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type HTTPClient struct {
-	config ModuleConfig
-	router *Router
+	config config.ModuleConfig
+	ctx    context.Context
 	client *http.Client
+	router route.RouteIO
 }
 
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.http.client",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 
-			return &HTTPClient{config: config}, nil
+			return &HTTPClient{config: config, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -31,17 +36,13 @@ func (hc *HTTPClient) Type() string {
 	return hc.config.Type
 }
 
-func (hc *HTTPClient) RegisterRouter(router *Router) {
-	hc.router = router
-}
-
 func (hc *HTTPClient) Run() error {
 
 	hc.client = &http.Client{
 		Timeout: 10 * time.Second,
 	}
 
-	<-hc.router.Context.Done()
+	<-hc.ctx.Done()
 	slog.Debug("router context done in module", "id", hc.config.Id)
 	return nil
 }

internal/module/http-server.go

@@ -1,16 +1,21 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"log/slog"
 	"net/http"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type HTTPServer struct {
-	config ModuleConfig
+	config config.ModuleConfig
 	Port   uint16
-	router *Router
+	ctx    context.Context
+	router route.RouteIO
 }
 
 type ResponseData struct {
@@ -21,7 +26,7 @@ type ResponseData struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.http.server",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 			port, ok := params["port"]
 			if !ok {
@@ -34,7 +39,7 @@ func init() {
 				return nil, fmt.Errorf("net.http.server port must be uint16")
 			}
 
-			return &HTTPServer{Port: uint16(portNum), config: config}, nil
+			return &HTTPServer{Port: uint16(portNum), config: config, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -47,10 +52,6 @@ func (hs *HTTPServer) Type() string {
 	return hs.config.Type
 }
 
-func (hs *HTTPServer) RegisterRouter(router *Router) {
-	hs.router = router
-}
-
 func (hs *HTTPServer) HandleDefault(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
@@ -87,18 +88,19 @@ func (hs *HTTPServer) Run() error {
 	}
 
 	go func() {
-		<-hs.router.Context.Done()
+		<-hs.ctx.Done()
 		slog.Debug("router context done in module", "id", hs.config.Id)
 		httpServer.Close()
 	}()
 
 	err := httpServer.ListenAndServe()
 	slog.Debug("net.http.server closed", "id", hs.config.Id)
+	// TODO(jwetzell): handle server closed error differently
 	if err != nil {
 		return err
 	}
 
-	<-hs.router.Context.Done()
+	<-hs.ctx.Done()
 	return nil
 }
 

internal/module/interval.go

@@ -1,36 +1,41 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type Interval struct {
-	config   ModuleConfig
+	config   config.ModuleConfig
 	Duration uint32
-	router   *Router
+	ctx      context.Context
+	router   route.RouteIO
 	ticker   *time.Ticker
 }
 
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "gen.interval",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 
 			duration, ok := params["duration"]
 			if !ok {
-				return nil, fmt.Errorf("interval requires a duration parameter")
+				return nil, fmt.Errorf("gen.interval requires a duration parameter")
 			}
 
 			durationNum, ok := duration.(float64)
 
 			if !ok {
-				return nil, fmt.Errorf("interval duration must be number")
+				return nil, fmt.Errorf("gen.interval duration must be number")
 			}
 
-			return &Interval{Duration: uint32(durationNum), config: config}, nil
+			return &Interval{Duration: uint32(durationNum), config: config, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -43,22 +48,19 @@ func (i *Interval) Type() string {
 	return i.config.Type
 }
 
-func (i *Interval) RegisterRouter(router *Router) {
-	i.router = router
-}
-
 func (i *Interval) Run() error {
 	ticker := time.NewTicker(time.Millisecond * time.Duration(i.Duration))
 	i.ticker = ticker
 	defer ticker.Stop()
+
 	for {
 		select {
-		case <-i.router.Context.Done():
+		case <-i.ctx.Done():
 			slog.Debug("router context done in module", "id", i.config.Id)
 			return nil
-		case t := <-ticker.C:
+		case <-ticker.C:
 			if i.router != nil {
-				i.router.HandleInput(i.config.Id, t)
+				i.router.HandleInput(i.config.Id, time.Now())
 			}
 		}
 	}

internal/module/midi-client.go

@@ -1,18 +1,22 @@
 //go:build cgo
 
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 	"gitlab.com/gomidi/midi/v2"
 	_ "gitlab.com/gomidi/midi/v2/drivers/rtmididrv"
 )
 
 type MIDIClient struct {
-	config     ModuleConfig
-	router     *Router
+	config     config.ModuleConfig
+	ctx        context.Context
+	router     route.RouteIO
 	InputPort  string
 	OutputPort string
 	SendFunc   func(midi.Message) error
@@ -22,12 +26,12 @@ func init() {
 	RegisterModule(ModuleRegistration{
 		//TODO(jwetzell): find a better namespace than "misc"
 		Type: "misc.midi.client",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 			input, ok := params["input"]
 
 			if !ok {
-				return nil, fmt.Errorf("net.mqtt.client requires a input parameter")
+				return nil, fmt.Errorf("misc.midi.client requires a input parameter")
 			}
 
 			inputString, ok := input.(string)
@@ -39,7 +43,7 @@ func init() {
 			output, ok := params["output"]
 
 			if !ok {
-				return nil, fmt.Errorf("net.mqtt.client requires a output parameter")
+				return nil, fmt.Errorf("misc.midi.client requires a output parameter")
 			}
 
 			outputString, ok := output.(string)
@@ -48,7 +52,7 @@ func init() {
 				return nil, fmt.Errorf("misc.midi.client output must be a string")
 			}
 
-			return &MIDIClient{config: config, InputPort: inputString, OutputPort: outputString}, nil
+			return &MIDIClient{config: config, InputPort: inputString, OutputPort: outputString, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -61,10 +65,6 @@ func (mc *MIDIClient) Type() string {
 	return mc.config.Type
 }
 
-func (mc *MIDIClient) RegisterRouter(router *Router) {
-	mc.router = router
-}
-
 func (mc *MIDIClient) Run() error {
 	defer midi.CloseDriver()
 
@@ -98,7 +98,7 @@ func (mc *MIDIClient) Run() error {
 
 	mc.SendFunc = send
 
-	<-mc.router.Context.Done()
+	<-mc.ctx.Done()
 	slog.Debug("router context done in module", "id", mc.config.Id)
 	return nil
 }

internal/module/module.go

@@ -1,33 +1,30 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"sync"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type ModuleError struct {
 	Index  int
-	Config ModuleConfig
+	Config config.ModuleConfig
 	Error  error
 }
 
 type Module interface {
 	Id() string
 	Type() string
-	RegisterRouter(*Router)
 	Run() error
 	Output(any) error
 }
 
-type ModuleConfig struct {
-	Id     string         `json:"id"`
-	Type   string         `json:"type"`
-	Params map[string]any `json:"params"`
-}
-
 type ModuleRegistration struct {
 	Type string `json:"type"`
-	New  func(ModuleConfig) (Module, error)
+	New  func(context.Context, config.ModuleConfig, route.RouteIO) (Module, error)
 }
 
 func RegisterModule(mod ModuleRegistration) {
@@ -42,13 +39,13 @@ func RegisterModule(mod ModuleRegistration) {
 	moduleRegistryMu.Lock()
 	defer moduleRegistryMu.Unlock()
 
-	if _, ok := moduleRegistry[string(mod.Type)]; ok {
+	if _, ok := ModuleRegistry[string(mod.Type)]; ok {
 		panic(fmt.Sprintf("module already registered: %s", mod.Type))
 	}
-	moduleRegistry[string(mod.Type)] = mod
+	ModuleRegistry[string(mod.Type)] = mod
 }
 
 var (
 	moduleRegistryMu sync.RWMutex
-	moduleRegistry   = make(map[string]ModuleRegistration)
+	ModuleRegistry   = make(map[string]ModuleRegistration)
 )

internal/module/mqtt-client.go

@@ -1,16 +1,20 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 
 	mqtt "github.com/eclipse/paho.mqtt.golang"
-	"github.com/jwetzell/showbridge-go/internal/processing"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/processor"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type MQTTClient struct {
-	config   ModuleConfig
-	router   *Router
+	config   config.ModuleConfig
+	ctx      context.Context
+	router   route.RouteIO
 	Broker   string
 	ClientID string
 	Topic    string
@@ -20,7 +24,7 @@ type MQTTClient struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.mqtt.client",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 			broker, ok := params["broker"]
 
@@ -31,7 +35,7 @@ func init() {
 			brokerString, ok := broker.(string)
 
 			if !ok {
-				return nil, fmt.Errorf("net.mqtt.client host must be string")
+				return nil, fmt.Errorf("net.mqtt.client broker must be string")
 			}
 
 			topic, ok := params["topic"]
@@ -43,7 +47,7 @@ func init() {
 			topicString, ok := topic.(string)
 
 			if !ok {
-				return nil, fmt.Errorf("net.mqtt.client host must be string")
+				return nil, fmt.Errorf("net.mqtt.client topic must be string")
 			}
 
 			clientId, ok := params["clientId"]
@@ -55,10 +59,10 @@ func init() {
 			clientIdString, ok := clientId.(string)
 
 			if !ok {
-				return nil, fmt.Errorf("net.mqtt.client host must be string")
+				return nil, fmt.Errorf("net.mqtt.client clientId must be string")
 			}
 
-			return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString}, nil
+			return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -71,10 +75,6 @@ func (mc *MQTTClient) Type() string {
 	return mc.config.Type
 }
 
-func (mc *MQTTClient) RegisterRouter(router *Router) {
-	mc.router = router
-}
-
 func (mc *MQTTClient) Run() error {
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(mc.Broker)
@@ -99,16 +99,16 @@ func (mc *MQTTClient) Run() error {
 		return err
 	}
 
-	<-mc.router.Context.Done()
+	<-mc.ctx.Done()
 	slog.Debug("router context done in module", "id", mc.config.Id)
 	return nil
 }
 
 func (mc *MQTTClient) Output(payload any) error {
-	payloadMessage, ok := payload.(processing.MQTTMessage)
+	payloadMessage, ok := payload.(processor.MQTTMessage)
 
 	if !ok {
-		return fmt.Errorf("net.mqtt.client is only able to output MQTTMessage")
+		return fmt.Errorf("net.mqtt.client is only able to output a MQTTMessage")
 	}
 
 	if mc.client == nil {

internal/module/nats-client.go

@@ -0,0 +1,113 @@
+package module
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/processor"
+	"github.com/jwetzell/showbridge-go/internal/route"
+	"github.com/nats-io/nats.go"
+)
+
+type NATSClient struct {
+	config  config.ModuleConfig
+	ctx     context.Context
+	router  route.RouteIO
+	URL     string
+	Subject string
+	client  *nats.Conn
+}
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type: "net.nats.client",
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
+			params := config.Params
+			url, ok := params["url"]
+
+			if !ok {
+				return nil, fmt.Errorf("net.nats.client requires a url parameter")
+			}
+
+			urlString, ok := url.(string)
+
+			if !ok {
+				return nil, fmt.Errorf("net.nats.client url must be string")
+			}
+
+			subject, ok := params["subject"]
+
+			if !ok {
+				return nil, fmt.Errorf("net.nats.client requires a subject parameter")
+			}
+
+			subjectString, ok := subject.(string)
+
+			if !ok {
+				return nil, fmt.Errorf("net.nats.client subject must be string")
+			}
+
+			return &NATSClient{config: config, URL: urlString, Subject: subjectString, ctx: ctx, router: router}, nil
+		},
+	})
+}
+
+func (nc *NATSClient) Id() string {
+	return nc.config.Id
+}
+
+func (nc *NATSClient) Type() string {
+	return nc.config.Type
+}
+
+func (nc *NATSClient) Run() error {
+	client, err := nats.Connect(nc.URL, nats.RetryOnFailedConnect(true))
+
+	if err != nil {
+		return err
+	}
+
+	nc.client = client
+
+	defer client.Drain()
+	defer client.Close()
+
+	sub, err := nc.client.Subscribe(nc.Subject, func(msg *nats.Msg) {
+		if nc.router != nil {
+			nc.router.HandleInput(nc.config.Id, msg)
+		}
+	})
+
+	if err != nil {
+		return err
+	}
+
+	defer sub.Unsubscribe()
+
+	<-nc.ctx.Done()
+	slog.Debug("router context done in module", "id", nc.config.Id)
+	return nil
+}
+
+func (nc *NATSClient) Output(payload any) error {
+
+	payloadMessage, ok := payload.(processor.NATSMessage)
+
+	if !ok {
+		return fmt.Errorf("net.nats.client is only able to output NATSMessage")
+	}
+
+	if nc.client == nil {
+		return fmt.Errorf("net.nats.client client is not setup")
+	}
+
+	if !nc.client.IsConnected() {
+		return fmt.Errorf("net.nats.client is not connected")
+	}
+
+	err := nc.client.Publish(payloadMessage.Subject, payloadMessage.Payload)
+
+	return err
+}

internal/module/psn-client.go

@@ -1,27 +1,31 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 	"net"
 	"time"
 
 	"github.com/jwetzell/psn-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type PSNClient struct {
-	config  ModuleConfig
+	config  config.ModuleConfig
 	conn    *net.UDPConn
-	router  *Router
+	ctx     context.Context
+	router  route.RouteIO
 	decoder *psn.Decoder
 }
 
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.psn.client",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 
-			return &PSNClient{config: config, decoder: psn.NewDecoder()}, nil
+			return &PSNClient{config: config, decoder: psn.NewDecoder(), ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -34,10 +38,6 @@ func (pc *PSNClient) Type() string {
 	return pc.config.Type
 }
 
-func (pc *PSNClient) RegisterRouter(router *Router) {
-	pc.router = router
-}
-
 func (pc *PSNClient) Run() error {
 
 	addr, err := net.ResolveUDPAddr("udp", "236.10.10.10:56565")
@@ -56,7 +56,7 @@ func (pc *PSNClient) Run() error {
 	buffer := make([]byte, 2048)
 	for {
 		select {
-		case <-pc.router.Context.Done():
+		case <-pc.ctx.Done():
 			// TODO(jwetzell): cleanup?
 			slog.Debug("router context done in module", "id", pc.config.Id)
 			return nil

internal/module/serial-client.go

@@ -0,0 +1,174 @@
+//go:build cgo
+
+package module
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/framer"
+	"github.com/jwetzell/showbridge-go/internal/route"
+	"go.bug.st/serial"
+)
+
+type SerialClient struct {
+	config config.ModuleConfig
+	ctx    context.Context
+	router route.RouteIO
+	Port   string
+	Framer framer.Framer
+	Mode   *serial.Mode
+	port   serial.Port
+}
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		//TODO(jwetzell): find a better namespace than "misc"
+		Type: "misc.serial.client",
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
+			params := config.Params
+			port, ok := params["port"]
+
+			if !ok {
+				return nil, fmt.Errorf("misc.serial.client requires a port parameter")
+			}
+
+			portString, ok := port.(string)
+
+			if !ok {
+				return nil, fmt.Errorf("misc.serial.client port must be a string")
+			}
+
+			framingMethod := "RAW"
+
+			framingMethodRaw, ok := params["framing"]
+
+			if ok {
+				framingMethodString, ok := framingMethodRaw.(string)
+
+				if !ok {
+					return nil, fmt.Errorf("misc.serial.client framing method must be a string")
+				}
+				framingMethod = framingMethodString
+			}
+
+			framer, err := framer.GetFramer(framingMethod)
+
+			if err != nil {
+				return nil, err
+			}
+
+			buadRate, ok := params["baudRate"]
+			if !ok {
+				return nil, fmt.Errorf("misc.serial.client requires a baudRate parameter")
+			}
+
+			baudRateNum, ok := buadRate.(float64)
+			if !ok {
+				return nil, fmt.Errorf("misc.serial.client baudRate must be a number")
+			}
+
+			mode := serial.Mode{
+				BaudRate: int(baudRateNum),
+			}
+
+			return &SerialClient{config: config, Port: portString, Framer: framer, Mode: &mode, ctx: ctx, router: router}, nil
+		},
+	})
+}
+
+func (mc *SerialClient) Id() string {
+	return mc.config.Id
+}
+
+func (mc *SerialClient) Type() string {
+	return mc.config.Type
+}
+
+func (mc *SerialClient) SetupPort() error {
+
+	port, err := serial.Open(mc.Port, mc.Mode)
+	if err != nil {
+		return fmt.Errorf("misc.serial.client can't open input port: %s", mc.Port)
+	}
+
+	mc.port = port
+
+	return nil
+}
+
+func (mc *SerialClient) Run() error {
+
+	// TODO(jwetzell): shutdown with router.Context properly
+	go func() {
+		<-mc.ctx.Done()
+		slog.Debug("router context done in module", "id", mc.config.Id)
+		if mc.port != nil {
+			mc.port.Close()
+		}
+	}()
+
+	for {
+		err := mc.SetupPort()
+		if err != nil {
+			if mc.ctx.Err() != nil {
+				slog.Debug("router context done in module", "id", mc.config.Id)
+				return nil
+			}
+			slog.Error("misc.serial.client", "id", mc.config.Id, "error", err.Error())
+			time.Sleep(time.Second * 2)
+			continue
+		}
+
+		buffer := make([]byte, 1024)
+		select {
+		case <-mc.ctx.Done():
+			slog.Debug("router context done in module", "id", mc.config.Id)
+			return nil
+		default:
+		READ:
+			for {
+				select {
+				case <-mc.ctx.Done():
+					slog.Debug("router context done in module", "id", mc.config.Id)
+					return nil
+				default:
+					byteCount, err := mc.port.Read(buffer)
+
+					if err != nil {
+						mc.Framer.Clear()
+						break READ
+					}
+
+					if mc.Framer != nil {
+						if byteCount > 0 {
+							messages := mc.Framer.Decode(buffer[0:byteCount])
+							for _, message := range messages {
+								if mc.router != nil {
+									mc.router.HandleInput(mc.config.Id, message)
+								} else {
+									slog.Error("misc.serial.client has no router", "id", mc.config.Id)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func (mc *SerialClient) Output(payload any) error {
+
+	payloadBytes, ok := payload.([]byte)
+
+	if !ok {
+		return fmt.Errorf("misc.serial.client can only ouptut bytes")
+	}
+
+	_, err := mc.port.Write(mc.Framer.Encode(payloadBytes))
+	return err
+}

internal/module/tcp-client.go

@@ -1,27 +1,30 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 	"net"
 	"time"
 
-	"github.com/jwetzell/showbridge-go/internal/framing"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/framer"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type TCPClient struct {
-	config ModuleConfig
-	Host   string
-	Port   uint16
-	framer framing.Framer
-	conn   net.Conn
-	router *Router
+	config config.ModuleConfig
+	framer framer.Framer
+	conn   *net.TCPConn
+	ctx    context.Context
+	router route.RouteIO
+	Addr   *net.TCPAddr
 }
 
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.tcp.client",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 			host, ok := params["host"]
 
@@ -32,7 +35,7 @@ func init() {
 			hostString, ok := host.(string)
 
 			if !ok {
-				return nil, fmt.Errorf("net.tcp.client host must be uint16")
+				return nil, fmt.Errorf("net.tcp.client host must be string")
 			}
 
 			port, ok := params["port"]
@@ -43,36 +46,34 @@ func init() {
 			portNum, ok := port.(float64)
 
 			if !ok {
-				return nil, fmt.Errorf("net.tcp.client port must be uint16")
+				return nil, fmt.Errorf("net.tcp.client port must be a number")
 			}
 
-			framingMethod, ok := params["framing"]
-			if !ok {
-				return nil, fmt.Errorf("net.tcp.client requires a framing method")
+			addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", hostString, uint16(portNum)))
+			if err != nil {
+				return nil, err
 			}
 
-			framingMethodString, ok := framingMethod.(string)
+			framingMethod := "RAW"
 
-			if !ok {
-				return nil, fmt.Errorf("tcp framing method must be a string")
+			framingMethodRaw, ok := params["framing"]
+
+			if ok {
+				framingMethodString, ok := framingMethodRaw.(string)
+
+				if !ok {
+					return nil, fmt.Errorf("misc.serial.client framing method must be a string")
+				}
+				framingMethod = framingMethodString
 			}
 
-			var framer framing.Framer
+			framer, err := framer.GetFramer(framingMethod)
 
-			switch framingMethodString {
-			case "CR":
-				framer = framing.NewByteSeparatorFramer([]byte{'\r'})
-			case "LF":
-				framer = framing.NewByteSeparatorFramer([]byte{'\n'})
-			case "CRLF":
-				framer = framing.NewByteSeparatorFramer([]byte{'\r', '\n'})
-			case "SLIP":
-				framer = framing.NewSlipFramer()
-			default:
-				return nil, fmt.Errorf("unknown framing method: %s", framingMethodString)
+			if err != nil {
+				return nil, err
 			}
 
-			return &TCPClient{framer: framer, Host: hostString, Port: uint16(portNum), config: config}, nil
+			return &TCPClient{framer: framer, Addr: addr, config: config, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -85,19 +86,11 @@ func (tc *TCPClient) Type() string {
 	return tc.config.Type
 }
 
-func (tc *TCPClient) RegisterRouter(router *Router) {
-	tc.router = router
-}
-
 func (tc *TCPClient) Run() error {
-	addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", tc.Host, tc.Port))
-	if err != nil {
-		return err
-	}
 
 	// TODO(jwetzell): shutdown with router.Context properly
 	go func() {
-		<-tc.router.Context.Done()
+		<-tc.ctx.Done()
 		slog.Debug("router context done in module", "id", tc.config.Id)
 		if tc.conn != nil {
 			tc.conn.Close()
@@ -105,9 +98,9 @@ func (tc *TCPClient) Run() error {
 	}()
 
 	for {
-		client, err := net.DialTCP("tcp", nil, addr)
+		err := tc.SetupConn()
 		if err != nil {
-			if tc.router.Context.Err() != nil {
+			if tc.ctx.Err() != nil {
 				slog.Debug("router context done in module", "id", tc.config.Id)
 				return nil
 			}
@@ -116,22 +109,20 @@ func (tc *TCPClient) Run() error {
 			continue
 		}
 
-		tc.conn = client
-
 		buffer := make([]byte, 1024)
 		select {
-		case <-tc.router.Context.Done():
+		case <-tc.ctx.Done():
 			slog.Debug("router context done in module", "id", tc.config.Id)
 			return nil
 		default:
 		READ:
 			for {
 				select {
-				case <-tc.router.Context.Done():
+				case <-tc.ctx.Done():
 					slog.Debug("router context done in module", "id", tc.config.Id)
 					return nil
 				default:
-					byteCount, err := client.Read(buffer)
+					byteCount, err := tc.conn.Read(buffer)
 
 					if err != nil {
 						tc.framer.Clear()
@@ -151,22 +142,29 @@ func (tc *TCPClient) Run() error {
 						}
 					}
 				}
-
 			}
 		}
-
 	}
+}
 
+func (tc *TCPClient) SetupConn() error {
+	client, err := net.DialTCP("tcp", nil, tc.Addr)
+	tc.conn = client
+	return err
 }
 
 func (tc *TCPClient) Output(payload any) error {
-	if tc.conn != nil {
-		payloadBytes, ok := payload.([]byte)
-		if !ok {
-			return fmt.Errorf("net.tcp.client is only able to output bytes")
+	// NOTE(jwetzell): not sure how this would occur but
+	if tc.conn == nil {
+		err := tc.SetupConn()
+		if err != nil {
+			return err
 		}
-		_, err := tc.conn.Write(tc.framer.Encode(payloadBytes))
-		return err
 	}
-	return nil
+	payloadBytes, ok := payload.([]byte)
+	if !ok {
+		return fmt.Errorf("net.tcp.client is only able to output bytes")
+	}
+	_, err := tc.conn.Write(tc.framer.Encode(payloadBytes))
+	return err
 }

internal/module/tcp-server.go

@@ -0,0 +1,220 @@
+package module
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net"
+	"slices"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/framer"
+	"github.com/jwetzell/showbridge-go/internal/route"
+)
+
+type TCPServer struct {
+	config        config.ModuleConfig
+	Addr          *net.TCPAddr
+	Framer        framer.Framer
+	ctx           context.Context
+	router        route.RouteIO
+	quit          chan interface{}
+	wg            sync.WaitGroup
+	connections   []*net.TCPConn
+	connectionsMu sync.RWMutex
+}
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type: "net.tcp.server",
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
+			params := config.Params
+			port, ok := params["port"]
+			if !ok {
+				return nil, fmt.Errorf("net.tcp.server requires a port parameter")
+			}
+
+			portNum, ok := port.(float64)
+
+			if !ok {
+				return nil, fmt.Errorf("net.tcp.server port must be a number")
+			}
+
+			framingMethod := "RAW"
+
+			framingMethodRaw, ok := params["framing"]
+
+			if ok {
+				framingMethodString, ok := framingMethodRaw.(string)
+
+				if !ok {
+					return nil, fmt.Errorf("misc.serial.client framing method must be a string")
+				}
+				framingMethod = framingMethodString
+			}
+
+			framer, err := framer.GetFramer(framingMethod)
+
+			if err != nil {
+				return nil, err
+			}
+
+			ipString := "0.0.0.0"
+
+			ip, ok := params["ip"]
+			if ok {
+
+				specificIpString, ok := ip.(string)
+
+				if !ok {
+					return nil, fmt.Errorf("net.tcp.server ip must be a string")
+				}
+				ipString = specificIpString
+			}
+
+			addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
+			if err != nil {
+				return nil, err
+			}
+
+			return &TCPServer{Framer: framer, Addr: addr, config: config, quit: make(chan interface{}), ctx: ctx, router: router}, nil
+		},
+	})
+}
+
+func (ts *TCPServer) Id() string {
+	return ts.config.Id
+}
+
+func (ts *TCPServer) Type() string {
+	return ts.config.Type
+}
+
+func (ts *TCPServer) handleClient(client *net.TCPConn) {
+	ts.connectionsMu.Lock()
+	ts.connections = append(ts.connections, client)
+	ts.connectionsMu.Unlock()
+	slog.Debug("net.tcp.server connection accepted", "id", ts.config.Id, "remoteAddr", client.RemoteAddr().String())
+	defer client.Close()
+
+	buffer := make([]byte, 1024)
+ClientRead:
+	for {
+		select {
+		case <-ts.quit:
+			return
+		default:
+			client.SetDeadline(time.Now().Add(time.Millisecond * 200))
+			byteCount, err := client.Read(buffer)
+
+			if err != nil {
+				if opErr, ok := err.(*net.OpError); ok {
+					//NOTE(jwetzell) we hit deadline
+					if opErr.Timeout() {
+						continue ClientRead
+					}
+					if errors.Is(opErr, syscall.ECONNRESET) {
+						ts.connectionsMu.Lock()
+						for i := 0; i < len(ts.connections); i++ {
+							if ts.connections[i] == client {
+								ts.connections = slices.Delete(ts.connections, i, i+1)
+								break
+							}
+						}
+						slog.Debug("net.tcp.server connection reset", "id", ts.config.Id, "remoteAddr", client.RemoteAddr().String())
+						ts.connectionsMu.Unlock()
+					}
+				}
+
+				if err.Error() == "EOF" {
+					ts.connectionsMu.Lock()
+					for i := 0; i < len(ts.connections); i++ {
+						if ts.connections[i] == client {
+							ts.connections = slices.Delete(ts.connections, i, i+1)
+							break
+						}
+					}
+					slog.Debug("net.tcp.server stream ended", "id", ts.config.Id, "remoteAddr", client.RemoteAddr().String())
+					ts.connectionsMu.Unlock()
+				}
+				return
+			}
+			if ts.Framer != nil {
+				if byteCount > 0 {
+					messages := ts.Framer.Decode(buffer[0:byteCount])
+					for _, message := range messages {
+						if ts.router != nil {
+							ts.router.HandleInput(ts.config.Id, message)
+						} else {
+							slog.Error("net.tcp.server has no router", "id", ts.config.Id)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func (ts *TCPServer) Run() error {
+	listener, err := net.ListenTCP("tcp", ts.Addr)
+	if err != nil {
+		return err
+	}
+	ts.wg.Add(1)
+
+	go func() {
+		<-ts.ctx.Done()
+		close(ts.quit)
+		listener.Close()
+		slog.Debug("router context done in module", "id", ts.config.Id)
+	}()
+
+AcceptLoop:
+	for {
+		conn, err := listener.AcceptTCP()
+		if err != nil {
+			select {
+			case <-ts.quit:
+				break AcceptLoop
+			default:
+				slog.Debug("net.tcp.server problem with listener", "error", err)
+			}
+		} else {
+			ts.wg.Add(1)
+			go func() {
+				ts.handleClient(conn)
+				ts.wg.Done()
+			}()
+		}
+	}
+	ts.wg.Done()
+	ts.wg.Wait()
+	return nil
+}
+
+func (ts *TCPServer) Output(payload any) error {
+	payloadBytes, ok := payload.([]byte)
+
+	if !ok {
+		return fmt.Errorf("net.tcp.server is only able to output bytes")
+	}
+	ts.connectionsMu.Lock()
+	errorString := ""
+
+	for _, connection := range ts.connections {
+		_, err := connection.Write(payloadBytes)
+		if err != nil {
+			errorString += fmt.Sprintf("%s\n", err.Error())
+		}
+	}
+	ts.connectionsMu.Unlock()
+
+	if errorString == "" {
+		return nil
+	}
+	return fmt.Errorf("%s", errorString)
+}

internal/module/timer.go

@@ -1,36 +1,41 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type Timer struct {
-	config   ModuleConfig
+	config   config.ModuleConfig
 	Duration uint32
-	router   *Router
+	ctx      context.Context
+	router   route.RouteIO
 	timer    *time.Timer
 }
 
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "gen.timer",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 
 			duration, ok := params["duration"]
 			if !ok {
-				return nil, fmt.Errorf("timer requires a duration parameter")
+				return nil, fmt.Errorf("gen.timer requires a duration parameter")
 			}
 
 			durationNum, ok := duration.(float64)
 
 			if !ok {
-				return nil, fmt.Errorf("timer duration must be number")
+				return nil, fmt.Errorf("gen.timer duration must be a number")
 			}
 
-			return &Timer{Duration: uint32(durationNum), config: config}, nil
+			return &Timer{Duration: uint32(durationNum), config: config, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -43,16 +48,12 @@ func (t *Timer) Type() string {
 	return t.config.Type
 }
 
-func (t *Timer) RegisterRouter(router *Router) {
-	t.router = router
-}
-
 func (t *Timer) Run() error {
 	t.timer = time.NewTimer(time.Millisecond * time.Duration(t.Duration))
 	defer t.timer.Stop()
 	for {
 		select {
-		case <-t.router.Context.Done():
+		case <-t.ctx.Done():
 			t.timer.Stop()
 			slog.Debug("router context done in module", "id", t.config.Id)
 			return nil

internal/module/udp-client.go

@@ -1,24 +1,28 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 	"net"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type UDPClient struct {
-	config ModuleConfig
-	Host   string
+	config config.ModuleConfig
+	Addr   *net.UDPAddr
 	Port   uint16
-	conn   net.Conn
-	router *Router
-	addr   *net.UDPAddr
+	conn   *net.UDPConn
+	ctx    context.Context
+	router route.RouteIO
 }
 
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.udp.client",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 			host, ok := params["host"]
 
@@ -29,7 +33,7 @@ func init() {
 			hostString, ok := host.(string)
 
 			if !ok {
-				return nil, fmt.Errorf("net.udp.client host must be uint16")
+				return nil, fmt.Errorf("net.udp.client host must be a string")
 			}
 
 			port, ok := params["port"]
@@ -43,7 +47,12 @@ func init() {
 				return nil, fmt.Errorf("net.udp.client port must be a number")
 			}
 
-			return &UDPClient{Host: hostString, Port: uint16(portNum), config: config}, nil
+			addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", hostString, uint16(portNum)))
+			if err != nil {
+				return nil, err
+			}
+
+			return &UDPClient{Addr: addr, config: config, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -56,21 +65,24 @@ func (uc *UDPClient) Type() string {
 	return uc.config.Type
 }
 
-func (uc *UDPClient) RegisterRouter(router *Router) {
-	uc.router = router
+func (uc *UDPClient) SetupConn() error {
+	client, err := net.DialUDP("udp", nil, uc.Addr)
+	uc.conn = client
+	return err
 }
 
 func (uc *UDPClient) Run() error {
 
-	addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", uc.Host, uc.Port))
+	err := uc.SetupConn()
 	if err != nil {
 		return err
 	}
 
-	uc.addr = addr
-
-	<-uc.router.Context.Done()
+	<-uc.ctx.Done()
 	slog.Debug("router context done in module", "id", uc.config.Id)
+	if uc.conn != nil {
+		uc.conn.Close()
+	}
 	return nil
 }
 
@@ -80,18 +92,14 @@ func (uc *UDPClient) Output(payload any) error {
 	if !ok {
 		return fmt.Errorf("net.udp.client is only able to output bytes")
 	}
+	if uc.conn != nil {
+		_, err := uc.conn.Write(payloadBytes)
 
-	client, err := net.DialUDP("udp", nil, uc.addr)
-	if err != nil {
-		return err
-	}
-
-	uc.conn = client
-
-	_, err = uc.conn.Write(payloadBytes)
-
-	if err != nil {
-		return err
+		if err != nil {
+			return err
+		}
+	} else {
+		return fmt.Errorf("net.udp.client client is not setup")
 	}
 	return nil
 }

internal/module/udp-multicast.go

@@ -0,0 +1,122 @@
+package module
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
+)
+
+type UDPMulticast struct {
+	config config.ModuleConfig
+	conn   *net.UDPConn
+	ctx    context.Context
+	router route.RouteIO
+	Addr   *net.UDPAddr
+}
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type: "net.udp.multicast",
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
+			params := config.Params
+			ip, ok := params["ip"]
+
+			if !ok {
+				return nil, fmt.Errorf("net.udp.client requires am ip parameter")
+			}
+
+			ipString, ok := ip.(string)
+
+			if !ok {
+				return nil, fmt.Errorf("net.udp.client ip must be a string")
+			}
+
+			port, ok := params["port"]
+			if !ok {
+				return nil, fmt.Errorf("net.udp.client requires a port parameter")
+			}
+
+			portNum, ok := port.(float64)
+
+			if !ok {
+				return nil, fmt.Errorf("net.udp.client port must be a number")
+			}
+
+			addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
+			if err != nil {
+				return nil, err
+			}
+			return &UDPMulticast{config: config, Addr: addr, ctx: ctx, router: router}, nil
+		},
+	})
+}
+
+func (um *UDPMulticast) Id() string {
+	return um.config.Id
+}
+
+func (um *UDPMulticast) Type() string {
+	return um.config.Type
+}
+
+func (um *UDPMulticast) Run() error {
+
+	client, err := net.ListenMulticastUDP("udp", nil, um.Addr)
+	if err != nil {
+		return err
+	}
+	defer client.Close()
+
+	um.conn = client
+
+	buffer := make([]byte, 2048)
+	for {
+		select {
+		case <-um.ctx.Done():
+			// TODO(jwetzell): cleanup?
+			slog.Debug("router context done in module", "id", um.config.Id)
+			return nil
+		default:
+			um.conn.SetDeadline(time.Now().Add(time.Millisecond * 200))
+
+			numBytes, _, err := um.conn.ReadFromUDP(buffer)
+			if err != nil {
+				//NOTE(jwetzell) we hit deadline
+				if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
+					continue
+				}
+				return err
+			}
+
+			if numBytes > 0 {
+				message := buffer[:numBytes]
+
+				if um.router != nil {
+					um.router.HandleInput(um.config.Id, message)
+				} else {
+					slog.Error("net.udp.multicast has no router", "id", um.config.Id)
+				}
+			}
+		}
+	}
+}
+
+func (um *UDPMulticast) Output(payload any) error {
+
+	payloadBytes, ok := payload.([]byte)
+	if !ok {
+		return fmt.Errorf("net.udp.multicast can only output bytes")
+	}
+
+	if um.conn == nil {
+		return fmt.Errorf("net.udp.multicast connection is not setup")
+	}
+
+	_, err := um.conn.Write(payloadBytes)
+	return err
+}

internal/module/udp-server.go

@@ -1,23 +1,28 @@
-package showbridge
+package module
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"log/slog"
 	"net"
 	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
 type UDPServer struct {
-	Port   uint16
-	config ModuleConfig
-	router *Router
+	Addr   *net.UDPAddr
+	config config.ModuleConfig
+	ctx    context.Context
+	router route.RouteIO
 }
 
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.udp.server",
-		New: func(config ModuleConfig) (Module, error) {
+		New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
 			params := config.Params
 			port, ok := params["port"]
 			if !ok {
@@ -27,10 +32,28 @@ func init() {
 			portNum, ok := port.(float64)
 
 			if !ok {
-				return nil, fmt.Errorf("net.udp.server port must be uint16")
+				return nil, fmt.Errorf("net.udp.server port must be a number")
 			}
 
-			return &UDPServer{Port: uint16(portNum), config: config}, nil
+			ipString := "0.0.0.0"
+
+			ip, ok := params["ip"]
+			if ok {
+
+				specificIpString, ok := ip.(string)
+
+				if !ok {
+					return nil, fmt.Errorf("net.udp.server ip must be a string")
+				}
+				ipString = specificIpString
+			}
+
+			addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
+			if err != nil {
+				log.Fatalf("error resolving UDP address: %v", err)
+			}
+
+			return &UDPServer{Addr: addr, config: config, ctx: ctx, router: router}, nil
 		},
 	})
 }
@@ -43,28 +66,20 @@ func (us *UDPServer) Type() string {
 	return us.config.Id
 }
 
-func (us *UDPServer) RegisterRouter(router *Router) {
-	us.router = router
-}
-
 func (us *UDPServer) Run() error {
 
-	addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", us.Port))
-	if err != nil {
-		log.Fatalf("error resolving UDP address: %v", err)
-	}
-
-	listener, err := net.ListenUDP("udp", addr)
+	listener, err := net.ListenUDP("udp", us.Addr)
 	if err != nil {
 		return err
 	}
 
 	defer listener.Close()
 
-	buffer := make([]byte, 1024)
+	// TODO(jwetzell): make buffer size configurable
+	buffer := make([]byte, 65535)
 	for {
 		select {
-		case <-us.router.Context.Done():
+		case <-us.ctx.Done():
 			// TODO(jwetzell): cleanup?
 			slog.Debug("router context done in module", "id", us.config.Id)
 			return nil

internal/processing/string-decode_test.go

@@ -1,41 +0,0 @@
-package processing_test
-
-import (
-	"testing"
-
-	"github.com/jwetzell/showbridge-go/internal/processing"
-)
-
-func TestGoodStringDecode(t *testing.T) {
-	stringDecoder := processing.StringDecode{}
-	tests := []struct {
-		processor processing.Processor
-		name      string
-		payload   any
-		expected  string
-	}{
-		{
-			processor: &stringDecoder,
-			name:      "hello",
-			payload:   []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f},
-			expected:  "hello",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			got, err := test.processor.Process(t.Context(), test.payload)
-
-			gotString, ok := got.(string)
-			if !ok {
-				t.Errorf("string.decode returned a %T payload: %s", got, got)
-			}
-			if err != nil {
-				t.Errorf("string.decode failed: %s", err)
-			}
-			if gotString != test.expected {
-				t.Errorf("string.decode got %s, expected %s", got, test.expected)
-			}
-		})
-	}
-}

internal/processor/debug-log.go

@@ -1,13 +1,15 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 	"log/slog"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type DebugLog struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (dl *DebugLog) Process(ctx context.Context, payload any) (any, error) {
@@ -22,7 +24,7 @@ func (dl *DebugLog) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "debug.log",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &DebugLog{config: config}, nil
 		},
 	})

internal/processor/float-parse.go

@@ -0,0 +1,41 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+type FloatParse struct {
+	config config.ProcessorConfig
+}
+
+func (fp *FloatParse) Process(ctx context.Context, payload any) (any, error) {
+	payloadString, ok := payload.(string)
+
+	if !ok {
+		return nil, fmt.Errorf("float.parse processor only accepts a string")
+	}
+
+	// TODO(jwetzell): make bitSize configurable
+	payloadFloat, err := strconv.ParseFloat(payloadString, 64)
+	if err != nil {
+		return nil, err
+	}
+	return payloadFloat, nil
+}
+
+func (fp *FloatParse) Type() string {
+	return fp.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type: "float.parse",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			return &FloatParse{config: config}, nil
+		},
+	})
+}

internal/processor/float-parse_test.go

@@ -0,0 +1,85 @@
+package processor_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+func TestGoodFloatParse(t *testing.T) {
+	floatParser := processor.FloatParse{}
+	tests := []struct {
+		processor processor.Processor
+		name      string
+		payload   any
+		expected  float64
+	}{
+		{
+			name:     "positive number",
+			payload:  "12345.67",
+			expected: 12345.67,
+		},
+		{
+			name:     "negative number",
+			payload:  "-12345.67",
+			expected: -12345.67,
+		},
+		{
+			name:     "zero",
+			payload:  "0",
+			expected: 0,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := floatParser.Process(t.Context(), test.payload)
+
+			gotFloat, ok := got.(float64)
+			if !ok {
+				t.Errorf("float.parse returned a %T payload: %s", got, got)
+			}
+			if err != nil {
+				t.Errorf("float.parse failed: %s", err)
+			}
+			if gotFloat != test.expected {
+				t.Errorf("float.parse got %f, expected %f", gotFloat, test.expected)
+			}
+		})
+	}
+}
+
+func TestBadFloatParse(t *testing.T) {
+	floatParser := processor.FloatParse{}
+	tests := []struct {
+		processor   processor.Processor
+		name        string
+		payload     any
+		errorString string
+	}{
+		{
+			name:        "non-string input",
+			payload:     []byte{0x01},
+			errorString: "float.parse processor only accepts a string",
+		},
+		{
+			name:        "not float string",
+			payload:     "abcd",
+			errorString: "strconv.ParseFloat: parsing \"abcd\": invalid syntax",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := floatParser.Process(t.Context(), test.payload)
+
+			if err == nil {
+				t.Errorf("float.parse expected to fail but succeeded, got: %v", got)
+
+			}
+			if err.Error() != test.errorString {
+				t.Errorf("float.parse got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/free-d-create.go

@@ -1,4 +1,4 @@
-package processing
+package processor
 
 import (
 	"bytes"
@@ -8,10 +8,11 @@ import (
 	"text/template"
 
 	freeD "github.com/jwetzell/free-d-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type FreeDCreate struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 	Id     *template.Template
 	Pan    *template.Template
 	Tilt   *template.Template
@@ -51,6 +52,10 @@ func (fc *FreeDCreate) Process(ctx context.Context, payload any) (any, error) {
 
 	panNum, err := strconv.ParseFloat(panString, 32)
 
+	if err != nil {
+		return nil, err
+	}
+
 	var tiltBuffer bytes.Buffer
 	err = fc.Tilt.Execute(&tiltBuffer, payload)
 
@@ -62,6 +67,10 @@ func (fc *FreeDCreate) Process(ctx context.Context, payload any) (any, error) {
 
 	tiltNum, err := strconv.ParseFloat(tiltString, 32)
 
+	if err != nil {
+		return nil, err
+	}
+
 	var rollBuffer bytes.Buffer
 	err = fc.Tilt.Execute(&rollBuffer, payload)
 
@@ -77,10 +86,6 @@ func (fc *FreeDCreate) Process(ctx context.Context, payload any) (any, error) {
 		return nil, err
 	}
 
-	if err != nil {
-		return nil, err
-	}
-
 	var posXBuffer bytes.Buffer
 	err = fc.PosX.Execute(&posXBuffer, payload)
 
@@ -178,7 +183,7 @@ func (fc *FreeDCreate) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "freed.create",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 
 			// TODO(jwetzell): make some params optional
 			params := config.Params

internal/processor/free-d-decode.go

@@ -1,4 +1,4 @@
-package processing
+package processor
 
 import (
 	"context"
@@ -6,10 +6,11 @@ import (
 	"log/slog"
 
 	freeD "github.com/jwetzell/free-d-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type FreeDDecode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (fdd *FreeDDecode) Process(ctx context.Context, payload any) (any, error) {
@@ -33,7 +34,7 @@ func (fdd *FreeDDecode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "freed.decode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &FreeDDecode{config: config}, nil
 		},
 	})

internal/processor/free-d-encode.go

@@ -1,14 +1,15 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 
 	freeD "github.com/jwetzell/free-d-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type FreeDEncode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (fde *FreeDEncode) Process(ctx context.Context, payload any) (any, error) {
@@ -29,7 +30,7 @@ func (fde *FreeDEncode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "freed.encode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &FreeDEncode{config: config}, nil
 		},
 	})

internal/processor/http-request-create.go

@@ -1,4 +1,4 @@
-package processing
+package processor
 
 import (
 	"bytes"
@@ -6,10 +6,12 @@ import (
 	"fmt"
 	"net/http"
 	"text/template"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type HTTPRequestCreate struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 	Method string
 	URL    *template.Template
 }
@@ -42,7 +44,7 @@ func (hre *HTTPRequestCreate) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "http.request.create",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 
 			method, ok := params["method"]

internal/processor/http-request-encode.go

@@ -1,14 +1,16 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 	"io"
 	"net/http"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type HTTPRequestEncode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (hre *HTTPRequestEncode) Process(ctx context.Context, payload any) (any, error) {
@@ -33,7 +35,7 @@ func (hre *HTTPRequestEncode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "http.request.encode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &HTTPRequestEncode{config: config}, nil
 		},
 	})

internal/processor/http-request-filter.go

@@ -1,14 +1,16 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"regexp"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type HTTPRequestFilter struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 	Path   *regexp.Regexp
 	Method string
 }
@@ -41,7 +43,7 @@ func (hrf *HTTPRequestFilter) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "http.request.filter",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			path, ok := params["path"]
 

internal/processor/http-response-encode.go

@@ -1,14 +1,16 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 	"io"
 	"net/http"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type HTTPResponseEncode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (hre *HTTPResponseEncode) Process(ctx context.Context, payload any) (any, error) {
@@ -34,7 +36,7 @@ func (hre *HTTPResponseEncode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "http.response.encode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &HTTPResponseEncode{config: config}, nil
 		},
 	})

internal/processor/int-parse.go

@@ -0,0 +1,41 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+type IntParse struct {
+	config config.ProcessorConfig
+}
+
+func (ip *IntParse) Process(ctx context.Context, payload any) (any, error) {
+	payloadString, ok := payload.(string)
+
+	if !ok {
+		return nil, fmt.Errorf("int.parse processor only accepts a string")
+	}
+
+	// TODO(jwetzell): make base and bitSize configurable
+	payloadInt, err := strconv.ParseInt(payloadString, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	return payloadInt, nil
+}
+
+func (ip *IntParse) Type() string {
+	return ip.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type: "int.parse",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			return &IntParse{config: config}, nil
+		},
+	})
+}

internal/processor/int-parse_test.go

@@ -0,0 +1,85 @@
+package processor_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+func TestGoodIntParse(t *testing.T) {
+	intParser := processor.IntParse{}
+	tests := []struct {
+		processor processor.Processor
+		name      string
+		payload   any
+		expected  int64
+	}{
+		{
+			name:     "positive number",
+			payload:  "12345",
+			expected: 12345,
+		},
+		{
+			name:     "negative number",
+			payload:  "-12345",
+			expected: -12345,
+		},
+		{
+			name:     "zero",
+			payload:  "0",
+			expected: 0,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := intParser.Process(t.Context(), test.payload)
+
+			gotInt, ok := got.(int64)
+			if !ok {
+				t.Errorf("int.parse returned a %T payload: %s", got, got)
+			}
+			if err != nil {
+				t.Errorf("int.parse failed: %s", err)
+			}
+			if gotInt != test.expected {
+				t.Errorf("int.parse got %d, expected %d", gotInt, test.expected)
+			}
+		})
+	}
+}
+
+func TestBadIntParse(t *testing.T) {
+	intParser := processor.IntParse{}
+	tests := []struct {
+		processor   processor.Processor
+		name        string
+		payload     any
+		errorString string
+	}{
+		{
+			name:        "non-string input",
+			payload:     []byte{0x01},
+			errorString: "int.parse processor only accepts a string",
+		},
+		{
+			name:        "not int string",
+			payload:     "123.46",
+			errorString: "strconv.ParseInt: parsing \"123.46\": invalid syntax",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := intParser.Process(t.Context(), test.payload)
+
+			if err == nil {
+				t.Errorf("int.parse expected to fail but succeeded, got: %v", got)
+
+			}
+			if err.Error() != test.errorString {
+				t.Errorf("int.parse got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/midi-message-decode.go

@@ -1,16 +1,17 @@
 //go:build cgo
 
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 
+	"github.com/jwetzell/showbridge-go/internal/config"
 	"gitlab.com/gomidi/midi/v2"
 )
 
 type MIDIMessageDecode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (mmd *MIDIMessageDecode) Process(ctx context.Context, payload any) (any, error) {
@@ -32,7 +33,7 @@ func (mmd *MIDIMessageDecode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "midi.message.decode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &MIDIMessageDecode{config: config}, nil
 		},
 	})

internal/processor/midi-message-encode.go

@@ -1,16 +1,17 @@
 //go:build cgo
 
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 
+	"github.com/jwetzell/showbridge-go/internal/config"
 	"gitlab.com/gomidi/midi/v2"
 )
 
 type MIDIMessageEncode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (mme *MIDIMessageEncode) Process(ctx context.Context, payload any) (any, error) {
@@ -30,7 +31,7 @@ func (mme *MIDIMessageEncode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "midi.message.encode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &MIDIMessageEncode{config: config}, nil
 		},
 	})

internal/processor/mqtt-message-create.go

@@ -1,8 +1,10 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type MQTTMessage struct {
@@ -13,7 +15,7 @@ type MQTTMessage struct {
 }
 
 type MQTTMessageCreate struct {
-	config   ProcessorConfig
+	config   config.ProcessorConfig
 	Topic    string
 	QoS      byte
 	Retained bool
@@ -39,7 +41,7 @@ func (mmc *MQTTMessageCreate) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "mqtt.message.create",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			topic, ok := params["topic"]
 

internal/processor/mqtt-message-encode.go

@@ -1,14 +1,15 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 
 	mqtt "github.com/eclipse/paho.mqtt.golang"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type MQTTMessageEncode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (mme *MQTTMessageEncode) Process(ctx context.Context, payload any) (any, error) {
@@ -28,7 +29,7 @@ func (mme *MQTTMessageEncode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "mqtt.message.encode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &MQTTMessageEncode{config: config}, nil
 		},
 	})

internal/processor/nats-message-create.go

@@ -0,0 +1,85 @@
+package processor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"text/template"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+type NATSMessage struct {
+	Subject string
+	Payload []byte
+}
+
+type NATSMessageCreate struct {
+	config  config.ProcessorConfig
+	Subject string
+	Payload *template.Template
+}
+
+func (nmc *NATSMessageCreate) Process(ctx context.Context, payload any) (any, error) {
+
+	var payloadBuffer bytes.Buffer
+	err := nmc.Payload.Execute(&payloadBuffer, payload)
+
+	if err != nil {
+		return nil, err
+	}
+
+	payloadString := payloadBuffer.String()
+
+	message := NATSMessage{
+		Subject: nmc.Subject,
+		Payload: []byte(payloadString),
+	}
+
+	return message, nil
+}
+
+func (nmc *NATSMessageCreate) Type() string {
+	return nmc.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type: "nats.message.create",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+			// TODO(jwetzell): support template for subject
+			subject, ok := params["subject"]
+
+			if !ok {
+				return nil, fmt.Errorf("nats.message.create requires a subject parameter")
+			}
+
+			subjectString, ok := subject.(string)
+
+			if !ok {
+				return nil, fmt.Errorf("nats.message.create subject must be a string")
+			}
+
+			payload, ok := params["payload"]
+
+			if !ok {
+				return nil, fmt.Errorf("osc.message.create requires a payload parameter")
+			}
+
+			payloadString, ok := payload.(string)
+
+			if !ok {
+				return nil, fmt.Errorf("osc.message.create payload must be a string")
+			}
+
+			payloadTemplate, err := template.New("payload").Parse(payloadString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			return &NATSMessageCreate{config: config, Subject: subjectString, Payload: payloadTemplate}, nil
+		},
+	})
+}

internal/processor/nats-message-encode.go

@@ -0,0 +1,36 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/nats-io/nats.go"
+)
+
+type NATSMessageEncode struct {
+	config config.ProcessorConfig
+}
+
+func (nme *NATSMessageEncode) Process(ctx context.Context, payload any) (any, error) {
+	payloadMessage, ok := payload.(*nats.Msg)
+
+	if !ok {
+		return nil, fmt.Errorf("nats.message.encode processor only accepts an nats.Msg")
+	}
+
+	return payloadMessage.Data, nil
+}
+
+func (nme *NATSMessageEncode) Type() string {
+	return nme.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type: "nats.message.encode",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			return &NATSMessageEncode{config: config}, nil
+		},
+	})
+}

internal/processor/osc-message-create.go

@@ -1,4 +1,4 @@
-package processing
+package processor
 
 import (
 	"bytes"
@@ -9,10 +9,11 @@ import (
 	"text/template"
 
 	"github.com/jwetzell/osc-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type OSCMessageCreate struct {
-	config  ProcessorConfig
+	config  config.ProcessorConfig
 	Address *template.Template
 	Args    []*template.Template
 	Types   string
@@ -76,7 +77,7 @@ func (o *OSCMessageCreate) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "osc.message.create",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			address, ok := params["address"]
 

internal/processor/osc-message-decode.go

@@ -1,14 +1,15 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 
 	osc "github.com/jwetzell/osc-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type OSCMessageDecode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (o *OSCMessageDecode) Process(ctx context.Context, payload any) (any, error) {
@@ -40,7 +41,7 @@ func (o *OSCMessageDecode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "osc.message.decode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &OSCMessageDecode{config: config}, nil
 		},
 	})

internal/processor/osc-message-encode.go

@@ -1,14 +1,15 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 
 	osc "github.com/jwetzell/osc-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type OSCMessageEncode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (o *OSCMessageEncode) Process(ctx context.Context, payload any) (any, error) {
@@ -29,7 +30,7 @@ func (o *OSCMessageEncode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "osc.message.encode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &OSCMessageEncode{config: config}, nil
 		},
 	})

internal/processor/osc-message-filter.go

@@ -1,4 +1,4 @@
-package processing
+package processor
 
 import (
 	"context"
@@ -7,10 +7,11 @@ import (
 	"strings"
 
 	"github.com/jwetzell/osc-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type OSCMessageFilter struct {
-	config  ProcessorConfig
+	config  config.ProcessorConfig
 	Address *regexp.Regexp
 }
 
@@ -36,7 +37,7 @@ func (o *OSCMessageFilter) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "osc.message.filter",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			address, ok := params["address"]
 

internal/processor/osc-message-transform.go

@@ -1,4 +1,4 @@
-package processing
+package processor
 
 import (
 	"bytes"
@@ -7,10 +7,11 @@ import (
 	"text/template"
 
 	osc "github.com/jwetzell/osc-go"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type OSCMessageTransform struct {
-	config  ProcessorConfig
+	config  config.ProcessorConfig
 	Address *template.Template
 }
 
@@ -51,7 +52,7 @@ func (o *OSCMessageTransform) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "osc.message.transform",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			address, ok := params["address"]
 

internal/processor/processor.go

@@ -1,9 +1,11 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 	"sync"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type Processor interface {
@@ -11,14 +13,9 @@ type Processor interface {
 	Process(context.Context, any) (any, error)
 }
 
-type ProcessorConfig struct {
-	Type   string         `json:"type"`
-	Params map[string]any `json:"params"`
-}
-
 type ProcessorRegistration struct {
 	Type string `json:"type"`
-	New  func(ProcessorConfig) (Processor, error)
+	New  func(config.ProcessorConfig) (Processor, error)
 }
 
 func RegisterProcessor(processor ProcessorRegistration) {

internal/processor/script-expr.go

@@ -1,4 +1,4 @@
-package processing
+package processor
 
 import (
 	"context"
@@ -6,11 +6,12 @@ import (
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/vm"
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 // NOTE(jwetzell): see language definition https://expr-lang.org/docs/language-definition
 type ScriptExpr struct {
-	config  ProcessorConfig
+	config  config.ProcessorConfig
 	Program *vm.Program
 }
 
@@ -31,7 +32,7 @@ func (se *ScriptExpr) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "script.expr",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 
 			expression, ok := params["expression"]

internal/processor/script-js.go

@@ -1,15 +1,16 @@
-package processing
+package processor
 
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 
+	"github.com/jwetzell/showbridge-go/internal/config"
 	"modernc.org/quickjs"
 )
 
 type ScriptJS struct {
-	config  ProcessorConfig
+	config  config.ProcessorConfig
 	Program string
 }
 
@@ -31,6 +32,10 @@ func (sj *ScriptJS) Process(ctx context.Context, payload any) (any, error) {
 
 	_, err = vm.Eval(sj.Program, quickjs.EvalGlobal)
 
+	if err != nil {
+		return nil, err
+	}
+
 	output, err := vm.GetProperty(vm.GlobalObject(), payloadAtom)
 
 	if err != nil {
@@ -63,7 +68,7 @@ func (sj *ScriptJS) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "script.js",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 
 			program, ok := params["program"]

internal/processor/string-create.go

@@ -0,0 +1,59 @@
+package processor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"text/template"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+type StringCreate struct {
+	config   config.ProcessorConfig
+	Template *template.Template
+}
+
+func (sc *StringCreate) Process(ctx context.Context, payload any) (any, error) {
+	var templateBuffer bytes.Buffer
+	err := sc.Template.Execute(&templateBuffer, payload)
+
+	if err != nil {
+		return nil, err
+	}
+
+	payloadString := templateBuffer.String()
+
+	return payloadString, nil
+}
+
+func (sc *StringCreate) Type() string {
+	return sc.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type: "string.create",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+			tmpl, ok := params["template"]
+
+			if !ok {
+				return nil, fmt.Errorf("string.create requires a template parameter")
+			}
+
+			templateString, ok := tmpl.(string)
+
+			if !ok {
+				return nil, fmt.Errorf("string.create template must be a string")
+			}
+
+			templateTemplate, err := template.New("template").Parse(templateString)
+
+			if err != nil {
+				return nil, err
+			}
+			return &StringCreate{config: config, Template: templateTemplate}, nil
+		},
+	})
+}

internal/processor/string-decode.go

@@ -1,12 +1,14 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type StringDecode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (sd *StringDecode) Process(ctx context.Context, payload any) (any, error) {
@@ -28,7 +30,7 @@ func (sd *StringDecode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "string.decode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &StringDecode{config: config}, nil
 		},
 	})

internal/processor/string-decode_test.go

@@ -0,0 +1,71 @@
+package processor_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+func TestGoodStringDecode(t *testing.T) {
+	stringDecoder := processor.StringDecode{}
+	tests := []struct {
+		processor processor.Processor
+		name      string
+		payload   any
+		expected  string
+	}{
+		{
+			processor: &stringDecoder,
+			name:      "hello",
+			payload:   []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f},
+			expected:  "hello",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := test.processor.Process(t.Context(), test.payload)
+
+			gotString, ok := got.(string)
+			if !ok {
+				t.Errorf("string.decode returned a %T payload: %s", got, got)
+			}
+			if err != nil {
+				t.Errorf("string.decode failed: %s", err)
+			}
+			if gotString != test.expected {
+				t.Errorf("string.decode got %s, expected %s", got, test.expected)
+			}
+		})
+	}
+}
+
+func TestBadStringDecode(t *testing.T) {
+	stringDecoder := processor.StringDecode{}
+	tests := []struct {
+		processor   processor.Processor
+		name        string
+		payload     any
+		errorString string
+	}{
+		{
+			processor:   &stringDecoder,
+			name:        "non-[]byte input",
+			payload:     "hello",
+			errorString: "string.decode processor only accepts a []byte",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := test.processor.Process(t.Context(), test.payload)
+
+			if err == nil {
+				t.Errorf("string.decode expected to fail but got payload: %s", got)
+			}
+			if err.Error() != test.errorString {
+				t.Errorf("string.decode got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/string-encode.go

@@ -1,12 +1,14 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type StringEncode struct {
-	config ProcessorConfig
+	config config.ProcessorConfig
 }
 
 func (se *StringEncode) Process(ctx context.Context, payload any) (any, error) {
@@ -28,7 +30,7 @@ func (se *StringEncode) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "string.encode",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &StringEncode{config: config}, nil
 		},
 	})

internal/processor/string-encode_test.go

@@ -0,0 +1,72 @@
+package processor_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+func TestGoodStringEncode(t *testing.T) {
+	stringEncoder := processor.StringEncode{}
+	tests := []struct {
+		processor processor.Processor
+		name      string
+		payload   any
+		expected  []byte
+	}{
+		{
+			processor: &stringEncoder,
+			name:      "hello",
+			payload:   "hello",
+			expected:  []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := test.processor.Process(t.Context(), test.payload)
+
+			gotBytes, ok := got.([]byte)
+			if !ok {
+				t.Errorf("string.encode returned a %T payload: %s", got, got)
+			}
+			if err != nil {
+				t.Errorf("string.encode failed: %s", err)
+			}
+			if !slices.Equal(gotBytes, test.expected) {
+				t.Errorf("string.encode got %s, expected %s", got, test.expected)
+			}
+		})
+	}
+}
+
+func TestBadStringEncode(t *testing.T) {
+	stringEncoder := processor.StringEncode{}
+	tests := []struct {
+		processor   processor.Processor
+		name        string
+		payload     any
+		errorString string
+	}{
+		{
+			processor:   &stringEncoder,
+			name:        "non-string input",
+			payload:     []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f},
+			errorString: "string.encode processor only accepts a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := test.processor.Process(t.Context(), test.payload)
+
+			if err == nil {
+				t.Errorf("string.encode expected to fail but got payload: %s", got)
+			}
+			if err.Error() != test.errorString {
+				t.Errorf("string.encode got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/string-filter.go

@@ -1,13 +1,15 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 	"regexp"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type StringFilter struct {
-	config  ProcessorConfig
+	config  config.ProcessorConfig
 	Pattern *regexp.Regexp
 }
 
@@ -32,7 +34,7 @@ func (se *StringFilter) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "string.filter",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 
 			pattern, ok := params["pattern"]

internal/processor/string-split.go

@@ -1,13 +1,15 @@
-package processing
+package processor
 
 import (
 	"context"
 	"fmt"
 	"strings"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
 type StringSplit struct {
-	config    ProcessorConfig
+	config    config.ProcessorConfig
 	Separator string
 }
 
@@ -30,7 +32,7 @@ func (se *StringSplit) Type() string {
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type: "string.split",
-		New: func(config ProcessorConfig) (Processor, error) {
+		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 
 			separator, ok := params["separator"]

internal/processor/string-split_test.go

@@ -0,0 +1,70 @@
+package processor_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+func TestGoodStringSplit(t *testing.T) {
+	tests := []struct {
+		processor processor.Processor
+		name      string
+		payload   any
+		expected  []string
+	}{
+		{
+			processor: &processor.StringSplit{Separator: ","},
+			name:      "comma separated",
+			payload:   "part1,part2,part3",
+			expected:  []string{"part1", "part2", "part3"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := test.processor.Process(t.Context(), test.payload)
+
+			gotStrings, ok := got.([]string)
+			if !ok {
+				t.Errorf("string.split returned a %T payload: %s", got, got)
+			}
+			if err != nil {
+				t.Errorf("string.split failed: %s", err)
+			}
+			if !slices.Equal(gotStrings, test.expected) {
+				t.Errorf("string.split got %s, expected %s", got, test.expected)
+			}
+		})
+	}
+}
+
+func TestBasStringSplit(t *testing.T) {
+	tests := []struct {
+		processor   processor.Processor
+		name        string
+		payload     any
+		errorString string
+	}{
+		{
+			processor:   &processor.StringSplit{Separator: ","},
+			name:        "hello",
+			payload:     []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f},
+			errorString: "string.split only accepts a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := test.processor.Process(t.Context(), test.payload)
+
+			if err == nil {
+				t.Errorf("string.split expected error but got none, payload: %s", got)
+			}
+			if err.Error() != test.errorString {
+				t.Errorf("string.split got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/uint-parse.go

@@ -0,0 +1,41 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+type UintParse struct {
+	config config.ProcessorConfig
+}
+
+func (up *UintParse) Process(ctx context.Context, payload any) (any, error) {
+	payloadString, ok := payload.(string)
+
+	if !ok {
+		return nil, fmt.Errorf("uint.parse processor only accepts a string")
+	}
+
+	// TODO(jwetzell): make base and bitSize configurable
+	payloadUint, err := strconv.ParseUint(payloadString, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	return payloadUint, nil
+}
+
+func (up *UintParse) Type() string {
+	return up.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type: "uint.parse",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			return &UintParse{config: config}, nil
+		},
+	})
+}

internal/processor/uint-parse_test.go

@@ -0,0 +1,80 @@
+package processor_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+func TestGoodUintParse(t *testing.T) {
+	uintParser := processor.UintParse{}
+	tests := []struct {
+		processor processor.Processor
+		name      string
+		payload   any
+		expected  uint64
+	}{
+		{
+			name:     "positive number",
+			payload:  "12345",
+			expected: 12345,
+		},
+		{
+			name:     "zero",
+			payload:  "0",
+			expected: 0,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := uintParser.Process(t.Context(), test.payload)
+
+			gotUint, ok := got.(uint64)
+			if !ok {
+				t.Errorf("uint.parse returned a %T payload: %s", got, got)
+			}
+			if err != nil {
+				t.Errorf("uint.parse failed: %s", err)
+			}
+			if gotUint != test.expected {
+				t.Errorf("uint.parse got %d, expected %d", gotUint, test.expected)
+			}
+		})
+	}
+}
+
+func TestBadUintParse(t *testing.T) {
+	uintParser := processor.UintParse{}
+	tests := []struct {
+		processor   processor.Processor
+		name        string
+		payload     any
+		errorString string
+	}{
+		{
+			name:        "non-string input",
+			payload:     []byte{0x01},
+			errorString: "uint.parse processor only accepts a string",
+		},
+		{
+			name:        "not uint string",
+			payload:     "-1234",
+			errorString: "strconv.ParseUint: parsing \"-1234\": invalid syntax",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := uintParser.Process(t.Context(), test.payload)
+
+			if err == nil {
+				t.Errorf("uint.parse expected to fail but succeeded, got: %v", got)
+
+			}
+			if err.Error() != test.errorString {
+				t.Errorf("uint.parse got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/route/route.go

@@ -0,0 +1,86 @@
+package route
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+type RouteError struct {
+	Index  int
+	Config config.RouteConfig
+	Error  error
+}
+
+type RouteIOError struct {
+	Index int
+	Error error
+}
+
+type RouteIO interface {
+	HandleInput(sourceId string, payload any) []RouteIOError
+	HandleOutput(sourceId string, destinationId string, payload any) error
+}
+
+type Route interface {
+	Input() string
+	Output() string
+	HandleInput(ctx context.Context, sourceId string, payload any, router RouteIO) error
+	HandleOutput(ctx context.Context, sourceId string, payload any, router RouteIO) error
+}
+
+type ProcessorRoute struct {
+	input      string
+	processors []processor.Processor
+	output     string
+}
+
+func NewRoute(config config.RouteConfig) (Route, error) {
+	processors := []processor.Processor{}
+
+	if len(config.Processors) > 0 {
+		for _, processorDecl := range config.Processors {
+			processorInfo, ok := processor.ProcessorRegistry[processorDecl.Type]
+			if !ok {
+				return nil, fmt.Errorf("problem loading processor registration for processor type: %s", processorDecl.Type)
+			}
+
+			processor, err := processorInfo.New(processorDecl)
+			if err != nil {
+				return nil, err
+			}
+			processors = append(processors, processor)
+		}
+	}
+
+	return &ProcessorRoute{input: config.Input, processors: processors, output: config.Output}, nil
+}
+
+func (r *ProcessorRoute) Input() string {
+	return r.input
+}
+
+func (r *ProcessorRoute) Output() string {
+	return r.output
+}
+
+func (r *ProcessorRoute) HandleInput(ctx context.Context, sourceId string, payload any, router RouteIO) error {
+	var err error
+	for _, processor := range r.processors {
+		payload, err = processor.Process(ctx, payload)
+		if err != nil {
+			return err
+		}
+		//NOTE(jwetzell) nil payload will result in the route being "terminated"
+		if payload == nil {
+			return nil
+		}
+	}
+	return r.HandleOutput(ctx, sourceId, payload, router)
+}
+
+func (r *ProcessorRoute) HandleOutput(ctx context.Context, sourceId string, payload any, router RouteIO) error {
+	return router.HandleOutput(sourceId, r.output, payload)
+}

route.go

@@ -1,67 +0,0 @@
-package showbridge
-
-import (
-	"fmt"
-
-	"github.com/jwetzell/showbridge-go/internal/processing"
-)
-
-type RouteError struct {
-	Index  int
-	Config RouteConfig
-	Error  error
-}
-
-type Route struct {
-	index      int
-	Input      string
-	Processors []processing.Processor
-	Output     string
-	router     *Router
-}
-
-type RouteConfig struct {
-	Input      string                       `json:"input"`
-	Processors []processing.ProcessorConfig `json:"processors"`
-	Output     string                       `json:"output"`
-}
-
-func NewRoute(index int, config RouteConfig, router *Router) (*Route, error) {
-	processors := []processing.Processor{}
-
-	if len(config.Processors) > 0 {
-		for _, processorDecl := range config.Processors {
-			processorInfo, ok := processing.ProcessorRegistry[processorDecl.Type]
-			if !ok {
-				return nil, fmt.Errorf("problem loading processor registration for processor type: %s", processorDecl.Type)
-			}
-
-			processor, err := processorInfo.New(processorDecl)
-			if err != nil {
-				return nil, err
-			}
-			processors = append(processors, processor)
-		}
-	}
-
-	return &Route{Input: config.Input, Processors: processors, Output: config.Output, router: router, index: index}, nil
-}
-
-func (r *Route) HandleInput(sourceId string, payload any) error {
-	var err error
-	for _, processor := range r.Processors {
-		payload, err = processor.Process(r.router.Context, payload)
-		if err != nil {
-			return err
-		}
-		//NOTE(jwetzell) nil payload will result in the route being "terminated"
-		if payload == nil {
-			return nil
-		}
-	}
-	return r.HandleOutput(sourceId, payload)
-}
-
-func (r *Route) HandleOutput(sourceId string, payload any) error {
-	return r.router.HandleOutput(sourceId, r.Output, payload)
-}

router.go

@@ -6,23 +6,21 @@ import (
 	"log/slog"
 	"os"
 	"sync"
-)
 
-type RoutingError struct {
-	Index int
-	Error error
-}
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+	"github.com/jwetzell/showbridge-go/internal/route"
+)
 
 type Router struct {
 	contextCancel   context.CancelFunc
 	Context         context.Context
-	ModuleInstances []Module
-	RouteInstances  []*Route
+	ModuleInstances []module.Module
+	RouteInstances  []route.Route
 	moduleWait      sync.WaitGroup
 }
 
-func NewRouter(ctx context.Context, config Config) (*Router, []ModuleError, []RouteError) {
-
+func NewRouter(ctx context.Context, config config.Config) (*Router, []module.ModuleError, []route.RouteError) {
 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 		Level: slog.LevelInfo,
 	}))
@@ -35,20 +33,20 @@ func NewRouter(ctx context.Context, config Config) (*Router, []ModuleError, []Ro
 	router := Router{
 		Context:         routerContext,
 		contextCancel:   cancel,
-		ModuleInstances: []Module{},
-		RouteInstances:  []*Route{},
+		ModuleInstances: []module.Module{},
+		RouteInstances:  []route.Route{},
 	}
 
-	var moduleErrors []ModuleError
+	var moduleErrors []module.ModuleError
 
 	for moduleIndex, moduleDecl := range config.Modules {
 
-		moduleInfo, ok := moduleRegistry[moduleDecl.Type]
+		moduleInfo, ok := module.ModuleRegistry[moduleDecl.Type]
 		if !ok {
 			if moduleErrors == nil {
-				moduleErrors = []ModuleError{}
+				moduleErrors = []module.ModuleError{}
 			}
-			moduleErrors = append(moduleErrors, ModuleError{
+			moduleErrors = append(moduleErrors, module.ModuleError{
 				Index:  moduleIndex,
 				Config: moduleDecl,
 				Error:  fmt.Errorf("module type not defined"),
@@ -61,9 +59,9 @@ func NewRouter(ctx context.Context, config Config) (*Router, []ModuleError, []Ro
 			if moduleInstance.Id() == moduleDecl.Id {
 				moduleInstanceExists = true
 				if moduleErrors == nil {
-					moduleErrors = []ModuleError{}
+					moduleErrors = []module.ModuleError{}
 				}
-				moduleErrors = append(moduleErrors, ModuleError{
+				moduleErrors = append(moduleErrors, module.ModuleError{
 					Index:  moduleIndex,
 					Config: moduleDecl,
 					Error:  fmt.Errorf("duplicate module id"),
@@ -73,12 +71,12 @@ func NewRouter(ctx context.Context, config Config) (*Router, []ModuleError, []Ro
 		}
 
 		if !moduleInstanceExists {
-			moduleInstance, err := moduleInfo.New(moduleDecl)
+			moduleInstance, err := moduleInfo.New(router.Context, moduleDecl, &router)
 			if err != nil {
 				if moduleErrors == nil {
-					moduleErrors = []ModuleError{}
+					moduleErrors = []module.ModuleError{}
 				}
-				moduleErrors = append(moduleErrors, ModuleError{
+				moduleErrors = append(moduleErrors, module.ModuleError{
 					Index:  moduleIndex,
 					Config: moduleDecl,
 					Error:  err,
@@ -91,26 +89,21 @@ func NewRouter(ctx context.Context, config Config) (*Router, []ModuleError, []Ro
 
 	}
 
-	var routeErrors []RouteError
+	var routeErrors []route.RouteError
 	for routeIndex, routeDecl := range config.Routes {
-		route, err := NewRoute(routeIndex, routeDecl, &router)
+		routeInstance, err := route.NewRoute(routeDecl)
 		if err != nil {
 			if routeErrors == nil {
-				routeErrors = []RouteError{}
+				routeErrors = []route.RouteError{}
 			}
-			routeErrors = append(routeErrors, RouteError{
+			routeErrors = append(routeErrors, route.RouteError{
 				Index:  routeIndex,
 				Config: routeDecl,
 				Error:  err,
 			})
 			continue
 		}
-		router.RouteInstances = append(router.RouteInstances, route)
-	}
-
-	for _, moduleInstance := range router.ModuleInstances {
-		slog.Debug("registering router with module", "id", moduleInstance.Id())
-		moduleInstance.RegisterRouter(&router)
+		router.RouteInstances = append(router.RouteInstances, routeInstance)
 	}
 
 	return &router, moduleErrors, routeErrors
@@ -119,7 +112,6 @@ func NewRouter(ctx context.Context, config Config) (*Router, []ModuleError, []Ro
 func (r *Router) Run() {
 	slog.Info("running router")
 	for _, moduleInstance := range r.ModuleInstances {
-		moduleInstance.RegisterRouter(r)
 		r.moduleWait.Add(1)
 		go func() {
 			err := moduleInstance.Run()
@@ -138,16 +130,16 @@ func (r *Router) Stop() {
 	r.contextCancel()
 }
 
-func (r *Router) HandleInput(sourceId string, payload any) []RoutingError {
-	var routingErrors []RoutingError
-	for routeIndex, route := range r.RouteInstances {
-		if route.Input == sourceId {
-			err := route.HandleInput(sourceId, payload)
+func (r *Router) HandleInput(sourceId string, payload any) []route.RouteIOError {
+	var routingErrors []route.RouteIOError
+	for routeIndex, routeInstance := range r.RouteInstances {
+		if routeInstance.Input() == sourceId {
+			err := routeInstance.HandleInput(r.Context, sourceId, payload, r)
 			if err != nil {
 				if routingErrors == nil {
-					routingErrors = []RoutingError{}
+					routingErrors = []route.RouteIOError{}
 				}
-				routingErrors = append(routingErrors, RoutingError{
+				routingErrors = append(routingErrors, route.RouteIOError{
 					Index: routeIndex,
 					Error: err,
 				})

tcp-server.go

@@ -1,157 +0,0 @@
-package showbridge
-
-import (
-	"fmt"
-	"log/slog"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/jwetzell/showbridge-go/internal/framing"
-)
-
-type TCPServer struct {
-	config        ModuleConfig
-	Port          uint16
-	framingMethod string
-	router        *Router
-	quit          chan interface{}
-	wg            sync.WaitGroup
-}
-
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "net.tcp.server",
-		New: func(config ModuleConfig) (Module, error) {
-			params := config.Params
-			port, ok := params["port"]
-			if !ok {
-				return nil, fmt.Errorf("net.tcp.server requires a port parameter")
-			}
-
-			portNum, ok := port.(float64)
-
-			if !ok {
-				return nil, fmt.Errorf("net.tcp.server port must be uint16")
-			}
-
-			framingMethod, ok := params["framing"]
-			if !ok {
-				return nil, fmt.Errorf("net.tcp.server requires a framing method")
-			}
-
-			framingMethodString, ok := framingMethod.(string)
-
-			if !ok {
-				return nil, fmt.Errorf("tcp framing method must be a string")
-			}
-
-			return &TCPServer{framingMethod: framingMethodString, Port: uint16(portNum), config: config, quit: make(chan interface{})}, nil
-		},
-	})
-}
-
-func (ts *TCPServer) Id() string {
-	return ts.config.Id
-}
-
-func (ts *TCPServer) Type() string {
-	return ts.config.Type
-}
-
-func (ts *TCPServer) RegisterRouter(router *Router) {
-	ts.router = router
-}
-
-func (ts *TCPServer) handleClient(client net.Conn) {
-	slog.Debug("connection accepted", "id", ts.config.Id, "remoteAddr", client.RemoteAddr().String())
-	defer client.Close()
-	var framer framing.Framer
-
-	switch ts.framingMethod {
-	case "LF":
-		framer = framing.NewByteSeparatorFramer([]byte{'\n'})
-	case "CR":
-		framer = framing.NewByteSeparatorFramer([]byte{'\r'})
-	case "CRLF":
-		framer = framing.NewByteSeparatorFramer([]byte{'\r', '\n'})
-	case "SLIP":
-		framer = framing.NewSlipFramer()
-	}
-
-	buffer := make([]byte, 1024)
-ClientRead:
-	for {
-		select {
-		case <-ts.quit:
-			return
-		default:
-			client.SetDeadline(time.Now().Add(time.Millisecond * 200))
-			byteCount, err := client.Read(buffer)
-
-			if err != nil {
-				//NOTE(jwetzell) we hit deadline
-				if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
-					continue ClientRead
-				}
-				if err.Error() == "EOF" {
-					slog.Debug("connection closed", "id", ts.config.Id, "remoteAddr", client.RemoteAddr().String())
-				}
-				return
-			}
-			if framer != nil {
-				if byteCount > 0 {
-					messages := framer.Decode(buffer[0:byteCount])
-					for _, message := range messages {
-						if ts.router != nil {
-							ts.router.HandleInput(ts.config.Id, message)
-						} else {
-							slog.Error("tcp-server has no router", "id", ts.config.Id)
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-func (ts *TCPServer) Run() error {
-	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", ts.Port))
-	if err != nil {
-		return err
-	}
-	ts.wg.Add(1)
-
-	go func() {
-		<-ts.router.Context.Done()
-		close(ts.quit)
-		listener.Close()
-		slog.Debug("router context done in module", "id", ts.config.Id)
-	}()
-
-AcceptLoop:
-	for {
-		conn, err := listener.Accept()
-		if err != nil {
-			select {
-			case <-ts.quit:
-				break AcceptLoop
-			default:
-				slog.Debug("net.tcp.server problem with listener", "error", err)
-			}
-		} else {
-			ts.wg.Add(1)
-			go func() {
-				ts.handleClient(conn)
-				ts.wg.Done()
-			}()
-		}
-	}
-	ts.wg.Done()
-	ts.wg.Wait()
-	return nil
-}
-
-func (ts *TCPServer) Output(payload any) error {
-	return fmt.Errorf("net.tcp.server output is not implemented")
-}