add id field to route and processor

Update module github.com/emiago/sipgo to v1.5.0

.github/dependabot.yml

@@ -1,10 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: 'github-actions'
-    directory: '/'
-    schedule:
-      interval: 'weekly'
-  - package-ecosystem: gomod
-    directory: /
-    schedule:
-      interval: "weekly"

.github/labeler.yml

@@ -1,23 +0,0 @@
-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

@@ -17,12 +17,13 @@ changelog:
     - title: Processor 🏭
       labels:
         - processor
-    - title: Route 🛣️
+    - title: Routing 🛣️
       labels:
+        - router
         - route
     - title: CLI ⌨️
       labels:
-        - cmd
+        - cli
     - title: Other Changes
       labels:
-        - '*'
+        - "*"

.github/workflows/label-pr.yaml

@@ -1,18 +0,0 @@
-# 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

@@ -4,59 +4,240 @@ on:
   push:
     tags:
       - "v*"
+  workflow_dispatch:
 
 permissions:
   contents: write
 
 jobs:
-  goreleaser:
+  setup_release:
     runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.set_version.outputs.version }}
+      short_commit: ${{ steps.set_commit.outputs.short_commit }}
     steps:
       - name: checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: set environment variables
+        run: echo "SHOWBRIDGE_VERSION=${GITHUB_REF_NAME}" >> $GITHUB_ENV
+      - name: clean tag
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: echo "SHOWBRIDGE_VERSION=${SHOWBRIDGE_VERSION#v}" >> $GITHUB_ENV
+      - name: set version
+        id: set_version
+        run: echo "version=${SHOWBRIDGE_VERSION}" >> $GITHUB_OUTPUT
+      - name: set commit
+        id: set_commit
+        run: echo "short_commit=${GITHUB_SHA::7}" >> $GITHUB_OUTPUT
+      - name: create release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          generate_release_notes: true
+  linux_amd64:
+    runs-on: ubuntu-24.04
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v7
         with:
           fetch-depth: 0
       - name: setup go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v7
         with:
-          go-version-file: 'go.mod'
+          go-version-file: "go.mod"
-      - name: release
+      - name: install alsa lib
-        uses: goreleaser/goreleaser-action@v6
+        run: sudo apt-get install -y libasound2-dev
+      - name: build
+        run: |
+          CGO_ENABLED=1 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_linux-amd64.tar.gz showbridge
+      - name: upload linux artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
         with:
-          workdir: cmd/showbridge
+          name: showbridge-linux-amd64
-          distribution: goreleaser
+          path: |
-          version: "v2.13.0"
+            showbridge_*.tar.gz
-          args: release --clean
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
+  linux_arm64:
+    runs-on: ubuntu-24.04-arm
+    needs: setup_release
     env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v7
+        with:
+          go-version-file: "go.mod"
+      - name: install alsa lib
+        run: sudo apt-get install -y libasound2-dev
+      - name: build
+        run: |
+          CGO_ENABLED=1 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_linux-arm64.tar.gz showbridge
+      - name: upload linux artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-linux-arm64
+          path: |
+            showbridge_*.tar.gz
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
+  windows:
+    runs-on: ubuntu-latest
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v7
+        with:
+          go-version-file: "go.mod"
+      - name: setup zig
+        uses: mlugg/setup-zig@v2
+        with:
+          version: 0.16.0
+      - name: build amd64
+        run: |
+          CGO_ENABLED=1 GOOS=windows GOARCH=amd64 CC="zig cc -target x86_64-windows-gnu" CXX="zig c++ -target x86_64-windows-gnu" go build -o showbridge.exe -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          zip showbridge_${SHOWBRIDGE_VERSION}_windows-amd64.zip showbridge.exe
+      - name: build arm64
+        run: |
+          CGO_ENABLED=1 GOOS=windows GOARCH=arm64 CC="zig cc -target aarch64-windows-gnu" CXX="zig c++ -target aarch64-windows-gnu" go build -o showbridge.exe -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          zip showbridge_${SHOWBRIDGE_VERSION}_windows-arm64.zip showbridge.exe
+      - name: upload windows artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-windows
+          path: |
+            showbridge_*.zip
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.zip
+  macos_arm64:
+    runs-on: macos-26
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v7
+        with:
+          go-version-file: "go.mod"
+      - name: build
+        run: |
+          CGO_ENABLED=1 GOOS=darwin GOARCH=arm64 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_macOS-arm64.tar.gz showbridge
+      - name: upload macos artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-macos-arm64
+          path: |
+            showbridge_*.tar.gz
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
+  macos_amd64:
+    runs-on: macos-26-intel
+    needs: setup_release
+    env:
+      SHOWBRIDGE_VERSION: ${{ needs.setup_release.outputs.version }}
+      SHORT_COMMIT: ${{ needs.setup_release.outputs.short_commit }}
+    steps:
+      - name: checkout
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: setup go
+        uses: actions/setup-go@v7
+        with:
+          go-version-file: "go.mod"
+      - name: build
+        run: |
+          CGO_ENABLED=1 GOOS=darwin GOARCH=amd64 go build -o showbridge -ldflags="-s -w -X main.version=${SHOWBRIDGE_VERSION}-${SHORT_COMMIT}" ./cmd/showbridge
+          tar -czf showbridge_${SHOWBRIDGE_VERSION}_macOS-amd64.tar.gz showbridge
+      - name: upload macos artifacts
+        uses: actions/upload-artifact@v7
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          name: showbridge-macos-amd64
+          path: |
+            showbridge_*.tar.gz
+      - name: upload artifacts to release
+        uses: softprops/action-gh-release@v3
+        if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch' && startsWith(github.ref, 'refs/tags/v')
+        with:
+          draft: true
+          files: showbridge_*.tar.gz
   docker:
     runs-on: ubuntu-latest
-    needs: goreleaser
+    needs: setup_release
+    if: github.ref_type == 'tag' && github.event_name != 'workflow_dispatch'
     steps:
       - name: Check out repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3.7.0
+        uses: docker/setup-qemu-action@96fe6ef7f33517b61c61be40b68a1882f3264fb8 # v4.2.0
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
+        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4.2.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Setup Docker metadata
         id: meta
-        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
+        uses: docker/metadata-action@dc802804100637a589fabce1cb79ff13a1411302 # v6.2.0
         with:
           images: |
             jwetzell/showbridge
 
       - name: Build and push
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
         with:
           push: true
           context: ./
