add git to builder image

upgrade osc-go library to v0.3.0 and handle new error cases

.github/labeler.yml

@@ -1,27 +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/**"
-
-router:
-  - changed-files:
-      - any-glob-to-any-file: "router*"
-
-route:
-  - changed-files:
-      - any-glob-to-any-file: "internal/route/**"
-
-cli:
-  - changed-files:
-      - any-glob-to-any-file: "cmd/showbridge/**"

.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

@@ -43,7 +43,7 @@ jobs:
         uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Login to Docker Hub
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}

Dockerfile

@@ -1,6 +1,6 @@
-ARG GO_VERSION=1.26.0
+ARG GO_VERSION=1.26.2
 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

@@ -25,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
 
@@ -36,9 +37,10 @@ USAGE:
    showbridge [global options]
 
 GLOBAL OPTIONS:
-   --config string      path to config file (default: "./config.yaml")
-   --log-level string   set log level (default: "info")
-   --log-format string  log format to use (default: "text")
+   --config string      path to config file (default: "./config.yaml") [$SHOWBRIDGE_CONFIG]
+   --log-level string   set log level (default: "info") [$SHOWBRIDGE_LOG_LEVEL]
+   --log-format string  log format to use (default: "text") [$SHOWBRIDGE_LOG_FORMAT]
+   --trace              enable OpenTelemetry tracing [$SHOWBRIDGE_TRACE]
    --help, -h           show help
    --version, -v        print the version
 ```

api.go

@@ -2,22 +2,19 @@ package showbridge
 
 import (
 	"context"
-	"embed"
 	_ "embed"
 	"encoding/json"
 	"fmt"
-	"io/fs"
+	"io"
 	"net/http"
 	"time"
 
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"github.com/jwetzell/showbridge-go/internal/module"
 	"github.com/jwetzell/showbridge-go/internal/route"
+	"github.com/jwetzell/showbridge-go/internal/schema"
 )
 
-//go:embed schema
-var schema embed.FS
-
 func (r *Router) startAPIServer(config config.ApiConfig) {
 	if !config.Enabled {
 		r.logger.Warn("API not enabled")
@@ -27,8 +24,11 @@ func (r *Router) startAPIServer(config config.ApiConfig) {
 	mux := http.NewServeMux()
 	mux.HandleFunc("/ws", r.handleWebsocket)
 	mux.HandleFunc("/health", r.handleHealthHTTP)
-	mux.Handle("/schema/{schema}", HandleFS(schema))
 	mux.HandleFunc("/api/v1/config", r.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)
 
 	r.apiServerMu.Lock()
 	defer r.apiServerMu.Unlock()
@@ -93,8 +93,41 @@ func (r *Router) handleConfigHTTP(w http.ResponseWriter, req *http.Request) {
 			http.Error(w, "Config update in progress.", http.StatusConflict)
 			return
 		}
+		//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.NewDecoder(req.Body).Decode(&newConfig)
+		err = json.Unmarshal(validCfgBytes, &newConfig)
 		if err != nil {
 			http.Error(w, "Bad request", http.StatusBadRequest)
 			return
@@ -131,14 +164,92 @@ func (r *Router) handleConfigHTTP(w http.ResponseWriter, req *http.Request) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.WriteHeader(http.StatusMethodNotAllowed)
 	}
-
 }
 
-func HandleFS(fs fs.FS) http.HandlerFunc {
-	handler := http.FileServerFS(fs)
-	return func(w http.ResponseWriter, req *http.Request) {
+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")
-		handler.ServeHTTP(w, req)
+		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)
 	}
 }

cmd/showbridge/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -15,6 +16,7 @@ import (
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"github.com/jwetzell/showbridge-go/internal/module"
 	"github.com/jwetzell/showbridge-go/internal/route"
+	"github.com/jwetzell/showbridge-go/internal/schema"
 	"github.com/urfave/cli/v3"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
@@ -36,9 +38,10 @@ func main() {
 		Version: version,
 		Flags: []cli.Flag{
 			&cli.StringFlag{
-				Name:  "config",
-				Value: "./config.yaml",
-				Usage: "path to config file",
+				Name:    "config",
+				Value:   "./config.yaml",
+				Usage:   "path to config file",
+				Sources: cli.EnvVars("SHOWBRIDGE_CONFIG"),
 			},
 			&cli.StringFlag{
 				Name:  "log-level",
@@ -51,6 +54,7 @@ func main() {
 					}
 					return nil
 				},
+				Sources: cli.EnvVars("SHOWBRIDGE_LOG_LEVEL"),
 			},
 			&cli.StringFlag{
 				Name:  "log-format",
@@ -63,11 +67,13 @@ func main() {
 					}
 					return nil
 				},
+				Sources: cli.EnvVars("SHOWBRIDGE_LOG_FORMAT"),
 			},
 			&cli.BoolFlag{
-				Name:  "trace",
-				Value: false,
-				Usage: "enable OpenTelemetry tracing",
+				Name:    "trace",
+				Value:   false,
+				Usage:   "enable OpenTelemetry tracing",
+				Sources: cli.EnvVars("SHOWBRIDGE_TRACE"),
 			},
 		},
 		Action: run,
@@ -103,7 +109,28 @@ 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{}, err
+	}
+
+	err = schema.ValidateConfig(yamlMap)
+	if err != nil {
+		return config.Config{}, err
+	}
+
+	validatedConfigBytes, err := json.Marshal(yamlMap)
+
+	err = json.Unmarshal(validatedConfigBytes, &cfg)
 	if err != nil {
 		return config.Config{}, err
 	}

go.mod

@@ -1,30 +1,31 @@
 module github.com/jwetzell/showbridge-go
 
-go 1.26.0
+go 1.26.2
 
 require (
 	github.com/eclipse/paho.mqtt.golang v1.5.1
 	github.com/emiago/diago v0.28.0
-	github.com/emiago/sipgo v1.2.1
+	github.com/emiago/sipgo v1.3.0
 	github.com/expr-lang/expr v1.17.8
 	github.com/extism/go-sdk v1.7.1
+	github.com/google/jsonschema-go v0.4.2
 	github.com/gorilla/websocket v1.5.3
 	github.com/jwetzell/artnet-go v0.2.1
 	github.com/jwetzell/free-d-go v0.1.0
-	github.com/jwetzell/osc-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-server/v2 v2.12.5
-	github.com/nats-io/nats.go v1.49.0
+	github.com/nats-io/nats-server/v2 v2.12.6
+	github.com/nats-io/nats.go v1.50.0
 	github.com/redis/go-redis/v9 v9.18.0
-	github.com/urfave/cli/v3 v3.7.0
+	github.com/urfave/cli/v3 v3.8.0
 	gitlab.com/gomidi/midi/v2 v2.3.23
 	go.bug.st/serial v1.6.4
-	go.opentelemetry.io/otel v1.42.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.42.0
-	go.opentelemetry.io/otel/sdk v1.42.0
-	go.opentelemetry.io/otel/trace v1.42.0
-	modernc.org/quickjs v0.17.1
-	modernc.org/sqlite v1.47.0
+	go.opentelemetry.io/otel v1.43.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0
+	go.opentelemetry.io/otel/sdk v1.43.0
+	go.opentelemetry.io/otel/trace v1.43.0
+	modernc.org/quickjs v0.17.2
+	modernc.org/sqlite v1.48.2
 	sigs.k8s.io/yaml v1.6.0
 )
 
@@ -49,10 +50,10 @@ require (
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 // indirect
 	github.com/ianlancetaylor/demangle v0.0.0-20240805132620-81f5be970eca // indirect
 	github.com/icholy/digest v1.1.0 // indirect
-	github.com/klauspost/compress v1.18.4 // indirect
+	github.com/klauspost/compress v1.18.5 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76 // indirect
-	github.com/nats-io/jwt/v2 v2.8.0 // indirect
+	github.com/nats-io/jwt/v2 v2.8.1 // indirect
 	github.com/nats-io/nkeys v0.4.15 // indirect
 	github.com/nats-io/nuid v1.0.1 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
@@ -68,24 +69,24 @@ require (
 	github.com/tetratelabs/wazero v1.9.0 // indirect
 	github.com/zaf/g711 v1.4.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.42.0 // indirect
-	go.opentelemetry.io/otel/metric v1.42.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.9.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 // indirect
+	go.opentelemetry.io/otel/metric v1.43.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.48.0 // indirect
-	golang.org/x/net v0.51.0 // indirect
-	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/crypto v0.49.0 // indirect
+	golang.org/x/net v0.52.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/text v0.34.0 // indirect
+	golang.org/x/text v0.35.0 // indirect
 	golang.org/x/time v0.15.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20260209200024-4cfbd4190f57 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57 // indirect
-	google.golang.org/grpc v1.79.2 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 // indirect
+	google.golang.org/grpc v1.80.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.70.0 // indirect
-	modernc.org/libquickjs v0.12.3 // indirect
+	modernc.org/libquickjs v0.12.4 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
 )

go.sum

@@ -24,8 +24,8 @@ github.com/emiago/diago v0.28.0 h1:VCiimhFYLoBTsxH6WrufLSt6tKWG8Fv7LfCkZHqct2E=
 github.com/emiago/diago v0.28.0/go.mod h1:eQT6j9co9PMQ/25aUiM2jpvwxxWFXLWi2w5R3lZNmKg=
 github.com/emiago/dtls/v3 v3.0.0-20260122183559-8b8d23e359c0 h1:o4LxpUnZ1zxiQ+Qjc9kLwXcjz31NGAHmnZ7xoJto3VM=
 github.com/emiago/dtls/v3 v3.0.0-20260122183559-8b8d23e359c0/go.mod h1:ydcZ977eS1I6uOWodzMuw30BwvNAzT9su/xcNYSJqjA=
-github.com/emiago/sipgo v1.2.1 h1:5JTwogbe3yQFA3sjBVueN2Q4WTU350tGeBwPYT8HMv0=
-github.com/emiago/sipgo v1.2.1/go.mod h1:DuwAxBZhKMqIzQFPGZb1MVAGU6Wuxj64oTOhd5dx/FY=
+github.com/emiago/sipgo v1.3.0 h1:efxQln1wJqcIU9+N+4eTKNtTZ7YsRsg8yc+0XYqyuQU=
+github.com/emiago/sipgo v1.3.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=
@@ -51,6 +51,8 @@ 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.2 h1:tmrUohrwoLZZS/P3x7ex0WAVknEkBZM46iALbcqoRA8=
+github.com/google/jsonschema-go v0.4.2/go.mod h1:r5quNTdLOYEz95Ru18zA0ydNbBuYoo9tgaYcxEYhJVE=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -69,12 +71,12 @@ github.com/jwetzell/artnet-go v0.2.1 h1:iYTKWcwYrF5kBkYfkw2UbWvoueeA23iKEn7fR27m
 github.com/jwetzell/artnet-go v0.2.1/go.mod h1:gli97Z32a0kMkZ6taoTiK7/lqHcF/dhiGjGJdx/PxqA=
 github.com/jwetzell/free-d-go v0.1.0 h1:xHt6dvyit98X+OC3jVzV0aLidxbyzi3vI9QiYkteEtA=
 github.com/jwetzell/free-d-go v0.1.0/go.mod h1:KmrkooRARRaxJTBSPvwt/6IMAIaHH1R8bSA8cwbbELw=
-github.com/jwetzell/osc-go v0.2.0 h1:4as+BYCeZhEddFczGveP5yZZxvY728Uavz+ZSLZfOII=
-github.com/jwetzell/osc-go v0.2.0/go.mod h1:D3ZIXYB12bt4S35lKFUqgCFbF1Y+9Ld0sOhHA9mGZZM=
+github.com/jwetzell/osc-go v0.3.0 h1:z75TxuQSEmdcmZ56OAepkDa3m88SdZh//3m4nBb/XZI=
+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.4 h1:RPhnKRAQ4Fh8zU2FY/6ZFDwTVTxgJ/EMydqSTzE9a2c=
-github.com/klauspost/compress v1.18.4/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
+github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
+github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
 github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
@@ -85,12 +87,12 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76 h1:KGuD/pM2JpL9FAYvBrnBBeENKZNh6eNtjqytV6TYjnk=
 github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
-github.com/nats-io/jwt/v2 v2.8.0 h1:K7uzyz50+yGZDO5o772eRE7atlcSEENpL7P+b74JV1g=
-github.com/nats-io/jwt/v2 v2.8.0/go.mod h1:me11pOkwObtcBNR8AiMrUbtVOUGkqYjMQZ6jnSdVUIA=
-github.com/nats-io/nats-server/v2 v2.12.5 h1:EOHLbsLJgUHUwzkj9gBTOlubkX+dmSs0EYWMdBiHivU=
-github.com/nats-io/nats-server/v2 v2.12.5/go.mod h1:JQDAKcwdXs0NRhvYO31dzsXkzCyDkOBS7SKU3Nozu14=
-github.com/nats-io/nats.go v1.49.0 h1:yh/WvY59gXqYpgl33ZI+XoVPKyut/IcEaqtsiuTJpoE=
-github.com/nats-io/nats.go v1.49.0/go.mod h1:fDCn3mN5cY8HooHwE2ukiLb4p4G4ImmzvXyJt+tGwdw=
+github.com/nats-io/jwt/v2 v2.8.1 h1:V0xpGuD/N8Mi+fQNDynXohVvp7ZztevW5io8CUWlPmU=
+github.com/nats-io/jwt/v2 v2.8.1/go.mod h1:nWnOEEiVMiKHQpnAy4eXlizVEtSfzacZ1Q43LIRavZg=
+github.com/nats-io/nats-server/v2 v2.12.6 h1:Egbx9Vl7Ch8wTtpXPGqbehkZ+IncKqShUxvrt1+Enc8=
+github.com/nats-io/nats-server/v2 v2.12.6/go.mod h1:4HPlrvtmSO3yd7KcElDNMx9kv5EBJBnJJzQPptXlheo=
+github.com/nats-io/nats.go v1.50.0 h1:5zAeQrTvyrKrWLJ0fu02W3br8ym57qf7csDzgLOpcds=
+github.com/nats-io/nats.go v1.50.0/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno=
 github.com/nats-io/nkeys v0.4.15 h1:JACV5jRVO9V856KOapQ7x+EY8Jo3qw1vJt/9Jpwzkk4=
 github.com/nats-io/nkeys v0.4.15/go.mod h1:CpMchTXC9fxA5zrMo4KpySxNjiDVvr8ANOSZdiNfUrs=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
@@ -125,8 +127,8 @@ github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834 h1:ZF+QBjOI+tILZ
 github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834/go.mod h1:m9ymHTgNSEjuxvw8E7WWe4Pl4hZQHXONY8wE6dMLaRk=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-github.com/urfave/cli/v3 v3.7.0 h1:AGSnbUyjtLiM+WJUb4dzXKldl/gL+F8OwmRDtVr6g2U=
-github.com/urfave/cli/v3 v3.7.0/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
+github.com/urfave/cli/v3 v3.8.0 h1:XqKPrm0q4P0q5JpoclYoCAv0/MIvH/jZ2umzuf8pNTI=
+github.com/urfave/cli/v3 v3.8.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=
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
@@ -137,22 +139,22 @@ go.bug.st/serial v1.6.4 h1:7FmqNPgVp3pu2Jz5PoPtbZ9jJO5gnEnZIvnI1lzve8A=
 go.bug.st/serial v1.6.4/go.mod h1:nofMJxTeNVny/m6+KaafC6vJGj3miwQZ6vW4BZUGJPI=
 go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
 go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
-go.opentelemetry.io/otel v1.42.0 h1:lSQGzTgVR3+sgJDAU/7/ZMjN9Z+vUip7leaqBKy4sho=
-go.opentelemetry.io/otel v1.42.0/go.mod h1:lJNsdRMxCUIWuMlVJWzecSMuNjE7dOYyWlqOXWkdqCc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.42.0 h1:THuZiwpQZuHPul65w4WcwEnkX2QIuMT+UFoOrygtoJw=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.42.0/go.mod h1:J2pvYM5NGHofZ2/Ru6zw/TNWnEQp5crgyDeSrYpXkAw=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.42.0 h1:uLXP+3mghfMf7XmV4PkGfFhFKuNWoCvvx5wP/wOXo0o=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.42.0/go.mod h1:v0Tj04armyT59mnURNUJf7RCKcKzq+lgJs6QSjHjaTc=
-go.opentelemetry.io/otel/metric v1.42.0 h1:2jXG+3oZLNXEPfNmnpxKDeZsFI5o4J+nz6xUlaFdF/4=
-go.opentelemetry.io/otel/metric v1.42.0/go.mod h1:RlUN/7vTU7Ao/diDkEpQpnz3/92J9ko05BIwxYa2SSI=
-go.opentelemetry.io/otel/sdk v1.42.0 h1:LyC8+jqk6UJwdrI/8VydAq/hvkFKNHZVIWuslJXYsDo=
-go.opentelemetry.io/otel/sdk v1.42.0/go.mod h1:rGHCAxd9DAph0joO4W6OPwxjNTYWghRWmkHuGbayMts=
-go.opentelemetry.io/otel/sdk/metric v1.42.0 h1:D/1QR46Clz6ajyZ3G8SgNlTJKBdGp84q9RKCAZ3YGuA=
-go.opentelemetry.io/otel/sdk/metric v1.42.0/go.mod h1:Ua6AAlDKdZ7tdvaQKfSmnFTdHx37+J4ba8MwVCYM5hc=
-go.opentelemetry.io/otel/trace v1.42.0 h1:OUCgIPt+mzOnaUTpOQcBiM/PLQ/Op7oq6g4LenLmOYY=
-go.opentelemetry.io/otel/trace v1.42.0/go.mod h1:f3K9S+IFqnumBkKhRJMeaZeNk9epyhnCmQh/EysQCdc=
-go.opentelemetry.io/proto/otlp v1.9.0 h1:l706jCMITVouPOqEnii2fIAuO3IVGBRPV5ICjceRb/A=
-go.opentelemetry.io/proto/otlp v1.9.0/go.mod h1:xE+Cx5E/eEHw+ISFkwPLwCZefwVjY+pqKg1qcK03+/4=
+go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
+go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 h1:88Y4s2C8oTui1LGM6bTWkw0ICGcOLCAI5l6zsD1j20k=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0/go.mod h1:Vl1/iaggsuRlrHf/hfPJPvVag77kKyvrLeD10kpMl+A=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 h1:3iZJKlCZufyRzPzlQhUIWVmfltrXuGyfjREgGP3UUjc=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0/go.mod h1:/G+nUPfhq2e+qiXMGxMwumDrP5jtzU+mWN7/sjT2rak=
+go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
+go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY=
+go.opentelemetry.io/otel/sdk v1.43.0 h1:pi5mE86i5rTeLXqoF/hhiBtUNcrAGHLKQdhg4h4V9Dg=
+go.opentelemetry.io/otel/sdk v1.43.0/go.mod h1:P+IkVU3iWukmiit/Yf9AWvpyRDlUeBaRg6Y+C58QHzg=
+go.opentelemetry.io/otel/sdk/metric v1.43.0 h1:S88dyqXjJkuBNLeMcVPRFXpRw2fuwdvfCGLEo89fDkw=
+go.opentelemetry.io/otel/sdk/metric v1.43.0/go.mod h1:C/RJtwSEJ5hzTiUz5pXF1kILHStzb9zFlIEe85bhj6A=
+go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
+go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0=
+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.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
@@ -161,32 +163,32 @@ 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.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
-golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
+golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
+golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
 golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
 golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
-golang.org/x/net v0.51.0 h1:94R/GTO7mt3/4wIKpcR5gkGmRLOuE/2hNGeWq/GBIFo=
-golang.org/x/net v0.51.0/go.mod h1:aamm+2QF5ogm02fjy5Bb7CQ0WMt1/WVM7FtyaTLlA9Y=
-golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
-golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
+golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
 golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
-golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
+golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
+golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
 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.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
 golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
-gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
-gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/api v0.0.0-20260209200024-4cfbd4190f57 h1:JLQynH/LBHfCTSbDWl+py8C+Rg/k1OVH3xfcaiANuF0=
-google.golang.org/genproto/googleapis/api v0.0.0-20260209200024-4cfbd4190f57/go.mod h1:kSJwQxqmFXeo79zOmbrALdflXQeAYcUbgS7PbpMknCY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57 h1:mWPCjDEyshlQYzBpMNHaEof6UX1PmHcaUODUywQ0uac=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57/go.mod h1:j9x/tPzZkyxcgEFkiKEEGxfvyumM01BEtsW8xzOahRQ=
-google.golang.org/grpc v1.79.2 h1:fRMD94s2tITpyJGtBBn7MkMseNpOZU8ZxgC3MMBaXRU=
-google.golang.org/grpc v1.79.2/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
+gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
+gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
+google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 h1:VPWxll4HlMw1Vs/qXtN7BvhZqsS9cdAittCNvVENElA=
+google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:7QBABkRtR8z+TEnmXTqIqwJLlzrZKVfAUm7tY3yGv0M=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 h1:m8qni9SQFH0tJc1X0vmnpw/0t+AImlSvp30sEupozUg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/grpc v1.80.0 h1:Xr6m2WmWZLETvUNvIUmeD5OAagMw3FiKmMlTdViWsHM=
+google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4=
 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=
@@ -212,20 +214,20 @@ modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
 modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
 modernc.org/libc v1.70.0 h1:U58NawXqXbgpZ/dcdS9kMshu08aiA6b7gusEusqzNkw=
 modernc.org/libc v1.70.0/go.mod h1:OVmxFGP1CI/Z4L3E0Q3Mf1PDE0BucwMkcXjjLntvHJo=
-modernc.org/libquickjs v0.12.3 h1:2IU9B6njBmce2PuYttJDkXeoLRV9WnvgP+eU5HAC8YI=
-modernc.org/libquickjs v0.12.3/go.mod h1:iCsgVxnHTX3i0YPxxHBmJk0GLA5sVUHXWI/090UXgeE=
+modernc.org/libquickjs v0.12.4 h1:WQ2XP6pAscvtHKPEVuHTf8NiAl5nMomKgIL6790r7AQ=
+modernc.org/libquickjs v0.12.4/go.mod h1:MqdjijqGUwLw+r86+YbFLLj7vKZhVHEKRs8XOsnM/n8=
 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/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
-modernc.org/quickjs v0.17.1 h1:CbYnbTf7ksZk9YZ1rRM2Ab1Zfi+X6s50kXiOhpd2NIg=
-modernc.org/quickjs v0.17.1/go.mod h1:hATT7DIJc33I5Q/Fjffhm0tpUHNSqdKHma/ossibTA0=
+modernc.org/quickjs v0.17.2 h1:LrhCQ763clXttVFFYdfnwAATM4JFv/vPKee/tLsFFIE=
+modernc.org/quickjs v0.17.2/go.mod h1:h8zcP/sP8AZkDvtMXwIoUV/g5pWTPqivz0PLU070URQ=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
-modernc.org/sqlite v1.47.0 h1:R1XyaNpoW4Et9yly+I2EeX7pBza/w+pmYee/0HJDyKk=
-modernc.org/sqlite v1.47.0/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig=
+modernc.org/sqlite v1.48.2 h1:5CnW4uP8joZtA0LedVqLbZV5GD7F/0x91AXeSyjoh5c=
+modernc.org/sqlite v1.48.2/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig=
 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/common/common.go

@@ -27,12 +27,55 @@ func GetAnyAsInt(value any) (int, bool) {
 		return int(byteValue), true
 	}
 
-	floatValue, ok := value.(float64)
+	float32Value, ok := value.(float32)
 	if ok {
-		if floatValue != math.Floor(floatValue) {
+		if float64(float32Value) != math.Floor(float64(float32Value)) {
 			return 0, false
 		}
-		return int(floatValue), true
+		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
 }
@@ -46,39 +89,11 @@ func GetAnyAsByteSlice(value any) ([]byte, bool) {
 	result := make([]byte, v.Len())
 	for i := 0; i < v.Len(); i++ {
 		elem := v.Index(i).Interface()
-		byteValue, ok := elem.(byte)
-		if ok {
-			result[i] = byteValue
-			continue
+		elemValue, ok := GetAnyAsByte(elem)
+		if !ok {
+			return nil, false
 		}
-		uintValue, ok := elem.(uint)
-		if ok {
-			if uintValue > 255 {
-				return nil, false
-			}
-			result[i] = byte(uintValue)
-			continue
-		}
-		intValue, ok := elem.(int)
-		if ok {
-			if intValue < 0 || intValue > 255 {
-				return nil, false
-			}
-			result[i] = byte(intValue)
-			continue
-		}
-		floatValue, ok := elem.(float64)
-		if ok {
-			if floatValue != math.Floor(floatValue) {
-				return nil, false
-			}
-			if floatValue < 0 || floatValue > 255 {
-				return nil, false
-			}
-			result[i] = byte(floatValue)
-			continue
-		}
-		return nil, false
+		result[i] = elemValue
 	}
 	return result, true
 }
@@ -92,30 +107,11 @@ func GetAnyAsIntSlice(value any) ([]int, bool) {
 	result := make([]int, v.Len())
 	for i := 0; i < v.Len(); i++ {
 		elem := v.Index(i).Interface()
-		byteValue, ok := elem.(byte)
-		if ok {
-			result[i] = int(byteValue)
-			continue
+		elemInt, ok := GetAnyAsInt(elem)
+		if !ok {
+			return nil, false
 		}
-		uintValue, ok := elem.(uint)
-		if ok {
-			result[i] = int(uintValue)
-			continue
-		}
-		intValue, ok := elem.(int)
-		if ok {
-			result[i] = int(intValue)
-			continue
-		}
-		floatValue, ok := elem.(float64)
-		if ok {
-			if floatValue != math.Floor(floatValue) {
-				return nil, false
-			}
-			result[i] = int(floatValue)
-			continue
-		}
-		return nil, false
+		result[i] = elemInt
 	}
 	return result, true
 }

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/payload_test.go

@@ -0,0 +1,82 @@
+package common_test
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/test"
+)
+
+func TestGoodGetWrappedPayload(t *testing.T) {
+	testCases := []struct {
+		name     string
+		ctx      context.Context
+		payload  any
+		expected common.WrappedPayload
+	}{
+		{
+			name:    "basic",
+			ctx:     t.Context(),
+			payload: "test",
+			expected: common.WrappedPayload{
+				Payload: "test",
+			},
+		},
+		{
+			name:    "with modules in context",
+			ctx:     test.GetContextWithModules(t.Context(), map[string]common.Module{}),
+			payload: "test",
+			expected: common.WrappedPayload{
+				Payload: "test",
+				Modules: map[string]common.Module{},
+			},
+		},
+		{
+			name:    "with sender in context",
+			ctx:     test.GetContextWithSender(t.Context(), "sender"),
+			payload: "test",
+			expected: common.WrappedPayload{
+				Payload: "test",
+				Sender:  "sender",
+			},
+		},
+		{
+			name:    "with source in context",
+			ctx:     test.GetContextWithSource(t.Context(), "source"),
+			payload: "test",
+			expected: common.WrappedPayload{
+				Payload: "test",
+				Source:  "source",
+			},
+		},
+		{
+			name: "with all fields in context",
+			ctx: test.GetContextWithSource(
+				test.GetContextWithSender(
+					test.GetContextWithModules(t.Context(), map[string]common.Module{}),
+					"sender",
+				),
+				"source",
+			),
+			payload: "test",
+			expected: common.WrappedPayload{
+				Payload: "test",
+				Modules: map[string]common.Module{},
+				Sender:  "sender",
+				Source:  "source",
+			},
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			wrappedPayload := common.GetWrappedPayload(testCase.ctx, testCase.payload)
+
+			if !reflect.DeepEqual(wrappedPayload, testCase.expected) {
+				t.Fatalf("GetWrappedPayload expected got %+v,  expected %+v", wrappedPayload, testCase.expected)
+			}
+		})
+	}
+
+}

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

@@ -5,23 +5,3 @@ type Config struct {
 	Modules []ModuleConfig `json:"modules"`
 	Routes  []RouteConfig  `json:"routes"`
 }
-
-type ApiConfig struct {
-	Enabled bool `json:"enabled"`
-	Port    int  `json:"port"`
-}
-type ModuleConfig struct {
-	Id     string `json:"id"`
-	Type   string `json:"type"`
-	Params Params `json:"params,omitempty"`
-}
-
-type RouteConfig struct {
-	Input      string            `json:"input"`
-	Processors []ProcessorConfig `json:"processors"`
-}
-
-type ProcessorConfig struct {
-	Type   string `json:"type"`
-	Params Params `json:"params,omitempty"`
-}

internal/config/config_test.go

@@ -1,297 +0,0 @@
-package config_test
-
-import (
-	"encoding/json"
-	"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 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 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 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 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 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 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 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)
-			}
-		})
-	}
-}

internal/config/module.go

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

internal/config/params.go

@@ -2,7 +2,6 @@ package config
 
 import (
 	"errors"
-	"fmt"
 
 	"github.com/jwetzell/showbridge-go/internal/common"
 )
@@ -10,14 +9,15 @@ import (
 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")
-	ErrParamNotByteSlice = errors.New("not a byte slice")
-	ErrParamNotIntSlice  = errors.New("not an int slice")
+	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) {
@@ -103,7 +103,7 @@ func (p Params) GetStringSlice(key string) ([]string, error) {
 	for i, v := range interfaceSlice {
 		str, ok := v.(string)
 		if !ok {
-			return nil, fmt.Errorf("element at index %d is not a string", i)
+			return nil, ErrParamNotStringSlice
 		}
 		stringSlice[i] = str
 	}

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,6 @@
+package config
+
+type ProcessorConfig struct {
+	Type   string `json:"type"`
+	Params Params `json:"params,omitempty"`
+}

internal/config/route.go

@@ -0,0 +1,6 @@
+package config
+
+type RouteConfig struct {
+	Input      string            `json:"input"`
+	Processors []ProcessorConfig `json:"processors"`
+}

internal/module/db-sqlite.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 
@@ -24,7 +25,19 @@ type DbSqlite struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "db.sqlite",
+		Type:  "db.sqlite",
+		Title: "SQLite Database",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"dsn": {
+					Type:      "string",
+					MinLength: jsonschema.Ptr(1),
+				},
+			},
+			Required:             []string{"dsn"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 
@@ -66,10 +79,6 @@ func (t *DbSqlite) Start(ctx context.Context) error {
 	return nil
 }
 
-func (t *DbSqlite) Output(ctx context.Context, payload any) error {
-	return nil
-}
-
 func (t *DbSqlite) Stop() {
 	if t.db != nil {
 		t.db.Close()

internal/module/http-server.go

@@ -9,6 +9,7 @@ import (
 	"net"
 	"net/http"
 
+	"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"
@@ -55,7 +56,21 @@ func (hsrw *HTTPServerResponseWriter) Write(data []byte) (int, error) {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "http.server",
+		Type:  "http.server",
+		Title: "HTTP Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title:   "Port",
+					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")

internal/module/midi-input.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"gitlab.com/gomidi/midi/v2"
@@ -26,7 +27,19 @@ type MIDIInput struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "midi.input",
+		Type:  "midi.input",
+		Title: "MIDI Input",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title: "Port",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 			portString, err := params.GetString("port")

internal/module/midi-output.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"gitlab.com/gomidi/midi/v2"
@@ -26,7 +27,19 @@ type MIDIOutput struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "midi.output",
+		Type:  "midi.output",
+		Title: "MIDI Output",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title: "Port",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"port"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 

internal/module/module.go

@@ -5,6 +5,7 @@ import (
 	"log/slog"
 	"sync"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -16,8 +17,11 @@ type ModuleError struct {
 }
 
 type ModuleRegistration struct {
-	Type string `json:"type"`
-	New  func(config.ModuleConfig) (common.Module, error)
+	Type         string             `json:"type"`
+	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) {

internal/module/mqtt-client.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 
 	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"
 )
@@ -25,7 +26,27 @@ type MQTTClient struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "mqtt.client",
+		Type:  "mqtt.client",
+		Title: "MQTT Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"broker": {
+					Title: "Broker URL",
+					Type:  "string",
+				},
+				"topic": {
+					Title: "Topic",
+					Type:  "string",
+				},
+				"clientId": {
+					Title: "Client ID",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"broker", "topic", "clientId"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 			brokerString, err := params.GetString("broker")

internal/module/nats-client.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"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/processor"
@@ -24,7 +25,23 @@ type NATSClient struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "nats.client",
+		Type:  "nats.client",
+		Title: "NATS Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"url": {
+					Title: "NATS Server URL",
+					Type:  "string",
+				},
+				"subject": {
+					Title: "Subject",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"url", "subject"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 			urlString, err := params.GetString("url")

internal/module/nats-server.go

@@ -2,12 +2,14 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
 	"net"
 	"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"
@@ -26,7 +28,27 @@ type NATSServer struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "nats.server",
+		Type:  "nats.server",
+		Title: "NATS Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:   "IP",
+					Type:    "string",
+					Default: json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:   "Port",
+					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")

internal/module/psn-client.go

@@ -24,9 +24,9 @@ type PSNClient struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "psn.client",
+		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
 		},
 	})

internal/module/redis-client.go

@@ -6,6 +6,7 @@ import (
 	"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/redis/go-redis/v9"
@@ -24,7 +25,23 @@ type RedisClient struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "redis.client",
+		Type:  "redis.client",
+		Title: "Redis Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"host": {
+					Type: "string",
+				},
+				"port": {
+					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")
@@ -51,7 +68,13 @@ func (rc *RedisClient) Type() string {
 	return rc.config.Type
 }
 
+func (rc *RedisClient) Printf(ctx context.Context, format string, v ...interface{}) {
+	msg := fmt.Sprintf(format, v...)
+	rc.logger.Debug(msg)
+}
+
 func (rc *RedisClient) Start(ctx context.Context) error {
+	redis.SetLogger(rc)
 	rc.logger.Debug("running")
 	router, ok := ctx.Value(common.RouterContextKey).(common.RouteIO)
 
@@ -79,11 +102,6 @@ func (rc *RedisClient) Start(ctx context.Context) error {
 	return nil
 }
 
-func (rc *RedisClient) Output(ctx context.Context, payload any) error {
-
-	return errors.ErrUnsupported
-}
-
 func (rc *RedisClient) Stop() {
 	rc.cancel()
 }

internal/module/serial-client.go

@@ -9,6 +9,7 @@ import (
 	"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/framer"
@@ -29,7 +30,23 @@ type SerialClient struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "serial.client",
+		Type:  "serial.client",
+		Title: "Serial Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"port": {
+					Title: "Port",
+					Type:  "string",
+				},
+				"baudRate": {
+					Title: "Baud Rate",
+					Type:  "integer",
+				},
+			},
+			Required:             []string{"port", "baudRate"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 			portString, err := params.GetString("port")

internal/module/sip-call-server.go

@@ -2,6 +2,7 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -14,6 +15,7 @@ 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"
@@ -45,7 +47,38 @@ type sipCallContextKey string
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "sip.call.server",
+		Type:  "sip.call.server",
+		Title: "SIP Call Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:   "IP",
+					Type:    "string",
+					Default: json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:   "Port",
+					Type:    "integer",
+					Minimum: jsonschema.Ptr[float64](1024),
+					Maximum: jsonschema.Ptr[float64](65535),
+					Default: json.RawMessage(`5060`),
+				},
+				"transport": {
+					Title:   "Transport",
+					Type:    "string",
+					Enum:    []any{"udp", "tcp", "ws", "udp4", "tcp4"},
+					Default: json.RawMessage(`"udp"`),
+				},
+				"userAgent": {
+					Title:   "User Agent",
+					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")

internal/module/sip-dtmf-server.go

@@ -2,6 +2,7 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -15,6 +16,7 @@ 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"
@@ -45,7 +47,44 @@ type SIPDTMFCall struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "sip.dtmf.server",
+		Type:  "sip.dtmf.server",
+		Title: "SIP DTMF Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:   "IP",
+					Type:    "string",
+					Default: json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:   "Port",
+					Type:    "integer",
+					Minimum: jsonschema.Ptr[float64](1024),
+					Maximum: jsonschema.Ptr[float64](65535),
+					Default: json.RawMessage(`5060`),
+				},
+				"transport": {
+					Title:   "Transport",
+					Type:    "string",
+					Enum:    []any{"udp", "tcp", "ws", "udp4", "tcp4"},
+					Default: json.RawMessage(`"udp"`),
+				},
+				"userAgent": {
+					Title:   "User Agent",
+					Type:    "string",
+					Default: json.RawMessage(`"showbridge"`),
+				},
+				"separator": {
+					Title:     "DTMF Separator",
+					Type:      "string",
+					MinLength: jsonschema.Ptr(1),
+					MaxLength: jsonschema.Ptr(1),
+				},
+			},
+			Required:             []string{"separator"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(moduleConfig config.ModuleConfig) (common.Module, error) {
 			params := moduleConfig.Params
 

internal/module/tcp-client.go

@@ -8,6 +8,7 @@ import (
 	"net"
 	"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"
@@ -26,7 +27,30 @@ type TCPClient struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "net.tcp.client",
+		Type:  "net.tcp.client",
+		Title: "TCP Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"host": {
+					Title: "Host",
+					Type:  "string",
+				},
+				"port": {
+					Title:   "Port",
+					Type:    "integer",
+					Minimum: jsonschema.Ptr[float64](1),
+					Maximum: jsonschema.Ptr[float64](65535),
+				},
+				"framing": {
+					Title: "Framing Method",
+					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
 			hostString, err := params.GetString("host")

internal/module/tcp-server.go

@@ -2,6 +2,7 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -11,6 +12,7 @@ import (
 	"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"
@@ -32,7 +34,31 @@ type TCPServer struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "net.tcp.server",
+		Type:  "net.tcp.server",
+		Title: "TCP Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:   "IP",
+					Type:    "string",
+					Default: json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:   "Port",
+					Type:    "integer",
+					Minimum: jsonschema.Ptr[float64](1024),
+					Maximum: jsonschema.Ptr[float64](65535),
+				},
+				"framing": {
+					Title: "Framing Method",
+					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")

internal/module/test/db-sqlite_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 TestDbSqliteFromRegistry(t *testing.T) {
+	registration, ok := module.ModuleRegistry["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 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.ModuleRegistry["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())
+
+			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/module_test.go

@@ -1,32 +1,14 @@
 package module_test
 
 import (
-	"context"
 	"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"
 )
 
-type TestModule struct {
-}
-
-func (m *TestModule) Start(ctx context.Context) error {
-	<-ctx.Done()
-	return nil
-}
-
-func (m *TestModule) Stop() {}
-
-func (m *TestModule) Type() string {
-	return "module.test"
-}
-
-func (m *TestModule) Id() string {
-	return "test"
-}
-
 func TestModuleBadRegistrationNoType(t *testing.T) {
 	defer func() {
 		if r := recover(); r == nil {
@@ -37,7 +19,7 @@ func TestModuleBadRegistrationNoType(t *testing.T) {
 	module.RegisterModule(module.ModuleRegistration{
 		Type: "",
 		New: func(config config.ModuleConfig) (common.Module, error) {
-			return &TestModule{}, nil
+			return &test.TestModule{}, nil
 		},
 	})
 }
@@ -65,14 +47,14 @@ func TestModuleBadRegistrationExistingType(t *testing.T) {
 	module.RegisterModule(module.ModuleRegistration{
 		Type: "module.test",
 		New: func(config config.ModuleConfig) (common.Module, error) {
-			return &TestModule{}, nil
+			return &test.TestModule{}, nil
 		},
 	})
 
 	module.RegisterModule(module.ModuleRegistration{
 		Type: "module.test",
 		New: func(config config.ModuleConfig) (common.Module, error) {
-			return &TestModule{}, nil
+			return &test.TestModule{}, nil
 		},
 	})
 }

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.ModuleRegistry["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.ModuleRegistry["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())
+
+			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/time-interval.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -23,7 +24,20 @@ type TimeInterval struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "time.interval",
+		Type:  "time.interval",
+		Title: "Interval",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"duration": {
+					Title:       "Duration",
+					Type:        "integer",
+					Description: "Interval duration in milliseconds",
+				},
+			},
+			Required:             []string{"duration"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 

internal/module/time-timer.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -23,7 +24,20 @@ type TimeTimer struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "time.timer",
+		Type:  "time.timer",
+		Title: "Timer",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"duration": {
+					Title:       "Duration",
+					Type:        "integer",
+					Description: "Interval duration in milliseconds",
+				},
+			},
+			Required:             []string{"duration"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ModuleConfig) (common.Module, error) {
 			params := config.Params
 

internal/module/udp-client.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"net"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -24,7 +25,25 @@ type UDPClient struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "net.udp.client",
+		Type:  "net.udp.client",
+		Title: "UDP Client",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"host": {
+					Title: "Host",
+					Type:  "string",
+				},
+				"port": {
+					Title:   "Port",
+					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")

internal/module/udp-multicast.go

@@ -8,6 +8,7 @@ import (
 	"net"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -24,7 +25,25 @@ type UDPMulticast struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "net.udp.multicast",
+		Type:  "net.udp.multicast",
+		Title: "UDP Multicast",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title: "IP",
+					Type:  "string",
+				},
+				"port": {
+					Title:   "Port",
+					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")

internal/module/udp-server.go

@@ -2,12 +2,14 @@ package module
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
 	"net"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -24,7 +26,33 @@ type UDPServer struct {
 
 func init() {
 	RegisterModule(ModuleRegistration{
-		Type: "net.udp.server",
+		Type:  "net.udp.server",
+		Title: "UDP Server",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"ip": {
+					Title:   "IP",
+					Type:    "string",
+					Default: json.RawMessage(`"0.0.0.0"`),
+				},
+				"port": {
+					Title:   "Port",
+					Type:    "integer",
+					Minimum: jsonschema.Ptr[float64](1024),
+					Maximum: jsonschema.Ptr[float64](65535),
+				},
+				"bufferSize": {
+					Title:   "Buffer Size",
+					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")

internal/processor/artnet-packet-decode.go

@@ -40,7 +40,8 @@ func (apd *ArtNetPacketDecode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "artnet.packet.decode",
+		Type:  "artnet.packet.decode",
+		Title: "Decode ArtNet Packet",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &ArtNetPacketDecode{config: config}, nil
 		},

internal/processor/artnet-packet-encode.go

@@ -39,7 +39,8 @@ func (ape *ArtNetPacketEncode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "artnet.packet.encode",
+		Type:  "artnet.packet.encode",
+		Title: "Encode ArtNet Packet",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &ArtNetPacketEncode{config: config}, nil
 		},

internal/processor/db-query.go

@@ -104,7 +104,8 @@ func (dq *DbQuery) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "db.query",
+		Type:  "db.query",
+		Title: "Query Database",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 
 			params := config.Params

internal/processor/debug-log.go

@@ -28,7 +28,8 @@ func (dl *DebugLog) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "debug.log",
+		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
 		},

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"
+)
+
+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
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "filter.change",
+		Title: "Filter On Change",
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			return &FilterChange{config: config}, nil
+		},
+	})
+}

internal/processor/filter-expr.go

@@ -6,6 +6,7 @@ import (
 
 	"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"
 )
@@ -47,7 +48,19 @@ func (fe *FilterExpr) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "filter.expr",
+		Type:  "filter.expr",
+		Title: "Filter by Expr expression",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"expression": {
+					Title: "Expression",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"expression"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/filter-regex.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"regexp"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -39,7 +40,19 @@ func (fr *FilterRegex) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "filter.regex",
+		Type:  "filter.regex",
+		Title: "Filter by Regex",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"pattern": {
+					Title: "Pattern",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"pattern"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/float-parse.go

@@ -2,10 +2,12 @@ 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"
 )
@@ -39,7 +41,20 @@ func (fp *FloatParse) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "float.parse",
+		Type:  "float.parse",
+		Title: "Parse Float",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"bitSize": {
+					Title:   "Bit Size",
+					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
 

internal/processor/float-random.go

@@ -2,10 +2,12 @@ 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"
 )
@@ -38,7 +40,29 @@ func (fr *FloatRandom) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "float.random",
+		Type:  "float.random",
+		Title: "Random Float",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"bitSize": {
+					Title:   "Bit Size",
+					Type:    "integer",
+					Enum:    []any{32, 64},
+					Default: json.RawMessage("32"),
+				},
+				"min": {
+					Title: "Minimum",
+					Type:  "number",
+				},
+				"max": {
+					Title: "Maximum",
+					Type:  "number",
+				},
+			},
+			Required:             []string{"min", "max"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(processorConfig config.ProcessorConfig) (Processor, error) {
 			params := processorConfig.Params
 

internal/processor/free-d-create.go

@@ -7,6 +7,7 @@ import (
 	"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"
@@ -205,7 +206,61 @@ func (fc *FreeDCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "freed.create",
+		Type:  "freed.create",
+		Title: "Create FreeD",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"id": {
+					Title: "Camera ID",
+					Type:  "string",
+				},
+				"pan": {
+					Title: "Pan",
+					Type:  "string",
+				},
+				"tilt": {
+					Title: "Tilt",
+					Type:  "string",
+				},
+				"roll": {
+					Title: "Roll",
+					Type:  "string",
+				},
+				"posX": {
+					Title: "Position X",
+					Type:  "string",
+				},
+				"posY": {
+					Title: "Position Y",
+					Type:  "string",
+				},
+				"posZ": {
+					Title: "Position Z",
+					Type:  "string",
+				},
+				"zoom": {
+					Title: "Zoom",
+					Type:  "string",
+				},
+				"focus": {
+					Title: "Focus",
+					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

internal/processor/free-d-decode.go

@@ -37,7 +37,8 @@ func (fd *FreeDDecode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "freed.decode",
+		Type:  "freed.decode",
+		Title: "Decode FreeD",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &FreeDDecode{config: config}, nil
 		},

internal/processor/free-d-encode.go

@@ -34,7 +34,8 @@ func (fe *FreeDEncode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "freed.encode",
+		Type:  "freed.encode",
+		Title: "Encode FreeD",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &FreeDEncode{config: config}, nil
 		},

internal/processor/http-request-do.go

@@ -9,6 +9,7 @@ import (
 	"text/template"
 	"time"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -70,7 +71,24 @@ func (hrd *HTTPRequestDo) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "http.request.do",
+		Type:  "http.request.do",
+		Title: "Do HTTP Request",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"method": {
+					Title: "HTTP Method",
+					Type:  "string",
+					Enum:  []any{"GET", "POST", "PUT", "PATCH", "DELETE"},
+				},
+				"url": {
+					Title: "URL",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"method", "url"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/http-response-create.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"text/template"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -44,7 +45,23 @@ func (hrc *HTTPResponseCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "http.response.create",
+		Type:  "http.response.create",
+		Title: "Create HTTP Response",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"status": {
+					Title: "Status Code",
+					Type:  "integer",
+				},
+				"body": {
+					Title: "Body",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"status", "body"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/int-parse.go

@@ -2,10 +2,12 @@ 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"
 )
@@ -40,7 +42,26 @@ func (ip *IntParse) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "int.parse",
+		Type:  "int.parse",
+		Title: "Parse Int",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"base": {
+					Title:   "Base",
+					Type:    "integer",
+					Enum:    []any{0, 2, 8, 10, 16},
+					Default: json.RawMessage("10"),
+				},
+				"bitSize": {
+					Title:   "Bit Size",
+					Type:    "integer",
+					Enum:    []any{0, 8, 16, 32, 64},
+					Default: json.RawMessage("64"),
+				},
+			},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(moduleConfig config.ProcessorConfig) (Processor, error) {
 			params := moduleConfig.Params
 

internal/processor/int-random.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"math/rand/v2"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -28,7 +29,23 @@ func (ir *IntRandom) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "int.random",
+		Type:  "int.random",
+		Title: "Random Int",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"min": {
+					Title: "Minimum",
+					Type:  "integer",
+				},
+				"max": {
+					Title: "Maximum",
+					Type:  "integer",
+				},
+			},
+			Required:             []string{"min", "max"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/int-scale.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -36,7 +37,31 @@ func (ir *IntScale) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "int.scale",
+		Type:  "int.scale",
+		Title: "Scale Int",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"inMin": {
+					Title: "Input Minimum",
+					Type:  "integer",
+				},
+				"inMax": {
+					Title: "Input Maximum",
+					Type:  "integer",
+				},
+				"outMin": {
+					Title: "Output Minimum",
+					Type:  "integer",
+				},
+				"outMax": {
+					Title: "Output Maximum",
+					Type:  "integer",
+				},
+			},
+			Required:             []string{"inMin", "inMax", "outMin", "outMax"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/json-decode.go

@@ -46,7 +46,8 @@ func (jd *JsonDecode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "json.decode",
+		Type:  "json.decode",
+		Title: "Decode JSON",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &JsonDecode{config: config}, nil
 		},

internal/processor/json-encode.go

@@ -38,7 +38,8 @@ func (je *JsonEncode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "json.encode",
+		Type:  "json.encode",
+		Title: "Encode JSON",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &JsonEncode{config: config}, nil
 		},

internal/processor/kv-get.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -51,7 +52,23 @@ func (kvg *KVGet) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "kv.get",
+		Type:  "kv.get",
+		Title: "Get Key",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"module": {
+					Title: "Module ID",
+					Type:  "string",
+				},
+				"key": {
+					Title: "Key",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"module", "key"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 
 			params := config.Params

internal/processor/kv-set.go

@@ -8,6 +8,7 @@ import (
 	"html/template"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -62,7 +63,27 @@ func (kvs *KVSet) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "kv.set",
+		Type:  "kv.set",
+		Title: "Set Key",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"module": {
+					Title: "Module ID",
+					Type:  "string",
+				},
+				"key": {
+					Title: "Key",
+					Type:  "string",
+				},
+				"value": {
+					Title: "Value",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"module", "key", "value"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 
 			params := config.Params

internal/processor/midi-control_change-create.go

@@ -0,0 +1,134 @@
+//go:build cgo
+
+package processor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strconv"
+	"text/template"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"gitlab.com/gomidi/midi/v2"
+)
+
+type MIDIControlChangeCreate struct {
+	config  config.ProcessorConfig
+	Channel *template.Template
+	Control *template.Template
+	Value   *template.Template
+}
+
+func (mccc *MIDIControlChangeCreate) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	templateData := wrappedPayload
+
+	var channelBuffer bytes.Buffer
+	err := mccc.Channel.Execute(&channelBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
+
+	var controlBuffer bytes.Buffer
+	err = mccc.Control.Execute(&controlBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	controlValue, err := strconv.ParseUint(controlBuffer.String(), 10, 8)
+
+	var valueBuffer bytes.Buffer
+	err = mccc.Value.Execute(&valueBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	valueValue, err := strconv.ParseUint(valueBuffer.String(), 10, 8)
+
+	payloadMessage := midi.ControlChange(uint8(channelValue), uint8(controlValue), uint8(valueValue))
+	wrappedPayload.Payload = payloadMessage
+	return wrappedPayload, nil
+}
+
+func (mccc *MIDIControlChangeCreate) Type() string {
+	return mccc.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "midi.control_change.create",
+		Title: "Create MIDI Control Change Message",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"channel": {
+					Title: "Channel",
+					Type:  "string",
+				},
+				"control": {
+					Title: "Control",
+					Type:  "string",
+				},
+				"value": {
+					Title: "Value",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"channel", "control", "value"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+
+			params := config.Params
+
+			channelString, err := params.GetString("channel")
+			if err != nil {
+				return nil, fmt.Errorf("midi.control_change.create channel error: %w", err)
+			}
+
+			channelTemplate, err := template.New("channel").Parse(channelString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			controlString, err := params.GetString("control")
+			if err != nil {
+				return nil, fmt.Errorf("midi.control_change.create control error: %w", err)
+			}
+
+			controlTemplate, err := template.New("control").Parse(controlString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			valueString, err := params.GetString("value")
+			if err != nil {
+				return nil, fmt.Errorf("midi.control_change.create value error: %w", err)
+			}
+
+			valueTemplate, err := template.New("value").Parse(valueString)
+
+			if err != nil {
+				return nil, err
+			}
+			return &MIDIControlChangeCreate{
+				config:  config,
+				Channel: channelTemplate,
+				Control: controlTemplate,
+				Value:   valueTemplate,
+			}, nil
+		},
+	})
+}

internal/processor/midi-message-create.go

@@ -1,340 +0,0 @@
-//go:build cgo
-
-package processor
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strconv"
-	"text/template"
-
-	"github.com/jwetzell/showbridge-go/internal/common"
-	"github.com/jwetzell/showbridge-go/internal/config"
-	"gitlab.com/gomidi/midi/v2"
-)
-
-// TODO(jwetzell): support using numbers in config file treated as hardcoded values
-type MIDIMessageCreate struct {
-	config      config.ProcessorConfig
-	ProcessFunc func(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error)
-}
-
-func (mmc *MIDIMessageCreate) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-	return mmc.ProcessFunc(ctx, wrappedPayload)
-}
-
-func (mmc *MIDIMessageCreate) Type() string {
-	return mmc.config.Type
-}
-
-func newMidiNoteOnCreate(config config.ProcessorConfig) (Processor, error) {
-
-	params := config.Params
-
-	channelString, err := params.GetString("channel")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create channel error: %w", err)
-	}
-
-	channelTemplate, err := template.New("channel").Parse(channelString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	noteString, err := params.GetString("note")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create note error: %w", err)
-	}
-
-	noteTemplate, err := template.New("note").Parse(noteString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	velocityString, err := params.GetString("velocity")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create velocity error: %w", err)
-	}
-
-	velocityTemplate, err := template.New("velocity").Parse(velocityString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &MIDIMessageCreate{config: config, ProcessFunc: func(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-		templateData := wrappedPayload
-
-		var channelBuffer bytes.Buffer
-		err := channelTemplate.Execute(&channelBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
-
-		var noteBuffer bytes.Buffer
-		err = noteTemplate.Execute(&noteBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		noteValue, err := strconv.ParseUint(noteBuffer.String(), 10, 8)
-
-		var velocityBuffer bytes.Buffer
-		err = velocityTemplate.Execute(&velocityBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		velocityValue, err := strconv.ParseUint(velocityBuffer.String(), 10, 8)
-		payloadMessage := midi.NoteOn(uint8(channelValue), uint8(noteValue), uint8(velocityValue))
-		wrappedPayload.Payload = payloadMessage
-		return wrappedPayload, nil
-	}}, nil
-}
-
-func newMidiNoteOffCreate(config config.ProcessorConfig) (Processor, error) {
-
-	params := config.Params
-
-	channelString, err := params.GetString("channel")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create channel error: %w", err)
-	}
-
-	channelTemplate, err := template.New("channel").Parse(channelString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	noteString, err := params.GetString("note")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create note error: %w", err)
-	}
-
-	noteTemplate, err := template.New("note").Parse(noteString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	velocityString, err := params.GetString("velocity")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create velocity error: %w", err)
-	}
-
-	velocityTemplate, err := template.New("velocity").Parse(velocityString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &MIDIMessageCreate{config: config, ProcessFunc: func(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-
-		templateData := wrappedPayload
-
-		var channelBuffer bytes.Buffer
-		err := channelTemplate.Execute(&channelBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
-
-		var noteBuffer bytes.Buffer
-		err = noteTemplate.Execute(&noteBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		noteValue, err := strconv.ParseUint(noteBuffer.String(), 10, 8)
-
-		var velocityBuffer bytes.Buffer
-		err = velocityTemplate.Execute(&velocityBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		velocityValue, err := strconv.ParseUint(velocityBuffer.String(), 10, 8)
-
-		payloadMessage := midi.NoteOffVelocity(uint8(channelValue), uint8(noteValue), uint8(velocityValue))
-		wrappedPayload.Payload = payloadMessage
-		return wrappedPayload, nil
-	}}, nil
-}
-
-func newMidiControlChangeCreate(config config.ProcessorConfig) (Processor, error) {
-
-	params := config.Params
-
-	channelString, err := params.GetString("channel")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create channel error: %w", err)
-	}
-
-	channelTemplate, err := template.New("channel").Parse(channelString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	controlString, err := params.GetString("control")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create control error: %w", err)
-	}
-
-	controlTemplate, err := template.New("control").Parse(controlString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	valueString, err := params.GetString("value")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create value error: %w", err)
-	}
-
-	valueTemplate, err := template.New("value").Parse(valueString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &MIDIMessageCreate{config: config, ProcessFunc: func(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-
-		templateData := wrappedPayload
-
-		var channelBuffer bytes.Buffer
-		err := channelTemplate.Execute(&channelBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
-
-		var controlBuffer bytes.Buffer
-		err = controlTemplate.Execute(&controlBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		controlValue, err := strconv.ParseUint(controlBuffer.String(), 10, 8)
-
-		var valueBuffer bytes.Buffer
-		err = valueTemplate.Execute(&valueBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		valueValue, err := strconv.ParseUint(valueBuffer.String(), 10, 8)
-
-		payloadMessage := midi.ControlChange(uint8(channelValue), uint8(controlValue), uint8(valueValue))
-		wrappedPayload.Payload = payloadMessage
-		return wrappedPayload, nil
-	}}, nil
-}
-
-func newMidiProgramChangeCreate(config config.ProcessorConfig) (Processor, error) {
-
-	params := config.Params
-
-	channelString, err := params.GetString("channel")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create channel error: %w", err)
-	}
-
-	channelTemplate, err := template.New("channel").Parse(channelString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	programString, err := params.GetString("program")
-	if err != nil {
-		return nil, fmt.Errorf("midi.message.create program error: %w", err)
-	}
-
-	programTemplate, err := template.New("program").Parse(programString)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &MIDIMessageCreate{config: config, ProcessFunc: func(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
-		templateData := wrappedPayload
-
-		var channelBuffer bytes.Buffer
-		err := channelTemplate.Execute(&channelBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
-
-		var programBuffer bytes.Buffer
-		err = programTemplate.Execute(&programBuffer, templateData)
-
-		if err != nil {
-			wrappedPayload.End = true
-			return wrappedPayload, err
-		}
-
-		programValue, err := strconv.ParseUint(programBuffer.String(), 10, 8)
-
-		payloadMessage := midi.ProgramChange(uint8(channelValue), uint8(programValue))
-		wrappedPayload.Payload = payloadMessage
-		return wrappedPayload, nil
-	}}, nil
-}
-
-func init() {
-	RegisterProcessor(ProcessorRegistration{
-		Type: "midi.message.create",
-		New: func(config config.ProcessorConfig) (Processor, error) {
-			params := config.Params
-
-			msgTypeString, err := params.GetString("type")
-			if err != nil {
-				return nil, fmt.Errorf("midi.message.create type error: %w", err)
-			}
-
-			switch msgTypeString {
-			case "NoteOn", "noteon", "note_on":
-				return newMidiNoteOnCreate(config)
-			case "NoteOff", "noteoff", "note_off":
-				return newMidiNoteOffCreate(config)
-			case "ControlChange", "controlchange", "control_change":
-				return newMidiControlChangeCreate(config)
-			case "ProgramChange", "programchange", "program_change":
-				return newMidiProgramChangeCreate(config)
-			default:
-				return nil, fmt.Errorf("midi.message.create does not support type %s", msgTypeString)
-			}
-		},
-	})
-}

internal/processor/midi-message-decode.go

@@ -36,7 +36,8 @@ func (mmd *MIDIMessageDecode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "midi.message.decode",
+		Type:  "midi.message.decode",
+		Title: "Decode MIDI Message",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &MIDIMessageDecode{config: config}, nil
 		},

internal/processor/midi-message-encode.go

@@ -34,7 +34,8 @@ func (mme *MIDIMessageEncode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "midi.message.encode",
+		Type:  "midi.message.encode",
+		Title: "Encode MIDI Message",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &MIDIMessageEncode{config: config}, nil
 		},

internal/processor/midi-message-unpack.go

@@ -92,7 +92,8 @@ func (mmu *MIDIMessageUnpack) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "midi.message.unpack",
+		Type:  "midi.message.unpack",
+		Title: "Unpack MIDI Message",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &MIDIMessageUnpack{config: config}, nil
 		},

internal/processor/midi-note_off-create.go

@@ -0,0 +1,132 @@
+//go:build cgo
+
+package processor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strconv"
+	"text/template"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"gitlab.com/gomidi/midi/v2"
+)
+
+type MIDINoteOffCreate struct {
+	config   config.ProcessorConfig
+	Channel  *template.Template
+	Note     *template.Template
+	Velocity *template.Template
+}
+
+func (mnoc *MIDINoteOffCreate) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	templateData := wrappedPayload
+
+	var channelBuffer bytes.Buffer
+	err := mnoc.Channel.Execute(&channelBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
+
+	var noteBuffer bytes.Buffer
+	err = mnoc.Note.Execute(&noteBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	noteValue, err := strconv.ParseUint(noteBuffer.String(), 10, 8)
+
+	var velocityBuffer bytes.Buffer
+	err = mnoc.Velocity.Execute(&velocityBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	velocityValue, err := strconv.ParseUint(velocityBuffer.String(), 10, 8)
+	payloadMessage := midi.NoteOffVelocity(uint8(channelValue), uint8(noteValue), uint8(velocityValue))
+	wrappedPayload.Payload = payloadMessage
+	return wrappedPayload, nil
+}
+
+func (mnoc *MIDINoteOffCreate) Type() string {
+	return mnoc.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "midi.note_off.create",
+		Title: "Create MIDI Note Off Message",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"channel": {
+					Title: "Channel",
+					Type:  "string",
+				},
+				"note": {
+					Title: "Note",
+					Type:  "string",
+				},
+				"velocity": {
+					Title: "Velocity",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"channel", "note", "velocity"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+
+			channelString, err := params.GetString("channel")
+			if err != nil {
+				return nil, fmt.Errorf("midi.note_off.create channel error: %w", err)
+			}
+
+			channelTemplate, err := template.New("channel").Parse(channelString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			noteString, err := params.GetString("note")
+			if err != nil {
+				return nil, fmt.Errorf("midi.note_off.create note error: %w", err)
+			}
+
+			noteTemplate, err := template.New("note").Parse(noteString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			velocityString, err := params.GetString("velocity")
+			if err != nil {
+				return nil, fmt.Errorf("midi.note_off.create velocity error: %w", err)
+			}
+
+			velocityTemplate, err := template.New("velocity").Parse(velocityString)
+
+			if err != nil {
+				return nil, err
+			}
+			return &MIDINoteOffCreate{
+				config:   config,
+				Channel:  channelTemplate,
+				Note:     noteTemplate,
+				Velocity: velocityTemplate,
+			}, nil
+		},
+	})
+}

internal/processor/midi-note_on-create.go

@@ -0,0 +1,132 @@
+//go:build cgo
+
+package processor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strconv"
+	"text/template"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"gitlab.com/gomidi/midi/v2"
+)
+
+type MIDINoteOnCreate struct {
+	config   config.ProcessorConfig
+	Channel  *template.Template
+	Note     *template.Template
+	Velocity *template.Template
+}
+
+func (mnoc *MIDINoteOnCreate) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	templateData := wrappedPayload
+
+	var channelBuffer bytes.Buffer
+	err := mnoc.Channel.Execute(&channelBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
+
+	var noteBuffer bytes.Buffer
+	err = mnoc.Note.Execute(&noteBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	noteValue, err := strconv.ParseUint(noteBuffer.String(), 10, 8)
+
+	var velocityBuffer bytes.Buffer
+	err = mnoc.Velocity.Execute(&velocityBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	velocityValue, err := strconv.ParseUint(velocityBuffer.String(), 10, 8)
+	payloadMessage := midi.NoteOn(uint8(channelValue), uint8(noteValue), uint8(velocityValue))
+	wrappedPayload.Payload = payloadMessage
+	return wrappedPayload, nil
+}
+
+func (mnoc *MIDINoteOnCreate) Type() string {
+	return mnoc.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "midi.note_on.create",
+		Title: "Create MIDI Note On Message",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"channel": {
+					Title: "Channel",
+					Type:  "string",
+				},
+				"note": {
+					Title: "Note",
+					Type:  "string",
+				},
+				"velocity": {
+					Title: "Velocity",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"channel", "note", "velocity"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+
+			channelString, err := params.GetString("channel")
+			if err != nil {
+				return nil, fmt.Errorf("midi.note_on.create channel error: %w", err)
+			}
+
+			channelTemplate, err := template.New("channel").Parse(channelString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			noteString, err := params.GetString("note")
+			if err != nil {
+				return nil, fmt.Errorf("midi.note_on.create note error: %w", err)
+			}
+
+			noteTemplate, err := template.New("note").Parse(noteString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			velocityString, err := params.GetString("velocity")
+			if err != nil {
+				return nil, fmt.Errorf("midi.note_on.create velocity error: %w", err)
+			}
+
+			velocityTemplate, err := template.New("velocity").Parse(velocityString)
+
+			if err != nil {
+				return nil, err
+			}
+			return &MIDINoteOnCreate{
+				config:   config,
+				Channel:  channelTemplate,
+				Note:     noteTemplate,
+				Velocity: velocityTemplate,
+			}, nil
+		},
+	})
+}

internal/processor/midi-program_change-create.go

@@ -0,0 +1,106 @@
+//go:build cgo
+
+package processor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strconv"
+	"text/template"
+
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"gitlab.com/gomidi/midi/v2"
+)
+
+type MIDIProgramChangeCreate struct {
+	config  config.ProcessorConfig
+	Channel *template.Template
+	Program *template.Template
+}
+
+func (mpcc *MIDIProgramChangeCreate) Process(ctx context.Context, wrappedPayload common.WrappedPayload) (common.WrappedPayload, error) {
+	templateData := wrappedPayload
+
+	var channelBuffer bytes.Buffer
+	err := mpcc.Channel.Execute(&channelBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	channelValue, err := strconv.ParseUint(channelBuffer.String(), 10, 8)
+
+	var programBuffer bytes.Buffer
+	err = mpcc.Program.Execute(&programBuffer, templateData)
+
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, err
+	}
+
+	programValue, err := strconv.ParseUint(programBuffer.String(), 10, 8)
+
+	payloadMessage := midi.ProgramChange(uint8(channelValue), uint8(programValue))
+	wrappedPayload.Payload = payloadMessage
+	return wrappedPayload, nil
+}
+
+func (mpcc *MIDIProgramChangeCreate) Type() string {
+	return mpcc.config.Type
+}
+
+func init() {
+	RegisterProcessor(ProcessorRegistration{
+		Type:  "midi.program_change.create",
+		Title: "Create MIDI Prgoram Change Message",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"channel": {
+					Title: "Channel",
+					Type:  "string",
+				},
+				"program": {
+					Title: "Program",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"type", "channel", "program"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
+		New: func(config config.ProcessorConfig) (Processor, error) {
+			params := config.Params
+
+			channelString, err := params.GetString("channel")
+			if err != nil {
+				return nil, fmt.Errorf("midi.program_change.create channel error: %w", err)
+			}
+
+			channelTemplate, err := template.New("channel").Parse(channelString)
+
+			if err != nil {
+				return nil, err
+			}
+
+			programString, err := params.GetString("program")
+			if err != nil {
+				return nil, fmt.Errorf("midi.program_change.create program error: %w", err)
+			}
+
+			programTemplate, err := template.New("program").Parse(programString)
+
+			if err != nil {
+				return nil, err
+			}
+			return &MIDIProgramChangeCreate{
+				config:  config,
+				Channel: channelTemplate,
+				Program: programTemplate,
+			}, nil
+		},
+	})
+}

internal/processor/mqtt-message-create.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -80,7 +81,31 @@ func (mmc *MQTTMessageCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "mqtt.message.create",
+		Type:  "mqtt.message.create",
+		Title: "Create MQTT Message",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"topic": {
+					Title: "Topic",
+					Type:  "string",
+				},
+				"qos": {
+					Title: "QoS",
+					Type:  "number",
+				},
+				"retained": {
+					Title: "Retained",
+					Type:  "boolean",
+				},
+				"payload": {
+					Title: "Payload",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"topic", "qos", "retained", "payload"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(processorConfig config.ProcessorConfig) (Processor, error) {
 			params := processorConfig.Params
 			topicString, err := params.GetString("topic")

internal/processor/nats-message-create.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"text/template"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -59,7 +60,23 @@ func (nmc *NATSMessageCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "nats.message.create",
+		Type:  "nats.message.create",
+		Title: "Create NATS Message",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"subject": {
+					Title: "Subject",
+					Type:  "string",
+				},
+				"payload": {
+					Title: "Payload",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"subject", "payload"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			subjectString, err := params.GetString("subject")

internal/processor/osc-message-create.go

@@ -9,6 +9,7 @@ import (
 	"strconv"
 	"text/template"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/osc-go"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
@@ -86,7 +87,30 @@ func (omc *OSCMessageCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "osc.message.create",
+		Type:  "osc.message.create",
+		Title: "Create OSC Message",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"address": {
+					Title: "Address",
+					Type:  "string",
+				},
+				"args": {
+					Title: "Arguments",
+					Type:  "array",
+					Items: &jsonschema.Schema{
+						Type: "string",
+					},
+				},
+				"types": {
+					Title: "Argument Types",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"address"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(processorConfig config.ProcessorConfig) (Processor, error) {
 			params := processorConfig.Params
 			addressString, err := params.GetString("address")

internal/processor/osc-message-decode.go

@@ -48,7 +48,8 @@ func (omd *OSCMessageDecode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "osc.message.decode",
+		Type:  "osc.message.decode",
+		Title: "Decode OSC Message",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &OSCMessageDecode{config: config}, nil
 		},

internal/processor/osc-message-encode.go

@@ -3,6 +3,7 @@ package processor
 import (
 	"context"
 	"errors"
+	"fmt"
 
 	osc "github.com/jwetzell/osc-go"
 	"github.com/jwetzell/showbridge-go/internal/common"
@@ -22,7 +23,12 @@ func (ome *OSCMessageEncode) Process(ctx context.Context, wrappedPayload common.
 		return wrappedPayload, errors.New("osc.message.encode processor only accepts an *OSCMessage")
 	}
 
-	wrappedPayload.Payload = payloadMessage.ToBytes()
+	bytes, err := payloadMessage.ToBytes()
+	if err != nil {
+		wrappedPayload.End = true
+		return wrappedPayload, fmt.Errorf("osc.message.encode processor failed to encode OSCMessage: %w", err)
+	}
+	wrappedPayload.Payload = bytes
 	return wrappedPayload, nil
 }
 
@@ -32,7 +38,8 @@ func (ome *OSCMessageEncode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "osc.message.encode",
+		Type:  "osc.message.encode",
+		Title: "Encode OSC Message",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &OSCMessageEncode{config: config}, nil
 		},

internal/processor/processor.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"sync"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -15,8 +16,11 @@ type Processor interface {
 }
 
 type ProcessorRegistration struct {
-	Type string `json:"type"`
-	New  func(config.ProcessorConfig) (Processor, error)
+	Type         string             `json:"type"`
+	Title        string             `json:"title,omitempty"`
+	Description  string             `json:"description,omitempty"`
+	ParamsSchema *jsonschema.Schema `json:"paramsSchema,omitempty"`
+	New          func(config.ProcessorConfig) (Processor, error)
 }
 
 func RegisterProcessor(processor ProcessorRegistration) {

internal/processor/router-input.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -44,7 +45,20 @@ func (ro *RouterInput) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "router.input",
+		Type:  "router.input",
+		Title: "Router Input",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"source": {
+					Title:       "Source",
+					Type:        "string",
+					Description: "source to report as to the router",
+				},
+			},
+			Required:             []string{"source"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 
 			params := config.Params

internal/processor/router-output.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log/slog"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -40,7 +41,20 @@ func (ro *RouterOutput) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "router.output",
+		Type:  "router.output",
+		Title: "Router Output",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"module": {
+					Title:       "Module ID",
+					Type:        "string",
+					Description: "ID of module to send output to",
+				},
+			},
+			Required:             []string{"module"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 
 			params := config.Params

internal/processor/script-expr.go

@@ -6,6 +6,7 @@ import (
 
 	"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"
 )
@@ -36,7 +37,19 @@ func (se *ScriptExpr) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "script.expr",
+		Type:  "script.expr",
+		Title: "Evaluate Expr Expression",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"expression": {
+					Title: "Expression",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"expression"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/script-js.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 	"modernc.org/quickjs"
@@ -21,9 +22,9 @@ func (sj *ScriptJS) Process(ctx context.Context, wrappedPayload common.WrappedPa
 
 	//NOTE(jwetzell): some weird conversion going on with these types
 	_, isUint8Slice := common.GetAnyAs[[]uint8](wrappedPayload.Payload)
-	_, isbyteSlice := common.GetAnyAs[[]byte](wrappedPayload.Payload)
+	_, isByteSlice := common.GetAnyAs[[]byte](wrappedPayload.Payload)
 
-	if isUint8Slice || isbyteSlice {
+	if isUint8Slice || isByteSlice {
 		intSlice, ok := common.GetAnyAsIntSlice(wrappedPayload.Payload)
 
 		if ok {
@@ -93,7 +94,19 @@ func (sj *ScriptJS) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "script.js",
+		Type:  "script.js",
+		Title: "Run JavaScript",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"program": {
+					Title: "Program",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"program"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/script-wasm.go

@@ -2,10 +2,12 @@ package processor
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 
 	extism "github.com/extism/go-sdk"
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -50,7 +52,29 @@ func (sw *ScriptWASM) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "script.wasm",
+		Type:  "script.wasm",
+		Title: "Run WASM Plugin",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"path": {
+					Title: "Path",
+					Type:  "string",
+				},
+				"function": {
+					Title:   "Function",
+					Type:    "string",
+					Default: json.RawMessage(`"process"`),
+				},
+				"enableWasi": {
+					Title:   "Enable WASI",
+					Type:    "boolean",
+					Default: json.RawMessage("false"),
+				},
+			},
+			Required:             []string{"path"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(processorConfig config.ProcessorConfig) (Processor, error) {
 			params := processorConfig.Params
 

internal/processor/sip-response-audio-create.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"text/template"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -51,7 +52,26 @@ func (srac *SipResponseAudioCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "sip.response.audio.create",
+		Type:  "sip.response.audio.create",
+		Title: "Create SIP Audio Response",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"preWait": {
+					Title: "Pre Wait (ms)",
+					Type:  "integer",
+				},
+				"postWait": {
+					Title: "Post Wait (ms)",
+					Type:  "integer",
+				},
+				"audioFile": {
+					Type: "string",
+				},
+			},
+			Required:             []string{"preWait", "postWait", "audioFile"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/sip-response-dtmf-create.go

@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"text/template"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -59,7 +60,26 @@ func (srdc *SipResponseDTMFCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "sip.response.dtmf.create",
+		Type:  "sip.response.dtmf.create",
+		Title: "Create SIP DTMF Response",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"preWait": {
+					Title: "Pre Wait (ms)",
+					Type:  "integer",
+				},
+				"postWait": {
+					Title: "Post Wait (ms)",
+					Type:  "integer",
+				},
+				"digits": {
+					Type: "string",
+				},
+			},
+			Required:             []string{"preWait", "postWait", "digits"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/string-create.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"text/template"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -37,7 +38,19 @@ func (sc *StringCreate) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "string.create",
+		Type:  "string.create",
+		Title: "Create String",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"template": {
+					Title: "Template",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"template"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			templateString, err := params.GetString("template")

internal/processor/string-decode.go

@@ -33,7 +33,8 @@ func (sd *StringDecode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "string.decode",
+		Type:  "string.decode",
+		Title: "Decode String",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &StringDecode{config: config}, nil
 		},

internal/processor/string-encode.go

@@ -32,7 +32,8 @@ func (se *StringEncode) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "string.encode",
+		Type:  "string.encode",
+		Title: "Encode String",
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			return &StringEncode{config: config}, nil
 		},

internal/processor/string-split.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -35,7 +36,19 @@ func (ss *StringSplit) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "string.split",
+		Type:  "string.split",
+		Title: "Split String",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"separator": {
+					Title: "Separator",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"separator"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 

internal/processor/struct-field-get.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -44,7 +45,19 @@ func (sf *StructFieldGet) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "struct.field.get",
+		Type:  "struct.field.get",
+		Title: "Get Struct Field",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"name": {
+					Title: "Field Name",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"name"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			nameString, err := params.GetString("name")

internal/processor/struct-method-get.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/jwetzell/showbridge-go/internal/common"
 	"github.com/jwetzell/showbridge-go/internal/config"
 )
@@ -63,7 +64,19 @@ func (sm *StructMethodGet) Type() string {
 
 func init() {
 	RegisterProcessor(ProcessorRegistration{
-		Type: "struct.method.get",
+		Type:  "struct.method.get",
+		Title: "Get Struct Method",
+		ParamsSchema: &jsonschema.Schema{
+			Type: "object",
+			Properties: map[string]*jsonschema.Schema{
+				"name": {
+					Title: "Method Name",
+					Type:  "string",
+				},
+			},
+			Required:             []string{"name"},
+			AdditionalProperties: &jsonschema.Schema{Not: &jsonschema.Schema{}},
+		},
 		New: func(config config.ProcessorConfig) (Processor, error) {
 			params := config.Params
 			nameString, err := params.GetString("name")

internal/processor/test/db-query_test.go

@@ -0,0 +1,301 @@
+package processor_test
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"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/test"
+	_ "modernc.org/sqlite"
+)
+
+func TestDbQueryFromRegistry(t *testing.T) {
+	registration, ok := processor.ProcessorRegistry["db.query"]
+	if !ok {
+		t.Fatalf("db.query processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "db.query",
+		Params: map[string]any{
+			"module": "test",
+			"query":  "SELECT sqlite_version();",
+		},
+	})
+	if err != nil {
+		t.Fatalf("failed to create db.query processor: %s", err)
+	}
+
+	if processorInstance.Type() != "db.query" {
+		t.Fatalf("db.query processor has wrong type: %s", processorInstance.Type())
+	}
+
+	payload := "hello"
+	expected := map[string]any{"sqlite_version()": "3.51.3"}
+
+	got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.GetContextWithModules(
+		t.Context(),
+		map[string]common.Module{
+			"test": test.NewTestDBModule("test"),
+		},
+	), payload))
+	if err != nil {
+		t.Fatalf("db.query processing failed: %s", err)
+	}
+
+	if !reflect.DeepEqual(got.Payload, expected) {
+		t.Fatalf("db.query got %+v, expected %+v", got.Payload, expected)
+	}
+}
+
+func TestGoodDbQuery(t *testing.T) {
+
+	testCases := []struct {
+		name     string
+		params   map[string]any
+		payload  any
+		expected any
+	}{
+		{
+			name: "basic query",
+			params: map[string]any{
+				"module": "test",
+				"query":  "select value from test where id = 1;",
+			},
+			payload:  "",
+			expected: map[string]any{"value": "test-1"},
+		},
+		{
+			name: "template query",
+			params: map[string]any{
+				"module": "test",
+				"query":  "select value from test where id = {{.Payload}};",
+			},
+			payload:  "1",
+			expected: map[string]any{"value": "test-1"},
+		},
+		{
+			name: "multiple rows",
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from test;",
+			},
+			payload: "",
+			expected: []map[string]any{
+				{"id": int64(1), "value": "test-1"},
+				{"id": int64(2), "value": "test-2"},
+			},
+		},
+		{
+			name: "no rows",
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from test where id = -1;",
+			},
+			payload:  "",
+			expected: nil,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["db.query"]
+			if !ok {
+				t.Fatalf("db.query processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "db.query",
+				Params: testCase.params,
+			})
+
+			if err != nil {
+				t.Fatalf("db.query failed to create processor: %s", err)
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.GetContextWithModules(
+				t.Context(),
+				map[string]common.Module{
+					"test": test.NewTestDBModule("test"),
+				},
+			), testCase.payload))
+
+			if err != nil {
+				t.Fatalf("db.query processing failed: %s", err)
+			}
+
+			if !reflect.DeepEqual(got.Payload, testCase.expected) {
+				t.Fatalf("db.query got payload: %+v, expected %+v", got.Payload, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadDbQuery(t *testing.T) {
+	tests := []struct {
+		name              string
+		params            map[string]any
+		payload           any
+		wrappedPayloadCtx context.Context
+		errorString       string
+	}{
+		{
+			name:    "no module param",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"query": "SELECT sqlite_version();",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "db.query module error: not found",
+		},
+		{
+			name:    "non string module",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": 1,
+				"query":  "SELECT sqlite_version();",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "db.query module error: not a string",
+		},
+		{
+			name:    "no query param",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "db.query query error: not found",
+		},
+		{
+			name:    "non string query",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  1,
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "db.query query error: not a string",
+		},
+		{
+			name:    "query template syntax error",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from {{",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "template: query:1: unclosed action",
+		},
+		{
+			name:    "query template error",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from {{.Data}}",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "template: query:1:16: executing \"query\" at <.Data>: can't evaluate field Data in type common.WrappedPayload",
+		},
+		{
+			name:    "query error",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from asdf;",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "db.query error executing query: SQL logic error: no such table: asdf (1)",
+		},
+		{
+			name:    "no modules in context",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from test;",
+			},
+			wrappedPayloadCtx: t.Context(),
+			errorString:       "db.query wrapped payload has no modules",
+		},
+		{
+			name:    "module not found in context",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from test;",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{}),
+			errorString:       "db.query unable to find module with id: test",
+		},
+		{
+			name:    "module not found in context",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from test;",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{}),
+			errorString:       "db.query unable to find module with id: test",
+		},
+		{
+			name:    "module not a DatabseModule",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"query":  "select * from test;",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestKVModule("test"),
+			}),
+			errorString: "db.query module with id test is not a DatabaseModule",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := processor.ProcessorRegistry["db.query"]
+			if !ok {
+				t.Fatalf("db.query processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "db.query",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("db.query got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.wrappedPayloadCtx, test.payload))
+
+			if err == nil {
+				t.Fatalf("db.query expected to fail but got payload: %+v", got)
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("db.query got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/test/filter-change_test.go

@@ -0,0 +1,124 @@
+package processor_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/processor"
+)
+
+func TestFilterChangeFromRegistry(t *testing.T) {
+	registration, ok := processor.ProcessorRegistry["filter.change"]
+	if !ok {
+		t.Fatalf("filter.change processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "filter.change",
+	})
+	if err != nil {
+		t.Fatalf("failed to create filter.change processor: %s", err)
+	}
+
+	if processorInstance.Type() != "filter.change" {
+		t.Fatalf("filter.change processor has wrong type: %s", processorInstance.Type())
+	}
+
+	payload := "hello"
+	expected := "hello"
+
+	got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), payload))
+	if err != nil {
+		t.Fatalf("filter.change processing failed: %s", err)
+	}
+
+	if !reflect.DeepEqual(got.Payload, expected) {
+		t.Fatalf("filter.change got %+v, expected %+v", got.Payload, expected)
+	}
+}
+
+func TestGoodFilterChange(t *testing.T) {
+	tests := []struct {
+		name    string
+		params  map[string]any
+		payload string
+		match   bool
+	}{
+		{
+			name:    "basic",
+			payload: "hello",
+			params:  nil,
+			match:   true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["filter.change"]
+			if !ok {
+				t.Fatalf("filter.change processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "filter.change",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("filter.change failed to create processor: %s", err)
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
+
+			if err != nil {
+				t.Fatalf("filter.change processing failed: %s", err)
+			}
+
+			if got.End != !test.match {
+				t.Fatalf("filter.change did not filter properly %+v, expected %+v", got, test.match)
+			}
+		})
+	}
+}
+
+func TestBadFilterChange(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]any
+		payload     any
+		errorString string
+	}{}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["filter.change"]
+			if !ok {
+				t.Fatalf("filter.change processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "filter.change",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("filter.change got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
+
+			if err == nil {
+				t.Fatalf("filter.change expected to fail but got payload: %+v", got)
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("filter.change got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/test/filter-expr_test.go

@@ -6,6 +6,7 @@ import (
 	"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/test"
 )
 
 func TestFilterExprFromRegistry(t *testing.T) {
@@ -30,7 +31,7 @@ func TestFilterExprFromRegistry(t *testing.T) {
 }
 
 func TestGoodFilterExpr(t *testing.T) {
-	tests := []struct {
+	testCases := []struct {
 		name    string
 		params  map[string]any
 		payload any
@@ -41,7 +42,7 @@ func TestGoodFilterExpr(t *testing.T) {
 			params: map[string]any{
 				"expression": "Payload.Int > 0",
 			},
-			payload: TestStruct{
+			payload: test.TestStruct{
 				Int: 1,
 			},
 			match: true,
@@ -51,7 +52,7 @@ func TestGoodFilterExpr(t *testing.T) {
 			params: map[string]any{
 				"expression": "Payload.String == 'hello'",
 			},
-			payload: TestStruct{
+			payload: test.TestStruct{
 				String: "hello",
 			},
 			match: true,
@@ -61,15 +62,15 @@ func TestGoodFilterExpr(t *testing.T) {
 			params: map[string]any{
 				"expression": "Payload.Int > 0",
 			},
-			payload: TestStruct{
+			payload: test.TestStruct{
 				Int: 0,
 			},
 			match: false,
 		},
 	}
 
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
 			registration, ok := processor.ProcessorRegistry["filter.expr"]
 			if !ok {
 				t.Fatalf("filter.expr processor not registered")
@@ -77,22 +78,22 @@ func TestGoodFilterExpr(t *testing.T) {
 
 			processorInstance, err := registration.New(config.ProcessorConfig{
 				Type:   "filter.expr",
-				Params: test.params,
+				Params: testCase.params,
 			})
 
 			if err != nil {
 				t.Fatalf("filter.expr failed to create processor: %s", err)
 			}
 
-			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), testCase.payload))
 
 			if err != nil {
 				t.Fatalf("filter.expr processing failed: %s", err)
 			}
 
 			//TODO(jwetzell): work out better way to compare the any/any
-			if got.End != !test.match {
-				t.Fatalf("filter.expr did fitler properly %+v (%T), expected %+v (%T)", got, got, test.match, test.match)
+			if got.End != !testCase.match {
+				t.Fatalf("filter.expr did fitler properly %+v (%T), expected %+v (%T)", got, got, testCase.match, testCase.match)
 			}
 		})
 	}
@@ -110,7 +111,7 @@ func TestBadFilterExpr(t *testing.T) {
 			params: map[string]any{
 				// no expression parameter
 			},
-			payload:     TestStruct{},
+			payload:     test.TestStruct{},
 			errorString: "filter.expr expression error: not found",
 		},
 		{
@@ -118,7 +119,7 @@ func TestBadFilterExpr(t *testing.T) {
 			params: map[string]any{
 				"expression": 12345,
 			},
-			payload:     TestStruct{},
+			payload:     test.TestStruct{},
 			errorString: "filter.expr expression error: not a string",
 		},
 		{
@@ -126,7 +127,7 @@ func TestBadFilterExpr(t *testing.T) {
 			params: map[string]any{
 				"expression": "foo +",
 			},
-			payload:     TestStruct{},
+			payload:     test.TestStruct{},
 			errorString: "unexpected token EOF (1:5)\n | foo +\n | ....^",
 		},
 		{

internal/processor/test/filter-regex_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/jwetzell/showbridge-go/internal/processor"
 )
 
-func TestStringFilterFromRegistry(t *testing.T) {
+func TestFilterRegexFromRegistry(t *testing.T) {
 	registration, ok := processor.ProcessorRegistry["filter.regex"]
 	if !ok {
 		t.Fatalf("filter.regex processor not registered")
@@ -39,7 +39,7 @@ func TestStringFilterFromRegistry(t *testing.T) {
 	gotString, ok := got.Payload.(string)
 
 	if !ok {
-		t.Fatalf("filter.regex should return byte slice")
+		t.Fatalf("filter.regex should return string")
 	}
 
 	if gotString != expected {
@@ -47,7 +47,7 @@ func TestStringFilterFromRegistry(t *testing.T) {
 	}
 }
 
-func TestGoodStringFilter(t *testing.T) {
+func TestGoodFilterRegex(t *testing.T) {
 	tests := []struct {
 		name    string
 		params  map[string]any
@@ -103,7 +103,7 @@ func TestGoodStringFilter(t *testing.T) {
 	}
 }
 
-func TestBadStringFilter(t *testing.T) {
+func TestBadFilterRegex(t *testing.T) {
 	tests := []struct {
 		name        string
 		params      map[string]any

internal/processor/test/kv-get_test.go

@@ -0,0 +1,235 @@
+package processor_test
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"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/test"
+)
+
+func TestKvGetFromRegistry(t *testing.T) {
+	registration, ok := processor.ProcessorRegistry["kv.get"]
+	if !ok {
+		t.Fatalf("kv.get processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "kv.get",
+		Params: map[string]any{
+			"module": "test",
+			"key":    "test",
+		},
+	})
+	if err != nil {
+		t.Fatalf("failed to create kv.get processor: %s", err)
+	}
+
+	if processorInstance.Type() != "kv.get" {
+		t.Fatalf("kv.get processor has wrong type: %s", processorInstance.Type())
+	}
+
+	payload := "hello"
+	expected := "test"
+
+	got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.GetContextWithModules(
+		t.Context(),
+		map[string]common.Module{
+			"test": test.NewTestKVModule("test"),
+		},
+	), payload))
+	if err != nil {
+		t.Fatalf("kv.get processing failed: %s", err)
+	}
+
+	if got.Payload != expected {
+		t.Fatalf("kv.get got %+v, expected %+v", got.Payload, expected)
+	}
+}
+
+func TestGoodKvGet(t *testing.T) {
+
+	testCases := []struct {
+		name     string
+		params   map[string]any
+		payload  any
+		expected any
+	}{
+		{
+			name: "basic value",
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "hello",
+			},
+			payload:  "hello",
+			expected: "test",
+		},
+		{
+			name: "template value",
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "{{.Payload}}",
+			},
+			payload:  "hello",
+			expected: "test",
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["kv.get"]
+			if !ok {
+				t.Fatalf("kv.get processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "kv.get",
+				Params: testCase.params,
+			})
+
+			if err != nil {
+				t.Fatalf("kv.get failed to create processor: %s", err)
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.GetContextWithModules(
+				t.Context(),
+				map[string]common.Module{
+					"test": test.NewTestKVModule("test"),
+				},
+			), testCase.payload))
+
+			if err != nil {
+				t.Fatalf("kv.get processing failed: %s", err)
+			}
+
+			if !reflect.DeepEqual(got.Payload, testCase.expected) {
+				t.Fatalf("kv.get got payload: %+v, expected %+v", got.Payload, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadKvGet(t *testing.T) {
+	tests := []struct {
+		name              string
+		params            map[string]any
+		payload           any
+		wrappedPayloadCtx context.Context
+		errorString       string
+	}{
+		{
+			name:    "no module param",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"key": "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestKVModule("test"),
+			}),
+			errorString: "kv.get module error: not found",
+		},
+		{
+			name:    "non string module",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": 1,
+				"key":    "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestKVModule("test"),
+			}),
+			errorString: "kv.get module error: not a string",
+		},
+		{
+			name:    "no key param",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestKVModule("test"),
+			}),
+			errorString: "kv.get key error: not found",
+		},
+		{
+			name:    "non string key",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    1,
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestKVModule("test"),
+			}),
+			errorString: "kv.get key error: not a string",
+		},
+		{
+			name:    "no modules in context",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+			},
+			wrappedPayloadCtx: t.Context(),
+			errorString:       "kv.get wrapped payload has no modules",
+		},
+		{
+			name:    "module not found in context",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{}),
+			errorString:       "kv.get unable to find module with id: test",
+		},
+		{
+			name:    "module not a kv module",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "kv.get module with id test is not a KeyValueModule",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			registration, ok := processor.ProcessorRegistry["kv.get"]
+			if !ok {
+				t.Fatalf("kv.get processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "kv.get",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("kv.get got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.wrappedPayloadCtx, test.payload))
+
+			if err == nil {
+				t.Fatalf("kv.get expected to fail but got payload: %+v", got)
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("kv.get got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/test/kv-set_test.go

@@ -0,0 +1,284 @@
+package processor_test
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"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/test"
+)
+
+func TestKvSetFromRegistry(t *testing.T) {
+	registration, ok := processor.ProcessorRegistry["kv.set"]
+	if !ok {
+		t.Fatalf("kv.set processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "kv.set",
+		Params: map[string]any{
+			"module": "test",
+			"key":    "test",
+			"value":  "hello",
+		},
+	})
+	if err != nil {
+		t.Fatalf("failed to create kv.set processor: %s", err)
+	}
+
+	if processorInstance.Type() != "kv.set" {
+		t.Fatalf("kv.set processor has wrong type: %s", processorInstance.Type())
+	}
+
+	payload := ""
+	expected := ""
+
+	got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.GetContextWithModules(
+		t.Context(),
+		map[string]common.Module{
+			"test": &test.TestKVModule{},
+		},
+	), payload))
+	if err != nil {
+		t.Fatalf("kv.set processing failed: %s", err)
+	}
+
+	if got.Payload != expected {
+		t.Fatalf("kv.set got %+v, expected %+v", got.Payload, expected)
+	}
+}
+
+func TestGoodKvSet(t *testing.T) {
+
+	testCases := []struct {
+		name     string
+		params   map[string]any
+		payload  any
+		expected any
+	}{
+		{
+			name: "basic key/value",
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "hello",
+			},
+			payload:  "",
+			expected: "",
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["kv.set"]
+			if !ok {
+				t.Fatalf("kv.set processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "kv.set",
+				Params: testCase.params,
+			})
+
+			if err != nil {
+				t.Fatalf("kv.set failed to create processor: %s", err)
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(test.GetContextWithModules(
+				t.Context(),
+				map[string]common.Module{
+					"test": &test.TestKVModule{},
+				},
+			), testCase.payload))
+
+			if err != nil {
+				t.Fatalf("kv.set processing failed: %s", err)
+			}
+
+			if !reflect.DeepEqual(got.Payload, testCase.expected) {
+				t.Fatalf("kv.set got payload: %+v, expected %+v", got.Payload, testCase.expected)
+			}
+		})
+	}
+}
+
+func TestBadKvSet(t *testing.T) {
+	testCases := []struct {
+		name              string
+		params            map[string]any
+		payload           any
+		wrappedPayloadCtx context.Context
+		errorString       string
+	}{
+		{
+			name:    "no module param",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"key":   "test",
+				"value": "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "kv.set module error: not found",
+		},
+		{
+			name:    "non string module",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": 1,
+				"key":    "test",
+				"value":  "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "kv.set module error: not a string",
+		},
+		{
+			name:    "no key param",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"value":  "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "kv.set key error: not found",
+		},
+		{
+			name:    "non string key",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    1,
+				"value":  "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "kv.set key error: not a string",
+		},
+		{
+			name:    "no value param",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "kv.set value error: not found",
+		},
+		{
+			name:    "non string value",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  1,
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "kv.set value error: not a string",
+		},
+		{
+			name:    "no modules in context",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "hello",
+			},
+			wrappedPayloadCtx: t.Context(),
+			errorString:       "kv.set wrapped payload has no modules",
+		},
+		{
+			name:    "value template syntax error",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "{{",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "template: template:1: unclosed action",
+		},
+		{
+			name:    "value template execution error",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "{{.Data}}",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": &test.TestKVModule{},
+			}),
+			errorString: "template: template:1:2: executing \"template\" at <.Data>: can't evaluate field Data in type common.WrappedPayload",
+		},
+		{
+			name:    "module not found in context",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "hello",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{}),
+			errorString:       "kv.set unable to find module with id: test",
+		},
+		{
+			name:    "module not a kv module",
+			payload: test.TestStruct{Data: "hello"},
+			params: map[string]any{
+				"module": "test",
+				"key":    "test",
+				"value":  "hello",
+			},
+			wrappedPayloadCtx: test.GetContextWithModules(t.Context(), map[string]common.Module{
+				"test": test.NewTestDBModule("test"),
+			}),
+			errorString: "kv.set module with id test is not a KeyValueModule",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+
+			registration, ok := processor.ProcessorRegistry["kv.set"]
+			if !ok {
+				t.Fatalf("kv.set processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "kv.set",
+				Params: testCase.params,
+			})
+
+			if err != nil {
+				if testCase.errorString != err.Error() {
+					t.Fatalf("kv.set got error '%s', expected '%s'", err.Error(), testCase.errorString)
+				}
+				return
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(testCase.wrappedPayloadCtx, testCase.payload))
+
+			if err == nil {
+				t.Fatalf("kv.set expected to fail but got payload: %+v", got)
+			}
+
+			if err.Error() != testCase.errorString {
+				t.Fatalf("kv.set got error '%s', expected '%s'", err.Error(), testCase.errorString)
+			}
+		})
+	}
+}

internal/processor/test/midi-control_change-create_test.go

@@ -0,0 +1,161 @@
+package processor_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/processor"
+	"gitlab.com/gomidi/midi/v2"
+)
+
+func TestMIDIControlChangeCreateFromRegistry(t *testing.T) {
+	registration, ok := processor.ProcessorRegistry["midi.control_change.create"]
+	if !ok {
+		t.Fatalf("midi.control_change.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "midi.control_change.create",
+		Params: map[string]any{
+			"channel": "1",
+			"control": "60",
+			"value":   "100",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create midi.control_change.create processor: %s", err)
+	}
+
+	if processorInstance.Type() != "midi.control_change.create" {
+		t.Fatalf("midi.control_change.create processor has wrong type: %s", processorInstance.Type())
+	}
+}
+
+func TestGoodMIDIControlChangeCreate(t *testing.T) {
+
+	tests := []struct {
+		name     string
+		params   map[string]any
+		payload  any
+		expected any
+	}{
+		{
+			name: "control_change message",
+			params: map[string]any{
+				"type":    "control_change",
+				"channel": "1",
+				"control": "64",
+				"value":   "127",
+			},
+			payload:  "test",
+			expected: midi.ControlChange(1, 64, 127),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["midi.control_change.create"]
+			if !ok {
+				t.Fatalf("midi.control_change.create processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "midi.control_change.create",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("midi.control_change.create failed to create processor: %s", err)
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
+			if err != nil {
+				t.Fatalf("midi.control_change.create processing failed: %s", err)
+			}
+
+			gotMessage, ok := got.Payload.(midi.Message)
+			if !ok {
+				t.Fatalf("midi.control_change.create returned a %T payload: %+v", got, got)
+			}
+
+			if !reflect.DeepEqual(gotMessage, test.expected) {
+				t.Fatalf("midi.control_change.create got %v, expected %v", gotMessage, test.expected)
+			}
+		})
+	}
+}
+
+func TestBadMIDIControlChangeCreate(t *testing.T) {
+
+	tests := []struct {
+		name        string
+		params      map[string]any
+		payload     any
+		errorString string
+	}{
+		{
+			name: "control_change no channel",
+			params: map[string]any{
+				"type":    "control_change",
+				"control": "64",
+				"value":   "127",
+			},
+			payload:     "test",
+			errorString: "midi.control_change.create channel error: not found",
+		},
+		{
+			name: "control_change no control",
+			params: map[string]any{
+				"type":    "control_change",
+				"channel": "1",
+				"value":   "127",
+			},
+			payload:     "test",
+			errorString: "midi.control_change.create control error: not found",
+		},
+		{
+			name: "control_change no value",
+			params: map[string]any{
+				"type":    "control_change",
+				"channel": "1",
+				"control": "64",
+			},
+			payload:     "test",
+			errorString: "midi.control_change.create value error: not found",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["midi.control_change.create"]
+			if !ok {
+				t.Fatalf("midi.control_change.create processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "midi.control_change.create",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("midi.control_change.create got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
+
+			if err == nil {
+				t.Fatalf("midi.control_change.create expected to fail but succeeded, got: %v", got)
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("midi.control_change.create got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}

internal/processor/test/midi-message-create_test.go

@@ -1,294 +0,0 @@
-package processor_test
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/jwetzell/showbridge-go/internal/common"
-	"github.com/jwetzell/showbridge-go/internal/config"
-	"github.com/jwetzell/showbridge-go/internal/processor"
-	"gitlab.com/gomidi/midi/v2"
-)
-
-func TestMIDIMessageCreateFromRegistry(t *testing.T) {
-	registration, ok := processor.ProcessorRegistry["midi.message.create"]
-	if !ok {
-		t.Fatalf("midi.message.create processor not registered")
-	}
-
-	processorInstance, err := registration.New(config.ProcessorConfig{
-		Type: "midi.message.create",
-		Params: map[string]any{
-			"type":     "note_on",
-			"channel":  "1",
-			"note":     "60",
-			"velocity": "100",
-		},
-	})
-
-	if err != nil {
-		t.Fatalf("failed to create midi.message.create processor: %s", err)
-	}
-
-	if processorInstance.Type() != "midi.message.create" {
-		t.Fatalf("midi.message.create processor has wrong type: %s", processorInstance.Type())
-	}
-}
-
-func TestGoodMIDIMessageCreate(t *testing.T) {
-
-	tests := []struct {
-		name     string
-		params   map[string]any
-		payload  any
-		expected any
-	}{
-		{
-			name: "note_on message",
-			params: map[string]any{
-				"type":     "note_on",
-				"channel":  "1",
-				"note":     "60",
-				"velocity": "100",
-			},
-			payload:  "test",
-			expected: midi.NoteOn(1, 60, 100),
-		},
-		{
-			name: "note_off message",
-			params: map[string]any{
-				"type":     "note_off",
-				"channel":  "1",
-				"note":     "60",
-				"velocity": "100",
-			},
-			payload:  "test",
-			expected: midi.NoteOffVelocity(1, 60, 100),
-		},
-		{
-			name: "control_change message",
-			params: map[string]any{
-				"type":    "control_change",
-				"channel": "1",
-				"control": "64",
-				"value":   "127",
-			},
-			payload:  "test",
-			expected: midi.ControlChange(1, 64, 127),
-		},
-		{
-			name: "program_change message",
-			params: map[string]any{
-				"type":    "program_change",
-				"channel": "1",
-				"program": "10",
-			},
-			payload:  "test",
-			expected: midi.ProgramChange(1, 10),
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			registration, ok := processor.ProcessorRegistry["midi.message.create"]
-			if !ok {
-				t.Fatalf("midi.message.create processor not registered")
-			}
-
-			processorInstance, err := registration.New(config.ProcessorConfig{
-				Type:   "midi.message.create",
-				Params: test.params,
-			})
-
-			if err != nil {
-				t.Fatalf("midi.message.create failed to create processor: %s", err)
-			}
-
-			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
-			if err != nil {
-				t.Fatalf("midi.message.create processing failed: %s", err)
-			}
-
-			gotMessage, ok := got.Payload.(midi.Message)
-			if !ok {
-				t.Fatalf("midi.message.create returned a %T payload: %+v", got, got)
-			}
-
-			if !reflect.DeepEqual(gotMessage, test.expected) {
-				t.Fatalf("midi.message.create got %v, expected %v", gotMessage, test.expected)
-			}
-		})
-	}
-}
-
-func TestBadMIDIMessageCreate(t *testing.T) {
-
-	tests := []struct {
-		name        string
-		params      map[string]any
-		payload     any
-		errorString string
-	}{
-		{
-			name:        "no type parameter",
-			params:      map[string]any{},
-			payload:     "test",
-			errorString: "midi.message.create type error: not found",
-		},
-		{
-			name: "non-string type parameter",
-			params: map[string]any{
-				"type": 1,
-			},
-			payload:     "test",
-			errorString: "midi.message.create type error: not a string",
-		},
-		{
-			name: "unknown type parameter",
-			params: map[string]any{
-				"type": "asdf",
-			},
-			payload:     "test",
-			errorString: "midi.message.create does not support type asdf",
-		},
-		{
-			name: "note_on message no channel",
-			params: map[string]any{
-				"type":     "note_on",
-				"note":     "60",
-				"velocity": "100",
-			},
-			payload:     "test",
-			errorString: "midi.message.create channel error: not found",
-		},
-		{
-			name: "note_on message no note",
-			params: map[string]any{
-				"type":     "note_on",
-				"channel":  "1",
-				"velocity": "100",
-			},
-			payload:     "test",
-			errorString: "midi.message.create note error: not found",
-		},
-		{
-			name: "note_on message no velocity",
-			params: map[string]any{
-				"type":    "note_on",
-				"channel": "1",
-				"note":    "60",
-			},
-			payload:     "test",
-			errorString: "midi.message.create velocity error: not found",
-		},
-		{
-			name: "note_off message no channel",
-			params: map[string]any{
-				"type":     "note_off",
-				"note":     "60",
-				"velocity": "100",
-			},
-			payload:     "test",
-			errorString: "midi.message.create channel error: not found",
-		},
-		{
-			name: "note_off message no note",
-			params: map[string]any{
-				"type":     "note_off",
-				"channel":  "1",
-				"velocity": "100",
-			},
-			payload:     "test",
-			errorString: "midi.message.create note error: not found",
-		},
-		{
-			name: "note_off message no velocity",
-			params: map[string]any{
-				"type":    "note_off",
-				"channel": "1",
-				"note":    "60",
-			},
-			payload:     "test",
-			errorString: "midi.message.create velocity error: not found",
-		},
-		{
-			name: "control_change no channel",
-			params: map[string]any{
-				"type":    "control_change",
-				"control": "64",
-				"value":   "127",
-			},
-			payload:     "test",
-			errorString: "midi.message.create channel error: not found",
-		},
-		{
-			name: "control_change no control",
-			params: map[string]any{
-				"type":    "control_change",
-				"channel": "1",
-				"value":   "127",
-			},
-			payload:     "test",
-			errorString: "midi.message.create control error: not found",
-		},
-		{
-			name: "control_change no value",
-			params: map[string]any{
-				"type":    "control_change",
-				"channel": "1",
-				"control": "64",
-			},
-			payload:     "test",
-			errorString: "midi.message.create value error: not found",
-		},
-		{
-			name: "program_change no channel",
-			params: map[string]any{
-				"type":    "program_change",
-				"program": "64",
-			},
-			payload:     "test",
-			errorString: "midi.message.create channel error: not found",
-		},
-		{
-			name: "program_change no program",
-			params: map[string]any{
-				"type":    "program_change",
-				"channel": "1",
-			},
-			payload:     "test",
-			errorString: "midi.message.create program error: not found",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			registration, ok := processor.ProcessorRegistry["midi.message.create"]
-			if !ok {
-				t.Fatalf("midi.message.create processor not registered")
-			}
-
-			processorInstance, err := registration.New(config.ProcessorConfig{
-				Type:   "midi.message.create",
-				Params: test.params,
-			})
-
-			if err != nil {
-				if test.errorString != err.Error() {
-					t.Fatalf("midi.message.create got error '%s', expected '%s'", err.Error(), test.errorString)
-				}
-				return
-			}
-
-			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
-
-			if err == nil {
-				t.Fatalf("midi.message.create expected to fail but succeeded, got: %v", got)
-			}
-
-			if err.Error() != test.errorString {
-				t.Fatalf("midi.message.create got error '%s', expected '%s'", err.Error(), test.errorString)
-			}
-		})
-	}
-}

internal/processor/test/midi-note_off-create_test.go

@@ -0,0 +1,160 @@
+package processor_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/jwetzell/showbridge-go/internal/common"
+	"github.com/jwetzell/showbridge-go/internal/config"
+	"github.com/jwetzell/showbridge-go/internal/processor"
+	"gitlab.com/gomidi/midi/v2"
+)
+
+func TestMIDINoteOffCreteaFromRegistry(t *testing.T) {
+	registration, ok := processor.ProcessorRegistry["midi.note_off.create"]
+	if !ok {
+		t.Fatalf("midi.note_off.create processor not registered")
+	}
+
+	processorInstance, err := registration.New(config.ProcessorConfig{
+		Type: "midi.note_off.create",
+		Params: map[string]any{
+			"channel":  "1",
+			"note":     "60",
+			"velocity": "100",
+		},
+	})
+
+	if err != nil {
+		t.Fatalf("failed to create midi.note_off.create processor: %s", err)
+	}
+
+	if processorInstance.Type() != "midi.note_off.create" {
+		t.Fatalf("midi.note_off.create processor has wrong type: %s", processorInstance.Type())
+	}
+}
+
+func TestGoodMIDINoteOffCretea(t *testing.T) {
+
+	tests := []struct {
+		name     string
+		params   map[string]any
+		payload  any
+		expected any
+	}{
+		{
+			name: "note_off message",
+			params: map[string]any{
+				"channel":  "1",
+				"note":     "60",
+				"velocity": "100",
+			},
+			payload:  "test",
+			expected: midi.NoteOffVelocity(1, 60, 100),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["midi.note_off.create"]
+			if !ok {
+				t.Fatalf("midi.note_off.create processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "midi.note_off.create",
+				Params: test.params,
+			})
+
+			if err != nil {
+				t.Fatalf("midi.note_off.create failed to create processor: %s", err)
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
+			if err != nil {
+				t.Fatalf("midi.note_off.create processing failed: %s", err)
+			}
+
+			gotMessage, ok := got.Payload.(midi.Message)
+			if !ok {
+				t.Fatalf("midi.note_off.create returned a %T payload: %+v", got, got)
+			}
+
+			if !reflect.DeepEqual(gotMessage, test.expected) {
+				t.Fatalf("midi.note_off.create got %v, expected %v", gotMessage, test.expected)
+			}
+		})
+	}
+}
+
+func TestBadMIDINoteOffCretea(t *testing.T) {
+
+	tests := []struct {
+		name        string
+		params      map[string]any
+		payload     any
+		errorString string
+	}{
+		{
+			name: "note_off message no channel",
+			params: map[string]any{
+				"type":     "note_off",
+				"note":     "60",
+				"velocity": "100",
+			},
+			payload:     "test",
+			errorString: "midi.note_off.create channel error: not found",
+		},
+		{
+			name: "note_off message no note",
+			params: map[string]any{
+				"type":     "note_off",
+				"channel":  "1",
+				"velocity": "100",
+			},
+			payload:     "test",
+			errorString: "midi.note_off.create note error: not found",
+		},
+		{
+			name: "note_off message no velocity",
+			params: map[string]any{
+				"type":    "note_off",
+				"channel": "1",
+				"note":    "60",
+			},
+			payload:     "test",
+			errorString: "midi.note_off.create velocity error: not found",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			registration, ok := processor.ProcessorRegistry["midi.note_off.create"]
+			if !ok {
+				t.Fatalf("midi.note_off.create processor not registered")
+			}
+
+			processorInstance, err := registration.New(config.ProcessorConfig{
+				Type:   "midi.note_off.create",
+				Params: test.params,
+			})
+
+			if err != nil {
+				if test.errorString != err.Error() {
+					t.Fatalf("midi.note_off.create got error '%s', expected '%s'", err.Error(), test.errorString)
+				}
+				return
+			}
+
+			got, err := processorInstance.Process(t.Context(), common.GetWrappedPayload(t.Context(), test.payload))
+
+			if err == nil {
+				t.Fatalf("midi.note_off.create expected to fail but succeeded, got: %v", got)
+			}
+
+			if err.Error() != test.errorString {
+				t.Fatalf("midi.note_off.create got error '%s', expected '%s'", err.Error(), test.errorString)
+			}
+		})
+	}
+}