@@ -65,4 +246,4 @@ jobs:
           labels: ${{ steps.meta.outputs.labels }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
-          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          platforms: linux/amd64

.github/workflows/test-showbridge.yaml

@@ -5,19 +5,19 @@ on:
     branches:
       - main
     paths:
-      - '**/*.go'
+      - "**/*.go"
-      - 'go.mod'
+      - "go.mod"
-      - 'go.sum'
+      - "go.sum"
   push:
     branches:
       - main
     paths:
-      - '**/*.go'
+      - "**/*.go"
-      - 'go.mod'
+      - "go.mod"
-      - 'go.sum'
+      - "go.sum"
 
 permissions:
-  contents: read
+  contents: write
 
 jobs:
   test:
@@ -26,12 +26,24 @@ jobs:
       - name: Install alsa
         run: sudo apt-get install -y libasound2-dev
 
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
-      - uses: actions/setup-go@v6
+      - uses: actions/setup-go@v7
         with:
-          go-version-file: 'go.mod'
+          go-version-file: "go.mod"
       - name: mod tidy
         run: go mod tidy
 
       - name: run tests
-        run: go test ./...
+        run: go test ./... -count=1 -coverpkg "github.com/jwetzell/showbridge-go/..." -coverprofile coverage.out
+
+      - name: clean up coverage report
+        run: cat coverage.out | grep -v "github.com/jwetzell/showbridge-go/cmd" > coverage.nocmd.out
+      - name: Update coverage report
+        uses: ncruces/go-coverage-report@v0.3.2
+        with:
+          coverage-file: coverage.nocmd.out
+          report: true
+          chart: true
+          amend: true
+        if: github.event_name == 'push'
+        continue-on-error: true

.vscode/launch.json

@@ -4,7 +4,6 @@
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
-
     {
       "name": "Launch showbridge",
       "type": "go",

Dockerfile

@@ -1,6 +1,6 @@
-ARG GO_VERSION=1.25.5
+ARG GO_VERSION=1.26.3
 FROM golang:${GO_VERSION}-alpine AS build
-RUN apk --no-cache add ca-certificates tzdata
+RUN apk --no-cache add ca-certificates tzdata git
 WORKDIR /build
 COPY go.mod go.sum ./
 RUN go mod download

README.md

@@ -2,6 +2,7 @@
 
 # showbridge (go edition)
 
+[![Coverage](https://github.com/jwetzell/showbridge-go/wiki/coverage.svg)](https://raw.githack.com/wiki/jwetzell/showbridge-go/coverage.html)
 Simple protocol router _/s_
 
 </div>
@@ -12,6 +13,7 @@ Simple protocol router _/s_
 </p>
 
 ### Supported Protocols
+
 - HTTP
 - UDP
 - TCP
@@ -23,6 +25,7 @@ Simple protocol router _/s_
 - [OSC](https://opensoundcontrol.stanford.edu/spec-1_0.html)
 - [FreeD](https://ptzoptics.com/freed/)
 - [SIP](https://en.wikipedia.org/wiki/Session_Initiation_Protocol)
+- [Redis](https://redis.io/)
 
 ### CLI Usage
 
@@ -34,9 +37,9 @@ USAGE:
    showbridge [global options]
 
 GLOBAL OPTIONS:
-   --config string      path to config file (default: "./config.yaml")
+   --config string      path to config file (default: "./config.yaml") [$SHOWBRIDGE_CONFIG]
-   --log-level string   set log level (default: "info")
+   --log-level string   set log level (default: "info") [$SHOWBRIDGE_LOG_LEVEL]
-   --log-format string  log format to use (default: "text")
+   --log-format string  log format to use (default: "text") [$SHOWBRIDGE_LOG_FORMAT]
    --help, -h           show help
    --version, -v        print the version
 ```

cmd/showbridge/.gitignore

@@ -1,2 +0,0 @@
-# Added by goreleaser init:
-dist/

cmd/showbridge/.goreleaser.yaml

@@ -1,33 +0,0 @@
-version: 2
-project_name: showbridge
-before:
-  hooks:
-    - go mod tidy
-
-builds:
-  - env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-      - windows
-      - darwin
-    goarch:
-      - "amd64"
-      - "arm64"
-    ldflags:
-      - '-s -w -X main.version={{.RawVersion}}-{{.ShortCommit}}'
-
-archives:
-  - formats: [tar.gz]
-    name_template: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}-{{ .Arch }}"
-    format_overrides:
-      - goos: windows
-        formats: [zip]
-
-changelog:
-  sort: asc
-  use: github-native
-
-release:
-  draft: true
-  replace_existing_draft: true

cmd/showbridge/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -9,15 +10,18 @@ import (
 	"os/signal"
 	"slices"
 	"sync"
+	"syscall"
 
 	"github.com/jwetzell/showbridge-go"
 	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/schema"
 	"github.com/urfave/cli/v3"
 	"sigs.k8s.io/yaml"
 )
 
 var (
 	version   = "dev"
+	sigHangup = make(chan os.Signal, 1)
 )
 
 func main() {
@@ -30,6 +34,7 @@ func main() {
 				Name:    "config",
 				Value:   "./config.yaml",
 				Usage:   "path to config file",
+				Sources: cli.EnvVars("SHOWBRIDGE_CONFIG"),
 			},
 			&cli.StringFlag{
 				Name:  "log-level",
@@ -42,6 +47,7 @@ func main() {
 					}
 					return nil
 				},
+				Sources: cli.EnvVars("SHOWBRIDGE_LOG_LEVEL"),
 			},
 			&cli.StringFlag{
 				Name:  "log-format",
@@ -54,12 +60,15 @@ func main() {
 					}
 					return nil
 				},
+				Sources: cli.EnvVars("SHOWBRIDGE_LOG_FORMAT"),
 			},
 		},
 		Action: run,
 	}
 
 	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
+
+	signal.Notify(sigHangup, syscall.SIGHUP)
 	defer cancel()
 	err := cmd.Run(ctx, os.Args)
 
@@ -69,6 +78,14 @@ func main() {
 
 }
 
+type showbridgeApp struct {
+	ctx         context.Context
+	configPath  string
+	logger      *slog.Logger
+	router      *showbridge.Router
+	routerMutex sync.Mutex
+}
+
 func readConfig(configPath string) (config.Config, error) {
 	cfg := config.Config{}
 
@@ -78,7 +95,31 @@ func readConfig(configPath string) (config.Config, error) {
 		return config.Config{}, err
 	}
 
-	err = yaml.Unmarshal(configBytes, &cfg)
+	//TODO(jwetzell): this is an annoying amount of marshaling
+
+	yamlMap := make(map[string]any)
+
+	err = yaml.Unmarshal(configBytes, &yamlMap)
+	if err != nil {
+		return config.Config{}, err
+	}
+
+	err = schema.ApplyDefaults(&yamlMap)
+	if err != nil {
+		return config.Config{}, fmt.Errorf("failed to apply defaults: %w", err)
+	}
+
+	err = schema.ValidateConfig(yamlMap)
+	if err != nil {
+		return config.Config{}, fmt.Errorf("failed to validate config: %w", err)
+	}
+
+	validatedConfigBytes, err := json.Marshal(yamlMap)
+	if err != nil {
+		return config.Config{}, err
+	}
+
+	err = json.Unmarshal(validatedConfigBytes, &cfg)
 	if err != nil {
 		return config.Config{}, err
 	}
@@ -86,18 +127,27 @@ func readConfig(configPath string) (config.Config, error) {
 	return cfg, nil
 }
 
-func run(ctx context.Context, c *cli.Command) error {
+func writeConfig(configPath string, newConfig config.Config) error {
-	configPath := c.String("config")
+	configBytes, err := yaml.Marshal(newConfig)
-	if configPath == "" {
-		return errors.New("config value cannot be empty")
-	}
-
-	config, err := readConfig(configPath)
 	if err != nil {
 		return err
 	}
 
-	logLevel := slog.LevelInfo
+	err = os.WriteFile(configPath, configBytes, 0600)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func run(ctx context.Context, c *cli.Command) error {
+	configPath := c.String("config")
+	if configPath == "" {
+		return errors.New("config path cannot be empty")
+	}
+
+	var logLevel slog.Level
 
 	logLevelFromFlag := c.String("log-level")
 
@@ -135,28 +185,80 @@ func run(ctx context.Context, c *cli.Command) error {
 
 	slog.SetDefault(slog.New(logHandler))
 
-	commandLogger := slog.Default().With("component", "cmd")
+	showbridgeApp := &showbridgeApp{
+		ctx:        ctx,
+		configPath: configPath,
+		logger:     slog.Default().With("component", "cmd"),
+	}
 
-	router, moduleErrors, routeErrors := showbridge.NewRouter(context.Background(), config)
+	config, err := readConfig(showbridgeApp.configPath)
+	if err != nil {
+		return err
+	}
 
+	router, moduleErrors, routeErrors := showbridge.NewRouter(config)
+
+	showbridgeApp.logConfigErrors(moduleErrors, routeErrors)
+
+	if moduleErrors != nil || routeErrors != nil {
+		return fmt.Errorf("errors initializing modules or routes")
+	}
+
+	showbridgeApp.routerMutex.Lock()
+	showbridgeApp.router = router
+
+	router.Start(context.Background())
+	showbridgeApp.routerMutex.Unlock()
+
+	go showbridgeApp.handleChannels()
+
+	<-showbridgeApp.ctx.Done()
+	showbridgeApp.logger.Debug("shutting down router")
+	showbridgeApp.router.Stop()
+	return nil
+}
+
+func (app *showbridgeApp) handleChannels() {
+	for {
+		select {
+		case <-sigHangup:
+			app.logger.Info("received SIGHUP, reloading configuration")
+			app.routerMutex.Lock()
+			config, err := readConfig(app.configPath)
+			if err != nil {
+				app.logger.Error("failed to read config file", "error", err)
+				app.routerMutex.Unlock()
+				continue
+			}
+			moduleErrors, routeErrors, err := app.router.UpdateConfig(config, false)
+			if err != nil {
+				app.logger.Error("failed to update router config", "error", err)
+				app.routerMutex.Unlock()
+				continue
+			}
+			app.logConfigErrors(moduleErrors, routeErrors)
+			app.logger.Info("configuration reloaded successfully")
+			app.routerMutex.Unlock()
+		case config := <-app.router.ConfigChange:
+			app.logger.Info("router config changed updating config file")
+			err := writeConfig(app.configPath, config)
+			if err != nil {
+				app.logger.Error("failed to write config file", "error", err)
+				continue
+			}
+			app.logger.Info("config file updated successfully")
+		case <-app.ctx.Done():
+			return
+		}
+	}
+}
+
+func (app *showbridgeApp) logConfigErrors(moduleErrors []config.ModuleError, routeErrors []config.RouteError) {
 	for _, moduleError := range moduleErrors {
-		commandLogger.Error("problem initializing module", "index", moduleError.Index, "error", moduleError.Error)
+		app.logger.Error("problem initializing module", "index", moduleError.Index, "error", moduleError.Error)
 	}
 
 	for _, routeError := range routeErrors {
-		commandLogger.Error("problem initializing route", "index", routeError.Index, "error", routeError.Error)
+		app.logger.Error("problem initializing route", "index", routeError.Index, "error", routeError.Error)
 	}
-
-	routerRunner := sync.WaitGroup{}
-
-	routerRunner.Go(func() {
-		router.Run()
-	})
-
-	<-ctx.Done()
-	commandLogger.Debug("shutting down router")
-	router.Stop()
-	commandLogger.Debug("waiting for router to exit")
-	routerRunner.Wait()
-	return nil
 }

config.go

@@ -0,0 +1,85 @@
+package showbridge
+
+import (
+	"errors"
+	"reflect"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/route"
+)
+
+func (r *Router) GetRunningConfig() config.Config {
+	r.runningConfigMu.RLock()
+	defer r.runningConfigMu.RUnlock()
+	return r.runningConfig
+}
+
+func (r *Router) UpdateConfig(newConfig config.Config, triggerChangeChan bool) ([]config.ModuleError, []config.RouteError, error) {
+	if !r.runningConfigMu.TryLock() {
+		return nil, nil, errors.New("config update in progress")
+	}
+	defer r.runningConfigMu.Unlock()
+	oldConfig := r.runningConfig
+	r.logger.Debug("received config update", "oldConfig", oldConfig, "newConfig", newConfig)
+
+	if !reflect.DeepEqual(oldConfig.Api, newConfig.Api) {
+		r.logger.Info("applying new API config")
+		r.apiServer.Stop()
+		r.apiServer.Start(newConfig.Api)
+		r.runningConfig.Api = newConfig.Api
+	}
+
+	// TODO(jwetzell): handle config update errors better
+	for _, moduleInstance := range r.ModuleInstances {
+		moduleInstance.Stop()
+	}
+	r.logger.Debug("waiting for modules to exit")
+	r.moduleWait.Wait()
+
+	r.ModuleInstances = make(map[string]common.Module)
+	r.RouteInstances = []*route.Route{}
+
+	var moduleErrors []config.ModuleError
+
+	for moduleIndex, moduleDecl := range newConfig.Modules {
+
+		err := r.addModule(moduleDecl)
+		if err != nil {
+			if moduleErrors == nil {
+				moduleErrors = []config.ModuleError{}
+			}
+			moduleErrors = append(moduleErrors, config.ModuleError{
+				Index:  moduleIndex,
+				Config: moduleDecl,
+				Error:  err.Error(),
+			})
+			continue
+		}
+
+	}
+
+	var routeErrors []config.RouteError
+	for routeIndex, routeDecl := range newConfig.Routes {
+		err := r.addRoute(routeDecl)
+		if err != nil {
+			if routeErrors == nil {
+				routeErrors = []config.RouteError{}
+			}
+			routeErrors = append(routeErrors, config.RouteError{
+				Index:  routeIndex,
+				Config: routeDecl,
+				Error:  err.Error(),
+			})
+			continue
+		}
+	}
+	r.runningConfig = newConfig
+	r.startModules()
+
+	if triggerChangeChan {
+		r.ConfigChange <- newConfig
+	}
+
+	return moduleErrors, routeErrors, nil
+}

config.smoke.yaml

@@ -0,0 +1,135 @@
+api:
+  enabled: true
+  port: 8080
+modules:
+  - id: sqlite
+    type: db.sqlite
+    params:
+      dsn: ":memory:"
+  - id: httpin
+    type: http.server
+    params:
+      port: 3000
+  - id: tcpout
+    type: net.tcp.client
+    params:
+      host: "localhost"
+      port: 9000
+      framing: "RAW"
+  - id: tcpin
+    type: net.tcp.server
+    params:
+      port: 9000
+      framing: "RAW"
+  - id: ticker
+    type: time.interval
+    params:
+      duration: 1000
+  - id: udpout
+    type: net.udp.client
+    params:
+      host: "localhost"
+      port: 9001
+  - id: udpin
+    type: net.udp.server
+    params:
+      port: 9001
+  - id: wsecho
+    type: websocket.client
+    params:
+      url: "wss://echo.websocket.org"
+  - id: natsserver
+    type: nats.server
+    params:
+      port: 4222
+  - id: natsout
+    type: nats.client
+    params:
+      url: "nats://localhost:4222"
+      subject: "hello"
+  - id: natsin
+    type: nats.client
+    params:
+      url: "nats://localhost:4222"
+      subject: "test"
+routes:
+  - input: ticker
+    processors:
+      - type: string.create
+        params:
+          template: "wsecho: {{.Payload.UnixMilli}}"
+      - type: module.output
+        params:
+          module: wsecho
+  - input: ticker
+    processors:
+      - type: string.create
+        params:
+          template: "tcpout: {{.Payload.UnixMilli}}"
+      - type: string.encode
+      - type: module.output
+        params:
+          module: tcpout
+  - input: ticker
+    processors:
+      - type: string.create
+        params:
+          template: "udpout: {{.Payload.UnixMilli}}"
+      - type: string.encode
+      - type: module.output
+        params:
+          module: udpout
+  - input: ticker
+    processors:
+      - type: http.request.do
+        params:
+          url: "http://localhost:3000/echo"
+          method: "GET"
+      - type: struct.field.get
+        params:
+          name: "Body"
+      - type: string.decode
+      - type: debug.log
+  - input: tcpin
+    processors:
+      - type: string.decode
+      - type: debug.log
+  - input: udpin
+    processors:
+      - type: string.decode
+      - type: debug.log
+  - input: wsecho
+    processors:
+      - type: debug.log
+  - input: ticker
+    processors:
+      - type: db.query
+        params:
+          module: "sqlite"
+          query: "SELECT 1;"
+      - type: debug.log
+  - input: natsin
+    processors:
+      - type: struct.field.get
+        params:
+          name: "Data"
+      - type: string.decode
+      - type: debug.log
+  - input: httpin
+    processors:
+      - type: http.response.create
+        params:
+          status: 200
+          bodyTemplate: "Hello, World!"
+      - type: module.output
+        params:
+          module: httpin
+  - input: ticker
+    processors:
+      - type: string.create
+        params:
+          template: "natsout: {{.Payload}}"
+      - type: pubsub.publish
+        params:
+          module: natsout
+          topic: "test"

config.yaml

@@ -1,3 +1,6 @@
+api:
+  enabled: true
+  port: 8080
 modules:
   - id: http
     type: http.server
@@ -10,9 +13,15 @@ modules:
       port: 8000
 routes:
   - input: http
+    id: http-to-osc
     processors:
-      - type: osc.message.create
+      - id: create-osc
+        type: osc.message.create
         params:
-          address: "{{.URL.Path}}"
+          address: "{{.Payload.URL.Path}}"
-      - type: osc.message.encode
+      - id: encode-osc
-    output: udp
+        type: osc.message.encode
+      - id: output-osc
+        type: module.output
+        params:
+          module: udp

events.go

@@ -0,0 +1,53 @@
+package showbridge
+
+import (
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+)
+
+func (r *Router) HandleEvent(event common.Event, sender common.EventDestination) {
+	switch event.Type {
+	case "ping":
+		r.unicastEvent(common.Event{Type: "pong", Data: map[string]any{
+			"timestamp": time.Now().UnixMilli(),
+		}}, sender)
+	default:
+		r.logger.Warn("unknown event type", "eventType", event.Type)
+	}
+}
+
+func (r *Router) AddEventDestination(dest common.EventDestination) {
+	r.eventDestinationsMu.Lock()
+	defer r.eventDestinationsMu.Unlock()
+	r.eventDestinations = append(r.eventDestinations, dest)
+}
+
+func (r *Router) RemoveEventDestination(dest common.EventDestination) {
+	r.eventDestinationsMu.Lock()
+	defer r.eventDestinationsMu.Unlock()
+	for i, d := range r.eventDestinations {
+		if d.Is(dest) {
+			r.eventDestinations = append(r.eventDestinations[:i], r.eventDestinations[i+1:]...)
+			break
+		}
+	}
+}
+
+func (r *Router) unicastEvent(event common.Event, dest common.EventDestination) {
+	err := dest.Send(event)
+	if err != nil {
+		r.logger.Error("failed to send event", "error", err)
+	}
+}
+
+func (r *Router) broadcastEvent(event common.Event) {
+	r.eventDestinationsMu.Lock()
+	defer r.eventDestinationsMu.Unlock()
+	for _, dest := range r.eventDestinations {
+		err := dest.Send(event)
+		if err != nil {
+			r.logger.Error("failed to send event", "error", err)
+		}
+	}
+}

go.mod

@@ -1,56 +1,76 @@
 module github.com/jwetzell/showbridge-go
 
-go 1.25.5
+go 1.26.3
 
 require (
 	github.com/eclipse/paho.mqtt.golang v1.5.1
-	github.com/emiago/diago v0.23.1-0.20251211215055-e1d875617111
+	github.com/emiago/diago v0.32.0
-	github.com/emiago/sipgo v1.0.1
+	github.com/emiago/sipgo v1.5.0
-	github.com/expr-lang/expr v1.17.7
+	github.com/expr-lang/expr v1.17.8
-	github.com/jwetzell/artnet-go v0.0.0-20251223201031-5097901aa9db
+	github.com/extism/go-sdk v1.7.1
-	github.com/jwetzell/free-d-go v0.1.0
+	github.com/google/jsonschema-go v0.4.3
-	github.com/jwetzell/osc-go v0.1.0
+	github.com/gorilla/websocket v1.5.3
+	github.com/jwetzell/artnet-go v0.3.0
+	github.com/jwetzell/free-d-go v0.2.0
+	github.com/jwetzell/osc-go v0.3.0
 	github.com/jwetzell/psn-go v0.3.0
-	github.com/nats-io/nats.go v1.48.0
+	github.com/nats-io/nats-server/v2 v2.14.5
-	github.com/urfave/cli/v3 v3.6.1
+	github.com/nats-io/nats.go v1.53.1
-	gitlab.com/gomidi/midi/v2 v2.3.18
+	github.com/redis/go-redis/v9 v9.22.0
-	go.bug.st/serial v1.6.4
+	github.com/urfave/cli/v3 v3.11.0
-	modernc.org/quickjs v0.17.0
+	gitlab.com/gomidi/midi/v2 v2.3.24
+	go.bug.st/serial v1.8.0
+	golang.org/x/time v0.15.0
+	modernc.org/quickjs v0.24.0
+	modernc.org/sqlite v1.56.0
 	sigs.k8s.io/yaml v1.6.0
 )
 
 require (
-	github.com/creack/goselect v0.1.2 // indirect
+	github.com/antithesishq/antithesis-sdk-go v0.7.2-default-no-op // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/dylibso/observe-sdk/go v0.0.0-20240828172851-9145d8ad07e1 // indirect
+	github.com/emiago/dtls/v3 v3.0.0-20260122183559-8b8d23e359c0 // indirect
 	github.com/go-audio/riff v1.0.0 // indirect
+	github.com/gobwas/glob v0.2.3 // indirect
 	github.com/gobwas/httphead v0.1.0 // indirect
 	github.com/gobwas/pool v0.2.1 // indirect
 	github.com/gobwas/ws v1.4.0 // indirect
+	github.com/google/go-tpm v0.9.8 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/ianlancetaylor/demangle v0.0.0-20260505044615-1ff4bf46051f // indirect
 	github.com/icholy/digest v1.1.0 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/compress v1.19.2 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-isatty v0.0.24 // indirect
-	github.com/nats-io/nkeys v0.4.11 // indirect
+	github.com/minio/highwayhash v1.0.4 // indirect
+	github.com/nats-io/jwt/v2 v2.8.2 // indirect
+	github.com/nats-io/nkeys v0.4.16 // indirect
 	github.com/nats-io/nuid v1.0.1 // indirect
-	github.com/ncruces/go-strftime v0.1.9 // indirect
+	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pion/logging v0.2.4 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
 	github.com/pion/rtcp v1.2.16 // indirect
-	github.com/pion/rtp v1.8.26 // indirect
+	github.com/pion/rtp v1.10.2 // indirect
-	github.com/pion/srtp/v3 v3.0.9 // indirect
+	github.com/pion/srtp/v3 v3.0.10 // indirect
-	github.com/pion/transport/v3 v3.1.1 // indirect
+	github.com/pion/transport/v4 v4.0.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/rogpeppe/go-internal v1.14.1 // indirect
+	github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834 // indirect
+	github.com/tetratelabs/wazero v1.11.0 // indirect
 	github.com/zaf/g711 v1.4.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.10.0 // indirect
+	go.uber.org/atomic v1.11.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
-	golang.org/x/crypto v0.42.0 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect
+	golang.org/x/crypto v0.55.0 // indirect
-	golang.org/x/net v0.44.0 // indirect
+	golang.org/x/net v0.57.0 // indirect
-	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sync v0.22.0 // indirect
-	golang.org/x/sys v0.39.0 // indirect
+	golang.org/x/sys v0.47.0 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
 	gopkg.in/hraban/opus.v2 v2.0.0-20230925203106-0188a62cb302 // indirect
-	modernc.org/libc v1.66.10 // indirect
+	modernc.org/libc v1.75.3 // indirect
-	modernc.org/libquickjs v0.12.2 // indirect
+	modernc.org/libquickjs v0.13.1 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
-	modernc.org/memory v1.11.0 // indirect
+	modernc.org/memory v1.12.0 // indirect
 )

go.sum

@@ -1,19 +1,37 @@
-github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
+github.com/antithesishq/antithesis-sdk-go v0.7.2-default-no-op h1:p2zFsAzvhIpFya8AIOHIbWf7NGvO34QpLGclyf7nXj8=
-github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
+github.com/antithesishq/antithesis-sdk-go v0.7.2-default-no-op/go.mod h1:FQyySiasQQM8735Ddel3MRojmy4dA1IqCeyJ5jmPMbI=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 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=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/dylibso/observe-sdk/go v0.0.0-20240828172851-9145d8ad07e1 h1:idfl8M8rPW93NehFw5H1qqH8yG158t5POr+LX9avbJY=
+github.com/dylibso/observe-sdk/go v0.0.0-20240828172851-9145d8ad07e1/go.mod h1:C8DzXehI4zAbrdlbtOByKX6pfivJTBiV9Jjqv56Yd9Q=
 github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE=
 github.com/eclipse/paho.mqtt.golang v1.5.1/go.mod h1:1/yJCneuyOoCOzKSsOTUc0AJfpsItBGWvYpBLimhArU=
-github.com/emiago/diago v0.23.1-0.20251211215055-e1d875617111 h1:jqhOZbH40pf2jiUhGaBNk334wOtNYvAaXg/mHOXhy/Y=
+github.com/emiago/diago v0.31.0 h1:w/GZQnMS60EBANKXMnf/MjFDlUfcfHLPOlEKiZkaNe0=
-github.com/emiago/diago v0.23.1-0.20251211215055-e1d875617111/go.mod h1:3vLCCq8/G/Ei5I64IHtrmBTag+nPLcgXcKeN1KkLtuc=
+github.com/emiago/diago v0.31.0/go.mod h1:CP7p9/aBZG/fQEYdtGdQkCblr1jLr1zbxODcu8MryVU=
-github.com/emiago/sipgo v1.0.1 h1:8eCZ6L/VX3isyByyv1RrBoQ5GyBoRXBHkNMYjwacRfk=
+github.com/emiago/diago v0.32.0 h1:U6urbJc/LD2HwrHVe1d/yT0lMgyDMRUFle7gMqJe0Jg=
-github.com/emiago/sipgo v1.0.1/go.mod h1:DuwAxBZhKMqIzQFPGZb1MVAGU6Wuxj64oTOhd5dx/FY=
+github.com/emiago/diago v0.32.0/go.mod h1:CP7p9/aBZG/fQEYdtGdQkCblr1jLr1zbxODcu8MryVU=
-github.com/expr-lang/expr v1.17.7 h1:Q0xY/e/2aCIp8g9s/LGvMDCC5PxYlvHgDZRQ4y16JX8=
+github.com/emiago/dtls/v3 v3.0.0-20260122183559-8b8d23e359c0 h1:o4LxpUnZ1zxiQ+Qjc9kLwXcjz31NGAHmnZ7xoJto3VM=
-github.com/expr-lang/expr v1.17.7/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
+github.com/emiago/dtls/v3 v3.0.0-20260122183559-8b8d23e359c0/go.mod h1:ydcZ977eS1I6uOWodzMuw30BwvNAzT9su/xcNYSJqjA=
+github.com/emiago/sipgo v1.4.3 h1:Ju1Ilp0LhTcSHCyp2jBYAQDQ8TAwuxQHzT1IhO6jSIY=
+github.com/emiago/sipgo v1.4.3/go.mod h1:DuwAxBZhKMqIzQFPGZb1MVAGU6Wuxj64oTOhd5dx/FY=
+github.com/emiago/sipgo v1.5.0 h1:YVq5Rw5eVN4DRsB5MoBBiiurpHXXCjJstaH9cTvrlyI=
+github.com/emiago/sipgo v1.5.0/go.mod h1:DuwAxBZhKMqIzQFPGZb1MVAGU6Wuxj64oTOhd5dx/FY=
+github.com/expr-lang/expr v1.17.8 h1:W1loDTT+0PQf5YteHSTpju2qfUfNoBt4yw9+wOEU9VM=
+github.com/expr-lang/expr v1.17.8/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
+github.com/extism/go-sdk v1.7.1 h1:lWJos6uY+tRFdlIHR+SJjwFDApY7OypS/2nMhiVQ9Sw=
+github.com/extism/go-sdk v1.7.1/go.mod h1:IT+Xdg5AZM9hVtpFUA+uZCJMge/hbvshl8bwzLtFyKA=
 github.com/go-audio/riff v1.0.0 h1:d8iCGbDvox9BfLagY94fBynxSPHO80LmZCaOsmKxokA=
 github.com/go-audio/riff v1.0.0/go.mod h1:l3cQwc85y79NQFCRB7TiPoNiaijp6q8Z0Uv38rVG498=
+github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
+github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
@@ -22,85 +40,130 @@ github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
 github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo=
+github.com/google/go-tpm v0.9.8/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
+github.com/google/jsonschema-go v0.4.3 h1:/DBOLZTfDow7pe2GmaJNhltueGTtDKICi8V8p+DQPd0=
+github.com/google/jsonschema-go v0.4.3/go.mod h1:r5quNTdLOYEz95Ru18zA0ydNbBuYoo9tgaYcxEYhJVE=
+github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo=
+github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
+github.com/ianlancetaylor/demangle v0.0.0-20260505044615-1ff4bf46051f h1:NW3E2QSchEk63/fjeEvWOa2cE02FSv9ox//VE/N4c8g=
+github.com/ianlancetaylor/demangle v0.0.0-20260505044615-1ff4bf46051f/go.mod h1:gx7rwoVhcfuVKG5uya9Hs3Sxj7EIvldVofAWIUtGouw=
 github.com/icholy/digest v1.1.0 h1:HfGg9Irj7i+IX1o1QAmPfIBNu/Q5A5Tu3n/MED9k9H4=
 github.com/icholy/digest v1.1.0/go.mod h1:QNrsSGQ5v7v9cReDI0+eyjsXGUoRSUZQHeQ5C4XLa0Y=
-github.com/jwetzell/artnet-go v0.0.0-20251223201031-5097901aa9db h1:PR9sdDEWBufi8/3yiQHRXncLNKUHBMKiEBDtdNWsK/E=
+github.com/jwetzell/artnet-go v0.3.0 h1:MDHElOSbpgmIbYGHO9SoxsT7ynrYtV5/UHGT82geHk0=
-github.com/jwetzell/artnet-go v0.0.0-20251223201031-5097901aa9db/go.mod h1:gli97Z32a0kMkZ6taoTiK7/lqHcF/dhiGjGJdx/PxqA=
+github.com/jwetzell/artnet-go v0.3.0/go.mod h1:zqRsSsrd6rPwJacwscPteDqGIqevjZ3Z6dpp092VJ1w=
-github.com/jwetzell/free-d-go v0.1.0 h1:xHt6dvyit98X+OC3jVzV0aLidxbyzi3vI9QiYkteEtA=
+github.com/jwetzell/free-d-go v0.2.0 h1:8WQW4du8Sf3d18aUzk9n5jZtHE6WdDQHDFjkFffvycc=
-github.com/jwetzell/free-d-go v0.1.0/go.mod h1:KmrkooRARRaxJTBSPvwt/6IMAIaHH1R8bSA8cwbbELw=
+github.com/jwetzell/free-d-go v0.2.0/go.mod h1:yHuRy51NeDfN26eJ6wzZgys8qyQiS7hkYILw8yF+UJ4=
-github.com/jwetzell/osc-go v0.1.0 h1:EXxup5VWBErHot2Ri4MFToPf6KCzLDTbCt2x6GLfw8I=
+github.com/jwetzell/osc-go v0.3.0 h1:z75TxuQSEmdcmZ56OAepkDa3m88SdZh//3m4nBb/XZI=
-github.com/jwetzell/osc-go v0.1.0/go.mod h1:xLz0jTwebSxtx1TkKN1YVdeRqvpFNweDhTut5TE393A=
+github.com/jwetzell/osc-go v0.3.0/go.mod h1:kCs329JxY6Qjga08tRQ/Gl0PqhgQzLIMpOhm6uszvIc=
 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.19.0 h1:sXLILfc9jV2QYWkzFOPWStmcUVH2RHEB1JCdY2oVvCQ=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/compress v1.19.0/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8=
+github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
-github.com/nats-io/nats.go v1.48.0 h1:pSFyXApG+yWU/TgbKCjmm5K4wrHu86231/w84qRVR+U=
+github.com/minio/highwayhash v1.0.4 h1:asJizugGgchQod2ja9NJlGOWq4s7KsAWr5XUc9Clgl4=
-github.com/nats-io/nats.go v1.48.0/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g=
+github.com/minio/highwayhash v1.0.4/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
-github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0=
+github.com/nats-io/jwt/v2 v2.8.2 h1:XXRgB60MSTnqsRwejQurVDs/hcv2dkt+86GjI+I/bMc=
-github.com/nats-io/nkeys v0.4.11/go.mod h1:szDimtgmfOi9n25JpfIdGw12tZFYXqhGxjhVxsatHVE=
+github.com/nats-io/jwt/v2 v2.8.2/go.mod h1:Ag/56sq9OblL4JgdYufDd16Egb17Kr/8WwwuO/forVc=
+github.com/nats-io/nats-server/v2 v2.14.4 h1:efgjZ8cdExAKRuqSg8UPJFprb+l7NlBtSDPhDlw3rO4=
+github.com/nats-io/nats-server/v2 v2.14.4/go.mod h1:BltdpOYestjbtQSnVO2zGHdg5SGBZjt+GYTgB9LZq/I=
+github.com/nats-io/nats-server/v2 v2.14.5 h1:M6yeo/Xb7khi97RSEVELof3DForDqmYza3P4tHCPFWw=
+github.com/nats-io/nats-server/v2 v2.14.5/go.mod h1:1D3iocrisKvWaD1B/imqarTqmaGrWMqALMLbEDo3v7Q=
+github.com/nats-io/nats.go v1.52.0 h1:n3avV4VBsCgsdwh71TppsTwtv+QdPs7ntSKM8qJLGsc=
+github.com/nats-io/nats.go v1.52.0/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno=
+github.com/nats-io/nats.go v1.53.1 h1:Otsq3uLc/kLdjmkNHkXH0jBqwUquwdKFoe3fq6/3/Xo=
+github.com/nats-io/nats.go v1.53.1/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno=
+github.com/nats-io/nkeys v0.4.16 h1:rd5oAuLOb8mnAycB0xleuEBNS1pVVnN0fv/FF34Eypg=
+github.com/nats-io/nkeys v0.4.16/go.mod h1:llLgWoI0o4z/Q57q2R1kHfmocyhGV6VG/U18Glg1Afs=
 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 v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
-github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8=
 github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so=
 github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
 github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
 github.com/pion/rtcp v1.2.16 h1:fk1B1dNW4hsI78XUCljZJlC4kZOPk67mNRuQ0fcEkSo=
 github.com/pion/rtcp v1.2.16/go.mod h1:/as7VKfYbs5NIb4h6muQ35kQF/J0ZVNz2Z3xKoCBYOo=
-github.com/pion/rtp v1.8.26 h1:VB+ESQFQhBXFytD+Gk8cxB6dXeVf2WQzg4aORvAvAAc=
+github.com/pion/rtp v1.10.2 h1:l+f6tTDcAH6xwepaAoW791ddhuYsJlqRATOzirO04Mo=
-github.com/pion/rtp v1.8.26/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM=
+github.com/pion/rtp v1.10.2/go.mod h1:Au8fc6cEByy8RLTwKTQTEeQqDB/SJDxwL4mZuxYA5Pk=
-github.com/pion/srtp/v3 v3.0.9 h1:lRGF4G61xxj+m/YluB3ZnBpiALSri2lTzba0kGZMrQY=
+github.com/pion/srtp/v3 v3.0.10 h1:tFirkpBb3XccP5VEXLi50GqXhv5SKPxqrdlhDCJlZrQ=
-github.com/pion/srtp/v3 v3.0.9/go.mod h1:E+AuWd7Ug2Fp5u38MKnhduvpVkveXJX6J4Lq4rxUYt8=
+github.com/pion/srtp/v3 v3.0.10/go.mod h1:3mOTIB0cq9qlbn59V4ozvv9ClW/BSEbRp4cY0VtaR7M=
-github.com/pion/transport/v3 v3.1.1 h1:Tr684+fnnKlhPceU+ICdrw6KKkTms+5qHMgw6bIkYOM=
+github.com/pion/transport/v4 v4.0.1 h1:sdROELU6BZ63Ab7FrOLn13M6YdJLY20wldXW2Cu2k8o=
-github.com/pion/transport/v3 v3.1.1/go.mod h1:+c2eewC5WJQHiAA46fkMMzoYZSuGzA/7E2FPrOYHctQ=
+github.com/pion/transport/v4 v4.0.1/go.mod h1:nEuEA4AD5lPdcIegQDpVLgNoDGreqM/YqmEx3ovP4jM=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0=
+github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/urfave/cli/v3 v3.6.1 h1:j8Qq8NyUawj/7rTYdBGrxcH7A/j7/G8Q5LhWEW4G3Mo=
+github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834 h1:ZF+QBjOI+tILZjBaFj3HgFonKXUcwgJ4djLb6i42S3Q=
-github.com/urfave/cli/v3 v3.6.1/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
+github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834/go.mod h1:m9ymHTgNSEjuxvw8E7WWe4Pl4hZQHXONY8wE6dMLaRk=
+github.com/tetratelabs/wazero v1.11.0 h1:+gKemEuKCTevU4d7ZTzlsvgd1uaToIDtlQlmNbwqYhA=
+github.com/tetratelabs/wazero v1.11.0/go.mod h1:eV28rsN8Q+xwjogd7f4/Pp4xFxO7uOGbLcD/LzB1wiU=
+github.com/urfave/cli/v3 v3.10.1 h1:7Kx9H50hrHbRbyxgO1KP6/BcbiGRz0uYh5YyQ30JEEY=
+github.com/urfave/cli/v3 v3.10.1/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
+github.com/urfave/cli/v3 v3.11.0 h1:P/euJp99kb9p0tlVY+iYTLYYTAQlfl0hR2gUO1Img1Q=
+github.com/urfave/cli/v3 v3.11.0/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
 github.com/zaf/g711 v1.4.0 h1:XZYkjjiAg9QTBnHqEg37m2I9q3IIDv5JRYXs2N8ma7c=
 github.com/zaf/g711 v1.4.0/go.mod h1:eCDXt3dSp/kYYAoooba7ukD/Q75jvAaS4WOMr0l1Roo=
-gitlab.com/gomidi/midi/v2 v2.3.18 h1:sj2fOhtvOe+zI8YJe8qTxLw5zv0ntULLUDwcFOaZQbI=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
-gitlab.com/gomidi/midi/v2 v2.3.18/go.mod h1:jDpP4O4skYi+7iVwt6Zyp18bd2M4hkjtMuw2cmgKgfw=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
-go.bug.st/serial v1.6.4 h1:7FmqNPgVp3pu2Jz5PoPtbZ9jJO5gnEnZIvnI1lzve8A=
+gitlab.com/gomidi/midi/v2 v2.3.24 h1:afkq5nhlzKvZaj9QK80YbK8tH3lIlKLnPPP9HxxD7Do=
-go.bug.st/serial v1.6.4/go.mod h1:nofMJxTeNVny/m6+KaafC6vJGj3miwQZ6vW4BZUGJPI=
+gitlab.com/gomidi/midi/v2 v2.3.24/go.mod h1:jDpP4O4skYi+7iVwt6Zyp18bd2M4hkjtMuw2cmgKgfw=
+go.bug.st/serial v1.8.0 h1:ZtnmN8aYXtPlTghwSvDWPHKBHL9TM6oFDa+KpSn4SQE=
+go.bug.st/serial v1.8.0/go.mod h1:d0MmS16Qt9b1m06yoYRNUXhRRTJV5Qg2S5EKqQtnayQ=
+go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g=
+go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 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.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.3/go.mod h1:tBHosrYAkRZjRAOREWbDnBXUf08JOwYq++0QNwQiWzI=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
-golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
+golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
-golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
+golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M=
-golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
+golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis=
-golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=
+golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
-golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w=
+golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
-golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
+golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
+golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
-golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
-golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
+golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
-golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
+golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q=
+golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
@@ -110,32 +173,40 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
 gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
-modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=
+modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI=
-modernc.org/cc/v4 v4.27.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI=
-modernc.org/ccgo/v4 v4.30.1 h1:4r4U1J6Fhj98NKfSjnPUN7Ze2c6MnAdL0hWw6+LrJpc=
+modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU=
-modernc.org/ccgo/v4 v4.30.1/go.mod h1:bIOeI1JL54Utlxn+LwrFyjCx2n2RDiYEaJVSrgdrRfM=
+modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk=
-modernc.org/fileutil v1.3.40 h1:ZGMswMNc9JOCrcrakF1HrvmergNLAmxOPjizirpfqBA=
+modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
-modernc.org/fileutil v1.3.40/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
 modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
 modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
-modernc.org/gc/v3 v3.1.1 h1:k8T3gkXWY9sEiytKhcgyiZ2L0DTyCQ/nvX+LoCljoRE=
+modernc.org/gc/v3 v3.1.5 h1:21ldfPfRYE31Tb7B3mwAK8gy1AxP4+dKjrOQPfqakoc=
-modernc.org/gc/v3 v3.1.1/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
+modernc.org/gc/v3 v3.1.5/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
 modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
 modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
-modernc.org/libc v1.66.10 h1:yZkb3YeLx4oynyR+iUsXsybsX4Ubx7MQlSYEw4yj59A=
+modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k=
-modernc.org/libc v1.66.10/go.mod h1:8vGSEwvoUoltr4dlywvHqjtAqHBaw0j1jI7iFBTAr2I=
+modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co=
-modernc.org/libquickjs v0.12.2 h1:XtF6iD+aoN/pEz1MAQjg1wMZT412pzmOlO11UGLW/wQ=
+modernc.org/libc v1.75.3 h1:vCqT5+R0jPXMnvMkGo0T2zXvFNth+lYXVCx5X7CCX/g=
-modernc.org/libquickjs v0.12.2/go.mod h1:n+vyuJ4mXh1pQYt1bJttvoCE+2t+MqCM8BFlcSDg/70=
+modernc.org/libc v1.75.3/go.mod h1:MjAX68G+0oufI+hNuh0QXcK+Ap+sL8bNPPcIC6EqOfo=
+modernc.org/libquickjs v0.13.1 h1:uCb9AYyEyL1JS2dnKtLZKWH/vDb36cx1Mr1SIdbzb8A=
+modernc.org/libquickjs v0.13.1/go.mod h1:tCEsA1Zda1+C5JagFIJGqjYZOxDPFOUYjK3dGhEeq0g=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
 modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
-modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
+modernc.org/memory v1.12.0 h1:twkmYNkGXCvtYWzoux02jtK6eovjZbdI0uHFUYp6kuU=
-modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/memory v1.12.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
-modernc.org/quickjs v0.17.0 h1:gYZRSCKVokyOiHhZEKwran/NoBaGjAaWk+xJq52SWfQ=
+modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg=
-modernc.org/quickjs v0.17.0/go.mod h1:TE+wpAYX4V7Nvi/sHRUrd9l5L176ZIiS0as3MMObvC0=
+modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/quickjs v0.23.0 h1:k+px+rFrMqHm2LPMvrd+vCR+8m6eogiTkROz+YJHkj8=
+modernc.org/quickjs v0.23.0/go.mod h1:bFvjVk4JGlbqLYXVFt72YvwdnHbwtNIE9nQ+eh4fdi0=
+modernc.org/quickjs v0.24.0 h1:Vo7bkccDIstEmNf7umJPPVBaEmwoAo/8RX1ymVPmZQM=
+modernc.org/quickjs v0.24.0/go.mod h1:KYT0ACuCE+4eFnNc3WEZBUWfsFeIfsdtyDSltZz21iE=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
+modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0=
+modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ=
 modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
 modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
 modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=

internal/api/api.go

@@ -0,0 +1,278 @@
+package api
+
+import (
+	"context"
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/schema"
+)
+
+type ApiServer struct {
+	config             config.ApiConfig
+	serverMu           sync.Mutex
+	server             *http.Server
+	logger             *slog.Logger
+	configurableRouter config.Configurable
+	eventRouter        common.EventRouter
+}
+
+func NewApiServer(configurableRouter config.Configurable, eventRouter common.EventRouter) *ApiServer {
+	return &ApiServer{
+		configurableRouter: configurableRouter,
+		eventRouter:        eventRouter,
+		logger:             slog.Default().With("component", "api"),
+	}
+}
+
+func (as *ApiServer) Start(config config.ApiConfig) {
+	as.config = config
+	if !as.config.Enabled {
+		as.logger.Warn("not enabled")
+		return
+	}
+	as.logger.Debug("starting", "port", as.config.Port)
+	mux := http.NewServeMux()
+	mux.HandleFunc("/ws", as.handleWebsocket)
+	mux.HandleFunc("/health", as.handleHealthHTTP)
+	mux.HandleFunc("/api/v1/config", as.handleConfigHTTP)
+	mux.HandleFunc("/schema/config.schema.json", handleConfigSchema)
+	mux.HandleFunc("/schema/routes.schema.json", handleRoutesSchema)
+	mux.HandleFunc("/schema/modules.schema.json", handleModulesSchema)
+	mux.HandleFunc("/schema/processors.schema.json", handleProcessorsSchema)
+
+	as.serverMu.Lock()
+	defer as.serverMu.Unlock()
+	as.server = &http.Server{
+		Addr:              fmt.Sprintf(":%d", as.config.Port),
+		ReadHeaderTimeout: 5 * time.Second,
+		Handler:           mux,
+	}
+
+	go func() {
+		err := as.server.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			as.logger.Error("server error", "error", err)
+		}
+	}()
+}
+
+func (as *ApiServer) Stop() {
+	if as.server == nil {
+		return
+	}
+	as.serverMu.Lock()
+	defer as.serverMu.Unlock()
+	if as.server != nil {
+		apiShutdownCtx, apiShutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer apiShutdownCancel()
+		err := as.server.Shutdown(apiShutdownCtx)
+		if err != nil {
+			as.logger.Error("error shutting down server", "error", err)
+		}
+		as.server = nil
+	}
+	as.logger.Debug("done")
+}
+
+func (as *ApiServer) handleHealthHTTP(w http.ResponseWriter, req *http.Request) {
+	switch req.Method {
+	case http.MethodGet:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusOK)
+	case http.MethodOptions:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusMethodNotAllowed)
+	}
+}
+
+func (as *ApiServer) handleConfigHTTP(w http.ResponseWriter, req *http.Request) {
+
+	switch req.Method {
+	case http.MethodGet:
+		configJSON, err := json.Marshal(as.configurableRouter.GetRunningConfig())
+		if err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(configJSON)
+	case http.MethodPut:
+		//TODO(jwetzell): again way too much marshaling
+		cfgBytes, err := io.ReadAll(req.Body)
+		if err != nil {
+			http.Error(w, "Bad request", http.StatusBadRequest)
+			return
+		}
+		cfgMap := make(map[string]any)
+		err = json.Unmarshal(cfgBytes, &cfgMap)
+		if err != nil {
+			http.Error(w, "Bad request", http.StatusBadRequest)
+			return
+		}
+
+		err = schema.ApplyDefaults(&cfgMap)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		err = schema.ValidateConfig(cfgMap)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		validCfgBytes, err := json.Marshal(cfgMap)
+		if err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+
+		var newConfig config.Config
+		err = json.Unmarshal(validCfgBytes, &newConfig)
+		if err != nil {
+			http.Error(w, "Bad request", http.StatusBadRequest)
+			return
+		}
+		moduleErrors, routeErrors, err := as.configurableRouter.UpdateConfig(newConfig, true)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusConflict)
+			return
+		}
+		if len(moduleErrors) > 0 || len(routeErrors) > 0 {
+			errorResponse := struct {
+				ModuleErrors []config.ModuleError `json:"moduleErrors,omitempty"`
+				RouteErrors  []config.RouteError  `json:"routeErrors,omitempty"`
+			}{
+				ModuleErrors: moduleErrors,
+				RouteErrors:  routeErrors,
+			}
+			errorResponseJSON, err := json.Marshal(errorResponse)
+			if err != nil {
+				http.Error(w, "Internal server error", http.StatusInternalServerError)
+				return
+			}
+			w.Header().Set("Access-Control-Allow-Origin", "*")
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write(errorResponseJSON)
+			return
+		}
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusOK)
+	case http.MethodOptions:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, PUT, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusMethodNotAllowed)
+	}
+}
+
+func handleConfigSchema(w http.ResponseWriter, req *http.Request) {
+	switch req.Method {
+	case http.MethodGet:
+		schemaJSON, err := json.Marshal(schema.ConfigSchema)
+		if err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(schemaJSON)
+	case http.MethodOptions:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusMethodNotAllowed)
+	}
+}
+
+func handleRoutesSchema(w http.ResponseWriter, req *http.Request) {
+	switch req.Method {
+	case http.MethodGet:
+		schemaJSON, err := json.Marshal(schema.RoutesConfigSchema)
+		if err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(schemaJSON)
+	case http.MethodOptions:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusMethodNotAllowed)
+	}
+}
+
+func handleModulesSchema(w http.ResponseWriter, req *http.Request) {
+	switch req.Method {
+	case http.MethodGet:
+		schemaJSON, err := json.Marshal(schema.GetModulesSchema())
+		if err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(schemaJSON)
+	case http.MethodOptions:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusMethodNotAllowed)
+	}
+}
+
+func handleProcessorsSchema(w http.ResponseWriter, req *http.Request) {
+	switch req.Method {
+	case http.MethodGet:
+		schemaJSON, err := json.Marshal(schema.GetProcessorsSchema())
+		if err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(schemaJSON)
+	case http.MethodOptions:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusMethodNotAllowed)
+	}
+}

internal/api/websocket.go

@@ -0,0 +1,82 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/gorilla/websocket"
+	"github.com/jwetzell/showbridge-go/internal/common"
+)
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool {
+		return true
+	},
+}
+
+type WebsocketEventDestination struct {
+	conn *websocket.Conn
+}
+
+func (d WebsocketEventDestination) Send(event common.Event) error {
+	eventJSON, err := event.ToJSON()
+	if err != nil {
+		return err
+	}
+	return d.conn.WriteMessage(websocket.TextMessage, eventJSON)
+}
+
+func (d WebsocketEventDestination) Is(dest common.EventDestination) bool {
+	other, ok := dest.(WebsocketEventDestination)
+	if !ok {
+		return false
+	}
+	return d.conn == other.conn
+}
+
+func (as *ApiServer) handleWebsocket(w http.ResponseWriter, req *http.Request) {
+	conn, err := upgrader.Upgrade(w, req, nil)
+	if err != nil {
+		as.logger.Error("websocket upgrade error", "error", err)
+		return
+	}
+	defer conn.Close()
+
+	eventDestination := WebsocketEventDestination{conn: conn}
+
+	as.eventRouter.AddEventDestination(eventDestination)
+READ_LOOP:
+	for {
+		messageType, message, err := conn.ReadMessage()
+		if err != nil {
+			_, ok := err.(*websocket.CloseError)
+			if ok {
+				break READ_LOOP
+			}
+		}
+
+		switch messageType {
+		case websocket.TextMessage, websocket.BinaryMessage:
+			event := common.Event{}
+			err = json.Unmarshal(message, &event)
+			if err != nil {
+				as.logger.Error("websocket message unmarshal error", "error", err)
+				continue
+			}
+			as.eventRouter.HandleEvent(event, WebsocketEventDestination{conn: conn})
+		case websocket.CloseMessage:
+			break READ_LOOP
+		case websocket.PingMessage:
+			err = conn.WriteMessage(websocket.PongMessage, nil)
+			if err != nil {
+				as.logger.Error("websocket pong error", "error", err)
+			}
+		default:
+			as.logger.Warn("unsupported websocket message type", "type", messageType)
+			continue
+		}
+
+	}
+	//NOTE(jwetzell): remove ws connection
+	as.eventRouter.RemoveEventDestination(eventDestination)
+}

internal/common/common.go

@@ -0,0 +1,191 @@
+package common
+
+import (
+	"math"
+	"reflect"
+)
+
+func GetAnyAs[T any](value any) (T, bool) {
+	typed, ok := value.(T)
+	return typed, ok
+}
+
+func GetAnyAsInt(value any) (int, bool) {
+
+	intValue, ok := value.(int)
+	if ok {
+		return intValue, true
+	}
+
+	uintValue, ok := value.(uint)
+	if ok {
+		return int(uintValue), true
+	}
+
+	byteValue, ok := value.(byte)
+	if ok {
+		return int(byteValue), true
+	}
+
+	float32Value, ok := value.(float32)
+	if ok {
+		if float64(float32Value) != math.Floor(float64(float32Value)) {
+			return 0, false
+		}
+		return int(float32Value), true
+	}
+
+	float64Value, ok := value.(float64)
+	if ok {
+		if float64Value != math.Floor(float64Value) {
+			return 0, false
+		}
+		return int(float64Value), true
+	}
+	return 0, false
+}
+
+func GetAnyAsByte(value any) (byte, bool) {
+
+	byteValue, ok := value.(byte)
+	if ok {
+		return byte(byteValue), true
+	}
+
+	intValue, ok := value.(int)
+	if ok {
+		return byte(intValue), true
+	}
+
+	uintValue, ok := value.(uint)
+	if ok {
+		return byte(uintValue), true
+	}
+
+	float32Value, ok := value.(float32)
+	if ok {
+		if float64(float32Value) != math.Floor(float64(float32Value)) {
+			return 0, false
+		}
+		return byte(float32Value), true
+	}
+
+	float64Value, ok := value.(float64)
+	if ok {
+		if float64Value != math.Floor(float64Value) {
+			return 0, false
+		}
+		return byte(float64Value), true
+	}
+	return 0, false
+}
+
+func GetAnyAsByteSlice(value any) ([]byte, bool) {
+	// already a []byte
+	byteSlice, ok := value.([]byte)
+	if ok {
+		return byteSlice, true
+	}
+
+	// check for a slice
+	v := reflect.ValueOf(value)
+	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+		return nil, false
+	}
+
+	// try to convert each element to a byte
+	result := make([]byte, v.Len())
+	for i := 0; i < v.Len(); i++ {
+		elem := v.Index(i).Interface()
+		elemValue, ok := GetAnyAsByte(elem)
+		if !ok {
+			return nil, false
+		}
+		result[i] = elemValue
+	}
+	return result, true
+}
+
+func GetAnyAsIntSlice(value any) ([]int, bool) {
+
+	// already a []int
+	intSlice, ok := value.([]int)
+	if ok {
+		return intSlice, true
+	}
+
+	// check for a slice
+	v := reflect.ValueOf(value)
+	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+		return nil, false
+	}
+
+	result := make([]int, v.Len())
+	for i := 0; i < v.Len(); i++ {
+		elem := v.Index(i).Interface()
+		elemInt, ok := GetAnyAsInt(elem)
+		if !ok {
+			return nil, false
+		}
+		result[i] = elemInt
+	}
+	return result, true
+}
+
+func GetAnyAsFloat32(value any) (float32, bool) {
+	float32Value, ok := value.(float32)
+	if ok {
+		return float32Value, true
+	}
+
+	float64Value, ok := value.(float64)
+	if ok {
+		return float32(float64Value), true
+	}
+
+	intValue, ok := value.(int)
+	if ok {
+		return float32(intValue), true
+	}
+
+	uintValue, ok := value.(uint)
+	if ok {
+		return float32(uintValue), true
+	}
+
+	byteValue, ok := value.(byte)
+	if ok {
+		return float32(byteValue), true
+	}
+
+	return 0, false
+}
+
+func GetAnyAsFloat64(value any) (float64, bool) {
+	float64Value, ok := value.(float64)
+	if ok {
+		return float64Value, true
+	}
+
+	float32Value, ok := value.(float32)
+	if ok {
+		return float64(float32Value), true
+	}
+
+	intValue, ok := value.(int)
+	if ok {
+		return float64(intValue), true
+	}
+
+	uintValue, ok := value.(uint)
+	if ok {
+		return float64(uintValue), true
+	}
+
+	byteValue, ok := value.(byte)
+	if ok {
+		return float64(byteValue), true
+	}
+
+	return 0, false
+}

internal/common/common_test.go

@@ -0,0 +1,424 @@
+package common_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+)
+
+func TestGoodGetAnyAsInt(t *testing.T) {
+	testCases := []struct {
+		name       string
+		value      any
+		typedValue int
+	}{
+		{
+			name:       "int",
+			value:      int(42),
+			typedValue: 42,
+		},
+		{
+			name:       "uint",
+			value:      uint(42),
+			typedValue: 42,
+		},
+		{
+			name:       "float32 without decimal",
+			value:      float32(42.0),
+			typedValue: 42,
+		},
+		{
+			name:       "float64 without decimal",
+			value:      float64(42.0),
+			typedValue: 42,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsInt(testCase.value)
+			if !ok {
+				t.Fatalf("GetAnyAsInt expected to succeed but failed")
+			}
+			if value != testCase.typedValue {
+				t.Fatalf("GetAnyAsInt expected got %d,  expected %d", value, testCase.typedValue)
+			}
+		})
+	}
+}
+
+func TestBadGetAnyAsInt(t *testing.T) {
+	testCases := []struct {
+		name  string
+		value any
+	}{
+		{
+			name:  "string",
+			value: "value",
+		},
+		{
+			name:  "float32 with decimal",
+			value: float32(1.5),
+		},
+		{
+			name:  "float64 with decimal",
+			value: float64(1.5),
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsInt(testCase.value)
+			if ok {
+				t.Fatalf("GetAnyAsInt expected to fail but succeeded, got: %v", value)
+			}
+		})
+	}
+}
+
+func TestGoodGetAnyAsByte(t *testing.T) {
+	testCases := []struct {
+		name       string
+		value      any
+		typedValue byte
+	}{
+		{
+			name:       "int",
+			value:      int(42),
+			typedValue: 42,
+		},
+		{
+			name:       "uint",
+			value:      uint(42),
+			typedValue: 42,
+		},
+		{
+			name:       "float32 without decimal",
+			value:      float32(42.0),
+			typedValue: 42,
+		},
+		{
+			name:       "float64 without decimal",
+			value:      float64(42.0),
+			typedValue: 42,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsByte(testCase.value)
+			if !ok {
+				t.Fatalf("GetAnyAsByte expected to succeed but failed")
+			}
+			if value != testCase.typedValue {
+				t.Fatalf("GetAnyAsByte expected got %d,  expected %d", value, testCase.typedValue)
+			}
+		})
+	}
+}
+
+func TestBadGetAnyAsByte(t *testing.T) {
+	testCases := []struct {
+		name  string
+		value any
+	}{
+		{
+			name:  "string",
+			value: "value",
+		},
+		{
+			name:  "float32 with decimal",
+			value: float32(1.5),
+		},
+		{
+			name:  "float64 with decimal",
+			value: float64(1.5),
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsByte(testCase.value)
+			if ok {
+				t.Fatalf("GetAnyAsByte expected to fail but succeeded, got: %v", value)
+			}
+		})
+	}
+}
+
+func TestGoodGetAnyAsByteSlice(t *testing.T) {
+	testCases := []struct {
+		name       string
+		value      any
+		typedValue []byte
+	}{
+		{
+			name:       "byte slice",
+			value:      []byte{1, 2, 3},
+			typedValue: []byte{1, 2, 3},
+		},
+		{
+			name:       "int slice",
+			value:      []int{1, 2, 3},
+			typedValue: []byte{1, 2, 3},
+		},
+		{
+			name:       "uint slice",
+			value:      []uint{1, 2, 3},
+			typedValue: []byte{1, 2, 3},
+		},
+		{
+			name:       "float32 without decimal slice",
+			value:      []float32{1, 2, 3},
+			typedValue: []byte{1, 2, 3},
+		},
+		{
+			name:       "float64 without decimal slice",
+			value:      []float64{1, 2, 3},
+			typedValue: []byte{1, 2, 3},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsByteSlice(testCase.value)
+			if !ok {
+				t.Fatalf("GetAnyAsByteSlice expected to succeed but failed")
+			}
+			if !slices.Equal(value, testCase.typedValue) {
+				t.Fatalf("GetAnyAsByteSlice expected got %d,  expected %d", value, testCase.typedValue)
+			}
+		})
+	}
+}
+
+func TestBadGetAnyAsByteSlice(t *testing.T) {
+	testCases := []struct {
+		name  string
+		value any
+	}{
+		{
+			name:  "not a slice",
+			value: "value",
+		},
+		{
+			name:  "not a int slice",
+			value: []any{"value1", 2},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsByteSlice(testCase.value)
+			if ok {
+				t.Fatalf("GetAnyAsByteSlice expected to fail but succeeded, got: %v", value)
+			}
+		})
+	}
+}
+
+func TestGoodGetAnyAsIntSlice(t *testing.T) {
+	testCases := []struct {
+		name       string
+		value      any
+		typedValue []int
+	}{
+		{
+			name:       "int slice",
+			value:      []int{1, 2, 3},
+			typedValue: []int{1, 2, 3},
+		},
+		{
+			name:       "byte slice",
+			value:      []byte{1, 2, 3},
+			typedValue: []int{1, 2, 3},
+		},
+		{
+			name:       "uint slice",
+			value:      []uint{1, 2, 3},
+			typedValue: []int{1, 2, 3},
+		},
+		{
+			name:       "float32 without decimal slice",
+			value:      []float32{1, 2, 3},
+			typedValue: []int{1, 2, 3},
+		},
+		{
+			name:       "float64 without decimal slice",
+			value:      []float64{1, 2, 3},
+			typedValue: []int{1, 2, 3},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsIntSlice(testCase.value)
+			if !ok {
+				t.Fatalf("GetAnyAsIntSlice expected to succeed but failed")
+			}
+			if !slices.Equal(value, testCase.typedValue) {
+				t.Fatalf("GetAnyAsIntSlice expected got %d,  expected %d", value, testCase.typedValue)
+			}
+		})
+	}
+}
+
+func TestBadGetAnyAsIntSlice(t *testing.T) {
+	testCases := []struct {
+		name  string
+		value any
+	}{
+		{
+			name:  "not a slice",
+			value: "value",
+		},
+		{
+			name:  "not a int slice",
+			value: []any{"value1", 2},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsIntSlice(testCase.value)
+			if ok {
+				t.Fatalf("GetAnyAsIntSlice expected to fail but succeeded, got: %v", value)
+			}
+		})
+	}
+}
+
+func TestGoodGetAnyAsFloat32(t *testing.T) {
+	testCases := []struct {
+		name       string
+		value      any
+		typedValue float32
+	}{
+		{
+			name:       "int",
+			value:      int(42),
+			typedValue: 42,
+		},
+		{
+			name:       "uint",
+			value:      uint(42),
+			typedValue: 42,
+		},
+		{
+			name:       "byte",
+			value:      byte(42),
+			typedValue: 42,
+		},
+		{
+			name:       "float32",
+			value:      float32(42.3),
+			typedValue: 42.3,
+		},
+		{
+			name:       "float64",
+			value:      float64(42.3),
+			typedValue: 42.3,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsFloat32(testCase.value)
+			if !ok {
+				t.Fatalf("GetAnyAsFloat32 expected to succeed but failed")
+			}
+			if value != testCase.typedValue {
+				t.Fatalf("GetAnyAsFloat32 expected got %f,  expected %f", value, testCase.typedValue)
+			}
+		})
+	}
+}
+
+func TestBadGetAnyAsFloat32(t *testing.T) {
+	testCases := []struct {
+		name  string
+		value any
+	}{
+		{
+			name:  "string",
+			value: "value",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsFloat32(testCase.value)
+			if ok {
+				t.Fatalf("GetAnyAsFloat32 expected to fail but succeeded, got: %v", value)
+			}
+		})
+	}
+}
+
+func TestGoodGetAnyAsFloat64(t *testing.T) {
+	testCases := []struct {
+		name       string
+		value      any
+		typedValue float64
+	}{
+		{
+			name:       "int",
+			value:      int(42),
+			typedValue: 42,
+		},
+		{
+			name:       "uint",
+			value:      uint(42),
+			typedValue: 42,
+		},
+		{
+			name:       "byte",
+			value:      byte(42),
+			typedValue: 42,
+		},
+		{
+			name:       "float32",
+			value:      float32(42.5),
+			typedValue: 42.5,
+		},
+		{
+			name:       "float64",
+			value:      float64(42.5),
+			typedValue: 42.5,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsFloat64(testCase.value)
+			if !ok {
+				t.Fatalf("GetAnyAsFloat64 expected to succeed but failed")
+			}
+			if value != testCase.typedValue {
+				t.Fatalf("GetAnyAsFloat64 expected got %f,  expected %f", value, testCase.typedValue)
+			}
+		})
+	}
+}
+
+func TestBadGetAnyAsFloat64(t *testing.T) {
+	testCases := []struct {
+		name  string
+		value any
+	}{
+		{
+			name:  "string",
+			value: "value",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			value, ok := common.GetAnyAsFloat64(testCase.value)
+			if ok {
+				t.Fatalf("GetAnyAsFloat64 expected to fail but succeeded, got: %v", value)
+			}
+		})
+	}
+}

internal/common/events.go

@@ -0,0 +1,26 @@
+package common
+
+import (
+	"encoding/json"
+)
+
+type Event struct {
+	Type  string `json:"type"`
+	Data  any    `json:"data,omitempty"`
+	Error string `json:"error,omitempty"`
+}
+
+func (e Event) ToJSON() ([]byte, error) {
+	return json.Marshal(e)
+}
+
+type EventDestination interface {
+	Send(event Event) error
+	Is(dest EventDestination) bool
+}
+
+type EventRouter interface {
+	HandleEvent(event Event, source EventDestination)
+	AddEventDestination(dest EventDestination)
+	RemoveEventDestination(dest EventDestination)
+}

internal/common/events_test.go

@@ -0,0 +1,24 @@
+package common_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+)
+
+func TestEventToJson(t *testing.T) {
+	e := common.Event{
+		Type: "test.event",
+		Data: map[string]any{
+			"key": "value",
+		},
+	}
+	jsonData, err := e.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert event to JSON: %v", err)
+	}
+	expectedJson := `{"type":"test.event","data":{"key":"value"}}`
+	if string(jsonData) != expectedJson {
+		t.Errorf("Expected JSON: %s, got: %s", expectedJson, string(jsonData))
+	}
+}

internal/common/module.go

@@ -0,0 +1,30 @@
+package common
+
+import (
+	"context"
+	"database/sql"
+)
+
+type Module interface {
+	Id() string
+	Type() string
+	Start(context.Context, InputHandler) error
+	Stop()
+}
+
+type OutputModule interface {
+	Output(context.Context, any) error
+}
+
+type KeyValueModule interface {
+	Get(ctx context.Context, key string) (any, error)
+	Set(ctx context.Context, key string, value any) error
+}
+
+type DatabaseModule interface {
+	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
+}
+
+type PubSubModule interface {
+	Publish(ctx context.Context, topic string, payload any) error
+}

internal/common/payload.go

@@ -0,0 +1,9 @@
+package common
+
+type WrappedPayload struct {
+	Payload      any
+	InputHandler InputHandler
+	Modules      map[string]Module
+	Source       string
+	End          bool
+}

internal/common/routing.go

@@ -0,0 +1,12 @@
+package common
+
+import (
+	"context"
+)
+
+type InputHandler func(ctx context.Context, sourceId string, payload any) (bool, []RouteIOError)
+
+type RouteIOError struct {
+	Index        int   `json:"index"`
+	ProcessError error `json:"processError"`
+}

internal/config/api.go

@@ -0,0 +1,6 @@
+package config
+
+type ApiConfig struct {
+	Enabled bool `json:"enabled"`
+	Port    int  `json:"port"`
+}

internal/config/config.go

@@ -1,23 +1,12 @@
 package config
 
 type Config struct {
+	Api     ApiConfig      `json:"api"`
 	Modules []ModuleConfig `json:"modules"`
 	Routes  []RouteConfig  `json:"routes"`
 }
 
-type ModuleConfig struct {
+type Configurable interface {
-	Id     string         `json:"id"`
+	UpdateConfig(newConfig Config, triggerChangeChannel bool) ([]ModuleError, []RouteError, error)
-	Type   string         `json:"type"`
+	GetRunningConfig() Config
-	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/config/module.go

@@ -0,0 +1,13 @@
+package config
+
+type ModuleConfig struct {
+	Id     string `json:"id"`
+	Type   string `json:"type"`
+	Params Params `json:"params,omitempty"`
+}
+
+type ModuleError struct {
+	Index  int          `json:"index"`
+	Config ModuleConfig `json:"config"`
+	Error  string       `json:"error"`
+}

internal/config/params.go

@@ -0,0 +1,140 @@
+package config
+
+import (
+	"errors"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+)
+
+type Params map[string]any
+
+var (
+	ErrParamNotFound       = errors.New("not found")
+	ErrParamNotString      = errors.New("not a string")
+	ErrParamNotNumber      = errors.New("not a number")
+	ErrParamNotInteger     = errors.New("not an integer")
+	ErrParamNotBool        = errors.New("not a boolean")
+	ErrParamNotSlice       = errors.New("not a slice")
+	ErrParamNotStringSlice = errors.New("not a string slice")
+	ErrParamNotByteSlice   = errors.New("not a byte slice")
+	ErrParamNotIntSlice    = errors.New("not an int slice")
+)
+
+func (p Params) GetString(key string) (string, error) {
+	value, ok := p[key]
+	if !ok {
+		return "", ErrParamNotFound
+	}
+
+	stringValue, ok := value.(string)
+	if !ok {
+		return "", ErrParamNotString
+	}
+	return stringValue, nil
+}
+
+func (p Params) GetInt(key string) (int, error) {
+	value, ok := p[key]
+	if !ok {
+		return 0, ErrParamNotFound
+	}
+
+	intValue, ok := common.GetAnyAsInt(value)
+	if ok {
+		return intValue, nil
+	}
+
+	return 0, ErrParamNotNumber
+}
+
+func (p Params) GetFloat32(key string) (float32, error) {
+	value, ok := p[key]
+	if !ok {
+		return 0, ErrParamNotFound
+	}
+
+	floatValue, ok := common.GetAnyAsFloat32(value)
+	if ok {
+		return floatValue, nil
+	}
+
+	return 0, ErrParamNotNumber
+}
+
+func (p Params) GetFloat64(key string) (float64, error) {
+	value, ok := p[key]
+	if !ok {
+		return 0, ErrParamNotFound
+	}
+
+	floatValue, ok := common.GetAnyAsFloat64(value)
+	if ok {
+		return floatValue, nil
+	}
+
+	return 0, ErrParamNotNumber
+}
+
+func (p Params) GetBool(key string) (bool, error) {
+	value, ok := p[key]
+	if !ok {
+		return false, ErrParamNotFound
+	}
+
+	boolValue, ok := value.(bool)
+	if !ok {
+		return false, ErrParamNotBool
+	}
+	return boolValue, nil
+}
+
+func (p Params) GetStringSlice(key string) ([]string, error) {
+	value, ok := p[key]
+	if !ok {
+		return nil, ErrParamNotFound
+	}
+
+	interfaceSlice, ok := value.([]any)
+	if !ok {
+		return nil, ErrParamNotSlice
+	}
+
+	stringSlice := make([]string, len(interfaceSlice))
+	for i, v := range interfaceSlice {
+		str, ok := v.(string)
+		if !ok {
+			return nil, ErrParamNotStringSlice
+		}
+		stringSlice[i] = str
+	}
+	return stringSlice, nil
+}
+
+func (p Params) GetIntSlice(key string) ([]int, error) {
+	value, ok := p[key]
+	if !ok {
+		return nil, ErrParamNotFound
+	}
+
+	intSlice, ok := common.GetAnyAsIntSlice(value)
+	if !ok {
+		return nil, ErrParamNotIntSlice
+	}
+
+	return intSlice, nil
+}
+
+func (p Params) GetByteSlice(key string) ([]byte, error) {
+	value, ok := p[key]
+	if !ok {
+		return nil, ErrParamNotFound
+	}
+
+	byteSlice, ok := common.GetAnyAsByteSlice(value)
+
+	if !ok {
+		return nil, ErrParamNotByteSlice
+	}
+
+	return byteSlice, nil
+}

internal/config/params_test.go

@@ -0,0 +1,628 @@
+package config_test
+
+import (
+	"encoding/json"
+	"errors"
+	"slices"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+func TestGoodStringParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   string
+	}{
+		{
+			name:       "string param",
+			paramsJSON: `{"key": "value"}`,
+			key:        "key",
+			expected:   "value",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetString(testCase.key)
+			if err != nil {
+				t.Fatalf("GetString returned error: %v", err)
+			}
+			if value != testCase.expected {
+				t.Fatalf("GetString	 got %s, expected %s", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadStringParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": "value"}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a string",
+			paramsJSON:  `{"key": 1}`,
+			key:         "key",
+			returnError: config.ErrParamNotString,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetString(testCase.key)
+			if err == nil {
+				t.Fatalf("GetString expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetString got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}
+
+func TestGoodIntParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   int
+	}{
+		{
+			name:       "int param",
+			paramsJSON: `{"key": 1}`,
+			key:        "key",
+			expected:   1,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetInt(testCase.key)
+			if err != nil {
+				t.Fatalf("GetInt returned error: %v", err)
+			}
+			if value != testCase.expected {
+				t.Fatalf("GetInt got %d, expected %d", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadIntParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": 1}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a number",
+			paramsJSON:  `{"key": "1"}`,
+			key:         "key",
+			returnError: config.ErrParamNotNumber,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetInt(testCase.key)
+			if err == nil {
+				t.Fatalf("GetInt expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetInt got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}
+
+func TestGoodFloat32ParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   float32
+	}{
+		{
+			name:       "no decimal param",
+			paramsJSON: `{"key": 1}`,
+			key:        "key",
+			expected:   1,
+		},
+		{
+			name:       "float param",
+			paramsJSON: `{"key": 1.23}`,
+			key:        "key",
+			expected:   1.23,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetFloat32(testCase.key)
+			if err != nil {
+				t.Fatalf("GetFloat32 returned error: %v", err)
+			}
+			if value != testCase.expected {
+				t.Fatalf("GetFloat32 got %f, expected %f", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadFloat32ParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": 1}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a number",
+			paramsJSON:  `{"key": "1"}`,
+			key:         "key",
+			returnError: config.ErrParamNotNumber,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetFloat32(testCase.key)
+			if err == nil {
+				t.Fatalf("GetFloat32 expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetFloat32 got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}
+
+func TestGoodFloat64ParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   float64
+	}{
+		{
+			name:       "no decimal param",
+			paramsJSON: `{"key": 1}`,
+			key:        "key",
+			expected:   1,
+		},
+		{
+			name:       "float param",
+			paramsJSON: `{"key": 1.23}`,
+			key:        "key",
+			expected:   1.23,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetFloat64(testCase.key)
+			if err != nil {
+				t.Fatalf("GetFloat64 returned error: %v", err)
+			}
+			if value != testCase.expected {
+				t.Fatalf("GetFloat64 got %f, expected %f", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadFloat64ParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": 1}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a number",
+			paramsJSON:  `{"key": "1"}`,
+			key:         "key",
+			returnError: config.ErrParamNotNumber,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetFloat64(testCase.key)
+			if err == nil {
+				t.Fatalf("GetFloat64 expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetFloat64 got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}
+
+func TestGoodBoolParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   bool
+	}{
+		{
+			name:       "bool param",
+			paramsJSON: `{"key": true}`,
+			key:        "key",
+			expected:   true,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetBool(testCase.key)
+			if err != nil {
+				t.Fatalf("GetBool returned error: %v", err)
+			}
+			if value != testCase.expected {
+				t.Fatalf("GetBool got %t, expected %t", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadBoolParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": 1}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a bool",
+			paramsJSON:  `{"key": "1"}`,
+			key:         "key",
+			returnError: config.ErrParamNotBool,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetBool(testCase.key)
+			if err == nil {
+				t.Fatalf("GetBool expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetBool got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}
+
+func TestGoodStringSliceParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   []string
+	}{
+		{
+			name:       "string array",
+			paramsJSON: `{"key": ["value1", "value2"]}`,
+			key:        "key",
+			expected:   []string{"value1", "value2"},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetStringSlice(testCase.key)
+			if err != nil {
+				t.Fatalf("GetStringSlice returned error: %v", err)
+			}
+			if !slices.Equal(value, testCase.expected) {
+				t.Fatalf("GetStringSlice got %v, expected %v", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadStringSliceParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": ["value1", "value2"]}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a slice",
+			paramsJSON:  `{"key": "value"}`,
+			key:         "key",
+			returnError: config.ErrParamNotSlice,
+		},
+		{
+			name:        "not a string slice",
+			paramsJSON:  `{"key": ["value1", 2]}`,
+			key:         "key",
+			returnError: config.ErrParamNotStringSlice,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetStringSlice(testCase.key)
+			if err == nil {
+				t.Fatalf("GetStringSlice expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetStringSlice got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}
+
+func TestGoodIntSliceParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   []int
+	}{
+		{
+			name:       "int array",
+			paramsJSON: `{"key": [1, 2, 3]}`,
+			key:        "key",
+			expected:   []int{1, 2, 3},
+		},
+		{
+			name:       "int array with floats",
+			paramsJSON: `{"key": [1.0, 2.0, 3.0]}`,
+			key:        "key",
+			expected:   []int{1, 2, 3},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetIntSlice(testCase.key)
+			if err != nil {
+				t.Fatalf("GetIntSlice returned error: %v", err)
+			}
+			if !slices.Equal(value, testCase.expected) {
+				t.Fatalf("GetIntSlice got %v, expected %v", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadIntSliceParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": ["value1", "value2"]}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a slice",
+			paramsJSON:  `{"key": "value"}`,
+			key:         "key",
+			returnError: config.ErrParamNotIntSlice,
+		},
+		{
+			name:        "not a int slice",
+			paramsJSON:  `{"key": ["value1", 2]}`,
+			key:         "key",
+			returnError: config.ErrParamNotIntSlice,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetIntSlice(testCase.key)
+			if err == nil {
+				t.Fatalf("GetIntSlice expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetIntSlice got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}
+
+func TestGoodByteSliceParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name       string
+		paramsJSON string
+		key        string
+		expected   []byte
+	}{
+		{
+			name:       "byte array",
+			paramsJSON: `{"key": [1,2,3,4]}`,
+			key:        "key",
+			expected:   []byte{1, 2, 3, 4},
+		},
+		{
+			name:       "byte array with floats",
+			paramsJSON: `{"key": [1.0,2.0,3.0,4.0]}`,
+			key:        "key",
+			expected:   []byte{1, 2, 3, 4},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetByteSlice(testCase.key)
+			if err != nil {
+				t.Fatalf("GetByteSlice returned error: %v", err)
+			}
+			if !slices.Equal(value, testCase.expected) {
+				t.Fatalf("GetByteSlice got %v, expected %v", value, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadByteSliceParamsJSON(t *testing.T) {
+	testCases := []struct {
+		name        string
+		paramsJSON  string
+		key         string
+		returnError error
+	}{
+		{
+			name:        "key not found",
+			paramsJSON:  `{"key": ["value1", "value2"]}`,
+			key:         "test",
+			returnError: config.ErrParamNotFound,
+		},
+		{
+			name:        "not a slice",
+			paramsJSON:  `{"key": "value"}`,
+			key:         "key",
+			returnError: config.ErrParamNotByteSlice,
+		},
+		{
+			name:        "not a int slice",
+			paramsJSON:  `{"key": ["value1", 2]}`,
+			key:         "key",
+			returnError: config.ErrParamNotByteSlice,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			params := config.Params{}
+			err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal params JSON: %v", err)
+			}
+			value, err := params.GetByteSlice(testCase.key)
+			if err == nil {
+				t.Fatalf("GetByteSlice expected to fail but succeeded, got: %v", value)
+			}
+			if !errors.Is(err, testCase.returnError) {
+				t.Fatalf("GetByteSlice got error '%s', expected '%s'", err, testCase.returnError)
+			}
+		})
+	}
+}

internal/config/processor.go

@@ -0,0 +1,7 @@
+package config
+
+type ProcessorConfig struct {
+	Id     string `json:"id"`
+	Type   string `json:"type"`
+	Params Params `json:"params,omitempty"`
+}

internal/config/route.go

@@ -0,0 +1,13 @@
+package config
+
+type RouteConfig struct {
+	Id         string            `json:"id"`
+	Input      string            `json:"input"`
+	Processors []ProcessorConfig `json:"processors"`
+}
+
+type RouteError struct {
+	Index  int         `json:"index"`
+	Config RouteConfig `json:"config"`
+	Error  string      `json:"error"`
+}

internal/framer/framer.go

@@ -10,15 +10,15 @@ type Framer interface {
 func GetFramer(framingType string) Framer {
 	switch framingType {
 	case "CR":
-		return NewByteSeparatorFramer([]byte{'\r'})
+		return newByteSeparatorFramer([]byte{'\r'})
 	case "LF":
-		return NewByteSeparatorFramer([]byte{'\n'})
+		return newByteSeparatorFramer([]byte{'\n'})
 	case "CRLF":
-		return NewByteSeparatorFramer([]byte{'\r', '\n'})
+		return newByteSeparatorFramer([]byte{'\r', '\n'})
 	case "SLIP":
-		return NewSlipFramer()
+		return newSlipFramer()
 	case "RAW":
-		return NewRawFramer()
+		return newRawFramer()
 	default:
 		return nil
 	}

internal/framer/raw.go

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

internal/framer/separator.go

@@ -4,16 +4,16 @@ import (
 	"bytes"
 )
 
-type ByteSeparatorFramer struct {
+type byteSeparatorFramer struct {
 	buffer    []byte
 	separator []byte
 }
 
-func NewByteSeparatorFramer(separator []byte) *ByteSeparatorFramer {
+func newByteSeparatorFramer(separator []byte) *byteSeparatorFramer {
-	return &ByteSeparatorFramer{separator: separator, buffer: []byte{}}
+	return &byteSeparatorFramer{separator: separator, buffer: []byte{}}
 }
 
-func (bsf *ByteSeparatorFramer) Decode(data []byte) [][]byte {
+func (bsf *byteSeparatorFramer) Decode(data []byte) [][]byte {
 	messages := [][]byte{}
 
 	bsf.buffer = append(bsf.buffer, data...)
@@ -28,14 +28,14 @@ func (bsf *ByteSeparatorFramer) Decode(data []byte) [][]byte {
 	return messages
 }
 
-func (bsf *ByteSeparatorFramer) Encode(data []byte) []byte {
+func (bsf *byteSeparatorFramer) Encode(data []byte) []byte {
 	return append(data, bsf.separator...)
 }
 
-func (bsf *ByteSeparatorFramer) Clear() {
+func (bsf *byteSeparatorFramer) Clear() {
 	bsf.buffer = []byte{}
 }
 
-func (bsf *ByteSeparatorFramer) Buffer() []byte {
+func (bsf *byteSeparatorFramer) Buffer() []byte {
 	return bsf.buffer
 }

internal/framer/slip.go

@@ -1,14 +1,14 @@
 package framer
 
-type SlipFramer struct {
+type slipFramer struct {
 	buffer []byte
 }
 
-func NewSlipFramer() *SlipFramer {
+func newSlipFramer() *slipFramer {
-	return &SlipFramer{buffer: []byte{}}
+	return &slipFramer{buffer: []byte{}}
 }
 
-func (sf *SlipFramer) Decode(data []byte) [][]byte {
+func (sf *slipFramer) Decode(data []byte) [][]byte {
 	messages := [][]byte{}
 
 	END := byte(0xc0)
@@ -25,9 +25,10 @@ func (sf *SlipFramer) Decode(data []byte) [][]byte {
 		}
 
 		if escapeNext {
-			if packetByte == ESC_END {
+			switch packetByte {
+			case ESC_END:
 				sf.buffer = append(sf.buffer, END)
-			} else if packetByte == ESC_ESC {
+			case ESC_ESC:
 				sf.buffer = append(sf.buffer, ESC)
 			}
 			escapeNext = false
@@ -48,7 +49,7 @@ func (sf *SlipFramer) Decode(data []byte) [][]byte {
 	return messages
 }
 
-func (sf *SlipFramer) Encode(data []byte) []byte {
+func (sf *slipFramer) Encode(data []byte) []byte {
 	END := byte(0xc0)
 	ESC := byte(0xdb)
 	ESC_END := byte(0xdc)
@@ -71,10 +72,10 @@ func (sf *SlipFramer) Encode(data []byte) []byte {
 	return encodedBytes
 }
 
-func (sf *SlipFramer) Clear() {
+func (sf *slipFramer) Clear() {
 	sf.buffer = []byte{}
 }
 
-func (sf *SlipFramer) Buffer() []byte {
+func (sf *slipFramer) Buffer() []byte {
 	return sf.buffer
 }

internal/module/db-sqlite.go

@@ -0,0 +1,103 @@
+package module
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"log/slog"
+	"sync"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+
+	_ "modernc.org/sqlite"
+)
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "db.sqlite",
+		Title: "SQLite Database",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"dsn": {
+					Title:       "Data Source Name",
+					Description: "the data source name (DSN) for the SQLite database",
+					Type:        "string",
+					MinLength:   new(1),
+				},
+			},
+			Required:             []string{"dsn"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			params := config.Params
+
+			dsnString, err := params.GetString("dsn")
+			if err != nil {
+				return nil, fmt.Errorf("db.sqlite dsn error: %w", err)
+			}
+
+			return &DbSqlite{Dsn: dsnString, config: config, logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
+type DbSqlite struct {
+	config       config.ModuleConfig
+	Dsn          string
+	ctx          context.Context
+	inputHandler common.InputHandler
+	db           *sql.DB
+	logger       *slog.Logger
+	dbMu         sync.Mutex
+	cancel       context.CancelFunc
+}
+
+func (dbs *DbSqlite) Id() string {
+	return dbs.config.Id
+}
+
+func (dbs *DbSqlite) Type() string {
+	return dbs.config.Type
+}
+
+func (dbs *DbSqlite) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	dbs.logger.Debug("running")
+	dbs.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	dbs.ctx = moduleContext
+	dbs.cancel = cancel
+
+	db, err := sql.Open("sqlite", dbs.Dsn)
+	if err != nil {
+		return fmt.Errorf("db.sqlite error opening database: %w", err)
+	}
+	dbs.dbMu.Lock()
+	dbs.db = db
+	dbs.dbMu.Unlock()
+	<-dbs.ctx.Done()
+	dbs.logger.Debug("done")
+	return nil
+}
+
+func (dbs *DbSqlite) Stop() {
+	if dbs.cancel != nil {
+		defer dbs.cancel()
+	}
+	dbs.dbMu.Lock()
+	defer dbs.dbMu.Unlock()
+	if dbs.db != nil {
+		dbs.db.Close()
+	}
+}
+
+func (dbs *DbSqlite) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error) {
+	dbs.dbMu.Lock()
+	defer dbs.dbMu.Unlock()
+	if dbs.db == nil {
+		return nil, fmt.Errorf("database not initialized")
+	}
+	return dbs.db.QueryContext(ctx, query, args...)
+}

internal/module/http-client.go

@@ -1,80 +0,0 @@
-package module
-
-import (
-	"context"
-	"errors"
-	"log/slog"
-	"net/http"
-	"time"
-
-	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/route"
-)
-
-type HTTPClient struct {
-	config config.ModuleConfig
-	ctx    context.Context
-	client *http.Client
-	router route.RouteIO
-	logger *slog.Logger
-}
-
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "http.client",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("http.client unable to get router from context")
-			}
-
-			return &HTTPClient{config: config, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
-		},
-	})
-}
-
-func (hc *HTTPClient) Id() string {
-	return hc.config.Id
-}
-
-func (hc *HTTPClient) Type() string {
-	return hc.config.Type
-}
-
-func (hc *HTTPClient) Run() error {
-
-	hc.client = &http.Client{
-		Timeout: 10 * time.Second,
-	}
-
-	<-hc.ctx.Done()
-	hc.logger.Debug("done")
-	return nil
-}
-
-func (hc *HTTPClient) Output(ctx context.Context, payload any) error {
-
-	payloadRequest, ok := payload.(*http.Request)
-
-	if !ok {
-		return errors.New("http.client is only able to output an http.Request")
-	}
-
-	if hc.client == nil {
-		return errors.New("http.client client is nil")
-	}
-
-	response, err := hc.client.Do(payloadRequest)
-
-	if err != nil {
-		return err
-	}
-
-	if hc.router != nil {
-		hc.router.HandleInput(hc.ctx, hc.Id(), response)
-	}
-
-	return nil
-}

internal/module/http-server.go

@@ -7,25 +7,58 @@ import (
 	"fmt"
 	"log/slog"
 	"net/http"
+	"sync"
+	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"github.com/jwetzell/showbridge-go/internal/processor"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "http.server",
+		Title: "HTTP Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title:       "Port",
+					Description: "the port for the HTTP server to listen on",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1024),
+					Maximum:     jsonschema.Ptr[float64](65535),
+				},
+			},
+			Required:             []string{"port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			params := config.Params
+			portNum, err := params.GetInt("port")
+			if err != nil {
+				return nil, fmt.Errorf("http.server port error: %w", err)
+			}
+			return &HTTPServer{Port: uint16(portNum), config: config, logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
 type HTTPServer struct {
 	config       config.ModuleConfig
 	Port         uint16
 	ctx          context.Context
-	router route.RouteIO
+	inputHandler common.InputHandler
 	logger       *slog.Logger
+	cancel       context.CancelFunc
+	server       *http.Server
+	serverMu     sync.Mutex
 }
 
 type ResponseIOError struct {
 	Index        int     `json:"index"`
-	OutputErrors []string `json:"outputErrors"`
 	ProcessError *string `json:"processError"`
-	InputError   *string  `json:"inputError"`
 }
 
 type IOResponseData struct {
@@ -51,33 +84,6 @@ func (hsrw *HTTPServerResponseWriter) Write(data []byte) (int, error) {
 	return hsrw.ResponseWriter.Write(data)
 }
 
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "http.server",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			params := config.Params
-			port, ok := params["port"]
-			if !ok {
-				return nil, errors.New("http.server requires a port parameter")
-			}
-
-			portNum, ok := port.(float64)
-
-			if !ok {
-				return nil, errors.New("http.server port must be uint16")
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("http.server unable to get router from context")
-			}
-
-			return &HTTPServer{Port: uint16(portNum), config: config, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
-		},
-	})
-}
-
 func (hs *HTTPServer) Id() string {
 	return hs.config.Id
 }
@@ -93,9 +99,9 @@ func (hs *HTTPServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		Message: "routing successful",
 		Status:  "ok",
 	}
-	if hs.router != nil {
+	if hs.inputHandler != nil {
 		inputContext := context.WithValue(hs.ctx, httpServerContextKey("responseWriter"), &responseWriter)
-		aRouteFound, routingErrors := hs.router.HandleInput(inputContext, hs.Id(), r)
+		aRouteFound, routingErrors := hs.inputHandler(inputContext, hs.Id(), r)
 		if !responseWriter.done {
 			if aRouteFound {
 				if routingErrors != nil {
@@ -109,26 +115,11 @@ func (hs *HTTPServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 							Index: responseIOError.Index,
 						}
 
-						if responseIOError.InputError != nil {
-							errorMsg := responseIOError.InputError.Error()
-							errorToAdd.InputError = &errorMsg
-						}
-
 						if responseIOError.ProcessError != nil {
 							errorMsg := responseIOError.ProcessError.Error()
 							errorToAdd.ProcessError = &errorMsg
 						}
 
-						if responseIOError.OutputErrors != nil {
-							outputErrorMsgs := []string{}
-
-							for _, outputError := range responseIOError.OutputErrors {
-								outputErrorMsgs = append(outputErrorMsgs, outputError.Error())
-							}
-
-							errorToAdd.OutputErrors = outputErrorMsgs
-						}
-
 						response.IOErrors = append(response.IOErrors, errorToAdd)
 
 					}
@@ -157,21 +148,27 @@ func (hs *HTTPServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (hs *HTTPServer) Run() error {
+func (hs *HTTPServer) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	hs.logger.Debug("running")
+	hs.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	hs.ctx = moduleContext
+	hs.cancel = cancel
+
 	httpServer := &http.Server{
 		Addr:              fmt.Sprintf(":%d", hs.Port),
+		ReadHeaderTimeout: 5 * time.Second,
 		Handler:           hs,
 	}
 
-	go func() {
+	hs.serverMu.Lock()
-		<-hs.ctx.Done()
+	hs.server = httpServer
-		httpServer.Close()
+	hs.serverMu.Unlock()
-	}()
 
 	err := httpServer.ListenAndServe()
 	// TODO(jwetzell): handle server closed error differently
 	if err != nil {
-		if err.Error() != "http: Server closed" {
+		if !errors.Is(err, http.ErrServerClosed) {
 			return err
 		}
 	}
@@ -188,7 +185,7 @@ func (hs *HTTPServer) Output(ctx context.Context, payload any) error {
 		return errors.New("http.server output must originate from an http.server input")
 	}
 
-	payloadResponse, ok := payload.(processor.HTTPResponse)
+	payloadResponse, ok := common.GetAnyAs[processor.HTTPResponse](payload)
 
 	if !ok {
 		return errors.New("http.server is only able to output HTTPResponse")
@@ -202,3 +199,17 @@ func (hs *HTTPServer) Output(ctx context.Context, payload any) error {
 	responseWriter.Write(payloadResponse.Body)
 	return nil
 }
+
+func (hs *HTTPServer) Stop() {
+	if hs.cancel != nil {
+		defer hs.cancel()
+	}
+	hs.serverMu.Lock()
+	defer hs.serverMu.Unlock()
+	if hs.server != nil {
+		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
+		hs.server.Shutdown(shutdownCtx)
+		shutdownCancel()
+		<-shutdownCtx.Done()
+	}
+}

internal/module/midi-input.go

@@ -4,53 +4,54 @@ package module
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"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 MIDIInput struct {
-	config   config.ModuleConfig
-	ctx      context.Context
-	router   route.RouteIO
-	Port     string
-	SendFunc func(midi.Message) error
-	logger   *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "midi.input",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "MIDI Input",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title:       "Port",
+					Description: "the name of the MIDI port to listen to",
+					Type:        "string",
+				},
+			},
+			Required:             []string{"port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
-			port, ok := params["port"]
+			portString, err := params.GetString("port")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("midi.input port error: %w", err)
-				return nil, errors.New("midi.input requires a port parameter")
 			}
 
-			portString, ok := port.(string)
+			return &MIDIInput{config: config, Port: portString, logger: CreateLogger(config)}, nil
-
-			if !ok {
-				return nil, errors.New("midi.input port must be a string")
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("midi.input unable to get router from context")
-			}
-
-			return &MIDIInput{config: config, Port: portString, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type MIDIInput struct {
+	config       config.ModuleConfig
+	ctx          context.Context
+	inputHandler common.InputHandler
+	Port         string
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	stop         func()
+}
+
 func (mi *MIDIInput) Id() string {
 	return mi.config.Id
 }
@@ -59,8 +60,12 @@ func (mi *MIDIInput) Type() string {
 	return mi.config.Type
 }
 
-func (mi *MIDIInput) Run() error {
+func (mi *MIDIInput) Start(ctx context.Context, inputHandler common.InputHandler) error {
-	defer midi.CloseDriver()
+	mi.logger.Debug("running")
+	mi.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	mi.ctx = moduleContext
+	mi.cancel = cancel
 
 	in, err := midi.FindInPort(mi.Port)
 	if err != nil {
@@ -68,22 +73,27 @@ func (mi *MIDIInput) Run() error {
 	}
 
 	stop, err := midi.ListenTo(in, func(msg midi.Message, timestampms int32) {
-		if mi.router != nil {
+		if mi.inputHandler != nil {
-			mi.router.HandleInput(mi.ctx, mi.Id(), msg)
+			mi.inputHandler(mi.ctx, mi.Id(), msg)
 		}
 	}, midi.UseSysEx())
 
 	if err != nil {
 		return err
 	}
-
+	mi.stop = stop
-	defer stop()
 
 	<-mi.ctx.Done()
 	mi.logger.Debug("done")
 	return nil
 }
 
-func (mi *MIDIInput) Output(ctx context.Context, payload any) error {
+func (mi *MIDIInput) Stop() {
-	return errors.New("midi.input output is not implemented")
+	if mi.cancel != nil {
+		defer mi.cancel()
+	}
+	if mi.stop != nil {
+		mi.stop()
+	}
+	midi.CloseDriver()
 }

internal/module/midi-output.go

@@ -7,51 +7,55 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"sync"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"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 MIDIOutput struct {
-	config   config.ModuleConfig
-	ctx      context.Context
-	router   route.RouteIO
-	Port     string
-	SendFunc func(midi.Message) error
-	logger   *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "midi.output",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "MIDI Output",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title:       "Port",
+					Description: "the name of the MIDI port to send messages to",
+					Type:        "string",
+				},
+			},
+			Required:             []string{"port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 
-			port, ok := params["port"]
+			portString, err := params.GetString("port")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("midi.output port error: %w", err)
-				return nil, errors.New("midi.output requires a port parameter")
 			}
 
-			portString, ok := port.(string)
+			return &MIDIOutput{config: config, Port: portString, logger: CreateLogger(config)}, nil
-
-			if !ok {
-				return nil, errors.New("midi.output port must be a string")
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("midi.output unable to get router from context")
-			}
-
-			return &MIDIOutput{config: config, Port: portString, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type MIDIOutput struct {
+	config       config.ModuleConfig
+	ctx          context.Context
+	inputHandler common.InputHandler
+	Port         string
+	sendFunc     func(midi.Message) error
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	sendFuncMu   sync.Mutex
+}
+
 func (mo *MIDIOutput) Id() string {
 	return mo.config.Id
 }
@@ -60,8 +64,12 @@ func (mo *MIDIOutput) Type() string {
 	return mo.config.Type
 }
 
-func (mo *MIDIOutput) Run() error {
+func (mo *MIDIOutput) Start(ctx context.Context, inputHandler common.InputHandler) error {
-	defer midi.CloseDriver()
+	mo.logger.Debug("running")
+	mo.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	mo.ctx = moduleContext
+	mo.cancel = cancel
 
 	out, err := midi.FindOutPort(mo.Port)
 
@@ -74,7 +82,9 @@ func (mo *MIDIOutput) Run() error {
 		return err
 	}
 
-	mo.SendFunc = send
+	mo.sendFuncMu.Lock()
+	mo.sendFunc = send
+	mo.sendFuncMu.Unlock()
 
 	<-mo.ctx.Done()
 	mo.logger.Debug("done")
@@ -82,15 +92,24 @@ func (mo *MIDIOutput) Run() error {
 }
 
 func (mo *MIDIOutput) Output(ctx context.Context, payload any) error {
-	if mo.SendFunc == nil {
+	mo.sendFuncMu.Lock()
+	defer mo.sendFuncMu.Unlock()
+	if mo.sendFunc == nil {
 		return errors.New("midi.output output is not setup")
 	}
 
-	payloadMessage, ok := payload.(midi.Message)
+	payloadMessage, ok := common.GetAnyAs[midi.Message](payload)
 
 	if !ok {
-		return errors.New("midi.output can only ouptut midi.Message")
+		return errors.New("midi.output can only output midi.Message")
 	}
 
-	return mo.SendFunc(payloadMessage)
+	return mo.sendFunc(payloadMessage)
+}
+
+func (mo *MIDIOutput) Stop() {
+	if mo.cancel != nil {
+		defer mo.cancel()
+	}
+	midi.CloseDriver()
 }

internal/module/module.go

@@ -1,30 +1,21 @@
 package module
 
 import (
-	"context"
 	"fmt"
 	"log/slog"
 	"sync"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
-type ModuleError struct {
-	Index  int
-	Config config.ModuleConfig
-	Error  error
-}
-
-type Module interface {
-	Id() string
-	Type() string
-	Run() error
-	Output(context.Context, any) error
-}
-
 type ModuleRegistration struct {
 	Type         string             `json:"type"`
-	New  func(context.Context, config.ModuleConfig) (Module, error)
+	Title        string             `json:"title,omitempty"`
+	Description  string             `json:"description,omitempty"`
+	ParamsSchema *jsonschema.Schema `json:"paramsSchema,omitempty"`
+	New          func(config.ModuleConfig) (common.Module, error)
 }
 
 func RegisterModule(mod ModuleRegistration) {
@@ -39,15 +30,37 @@ func RegisterModule(mod ModuleRegistration) {
 	moduleRegistryMu.Lock()
 	defer moduleRegistryMu.Unlock()
 
-	if _, ok := ModuleRegistry[string(mod.Type)]; ok {
+	_, exists := moduleRegistry[string(mod.Type)]
+	if exists {
 		panic(fmt.Sprintf("module already registered: %s", mod.Type))
 	}
-	ModuleRegistry[string(mod.Type)] = mod
+	moduleRegistry[string(mod.Type)] = mod
+}
+
+type ModuleRegistry map[string]ModuleRegistration
+
+func GetModuleRegistration(moduleType string) (ModuleRegistration, bool) {
+	moduleRegistryMu.RLock()
+	defer moduleRegistryMu.RUnlock()
+
+	mod, ok := moduleRegistry[moduleType]
+	return mod, ok
+}
+
+func GetModuleRegistrations() []ModuleRegistration {
+	moduleRegistryMu.RLock()
+	defer moduleRegistryMu.RUnlock()
+
+	registrations := make([]ModuleRegistration, 0, len(moduleRegistry))
+	for _, mod := range moduleRegistry {
+		registrations = append(registrations, mod)
+	}
+	return registrations
 }
 
 var (
 	moduleRegistryMu sync.RWMutex
-	ModuleRegistry   = make(map[string]ModuleRegistration)
+	moduleRegistry   = make(ModuleRegistry)
 )
 
 func CreateLogger(config config.ModuleConfig) *slog.Logger {

internal/module/mqtt-client.go

@@ -2,77 +2,118 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
+	"fmt"
 	"log/slog"
+	"sync"
 
 	mqtt "github.com/eclipse/paho.mqtt.golang"
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
-type MQTTClient struct {
-	config   config.ModuleConfig
-	ctx      context.Context
-	router   route.RouteIO
-	Broker   string
-	ClientID string
-	Topic    string
-	client   mqtt.Client
-	logger   *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "mqtt.client",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "MQTT Client",
-			params := config.Params
+		ParamsSchema: &jsonschema.Schema{
-			broker, ok := params["broker"]
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"broker": {
+					Title:       "Broker URL",
+					Description: "the URL of the MQTT broker to connect to",
+					Type:        "string",
+				},
+				"topic": {
+					Title:       "Topic",
+					Description: "an MQTT topic to subscribe to",
+					Type:        "string",
+				},
+				"clientId": {
+					Title:       "Client ID",
+					Description: "the client ID to use when connecting to the MQTT broker",
+					Type:        "string",
+				},
+				"qos": {
+					Title:       "QoS",
+					Description: "the QoS level to use when publishing messages",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](0),
+					Maximum:     jsonschema.Ptr[float64](2),
+					Default:     json.RawMessage(`0`),
+				},
+				"retained": {
+					Title:       "Retained",
+					Description: "whether to set the retained flag when publishing messages",
+					Type:        "boolean",
+					Default:     json.RawMessage(`false`),
+				},
+			},
+			Required:             []string{"broker", "topic", "clientId"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
+			params := moduleConfig.Params
+			brokerString, err := params.GetString("broker")
 
-			if !ok {
+			if err != nil {
-				return nil, errors.New("mqtt.client requires a broker parameter")
+				return nil, fmt.Errorf("mqtt.client broker error: %w", err)
 			}
 
-			brokerString, ok := broker.(string)
+			topicString, err := params.GetString("topic")
 
-			if !ok {
+			if err != nil {
-				return nil, errors.New("mqtt.client broker must be string")
+				return nil, fmt.Errorf("mqtt.client topic error: %w", err)
 			}
 
-			topic, ok := params["topic"]
+			clientIdString, err := params.GetString("clientId")
 
-			if !ok {
+			if err != nil {
-				return nil, errors.New("mqtt.client requires a topic parameter")
+				return nil, fmt.Errorf("mqtt.client clientId error: %w", err)
 			}
 
-			topicString, ok := topic.(string)
+			qosString, err := params.GetInt("qos")
 
-			if !ok {
+			if err != nil {
-				return nil, errors.New("mqtt.client topic must be string")
+				if errors.Is(err, config.ErrParamNotFound) {
+					qosString = 0
+				} else {
+					return nil, fmt.Errorf("mqtt.client qos error: %w", err)
+				}
 			}
 
-			clientId, ok := params["clientId"]
+			retainedBool, err := params.GetBool("retained")
 
-			if !ok {
+			if err != nil {
-				return nil, errors.New("mqtt.client requires a clientId parameter")
+				if errors.Is(err, config.ErrParamNotFound) {
+					retainedBool = false
+				} else {
+					return nil, fmt.Errorf("mqtt.client retained error: %w", err)
+				}
 			}
 
-			clientIdString, ok := clientId.(string)
+			return &MQTTClient{config: moduleConfig, Broker: brokerString, Topic: topicString, ClientID: clientIdString, QoS: byte(qosString), Retained: retainedBool, logger: CreateLogger(moduleConfig)}, nil
-
-			if !ok {
-				return nil, errors.New("mqtt.client clientId must be string")
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("mqtt.client unable to get router from context")
-			}
-
-			return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type MQTTClient struct {
+	config       config.ModuleConfig
+	ctx          context.Context
+	inputHandler common.InputHandler
+	Broker       string
+	ClientID     string
+	Topic        string
+	QoS          byte
+	Retained     bool
+	client       mqtt.Client
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	clientMu     sync.Mutex
+}
+
 func (mc *MQTTClient) Id() string {
 	return mc.config.Id
 }
@@ -81,7 +122,13 @@ func (mc *MQTTClient) Type() string {
 	return mc.config.Type
 }
 
-func (mc *MQTTClient) Run() error {
+func (mc *MQTTClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	mc.logger.Debug("running")
+	mc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	mc.ctx = moduleContext
+	mc.cancel = cancel
+
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(mc.Broker)
 	opts.SetClientID(mc.ClientID)
@@ -90,14 +137,18 @@ func (mc *MQTTClient) Run() error {
 
 	opts.OnConnect = func(c mqtt.Client) {
 		token := mc.client.Subscribe(mc.Topic, 1, func(c mqtt.Client, m mqtt.Message) {
-			mc.router.HandleInput(mc.ctx, mc.Id(), m)
+			if mc.inputHandler != nil {
+				mc.inputHandler(mc.ctx, mc.Id(), m)
+			}
 		})
 		token.Wait()
 	}
 
+	mc.clientMu.Lock()
 	mc.client = mqtt.NewClient(opts)
 
 	token := mc.client.Connect()
+	mc.clientMu.Unlock()
 
 	token.Wait()
 	err := token.Error()
@@ -110,11 +161,15 @@ func (mc *MQTTClient) Run() error {
 	return nil
 }
 
-func (mc *MQTTClient) Output(ctx context.Context, payload any) error {
+func (mc *MQTTClient) Publish(ctx context.Context, topic string, payload any) error {
-	payloadMessage, ok := payload.(mqtt.Message)
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
 
 	if !ok {
-		return errors.New("mqtt.client is only able to output a MQTTMessage")
+		payloadString, ok := common.GetAnyAs[string](payload)
+		if !ok {
+			return errors.New("mqtt.client is only able to publish bytes or string")
+		}
+		payloadBytes = []byte(payloadString)
 	}
 
 	if mc.client == nil {
@@ -125,9 +180,20 @@ func (mc *MQTTClient) Output(ctx context.Context, payload any) error {
 		return errors.New("mqtt.client is not connected")
 	}
 
-	token := mc.client.Publish(payloadMessage.Topic(), payloadMessage.Qos(), payloadMessage.Retained(), payloadMessage.Payload())
+	token := mc.client.Publish(topic, mc.QoS, mc.Retained, payloadBytes)
 
 	token.Wait()
 
 	return token.Error()
 }
+
+func (mc *MQTTClient) Stop() {
+	if mc.cancel != nil {
+		mc.cancel()
+	}
+	mc.clientMu.Lock()
+	defer mc.clientMu.Unlock()
+	if mc.client != nil {
+		mc.client.Disconnect(250)
+	}
+}

internal/module/nats-client.go

@@ -4,63 +4,67 @@ import (
 	"context"
 	"errors"
 	"log/slog"
+	"sync"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"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
-	logger  *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "nats.client",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "NATS Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"url": {
+					Title:       "NATS Server URL",
+					Description: "the URL of the NATS server to connect to",
+					Type:        "string",
+				},
+				"subject": {
+					Title:       "Subject",
+					Description: "the subject to subscribe to",
+					Type:        "string",
+				},
+			},
+			Required:             []string{"url", "subject"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
-			url, ok := params["url"]
+			urlString, err := params.GetString("url")
-
+			if err != nil {
-			if !ok {
+				return nil, errors.New("nats.client url error: " + err.Error())
-				return nil, errors.New("nats.client requires a url parameter")
 			}
 
-			urlString, ok := url.(string)
+			subjectString, err := params.GetString("subject")
 
-			if !ok {
+			if err != nil {
-				return nil, errors.New("nats.client url must be string")
+				return nil, errors.New("nats.client subject error: " + err.Error())
 			}
 
-			subject, ok := params["subject"]
+			return &NATSClient{config: config, URL: urlString, Subject: subjectString, logger: CreateLogger(config)}, nil
-
-			if !ok {
-				return nil, errors.New("nats.client requires a subject parameter")
-			}
-
-			subjectString, ok := subject.(string)
-
-			if !ok {
-				return nil, errors.New("nats.client subject must be string")
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("nats.client unable to get router from context")
-			}
-
-			return &NATSClient{config: config, URL: urlString, Subject: subjectString, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type NATSClient struct {
+	config       config.ModuleConfig
+	ctx          context.Context
+	inputHandler common.InputHandler
+	URL          string
+	Subject      string
+	client       *nats.Conn
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	sub          *nats.Subscription
+	subMu        sync.Mutex
+	clientMu     sync.Mutex
+}
+
 func (nc *NATSClient) Id() string {
 	return nc.config.Id
 }
@@ -69,42 +73,55 @@ func (nc *NATSClient) Type() string {
 	return nc.config.Type
 }
 
-func (nc *NATSClient) Run() error {
+func (nc *NATSClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	nc.logger.Debug("running")
+	nc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	nc.ctx = moduleContext
+	nc.cancel = cancel
+
 	client, err := nats.Connect(nc.URL, nats.RetryOnFailedConnect(true))
 
 	if err != nil {
 		return err
 	}
 
+	nc.clientMu.Lock()
 	nc.client = client
-
+	nc.clientMu.Unlock()
-	defer client.Drain()
-	defer client.Close()
 
 	sub, err := nc.client.Subscribe(nc.Subject, func(msg *nats.Msg) {
-		if nc.router != nil {
+		if nc.inputHandler != nil {
-			nc.router.HandleInput(nc.ctx, nc.Id(), msg)
+			nc.inputHandler(nc.ctx, nc.Id(), msg)
 		}
 	})
 
 	if err != nil {
 		return err
 	}
-
+	nc.subMu.Lock()
-	defer sub.Unsubscribe()
+	nc.sub = sub
+	nc.subMu.Unlock()
 
 	<-nc.ctx.Done()
 	nc.logger.Debug("done")
 	return nil
 }
 
-func (nc *NATSClient) Output(ctx context.Context, payload any) error {
+func (nc *NATSClient) Publish(ctx context.Context, topic string, payload any) error {
 
-	payloadMessage, ok := payload.(processor.NATSMessage)
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
 
 	if !ok {
-		return errors.New("nats.client is only able to output NATSMessage")
+		payloadString, ok := common.GetAnyAs[string](payload)
+		if !ok {
+			return errors.New("nats.client is only able to publish bytes or string")
 		}
+		payloadBytes = []byte(payloadString)
+	}
+
+	nc.clientMu.Lock()
+	defer nc.clientMu.Unlock()
 
 	if nc.client == nil {
 		return errors.New("nats.client client is not setup")
@@ -114,7 +131,26 @@ func (nc *NATSClient) Output(ctx context.Context, payload any) error {
 		return errors.New("nats.client is not connected")
 	}
 
-	err := nc.client.Publish(payloadMessage.Subject, payloadMessage.Payload)
+	err := nc.client.Publish(topic, payloadBytes)
 
 	return err
 }
+
+func (nc *NATSClient) Stop() {
+	if nc.cancel != nil {
+		defer nc.cancel()
+	}
+	nc.subMu.Lock()
+	defer nc.subMu.Unlock()
+	if nc.sub != nil {
+		nc.sub.Unsubscribe()
+	}
+
+	nc.clientMu.Lock()
+	defer nc.clientMu.Unlock()
+	if nc.client != nil {
+		nc.client.Drain()
+		// TODO(jwetzell): setup closed callback to get when client is fully closed
+		nc.client.Close()
+	}
+}

internal/module/nats-server.go

@@ -0,0 +1,135 @@
+package module
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/nats-io/nats-server/v2/server"
+)
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "nats.server",
+		Title: "NATS Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:       "IP",
+					Description: "the IP address to bind the NATS server to",
+					Type:        "string",
+					Default:     json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port for the NATS server to listen on",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1024),
+					Maximum:     jsonschema.Ptr[float64](65535),
+					Default:     json.RawMessage(`4222`),
+				},
+			},
+			Required:             []string{},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
+			params := moduleConfig.Params
+			portNum, err := params.GetInt("port")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					portNum = 4222
+				} else {
+					return nil, fmt.Errorf("nats.server port error: %w", err)
+				}
+			}
+
+			ipString, err := params.GetString("ip")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					ipString = "0.0.0.0"
+				} else {
+					return nil, fmt.Errorf("nats.server ip error: %w", err)
+				}
+			}
+
+			_, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
+			if err != nil {
+				return nil, err
+			}
+			return &NATSServer{config: moduleConfig, logger: CreateLogger(moduleConfig), Ip: ipString, Port: portNum}, nil
+		},
+	})
+}
+
+type NATSServer struct {
+	config       config.ModuleConfig
+	ctx          context.Context
+	Ip           string
+	Port         int
+	inputHandler common.InputHandler
+	server       *server.Server
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	serverMu     sync.Mutex
+}
+
+func (ns *NATSServer) Id() string {
+	return ns.config.Id
+}
+
+func (ns *NATSServer) Type() string {
+	return ns.config.Type
+}
+
+func (ns *NATSServer) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	ns.logger.Debug("running")
+	ns.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	ns.ctx = moduleContext
+	ns.cancel = cancel
+
+	natsServer, err := server.NewServer(&server.Options{
+		Host:   ns.Ip,
+		Port:   ns.Port,
+		NoLog:  true,
+		NoSigs: true,
+	})
+
+	if err != nil {
+		return err
+	}
+
+	ns.serverMu.Lock()
+	ns.server = natsServer
+	natsServer.Start()
+
+	if !natsServer.ReadyForConnections(5 * time.Second) {
+		return errors.New("nats.server failed to start")
+	}
+	ns.serverMu.Unlock()
+
+	<-ns.ctx.Done()
+	ns.logger.Debug("done")
+	return nil
+}
+
+func (ns *NATSServer) Stop() {
+	if ns.cancel != nil {
+		defer ns.cancel()
+	}
+	ns.serverMu.Lock()
+	defer ns.serverMu.Unlock()
+	if ns.server != nil {
+		ns.server.Shutdown()
+		ns.server.WaitForShutdown()
+	}
+}

internal/module/psn-client.go

@@ -2,38 +2,35 @@ package module
 
 import (
 	"context"
-	"errors"
-	"fmt"
 	"log/slog"
 	"net"
+	"sync"
 	"time"
 
 	"github.com/jwetzell/psn-go"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "psn.client",
+		Title: "PosiStageNet Client",
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			return &PSNClient{config: config, decoder: psn.NewDecoder(), logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
 type PSNClient struct {
 	config       config.ModuleConfig
 	conn         *net.UDPConn
 	ctx          context.Context
-	router  route.RouteIO
+	inputHandler common.InputHandler
 	decoder      *psn.Decoder
 	logger       *slog.Logger
-}
+	cancel       context.CancelFunc
-
+	connMu       sync.Mutex
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "psn.client",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("psn.client unable to get router from context")
-			}
-			return &PSNClient{config: config, decoder: psn.NewDecoder(), ctx: ctx, router: router, logger: CreateLogger(config)}, nil
-		},
-	})
 }
 
 func (pc *PSNClient) Id() string {
@@ -44,7 +41,12 @@ func (pc *PSNClient) Type() string {
 	return pc.config.Type
 }
 
-func (pc *PSNClient) Run() error {
+func (pc *PSNClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	pc.logger.Debug("running")
+	pc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	pc.ctx = moduleContext
+	pc.cancel = cancel
 
 	addr, err := net.ResolveUDPAddr("udp", "236.10.10.10:56565")
 	if err != nil {
@@ -55,24 +57,26 @@ func (pc *PSNClient) Run() error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 
+	pc.connMu.Lock()
 	pc.conn = client
+	pc.connMu.Unlock()
 
 	buffer := make([]byte, 2048)
-	for {
+	for pc.ctx.Err() == nil {
 		select {
 		case <-pc.ctx.Done():
-			// TODO(jwetzell): cleanup?
-			pc.logger.Debug("done")
 			return nil
 		default:
+			pc.connMu.Lock()
 			pc.conn.SetDeadline(time.Now().Add(time.Millisecond * 200))
 
 			numBytes, _, err := pc.conn.ReadFromUDP(buffer)
+			pc.connMu.Unlock()
 			if err != nil {
 				//NOTE(jwetzell) we hit deadline
-				if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
+				opErr, ok := err.(*net.OpError)
+				if ok && opErr.Timeout() {
 					continue
 				}
 				return err
@@ -85,18 +89,29 @@ func (pc *PSNClient) Run() error {
 					pc.logger.Error("problem decoding psn traffic", "error", err)
 				}
 
-				if pc.router != nil {
+				if pc.inputHandler != nil {
+					// TODO(jwetzell): better input handling
 					for _, tracker := range pc.decoder.Trackers {
-						pc.router.HandleInput(pc.ctx, pc.Id(), tracker)
+						pc.inputHandler(pc.ctx, pc.Id(), tracker)
 					}
 				} else {
-					pc.logger.Error("has no router")
+					pc.logger.Error("has no input handler")
 				}
 			}
 		}
 	}
+	<-pc.ctx.Done()
+	pc.logger.Debug("done")
+	return nil
 }
 
-func (pc *PSNClient) Output(ctx context.Context, payload any) error {
+func (pc *PSNClient) Stop() {
-	return fmt.Errorf("psn.client output is not implemented")
+	if pc.cancel != nil {
+		defer pc.cancel()
+	}
+	pc.connMu.Lock()
+	defer pc.connMu.Unlock()
+	if pc.conn != nil {
+		pc.conn.Close()
+	}
 }

internal/module/redis-client.go

@@ -0,0 +1,133 @@
+package module
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"sync"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/redis/go-redis/v9"
+)
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "redis.client",
+		Title: "Redis Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"host": {
+					Title:       "Host",
+					Description: "the hostname or IP address of the Redis server to connect to",
+					Type:        "string",
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port to use when connecting to the Redis server",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1),
+					Maximum:     jsonschema.Ptr[float64](65535),
+				},
+			},
+			Required:             []string{"host", "port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			params := config.Params
+			hostString, err := params.GetString("host")
+			if err != nil {
+				return nil, errors.New("redis.client host error: " + err.Error())
+			}
+
+			portInt, err := params.GetInt("port")
+
+			if err != nil {
+				return nil, errors.New("redis.client port error: " + err.Error())
+			}
+
+			return &RedisClient{config: config, Host: hostString, Port: uint16(portInt), logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
+type RedisClient struct {
+	config       config.ModuleConfig
+	ctx          context.Context
+	inputHandler common.InputHandler
+	Host         string
+	Port         uint16
+	client       *redis.Client
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	clientMu     sync.Mutex
+}
+
+func (rc *RedisClient) Id() string {
+	return rc.config.Id
+}
+
+func (rc *RedisClient) Type() string {
+	return rc.config.Type
+}
+
+func (rc *RedisClient) Printf(ctx context.Context, format string, v ...any) {
+	msg := fmt.Sprintf(format, v...)
+	rc.logger.Debug(msg)
+}
+
+func (rc *RedisClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	redis.SetLogger(rc)
+	rc.logger.Debug("running")
+	rc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	rc.ctx = moduleContext
+	rc.cancel = cancel
+
+	client := redis.NewClient(&redis.Options{
+		Addr:     fmt.Sprintf("%s:%d", rc.Host, rc.Port),
+		Password: "",
+		DB:       0,
+	})
+
+	rc.clientMu.Lock()
+	rc.client = client
+	rc.clientMu.Unlock()
+
+	<-rc.ctx.Done()
+	rc.logger.Debug("done")
+	return nil
+}
+
+func (rc *RedisClient) Stop() {
+	if rc.cancel != nil {
+		defer rc.cancel()
+	}
+	rc.clientMu.Lock()
+	defer rc.clientMu.Unlock()
+	if rc.client != nil {
+		rc.client.Close()
+	}
+}
+
+func (rc *RedisClient) Get(ctx context.Context, key string) (any, error) {
+	if rc.client != nil {
+		val, err := rc.client.Get(ctx, key).Result()
+		if err != nil {
+			return nil, err
+		}
+		return val, nil
+	}
+	return nil, errors.New("redis.client not setup")
+}
+
+func (rc *RedisClient) Set(ctx context.Context, key string, value any) error {
+	if rc.client != nil {
+		status := rc.client.Set(ctx, key, value, 0)
+		return status.Err()
+	}
+	return errors.New("redis.client not setup")
+}

internal/module/serial-client.go

@@ -7,86 +7,91 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"sync"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"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
-	logger *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "serial.client",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "Serial Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title:       "Port",
+					Description: "the name of the serial port to connect to",
+					Type:        "string",
+				},
+				"baudRate": {
+					Title:       "Baud Rate",
+					Description: "the baud rate to use when connecting to the serial port",
+					Type:        "integer",
+				},
+				"framing": {
+					Title:       "Framing Method",
+					Description: "the method to use for framing messages on the serial port",
+					Type:        "string",
+					Enum:        []any{"LF", "CR", "CRLF", "SLIP", "RAW"},
+				},
+			},
+			Required:             []string{"port", "baudRate", "framing"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
-			port, ok := params["port"]
+			portString, err := params.GetString("port")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("serial.client port error: %w", err)
-				return nil, errors.New("serial.client requires a port parameter")
 			}
 
-			portString, ok := port.(string)
+			framingMethodString, err := params.GetString("framing")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("serial.client framing error: %w", err)
-				return nil, errors.New("serial.client port must be a string")
 			}
 
-			framingMethod := "RAW"
+			inFramer := framer.GetFramer(framingMethodString)
 
-			framingMethodRaw, ok := params["framing"]
+			if inFramer == nil {
-
+				return nil, fmt.Errorf("serial.client unknown framing method: %s", framingMethodString)
-			if ok {
-				framingMethodString, ok := framingMethodRaw.(string)
-
-				if !ok {
-					return nil, errors.New("serial.client framing method must be a string")
-				}
-				framingMethod = framingMethodString
 			}
 
-			framer := framer.GetFramer(framingMethod)
+			outFramer := framer.GetFramer(framingMethodString)
 
-			if framer == nil {
+			baudRateInt, err := params.GetInt("baudRate")
-				return nil, fmt.Errorf("serial.client unknown framing method: %s", framingMethod)
+			if err != nil {
-			}
+				return nil, fmt.Errorf("serial.client baudRate error: %w", err)
-
-			buadRate, ok := params["baudRate"]
-			if !ok {
-				return nil, errors.New("serial.client requires a baudRate parameter")
-			}
-
-			baudRateNum, ok := buadRate.(float64)
-			if !ok {
-				return nil, errors.New("serial.client baudRate must be a number")
 			}
 
 			mode := serial.Mode{
-				BaudRate: int(baudRateNum),
+				BaudRate: baudRateInt,
 			}
 
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
+			return &SerialClient{config: config, Port: portString, inFramer: inFramer, outFramer: outFramer, Mode: &mode, logger: CreateLogger(config)}, nil
-
-			if !ok {
-				return nil, errors.New("serial.client unable to get router from context")
-			}
-
-			return &SerialClient{config: config, Port: portString, Framer: framer, Mode: &mode, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type SerialClient struct {
+	config       config.ModuleConfig
+	ctx          context.Context
+	inputHandler common.InputHandler
+	Port         string
+	inFramer     framer.Framer
+	outFramer    framer.Framer
+	Mode         *serial.Mode
+	port         serial.Port
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	portMu       sync.Mutex
+}
+
 func (sc *SerialClient) Id() string {
 	return sc.config.Id
 }
@@ -96,10 +101,11 @@ func (sc *SerialClient) Type() string {
 }
 
 func (sc *SerialClient) SetupPort() error {
-
+	sc.portMu.Lock()
+	defer sc.portMu.Unlock()
 	port, err := serial.Open(sc.Port, sc.Mode)
 	if err != nil {
-		return fmt.Errorf("serial.client can't open input port: %s", sc.Port)
+		return err
 	}
 
 	sc.port = port
@@ -107,25 +113,20 @@ func (sc *SerialClient) SetupPort() error {
 	return nil
 }
 
-func (sc *SerialClient) Run() error {
+func (sc *SerialClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	sc.logger.Debug("running")
+	sc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	sc.ctx = moduleContext
+	sc.cancel = cancel
 
-	// TODO(jwetzell): shutdown with router.Context properly
+	for sc.ctx.Err() == nil {
-	go func() {
-		<-sc.ctx.Done()
-		sc.logger.Debug("done")
-		if sc.port != nil {
-			sc.port.Close()
-		}
-	}()
-
-	for {
 		err := sc.SetupPort()
 		if err != nil {
 			if sc.ctx.Err() != nil {
-				sc.logger.Debug("done")
 				return nil
 			}
-			sc.logger.Error("port setup error", "error", err.Error())
+			sc.logger.Error("port setup error", "port", sc.Port, "error", err.Error())
 			time.Sleep(time.Second * 2)
 			continue
 		}
@@ -133,29 +134,27 @@ func (sc *SerialClient) Run() error {
 		buffer := make([]byte, 1024)
 		select {
 		case <-sc.ctx.Done():
-			sc.logger.Debug("done")
 			return nil
 		default:
 		READ:
-			for {
+			for sc.ctx.Err() == nil {
 				select {
 				case <-sc.ctx.Done():
-					sc.logger.Debug("done")
 					return nil
 				default:
 					byteCount, err := sc.port.Read(buffer)
 
 					if err != nil {
-						sc.Framer.Clear()
+						sc.inFramer.Clear()
 						break READ
 					}
 
-					if sc.Framer != nil {
+					if sc.inFramer != nil {
 						if byteCount > 0 {
-							messages := sc.Framer.Decode(buffer[0:byteCount])
+							messages := sc.inFramer.Decode(buffer[0:byteCount])
 							for _, message := range messages {
-								if sc.router != nil {
+								if sc.inputHandler != nil {
-									sc.router.HandleInput(sc.ctx, sc.Id(), message)
+									sc.inputHandler(sc.ctx, sc.Id(), message)
 								} else {
 									sc.logger.Error("input received but no router is configured")
 								}
@@ -166,16 +165,38 @@ func (sc *SerialClient) Run() error {
 			}
 		}
 	}
+	<-sc.ctx.Done()
+	sc.logger.Debug("done")
+	return nil
 }
 
 func (sc *SerialClient) Output(ctx context.Context, payload any) error {
 
-	payloadBytes, ok := payload.([]byte)
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
 
 	if !ok {
-		return errors.New("serial.client can only ouptut bytes")
+		return errors.New("serial.client can only output bytes")
 	}
 
-	_, err := sc.port.Write(sc.Framer.Encode(payloadBytes))
+	_, err := sc.port.Write(sc.outFramer.Encode(payloadBytes))
 	return err
 }
+
+func (sc *SerialClient) Stop() {
+	if sc.cancel != nil {
+		defer sc.cancel()
+	}
+	sc.portMu.Lock()
+	defer sc.portMu.Unlock()
+	if sc.port != nil {
+		sc.port.Close()
+	}
+
+	if sc.inFramer != nil {
+		sc.inFramer.Clear()
+	}
+
+	if sc.outFramer != nil {
+		sc.outFramer.Clear()
+	}
+}

internal/module/sip-call-server.go

@@ -2,6 +2,7 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -14,21 +15,106 @@ import (
 	"github.com/emiago/diago/media"
 	"github.com/emiago/sipgo"
 	"github.com/emiago/sipgo/sip"
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"github.com/jwetzell/showbridge-go/internal/processor"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "sip.call.server",
+		Title: "SIP Call Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:       "IP",
+					Description: "the IP address to bind the SIP server to",
+					Type:        "string",
+					Default:     json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port for the SIP server to listen on",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1024),
+					Maximum:     jsonschema.Ptr[float64](65535),
+					Default:     json.RawMessage(`5060`),
+				},
+				"transport": {
+					Title:       "Transport",
+					Description: "the transport protocol to use for the SIP server",
+					Type:        "string",
+					Enum:        []any{"udp", "tcp", "ws", "udp4", "tcp4"},
+					Default:     json.RawMessage(`"udp"`),
+				},
+				"userAgent": {
+					Title:       "User Agent",
+					Description: "the user agent string to use",
+					Type:        "string",
+					Default:     json.RawMessage(`"showbridge"`),
+				},
+			},
+			Required:             []string{},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
+			params := moduleConfig.Params
+			portNum, err := params.GetInt("port")
+			if err != nil {
+
+				if errors.Is(err, config.ErrParamNotFound) {
+					portNum = 5060
+				} else {
+					return nil, fmt.Errorf("sip.call.server port error: %w", err)
+				}
+			}
+
+			ipString, err := params.GetString("ip")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					ipString = "0.0.0.0"
+				} else {
+					return nil, fmt.Errorf("sip.call.server ip error: %w", err)
+				}
+			}
+
+			transportString, err := params.GetString("transport")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					transportString = "udp"
+				} else {
+					return nil, fmt.Errorf("sip.call.server transport error: %w", err)
+				}
+			}
+
+			userAgentString, err := params.GetString("userAgent")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					userAgentString = "showbridge"
+				} else {
+					return nil, fmt.Errorf("sip.call.server userAgent error: %w", err)
+				}
+			}
+
+			return &SIPCallServer{config: moduleConfig, IP: ipString, Port: int(portNum), Transport: transportString, UserAgent: userAgentString, logger: CreateLogger(moduleConfig)}, nil
+		},
+	})
+}
+
 type SIPCallServer struct {
 	config       config.ModuleConfig
 	ctx          context.Context
-	router    route.RouteIO
+	inputHandler common.InputHandler
 	IP           string
 	Port         int
 	Transport    string
 	UserAgent    string
-	dg        *diago.Diago
 	logger       *slog.Logger
+	cancel       context.CancelFunc
+	ua           *sipgo.UserAgent
+	uaMu         sync.Mutex
 }
 
 type SIPCallMessage struct {
@@ -42,72 +128,6 @@ type SIPCall struct {
 
 type sipCallContextKey string
 
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "sip.call.server",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			params := config.Params
-			portNum := 5060
-
-			port, ok := params["port"]
-			if ok {
-				specificPortNum, ok := port.(float64)
-
-				if !ok {
-					return nil, errors.New("sip.call.server port must be a number")
-				}
-				portNum = int(specificPortNum)
-			}
-
-			ipString := "0.0.0.0"
-
-			ip, ok := params["ip"]
-			if ok {
-
-				specificIpString, ok := ip.(string)
-
-				if !ok {
-					return nil, errors.New("sip.call.server ip must be a string")
-				}
-				ipString = specificIpString
-			}
-
-			transportString := "udp"
-
-			transport, ok := params["transport"]
-			if ok {
-
-				specificTransportString, ok := transport.(string)
-
-				if !ok {
-					return nil, errors.New("sip.call.server transport must be a string")
-				}
-				transportString = specificTransportString
-			}
-
-			userAgentString := "showbridge"
-
-			userAgent, ok := params["userAgent"]
-			if ok {
-
-				specificTransportString, ok := userAgent.(string)
-
-				if !ok {
-					return nil, errors.New("sip.call.server userAgent must be a string")
-				}
-				userAgentString = specificTransportString
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("sip.call.server unable to get router from context")
-			}
-			return &SIPCallServer{config: config, ctx: ctx, router: router, IP: ipString, Port: int(portNum), Transport: transportString, UserAgent: userAgentString, logger: CreateLogger(config)}, nil
-		},
-	})
-}
-
 func (scs *SIPCallServer) Id() string {
 	return scs.config.Id
 }
@@ -116,7 +136,13 @@ func (scs *SIPCallServer) Type() string {
 	return scs.config.Type
 }
 
-func (scs *SIPCallServer) Run() error {
+func (scs *SIPCallServer) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	scs.logger.Debug("running")
+	scs.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	scs.ctx = moduleContext
+	scs.cancel = cancel
+
 	diagoLogger := slog.New(slog.NewJSONHandler(io.Discard, nil))
 
 	ua, _ := sipgo.NewUA(
@@ -124,7 +150,9 @@ func (scs *SIPCallServer) Run() error {
 		sipgo.WithUserAgentTransportLayerOptions(sip.WithTransportLayerLogger(diagoLogger)),
 		sipgo.WithUserAgentTransactionLayerOptions(sip.WithTransactionLayerLogger(diagoLogger)),
 	)
-	defer ua.Close()
+	scs.uaMu.Lock()
+	scs.ua = ua
+	scs.uaMu.Unlock()
 
 	sip.SetDefaultLogger(diagoLogger)
 	media.SetDefaultLogger(diagoLogger)
@@ -136,13 +164,12 @@ func (scs *SIPCallServer) Run() error {
 		},
 	))
 
-	go func() {
+	err := dg.Serve(scs.ctx, func(inDialog *diago.DialogServerSession) {
-		dg.Serve(scs.ctx, func(inDialog *diago.DialogServerSession) {
 		scs.HandleCall(inDialog)
 	})
-	}()
+	if err != nil {
-
+		scs.logger.Error("diago serve error", "error", err)
-	scs.dg = dg
+	}
 
 	<-scs.ctx.Done()
 	scs.logger.Debug("done")
@@ -157,10 +184,11 @@ func (scs *SIPCallServer) HandleCall(inDialog *diago.DialogServerSession) {
 	dialogContext := context.WithValue(scs.ctx, sipCallContextKey("call"), &SIPCall{
 		inDialog: inDialog,
 	})
-	scs.router.HandleInput(dialogContext, scs.Id(), SIPCallMessage{
+	if scs.inputHandler != nil {
+		scs.inputHandler(dialogContext, scs.Id(), SIPCallMessage{
 			To: inDialog.ToUser(),
 		})
-	fmt.Println(inDialog.LoadState())
+	}
 }
 
 func (scs *SIPCallServer) Output(ctx context.Context, payload any) error {
@@ -181,11 +209,13 @@ func (scs *SIPCallServer) Output(ctx context.Context, payload any) error {
 		return errors.New("sip.call.server inDialog already ended")
 	}
 
-	payloadDTMFResponse, ok := payload.(processor.SipDTMFResponse)
+	payloadDTMFResponse, ok := common.GetAnyAs[processor.SipDTMFResponse](payload)
 
 	if ok {
-		dtmfWriter := call.inDialog.AudioWriterDTMF()
+		dtmfWriter, err := call.inDialog.AudioWriterDTMF()
-
+		if err != nil {
+			return err
+		}
 		time.Sleep(time.Millisecond * time.Duration(payloadDTMFResponse.PreWait))
 		for i, dtmfRune := range payloadDTMFResponse.Digits {
 			err := dtmfWriter.WriteDTMF(dtmfRune)
@@ -194,11 +224,11 @@ func (scs *SIPCallServer) Output(ctx context.Context, payload any) error {
 				return fmt.Errorf("sip.dtmf.server error output dtmf digit at index %d", i)
 			}
 		}
-		time.Sleep(time.Millisecond * time.Duration(payloadDTMFResponse.PreWait))
+		time.Sleep(time.Millisecond * time.Duration(payloadDTMFResponse.PostWait))
 		return nil
 	}
 
-	payloadAudioFileResponse, ok := payload.(processor.SipAudioFileResponse)
+	payloadAudioFileResponse, ok := common.GetAnyAs[processor.SipAudioFileResponse](payload)
 
 	if ok {
 		audioFile, err := os.Open(payloadAudioFileResponse.AudioFile)
@@ -226,3 +256,14 @@ func (scs *SIPCallServer) Output(ctx context.Context, payload any) error {
 	}
 	return errors.New("sip.dtmf.server can only output SipDTMFResponse or SipAudioFileResponse")
 }
+
+func (scs *SIPCallServer) Stop() {
+	if scs.cancel != nil {
+		defer scs.cancel()
+	}
+	scs.uaMu.Lock()
+	defer scs.uaMu.Unlock()
+	if scs.ua != nil {
+		scs.ua.Close()
+	}
+}

internal/module/sip-dtmf-server.go

@@ -2,6 +2,7 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -15,20 +16,127 @@ import (
 	"github.com/emiago/diago/media"
 	"github.com/emiago/sipgo"
 	"github.com/emiago/sipgo/sip"
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"github.com/jwetzell/showbridge-go/internal/processor"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "sip.dtmf.server",
+		Title: "SIP DTMF Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:       "IP",
+					Description: "the IP address to bind the SIP server to",
+					Type:        "string",
+					Default:     json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port for the SIP server to listen on",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1024),
+					Maximum:     jsonschema.Ptr[float64](65535),
+					Default:     json.RawMessage(`5060`),
+				},
+				"transport": {
+					Title:       "Transport",
+					Description: "the transport protocol to use for the SIP server",
+					Type:        "string",
+					Enum:        []any{"udp", "tcp", "ws", "udp4", "tcp4"},
+					Default:     json.RawMessage(`"udp"`),
+				},
+				"userAgent": {
+					Title:       "User Agent",
+					Description: "the user agent string to use",
+					Type:        "string",
+					Default:     json.RawMessage(`"showbridge"`),
+				},
+				"separator": {
+					Title:       "DTMF Separator",
+					Description: "the DTMF character to use as a separator between DTMF digit groups",
+					Type:        "string",
+					MinLength:   new(1),
+					MaxLength:   new(1),
+				},
+			},
+			Required:             []string{"separator"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
+			params := moduleConfig.Params
+
+			portNum, err := params.GetInt("port")
+			if err != nil {
+
+				if errors.Is(err, config.ErrParamNotFound) {
+					portNum = 5060
+				} else {
+					return nil, fmt.Errorf("sip.dtmf.server port error: %w", err)
+				}
+			}
+
+			ipString, err := params.GetString("ip")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					ipString = "0.0.0.0"
+				} else {
+					return nil, fmt.Errorf("sip.dtmf.server ip error: %w", err)
+				}
+			}
+
+			transportString, err := params.GetString("transport")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					transportString = "udp"
+				} else {
+					return nil, fmt.Errorf("sip.dtmf.server transport error: %w", err)
+				}
+			}
+
+			userAgentString, err := params.GetString("userAgent")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					userAgentString = "showbridge"
+				} else {
+					return nil, fmt.Errorf("sip.dtmf.server userAgent error: %w", err)
+				}
+			}
+
+			separatorString, err := params.GetString("separator")
+			if err != nil {
+				return nil, fmt.Errorf("sip.dtmf.server separator error: %w", err)
+			}
+
+			if len(separatorString) != 1 {
+				return nil, errors.New("sip.dtmf.server separator must be a single character")
+			}
+
+			if !strings.ContainsRune("0123456789*#ABCD", rune(separatorString[0])) {
+				return nil, errors.New("sip.dtmf.server separator must be a valid DTMF character")
+			}
+			return &SIPDTMFServer{config: moduleConfig, IP: ipString, Port: int(portNum), Transport: transportString, UserAgent: userAgentString, Separator: separatorString, logger: CreateLogger(moduleConfig)}, nil
+		},
+	})
+}
+
 type SIPDTMFServer struct {
 	config       config.ModuleConfig
 	ctx          context.Context
-	router    route.RouteIO
+	inputHandler common.InputHandler
 	IP           string
 	Port         int
 	Transport    string
+	UserAgent    string
 	Separator    string
 	logger       *slog.Logger
+	cancel       context.CancelFunc
+	ua           *sipgo.UserAgent
+	uaMu         sync.Mutex
 }
 
 type SIPDTMFMessage struct {
@@ -41,75 +149,6 @@ type SIPDTMFCall struct {
 	lock     sync.Mutex
 }
 
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "sip.dtmf.server",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			params := config.Params
-			portNum := 5060
-
-			port, ok := params["port"]
-			if ok {
-				specificPortNum, ok := port.(float64)
-
-				if !ok {
-					return nil, errors.New("sip.dtmf.server port must be a number")
-				}
-				portNum = int(specificPortNum)
-			}
-
-			ipString := "0.0.0.0"
-
-			ip, ok := params["ip"]
-			if ok {
-
-				specificIpString, ok := ip.(string)
-
-				if !ok {
-					return nil, errors.New("sip.dtmf.server ip must be a string")
-				}
-				ipString = specificIpString
-			}
-
-			transportString := "udp"
-
-			transport, ok := params["transport"]
-			if ok {
-
-				specificTransportString, ok := transport.(string)
-
-				if !ok {
-					return nil, errors.New("sip.dtmf.server transport must be a string")
-				}
-				transportString = specificTransportString
-			}
-
-			separator, ok := params["separator"]
-			if !ok {
-				return nil, errors.New("sip.dtmf.server requires a separator parameter")
-			}
-			separatorString, ok := separator.(string)
-			if !ok {
-				return nil, errors.New("sip.dtmf.server separator must be a string")
-			}
-
-			if len(separatorString) != 1 {
-				return nil, errors.New("sip.dtmf.server separator must be a single character")
-			}
-
-			if !strings.ContainsRune("0123456789*#ABCD", rune(separatorString[0])) {
-				return nil, errors.New("sip.dtmf.server separator must be a valid DTMF character")
-			}
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("sip.dtmf.server unable to get router from context")
-			}
-			return &SIPDTMFServer{config: config, ctx: ctx, router: router, IP: ipString, Port: int(portNum), Transport: transportString, Separator: separatorString, logger: CreateLogger(config)}, nil
-		},
-	})
-}
-
 func (sds *SIPDTMFServer) Id() string {
 	return sds.config.Id
 }
@@ -118,14 +157,24 @@ func (sds *SIPDTMFServer) Type() string {
 	return sds.config.Type
 }
 
-func (sds *SIPDTMFServer) Run() error {
+func (sds *SIPDTMFServer) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	sds.logger.Debug("running")
+	sds.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	sds.ctx = moduleContext
+	sds.cancel = cancel
+
 	diagoLogger := slog.New(slog.NewJSONHandler(io.Discard, nil))
 
 	ua, _ := sipgo.NewUA(
+		sipgo.WithUserAgent(sds.UserAgent),
 		sipgo.WithUserAgentTransportLayerOptions(sip.WithTransportLayerLogger(diagoLogger)),
 		sipgo.WithUserAgentTransactionLayerOptions(sip.WithTransactionLayerLogger(diagoLogger)),
 	)
-	defer ua.Close()
+
+	sds.uaMu.Lock()
+	sds.ua = ua
+	sds.uaMu.Unlock()
 
 	sip.SetDefaultLogger(diagoLogger)
 	media.SetDefaultLogger(diagoLogger)
@@ -155,16 +204,19 @@ func (sds *SIPDTMFServer) HandleCall(inDialog *diago.DialogServerSession) error
 	inDialog.Ringing()
 	inDialog.Answer()
 
-	reader := inDialog.AudioReaderDTMF()
+	reader, err := inDialog.AudioReaderDTMF()
+	if err != nil {
+		return err
+	}
 	userString := ""
 
 	return reader.Listen(func(dtmf rune) error {
 		if dtmf == rune(sds.Separator[0]) {
-			if sds.router != nil {
+			if sds.inputHandler != nil {
 				dialogContext := context.WithValue(sds.ctx, sipCallContextKey("call"), &SIPDTMFCall{
 					inDialog: inDialog,
 				})
-				sds.router.HandleInput(dialogContext, sds.Id(), SIPDTMFMessage{
+				sds.inputHandler(dialogContext, sds.Id(), SIPDTMFMessage{
 					To:     inDialog.ToUser(),
 					Digits: userString,
 				})
@@ -194,10 +246,13 @@ func (sds *SIPDTMFServer) Output(ctx context.Context, payload any) error {
 		return errors.New("sip.dtmf.server inDialog already ended")
 	}
 
-	payloadDTMFResponse, ok := payload.(processor.SipDTMFResponse)
+	payloadDTMFResponse, ok := common.GetAnyAs[processor.SipDTMFResponse](payload)
 
 	if ok {
-		dtmfWriter := call.inDialog.AudioWriterDTMF()
+		dtmfWriter, err := call.inDialog.AudioWriterDTMF()
+		if err != nil {
+			return err
+		}
 
 		time.Sleep(time.Millisecond * time.Duration(payloadDTMFResponse.PreWait))
 		for i, dtmfRune := range payloadDTMFResponse.Digits {
@@ -207,11 +262,11 @@ func (sds *SIPDTMFServer) Output(ctx context.Context, payload any) error {
 				return fmt.Errorf("sip.dtmf.server error output dtmf digit at index %d", i)
 			}
 		}
-		time.Sleep(time.Millisecond * time.Duration(payloadDTMFResponse.PreWait))
+		time.Sleep(time.Millisecond * time.Duration(payloadDTMFResponse.PostWait))
 		return nil
 	}
 
-	payloadAudioFileResponse, ok := payload.(processor.SipAudioFileResponse)
+	payloadAudioFileResponse, ok := common.GetAnyAs[processor.SipAudioFileResponse](payload)
 
 	if ok {
 		audioFile, err := os.Open(payloadAudioFileResponse.AudioFile)
@@ -240,3 +295,14 @@ func (sds *SIPDTMFServer) Output(ctx context.Context, payload any) error {
 
 	return errors.New("sip.dtmf.server can only output SipDTMFResponse or SipAudioFileResponse")
 }
+
+func (sds *SIPDTMFServer) Stop() {
+	if sds.cancel != nil {
+		defer sds.cancel()
+	}
+	sds.uaMu.Lock()
+	defer sds.uaMu.Unlock()
+	if sds.ua != nil {
+		sds.ua.Close()
+	}
+}

internal/module/tcp-client.go

@@ -6,49 +6,54 @@ import (
 	"fmt"
 	"log/slog"
 	"net"
+	"sync"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"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 config.ModuleConfig
-	framer framer.Framer
-	conn   *net.TCPConn
-	ctx    context.Context
-	router route.RouteIO
-	Addr   *net.TCPAddr
-	logger *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "net.tcp.client",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "TCP Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"host": {
+					Title:       "Host",
+					Description: "the hostname or IP address of the TCP server to connect to",
+					Type:        "string",
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port of the TCP server to connect to",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1),
+					Maximum:     jsonschema.Ptr[float64](65535),
+				},
+				"framing": {
+					Title:       "Framing Method",
+					Description: "the method used to frame messages over the TCP connection",
+					Type:        "string",
+					Enum:        []any{"LF", "CR", "CRLF", "SLIP", "RAW"},
+				},
+			},
+			Required:             []string{"host", "port", "framing"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
-			host, ok := params["host"]
+			hostString, err := params.GetString("host")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("net.tcp.client host error: %w", err)
-				return nil, errors.New("net.tcp.client requires a host parameter")
 			}
 
-			hostString, ok := host.(string)
+			portNum, err := params.GetInt("port")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("net.tcp.client port error: %w", err)
-				return nil, errors.New("net.tcp.client host must be string")
-			}
-
-			port, ok := params["port"]
-			if !ok {
-				return nil, errors.New("net.tcp.client requires a port parameter")
-			}
-
-			portNum, ok := port.(float64)
-
-			if !ok {
-				return nil, errors.New("net.tcp.client port must be a number")
 			}
 
 			addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", hostString, uint16(portNum)))
@@ -56,36 +61,36 @@ func init() {
 				return nil, err
 			}
 
-			framingMethod := "RAW"
+			framingMethodString, err := params.GetString("framing")
-
+			if err != nil {
-			framingMethodRaw, ok := params["framing"]
+				return nil, fmt.Errorf("net.tcp.client framing error: %w", err)
-
-			if ok {
-				framingMethodString, ok := framingMethodRaw.(string)
-
-				if !ok {
-					return nil, errors.New("net.tcp.client framing method must be a string")
-				}
-				framingMethod = framingMethodString
 			}
 
-			framer := framer.GetFramer(framingMethod)
+			inFramer := framer.GetFramer(framingMethodString)
 
-			if framer == nil {
+			if inFramer == nil {
-				return nil, fmt.Errorf("net.tcp.client unknown framing method: %s", framingMethod)
+				return nil, fmt.Errorf("net.tcp.client unknown framing method: %s", framingMethodString)
 			}
 
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
+			outFramer := framer.GetFramer(framingMethodString)
-
+			return &TCPClient{inFramer: inFramer, outFramer: outFramer, Addr: addr, config: config, logger: CreateLogger(config)}, nil
-			if !ok {
-				return nil, errors.New("net.tcp.client unable to get router from context")
-			}
-
-			return &TCPClient{framer: framer, Addr: addr, config: config, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type TCPClient struct {
+	config       config.ModuleConfig
+	inFramer     framer.Framer
+	outFramer    framer.Framer
+	conn         *net.TCPConn
+	ctx          context.Context
+	inputHandler common.InputHandler
+	Addr         *net.TCPAddr
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	connMu       sync.Mutex
+}
+
 func (tc *TCPClient) Id() string {
 	return tc.config.Id
 }
@@ -94,23 +99,19 @@ func (tc *TCPClient) Type() string {
 	return tc.config.Type
 }
 
-func (tc *TCPClient) Run() error {
+func (tc *TCPClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	tc.logger.Debug("running")
+	tc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	tc.ctx = moduleContext
+	tc.cancel = cancel
 
-	// TODO(jwetzell): shutdown with router.Context properly
+CONNECT_RETRY:
-	go func() {
+	for tc.ctx.Err() == nil {
-		<-tc.ctx.Done()
-		tc.logger.Debug("done")
-		if tc.conn != nil {
-			tc.conn.Close()
-		}
-	}()
-
-	for {
 		err := tc.SetupConn()
 		if err != nil {
 			if tc.ctx.Err() != nil {
-				tc.logger.Debug("done")
+				break CONNECT_RETRY
-				return nil
 			}
 			tc.logger.Error("connection error", "error", err.Error())
 			time.Sleep(time.Second * 2)
@@ -118,61 +119,82 @@ func (tc *TCPClient) Run() error {
 		}
 
 		buffer := make([]byte, 1024)
-		select {
+
-		case <-tc.ctx.Done():
-			tc.logger.Debug("done")
-			return nil
-		default:
 	READ:
-			for {
+		for tc.ctx.Err() == nil {
-				select {
+			tc.conn.SetReadDeadline(time.Now().Add(time.Millisecond * 200))
-				case <-tc.ctx.Done():
-					tc.logger.Debug("done")
-					return nil
-				default:
 			byteCount, err := tc.conn.Read(buffer)
 
 			if err != nil {
-						tc.framer.Clear()
+				opErr, ok := err.(*net.OpError)
+				if ok {
+					//NOTE(jwetzell) we hit deadline
+					if opErr.Timeout() {
+						continue
+					}
+				}
+				if errors.Is(err, net.ErrClosed) {
+					break CONNECT_RETRY
+				}
 				break READ
 			}
 
-					if tc.framer != nil {
+			if tc.inFramer != nil {
 				if byteCount > 0 {
-							messages := tc.framer.Decode(buffer[0:byteCount])
+					messages := tc.inFramer.Decode(buffer[0:byteCount])
 					for _, message := range messages {
-								if tc.router != nil {
+						if tc.inputHandler != nil {
-									tc.router.HandleInput(tc.ctx, tc.Id(), message)
+							tc.inputHandler(tc.ctx, tc.Id(), message)
 						} else {
-									tc.logger.Error("input received but no router is configured")
+							tc.logger.Error("input received but no input handler is configured")
-								}
-							}
 						}
 					}
 				}
 			}
 		}
 	}
+	<-tc.ctx.Done()
+	tc.logger.Debug("done")
+	return nil
 }
 
 func (tc *TCPClient) SetupConn() error {
+	tc.connMu.Lock()
+	defer tc.connMu.Unlock()
 	client, err := net.DialTCP("tcp", nil, tc.Addr)
 	tc.conn = client
 	return err
 }
 
 func (tc *TCPClient) Output(ctx context.Context, payload any) error {
-	// NOTE(jwetzell): not sure how this would occur but
+	tc.connMu.Lock()
+	defer tc.connMu.Unlock()
 	if tc.conn == nil {
-		err := tc.SetupConn()
+		return errors.New("net.tcp.client client is not setup")
-		if err != nil {
-			return err
 	}
-	}
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
-	payloadBytes, ok := payload.([]byte)
 	if !ok {
 		return errors.New("net.tcp.client is only able to output bytes")
 	}
-	_, err := tc.conn.Write(tc.framer.Encode(payloadBytes))
+	_, err := tc.conn.Write(tc.inFramer.Encode(payloadBytes))
 	return err
 }
+
+func (tc *TCPClient) Stop() {
+	if tc.cancel != nil {
+		defer tc.cancel()
+	}
+	tc.connMu.Lock()
+	defer tc.connMu.Unlock()
+	if tc.conn != nil {
+		tc.conn.Close()
+	}
+
+	if tc.inFramer != nil {
+		tc.inFramer.Clear()
+	}
+
+	if tc.outFramer != nil {
+		tc.outFramer.Clear()
+	}
+}

internal/module/tcp-server.go

@@ -2,97 +2,114 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
 	"net"
 	"slices"
+	"strings"
 	"sync"
-	"syscall"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"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
-	logger        *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "net.tcp.server",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "TCP Server",
-			params := config.Params
+		ParamsSchema: &jsonschema.Schema{
-			port, ok := params["port"]
+			Type: "object",
-			if !ok {
+			Properties: map[string]*jsonschema.Schema{
-				return nil, errors.New("net.tcp.server requires a port parameter")
+				"ip": {
+					Title:       "IP",
+					Description: "the IP address to bind the TCP server to",
+					Type:        "string",
+					Default:     json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port for the TCP server to listen on",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1024),
+					Maximum:     jsonschema.Ptr[float64](65535),
+				},
+				"framing": {
+					Title:       "Framing Method",
+					Description: "the method used to frame messages over the TCP connection",
+					Type:        "string",
+					Enum:        []any{"LF", "CR", "CRLF", "SLIP", "RAW"},
+				},
+			},
+			Required:             []string{"port", "framing"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
+			params := moduleConfig.Params
+			portNum, err := params.GetInt("port")
+			if err != nil {
+				return nil, fmt.Errorf("net.tcp.server port error: %w", err)
 			}
 
-			portNum, ok := port.(float64)
+			framingMethodString, err := params.GetString("framing")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("net.tcp.server framing error: %w", err)
-				return nil, errors.New("net.tcp.server port must be a number")
 			}
 
-			framingMethod := "RAW"
+			inFramer := framer.GetFramer(framingMethodString)
 
-			framingMethodRaw, ok := params["framing"]
+			if inFramer == nil {
-
+				return nil, fmt.Errorf("net.tcp.server unknown framing method: %s", framingMethodString)
-			if ok {
-				framingMethodString, ok := framingMethodRaw.(string)
-
-				if !ok {
-					return nil, errors.New("net.tcp.server framing method must be a string")
-				}
-				framingMethod = framingMethodString
 			}
 
-			framer := framer.GetFramer(framingMethod)
+			outFramer := framer.GetFramer(framingMethodString)
 
-			if framer == nil {
+			ipString, err := params.GetString("ip")
-				return nil, fmt.Errorf("net.tcp.server unknown framing method: %s", framingMethod)
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					ipString = "0.0.0.0"
+				} else {
+					return nil, fmt.Errorf("net.tcp.server ip error: %w", err)
 				}
-
-			ipString := "0.0.0.0"
-
-			ip, ok := params["ip"]
-			if ok {
-
-				specificIpString, ok := ip.(string)
-
-				if !ok {
-					return nil, errors.New("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{inFramer: inFramer, outFramer: outFramer, framerType: framingMethodString, Addr: addr, config: moduleConfig, logger: CreateLogger(moduleConfig)}, nil
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("net.tcp.server unable to get router from context")
-			}
-
-			return &TCPServer{Framer: framer, Addr: addr, config: config, quit: make(chan interface{}), ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type tcpConnection struct {
+	conn   *net.TCPConn
+	framer framer.Framer
+}
+
+type TCPServer struct {
+	config                config.ModuleConfig
+	Addr                  *net.TCPAddr
+	inFramer              framer.Framer
+	outFramer             framer.Framer
+	framerType            string
+	ctx                   context.Context
+	inputHandler          common.InputHandler
+	wg                    sync.WaitGroup
+	connections           []tcpConnection
+	connectionsMu         sync.RWMutex
+	logger                *slog.Logger
+	cancel                context.CancelFunc
+	listener              *net.TCPListener
+	listenerMu            sync.Mutex
+	connectionShutdownCtx context.Context
+	connectionShutdown    context.CancelFunc
+}
+
 func (ts *TCPServer) Id() string {
 	return ts.config.Id
 }
@@ -103,62 +120,44 @@ func (ts *TCPServer) Type() string {
 
 func (ts *TCPServer) handleClient(client *net.TCPConn) {
 	ts.connectionsMu.Lock()
-	ts.connections = append(ts.connections, client)
+	ts.connections = append(ts.connections, tcpConnection{conn: client, framer: framer.GetFramer(ts.framerType)})
 	ts.connectionsMu.Unlock()
-	ts.logger.Debug("net.tcp.server connection accepted", "remoteAddr", client.RemoteAddr().String())
+	ts.logger.Debug("connection accepted", "remoteAddr", client.RemoteAddr().String())
-	defer client.Close()
+	defer func() {
+		client.Close()
+		ts.connectionsMu.Lock()
+		for i := 0; i < len(ts.connections); i++ {
+			if ts.connections[i].conn == client {
+				ts.connections = slices.Delete(ts.connections, i, i+1)
+				break
+			}
+		}
+		ts.connectionsMu.Unlock()
+		ts.logger.Debug("connection closed", "remoteAddr", client.RemoteAddr().String())
+	}()
 
 	buffer := make([]byte, 1024)
-ClientRead:
+	for ts.ctx.Err() == nil && ts.connectionShutdownCtx.Err() == nil {
-	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 {
+			opErr, ok := err.(*net.OpError)
+			if ok {
 				//NOTE(jwetzell) we hit deadline
 				if opErr.Timeout() {
-						continue ClientRead
+					continue
+				}
 			}
-					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
 		}
-						}
+		if ts.inFramer != nil {
-						ts.logger.Debug("connection reset", "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
-						}
-					}
-					ts.logger.Debug("stream ended", "remoteAddr", client.RemoteAddr().String())
-					ts.connectionsMu.Unlock()
-				}
-				return
-			}
-			if ts.Framer != nil {
 			if byteCount > 0 {
-					messages := ts.Framer.Decode(buffer[0:byteCount])
+				messages := ts.inFramer.Decode(buffer[0:byteCount])
 				for _, message := range messages {
-						if ts.router != nil {
+					if ts.inputHandler != nil {
-							ts.router.HandleInput(ts.ctx, ts.Id(), message)
+						ts.inputHandler(ts.ctx, ts.Id(), message)
 					} else {
-							ts.logger.Error("input received but no router is configured")
+						ts.logger.Error("input received but no input handler is configured")
-						}
 					}
 				}
 			}
@@ -166,62 +165,94 @@ ClientRead:
 	}
 }
 
-func (ts *TCPServer) Run() error {
+func (ts *TCPServer) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	ts.logger.Debug("running")
+	ts.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	ts.ctx = moduleContext
+	ts.cancel = cancel
+
+	shutdownCtx, shutdownCancel := context.WithCancel(context.Background())
+	ts.connectionShutdownCtx = shutdownCtx
+	ts.connectionShutdown = shutdownCancel
+
 	listener, err := net.ListenTCP("tcp", ts.Addr)
 	if err != nil {
 		return err
 	}
+	ts.listenerMu.Lock()
+	ts.listener = listener
+	ts.listenerMu.Unlock()
 	ts.wg.Add(1)
 
-	go func() {
-		<-ts.ctx.Done()
-		close(ts.quit)
-		listener.Close()
-		ts.logger.Debug("done")
-	}()
-
 AcceptLoop:
-	for {
+	for ts.ctx.Err() == nil {
 		conn, err := listener.AcceptTCP()
 		if err != nil {
+			if errors.Is(err, net.ErrClosed) {
+				break AcceptLoop
+			}
 			select {
-			case <-ts.quit:
+			case <-ts.ctx.Done():
 				break AcceptLoop
 			default:
 				ts.logger.Debug("problem with listener", "error", err)
 			}
 		} else {
-			ts.wg.Add(1)
+			ts.wg.Go(func() {
-			go func() {
 				ts.handleClient(conn)
-				ts.wg.Done()
+			})
-			}()
 		}
 	}
 	ts.wg.Done()
-	ts.wg.Wait()
+	<-ts.ctx.Done()
+	ts.logger.Debug("done")
 	return nil
 }
 
 func (ts *TCPServer) Output(ctx context.Context, payload any) error {
-	payloadBytes, ok := payload.([]byte)
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
 
 	if !ok {
 		return errors.New("net.tcp.server is only able to output bytes")
 	}
 	ts.connectionsMu.Lock()
-	errorString := ""
+	defer ts.connectionsMu.Unlock()
+	var errorString strings.Builder
+
+	if ts.outFramer == nil {
+		return errors.New("no output framer configured")
+	}
+
+	outputBytes := ts.outFramer.Encode(payloadBytes)
 
 	for _, connection := range ts.connections {
-		_, err := connection.Write(payloadBytes)
+		_, err := connection.conn.Write(outputBytes)
 		if err != nil {
-			errorString += fmt.Sprintf("%s\n", err.Error())
+			fmt.Fprintf(&errorString, "%s\n", err.Error())
 		}
 	}
-	ts.connectionsMu.Unlock()
 
-	if errorString == "" {
+	if errorString.String() == "" {
 		return nil
 	}
-	return fmt.Errorf("net.tcp.server error during output: %s", errorString)
+	return fmt.Errorf("net.tcp.server error during output: %s", errorString.String())
+}
+
+func (ts *TCPServer) Stop() {
+	if ts.cancel != nil {
+		defer ts.cancel()
+	}
+	if ts.connectionShutdown != nil {
+		ts.connectionShutdown()
+	}
+
+	ts.listenerMu.Lock()
+	defer ts.listenerMu.Unlock()
+	if ts.listener != nil {
+		ts.listener.Close()
+	}
+	ts.logger.Debug("waiting for connections to close")
+	ts.wg.Wait()
+	ts.logger.Debug("all connections closed")
 }

internal/module/test/db-sqlite_test.go

@@ -0,0 +1,139 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestDbSqliteFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("db.sqlite")
+	if !ok {
+		t.Fatalf("db.sqlite module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "db.sqlite",
+		Params: map[string]any{
+			"dsn": ":memory:",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create db.sqlite module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("db.sqlite module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "db.sqlite" {
+		t.Fatalf("db.sqlite module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodDbSqlite(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "in memory db",
+			params: map[string]any{
+				"dsn": ":memory:",
+			},
+		},
+		{
+			name: "file db",
+			params: map[string]any{
+				"dsn": "test.db",
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("db.sqlite")
+			if !ok {
+				t.Fatalf("db.sqlite module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "db.sqlite",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("db.sqlite failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("db.sqlite failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadDbSqlite(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no dsn param",
+			params:      map[string]any{},
+			errorString: "db.sqlite dsn error: not found",
+		},
+		{
+			name:        "non-string dsn",
+			params:      map[string]any{"dsn": 123},
+			errorString: "db.sqlite dsn error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("db.sqlite")
+			if !ok {
+				t.Fatalf("db.sqlite module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "db.sqlite",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("db.sqlite got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("db.sqlite expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("db.sqlite got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/http-server_test.go

@@ -0,0 +1,134 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestHTTPServerFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("http.server")
+	if !ok {
+		t.Fatalf("http.server module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "http.server",
+		Params: map[string]any{
+			"port": 3000,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create http.server module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("http.server module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "http.server" {
+		t.Fatalf("http.server module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodHTTPServer(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "minimal config",
+			params: map[string]any{
+				"port": 8000,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("http.server")
+			if !ok {
+				t.Fatalf("http.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "http.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("http.server failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("http.server failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadHTTPServer(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no port param",
+			params:      map[string]any{},
+			errorString: "http.server port error: not found",
+		},
+		{
+			name:        "non-numeric port",
+			params:      map[string]any{"port": "3000"},
+			errorString: "http.server port error: not a number",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("http.server")
+			if !ok {
+				t.Fatalf("http.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "http.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("http.server got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("http.server expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("http.server got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/midi-input_test.go

@@ -0,0 +1,87 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestMIDIInputFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("midi.input")
+	if !ok {
+		t.Fatalf("midi.input module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "midi.input",
+		Params: map[string]any{
+			"port": "test",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create midi.input module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("midi.input module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "midi.input" {
+		t.Fatalf("midi.input module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadMIDIInput(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no port param",
+			params:      map[string]any{},
+			errorString: "midi.input port error: not found",
+		},
+		{
+			name:        "non-string port",
+			params:      map[string]any{"port": 123},
+			errorString: "midi.input port error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("midi.input")
+			if !ok {
+				t.Fatalf("midi.input module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "midi.input",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("midi.input got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("midi.input expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("midi.input got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/midi-output_test.go

@@ -0,0 +1,87 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestMIDIOutputFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("midi.output")
+	if !ok {
+		t.Fatalf("midi.output module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "midi.output",
+		Params: map[string]any{
+			"port": "test",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create midi.output module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("midi.output module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "midi.output" {
+		t.Fatalf("midi.output module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadMIDIOutput(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no port param",
+			params:      map[string]any{},
+			errorString: "midi.output port error: not found",
+		},
+		{
+			name:        "non-string port",
+			params:      map[string]any{"port": 123},
+			errorString: "midi.output port error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("midi.output")
+			if !ok {
+				t.Fatalf("midi.output module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "midi.output",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("midi.output got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("midi.output expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("midi.output got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/module_test.go

@@ -0,0 +1,63 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+	"github.com/jwetzell/showbridge-go/internal/test"
+)
+
+func TestModuleBadRegistrationNoType(t *testing.T) {
+	defer func() {
+		r := recover()
+		if r == nil {
+			t.Fatalf("module registration should have panicked but did not")
+		}
+	}()
+
+	module.RegisterModule(module.ModuleRegistration{
+		Type: "",
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			return test.NewTestModule("test"), nil
+		},
+	})
+}
+
+func TestModuleBadRegistrationNoNew(t *testing.T) {
+	defer func() {
+		r := recover()
+		if r == nil {
+			t.Fatalf("processor registration should have panicked but did not")
+		}
+	}()
+
+	module.RegisterModule(module.ModuleRegistration{
+		Type: "module.test",
+		New:  nil,
+	})
+}
+
+func TestModuleBadRegistrationExistingType(t *testing.T) {
+	defer func() {
+		r := recover()
+		if r == nil {
+			t.Fatalf("processor registration should have panicked but did not")
+		}
+	}()
+
+	module.RegisterModule(module.ModuleRegistration{
+		Type: "module.test",
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			return test.NewTestModule("test"), nil
+		},
+	})
+
+	module.RegisterModule(module.ModuleRegistration{
+		Type: "module.test",
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			return test.NewTestModule("test"), nil
+		},
+	})
+}

internal/module/test/mqtt-client_test.go

@@ -0,0 +1,130 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestMQTTClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("mqtt.client")
+	if !ok {
+		t.Fatalf("mqtt.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "mqtt.client",
+		Params: map[string]any{
+			"broker":   "mqtt://localhost:1883",
+			"topic":    "test/topic",
+			"clientId": "test",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create mqtt.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("mqtt.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "mqtt.client" {
+		t.Fatalf("mqtt.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadMQTTClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no broker param",
+			params: map[string]any{
+				"topic":    "test/topic",
+				"clientId": "test",
+			},
+			errorString: "mqtt.client broker error: not found",
+		},
+		{
+			name: "non-string broker",
+			params: map[string]any{
+				"broker":   123,
+				"topic":    "test/topic",
+				"clientId": "test",
+			},
+			errorString: "mqtt.client broker error: not a string",
+		},
+		{
+			name: "no topic param",
+			params: map[string]any{
+				"broker":   "mqtt://localhost:1883",
+				"clientId": "test",
+			},
+			errorString: "mqtt.client topic error: not found",
+		},
+		{
+			name: "non-string topic",
+			params: map[string]any{
+				"broker":   "mqtt://localhost:1883",
+				"topic":    123,
+				"clientId": "test",
+			},
+			errorString: "mqtt.client topic error: not a string",
+		},
+		{
+			name: "no clientId param",
+			params: map[string]any{
+				"broker": "mqtt://localhost:1883",
+				"topic":  "test/topic",
+			},
+			errorString: "mqtt.client clientId error: not found",
+		},
+		{
+			name: "non-string clientId",
+			params: map[string]any{
+				"broker":   "mqtt://localhost:1883",
+				"topic":    "test/topic",
+				"clientId": 123,
+			},
+			errorString: "mqtt.client clientId error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("mqtt.client")
+			if !ok {
+				t.Fatalf("mqtt.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "mqtt.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("mqtt.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("mqtt.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("mqtt.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/nats-client_test.go

@@ -0,0 +1,108 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestNATSClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("nats.client")
+	if !ok {
+		t.Fatalf("nats.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "nats.client",
+		Params: map[string]any{
+			"url":     "nats://127.0.0.1:4222",
+			"subject": "test",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create nats.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("nats.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "nats.client" {
+		t.Fatalf("nats.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadNATSClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no url param",
+			params: map[string]any{
+				"subject": "test/subject",
+			},
+			errorString: "nats.client url error: not found",
+		},
+		{
+			name: "non-string url",
+			params: map[string]any{
+				"url":     123,
+				"subject": "test/subject",
+			},
+			errorString: "nats.client url error: not a string",
+		},
+		{
+			name: "no subject param",
+			params: map[string]any{
+				"url": "nats://127.0.0.1:4222",
+			},
+			errorString: "nats.client subject error: not found",
+		},
+		{
+			name: "non-string subject",
+			params: map[string]any{
+				"url":     "nats://127.0.0.1:4222",
+				"subject": 123,
+			},
+			errorString: "nats.client subject error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("nats.client")
+			if !ok {
+				t.Fatalf("nats.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "nats.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("nats.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("nats.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("nats.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/nats-server_test.go

@@ -0,0 +1,132 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestNATSServerFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("nats.server")
+	if !ok {
+		t.Fatalf("nats.server module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "nats.server",
+		Params: map[string]any{
+			"ip":   "127.0.0.1",
+			"port": 4222,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create nats.server module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("nats.server module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "nats.server" {
+		t.Fatalf("nats.server module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodNATSServer(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "minimal config",
+			params: map[string]any{
+				"port": 4222,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("nats.server")
+			if !ok {
+				t.Fatalf("nats.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "nats.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("nats.server failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("nats.server failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadNATSServer(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "non-string ip",
+			params: map[string]any{
+				"ip": 123,
+			},
+			errorString: "nats.server ip error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("nats.server")
+			if !ok {
+				t.Fatalf("nats.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "nats.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("nats.server got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("nats.server expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("nats.server got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/psn-client_test.go

@@ -0,0 +1,73 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestPSNClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("psn.client")
+	if !ok {
+		t.Fatalf("psn.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "psn.client",
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create psn.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("psn.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "psn.client" {
+		t.Fatalf("psn.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadPSNClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("psn.client")
+			if !ok {
+				t.Fatalf("psn.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "psn.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("psn.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("psn.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("psn.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/redis-client_test.go

@@ -0,0 +1,108 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestRedisClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("redis.client")
+	if !ok {
+		t.Fatalf("redis.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "redis.client",
+		Params: map[string]any{
+			"host": "localhost",
+			"port": 6379,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create redis.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("redis.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "redis.client" {
+		t.Fatalf("redis.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadRedisClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no host param",
+			params: map[string]any{
+				"port": 6379,
+			},
+			errorString: "redis.client host error: not found",
+		},
+		{
+			name: "non-string host",
+			params: map[string]any{
+				"host": 123,
+				"port": 6379,
+			},
+			errorString: "redis.client host error: not a string",
+		},
+		{
+			name: "no port param",
+			params: map[string]any{
+				"host": "localhost",
+			},
+			errorString: "redis.client port error: not found",
+		},
+		{
+			name: "non-number port",
+			params: map[string]any{
+				"host": "localhost",
+				"port": "6379",
+			},
+			errorString: "redis.client port error: not a number",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("redis.client")
+			if !ok {
+				t.Fatalf("redis.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "redis.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("redis.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("redis.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("redis.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/serial-client_test.go

@@ -0,0 +1,117 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestSerialClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("serial.client")
+	if !ok {
+		t.Fatalf("serial.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "serial.client",
+		Params: map[string]any{
+			"port":     "/dev/ttyUSB0",
+			"framing":  "LF",
+			"baudRate": 9600,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create serial.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("serial.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "serial.client" {
+		t.Fatalf("serial.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadSerialClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no port param",
+			params: map[string]any{
+				"framing": "LF",
+			},
+			errorString: "serial.client port error: not found",
+		},
+		{
+			name: "non-string port param",
+			params: map[string]any{
+				"port":    8000,
+				"framing": "LF",
+			},
+			errorString: "serial.client port error: not a string",
+		},
+		{
+			name: "no framing param",
+			params: map[string]any{
+				"port": "/dev/ttyUSB0",
+			},
+			errorString: "serial.client framing error: not found",
+		},
+		{
+			name: "non-string framing param",
+			params: map[string]any{
+				"port":    "/dev/ttyUSB0",
+				"framing": 1,
+			},
+			errorString: "serial.client framing error: not a string",
+		},
+		{
+			name: "unkown framing method",
+			params: map[string]any{
+				"port":    "/dev/ttyUSB0",
+				"framing": "asdfasdfasdfasdflkj",
+			},
+			errorString: "serial.client unknown framing method: asdfasdfasdfasdflkj",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("serial.client")
+			if !ok {
+				t.Fatalf("serial.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "serial.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("serial.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("serial.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("serial.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/sip-call-server_test.go

@@ -0,0 +1,102 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestSIPCallServerFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("sip.call.server")
+	if !ok {
+		t.Fatalf("sip.call.server module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "sip.call.server",
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create sip.call.server module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("sip.call.server module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "sip.call.server" {
+		t.Fatalf("sip.call.server module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadSIPCallServer(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "non-number port param",
+			params: map[string]any{
+				"port": "8000",
+			},
+			errorString: "sip.call.server port error: not a number",
+		},
+		{
+			name: "non-string ip param",
+			params: map[string]any{
+				"ip": 123,
+			},
+			errorString: "sip.call.server ip error: not a string",
+		},
+		{
+			name: "non-string transport param",
+			params: map[string]any{
+				"transport": 123,
+			},
+			errorString: "sip.call.server transport error: not a string",
+		},
+		{
+			name: "non-string userAgent param",
+			params: map[string]any{
+				"userAgent": 123,
+			},
+			errorString: "sip.call.server userAgent error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("sip.call.server")
+			if !ok {
+				t.Fatalf("sip.call.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "sip.call.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("sip.call.server got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("sip.call.server expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("sip.call.server got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/sip-dtmf-server_test.go

@@ -0,0 +1,121 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestSIPDTMFServerFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("sip.dtmf.server")
+	if !ok {
+		t.Fatalf("sip.dtmf.server module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "sip.dtmf.server",
+		Params: map[string]any{
+			"separator": "#",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create sip.dtmf.server module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("sip.dtmf.server module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "sip.dtmf.server" {
+		t.Fatalf("sip.dtmf.server module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadSIPDTMFServer(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no separator param",
+			params:      map[string]any{},
+			errorString: "sip.dtmf.server separator error: not found",
+		},
+		{
+			name: "non-string separator param",
+			params: map[string]any{
+				"separator": 123,
+			},
+			errorString: "sip.dtmf.server separator error: not a string",
+		},
+		{
+			name: "non-number port param",
+			params: map[string]any{
+				"separator": "#",
+				"port":      "8000",
+			},
+			errorString: "sip.dtmf.server port error: not a number",
+		},
+		{
+			name: "non-string ip param",
+			params: map[string]any{
+				"separator": "#",
+				"ip":        123,
+			},
+			errorString: "sip.dtmf.server ip error: not a string",
+		},
+		{
+			name: "non-string transport param",
+			params: map[string]any{
+				"separator": "#",
+				"transport": 123,
+			},
+			errorString: "sip.dtmf.server transport error: not a string",
+		},
+		{
+			name: "non-string userAgent param",
+			params: map[string]any{
+				"separator": "#",
+				"userAgent": 123,
+			},
+			errorString: "sip.dtmf.server userAgent error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("sip.dtmf.server")
+			if !ok {
+				t.Fatalf("sip.dtmf.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "sip.dtmf.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("sip.dtmf.server got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("sip.dtmf.server expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("sip.dtmf.server got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/tcp-client_test.go

@@ -0,0 +1,109 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestTCPClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("net.tcp.client")
+	if !ok {
+		t.Fatalf("net.tcp.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "net.tcp.client",
+		Params: map[string]any{
+			"host":    "localhost",
+			"port":    8000,
+			"framing": "LF",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create net.tcp.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("net.tcp.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "net.tcp.client" {
+		t.Fatalf("net.tcp.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadTCPClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no port param",
+			params: map[string]any{
+				"host": "localhost",
+			},
+			errorString: "net.tcp.client port error: not found",
+		},
+		{
+			name: "non-number port param",
+			params: map[string]any{
+				"host": "localhost",
+				"port": "8000",
+			},
+			errorString: "net.tcp.client port error: not a number",
+		},
+		{
+			name: "no host param",
+			params: map[string]any{
+				"port": 8000,
+			},
+			errorString: "net.tcp.client host error: not found",
+		},
+		{
+			name: "non-string host param",
+			params: map[string]any{
+				"host": 123,
+				"port": 8000,
+			},
+			errorString: "net.tcp.client host error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.tcp.client")
+			if !ok {
+				t.Fatalf("net.tcp.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.tcp.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("net.tcp.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("net.tcp.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("net.tcp.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/tcp-server_test.go

@@ -0,0 +1,181 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestTCPServerFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("net.tcp.server")
+	if !ok {
+		t.Fatalf("net.tcp.server module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "net.tcp.server",
+		Params: map[string]any{
+			"port":    8000,
+			"framing": "LF",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create net.tcp.server module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("net.tcp.server module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "net.tcp.server" {
+		t.Fatalf("net.tcp.server module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodTCPServer(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "minimal config",
+			params: map[string]any{
+				"port":    8000,
+				"framing": "LF",
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.tcp.server")
+			if !ok {
+				t.Fatalf("net.tcp.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.tcp.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("net.tcp.server failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("net.tcp.server failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadTCPServer(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no port param",
+			params: map[string]any{
+				"framing": "LF",
+			},
+			errorString: "net.tcp.server port error: not found",
+		},
+		{
+			name: "non-number port param",
+			params: map[string]any{
+				"port":    "8000",
+				"framing": "LF",
+			},
+			errorString: "net.tcp.server port error: not a number",
+		},
+		{
+			name: "no framing param",
+			params: map[string]any{
+				"port": 8000,
+			},
+			errorString: "net.tcp.server framing error: not found",
+		},
+		{
+			name: "non-string framing param",
+			params: map[string]any{
+				"port":    8000,
+				"framing": 1,
+			},
+			errorString: "net.tcp.server framing error: not a string",
+		},
+		{
+			name: "unkown framing method",
+			params: map[string]any{
+				"port":    8000,
+				"framing": "asdfasdfasdfasdflkj",
+			},
+			errorString: "net.tcp.server unknown framing method: asdfasdfasdfasdflkj",
+		},
+		{
+			name: "non-string ip param",
+			params: map[string]any{
+				"port":    8000,
+				"framing": "LF",
+				"ip":      123,
+			},
+			errorString: "net.tcp.server ip error: not a string",
+		},
+		{
+			name: "invalid addr",
+			params: map[string]any{
+				"ip":      "127.0.0.",
+				"port":    8000,
+				"framing": "LF",
+			},
+			errorString: "lookup 127.0.0.: no such host",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.tcp.server")
+			if !ok {
+				t.Fatalf("net.tcp.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.tcp.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("net.tcp.server got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("net.tcp.server expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("net.tcp.server got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/time-interval_test.go

@@ -0,0 +1,135 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestTimeIntervalFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("time.interval")
+	if !ok {
+		t.Fatalf("time.interval module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "time.interval",
+		Params: map[string]any{
+			"duration": 1000,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create time.interval module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("time.interval module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "time.interval" {
+		t.Fatalf("time.interval module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodTimeInterval(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "minimal config",
+			params: map[string]any{
+				"duration": 1000,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("time.interval")
+			if !ok {
+				t.Fatalf("time.interval module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "time.interval",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("time.interval failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("time.interval failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadTimeInterval(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no duration param",
+			params:      map[string]any{},
+			errorString: "time.interval duration error: not found",
+		},
+		{
+			name: "non-number duration param",
+			params: map[string]any{
+				"duration": "8000",
+			},
+			errorString: "time.interval duration error: not a number",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("time.interval")
+			if !ok {
+				t.Fatalf("time.interval module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "time.interval",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("time.interval got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("time.interval expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("time.interval got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/time-timer_test.go

@@ -0,0 +1,135 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestTimeTimerFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("time.timer")
+	if !ok {
+		t.Fatalf("time.timer module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "time.timer",
+		Params: map[string]any{
+			"duration": 1000,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create time.timer module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("time.timer module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "time.timer" {
+		t.Fatalf("time.timer module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodTimeTimer(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "minimal config",
+			params: map[string]any{
+				"duration": 2000,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("time.timer")
+			if !ok {
+				t.Fatalf("time.timer module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "time.timer",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("time.timer failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("time.timer failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadTimeTimer(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no duration param",
+			params:      map[string]any{},
+			errorString: "time.timer duration error: not found",
+		},
+		{
+			name: "non-number duration param",
+			params: map[string]any{
+				"duration": "8000",
+			},
+			errorString: "time.timer duration error: not a number",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("time.timer")
+			if !ok {
+				t.Fatalf("time.timer module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "time.timer",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("time.timer got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("time.timer expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("time.timer got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/udp-client_test.go

@@ -0,0 +1,157 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestUDPClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("net.udp.client")
+	if !ok {
+		t.Fatalf("udp.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "net.udp.client",
+		Params: map[string]any{
+			"host":    "localhost",
+			"port":    8000,
+			"framing": "LF",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create net.udp.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("net.udp.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "net.udp.client" {
+		t.Fatalf("net.udp.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodUDPClient(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "minimal config",
+			params: map[string]any{
+				"host": "localhost",
+				"port": 8000,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.udp.client")
+			if !ok {
+				t.Fatalf("net.udp.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.udp.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("net.udp.client failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("net.udp.client failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadUDPClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no port param",
+			params: map[string]any{
+				"host": "localhost",
+			},
+			errorString: "net.udp.client port error: not found",
+		},
+		{
+			name: "non-number port param",
+			params: map[string]any{
+				"host": "localhost",
+				"port": "8000",
+			},
+			errorString: "net.udp.client port error: not a number",
+		},
+		{
+			name: "no host param",
+			params: map[string]any{
+				"port": 8000,
+			},
+			errorString: "net.udp.client host error: not found",
+		},
+		{
+			name: "non-string host param",
+			params: map[string]any{
+				"host": 123,
+				"port": 8000,
+			},
+			errorString: "net.udp.client host error: not a string",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.udp.client")
+			if !ok {
+				t.Fatalf("net.udp.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.udp.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("net.udp.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("net.udp.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("net.udp.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/udp-multicast_test.go

@@ -0,0 +1,116 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestUDPMulticastFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("net.udp.multicast")
+	if !ok {
+		t.Fatalf("udp.multicast module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "net.udp.multicast",
+		Params: map[string]any{
+			"ip":   "236.10.10.10",
+			"port": 56565,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create net.udp.multicast module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("net.udp.multicast module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "net.udp.multicast" {
+		t.Fatalf("net.udp.multicast module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadUDPMulticast(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name: "no port param",
+			params: map[string]any{
+				"ip": "localhost",
+			},
+			errorString: "net.udp.multicast port error: not found",
+		},
+		{
+			name: "non-number port param",
+			params: map[string]any{
+				"ip":   "localhost",
+				"port": "8000",
+			},
+			errorString: "net.udp.multicast port error: not a number",
+		},
+		{
+			name: "no ip param",
+			params: map[string]any{
+				"port": 8000,
+			},
+			errorString: "net.udp.multicast ip error: not found",
+		},
+		{
+			name: "non-string ip param",
+			params: map[string]any{
+				"ip":   123,
+				"port": 8000,
+			},
+			errorString: "net.udp.multicast ip error: not a string",
+		},
+		{
+			name: "invalid addr",
+			params: map[string]any{
+				"ip":   "127.0.0.",
+				"port": 8000,
+			},
+			errorString: "lookup 127.0.0.: no such host",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.udp.multicast")
+			if !ok {
+				t.Fatalf("net.udp.multicast module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.udp.multicast",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("net.udp.multicast got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("net.udp.multicast expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("net.udp.multicast got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/udp-server_test.go

@@ -0,0 +1,160 @@
+package module_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestUDPServerFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("net.udp.server")
+	if !ok {
+		t.Fatalf("net.udp.server module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "net.udp.server",
+		Params: map[string]any{
+			"port": 8000,
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create udp.server module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("udp.server module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "net.udp.server" {
+		t.Fatalf("net.udp.server module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestGoodUDPServer(t *testing.T) {
+
+	testCases := []struct {
+		name   string
+		params map[string]any
+	}{
+		{
+			name: "minimal config",
+			params: map[string]any{
+				"port": 8000,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.udp.server")
+			if !ok {
+				t.Fatalf("net.udp.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.udp.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("net.udp.server failed to create module: %s", err)
+			}
+			// TODO(jwetzell) this is kind of hacky
+			go func() {
+				time.Sleep(1 * time.Second)
+				moduleInstance.Stop()
+			}()
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err != nil {
+				t.Fatalf("net.udp.server failed to start: %s", err)
+			}
+		})
+	}
+}
+
+func TestBadUDPServer(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no port param",
+			params:      map[string]any{},
+			errorString: "net.udp.server port error: not found",
+		},
+		{
+			name: "non-number port param",
+			params: map[string]any{
+				"port": "8000",
+			},
+			errorString: "net.udp.server port error: not a number",
+		},
+		{
+			name: "non-string ip param",
+			params: map[string]any{
+				"port": 8000,
+				"ip":   123,
+			},
+			errorString: "net.udp.server ip error: not a string",
+		},
+		{
+			name: "non-number bufferSize param",
+			params: map[string]any{
+				"port":       8000,
+				"bufferSize": "1024",
+			},
+			errorString: "net.udp.server bufferSize error: not a number",
+		},
+		{
+			name: "invalid addr",
+			params: map[string]any{
+				"ip":   "127.0.0.",
+				"port": 8000,
+			},
+			errorString: "lookup 127.0.0.: no such host",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("net.udp.server")
+			if !ok {
+				t.Fatalf("net.udp.server module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "net.udp.server",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("net.udp.server got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("net.udp.server expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("net.udp.server got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/test/websocket-client_test.go

@@ -0,0 +1,96 @@
+package module_test
+
+import (
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/module"
+)
+
+func TestWebSocketClientFromRegistry(t *testing.T) {
+	registration, ok := module.GetModuleRegistration("websocket.client")
+	if !ok {
+		t.Fatalf("websocket.client module not registered")
+	}
+
+	moduleInstance, err := registration.New(config.ModuleConfig{
+		Id:   "test",
+		Type: "websocket.client",
+		Params: map[string]any{
+			"url": "ws://localhost",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create websocket.client module: %s", err)
+	}
+
+	if moduleInstance.Id() != "test" {
+		t.Fatalf("websocket.client module has wrong id: %s", moduleInstance.Id())
+	}
+
+	if moduleInstance.Type() != "websocket.client" {
+		t.Fatalf("websocket.client module has wrong type: %s", moduleInstance.Type())
+	}
+}
+
+func TestBadWebSocketClient(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		errorString string
+	}{
+		{
+			name:        "no url param",
+			params:      map[string]any{},
+			errorString: "websocket.client url error: not found",
+		},
+		{
+			name: "non-string url param",
+			params: map[string]any{
+				"url": 123,
+			},
+			errorString: "websocket.client url error: not a string",
+		},
+		{
+			name: "invalid url param",
+			params: map[string]any{
+				"url": "invalid-url",
+			},
+			errorString: "websocket.client url error: scheme must be ws or wss",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := module.GetModuleRegistration("websocket.client")
+			if !ok {
+				t.Fatalf("websocket.client module not registered")
+			}
+
+			moduleInstance, err := registration.New(config.ModuleConfig{
+				Id:     "test",
+				Type:   "websocket.client",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("websocket.client got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			err = moduleInstance.Start(t.Context(), nil)
+
+			if err == nil {
+				t.Fatalf("websocket.client expected to fail")
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("websocket.client got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/module/time-interval.go

@@ -2,49 +2,51 @@ package module
 
 import (
 	"context"
-	"errors"
+	"fmt"
 	"log/slog"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "time.interval",
+		Title: "Interval",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"duration": {
+					Title:       "Duration",
+					Description: "time in milliseconds between emitted events",
+					Type:        "integer",
+				},
+			},
+			Required:             []string{"duration"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			params := config.Params
+
+			durationInt, err := params.GetInt("duration")
+			if err != nil {
+				return nil, fmt.Errorf("time.interval duration error: %w", err)
+			}
+			return &TimeInterval{Duration: uint32(durationInt), config: config, logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
 type TimeInterval struct {
 	config       config.ModuleConfig
 	Duration     uint32
 	ctx          context.Context
-	router   route.RouteIO
+	inputHandler common.InputHandler
 	ticker       *time.Ticker
 	logger       *slog.Logger
-}
+	cancel       context.CancelFunc
-
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "time.interval",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			params := config.Params
-
-			duration, ok := params["duration"]
-			if !ok {
-				return nil, errors.New("time.interval requires a duration parameter")
-			}
-
-			durationNum, ok := duration.(float64)
-
-			if !ok {
-				return nil, errors.New("time.interval duration must be number")
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("time.interval unable to get router from context")
-			}
-
-			return &TimeInterval{Duration: uint32(durationNum), config: config, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
-		},
-	})
 }
 
 func (i *TimeInterval) Id() string {
@@ -55,26 +57,36 @@ func (i *TimeInterval) Type() string {
 	return i.config.Type
 }
 
-func (i *TimeInterval) Run() error {
+func (i *TimeInterval) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	i.logger.Debug("running")
+	i.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	i.ctx = moduleContext
+	i.cancel = cancel
+
 	ticker := time.NewTicker(time.Millisecond * time.Duration(i.Duration))
 	i.ticker = ticker
-	defer ticker.Stop()
 
-	for {
+	for i.ctx.Err() == nil {
 		select {
-		case <-i.ctx.Done():
+		case <-ticker.C:
+			if i.inputHandler != nil {
+				i.inputHandler(i.ctx, i.Id(), time.Now())
+			}
+		default:
+			continue
+		}
+	}
+	<-i.ctx.Done()
 	i.logger.Debug("done")
 	return nil
-		case <-ticker.C:
-			if i.router != nil {
-				i.router.HandleInput(i.ctx, i.Id(), time.Now())
-			}
-		}
 }
 
+func (i *TimeInterval) Stop() {
+	if i.cancel != nil {
+		defer i.cancel()
+	}
+	if i.ticker != nil {
+		i.ticker.Stop()
 	}
-
-func (i *TimeInterval) Output(ctx context.Context, payload any) error {
-	i.ticker.Reset(time.Millisecond * time.Duration(i.Duration))
-	return nil
 }

internal/module/time-timer.go

@@ -2,49 +2,52 @@ package module
 
 import (
 	"context"
-	"errors"
+	"fmt"
 	"log/slog"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "time.timer",
+		Title: "Timer",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"duration": {
+					Title:       "Duration",
+					Description: "time in milliseconds before the timer fires",
+					Type:        "integer",
+				},
+			},
+			Required:             []string{"duration"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			params := config.Params
+
+			durationNum, err := params.GetInt("duration")
+			if err != nil {
+				return nil, fmt.Errorf("time.timer duration error: %w", err)
+			}
+
+			return &TimeTimer{Duration: uint32(durationNum), config: config, logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
 type TimeTimer struct {
 	config       config.ModuleConfig
 	Duration     uint32
 	ctx          context.Context
-	router   route.RouteIO
+	inputHandler common.InputHandler
 	timer        *time.Timer
 	logger       *slog.Logger
-}
+	cancel       context.CancelFunc
-
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "time.timer",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			params := config.Params
-
-			duration, ok := params["duration"]
-			if !ok {
-				return nil, errors.New("time.timer requires a duration parameter")
-			}
-
-			durationNum, ok := duration.(float64)
-
-			if !ok {
-				return nil, errors.New("time.timer duration must be a number")
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("net.tcp.client unable to get router from context")
-			}
-
-			return &TimeTimer{Duration: uint32(durationNum), config: config, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
-		},
-	})
 }
 
 func (t *TimeTimer) Id() string {
@@ -55,24 +58,34 @@ func (t *TimeTimer) Type() string {
 	return t.config.Type
 }
 
-func (t *TimeTimer) Run() error {
+func (t *TimeTimer) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	t.logger.Debug("running")
+	t.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	t.ctx = moduleContext
+	t.cancel = cancel
+
 	t.timer = time.NewTimer(time.Millisecond * time.Duration(t.Duration))
-	defer t.timer.Stop()
+	for t.ctx.Err() == nil {
-	for {
 		select {
 		case <-t.ctx.Done():
-			t.timer.Stop()
-			t.logger.Debug("done")
 			return nil
 		case time := <-t.timer.C:
-			if t.router != nil {
+			if t.inputHandler != nil {
-				t.router.HandleInput(t.ctx, t.Id(), time)
+				t.inputHandler(t.ctx, t.Id(), time)
 			}
 		}
 	}
-}
+	<-t.ctx.Done()
-
+	t.logger.Debug("done")
-func (t *TimeTimer) Output(ctx context.Context, payload any) error {
-	t.timer.Reset(time.Millisecond * time.Duration(t.Duration))
 	return nil
 }
+
+func (t *TimeTimer) Stop() {
+	if t.cancel != nil {
+		defer t.cancel()
+	}
+	if t.timer != nil {
+		t.timer.Stop()
+	}
+}

internal/module/udp-client.go

@@ -6,63 +6,67 @@ import (
 	"fmt"
 	"log/slog"
 	"net"
+	"sync"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "net.udp.client",
+		Title: "UDP Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"host": {
+					Title:       "Host",
+					Description: "the hostname or IP address of the UDP server to connect to",
+					Type:        "string",
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port of the UDP server to connect to",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1),
+					Maximum:     jsonschema.Ptr[float64](65535),
+				},
+			},
+			Required:             []string{"host", "port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			params := config.Params
+			hostString, err := params.GetString("host")
+			if err != nil {
+				return nil, fmt.Errorf("net.udp.client host error: %w", err)
+			}
+
+			portNum, err := params.GetInt("port")
+			if err != nil {
+				return nil, fmt.Errorf("net.udp.client port error: %w", err)
+			}
+
+			addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", hostString, uint16(portNum)))
+			if err != nil {
+				return nil, err
+			}
+			return &UDPClient{Addr: addr, config: config, logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
 type UDPClient struct {
 	config       config.ModuleConfig
 	Addr         *net.UDPAddr
 	Port         uint16
 	conn         *net.UDPConn
 	ctx          context.Context
-	router route.RouteIO
+	inputHandler common.InputHandler
 	logger       *slog.Logger
-}
+	cancel       context.CancelFunc
-
+	connMu       sync.Mutex
-func init() {
-	RegisterModule(ModuleRegistration{
-		Type: "net.udp.client",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			params := config.Params
-			host, ok := params["host"]
-
-			if !ok {
-				return nil, errors.New("net.udp.client requires a host parameter")
-			}
-
-			hostString, ok := host.(string)
-
-			if !ok {
-				return nil, errors.New("net.udp.client host must be a string")
-			}
-
-			port, ok := params["port"]
-			if !ok {
-				return nil, errors.New("net.udp.client requires a port parameter")
-			}
-
-			portNum, ok := port.(float64)
-
-			if !ok {
-				return nil, errors.New("net.udp.client port must be a number")
-			}
-
-			addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", hostString, uint16(portNum)))
-			if err != nil {
-				return nil, err
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("net.udp.client unable to get router from context")
-			}
-
-			return &UDPClient{Addr: addr, config: config, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
-		},
-	})
 }
 
 func (uc *UDPClient) Id() string {
@@ -74,12 +78,19 @@ func (uc *UDPClient) Type() string {
 }
 
 func (uc *UDPClient) SetupConn() error {
+	uc.connMu.Lock()
+	defer uc.connMu.Unlock()
 	client, err := net.DialUDP("udp", nil, uc.Addr)
 	uc.conn = client
 	return err
 }
 
-func (uc *UDPClient) Run() error {
+func (uc *UDPClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	uc.logger.Debug("running")
+	uc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	uc.ctx = moduleContext
+	uc.cancel = cancel
 
 	err := uc.SetupConn()
 	if err != nil {
@@ -88,15 +99,13 @@ func (uc *UDPClient) Run() error {
 
 	<-uc.ctx.Done()
 	uc.logger.Debug("done")
-	if uc.conn != nil {
-		uc.conn.Close()
-	}
 	return nil
 }
 
 func (uc *UDPClient) Output(ctx context.Context, payload any) error {
-
+	uc.connMu.Lock()
-	payloadBytes, ok := payload.([]byte)
+	defer uc.connMu.Unlock()
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
 	if !ok {
 		return errors.New("net.udp.client is only able to output bytes")
 	}
@@ -111,3 +120,14 @@ func (uc *UDPClient) Output(ctx context.Context, payload any) error {
 	}
 	return nil
 }
+
+func (uc *UDPClient) Stop() {
+	if uc.cancel != nil {
+		defer uc.cancel()
+	}
+	uc.connMu.Lock()
+	defer uc.connMu.Unlock()
+	if uc.conn != nil {
+		uc.conn.Close()
+	}
+}

internal/module/udp-multicast.go

@@ -6,64 +6,69 @@ import (
 	"fmt"
 	"log/slog"
 	"net"
+	"sync"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"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
-	logger *slog.Logger
-}
-
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type:  "net.udp.multicast",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
+		Title: "UDP Multicast",
-			params := config.Params
+		ParamsSchema: &jsonschema.Schema{
-			ip, ok := params["ip"]
+			Type: "object",
-
+			Properties: map[string]*jsonschema.Schema{
-			if !ok {
+				"ip": {
-				return nil, errors.New("net.udp.multicast requires an ip parameter")
+					Title:       "IP",
+					Description: "the multicast address to listen on",
+					Type:        "string",
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port to listen on",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1024),
+					Maximum:     jsonschema.Ptr[float64](65535),
+				},
+			},
+			Required:             []string{"ip", "port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
+			params := moduleConfig.Params
+			ipString, err := params.GetString("ip")
+			if err != nil {
+				return nil, fmt.Errorf("net.udp.multicast ip error: %w", err)
 			}
 
-			ipString, ok := ip.(string)
+			portNum, err := params.GetInt("port")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("net.udp.multicast port error: %w", err)
-				return nil, errors.New("net.udp.multicast ip must be a string")
-			}
-
-			port, ok := params["port"]
-			if !ok {
-				return nil, errors.New("net.udp.multicast requires a port parameter")
-			}
-
-			portNum, ok := port.(float64)
-
-			if !ok {
-				return nil, errors.New("net.udp.multicast 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: moduleConfig, Addr: addr, logger: CreateLogger(moduleConfig)}, nil
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("net.udp.multicast unable to get router from context")
-			}
-			return &UDPMulticast{config: config, Addr: addr, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
 		},
 	})
 }
 
+type UDPMulticast struct {
+	config       config.ModuleConfig
+	conn         *net.UDPConn
+	ctx          context.Context
+	inputHandler common.InputHandler
+	Addr         *net.UDPAddr
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	connMu       sync.Mutex
+}
+
 func (um *UDPMulticast) Id() string {
 	return um.config.Id
 }
@@ -72,7 +77,12 @@ func (um *UDPMulticast) Type() string {
 	return um.config.Type
 }
 
-func (um *UDPMulticast) Run() error {
+func (um *UDPMulticast) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	um.logger.Debug("running")
+	um.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	um.ctx = moduleContext
+	um.cancel = cancel
 
 	client, err := net.ListenMulticastUDP("udp", nil, um.Addr)
 	if err != nil {
@@ -80,22 +90,22 @@ func (um *UDPMulticast) Run() error {
 	}
 	defer client.Close()
 
+	um.connMu.Lock()
 	um.conn = client
+	um.connMu.Unlock()
 
 	buffer := make([]byte, 2048)
-	for {
+	for um.ctx.Err() == nil {
-		select {
-		case <-um.ctx.Done():
-			// TODO(jwetzell): cleanup?
-			um.logger.Debug("done")
-			return nil
-		default:
 		um.conn.SetDeadline(time.Now().Add(time.Millisecond * 200))
 
 		numBytes, _, err := um.conn.ReadFromUDP(buffer)
 		if err != nil {
+			if errors.Is(err, net.ErrClosed) {
+				break
+			}
 			//NOTE(jwetzell) we hit deadline
-				if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
+			opErr, ok := err.(*net.OpError)
+			if ok && opErr.Timeout() {
 				continue
 			}
 			return err
@@ -104,19 +114,21 @@ func (um *UDPMulticast) Run() error {
 		if numBytes > 0 {
 			message := buffer[:numBytes]
 
-				if um.router != nil {
+			if um.inputHandler != nil {
-					um.router.HandleInput(um.ctx, um.Id(), message)
+				um.inputHandler(um.ctx, um.Id(), message)
 			} else {
-					um.logger.Error("input received but no router is configured")
+				um.logger.Error("input received but no input handler is configured")
-				}
 			}
 		}
 	}
+	<-um.ctx.Done()
+	um.logger.Debug("done")
+	return nil
 }
 
 func (um *UDPMulticast) Output(ctx context.Context, payload any) error {
 
-	payloadBytes, ok := payload.([]byte)
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
 	if !ok {
 		return errors.New("net.udp.multicast can only output bytes")
 	}
@@ -128,3 +140,14 @@ func (um *UDPMulticast) Output(ctx context.Context, payload any) error {
 	_, err := um.conn.Write(payloadBytes)
 	return err
 }
+
+func (um *UDPMulticast) Stop() {
+	if um.cancel != nil {
+		defer um.cancel()
+	}
+	um.connMu.Lock()
+	defer um.connMu.Unlock()
+	if um.conn != nil {
+		um.conn.Close()
+	}
+}

internal/module/udp-server.go

@@ -2,80 +2,95 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"log"
 	"log/slog"
 	"net"
+	"sync"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/route"
 )
 
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "net.udp.server",
+		Title: "UDP Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:       "IP",
+					Description: "the IP address to bind the UDP server to",
+					Type:        "string",
+					Default:     json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:       "Port",
+					Description: "the port for the UDP server to listen on",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1024),
+					Maximum:     jsonschema.Ptr[float64](65535),
+				},
+				"bufferSize": {
+					Title:       "Buffer Size",
+					Description: "the size of the buffer for incoming UDP messages",
+					Type:        "integer",
+					Minimum:     jsonschema.Ptr[float64](1),
+					Maximum:     jsonschema.Ptr[float64](65535),
+					Default:     json.RawMessage("2048"),
+				},
+			},
+			Required:             []string{"port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
+			params := moduleConfig.Params
+			portNum, err := params.GetInt("port")
+			if err != nil {
+				return nil, fmt.Errorf("net.udp.server port error: %w", err)
+			}
+
+			ipString, err := params.GetString("ip")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					ipString = "0.0.0.0"
+				} else {
+					return nil, fmt.Errorf("net.udp.server ip error: %w", err)
+				}
+			}
+
+			addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
+			if err != nil {
+				return nil, err
+			}
+
+			bufferSizeNum, err := params.GetInt("bufferSize")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					bufferSizeNum = 2048
+				} else {
+					return nil, fmt.Errorf("net.udp.server bufferSize error: %w", err)
+				}
+			}
+			return &UDPServer{Addr: addr, BufferSize: bufferSizeNum, config: moduleConfig, logger: CreateLogger(moduleConfig)}, nil
+		},
+	})
+}
+
 type UDPServer struct {
 	Addr         *net.UDPAddr
 	BufferSize   int
 	config       config.ModuleConfig
 	ctx          context.Context
-	router     route.RouteIO
+	inputHandler common.InputHandler
 	logger       *slog.Logger
-}
+	cancel       context.CancelFunc
-
+	listener     *net.UDPConn
-func init() {
+	listenerMu   sync.Mutex
-	RegisterModule(ModuleRegistration{
-		Type: "net.udp.server",
-		New: func(ctx context.Context, config config.ModuleConfig) (Module, error) {
-			params := config.Params
-			port, ok := params["port"]
-			if !ok {
-				return nil, errors.New("net.udp.server requires a port parameter")
-			}
-
-			portNum, ok := port.(float64)
-
-			if !ok {
-				return nil, errors.New("net.udp.server port must be a number")
-			}
-
-			ipString := "0.0.0.0"
-
-			ip, ok := params["ip"]
-			if ok {
-
-				specificIpString, ok := ip.(string)
-
-				if !ok {
-					return nil, errors.New("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)
-			}
-
-			bufferSizeNum := 2048
-			bufferSize, ok := params["bufferSize"]
-
-			if ok {
-				bufferSizeFloat, ok := bufferSize.(float64)
-
-				if !ok {
-					return nil, errors.New("net.udp.server bufferSize must be a number")
-				}
-				bufferSizeNum = int(bufferSizeFloat)
-			}
-
-			router, ok := ctx.Value(route.RouterContextKey).(route.RouteIO)
-
-			if !ok {
-				return nil, errors.New("net.udp.server unable to get router from context")
-			}
-			return &UDPServer{Addr: addr, BufferSize: bufferSizeNum, config: config, ctx: ctx, router: router, logger: CreateLogger(config)}, nil
-		},
-	})
 }
 
 func (us *UDPServer) Id() string {
@@ -83,47 +98,60 @@ func (us *UDPServer) Id() string {
 }
 
 func (us *UDPServer) Type() string {
-	return us.config.Id
+	return us.config.Type
 }
 
-func (us *UDPServer) Run() error {
+func (us *UDPServer) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	us.logger.Debug("running")
+	us.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	us.ctx = moduleContext
+	us.cancel = cancel
 
 	listener, err := net.ListenUDP("udp", us.Addr)
 	if err != nil {
 		return err
 	}
-
+	us.listenerMu.Lock()
-	defer listener.Close()
+	us.listener = listener
+	us.listenerMu.Unlock()
 
 	buffer := make([]byte, us.BufferSize)
-	for {
+	for us.ctx.Err() == nil {
-		select {
-		case <-us.ctx.Done():
-			// TODO(jwetzell): cleanup?
-			us.logger.Debug("done")
-			return nil
-		default:
 		listener.SetDeadline(time.Now().Add(time.Millisecond * 200))
 
 		numBytes, _, err := listener.ReadFromUDP(buffer)
 		if err != nil {
 			//NOTE(jwetzell) we hit deadline
-				if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
+			opErr, ok := err.(*net.OpError)
+			if ok && opErr.Timeout() {
 				continue
 			}
-				return err
+			break
 		}
 		message := buffer[:numBytes]
-			if us.router != nil {
+		if us.inputHandler != nil {
-				us.router.HandleInput(us.ctx, us.Id(), message)
+			us.inputHandler(us.ctx, us.Id(), message)
 		} else {
-				us.logger.Error("input received but no router is configured")
+			us.logger.Error("input received but no input handler is configured")
 		}
 	}
-	}
+	<-us.ctx.Done()
-
+	us.logger.Debug("done")
+	return nil
 }
 
 func (us *UDPServer) Output(ctx context.Context, payload any) error {
 	return errors.New("net.udp.server output is not implemented")
 }
+
+func (us *UDPServer) Stop() {
+	if us.cancel != nil {
+		defer us.cancel()
+	}
+	us.listenerMu.Lock()
+	defer us.listenerMu.Unlock()
+	if us.listener != nil {
+		us.listener.Close()
+	}
+}

internal/module/websocket-client.go

@@ -0,0 +1,217 @@
+package module
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/gorilla/websocket"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+func init() {
+	RegisterModule(ModuleRegistration{
+		Type:  "websocket.client",
+		Title: "WebSocket Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"url": {
+					Title:       "URL",
+					Description: "the URL of the WebSocket server to connect",
+					Type:        "string",
+				},
+			},
+			Required:             []string{"url"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ModuleConfig) (common.Module, error) {
+			params := config.Params
+			urlString, err := params.GetString("url")
+			if err != nil {
+				return nil, fmt.Errorf("websocket.client url error: %w", err)
+			}
+
+			parsedURL, err := url.Parse(urlString)
+			if err != nil {
+				return nil, fmt.Errorf("websocket.client url error: %w", err)
+			}
+
+			if parsedURL.Scheme != "ws" && parsedURL.Scheme != "wss" {
+				return nil, fmt.Errorf("websocket.client url error: scheme must be ws or wss")
+			}
+
+			return &WebSocketClient{URL: *parsedURL, config: config, logger: CreateLogger(config)}, nil
+		},
+	})
+}
+
+type WebSocketClient struct {
+	config       config.ModuleConfig
+	URL          url.URL
+	ctx          context.Context
+	conn         *websocket.Conn
+	inputHandler common.InputHandler
+	logger       *slog.Logger
+	cancel       context.CancelFunc
+	connMu       sync.Mutex
+}
+
+func (wc *WebSocketClient) Id() string {
+	return wc.config.Id
+}
+
+func (wc *WebSocketClient) Type() string {
+	return wc.config.Type
+}
+
+func (wc *WebSocketClient) SetupConn() error {
+	wc.connMu.Lock()
+	defer wc.connMu.Unlock()
+	if wc.conn != nil {
+		wc.conn.Close()
+	}
+	conn, _, err := websocket.DefaultDialer.Dial(wc.URL.String(), nil)
+
+	if err != nil {
+		return fmt.Errorf("websocket.client dial error: %w", err)
+	}
+
+	conn.SetCloseHandler(func(code int, text string) error {
+		// NOTE(jwetzell): attempt to send close message back to server before closing connection
+		err := wc.conn.WriteControl(
+			websocket.CloseMessage,
+			websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""),
+			time.Now().Add(time.Minute),
+		)
+		wc.connMu.Lock()
+		defer wc.connMu.Unlock()
+		if wc.conn != nil {
+			wc.conn.Close()
+		}
+		return err
+	})
+
+	wc.conn = conn
+	return err
+}
+
+func (wc *WebSocketClient) Start(ctx context.Context, inputHandler common.InputHandler) error {
+	wc.logger.Debug("running")
+	wc.inputHandler = inputHandler
+	moduleContext, cancel := context.WithCancel(ctx)
+	wc.ctx = moduleContext
+	wc.cancel = cancel
+
+	for wc.ctx.Err() == nil {
+		err := wc.SetupConn()
+		if err != nil {
+			wc.logger.Error("connection error", "error", err)
+		} else {
+			// NOTE(jwetzell): enter read loop until an error occurs
+			wc.readLoop()
+		}
+		// NOTE(jwetzell): if connection is lost or read error wait before trying again
+		time.Sleep(2 * time.Second)
+	}
+	<-wc.ctx.Done()
+	wc.logger.Debug("done")
+	return nil
+}
+
+func (wc *WebSocketClient) readLoop() {
+	for wc.ctx.Err() == nil {
+		if wc.conn == nil {
+			wc.logger.Error("websocket connection is not established")
+			return
+		}
+		// TODO(jwetzell): other ways to timeout?
+		wc.conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+		messageType, message, err := wc.conn.ReadMessage()
+		if err != nil {
+			return
+		}
+		if wc.inputHandler != nil {
+			switch messageType {
+			case websocket.CloseMessage:
+				return
+			case websocket.PingMessage:
+				err := wc.conn.WriteMessage(websocket.PongMessage, nil)
+				if err != nil {
+					wc.logger.Error("websocket pong error", "error", err)
+					return
+				}
+			case websocket.TextMessage:
+				wc.inputHandler(wc.ctx, wc.Id(), string(message))
+			case websocket.BinaryMessage:
+				wc.inputHandler(wc.ctx, wc.Id(), message)
+			default:
+				wc.logger.Warn("unsupported message type received", "messageType", messageType)
+			}
+		} else {
+			wc.logger.Error("input received but no input handler is configured")
+			continue
+		}
+	}
+}
+
+func (wc *WebSocketClient) outputBytes(ctx context.Context, payload []byte) error {
+	if wc.conn == nil {
+		return errors.New("websocket.client client is not setup")
+	}
+	err := wc.conn.WriteMessage(websocket.BinaryMessage, payload)
+
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (wc *WebSocketClient) outputString(ctx context.Context, payload string) error {
+	if wc.conn == nil {
+		return errors.New("websocket.client client is not setup")
+	}
+	err := wc.conn.WriteMessage(websocket.TextMessage, []byte(payload))
+
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (wc *WebSocketClient) Output(ctx context.Context, payload any) error {
+	wc.connMu.Lock()
+	defer wc.connMu.Unlock()
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
+	if ok {
+		return wc.outputBytes(ctx, payloadBytes)
+	} else {
+		payloadString, ok := common.GetAnyAs[string](payload)
+		if ok {
+			return wc.outputString(ctx, payloadString)
+		} else {
+			return errors.New("websocket.client payload must be string or []byte")
+		}
+	}
+}
+
+func (wc *WebSocketClient) Stop() {
+	if wc.cancel != nil {
+		defer wc.cancel()
+	}
+	wc.connMu.Lock()
+	defer wc.connMu.Unlock()
+	if wc.conn != nil {
+		err := wc.conn.WriteControl(websocket.CloseMessage, nil, time.Now().Add(time.Minute))
+		if err != nil {
+			wc.logger.Error("websocket close error", "error", err)
+		}
+		wc.conn.Close()
+	}
+}

internal/processor/artnet-packet-decode.go

@@ -5,38 +5,45 @@ import (
 	"fmt"
 
 	"github.com/jwetzell/artnet-go"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
-type ArtNetPacketDecode struct {
-	config config.ProcessorConfig
-}
-
-func (apd *ArtNetPacketDecode) Process(ctx context.Context, payload any) (any, error) {
-	payloadBytes, ok := payload.([]byte)
-
-	if !ok {
-		return nil, fmt.Errorf("artnet.packet.decode processor only accepts a []byte")
-	}
-
-	payloadMessage, err := artnet.Decode(payloadBytes)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return payloadMessage, nil
-}
-
-func (apd *ArtNetPacketDecode) Type() string {
-	return apd.config.Type
-}
-
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type:  "artnet.packet.decode",
+		Title: "Decode ArtNet Packet",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &ArtNetPacketDecode{config: config}, nil
 		},
 	})
 }
+
+type ArtNetPacketDecode struct {
+	config config.ProcessorConfig
+}
+
+func (apd *ArtNetPacketDecode) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	payload := wrappedPayload.Payload
+	payloadBytes, ok := common.GetAnyAsByteSlice(payload)
+
+	if !ok {
+		wrappedPayload.End = true
+		return wrappedPayload, fmt.Errorf("artnet.packet.decode processor only accepts a []byte")
+	}
+
+	payloadMessage, err := artnet.Decode(payloadBytes)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	wrappedPayload.Payload = payloadMessage
+
+	return wrappedPayload, nil
+}
+
+func (apd *ArtNetPacketDecode) Type() string {
+	return apd.config.Type
+}

internal/processor/artnet-packet-encode.go

@@ -5,37 +5,44 @@ import (
 	"fmt"
 
 	"github.com/jwetzell/artnet-go"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
-type ArtNetPacketEncode struct {
-	config config.ProcessorConfig
-}
-
-func (ape *ArtNetPacketEncode) Process(ctx context.Context, payload any) (any, error) {
-	payloadPacket, ok := payload.(artnet.ArtNetPacket)
-
-	if !ok {
-		return nil, fmt.Errorf("artnet.packet.encode processor only accepts an ArtNetPacket")
-	}
-
-	payloadBytes, err := payloadPacket.MarshalBinary()
-	if err != nil {
-		return nil, err
-	}
-
-	return payloadBytes, nil
-}
-
-func (ape *ArtNetPacketEncode) Type() string {
-	return ape.config.Type
-}
-
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type:  "artnet.packet.encode",
+		Title: "Encode ArtNet Packet",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &ArtNetPacketEncode{config: config}, nil
 		},
 	})
 }
+
+type ArtNetPacketEncode struct {
+	config config.ProcessorConfig
+}
+
+func (ape *ArtNetPacketEncode) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	payload := wrappedPayload.Payload
+	payloadPacket, ok := common.GetAnyAs[artnet.ArtNetPacket](payload)
+
+	if !ok {
+		wrappedPayload.End = true
+		return wrappedPayload, fmt.Errorf("artnet.packet.encode processor only accepts an ArtNetPacket")
+	}
+
+	payloadBytes, err := payloadPacket.MarshalBinary()
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	wrappedPayload.Payload = payloadBytes
+
+	return wrappedPayload, nil
+}
+
+func (ape *ArtNetPacketEncode) Type() string {
+	return ape.config.Type
+}

internal/processor/artnet-packet-filter.go

@@ -1,52 +0,0 @@
-package processor
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jwetzell/artnet-go"
-	"github.com/jwetzell/showbridge-go/internal/config"
-)
-
-type ArtNetPacketFilter struct {
-	config config.ProcessorConfig
-	OpCode uint16
-}
-
-func (apf *ArtNetPacketFilter) Process(ctx context.Context, payload any) (any, error) {
-	payloadPacket, ok := payload.(artnet.ArtNetPacket)
-
-	if !ok {
-		return nil, fmt.Errorf("artnet.packet.filter processor only accepts an ArtNetPacket")
-	}
-
-	if payloadPacket.GetOpCode() != apf.OpCode {
-		return nil, nil
-	}
-
-	return payloadPacket, nil
-}
-
-func (apf *ArtNetPacketFilter) Type() string {
-	return apf.config.Type
-}
-
-func init() {
-	RegisterProcessor(ProcessorRegistration{
-		Type: "artnet.packet.filter",
-		New: func(config config.ProcessorConfig) (Processor, error) {
-			params := config.Params
-
-			opCode, ok := params["opCode"]
-			if !ok {
-				return nil, fmt.Errorf("artnet.packet.filter requires an opCode parameter")
-			}
-			opCodeNum, ok := opCode.(float64)
-			if !ok {
-				return nil, fmt.Errorf("artnet.packet.filter opCode must be a number")
-			}
-
-			return &ArtNetPacketFilter{config: config, OpCode: uint16(opCodeNum)}, nil
-		},
-	})
-}

internal/processor/db-query.go

@@ -0,0 +1,148 @@
+package processor
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"text/template"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "db.query",
+		Title: "Query Database",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"module": {
+					Title:       "Module ID",
+					Description: "ID of the database module to query",
+					Type:        "string",
+				},
+				"query": {
+					Title:       "Query",
+					Description: "SQL query to execute",
+					Type:        "string",
+				},
+			},
+			Required:             []string{"module", "query"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+
+			params := config.Params
+
+			moduleIdString, err := params.GetString("module")
+			if err != nil {
+				return nil, fmt.Errorf("db.query module error: %w", err)
+			}
+
+			queryString, err := params.GetString("query")
+			if err != nil {
+				return nil, fmt.Errorf("db.query query error: %w", err)
+			}
+
+			queryTemplate, err := template.New("query").Parse(queryString)
+
+			if err != nil {
+				return nil, err
+			}
+			return &DbQuery{config: config, ModuleId: moduleIdString, Query: queryTemplate, logger: slog.Default().With("component", "processor", "type", config.Type)}, nil
+		},
+	})
+}
+
+type DbQuery struct {
+	config   config.ProcessorConfig
+	ModuleId string
+	Query    *template.Template
+	logger   *slog.Logger
+	module   common.DatabaseModule
+}
+
+func (dq *DbQuery) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	if dq.module == nil {
+		if wrappedPayload.Modules == nil {
+			wrappedPayload.End = true
+			return wrappedPayload, errors.New("db.query wrapped payload has no modules")
+		}
+
+		module, ok := wrappedPayload.Modules[dq.ModuleId]
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("db.query unable to find module with id: %s", dq.ModuleId)
+		}
+
+		dbModule, ok := module.(common.DatabaseModule)
+		if !ok {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("db.query module with id %s is not a DatabaseModule", dq.ModuleId)
+		}
+		dq.module = dbModule
+	}
+
+	var queryBuffer bytes.Buffer
+	err := dq.Query.Execute(&queryBuffer, wrappedPayload)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	// support proper parameterized queries
+	rows, err := dq.module.QueryContext(ctx, queryBuffer.String())
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, fmt.Errorf("db.query error executing query: %w", err)
+	}
+	defer rows.Close()
+
+	columns, err := rows.Columns()
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, fmt.Errorf("db.query error getting columns: %w", err)
+	}
+
+	// TODO(jwetzell): optimize this
+	results := make([]map[string]any, 0)
+
+	for rows.Next() {
+		columnValues := make([]any, len(columns))
+
+		for i := range columnValues {
+			columnValues[i] = new(any)
+		}
+
+		if err := rows.Scan(columnValues...); err != nil {
+			wrappedPayload.End = true
+			return wrappedPayload, fmt.Errorf("db.query error scanning row: %w", err)
+		}
+
+		rowMap := make(map[string]any)
+		for i, colName := range columns {
+			value := *columnValues[i].(*any)
+			rowMap[colName] = value
+		}
+		results = append(results, rowMap)
+	}
+
+	if len(results) == 0 {
+		wrappedPayload.Payload = nil
+		return wrappedPayload, nil
+	} else if len(results) == 1 {
+		wrappedPayload.Payload = results[0]
+		return wrappedPayload, nil
+	}
+	wrappedPayload.Payload = results
+	return wrappedPayload, nil
+}
+
+func (dq *DbQuery) Type() string {
+	return dq.config.Type
+}

internal/processor/debug-log.go

@@ -5,28 +5,35 @@ import (
 	"fmt"
 	"log/slog"
 
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "debug.log",
+		Title: "Debug Log",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			return &DebugLog{config: config, logger: slog.Default().With("component", "processor", "type", config.Type)}, nil
+		},
+	})
+}
+
 type DebugLog struct {
 	config config.ProcessorConfig
 	logger *slog.Logger
 }
 
-func (dl *DebugLog) Process(ctx context.Context, payload any) (any, error) {
+// TODO(jwetzell): maybe make a more useful logging processor
-	dl.logger.Debug("", "payload", payload, "payloadType", fmt.Sprintf("%T", payload))
+func (dl *DebugLog) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-	return payload, nil
+	payload := wrappedPayload.Payload
+	payloadString := fmt.Sprintf("%+v", payload)
+	payloadType := fmt.Sprintf("%T", payload)
+	dl.logger.Debug("", "payload", payloadString, "payloadType", payloadType)
+	return wrappedPayload, nil
 }
 
 func (dl *DebugLog) Type() string {
 	return dl.config.Type
 }
 
-func init() {
-	RegisterProcessor(ProcessorRegistration{
-		Type: "debug.log",
-		New: func(config config.ProcessorConfig) (Processor, error) {
-			return &DebugLog{config: config, logger: slog.Default().With("component", "processor", "type", config.Type)}, nil
-		},
-	})
-}

internal/processor/debug-log_test.go

@@ -1,39 +0,0 @@
-package processor_test
-
-import (
-	"testing"
-
-	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/processor"
-)
-
-func TestDebugLogFromRegistry(t *testing.T) {
-	registration, ok := processor.ProcessorRegistry["debug.log"]
-	if !ok {
-		t.Fatalf("debug.log processor not registered")
-	}
-
-	processorInstance, err := registration.New(config.ProcessorConfig{
-		Type: "debug.log",
-	})
-
-	if err != nil {
-		t.Fatalf("failed to create debug.log processor: %s", err)
-	}
-
-	if processorInstance.Type() != "debug.log" {
-		t.Fatalf("debug.log processor has wrong type: %s", processorInstance.Type())
-	}
-
-	payload := "test"
-	expected := "test"
-
-	got, err := processorInstance.Process(t.Context(), payload)
-	if err != nil {
-		t.Fatalf("debug.log processing failed: %s", err)
-	}
-
-	if got != expected {
-		t.Fatalf("debug.log got %+v, expected %+v", got, expected)
-	}
-}

internal/processor/filter-change.go

@@ -0,0 +1,40 @@
+package processor
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "filter.change",
+		Title: "Filter On Change",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			return &FilterChange{config: config}, nil
+		},
+	})
+}
+
+type FilterChange struct {
+	config   config.ProcessorConfig
+	previous any
+}
+
+func (fc *FilterChange) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	payload := wrappedPayload.Payload
+
+	if reflect.DeepEqual(payload, fc.previous) {
+		wrappedPayload.End = true
+		return wrappedPayload, nil
+	}
+	fc.previous = payload
+
+	return wrappedPayload, nil
+}
+
+func (fc *FilterChange) Type() string {
+	return fc.config.Type
+}

internal/processor/filter-expr.go

@@ -0,0 +1,81 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "filter.expr",
+		Title: "Filter by Expr expression",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"expression": {
+					Title:       "Expression",
+					Description: "Expr expression to evaluate, must return a boolean",
+					Type:        "string",
+				},
+			},
+			Required:             []string{"expression"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+
+			expressionString, err := params.GetString("expression")
+			if err != nil {
+				return nil, fmt.Errorf("filter.expr expression error: %w", err)
+			}
+
+			program, err := expr.Compile(expressionString)
+			if err != nil {
+				return nil, err
+			}
+
+			return &FilterExpr{config: config, Program: program}, nil
+		},
+	})
+}
+
+// NOTE(jwetzell): see language definition https://expr-lang.org/docs/language-definition
+type FilterExpr struct {
+	config  config.ProcessorConfig
+	Program *vm.Program
+}
+
+func (fe *FilterExpr) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+
+	exprEnv := wrappedPayload
+
+	output, err := expr.Run(fe.Program, exprEnv)
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	outputBool, ok := output.(bool)
+	if !ok {
+		wrappedPayload.End = true
+		return wrappedPayload, fmt.Errorf("filter.expr expression did not return a boolean")
+	}
+	if !outputBool {
+		wrappedPayload.End = true
+		return wrappedPayload, nil
+	}
+
+	wrappedPayload.Payload = exprEnv.Payload
+
+	return wrappedPayload, nil
+}
+
+func (fe *FilterExpr) Type() string {
+	return fe.config.Type
+}

internal/processor/filter-rate.go

@@ -0,0 +1,58 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"golang.org/x/time/rate"
+)
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "filter.rate",
+		Title: "Filter by Rate",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"rate": {
+					Title:       "Rate",
+					Description: "number of events to allow per second",
+					Type:        "integer",
+				},
+			},
+			Required: []string{"rate"},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+			rateInt, err := params.GetInt("rate")
+			if err != nil {
+				return nil, fmt.Errorf("filter.rate rate error: %w", err)
+			}
+
+			limiter := rate.NewLimiter(rate.Limit(rateInt), rateInt*2)
+
+			return &FilterRate{config: config, limiter: limiter}, nil
+		},
+	})
+}
+
+type FilterRate struct {
+	config  config.ProcessorConfig
+	limiter *rate.Limiter
+}
+
+func (fc *FilterRate) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	err := fc.limiter.Wait(ctx)
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+	return wrappedPayload, nil
+}
+
+func (fc *FilterRate) Type() string {
+	return fc.config.Type
+}

internal/processor/filter-regex.go

@@ -0,0 +1,74 @@
+package processor
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"regexp"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "filter.regex",
+		Title: "Filter by Regex",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"pattern": {
+					Title:       "Pattern",
+					Description: "regex pattern to match against",
+					Type:        "string",
+				},
+			},
+			Required:             []string{"pattern"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+
+			patternString, err := params.GetString("pattern")
+			if err != nil {
+				return nil, fmt.Errorf("filter.regex pattern error: %w", err)
+			}
+
+			patternRegexp, err := regexp.Compile(patternString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			return &FilterRegex{config: config, Pattern: patternRegexp}, nil
+		},
+	})
+}
+
+type FilterRegex struct {
+	config  config.ProcessorConfig
+	Pattern *regexp.Regexp
+}
+
+func (fr *FilterRegex) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	payload := wrappedPayload.Payload
+	payloadString, ok := common.GetAnyAs[string](payload)
+
+	if !ok {
+		wrappedPayload.End = true
+		return wrappedPayload, errors.New("filter.regex processor only accepts a string")
+	}
+
+	if !fr.Pattern.MatchString(payloadString) {
+		wrappedPayload.End = true
+		return wrappedPayload, nil
+	}
+
+	wrappedPayload.Payload = payloadString
+	return wrappedPayload, nil
+}
+
+func (fr *FilterRegex) Type() string {
+	return fr.config.Type
+}

internal/processor/float-parse.go

@@ -2,52 +2,72 @@ package processor
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
+	"fmt"
 	"strconv"
 
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "float.parse",
+		Title: "Parse Float",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"bitSize": {
+					Title:       "Bit Size",
+					Description: "bit size of the resulting float",
+					Type:        "integer",
+					Enum:        []any{32, 64},
+					Default:     json.RawMessage("64"),
+				},
+			},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(moduleConfig config.ProcessorConfig) (Processor, error) {
+			params := moduleConfig.Params
+
+			bitSizeNum, err := params.GetInt("bitSize")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					bitSizeNum = 64
+				} else {
+					return nil, fmt.Errorf("float.parse bitSize error: %w", err)
+				}
+			}
+			return &FloatParse{config: moduleConfig, BitSize: bitSizeNum}, nil
+		},
+	})
+}
+
 type FloatParse struct {
 	BitSize int
 	config  config.ProcessorConfig
 }
 
-func (fp *FloatParse) Process(ctx context.Context, payload any) (any, error) {
+func (fp *FloatParse) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-	payloadString, ok := payload.(string)
+	payload := wrappedPayload.Payload
+	payloadString, ok := common.GetAnyAs[string](payload)
 
 	if !ok {
-		return nil, errors.New("float.parse processor only accepts a string")
+		wrappedPayload.End = true
+		return wrappedPayload, errors.New("float.parse processor only accepts a string")
 	}
 
 	payloadFloat, err := strconv.ParseFloat(payloadString, fp.BitSize)
 	if err != nil {
-		return nil, err
+		wrappedPayload.End = true
+		return wrappedPayload, err
 	}
-	return payloadFloat, nil
+	wrappedPayload.Payload = payloadFloat
+	return wrappedPayload, nil
 }
 
 func (fp *FloatParse) Type() string {
 	return fp.config.Type
 }
-
-func init() {
-	RegisterProcessor(ProcessorRegistration{
-		Type: "float.parse",
-		New: func(config config.ProcessorConfig) (Processor, error) {
-			params := config.Params
-			bitSizeNum := 64
-			bitSize, ok := params["bitSize"]
-			if ok {
-				bitSizeFloat, ok := bitSize.(float64)
-
-				if !ok {
-					return nil, errors.New("float.parse bitSize must be a number")
-				}
-
-				bitSizeNum = int(bitSizeFloat)
-			}
-			return &FloatParse{config: config, BitSize: bitSizeNum}, nil
-		},
-	})
-}

internal/processor/float-parse_test.go

@@ -1,173 +0,0 @@
-package processor_test
-
-import (
-	"testing"
-
-	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/processor"
-)
-
-func TestFloatParseFromRegistry(t *testing.T) {
-	registration, ok := processor.ProcessorRegistry["float.parse"]
-	if !ok {
-		t.Fatalf("float.parse processor not registered")
-	}
-
-	processorInstance, err := registration.New(config.ProcessorConfig{
-		Type: "float.parse",
-	})
-
-	if err != nil {
-		t.Fatalf("failed to create float.parse processor: %s", err)
-	}
-
-	if processorInstance.Type() != "float.parse" {
-		t.Fatalf("float.parse processor has wrong type: %s", processorInstance.Type())
-	}
-}
-
-func TestFloatParseBadConfigBitSizeString(t *testing.T) {
-	registration, ok := processor.ProcessorRegistry["float.parse"]
-	if !ok {
-		t.Fatalf("float.parse processor not registered")
-	}
-
-	_, err := registration.New(config.ProcessorConfig{
-		Type: "float.parse",
-		Params: map[string]any{
-			"bitSize": "64",
-		},
-	})
-
-	if err == nil {
-		t.Fatalf("float.parse should have returned an error for bad bitSize config")
-	}
-}
-
-func TestFloatParseGoodConfig(t *testing.T) {
-	registration, ok := processor.ProcessorRegistry["float.parse"]
-	if !ok {
-		t.Fatalf("float.parse processor not registered")
-	}
-
-	processorInstance, err := registration.New(config.ProcessorConfig{
-		Type: "float.parse",
-		Params: map[string]any{
-			"bitSize": 64.0,
-		},
-	})
-
-	if err != nil {
-		t.Fatalf("float.parse should have created processor but got error: %s", err)
-	}
-
-	payload := "12345.0"
-	expected := float64(12345.0)
-
-	got, err := processorInstance.Process(t.Context(), payload)
-	if err != nil {
-		t.Fatalf("float.parse processing failed: %s", err)
-	}
-
-	gotFloat, ok := got.(float64)
-	if !ok {
-		t.Fatalf("float.parse returned a %T payload: %s", got, got)
-	}
-
-	if gotFloat != expected {
-		t.Fatalf("float.parse got %f, expected %f", gotFloat, expected)
-	}
-}
-
-func TestGoodFloatParse(t *testing.T) {
-	floatParser := processor.FloatParse{}
-	tests := []struct {
-		processor processor.Processor
-		name      string
-		payload   any
-		bitSize   int
-		expected  float64
-	}{
-		{
-			name:     "positive number",
-			payload:  "12345.67",
-			bitSize:  64,
-			expected: 12345.67,
-		},
-		{
-			name:     "negative number",
-			payload:  "-12345.67",
-			bitSize:  64,
-			expected: -12345.67,
-		},
-		{
-			name:     "zero",
-			payload:  "0",
-			bitSize:  64,
-			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.Fatalf("float.parse returned a %T payload: %s", got, got)
-			}
-			if err != nil {
-				t.Fatalf("float.parse failed: %s", err)
-			}
-			if gotFloat != test.expected {
-				t.Fatalf("float.parse got %f, expected %f", gotFloat, test.expected)
-			}
-		})
-	}
-}
-
-func TestBadFloatParse(t *testing.T) {
-	tests := []struct {
-		processor   processor.Processor
-		name        string
-		payload     any
-		bitSize     int
-		errorString string
-	}{
-		{
-			name:        "non-string input",
-			payload:     []byte{0x01},
-			bitSize:     64,
-			errorString: "float.parse processor only accepts a string",
-		},
-		{
-			name:        "not float string",
-			payload:     "abcd",
-			bitSize:     64,
-			errorString: "strconv.ParseFloat: parsing \"abcd\": invalid syntax",
-		},
-		{
-			name:        "bit size overflow",
-			payload:     "1.79e+64",
-			bitSize:     32,
-			errorString: "strconv.ParseFloat: parsing \"1.79e+64\": value out of range",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			floatParser := processor.FloatParse{
-				BitSize: test.bitSize,
-			}
-			got, err := floatParser.Process(t.Context(), test.payload)
-
-			if err == nil {
-				t.Fatalf("float.parse expected to fail but succeeded, got: %v", got)
-
-			}
-			if err.Error() != test.errorString {
-				t.Fatalf("float.parse got error '%s', expected '%s'", err.Error(), test.errorString)
-			}
-		})
-	}
-}

internal/processor/float-random.go

@@ -0,0 +1,102 @@
+package processor
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/rand/v2"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+)
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "float.random",
+		Title: "Random Float",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"bitSize": {
+					Title:       "Bit Size",
+					Description: "bit size of the resulting float",
+					Type:        "integer",
+					Enum:        []any{32, 64},
+					Default:     json.RawMessage("32"),
+				},
+				"min": {
+					Title:       "Minimum",
+					Description: "inclusive minimum value of the random float",
+					Type:        "number",
+				},
+				"max": {
+					Title:       "Maximum",
+					Description: "exclusive maximum value of the random float",
+					Type:        "number",
+				},
+			},
+			Required:             []string{"min", "max"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(processorConfig config.ProcessorConfig) (Processor, error) {
+			params := processorConfig.Params
+
+			bitSizeInt, err := params.GetInt("bitSize")
+			if err != nil {
+				if errors.Is(err, config.ErrParamNotFound) {
+					bitSizeInt = 32
+				} else {
+					return nil, fmt.Errorf("float.random bitSize error: %w", err)
+				}
+			}
+
+			if bitSizeInt != 32 && bitSizeInt != 64 {
+				return nil, errors.New("float.random bitSize error: must be 32 or 64")
+			}
+
+			minFloat, err := params.GetFloat64("min")
+			if err != nil {
+				return nil, fmt.Errorf("float.random min error: %w", err)
+			}
+
+			maxFloat, err := params.GetFloat64("max")
+			if err != nil {
+				return nil, fmt.Errorf("float.random max error: %w", err)
+			}
+
+			if maxFloat < minFloat {
+				return nil, errors.New("float.random max must be greater than min")
+			}
+
+			return &FloatRandom{config: processorConfig, Min: minFloat, Max: maxFloat, BitSize: bitSizeInt}, nil
+		},
+	})
+}
+
+type FloatRandom struct {
+	BitSize int
+	Min     float64
+	Max     float64
+	config  config.ProcessorConfig
+}
+
+func (fr *FloatRandom) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	if fr.BitSize == 32 {
+		payloadFloat := rand.Float32()*(float32(fr.Max)-float32(fr.Min)) + float32(fr.Min)
+		wrappedPayload.Payload = payloadFloat
+		return wrappedPayload, nil
+	}
+	if fr.BitSize == 64 {
+		payloadFloat := rand.Float64()*(fr.Max-fr.Min) + fr.Min
+		wrappedPayload.Payload = payloadFloat
+		return wrappedPayload, nil
+	}
+	wrappedPayload.End = true
+	return wrappedPayload, errors.New("float.random bitSize error: must be 32 or 64")
+}
+
+func (fr *FloatRandom) Type() string {
+	return fr.config.Type
+}

internal/processor/free-d-create.go

@@ -3,200 +3,89 @@ package processor
 import (
 	"bytes"
 	"context"
-	"errors"
+	"fmt"
 	"strconv"
 	"text/template"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	freeD "github.com/jwetzell/free-d-go"
+	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
 
-type FreeDCreate struct {
-	config config.ProcessorConfig
-	Id     *template.Template
-	Pan    *template.Template
-	Tilt   *template.Template
-	Roll   *template.Template
-	PosX   *template.Template
-	PosY   *template.Template
-	PosZ   *template.Template
-	Zoom   *template.Template
-	Focus  *template.Template
-}
-
-func (fc *FreeDCreate) Process(ctx context.Context, payload any) (any, error) {
-
-	var idBuffer bytes.Buffer
-	err := fc.Id.Execute(&idBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	idString := idBuffer.String()
-
-	idNum, err := strconv.ParseUint(idString, 10, 8)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var panBuffer bytes.Buffer
-	err = fc.Pan.Execute(&panBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	panString := panBuffer.String()
-
-	panNum, err := strconv.ParseFloat(panString, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var tiltBuffer bytes.Buffer
-	err = fc.Tilt.Execute(&tiltBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	tiltString := tiltBuffer.String()
-
-	tiltNum, err := strconv.ParseFloat(tiltString, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var rollBuffer bytes.Buffer
-	err = fc.Tilt.Execute(&rollBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	rollString := rollBuffer.String()
-
-	rollNum, err := strconv.ParseFloat(rollString, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var posXBuffer bytes.Buffer
-	err = fc.PosX.Execute(&posXBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	posXString := posXBuffer.String()
-
-	posXNum, err := strconv.ParseFloat(posXString, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var posYBuffer bytes.Buffer
-	err = fc.PosY.Execute(&posYBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	posYString := posYBuffer.String()
-
-	posYNum, err := strconv.ParseFloat(posYString, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var posZBuffer bytes.Buffer
-	err = fc.PosZ.Execute(&posZBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	posZString := posZBuffer.String()
-
-	posZNum, err := strconv.ParseFloat(posZString, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var zoomBuffer bytes.Buffer
-	err = fc.Zoom.Execute(&zoomBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	zoomString := zoomBuffer.String()
-
-	zoomNum, err := strconv.ParseInt(zoomString, 10, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var focusBuffer bytes.Buffer
-	err = fc.Zoom.Execute(&focusBuffer, payload)
-
-	if err != nil {
-		return nil, err
-	}
-
-	focusString := focusBuffer.String()
-
-	focusNum, err := strconv.ParseInt(focusString, 10, 32)
-
-	if err != nil {
-		return nil, err
-	}
-
-	payloadMessage := freeD.FreeDPosition{
-		ID:    uint8(idNum),
-		Pan:   float32(panNum),
-		Tilt:  float32(tiltNum),
-		Roll:  float32(rollNum),
-		PosX:  float32(posXNum),
-		PosY:  float32(posYNum),
-		PosZ:  float32(posZNum),
-		Zoom:  int32(zoomNum),
-		Focus: int32(focusNum),
-	}
-
-	return payloadMessage, nil
-}
-
-func (fc *FreeDCreate) Type() string {
-	return fc.config.Type
-}
-
 func init() {
 	RegisterProcessor(ProcessorRegistration{
 		Type:  "freed.create",
+		Title: "Create FreeD",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"id": {
+					Title:       "Camera ID",
+					Description: "ID of the camera this FreeD position corresponds to",
+					Type:        "string",
+				},
+				"pan": {
+					Title:       "Pan",
+					Description: "pan angle of the camera",
+					Type:        "string",
+				},
+				"tilt": {
+					Title:       "Tilt",
+					Description: "tilt angle of the camera",
+					Type:        "string",
+				},
+				"roll": {
+					Title:       "Roll",
+					Description: "roll angle of the camera",
+					Type:        "string",
+				},
+				"posX": {
+					Title:       "Position X",
+					Description: "X coordinate of the camera's position",
+					Type:        "string",
+				},
+				"posY": {
+					Title:       "Position Y",
+					Description: "Y coordinate of the camera's position",
+					Type:        "string",
+				},
+				"posZ": {
+					Title:       "Position Z",
+					Description: "Z coordinate of the camera's position",
+					Type:        "string",
+				},
+				"zoom": {
+					Title:       "Zoom",
+					Description: "zoom level of the camera",
+					Type:        "string",
+				},
+				"focus": {
+					Title:       "Focus",
+					Description: "focus level of the camera",
+					Type:        "string",
+				},
+			},
+			Required: []string{
+				"id",
+				"pan",
+				"tilt",
+				"roll",
+				"posX",
+				"posY",
+				"posZ",
+				"zoom",
+				"focus",
+			},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 
 			// TODO(jwetzell): make some params optional
 			params := config.Params
-			id, ok := params["id"]
+			idString, err := params.GetString("id")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create id error: %w", err)
-				return nil, errors.New("freed.create requires an id parameter")
-			}
-
-			idString, ok := id.(string)
-
-			if !ok {
-				return nil, errors.New("freed.create id must be a string")
 			}
 
 			idTemplate, err := template.New("id").Parse(idString)
@@ -205,44 +94,31 @@ func init() {
 				return nil, err
 			}
 
-			pan, ok := params["pan"]
+			panString, err := params.GetString("pan")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create pan error: %w", err)
-				return nil, errors.New("freed.create requires a pan parameter")
-			}
-
-			panString, ok := pan.(string)
-
-			if !ok {
-				return nil, errors.New("freed.create pan must be a string")
 			}
 
 			panTemplate, err := template.New("pan").Parse(panString)
 
-			tilt, ok := params["tilt"]
+			if err != nil {
-
+				return nil, err
-			if !ok {
-				return nil, errors.New("freed.create requires a tilt parameter")
 			}
 
-			tiltString, ok := tilt.(string)
+			tiltString, err := params.GetString("tilt")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create tilt error: %w", err)
-				return nil, errors.New("freed.create tilt must be a string")
 			}
 
 			tiltTemplate, err := template.New("tilt").Parse(tiltString)
 
-			roll, ok := params["roll"]
+			if err != nil {
-
+				return nil, err
-			if !ok {
-				return nil, errors.New("freed.create requires a roll parameter")
 			}
 
-			rollString, ok := roll.(string)
+			rollString, err := params.GetString("roll")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create roll error: %w", err)
-				return nil, errors.New("freed.create roll must be a string")
 			}
 
 			rollTemplate, err := template.New("roll").Parse(rollString)
@@ -251,16 +127,9 @@ func init() {
 				return nil, err
 			}
 
-			posX, ok := params["posX"]
+			posXString, err := params.GetString("posX")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create posX error: %w", err)
-				return nil, errors.New("freed.create requires a posX parameter")
-			}
-
-			posXString, ok := posX.(string)
-
-			if !ok {
-				return nil, errors.New("freed.create posX must be a string")
 			}
 
 			posXTemplate, err := template.New("posX").Parse(posXString)
@@ -269,16 +138,9 @@ func init() {
 				return nil, err
 			}
 
-			posY, ok := params["posY"]
+			posYString, err := params.GetString("posY")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create posY error: %w", err)
-				return nil, errors.New("freed.create requires a posY parameter")
-			}
-
-			posYString, ok := posY.(string)
-
-			if !ok {
-				return nil, errors.New("freed.create posY must be a string")
 			}
 
 			posYTemplate, err := template.New("posY").Parse(posYString)
@@ -287,16 +149,9 @@ func init() {
 				return nil, err
 			}
 
-			posZ, ok := params["posZ"]
+			posZString, err := params.GetString("posZ")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create posZ error: %w", err)
-				return nil, errors.New("freed.create requires a posZ parameter")
-			}
-
-			posZString, ok := posZ.(string)
-
-			if !ok {
-				return nil, errors.New("freed.create posZ must be a string")
 			}
 
 			posZTemplate, err := template.New("posZ").Parse(posZString)
@@ -305,33 +160,26 @@ func init() {
 				return nil, err
 			}
 
-			zoom, ok := params["zoom"]
+			zoomString, err := params.GetString("zoom")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create zoom error: %w", err)
-				return nil, errors.New("freed.create requires a zoom parameter")
-			}
-
-			zoomString, ok := zoom.(string)
-
-			if !ok {
-				return nil, errors.New("freed.create zoom must be a string")
 			}
 
 			zoomTemplate, err := template.New("zoom").Parse(zoomString)
 
-			focus, ok := params["focus"]
+			if err != nil {
-
+				return nil, err
-			if !ok {
-				return nil, errors.New("freed.create requires a focus parameter")
 			}
 
-			focusString, ok := focus.(string)
+			focusString, err := params.GetString("focus")
-
+			if err != nil {
-			if !ok {
+				return nil, fmt.Errorf("freed.create focus error: %w", err)
-				return nil, errors.New("freed.create focus must be a string")
 			}
 
 			focusTemplate, err := template.New("focus").Parse(focusString)
+			if err != nil {
+				return nil, err
+			}
 
 			return &FreeDCreate{
 				config: config,
@@ -348,3 +196,194 @@ func init() {
 		},
 	})
 }
+
+type FreeDCreate struct {
+	config config.ProcessorConfig
+	Id     *template.Template
+	Pan    *template.Template
+	Tilt   *template.Template
+	Roll   *template.Template
+	PosX   *template.Template
+	PosY   *template.Template
+	PosZ   *template.Template
+	Zoom   *template.Template
+	Focus  *template.Template
+}
+
+func (fc *FreeDCreate) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+
+	templateData := wrappedPayload
+
+	var idBuffer bytes.Buffer
+	err := fc.Id.Execute(&idBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	idString := idBuffer.String()
+
+	idNum, err := strconv.ParseUint(idString, 10, 8)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var panBuffer bytes.Buffer
+	err = fc.Pan.Execute(&panBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	panString := panBuffer.String()
+
+	panNum, err := strconv.ParseFloat(panString, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var tiltBuffer bytes.Buffer
+	err = fc.Tilt.Execute(&tiltBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	tiltString := tiltBuffer.String()
+
+	tiltNum, err := strconv.ParseFloat(tiltString, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var rollBuffer bytes.Buffer
+	err = fc.Roll.Execute(&rollBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	rollString := rollBuffer.String()
+
+	rollNum, err := strconv.ParseFloat(rollString, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var posXBuffer bytes.Buffer
+	err = fc.PosX.Execute(&posXBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	posXString := posXBuffer.String()
+
+	posXNum, err := strconv.ParseFloat(posXString, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var posYBuffer bytes.Buffer
+	err = fc.PosY.Execute(&posYBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	posYString := posYBuffer.String()
+
+	posYNum, err := strconv.ParseFloat(posYString, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var posZBuffer bytes.Buffer
+	err = fc.PosZ.Execute(&posZBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	posZString := posZBuffer.String()
+
+	posZNum, err := strconv.ParseFloat(posZString, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var zoomBuffer bytes.Buffer
+	err = fc.Zoom.Execute(&zoomBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	zoomString := zoomBuffer.String()
+
+	zoomNum, err := strconv.ParseInt(zoomString, 10, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	var focusBuffer bytes.Buffer
+	err = fc.Focus.Execute(&focusBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	focusString := focusBuffer.String()
+
+	focusNum, err := strconv.ParseInt(focusString, 10, 32)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	payloadMessage := freeD.FreeDPosition{
+		ID:    uint8(idNum),
+		Pan:   float32(panNum),
+		Tilt:  float32(tiltNum),
+		Roll:  float32(rollNum),
+		PosX:  float32(posXNum),
+		PosY:  float32(posYNum),
+		PosZ:  float32(posZNum),
+		Zoom:  int32(zoomNum),
+		Focus: int32(focusNum),
+	}
+
+	wrappedPayload.Payload = payloadMessage
+
+	return wrappedPayload, nil
+}
+
+func (fc *FreeDCreate) Type() string {
+	return fc.config.Type
+}