diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..f79d44f
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,4 @@
+/front/node_modules
+/vol
+/.idea
+/data
\ No newline at end of file
diff --git a/proto/admin/.keep b/.fastad_root
similarity index 100%
rename from proto/admin/.keep
rename to .fastad_root
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index abcf7b3..596067b 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -4,89 +4,107 @@ on:
   pull_request:
     branches:
       - master
+
+permissions:
+  contents: read
+  checks: write
+
 jobs:
   tests:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - name: Set up Go 1.18
-        uses: actions/setup-go@v2
+      - name: Set up Go
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18
-
-      - name: "Cache go deps"
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
+          go-version-file: 'go.mod'
 
       - name: Run tests
         run: make test
 
-  lint-go:
+  e2e-tests:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        preset: [simple, production]
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+      - name: Set up Go
+        uses: actions/setup-go@v5
         with:
-          version: latest
-          args: --config .golangci.yml
+          go-version-file: 'go.mod'
 
-  lint-front:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
 
-      - name: Set up Node 16
-        uses: actions/setup-node@v2
-        with:
-          node-version: "16"
+      - name: Pre-build Docker images
+        run: |
+          go run ./cmd/fastad init --game-config tests/e2e/fastad_test.yaml --preset ${{ matrix.preset }}
+          docker compose -f compose.yml build
 
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
+      - name: Run E2E tests (${{ matrix.preset }} preset)
+        run: go test -tags "e2e e2e_${{ matrix.preset }}" -v ./tests/e2e/... -timeout 15m
 
-      - name: "Cache deps"
-        uses: actions/cache@v3
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
+      - name: Collect Docker logs on failure
+        if: failure()
+        run: |
+          docker compose -f compose.yml logs --tail=100 || true
+          docker ps -a || true
 
-      - name: Install dependencies
-        working-directory: front
-        run: yarn install
+  lint-go:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-      - name: Run linters
-        uses: wearerequired/lint-action@v2
+      - name: Set up Go
+        uses: actions/setup-go@v5
         with:
-          eslint: true
-          eslint_dir: front/src
-          eslint_args: "--ext .js,.vue,.ts"
+          go-version-file: 'go.mod'
 
-      - name: Check the frontend compiles
-        working-directory: front
-        run: yarn build
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v8
+        with:
+          version: v2.8.0
 
   lint-proto:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup buf
-        uses: bufbuild/buf-setup-action@v1.7.0
+        uses: bufbuild/buf-setup-action@v1.48.0
 
       - name: Lint proto
         run: make lint-proto
+
+  lint-front:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          package_json_file: 'front/package.json'
+
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: 'front/.node-version'
+          cache: 'pnpm'
+          cache-dependency-path: 'front/pnpm-lock.yaml'
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+        working-directory: front
+
+      - name: Lint front
+        run: make lint-front
diff --git a/.gitignore b/.gitignore
index 4c8b52f..69fc208 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,13 @@
 .idea
 .DS_Store
 .vscode
+mise.local.toml
+__pycache__
+.sccignore
+.generated
+.env
+/compose.yml
+/fastad.yaml
+.sisyphus
+/fastad
+/data
diff --git a/.golangci.yml b/.golangci.yml
index f5c418d..5eea9c6 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,51 +1,160 @@
----
+version: "2"
 run:
-  timeout: 5m
+  concurrency: 4
   modules-download-mode: readonly
-
+  tests: true
 linters:
+  default: none
   enable:
+    - asasalint
     - asciicheck
+    - bidichk
     - bodyclose
-    - deadcode
+    - canonicalheader
+    - containedctx
+    - copyloopvar
     - dogsled
     - durationcheck
+    - errcheck
     - errname
-    - exportloopref
+    - errorlint
     - exhaustive
+    - fatcontext
+    - forbidigo
+    - forcetypeassert
+    - gocheckcompilerdirectives
+    - gochecknoinits
+    - goconst
     - gocritic
-    - gofmt
-    - goimports
+    - godot
     - gomoddirectives
-    - gosimple
+    - gomodguard
+    - goprintffuncname
+    - gosmopolitan
     - govet
-    - ifshort
+    - inamedparam
     - ineffassign
-    - importas
+    - intrange
+    - loggercheck
+    - makezero
+    - mirror
     - misspell
+    - musttag
+    - nilerr
+    - nilnil
     - noctx
+    - nolintlint
+    - nosprintfhostport
+    - perfsprint
     - prealloc
     - predeclared
+    - protogetter
+    - reassign
     - revive
+    - rowserrcheck
+    - spancheck
+    - sqlclosecheck
     - staticcheck
+    - testifylint
+    - testpackage
     - thelper
     - tparallel
     - unconvert
     - unparam
     - unused
-    - varcheck
+    - usestdlibvars
+    - wastedassign
     - whitespace
     - wrapcheck
-
-linters-settings:
-  wrapcheck:
-    ignoreSigs:
-      - errors.New
-      - (context.Context).Err()
-      - google.golang.org/grpc/status.Error
-      - google.golang.org/grpc/status.Errorf
-      - .Read(p []byte)  # most Read errors should be passed as-is, e.g. io.EOF.
-
-issues:
-  max-issues-per-linter: 0
-  max-same-issues: 0
+  settings:
+    asasalint:
+      use-builtin-exclusions: false
+    copyloopvar:
+      check-alias: true
+    errcheck:
+      disable-default-exclusions: true
+      check-type-assertions: true
+      check-blank: true
+    exhaustive:
+      default-signifies-exhaustive: true
+    forbidigo:
+      forbid:
+        - pattern: self
+        - pattern: this
+      exclude-godoc-examples: false
+    godot:
+      capital: true
+    gomoddirectives:
+      exclude-forbidden: true
+    gomodguard:
+      blocked:
+        modules:
+          - github.com/golang/protobuf:
+              recommendations:
+                - google.golang.org/protobuf
+          - github.com/satori/go.uuid:
+              recommendations:
+                - github.com/google/uuid
+          - github.com/gofrs/uuid:
+              recommendations:
+                - github.com/gofrs/uuid/v5
+    govet:
+      disable:
+        - fieldalignment
+        - shadow
+      enable-all: true
+    inamedparam:
+      skip-single-param: true
+    loggercheck:
+      require-string-key: true
+    makezero:
+      always: true
+    nolintlint:
+      require-explanation: true
+      require-specific: true
+    perfsprint:
+      strconcat: false
+    wrapcheck:
+      ignore-sigs:
+        - func errors.New(text string) error
+        - status.Error(
+        - status.Errorf(
+        - fmt.Errorf(
+        - (context.Context).Err()
+        - (*google.golang.org/grpc/internal/status.Status).Err()
+        - (github.com/labstack/echo/v4.Context).JSONBlob(code int, b []byte) error
+        - (github.com/labstack/echo/v4.Context).Blob(code int, contentType string, b []byte) error
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    rules:
+      - linters:
+          - goconst
+        path: (.+)_test\.go
+formatters:
+  enable:
+    - gofmt
+    - gofumpt
+    - gci
+  settings:
+    gofmt:
+      simplify: true
+      rewrite-rules:
+        - pattern: 'interface{}'
+          replacement: 'any'
+    gofumpt:
+      extra-rules: true
+    gci:
+      sections:
+        - standard
+        - default
+        - prefix(github.com/c4t-but-s4d/fastad)
+        - blank
+        - localmodule
+      custom-order: true
+  exclusions:
+    generated: lax
diff --git a/Makefile b/Makefile
index 733cd9a..b26ead8 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,6 @@
 .PHONY: lint-proto
 lint-proto:
-	cd proto && buf lint && buf build
+	cd proto && buf lint
 
 .PHONY: lint-go
 lint-go:
@@ -8,10 +8,15 @@ lint-go:
 
 .PHONY: lint-front
 lint-front:
-	cd front && yarn lint
+	cd front && pnpm lint
+
+.PHONY: goimports
+goimports:
+	gofancyimports fix --local github.com/c4t-but-s4d/fastad -w $(shell find . -type f -name '*.go' -not -path "./pkg/proto/*")
 
 .PHONY: proto
 proto: lint-proto
+	rm -rf pkg/proto front/src/proto
 	cd proto && buf generate
 
 .PHONY: tidy
@@ -27,3 +32,22 @@ test-go:
 
 .PHONY: test
 test: test-go
+
+.PHONY: commit-proto
+commit-proto: proto
+	git add proto
+	git add pkg/proto
+	git add front/src/proto
+	git commit -m "Regenerate proto"
+
+.PHONY: reset-db
+reset-db:
+	docker compose exec postgres psql -U fastad fastad -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"
+	go run ./cmd/migrator/main.go init
+
+.PHONY: migrate-db
+migrate-db:
+	go run ./cmd/migrator/main.go migrate
+
+.PHONY: db
+db: reset-db migrate-db
diff --git a/cmd/allinone/main.go b/cmd/allinone/main.go
new file mode 100644
index 0000000..b463c4d
--- /dev/null
+++ b/cmd/allinone/main.go
@@ -0,0 +1,172 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/google/uuid"
+	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
+
+	apiImpl "github.com/c4t-but-s4d/fastad/cmd/api/impl"
+	checkersImpl "github.com/c4t-but-s4d/fastad/cmd/checkers/impl"
+	dataserviceImpl "github.com/c4t-but-s4d/fastad/cmd/dataservice/impl"
+	receiverImpl "github.com/c4t-but-s4d/fastad/cmd/receiver/impl"
+	schedulerImpl "github.com/c4t-but-s4d/fastad/cmd/scheduler/impl"
+	slacImpl "github.com/c4t-but-s4d/fastad/cmd/slac/impl"
+	"github.com/c4t-but-s4d/fastad/internal/checkers"
+	"github.com/c4t-but-s4d/fastad/internal/dataservice"
+	"github.com/c4t-but-s4d/fastad/internal/handlers"
+	"github.com/c4t-but-s4d/fastad/internal/receiver"
+	"github.com/c4t-but-s4d/fastad/internal/scheduler"
+	"github.com/c4t-but-s4d/fastad/internal/slac"
+	"github.com/c4t-but-s4d/fastad/pkg/apiwait"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/metrics"
+	"github.com/c4t-but-s4d/fastad/pkg/stop"
+)
+
+type Config struct {
+	UserAgent string `mapstructure:"user_agent" default:"allinone"`
+
+	MetricsAddress string `mapstructure:"metrics_address" default:":3000"`
+	IntercomToken  string `mapstructure:"intercom_token"`
+
+	Postgres    config.Postgres    `mapstructure:"postgres"`
+	Temporal    config.Temporal    `mapstructure:"temporal"`
+	DataService dataservice.Config `mapstructure:"data_service"`
+	Scheduler   scheduler.Config   `mapstructure:"scheduler"`
+	Slac        slac.Config        `mapstructure:"slac"`
+	API         handlers.Config    `mapstructure:"api"`
+	Checkers    checkers.Config    `mapstructure:"checkers"`
+	Receiver    receiver.Config    `mapstructure:"receiver"`
+}
+
+func main() {
+	defer logging.Init().Close()
+
+	cfg := baseconfig.MustSetupAll(&Config{}, baseconfig.WithEnvPrefix("FASTAD_ALLINONE"))
+
+	setupConfig(cfg)
+
+	runCtx, shutdownCtx, cancel := stop.SetupCtx()
+	defer cancel()
+
+	g, gctx := errgroup.WithContext(runCtx)
+
+	g.Go(func() error {
+		if err := dataserviceImpl.Run(gctx, shutdownCtx, &cfg.DataService); err != nil {
+			return fmt.Errorf("running dataservice: %w", err)
+		}
+		return nil
+	})
+
+	g.Go(func() error {
+		if err := slacImpl.Run(gctx, shutdownCtx, &cfg.Slac); err != nil {
+			return fmt.Errorf("running slac: %w", err)
+		}
+		return nil
+	})
+
+	if err := apiwait.GRPC(gctx, cfg.DataService.ListenAddress); err != nil {
+		zap.L().Error("waiting for DataService", zap.Error(err))
+		cancel()
+		return
+	}
+
+	if err := apiwait.GRPC(gctx, cfg.Slac.ListenAddress); err != nil {
+		zap.L().Error("waiting for SLAC", zap.Error(err))
+		cancel()
+		return
+	}
+
+	cfg.API.DataService.Address = cfg.DataService.ListenAddress
+	cfg.API.SlacAddress = cfg.Slac.ListenAddress
+	cfg.API.ReceiverAddress = cfg.Receiver.ListenAddress
+	g.Go(func() error {
+		if err := apiImpl.Run(gctx, shutdownCtx, &cfg.API); err != nil {
+			return fmt.Errorf("running api: %w", err)
+		}
+		return nil
+	})
+
+	if err := apiwait.HTTP(gctx, cfg.API.ListenAddress); err != nil {
+		zap.L().Error("waiting for API", zap.Error(err))
+		cancel()
+		return
+	}
+
+	cfg.Receiver.DataService.Address = cfg.DataService.ListenAddress
+	cfg.Receiver.CentrifugeClient.Address = fmt.Sprintf("ws://%s/centrifuge/websocket", cfg.API.ListenAddress)
+	g.Go(func() error {
+		if err := receiverImpl.Run(gctx, shutdownCtx, &cfg.Receiver); err != nil {
+			return fmt.Errorf("running receiver: %w", err)
+		}
+		return nil
+	})
+
+	cfg.Checkers.DataService.Address = cfg.DataService.ListenAddress
+	g.Go(func() error {
+		if err := checkersImpl.Run(gctx, shutdownCtx, &cfg.Checkers); err != nil {
+			return fmt.Errorf("running checkers: %w", err)
+		}
+		return nil
+	})
+
+	cfg.Scheduler.DataService.Address = cfg.DataService.ListenAddress
+	g.Go(func() error {
+		if err := schedulerImpl.Run(gctx, shutdownCtx, &cfg.Scheduler); err != nil {
+			return fmt.Errorf("running scheduler: %w", err)
+		}
+		return nil
+	})
+
+	g.Go(func() error {
+		metrics.RunServer(gctx, shutdownCtx, cfg.MetricsAddress)
+		return nil
+	})
+
+	if err := g.Wait(); err != nil {
+		zap.L().Fatal("all-in-one run failed", zap.Error(err))
+	}
+}
+
+func setupConfig(cfg *Config) {
+	if cfg.IntercomToken == "" {
+		cfg.IntercomToken = uuid.NewString()
+	}
+
+	cfg.DataService.IntercomToken = cfg.IntercomToken
+	cfg.API.IntercomToken = cfg.IntercomToken
+	cfg.Slac.IntercomToken = cfg.IntercomToken
+	cfg.Receiver.IntercomToken = cfg.IntercomToken
+	cfg.Checkers.IntercomToken = cfg.IntercomToken
+	cfg.Scheduler.IntercomToken = cfg.IntercomToken
+
+	cfg.DataService.Postgres = cfg.Postgres
+	cfg.Scheduler.Postgres = cfg.Postgres
+	cfg.Slac.Postgres = cfg.Postgres
+	cfg.API.Postgres = cfg.Postgres
+	cfg.Checkers.Postgres = cfg.Postgres
+	cfg.Receiver.Postgres = cfg.Postgres
+
+	cfg.Scheduler.Temporal = cfg.Temporal
+	cfg.Checkers.Temporal = cfg.Temporal
+
+	cfg.DataService.Installation = fmt.Sprintf("%s/dataservice", cfg.UserAgent)
+	cfg.Scheduler.Installation = fmt.Sprintf("%s/scheduler", cfg.UserAgent)
+	cfg.Slac.Installation = fmt.Sprintf("%s/slac", cfg.UserAgent)
+	cfg.API.Installation = fmt.Sprintf("%s/api", cfg.UserAgent)
+	cfg.Checkers.Installation = fmt.Sprintf("%s/checkers", cfg.UserAgent)
+	cfg.Receiver.Installation = fmt.Sprintf("%s/receiver", cfg.UserAgent)
+
+	cfg.DataService.MetricsAddress = ""
+	cfg.Scheduler.MetricsAddress = ""
+	cfg.Slac.MetricsAddress = ""
+	cfg.API.MetricsAddress = ""
+	cfg.Receiver.MetricsAddress = ""
+
+	// Checkers are listening on a different port.
+	cfg.Checkers.MetricsAddress = ""
+}
diff --git a/cmd/api/impl/run.go b/cmd/api/impl/run.go
new file mode 100644
index 0000000..7c89293
--- /dev/null
+++ b/cmd/api/impl/run.go
@@ -0,0 +1,196 @@
+package impl
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/centrifugal/centrifuge"
+	"github.com/labstack/echo-contrib/echoprometheus"
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/c4t-but-s4d/fastad/internal/centutil"
+	"github.com/c4t-but-s4d/fastad/internal/handlers"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	"github.com/c4t-but-s4d/fastad/pkg/httpext"
+	"github.com/c4t-but-s4d/fastad/pkg/metrics"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+	slacpb "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+)
+
+func Run(runCtx, shutdownCtx context.Context, cfg *handlers.Config) error {
+	dataServiceConn, err := grpcext.Dial(
+		cfg.DataService.Address,
+		cfg.Installation,
+		grpcext.AuthDialOptions(cfg.IntercomToken)...,
+	)
+	if err != nil {
+		return fmt.Errorf("connecting to data service: %w", err)
+	}
+
+	teamsClient := teams.NewClient(teamspb.NewTeamsServiceClient(dataServiceConn), cfg.Installation)
+	servicesClient := services.NewClient(servicespb.NewServicesServiceClient(dataServiceConn), cfg.Installation)
+	gameStateClient := gamestate.NewClient(gspb.NewGameStateServiceClient(dataServiceConn), cfg.Installation)
+
+	receiverConn, err := grpcext.Dial(
+		cfg.ReceiverAddress,
+		cfg.Installation,
+		grpcext.AuthDialOptions(cfg.IntercomToken)...,
+	)
+	if err != nil {
+		return fmt.Errorf("connecting to receiver: %w", err)
+	}
+	receiverClient := receiverpb.NewReceiverServiceClient(receiverConn)
+
+	slacConn, err := grpcext.Dial(
+		cfg.SlacAddress,
+		cfg.Installation,
+		grpcext.AuthDialOptions(cfg.IntercomToken)...,
+	)
+	if err != nil {
+		return fmt.Errorf("connecting to slac: %w", err)
+	}
+	slacClient := slacpb.NewSlacServiceClient(slacConn)
+
+	centConfig := centrifuge.Config{
+		Name:     cfg.Installation,
+		LogLevel: centrifuge.LogLevelDebug,
+		LogHandler: func(entry centrifuge.LogEntry) {
+			zap.L().Debug(
+				"centrifuge log",
+				zap.String("message", entry.Message),
+				zap.Any("entry", entry.Fields),
+			)
+		},
+	}
+	node, err := centrifuge.New(centConfig)
+	if err != nil {
+		return fmt.Errorf("creating centrifuge node: %w", err)
+	}
+
+	producer := centutil.NewNodeProducer(node, cfg.ScoreboardChannel)
+
+	boardBuilder := handlers.NewBoardBuilder(
+		teamsClient,
+		servicesClient,
+		receiverClient,
+		slacClient,
+		producer,
+	)
+
+	db := cfg.Postgres.BunDB()
+
+	apiService := handlers.NewService(
+		cfg,
+		db,
+		node,
+		teamsClient,
+		servicesClient,
+		gameStateClient,
+		receiverClient,
+		slacClient,
+		boardBuilder,
+	)
+
+	e := echo.New()
+	e.Use(
+		echoprometheus.NewMiddleware("http"),
+		httpext.RequestIDMiddleware(),
+		middleware.RequestLoggerWithConfig(middleware.RequestLoggerConfig{
+			LogMethod:    true,
+			LogURI:       true,
+			LogStatus:    true,
+			LogLatency:   true,
+			LogRemoteIP:  true,
+			LogRoutePath: true,
+			LogValuesFunc: func(_ echo.Context, v middleware.RequestLoggerValues) error {
+				logFunc := zap.L().Debug
+				switch v.Status / 100 {
+				case 5:
+					logFunc = zap.L().Error
+				case 4:
+					logFunc = zap.L().Warn
+				}
+
+				logFunc("request",
+					zap.String("method", v.Method),
+					zap.String("URI", v.URI),
+					zap.Int("status", v.Status),
+					zap.Duration("latency", v.Latency),
+					zap.String("remote_ip", v.RemoteIP),
+					zap.String("path", v.RoutePath),
+				)
+
+				return nil
+			},
+		}),
+		middleware.Recover(),
+		middleware.Gzip(),
+		middleware.Secure(), // TODO: allow images from external sources for avatars.
+		middleware.CORSWithConfig(middleware.CORSConfig{
+			AllowOrigins:                             []string{"*"},
+			AllowCredentials:                         true,
+			UnsafeWildcardOriginWithAllowCredentials: true,
+		}),
+	)
+	e.GET("/healthcheck", httpext.HealthHandler())
+
+	e.HTTPErrorHandler = httpext.ErrorHandler()
+	apiService.RegisterRoutes(e)
+	apiService.RegisterNode()
+
+	if err := node.Run(); err != nil {
+		return fmt.Errorf("running centrifuge node: %w", err)
+	}
+
+	g, gctx := errgroup.WithContext(runCtx)
+	g.Go(func() error {
+		boardBuilder.Run(gctx)
+		return nil
+	})
+
+	if cfg.MetricsAddress != "" {
+		g.Go(func() error {
+			metrics.RunServer(gctx, shutdownCtx, cfg.MetricsAddress)
+			return nil
+		})
+	}
+
+	g.Go(func() error {
+		zap.L().Info("starting api server", zap.String("address", cfg.ListenAddress))
+		if err := e.Start(cfg.ListenAddress); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			return fmt.Errorf("running server: %w", err)
+		}
+		zap.L().Info("api server stopped")
+		return nil
+	})
+
+	g.Go(func() error {
+		<-gctx.Done()
+
+		zap.L().Info("shutting down api server")
+		if err := e.Shutdown(shutdownCtx); err != nil {
+			return fmt.Errorf("shutting down server: %w", err)
+		}
+		if err := node.Shutdown(shutdownCtx); err != nil {
+			return fmt.Errorf("shutting down centrifuge node: %w", err)
+		}
+		return nil
+	})
+
+	if err := g.Wait(); err != nil {
+		return fmt.Errorf("waiting for goroutines: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/api/main.go b/cmd/api/main.go
new file mode 100644
index 0000000..3d00a0b
--- /dev/null
+++ b/cmd/api/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/cmd/api/impl"
+	"github.com/c4t-but-s4d/fastad/internal/handlers"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/stop"
+)
+
+func main() {
+	defer logging.Init().Close()
+
+	cfg := baseconfig.MustSetupAll(&handlers.Config{}, baseconfig.WithEnvPrefix("FASTAD_API"))
+
+	runCtx, shutdownCtx, cancel := stop.SetupCtx()
+	defer cancel()
+
+	if err := impl.Run(runCtx, shutdownCtx, cfg); err != nil {
+		zap.L().Fatal("api run failed", zap.Error(err))
+	}
+}
diff --git a/cmd/checkers/impl/run.go b/cmd/checkers/impl/run.go
new file mode 100644
index 0000000..7930cd2
--- /dev/null
+++ b/cmd/checkers/impl/run.go
@@ -0,0 +1,148 @@
+package impl
+
+import (
+	"context"
+	"fmt"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/worker"
+	"go.temporal.io/sdk/workflow"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/internal/checkers"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/metrics"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+func Run(runCtx, shutdownCtx context.Context, cfg *checkers.Config) error {
+	temporalClientOpts := client.Options{
+		HostPort: cfg.Temporal.Address,
+		Logger: logging.NewTemporalAdapter(
+			zap.L().Named("checkers_worker"),
+		),
+	}
+	if cfg.MetricsAddress != "" {
+		handler, err := metrics.TemporalHandler(cfg.MetricsAddress)
+		if err != nil {
+			return fmt.Errorf("creating metrics handler: %w", err)
+		}
+		temporalClientOpts.MetricsHandler = handler
+	}
+	temporalClient, err := client.Dial(temporalClientOpts)
+	if err != nil {
+		return fmt.Errorf("creating temporal client: %w", err)
+	}
+	defer temporalClient.Close()
+
+	db := cfg.Postgres.BunDB()
+
+	checkersMetrics := checkers.NewMetrics(cfg.Installation)
+	checkersController := checkers.NewController(db, checkersMetrics)
+
+	dataServiceConn, err := grpcext.Dial(
+		cfg.DataService.Address,
+		cfg.Installation,
+		grpcext.AuthDialOptions(cfg.IntercomToken)...,
+	)
+	if err != nil {
+		return fmt.Errorf("dialing data service: %w", err)
+	}
+
+	teamsClient := teams.NewClient(teamspb.NewTeamsServiceClient(dataServiceConn), cfg.Installation)
+	servicesClient := services.NewClient(servicespb.NewServicesServiceClient(dataServiceConn), cfg.Installation)
+	gameStateClient := gamestate.NewClient(gspb.NewGameStateServiceClient(dataServiceConn), cfg.Installation)
+
+	checkersWorker := worker.New(temporalClient, "checkers", worker.Options{
+		DisableRegistrationAliasing: true,
+	})
+
+	// Activities.
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewCheckActivity().ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.CheckActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewFetchDataActivity(
+			teamsClient,
+			servicesClient,
+			gameStateClient,
+		).ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.FetchDataActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewGetActivity().ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.GetActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewPickGetFlagActivity(checkersController).ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.PickGetFlagActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewPrepareRoundActivity(checkersController, gameStateClient).ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.PrepareRoundActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewPutActivity().ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.PutActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewSaveRoundDataActivity(checkersController).ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.SaveRoundDataActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewSaveVerdictActivity(checkersController).ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.SaveVerdictActivityName},
+	)
+
+	checkersWorker.RegisterActivityWithOptions(
+		checkers.NewGetLastExecutionActivity(checkersController).ActivityDefinition,
+		activity.RegisterOptions{Name: checkers.GetLastExecutionActivityName},
+	)
+	// End of activities.
+
+	// Workflows.
+	checkersWorker.RegisterWorkflowWithOptions(
+		checkers.CheckWorkflowDefinition,
+		workflow.RegisterOptions{Name: checkers.CheckWorkflowName},
+	)
+
+	checkersWorker.RegisterWorkflowWithOptions(
+		checkers.GetWorkflowDefinition,
+		workflow.RegisterOptions{Name: checkers.GetWorkflowName},
+	)
+
+	checkersWorker.RegisterWorkflowWithOptions(
+		checkers.RoundWorkflowDefinition,
+		workflow.RegisterOptions{Name: checkers.RoundWorkflowName},
+	)
+	// End of workflows.
+
+	if cfg.MetricsAddress != "" {
+		go metrics.RunServer(runCtx, shutdownCtx, cfg.MetricsAddress)
+	}
+
+	go func() {
+		<-runCtx.Done()
+		checkersWorker.Stop()
+	}()
+	if err := checkersWorker.Run(nil); err != nil {
+		return fmt.Errorf("running worker: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/checkers/main.go b/cmd/checkers/main.go
new file mode 100644
index 0000000..1d969d7
--- /dev/null
+++ b/cmd/checkers/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/cmd/checkers/impl"
+	"github.com/c4t-but-s4d/fastad/internal/checkers"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/stop"
+)
+
+func main() {
+	defer logging.Init().Close()
+
+	cfg := baseconfig.MustSetupAll(&checkers.Config{}, baseconfig.WithEnvPrefix("FASTAD_CHECKERS"))
+
+	runCtx, shutdownCtx, cancel := stop.SetupCtx()
+	defer cancel()
+
+	if err := impl.Run(runCtx, shutdownCtx, cfg); err != nil {
+		zap.L().Fatal("checkers worker run failed", zap.Error(err))
+	}
+}
diff --git a/cmd/dataservice/impl/run.go b/cmd/dataservice/impl/run.go
new file mode 100644
index 0000000..dfbb20a
--- /dev/null
+++ b/cmd/dataservice/impl/run.go
@@ -0,0 +1,50 @@
+package impl
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/c4t-but-s4d/fastad/internal/dataservice"
+	"github.com/c4t-but-s4d/fastad/internal/dataservice/gamestate"
+	"github.com/c4t-but-s4d/fastad/internal/dataservice/services"
+	"github.com/c4t-but-s4d/fastad/internal/dataservice/teams"
+	"github.com/c4t-but-s4d/fastad/internal/version"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	"github.com/c4t-but-s4d/fastad/pkg/metrics"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+func Run(runCtx, shutdownCtx context.Context, cfg *dataservice.Config) error {
+	db := cfg.Postgres.BunDB()
+
+	versionController := version.NewController(db)
+
+	teamsController := teams.NewController(db, versionController)
+	teamsService := teams.NewService(teamsController)
+
+	servicesController := services.NewController(db, versionController)
+	servicesService := services.NewService(servicesController)
+
+	gameStateController := gamestate.NewController(db, versionController)
+	gameStateService := gamestate.NewService(gameStateController)
+
+	server := grpcext.NewServer(
+		grpcext.WithServerInstallation(cfg.Installation),
+		grpcext.WithServerTokenAuth(cfg.IntercomToken),
+	)
+	teamspb.RegisterTeamsServiceServer(server, teamsService)
+	servicespb.RegisterServicesServiceServer(server, servicesService)
+	gspb.RegisterGameStateServiceServer(server, gameStateService)
+
+	if cfg.MetricsAddress != "" {
+		go metrics.RunServer(runCtx, shutdownCtx, cfg.MetricsAddress)
+	}
+
+	if err := grpcext.RunServer(runCtx, shutdownCtx, server, cfg.ListenAddress); err != nil {
+		return fmt.Errorf("running server: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/dataservice/main.go b/cmd/dataservice/main.go
new file mode 100644
index 0000000..6274062
--- /dev/null
+++ b/cmd/dataservice/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/cmd/dataservice/impl"
+	"github.com/c4t-but-s4d/fastad/internal/dataservice"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/stop"
+)
+
+func main() {
+	defer logging.Init().Close()
+
+	cfg := baseconfig.MustSetupAll(&dataservice.Config{}, baseconfig.WithEnvPrefix("FASTAD_DATA_SERVICE"))
+
+	runCtx, shutdownCtx, cancel := stop.SetupCtx()
+	defer cancel()
+
+	if err := impl.Run(runCtx, shutdownCtx, cfg); err != nil {
+		zap.L().Fatal("error running server", zap.Error(err))
+	}
+}
diff --git a/cmd/fastad/cmd/context.go b/cmd/fastad/cmd/context.go
new file mode 100644
index 0000000..675091b
--- /dev/null
+++ b/cmd/fastad/cmd/context.go
@@ -0,0 +1,21 @@
+package cmd
+
+import (
+	"context"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+type Context struct {
+	Context context.Context //nolint:containedctx // cobra pattern: context passed through command tree
+	Viper   *viper.Viper
+}
+
+type CommandFactory func(cc *Context) *cobra.Command
+
+func NewContext(v *viper.Viper) *Context {
+	return &Context{
+		Viper: v,
+	}
+}
diff --git a/cmd/fastad/cmd/init.go b/cmd/fastad/cmd/init.go
new file mode 100644
index 0000000..585912b
--- /dev/null
+++ b/cmd/fastad/cmd/init.go
@@ -0,0 +1,111 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+	"gopkg.in/yaml.v3"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+)
+
+func NewInitCmd(cc *Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "init",
+		Short: "Initialize game infrastructure (generate compose.yml, .env, etc.)",
+		RunE: func(_ *cobra.Command, _ []string) error {
+			root, err := gameconfig.GetFastADRoot()
+			if err != nil {
+				return fmt.Errorf("getting fastad root: %w", err)
+			}
+
+			configPath := cc.Viper.GetString("game_config")
+			if configPath == "" {
+				configPath = filepath.Join(root, "fastad.yaml")
+			}
+
+			zap.S().Infof("reading game config from %s", configPath)
+
+			content, err := os.ReadFile(configPath)
+			if os.IsNotExist(err) {
+				examplePath := filepath.Join(root, "fastad.yaml.example")
+				return fmt.Errorf(
+					"config file not found: %s\n\nTo get started:\n  cp %s %s\n  # edit %s with your game settings\n  fastad init",
+					configPath, examplePath, configPath, configPath,
+				)
+			}
+			if err != nil {
+				return fmt.Errorf("reading game config: %w", err)
+			}
+
+			var cfg *gameconfig.GameConfig
+			if err := yaml.Unmarshal(content, &cfg); err != nil {
+				return fmt.Errorf("unmarshalling game config: %w", err)
+			}
+
+			zap.S().Infof("parsed game config: %+v", cfg)
+
+			if err := cfg.Validate(); err != nil {
+				return fmt.Errorf("validating game config: %w", err)
+			}
+
+			zap.S().Info("game config validated")
+
+			// Check if already initialized
+			generatedDir := filepath.Join(root, gameconfig.GeneratedDir)
+			generatedConfigPath := filepath.Join(generatedDir, gameconfig.GeneratedGameConfig)
+			if _, err := os.Stat(generatedConfigPath); err == nil && !cc.Viper.GetBool("force") {
+				return fmt.Errorf(
+					"game already initialized (config at %s exists). Use --force to reinitialize",
+					generatedConfigPath,
+				)
+			}
+
+			switch cc.Viper.GetString("preset") {
+			case "simple":
+				zap.L().Info("initializing simple preset")
+				if err := PresetSimple(root, cfg); err != nil {
+					return fmt.Errorf("initializing simple preset: %w", err)
+				}
+				zap.L().Info("simple preset initialized")
+			case "production":
+				zap.L().Info("initializing production preset")
+				if err := PresetProduction(root, cfg); err != nil {
+					return fmt.Errorf("initializing production preset: %w", err)
+				}
+				zap.L().Info("production preset initialized")
+			default:
+				return fmt.Errorf("unsupported preset: %s (supported: simple, production)", cc.Viper.GetString("preset"))
+			}
+
+			// Save generated config
+			if err := os.MkdirAll(generatedDir, 0o755); err != nil {
+				return fmt.Errorf("creating generated dir: %w", err)
+			}
+			configContent, err := yaml.Marshal(cfg)
+			if err != nil {
+				return fmt.Errorf("marshalling game config: %w", err)
+			}
+			if err := os.WriteFile(generatedConfigPath, configContent, 0o644); err != nil {
+				return fmt.Errorf("writing generated game config: %w", err)
+			}
+
+			zap.L().Info("initialization complete",
+				zap.String("generated_config", generatedConfigPath),
+				zap.String("compose_file", filepath.Join(root, "compose.yml")),
+			)
+			zap.L().Info("run 'fastad run' to start the game")
+
+			return nil
+		},
+	}
+
+	cmd.Flags().StringP("game-config", "c", "", "path to game config yaml file (defaults to fastad.yaml in fastad root)")
+	cmd.Flags().String("preset", "simple", "preset to use ('simple' or 'production')")
+	cmd.Flags().Bool("force", false, "overwrite existing generated files")
+
+	return cmd
+}
diff --git a/cmd/fastad/cmd/preset_common.go b/cmd/fastad/cmd/preset_common.go
new file mode 100644
index 0000000..68b565b
--- /dev/null
+++ b/cmd/fastad/cmd/preset_common.go
@@ -0,0 +1,169 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"go.uber.org/zap"
+	"gopkg.in/yaml.v3"
+)
+
+type TemporalPostgresConfig struct {
+	User         string
+	Password     string
+	Database     string
+	Host         string
+	Port         string
+	TLS          string
+	SkipDBCreate string
+}
+
+func DefaultTemporalPostgresConfig() TemporalPostgresConfig {
+	return TemporalPostgresConfig{
+		Host:         "temporal-postgres",
+		Port:         "5432",
+		User:         "temporal",
+		Password:     "temporal",
+		Database:     "temporal",
+		TLS:          "false",
+		SkipDBCreate: "false",
+	}
+}
+
+func ParseTemporalDSN(dsn string) (TemporalPostgresConfig, error) {
+	parsedDSN, err := url.Parse(dsn)
+	if err != nil {
+		return TemporalPostgresConfig{}, fmt.Errorf("parsing temporal dsn: %w", err)
+	}
+	if parsedDSN.Scheme != "postgres" {
+		return TemporalPostgresConfig{}, errors.New("temporal dsn scheme must be postgres")
+	}
+
+	cfg := TemporalPostgresConfig{
+		User:         parsedDSN.User.Username(),
+		Host:         parsedDSN.Hostname(),
+		Port:         parsedDSN.Port(),
+		Database:     strings.TrimPrefix(parsedDSN.Path, "/"),
+		TLS:          "false",
+		SkipDBCreate: "true",
+	}
+	cfg.Password, _ = parsedDSN.User.Password()
+
+	return cfg, nil
+}
+
+// ComposeFile represents a docker-compose.yml file.
+type ComposeFile struct {
+	Services map[string]any `yaml:"services,omitempty"`
+	Volumes  map[string]any `yaml:"volumes,omitempty"`
+	Networks map[string]any `yaml:"networks,omitempty"`
+}
+
+// ComposeManipulator provides simple compose file manipulation.
+type ComposeManipulator struct {
+	data *ComposeFile
+}
+
+func LoadCompose(path string) (*ComposeManipulator, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("reading compose file: %w", err)
+	}
+
+	var data ComposeFile
+	if err := yaml.Unmarshal(content, &data); err != nil {
+		return nil, fmt.Errorf("parsing compose file: %w", err)
+	}
+
+	if data.Services == nil {
+		data.Services = make(map[string]any)
+	}
+	if data.Volumes == nil {
+		data.Volumes = make(map[string]any)
+	}
+
+	return &ComposeManipulator{data: &data}, nil
+}
+
+func (c *ComposeManipulator) Services() map[string]any {
+	return c.data.Services
+}
+
+func (c *ComposeManipulator) Volumes() map[string]any {
+	return c.data.Volumes
+}
+
+func (c *ComposeManipulator) RemoveService(name string) {
+	delete(c.data.Services, name)
+}
+
+func (c *ComposeManipulator) RemoveVolume(name string) {
+	delete(c.data.Volumes, name)
+}
+
+func (c *ComposeManipulator) getService(name string) map[string]any {
+	svc, ok := c.data.Services[name]
+	if !ok {
+		return nil
+	}
+	svcMap, ok := svc.(map[string]any)
+	if !ok {
+		return nil
+	}
+	return svcMap
+}
+
+func (c *ComposeManipulator) RemoveDependsOn(serviceName string) {
+	svc := c.getService(serviceName)
+	if svc == nil {
+		return
+	}
+	delete(svc, "depends_on")
+}
+
+func (c *ComposeManipulator) SetDependsOn(serviceName string, deps map[string]any) {
+	svc := c.getService(serviceName)
+	if svc == nil {
+		return
+	}
+	svc["depends_on"] = deps
+}
+
+func (c *ComposeManipulator) SetVolumes(serviceName string, volumes []string) {
+	svc := c.getService(serviceName)
+	if svc == nil {
+		return
+	}
+	svc["volumes"] = volumes
+}
+
+func (c *ComposeManipulator) Write(path string) error {
+	content, err := yaml.Marshal(c.data)
+	if err != nil {
+		return fmt.Errorf("marshalling compose file: %w", err)
+	}
+
+	if err := os.WriteFile(path, content, 0o644); err != nil {
+		return fmt.Errorf("writing compose file: %w", err)
+	}
+
+	zap.L().Info("wrote compose file", zap.String("path", path))
+	return nil
+}
+
+func WriteEnvFile(path string, content []byte) error {
+	if err := os.WriteFile(path, content, 0o644); err != nil {
+		return fmt.Errorf("writing env file: %w", err)
+	}
+
+	zap.L().Info("wrote .env file", zap.String("path", path))
+	return nil
+}
+
+func PresetComposePath(root, preset string) string {
+	return filepath.Join(root, "docker", "presets", preset, "compose.yml")
+}
diff --git a/cmd/fastad/cmd/preset_common_test.go b/cmd/fastad/cmd/preset_common_test.go
new file mode 100644
index 0000000..c47be52
--- /dev/null
+++ b/cmd/fastad/cmd/preset_common_test.go
@@ -0,0 +1,230 @@
+package cmd_test
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/c4t-but-s4d/fastad/cmd/fastad/cmd"
+)
+
+func TestDefaultTemporalPostgresConfig(t *testing.T) {
+	cfg := cmd.DefaultTemporalPostgresConfig()
+
+	assert.Equal(t, "temporal-postgres", cfg.Host)
+	assert.Equal(t, "5432", cfg.Port)
+	assert.Equal(t, "temporal", cfg.User)
+	assert.Equal(t, "temporal", cfg.Password)
+	assert.Equal(t, "temporal", cfg.Database)
+	assert.Equal(t, "false", cfg.TLS)
+	assert.Equal(t, "false", cfg.SkipDBCreate)
+}
+
+func TestParseTemporalDSN(t *testing.T) {
+	tests := []struct {
+		name    string
+		dsn     string
+		want    cmd.TemporalPostgresConfig
+		wantErr string
+	}{
+		{
+			name: "full dsn",
+			dsn:  "postgres://user:pass@host:5433/mydb",
+			want: cmd.TemporalPostgresConfig{
+				User:         "user",
+				Password:     "pass",
+				Host:         "host",
+				Port:         "5433",
+				Database:     "mydb",
+				TLS:          "false",
+				SkipDBCreate: "true",
+			},
+		},
+		{
+			name: "dsn without password",
+			dsn:  "postgres://user@host:5432/mydb",
+			want: cmd.TemporalPostgresConfig{
+				User:         "user",
+				Password:     "",
+				Host:         "host",
+				Port:         "5432",
+				Database:     "mydb",
+				TLS:          "false",
+				SkipDBCreate: "true",
+			},
+		},
+		{
+			name: "dsn with leading slash in path",
+			dsn:  "postgres://user:pass@host:5432/database",
+			want: cmd.TemporalPostgresConfig{
+				User:         "user",
+				Password:     "pass",
+				Host:         "host",
+				Port:         "5432",
+				Database:     "database",
+				TLS:          "false",
+				SkipDBCreate: "true",
+			},
+		},
+		{
+			name:    "invalid scheme",
+			dsn:     "mysql://user:pass@host:3306/db",
+			wantErr: "scheme must be postgres",
+		},
+		{
+			name:    "invalid url",
+			dsn:     "://invalid",
+			wantErr: "parsing temporal dsn",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := cmd.ParseTemporalDSN(tt.dsn)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func TestComposeManipulator(t *testing.T) {
+	tmpDir := t.TempDir()
+	composePath := filepath.Join(tmpDir, "compose.yml")
+
+	initialContent := `services:
+  app:
+    image: myapp
+    depends_on:
+      postgres:
+        condition: service_healthy
+    volumes:
+      - ./data:/data
+  postgres:
+    image: postgres:17
+  redis:
+    image: redis:7
+volumes:
+  app-data:
+  postgres-data:
+`
+
+	err := os.WriteFile(composePath, []byte(initialContent), 0o644)
+	require.NoError(t, err)
+
+	t.Run("LoadCompose", func(t *testing.T) {
+		compose, err := cmd.LoadCompose(composePath)
+		require.NoError(t, err)
+		assert.Len(t, compose.Services(), 3)
+		assert.Len(t, compose.Volumes(), 2)
+	})
+
+	t.Run("RemoveService", func(t *testing.T) {
+		compose, err := cmd.LoadCompose(composePath)
+		require.NoError(t, err)
+
+		compose.RemoveService("postgres")
+		assert.Len(t, compose.Services(), 2)
+		_, exists := compose.Services()["postgres"]
+		assert.False(t, exists)
+	})
+
+	t.Run("RemoveVolume", func(t *testing.T) {
+		compose, err := cmd.LoadCompose(composePath)
+		require.NoError(t, err)
+
+		compose.RemoveVolume("postgres-data")
+		assert.Len(t, compose.Volumes(), 1)
+		_, exists := compose.Volumes()["postgres-data"]
+		assert.False(t, exists)
+	})
+
+	t.Run("RemoveDependsOn", func(t *testing.T) {
+		compose, err := cmd.LoadCompose(composePath)
+		require.NoError(t, err)
+
+		compose.RemoveDependsOn("app")
+		appService, ok := compose.Services()["app"].(map[string]any)
+		require.True(t, ok, "app service should be a map")
+		_, hasDeps := appService["depends_on"]
+		assert.False(t, hasDeps)
+	})
+
+	t.Run("SetDependsOn", func(t *testing.T) {
+		compose, err := cmd.LoadCompose(composePath)
+		require.NoError(t, err)
+
+		newDeps := map[string]any{
+			"redis": map[string]any{"condition": "service_started"},
+		}
+		compose.SetDependsOn("app", newDeps)
+
+		appService, ok := compose.Services()["app"].(map[string]any)
+		require.True(t, ok, "app service should be a map")
+		deps, ok := appService["depends_on"].(map[string]any)
+		require.True(t, ok, "depends_on should be a map")
+		redisDep, ok := deps["redis"].(map[string]any)
+		require.True(t, ok, "redis dep should be a map")
+		assert.Equal(t, "service_started", redisDep["condition"])
+	})
+
+	t.Run("SetVolumes", func(t *testing.T) {
+		compose, err := cmd.LoadCompose(composePath)
+		require.NoError(t, err)
+
+		compose.SetVolumes("app", []string{"/new/path:/container/path"})
+
+		appService, ok := compose.Services()["app"].(map[string]any)
+		require.True(t, ok, "app service should be a map")
+		volumes, ok := appService["volumes"].([]string)
+		require.True(t, ok, "volumes should be a string slice")
+		require.Len(t, volumes, 1)
+		assert.Equal(t, "/new/path:/container/path", volumes[0])
+	})
+
+	t.Run("Write", func(t *testing.T) {
+		compose, err := cmd.LoadCompose(composePath)
+		require.NoError(t, err)
+
+		compose.RemoveService("redis")
+
+		outputPath := filepath.Join(tmpDir, "output.yml")
+		err = compose.Write(outputPath)
+		require.NoError(t, err)
+
+		reloaded, err := cmd.LoadCompose(outputPath)
+		require.NoError(t, err)
+		assert.Len(t, reloaded.Services(), 2)
+	})
+
+	t.Run("LoadCompose_FileNotFound", func(t *testing.T) {
+		_, err := cmd.LoadCompose("/nonexistent/path/compose.yml")
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "reading compose file")
+	})
+}
+
+func TestWriteEnvFile(t *testing.T) {
+	tmpDir := t.TempDir()
+	envPath := filepath.Join(tmpDir, ".env")
+
+	content := []byte("KEY=value\nANOTHER=test\n")
+	err := cmd.WriteEnvFile(envPath, content)
+	require.NoError(t, err)
+
+	read, err := os.ReadFile(envPath)
+	require.NoError(t, err)
+	assert.Equal(t, content, read)
+}
+
+func TestPresetComposePath(t *testing.T) {
+	path := cmd.PresetComposePath("/root/project", "simple")
+	assert.Equal(t, "/root/project/docker/presets/simple/compose.yml", path)
+}
diff --git a/cmd/fastad/cmd/preset_production.go b/cmd/fastad/cmd/preset_production.go
new file mode 100644
index 0000000..7e1aff5
--- /dev/null
+++ b/cmd/fastad/cmd/preset_production.go
@@ -0,0 +1,117 @@
+package cmd
+
+import (
+	"bytes"
+	"fmt"
+	"path/filepath"
+	"text/template"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+)
+
+type productionEnvTemplateContext struct {
+	LogLevel      string
+	PublicPort    int
+	IntercomToken string
+	CheckersDir   string
+
+	DatabaseDSN string
+	Temporal    TemporalPostgresConfig
+}
+
+const productionEnvTemplateData = `# FastAD production preset environment file
+# This file was generated by FastAD setup
+# Do not edit this file manually
+
+# services
+FASTAD_LOG_LEVEL={{ .LogLevel }}
+FASTAD_POSTGRES_DSN={{ .DatabaseDSN }}
+FASTAD_INTERCOM_TOKEN={{ .IntercomToken }}
+
+# checkers
+CHECKERS_DIR={{ .CheckersDir }}
+
+# temporal
+TEMPORAL_POSTGRES_USER={{ .Temporal.User }}
+TEMPORAL_POSTGRES_PASSWORD={{ .Temporal.Password }}
+TEMPORAL_POSTGRES_DATABASE={{ .Temporal.Database }}
+TEMPORAL_POSTGRES_HOST={{ .Temporal.Host }}
+TEMPORAL_POSTGRES_PORT={{ .Temporal.Port }}
+TEMPORAL_POSTGRES_TLS={{ .Temporal.TLS }}
+TEMPORAL_SKIP_DB_CREATE={{ .Temporal.SkipDBCreate }}
+
+# caddy
+CADDY_PORT={{ .PublicPort }}
+`
+
+var productionEnvTemplate = template.Must(template.New("productionEnv").Parse(productionEnvTemplateData))
+
+func PresetProduction(root string, config *gameconfig.GameConfig) error {
+	envContext := productionEnvTemplateContext{
+		LogLevel:      config.FastAD.LogLevel,
+		PublicPort:    config.FastAD.ListenPort,
+		IntercomToken: config.FastAD.IntercomToken,
+	}
+
+	checkersPath := config.Game.CheckersBasePath
+	if filepath.IsAbs(checkersPath) {
+		relPath, err := filepath.Rel(root, checkersPath)
+		if err == nil {
+			checkersPath = relPath
+		}
+	}
+	envContext.CheckersDir = checkersPath
+
+	startPostgres := true
+	if config.Database != nil && config.Database.ExternalDSN != "" {
+		envContext.DatabaseDSN = config.Database.ExternalDSN
+		startPostgres = false
+	} else {
+		envContext.DatabaseDSN = "postgres://fastad:fastad@postgres:5432/fastad?sslmode=disable"
+	}
+
+	startTemporalPostgres := true
+	if config.Database != nil && config.Database.TemporalExternalDSN != "" {
+		var err error
+		envContext.Temporal, err = ParseTemporalDSN(config.Database.TemporalExternalDSN)
+		if err != nil {
+			return fmt.Errorf("parsing temporal external dsn: %w", err)
+		}
+		startTemporalPostgres = false
+	} else {
+		envContext.Temporal = DefaultTemporalPostgresConfig()
+	}
+
+	var envContent bytes.Buffer
+	if err := productionEnvTemplate.Execute(&envContent, envContext); err != nil {
+		return fmt.Errorf("executing env template: %w", err)
+	}
+
+	envPath := filepath.Join(root, ".env")
+	if err := WriteEnvFile(envPath, envContent.Bytes()); err != nil {
+		return err
+	}
+
+	compose, err := LoadCompose(PresetComposePath(root, "production"))
+	if err != nil {
+		return err
+	}
+
+	if !startPostgres {
+		compose.RemoveService("postgres")
+		compose.RemoveDependsOn("migrator")
+	}
+
+	if !startTemporalPostgres {
+		compose.RemoveService("temporal-postgres")
+		compose.RemoveDependsOn("temporal-admin-tools")
+	}
+
+	config.Game.CheckersBasePath = "/checkers-scripts"
+	for _, service := range config.Services {
+		service.Checker.Path = filepath.Join(config.Game.CheckersBasePath, service.Checker.Path)
+	}
+
+	destCompose := filepath.Join(root, "compose.yml")
+	return compose.Write(destCompose)
+}
diff --git a/cmd/fastad/cmd/preset_simple.go b/cmd/fastad/cmd/preset_simple.go
new file mode 100644
index 0000000..447c84c
--- /dev/null
+++ b/cmd/fastad/cmd/preset_simple.go
@@ -0,0 +1,119 @@
+package cmd
+
+import (
+	"bytes"
+	"fmt"
+	"path/filepath"
+	"text/template"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+)
+
+type simpleEnvTemplateContext struct {
+	LogLevel      string
+	PublicPort    int
+	IntercomToken string
+
+	DatabaseDSN string
+	Temporal    TemporalPostgresConfig
+}
+
+const simpleEnvTemplateData = `# FastAD simple preset environment file
+# This file was generated by FastAD setup
+# Do not edit this file manually
+
+# allinone
+FASTAD_LOG_LEVEL={{ .LogLevel }}
+FASTAD_POSTGRES_DSN={{ .DatabaseDSN }}
+FASTAD_INTERCOM_TOKEN={{ .IntercomToken }}
+
+# temporal
+TEMPORAL_POSTGRES_USER={{ .Temporal.User }}
+TEMPORAL_POSTGRES_PASSWORD={{ .Temporal.Password }}
+TEMPORAL_POSTGRES_DATABASE={{ .Temporal.Database }}
+TEMPORAL_POSTGRES_HOST={{ .Temporal.Host }}
+TEMPORAL_POSTGRES_PORT={{ .Temporal.Port }}
+TEMPORAL_POSTGRES_TLS={{ .Temporal.TLS }}
+TEMPORAL_SKIP_DB_CREATE={{ .Temporal.SkipDBCreate }}
+
+# caddy
+CADDY_PORT={{ .PublicPort }}
+`
+
+var simpleEnvTemplate = template.Must(template.New("simpleEnv").Parse(simpleEnvTemplateData))
+
+func PresetSimple(root string, config *gameconfig.GameConfig) error {
+	envContext := simpleEnvTemplateContext{
+		LogLevel:      config.FastAD.LogLevel,
+		PublicPort:    config.FastAD.ListenPort,
+		IntercomToken: config.FastAD.IntercomToken,
+	}
+
+	startPostgres := true
+	if config.Database != nil && config.Database.ExternalDSN != "" {
+		envContext.DatabaseDSN = config.Database.ExternalDSN
+		startPostgres = false
+	} else {
+		envContext.DatabaseDSN = "postgres://fastad:fastad@postgres:5432/fastad?sslmode=disable"
+	}
+
+	startTemporalPostgres := true
+	if config.Database != nil && config.Database.TemporalExternalDSN != "" {
+		var err error
+		envContext.Temporal, err = ParseTemporalDSN(config.Database.TemporalExternalDSN)
+		if err != nil {
+			return fmt.Errorf("parsing temporal external dsn: %w", err)
+		}
+		startTemporalPostgres = false
+	} else {
+		envContext.Temporal = DefaultTemporalPostgresConfig()
+	}
+
+	var envContent bytes.Buffer
+	if err := simpleEnvTemplate.Execute(&envContent, envContext); err != nil {
+		return fmt.Errorf("executing env template: %w", err)
+	}
+
+	envPath := filepath.Join(root, ".env")
+	if err := WriteEnvFile(envPath, envContent.Bytes()); err != nil {
+		return err
+	}
+
+	compose, err := LoadCompose(PresetComposePath(root, "simple"))
+	if err != nil {
+		return err
+	}
+
+	if !startPostgres {
+		compose.RemoveService("postgres")
+		compose.RemoveVolume("fastad-db")
+		compose.SetDependsOn("app", map[string]any{
+			"temporal": map[string]any{
+				"condition": "service_healthy",
+			},
+		})
+	}
+
+	if !startTemporalPostgres {
+		compose.RemoveService("temporal-postgres")
+		compose.RemoveVolume("temporal-db")
+		compose.RemoveDependsOn("temporal-admin-tools")
+	}
+
+	checkersPath := config.Game.CheckersBasePath
+	if !filepath.IsAbs(checkersPath) {
+		checkersPath = filepath.Join(root, checkersPath)
+	}
+
+	compose.SetVolumes("app", []string{
+		fmt.Sprintf("%s:/checkers", checkersPath),
+	})
+
+	config.Game.CheckersBasePath = "/checkers"
+	for _, service := range config.Services {
+		service.Checker.Path = filepath.Join(config.Game.CheckersBasePath, service.Checker.Path)
+	}
+
+	destCompose := filepath.Join(root, "compose.yml")
+	return compose.Write(destCompose)
+}
diff --git a/cmd/fastad/cmd/reset.go b/cmd/fastad/cmd/reset.go
new file mode 100644
index 0000000..0e81d82
--- /dev/null
+++ b/cmd/fastad/cmd/reset.go
@@ -0,0 +1,55 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+)
+
+func NewResetCmd(_ *Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "reset",
+		Short: "Reset the game (stops containers, removes volumes and data)",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			ctx := cmd.Context()
+			root, err := gameconfig.GetFastADRoot()
+			if err != nil {
+				return fmt.Errorf("getting fastad root: %w", err)
+			}
+
+			composePath := filepath.Join(root, "compose.yml")
+			if _, err := os.Stat(composePath); os.IsNotExist(err) {
+				zap.L().Info("compose.yml not found, nothing to reset")
+				return nil
+			}
+
+			zap.L().Info("stopping and removing containers")
+			stopCmd := exec.CommandContext(ctx, "docker", "compose", "-f", composePath, "down", "-v", "--remove-orphans")
+			stopCmd.Dir = root
+			stopCmd.Stdout = os.Stdout
+			stopCmd.Stderr = os.Stderr
+			if err := stopCmd.Run(); err != nil {
+				return fmt.Errorf("stopping containers: %w", err)
+			}
+
+			dataDir := filepath.Join(root, "data")
+			if _, err := os.Stat(dataDir); err == nil {
+				zap.L().Info("removing data directory", zap.String("path", dataDir))
+				if err := os.RemoveAll(dataDir); err != nil {
+					zap.L().Warn("failed to remove data directory", zap.Error(err))
+				}
+			}
+
+			zap.L().Info("reset complete")
+			return nil
+		},
+	}
+
+	return cmd
+}
diff --git a/cmd/fastad/cmd/root.go b/cmd/fastad/cmd/root.go
new file mode 100644
index 0000000..e444462
--- /dev/null
+++ b/cmd/fastad/cmd/root.go
@@ -0,0 +1,24 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/c4t-but-s4d/fastad/pkg/viperext"
+)
+
+func NewRootCmd(cc *Context) *cobra.Command {
+	rootCmd := &cobra.Command{
+		Use:              "fastad",
+		Short:            "FastAD - Blazing fast Attack & Defence CTF platform",
+		SilenceUsage:     true,
+		SilenceErrors:    true,
+		TraverseChildren: true,
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			viperext.RunBindCommandFlags(cc.Viper, cmd)
+			cc.Context = cmd.Context()
+			return nil
+		},
+	}
+
+	return rootCmd
+}
diff --git a/cmd/fastad/cmd/run.go b/cmd/fastad/cmd/run.go
new file mode 100644
index 0000000..caa412e
--- /dev/null
+++ b/cmd/fastad/cmd/run.go
@@ -0,0 +1,144 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/samber/lo"
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/apiwait"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+func NewRunCmd(cc *Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "run",
+		Short: "Start the game (runs docker compose and initializes game state)",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			ctx := cmd.Context()
+			root, err := gameconfig.GetFastADRoot()
+			if err != nil {
+				return fmt.Errorf("getting fastad root: %w", err)
+			}
+
+			// Read the generated config (created by 'fastad init')
+			cfg, err := gameconfig.ReadGeneratedConfig()
+			if err != nil {
+				return fmt.Errorf("reading generated config: %w (did you run 'fastad init' first?)", err)
+			}
+
+			composePath := filepath.Join(root, "compose.yml")
+			if _, err := os.Stat(composePath); os.IsNotExist(err) {
+				return fmt.Errorf("compose.yml not found at %s (did you run 'fastad init' first?)", composePath)
+			}
+
+			if !cc.Viper.GetBool("only_init") {
+				// Stop existing services first
+				zap.L().Info("stopping existing services")
+				stopCmd := exec.CommandContext(ctx, "docker", "compose", "-f", composePath, "down", "-v", "--remove-orphans")
+				stopCmd.Dir = root
+				stopCmd.Stdout = os.Stdout
+				stopCmd.Stderr = os.Stderr
+				if err := stopCmd.Run(); err != nil {
+					return fmt.Errorf("stopping existing services: %w", err)
+				}
+
+				// Start services
+				args := []string{"compose", "-f", composePath, "up", "-d"}
+				if !cc.Viper.GetBool("no_build") {
+					args = append(args, "--build")
+				}
+
+				dockerCmd := exec.CommandContext(ctx, "docker", args...)
+				dockerCmd.Dir = root
+				dockerCmd.Stdout = os.Stdout
+				dockerCmd.Stderr = os.Stderr
+
+				zap.L().Info("starting services", zap.String("command", dockerCmd.String()))
+				if err := dockerCmd.Run(); err != nil {
+					return fmt.Errorf("running docker compose: %w", err)
+				}
+			} else {
+				zap.L().Info("skipping starting the services (--only-init)")
+			}
+
+			// Wait for services to be ready
+			zap.L().Info("waiting for services to start")
+			httpAddr := fmt.Sprintf("127.0.0.1:%d", cfg.FastAD.ListenPort)
+			if err := apiwait.HTTP(ctx, httpAddr); err != nil {
+				return fmt.Errorf("waiting for API service: %w", err)
+			}
+
+			// Initialize game state
+			apiAddress := fmt.Sprintf("127.0.0.1:%d", cfg.FastAD.ListenPort)
+			zap.L().Info("initializing game", zap.String("api_address", apiAddress))
+
+			apiConn, err := grpcext.Dial(
+				apiAddress,
+				"fastad-setup",
+				grpcext.AuthDialOptions(cfg.FastAD.IntercomToken)...,
+			)
+			if err != nil {
+				return fmt.Errorf("dialing data service: %w", err)
+			}
+			defer apiConn.Close()
+
+			teamsClient := teams.NewClient(teamspb.NewTeamsServiceClient(apiConn), "fastad-cli")
+			servicesClient := services.NewClient(servicespb.NewServicesServiceClient(apiConn), "fastad-cli")
+			gameStateClient := gamestate.NewClient(gspb.NewGameStateServiceClient(apiConn), "fastad-cli")
+
+			teamsToCreate := lo.Map(cfg.Teams, func(t *gameconfig.Team, _ int) *teamspb.Team {
+				return t.ToProto()
+			})
+
+			servicesToCreate := lo.Map(cfg.Services, func(s *gameconfig.Service, _ int) *servicespb.Service {
+				return s.ToProto()
+			})
+
+			createdTeams, err := teamsClient.CreateBatch(ctx, teamsToCreate)
+			if err != nil {
+				return fmt.Errorf("creating teams: %w", err)
+			}
+			zap.S().Infof("created teams: %v", createdTeams)
+
+			createdServices, err := servicesClient.CreateBatch(ctx, servicesToCreate)
+			if err != nil {
+				return fmt.Errorf("creating services: %w", err)
+			}
+			zap.S().Infof("created services: %v", createdServices)
+
+			// Try to get existing game state first
+			existingGameState, err := gameStateClient.Get(ctx)
+			if err == nil && existingGameState != nil {
+				zap.S().Infof("game state already exists, skipping creation: %+v", existingGameState)
+			} else {
+				// Create new game state
+				createdGameState, err := gameStateClient.Create(ctx, cfg.Game.ToCreateRequestProto())
+				if err != nil {
+					return fmt.Errorf("creating game state: %w", err)
+				}
+				zap.S().Infof("created game state: %+v", createdGameState)
+			}
+
+			zap.L().Info("game started successfully")
+
+			return nil
+		},
+	}
+
+	cmd.Flags().Bool("no-build", false, "skip building images (use --build by default)")
+	cmd.Flags().Bool("only-init", false, "only initialize the game state (skip starting containers)")
+
+	return cmd
+}
diff --git a/cmd/fastad/cmd/tokens.go b/cmd/fastad/cmd/tokens.go
new file mode 100644
index 0000000..2c2a77f
--- /dev/null
+++ b/cmd/fastad/cmd/tokens.go
@@ -0,0 +1,78 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+func NewTokensCmd(cc *Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "tokens",
+		Short: "Print team tokens",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			ctx := cmd.Context()
+			cfg, err := gameconfig.ReadGeneratedConfig()
+			if err != nil {
+				return fmt.Errorf("reading generated config: %w", err)
+			}
+
+			apiAddress := fmt.Sprintf("127.0.0.1:%d", cfg.FastAD.ListenPort)
+			apiConn, err := grpcext.Dial(
+				apiAddress,
+				"fastad-setup",
+				grpcext.AuthDialOptions(cfg.FastAD.IntercomToken)...,
+			)
+			if err != nil {
+				return fmt.Errorf("dialing data service: %w", err)
+			}
+			defer apiConn.Close()
+
+			teamsClient := teams.NewClient(teamspb.NewTeamsServiceClient(apiConn), "fastad-cli")
+
+			teamsList, err := teamsClient.List(ctx)
+			if err != nil {
+				return fmt.Errorf("listing teams: %w", err)
+			}
+
+			switch cc.Viper.GetString("format") {
+			case "json":
+				type teamToken struct {
+					ID    int64  `json:"id"`
+					Name  string `json:"name"`
+					Token string `json:"token"`
+				}
+				data := make([]teamToken, 0, len(teamsList))
+				for _, team := range teamsList {
+					data = append(data, teamToken{
+						ID:    team.GetId(),
+						Name:  team.GetName(),
+						Token: team.GetToken(),
+					})
+				}
+				if err := json.NewEncoder(os.Stdout).Encode(data); err != nil {
+					return fmt.Errorf("encoding JSON: %w", err)
+				}
+			case "text":
+				for _, team := range teamsList {
+					fmt.Printf("%s:%s\n", team.GetName(), team.GetToken())
+				}
+			default:
+				return fmt.Errorf("unsupported format: %s", cc.Viper.GetString("format"))
+			}
+
+			return nil
+		},
+	}
+
+	cmd.Flags().StringP("format", "f", "text", "output format (json, text)")
+
+	return cmd
+}
diff --git a/cmd/fastad/main.go b/cmd/fastad/main.go
new file mode 100644
index 0000000..5c90eb2
--- /dev/null
+++ b/cmd/fastad/main.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"context"
+	"os/signal"
+	"syscall"
+
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/cmd/fastad/cmd"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/viperext"
+)
+
+func main() {
+	cobra.EnableTraverseRunHooks = true
+
+	defer logging.Init().Close()
+
+	v, err := viperext.NewViper("FASTAD")
+	if err != nil {
+		zap.L().Fatal("creating viper", zap.Error(err))
+	}
+
+	cc := cmd.NewContext(v)
+
+	rootCmd := cmd.NewRootCmd(cc)
+	rootCmd.AddCommand(cmd.NewInitCmd(cc))
+	rootCmd.AddCommand(cmd.NewRunCmd(cc))
+	rootCmd.AddCommand(cmd.NewResetCmd(cc))
+	rootCmd.AddCommand(cmd.NewTokensCmd(cc))
+
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
+	defer cancel()
+
+	if err := rootCmd.ExecuteContext(ctx); err != nil {
+		zap.L().Fatal("running app", zap.Error(err))
+	}
+}
diff --git a/cmd/migrator/main.go b/cmd/migrator/main.go
new file mode 100644
index 0000000..7da5430
--- /dev/null
+++ b/cmd/migrator/main.go
@@ -0,0 +1,215 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+	"github.com/urfave/cli/v2"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/cmd/migrator/migrations"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+)
+
+const (
+	maxRetries     = 10
+	initialBackoff = 1 * time.Second
+	maxBackoff     = 30 * time.Second
+)
+
+func connectWithRetry(ctx context.Context, pgCfg *config.Postgres) (*bun.DB, error) {
+	var db *bun.DB
+	backoff := initialBackoff
+
+	for attempt := 1; attempt <= maxRetries; attempt++ {
+		db = pgCfg.BunDB()
+
+		if err := db.PingContext(ctx); err != nil {
+			zap.L().Warn(
+				"failed to connect to postgres, retrying",
+				zap.Int("attempt", attempt),
+				zap.Int("max_retries", maxRetries),
+				zap.Duration("backoff", backoff),
+				zap.Error(err),
+			)
+
+			if err := db.Close(); err != nil {
+				zap.L().Warn("failed to close db connection", zap.Error(err))
+			}
+
+			if attempt == maxRetries {
+				return nil, fmt.Errorf("failed to connect to postgres after %d attempts: %w", maxRetries, err)
+			}
+
+			select {
+			case <-ctx.Done():
+				return nil, ctx.Err()
+			case <-time.After(backoff):
+			}
+
+			backoff *= 2
+			if backoff > maxBackoff {
+				backoff = maxBackoff
+			}
+			continue
+		}
+
+		zap.L().Info("connected to postgres", zap.Int("attempt", attempt))
+		return db, nil
+	}
+
+	return nil, fmt.Errorf("failed to connect to postgres after %d attempts", maxRetries)
+}
+
+type Config struct {
+	Postgres config.Postgres `mapstructure:"postgres"`
+}
+
+func main() {
+	defer logging.Init().Close()
+
+	app := cli.NewApp()
+
+	var cfg *Config
+	var migrator *migrate.Migrator
+	app.Before = func(c *cli.Context) error {
+		var err error
+		if cfg, err = baseconfig.SetupAll(&Config{}, baseconfig.WithEnvPrefix("FASTAD_MIGRATOR")); err != nil {
+			return fmt.Errorf("setting up config: %w", err)
+		}
+
+		db, err := connectWithRetry(c.Context, &cfg.Postgres)
+		if err != nil {
+			return fmt.Errorf("connecting to postgres: %w", err)
+		}
+
+		migrator = migrate.NewMigrator(db, migrations.Migrations)
+		return nil
+	}
+
+	app.Commands = []*cli.Command{
+		{
+			Name:  "init",
+			Usage: "create migration tables",
+			Action: func(c *cli.Context) error {
+				return migrator.Init(c.Context)
+			},
+		},
+		{
+			Name:  "migrate",
+			Usage: "migrate database",
+			Action: func(c *cli.Context) error {
+				group, err := migrator.Migrate(c.Context)
+				if err != nil {
+					return fmt.Errorf("migrating: %w", err)
+				}
+
+				if group.ID == 0 {
+					zap.L().Info("there are no new migrations to run")
+					return nil
+				}
+
+				zap.S().Infof("migrated to %s", group)
+				return nil
+			},
+		},
+		{
+			Name:  "rollback",
+			Usage: "rollback the last migration group",
+			Action: func(c *cli.Context) error {
+				group, err := migrator.Rollback(c.Context)
+				if err != nil {
+					return fmt.Errorf("rolling back: %w", err)
+				}
+
+				if group.ID == 0 {
+					zap.L().Info("there are no groups to roll back")
+					return nil
+				}
+
+				zap.S().Infof("rolled back %s", group)
+				return nil
+			},
+		},
+		{
+			Name:  "create_go",
+			Usage: "create Go migration",
+			Action: func(c *cli.Context) error {
+				name := strings.Join(c.Args().Slice(), "_")
+				mf, err := migrator.CreateGoMigration(c.Context, name)
+				if err != nil {
+					return fmt.Errorf("creating Go migration: %w", err)
+				}
+				zap.S().Infof("created migration %s (%s)", mf.Name, mf.Path)
+
+				return nil
+			},
+		},
+		{
+			Name:  "create_sql",
+			Usage: "create up and down SQL migrations",
+			Action: func(c *cli.Context) error {
+				name := strings.Join(c.Args().Slice(), "_")
+				files, err := migrator.CreateSQLMigrations(c.Context, name)
+				if err != nil {
+					return fmt.Errorf("creating SQL migrations: %w", err)
+				}
+
+				for _, mf := range files {
+					zap.S().Infof("created migration %s (%s)", mf.Name, mf.Path)
+				}
+
+				return nil
+			},
+		},
+		{
+			Name:  "status",
+			Usage: "print migrations status",
+			Action: func(c *cli.Context) error {
+				ms, err := migrator.MigrationsWithStatus(c.Context)
+				if err != nil {
+					return fmt.Errorf("checking migrations status: %w", err)
+				}
+				zap.S().Infof("migrations: %s", ms)
+				zap.S().Infof("unapplied migrations: %s", ms.Unapplied())
+				zap.S().Infof("last migration group: %s", ms.LastGroup())
+
+				return nil
+			},
+		},
+		{
+			Name:  "mark_applied",
+			Usage: "mark migrations as applied without actually running them",
+			Action: func(c *cli.Context) error {
+				group, err := migrator.Migrate(c.Context, migrate.WithNopMigration())
+				if err != nil {
+					return fmt.Errorf("migrating: %w", err)
+				}
+
+				if group.ID == 0 {
+					zap.L().Info("there are no new migrations to mark as applied")
+					return nil
+				}
+
+				zap.S().Infof("marked as applied %s", group)
+				return nil
+			},
+		},
+	}
+
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer cancel()
+
+	if err := app.RunContext(ctx, os.Args); err != nil {
+		zap.L().Fatal("error running app", zap.Error(err))
+	}
+}
diff --git a/cmd/migrator/migrations/20241223100353_data_service_models.go b/cmd/migrator/migrations/20241223100353_data_service_models.go
new file mode 100644
index 0000000..0480397
--- /dev/null
+++ b/cmd/migrator/migrations/20241223100353_data_service_models.go
@@ -0,0 +1,47 @@
+package migrations
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+//nolint:gochecknoinits // Migrations should be initialized in init functions.
+func init() {
+	Migrations.MustRegister(func(ctx context.Context, db *bun.DB) error {
+		if _, err := db.NewCreateTable().
+			Model((*models.Version)(nil)).
+			IfNotExists().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating versions: %w", err)
+		}
+
+		if _, err := db.NewCreateTable().
+			Model((*models.Team)(nil)).
+			IfNotExists().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating teams: %w", err)
+		}
+
+		if _, err := db.NewCreateTable().
+			Model((*models.Service)(nil)).
+			IfNotExists().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating services: %w", err)
+		}
+
+		if _, err := db.NewCreateTable().
+			Model((*models.GameState)(nil)).
+			IfNotExists().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating game_states: %w", err)
+		}
+
+		return nil
+	}, func(context.Context, *bun.DB) error {
+		return nil
+	})
+}
diff --git a/cmd/migrator/migrations/20241223100559_checkers_models.go b/cmd/migrator/migrations/20241223100559_checkers_models.go
new file mode 100644
index 0000000..89587f7
--- /dev/null
+++ b/cmd/migrator/migrations/20241223100559_checkers_models.go
@@ -0,0 +1,46 @@
+package migrations
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+//nolint:gochecknoinits // Migrations should be initialized in init functions.
+func init() {
+	Migrations.MustRegister(func(ctx context.Context, db *bun.DB) error {
+		if _, err := db.
+			NewCreateTable().
+			Model((*models.CheckerExecution)(nil)).
+			IfNotExists().
+			WithForeignKeys().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating checkers_executions: %w", err)
+		}
+
+		if _, err := db.
+			NewCreateTable().
+			Model((*models.Flag)(nil)).
+			IfNotExists().
+			WithForeignKeys().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating flags: %w", err)
+		}
+
+		if _, err := db.
+			NewCreateTable().
+			Model((*models.AttackDataSnapshot)(nil)).
+			IfNotExists().
+			WithForeignKeys().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating attack_data_snapshots: %w", err)
+		}
+
+		return nil
+	}, func(context.Context, *bun.DB) error {
+		return nil
+	})
+}
diff --git a/cmd/migrator/migrations/20241223101112_receiver_models.go b/cmd/migrator/migrations/20241223101112_receiver_models.go
new file mode 100644
index 0000000..0ebad10
--- /dev/null
+++ b/cmd/migrator/migrations/20241223101112_receiver_models.go
@@ -0,0 +1,28 @@
+package migrations
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+//nolint:gochecknoinits // Migrations should be initialized in init functions.
+func init() {
+	Migrations.MustRegister(func(ctx context.Context, db *bun.DB) error {
+		if _, err := db.
+			NewCreateTable().
+			Model((*models.Attack)(nil)).
+			IfNotExists().
+			WithForeignKeys().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating attacks: %w", err)
+		}
+
+		return nil
+	}, func(context.Context, *bun.DB) error {
+		return nil
+	})
+}
diff --git a/cmd/migrator/migrations/20241223103441_scheduler_models.go b/cmd/migrator/migrations/20241223103441_scheduler_models.go
new file mode 100644
index 0000000..8dbf5de
--- /dev/null
+++ b/cmd/migrator/migrations/20241223103441_scheduler_models.go
@@ -0,0 +1,26 @@
+package migrations
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+//nolint:gochecknoinits // Migrations should be initialized in init functions.
+func init() {
+	Migrations.MustRegister(func(ctx context.Context, db *bun.DB) error {
+		if _, err := db.NewCreateTable().
+			Model((*models.SchedulerState)(nil)).
+			IfNotExists().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating scheduler_states: %w", err)
+		}
+
+		return nil
+	}, func(context.Context, *bun.DB) error {
+		return nil
+	})
+}
diff --git a/cmd/migrator/migrations/20241223124709_data_service_aux.up.sql b/cmd/migrator/migrations/20241223124709_data_service_aux.up.sql
new file mode 100644
index 0000000..b957d08
--- /dev/null
+++ b/cmd/migrator/migrations/20241223124709_data_service_aux.up.sql
@@ -0,0 +1,6 @@
+SET statement_timeout = 0;
+
+--bun:split
+
+ALTER TABLE game_state
+    ADD CONSTRAINT hardness_non_zero CHECK (hardness > 0);
diff --git a/cmd/migrator/migrations/20241224083434_checkers_aux.up.sql b/cmd/migrator/migrations/20241224083434_checkers_aux.up.sql
new file mode 100644
index 0000000..4542a6d
--- /dev/null
+++ b/cmd/migrator/migrations/20241224083434_checkers_aux.up.sql
@@ -0,0 +1,16 @@
+SET statement_timeout = 0;
+
+--bun:split
+
+-- For faster flag picking for GET.
+CREATE INDEX IF NOT EXISTS idx_flags_team_service_round ON flags (team_id, service_id, round);
+
+--bun:split
+
+--For faster slac processing
+CREATE INDEX IF NOT EXISTS idx_checker_executions_created_at ON checker_executions (created_at);
+
+--bun:split
+
+--For faster attack_data handle
+CREATE INDEX IF NOT EXISTS idx_attack_data_snapshots ON attack_data_snapshots (created_at DESC);
diff --git a/cmd/migrator/migrations/20241224120831_scoreboard_models.go b/cmd/migrator/migrations/20241224120831_scoreboard_models.go
new file mode 100644
index 0000000..8440bb2
--- /dev/null
+++ b/cmd/migrator/migrations/20241224120831_scoreboard_models.go
@@ -0,0 +1,27 @@
+package migrations
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+//nolint:gochecknoinits // Migrations should be initialized in init functions.
+func init() {
+	Migrations.MustRegister(func(ctx context.Context, db *bun.DB) error {
+		if _, err := db.NewCreateTable().
+			Model((*models.SlacProcessedItem)(nil)).
+			IfNotExists().
+			// Don't create foreign keys here.
+			Exec(ctx); err != nil {
+			return fmt.Errorf("creating processor_states: %w", err)
+		}
+
+		return nil
+	}, func(context.Context, *bun.DB) error {
+		return nil
+	})
+}
diff --git a/cmd/migrator/migrations/main.go b/cmd/migrator/migrations/main.go
new file mode 100644
index 0000000..c7755e6
--- /dev/null
+++ b/cmd/migrator/migrations/main.go
@@ -0,0 +1,19 @@
+package migrations
+
+import (
+	"embed"
+
+	"github.com/uptrace/bun/migrate"
+)
+
+var Migrations = migrate.NewMigrations()
+
+//go:embed *.sql
+var sqlMigrations embed.FS
+
+//nolint:gochecknoinits // Migrations should be initialized in init functions.
+func init() {
+	if err := Migrations.Discover(sqlMigrations); err != nil {
+		panic(err)
+	}
+}
diff --git a/cmd/receiver/impl/run.go b/cmd/receiver/impl/run.go
new file mode 100644
index 0000000..e556484
--- /dev/null
+++ b/cmd/receiver/impl/run.go
@@ -0,0 +1,97 @@
+package impl
+
+import (
+	"context"
+	"fmt"
+
+	"golang.org/x/sync/errgroup"
+
+	"github.com/c4t-but-s4d/fastad/internal/centutil"
+	"github.com/c4t-but-s4d/fastad/internal/receiver"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	"github.com/c4t-but-s4d/fastad/pkg/metrics"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+)
+
+func Run(runCtx, shutdownCtx context.Context, cfg *receiver.Config) error {
+	db := cfg.Postgres.BunDB()
+
+	producer, err := centutil.NewClientProducer(
+		cfg.CentrifugeClient.Address,
+		cfg.Channel,
+		cfg.Installation,
+		cfg.IntercomToken,
+	)
+	if err != nil {
+		return fmt.Errorf("creating centrifuge producer: %w", err)
+	}
+
+	dataServiceConn, err := grpcext.Dial(
+		cfg.DataService.Address,
+		cfg.Installation,
+		grpcext.AuthDialOptions(cfg.IntercomToken)...,
+	)
+	if err != nil {
+		return fmt.Errorf("dialing data service: %w", err)
+	}
+
+	teamsClient := teams.NewClient(teamspb.NewTeamsServiceClient(dataServiceConn), cfg.Installation)
+	servicesClient := services.NewClient(servicespb.NewServicesServiceClient(dataServiceConn), cfg.Installation)
+	gameStateClient := gamestate.NewClient(gspb.NewGameStateServiceClient(dataServiceConn), cfg.Installation)
+
+	receiverMetrics := receiver.NewMetrics(cfg.Installation)
+
+	receiverService := receiver.New(
+		db,
+		teamsClient,
+		servicesClient,
+		gameStateClient,
+		producer,
+		receiverMetrics,
+	)
+
+	if err := receiverService.RestoreState(runCtx); err != nil {
+		return fmt.Errorf("restoring state: %w", err)
+	}
+
+	grpcServer := grpcext.NewServer(
+		grpcext.WithServerInstallation(cfg.Installation),
+		grpcext.WithServerTokenAuth(cfg.IntercomToken),
+	)
+	receiverpb.RegisterReceiverServiceServer(grpcServer, receiverService)
+
+	g, gctx := errgroup.WithContext(runCtx)
+
+	if cfg.MetricsAddress != "" {
+		g.Go(func() error {
+			metrics.RunServer(runCtx, shutdownCtx, cfg.MetricsAddress)
+			return nil
+		})
+	}
+
+	g.Go(func() error {
+		if err := producer.Run(gctx); err != nil {
+			return fmt.Errorf("running client: %w", err)
+		}
+		return nil
+	})
+
+	g.Go(func() error {
+		if err := grpcext.RunServer(gctx, shutdownCtx, grpcServer, cfg.ListenAddress); err != nil {
+			return fmt.Errorf("running server: %w", err)
+		}
+		return nil
+	})
+
+	if err := g.Wait(); err != nil {
+		return fmt.Errorf("waiting: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/receiver/main.go b/cmd/receiver/main.go
index 1fb5486..5c33e36 100644
--- a/cmd/receiver/main.go
+++ b/cmd/receiver/main.go
@@ -1,64 +1,24 @@
 package main
 
 import (
-	"context"
-	"errors"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
+	"go.uber.org/zap"
 
-	"github.com/c4t-but-s4d/fastad/internal/multiproto"
-	"github.com/c4t-but-s4d/fastad/internal/pinger"
+	"github.com/c4t-but-s4d/fastad/cmd/receiver/impl"
 	"github.com/c4t-but-s4d/fastad/internal/receiver"
-	pingerpb "github.com/c4t-but-s4d/fastad/pkg/proto/pinger"
-	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
-
-	"github.com/sirupsen/logrus"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/reflection"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/stop"
 )
 
 func main() {
-	initLogger()
-
-	logrus.Info("Starting flag receiver")
-
-	grpcServer := grpc.NewServer()
-	receiverpb.RegisterReceiverServiceServer(grpcServer, receiver.New())
-	pingerpb.RegisterPingerServiceServer(grpcServer, pinger.New())
-	reflection.Register(grpcServer)
-
-	httpServer := &http.Server{
-		Addr:    "0.0.0.0:8002",
-		Handler: multiproto.NewHandler(grpcServer),
-	}
-
-	go func() {
-		logrus.Infof("Running http server on %s", httpServer.Addr)
-		if err := httpServer.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
-			logrus.Fatalf("Error running http server: %v", err)
-		}
-	}()
+	defer logging.Init().Close()
 
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
-	<-c
+	cfg := baseconfig.MustSetupAll(&receiver.Config{}, baseconfig.WithEnvPrefix("FASTAD_RECEIVER"))
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	runCtx, shutdownCtx, cancel := stop.SetupCtx()
 	defer cancel()
 
-	if err := httpServer.Shutdown(ctx); err != nil {
-		logrus.Fatalf("Shutting down http server: %v", err)
+	if err := impl.Run(runCtx, shutdownCtx, cfg); err != nil {
+		zap.L().Fatal("receiver run failed", zap.Error(err))
 	}
 }
-
-func initLogger() {
-	mainFormatter := &logrus.TextFormatter{}
-	mainFormatter.FullTimestamp = true
-	mainFormatter.ForceColors = true
-	mainFormatter.PadLevelText = true
-	mainFormatter.TimestampFormat = "2006-01-02 15:04:05"
-	logrus.SetFormatter(mainFormatter)
-}
diff --git a/cmd/scheduler/impl/run.go b/cmd/scheduler/impl/run.go
new file mode 100644
index 0000000..603f854
--- /dev/null
+++ b/cmd/scheduler/impl/run.go
@@ -0,0 +1,95 @@
+package impl
+
+import (
+	"context"
+	"fmt"
+
+	"go.temporal.io/sdk/client"
+	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/c4t-but-s4d/fastad/internal/scheduler"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/metrics"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+func Run(runCtx, shutdownCtx context.Context, cfg *scheduler.Config) error {
+	logger := zap.L().Named(cfg.Installation)
+
+	temporalClient, err := client.Dial(client.Options{
+		HostPort: cfg.Temporal.Address,
+		Logger: logging.NewTemporalAdapter(
+			logger.Named("temporal_client"),
+		),
+	})
+	if err != nil {
+		return fmt.Errorf("creating temporal client: %w", err)
+	}
+	defer temporalClient.Close()
+
+	db := cfg.Postgres.BunDB()
+
+	dataServiceConn, err := grpcext.Dial(
+		cfg.DataService.Address,
+		cfg.Installation,
+		grpcext.AuthDialOptions(cfg.IntercomToken)...,
+	)
+	if err != nil {
+		return fmt.Errorf("dialing data service: %w", err)
+	}
+
+	gameStateClient := gamestate.NewClient(gspb.NewGameStateServiceClient(dataServiceConn), cfg.Installation)
+	teamsClient := teams.NewClient(teamspb.NewTeamsServiceClient(dataServiceConn), cfg.Installation)
+	servicesClient := services.NewClient(servicespb.NewServicesServiceClient(dataServiceConn), cfg.Installation)
+
+	t := scheduler.NewRoundScheduler(
+		temporalClient,
+		gameStateClient,
+		db,
+		logger,
+	)
+
+	cm := scheduler.NewCheckManager(
+		db,
+		gameStateClient,
+		teamsClient,
+		servicesClient,
+		temporalClient,
+		logger,
+	)
+
+	g, gctx := errgroup.WithContext(runCtx)
+	g.Go(func() error {
+		if err := t.Run(gctx); err != nil {
+			return fmt.Errorf("running round scheduler: %w", err)
+		}
+		return nil
+	})
+
+	g.Go(func() error {
+		if err := cm.Run(gctx); err != nil {
+			return fmt.Errorf("running check manager: %w", err)
+		}
+		return nil
+	})
+
+	if cfg.MetricsAddress != "" {
+		g.Go(func() error {
+			metrics.RunServer(gctx, shutdownCtx, cfg.MetricsAddress)
+			return nil
+		})
+	}
+
+	if err := g.Wait(); err != nil {
+		return fmt.Errorf("running errgroup: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/scheduler/main.go b/cmd/scheduler/main.go
new file mode 100644
index 0000000..b8ba74f
--- /dev/null
+++ b/cmd/scheduler/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/cmd/scheduler/impl"
+	"github.com/c4t-but-s4d/fastad/internal/scheduler"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/stop"
+)
+
+func main() {
+	defer logging.Init().Close()
+
+	cfg := baseconfig.MustSetupAll(&scheduler.Config{}, baseconfig.WithEnvPrefix("FASTAD_SCHEDULER"))
+
+	runCtx, shutdownCtx, cancel := stop.SetupCtx()
+	defer cancel()
+
+	if err := impl.Run(runCtx, shutdownCtx, cfg); err != nil {
+		zap.L().Fatal("scheduler worker run failed", zap.Error(err))
+	}
+}
diff --git a/cmd/slac/impl/run.go b/cmd/slac/impl/run.go
new file mode 100644
index 0000000..6b56f95
--- /dev/null
+++ b/cmd/slac/impl/run.go
@@ -0,0 +1,56 @@
+package impl
+
+import (
+	"context"
+	"fmt"
+
+	"golang.org/x/sync/errgroup"
+
+	"github.com/c4t-but-s4d/fastad/internal/slac"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	"github.com/c4t-but-s4d/fastad/pkg/metrics"
+	slacpb "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+)
+
+func Run(runCtx, shutdownCtx context.Context, cfg *slac.Config) error {
+	db := cfg.Postgres.BunDB()
+
+	service := slac.NewService(db, cfg)
+
+	if err := service.RestoreState(runCtx); err != nil {
+		return fmt.Errorf("restoring state: %w", err)
+	}
+
+	g, gctx := errgroup.WithContext(runCtx)
+
+	grpcServer := grpcext.NewServer(
+		grpcext.WithServerInstallation(cfg.Installation),
+		grpcext.WithServerTokenAuth(cfg.IntercomToken),
+	)
+	slacpb.RegisterSlacServiceServer(grpcServer, service)
+
+	if cfg.MetricsAddress != "" {
+		g.Go(func() error {
+			metrics.RunServer(gctx, shutdownCtx, cfg.MetricsAddress)
+			return nil
+		})
+	}
+
+	g.Go(func() error {
+		service.Run(gctx)
+		return nil
+	})
+
+	g.Go(func() error {
+		if err := grpcext.RunServer(gctx, shutdownCtx, grpcServer, cfg.ListenAddress); err != nil {
+			return fmt.Errorf("running server: %w", err)
+		}
+		return nil
+	})
+
+	if err := g.Wait(); err != nil {
+		return fmt.Errorf("waiting: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/slac/main.go b/cmd/slac/main.go
new file mode 100644
index 0000000..bfe2508
--- /dev/null
+++ b/cmd/slac/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/cmd/slac/impl"
+	"github.com/c4t-but-s4d/fastad/internal/slac"
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	"github.com/c4t-but-s4d/fastad/pkg/stop"
+)
+
+func main() {
+	defer logging.Init().Close()
+
+	cfg := baseconfig.MustSetupAll(&slac.Config{}, baseconfig.WithEnvPrefix("FASTAD_SLAC"))
+
+	runCtx, shutdownCtx, cancel := stop.SetupCtx()
+	defer cancel()
+
+	if err := impl.Run(runCtx, shutdownCtx, cfg); err != nil {
+		zap.L().Fatal("slac run failed", zap.Error(err))
+	}
+}
diff --git a/config/game.yml b/config/game.yml
new file mode 100644
index 0000000..8ac670b
--- /dev/null
+++ b/config/game.yml
@@ -0,0 +1,32 @@
+game:
+  # start time in rfc3339 format
+  start_time: '2021-11-30T15:30:00+03:00'
+  end_time: '2022-11-30T15:30:00+03:00'
+  round_duration: '10s'
+  flag_lifetime_rounds: 10
+  mode: 'classic'
+  hardness: 15
+
+teams:
+  - name: 'team1'
+    address: 'addr3'
+
+  - name: 'team2'
+    address: 'addr2'
+
+services:
+  - name: 'service1'
+    default_score: 3000
+    checker:
+      default_timeout: 10s
+      path: 'service1/checker.py'
+
+  - name: 'service2'
+    default_score: 2000
+    checker:
+      default_timeout: 11s
+      path: 'service2/checker2.py'
+      actions:
+        get:
+          timeout: 12s
+          count: 2
diff --git a/config/tests/simple/game.yml b/config/tests/simple/game.yml
new file mode 100644
index 0000000..497e661
--- /dev/null
+++ b/config/tests/simple/game.yml
@@ -0,0 +1,31 @@
+game:
+  start_time: '2025-01-12T20:50:00+03:00'
+  end_time: '2025-01-12T21:35:00+03:00'
+  round_duration: '10s'
+  flag_lifetime_rounds: 10
+  hardness: 15
+  checkers_base_path: '.'
+
+teams:
+  - name: 'team1'
+    address: '127.0.0.1'
+
+  - name: 'team2'
+    address: '127.0.0.1'
+
+services:
+  - name: 'test service'
+    default_score: 3000
+    checker:
+      default_timeout: 10s
+      path: 'tests/service/checker.py'
+
+  - name: 'test service (no checker)'
+    default_score: 2000
+    checker:
+      default_timeout: 11s
+      path: 'no-checker.py'
+      actions:
+        get:
+          timeout: 12s
+          count: 2
diff --git a/docker/presets/production/Caddyfile b/docker/presets/production/Caddyfile
new file mode 100644
index 0000000..43f3080
--- /dev/null
+++ b/docker/presets/production/Caddyfile
@@ -0,0 +1,44 @@
+{
+    servers :80 {
+        protocols h1 h2 h2c
+    }
+}
+
+:80 {
+    log {
+    	output stderr
+    	level DEBUG
+    	format console
+    }
+
+    handle /temporal* {
+        reverse_proxy temporal-ui:8080
+    }
+
+    handle /api/* {
+        reverse_proxy api:8080
+    }
+
+    handle /centrifuge/* {
+        reverse_proxy api:8080
+    }
+
+    handle /healthcheck {
+        reverse_proxy api:8080
+    }
+
+    handle /flags {
+        reverse_proxy api:8080
+    }
+
+    handle /data.* {
+       reverse_proxy h2c://dataservice:8003
+    }
+
+    handle {
+        encode gzip
+        root * /front
+        try_files {path} /index.html
+        file_server
+    }
+}
diff --git a/docker/presets/production/checkers.Dockerfile b/docker/presets/production/checkers.Dockerfile
new file mode 100644
index 0000000..f880082
--- /dev/null
+++ b/docker/presets/production/checkers.Dockerfile
@@ -0,0 +1,43 @@
+FROM golang:1.25-alpine AS builder
+
+ENV CGO_ENABLED=0
+
+RUN apk add --no-cache upx
+
+WORKDIR /app
+
+COPY cmd cmd
+COPY pkg pkg
+COPY internal internal
+COPY go.* ./
+
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+        go build \
+            -trimpath \
+            -ldflags="-w -s" \
+            -o "/checkers" \
+            "./cmd/checkers/main.go"
+
+ARG COMPRESS_BINARIES="false"
+ENV COMPRESS_BINARIES=$COMPRESS_BINARIES
+RUN if [ "${COMPRESS_BINARIES}" = "true" ]; then upx --lzma -9 "/checkers"; fi
+
+FROM python:3.12-bookworm
+
+ENV PWNLIB_NOTERM=true
+ENV UV_BREAK_SYSTEM_PACKAGES=true
+ENV PIP_BREAK_SYSTEM_PACKAGES=true
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/
+
+ARG CHECKERS_DIR
+COPY ${CHECKERS_DIR} /checkers-scripts
+RUN --mount=type=cache,target=/root/.cache/uv \
+    find /checkers-scripts -name "requirements.txt" | while read -r file; do \
+      echo "Installing requirements from ${file}"; uv pip install --system -r "$file"; \
+    done
+
+COPY --from=builder /checkers /checkers
+
+ENTRYPOINT ["/checkers"]
diff --git a/docker/presets/production/compose.yml b/docker/presets/production/compose.yml
new file mode 100644
index 0000000..8a5cc49
--- /dev/null
+++ b/docker/presets/production/compose.yml
@@ -0,0 +1,312 @@
+services:
+  migrator:
+    build:
+      context: .
+      dockerfile: ./docker/presets/production/service.Dockerfile
+      args:
+        SERVICE_NAME: migrator
+    restart: on-failure:5
+    environment:
+      FASTAD_MIGRATOR_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+    depends_on:
+      postgres:
+        condition: service_healthy
+    command: ["sh", "-c", "/service init && /service migrate"]
+
+  dataservice:
+    build:
+      context: .
+      dockerfile: ./docker/presets/production/service.Dockerfile
+      args:
+        SERVICE_NAME: dataservice
+    restart: unless-stopped
+    environment:
+      FASTAD_DATA_SERVICE_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_DATA_SERVICE_INTERCOM_TOKEN: ${FASTAD_INTERCOM_TOKEN}
+      FASTAD_DATA_SERVICE_LISTEN_ADDRESS: ":8003"
+      FASTAD_DATA_SERVICE_METRICS_ADDRESS: ":3004"
+      FASTAD_DATA_SERVICE_INSTALLATION: "fastad-prod"
+    depends_on:
+      migrator:
+        condition: service_completed_successfully
+    healthcheck:
+      test: ['CMD-SHELL', 'nc -z localhost 8003 || exit 1']
+      interval: 5s
+      timeout: 3s
+      retries: 10
+      start_period: 10s
+
+  api:
+    build:
+      context: .
+      dockerfile: ./docker/presets/production/service.Dockerfile
+      args:
+        SERVICE_NAME: api
+    restart: unless-stopped
+    environment:
+      FASTAD_API_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_API_INTERCOM_TOKEN: ${FASTAD_INTERCOM_TOKEN}
+      FASTAD_API_LISTEN_ADDRESS: ":8080"
+      FASTAD_API_METRICS_ADDRESS: ":3001"
+      FASTAD_API_DATA_SERVICE_ADDRESS: "dataservice:8003"
+      FASTAD_API_RECEIVER_ADDRESS: "receiver:8001"
+      FASTAD_API_SLAC_ADDRESS: "slac:8002"
+      FASTAD_API_INSTALLATION: "fastad-prod"
+      FASTAD_API_SCOREBOARD_CHANNEL: "scoreboard"
+    depends_on:
+      dataservice:
+        condition: service_healthy
+      slac:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD-SHELL', 'wget -qO- http://localhost:8080/healthcheck || exit 1']
+      interval: 5s
+      timeout: 5s
+      retries: 10
+      start_period: 30s
+
+  receiver:
+    build:
+      context: .
+      dockerfile: ./docker/presets/production/service.Dockerfile
+      args:
+        SERVICE_NAME: receiver
+    restart: unless-stopped
+    environment:
+      FASTAD_RECEIVER_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_RECEIVER_INTERCOM_TOKEN: ${FASTAD_INTERCOM_TOKEN}
+      FASTAD_RECEIVER_LISTEN_ADDRESS: ":8001"
+      FASTAD_RECEIVER_METRICS_ADDRESS: ":3002"
+      FASTAD_RECEIVER_DATA_SERVICE_ADDRESS: "dataservice:8003"
+      FASTAD_RECEIVER_CENTRIFUGE_CLIENT_ADDRESS: "ws://api:8080/centrifuge/websocket"
+      FASTAD_RECEIVER_INSTALLATION: "fastad-prod"
+    depends_on:
+      dataservice:
+        condition: service_healthy
+      api:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD-SHELL', 'nc -z localhost 8001 || exit 1']
+      interval: 5s
+      timeout: 3s
+      retries: 10
+      start_period: 10s
+
+  slac:
+    build:
+      context: .
+      dockerfile: ./docker/presets/production/service.Dockerfile
+      args:
+        SERVICE_NAME: slac
+    restart: unless-stopped
+    environment:
+      FASTAD_SLAC_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_SLAC_INTERCOM_TOKEN: ${FASTAD_INTERCOM_TOKEN}
+      FASTAD_SLAC_LISTEN_ADDRESS: ":8002"
+      FASTAD_SLAC_METRICS_ADDRESS: ":3003"
+      FASTAD_SLAC_DATA_SERVICE_ADDRESS: "dataservice:8003"
+      FASTAD_SLAC_INSTALLATION: "fastad-prod"
+    depends_on:
+      dataservice:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD-SHELL', 'nc -z localhost 8002 || exit 1']
+      interval: 5s
+      timeout: 3s
+      retries: 10
+      start_period: 10s
+
+  scheduler:
+    build:
+      context: .
+      dockerfile: ./docker/presets/production/service.Dockerfile
+      args:
+        SERVICE_NAME: scheduler
+    restart: unless-stopped
+    environment:
+      FASTAD_SCHEDULER_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_SCHEDULER_INTERCOM_TOKEN: ${FASTAD_INTERCOM_TOKEN}
+      FASTAD_SCHEDULER_METRICS_ADDRESS: ":3005"
+      FASTAD_SCHEDULER_DATA_SERVICE_ADDRESS: "dataservice:8003"
+      FASTAD_SCHEDULER_TEMPORAL_ADDRESS: "temporal:7233"
+      FASTAD_SCHEDULER_INSTALLATION: "fastad-prod"
+    depends_on:
+      temporal-create-namespace:
+        condition: service_completed_successfully
+      dataservice:
+        condition: service_healthy
+
+  checkers:
+    build:
+      context: .
+      dockerfile: ./docker/presets/production/checkers.Dockerfile
+      args:
+        CHECKERS_DIR: ${CHECKERS_DIR:-checkers}
+    restart: unless-stopped
+    environment:
+      FASTAD_CHECKERS_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_CHECKERS_INTERCOM_TOKEN: ${FASTAD_INTERCOM_TOKEN}
+      FASTAD_CHECKERS_METRICS_ADDRESS: ":3006"
+      FASTAD_CHECKERS_TEMPORAL_ADDRESS: "temporal:7233"
+      FASTAD_CHECKERS_DATA_SERVICE_ADDRESS: "dataservice:8003"
+      FASTAD_CHECKERS_INSTALLATION: "fastad-prod"
+    depends_on:
+      temporal-create-namespace:
+        condition: service_completed_successfully
+      dataservice:
+        condition: service_healthy
+
+  caddy:
+    build:
+      context: .
+      dockerfile: ./docker/presets/simple/caddy.Dockerfile
+    restart: unless-stopped
+    ports:
+      - "${CADDY_PORT}:80"
+    volumes:
+      - ./docker/presets/production/Caddyfile:/etc/caddy/Caddyfile:ro
+      - caddy-data:/data
+      - caddy-config:/config
+    depends_on:
+      api:
+        condition: service_healthy
+
+  temporal-admin-tools:
+    image: temporalio/admin-tools:1.26.2
+    restart: on-failure:6
+    depends_on:
+      temporal-postgres:
+        condition: service_healthy
+    environment:
+      DB: postgres12
+      DB_PORT: ${TEMPORAL_POSTGRES_PORT}
+      POSTGRES_USER: ${TEMPORAL_POSTGRES_USER}
+      POSTGRES_PWD: ${TEMPORAL_POSTGRES_PASSWORD}
+      POSTGRES_SEEDS: ${TEMPORAL_POSTGRES_HOST}
+      SQL_PASSWORD: ${TEMPORAL_POSTGRES_PASSWORD}
+    volumes:
+      - ./docker/presets/simple/temporal-scripts:/scripts:ro
+    entrypoint: ["/bin/sh"]
+    command: /scripts/setup-postgres.sh
+
+  temporal:
+    image: temporalio/server:1.26.2
+    restart: unless-stopped
+    environment:
+      DB: postgres12
+      DB_PORT: ${TEMPORAL_POSTGRES_PORT}
+      POSTGRES_USER: ${TEMPORAL_POSTGRES_USER}
+      POSTGRES_PWD: ${TEMPORAL_POSTGRES_PASSWORD}
+      POSTGRES_SEEDS: ${TEMPORAL_POSTGRES_HOST}
+      BIND_ON_IP: "0.0.0.0"
+      DYNAMIC_CONFIG_FILE_PATH: config/dynamicconfig/development-sql.yaml
+    depends_on:
+      temporal-admin-tools:
+        condition: service_completed_successfully
+    volumes:
+      - ./docker/presets/simple/temporal-dynamicconfig:/etc/temporal/config/dynamicconfig:ro
+    healthcheck:
+      test: ['CMD', 'nc', '-z', 'localhost', '7233']
+      interval: 5s
+      timeout: 3s
+      retries: 60
+      start_period: 30s
+
+  temporal-create-namespace:
+    image: temporalio/admin-tools:1.26.2
+    restart: on-failure:5
+    depends_on:
+      temporal:
+        condition: service_healthy
+    environment:
+      TEMPORAL_ADDRESS: temporal:7233
+      DEFAULT_NAMESPACE: default
+    volumes:
+      - ./docker/presets/simple/temporal-scripts:/scripts:ro
+    entrypoint: ["/bin/sh"]
+    command: /scripts/create-namespace.sh
+
+  temporal-ui:
+    image: temporalio/ui:2.33.0
+    restart: unless-stopped
+    environment:
+      - TEMPORAL_ADDRESS=temporal:7233
+      - TEMPORAL_UI_PORT=8080
+      - TEMPORAL_UI_PUBLIC_PATH=/temporal
+    depends_on:
+      temporal:
+        condition: service_healthy
+
+  postgres:
+    image: postgres:17.2-alpine
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:${FASTAD_POSTGRES_EXTERNAL_PORT:-5433}:5432"
+    environment:
+      POSTGRES_USER: fastad
+      POSTGRES_PASSWORD: fastad
+      POSTGRES_DB: fastad
+    volumes:
+      - ${FASTAD_DATA_DIR:-./data}/fastad-db:/var/lib/postgresql/data
+    healthcheck:
+      test: pg_isready -U fastad -d fastad
+      interval: 5s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+
+  temporal-postgres:
+    image: postgres:17.2-alpine
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: ${TEMPORAL_POSTGRES_USER}
+      POSTGRES_PASSWORD: ${TEMPORAL_POSTGRES_PASSWORD}
+      POSTGRES_DB: ${TEMPORAL_POSTGRES_DATABASE}
+    volumes:
+      - ${FASTAD_DATA_DIR:-./data}/temporal-db:/var/lib/postgresql/data
+    healthcheck:
+      test: pg_isready -U temporal -d temporal
+      interval: 5s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+
+  victoriametrics:
+    image: victoriametrics/victoria-metrics:v1.108.1
+    restart: unless-stopped
+    command:
+      - "-storageDataPath=/storage"
+      - "-retentionPeriod=30d"
+      - "-promscrape.config=/etc/victoriametrics/scrape.yml"
+    volumes:
+      - ${FASTAD_DATA_DIR:-./data}/victoriametrics:/storage
+      - ./docker/presets/production/victoriametrics:/etc/victoriametrics:ro
+    healthcheck:
+      test: ['CMD', 'wget', '-qO-', 'http://127.0.0.1:8428/-/healthy']
+      interval: 5s
+      timeout: 3s
+      retries: 10
+      start_period: 10s
+
+  grafana:
+    image: grafana/grafana:11.4.0
+    restart: unless-stopped
+    ports:
+      - "${GRAFANA_PORT:-3030}:3000"
+    environment:
+      GF_SECURITY_ADMIN_USER: ${GRAFANA_ADMIN_USER:-admin}
+      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD:-fastad}
+      GF_USERS_ALLOW_SIGN_UP: "false"
+      GF_AUTH_ANONYMOUS_ENABLED: "false"
+    volumes:
+      - grafana-data:/var/lib/grafana
+      - ./docker/presets/production/grafana/provisioning:/etc/grafana/provisioning:ro
+      - ./docker/presets/production/grafana/dashboards:/var/lib/grafana/dashboards:ro
+    depends_on:
+      victoriametrics:
+        condition: service_healthy
+
+volumes:
+  caddy-data:
+  caddy-config:
+  grafana-data:
diff --git a/docker/presets/production/grafana/dashboards/checkers.json b/docker/presets/production/grafana/dashboards/checkers.json
new file mode 100644
index 0000000..797a974
--- /dev/null
+++ b/docker/presets/production/grafana/dashboards/checkers.json
@@ -0,0 +1,438 @@
+{
+  "annotations": {
+    "list": []
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 1,
+  "id": null,
+  "links": [],
+  "panels": [
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "normal"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".*STATUS_UP.*"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "green",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".*STATUS_DOWN.*"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "red",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".*STATUS_MUMBLE.*"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "orange",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".*STATUS_CORRUPT.*"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "purple",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "options": {
+        "legend": {
+          "calcs": ["sum"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(fastad_checker_execution_status_total[1m])) by (status)",
+          "legendFormat": "{{status}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Checker Execution Status (rate/min)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "normal"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 2,
+      "options": {
+        "legend": {
+          "calcs": ["sum"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(fastad_checker_executions_total[1m])) by (action)",
+          "legendFormat": "{{action}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Checker Executions by Action (rate/min)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 8
+      },
+      "id": 3,
+      "options": {
+        "legend": {
+          "calcs": ["sum"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(fastad_checker_executions_total[1m])) by (service_id)",
+          "legendFormat": "service {{service_id}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Checker Executions by Service (rate/min)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "#EAB839",
+                "value": 0.8
+              },
+              {
+                "color": "red",
+                "value": 0.5
+              }
+            ]
+          },
+          "unit": "percentunit"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 8
+      },
+      "id": 4,
+      "options": {
+        "minVizHeight": 75,
+        "minVizWidth": 75,
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": ["lastNotNull"],
+          "fields": "",
+          "values": false
+        },
+        "showThresholdLabels": false,
+        "showThresholdMarkers": true,
+        "sizing": "auto"
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(fastad_checker_execution_status_total{status=\"STATUS_UP\"}[5m])) by (service_id) / sum(rate(fastad_checker_execution_status_total[5m])) by (service_id)",
+          "legendFormat": "service {{service_id}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Service Availability (UP ratio)",
+      "type": "gauge"
+    }
+  ],
+  "refresh": "10s",
+  "schemaVersion": 39,
+  "tags": ["fastad", "checkers"],
+  "templating": {
+    "list": [
+      {
+        "current": {
+          "selected": false,
+          "text": "VictoriaMetrics",
+          "value": "VictoriaMetrics"
+        },
+        "hide": 0,
+        "includeAll": false,
+        "label": "Datasource",
+        "multi": false,
+        "name": "datasource",
+        "options": [],
+        "query": "prometheus",
+        "queryValue": "",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "type": "datasource"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-1h",
+    "to": "now"
+  },
+  "timepicker": {},
+  "timezone": "browser",
+  "title": "FastAD Checkers",
+  "uid": "fastad-checkers",
+  "version": 1
+}
diff --git a/docker/presets/production/grafana/dashboards/flags.json b/docker/presets/production/grafana/dashboards/flags.json
new file mode 100644
index 0000000..173efbe
--- /dev/null
+++ b/docker/presets/production/grafana/dashboards/flags.json
@@ -0,0 +1,932 @@
+{
+  "annotations": {
+    "list": []
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 1,
+  "id": null,
+  "links": [],
+  "panels": [
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "normal"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "options": {
+        "legend": {
+          "calcs": ["sum"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(fastad_flags_processed_total[1m])) by (verdict)",
+          "legendFormat": "{{verdict}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Flags Processed by Verdict (rate/min)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 2,
+      "options": {
+        "legend": {
+          "calcs": ["sum"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(fastad_attacks_by_attacker_total[1m])) by (service_name)",
+          "legendFormat": "{{service_name}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Successful Attacks by Service (rate/min)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 8
+      },
+      "id": 3,
+      "options": {
+        "legend": {
+          "calcs": ["sum"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true,
+          "sortBy": "Total",
+          "sortDesc": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(fastad_flags_submitted_total[1m])) by (team_name)",
+          "legendFormat": "{{team_name}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Flag Submissions by Team (rate/min)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "s"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 8
+      },
+      "id": 4,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "max"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "histogram_quantile(0.50, sum(rate(fastad_flag_processing_seconds_bucket[5m])) by (le, verdict_summary))",
+          "legendFormat": "p50 {{verdict_summary}}",
+          "refId": "A"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "histogram_quantile(0.95, sum(rate(fastad_flag_processing_seconds_bucket[5m])) by (le, verdict_summary))",
+          "legendFormat": "p95 {{verdict_summary}}",
+          "refId": "B"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "histogram_quantile(0.99, sum(rate(fastad_flag_processing_seconds_bucket[5m])) by (le, verdict_summary))",
+          "legendFormat": "p99 {{verdict_summary}}",
+          "refId": "C"
+        }
+      ],
+      "title": "Flag Processing Latency",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 24,
+        "x": 0,
+        "y": 16
+      },
+      "id": 5,
+      "options": {
+        "legend": {
+          "calcs": ["sum"],
+          "displayMode": "table",
+          "placement": "right",
+          "showLegend": true,
+          "sortBy": "Total",
+          "sortDesc": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(increase(fastad_points_transferred_total[5m])) by (service_name)",
+          "legendFormat": "{{service_name}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Points Transferred by Service (5m window)",
+      "type": "timeseries"
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 24
+      },
+      "id": 10,
+      "panels": [],
+      "title": "Detailed Attack Analysis",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "yellow",
+                "value": 50
+              },
+              {
+                "color": "red",
+                "value": 100
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 25
+      },
+      "id": 6,
+      "options": {
+        "displayMode": "gradient",
+        "maxVizHeight": 300,
+        "minVizHeight": 16,
+        "minVizWidth": 8,
+        "namePlacement": "auto",
+        "orientation": "horizontal",
+        "reduceOptions": {
+          "calcs": ["lastNotNull"],
+          "fields": "",
+          "values": false
+        },
+        "showUnfilled": true,
+        "sizing": "auto",
+        "valueMode": "color"
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "topk(10, sum by (attacker_name) (increase(fastad_flag_verdicts_detailed_total{verdict=\"VERDICT_ACCEPTED\", attacker_name=~\"$attacker\", victim_name=~\"$victim\", service_name=~\"$service\"}[$__range])))",
+          "format": "time_series",
+          "instant": true,
+          "legendFormat": "{{attacker_name}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Top 10 Attackers (Successful Attacks)",
+      "type": "bargauge"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "yellow",
+                "value": 50
+              },
+              {
+                "color": "red",
+                "value": 100
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 25
+      },
+      "id": 7,
+      "options": {
+        "displayMode": "gradient",
+        "maxVizHeight": 300,
+        "minVizHeight": 16,
+        "minVizWidth": 8,
+        "namePlacement": "auto",
+        "orientation": "horizontal",
+        "reduceOptions": {
+          "calcs": ["lastNotNull"],
+          "fields": "",
+          "values": false
+        },
+        "showUnfilled": true,
+        "sizing": "auto",
+        "valueMode": "color"
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "topk(10, sum by (victim_name) (increase(fastad_flag_verdicts_detailed_total{verdict=\"VERDICT_ACCEPTED\", attacker_name=~\"$attacker\", victim_name=~\"$victim\", service_name=~\"$service\"}[$__range])))",
+          "format": "time_series",
+          "instant": true,
+          "legendFormat": "{{victim_name}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Top 10 Victims (Attacks Received)",
+      "type": "bargauge"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "custom": {
+            "align": "auto",
+            "cellOptions": {
+              "type": "color-background"
+            },
+            "inspect": false
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "transparent",
+                "value": null
+              },
+              {
+                "color": "green",
+                "value": 1
+              },
+              {
+                "color": "yellow",
+                "value": 10
+              },
+              {
+                "color": "orange",
+                "value": 50
+              },
+              {
+                "color": "red",
+                "value": 100
+              }
+            ]
+          }
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "attacker_name"
+            },
+            "properties": [
+              {
+                "id": "custom.cellOptions",
+                "value": {
+                  "type": "auto"
+                }
+              },
+              {
+                "id": "custom.width",
+                "value": 150
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "victim_name"
+            },
+            "properties": [
+              {
+                "id": "custom.cellOptions",
+                "value": {
+                  "type": "auto"
+                }
+              },
+              {
+                "id": "custom.width",
+                "value": 150
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "service_name"
+            },
+            "properties": [
+              {
+                "id": "custom.cellOptions",
+                "value": {
+                  "type": "auto"
+                }
+              },
+              {
+                "id": "custom.width",
+                "value": 120
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 12,
+        "w": 24,
+        "x": 0,
+        "y": 33
+      },
+      "id": 8,
+      "options": {
+        "cellHeight": "sm",
+        "footer": {
+          "countRows": false,
+          "fields": "",
+          "reducer": ["sum"],
+          "show": false
+        },
+        "showHeader": true,
+        "sortBy": [
+          {
+            "desc": true,
+            "displayName": "Value"
+          }
+        ]
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum by (attacker_name, victim_name, service_name) (increase(fastad_flag_verdicts_detailed_total{verdict=\"VERDICT_ACCEPTED\", attacker_name=~\"$attacker\", victim_name=~\"$victim\", service_name=~\"$service\"}[$__range]))",
+          "format": "table",
+          "instant": true,
+          "legendFormat": "",
+          "refId": "A"
+        }
+      ],
+      "title": "Attack Matrix (Attacker → Victim by Service)",
+      "transformations": [
+        {
+          "id": "organize",
+          "options": {
+            "excludeByName": {
+              "Time": true
+            },
+            "indexByName": {
+              "Time": 0,
+              "Value": 4,
+              "attacker_name": 1,
+              "service_name": 3,
+              "victim_name": 2
+            },
+            "renameByName": {
+              "Value": "Attacks",
+              "attacker_name": "Attacker",
+              "service_name": "Service",
+              "victim_name": "Victim"
+            }
+          }
+        },
+        {
+          "id": "filterByValue",
+          "options": {
+            "filters": [
+              {
+                "config": {
+                  "id": "greater",
+                  "options": {
+                    "value": 0
+                  }
+                },
+                "fieldName": "Attacks"
+              }
+            ],
+            "match": "any",
+            "type": "include"
+          }
+        }
+      ],
+      "type": "table"
+    }
+  ],
+  "refresh": "10s",
+  "schemaVersion": 39,
+  "tags": ["fastad", "flags"],
+  "templating": {
+    "list": [
+      {
+        "current": {
+          "selected": false,
+          "text": "VictoriaMetrics",
+          "value": "VictoriaMetrics"
+        },
+        "hide": 0,
+        "includeAll": false,
+        "label": "Datasource",
+        "multi": false,
+        "name": "datasource",
+        "options": [],
+        "query": "prometheus",
+        "queryValue": "",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "type": "datasource"
+      },
+      {
+        "allValue": ".*",
+        "current": {
+          "selected": true,
+          "text": ["All"],
+          "value": ["$__all"]
+        },
+        "datasource": {
+          "type": "prometheus",
+          "uid": "${datasource}"
+        },
+        "definition": "label_values(fastad_flag_verdicts_detailed_total, attacker_name)",
+        "hide": 0,
+        "includeAll": true,
+        "label": "Attacker",
+        "multi": true,
+        "name": "attacker",
+        "options": [],
+        "query": {
+          "qryType": 1,
+          "query": "label_values(fastad_flag_verdicts_detailed_total, attacker_name)",
+          "refId": "PrometheusVariableQueryEditor-VariableQuery"
+        },
+        "refresh": 2,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 1,
+        "type": "query"
+      },
+      {
+        "allValue": ".*",
+        "current": {
+          "selected": true,
+          "text": ["All"],
+          "value": ["$__all"]
+        },
+        "datasource": {
+          "type": "prometheus",
+          "uid": "${datasource}"
+        },
+        "definition": "label_values(fastad_flag_verdicts_detailed_total, victim_name)",
+        "hide": 0,
+        "includeAll": true,
+        "label": "Victim",
+        "multi": true,
+        "name": "victim",
+        "options": [],
+        "query": {
+          "qryType": 1,
+          "query": "label_values(fastad_flag_verdicts_detailed_total, victim_name)",
+          "refId": "PrometheusVariableQueryEditor-VariableQuery"
+        },
+        "refresh": 2,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 1,
+        "type": "query"
+      },
+      {
+        "allValue": ".*",
+        "current": {
+          "selected": true,
+          "text": ["All"],
+          "value": ["$__all"]
+        },
+        "datasource": {
+          "type": "prometheus",
+          "uid": "${datasource}"
+        },
+        "definition": "label_values(fastad_flag_verdicts_detailed_total, service_name)",
+        "hide": 0,
+        "includeAll": true,
+        "label": "Service",
+        "multi": true,
+        "name": "service",
+        "options": [],
+        "query": {
+          "qryType": 1,
+          "query": "label_values(fastad_flag_verdicts_detailed_total, service_name)",
+          "refId": "PrometheusVariableQueryEditor-VariableQuery"
+        },
+        "refresh": 2,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 1,
+        "type": "query"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-1h",
+    "to": "now"
+  },
+  "timepicker": {},
+  "timezone": "browser",
+  "title": "FastAD Flag Submissions",
+  "uid": "fastad-flags",
+  "version": 1
+}
diff --git a/docker/presets/production/grafana/dashboards/overview.json b/docker/presets/production/grafana/dashboards/overview.json
new file mode 100644
index 0000000..7f3f322
--- /dev/null
+++ b/docker/presets/production/grafana/dashboards/overview.json
@@ -0,0 +1,460 @@
+{
+  "annotations": {
+    "list": []
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 1,
+  "id": null,
+  "links": [],
+  "panels": [
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "reqps"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "lastNotNull"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(http_requests_total[1m])) by (url)",
+          "legendFormat": "{{url}}",
+          "refId": "A"
+        }
+      ],
+      "title": "HTTP Request Rate by URL",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "s"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 2,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "max"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, url))",
+          "legendFormat": "p95 {{url}}",
+          "refId": "A"
+        }
+      ],
+      "title": "HTTP Latency p95 by URL",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "reqps"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 8
+      },
+      "id": 3,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "lastNotNull"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(rate(grpc_server_handled_total[1m])) by (grpc_service, grpc_method)",
+          "legendFormat": "{{grpc_service}}/{{grpc_method}}",
+          "refId": "A"
+        }
+      ],
+      "title": "gRPC Request Rate",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          },
+          "unit": "s"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 8
+      },
+      "id": 4,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "max"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "histogram_quantile(0.95, sum(rate(grpc_server_handling_seconds_bucket[5m])) by (le, grpc_service, grpc_method))",
+          "legendFormat": "p95 {{grpc_service}}/{{grpc_method}}",
+          "refId": "A"
+        }
+      ],
+      "title": "gRPC Latency p95",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${datasource}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 1
+              }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 6,
+        "x": 0,
+        "y": 16
+      },
+      "id": 6,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": ["lastNotNull"],
+          "fields": "",
+          "values": false
+        },
+        "textMode": "auto"
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${datasource}"
+          },
+          "expr": "sum(grpc_server_panics_recovered_total)",
+          "legendFormat": "",
+          "refId": "A"
+        }
+      ],
+      "title": "gRPC Panics Total",
+      "type": "stat"
+    }
+  ],
+  "refresh": "10s",
+  "schemaVersion": 39,
+  "tags": ["fastad"],
+  "templating": {
+    "list": [
+      {
+        "current": {
+          "selected": false,
+          "text": "VictoriaMetrics",
+          "value": "VictoriaMetrics"
+        },
+        "hide": 0,
+        "includeAll": false,
+        "label": "Datasource",
+        "multi": false,
+        "name": "datasource",
+        "options": [],
+        "query": "prometheus",
+        "queryValue": "",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "type": "datasource"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-1h",
+    "to": "now"
+  },
+  "timepicker": {},
+  "timezone": "browser",
+  "title": "FastAD Overview",
+  "uid": "fastad-overview",
+  "version": 1
+}
diff --git a/docker/presets/production/grafana/provisioning/dashboards/default.yml b/docker/presets/production/grafana/provisioning/dashboards/default.yml
new file mode 100644
index 0000000..96a4ca6
--- /dev/null
+++ b/docker/presets/production/grafana/provisioning/dashboards/default.yml
@@ -0,0 +1,13 @@
+apiVersion: 1
+
+providers:
+  - name: 'FastAD Dashboards'
+    orgId: 1
+    folder: 'FastAD'
+    folderUid: 'fastad'
+    type: file
+    disableDeletion: false
+    updateIntervalSeconds: 30
+    allowUiUpdates: true
+    options:
+      path: /var/lib/grafana/dashboards
diff --git a/docker/presets/production/grafana/provisioning/datasources/victoriametrics.yml b/docker/presets/production/grafana/provisioning/datasources/victoriametrics.yml
new file mode 100644
index 0000000..9c578b5
--- /dev/null
+++ b/docker/presets/production/grafana/provisioning/datasources/victoriametrics.yml
@@ -0,0 +1,9 @@
+apiVersion: 1
+
+datasources:
+  - name: VictoriaMetrics
+    type: prometheus
+    access: proxy
+    url: http://victoriametrics:8428
+    isDefault: true
+    editable: false
diff --git a/docker/presets/production/service.Dockerfile b/docker/presets/production/service.Dockerfile
new file mode 100644
index 0000000..7b20e76
--- /dev/null
+++ b/docker/presets/production/service.Dockerfile
@@ -0,0 +1,31 @@
+FROM golang:1.25-alpine AS builder
+
+ARG SERVICE_NAME
+ENV CGO_ENABLED=0
+
+RUN apk add --no-cache upx
+
+WORKDIR /app
+
+COPY cmd cmd
+COPY pkg pkg
+COPY internal internal
+COPY go.* ./
+
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+        go build \
+            -trimpath \
+            -ldflags="-w -s" \
+            -o "/service" \
+            "./cmd/${SERVICE_NAME}/main.go"
+
+ARG COMPRESS_BINARIES="false"
+ENV COMPRESS_BINARIES=$COMPRESS_BINARIES
+RUN if [ "${COMPRESS_BINARIES}" = "true" ]; then upx --lzma -9 "/service"; fi
+
+FROM alpine:3.21
+
+COPY --from=builder /service /service
+
+CMD ["/service"]
diff --git a/docker/presets/production/victoriametrics/scrape.yml b/docker/presets/production/victoriametrics/scrape.yml
new file mode 100644
index 0000000..00c244c
--- /dev/null
+++ b/docker/presets/production/victoriametrics/scrape.yml
@@ -0,0 +1,28 @@
+global:
+  scrape_interval: 15s
+  scrape_timeout: 10s
+
+scrape_configs:
+  - job_name: 'api'
+    static_configs:
+      - targets: ['api:3001']
+
+  - job_name: 'receiver'
+    static_configs:
+      - targets: ['receiver:3002']
+
+  - job_name: 'slac'
+    static_configs:
+      - targets: ['slac:3003']
+
+  - job_name: 'dataservice'
+    static_configs:
+      - targets: ['dataservice:3004']
+
+  - job_name: 'scheduler'
+    static_configs:
+      - targets: ['scheduler:3005']
+
+  - job_name: 'checkers'
+    static_configs:
+      - targets: ['checkers:3006']
diff --git a/docker/presets/simple/Caddyfile b/docker/presets/simple/Caddyfile
new file mode 100644
index 0000000..95d3749
--- /dev/null
+++ b/docker/presets/simple/Caddyfile
@@ -0,0 +1,44 @@
+{
+    servers :80 {
+        protocols h1 h2 h2c
+    }
+}
+
+:80 {
+    log {
+    	output stderr
+    	level DEBUG
+    	format console
+    }
+
+    handle /temporal* {
+        reverse_proxy temporal-ui:8080
+    }
+
+    handle /api/* {
+        reverse_proxy app:8080
+    }
+
+    handle /centrifuge/* {
+        reverse_proxy app:8080
+    }
+
+    handle /healthcheck {
+        reverse_proxy app:8080
+    }
+
+    handle /flags {
+        reverse_proxy app:8080
+    }
+
+    handle /data.* {
+       reverse_proxy h2c://app:8004
+    }
+
+    handle {
+        encode gzip
+        root * /front
+        try_files {path} /index.html
+        file_server
+    }
+}
diff --git a/docker/presets/simple/app.Dockerfile b/docker/presets/simple/app.Dockerfile
new file mode 100644
index 0000000..b4b6b97
--- /dev/null
+++ b/docker/presets/simple/app.Dockerfile
@@ -0,0 +1,52 @@
+FROM golang:1.25-alpine AS builder
+
+ENV CGO_ENABLED=0
+
+RUN apk add --no-cache upx
+
+WORKDIR /app
+
+COPY cmd cmd
+COPY pkg pkg
+COPY internal internal
+COPY go.* ./
+
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+        go build \
+            -trimpath \
+            -ldflags="-w -s" \
+            -o "/allinone" \
+            "./cmd/allinone/main.go"
+
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+        go build \
+            -trimpath \
+            -ldflags="-w -s" \
+            -o "/migrator" \
+            "./cmd/migrator/main.go"
+
+ARG COMPRESS_BINARIES="false"
+ENV COMPRESS_BINARIES=$COMPRESS_BINARIES
+RUN if [ "${COMPRESS_BINARIES}" = "true" ]; then upx --lzma -9 "/allinone" && upx --lzma -9 "/migrator"; fi
+
+FROM python:3.12-bookworm
+
+ENV PWNLIB_NOTERM=true
+ENV UV_BREAK_SYSTEM_PACKAGES=true
+ENV PIP_BREAK_SYSTEM_PACKAGES=true
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/
+
+ARG CHECKERS_DIR
+COPY ${CHECKERS_DIR} /checkers
+RUN --mount=type=cache,target=/root/.cache/uv \
+    find /checkers -name "requirements.txt" | while read -r file; do \
+      echo "Installing requirements from ${file}"; uv pip install --system -r "$file"; \
+    done
+
+COPY --from=builder /allinone /allinone
+COPY --from=builder /migrator /migrator
+
+CMD ["/bin/sh", "-c", "/migrator init && /migrator migrate && /allinone"]
diff --git a/docker/presets/simple/caddy.Dockerfile b/docker/presets/simple/caddy.Dockerfile
new file mode 100644
index 0000000..8991d24
--- /dev/null
+++ b/docker/presets/simple/caddy.Dockerfile
@@ -0,0 +1,16 @@
+FROM node:22.14.0-alpine AS front-base
+
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+
+COPY front /app
+WORKDIR /app
+RUN corepack enable
+
+FROM front-base AS front-build
+RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile
+RUN pnpm run build
+
+FROM caddy:2.9.1-alpine
+
+COPY --from=front-build /app/dist /front
diff --git a/docker/presets/simple/compose.yml b/docker/presets/simple/compose.yml
new file mode 100644
index 0000000..9c4ad72
--- /dev/null
+++ b/docker/presets/simple/compose.yml
@@ -0,0 +1,143 @@
+services:
+  app:
+    build:
+      context: .
+      dockerfile: ./docker/presets/simple/app.Dockerfile
+    restart: unless-stopped
+    environment:
+      FASTAD_ALLINONE_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_MIGRATOR_POSTGRES_DSN: ${FASTAD_POSTGRES_DSN}
+      FASTAD_ALLINONE_INTERCOM_TOKEN: ${FASTAD_INTERCOM_TOKEN}
+      FASTAD_ALLINONE_TEMPORAL_ADDRESS: "temporal:7233"
+      FASTAD_ALLINONE_API_LISTEN_ADDRESS: ":8080"
+      FASTAD_LOG_LEVEL: ${FASTAD_LOG_LEVEL}
+    depends_on:
+      temporal-create-namespace:
+        condition: service_completed_successfully
+      postgres:
+        condition: service_healthy
+    healthcheck:
+      test: ['CMD-SHELL', 'wget -qO- http://localhost:8080/healthcheck || exit 1']
+      interval: 5s
+      timeout: 5s
+      retries: 10
+      start_period: 30s
+
+  caddy:
+    build:
+      context: .
+      dockerfile: ./docker/presets/simple/caddy.Dockerfile
+    restart: unless-stopped
+    ports:
+      - "${CADDY_PORT}:80"
+    volumes:
+      - ./docker/presets/simple/Caddyfile:/etc/caddy/Caddyfile:ro
+      - caddy-data:/data
+      - caddy-config:/config
+    depends_on:
+      app:
+        condition: service_healthy
+
+  temporal-admin-tools:
+    image: temporalio/admin-tools:1.26.2
+    restart: on-failure:6
+    depends_on:
+      temporal-postgres:
+        condition: service_healthy
+    environment:
+      DB: postgres12
+      DB_PORT: ${TEMPORAL_POSTGRES_PORT}
+      POSTGRES_USER: ${TEMPORAL_POSTGRES_USER}
+      POSTGRES_PWD: ${TEMPORAL_POSTGRES_PASSWORD}
+      POSTGRES_SEEDS: ${TEMPORAL_POSTGRES_HOST}
+      SQL_PASSWORD: ${TEMPORAL_POSTGRES_PASSWORD}
+    volumes:
+      - ./docker/presets/simple/temporal-scripts:/scripts:ro
+    entrypoint: ["/bin/sh"]
+    command: /scripts/setup-postgres.sh
+
+  temporal:
+    image: temporalio/server:1.26.2
+    restart: unless-stopped
+    environment:
+      DB: postgres12
+      DB_PORT: ${TEMPORAL_POSTGRES_PORT}
+      POSTGRES_USER: ${TEMPORAL_POSTGRES_USER}
+      POSTGRES_PWD: ${TEMPORAL_POSTGRES_PASSWORD}
+      POSTGRES_SEEDS: ${TEMPORAL_POSTGRES_HOST}
+      BIND_ON_IP: "0.0.0.0"
+      DYNAMIC_CONFIG_FILE_PATH: config/dynamicconfig/development-sql.yaml
+    depends_on:
+      temporal-admin-tools:
+        condition: service_completed_successfully
+    volumes:
+      - ./docker/presets/simple/temporal-dynamicconfig:/etc/temporal/config/dynamicconfig:ro
+    healthcheck:
+      test: ['CMD', 'nc', '-z', 'localhost', '7233']
+      interval: 5s
+      timeout: 3s
+      retries: 60
+      start_period: 30s
+
+  temporal-create-namespace:
+    image: temporalio/admin-tools:1.26.2
+    restart: on-failure:5
+    depends_on:
+      temporal:
+        condition: service_healthy
+    environment:
+      TEMPORAL_ADDRESS: temporal:7233
+      DEFAULT_NAMESPACE: default
+    volumes:
+      - ./docker/presets/simple/temporal-scripts:/scripts:ro
+    entrypoint: ["/bin/sh"]
+    command: /scripts/create-namespace.sh
+
+  temporal-ui:
+    image: temporalio/ui:2.33.0
+    restart: unless-stopped
+    environment:
+      - TEMPORAL_ADDRESS=temporal:7233
+      - TEMPORAL_UI_PORT=8080
+      - TEMPORAL_UI_PUBLIC_PATH=/temporal
+    depends_on:
+      temporal:
+        condition: service_healthy
+
+  postgres:
+    image: postgres:17.2-alpine
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:${FASTAD_POSTGRES_EXTERNAL_PORT:-5433}:5432"
+    environment:
+      POSTGRES_USER: fastad
+      POSTGRES_PASSWORD: fastad
+      POSTGRES_DB: fastad
+    volumes:
+      - ${FASTAD_DATA_DIR:-./data}/fastad-db:/var/lib/postgresql/data
+    healthcheck:
+      test: pg_isready -U fastad -d fastad
+      interval: 5s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+
+  temporal-postgres:
+    image: postgres:17.2-alpine
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: ${TEMPORAL_POSTGRES_USER}
+      POSTGRES_PASSWORD: ${TEMPORAL_POSTGRES_PASSWORD}
+      POSTGRES_DB: ${TEMPORAL_POSTGRES_DATABASE}
+    volumes:
+      - ${FASTAD_DATA_DIR:-./data}/temporal-db:/var/lib/postgresql/data
+    healthcheck:
+      test: pg_isready -U temporal -d temporal
+      interval: 5s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+
+volumes:
+  caddy-data:
+  caddy-config:
diff --git a/docker/presets/simple/temporal-dynamicconfig/development-sql.yaml b/docker/presets/simple/temporal-dynamicconfig/development-sql.yaml
new file mode 100644
index 0000000..8862dfa
--- /dev/null
+++ b/docker/presets/simple/temporal-dynamicconfig/development-sql.yaml
@@ -0,0 +1,6 @@
+limit.maxIDLength:
+  - value: 255
+    constraints: {}
+system.forceSearchAttributesCacheRefreshOnRead:
+  - value: true # Dev setup only. Please don't turn this on in production.
+    constraints: {}
diff --git a/docker/presets/simple/temporal-scripts/create-namespace.sh b/docker/presets/simple/temporal-scripts/create-namespace.sh
new file mode 100755
index 0000000..45334f0
--- /dev/null
+++ b/docker/presets/simple/temporal-scripts/create-namespace.sh
@@ -0,0 +1,27 @@
+#!/bin/sh
+set -eu
+
+NAMESPACE=${DEFAULT_NAMESPACE:-default}
+TEMPORAL_ADDRESS=${TEMPORAL_ADDRESS:-temporal:7233}
+
+echo "Waiting for Temporal server port to be available..."
+nc -z -w 10 $(echo $TEMPORAL_ADDRESS | cut -d: -f1) $(echo $TEMPORAL_ADDRESS | cut -d: -f2)
+echo 'Temporal server port is available'
+
+echo 'Waiting for Temporal server to be healthy...'
+max_attempts=3
+attempt=0
+
+until temporal operator cluster health --address $TEMPORAL_ADDRESS; do
+  attempt=$((attempt + 1))
+  if [ $attempt -ge $max_attempts ]; then
+    echo "Server did not become healthy after $max_attempts attempts"
+    exit 1
+  fi
+  echo "Server not ready yet, waiting... (attempt $attempt/$max_attempts)"
+  sleep 5
+done
+
+echo "Server is healthy, creating namespace '$NAMESPACE'..."
+temporal operator namespace describe -n $NAMESPACE --address $TEMPORAL_ADDRESS || temporal operator namespace create -n $NAMESPACE --address $TEMPORAL_ADDRESS
+echo "Namespace '$NAMESPACE' created"
diff --git a/docker/presets/simple/temporal-scripts/setup-postgres.sh b/docker/presets/simple/temporal-scripts/setup-postgres.sh
new file mode 100755
index 0000000..4c6f8ca
--- /dev/null
+++ b/docker/presets/simple/temporal-scripts/setup-postgres.sh
@@ -0,0 +1,33 @@
+#!/bin/sh
+set -eu
+
+echo 'Starting PostgreSQL schema setup for Temporal...'
+echo 'Waiting for PostgreSQL port to be available...'
+
+# Wait for postgres to be reachable
+max_attempts=30
+attempt=0
+until nc -z -w 5 ${POSTGRES_SEEDS} ${DB_PORT}; do
+  attempt=$((attempt + 1))
+  if [ $attempt -ge $max_attempts ]; then
+    echo "PostgreSQL did not become available after $max_attempts attempts"
+    exit 1
+  fi
+  echo "Waiting for PostgreSQL... (attempt $attempt/$max_attempts)"
+  sleep 2
+done
+echo 'PostgreSQL port is available'
+
+# Create and setup temporal database
+echo 'Creating temporal database...'
+temporal-sql-tool --plugin postgres12 --ep ${POSTGRES_SEEDS} -u ${POSTGRES_USER} -p ${DB_PORT} --db temporal create || echo 'Database temporal may already exist'
+temporal-sql-tool --plugin postgres12 --ep ${POSTGRES_SEEDS} -u ${POSTGRES_USER} -p ${DB_PORT} --db temporal setup-schema -v 0.0
+temporal-sql-tool --plugin postgres12 --ep ${POSTGRES_SEEDS} -u ${POSTGRES_USER} -p ${DB_PORT} --db temporal update-schema -d /etc/temporal/schema/postgresql/v12/temporal/versioned
+
+# Create and setup visibility database
+echo 'Creating temporal_visibility database...'
+temporal-sql-tool --plugin postgres12 --ep ${POSTGRES_SEEDS} -u ${POSTGRES_USER} -p ${DB_PORT} --db temporal_visibility create || echo 'Database temporal_visibility may already exist'
+temporal-sql-tool --plugin postgres12 --ep ${POSTGRES_SEEDS} -u ${POSTGRES_USER} -p ${DB_PORT} --db temporal_visibility setup-schema -v 0.0
+temporal-sql-tool --plugin postgres12 --ep ${POSTGRES_SEEDS} -u ${POSTGRES_USER} -p ${DB_PORT} --db temporal_visibility update-schema -d /etc/temporal/schema/postgresql/v12/visibility/versioned
+
+echo 'PostgreSQL schema setup complete'
diff --git a/docs/index.html b/docs/index.html
new file mode 100644
index 0000000..a942ea8
--- /dev/null
+++ b/docs/index.html
@@ -0,0 +1,699 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FastAD Rating Formula Visualizer</title>
+    <script src="https://d3js.org/d3.v7.min.js"></script>
+    <style>
+        :root {
+            --bg-primary: #0d1117;
+            --bg-secondary: #161b22;
+            --bg-tertiary: #21262d;
+            --text-primary: #f0f6fc;
+            --text-secondary: #8b949e;
+            --accent: #58a6ff;
+            --accent-hover: #79c0ff;
+            --border: #30363d;
+            --success: #3fb950;
+            --warning: #d29922;
+            --danger: #f85149;
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Noto Sans', Helvetica, Arial, sans-serif;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            min-height: 100vh;
+            line-height: 1.5;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 2rem;
+        }
+
+        header {
+            text-align: center;
+            margin-bottom: 2rem;
+            padding-bottom: 1.5rem;
+            border-bottom: 1px solid var(--border);
+        }
+
+        h1 {
+            font-size: 2rem;
+            font-weight: 600;
+            margin-bottom: 0.5rem;
+            background: linear-gradient(135deg, var(--accent), var(--success));
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+
+        .subtitle {
+            color: var(--text-secondary);
+            font-size: 1rem;
+        }
+
+        .main-content {
+            display: grid;
+            grid-template-columns: 1fr 300px;
+            gap: 2rem;
+            align-items: start;
+        }
+
+        @media (max-width: 900px) {
+            .main-content {
+                grid-template-columns: 1fr;
+            }
+        }
+
+        .chart-container {
+            background: var(--bg-secondary);
+            border-radius: 12px;
+            padding: 1.5rem;
+            border: 1px solid var(--border);
+        }
+
+        .chart-title {
+            font-size: 1.1rem;
+            font-weight: 600;
+            margin-bottom: 1rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .chart-title::before {
+            content: '';
+            width: 4px;
+            height: 1.2em;
+            background: var(--accent);
+            border-radius: 2px;
+        }
+
+        #heatmap {
+            width: 100%;
+            display: flex;
+            justify-content: center;
+        }
+
+        .controls-panel {
+            background: var(--bg-secondary);
+            border-radius: 12px;
+            padding: 1.5rem;
+            border: 1px solid var(--border);
+            position: sticky;
+            top: 1rem;
+        }
+
+        .controls-title {
+            font-size: 1.1rem;
+            font-weight: 600;
+            margin-bottom: 1.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .controls-title::before {
+            content: '';
+            width: 4px;
+            height: 1.2em;
+            background: var(--success);
+            border-radius: 2px;
+        }
+
+        .control-group {
+            margin-bottom: 1.5rem;
+        }
+
+        .control-group:last-child {
+            margin-bottom: 0;
+        }
+
+        .control-label {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 0.5rem;
+            font-size: 0.875rem;
+            font-weight: 500;
+        }
+
+        .control-label span:first-child {
+            color: var(--text-secondary);
+        }
+
+        .slider-container {
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+        }
+
+        input[type="range"] {
+            flex: 1;
+            height: 6px;
+            -webkit-appearance: none;
+            appearance: none;
+            background: var(--bg-tertiary);
+            border-radius: 3px;
+            outline: none;
+        }
+
+        input[type="range"]::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            appearance: none;
+            width: 18px;
+            height: 18px;
+            border-radius: 50%;
+            background: var(--accent);
+            cursor: pointer;
+            border: 2px solid var(--bg-secondary);
+            transition: transform 0.15s ease, box-shadow 0.15s ease;
+        }
+
+        input[type="range"]::-webkit-slider-thumb:hover {
+            transform: scale(1.1);
+            box-shadow: 0 0 0 4px rgba(88, 166, 255, 0.2);
+        }
+
+        input[type="range"]::-moz-range-thumb {
+            width: 18px;
+            height: 18px;
+            border-radius: 50%;
+            background: var(--accent);
+            cursor: pointer;
+            border: 2px solid var(--bg-secondary);
+        }
+
+        input[type="number"] {
+            width: 80px;
+            padding: 0.4rem 0.6rem;
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            background: var(--bg-tertiary);
+            color: var(--text-primary);
+            font-size: 0.875rem;
+            text-align: right;
+            outline: none;
+            transition: border-color 0.2s ease, box-shadow 0.2s ease;
+        }
+
+        input[type="number"]:focus {
+            border-color: var(--accent);
+            box-shadow: 0 0 0 3px rgba(88, 166, 255, 0.15);
+        }
+
+        input[type="number"]::-webkit-inner-spin-button,
+        input[type="number"]::-webkit-outer-spin-button {
+            -webkit-appearance: none;
+            margin: 0;
+        }
+
+        input[type="number"] {
+            -moz-appearance: textfield;
+        }
+
+        .formula-section {
+            margin-top: 2rem;
+            background: var(--bg-secondary);
+            border-radius: 12px;
+            padding: 1.5rem;
+            border: 1px solid var(--border);
+        }
+
+        .formula-title {
+            font-size: 1.1rem;
+            font-weight: 600;
+            margin-bottom: 1rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .formula-title::before {
+            content: '';
+            width: 4px;
+            height: 1.2em;
+            background: var(--warning);
+            border-radius: 2px;
+        }
+
+        .formula-code {
+            background: var(--bg-primary);
+            border-radius: 8px;
+            padding: 1rem;
+            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+            font-size: 0.85rem;
+            overflow-x: auto;
+            border: 1px solid var(--border);
+        }
+
+        .formula-code .keyword {
+            color: #ff7b72;
+        }
+
+        .formula-code .function {
+            color: #d2a8ff;
+        }
+
+        .formula-code .variable {
+            color: #79c0ff;
+        }
+
+        .formula-code .operator {
+            color: #ff7b72;
+        }
+
+        .formula-code .number {
+            color: #a5d6ff;
+        }
+
+        .formula-code .comment {
+            color: var(--text-secondary);
+            font-style: italic;
+        }
+
+        .tooltip {
+            position: absolute;
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: 0.75rem 1rem;
+            font-size: 0.85rem;
+            pointer-events: none;
+            opacity: 0;
+            transition: opacity 0.15s ease;
+            z-index: 100;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+        }
+
+        .tooltip.visible {
+            opacity: 1;
+        }
+
+        .tooltip-row {
+            display: flex;
+            justify-content: space-between;
+            gap: 1.5rem;
+            margin-bottom: 0.25rem;
+        }
+
+        .tooltip-row:last-child {
+            margin-bottom: 0;
+        }
+
+        .tooltip-label {
+            color: var(--text-secondary);
+        }
+
+        .tooltip-value {
+            font-weight: 600;
+            font-family: 'SFMono-Regular', Consolas, monospace;
+        }
+
+        .tooltip-value.positive {
+            color: var(--success);
+        }
+
+        .legend {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin-top: 1rem;
+            gap: 0.75rem;
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+        }
+
+        .legend-center {
+            display: flex;
+            flex-direction: column;
+            align-items: stretch;
+        }
+
+        .legend-gradient {
+            width: 200px;
+            height: 12px;
+            border-radius: 6px;
+        }
+
+        .legend-labels {
+            display: flex;
+            justify-content: space-between;
+            width: 200px;
+            margin-top: 0.35rem;
+            font-size: 0.75rem;
+            color: var(--text-secondary);
+        }
+
+        .axis-label {
+            font-size: 0.85rem;
+            fill: var(--text-secondary);
+        }
+
+        footer {
+            margin-top: 3rem;
+            padding-top: 1.5rem;
+            border-top: 1px solid var(--border);
+            text-align: center;
+            color: var(--text-secondary);
+            font-size: 0.85rem;
+        }
+
+        footer a {
+            color: var(--accent);
+            text-decoration: none;
+        }
+
+        footer a:hover {
+            text-decoration: underline;
+        }
+
+        .info-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.3rem;
+            padding: 0.2rem 0.5rem;
+            background: var(--bg-tertiary);
+            border-radius: 4px;
+            font-size: 0.75rem;
+            color: var(--text-secondary);
+            margin-left: 0.5rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>FastAD Rating Formula Visualizer</h1>
+            <p class="subtitle">Interactive heatmap showing rating delta based on attacker and victim scores</p>
+        </header>
+
+        <div class="main-content">
+            <div class="chart-container">
+                <div class="chart-title">Rating Delta Heatmap</div>
+                <div id="heatmap"></div>
+                <div class="legend">
+                    <span>Low</span>
+                    <div class="legend-center">
+                        <div id="legend-gradient" class="legend-gradient"></div>
+                        <div class="legend-labels" id="legend-labels"></div>
+                    </div>
+                    <span>High</span>
+                </div>
+            </div>
+
+            <div class="controls-panel">
+                <div class="controls-title">Parameters</div>
+                
+                <div class="control-group">
+                    <div class="control-label">
+                        <span>Hardness</span>
+                        <span class="info-badge">Scoring intensity</span>
+                    </div>
+                    <div class="slider-container">
+                        <input type="range" id="hardness-slider" min="2" max="100" value="15" step="0.5">
+                        <input type="number" id="hardness-input" value="15" min="1.1" step="0.5">
+                    </div>
+                </div>
+
+                <div class="control-group">
+                    <div class="control-label">
+                        <span>Max Score</span>
+                        <span class="info-badge">Chart range</span>
+                    </div>
+                    <div class="slider-container">
+                        <input type="range" id="maxscore-slider" min="1000" max="50000" value="10000" step="500">
+                        <input type="number" id="maxscore-input" value="10000" min="100" step="100">
+                    </div>
+                </div>
+
+                <div class="control-group">
+                    <div class="control-label">
+                        <span>Resolution</span>
+                        <span class="info-badge">Grid cells</span>
+                    </div>
+                    <div class="slider-container">
+                        <input type="range" id="resolution-slider" min="20" max="100" value="50" step="5">
+                        <input type="number" id="resolution-input" value="50" min="10" max="150" step="5">
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="formula-section">
+            <div class="formula-title">Rating Formula</div>
+            <pre class="formula-code"><span class="comment">// FastAD rating delta calculation</span>
+<span class="keyword">const</span> <span class="variable">scale</span> <span class="operator">=</span> <span class="number">50</span> <span class="operator">*</span> <span class="function">Math.sqrt</span>(<span class="variable">hardness</span>);
+<span class="keyword">const</span> <span class="variable">norm</span> <span class="operator">=</span> <span class="function">Math.log</span>(<span class="function">Math.log</span>(<span class="variable">hardness</span>)) <span class="operator">/</span> <span class="number">12</span>;
+<span class="keyword">const</span> <span class="variable">ratingDelta</span> <span class="operator">=</span> <span class="function">Math.sqrt</span>(<span class="variable">attackerScore</span>) <span class="operator">-</span> <span class="function">Math.sqrt</span>(<span class="variable">victimScore</span>);
+<span class="keyword">const</span> <span class="variable">ratingDeltaNorm</span> <span class="operator">=</span> <span class="variable">ratingDelta</span> <span class="operator">*</span> <span class="variable">norm</span>;
+<span class="keyword">const</span> <span class="variable">attackerDelta</span> <span class="operator">=</span> <span class="variable">scale</span> <span class="operator">/</span> (<span class="number">1</span> <span class="operator">+</span> <span class="function">Math.exp</span>(<span class="variable">ratingDeltaNorm</span>));</pre>
+        </div>
+
+        <footer>
+            <p>Part of <a href="https://github.com/C4T-BuT-S4D/FastAD" target="_blank">FastAD</a> - Blazing fast Attack &amp; Defence CTF platform</p>
+        </footer>
+    </div>
+
+    <div class="tooltip" id="tooltip"></div>
+
+    <script>
+        // Rating formula implementation
+        function calculateAttackerDelta(attackerScore, victimScore, hardness) {
+            // Ensure hardness is valid for log(log(x))
+            if (hardness <= 1) hardness = 1.1;
+            const scale = 50 * Math.sqrt(hardness);
+            const norm = Math.log(Math.log(hardness)) / 12;
+            const ratingDelta = Math.sqrt(attackerScore) - Math.sqrt(victimScore);
+            const ratingDeltaNorm = ratingDelta * norm;
+            const attackerDelta = scale / (1 + Math.exp(ratingDeltaNorm));
+            return attackerDelta;
+        }
+
+        // Chart configuration
+        const margin = { top: 40, right: 30, bottom: 60, left: 70 };
+        const width = 600 - margin.left - margin.right;
+        const height = 500 - margin.top - margin.bottom;
+
+        // Create SVG
+        const svg = d3.select('#heatmap')
+            .append('svg')
+            .attr('viewBox', `0 0 ${width + margin.left + margin.right} ${height + margin.top + margin.bottom}`)
+            .attr('preserveAspectRatio', 'xMidYMid meet')
+            .style('max-width', '100%')
+            .style('height', 'auto')
+            .append('g')
+            .attr('transform', `translate(${margin.left},${margin.top})`);
+
+        // Tooltip
+        const tooltip = d3.select('#tooltip');
+
+        // Scales
+        let xScale = d3.scaleLinear().range([0, width]);
+        let yScale = d3.scaleLinear().range([height, 0]);
+        let colorScale;
+
+        // Axes
+        const xAxisGroup = svg.append('g')
+            .attr('transform', `translate(0,${height})`)
+            .attr('class', 'x-axis');
+
+        const yAxisGroup = svg.append('g')
+            .attr('class', 'y-axis');
+
+        // Axis labels
+        svg.append('text')
+            .attr('class', 'axis-label')
+            .attr('x', width / 2)
+            .attr('y', height + 45)
+            .attr('text-anchor', 'middle')
+            .text("Victim's Score");
+
+        svg.append('text')
+            .attr('class', 'axis-label')
+            .attr('transform', 'rotate(-90)')
+            .attr('x', -height / 2)
+            .attr('y', -50)
+            .attr('text-anchor', 'middle')
+            .text("Attacker's Score");
+
+        // Create heatmap cells container
+        const cellsGroup = svg.append('g').attr('class', 'cells');
+
+        // Get control elements
+        const hardnessSlider = document.getElementById('hardness-slider');
+        const hardnessInput = document.getElementById('hardness-input');
+        const maxscoreSlider = document.getElementById('maxscore-slider');
+        const maxscoreInput = document.getElementById('maxscore-input');
+        const resolutionSlider = document.getElementById('resolution-slider');
+        const resolutionInput = document.getElementById('resolution-input');
+
+        // Sync slider and input
+        function syncControls(slider, input) {
+            slider.addEventListener('input', () => {
+                input.value = slider.value;
+                updateChart();
+            });
+            input.addEventListener('change', () => {
+                const val = parseFloat(input.value);
+                if (!isNaN(val) && val >= parseFloat(input.min)) {
+                    slider.value = Math.min(Math.max(val, parseFloat(slider.min)), parseFloat(slider.max));
+                    updateChart();
+                }
+            });
+        }
+
+        syncControls(hardnessSlider, hardnessInput);
+        syncControls(maxscoreSlider, maxscoreInput);
+        syncControls(resolutionSlider, resolutionInput);
+
+        // Generate heatmap data
+        function generateData(maxScore, resolution, hardness) {
+            const data = [];
+            const step = maxScore / resolution;
+            
+            for (let i = 0; i < resolution; i++) {
+                for (let j = 0; j < resolution; j++) {
+                    const victimScore = step * (j + 0.5);
+                    const attackerScore = step * (i + 0.5);
+                    const delta = calculateAttackerDelta(attackerScore, victimScore, hardness);
+                    data.push({
+                        x: j,
+                        y: i,
+                        victimScore,
+                        attackerScore,
+                        delta
+                    });
+                }
+            }
+            return data;
+        }
+
+        // Update chart
+        function updateChart() {
+            const hardness = parseFloat(hardnessInput.value) || 15;
+            const maxScore = parseFloat(maxscoreInput.value) || 10000;
+            const resolution = parseInt(resolutionInput.value) || 50;
+
+            const data = generateData(maxScore, resolution, hardness);
+
+            // Update scales
+            xScale.domain([0, maxScore]);
+            yScale.domain([0, maxScore]);
+
+            const deltaExtent = d3.extent(data, d => d.delta);
+            colorScale = d3.scaleSequential()
+                .domain(deltaExtent)
+                .interpolator(d3.interpolateViridis);
+
+            // Update axes with formatted ticks
+            const formatNumber = d3.format(',.0f');
+            xAxisGroup.transition().duration(300)
+                .call(d3.axisBottom(xScale).ticks(6).tickFormat(formatNumber));
+            yAxisGroup.transition().duration(300)
+                .call(d3.axisLeft(yScale).ticks(6).tickFormat(formatNumber));
+
+            // Style axes
+            svg.selectAll('.x-axis text, .y-axis text')
+                .style('fill', '#8b949e')
+                .style('font-size', '11px');
+            svg.selectAll('.x-axis line, .y-axis line, .x-axis path, .y-axis path')
+                .style('stroke', '#30363d');
+
+            // Cell dimensions
+            const cellWidth = width / resolution;
+            const cellHeight = height / resolution;
+
+            // Update cells
+            const cells = cellsGroup.selectAll('rect')
+                .data(data, d => `${d.x}-${d.y}`);
+
+            cells.exit().remove();
+
+            const cellsEnter = cells.enter()
+                .append('rect')
+                .attr('x', d => d.x * cellWidth)
+                .attr('y', d => height - (d.y + 1) * cellHeight)
+                .attr('width', cellWidth + 0.5)
+                .attr('height', cellHeight + 0.5)
+                .attr('shape-rendering', 'crispEdges')
+                .style('stroke', 'none')
+                .style('cursor', 'crosshair');
+
+            cellsEnter.merge(cells)
+                .transition()
+                .duration(300)
+                .attr('x', d => d.x * cellWidth)
+                .attr('y', d => height - (d.y + 1) * cellHeight)
+                .attr('width', cellWidth + 0.5)
+                .attr('height', cellHeight + 0.5)
+                .attr('fill', d => colorScale(d.delta));
+
+            // Update hover events
+            cellsGroup.selectAll('rect')
+                .on('mouseover', function(event, d) {
+                    d3.select(this).style('stroke', '#fff').style('stroke-width', 2);
+                    tooltip.classed('visible', true);
+                    tooltip.html(`
+                        <div class="tooltip-row">
+                            <span class="tooltip-label">Victim Score:</span>
+                            <span class="tooltip-value">${d.victimScore.toFixed(1)}</span>
+                        </div>
+                        <div class="tooltip-row">
+                            <span class="tooltip-label">Attacker Score:</span>
+                            <span class="tooltip-value">${d.attackerScore.toFixed(1)}</span>
+                        </div>
+                        <div class="tooltip-row">
+                            <span class="tooltip-label">Rating Delta:</span>
+                            <span class="tooltip-value positive">+${d.delta.toFixed(2)}</span>
+                        </div>
+                    `);
+                })
+                .on('mousemove', function(event) {
+                    tooltip
+                        .style('left', (event.pageX + 15) + 'px')
+                        .style('top', (event.pageY - 10) + 'px');
+                })
+                .on('mouseout', function() {
+                    d3.select(this).style('stroke', 'none');
+                    tooltip.classed('visible', false);
+                });
+
+            // Update legend
+            updateLegend(deltaExtent);
+        }
+
+        // Update legend gradient
+        function updateLegend(extent) {
+            const gradient = d3.select('#legend-gradient');
+            const numStops = 10;
+            const stops = d3.range(numStops).map(i => {
+                const t = i / (numStops - 1);
+                const value = extent[0] + t * (extent[1] - extent[0]);
+                return colorScale(value);
+            });
+            
+            gradient.style('background', `linear-gradient(to right, ${stops.join(', ')})`);
+            
+            d3.select('#legend-labels').html(`
+                <span>${extent[0].toFixed(1)}</span>
+                <span>${((extent[0] + extent[1]) / 2).toFixed(1)}</span>
+                <span>${extent[1].toFixed(1)}</span>
+            `);
+        }
+
+        // Initial render
+        updateChart();
+    </script>
+</body>
+</html>
diff --git a/fastad.yaml.example b/fastad.yaml.example
new file mode 100644
index 0000000..0bf17db
--- /dev/null
+++ b/fastad.yaml.example
@@ -0,0 +1,81 @@
+# FastAD Game Configuration
+# Copy this file to fastad.yaml and modify as needed.
+
+# Platform settings (optional - defaults are sensible)
+fastad:
+  listen_port: 8080          # port for the web interface
+  log_level: info            # debug, info, warn, error
+  intercom_token: ""         # leave empty to auto-generate, or set for reproducible deploys
+
+# Admin credentials for the management interface
+# If omitted, random credentials will be generated and logged on startup
+admin:
+  username: admin
+  password: changeme123      # please change this!
+
+# Database connection (optional)
+# If omitted, FastAD will start its own PostgreSQL containers
+# Useful when you want to use an external managed database
+database:
+  external_dsn: ""                  # postgres://user:pass@host:5432/fastad?sslmode=disable
+  temporal_external_dsn: ""         # postgres://user:pass@host:5432/temporal?sslmode=disable
+
+# Game timing and scoring parameters
+game:
+  start_time: "2025-02-01T10:00:00Z"   # ISO 8601 format, when the game begins
+  end_time: "2025-02-01T18:00:00Z"     # optional, game ends when this time is reached
+  total_rounds: 0                       # or specify fixed number of rounds (0 = unlimited)
+
+  round_duration: 60s          # how long each round lasts (60s = 1 minute)
+  flag_lifetime_rounds: 5      # flags expire after this many rounds
+  hardness: 10.0               # scoring parameter, higher = more points per stolen flag
+  inflation: false             # if true, later rounds are worth more points
+
+  checkers_base_path: checkers # directory containing checker scripts (relative to fastad root)
+
+# Teams participating in the CTF
+teams:
+  - name: Team Alpha
+    address: 10.60.1.1         # vulnbox IP or hostname
+    labels:                    # optional metadata for filtering/display
+      country: US
+      university: MIT
+
+  - name: Team Beta
+    address: 10.60.1.2
+    labels:
+      country: DE
+
+  - name: Team Gamma
+    address: 10.60.1.3
+    # labels are optional
+
+# Services to be checked during the game
+services:
+  - name: example_service
+    default_score: 2500.0      # starting score for this service
+
+    checker:
+      type: legacy             # legacy (forcad-compatible), or leave empty for default
+      path: example/checker.py # relative to checkers_base_path
+      default_timeout: 30s     # max time for any checker action
+
+      # Per-action configuration (optional)
+      # Allows fine-tuning how many times each action runs and custom timeouts
+      actions:
+        check:
+          count: 1             # how many times to run CHECK per round
+          timeout: 15s         # override default_timeout for this action
+        put:
+          count: 1             # how many flags to PUT per round
+          timeout: 30s
+        get:
+          count: 3             # run GET multiple times (retrieves older flags)
+          timeout: 30s
+
+  - name: another_service
+    default_score: 2500.0
+    checker:
+      path: another/checker.py
+      default_timeout: 20s
+      # uses default action counts if not specified
diff --git a/front/.eslintrc.cjs b/front/.eslintrc.cjs
deleted file mode 100644
index d47feea..0000000
--- a/front/.eslintrc.cjs
+++ /dev/null
@@ -1,10 +0,0 @@
-/* eslint-env node */
-require("@rushstack/eslint-patch/modern-module-resolution")
-
-module.exports = {
-  extends: [
-    'plugin:vue/vue3-essential',
-    '@vue/eslint-config-typescript/recommended',
-    '@vue/eslint-config-prettier'
-  ]
-}
\ No newline at end of file
diff --git a/front/.node-version b/front/.node-version
new file mode 100644
index 0000000..1d9b783
--- /dev/null
+++ b/front/.node-version
@@ -0,0 +1 @@
+22.12.0
diff --git a/front/.prettierignore b/front/.prettierignore
new file mode 100644
index 0000000..c4a10d3
--- /dev/null
+++ b/front/.prettierignore
@@ -0,0 +1 @@
+/src/proto
diff --git a/front/.prettierrc b/front/.prettierrc
new file mode 100644
index 0000000..9e4c08a
--- /dev/null
+++ b/front/.prettierrc
@@ -0,0 +1,5 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "all"
+}
diff --git a/front/README.md b/front/README.md
index 98f4a52..fc4372f 100644
--- a/front/README.md
+++ b/front/README.md
@@ -1,23 +1,53 @@
-# Vue 3 + TypeScript + Vite
+# React + TypeScript + Vite
 
-This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue
-3 `<script setup>` SFCs, check out
-the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
 
-## Recommended IDE Setup
+Currently, two official plugins are available:
 
-- [VS Code](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar)
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md)
+  uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast
+  Refresh
 
-## Type Support For `.vue` Imports in TS
+## Expanding the ESLint configuration
 
-Since TypeScript cannot handle type information for `.vue` imports, they are shimmed to be a generic Vue component type
-by default. In most cases this is fine if you don't really care about component prop types outside of templates.
-However, if you wish to get actual prop types in `.vue` imports (for example to get props validation when using
-manual `h(...)` calls), you can enable Volar's Take Over mode by following these steps:
+If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
 
-1. Run `Extensions: Show Built-in Extensions` from VS Code's command palette, look
-   for `TypeScript and JavaScript Language Features`, then right click and select `Disable (Workspace)`. By default,
-   Take Over mode will enable itself if the default TypeScript extension is disabled.
-2. Reload the VS Code window by running `Developer: Reload Window` from the command palette.
+- Configure the top-level `parserOptions` property like this:
 
-You can learn more about Take Over mode [here](https://github.com/johnsoncodehk/volar/discussions/471).
+```js
+export default tseslint.config({
+  languageOptions: {
+    // other options...
+    parserOptions: {
+      project: ['./tsconfig.node.json', './tsconfig.app.json'],
+      tsconfigRootDir: import.meta.dirname,
+    },
+  },
+});
+```
+
+- Replace `tseslint.configs.recommended` to `tseslint.configs.recommendedTypeChecked` or
+  `tseslint.configs.strictTypeChecked`
+- Optionally add `...tseslint.configs.stylisticTypeChecked`
+- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and update the config:
+
+```js
+// eslint.config.js
+import react from 'eslint-plugin-react';
+
+export default tseslint.config({
+  // Set the react version
+  settings: { react: { version: '18.3' } },
+  plugins: {
+    // Add the react plugin
+    react,
+  },
+  rules: {
+    // other rules...
+    // Enable its recommended rules
+    ...react.configs.recommended.rules,
+    ...react.configs['jsx-runtime'].rules,
+  },
+});
+```
diff --git a/front/eslint.config.js b/front/eslint.config.js
new file mode 100644
index 0000000..2f7d83b
--- /dev/null
+++ b/front/eslint.config.js
@@ -0,0 +1,38 @@
+import js from '@eslint/js';
+import eslintPrettier from 'eslint-plugin-prettier/recommended';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  { ignores: ['dist', 'src/proto'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.stylisticTypeChecked],
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  },
+  eslintPrettier,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+);
diff --git a/front/index.html b/front/index.html
index 6e686d7..bbc4795 100644
--- a/front/index.html
+++ b/front/index.html
@@ -1,13 +1,23 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
-<head>
-    <meta charset="UTF-8"/>
-    <link href="/vite.svg" rel="icon" type="image/svg+xml"/>
-    <meta content="width=device-width, initial-scale=1.0" name="viewport"/>
+  <head>
+    <meta charset="UTF-8" />
+    <link href="/vite.svg" rel="icon" type="image/svg+xml" />
+    <meta content="width=device-width, initial-scale=1.0" name="viewport" />
     <title>FastAD</title>
-</head>
-<body>
-<div id="app"></div>
-<script src="/src/main.ts" type="module"></script>
-</body>
+    <link href="https://fonts.googleapis.com" rel="preconnect" />
+    <link crossorigin href="https://fonts.gstatic.com" rel="preconnect" />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap"
+      rel="stylesheet"
+    />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Roboto+Mono:ital,wght@0,100..700;1,100..700&display=swap"
+      rel="stylesheet"
+    />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script src="/src/main.tsx" type="module"></script>
+  </body>
 </html>
diff --git a/front/package.json b/front/package.json
index 6c1b4e7..52df3f0 100644
--- a/front/package.json
+++ b/front/package.json
@@ -1,32 +1,47 @@
 {
-    "name": "fastad",
-    "private": true,
-    "version": "0.0.0",
-    "type": "module",
-    "scripts": {
-        "dev": "vite",
-        "build": "vue-tsc --noEmit && vite build",
-        "preview": "vite preview",
-        "lint": "eslint --ext .js,.vue,.ts --ignore-path .gitignore --fix src"
-    },
-    "dependencies": {
-        "@improbable-eng/grpc-web": "^0.15.0",
-        "google-protobuf": "^3.20.1",
-        "nice-grpc-web": "^1.1.0",
-        "protobufjs": "^7.0.0",
-        "vue": "^3.2.37"
-    },
-    "devDependencies": {
-        "@rushstack/eslint-patch": "^1.1.4",
-        "@types/node": "^18.6.1",
-        "@vitejs/plugin-vue": "^3.0.0",
-        "@vue/eslint-config-prettier": "^7.0.0",
-        "@vue/eslint-config-typescript": "^11.0.0",
-        "eslint": "^8.20.0",
-        "eslint-plugin-vue": "^9.3.0",
-        "prettier": "^2.7.1",
-        "typescript": "^4.6.4",
-        "vite": "^3.0.0",
-        "vue-tsc": "^0.38.4"
-    }
+  "name": "front",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.2.3",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@mui/icons-material": "^6.3.0",
+    "@mui/lab": "6.0.0-beta.21",
+    "@mui/material": "^6.3.0",
+    "@types/react-window": "^1.8.8",
+    "@uidotdev/usehooks": "^2.4.1",
+    "axios": "^1.7.9",
+    "centrifuge": "^5.2.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router": "^7.1.1",
+    "react-window": "^1.8.11"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@types/node": "^22.10.2",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-react-refresh": "^0.4.16",
+    "globals": "^15.14.0",
+    "prettier": "^3.4.2",
+    "typescript": "~5.6.2",
+    "typescript-eslint": "^8.18.2",
+    "vite": "^6.0.5"
+  },
+  "packageManager": "pnpm@9.15.2+sha512.93e57b0126f0df74ce6bff29680394c0ba54ec47246b9cf321f0121d8d9bb03f750a705f24edc3c1180853afd7c2c3b94196d0a3d53d3e069d9e2793ef11f321"
 }
diff --git a/front/pnpm-lock.yaml b/front/pnpm-lock.yaml
new file mode 100644
index 0000000..f770ea1
--- /dev/null
+++ b/front/pnpm-lock.yaml
@@ -0,0 +1,3014 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@bufbuild/protobuf':
+        specifier: ^2.2.3
+        version: 2.2.3
+      '@emotion/react':
+        specifier: ^11.14.0
+        version: 11.14.0(@types/react@18.3.18)(react@19.0.0)
+      '@emotion/styled':
+        specifier: ^11.14.0
+        version: 11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+      '@mui/icons-material':
+        specifier: ^6.3.0
+        version: 6.3.0(@mui/material@6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+      '@mui/lab':
+        specifier: 6.0.0-beta.21
+        version: 6.0.0-beta.21(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@mui/material@6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      '@mui/material':
+        specifier: ^6.3.0
+        version: 6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      '@types/react-window':
+        specifier: ^1.8.8
+        version: 1.8.8
+      '@uidotdev/usehooks':
+        specifier: ^2.4.1
+        version: 2.4.1(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      axios:
+        specifier: ^1.7.9
+        version: 1.7.9
+      centrifuge:
+        specifier: ^5.2.2
+        version: 5.2.2
+      react:
+        specifier: ^19.0.0
+        version: 19.0.0
+      react-dom:
+        specifier: ^19.0.0
+        version: 19.0.0(react@19.0.0)
+      react-router:
+        specifier: ^7.1.1
+        version: 7.1.1(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      react-window:
+        specifier: ^1.8.11
+        version: 1.8.11(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+    devDependencies:
+      '@eslint/js':
+        specifier: ^9.17.0
+        version: 9.17.0
+      '@types/node':
+        specifier: ^22.10.2
+        version: 22.10.2
+      '@types/react':
+        specifier: ^18.3.18
+        version: 18.3.18
+      '@types/react-dom':
+        specifier: ^18.3.5
+        version: 18.3.5(@types/react@18.3.18)
+      '@vitejs/plugin-react':
+        specifier: ^4.3.4
+        version: 4.3.4(vite@6.0.6(@types/node@22.10.2))
+      eslint:
+        specifier: ^9.17.0
+        version: 9.17.0
+      eslint-config-prettier:
+        specifier: ^9.1.0
+        version: 9.1.0(eslint@9.17.0)
+      eslint-plugin-prettier:
+        specifier: ^5.2.1
+        version: 5.2.1(eslint-config-prettier@9.1.0(eslint@9.17.0))(eslint@9.17.0)(prettier@3.4.2)
+      eslint-plugin-react-hooks:
+        specifier: ^5.0.0
+        version: 5.1.0(eslint@9.17.0)
+      eslint-plugin-react-refresh:
+        specifier: ^0.4.16
+        version: 0.4.16(eslint@9.17.0)
+      globals:
+        specifier: ^15.14.0
+        version: 15.14.0
+      prettier:
+        specifier: ^3.4.2
+        version: 3.4.2
+      typescript:
+        specifier: ~5.6.2
+        version: 5.6.3
+      typescript-eslint:
+        specifier: ^8.18.2
+        version: 8.18.2(eslint@9.17.0)(typescript@5.6.3)
+      vite:
+        specifier: ^6.0.5
+        version: 6.0.6(@types/node@22.10.2)
+
+packages:
+
+  '@ampproject/remapping@2.3.0':
+    resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==}
+    engines: {node: '>=6.0.0'}
+
+  '@babel/code-frame@7.26.2':
+    resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/compat-data@7.26.3':
+    resolution: {integrity: sha512-nHIxvKPniQXpmQLb0vhY3VaFb3S0YrTAwpOWJZh1wn3oJPjJk9Asva204PsBdmAE8vpzfHudT8DB0scYvy9q0g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/core@7.26.0':
+    resolution: {integrity: sha512-i1SLeK+DzNnQ3LL/CswPCa/E5u4lh1k6IAEphON8F+cXt0t9euTshDru0q7/IqMa1PMPz5RnHuHscF8/ZJsStg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/generator@7.26.3':
+    resolution: {integrity: sha512-6FF/urZvD0sTeO7k6/B15pMLC4CHUv1426lzr3N01aHJTl046uCAh9LXW/fzeXXjPNCJ6iABW5XaWOsIZB93aQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-compilation-targets@7.25.9':
+    resolution: {integrity: sha512-j9Db8Suy6yV/VHa4qzrj9yZfZxhLWQdVnRlXxmKLYlhWUVB1sB2G5sxuWYXk/whHD9iW76PmNzxZ4UCnTQTVEQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-imports@7.25.9':
+    resolution: {integrity: sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-transforms@7.26.0':
+    resolution: {integrity: sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-plugin-utils@7.25.9':
+    resolution: {integrity: sha512-kSMlyUVdWe25rEsRGviIgOWnoT/nfABVWlqt9N19/dIPWViAOW2s9wznP5tURbs/IDuNk4gPy3YdYRgH3uxhBw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-string-parser@7.25.9':
+    resolution: {integrity: sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.25.9':
+    resolution: {integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-option@7.25.9':
+    resolution: {integrity: sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helpers@7.26.0':
+    resolution: {integrity: sha512-tbhNuIxNcVb21pInl3ZSjksLCvgdZy9KwJ8brv993QtIVKJBBkYXz4q4ZbAv31GdnC+R90np23L5FbEBlthAEw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.26.3':
+    resolution: {integrity: sha512-WJ/CvmY8Mea8iDXo6a7RK2wbmJITT5fN3BEkRuFlxVyNx8jOKIIhmC4fSkTcPcf8JyavbBwIe6OpiCOBXt/IcA==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/plugin-transform-react-jsx-self@7.25.9':
+    resolution: {integrity: sha512-y8quW6p0WHkEhmErnfe58r7x0A70uKphQm8Sp8cV7tjNQwK56sNVK0M73LK3WuYmsuyrftut4xAkjjgU0twaMg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-jsx-source@7.25.9':
+    resolution: {integrity: sha512-+iqjT8xmXhhYv4/uiYd8FNQsraMFZIfxVSqxxVSZP0WbbSAWvBXAul0m/zu+7Vv4O/3WtApy9pmaTMiumEZgfg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/runtime@7.26.0':
+    resolution: {integrity: sha512-FDSOghenHTiToteC/QRlv2q3DhPZ/oOXTBoirfWNx1Cx3TMVcGWQtMMmQcSvb/JjpNeGzx8Pq/b4fKEJuWm1sw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/template@7.25.9':
+    resolution: {integrity: sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/traverse@7.26.4':
+    resolution: {integrity: sha512-fH+b7Y4p3yqvApJALCPJcwb0/XaOSgtK4pzV6WVjPR5GLFQBRI7pfoX2V2iM48NXvX07NUxxm1Vw98YjqTcU5w==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.26.3':
+    resolution: {integrity: sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==}
+    engines: {node: '>=6.9.0'}
+
+  '@bufbuild/protobuf@2.2.3':
+    resolution: {integrity: sha512-tFQoXHJdkEOSwj5tRIZSPNUuXK3RaR7T1nUrPgbYX1pUbvqqaaZAsfo+NXBPsz5rZMSKVFrgK1WL8Q/MSLvprg==}
+
+  '@emotion/babel-plugin@11.13.5':
+    resolution: {integrity: sha512-pxHCpT2ex+0q+HH91/zsdHkw/lXd468DIN2zvfvLtPKLLMo6gQj7oLObq8PhkrxOZb/gGCq03S3Z7PDhS8pduQ==}
+
+  '@emotion/cache@11.14.0':
+    resolution: {integrity: sha512-L/B1lc/TViYk4DcpGxtAVbx0ZyiKM5ktoIyafGkH6zg/tj+mA+NE//aPYKG0k8kCHSHVJrpLpcAlOBEXQ3SavA==}
+
+  '@emotion/hash@0.9.2':
+    resolution: {integrity: sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g==}
+
+  '@emotion/is-prop-valid@1.3.1':
+    resolution: {integrity: sha512-/ACwoqx7XQi9knQs/G0qKvv5teDMhD7bXYns9N/wM8ah8iNb8jZ2uNO0YOgiq2o2poIvVtJS2YALasQuMSQ7Kw==}
+
+  '@emotion/memoize@0.9.0':
+    resolution: {integrity: sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==}
+
+  '@emotion/react@11.14.0':
+    resolution: {integrity: sha512-O000MLDBDdk/EohJPFUqvnp4qnHeYkVP5B0xEG0D/L7cOKP9kefu2DXn8dj74cQfsEzUqh+sr1RzFqiL1o+PpA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: '>=16.8.0'
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@emotion/serialize@1.3.3':
+    resolution: {integrity: sha512-EISGqt7sSNWHGI76hC7x1CksiXPahbxEOrC5RjmFRJTqLyEK9/9hZvBbiYn70dw4wuwMKiEMCUlR6ZXTSWQqxA==}
+
+  '@emotion/sheet@1.4.0':
+    resolution: {integrity: sha512-fTBW9/8r2w3dXWYM4HCB1Rdp8NLibOw2+XELH5m5+AkWiL/KqYX6dc0kKYlaYyKjrQ6ds33MCdMPEwgs2z1rqg==}
+
+  '@emotion/styled@11.14.0':
+    resolution: {integrity: sha512-XxfOnXFffatap2IyCeJyNov3kiDQWoR08gPUQxvbL7fxKryGBKUZUkG6Hz48DZwVrJSVh9sJboyV1Ds4OW6SgA==}
+    peerDependencies:
+      '@emotion/react': ^11.0.0-rc.0
+      '@types/react': '*'
+      react: '>=16.8.0'
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@emotion/unitless@0.10.0':
+    resolution: {integrity: sha512-dFoMUuQA20zvtVTuxZww6OHoJYgrzfKM1t52mVySDJnMSEa08ruEvdYQbhvyu6soU+NeLVd3yKfTfT0NeV6qGg==}
+
+  '@emotion/use-insertion-effect-with-fallbacks@1.2.0':
+    resolution: {integrity: sha512-yJMtVdH59sxi/aVJBpk9FQq+OR8ll5GT8oWd57UpeaKEVGab41JWaCFA7FRLoMLloOZF/c/wsPoe+bfGmRKgDg==}
+    peerDependencies:
+      react: '>=16.8.0'
+
+  '@emotion/utils@1.4.2':
+    resolution: {integrity: sha512-3vLclRofFziIa3J2wDh9jjbkUz9qk5Vi3IZ/FSTKViB0k+ef0fPV7dYrUIugbgupYDx7v9ud/SjrtEP8Y4xLoA==}
+
+  '@emotion/weak-memoize@0.4.0':
+    resolution: {integrity: sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg==}
+
+  '@esbuild/aix-ppc64@0.24.2':
+    resolution: {integrity: sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.24.2':
+    resolution: {integrity: sha512-cNLgeqCqV8WxfcTIOeL4OAtSmL8JjcN6m09XIgro1Wi7cF4t/THaWEa7eL5CMoMBdjoHOTh/vwTO/o2TRXIyzg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.24.2':
+    resolution: {integrity: sha512-tmwl4hJkCfNHwFB3nBa8z1Uy3ypZpxqxfTQOcHX+xRByyYgunVbZ9MzUUfb0RxaHIMnbHagwAxuTL+tnNM+1/Q==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.24.2':
+    resolution: {integrity: sha512-B6Q0YQDqMx9D7rvIcsXfmJfvUYLoP722bgfBlO5cGvNVb5V/+Y7nhBE3mHV9OpxBf4eAS2S68KZztiPaWq4XYw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.24.2':
+    resolution: {integrity: sha512-kj3AnYWc+CekmZnS5IPu9D+HWtUI49hbnyqk0FLEJDbzCIQt7hg7ucF1SQAilhtYpIujfaHr6O0UHlzzSPdOeA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.24.2':
+    resolution: {integrity: sha512-WeSrmwwHaPkNR5H3yYfowhZcbriGqooyu3zI/3GGpF8AyUdsrrP0X6KumITGA9WOyiJavnGZUwPGvxvwfWPHIA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.24.2':
+    resolution: {integrity: sha512-UN8HXjtJ0k/Mj6a9+5u6+2eZ2ERD7Edt1Q9IZiB5UZAIdPnVKDoG7mdTVGhHJIeEml60JteamR3qhsr1r8gXvg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.24.2':
+    resolution: {integrity: sha512-TvW7wE/89PYW+IevEJXZ5sF6gJRDY/14hyIGFXdIucxCsbRmLUcjseQu1SyTko+2idmCw94TgyaEZi9HUSOe3Q==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.24.2':
+    resolution: {integrity: sha512-7HnAD6074BW43YvvUmE/35Id9/NB7BeX5EoNkK9obndmZBUk8xmJJeU7DwmUeN7tkysslb2eSl6CTrYz6oEMQg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.24.2':
+    resolution: {integrity: sha512-n0WRM/gWIdU29J57hJyUdIsk0WarGd6To0s+Y+LwvlC55wt+GT/OgkwoXCXvIue1i1sSNWblHEig00GBWiJgfA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.24.2':
+    resolution: {integrity: sha512-sfv0tGPQhcZOgTKO3oBE9xpHuUqguHvSo4jl+wjnKwFpapx+vUDcawbwPNuBIAYdRAvIDBfZVvXprIj3HA+Ugw==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.24.2':
+    resolution: {integrity: sha512-CN9AZr8kEndGooS35ntToZLTQLHEjtVB5n7dl8ZcTZMonJ7CCfStrYhrzF97eAecqVbVJ7APOEe18RPI4KLhwQ==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.24.2':
+    resolution: {integrity: sha512-iMkk7qr/wl3exJATwkISxI7kTcmHKE+BlymIAbHO8xanq/TjHaaVThFF6ipWzPHryoFsesNQJPE/3wFJw4+huw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.24.2':
+    resolution: {integrity: sha512-shsVrgCZ57Vr2L8mm39kO5PPIb+843FStGt7sGGoqiiWYconSxwTiuswC1VJZLCjNiMLAMh34jg4VSEQb+iEbw==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.24.2':
+    resolution: {integrity: sha512-4eSFWnU9Hhd68fW16GD0TINewo1L6dRrB+oLNNbYyMUAeOD2yCK5KXGK1GH4qD/kT+bTEXjsyTCiJGHPZ3eM9Q==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.24.2':
+    resolution: {integrity: sha512-S0Bh0A53b0YHL2XEXC20bHLuGMOhFDO6GN4b3YjRLK//Ep3ql3erpNcPlEFed93hsQAjAQDNsvcK+hV90FubSw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.24.2':
+    resolution: {integrity: sha512-8Qi4nQcCTbLnK9WoMjdC9NiTG6/E38RNICU6sUNqK0QFxCYgoARqVqxdFmWkdonVsvGqWhmm7MO0jyTqLqwj0Q==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.24.2':
+    resolution: {integrity: sha512-wuLK/VztRRpMt9zyHSazyCVdCXlpHkKm34WUyinD2lzK07FAHTq0KQvZZlXikNWkDGoT6x3TD51jKQ7gMVpopw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.24.2':
+    resolution: {integrity: sha512-VefFaQUc4FMmJuAxmIHgUmfNiLXY438XrL4GDNV1Y1H/RW3qow68xTwjZKfj/+Plp9NANmzbH5R40Meudu8mmw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.24.2':
+    resolution: {integrity: sha512-YQbi46SBct6iKnszhSvdluqDmxCJA+Pu280Av9WICNwQmMxV7nLRHZfjQzwbPs3jeWnuAhE9Jy0NrnJ12Oz+0A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.24.2':
+    resolution: {integrity: sha512-+iDS6zpNM6EnJyWv0bMGLWSWeXGN/HTaF/LXHXHwejGsVi+ooqDfMCCTerNFxEkM3wYVcExkeGXNqshc9iMaOA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/sunos-x64@0.24.2':
+    resolution: {integrity: sha512-hTdsW27jcktEvpwNHJU4ZwWFGkz2zRJUz8pvddmXPtXDzVKTTINmlmga3ZzwcuMpUvLw7JkLy9QLKyGpD2Yxig==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.24.2':
+    resolution: {integrity: sha512-LihEQ2BBKVFLOC9ZItT9iFprsE9tqjDjnbulhHoFxYQtQfai7qfluVODIYxt1PgdoyQkz23+01rzwNwYfutxUQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.24.2':
+    resolution: {integrity: sha512-q+iGUwfs8tncmFC9pcnD5IvRHAzmbwQ3GPS5/ceCyHdjXubwQWI12MKWSNSMYLJMq23/IUCvJMS76PDqXe1fxA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.24.2':
+    resolution: {integrity: sha512-7VTgWzgMGvup6aSqDPLiW5zHaxYJGTO4OokMjIlrCtf+VpEL+cXKtCvg723iguPYI5oaUNdS+/V7OU2gvXVWEg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@eslint-community/eslint-utils@4.4.1':
+    resolution: {integrity: sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+
+  '@eslint-community/regexpp@4.12.1':
+    resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+
+  '@eslint/config-array@0.19.1':
+    resolution: {integrity: sha512-fo6Mtm5mWyKjA/Chy1BYTdn5mGJoDNjC7C64ug20ADsRDGrA85bN3uK3MaKbeRkRuuIEAR5N33Jr1pbm411/PA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/core@0.9.1':
+    resolution: {integrity: sha512-GuUdqkyyzQI5RMIWkHhvTWLCyLo1jNK3vzkSyaExH5kHPDHcuL2VOpHjmMY+y3+NC69qAKToBqldTBgYeLSr9Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/eslintrc@3.2.0':
+    resolution: {integrity: sha512-grOjVNN8P3hjJn/eIETF1wwd12DdnwFDoyceUJLYYdkpbwq3nLi+4fqrTAONx7XDALqlL220wC/RHSC/QTI/0w==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/js@9.17.0':
+    resolution: {integrity: sha512-Sxc4hqcs1kTu0iID3kcZDW3JHq2a77HO9P8CP6YEA/FpH3Ll8UXE2r/86Rz9YJLKme39S9vU5OWNjC6Xl0Cr3w==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/object-schema@2.1.5':
+    resolution: {integrity: sha512-o0bhxnL89h5Bae5T318nFoFzGy+YE5i/gGkoPAgkmTVdRKTiv3p8JHevPiPaMwoloKfEiiaHlawCqaZMqRm+XQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/plugin-kit@0.2.4':
+    resolution: {integrity: sha512-zSkKow6H5Kdm0ZUQUB2kV5JIXqoG0+uH5YADhaEHswm664N9Db8dXSi0nMJpacpMf+MyyglF1vnZohpEg5yUtg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@floating-ui/core@1.6.8':
+    resolution: {integrity: sha512-7XJ9cPU+yI2QeLS+FCSlqNFZJq8arvswefkZrYI1yQBbftw6FyrZOxYSh+9S7z7TpeWlRt9zJ5IhM1WIL334jA==}
+
+  '@floating-ui/dom@1.6.12':
+    resolution: {integrity: sha512-NP83c0HjokcGVEMeoStg317VD9W7eDlGK7457dMBANbKA6GJZdc7rjujdgqzTaz93jkGgc5P/jeWbaCHnMNc+w==}
+
+  '@floating-ui/react-dom@2.1.2':
+    resolution: {integrity: sha512-06okr5cgPzMNBy+Ycse2A6udMi4bqwW/zgBF/rwjcNqWkyr82Mcg8b0vjX8OJpZFy/FKjJmw6wV7t44kK6kW7A==}
+    peerDependencies:
+      react: '>=16.8.0'
+      react-dom: '>=16.8.0'
+
+  '@floating-ui/utils@0.2.8':
+    resolution: {integrity: sha512-kym7SodPp8/wloecOpcmSnWJsK7M0E5Wg8UcFA+uO4B9s5d0ywXOEro/8HM9x0rW+TljRzul/14UYz3TleT3ig==}
+
+  '@humanfs/core@0.19.1':
+    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/node@0.16.6':
+    resolution: {integrity: sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanwhocodes/module-importer@1.0.1':
+    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
+    engines: {node: '>=12.22'}
+
+  '@humanwhocodes/retry@0.3.1':
+    resolution: {integrity: sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==}
+    engines: {node: '>=18.18'}
+
+  '@humanwhocodes/retry@0.4.1':
+    resolution: {integrity: sha512-c7hNEllBlenFTHBky65mhq8WD2kbN9Q6gk0bTk8lSBvc554jpXSkST1iePudpt7+A/AQvuHs9EMqjHDXMY1lrA==}
+    engines: {node: '>=18.18'}
+
+  '@jridgewell/gen-mapping@0.3.8':
+    resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/set-array@1.2.1':
+    resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.0':
+    resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==}
+
+  '@jridgewell/trace-mapping@0.3.25':
+    resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==}
+
+  '@mui/base@5.0.0-beta.68':
+    resolution: {integrity: sha512-F1JMNeLS9Qhjj3wN86JUQYBtJoXyQvknxlzwNl6eS0ZABo1MiohMONj3/WQzYPSXIKC2bS/ZbyBzdHhi2GnEpA==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@mui/core-downloads-tracker@6.3.0':
+    resolution: {integrity: sha512-/d8NwSuC3rMwCjswmGB3oXC4sdDuhIUJ8inVQAxGrADJhf0eq/kmy+foFKvpYhHl2siOZR+MLdFttw6/Bzqtqg==}
+
+  '@mui/icons-material@6.3.0':
+    resolution: {integrity: sha512-3uWws6DveDn5KxCS34p+sUNMxehuclQY6OmoJeJJ+Sfg9L7LGBpksY/nX5ywKAqickTZnn+sQyVcp963ep9jvw==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@mui/material': ^6.3.0
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@mui/lab@6.0.0-beta.21':
+    resolution: {integrity: sha512-hiFZgTwBNhJMUlEhmqfW4+5wy3C8UF9KFuzSOux6x4kgc9hsC0l+motXcF1Vyh+jhJYGeZ6yUoImqCf9RWzEvw==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@emotion/react': ^11.5.0
+      '@emotion/styled': ^11.3.0
+      '@mui/material': ^6.3.0
+      '@mui/material-pigment-css': ^6.3.0
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/react':
+        optional: true
+      '@emotion/styled':
+        optional: true
+      '@mui/material-pigment-css':
+        optional: true
+      '@types/react':
+        optional: true
+
+  '@mui/material@6.3.0':
+    resolution: {integrity: sha512-qhlTFyRMxfoVPxUtA5e8IvqxP0dWo2Ij7cvot7Orag+etUlZH+3UwD8gZGt+3irOoy7Ms3UNBflYjwEikUXtAQ==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@emotion/react': ^11.5.0
+      '@emotion/styled': ^11.3.0
+      '@mui/material-pigment-css': ^6.3.0
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/react':
+        optional: true
+      '@emotion/styled':
+        optional: true
+      '@mui/material-pigment-css':
+        optional: true
+      '@types/react':
+        optional: true
+
+  '@mui/private-theming@6.3.0':
+    resolution: {integrity: sha512-tdS8jvqMokltNTXg6ioRCCbVdDmZUJZa/T9VtTnX2Lwww3FTgCakst9tWLZSxm1fEE9Xp0m7onZJmgeUmWQYVw==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@mui/styled-engine@6.3.0':
+    resolution: {integrity: sha512-iWA6eyiPkO07AlHxRUvI7dwVRSc+84zV54kLmjUms67GJeOWVuXlu8ZO+UhCnwJxHacghxnabsMEqet5PYQmHg==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@emotion/react': ^11.4.1
+      '@emotion/styled': ^11.3.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/react':
+        optional: true
+      '@emotion/styled':
+        optional: true
+
+  '@mui/system@6.3.0':
+    resolution: {integrity: sha512-L+8hUHMNlfReKSqcnVslFrVhoNfz/jw7Fe9NfDE85R3KarvZ4O3MU9daF/lZeqEAvnYxEilkkTfDwQ7qCgJdFg==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@emotion/react': ^11.5.0
+      '@emotion/styled': ^11.3.0
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/react':
+        optional: true
+      '@emotion/styled':
+        optional: true
+      '@types/react':
+        optional: true
+
+  '@mui/types@7.2.20':
+    resolution: {integrity: sha512-straFHD7L8v05l/N5vcWk+y7eL9JF0C2mtph/y4BPm3gn2Eh61dDwDB65pa8DLss3WJfDXYC7Kx5yjP0EmXpgw==}
+    peerDependencies:
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@mui/utils@6.3.0':
+    resolution: {integrity: sha512-MkDBF08OPVwXhAjedyMykRojgvmf0y/jxkBWjystpfI/pasyTYrfdv4jic6s7j3y2+a+SJzS9qrD6X8ZYj/8AQ==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      '@types/react': ^17.0.0 || ^18.0.0 || ^19.0.0
+      react: ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@nodelib/fs.scandir@2.1.5':
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.stat@2.0.5':
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.walk@1.2.8':
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+
+  '@pkgr/core@0.1.1':
+    resolution: {integrity: sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
+
+  '@popperjs/core@2.11.8':
+    resolution: {integrity: sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==}
+
+  '@protobufjs/aspromise@1.1.2':
+    resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==}
+
+  '@protobufjs/base64@1.1.2':
+    resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==}
+
+  '@protobufjs/codegen@2.0.4':
+    resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==}
+
+  '@protobufjs/eventemitter@1.1.0':
+    resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==}
+
+  '@protobufjs/fetch@1.1.0':
+    resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==}
+
+  '@protobufjs/float@1.0.2':
+    resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==}
+
+  '@protobufjs/inquire@1.1.0':
+    resolution: {integrity: sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==}
+
+  '@protobufjs/path@1.1.2':
+    resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==}
+
+  '@protobufjs/pool@1.1.0':
+    resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==}
+
+  '@protobufjs/utf8@1.1.0':
+    resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==}
+
+  '@rollup/rollup-android-arm-eabi@4.29.1':
+    resolution: {integrity: sha512-ssKhA8RNltTZLpG6/QNkCSge+7mBQGUqJRisZ2MDQcEGaK93QESEgWK2iOpIDZ7k9zPVkG5AS3ksvD5ZWxmItw==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.29.1':
+    resolution: {integrity: sha512-CaRfrV0cd+NIIcVVN/jx+hVLN+VRqnuzLRmfmlzpOzB87ajixsN/+9L5xNmkaUUvEbI5BmIKS+XTwXsHEb65Ew==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.29.1':
+    resolution: {integrity: sha512-2ORr7T31Y0Mnk6qNuwtyNmy14MunTAMx06VAPI6/Ju52W10zk1i7i5U3vlDRWjhOI5quBcrvhkCHyF76bI7kEw==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.29.1':
+    resolution: {integrity: sha512-j/Ej1oanzPjmN0tirRd5K2/nncAhS9W6ICzgxV+9Y5ZsP0hiGhHJXZ2JQ53iSSjj8m6cRY6oB1GMzNn2EUt6Ng==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-freebsd-arm64@4.29.1':
+    resolution: {integrity: sha512-91C//G6Dm/cv724tpt7nTyP+JdN12iqeXGFM1SqnljCmi5yTXriH7B1r8AD9dAZByHpKAumqP1Qy2vVNIdLZqw==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/rollup-freebsd-x64@4.29.1':
+    resolution: {integrity: sha512-hEioiEQ9Dec2nIRoeHUP6hr1PSkXzQaCUyqBDQ9I9ik4gCXQZjJMIVzoNLBRGet+hIUb3CISMh9KXuCcWVW/8w==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.29.1':
+    resolution: {integrity: sha512-Py5vFd5HWYN9zxBv3WMrLAXY3yYJ6Q/aVERoeUFwiDGiMOWsMs7FokXihSOaT/PMWUty/Pj60XDQndK3eAfE6A==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.29.1':
+    resolution: {integrity: sha512-RiWpGgbayf7LUcuSNIbahr0ys2YnEERD4gYdISA06wa0i8RALrnzflh9Wxii7zQJEB2/Eh74dX4y/sHKLWp5uQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-gnu@4.29.1':
+    resolution: {integrity: sha512-Z80O+taYxTQITWMjm/YqNoe9d10OX6kDh8X5/rFCMuPqsKsSyDilvfg+vd3iXIqtfmp+cnfL1UrYirkaF8SBZA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-musl@4.29.1':
+    resolution: {integrity: sha512-fOHRtF9gahwJk3QVp01a/GqS4hBEZCV1oKglVVq13kcK3NeVlS4BwIFzOHDbmKzt3i0OuHG4zfRP0YoG5OF/rA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-loongarch64-gnu@4.29.1':
+    resolution: {integrity: sha512-5a7q3tnlbcg0OodyxcAdrrCxFi0DgXJSoOuidFUzHZ2GixZXQs6Tc3CHmlvqKAmOs5eRde+JJxeIf9DonkmYkw==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/rollup-linux-powerpc64le-gnu@4.29.1':
+    resolution: {integrity: sha512-9b4Mg5Yfz6mRnlSPIdROcfw1BU22FQxmfjlp/CShWwO3LilKQuMISMTtAu/bxmmrE6A902W2cZJuzx8+gJ8e9w==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.29.1':
+    resolution: {integrity: sha512-G5pn0NChlbRM8OJWpJFMX4/i8OEU538uiSv0P6roZcbpe/WfhEO+AT8SHVKfp8qhDQzaz7Q+1/ixMy7hBRidnQ==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-s390x-gnu@4.29.1':
+    resolution: {integrity: sha512-WM9lIkNdkhVwiArmLxFXpWndFGuOka4oJOZh8EP3Vb8q5lzdSCBuhjavJsw68Q9AKDGeOOIHYzYm4ZFvmWez5g==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-gnu@4.29.1':
+    resolution: {integrity: sha512-87xYCwb0cPGZFoGiErT1eDcssByaLX4fc0z2nRM6eMtV9njAfEE6OW3UniAoDhX4Iq5xQVpE6qO9aJbCFumKYQ==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-musl@4.29.1':
+    resolution: {integrity: sha512-xufkSNppNOdVRCEC4WKvlR1FBDyqCSCpQeMMgv9ZyXqqtKBfkw1yfGMTUTs9Qsl6WQbJnsGboWCp7pJGkeMhKA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-win32-arm64-msvc@4.29.1':
+    resolution: {integrity: sha512-F2OiJ42m77lSkizZQLuC+jiZ2cgueWQL5YC9tjo3AgaEw+KJmVxHGSyQfDUoYR9cci0lAywv2Clmckzulcq6ig==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.29.1':
+    resolution: {integrity: sha512-rYRe5S0FcjlOBZQHgbTKNrqxCBUmgDJem/VQTCcTnA2KCabYSWQDrytOzX7avb79cAAweNmMUb/Zw18RNd4mng==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.29.1':
+    resolution: {integrity: sha512-+10CMg9vt1MoHj6x1pxyjPSMjHTIlqs8/tBztXvPAx24SKs9jwVnKqHJumlH/IzhaPUaj3T6T6wfZr8okdXaIg==}
+    cpu: [x64]
+    os: [win32]
+
+  '@types/babel__core@7.20.5':
+    resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
+
+  '@types/babel__generator@7.6.8':
+    resolution: {integrity: sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw==}
+
+  '@types/babel__template@7.4.4':
+    resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
+
+  '@types/babel__traverse@7.20.6':
+    resolution: {integrity: sha512-r1bzfrm0tomOI8g1SzvCaQHo6Lcv6zu0EA+W2kHrt8dyrHQxGzBBL4kdkzIS+jBMV+EYcMAEAqXqYaLJq5rOZg==}
+
+  '@types/cookie@0.6.0':
+    resolution: {integrity: sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==}
+
+  '@types/estree@1.0.6':
+    resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==}
+
+  '@types/json-schema@7.0.15':
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
+  '@types/node@22.10.2':
+    resolution: {integrity: sha512-Xxr6BBRCAOQixvonOye19wnzyDiUtTeqldOOmj3CkeblonbccA12PFwlufvRdrpjXxqnmUaeiU5EOA+7s5diUQ==}
+
+  '@types/parse-json@4.0.2':
+    resolution: {integrity: sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==}
+
+  '@types/prop-types@15.7.14':
+    resolution: {integrity: sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==}
+
+  '@types/react-dom@18.3.5':
+    resolution: {integrity: sha512-P4t6saawp+b/dFrUr2cvkVsfvPguwsxtH6dNIYRllMsefqFzkZk5UIjzyDOv5g1dXIPdG4Sp1yCR4Z6RCUsG/Q==}
+    peerDependencies:
+      '@types/react': ^18.0.0
+
+  '@types/react-transition-group@4.4.12':
+    resolution: {integrity: sha512-8TV6R3h2j7a91c+1DXdJi3Syo69zzIZbz7Lg5tORM5LEJG7X/E6a1V3drRyBRZq7/utz7A+c4OgYLiLcYGHG6w==}
+    peerDependencies:
+      '@types/react': '*'
+
+  '@types/react-window@1.8.8':
+    resolution: {integrity: sha512-8Ls660bHR1AUA2kuRvVG9D/4XpRC6wjAaPT9dil7Ckc76eP9TKWZwwmgfq8Q1LANX3QNDnoU4Zp48A3w+zK69Q==}
+
+  '@types/react@18.3.18':
+    resolution: {integrity: sha512-t4yC+vtgnkYjNSKlFx1jkAhH8LgTo2N/7Qvi83kdEaUtMDiwpbLAktKDaAMlRcJ5eSxZkH74eEGt1ky31d7kfQ==}
+
+  '@typescript-eslint/eslint-plugin@8.18.2':
+    resolution: {integrity: sha512-adig4SzPLjeQ0Tm+jvsozSGiCliI2ajeURDGHjZ2llnA+A67HihCQ+a3amtPhUakd1GlwHxSRvzOZktbEvhPPg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      '@typescript-eslint/parser': ^8.0.0 || ^8.0.0-alpha.0
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <5.8.0'
+
+  '@typescript-eslint/parser@8.18.2':
+    resolution: {integrity: sha512-y7tcq4StgxQD4mDr9+Jb26dZ+HTZ/SkfqpXSiqeUXZHxOUyjWDKsmwKhJ0/tApR08DgOhrFAoAhyB80/p3ViuA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <5.8.0'
+
+  '@typescript-eslint/scope-manager@8.18.2':
+    resolution: {integrity: sha512-YJFSfbd0CJjy14r/EvWapYgV4R5CHzptssoag2M7y3Ra7XNta6GPAJPPP5KGB9j14viYXyrzRO5GkX7CRfo8/g==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/type-utils@8.18.2':
+    resolution: {integrity: sha512-AB/Wr1Lz31bzHfGm/jgbFR0VB0SML/hd2P1yxzKDM48YmP7vbyJNHRExUE/wZsQj2wUCvbWH8poNHFuxLqCTnA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <5.8.0'
+
+  '@typescript-eslint/types@8.18.2':
+    resolution: {integrity: sha512-Z/zblEPp8cIvmEn6+tPDIHUbRu/0z5lqZ+NvolL5SvXWT5rQy7+Nch83M0++XzO0XrWRFWECgOAyE8bsJTl1GQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/typescript-estree@8.18.2':
+    resolution: {integrity: sha512-WXAVt595HjpmlfH4crSdM/1bcsqh+1weFRWIa9XMTx/XHZ9TCKMcr725tLYqWOgzKdeDrqVHxFotrvWcEsk2Tg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <5.8.0'
+
+  '@typescript-eslint/utils@8.18.2':
+    resolution: {integrity: sha512-Cr4A0H7DtVIPkauj4sTSXVl+VBWewE9/o40KcF3TV9aqDEOWoXF3/+oRXNby3DYzZeCATvbdksYsGZzplwnK/Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <5.8.0'
+
+  '@typescript-eslint/visitor-keys@8.18.2':
+    resolution: {integrity: sha512-zORcwn4C3trOWiCqFQP1x6G3xTRyZ1LYydnj51cRnJ6hxBlr/cKPckk+PKPUw/fXmvfKTcw7bwY3w9izgx5jZw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@uidotdev/usehooks@2.4.1':
+    resolution: {integrity: sha512-1I+RwWyS+kdv3Mv0Vmc+p0dPYH0DTRAo04HLyXReYBL9AeseDWUJyi4THuksBJcu9F0Pih69Ak150VDnqbVnXg==}
+    engines: {node: '>=16'}
+    peerDependencies:
+      react: '>=18.0.0'
+      react-dom: '>=18.0.0'
+
+  '@vitejs/plugin-react@4.3.4':
+    resolution: {integrity: sha512-SCCPBJtYLdE8PX/7ZQAs1QAZ8Jqwih+0VBLum1EGqmCCQal+MIUqLCzj3ZUy8ufbC0cAM4LRlSTm7IQJwWT4ug==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      vite: ^4.2.0 || ^5.0.0 || ^6.0.0
+
+  acorn-jsx@5.3.2:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
+  acorn@8.14.0:
+    resolution: {integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  ajv@6.12.6:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+
+  ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+
+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  asynckit@0.4.0:
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
+
+  axios@1.7.9:
+    resolution: {integrity: sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==}
+
+  babel-plugin-macros@3.1.0:
+    resolution: {integrity: sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==}
+    engines: {node: '>=10', npm: '>=6'}
+
+  balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  brace-expansion@1.1.11:
+    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+
+  brace-expansion@2.0.1:
+    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  browserslist@4.24.3:
+    resolution: {integrity: sha512-1CPmv8iobE2fyRMV97dAcMVegvvWKxmq94hkLiAkUGwKVTyDLw33K+ZxiFrREKmmps4rIw6grcCFCnTMSZ/YiA==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+
+  callsites@3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+
+  caniuse-lite@1.0.30001690:
+    resolution: {integrity: sha512-5ExiE3qQN6oF8Clf8ifIDcMRCRE/dMGcETG/XGMD8/XiXm6HXQgQTh1yZYLXXpSOsEUlJm1Xr7kGULZTuGtP/w==}
+
+  centrifuge@5.2.2:
+    resolution: {integrity: sha512-d1PW3HxtmN7rMhtaDeLgZnSuXuTqoWhlZPC/pm0UwzTnBve1QlMgzY4DHQ21mpQYEeVGes46KKXj0cZP7/uZrw==}
+
+  chalk@4.1.2:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+
+  clsx@2.1.1:
+    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
+    engines: {node: '>=6'}
+
+  color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+
+  color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+
+  combined-stream@1.0.8:
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
+
+  concat-map@0.0.1:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  convert-source-map@1.9.0:
+    resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==}
+
+  convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+  cookie@1.0.2:
+    resolution: {integrity: sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==}
+    engines: {node: '>=18'}
+
+  cosmiconfig@7.1.0:
+    resolution: {integrity: sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==}
+    engines: {node: '>=10'}
+
+  cross-spawn@7.0.6:
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
+
+  csstype@3.1.3:
+    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
+
+  debug@4.4.0:
+    resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  deep-is@0.1.4:
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
+
+  delayed-stream@1.0.0:
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
+    engines: {node: '>=0.4.0'}
+
+  dom-helpers@5.2.1:
+    resolution: {integrity: sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==}
+
+  electron-to-chromium@1.5.76:
+    resolution: {integrity: sha512-CjVQyG7n7Sr+eBXE86HIulnL5N8xZY1sgmOPGuq/F0Rr0FJq63lg0kEtOIDfZBk44FnDLf6FUJ+dsJcuiUDdDQ==}
+
+  error-ex@1.3.2:
+    resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
+
+  esbuild@0.24.2:
+    resolution: {integrity: sha512-+9egpBW8I3CD5XPe0n6BfT5fxLzxrlDzqydF3aviG+9ni1lDC/OvMHcxqEFV0+LANZG5R1bFMWfUrjVsdwxJvA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  escape-string-regexp@4.0.0:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+
+  eslint-config-prettier@9.1.0:
+    resolution: {integrity: sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==}
+    hasBin: true
+    peerDependencies:
+      eslint: '>=7.0.0'
+
+  eslint-plugin-prettier@5.2.1:
+    resolution: {integrity: sha512-gH3iR3g4JfF+yYPaJYkN7jEl9QbweL/YfkoRlNnuIEHEz1vHVlCmWOS+eGGiRuzHQXdJFCOTxRgvju9b8VUmrw==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      '@types/eslint': '>=8.0.0'
+      eslint: '>=8.0.0'
+      eslint-config-prettier: '*'
+      prettier: '>=3.0.0'
+    peerDependenciesMeta:
+      '@types/eslint':
+        optional: true
+      eslint-config-prettier:
+        optional: true
+
+  eslint-plugin-react-hooks@5.1.0:
+    resolution: {integrity: sha512-mpJRtPgHN2tNAvZ35AMfqeB3Xqeo273QxrHJsbBEPWODRM4r0yB6jfoROqKEYrOn27UtRPpcpHc2UqyBSuUNTw==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0
+
+  eslint-plugin-react-refresh@0.4.16:
+    resolution: {integrity: sha512-slterMlxAhov/DZO8NScf6mEeMBBXodFUolijDvrtTxyezyLoTQaa73FyYus/VbTdftd8wBgBxPMRk3poleXNQ==}
+    peerDependencies:
+      eslint: '>=8.40'
+
+  eslint-scope@8.2.0:
+    resolution: {integrity: sha512-PHlWUfG6lvPc3yvP5A4PNyBL1W8fkDUccmI21JUu/+GKZBoH/W5u6usENXUrWFRsyoW5ACUjFGgAFQp5gUlb/A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  eslint-visitor-keys@3.4.3:
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  eslint-visitor-keys@4.2.0:
+    resolution: {integrity: sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  eslint@9.17.0:
+    resolution: {integrity: sha512-evtlNcpJg+cZLcnVKwsai8fExnqjGPicK7gnUtlNuzu+Fv9bI0aLpND5T44VLQtoMEnI57LoXO9XAkIXwohKrA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+
+  espree@10.3.0:
+    resolution: {integrity: sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  esquery@1.6.0:
+    resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
+    engines: {node: '>=0.10'}
+
+  esrecurse@4.3.0:
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
+
+  estraverse@5.3.0:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+
+  esutils@2.0.3:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+
+  events@3.3.0:
+    resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
+    engines: {node: '>=0.8.x'}
+
+  fast-deep-equal@3.1.3:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+
+  fast-diff@1.3.0:
+    resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==}
+
+  fast-glob@3.3.2:
+    resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==}
+    engines: {node: '>=8.6.0'}
+
+  fast-json-stable-stringify@2.1.0:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+
+  fast-levenshtein@2.0.6:
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
+
+  fastq@1.18.0:
+    resolution: {integrity: sha512-QKHXPW0hD8g4UET03SdOdunzSouc9N4AuHdsX8XNcTsuz+yYFILVNIX4l9yHABMhiEI9Db0JTTIpu0wB+Y1QQw==}
+
+  file-entry-cache@8.0.0:
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  find-root@1.1.0:
+    resolution: {integrity: sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==}
+
+  find-up@5.0.0:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+
+  flat-cache@4.0.1:
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
+
+  flatted@3.3.2:
+    resolution: {integrity: sha512-AiwGJM8YcNOaobumgtng+6NHuOqC3A7MixFeDafM3X9cIUM+xUXoS5Vfgf+OihAYe20fxqNM9yPBXJzRtZ/4eA==}
+
+  follow-redirects@1.15.9:
+    resolution: {integrity: sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
+  form-data@4.0.1:
+    resolution: {integrity: sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==}
+    engines: {node: '>= 6'}
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  gensync@1.0.0-beta.2:
+    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
+    engines: {node: '>=6.9.0'}
+
+  glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  glob-parent@6.0.2:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+
+  globals@11.12.0:
+    resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
+    engines: {node: '>=4'}
+
+  globals@14.0.0:
+    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
+    engines: {node: '>=18'}
+
+  globals@15.14.0:
+    resolution: {integrity: sha512-OkToC372DtlQeje9/zHIo5CT8lRP/FUgEOKBEhU4e0abL7J7CD24fD9ohiLN5hagG/kWCYj4K5oaxxtj2Z0Dig==}
+    engines: {node: '>=18'}
+
+  graphemer@1.4.0:
+    resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==}
+
+  has-flag@4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+
+  hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
+
+  hoist-non-react-statics@3.3.2:
+    resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==}
+
+  ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  import-fresh@3.3.0:
+    resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==}
+    engines: {node: '>=6'}
+
+  imurmurhash@0.1.4:
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
+    engines: {node: '>=0.8.19'}
+
+  is-arrayish@0.2.1:
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+
+  is-core-module@2.16.1:
+    resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
+    engines: {node: '>= 0.4'}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  isexe@2.0.0:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  js-yaml@4.1.0:
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+    hasBin: true
+
+  jsesc@3.1.0:
+    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  json-buffer@3.0.1:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+
+  json-parse-even-better-errors@2.3.1:
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+
+  json-schema-traverse@0.4.1:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+
+  json-stable-stringify-without-jsonify@1.0.1:
+    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
+
+  json5@2.2.3:
+    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  keyv@4.5.4:
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
+
+  levn@0.4.1:
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
+
+  lines-and-columns@1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+
+  locate-path@6.0.0:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+
+  lodash.merge@4.6.2:
+    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
+
+  long@5.2.3:
+    resolution: {integrity: sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==}
+
+  loose-envify@1.4.0:
+    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
+    hasBin: true
+
+  lru-cache@5.1.1:
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
+
+  memoize-one@5.2.1:
+    resolution: {integrity: sha512-zYiwtZUcYyXKo/np96AGZAckk+FWWsUdJ3cHGGmld7+AhvcWmQyGCYUh1hc4Q/pkOhb65dQR/pqCyK0cOaHz4Q==}
+
+  merge2@1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+
+  mime-db@1.52.0:
+    resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
+    engines: {node: '>= 0.6'}
+
+  mime-types@2.1.35:
+    resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
+    engines: {node: '>= 0.6'}
+
+  minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+
+  minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  nanoid@3.3.8:
+    resolution: {integrity: sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  natural-compare@1.4.0:
+    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
+
+  node-releases@2.0.19:
+    resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==}
+
+  object-assign@4.1.1:
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
+
+  optionator@0.9.4:
+    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
+    engines: {node: '>= 0.8.0'}
+
+  p-limit@3.1.0:
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
+
+  p-locate@5.0.0:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+
+  parent-module@1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+
+  parse-json@5.2.0:
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
+
+  path-exists@4.0.0:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+
+  path-key@3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+
+  path-parse@1.0.7:
+    resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
+
+  path-type@4.0.0:
+    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+    engines: {node: '>=8'}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+
+  postcss@8.4.49:
+    resolution: {integrity: sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  prelude-ls@1.2.1:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+
+  prettier-linter-helpers@1.0.0:
+    resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==}
+    engines: {node: '>=6.0.0'}
+
+  prettier@3.4.2:
+    resolution: {integrity: sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  prop-types@15.8.1:
+    resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==}
+
+  protobufjs@7.4.0:
+    resolution: {integrity: sha512-mRUWCc3KUU4w1jU8sGxICXH/gNS94DvI1gxqDvBzhj1JpcsimQkYiOJfwsPUykUI5ZaspFbSgmBLER8IrQ3tqw==}
+    engines: {node: '>=12.0.0'}
+
+  proxy-from-env@1.1.0:
+    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
+
+  punycode@2.3.1:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
+  queue-microtask@1.2.3:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+
+  react-dom@19.0.0:
+    resolution: {integrity: sha512-4GV5sHFG0e/0AD4X+ySy6UJd3jVl1iNsNHdpad0qhABJ11twS3TTBnseqsKurKcsNqCEFeGL3uLpVChpIO3QfQ==}
+    peerDependencies:
+      react: ^19.0.0
+
+  react-is@16.13.1:
+    resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
+
+  react-is@19.0.0:
+    resolution: {integrity: sha512-H91OHcwjZsbq3ClIDHMzBShc1rotbfACdWENsmEf0IFvZ3FgGPtdHMcsv45bQ1hAbgdfiA8SnxTKfDS+x/8m2g==}
+
+  react-refresh@0.14.2:
+    resolution: {integrity: sha512-jCvmsr+1IUSMUyzOkRcvnVbX3ZYC6g9TDrDbFuFmRDq7PD4yaGbLKNQL6k2jnArV8hjYxh7hVhAZB6s9HDGpZA==}
+    engines: {node: '>=0.10.0'}
+
+  react-router@7.1.1:
+    resolution: {integrity: sha512-39sXJkftkKWRZ2oJtHhCxmoCrBCULr/HAH4IT5DHlgu/Q0FCPV0S4Lx+abjDTx/74xoZzNYDYbOZWlJjruyuDQ==}
+    engines: {node: '>=20.0.0'}
+    peerDependencies:
+      react: '>=18'
+      react-dom: '>=18'
+    peerDependenciesMeta:
+      react-dom:
+        optional: true
+
+  react-transition-group@4.4.5:
+    resolution: {integrity: sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==}
+    peerDependencies:
+      react: '>=16.6.0'
+      react-dom: '>=16.6.0'
+
+  react-window@1.8.11:
+    resolution: {integrity: sha512-+SRbUVT2scadgFSWx+R1P754xHPEqvcfSfVX10QYg6POOz+WNgkN48pS+BtZNIMGiL1HYrSEiCkwsMS15QogEQ==}
+    engines: {node: '>8.0.0'}
+    peerDependencies:
+      react: ^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
+  react@19.0.0:
+    resolution: {integrity: sha512-V8AVnmPIICiWpGfm6GLzCR/W5FXLchHop40W4nXBmdlEceh16rCN8O8LNWm5bh5XUX91fh7KpA+W0TgMKmgTpQ==}
+    engines: {node: '>=0.10.0'}
+
+  regenerator-runtime@0.14.1:
+    resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==}
+
+  resolve-from@4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+
+  resolve@1.22.10:
+    resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==}
+    engines: {node: '>= 0.4'}
+    hasBin: true
+
+  reusify@1.0.4:
+    resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+
+  rollup@4.29.1:
+    resolution: {integrity: sha512-RaJ45M/kmJUzSWDs1Nnd5DdV4eerC98idtUOVr6FfKcgxqvjwHmxc5upLF9qZU9EpsVzzhleFahrT3shLuJzIw==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  run-parallel@1.2.0:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+
+  scheduler@0.25.0:
+    resolution: {integrity: sha512-xFVuu11jh+xcO7JOAGJNOXld8/TcEHK/4CituBUeUb5hqxJLj9YuemAEuvm9gQ/+pgXYfbQuqAkiYu+u7YEsNA==}
+
+  semver@6.3.1:
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
+    hasBin: true
+
+  semver@7.6.3:
+    resolution: {integrity: sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  set-cookie-parser@2.7.1:
+    resolution: {integrity: sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==}
+
+  shebang-command@2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+
+  shebang-regex@3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  source-map@0.5.7:
+    resolution: {integrity: sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==}
+    engines: {node: '>=0.10.0'}
+
+  strip-json-comments@3.1.1:
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
+
+  stylis@4.2.0:
+    resolution: {integrity: sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==}
+
+  supports-color@7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+
+  supports-preserve-symlinks-flag@1.0.0:
+    resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
+    engines: {node: '>= 0.4'}
+
+  synckit@0.9.2:
+    resolution: {integrity: sha512-vrozgXDQwYO72vHjUb/HnFbQx1exDjoKzqx23aXEg2a9VIg2TSFZ8FmeZpTjUCFMYw7mpX4BE2SFu8wI7asYsw==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  ts-api-utils@1.4.3:
+    resolution: {integrity: sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==}
+    engines: {node: '>=16'}
+    peerDependencies:
+      typescript: '>=4.2.0'
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  turbo-stream@2.4.0:
+    resolution: {integrity: sha512-FHncC10WpBd2eOmGwpmQsWLDoK4cqsA/UT/GqNoaKOQnT8uzhtCbg3EoUDMvqpOSAI0S26mr0rkjzbOO6S3v1g==}
+
+  type-check@0.4.0:
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
+
+  typescript-eslint@8.18.2:
+    resolution: {integrity: sha512-KuXezG6jHkvC3MvizeXgupZzaG5wjhU3yE8E7e6viOvAvD9xAWYp8/vy0WULTGe9DYDWcQu7aW03YIV3mSitrQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <5.8.0'
+
+  typescript@5.6.3:
+    resolution: {integrity: sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  undici-types@6.20.0:
+    resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==}
+
+  update-browserslist-db@1.1.1:
+    resolution: {integrity: sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+
+  uri-js@4.4.1:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+
+  vite@6.0.6:
+    resolution: {integrity: sha512-NSjmUuckPmDU18bHz7QZ+bTYhRR0iA72cs2QAxCqDpafJ0S6qetco0LB3WW2OxlMHS0JmAv+yZ/R3uPmMyGTjQ==}
+    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
+      jiti: '>=1.21.0'
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  which@2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+
+  word-wrap@1.2.5:
+    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
+    engines: {node: '>=0.10.0'}
+
+  yallist@3.1.1:
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
+
+  yaml@1.10.2:
+    resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==}
+    engines: {node: '>= 6'}
+
+  yocto-queue@0.1.0:
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
+
+snapshots:
+
+  '@ampproject/remapping@2.3.0':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.8
+      '@jridgewell/trace-mapping': 0.3.25
+
+  '@babel/code-frame@7.26.2':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.25.9
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/compat-data@7.26.3': {}
+
+  '@babel/core@7.26.0':
+    dependencies:
+      '@ampproject/remapping': 2.3.0
+      '@babel/code-frame': 7.26.2
+      '@babel/generator': 7.26.3
+      '@babel/helper-compilation-targets': 7.25.9
+      '@babel/helper-module-transforms': 7.26.0(@babel/core@7.26.0)
+      '@babel/helpers': 7.26.0
+      '@babel/parser': 7.26.3
+      '@babel/template': 7.25.9
+      '@babel/traverse': 7.26.4
+      '@babel/types': 7.26.3
+      convert-source-map: 2.0.0
+      debug: 4.4.0
+      gensync: 1.0.0-beta.2
+      json5: 2.2.3
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/generator@7.26.3':
+    dependencies:
+      '@babel/parser': 7.26.3
+      '@babel/types': 7.26.3
+      '@jridgewell/gen-mapping': 0.3.8
+      '@jridgewell/trace-mapping': 0.3.25
+      jsesc: 3.1.0
+
+  '@babel/helper-compilation-targets@7.25.9':
+    dependencies:
+      '@babel/compat-data': 7.26.3
+      '@babel/helper-validator-option': 7.25.9
+      browserslist: 4.24.3
+      lru-cache: 5.1.1
+      semver: 6.3.1
+
+  '@babel/helper-module-imports@7.25.9':
+    dependencies:
+      '@babel/traverse': 7.26.4
+      '@babel/types': 7.26.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-transforms@7.26.0(@babel/core@7.26.0)':
+    dependencies:
+      '@babel/core': 7.26.0
+      '@babel/helper-module-imports': 7.25.9
+      '@babel/helper-validator-identifier': 7.25.9
+      '@babel/traverse': 7.26.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-plugin-utils@7.25.9': {}
+
+  '@babel/helper-string-parser@7.25.9': {}
+
+  '@babel/helper-validator-identifier@7.25.9': {}
+
+  '@babel/helper-validator-option@7.25.9': {}
+
+  '@babel/helpers@7.26.0':
+    dependencies:
+      '@babel/template': 7.25.9
+      '@babel/types': 7.26.3
+
+  '@babel/parser@7.26.3':
+    dependencies:
+      '@babel/types': 7.26.3
+
+  '@babel/plugin-transform-react-jsx-self@7.25.9(@babel/core@7.26.0)':
+    dependencies:
+      '@babel/core': 7.26.0
+      '@babel/helper-plugin-utils': 7.25.9
+
+  '@babel/plugin-transform-react-jsx-source@7.25.9(@babel/core@7.26.0)':
+    dependencies:
+      '@babel/core': 7.26.0
+      '@babel/helper-plugin-utils': 7.25.9
+
+  '@babel/runtime@7.26.0':
+    dependencies:
+      regenerator-runtime: 0.14.1
+
+  '@babel/template@7.25.9':
+    dependencies:
+      '@babel/code-frame': 7.26.2
+      '@babel/parser': 7.26.3
+      '@babel/types': 7.26.3
+
+  '@babel/traverse@7.26.4':
+    dependencies:
+      '@babel/code-frame': 7.26.2
+      '@babel/generator': 7.26.3
+      '@babel/parser': 7.26.3
+      '@babel/template': 7.25.9
+      '@babel/types': 7.26.3
+      debug: 4.4.0
+      globals: 11.12.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/types@7.26.3':
+    dependencies:
+      '@babel/helper-string-parser': 7.25.9
+      '@babel/helper-validator-identifier': 7.25.9
+
+  '@bufbuild/protobuf@2.2.3': {}
+
+  '@emotion/babel-plugin@11.13.5':
+    dependencies:
+      '@babel/helper-module-imports': 7.25.9
+      '@babel/runtime': 7.26.0
+      '@emotion/hash': 0.9.2
+      '@emotion/memoize': 0.9.0
+      '@emotion/serialize': 1.3.3
+      babel-plugin-macros: 3.1.0
+      convert-source-map: 1.9.0
+      escape-string-regexp: 4.0.0
+      find-root: 1.1.0
+      source-map: 0.5.7
+      stylis: 4.2.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@emotion/cache@11.14.0':
+    dependencies:
+      '@emotion/memoize': 0.9.0
+      '@emotion/sheet': 1.4.0
+      '@emotion/utils': 1.4.2
+      '@emotion/weak-memoize': 0.4.0
+      stylis: 4.2.0
+
+  '@emotion/hash@0.9.2': {}
+
+  '@emotion/is-prop-valid@1.3.1':
+    dependencies:
+      '@emotion/memoize': 0.9.0
+
+  '@emotion/memoize@0.9.0': {}
+
+  '@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@emotion/babel-plugin': 11.13.5
+      '@emotion/cache': 11.14.0
+      '@emotion/serialize': 1.3.3
+      '@emotion/use-insertion-effect-with-fallbacks': 1.2.0(react@19.0.0)
+      '@emotion/utils': 1.4.2
+      '@emotion/weak-memoize': 0.4.0
+      hoist-non-react-statics: 3.3.2
+      react: 19.0.0
+    optionalDependencies:
+      '@types/react': 18.3.18
+    transitivePeerDependencies:
+      - supports-color
+
+  '@emotion/serialize@1.3.3':
+    dependencies:
+      '@emotion/hash': 0.9.2
+      '@emotion/memoize': 0.9.0
+      '@emotion/unitless': 0.10.0
+      '@emotion/utils': 1.4.2
+      csstype: 3.1.3
+
+  '@emotion/sheet@1.4.0': {}
+
+  '@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@emotion/babel-plugin': 11.13.5
+      '@emotion/is-prop-valid': 1.3.1
+      '@emotion/react': 11.14.0(@types/react@18.3.18)(react@19.0.0)
+      '@emotion/serialize': 1.3.3
+      '@emotion/use-insertion-effect-with-fallbacks': 1.2.0(react@19.0.0)
+      '@emotion/utils': 1.4.2
+      react: 19.0.0
+    optionalDependencies:
+      '@types/react': 18.3.18
+    transitivePeerDependencies:
+      - supports-color
+
+  '@emotion/unitless@0.10.0': {}
+
+  '@emotion/use-insertion-effect-with-fallbacks@1.2.0(react@19.0.0)':
+    dependencies:
+      react: 19.0.0
+
+  '@emotion/utils@1.4.2': {}
+
+  '@emotion/weak-memoize@0.4.0': {}
+
+  '@esbuild/aix-ppc64@0.24.2':
+    optional: true
+
+  '@esbuild/android-arm64@0.24.2':
+    optional: true
+
+  '@esbuild/android-arm@0.24.2':
+    optional: true
+
+  '@esbuild/android-x64@0.24.2':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.24.2':
+    optional: true
+
+  '@esbuild/darwin-x64@0.24.2':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.24.2':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.24.2':
+    optional: true
+
+  '@esbuild/linux-arm64@0.24.2':
+    optional: true
+
+  '@esbuild/linux-arm@0.24.2':
+    optional: true
+
+  '@esbuild/linux-ia32@0.24.2':
+    optional: true
+
+  '@esbuild/linux-loong64@0.24.2':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.24.2':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.24.2':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.24.2':
+    optional: true
+
+  '@esbuild/linux-s390x@0.24.2':
+    optional: true
+
+  '@esbuild/linux-x64@0.24.2':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.24.2':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.24.2':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.24.2':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.24.2':
+    optional: true
+
+  '@esbuild/sunos-x64@0.24.2':
+    optional: true
+
+  '@esbuild/win32-arm64@0.24.2':
+    optional: true
+
+  '@esbuild/win32-ia32@0.24.2':
+    optional: true
+
+  '@esbuild/win32-x64@0.24.2':
+    optional: true
+
+  '@eslint-community/eslint-utils@4.4.1(eslint@9.17.0)':
+    dependencies:
+      eslint: 9.17.0
+      eslint-visitor-keys: 3.4.3
+
+  '@eslint-community/regexpp@4.12.1': {}
+
+  '@eslint/config-array@0.19.1':
+    dependencies:
+      '@eslint/object-schema': 2.1.5
+      debug: 4.4.0
+      minimatch: 3.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/core@0.9.1':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@eslint/eslintrc@3.2.0':
+    dependencies:
+      ajv: 6.12.6
+      debug: 4.4.0
+      espree: 10.3.0
+      globals: 14.0.0
+      ignore: 5.3.2
+      import-fresh: 3.3.0
+      js-yaml: 4.1.0
+      minimatch: 3.1.2
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/js@9.17.0': {}
+
+  '@eslint/object-schema@2.1.5': {}
+
+  '@eslint/plugin-kit@0.2.4':
+    dependencies:
+      levn: 0.4.1
+
+  '@floating-ui/core@1.6.8':
+    dependencies:
+      '@floating-ui/utils': 0.2.8
+
+  '@floating-ui/dom@1.6.12':
+    dependencies:
+      '@floating-ui/core': 1.6.8
+      '@floating-ui/utils': 0.2.8
+
+  '@floating-ui/react-dom@2.1.2(react-dom@19.0.0(react@19.0.0))(react@19.0.0)':
+    dependencies:
+      '@floating-ui/dom': 1.6.12
+      react: 19.0.0
+      react-dom: 19.0.0(react@19.0.0)
+
+  '@floating-ui/utils@0.2.8': {}
+
+  '@humanfs/core@0.19.1': {}
+
+  '@humanfs/node@0.16.6':
+    dependencies:
+      '@humanfs/core': 0.19.1
+      '@humanwhocodes/retry': 0.3.1
+
+  '@humanwhocodes/module-importer@1.0.1': {}
+
+  '@humanwhocodes/retry@0.3.1': {}
+
+  '@humanwhocodes/retry@0.4.1': {}
+
+  '@jridgewell/gen-mapping@0.3.8':
+    dependencies:
+      '@jridgewell/set-array': 1.2.1
+      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/trace-mapping': 0.3.25
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/set-array@1.2.1': {}
+
+  '@jridgewell/sourcemap-codec@1.5.0': {}
+
+  '@jridgewell/trace-mapping@0.3.25':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.0
+
+  '@mui/base@5.0.0-beta.68(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@floating-ui/react-dom': 2.1.2(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      '@mui/types': 7.2.20(@types/react@18.3.18)
+      '@mui/utils': 6.3.0(@types/react@18.3.18)(react@19.0.0)
+      '@popperjs/core': 2.11.8
+      clsx: 2.1.1
+      prop-types: 15.8.1
+      react: 19.0.0
+      react-dom: 19.0.0(react@19.0.0)
+    optionalDependencies:
+      '@types/react': 18.3.18
+
+  '@mui/core-downloads-tracker@6.3.0': {}
+
+  '@mui/icons-material@6.3.0(@mui/material@6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@mui/material': 6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      react: 19.0.0
+    optionalDependencies:
+      '@types/react': 18.3.18
+
+  '@mui/lab@6.0.0-beta.21(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@mui/material@6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@mui/base': 5.0.0-beta.68(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      '@mui/material': 6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+      '@mui/system': 6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+      '@mui/types': 7.2.20(@types/react@18.3.18)
+      '@mui/utils': 6.3.0(@types/react@18.3.18)(react@19.0.0)
+      clsx: 2.1.1
+      prop-types: 15.8.1
+      react: 19.0.0
+      react-dom: 19.0.0(react@19.0.0)
+    optionalDependencies:
+      '@emotion/react': 11.14.0(@types/react@18.3.18)(react@19.0.0)
+      '@emotion/styled': 11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+      '@types/react': 18.3.18
+
+  '@mui/material@6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@mui/core-downloads-tracker': 6.3.0
+      '@mui/system': 6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+      '@mui/types': 7.2.20(@types/react@18.3.18)
+      '@mui/utils': 6.3.0(@types/react@18.3.18)(react@19.0.0)
+      '@popperjs/core': 2.11.8
+      '@types/react-transition-group': 4.4.12(@types/react@18.3.18)
+      clsx: 2.1.1
+      csstype: 3.1.3
+      prop-types: 15.8.1
+      react: 19.0.0
+      react-dom: 19.0.0(react@19.0.0)
+      react-is: 19.0.0
+      react-transition-group: 4.4.5(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
+    optionalDependencies:
+      '@emotion/react': 11.14.0(@types/react@18.3.18)(react@19.0.0)
+      '@emotion/styled': 11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+      '@types/react': 18.3.18
+
+  '@mui/private-theming@6.3.0(@types/react@18.3.18)(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@mui/utils': 6.3.0(@types/react@18.3.18)(react@19.0.0)
+      prop-types: 15.8.1
+      react: 19.0.0
+    optionalDependencies:
+      '@types/react': 18.3.18
+
+  '@mui/styled-engine@6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@emotion/cache': 11.14.0
+      '@emotion/serialize': 1.3.3
+      '@emotion/sheet': 1.4.0
+      csstype: 3.1.3
+      prop-types: 15.8.1
+      react: 19.0.0
+    optionalDependencies:
+      '@emotion/react': 11.14.0(@types/react@18.3.18)(react@19.0.0)
+      '@emotion/styled': 11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+
+  '@mui/system@6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@mui/private-theming': 6.3.0(@types/react@18.3.18)(react@19.0.0)
+      '@mui/styled-engine': 6.3.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@emotion/styled@11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0))(react@19.0.0)
+      '@mui/types': 7.2.20(@types/react@18.3.18)
+      '@mui/utils': 6.3.0(@types/react@18.3.18)(react@19.0.0)
+      clsx: 2.1.1
+      csstype: 3.1.3
+      prop-types: 15.8.1
+      react: 19.0.0
+    optionalDependencies:
+      '@emotion/react': 11.14.0(@types/react@18.3.18)(react@19.0.0)
+      '@emotion/styled': 11.14.0(@emotion/react@11.14.0(@types/react@18.3.18)(react@19.0.0))(@types/react@18.3.18)(react@19.0.0)
+      '@types/react': 18.3.18
+
+  '@mui/types@7.2.20(@types/react@18.3.18)':
+    optionalDependencies:
+      '@types/react': 18.3.18
+
+  '@mui/utils@6.3.0(@types/react@18.3.18)(react@19.0.0)':
+    dependencies:
+      '@babel/runtime': 7.26.0
+      '@mui/types': 7.2.20(@types/react@18.3.18)
+      '@types/prop-types': 15.7.14
+      clsx: 2.1.1
+      prop-types: 15.8.1
+      react: 19.0.0
+      react-is: 19.0.0
+    optionalDependencies:
+      '@types/react': 18.3.18
+
+  '@nodelib/fs.scandir@2.1.5':
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+
+  '@nodelib/fs.stat@2.0.5': {}
+
+  '@nodelib/fs.walk@1.2.8':
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.18.0
+
+  '@pkgr/core@0.1.1': {}
+
+  '@popperjs/core@2.11.8': {}
+
+  '@protobufjs/aspromise@1.1.2': {}
+
+  '@protobufjs/base64@1.1.2': {}
+
+  '@protobufjs/codegen@2.0.4': {}
+
+  '@protobufjs/eventemitter@1.1.0': {}
+
+  '@protobufjs/fetch@1.1.0':
+    dependencies:
+      '@protobufjs/aspromise': 1.1.2
+      '@protobufjs/inquire': 1.1.0
+
+  '@protobufjs/float@1.0.2': {}
+
+  '@protobufjs/inquire@1.1.0': {}
+
+  '@protobufjs/path@1.1.2': {}
+
+  '@protobufjs/pool@1.1.0': {}
+
+  '@protobufjs/utf8@1.1.0': {}
+
+  '@rollup/rollup-android-arm-eabi@4.29.1':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.29.1':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.29.1':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.29.1':
+    optional: true
+
+  '@rollup/rollup-freebsd-arm64@4.29.1':
+    optional: true
+
+  '@rollup/rollup-freebsd-x64@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-loongarch64-gnu@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-powerpc64le-gnu@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.29.1':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.29.1':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.29.1':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.29.1':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.29.1':
+    optional: true
+
+  '@types/babel__core@7.20.5':
+    dependencies:
+      '@babel/parser': 7.26.3
+      '@babel/types': 7.26.3
+      '@types/babel__generator': 7.6.8
+      '@types/babel__template': 7.4.4
+      '@types/babel__traverse': 7.20.6
+
+  '@types/babel__generator@7.6.8':
+    dependencies:
+      '@babel/types': 7.26.3
+
+  '@types/babel__template@7.4.4':
+    dependencies:
+      '@babel/parser': 7.26.3
+      '@babel/types': 7.26.3
+
+  '@types/babel__traverse@7.20.6':
+    dependencies:
+      '@babel/types': 7.26.3
+
+  '@types/cookie@0.6.0': {}
+
+  '@types/estree@1.0.6': {}
+
+  '@types/json-schema@7.0.15': {}
+
+  '@types/node@22.10.2':
+    dependencies:
+      undici-types: 6.20.0
+
+  '@types/parse-json@4.0.2': {}
+
+  '@types/prop-types@15.7.14': {}
+
+  '@types/react-dom@18.3.5(@types/react@18.3.18)':
+    dependencies:
+      '@types/react': 18.3.18
+
+  '@types/react-transition-group@4.4.12(@types/react@18.3.18)':
+    dependencies:
+      '@types/react': 18.3.18
+
+  '@types/react-window@1.8.8':
+    dependencies:
+      '@types/react': 18.3.18
+
+  '@types/react@18.3.18':
+    dependencies:
+      '@types/prop-types': 15.7.14
+      csstype: 3.1.3
+
+  '@typescript-eslint/eslint-plugin@8.18.2(@typescript-eslint/parser@8.18.2(eslint@9.17.0)(typescript@5.6.3))(eslint@9.17.0)(typescript@5.6.3)':
+    dependencies:
+      '@eslint-community/regexpp': 4.12.1
+      '@typescript-eslint/parser': 8.18.2(eslint@9.17.0)(typescript@5.6.3)
+      '@typescript-eslint/scope-manager': 8.18.2
+      '@typescript-eslint/type-utils': 8.18.2(eslint@9.17.0)(typescript@5.6.3)
+      '@typescript-eslint/utils': 8.18.2(eslint@9.17.0)(typescript@5.6.3)
+      '@typescript-eslint/visitor-keys': 8.18.2
+      eslint: 9.17.0
+      graphemer: 1.4.0
+      ignore: 5.3.2
+      natural-compare: 1.4.0
+      ts-api-utils: 1.4.3(typescript@5.6.3)
+      typescript: 5.6.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/parser@8.18.2(eslint@9.17.0)(typescript@5.6.3)':
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.18.2
+      '@typescript-eslint/types': 8.18.2
+      '@typescript-eslint/typescript-estree': 8.18.2(typescript@5.6.3)
+      '@typescript-eslint/visitor-keys': 8.18.2
+      debug: 4.4.0
+      eslint: 9.17.0
+      typescript: 5.6.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/scope-manager@8.18.2':
+    dependencies:
+      '@typescript-eslint/types': 8.18.2
+      '@typescript-eslint/visitor-keys': 8.18.2
+
+  '@typescript-eslint/type-utils@8.18.2(eslint@9.17.0)(typescript@5.6.3)':
+    dependencies:
+      '@typescript-eslint/typescript-estree': 8.18.2(typescript@5.6.3)
+      '@typescript-eslint/utils': 8.18.2(eslint@9.17.0)(typescript@5.6.3)
+      debug: 4.4.0
+      eslint: 9.17.0
+      ts-api-utils: 1.4.3(typescript@5.6.3)
+      typescript: 5.6.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/types@8.18.2': {}
+
+  '@typescript-eslint/typescript-estree@8.18.2(typescript@5.6.3)':
+    dependencies:
+      '@typescript-eslint/types': 8.18.2
+      '@typescript-eslint/visitor-keys': 8.18.2
+      debug: 4.4.0
+      fast-glob: 3.3.2
+      is-glob: 4.0.3
+      minimatch: 9.0.5
+      semver: 7.6.3
+      ts-api-utils: 1.4.3(typescript@5.6.3)
+      typescript: 5.6.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/utils@8.18.2(eslint@9.17.0)(typescript@5.6.3)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.1(eslint@9.17.0)
+      '@typescript-eslint/scope-manager': 8.18.2
+      '@typescript-eslint/types': 8.18.2
+      '@typescript-eslint/typescript-estree': 8.18.2(typescript@5.6.3)
+      eslint: 9.17.0
+      typescript: 5.6.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/visitor-keys@8.18.2':
+    dependencies:
+      '@typescript-eslint/types': 8.18.2
+      eslint-visitor-keys: 4.2.0
+
+  '@uidotdev/usehooks@2.4.1(react-dom@19.0.0(react@19.0.0))(react@19.0.0)':
+    dependencies:
+      react: 19.0.0
+      react-dom: 19.0.0(react@19.0.0)
+
+  '@vitejs/plugin-react@4.3.4(vite@6.0.6(@types/node@22.10.2))':
+    dependencies:
+      '@babel/core': 7.26.0
+      '@babel/plugin-transform-react-jsx-self': 7.25.9(@babel/core@7.26.0)
+      '@babel/plugin-transform-react-jsx-source': 7.25.9(@babel/core@7.26.0)
+      '@types/babel__core': 7.20.5
+      react-refresh: 0.14.2
+      vite: 6.0.6(@types/node@22.10.2)
+    transitivePeerDependencies:
+      - supports-color
+
+  acorn-jsx@5.3.2(acorn@8.14.0):
+    dependencies:
+      acorn: 8.14.0
+
+  acorn@8.14.0: {}
+
+  ajv@6.12.6:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+
+  ansi-styles@4.3.0:
+    dependencies:
+      color-convert: 2.0.1
+
+  argparse@2.0.1: {}
+
+  asynckit@0.4.0: {}
+
+  axios@1.7.9:
+    dependencies:
+      follow-redirects: 1.15.9
+      form-data: 4.0.1
+      proxy-from-env: 1.1.0
+    transitivePeerDependencies:
+      - debug
+
+  babel-plugin-macros@3.1.0:
+    dependencies:
+      '@babel/runtime': 7.26.0
+      cosmiconfig: 7.1.0
+      resolve: 1.22.10
+
+  balanced-match@1.0.2: {}
+
+  brace-expansion@1.1.11:
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  brace-expansion@2.0.1:
+    dependencies:
+      balanced-match: 1.0.2
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+
+  browserslist@4.24.3:
+    dependencies:
+      caniuse-lite: 1.0.30001690
+      electron-to-chromium: 1.5.76
+      node-releases: 2.0.19
+      update-browserslist-db: 1.1.1(browserslist@4.24.3)
+
+  callsites@3.1.0: {}
+
+  caniuse-lite@1.0.30001690: {}
+
+  centrifuge@5.2.2:
+    dependencies:
+      events: 3.3.0
+      protobufjs: 7.4.0
+
+  chalk@4.1.2:
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+
+  clsx@2.1.1: {}
+
+  color-convert@2.0.1:
+    dependencies:
+      color-name: 1.1.4
+
+  color-name@1.1.4: {}
+
+  combined-stream@1.0.8:
+    dependencies:
+      delayed-stream: 1.0.0
+
+  concat-map@0.0.1: {}
+
+  convert-source-map@1.9.0: {}
+
+  convert-source-map@2.0.0: {}
+
+  cookie@1.0.2: {}
+
+  cosmiconfig@7.1.0:
+    dependencies:
+      '@types/parse-json': 4.0.2
+      import-fresh: 3.3.0
+      parse-json: 5.2.0
+      path-type: 4.0.0
+      yaml: 1.10.2
+
+  cross-spawn@7.0.6:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  csstype@3.1.3: {}
+
+  debug@4.4.0:
+    dependencies:
+      ms: 2.1.3
+
+  deep-is@0.1.4: {}
+
+  delayed-stream@1.0.0: {}
+
+  dom-helpers@5.2.1:
+    dependencies:
+      '@babel/runtime': 7.26.0
+      csstype: 3.1.3
+
+  electron-to-chromium@1.5.76: {}
+
+  error-ex@1.3.2:
+    dependencies:
+      is-arrayish: 0.2.1
+
+  esbuild@0.24.2:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.24.2
+      '@esbuild/android-arm': 0.24.2
+      '@esbuild/android-arm64': 0.24.2
+      '@esbuild/android-x64': 0.24.2
+      '@esbuild/darwin-arm64': 0.24.2
+      '@esbuild/darwin-x64': 0.24.2
+      '@esbuild/freebsd-arm64': 0.24.2
+      '@esbuild/freebsd-x64': 0.24.2
+      '@esbuild/linux-arm': 0.24.2
+      '@esbuild/linux-arm64': 0.24.2
+      '@esbuild/linux-ia32': 0.24.2
+      '@esbuild/linux-loong64': 0.24.2
+      '@esbuild/linux-mips64el': 0.24.2
+      '@esbuild/linux-ppc64': 0.24.2
+      '@esbuild/linux-riscv64': 0.24.2
+      '@esbuild/linux-s390x': 0.24.2
+      '@esbuild/linux-x64': 0.24.2
+      '@esbuild/netbsd-arm64': 0.24.2
+      '@esbuild/netbsd-x64': 0.24.2
+      '@esbuild/openbsd-arm64': 0.24.2
+      '@esbuild/openbsd-x64': 0.24.2
+      '@esbuild/sunos-x64': 0.24.2
+      '@esbuild/win32-arm64': 0.24.2
+      '@esbuild/win32-ia32': 0.24.2
+      '@esbuild/win32-x64': 0.24.2
+
+  escalade@3.2.0: {}
+
+  escape-string-regexp@4.0.0: {}
+
+  eslint-config-prettier@9.1.0(eslint@9.17.0):
+    dependencies:
+      eslint: 9.17.0
+
+  eslint-plugin-prettier@5.2.1(eslint-config-prettier@9.1.0(eslint@9.17.0))(eslint@9.17.0)(prettier@3.4.2):
+    dependencies:
+      eslint: 9.17.0
+      prettier: 3.4.2
+      prettier-linter-helpers: 1.0.0
+      synckit: 0.9.2
+    optionalDependencies:
+      eslint-config-prettier: 9.1.0(eslint@9.17.0)
+
+  eslint-plugin-react-hooks@5.1.0(eslint@9.17.0):
+    dependencies:
+      eslint: 9.17.0
+
+  eslint-plugin-react-refresh@0.4.16(eslint@9.17.0):
+    dependencies:
+      eslint: 9.17.0
+
+  eslint-scope@8.2.0:
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+
+  eslint-visitor-keys@3.4.3: {}
+
+  eslint-visitor-keys@4.2.0: {}
+
+  eslint@9.17.0:
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.1(eslint@9.17.0)
+      '@eslint-community/regexpp': 4.12.1
+      '@eslint/config-array': 0.19.1
+      '@eslint/core': 0.9.1
+      '@eslint/eslintrc': 3.2.0
+      '@eslint/js': 9.17.0
+      '@eslint/plugin-kit': 0.2.4
+      '@humanfs/node': 0.16.6
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.4.1
+      '@types/estree': 1.0.6
+      '@types/json-schema': 7.0.15
+      ajv: 6.12.6
+      chalk: 4.1.2
+      cross-spawn: 7.0.6
+      debug: 4.4.0
+      escape-string-regexp: 4.0.0
+      eslint-scope: 8.2.0
+      eslint-visitor-keys: 4.2.0
+      espree: 10.3.0
+      esquery: 1.6.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.2
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      lodash.merge: 4.6.2
+      minimatch: 3.1.2
+      natural-compare: 1.4.0
+      optionator: 0.9.4
+    transitivePeerDependencies:
+      - supports-color
+
+  espree@10.3.0:
+    dependencies:
+      acorn: 8.14.0
+      acorn-jsx: 5.3.2(acorn@8.14.0)
+      eslint-visitor-keys: 4.2.0
+
+  esquery@1.6.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  esrecurse@4.3.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  estraverse@5.3.0: {}
+
+  esutils@2.0.3: {}
+
+  events@3.3.0: {}
+
+  fast-deep-equal@3.1.3: {}
+
+  fast-diff@1.3.0: {}
+
+  fast-glob@3.3.2:
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.8
+
+  fast-json-stable-stringify@2.1.0: {}
+
+  fast-levenshtein@2.0.6: {}
+
+  fastq@1.18.0:
+    dependencies:
+      reusify: 1.0.4
+
+  file-entry-cache@8.0.0:
+    dependencies:
+      flat-cache: 4.0.1
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  find-root@1.1.0: {}
+
+  find-up@5.0.0:
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+
+  flat-cache@4.0.1:
+    dependencies:
+      flatted: 3.3.2
+      keyv: 4.5.4
+
+  flatted@3.3.2: {}
+
+  follow-redirects@1.15.9: {}
+
+  form-data@4.0.1:
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      mime-types: 2.1.35
+
+  fsevents@2.3.3:
+    optional: true
+
+  function-bind@1.1.2: {}
+
+  gensync@1.0.0-beta.2: {}
+
+  glob-parent@5.1.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob-parent@6.0.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  globals@11.12.0: {}
+
+  globals@14.0.0: {}
+
+  globals@15.14.0: {}
+
+  graphemer@1.4.0: {}
+
+  has-flag@4.0.0: {}
+
+  hasown@2.0.2:
+    dependencies:
+      function-bind: 1.1.2
+
+  hoist-non-react-statics@3.3.2:
+    dependencies:
+      react-is: 16.13.1
+
+  ignore@5.3.2: {}
+
+  import-fresh@3.3.0:
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+
+  imurmurhash@0.1.4: {}
+
+  is-arrayish@0.2.1: {}
+
+  is-core-module@2.16.1:
+    dependencies:
+      hasown: 2.0.2
+
+  is-extglob@2.1.1: {}
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-number@7.0.0: {}
+
+  isexe@2.0.0: {}
+
+  js-tokens@4.0.0: {}
+
+  js-yaml@4.1.0:
+    dependencies:
+      argparse: 2.0.1
+
+  jsesc@3.1.0: {}
+
+  json-buffer@3.0.1: {}
+
+  json-parse-even-better-errors@2.3.1: {}
+
+  json-schema-traverse@0.4.1: {}
+
+  json-stable-stringify-without-jsonify@1.0.1: {}
+
+  json5@2.2.3: {}
+
+  keyv@4.5.4:
+    dependencies:
+      json-buffer: 3.0.1
+
+  levn@0.4.1:
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+
+  lines-and-columns@1.2.4: {}
+
+  locate-path@6.0.0:
+    dependencies:
+      p-locate: 5.0.0
+
+  lodash.merge@4.6.2: {}
+
+  long@5.2.3: {}
+
+  loose-envify@1.4.0:
+    dependencies:
+      js-tokens: 4.0.0
+
+  lru-cache@5.1.1:
+    dependencies:
+      yallist: 3.1.1
+
+  memoize-one@5.2.1: {}
+
+  merge2@1.4.1: {}
+
+  micromatch@4.0.8:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.1
+
+  mime-db@1.52.0: {}
+
+  mime-types@2.1.35:
+    dependencies:
+      mime-db: 1.52.0
+
+  minimatch@3.1.2:
+    dependencies:
+      brace-expansion: 1.1.11
+
+  minimatch@9.0.5:
+    dependencies:
+      brace-expansion: 2.0.1
+
+  ms@2.1.3: {}
+
+  nanoid@3.3.8: {}
+
+  natural-compare@1.4.0: {}
+
+  node-releases@2.0.19: {}
+
+  object-assign@4.1.1: {}
+
+  optionator@0.9.4:
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.4.1
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+      word-wrap: 1.2.5
+
+  p-limit@3.1.0:
+    dependencies:
+      yocto-queue: 0.1.0
+
+  p-locate@5.0.0:
+    dependencies:
+      p-limit: 3.1.0
+
+  parent-module@1.0.1:
+    dependencies:
+      callsites: 3.1.0
+
+  parse-json@5.2.0:
+    dependencies:
+      '@babel/code-frame': 7.26.2
+      error-ex: 1.3.2
+      json-parse-even-better-errors: 2.3.1
+      lines-and-columns: 1.2.4
+
+  path-exists@4.0.0: {}
+
+  path-key@3.1.1: {}
+
+  path-parse@1.0.7: {}
+
+  path-type@4.0.0: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@2.3.1: {}
+
+  postcss@8.4.49:
+    dependencies:
+      nanoid: 3.3.8
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  prelude-ls@1.2.1: {}
+
+  prettier-linter-helpers@1.0.0:
+    dependencies:
+      fast-diff: 1.3.0
+
+  prettier@3.4.2: {}
+
+  prop-types@15.8.1:
+    dependencies:
+      loose-envify: 1.4.0
+      object-assign: 4.1.1
+      react-is: 16.13.1
+
+  protobufjs@7.4.0:
+    dependencies:
+      '@protobufjs/aspromise': 1.1.2
+      '@protobufjs/base64': 1.1.2
+      '@protobufjs/codegen': 2.0.4
+      '@protobufjs/eventemitter': 1.1.0
+      '@protobufjs/fetch': 1.1.0
+      '@protobufjs/float': 1.0.2
+      '@protobufjs/inquire': 1.1.0
+      '@protobufjs/path': 1.1.2
+      '@protobufjs/pool': 1.1.0
+      '@protobufjs/utf8': 1.1.0
+      '@types/node': 22.10.2
+      long: 5.2.3
+
+  proxy-from-env@1.1.0: {}
+
+  punycode@2.3.1: {}
+
+  queue-microtask@1.2.3: {}
+
+  react-dom@19.0.0(react@19.0.0):
+    dependencies:
+      react: 19.0.0
+      scheduler: 0.25.0
+
+  react-is@16.13.1: {}
+
+  react-is@19.0.0: {}
+
+  react-refresh@0.14.2: {}
+
+  react-router@7.1.1(react-dom@19.0.0(react@19.0.0))(react@19.0.0):
+    dependencies:
+      '@types/cookie': 0.6.0
+      cookie: 1.0.2
+      react: 19.0.0
+      set-cookie-parser: 2.7.1
+      turbo-stream: 2.4.0
+    optionalDependencies:
+      react-dom: 19.0.0(react@19.0.0)
+
+  react-transition-group@4.4.5(react-dom@19.0.0(react@19.0.0))(react@19.0.0):
+    dependencies:
+      '@babel/runtime': 7.26.0
+      dom-helpers: 5.2.1
+      loose-envify: 1.4.0
+      prop-types: 15.8.1
+      react: 19.0.0
+      react-dom: 19.0.0(react@19.0.0)
+
+  react-window@1.8.11(react-dom@19.0.0(react@19.0.0))(react@19.0.0):
+    dependencies:
+      '@babel/runtime': 7.26.0
+      memoize-one: 5.2.1
+      react: 19.0.0
+      react-dom: 19.0.0(react@19.0.0)
+
+  react@19.0.0: {}
+
+  regenerator-runtime@0.14.1: {}
+
+  resolve-from@4.0.0: {}
+
+  resolve@1.22.10:
+    dependencies:
+      is-core-module: 2.16.1
+      path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
+
+  reusify@1.0.4: {}
+
+  rollup@4.29.1:
+    dependencies:
+      '@types/estree': 1.0.6
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.29.1
+      '@rollup/rollup-android-arm64': 4.29.1
+      '@rollup/rollup-darwin-arm64': 4.29.1
+      '@rollup/rollup-darwin-x64': 4.29.1
+      '@rollup/rollup-freebsd-arm64': 4.29.1
+      '@rollup/rollup-freebsd-x64': 4.29.1
+      '@rollup/rollup-linux-arm-gnueabihf': 4.29.1
+      '@rollup/rollup-linux-arm-musleabihf': 4.29.1
+      '@rollup/rollup-linux-arm64-gnu': 4.29.1
+      '@rollup/rollup-linux-arm64-musl': 4.29.1
+      '@rollup/rollup-linux-loongarch64-gnu': 4.29.1
+      '@rollup/rollup-linux-powerpc64le-gnu': 4.29.1
+      '@rollup/rollup-linux-riscv64-gnu': 4.29.1
+      '@rollup/rollup-linux-s390x-gnu': 4.29.1
+      '@rollup/rollup-linux-x64-gnu': 4.29.1
+      '@rollup/rollup-linux-x64-musl': 4.29.1
+      '@rollup/rollup-win32-arm64-msvc': 4.29.1
+      '@rollup/rollup-win32-ia32-msvc': 4.29.1
+      '@rollup/rollup-win32-x64-msvc': 4.29.1
+      fsevents: 2.3.3
+
+  run-parallel@1.2.0:
+    dependencies:
+      queue-microtask: 1.2.3
+
+  scheduler@0.25.0: {}
+
+  semver@6.3.1: {}
+
+  semver@7.6.3: {}
+
+  set-cookie-parser@2.7.1: {}
+
+  shebang-command@2.0.0:
+    dependencies:
+      shebang-regex: 3.0.0
+
+  shebang-regex@3.0.0: {}
+
+  source-map-js@1.2.1: {}
+
+  source-map@0.5.7: {}
+
+  strip-json-comments@3.1.1: {}
+
+  stylis@4.2.0: {}
+
+  supports-color@7.2.0:
+    dependencies:
+      has-flag: 4.0.0
+
+  supports-preserve-symlinks-flag@1.0.0: {}
+
+  synckit@0.9.2:
+    dependencies:
+      '@pkgr/core': 0.1.1
+      tslib: 2.8.1
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+
+  ts-api-utils@1.4.3(typescript@5.6.3):
+    dependencies:
+      typescript: 5.6.3
+
+  tslib@2.8.1: {}
+
+  turbo-stream@2.4.0: {}
+
+  type-check@0.4.0:
+    dependencies:
+      prelude-ls: 1.2.1
+
+  typescript-eslint@8.18.2(eslint@9.17.0)(typescript@5.6.3):
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 8.18.2(@typescript-eslint/parser@8.18.2(eslint@9.17.0)(typescript@5.6.3))(eslint@9.17.0)(typescript@5.6.3)
+      '@typescript-eslint/parser': 8.18.2(eslint@9.17.0)(typescript@5.6.3)
+      '@typescript-eslint/utils': 8.18.2(eslint@9.17.0)(typescript@5.6.3)
+      eslint: 9.17.0
+      typescript: 5.6.3
+    transitivePeerDependencies:
+      - supports-color
+
+  typescript@5.6.3: {}
+
+  undici-types@6.20.0: {}
+
+  update-browserslist-db@1.1.1(browserslist@4.24.3):
+    dependencies:
+      browserslist: 4.24.3
+      escalade: 3.2.0
+      picocolors: 1.1.1
+
+  uri-js@4.4.1:
+    dependencies:
+      punycode: 2.3.1
+
+  vite@6.0.6(@types/node@22.10.2):
+    dependencies:
+      esbuild: 0.24.2
+      postcss: 8.4.49
+      rollup: 4.29.1
+    optionalDependencies:
+      '@types/node': 22.10.2
+      fsevents: 2.3.3
+
+  which@2.0.2:
+    dependencies:
+      isexe: 2.0.0
+
+  word-wrap@1.2.5: {}
+
+  yallist@3.1.1: {}
+
+  yaml@1.10.2: {}
+
+  yocto-queue@0.1.0: {}
diff --git a/front/public/vite.svg b/front/public/vite.svg
index 2184d4b..7860dd3 100644
--- a/front/public/vite.svg
+++ b/front/public/vite.svg
@@ -1,5 +1,5 @@
-<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88"
-     height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257">
+<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img"
+     class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257">
     <defs>
         <linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%">
             <stop offset="0%" stop-color="#41D1FF"></stop>
@@ -15,4 +15,4 @@
           d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path>
     <path fill="url(#IconifyId1813088fe1fbc01fb467)"
           d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path>
-</svg>
\ No newline at end of file
+</svg>
diff --git a/front/src/App.vue b/front/src/App.vue
deleted file mode 100644
index 7614197..0000000
--- a/front/src/App.vue
+++ /dev/null
@@ -1,33 +0,0 @@
-<script lang="ts" setup>
-// This starter template is using Vue 3 <script setup> SFCs
-// Check out https://vuejs.org/api/sfc-script-setup.html#script-setup
-import HelloWorld from "./components/HelloWorld.vue";
-</script>
-
-<template>
-  <div>
-    <a href="https://vitejs.dev" target="_blank">
-      <img alt="Vite logo" class="logo" src="/vite.svg" />
-    </a>
-    <a href="https://vuejs.org/" target="_blank">
-      <img alt="Vue logo" class="logo vue" src="./assets/vue.svg" />
-    </a>
-  </div>
-  <HelloWorld msg="Vite + Vue" />
-</template>
-
-<style scoped>
-.logo {
-  height: 6em;
-  padding: 1.5em;
-  will-change: filter;
-}
-
-.logo:hover {
-  filter: drop-shadow(0 0 2em #646cffaa);
-}
-
-.logo.vue:hover {
-  filter: drop-shadow(0 0 2em #42b883aa);
-}
-</style>
diff --git a/front/src/assets/react.svg b/front/src/assets/react.svg
new file mode 100644
index 0000000..4f23537
--- /dev/null
+++ b/front/src/assets/react.svg
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img"
+     class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228">
+    <path fill="#00D8FF"
+          d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path>
+</svg>
diff --git a/front/src/assets/vue.svg b/front/src/assets/vue.svg
deleted file mode 100644
index aa355c9..0000000
--- a/front/src/assets/vue.svg
+++ /dev/null
@@ -1,6 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" class="iconify iconify--logos" width="37.07"
-     height="36" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 198">
-    <path fill="#41B883" d="M204.8 0H256L128 220.8L0 0h97.92L128 51.2L157.44 0h47.36Z"></path>
-    <path fill="#41B883" d="m0 0l128 220.8L256 0h-51.2L128 132.48L50.56 0H0Z"></path>
-    <path fill="#35495E" d="M50.56 0L128 133.12L204.8 0h-47.36L128 51.2L97.92 0H50.56Z"></path>
-</svg>
\ No newline at end of file
diff --git a/front/src/components/ForcAD/Live.tsx b/front/src/components/ForcAD/Live.tsx
new file mode 100644
index 0000000..83c2fb1
--- /dev/null
+++ b/front/src/components/ForcAD/Live.tsx
@@ -0,0 +1,113 @@
+import { centrifugeWSURL } from '@/config';
+import { useServices, useTeams } from '@/lib/hooks/scoreboard';
+import { AttackNotification_Batch } from '@/proto/receiver/receiver';
+import { Box } from '@mui/material';
+import { styled } from '@mui/material/styles';
+import { useWindowSize } from '@uidotdev/usehooks';
+import { Centrifuge } from 'centrifuge';
+import { useEffect, useMemo, useState } from 'react';
+import { FixedSizeList } from 'react-window';
+
+interface Event {
+  victimName: string;
+  attackerName: string;
+  serviceName: string;
+  attackerDelta: number;
+  victimDelta: number;
+}
+
+const EventText = styled('div')({
+  fontFamily: 'Roboto Mono',
+  fontSize: '0.9rem',
+  color: '#00ff00',
+});
+
+const Highlight = styled('span')({
+  fontWeight: 'bold',
+  color: '#ffff00',
+});
+
+const MAX_EVENTS = 5000;
+
+export default function Live() {
+  const [events, setEvents] = useState<Event[]>([]);
+  const teams = useTeams();
+  const services = useServices();
+
+  const { height: windowHeight } = useWindowSize();
+
+  const teamMap = useMemo(() => {
+    return new Map(teams?.map((team) => [team.id, team]));
+  }, [teams]);
+
+  const serviceMap = useMemo(() => {
+    return new Map(services?.map((service) => [service.id, service]));
+  }, [services]);
+
+  useEffect(() => {
+    if (!teamMap || !serviceMap) {
+      return;
+    }
+
+    const centrifuge = new Centrifuge(centrifugeWSURL);
+
+    const sub = centrifuge.newSubscription('attacks');
+
+    sub.on('publication', (ctx) => {
+      const attackBatch = AttackNotification_Batch.fromJSON(ctx.data);
+
+      const newEvents = attackBatch.attacks.map((attack) => ({
+        victimName: teamMap.get(attack.victimId)?.name ?? 'Unknown',
+        attackerName: teamMap.get(attack.attackerId)?.name ?? 'Unknown',
+        serviceName: serviceMap.get(attack.serviceId)?.name ?? 'Unknown',
+        attackerDelta: attack.attackerDelta,
+        victimDelta: attack.victimDelta,
+      }));
+
+      setEvents((prev) => [...newEvents, ...prev].slice(0, MAX_EVENTS));
+    });
+
+    sub.subscribe();
+    centrifuge.connect();
+
+    return () => {
+      sub.unsubscribe();
+      centrifuge.disconnect();
+    };
+  }, [serviceMap, teamMap]);
+
+  const Row = ({
+    index,
+    style,
+  }: {
+    index: number;
+    style: React.CSSProperties;
+  }) => {
+    const event = events[index];
+    return (
+      <EventText style={style}>
+        <Highlight>{event.attackerName}</Highlight> attacked{' '}
+        <Highlight>{event.victimName}</Highlight>'s service{' '}
+        <Highlight>{event.serviceName}</Highlight> and got{' '}
+        <Highlight>{event.attackerDelta.toFixed(2)}</Highlight> points
+      </EventText>
+    );
+  };
+
+  if (!windowHeight) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <Box sx={{ height: '100vh', width: '100vw', backgroundColor: '#000' }}>
+      <FixedSizeList
+        height={windowHeight}
+        width="100%"
+        itemCount={events.length}
+        itemSize={20}
+      >
+        {Row}
+      </FixedSizeList>
+    </Box>
+  );
+}
diff --git a/front/src/components/ForcAD/Scoreboard.tsx b/front/src/components/ForcAD/Scoreboard.tsx
new file mode 100644
index 0000000..6eee3ad
--- /dev/null
+++ b/front/src/components/ForcAD/Scoreboard.tsx
@@ -0,0 +1,284 @@
+import { useScoreboard } from '@/lib/hooks/scoreboard';
+import statusColor from '@/lib/styles/statusColor';
+import { Status } from '@/proto/checker/checker';
+import FlagIcon from '@mui/icons-material/Flag';
+import HistoryIcon from '@mui/icons-material/History';
+import InfoIcon from '@mui/icons-material/Info';
+import {
+  Avatar,
+  Box,
+  IconButton,
+  Stack,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableRow,
+  Tooltip,
+  Typography,
+} from '@mui/material';
+import { styled, Theme } from '@mui/material/styles';
+import { useWindowSize } from '@uidotdev/usehooks';
+import { useEffect, useState } from 'react';
+import { Link } from 'react-router';
+
+const RANK_COL_WIDTH = 40;
+const TEAM_COL_WIDTH = 400;
+const SCORE_COL_WIDTH = 120;
+const SERVICE_COL_MIN_WIDTH = 200;
+
+const MonoFontCell = styled(TableCell)({
+  fontFamily: 'Roboto Mono',
+});
+
+const HeaderCell = styled(MonoFontCell)({
+  fontWeight: 500,
+});
+
+const TeamServiceCell = styled(MonoFontCell)({
+  transition: 'background-color 1s ease-in-out',
+  whiteSpace: 'nowrap',
+  py: '0',
+  px: '1em',
+});
+
+export default function ScoreboardTable() {
+  const [tableWidth, setTableWidth] = useState('');
+  const { width: windowWidth } = useWindowSize();
+  const { teams, services, scoreboard } = useScoreboard();
+
+  useEffect(() => {
+    const fullWidth =
+      RANK_COL_WIDTH +
+      TEAM_COL_WIDTH +
+      SCORE_COL_WIDTH +
+      SERVICE_COL_MIN_WIDTH * (services?.length ?? 1);
+
+    if (windowWidth && windowWidth < fullWidth) {
+      setTableWidth('100%');
+    } else {
+      setTableWidth(`${fullWidth}px`);
+    }
+  }, [windowWidth, services]);
+
+  if (!teams || !services || !scoreboard || !tableWidth) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <TableContainer sx={{ width: '100%', overflowX: 'auto' }}>
+      <Table
+        sx={{
+          tableLayout: 'fixed',
+          margin: '0 auto',
+          width: tableWidth,
+        }}
+      >
+        <colgroup>
+          <col style={{ width: `${RANK_COL_WIDTH}px` }} />
+          <col style={{ width: `${TEAM_COL_WIDTH}px` }} />
+          <col style={{ width: `${SCORE_COL_WIDTH}px` }} />
+
+          {/* Each service column divides leftover space equally */}
+          {services.map((service) => (
+            <col
+              key={`service-col-${service.id}`}
+              style={{ width: `${SERVICE_COL_MIN_WIDTH}px` }}
+            />
+          ))}
+        </colgroup>
+
+        <TableHead>
+          <TableRow>
+            <HeaderCell align="center"> #</HeaderCell>
+            <HeaderCell align="center">Team</HeaderCell>
+            <HeaderCell align="center">Score</HeaderCell>
+            {services.map((s) => (
+              <HeaderCell key={`service-header-${s.id}`} align="center">
+                {s.name}
+              </HeaderCell>
+            ))}
+          </TableRow>
+        </TableHead>
+
+        <TableBody>
+          {teams.map((team, i) => {
+            const rank = i + 1;
+            return (
+              <TableRow key={`team-row-${team.id}`}>
+                <MonoFontCell align="center">{rank}</MonoFontCell>
+                <MonoFontCell align="center">
+                  <Stack
+                    direction="row"
+                    sx={{
+                      display: 'flex',
+                      alignItems: 'center',
+                      gap: 2,
+                      minWidth: 0,
+                    }}
+                  >
+                    {team.avatarUrl ? (
+                      <Avatar
+                        variant="square"
+                        src={team.avatarUrl}
+                        sx={{
+                          width: 64,
+                          height: 64,
+                        }}
+                      />
+                    ) : (
+                      <Avatar
+                        variant="square"
+                        sx={{
+                          width: 64,
+                          height: 64,
+                        }}
+                      >
+                        {team.name[0].toUpperCase()}
+                      </Avatar>
+                    )}
+
+                    <Box
+                      sx={{
+                        display: 'flex',
+                        flexDirection: 'column',
+                        flex: 1,
+                        minWidth: 0,
+                      }}
+                    >
+                      <Typography
+                        variant="subtitle1"
+                        noWrap
+                        sx={{
+                          fontFamily: 'Roboto Mono',
+                        }}
+                      >
+                        {team.name}
+                      </Typography>
+
+                      <Typography
+                        variant="body2"
+                        noWrap
+                        sx={{ fontFamily: 'Roboto Mono' }}
+                      >
+                        {team.address}
+                      </Typography>
+                    </Box>
+                    <Box>
+                      <IconButton
+                        size="small"
+                        sx={{ p: 0, color: 'inherit' }}
+                        component={Link}
+                        to={`/teams/${team.id}/history`}
+                      >
+                        <HistoryIcon />
+                      </IconButton>
+                    </Box>
+                  </Stack>
+                </MonoFontCell>
+                <MonoFontCell align="center">
+                  {scoreboard.getTeamScore(team.id).toFixed(2)}
+                </MonoFontCell>
+                {services.map((service) => {
+                  const tss = scoreboard.getTeamServiceState(
+                    team.id,
+                    service.id,
+                  );
+                  let st: Status = Status.STATUS_UP;
+                  let tooltipMessage = '';
+                  if (tss?.checkStatuses && tss.checkStatuses.length > 0) {
+                    st = tss.checkStatuses[tss.checkStatuses.length - 1].status;
+                    tooltipMessage =
+                      tss.checkStatuses[tss.checkStatuses.length - 1].message;
+                  }
+                  const checksTotal = parseInt(tss?.checksTotal ?? '0');
+                  const checksPassed = parseInt(tss?.checksPassed ?? '0');
+                  const sla =
+                    (checksTotal > 0 ? checksPassed / checksTotal : 1) * 100;
+
+                  return (
+                    <TeamServiceCell
+                      key={`ts-cell-${team.id}-${service.id}`}
+                      sx={(theme: Theme) => ({
+                        backgroundColor: statusColor(theme, st).main,
+                        color: '#000000',
+                      })}
+                    >
+                      <Stack
+                        direction="row"
+                        gap={2}
+                        alignItems="center"
+                        justifyContent="space-between"
+                      >
+                        <Box>
+                          <Typography
+                            variant="body2"
+                            sx={{ fontFamily: 'Roboto Mono' }}
+                          >
+                            <strong>SLA:</strong> {sla.toFixed(2)}%
+                          </Typography>
+                          <Typography
+                            variant="body2"
+                            sx={{ fontFamily: 'Roboto Mono' }}
+                          >
+                            <strong>FP:</strong> {tss?.points.toFixed(2)}
+                          </Typography>
+                          <Stack alignItems="center" direction="row" gap={0.5}>
+                            <FlagIcon sx={{ fontSize: '1.2em' }} />
+                            <Typography
+                              variant="body2"
+                              sx={{ fontFamily: 'Roboto Mono' }}
+                            >
+                              +{tss?.flagsStolen}/-{tss?.flagsLost}
+                            </Typography>
+                          </Stack>
+                        </Box>
+                        <Stack direction="column" gap={1}>
+                          <Box>
+                            <Tooltip title={tooltipMessage}>
+                              <IconButton
+                                size="small"
+                                sx={{
+                                  p: 0,
+                                  color: 'inherit',
+                                  opacity: 0.7,
+                                  '&:hover': {
+                                    opacity: 1,
+                                  },
+                                }}
+                              >
+                                <InfoIcon fontSize="small" />
+                              </IconButton>
+                            </Tooltip>
+                          </Box>
+                          <Box>
+                            <IconButton
+                              size="small"
+                              component={Link}
+                              to={`/teams/${team.id}/history?serviceId=${service.id}`}
+                              sx={{
+                                p: 0,
+                                color: 'inherit',
+                                opacity: 0.7,
+                                '&:hover': {
+                                  opacity: 1,
+                                },
+                              }}
+                            >
+                              <HistoryIcon fontSize="small" />
+                            </IconButton>
+                          </Box>
+                        </Stack>
+                      </Stack>
+                    </TeamServiceCell>
+                  );
+                })}
+              </TableRow>
+            );
+          })}
+        </TableBody>
+      </Table>
+    </TableContainer>
+  );
+}
diff --git a/front/src/components/ForcAD/Statuses.tsx b/front/src/components/ForcAD/Statuses.tsx
new file mode 100644
index 0000000..651c905
--- /dev/null
+++ b/front/src/components/ForcAD/Statuses.tsx
@@ -0,0 +1,44 @@
+import Stack from '@mui/material/Stack';
+import { styled } from '@mui/material/styles';
+
+const StatusBarItem = styled('div')({
+  width: '100%',
+  textAlign: 'center',
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'center',
+  color: 'black',
+  padding: '0.3em',
+});
+
+const UpStatusBarItem = styled(StatusBarItem)(({ theme }) => ({
+  backgroundColor: theme.palette.statusUp!.main,
+}));
+
+const CorruptStatusBarItem = styled(StatusBarItem)(({ theme }) => ({
+  backgroundColor: theme.palette.statusCorrupt!.main,
+}));
+
+const MumbleStatusBarItem = styled(StatusBarItem)(({ theme }) => ({
+  backgroundColor: theme.palette.statusMumble!.main,
+}));
+
+const DownStatusBarItem = styled(StatusBarItem)(({ theme }) => ({
+  backgroundColor: theme.palette.statusDown!.main,
+}));
+
+const CheckFailedStatusBarItem = styled(StatusBarItem)(({ theme }) => ({
+  backgroundColor: theme.palette.statusCheckFailed!.main,
+}));
+
+export default function Statuses() {
+  return (
+    <Stack direction={'row'} spacing={0}>
+      <UpStatusBarItem>UP</UpStatusBarItem>
+      <MumbleStatusBarItem>MUMBLE</MumbleStatusBarItem>
+      <CorruptStatusBarItem>CORRUPT</CorruptStatusBarItem>
+      <DownStatusBarItem>DOWN</DownStatusBarItem>
+      <CheckFailedStatusBarItem>CHECK FAILED</CheckFailedStatusBarItem>
+    </Stack>
+  );
+}
diff --git a/front/src/components/ForcAD/TeamHistoryTimeline.tsx b/front/src/components/ForcAD/TeamHistoryTimeline.tsx
new file mode 100644
index 0000000..ccfe42d
--- /dev/null
+++ b/front/src/components/ForcAD/TeamHistoryTimeline.tsx
@@ -0,0 +1,92 @@
+import { createProtoJSONTransform } from '@/lib/clients/common';
+import statusColor from '@/lib/styles/statusColor';
+import {
+  actionToJSON,
+  Execution,
+  Execution_Batch,
+  Status,
+  statusToJSON,
+} from '@/proto/checker/checker';
+import { Service, Service_Batch } from '@/proto/data/services/services';
+import Timeline from '@mui/lab/Timeline';
+import TimelineConnector from '@mui/lab/TimelineConnector';
+import TimelineContent from '@mui/lab/TimelineContent';
+import TimelineDot from '@mui/lab/TimelineDot';
+import TimelineItem from '@mui/lab/TimelineItem';
+import TimelineOppositeContent from '@mui/lab/TimelineOppositeContent';
+import TimelineSeparator from '@mui/lab/TimelineSeparator';
+import { Typography } from '@mui/material';
+import axios from 'axios';
+import { useEffect, useState } from 'react';
+
+interface Props {
+  teamID: string;
+  serviceID: string;
+}
+
+export default function TeamHistoryTimeline(props: Props) {
+  const [services, setServices] = useState<Map<string, Service> | null>(null);
+  const [history, setHistory] = useState<Execution[]>([]);
+
+  useEffect(() => {
+    async function fetchHistory() {
+      const { data } = await axios.get<Execution_Batch>(
+        `/teams/${props.teamID}/history`,
+        {
+          transformResponse: createProtoJSONTransform(Execution_Batch),
+          params: {
+            service_id: props.serviceID,
+          },
+        },
+      );
+      setHistory(data.executions);
+    }
+    fetchHistory();
+  }, [props]);
+
+  useEffect(() => {
+    async function fetchServices() {
+      const { data } = await axios.get<Service_Batch>(`/services`, {
+        transformResponse: createProtoJSONTransform(Service_Batch),
+      });
+      setServices(
+        new Map(data.services.map((service) => [service.id, service])),
+      );
+    }
+    fetchServices();
+  }, []);
+
+  if (!history || !services) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <Timeline position="right">
+      {history.map((execution) => (
+        <TimelineItem key={execution.createdAt?.toString()}>
+          <TimelineOppositeContent color="text.secondary">
+            {execution.createdAt?.toLocaleString()}
+          </TimelineOppositeContent>
+          <TimelineSeparator>
+            <TimelineDot
+              sx={(theme) => ({
+                backgroundColor: statusColor(theme, execution.status).main,
+              })}
+            />
+            <TimelineConnector />
+          </TimelineSeparator>
+          <TimelineContent>
+            <Typography>
+              {services.get(execution.serviceId)?.name}:{' '}
+              {execution.status == Status.STATUS_UP ? 'OK' : execution.public}
+            </Typography>
+            <Typography variant="body2" color="text.secondary">
+              {actionToJSON(execution.action).replace('ACTION_', '')}:{' '}
+              {statusToJSON(execution.status).replace('STATUS_', '')}
+            </Typography>
+          </TimelineContent>
+        </TimelineItem>
+      ))}
+    </Timeline>
+  );
+}
diff --git a/front/src/components/ForcAD/TopBar.tsx b/front/src/components/ForcAD/TopBar.tsx
new file mode 100644
index 0000000..ce36d41
--- /dev/null
+++ b/front/src/components/ForcAD/TopBar.tsx
@@ -0,0 +1,105 @@
+import TopBarRoundProgress from '@/components/ForcAD/TopBarRoundProgress';
+import { createProtoTransform } from '@/lib/clients/common';
+import { GameState, GameStatus } from '@/proto/data/game_state/game_state';
+import { AppBar, Box, Toolbar, Typography } from '@mui/material';
+import axios from 'axios';
+import { useEffect, useState } from 'react';
+import { Link } from 'react-router';
+
+export default function TopBar() {
+  const [gameState, setGameState] = useState<GameState | null>(null);
+
+  useEffect(() => {
+    async function fetchGameState() {
+      const { data } = await axios.get<GameState>('/game', {
+        transformResponse: createProtoTransform(GameState),
+        responseType: 'arraybuffer',
+        params: {
+          format: 'proto',
+        },
+      });
+      setGameState(data);
+    }
+
+    fetchGameState();
+    const interval = setInterval(fetchGameState, 1000);
+
+    return () => clearInterval(interval);
+  }, []);
+
+  return (
+    <AppBar position="static" color="default">
+      <Toolbar>
+        <Typography
+          variant="h6"
+          component={Link}
+          to="/"
+          sx={{
+            textDecoration: 'none',
+            color: 'inherit',
+            flexGrow: 0,
+            fontFamily: 'Roboto Mono',
+          }}
+        >
+          FastAD
+        </Typography>
+
+        <Box
+          component={Link}
+          to="/live"
+          sx={{ textDecoration: 'none', color: 'inherit', ml: 4 }}
+        >
+          <Typography variant="body1" sx={{ fontFamily: 'Roboto Mono' }}>
+            Live
+          </Typography>
+        </Box>
+
+        <Box
+          component={Link}
+          to="/attack_data"
+          sx={{ textDecoration: 'none', color: 'inherit', ml: 3 }}
+        >
+          <Typography variant="body1" sx={{ fontFamily: 'Roboto Mono' }}>
+            Attack Data
+          </Typography>
+        </Box>
+
+        <Box
+          component={Link}
+          to="https://github.com/C4T-BuT-S4D/FastAD"
+          sx={{ textDecoration: 'none', color: 'inherit', ml: 3 }}
+        >
+          <Typography variant="body1" sx={{ fontFamily: 'Roboto Mono' }}>
+            GitHub
+          </Typography>
+        </Box>
+
+        <Box sx={{ flexGrow: 1 }} />
+
+        {gameState?.status === GameStatus.GAME_STATUS_FINISHED ? (
+          <Typography variant="body1" sx={{ fontFamily: 'Roboto Mono' }}>
+            Game Over
+          </Typography>
+        ) : gameState?.status === GameStatus.GAME_STATUS_PAUSED ? (
+          <Typography variant="body1" sx={{ fontFamily: 'Roboto Mono' }}>
+            Game Paused
+          </Typography>
+        ) : gameState?.status === GameStatus.GAME_STATUS_NOT_STARTED ? (
+          <Typography variant="body1" sx={{ fontFamily: 'Roboto Mono' }}>
+            Game Not Started
+          </Typography>
+        ) : (
+          gameState?.runningRoundStart &&
+          gameState?.roundDuration && (
+            <TopBarRoundProgress
+              round={gameState.runningRound}
+              totalRounds={gameState.totalRounds}
+              startTime={gameState.runningRoundStart}
+              duration={gameState.roundDuration}
+            />
+          )
+        )}
+      </Toolbar>
+    </AppBar>
+  );
+}
diff --git a/front/src/components/ForcAD/TopBarRoundProgress.tsx b/front/src/components/ForcAD/TopBarRoundProgress.tsx
new file mode 100644
index 0000000..310b3e6
--- /dev/null
+++ b/front/src/components/ForcAD/TopBarRoundProgress.tsx
@@ -0,0 +1,61 @@
+import { Duration } from '@/proto/google/protobuf/duration';
+import { Box, CircularProgress, Stack, Typography } from '@mui/material';
+
+import { useEffect, useState } from 'react';
+
+interface Props {
+  round: string;
+  totalRounds: string | undefined;
+  startTime: Date;
+  duration: Duration;
+}
+
+export default function TopBarRoundProgress(props: Props) {
+  const [progress, setProgress] = useState(0);
+
+  useEffect(() => {
+    const updateProgress = () => {
+      const nowNanos = Date.now() * 1e6;
+      const startTimeNanos = props.startTime.getTime() * 1e6;
+      const durationNanos =
+        parseInt(props.duration.seconds) * 1e9 + props.duration.nanos;
+      const elapsedNanos = nowNanos - startTimeNanos;
+      const percentage = (elapsedNanos / durationNanos) * 100;
+      setProgress(Math.min(percentage, 100));
+    };
+
+    const timer = setInterval(updateProgress, 100);
+    updateProgress(); // Initial update
+
+    return () => clearInterval(timer);
+  }, [props]);
+
+  return (
+    <Stack direction="row" spacing={1} alignItems="center">
+      <Typography variant="caption" component="div" color="text.secondary">
+        {props.totalRounds && props.totalRounds !== '0'
+          ? `Round ${props.round}/${props.totalRounds}`
+          : `Round ${props.round}`}
+      </Typography>
+      <Box sx={{ position: 'relative', display: 'inline-flex' }}>
+        <CircularProgress variant="determinate" value={progress} />
+        <Box
+          sx={{
+            top: 0,
+            left: 0,
+            bottom: 0,
+            right: 0,
+            position: 'absolute',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+          }}
+        >
+          <Typography variant="caption" component="div" color="text.secondary">
+            {`${Math.round(progress)}%`}
+          </Typography>
+        </Box>
+      </Box>
+    </Stack>
+  );
+}
diff --git a/front/src/components/HelloWorld.vue b/front/src/components/HelloWorld.vue
deleted file mode 100644
index cbedf1a..0000000
--- a/front/src/components/HelloWorld.vue
+++ /dev/null
@@ -1,38 +0,0 @@
-<script lang="ts" setup>
-import { ref } from "vue";
-
-defineProps<{ msg: string }>();
-
-const count = ref(0);
-</script>
-
-<template>
-  <h1>{{ msg }}</h1>
-
-  <div class="card">
-    <button type="button" @click="count++">count is {{ count }}</button>
-    <p>
-      Edit
-      <code>components/HelloWorld.vue</code> to test HMR
-    </p>
-  </div>
-
-  <p>
-    Check out
-    <a href="https://vuejs.org/guide/quick-start.html#local" target="_blank"
-      >create-vue</a
-    >, the official Vue + Vite starter
-  </p>
-  <p>
-    Install
-    <a href="https://github.com/johnsoncodehk/volar" target="_blank">Volar</a>
-    in your IDE for a better DX
-  </p>
-  <p class="read-the-docs">Click on the Vite and Vue logos to learn more</p>
-</template>
-
-<style scoped>
-.read-the-docs {
-  color: #888;
-}
-</style>
diff --git a/front/src/config.ts b/front/src/config.ts
new file mode 100644
index 0000000..dc51cac
--- /dev/null
+++ b/front/src/config.ts
@@ -0,0 +1,11 @@
+const apiURL = import.meta.env.DEV
+  ? 'http://127.0.0.1:8001/api'
+  : window.location.origin + '/api';
+
+const centrifugeWSURL = import.meta.env.DEV
+  ? 'ws://127.0.0.1:8001/centrifuge/websocket'
+  : (window.location.protocol === 'https:' ? 'wss://' : 'ws://') +
+    window.location.host +
+    '/centrifuge/websocket';
+
+export { apiURL, centrifugeWSURL };
diff --git a/front/src/index.css b/front/src/index.css
new file mode 100644
index 0000000..9de717e
--- /dev/null
+++ b/front/src/index.css
@@ -0,0 +1,6 @@
+body {
+  font-family: 'Roboto', sans-serif;
+  margin: 0;
+  padding: 0;
+  background-color: #f5f5f5;
+}
diff --git a/front/src/layouts/ForcADScoreboard.tsx b/front/src/layouts/ForcADScoreboard.tsx
new file mode 100644
index 0000000..4c0eb77
--- /dev/null
+++ b/front/src/layouts/ForcADScoreboard.tsx
@@ -0,0 +1,18 @@
+import Scoreboard from '@/components/ForcAD/Scoreboard';
+import Statuses from '@/components/ForcAD/Statuses.tsx';
+import TopBar from '@/components/ForcAD/TopBar';
+import Box from '@mui/material/Box';
+
+export default function ForcADScoreboardLayout() {
+  return (
+    <>
+      <TopBar />
+      <Box sx={{ paddingTop: 2, paddingLeft: 2, paddingRight: 2 }}>
+        <Statuses />
+      </Box>
+      <Box sx={{ paddingTop: 2, paddingLeft: 2, paddingRight: 2 }}>
+        <Scoreboard />
+      </Box>
+    </>
+  );
+}
diff --git a/front/src/layouts/Live.tsx b/front/src/layouts/Live.tsx
new file mode 100644
index 0000000..642bc72
--- /dev/null
+++ b/front/src/layouts/Live.tsx
@@ -0,0 +1,9 @@
+import Live from '@/components/ForcAD/Live';
+
+export default function LiveLayout() {
+  return (
+    <>
+      <Live />
+    </>
+  );
+}
diff --git a/front/src/layouts/TeamHistory.tsx b/front/src/layouts/TeamHistory.tsx
new file mode 100644
index 0000000..0a93294
--- /dev/null
+++ b/front/src/layouts/TeamHistory.tsx
@@ -0,0 +1,23 @@
+import TeamHistoryTimeline from '@/components/ForcAD/TeamHistoryTimeline';
+import TopBar from '@/components/ForcAD/TopBar';
+import Box from '@mui/material/Box';
+import { Navigate, useParams, useSearchParams } from 'react-router';
+
+export default function TeamHistoryLayout() {
+  const { teamID } = useParams();
+  const [searchParams] = useSearchParams();
+  const serviceID = searchParams.get('serviceId') ?? '';
+
+  if (!teamID) {
+    return <Navigate to="/" />;
+  }
+
+  return (
+    <>
+      <TopBar />
+      <Box sx={{ paddingTop: 2, paddingLeft: 2, paddingRight: 2 }}>
+        <TeamHistoryTimeline teamID={teamID} serviceID={serviceID} />
+      </Box>
+    </>
+  );
+}
diff --git a/front/src/lib/clients/common.ts b/front/src/lib/clients/common.ts
new file mode 100644
index 0000000..881d9ca
--- /dev/null
+++ b/front/src/lib/clients/common.ts
@@ -0,0 +1,55 @@
+import {
+  AxiosError,
+  AxiosInstance,
+  AxiosResponse,
+  InternalAxiosRequestConfig,
+} from 'axios';
+
+const onRequest = (
+  config: InternalAxiosRequestConfig,
+): InternalAxiosRequestConfig => {
+  return config;
+};
+
+const onRequestError = (error: AxiosError): Promise<AxiosError> => {
+  console.error(`[request error] [${JSON.stringify(error)}]`);
+  return Promise.reject(error);
+};
+
+const onResponse = (response: AxiosResponse): AxiosResponse => {
+  return response;
+};
+
+const onResponseError = (error: AxiosError): Promise<AxiosError> => {
+  console.error(`[response error] [${JSON.stringify(error)}]`);
+  return Promise.reject(error);
+};
+
+export function setupInterceptorsTo(
+  axiosInstance: AxiosInstance,
+): AxiosInstance {
+  axiosInstance.interceptors.request.use(onRequest, onRequestError);
+  axiosInstance.interceptors.response.use(onResponse, onResponseError);
+  return axiosInstance;
+}
+
+interface ProtoMessage {
+  // eslint-disable-next-line no-unused-vars
+  fromJSON(data: any): any;
+  // eslint-disable-next-line no-unused-vars
+  decode(data: Uint8Array): any;
+}
+
+export function createProtoJSONTransform<T extends ProtoMessage>(
+  messageType: T,
+) {
+  return (response: string) => {
+    return messageType.fromJSON(JSON.parse(response));
+  };
+}
+
+export function createProtoTransform<T extends ProtoMessage>(messageType: T) {
+  return (response: ArrayBufferLike) => {
+    return messageType.decode(new Uint8Array(response));
+  };
+}
diff --git a/front/src/lib/hooks/scoreboard.ts b/front/src/lib/hooks/scoreboard.ts
new file mode 100644
index 0000000..eedd1bf
--- /dev/null
+++ b/front/src/lib/hooks/scoreboard.ts
@@ -0,0 +1,96 @@
+import { centrifugeWSURL } from '@/config';
+import { Service, Service_Batch } from '@/proto/data/services/services';
+import { Team, Team_Batch } from '@/proto/data/teams/teams';
+import { Scoreboard } from '@/proto/scoreboard/scoreboard';
+import axios from 'axios';
+import { Centrifuge, PublicationContext } from 'centrifuge';
+import { useEffect, useMemo, useState } from 'react';
+import { createProtoJSONTransform } from '../clients/common';
+import { ScoreboardState } from '../models/scoreboardState';
+
+export function useTeams() {
+  const [teams, setTeams] = useState<Team[] | null>(null);
+
+  useEffect(() => {
+    async function fetchTeams() {
+      const { data } = await axios.get<Team_Batch>('/teams', {
+        transformResponse: createProtoJSONTransform(Team_Batch),
+      });
+      setTeams(data.teams);
+    }
+
+    fetchTeams();
+  }, []);
+
+  return teams;
+}
+
+export function useServices() {
+  const [services, setServices] = useState<Service[] | null>(null);
+
+  useEffect(() => {
+    async function fetchServices() {
+      const res = await axios.get<Service_Batch>('/services', {
+        transformResponse: createProtoJSONTransform(Service_Batch),
+      });
+      setServices(res.data.services);
+    }
+
+    fetchServices();
+  }, []);
+
+  return services;
+}
+
+export function useScoreboard() {
+  const teams = useTeams();
+  const services = useServices();
+  const [scoreboard, setScoreboard] = useState<ScoreboardState | null>(null);
+
+  useEffect(() => {
+    async function fetchScoreboard() {
+      const { data: scoreboardData } = await axios.get<Scoreboard>(
+        '/scoreboard',
+        {
+          transformResponse: createProtoJSONTransform(Scoreboard),
+        },
+      );
+
+      const scoreboardState = new ScoreboardState(scoreboardData);
+      setScoreboard(scoreboardState);
+    }
+
+    fetchScoreboard();
+  }, []);
+
+  useEffect(() => {
+    const centrifuge = new Centrifuge(centrifugeWSURL);
+
+    const scoreboardSub = centrifuge.newSubscription('scoreboard');
+    scoreboardSub.on('publication', (ctx: PublicationContext) => {
+      const scoreboardState = new ScoreboardState(
+        Scoreboard.fromJSON(ctx.data),
+      );
+      setScoreboard(scoreboardState);
+    });
+
+    scoreboardSub.subscribe();
+    centrifuge.connect();
+  }, []);
+
+  const preparedTeams = useMemo(() => {
+    if (!scoreboard || !teams) {
+      return [];
+    }
+    return scoreboard.prepareTeams(teams);
+  }, [scoreboard, teams]);
+
+  const preparedServices = useMemo(() => {
+    if (!scoreboard || !services) {
+      return [];
+    }
+    return scoreboard.prepareServices(services);
+  }, [scoreboard, services]);
+
+  return { scoreboard, teams: preparedTeams, services: preparedServices };
+}
diff --git a/front/src/lib/models/scoreboardState.ts b/front/src/lib/models/scoreboardState.ts
new file mode 100644
index 0000000..cb12fde
--- /dev/null
+++ b/front/src/lib/models/scoreboardState.ts
@@ -0,0 +1,64 @@
+import { Service } from '@/proto/data/services/services';
+import { Team } from '@/proto/data/teams/teams';
+import {
+  Scoreboard,
+  Scoreboard_TeamServiceState,
+} from '@/proto/scoreboard/scoreboard';
+
+export class ScoreboardState {
+  private teamServiceState: Map<
+    string,
+    Map<string, Scoreboard_TeamServiceState>
+  >;
+  private teamScore: Map<string, number>;
+
+  constructor(scoreboard: Scoreboard) {
+    this.teamServiceState = new Map();
+    this.teamScore = new Map();
+
+    scoreboard.teamServiceStates.forEach((tss) => {
+      if (!this.teamServiceState.has(tss.teamId)) {
+        const serviceState = new Map<string, Scoreboard_TeamServiceState>();
+        serviceState.set(tss.serviceId, tss);
+        this.teamServiceState.set(tss.teamId, serviceState);
+      } else {
+        this.teamServiceState.get(tss.teamId)?.set(tss.serviceId, tss);
+      }
+
+      const checksTotal = parseInt(tss.checksTotal);
+      const checksPassed = parseInt(tss.checksPassed);
+      this.teamScore.set(
+        tss.teamId,
+        (this.teamScore.get(tss.teamId) ?? 0) +
+          tss.points * (checksTotal > 0 ? checksPassed / checksTotal : 1),
+      );
+    });
+  }
+
+  public prepareTeams(teams: Team[]) {
+    const sortedTeams = teams
+      .map((t) => ({
+        ...t,
+      }))
+      .sort((a, b) => {
+        const scoreA = this.teamScore.get(a.id) ?? 0;
+        const scoreB = this.teamScore.get(b.id) ?? 0;
+        return scoreB - scoreA;
+      });
+    return sortedTeams;
+  }
+
+  public prepareServices(services: Service[]) {
+    return [...services].sort((a, b) => {
+      return parseInt(a.id) - parseInt(b.id);
+    });
+  }
+
+  public getTeamScore(teamId: string) {
+    return this.teamScore.get(teamId) ?? 0;
+  }
+
+  public getTeamServiceState(teamId: string, serviceId: string) {
+    return this.teamServiceState.get(teamId)?.get(serviceId);
+  }
+}
diff --git a/front/src/lib/styles/statusColor.ts b/front/src/lib/styles/statusColor.ts
new file mode 100644
index 0000000..e49045f
--- /dev/null
+++ b/front/src/lib/styles/statusColor.ts
@@ -0,0 +1,19 @@
+import { Status } from '@/proto/checker/checker';
+import { Theme } from '@mui/material';
+
+export default function statusColor(theme: Theme, status: Status) {
+  switch (status) {
+    case Status.STATUS_UP:
+      return theme.palette.statusUp;
+    case Status.STATUS_DOWN:
+      return theme.palette.statusDown;
+    case Status.STATUS_CORRUPT:
+      return theme.palette.statusCorrupt;
+    case Status.STATUS_MUMBLE:
+      return theme.palette.statusMumble;
+    case Status.STATUS_CHECK_FAILED:
+      return theme.palette.statusCheckFailed;
+    default:
+      return theme.palette.statusUnspecified;
+  }
+}
diff --git a/front/src/main.ts b/front/src/main.ts
deleted file mode 100644
index 3c9bfeb..0000000
--- a/front/src/main.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { createApp } from "vue";
-import "./style.css";
-import App from "./App.vue";
-
-createApp(App).mount("#app");
diff --git a/front/src/main.tsx b/front/src/main.tsx
new file mode 100644
index 0000000..cf6ddf3
--- /dev/null
+++ b/front/src/main.tsx
@@ -0,0 +1,33 @@
+import ForcADScoreboardLayout from '@/layouts/ForcADScoreboard.tsx';
+import LiveLayout from '@/layouts/Live.tsx';
+import TeamHistoryLayout from '@/layouts/TeamHistory.tsx';
+import { setupInterceptorsTo } from '@/lib/clients/common.ts';
+import theme from '@/theme.ts';
+import ThemeProvider from '@mui/material/styles/ThemeProvider';
+import axios from 'axios';
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { BrowserRouter, Route, Routes } from 'react-router';
+import { apiURL } from './config.ts';
+import './index.css';
+
+axios.defaults.baseURL = apiURL;
+
+setupInterceptorsTo(axios);
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <ThemeProvider theme={theme}>
+      <BrowserRouter>
+        <Routes>
+          <Route path="/" element={<ForcADScoreboardLayout />} />
+          <Route
+            path="/teams/:teamID/history"
+            element={<TeamHistoryLayout />}
+          />
+          <Route path="/live" element={<LiveLayout />} />
+        </Routes>
+      </BrowserRouter>
+    </ThemeProvider>
+  </StrictMode>,
+);
diff --git a/front/src/proto/checker/checker.ts b/front/src/proto/checker/checker.ts
new file mode 100644
index 0000000..1c15da2
--- /dev/null
+++ b/front/src/proto/checker/checker.ts
@@ -0,0 +1,539 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: checker/checker.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Timestamp } from "../google/protobuf/timestamp";
+
+export const protobufPackage = "checker";
+
+export const Action = { ACTION_UNSPECIFIED: 0, ACTION_CHECK: 1, ACTION_PUT: 2, ACTION_GET: 3 } as const;
+
+export type Action = typeof Action[keyof typeof Action];
+
+export namespace Action {
+  export type ACTION_UNSPECIFIED = typeof Action.ACTION_UNSPECIFIED;
+  export type ACTION_CHECK = typeof Action.ACTION_CHECK;
+  export type ACTION_PUT = typeof Action.ACTION_PUT;
+  export type ACTION_GET = typeof Action.ACTION_GET;
+}
+
+export function actionFromJSON(object: any): Action {
+  switch (object) {
+    case 0:
+    case "ACTION_UNSPECIFIED":
+      return Action.ACTION_UNSPECIFIED;
+    case 1:
+    case "ACTION_CHECK":
+      return Action.ACTION_CHECK;
+    case 2:
+    case "ACTION_PUT":
+      return Action.ACTION_PUT;
+    case 3:
+    case "ACTION_GET":
+      return Action.ACTION_GET;
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum Action");
+  }
+}
+
+export function actionToJSON(object: Action): string {
+  switch (object) {
+    case Action.ACTION_UNSPECIFIED:
+      return "ACTION_UNSPECIFIED";
+    case Action.ACTION_CHECK:
+      return "ACTION_CHECK";
+    case Action.ACTION_PUT:
+      return "ACTION_PUT";
+    case Action.ACTION_GET:
+      return "ACTION_GET";
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum Action");
+  }
+}
+
+export const Status = {
+  STATUS_UNSPECIFIED: 0,
+  STATUS_UP: 1,
+  STATUS_MUMBLE: 2,
+  STATUS_CORRUPT: 3,
+  STATUS_DOWN: 4,
+  STATUS_CHECK_FAILED: 5,
+} as const;
+
+export type Status = typeof Status[keyof typeof Status];
+
+export namespace Status {
+  export type STATUS_UNSPECIFIED = typeof Status.STATUS_UNSPECIFIED;
+  export type STATUS_UP = typeof Status.STATUS_UP;
+  export type STATUS_MUMBLE = typeof Status.STATUS_MUMBLE;
+  export type STATUS_CORRUPT = typeof Status.STATUS_CORRUPT;
+  export type STATUS_DOWN = typeof Status.STATUS_DOWN;
+  export type STATUS_CHECK_FAILED = typeof Status.STATUS_CHECK_FAILED;
+}
+
+export function statusFromJSON(object: any): Status {
+  switch (object) {
+    case 0:
+    case "STATUS_UNSPECIFIED":
+      return Status.STATUS_UNSPECIFIED;
+    case 1:
+    case "STATUS_UP":
+      return Status.STATUS_UP;
+    case 2:
+    case "STATUS_MUMBLE":
+      return Status.STATUS_MUMBLE;
+    case 3:
+    case "STATUS_CORRUPT":
+      return Status.STATUS_CORRUPT;
+    case 4:
+    case "STATUS_DOWN":
+      return Status.STATUS_DOWN;
+    case 5:
+    case "STATUS_CHECK_FAILED":
+      return Status.STATUS_CHECK_FAILED;
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum Status");
+  }
+}
+
+export function statusToJSON(object: Status): string {
+  switch (object) {
+    case Status.STATUS_UNSPECIFIED:
+      return "STATUS_UNSPECIFIED";
+    case Status.STATUS_UP:
+      return "STATUS_UP";
+    case Status.STATUS_MUMBLE:
+      return "STATUS_MUMBLE";
+    case Status.STATUS_CORRUPT:
+      return "STATUS_CORRUPT";
+    case Status.STATUS_DOWN:
+      return "STATUS_DOWN";
+    case Status.STATUS_CHECK_FAILED:
+      return "STATUS_CHECK_FAILED";
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum Status");
+  }
+}
+
+export const Type = { TYPE_UNSPECIFIED: 0, TYPE_LEGACY: 1 } as const;
+
+export type Type = typeof Type[keyof typeof Type];
+
+export namespace Type {
+  export type TYPE_UNSPECIFIED = typeof Type.TYPE_UNSPECIFIED;
+  export type TYPE_LEGACY = typeof Type.TYPE_LEGACY;
+}
+
+export function typeFromJSON(object: any): Type {
+  switch (object) {
+    case 0:
+    case "TYPE_UNSPECIFIED":
+      return Type.TYPE_UNSPECIFIED;
+    case 1:
+    case "TYPE_LEGACY":
+      return Type.TYPE_LEGACY;
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum Type");
+  }
+}
+
+export function typeToJSON(object: Type): string {
+  switch (object) {
+    case Type.TYPE_UNSPECIFIED:
+      return "TYPE_UNSPECIFIED";
+    case Type.TYPE_LEGACY:
+      return "TYPE_LEGACY";
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum Type");
+  }
+}
+
+export interface Execution {
+  teamId: string;
+  serviceId: string;
+  action: Action;
+  status: Status;
+  public: string;
+  private: string;
+  command: string;
+  createdAt: Date | undefined;
+}
+
+export interface Execution_Batch {
+  executions: Execution[];
+}
+
+function createBaseExecution(): Execution {
+  return {
+    teamId: "0",
+    serviceId: "0",
+    action: 0,
+    status: 0,
+    public: "",
+    private: "",
+    command: "",
+    createdAt: undefined,
+  };
+}
+
+export const Execution: MessageFns<Execution> = {
+  encode(message: Execution, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.teamId !== "0") {
+      writer.uint32(8).int64(message.teamId);
+    }
+    if (message.serviceId !== "0") {
+      writer.uint32(16).int64(message.serviceId);
+    }
+    if (message.action !== 0) {
+      writer.uint32(24).int32(message.action);
+    }
+    if (message.status !== 0) {
+      writer.uint32(32).int32(message.status);
+    }
+    if (message.public !== "") {
+      writer.uint32(42).string(message.public);
+    }
+    if (message.private !== "") {
+      writer.uint32(50).string(message.private);
+    }
+    if (message.command !== "") {
+      writer.uint32(58).string(message.command);
+    }
+    if (message.createdAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(66).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Execution {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExecution();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.teamId = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.serviceId = reader.int64().toString();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.action = reader.int32() as any;
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.status = reader.int32() as any;
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.public = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.private = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.command = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Execution, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Execution | Execution[]> | Iterable<Execution | Execution[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Execution.encode(p).finish()];
+        }
+      } else {
+        yield* [Execution.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Execution>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Execution> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Execution.decode(p)];
+        }
+      } else {
+        yield* [Execution.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Execution {
+    return {
+      teamId: isSet(object.teamId)
+        ? globalThis.String(object.teamId)
+        : isSet(object.team_id)
+        ? globalThis.String(object.team_id)
+        : "0",
+      serviceId: isSet(object.serviceId)
+        ? globalThis.String(object.serviceId)
+        : isSet(object.service_id)
+        ? globalThis.String(object.service_id)
+        : "0",
+      action: isSet(object.action) ? actionFromJSON(object.action) : 0,
+      status: isSet(object.status) ? statusFromJSON(object.status) : 0,
+      public: isSet(object.public) ? globalThis.String(object.public) : "",
+      private: isSet(object.private) ? globalThis.String(object.private) : "",
+      command: isSet(object.command) ? globalThis.String(object.command) : "",
+      createdAt: isSet(object.createdAt)
+        ? fromJsonTimestamp(object.createdAt)
+        : isSet(object.created_at)
+        ? fromJsonTimestamp(object.created_at)
+        : undefined,
+    };
+  },
+
+  toJSON(message: Execution): unknown {
+    const obj: any = {};
+    if (message.teamId !== "0") {
+      obj.teamId = message.teamId;
+    }
+    if (message.serviceId !== "0") {
+      obj.serviceId = message.serviceId;
+    }
+    if (message.action !== 0) {
+      obj.action = actionToJSON(message.action);
+    }
+    if (message.status !== 0) {
+      obj.status = statusToJSON(message.status);
+    }
+    if (message.public !== "") {
+      obj.public = message.public;
+    }
+    if (message.private !== "") {
+      obj.private = message.private;
+    }
+    if (message.command !== "") {
+      obj.command = message.command;
+    }
+    if (message.createdAt !== undefined) {
+      obj.createdAt = message.createdAt.toISOString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Execution>, I>>(base?: I): Execution {
+    return Execution.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Execution>, I>>(object: I): Execution {
+    const message = createBaseExecution();
+    message.teamId = object.teamId ?? "0";
+    message.serviceId = object.serviceId ?? "0";
+    message.action = object.action ?? 0;
+    message.status = object.status ?? 0;
+    message.public = object.public ?? "";
+    message.private = object.private ?? "";
+    message.command = object.command ?? "";
+    message.createdAt = object.createdAt ?? undefined;
+    return message;
+  },
+};
+
+function createBaseExecution_Batch(): Execution_Batch {
+  return { executions: [] };
+}
+
+export const Execution_Batch: MessageFns<Execution_Batch> = {
+  encode(message: Execution_Batch, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.executions) {
+      Execution.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Execution_Batch {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExecution_Batch();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.executions.push(Execution.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Execution_Batch, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Execution_Batch | Execution_Batch[]> | Iterable<Execution_Batch | Execution_Batch[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Execution_Batch.encode(p).finish()];
+        }
+      } else {
+        yield* [Execution_Batch.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Execution_Batch>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Execution_Batch> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Execution_Batch.decode(p)];
+        }
+      } else {
+        yield* [Execution_Batch.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Execution_Batch {
+    return {
+      executions: globalThis.Array.isArray(object?.executions)
+        ? object.executions.map((e: any) => Execution.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: Execution_Batch): unknown {
+    const obj: any = {};
+    if (message.executions?.length) {
+      obj.executions = message.executions.map((e) => Execution.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Execution_Batch>, I>>(base?: I): Execution_Batch {
+    return Execution_Batch.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Execution_Batch>, I>>(object: I): Execution_Batch {
+    const message = createBaseExecution_Batch();
+    message.executions = object.executions?.map((e) => Execution.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function toTimestamp(date: Date): Timestamp {
+  const seconds = Math.trunc(date.getTime() / 1_000).toString();
+  const nanos = (date.getTime() % 1_000) * 1_000_000;
+  return { seconds, nanos };
+}
+
+function fromTimestamp(t: Timestamp): Date {
+  let millis = (globalThis.Number(t.seconds) || 0) * 1_000;
+  millis += (t.nanos || 0) / 1_000_000;
+  return new globalThis.Date(millis);
+}
+
+function fromJsonTimestamp(o: any): Date {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/data/game_state/game_state.ts b/front/src/proto/data/game_state/game_state.ts
new file mode 100644
index 0000000..0c5c766
--- /dev/null
+++ b/front/src/proto/data/game_state/game_state.ts
@@ -0,0 +1,1669 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: data/game_state/game_state.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Duration } from "../../google/protobuf/duration";
+import { Timestamp } from "../../google/protobuf/timestamp";
+import { Version } from "../version/version";
+
+export const protobufPackage = "data.game_state";
+
+export const GameStatus = {
+  GAME_STATUS_UNSPECIFIED: 0,
+  GAME_STATUS_NOT_STARTED: 1,
+  GAME_STATUS_RUNNING: 2,
+  GAME_STATUS_PAUSED: 3,
+  GAME_STATUS_FINISHED: 4,
+} as const;
+
+export type GameStatus = typeof GameStatus[keyof typeof GameStatus];
+
+export namespace GameStatus {
+  export type GAME_STATUS_UNSPECIFIED = typeof GameStatus.GAME_STATUS_UNSPECIFIED;
+  export type GAME_STATUS_NOT_STARTED = typeof GameStatus.GAME_STATUS_NOT_STARTED;
+  export type GAME_STATUS_RUNNING = typeof GameStatus.GAME_STATUS_RUNNING;
+  export type GAME_STATUS_PAUSED = typeof GameStatus.GAME_STATUS_PAUSED;
+  export type GAME_STATUS_FINISHED = typeof GameStatus.GAME_STATUS_FINISHED;
+}
+
+export function gameStatusFromJSON(object: any): GameStatus {
+  switch (object) {
+    case 0:
+    case "GAME_STATUS_UNSPECIFIED":
+      return GameStatus.GAME_STATUS_UNSPECIFIED;
+    case 1:
+    case "GAME_STATUS_NOT_STARTED":
+      return GameStatus.GAME_STATUS_NOT_STARTED;
+    case 2:
+    case "GAME_STATUS_RUNNING":
+      return GameStatus.GAME_STATUS_RUNNING;
+    case 3:
+    case "GAME_STATUS_PAUSED":
+      return GameStatus.GAME_STATUS_PAUSED;
+    case 4:
+    case "GAME_STATUS_FINISHED":
+      return GameStatus.GAME_STATUS_FINISHED;
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum GameStatus");
+  }
+}
+
+export function gameStatusToJSON(object: GameStatus): string {
+  switch (object) {
+    case GameStatus.GAME_STATUS_UNSPECIFIED:
+      return "GAME_STATUS_UNSPECIFIED";
+    case GameStatus.GAME_STATUS_NOT_STARTED:
+      return "GAME_STATUS_NOT_STARTED";
+    case GameStatus.GAME_STATUS_RUNNING:
+      return "GAME_STATUS_RUNNING";
+    case GameStatus.GAME_STATUS_PAUSED:
+      return "GAME_STATUS_PAUSED";
+    case GameStatus.GAME_STATUS_FINISHED:
+      return "GAME_STATUS_FINISHED";
+    default:
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum GameStatus");
+  }
+}
+
+export interface GameState {
+  startTime: Date | undefined;
+  endTime: Date | undefined;
+  totalRounds: string;
+  status: GameStatus;
+  flagLifetimeRounds: string;
+  roundDuration: Duration | undefined;
+  runningRound: string;
+  runningRoundStart: Date | undefined;
+  hardness: number;
+  inflation: boolean;
+}
+
+export interface GetRequest {
+  version: Version | undefined;
+}
+
+export interface GetResponse {
+  gameState: GameState | undefined;
+  version: Version | undefined;
+}
+
+export interface UpdateRequest {
+  startTime:
+    | Date
+    | undefined;
+  /** Zero time means no end time. */
+  endTime: Date | undefined;
+  totalRounds?: string | undefined;
+  status: GameStatus;
+  flagLifetimeRounds?: string | undefined;
+  roundDuration: Duration | undefined;
+  hardness?: number | undefined;
+  inflation?: boolean | undefined;
+}
+
+export interface UpdateResponse {
+  gameState: GameState | undefined;
+  version: Version | undefined;
+}
+
+export interface UpdateRoundRequest {
+  runningRound: string;
+  runningRoundStart: Date | undefined;
+}
+
+export interface UpdateRoundResponse {
+  gameState: GameState | undefined;
+  version: Version | undefined;
+}
+
+export interface FinishGameRequest {
+}
+
+export interface FinishGameResponse {
+  gameState: GameState | undefined;
+  version: Version | undefined;
+}
+
+export interface CreateRequest {
+  gameState: GameState | undefined;
+}
+
+export interface CreateResponse {
+  gameState: GameState | undefined;
+  version: Version | undefined;
+}
+
+function createBaseGameState(): GameState {
+  return {
+    startTime: undefined,
+    endTime: undefined,
+    totalRounds: "0",
+    status: 0,
+    flagLifetimeRounds: "0",
+    roundDuration: undefined,
+    runningRound: "0",
+    runningRoundStart: undefined,
+    hardness: 0,
+    inflation: false,
+  };
+}
+
+export const GameState: MessageFns<GameState> = {
+  encode(message: GameState, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.startTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.startTime), writer.uint32(10).fork()).join();
+    }
+    if (message.endTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.endTime), writer.uint32(18).fork()).join();
+    }
+    if (message.totalRounds !== "0") {
+      writer.uint32(24).uint64(message.totalRounds);
+    }
+    if (message.status !== 0) {
+      writer.uint32(32).int32(message.status);
+    }
+    if (message.flagLifetimeRounds !== "0") {
+      writer.uint32(40).uint64(message.flagLifetimeRounds);
+    }
+    if (message.roundDuration !== undefined) {
+      Duration.encode(message.roundDuration, writer.uint32(50).fork()).join();
+    }
+    if (message.runningRound !== "0") {
+      writer.uint32(56).uint64(message.runningRound);
+    }
+    if (message.runningRoundStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.runningRoundStart), writer.uint32(66).fork()).join();
+    }
+    if (message.hardness !== 0) {
+      writer.uint32(73).double(message.hardness);
+    }
+    if (message.inflation !== false) {
+      writer.uint32(80).bool(message.inflation);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GameState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGameState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.endTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.totalRounds = reader.uint64().toString();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.status = reader.int32() as any;
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.flagLifetimeRounds = reader.uint64().toString();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.roundDuration = Duration.decode(reader, reader.uint32());
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+
+          message.runningRound = reader.uint64().toString();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.runningRoundStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 9: {
+          if (tag !== 73) {
+            break;
+          }
+
+          message.hardness = reader.double();
+          continue;
+        }
+        case 10: {
+          if (tag !== 80) {
+            break;
+          }
+
+          message.inflation = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<GameState, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<GameState | GameState[]> | Iterable<GameState | GameState[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GameState.encode(p).finish()];
+        }
+      } else {
+        yield* [GameState.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, GameState>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<GameState> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GameState.decode(p)];
+        }
+      } else {
+        yield* [GameState.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): GameState {
+    return {
+      startTime: isSet(object.startTime)
+        ? fromJsonTimestamp(object.startTime)
+        : isSet(object.start_time)
+        ? fromJsonTimestamp(object.start_time)
+        : undefined,
+      endTime: isSet(object.endTime)
+        ? fromJsonTimestamp(object.endTime)
+        : isSet(object.end_time)
+        ? fromJsonTimestamp(object.end_time)
+        : undefined,
+      totalRounds: isSet(object.totalRounds)
+        ? globalThis.String(object.totalRounds)
+        : isSet(object.total_rounds)
+        ? globalThis.String(object.total_rounds)
+        : "0",
+      status: isSet(object.status) ? gameStatusFromJSON(object.status) : 0,
+      flagLifetimeRounds: isSet(object.flagLifetimeRounds)
+        ? globalThis.String(object.flagLifetimeRounds)
+        : isSet(object.flag_lifetime_rounds)
+        ? globalThis.String(object.flag_lifetime_rounds)
+        : "0",
+      roundDuration: isSet(object.roundDuration)
+        ? Duration.fromJSON(object.roundDuration)
+        : isSet(object.round_duration)
+        ? Duration.fromJSON(object.round_duration)
+        : undefined,
+      runningRound: isSet(object.runningRound)
+        ? globalThis.String(object.runningRound)
+        : isSet(object.running_round)
+        ? globalThis.String(object.running_round)
+        : "0",
+      runningRoundStart: isSet(object.runningRoundStart)
+        ? fromJsonTimestamp(object.runningRoundStart)
+        : isSet(object.running_round_start)
+        ? fromJsonTimestamp(object.running_round_start)
+        : undefined,
+      hardness: isSet(object.hardness) ? globalThis.Number(object.hardness) : 0,
+      inflation: isSet(object.inflation) ? globalThis.Boolean(object.inflation) : false,
+    };
+  },
+
+  toJSON(message: GameState): unknown {
+    const obj: any = {};
+    if (message.startTime !== undefined) {
+      obj.startTime = message.startTime.toISOString();
+    }
+    if (message.endTime !== undefined) {
+      obj.endTime = message.endTime.toISOString();
+    }
+    if (message.totalRounds !== "0") {
+      obj.totalRounds = message.totalRounds;
+    }
+    if (message.status !== 0) {
+      obj.status = gameStatusToJSON(message.status);
+    }
+    if (message.flagLifetimeRounds !== "0") {
+      obj.flagLifetimeRounds = message.flagLifetimeRounds;
+    }
+    if (message.roundDuration !== undefined) {
+      obj.roundDuration = Duration.toJSON(message.roundDuration);
+    }
+    if (message.runningRound !== "0") {
+      obj.runningRound = message.runningRound;
+    }
+    if (message.runningRoundStart !== undefined) {
+      obj.runningRoundStart = message.runningRoundStart.toISOString();
+    }
+    if (message.hardness !== 0) {
+      obj.hardness = message.hardness;
+    }
+    if (message.inflation !== false) {
+      obj.inflation = message.inflation;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GameState>, I>>(base?: I): GameState {
+    return GameState.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GameState>, I>>(object: I): GameState {
+    const message = createBaseGameState();
+    message.startTime = object.startTime ?? undefined;
+    message.endTime = object.endTime ?? undefined;
+    message.totalRounds = object.totalRounds ?? "0";
+    message.status = object.status ?? 0;
+    message.flagLifetimeRounds = object.flagLifetimeRounds ?? "0";
+    message.roundDuration = (object.roundDuration !== undefined && object.roundDuration !== null)
+      ? Duration.fromPartial(object.roundDuration)
+      : undefined;
+    message.runningRound = object.runningRound ?? "0";
+    message.runningRoundStart = object.runningRoundStart ?? undefined;
+    message.hardness = object.hardness ?? 0;
+    message.inflation = object.inflation ?? false;
+    return message;
+  },
+};
+
+function createBaseGetRequest(): GetRequest {
+  return { version: undefined };
+}
+
+export const GetRequest: MessageFns<GetRequest> = {
+  encode(message: GetRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<GetRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<GetRequest | GetRequest[]> | Iterable<GetRequest | GetRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [GetRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, GetRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<GetRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetRequest.decode(p)];
+        }
+      } else {
+        yield* [GetRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): GetRequest {
+    return { version: isSet(object.version) ? Version.fromJSON(object.version) : undefined };
+  },
+
+  toJSON(message: GetRequest): unknown {
+    const obj: any = {};
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetRequest>, I>>(base?: I): GetRequest {
+    return GetRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetRequest>, I>>(object: I): GetRequest {
+    const message = createBaseGetRequest();
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetResponse(): GetResponse {
+  return { gameState: undefined, version: undefined };
+}
+
+export const GetResponse: MessageFns<GetResponse> = {
+  encode(message: GetResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.gameState !== undefined) {
+      GameState.encode(message.gameState, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.gameState = GameState.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<GetResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<GetResponse | GetResponse[]> | Iterable<GetResponse | GetResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [GetResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, GetResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<GetResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetResponse.decode(p)];
+        }
+      } else {
+        yield* [GetResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): GetResponse {
+    return {
+      gameState: isSet(object.gameState)
+        ? GameState.fromJSON(object.gameState)
+        : isSet(object.game_state)
+        ? GameState.fromJSON(object.game_state)
+        : undefined,
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: GetResponse): unknown {
+    const obj: any = {};
+    if (message.gameState !== undefined) {
+      obj.gameState = GameState.toJSON(message.gameState);
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetResponse>, I>>(base?: I): GetResponse {
+    return GetResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetResponse>, I>>(object: I): GetResponse {
+    const message = createBaseGetResponse();
+    message.gameState = (object.gameState !== undefined && object.gameState !== null)
+      ? GameState.fromPartial(object.gameState)
+      : undefined;
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateRequest(): UpdateRequest {
+  return {
+    startTime: undefined,
+    endTime: undefined,
+    totalRounds: undefined,
+    status: 0,
+    flagLifetimeRounds: undefined,
+    roundDuration: undefined,
+    hardness: undefined,
+    inflation: undefined,
+  };
+}
+
+export const UpdateRequest: MessageFns<UpdateRequest> = {
+  encode(message: UpdateRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.startTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.startTime), writer.uint32(10).fork()).join();
+    }
+    if (message.endTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.endTime), writer.uint32(18).fork()).join();
+    }
+    if (message.totalRounds !== undefined) {
+      writer.uint32(24).uint64(message.totalRounds);
+    }
+    if (message.status !== 0) {
+      writer.uint32(32).int32(message.status);
+    }
+    if (message.flagLifetimeRounds !== undefined) {
+      writer.uint32(40).uint64(message.flagLifetimeRounds);
+    }
+    if (message.roundDuration !== undefined) {
+      Duration.encode(message.roundDuration, writer.uint32(50).fork()).join();
+    }
+    if (message.hardness !== undefined) {
+      writer.uint32(57).double(message.hardness);
+    }
+    if (message.inflation !== undefined) {
+      writer.uint32(64).bool(message.inflation);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.endTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.totalRounds = reader.uint64().toString();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.status = reader.int32() as any;
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.flagLifetimeRounds = reader.uint64().toString();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.roundDuration = Duration.decode(reader, reader.uint32());
+          continue;
+        }
+        case 7: {
+          if (tag !== 57) {
+            break;
+          }
+
+          message.hardness = reader.double();
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+
+          message.inflation = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<UpdateRequest | UpdateRequest[]> | Iterable<UpdateRequest | UpdateRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRequest.decode(p)];
+        }
+      } else {
+        yield* [UpdateRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateRequest {
+    return {
+      startTime: isSet(object.startTime)
+        ? fromJsonTimestamp(object.startTime)
+        : isSet(object.start_time)
+        ? fromJsonTimestamp(object.start_time)
+        : undefined,
+      endTime: isSet(object.endTime)
+        ? fromJsonTimestamp(object.endTime)
+        : isSet(object.end_time)
+        ? fromJsonTimestamp(object.end_time)
+        : undefined,
+      totalRounds: isSet(object.totalRounds)
+        ? globalThis.String(object.totalRounds)
+        : isSet(object.total_rounds)
+        ? globalThis.String(object.total_rounds)
+        : undefined,
+      status: isSet(object.status) ? gameStatusFromJSON(object.status) : 0,
+      flagLifetimeRounds: isSet(object.flagLifetimeRounds)
+        ? globalThis.String(object.flagLifetimeRounds)
+        : isSet(object.flag_lifetime_rounds)
+        ? globalThis.String(object.flag_lifetime_rounds)
+        : undefined,
+      roundDuration: isSet(object.roundDuration)
+        ? Duration.fromJSON(object.roundDuration)
+        : isSet(object.round_duration)
+        ? Duration.fromJSON(object.round_duration)
+        : undefined,
+      hardness: isSet(object.hardness) ? globalThis.Number(object.hardness) : undefined,
+      inflation: isSet(object.inflation) ? globalThis.Boolean(object.inflation) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateRequest): unknown {
+    const obj: any = {};
+    if (message.startTime !== undefined) {
+      obj.startTime = message.startTime.toISOString();
+    }
+    if (message.endTime !== undefined) {
+      obj.endTime = message.endTime.toISOString();
+    }
+    if (message.totalRounds !== undefined) {
+      obj.totalRounds = message.totalRounds;
+    }
+    if (message.status !== 0) {
+      obj.status = gameStatusToJSON(message.status);
+    }
+    if (message.flagLifetimeRounds !== undefined) {
+      obj.flagLifetimeRounds = message.flagLifetimeRounds;
+    }
+    if (message.roundDuration !== undefined) {
+      obj.roundDuration = Duration.toJSON(message.roundDuration);
+    }
+    if (message.hardness !== undefined) {
+      obj.hardness = message.hardness;
+    }
+    if (message.inflation !== undefined) {
+      obj.inflation = message.inflation;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateRequest>, I>>(base?: I): UpdateRequest {
+    return UpdateRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateRequest>, I>>(object: I): UpdateRequest {
+    const message = createBaseUpdateRequest();
+    message.startTime = object.startTime ?? undefined;
+    message.endTime = object.endTime ?? undefined;
+    message.totalRounds = object.totalRounds ?? undefined;
+    message.status = object.status ?? 0;
+    message.flagLifetimeRounds = object.flagLifetimeRounds ?? undefined;
+    message.roundDuration = (object.roundDuration !== undefined && object.roundDuration !== null)
+      ? Duration.fromPartial(object.roundDuration)
+      : undefined;
+    message.hardness = object.hardness ?? undefined;
+    message.inflation = object.inflation ?? undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateResponse(): UpdateResponse {
+  return { gameState: undefined, version: undefined };
+}
+
+export const UpdateResponse: MessageFns<UpdateResponse> = {
+  encode(message: UpdateResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.gameState !== undefined) {
+      GameState.encode(message.gameState, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.gameState = GameState.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<UpdateResponse | UpdateResponse[]> | Iterable<UpdateResponse | UpdateResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateResponse.decode(p)];
+        }
+      } else {
+        yield* [UpdateResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateResponse {
+    return {
+      gameState: isSet(object.gameState)
+        ? GameState.fromJSON(object.gameState)
+        : isSet(object.game_state)
+        ? GameState.fromJSON(object.game_state)
+        : undefined,
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateResponse): unknown {
+    const obj: any = {};
+    if (message.gameState !== undefined) {
+      obj.gameState = GameState.toJSON(message.gameState);
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateResponse>, I>>(base?: I): UpdateResponse {
+    return UpdateResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateResponse>, I>>(object: I): UpdateResponse {
+    const message = createBaseUpdateResponse();
+    message.gameState = (object.gameState !== undefined && object.gameState !== null)
+      ? GameState.fromPartial(object.gameState)
+      : undefined;
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateRoundRequest(): UpdateRoundRequest {
+  return { runningRound: "0", runningRoundStart: undefined };
+}
+
+export const UpdateRoundRequest: MessageFns<UpdateRoundRequest> = {
+  encode(message: UpdateRoundRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.runningRound !== "0") {
+      writer.uint32(8).uint64(message.runningRound);
+    }
+    if (message.runningRoundStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.runningRoundStart), writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateRoundRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateRoundRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.runningRound = reader.uint64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.runningRoundStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateRoundRequest, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<UpdateRoundRequest | UpdateRoundRequest[]>
+      | Iterable<UpdateRoundRequest | UpdateRoundRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRoundRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateRoundRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateRoundRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateRoundRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRoundRequest.decode(p)];
+        }
+      } else {
+        yield* [UpdateRoundRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateRoundRequest {
+    return {
+      runningRound: isSet(object.runningRound)
+        ? globalThis.String(object.runningRound)
+        : isSet(object.running_round)
+        ? globalThis.String(object.running_round)
+        : "0",
+      runningRoundStart: isSet(object.runningRoundStart)
+        ? fromJsonTimestamp(object.runningRoundStart)
+        : isSet(object.running_round_start)
+        ? fromJsonTimestamp(object.running_round_start)
+        : undefined,
+    };
+  },
+
+  toJSON(message: UpdateRoundRequest): unknown {
+    const obj: any = {};
+    if (message.runningRound !== "0") {
+      obj.runningRound = message.runningRound;
+    }
+    if (message.runningRoundStart !== undefined) {
+      obj.runningRoundStart = message.runningRoundStart.toISOString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateRoundRequest>, I>>(base?: I): UpdateRoundRequest {
+    return UpdateRoundRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateRoundRequest>, I>>(object: I): UpdateRoundRequest {
+    const message = createBaseUpdateRoundRequest();
+    message.runningRound = object.runningRound ?? "0";
+    message.runningRoundStart = object.runningRoundStart ?? undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateRoundResponse(): UpdateRoundResponse {
+  return { gameState: undefined, version: undefined };
+}
+
+export const UpdateRoundResponse: MessageFns<UpdateRoundResponse> = {
+  encode(message: UpdateRoundResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.gameState !== undefined) {
+      GameState.encode(message.gameState, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateRoundResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateRoundResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.gameState = GameState.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateRoundResponse, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<UpdateRoundResponse | UpdateRoundResponse[]>
+      | Iterable<UpdateRoundResponse | UpdateRoundResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRoundResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateRoundResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateRoundResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateRoundResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRoundResponse.decode(p)];
+        }
+      } else {
+        yield* [UpdateRoundResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateRoundResponse {
+    return {
+      gameState: isSet(object.gameState)
+        ? GameState.fromJSON(object.gameState)
+        : isSet(object.game_state)
+        ? GameState.fromJSON(object.game_state)
+        : undefined,
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateRoundResponse): unknown {
+    const obj: any = {};
+    if (message.gameState !== undefined) {
+      obj.gameState = GameState.toJSON(message.gameState);
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateRoundResponse>, I>>(base?: I): UpdateRoundResponse {
+    return UpdateRoundResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateRoundResponse>, I>>(object: I): UpdateRoundResponse {
+    const message = createBaseUpdateRoundResponse();
+    message.gameState = (object.gameState !== undefined && object.gameState !== null)
+      ? GameState.fromPartial(object.gameState)
+      : undefined;
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseFinishGameRequest(): FinishGameRequest {
+  return {};
+}
+
+export const FinishGameRequest: MessageFns<FinishGameRequest> = {
+  encode(_: FinishGameRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FinishGameRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFinishGameRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<FinishGameRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<FinishGameRequest | FinishGameRequest[]> | Iterable<FinishGameRequest | FinishGameRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [FinishGameRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [FinishGameRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, FinishGameRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<FinishGameRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [FinishGameRequest.decode(p)];
+        }
+      } else {
+        yield* [FinishGameRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(_: any): FinishGameRequest {
+    return {};
+  },
+
+  toJSON(_: FinishGameRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FinishGameRequest>, I>>(base?: I): FinishGameRequest {
+    return FinishGameRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<FinishGameRequest>, I>>(_: I): FinishGameRequest {
+    const message = createBaseFinishGameRequest();
+    return message;
+  },
+};
+
+function createBaseFinishGameResponse(): FinishGameResponse {
+  return { gameState: undefined, version: undefined };
+}
+
+export const FinishGameResponse: MessageFns<FinishGameResponse> = {
+  encode(message: FinishGameResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.gameState !== undefined) {
+      GameState.encode(message.gameState, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FinishGameResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFinishGameResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.gameState = GameState.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<FinishGameResponse, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<FinishGameResponse | FinishGameResponse[]>
+      | Iterable<FinishGameResponse | FinishGameResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [FinishGameResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [FinishGameResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, FinishGameResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<FinishGameResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [FinishGameResponse.decode(p)];
+        }
+      } else {
+        yield* [FinishGameResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): FinishGameResponse {
+    return {
+      gameState: isSet(object.gameState)
+        ? GameState.fromJSON(object.gameState)
+        : isSet(object.game_state)
+        ? GameState.fromJSON(object.game_state)
+        : undefined,
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: FinishGameResponse): unknown {
+    const obj: any = {};
+    if (message.gameState !== undefined) {
+      obj.gameState = GameState.toJSON(message.gameState);
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FinishGameResponse>, I>>(base?: I): FinishGameResponse {
+    return FinishGameResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<FinishGameResponse>, I>>(object: I): FinishGameResponse {
+    const message = createBaseFinishGameResponse();
+    message.gameState = (object.gameState !== undefined && object.gameState !== null)
+      ? GameState.fromPartial(object.gameState)
+      : undefined;
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseCreateRequest(): CreateRequest {
+  return { gameState: undefined };
+}
+
+export const CreateRequest: MessageFns<CreateRequest> = {
+  encode(message: CreateRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.gameState !== undefined) {
+      GameState.encode(message.gameState, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.gameState = GameState.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<CreateRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<CreateRequest | CreateRequest[]> | Iterable<CreateRequest | CreateRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [CreateRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CreateRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<CreateRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateRequest.decode(p)];
+        }
+      } else {
+        yield* [CreateRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): CreateRequest {
+    return {
+      gameState: isSet(object.gameState)
+        ? GameState.fromJSON(object.gameState)
+        : isSet(object.game_state)
+        ? GameState.fromJSON(object.game_state)
+        : undefined,
+    };
+  },
+
+  toJSON(message: CreateRequest): unknown {
+    const obj: any = {};
+    if (message.gameState !== undefined) {
+      obj.gameState = GameState.toJSON(message.gameState);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateRequest>, I>>(base?: I): CreateRequest {
+    return CreateRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateRequest>, I>>(object: I): CreateRequest {
+    const message = createBaseCreateRequest();
+    message.gameState = (object.gameState !== undefined && object.gameState !== null)
+      ? GameState.fromPartial(object.gameState)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseCreateResponse(): CreateResponse {
+  return { gameState: undefined, version: undefined };
+}
+
+export const CreateResponse: MessageFns<CreateResponse> = {
+  encode(message: CreateResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.gameState !== undefined) {
+      GameState.encode(message.gameState, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.gameState = GameState.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<CreateResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<CreateResponse | CreateResponse[]> | Iterable<CreateResponse | CreateResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [CreateResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CreateResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<CreateResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateResponse.decode(p)];
+        }
+      } else {
+        yield* [CreateResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): CreateResponse {
+    return {
+      gameState: isSet(object.gameState)
+        ? GameState.fromJSON(object.gameState)
+        : isSet(object.game_state)
+        ? GameState.fromJSON(object.game_state)
+        : undefined,
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: CreateResponse): unknown {
+    const obj: any = {};
+    if (message.gameState !== undefined) {
+      obj.gameState = GameState.toJSON(message.gameState);
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateResponse>, I>>(base?: I): CreateResponse {
+    return CreateResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateResponse>, I>>(object: I): CreateResponse {
+    const message = createBaseCreateResponse();
+    message.gameState = (object.gameState !== undefined && object.gameState !== null)
+      ? GameState.fromPartial(object.gameState)
+      : undefined;
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function toTimestamp(date: Date): Timestamp {
+  const seconds = Math.trunc(date.getTime() / 1_000).toString();
+  const nanos = (date.getTime() % 1_000) * 1_000_000;
+  return { seconds, nanos };
+}
+
+function fromTimestamp(t: Timestamp): Date {
+  let millis = (globalThis.Number(t.seconds) || 0) * 1_000;
+  millis += (t.nanos || 0) / 1_000_000;
+  return new globalThis.Date(millis);
+}
+
+function fromJsonTimestamp(o: any): Date {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/data/game_state/game_state_service.ts b/front/src/proto/data/game_state/game_state_service.ts
new file mode 100644
index 0000000..1148369
--- /dev/null
+++ b/front/src/proto/data/game_state/game_state_service.ts
@@ -0,0 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: data/game_state/game_state_service.proto
+
+/* eslint-disable */
+
+export const protobufPackage = "data.game_state";
diff --git a/front/src/proto/data/services/services.ts b/front/src/proto/data/services/services.ts
new file mode 100644
index 0000000..24a92a8
--- /dev/null
+++ b/front/src/proto/data/services/services.ts
@@ -0,0 +1,1239 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: data/services/services.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Action, actionFromJSON, actionToJSON, Type, typeFromJSON, typeToJSON } from "../../checker/checker";
+import { Duration } from "../../google/protobuf/duration";
+import { Version } from "../version/version";
+
+export const protobufPackage = "data.services";
+
+export interface Service {
+  id: string;
+  name: string;
+  checker: Service_Checker | undefined;
+  defaultScore: number;
+  disabled: boolean;
+}
+
+export interface Service_Batch {
+  services: Service[];
+}
+
+export interface Service_Checker {
+  type: Type;
+  path: string;
+  defaultTimeout: Duration | undefined;
+  actions: Service_Checker_Action[];
+}
+
+export interface Service_Checker_Action {
+  action: Action;
+  timeout: Duration | undefined;
+  runCount: string;
+}
+
+export interface ListRequest {
+  version: Version | undefined;
+}
+
+export interface ListResponse {
+  services: Service[];
+  version: Version | undefined;
+}
+
+export interface CreateBatchRequest {
+  services: Service[];
+}
+
+export interface CreateBatchResponse {
+  services: Service[];
+}
+
+export interface UpdateRequest {
+  id: string;
+  disabled?: boolean | undefined;
+}
+
+export interface UpdateResponse {
+  service: Service | undefined;
+  version: Version | undefined;
+}
+
+function createBaseService(): Service {
+  return { id: "0", name: "", checker: undefined, defaultScore: 0, disabled: false };
+}
+
+export const Service: MessageFns<Service> = {
+  encode(message: Service, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "0") {
+      writer.uint32(8).int64(message.id);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.checker !== undefined) {
+      Service_Checker.encode(message.checker, writer.uint32(26).fork()).join();
+    }
+    if (message.defaultScore !== 0) {
+      writer.uint32(33).double(message.defaultScore);
+    }
+    if (message.disabled !== false) {
+      writer.uint32(40).bool(message.disabled);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Service {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseService();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.checker = Service_Checker.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 33) {
+            break;
+          }
+
+          message.defaultScore = reader.double();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.disabled = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Service, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Service | Service[]> | Iterable<Service | Service[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service.encode(p).finish()];
+        }
+      } else {
+        yield* [Service.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Service>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Service> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service.decode(p)];
+        }
+      } else {
+        yield* [Service.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Service {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "0",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      checker: isSet(object.checker) ? Service_Checker.fromJSON(object.checker) : undefined,
+      defaultScore: isSet(object.defaultScore)
+        ? globalThis.Number(object.defaultScore)
+        : isSet(object.default_score)
+        ? globalThis.Number(object.default_score)
+        : 0,
+      disabled: isSet(object.disabled) ? globalThis.Boolean(object.disabled) : false,
+    };
+  },
+
+  toJSON(message: Service): unknown {
+    const obj: any = {};
+    if (message.id !== "0") {
+      obj.id = message.id;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.checker !== undefined) {
+      obj.checker = Service_Checker.toJSON(message.checker);
+    }
+    if (message.defaultScore !== 0) {
+      obj.defaultScore = message.defaultScore;
+    }
+    if (message.disabled !== false) {
+      obj.disabled = message.disabled;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Service>, I>>(base?: I): Service {
+    return Service.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Service>, I>>(object: I): Service {
+    const message = createBaseService();
+    message.id = object.id ?? "0";
+    message.name = object.name ?? "";
+    message.checker = (object.checker !== undefined && object.checker !== null)
+      ? Service_Checker.fromPartial(object.checker)
+      : undefined;
+    message.defaultScore = object.defaultScore ?? 0;
+    message.disabled = object.disabled ?? false;
+    return message;
+  },
+};
+
+function createBaseService_Batch(): Service_Batch {
+  return { services: [] };
+}
+
+export const Service_Batch: MessageFns<Service_Batch> = {
+  encode(message: Service_Batch, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.services) {
+      Service.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Service_Batch {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseService_Batch();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.services.push(Service.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Service_Batch, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Service_Batch | Service_Batch[]> | Iterable<Service_Batch | Service_Batch[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service_Batch.encode(p).finish()];
+        }
+      } else {
+        yield* [Service_Batch.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Service_Batch>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Service_Batch> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service_Batch.decode(p)];
+        }
+      } else {
+        yield* [Service_Batch.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Service_Batch {
+    return {
+      services: globalThis.Array.isArray(object?.services) ? object.services.map((e: any) => Service.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: Service_Batch): unknown {
+    const obj: any = {};
+    if (message.services?.length) {
+      obj.services = message.services.map((e) => Service.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Service_Batch>, I>>(base?: I): Service_Batch {
+    return Service_Batch.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Service_Batch>, I>>(object: I): Service_Batch {
+    const message = createBaseService_Batch();
+    message.services = object.services?.map((e) => Service.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseService_Checker(): Service_Checker {
+  return { type: 0, path: "", defaultTimeout: undefined, actions: [] };
+}
+
+export const Service_Checker: MessageFns<Service_Checker> = {
+  encode(message: Service_Checker, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.type !== 0) {
+      writer.uint32(8).int32(message.type);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    if (message.defaultTimeout !== undefined) {
+      Duration.encode(message.defaultTimeout, writer.uint32(26).fork()).join();
+    }
+    for (const v of message.actions) {
+      Service_Checker_Action.encode(v!, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Service_Checker {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseService_Checker();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.type = reader.int32() as any;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.path = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.defaultTimeout = Duration.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.actions.push(Service_Checker_Action.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Service_Checker, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Service_Checker | Service_Checker[]> | Iterable<Service_Checker | Service_Checker[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service_Checker.encode(p).finish()];
+        }
+      } else {
+        yield* [Service_Checker.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Service_Checker>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Service_Checker> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service_Checker.decode(p)];
+        }
+      } else {
+        yield* [Service_Checker.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Service_Checker {
+    return {
+      type: isSet(object.type) ? typeFromJSON(object.type) : 0,
+      path: isSet(object.path) ? globalThis.String(object.path) : "",
+      defaultTimeout: isSet(object.defaultTimeout)
+        ? Duration.fromJSON(object.defaultTimeout)
+        : isSet(object.default_timeout)
+        ? Duration.fromJSON(object.default_timeout)
+        : undefined,
+      actions: globalThis.Array.isArray(object?.actions)
+        ? object.actions.map((e: any) => Service_Checker_Action.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: Service_Checker): unknown {
+    const obj: any = {};
+    if (message.type !== 0) {
+      obj.type = typeToJSON(message.type);
+    }
+    if (message.path !== "") {
+      obj.path = message.path;
+    }
+    if (message.defaultTimeout !== undefined) {
+      obj.defaultTimeout = Duration.toJSON(message.defaultTimeout);
+    }
+    if (message.actions?.length) {
+      obj.actions = message.actions.map((e) => Service_Checker_Action.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Service_Checker>, I>>(base?: I): Service_Checker {
+    return Service_Checker.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Service_Checker>, I>>(object: I): Service_Checker {
+    const message = createBaseService_Checker();
+    message.type = object.type ?? 0;
+    message.path = object.path ?? "";
+    message.defaultTimeout = (object.defaultTimeout !== undefined && object.defaultTimeout !== null)
+      ? Duration.fromPartial(object.defaultTimeout)
+      : undefined;
+    message.actions = object.actions?.map((e) => Service_Checker_Action.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseService_Checker_Action(): Service_Checker_Action {
+  return { action: 0, timeout: undefined, runCount: "0" };
+}
+
+export const Service_Checker_Action: MessageFns<Service_Checker_Action> = {
+  encode(message: Service_Checker_Action, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.action !== 0) {
+      writer.uint32(8).int32(message.action);
+    }
+    if (message.timeout !== undefined) {
+      Duration.encode(message.timeout, writer.uint32(18).fork()).join();
+    }
+    if (message.runCount !== "0") {
+      writer.uint32(24).int64(message.runCount);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Service_Checker_Action {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseService_Checker_Action();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.action = reader.int32() as any;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.timeout = Duration.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.runCount = reader.int64().toString();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Service_Checker_Action, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<Service_Checker_Action | Service_Checker_Action[]>
+      | Iterable<Service_Checker_Action | Service_Checker_Action[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service_Checker_Action.encode(p).finish()];
+        }
+      } else {
+        yield* [Service_Checker_Action.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Service_Checker_Action>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Service_Checker_Action> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Service_Checker_Action.decode(p)];
+        }
+      } else {
+        yield* [Service_Checker_Action.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Service_Checker_Action {
+    return {
+      action: isSet(object.action) ? actionFromJSON(object.action) : 0,
+      timeout: isSet(object.timeout) ? Duration.fromJSON(object.timeout) : undefined,
+      runCount: isSet(object.runCount)
+        ? globalThis.String(object.runCount)
+        : isSet(object.run_count)
+        ? globalThis.String(object.run_count)
+        : "0",
+    };
+  },
+
+  toJSON(message: Service_Checker_Action): unknown {
+    const obj: any = {};
+    if (message.action !== 0) {
+      obj.action = actionToJSON(message.action);
+    }
+    if (message.timeout !== undefined) {
+      obj.timeout = Duration.toJSON(message.timeout);
+    }
+    if (message.runCount !== "0") {
+      obj.runCount = message.runCount;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Service_Checker_Action>, I>>(base?: I): Service_Checker_Action {
+    return Service_Checker_Action.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Service_Checker_Action>, I>>(object: I): Service_Checker_Action {
+    const message = createBaseService_Checker_Action();
+    message.action = object.action ?? 0;
+    message.timeout = (object.timeout !== undefined && object.timeout !== null)
+      ? Duration.fromPartial(object.timeout)
+      : undefined;
+    message.runCount = object.runCount ?? "0";
+    return message;
+  },
+};
+
+function createBaseListRequest(): ListRequest {
+  return { version: undefined };
+}
+
+export const ListRequest: MessageFns<ListRequest> = {
+  encode(message: ListRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<ListRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<ListRequest | ListRequest[]> | Iterable<ListRequest | ListRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [ListRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, ListRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<ListRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListRequest.decode(p)];
+        }
+      } else {
+        yield* [ListRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): ListRequest {
+    return { version: isSet(object.version) ? Version.fromJSON(object.version) : undefined };
+  },
+
+  toJSON(message: ListRequest): unknown {
+    const obj: any = {};
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListRequest>, I>>(base?: I): ListRequest {
+    return ListRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListRequest>, I>>(object: I): ListRequest {
+    const message = createBaseListRequest();
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseListResponse(): ListResponse {
+  return { services: [], version: undefined };
+}
+
+export const ListResponse: MessageFns<ListResponse> = {
+  encode(message: ListResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.services) {
+      Service.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.services.push(Service.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<ListResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<ListResponse | ListResponse[]> | Iterable<ListResponse | ListResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [ListResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, ListResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<ListResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListResponse.decode(p)];
+        }
+      } else {
+        yield* [ListResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): ListResponse {
+    return {
+      services: globalThis.Array.isArray(object?.services) ? object.services.map((e: any) => Service.fromJSON(e)) : [],
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: ListResponse): unknown {
+    const obj: any = {};
+    if (message.services?.length) {
+      obj.services = message.services.map((e) => Service.toJSON(e));
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListResponse>, I>>(base?: I): ListResponse {
+    return ListResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListResponse>, I>>(object: I): ListResponse {
+    const message = createBaseListResponse();
+    message.services = object.services?.map((e) => Service.fromPartial(e)) || [];
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseCreateBatchRequest(): CreateBatchRequest {
+  return { services: [] };
+}
+
+export const CreateBatchRequest: MessageFns<CreateBatchRequest> = {
+  encode(message: CreateBatchRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.services) {
+      Service.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateBatchRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateBatchRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.services.push(Service.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<CreateBatchRequest, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<CreateBatchRequest | CreateBatchRequest[]>
+      | Iterable<CreateBatchRequest | CreateBatchRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [CreateBatchRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CreateBatchRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<CreateBatchRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchRequest.decode(p)];
+        }
+      } else {
+        yield* [CreateBatchRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): CreateBatchRequest {
+    return {
+      services: globalThis.Array.isArray(object?.services) ? object.services.map((e: any) => Service.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: CreateBatchRequest): unknown {
+    const obj: any = {};
+    if (message.services?.length) {
+      obj.services = message.services.map((e) => Service.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateBatchRequest>, I>>(base?: I): CreateBatchRequest {
+    return CreateBatchRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateBatchRequest>, I>>(object: I): CreateBatchRequest {
+    const message = createBaseCreateBatchRequest();
+    message.services = object.services?.map((e) => Service.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseCreateBatchResponse(): CreateBatchResponse {
+  return { services: [] };
+}
+
+export const CreateBatchResponse: MessageFns<CreateBatchResponse> = {
+  encode(message: CreateBatchResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.services) {
+      Service.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateBatchResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateBatchResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.services.push(Service.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<CreateBatchResponse, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<CreateBatchResponse | CreateBatchResponse[]>
+      | Iterable<CreateBatchResponse | CreateBatchResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [CreateBatchResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CreateBatchResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<CreateBatchResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchResponse.decode(p)];
+        }
+      } else {
+        yield* [CreateBatchResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): CreateBatchResponse {
+    return {
+      services: globalThis.Array.isArray(object?.services) ? object.services.map((e: any) => Service.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: CreateBatchResponse): unknown {
+    const obj: any = {};
+    if (message.services?.length) {
+      obj.services = message.services.map((e) => Service.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateBatchResponse>, I>>(base?: I): CreateBatchResponse {
+    return CreateBatchResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateBatchResponse>, I>>(object: I): CreateBatchResponse {
+    const message = createBaseCreateBatchResponse();
+    message.services = object.services?.map((e) => Service.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseUpdateRequest(): UpdateRequest {
+  return { id: "0", disabled: undefined };
+}
+
+export const UpdateRequest: MessageFns<UpdateRequest> = {
+  encode(message: UpdateRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "0") {
+      writer.uint32(8).int64(message.id);
+    }
+    if (message.disabled !== undefined) {
+      writer.uint32(16).bool(message.disabled);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.disabled = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<UpdateRequest | UpdateRequest[]> | Iterable<UpdateRequest | UpdateRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRequest.decode(p)];
+        }
+      } else {
+        yield* [UpdateRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateRequest {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "0",
+      disabled: isSet(object.disabled) ? globalThis.Boolean(object.disabled) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateRequest): unknown {
+    const obj: any = {};
+    if (message.id !== "0") {
+      obj.id = message.id;
+    }
+    if (message.disabled !== undefined) {
+      obj.disabled = message.disabled;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateRequest>, I>>(base?: I): UpdateRequest {
+    return UpdateRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateRequest>, I>>(object: I): UpdateRequest {
+    const message = createBaseUpdateRequest();
+    message.id = object.id ?? "0";
+    message.disabled = object.disabled ?? undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateResponse(): UpdateResponse {
+  return { service: undefined, version: undefined };
+}
+
+export const UpdateResponse: MessageFns<UpdateResponse> = {
+  encode(message: UpdateResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.service !== undefined) {
+      Service.encode(message.service, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.service = Service.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<UpdateResponse | UpdateResponse[]> | Iterable<UpdateResponse | UpdateResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateResponse.decode(p)];
+        }
+      } else {
+        yield* [UpdateResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateResponse {
+    return {
+      service: isSet(object.service) ? Service.fromJSON(object.service) : undefined,
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateResponse): unknown {
+    const obj: any = {};
+    if (message.service !== undefined) {
+      obj.service = Service.toJSON(message.service);
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateResponse>, I>>(base?: I): UpdateResponse {
+    return UpdateResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateResponse>, I>>(object: I): UpdateResponse {
+    const message = createBaseUpdateResponse();
+    message.service = (object.service !== undefined && object.service !== null)
+      ? Service.fromPartial(object.service)
+      : undefined;
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/data/services/services_service.ts b/front/src/proto/data/services/services_service.ts
new file mode 100644
index 0000000..e0371ed
--- /dev/null
+++ b/front/src/proto/data/services/services_service.ts
@@ -0,0 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: data/services/services_service.proto
+
+/* eslint-disable */
+
+export const protobufPackage = "data.services";
diff --git a/front/src/proto/data/teams/teams.ts b/front/src/proto/data/teams/teams.ts
new file mode 100644
index 0000000..fe0255f
--- /dev/null
+++ b/front/src/proto/data/teams/teams.ts
@@ -0,0 +1,1146 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: data/teams/teams.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Version } from "../version/version";
+
+export const protobufPackage = "data.teams";
+
+export interface Team {
+  id: string;
+  name: string;
+  address: string;
+  token: string;
+  labels: { [key: string]: string };
+  avatarUrl: string;
+}
+
+export interface Team_Batch {
+  teams: Team[];
+}
+
+export interface Team_LabelsEntry {
+  key: string;
+  value: string;
+}
+
+export interface ListRequest {
+  version: Version | undefined;
+}
+
+export interface ListResponse {
+  teams: Team[];
+  version: Version | undefined;
+}
+
+export interface CreateBatchRequest {
+  teams: Team[];
+}
+
+export interface CreateBatchResponse {
+  teams: Team[];
+}
+
+export interface UpdateRequest {
+  id: string;
+  name: string;
+  address: string;
+  token: string;
+  avatarUrl: string;
+}
+
+export interface UpdateResponse {
+  team: Team | undefined;
+  version: Version | undefined;
+}
+
+function createBaseTeam(): Team {
+  return { id: "0", name: "", address: "", token: "", labels: {}, avatarUrl: "" };
+}
+
+export const Team: MessageFns<Team> = {
+  encode(message: Team, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "0") {
+      writer.uint32(8).int64(message.id);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.address !== "") {
+      writer.uint32(26).string(message.address);
+    }
+    if (message.token !== "") {
+      writer.uint32(34).string(message.token);
+    }
+    globalThis.Object.entries(message.labels).forEach(([key, value]: [string, string]) => {
+      Team_LabelsEntry.encode({ key: key as any, value }, writer.uint32(42).fork()).join();
+    });
+    if (message.avatarUrl !== "") {
+      writer.uint32(50).string(message.avatarUrl);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Team {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTeam();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.token = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          const entry5 = Team_LabelsEntry.decode(reader, reader.uint32());
+          if (entry5.value !== undefined) {
+            message.labels[entry5.key] = entry5.value;
+          }
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.avatarUrl = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Team, Uint8Array>
+  async *encodeTransform(source: AsyncIterable<Team | Team[]> | Iterable<Team | Team[]>): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Team.encode(p).finish()];
+        }
+      } else {
+        yield* [Team.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Team>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Team> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Team.decode(p)];
+        }
+      } else {
+        yield* [Team.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Team {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "0",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      address: isSet(object.address) ? globalThis.String(object.address) : "",
+      token: isSet(object.token) ? globalThis.String(object.token) : "",
+      labels: isObject(object.labels)
+        ? (globalThis.Object.entries(object.labels) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
+      avatarUrl: isSet(object.avatarUrl)
+        ? globalThis.String(object.avatarUrl)
+        : isSet(object.avatar_url)
+        ? globalThis.String(object.avatar_url)
+        : "",
+    };
+  },
+
+  toJSON(message: Team): unknown {
+    const obj: any = {};
+    if (message.id !== "0") {
+      obj.id = message.id;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.address !== "") {
+      obj.address = message.address;
+    }
+    if (message.token !== "") {
+      obj.token = message.token;
+    }
+    if (message.labels) {
+      const entries = globalThis.Object.entries(message.labels) as [string, string][];
+      if (entries.length > 0) {
+        obj.labels = {};
+        entries.forEach(([k, v]) => {
+          obj.labels[k] = v;
+        });
+      }
+    }
+    if (message.avatarUrl !== "") {
+      obj.avatarUrl = message.avatarUrl;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Team>, I>>(base?: I): Team {
+    return Team.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Team>, I>>(object: I): Team {
+    const message = createBaseTeam();
+    message.id = object.id ?? "0";
+    message.name = object.name ?? "";
+    message.address = object.address ?? "";
+    message.token = object.token ?? "";
+    message.labels = (globalThis.Object.entries(object.labels ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.avatarUrl = object.avatarUrl ?? "";
+    return message;
+  },
+};
+
+function createBaseTeam_Batch(): Team_Batch {
+  return { teams: [] };
+}
+
+export const Team_Batch: MessageFns<Team_Batch> = {
+  encode(message: Team_Batch, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.teams) {
+      Team.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Team_Batch {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTeam_Batch();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.teams.push(Team.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Team_Batch, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Team_Batch | Team_Batch[]> | Iterable<Team_Batch | Team_Batch[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Team_Batch.encode(p).finish()];
+        }
+      } else {
+        yield* [Team_Batch.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Team_Batch>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Team_Batch> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Team_Batch.decode(p)];
+        }
+      } else {
+        yield* [Team_Batch.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Team_Batch {
+    return { teams: globalThis.Array.isArray(object?.teams) ? object.teams.map((e: any) => Team.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: Team_Batch): unknown {
+    const obj: any = {};
+    if (message.teams?.length) {
+      obj.teams = message.teams.map((e) => Team.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Team_Batch>, I>>(base?: I): Team_Batch {
+    return Team_Batch.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Team_Batch>, I>>(object: I): Team_Batch {
+    const message = createBaseTeam_Batch();
+    message.teams = object.teams?.map((e) => Team.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseTeam_LabelsEntry(): Team_LabelsEntry {
+  return { key: "", value: "" };
+}
+
+export const Team_LabelsEntry: MessageFns<Team_LabelsEntry> = {
+  encode(message: Team_LabelsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Team_LabelsEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTeam_LabelsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Team_LabelsEntry, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Team_LabelsEntry | Team_LabelsEntry[]> | Iterable<Team_LabelsEntry | Team_LabelsEntry[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Team_LabelsEntry.encode(p).finish()];
+        }
+      } else {
+        yield* [Team_LabelsEntry.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Team_LabelsEntry>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Team_LabelsEntry> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Team_LabelsEntry.decode(p)];
+        }
+      } else {
+        yield* [Team_LabelsEntry.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Team_LabelsEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: Team_LabelsEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Team_LabelsEntry>, I>>(base?: I): Team_LabelsEntry {
+    return Team_LabelsEntry.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Team_LabelsEntry>, I>>(object: I): Team_LabelsEntry {
+    const message = createBaseTeam_LabelsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseListRequest(): ListRequest {
+  return { version: undefined };
+}
+
+export const ListRequest: MessageFns<ListRequest> = {
+  encode(message: ListRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<ListRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<ListRequest | ListRequest[]> | Iterable<ListRequest | ListRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [ListRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, ListRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<ListRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListRequest.decode(p)];
+        }
+      } else {
+        yield* [ListRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): ListRequest {
+    return { version: isSet(object.version) ? Version.fromJSON(object.version) : undefined };
+  },
+
+  toJSON(message: ListRequest): unknown {
+    const obj: any = {};
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListRequest>, I>>(base?: I): ListRequest {
+    return ListRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListRequest>, I>>(object: I): ListRequest {
+    const message = createBaseListRequest();
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseListResponse(): ListResponse {
+  return { teams: [], version: undefined };
+}
+
+export const ListResponse: MessageFns<ListResponse> = {
+  encode(message: ListResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.teams) {
+      Team.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.teams.push(Team.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<ListResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<ListResponse | ListResponse[]> | Iterable<ListResponse | ListResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [ListResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, ListResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<ListResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [ListResponse.decode(p)];
+        }
+      } else {
+        yield* [ListResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): ListResponse {
+    return {
+      teams: globalThis.Array.isArray(object?.teams) ? object.teams.map((e: any) => Team.fromJSON(e)) : [],
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: ListResponse): unknown {
+    const obj: any = {};
+    if (message.teams?.length) {
+      obj.teams = message.teams.map((e) => Team.toJSON(e));
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListResponse>, I>>(base?: I): ListResponse {
+    return ListResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListResponse>, I>>(object: I): ListResponse {
+    const message = createBaseListResponse();
+    message.teams = object.teams?.map((e) => Team.fromPartial(e)) || [];
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseCreateBatchRequest(): CreateBatchRequest {
+  return { teams: [] };
+}
+
+export const CreateBatchRequest: MessageFns<CreateBatchRequest> = {
+  encode(message: CreateBatchRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.teams) {
+      Team.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateBatchRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateBatchRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.teams.push(Team.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<CreateBatchRequest, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<CreateBatchRequest | CreateBatchRequest[]>
+      | Iterable<CreateBatchRequest | CreateBatchRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [CreateBatchRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CreateBatchRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<CreateBatchRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchRequest.decode(p)];
+        }
+      } else {
+        yield* [CreateBatchRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): CreateBatchRequest {
+    return { teams: globalThis.Array.isArray(object?.teams) ? object.teams.map((e: any) => Team.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: CreateBatchRequest): unknown {
+    const obj: any = {};
+    if (message.teams?.length) {
+      obj.teams = message.teams.map((e) => Team.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateBatchRequest>, I>>(base?: I): CreateBatchRequest {
+    return CreateBatchRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateBatchRequest>, I>>(object: I): CreateBatchRequest {
+    const message = createBaseCreateBatchRequest();
+    message.teams = object.teams?.map((e) => Team.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseCreateBatchResponse(): CreateBatchResponse {
+  return { teams: [] };
+}
+
+export const CreateBatchResponse: MessageFns<CreateBatchResponse> = {
+  encode(message: CreateBatchResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.teams) {
+      Team.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateBatchResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateBatchResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.teams.push(Team.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<CreateBatchResponse, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<CreateBatchResponse | CreateBatchResponse[]>
+      | Iterable<CreateBatchResponse | CreateBatchResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [CreateBatchResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CreateBatchResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<CreateBatchResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [CreateBatchResponse.decode(p)];
+        }
+      } else {
+        yield* [CreateBatchResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): CreateBatchResponse {
+    return { teams: globalThis.Array.isArray(object?.teams) ? object.teams.map((e: any) => Team.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: CreateBatchResponse): unknown {
+    const obj: any = {};
+    if (message.teams?.length) {
+      obj.teams = message.teams.map((e) => Team.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateBatchResponse>, I>>(base?: I): CreateBatchResponse {
+    return CreateBatchResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateBatchResponse>, I>>(object: I): CreateBatchResponse {
+    const message = createBaseCreateBatchResponse();
+    message.teams = object.teams?.map((e) => Team.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseUpdateRequest(): UpdateRequest {
+  return { id: "0", name: "", address: "", token: "", avatarUrl: "" };
+}
+
+export const UpdateRequest: MessageFns<UpdateRequest> = {
+  encode(message: UpdateRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "0") {
+      writer.uint32(8).int64(message.id);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.address !== "") {
+      writer.uint32(26).string(message.address);
+    }
+    if (message.token !== "") {
+      writer.uint32(34).string(message.token);
+    }
+    if (message.avatarUrl !== "") {
+      writer.uint32(42).string(message.avatarUrl);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.token = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.avatarUrl = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<UpdateRequest | UpdateRequest[]> | Iterable<UpdateRequest | UpdateRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateRequest.decode(p)];
+        }
+      } else {
+        yield* [UpdateRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateRequest {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "0",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      address: isSet(object.address) ? globalThis.String(object.address) : "",
+      token: isSet(object.token) ? globalThis.String(object.token) : "",
+      avatarUrl: isSet(object.avatarUrl)
+        ? globalThis.String(object.avatarUrl)
+        : isSet(object.avatar_url)
+        ? globalThis.String(object.avatar_url)
+        : "",
+    };
+  },
+
+  toJSON(message: UpdateRequest): unknown {
+    const obj: any = {};
+    if (message.id !== "0") {
+      obj.id = message.id;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.address !== "") {
+      obj.address = message.address;
+    }
+    if (message.token !== "") {
+      obj.token = message.token;
+    }
+    if (message.avatarUrl !== "") {
+      obj.avatarUrl = message.avatarUrl;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateRequest>, I>>(base?: I): UpdateRequest {
+    return UpdateRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateRequest>, I>>(object: I): UpdateRequest {
+    const message = createBaseUpdateRequest();
+    message.id = object.id ?? "0";
+    message.name = object.name ?? "";
+    message.address = object.address ?? "";
+    message.token = object.token ?? "";
+    message.avatarUrl = object.avatarUrl ?? "";
+    return message;
+  },
+};
+
+function createBaseUpdateResponse(): UpdateResponse {
+  return { team: undefined, version: undefined };
+}
+
+export const UpdateResponse: MessageFns<UpdateResponse> = {
+  encode(message: UpdateResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.team !== undefined) {
+      Team.encode(message.team, writer.uint32(10).fork()).join();
+    }
+    if (message.version !== undefined) {
+      Version.encode(message.version, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.team = Team.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = Version.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<UpdateResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<UpdateResponse | UpdateResponse[]> | Iterable<UpdateResponse | UpdateResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [UpdateResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, UpdateResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<UpdateResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [UpdateResponse.decode(p)];
+        }
+      } else {
+        yield* [UpdateResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): UpdateResponse {
+    return {
+      team: isSet(object.team) ? Team.fromJSON(object.team) : undefined,
+      version: isSet(object.version) ? Version.fromJSON(object.version) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateResponse): unknown {
+    const obj: any = {};
+    if (message.team !== undefined) {
+      obj.team = Team.toJSON(message.team);
+    }
+    if (message.version !== undefined) {
+      obj.version = Version.toJSON(message.version);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateResponse>, I>>(base?: I): UpdateResponse {
+    return UpdateResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateResponse>, I>>(object: I): UpdateResponse {
+    const message = createBaseUpdateResponse();
+    message.team = (object.team !== undefined && object.team !== null) ? Team.fromPartial(object.team) : undefined;
+    message.version = (object.version !== undefined && object.version !== null)
+      ? Version.fromPartial(object.version)
+      : undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/data/teams/teams_service.ts b/front/src/proto/data/teams/teams_service.ts
new file mode 100644
index 0000000..c74a243
--- /dev/null
+++ b/front/src/proto/data/teams/teams_service.ts
@@ -0,0 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: data/teams/teams_service.proto
+
+/* eslint-disable */
+
+export const protobufPackage = "data.teams";
diff --git a/front/src/proto/data/version/version.ts b/front/src/proto/data/version/version.ts
new file mode 100644
index 0000000..b42e53f
--- /dev/null
+++ b/front/src/proto/data/version/version.ts
@@ -0,0 +1,134 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: data/version/version.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "data.version";
+
+export interface Version {
+  version: string;
+}
+
+function createBaseVersion(): Version {
+  return { version: "0" };
+}
+
+export const Version: MessageFns<Version> = {
+  encode(message: Version, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.version !== "0") {
+      writer.uint32(8).int64(message.version);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Version {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVersion();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.version = reader.int64().toString();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Version, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Version | Version[]> | Iterable<Version | Version[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Version.encode(p).finish()];
+        }
+      } else {
+        yield* [Version.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Version>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Version> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Version.decode(p)];
+        }
+      } else {
+        yield* [Version.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Version {
+    return { version: isSet(object.version) ? globalThis.String(object.version) : "0" };
+  },
+
+  toJSON(message: Version): unknown {
+    const obj: any = {};
+    if (message.version !== "0") {
+      obj.version = message.version;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Version>, I>>(base?: I): Version {
+    return Version.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Version>, I>>(object: I): Version {
+    const message = createBaseVersion();
+    message.version = object.version ?? "0";
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/google/protobuf/duration.ts b/front/src/proto/google/protobuf/duration.ts
new file mode 100644
index 0000000..891d8f3
--- /dev/null
+++ b/front/src/proto/google/protobuf/duration.ts
@@ -0,0 +1,226 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: google/protobuf/duration.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "google.protobuf";
+
+/**
+ * A Duration represents a signed, fixed-length span of time represented
+ * as a count of seconds and fractions of seconds at nanosecond
+ * resolution. It is independent of any calendar and concepts like "day"
+ * or "month". It is related to Timestamp in that the difference between
+ * two Timestamp values is a Duration and it can be added or subtracted
+ * from a Timestamp. Range is approximately +-10,000 years.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Duration from two Timestamps in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Timestamp end = ...;
+ *     Duration duration = ...;
+ *
+ *     duration.seconds = end.seconds - start.seconds;
+ *     duration.nanos = end.nanos - start.nanos;
+ *
+ *     if (duration.seconds < 0 && duration.nanos > 0) {
+ *       duration.seconds += 1;
+ *       duration.nanos -= 1000000000;
+ *     } else if (duration.seconds > 0 && duration.nanos < 0) {
+ *       duration.seconds -= 1;
+ *       duration.nanos += 1000000000;
+ *     }
+ *
+ * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Duration duration = ...;
+ *     Timestamp end = ...;
+ *
+ *     end.seconds = start.seconds + duration.seconds;
+ *     end.nanos = start.nanos + duration.nanos;
+ *
+ *     if (end.nanos < 0) {
+ *       end.seconds -= 1;
+ *       end.nanos += 1000000000;
+ *     } else if (end.nanos >= 1000000000) {
+ *       end.seconds += 1;
+ *       end.nanos -= 1000000000;
+ *     }
+ *
+ * Example 3: Compute Duration from datetime.timedelta in Python.
+ *
+ *     td = datetime.timedelta(days=3, minutes=10)
+ *     duration = Duration()
+ *     duration.FromTimedelta(td)
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Duration type is encoded as a string rather than an
+ * object, where the string ends in the suffix "s" (indicating seconds) and
+ * is preceded by the number of seconds, with nanoseconds expressed as
+ * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+ * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+ * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+ * microsecond should be expressed in JSON format as "3.000001s".
+ */
+export interface Duration {
+  /**
+   * Signed seconds of the span of time. Must be from -315,576,000,000
+   * to +315,576,000,000 inclusive. Note: these bounds are computed from:
+   * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+   */
+  seconds: string;
+  /**
+   * Signed fractions of a second at nanosecond resolution of the span
+   * of time. Durations less than one second are represented with a 0
+   * `seconds` field and a positive or negative `nanos` field. For durations
+   * of one second or more, a non-zero value for the `nanos` field must be
+   * of the same sign as the `seconds` field. Must be from -999,999,999
+   * to +999,999,999 inclusive.
+   */
+  nanos: number;
+}
+
+function createBaseDuration(): Duration {
+  return { seconds: "0", nanos: 0 };
+}
+
+export const Duration: MessageFns<Duration> = {
+  encode(message: Duration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.seconds !== "0") {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Duration {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDuration();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.seconds = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.nanos = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Duration, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Duration | Duration[]> | Iterable<Duration | Duration[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Duration.encode(p).finish()];
+        }
+      } else {
+        yield* [Duration.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Duration>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Duration> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Duration.decode(p)];
+        }
+      } else {
+        yield* [Duration.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Duration {
+    return {
+      seconds: isSet(object.seconds) ? globalThis.String(object.seconds) : "0",
+      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0,
+    };
+  },
+
+  toJSON(message: Duration): unknown {
+    const obj: any = {};
+    if (message.seconds !== "0") {
+      obj.seconds = message.seconds;
+    }
+    if (message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Duration>, I>>(base?: I): Duration {
+    return Duration.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Duration>, I>>(object: I): Duration {
+    const message = createBaseDuration();
+    message.seconds = object.seconds ?? "0";
+    message.nanos = object.nanos ?? 0;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/google/protobuf/timestamp.ts b/front/src/proto/google/protobuf/timestamp.ts
new file mode 100644
index 0000000..7dc03ef
--- /dev/null
+++ b/front/src/proto/google/protobuf/timestamp.ts
@@ -0,0 +1,255 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: google/protobuf/timestamp.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "google.protobuf";
+
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ */
+export interface Timestamp {
+  /**
+   * Represents seconds of UTC time since Unix epoch
+   * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+   * 9999-12-31T23:59:59Z inclusive.
+   */
+  seconds: string;
+  /**
+   * Non-negative fractions of a second at nanosecond resolution. Negative
+   * second values with fractions must still have non-negative nanos values
+   * that count forward in time. Must be from 0 to 999,999,999
+   * inclusive.
+   */
+  nanos: number;
+}
+
+function createBaseTimestamp(): Timestamp {
+  return { seconds: "0", nanos: 0 };
+}
+
+export const Timestamp: MessageFns<Timestamp> = {
+  encode(message: Timestamp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.seconds !== "0") {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Timestamp {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.seconds = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.nanos = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Timestamp, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Timestamp | Timestamp[]> | Iterable<Timestamp | Timestamp[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Timestamp.encode(p).finish()];
+        }
+      } else {
+        yield* [Timestamp.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Timestamp>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Timestamp> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Timestamp.decode(p)];
+        }
+      } else {
+        yield* [Timestamp.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Timestamp {
+    return {
+      seconds: isSet(object.seconds) ? globalThis.String(object.seconds) : "0",
+      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0,
+    };
+  },
+
+  toJSON(message: Timestamp): unknown {
+    const obj: any = {};
+    if (message.seconds !== "0") {
+      obj.seconds = message.seconds;
+    }
+    if (message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Timestamp>, I>>(base?: I): Timestamp {
+    return Timestamp.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Timestamp>, I>>(object: I): Timestamp {
+    const message = createBaseTimestamp();
+    message.seconds = object.seconds ?? "0";
+    message.nanos = object.nanos ?? 0;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/pinger/pinger.ts b/front/src/proto/pinger/pinger.ts
index 5fb6abe..342d482 100644
--- a/front/src/proto/pinger/pinger.ts
+++ b/front/src/proto/pinger/pinger.ts
@@ -1,36 +1,77 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: pinger/pinger.proto
+
 /* eslint-disable */
-import * as _m0 from "protobufjs/minimal";
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 
 export const protobufPackage = "pinger";
 
-export interface PingRequest {}
+export interface PingRequest {
+}
 
-export interface PingResponse {}
+export interface PingResponse {
+}
 
 function createBasePingRequest(): PingRequest {
   return {};
 }
 
-export const PingRequest = {
-  encode(_: PingRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const PingRequest: MessageFns<PingRequest> = {
+  encode(_: PingRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): PingRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+  decode(input: BinaryReader | Uint8Array, length?: number): PingRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBasePingRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        default:
-          reader.skipType(tag & 7);
-          break;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
     }
     return message;
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<PingRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<PingRequest | PingRequest[]> | Iterable<PingRequest | PingRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [PingRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [PingRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, PingRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<PingRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [PingRequest.decode(p)];
+        }
+      } else {
+        yield* [PingRequest.decode(pkt as any)];
+      }
+    }
+  },
+
   fromJSON(_: any): PingRequest {
     return {};
   },
@@ -40,6 +81,9 @@ export const PingRequest = {
     return obj;
   },
 
+  create<I extends Exact<DeepPartial<PingRequest>, I>>(base?: I): PingRequest {
+    return PingRequest.fromPartial(base ?? ({} as any));
+  },
   fromPartial<I extends Exact<DeepPartial<PingRequest>, I>>(_: I): PingRequest {
     const message = createBasePingRequest();
     return message;
@@ -50,29 +94,59 @@ function createBasePingResponse(): PingResponse {
   return {};
 }
 
-export const PingResponse = {
-  encode(
-    _: PingResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+export const PingResponse: MessageFns<PingResponse> = {
+  encode(_: PingResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): PingResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+  decode(input: BinaryReader | Uint8Array, length?: number): PingResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBasePingResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        default:
-          reader.skipType(tag & 7);
-          break;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
     }
     return message;
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<PingResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<PingResponse | PingResponse[]> | Iterable<PingResponse | PingResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [PingResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [PingResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, PingResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<PingResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [PingResponse.decode(p)];
+        }
+      } else {
+        yield* [PingResponse.decode(pkt as any)];
+      }
+    }
+  },
+
   fromJSON(_: any): PingResponse {
     return {};
   },
@@ -82,37 +156,37 @@ export const PingResponse = {
     return obj;
   },
 
-  fromPartial<I extends Exact<DeepPartial<PingResponse>, I>>(
-    _: I
-  ): PingResponse {
+  create<I extends Exact<DeepPartial<PingResponse>, I>>(base?: I): PingResponse {
+    return PingResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<PingResponse>, I>>(_: I): PingResponse {
     const message = createBasePingResponse();
     return message;
   },
 };
 
-type Builtin =
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | boolean
-  | undefined;
-
-export type DeepPartial<T> = T extends Builtin
-  ? T
-  : T extends Array<infer U>
-  ? Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<DeepPartial<U>>
-  : T extends {}
-  ? { [K in keyof T]?: DeepPartial<T[K]> }
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
   : Partial<T>;
 
 type KeysOfUnion<T> = T extends T ? keyof T : never;
-export type Exact<P, I extends P> = P extends Builtin
-  ? P
-  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
-        Exclude<keyof I, KeysOfUnion<P>>,
-        never
-      >;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/pinger/pinger_service.ts b/front/src/proto/pinger/pinger_service.ts
index d751c3c..696528c 100644
--- a/front/src/proto/pinger/pinger_service.ts
+++ b/front/src/proto/pinger/pinger_service.ts
@@ -1,20 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: pinger/pinger_service.proto
+
 /* eslint-disable */
-import { PingRequest, PingResponse } from "./pinger.js";
 
 export const protobufPackage = "pinger";
-
-export type PingerServiceDefinition = typeof PingerServiceDefinition;
-export const PingerServiceDefinition = {
-  name: "PingerService",
-  fullName: "pinger.PingerService",
-  methods: {
-    ping: {
-      name: "Ping",
-      requestType: PingRequest,
-      requestStream: false,
-      responseType: PingResponse,
-      responseStream: false,
-      options: {},
-    },
-  },
-} as const;
diff --git a/front/src/proto/receiver/receiver.ts b/front/src/proto/receiver/receiver.ts
index 1051c32..25f763b 100644
--- a/front/src/proto/receiver/receiver.ts
+++ b/front/src/proto/receiver/receiver.ts
@@ -1,31 +1,52 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: receiver/receiver.proto
+
 /* eslint-disable */
-import * as _m0 from "protobufjs/minimal";
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 
 export const protobufPackage = "receiver";
 
 export interface SubmitFlagsRequest {
   flags: string[];
+  teamToken: string;
 }
 
 export interface FlagResponse {
   flag: string;
   verdict: FlagResponse_Verdict;
   message: string;
-  flagPoints: number;
+  victimId: string;
+  serviceId: string;
+  attackerDelta: number;
+  victimDelta: number;
 }
 
-export enum FlagResponse_Verdict {
-  VERDICT_UNSPECIFIED = 0,
-  VERDICT_ACCEPTED = 1,
-  VERDICT_OWN = 2,
-  VERDICT_OLD = 3,
-  VERDICT_INVALID = 4,
-  UNRECOGNIZED = -1,
+export const FlagResponse_Verdict = {
+  VERDICT_UNSPECIFIED: 0,
+  VERDICT_ACCEPTED: 1,
+  VERDICT_OWN: 2,
+  VERDICT_OLD: 3,
+  VERDICT_INVALID: 4,
+  VERDICT_DUPLICATE: 5,
+  VERDICT_FLAG_NOT_READY: 6,
+} as const;
+
+export type FlagResponse_Verdict = typeof FlagResponse_Verdict[keyof typeof FlagResponse_Verdict];
+
+export namespace FlagResponse_Verdict {
+  export type VERDICT_UNSPECIFIED = typeof FlagResponse_Verdict.VERDICT_UNSPECIFIED;
+  export type VERDICT_ACCEPTED = typeof FlagResponse_Verdict.VERDICT_ACCEPTED;
+  export type VERDICT_OWN = typeof FlagResponse_Verdict.VERDICT_OWN;
+  export type VERDICT_OLD = typeof FlagResponse_Verdict.VERDICT_OLD;
+  export type VERDICT_INVALID = typeof FlagResponse_Verdict.VERDICT_INVALID;
+  export type VERDICT_DUPLICATE = typeof FlagResponse_Verdict.VERDICT_DUPLICATE;
+  export type VERDICT_FLAG_NOT_READY = typeof FlagResponse_Verdict.VERDICT_FLAG_NOT_READY;
 }
 
-export function flagResponse_VerdictFromJSON(
-  object: any
-): FlagResponse_Verdict {
+export function flagResponse_VerdictFromJSON(object: any): FlagResponse_Verdict {
   switch (object) {
     case 0:
     case "VERDICT_UNSPECIFIED":
@@ -42,16 +63,18 @@ export function flagResponse_VerdictFromJSON(
     case 4:
     case "VERDICT_INVALID":
       return FlagResponse_Verdict.VERDICT_INVALID;
-    case -1:
-    case "UNRECOGNIZED":
+    case 5:
+    case "VERDICT_DUPLICATE":
+      return FlagResponse_Verdict.VERDICT_DUPLICATE;
+    case 6:
+    case "VERDICT_FLAG_NOT_READY":
+      return FlagResponse_Verdict.VERDICT_FLAG_NOT_READY;
     default:
-      return FlagResponse_Verdict.UNRECOGNIZED;
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum FlagResponse_Verdict");
   }
 }
 
-export function flagResponse_VerdictToJSON(
-  object: FlagResponse_Verdict
-): string {
+export function flagResponse_VerdictToJSON(object: FlagResponse_Verdict): string {
   switch (object) {
     case FlagResponse_Verdict.VERDICT_UNSPECIFIED:
       return "VERDICT_UNSPECIFIED";
@@ -63,85 +86,170 @@ export function flagResponse_VerdictToJSON(
       return "VERDICT_OLD";
     case FlagResponse_Verdict.VERDICT_INVALID:
       return "VERDICT_INVALID";
-    case FlagResponse_Verdict.UNRECOGNIZED:
+    case FlagResponse_Verdict.VERDICT_DUPLICATE:
+      return "VERDICT_DUPLICATE";
+    case FlagResponse_Verdict.VERDICT_FLAG_NOT_READY:
+      return "VERDICT_FLAG_NOT_READY";
     default:
-      return "UNRECOGNIZED";
+      throw new globalThis.Error("Unrecognized enum value " + object + " for enum FlagResponse_Verdict");
   }
 }
 
+export interface AttackNotification {
+  attackerId: string;
+  victimId: string;
+  serviceId: string;
+  attackerDelta: number;
+  victimDelta: number;
+}
+
+export interface AttackNotification_Batch {
+  attacks: AttackNotification[];
+}
+
+export interface State {
+  teamServices: State_TeamService[];
+}
+
+export interface State_TeamService {
+  teamId: string;
+  serviceId: string;
+  points: number;
+  flagsStolen: string;
+  flagsLost: string;
+}
+
 export interface SubmitFlagsResponse {
   responses: FlagResponse[];
 }
 
+export interface GetStateRequest {
+}
+
+export interface GetStateResponse {
+  state: State | undefined;
+}
+
 function createBaseSubmitFlagsRequest(): SubmitFlagsRequest {
-  return { flags: [] };
+  return { flags: [], teamToken: "" };
 }
 
-export const SubmitFlagsRequest = {
-  encode(
-    message: SubmitFlagsRequest,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+export const SubmitFlagsRequest: MessageFns<SubmitFlagsRequest> = {
+  encode(message: SubmitFlagsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     for (const v of message.flags) {
       writer.uint32(10).string(v!);
     }
+    if (message.teamToken !== "") {
+      writer.uint32(18).string(message.teamToken);
+    }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): SubmitFlagsRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+  decode(input: BinaryReader | Uint8Array, length?: number): SubmitFlagsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseSubmitFlagsRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
           message.flags.push(reader.string());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.teamToken = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skip(tag & 7);
     }
     return message;
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<SubmitFlagsRequest, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<SubmitFlagsRequest | SubmitFlagsRequest[]>
+      | Iterable<SubmitFlagsRequest | SubmitFlagsRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [SubmitFlagsRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [SubmitFlagsRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, SubmitFlagsRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<SubmitFlagsRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [SubmitFlagsRequest.decode(p)];
+        }
+      } else {
+        yield* [SubmitFlagsRequest.decode(pkt as any)];
+      }
+    }
+  },
+
   fromJSON(object: any): SubmitFlagsRequest {
     return {
-      flags: Array.isArray(object?.flags)
-        ? object.flags.map((e: any) => String(e))
-        : [],
+      flags: globalThis.Array.isArray(object?.flags) ? object.flags.map((e: any) => globalThis.String(e)) : [],
+      teamToken: isSet(object.teamToken)
+        ? globalThis.String(object.teamToken)
+        : isSet(object.team_token)
+        ? globalThis.String(object.team_token)
+        : "",
     };
   },
 
   toJSON(message: SubmitFlagsRequest): unknown {
     const obj: any = {};
-    if (message.flags) {
-      obj.flags = message.flags.map((e) => e);
-    } else {
-      obj.flags = [];
+    if (message.flags?.length) {
+      obj.flags = message.flags;
+    }
+    if (message.teamToken !== "") {
+      obj.teamToken = message.teamToken;
     }
     return obj;
   },
 
-  fromPartial<I extends Exact<DeepPartial<SubmitFlagsRequest>, I>>(
-    object: I
-  ): SubmitFlagsRequest {
+  create<I extends Exact<DeepPartial<SubmitFlagsRequest>, I>>(base?: I): SubmitFlagsRequest {
+    return SubmitFlagsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SubmitFlagsRequest>, I>>(object: I): SubmitFlagsRequest {
     const message = createBaseSubmitFlagsRequest();
     message.flags = object.flags?.map((e) => e) || [];
+    message.teamToken = object.teamToken ?? "";
     return message;
   },
 };
 
 function createBaseFlagResponse(): FlagResponse {
-  return { flag: "", verdict: 0, message: "", flagPoints: 0 };
+  return { flag: "", verdict: 0, message: "", victimId: "0", serviceId: "0", attackerDelta: 0, victimDelta: 0 };
 }
 
-export const FlagResponse = {
-  encode(
-    message: FlagResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+export const FlagResponse: MessageFns<FlagResponse> = {
+  encode(message: FlagResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.flag !== "") {
       writer.uint32(10).string(message.flag);
     }
@@ -151,68 +259,733 @@ export const FlagResponse = {
     if (message.message !== "") {
       writer.uint32(26).string(message.message);
     }
-    if (message.flagPoints !== 0) {
-      writer.uint32(33).double(message.flagPoints);
+    if (message.victimId !== "0") {
+      writer.uint32(32).int64(message.victimId);
+    }
+    if (message.serviceId !== "0") {
+      writer.uint32(40).int64(message.serviceId);
+    }
+    if (message.attackerDelta !== 0) {
+      writer.uint32(49).double(message.attackerDelta);
+    }
+    if (message.victimDelta !== 0) {
+      writer.uint32(57).double(message.victimDelta);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): FlagResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+  decode(input: BinaryReader | Uint8Array, length?: number): FlagResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseFlagResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
           message.flag = reader.string();
-          break;
-        case 2:
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
           message.verdict = reader.int32() as any;
-          break;
-        case 3:
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
           message.message = reader.string();
-          break;
-        case 4:
-          message.flagPoints = reader.double();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.victimId = reader.int64().toString();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.serviceId = reader.int64().toString();
+          continue;
+        }
+        case 6: {
+          if (tag !== 49) {
+            break;
+          }
+
+          message.attackerDelta = reader.double();
+          continue;
+        }
+        case 7: {
+          if (tag !== 57) {
+            break;
+          }
+
+          message.victimDelta = reader.double();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skip(tag & 7);
     }
     return message;
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<FlagResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<FlagResponse | FlagResponse[]> | Iterable<FlagResponse | FlagResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [FlagResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [FlagResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, FlagResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<FlagResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [FlagResponse.decode(p)];
+        }
+      } else {
+        yield* [FlagResponse.decode(pkt as any)];
+      }
+    }
+  },
+
   fromJSON(object: any): FlagResponse {
     return {
-      flag: isSet(object.flag) ? String(object.flag) : "",
-      verdict: isSet(object.verdict)
-        ? flagResponse_VerdictFromJSON(object.verdict)
+      flag: isSet(object.flag) ? globalThis.String(object.flag) : "",
+      verdict: isSet(object.verdict) ? flagResponse_VerdictFromJSON(object.verdict) : 0,
+      message: isSet(object.message) ? globalThis.String(object.message) : "",
+      victimId: isSet(object.victimId)
+        ? globalThis.String(object.victimId)
+        : isSet(object.victim_id)
+        ? globalThis.String(object.victim_id)
+        : "0",
+      serviceId: isSet(object.serviceId)
+        ? globalThis.String(object.serviceId)
+        : isSet(object.service_id)
+        ? globalThis.String(object.service_id)
+        : "0",
+      attackerDelta: isSet(object.attackerDelta)
+        ? globalThis.Number(object.attackerDelta)
+        : isSet(object.attacker_delta)
+        ? globalThis.Number(object.attacker_delta)
+        : 0,
+      victimDelta: isSet(object.victimDelta)
+        ? globalThis.Number(object.victimDelta)
+        : isSet(object.victim_delta)
+        ? globalThis.Number(object.victim_delta)
         : 0,
-      message: isSet(object.message) ? String(object.message) : "",
-      flagPoints: isSet(object.flagPoints) ? Number(object.flagPoints) : 0,
     };
   },
 
   toJSON(message: FlagResponse): unknown {
     const obj: any = {};
-    message.flag !== undefined && (obj.flag = message.flag);
-    message.verdict !== undefined &&
-      (obj.verdict = flagResponse_VerdictToJSON(message.verdict));
-    message.message !== undefined && (obj.message = message.message);
-    message.flagPoints !== undefined && (obj.flagPoints = message.flagPoints);
+    if (message.flag !== "") {
+      obj.flag = message.flag;
+    }
+    if (message.verdict !== 0) {
+      obj.verdict = flagResponse_VerdictToJSON(message.verdict);
+    }
+    if (message.message !== "") {
+      obj.message = message.message;
+    }
+    if (message.victimId !== "0") {
+      obj.victimId = message.victimId;
+    }
+    if (message.serviceId !== "0") {
+      obj.serviceId = message.serviceId;
+    }
+    if (message.attackerDelta !== 0) {
+      obj.attackerDelta = message.attackerDelta;
+    }
+    if (message.victimDelta !== 0) {
+      obj.victimDelta = message.victimDelta;
+    }
     return obj;
   },
 
-  fromPartial<I extends Exact<DeepPartial<FlagResponse>, I>>(
-    object: I
-  ): FlagResponse {
+  create<I extends Exact<DeepPartial<FlagResponse>, I>>(base?: I): FlagResponse {
+    return FlagResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<FlagResponse>, I>>(object: I): FlagResponse {
     const message = createBaseFlagResponse();
     message.flag = object.flag ?? "";
     message.verdict = object.verdict ?? 0;
     message.message = object.message ?? "";
-    message.flagPoints = object.flagPoints ?? 0;
+    message.victimId = object.victimId ?? "0";
+    message.serviceId = object.serviceId ?? "0";
+    message.attackerDelta = object.attackerDelta ?? 0;
+    message.victimDelta = object.victimDelta ?? 0;
+    return message;
+  },
+};
+
+function createBaseAttackNotification(): AttackNotification {
+  return { attackerId: "0", victimId: "0", serviceId: "0", attackerDelta: 0, victimDelta: 0 };
+}
+
+export const AttackNotification: MessageFns<AttackNotification> = {
+  encode(message: AttackNotification, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.attackerId !== "0") {
+      writer.uint32(8).int64(message.attackerId);
+    }
+    if (message.victimId !== "0") {
+      writer.uint32(16).int64(message.victimId);
+    }
+    if (message.serviceId !== "0") {
+      writer.uint32(24).int64(message.serviceId);
+    }
+    if (message.attackerDelta !== 0) {
+      writer.uint32(33).double(message.attackerDelta);
+    }
+    if (message.victimDelta !== 0) {
+      writer.uint32(41).double(message.victimDelta);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AttackNotification {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAttackNotification();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.attackerId = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.victimId = reader.int64().toString();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.serviceId = reader.int64().toString();
+          continue;
+        }
+        case 4: {
+          if (tag !== 33) {
+            break;
+          }
+
+          message.attackerDelta = reader.double();
+          continue;
+        }
+        case 5: {
+          if (tag !== 41) {
+            break;
+          }
+
+          message.victimDelta = reader.double();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<AttackNotification, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<AttackNotification | AttackNotification[]>
+      | Iterable<AttackNotification | AttackNotification[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [AttackNotification.encode(p).finish()];
+        }
+      } else {
+        yield* [AttackNotification.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, AttackNotification>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<AttackNotification> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [AttackNotification.decode(p)];
+        }
+      } else {
+        yield* [AttackNotification.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): AttackNotification {
+    return {
+      attackerId: isSet(object.attackerId)
+        ? globalThis.String(object.attackerId)
+        : isSet(object.attacker_id)
+        ? globalThis.String(object.attacker_id)
+        : "0",
+      victimId: isSet(object.victimId)
+        ? globalThis.String(object.victimId)
+        : isSet(object.victim_id)
+        ? globalThis.String(object.victim_id)
+        : "0",
+      serviceId: isSet(object.serviceId)
+        ? globalThis.String(object.serviceId)
+        : isSet(object.service_id)
+        ? globalThis.String(object.service_id)
+        : "0",
+      attackerDelta: isSet(object.attackerDelta)
+        ? globalThis.Number(object.attackerDelta)
+        : isSet(object.attacker_delta)
+        ? globalThis.Number(object.attacker_delta)
+        : 0,
+      victimDelta: isSet(object.victimDelta)
+        ? globalThis.Number(object.victimDelta)
+        : isSet(object.victim_delta)
+        ? globalThis.Number(object.victim_delta)
+        : 0,
+    };
+  },
+
+  toJSON(message: AttackNotification): unknown {
+    const obj: any = {};
+    if (message.attackerId !== "0") {
+      obj.attackerId = message.attackerId;
+    }
+    if (message.victimId !== "0") {
+      obj.victimId = message.victimId;
+    }
+    if (message.serviceId !== "0") {
+      obj.serviceId = message.serviceId;
+    }
+    if (message.attackerDelta !== 0) {
+      obj.attackerDelta = message.attackerDelta;
+    }
+    if (message.victimDelta !== 0) {
+      obj.victimDelta = message.victimDelta;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<AttackNotification>, I>>(base?: I): AttackNotification {
+    return AttackNotification.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<AttackNotification>, I>>(object: I): AttackNotification {
+    const message = createBaseAttackNotification();
+    message.attackerId = object.attackerId ?? "0";
+    message.victimId = object.victimId ?? "0";
+    message.serviceId = object.serviceId ?? "0";
+    message.attackerDelta = object.attackerDelta ?? 0;
+    message.victimDelta = object.victimDelta ?? 0;
+    return message;
+  },
+};
+
+function createBaseAttackNotification_Batch(): AttackNotification_Batch {
+  return { attacks: [] };
+}
+
+export const AttackNotification_Batch: MessageFns<AttackNotification_Batch> = {
+  encode(message: AttackNotification_Batch, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.attacks) {
+      AttackNotification.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AttackNotification_Batch {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAttackNotification_Batch();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.attacks.push(AttackNotification.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<AttackNotification_Batch, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<AttackNotification_Batch | AttackNotification_Batch[]>
+      | Iterable<AttackNotification_Batch | AttackNotification_Batch[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [AttackNotification_Batch.encode(p).finish()];
+        }
+      } else {
+        yield* [AttackNotification_Batch.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, AttackNotification_Batch>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<AttackNotification_Batch> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [AttackNotification_Batch.decode(p)];
+        }
+      } else {
+        yield* [AttackNotification_Batch.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): AttackNotification_Batch {
+    return {
+      attacks: globalThis.Array.isArray(object?.attacks)
+        ? object.attacks.map((e: any) => AttackNotification.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: AttackNotification_Batch): unknown {
+    const obj: any = {};
+    if (message.attacks?.length) {
+      obj.attacks = message.attacks.map((e) => AttackNotification.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<AttackNotification_Batch>, I>>(base?: I): AttackNotification_Batch {
+    return AttackNotification_Batch.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<AttackNotification_Batch>, I>>(object: I): AttackNotification_Batch {
+    const message = createBaseAttackNotification_Batch();
+    message.attacks = object.attacks?.map((e) => AttackNotification.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseState(): State {
+  return { teamServices: [] };
+}
+
+export const State: MessageFns<State> = {
+  encode(message: State, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.teamServices) {
+      State_TeamService.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): State {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.teamServices.push(State_TeamService.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<State, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<State | State[]> | Iterable<State | State[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [State.encode(p).finish()];
+        }
+      } else {
+        yield* [State.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, State>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<State> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [State.decode(p)];
+        }
+      } else {
+        yield* [State.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): State {
+    return {
+      teamServices: globalThis.Array.isArray(object?.teamServices)
+        ? object.teamServices.map((e: any) => State_TeamService.fromJSON(e))
+        : globalThis.Array.isArray(object?.team_services)
+        ? object.team_services.map((e: any) => State_TeamService.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: State): unknown {
+    const obj: any = {};
+    if (message.teamServices?.length) {
+      obj.teamServices = message.teamServices.map((e) => State_TeamService.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<State>, I>>(base?: I): State {
+    return State.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<State>, I>>(object: I): State {
+    const message = createBaseState();
+    message.teamServices = object.teamServices?.map((e) => State_TeamService.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseState_TeamService(): State_TeamService {
+  return { teamId: "0", serviceId: "0", points: 0, flagsStolen: "0", flagsLost: "0" };
+}
+
+export const State_TeamService: MessageFns<State_TeamService> = {
+  encode(message: State_TeamService, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.teamId !== "0") {
+      writer.uint32(8).int64(message.teamId);
+    }
+    if (message.serviceId !== "0") {
+      writer.uint32(16).int64(message.serviceId);
+    }
+    if (message.points !== 0) {
+      writer.uint32(25).double(message.points);
+    }
+    if (message.flagsStolen !== "0") {
+      writer.uint32(32).int64(message.flagsStolen);
+    }
+    if (message.flagsLost !== "0") {
+      writer.uint32(40).int64(message.flagsLost);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): State_TeamService {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseState_TeamService();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.teamId = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.serviceId = reader.int64().toString();
+          continue;
+        }
+        case 3: {
+          if (tag !== 25) {
+            break;
+          }
+
+          message.points = reader.double();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.flagsStolen = reader.int64().toString();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.flagsLost = reader.int64().toString();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<State_TeamService, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<State_TeamService | State_TeamService[]> | Iterable<State_TeamService | State_TeamService[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [State_TeamService.encode(p).finish()];
+        }
+      } else {
+        yield* [State_TeamService.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, State_TeamService>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<State_TeamService> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [State_TeamService.decode(p)];
+        }
+      } else {
+        yield* [State_TeamService.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): State_TeamService {
+    return {
+      teamId: isSet(object.teamId)
+        ? globalThis.String(object.teamId)
+        : isSet(object.team_id)
+        ? globalThis.String(object.team_id)
+        : "0",
+      serviceId: isSet(object.serviceId)
+        ? globalThis.String(object.serviceId)
+        : isSet(object.service_id)
+        ? globalThis.String(object.service_id)
+        : "0",
+      points: isSet(object.points) ? globalThis.Number(object.points) : 0,
+      flagsStolen: isSet(object.flagsStolen)
+        ? globalThis.String(object.flagsStolen)
+        : isSet(object.flags_stolen)
+        ? globalThis.String(object.flags_stolen)
+        : "0",
+      flagsLost: isSet(object.flagsLost)
+        ? globalThis.String(object.flagsLost)
+        : isSet(object.flags_lost)
+        ? globalThis.String(object.flags_lost)
+        : "0",
+    };
+  },
+
+  toJSON(message: State_TeamService): unknown {
+    const obj: any = {};
+    if (message.teamId !== "0") {
+      obj.teamId = message.teamId;
+    }
+    if (message.serviceId !== "0") {
+      obj.serviceId = message.serviceId;
+    }
+    if (message.points !== 0) {
+      obj.points = message.points;
+    }
+    if (message.flagsStolen !== "0") {
+      obj.flagsStolen = message.flagsStolen;
+    }
+    if (message.flagsLost !== "0") {
+      obj.flagsLost = message.flagsLost;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<State_TeamService>, I>>(base?: I): State_TeamService {
+    return State_TeamService.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<State_TeamService>, I>>(object: I): State_TeamService {
+    const message = createBaseState_TeamService();
+    message.teamId = object.teamId ?? "0";
+    message.serviceId = object.serviceId ?? "0";
+    message.points = object.points ?? 0;
+    message.flagsStolen = object.flagsStolen ?? "0";
+    message.flagsLost = object.flagsLost ?? "0";
     return message;
   },
 };
@@ -221,38 +994,75 @@ function createBaseSubmitFlagsResponse(): SubmitFlagsResponse {
   return { responses: [] };
 }
 
-export const SubmitFlagsResponse = {
-  encode(
-    message: SubmitFlagsResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+export const SubmitFlagsResponse: MessageFns<SubmitFlagsResponse> = {
+  encode(message: SubmitFlagsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     for (const v of message.responses) {
-      FlagResponse.encode(v!, writer.uint32(10).fork()).ldelim();
+      FlagResponse.encode(v!, writer.uint32(10).fork()).join();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): SubmitFlagsResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+  decode(input: BinaryReader | Uint8Array, length?: number): SubmitFlagsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseSubmitFlagsResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
           message.responses.push(FlagResponse.decode(reader, reader.uint32()));
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skip(tag & 7);
     }
     return message;
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<SubmitFlagsResponse, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<SubmitFlagsResponse | SubmitFlagsResponse[]>
+      | Iterable<SubmitFlagsResponse | SubmitFlagsResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [SubmitFlagsResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [SubmitFlagsResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, SubmitFlagsResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<SubmitFlagsResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [SubmitFlagsResponse.decode(p)];
+        }
+      } else {
+        yield* [SubmitFlagsResponse.decode(pkt as any)];
+      }
+    }
+  },
+
   fromJSON(object: any): SubmitFlagsResponse {
     return {
-      responses: Array.isArray(object?.responses)
+      responses: globalThis.Array.isArray(object?.responses)
         ? object.responses.map((e: any) => FlagResponse.fromJSON(e))
         : [],
     };
@@ -260,53 +1070,213 @@ export const SubmitFlagsResponse = {
 
   toJSON(message: SubmitFlagsResponse): unknown {
     const obj: any = {};
-    if (message.responses) {
-      obj.responses = message.responses.map((e) =>
-        e ? FlagResponse.toJSON(e) : undefined
-      );
-    } else {
-      obj.responses = [];
+    if (message.responses?.length) {
+      obj.responses = message.responses.map((e) => FlagResponse.toJSON(e));
     }
     return obj;
   },
 
-  fromPartial<I extends Exact<DeepPartial<SubmitFlagsResponse>, I>>(
-    object: I
-  ): SubmitFlagsResponse {
+  create<I extends Exact<DeepPartial<SubmitFlagsResponse>, I>>(base?: I): SubmitFlagsResponse {
+    return SubmitFlagsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SubmitFlagsResponse>, I>>(object: I): SubmitFlagsResponse {
     const message = createBaseSubmitFlagsResponse();
-    message.responses =
-      object.responses?.map((e) => FlagResponse.fromPartial(e)) || [];
+    message.responses = object.responses?.map((e) => FlagResponse.fromPartial(e)) || [];
     return message;
   },
 };
 
-type Builtin =
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | boolean
-  | undefined;
-
-export type DeepPartial<T> = T extends Builtin
-  ? T
-  : T extends Array<infer U>
-  ? Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<DeepPartial<U>>
-  : T extends {}
-  ? { [K in keyof T]?: DeepPartial<T[K]> }
+function createBaseGetStateRequest(): GetStateRequest {
+  return {};
+}
+
+export const GetStateRequest: MessageFns<GetStateRequest> = {
+  encode(_: GetStateRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetStateRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetStateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<GetStateRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<GetStateRequest | GetStateRequest[]> | Iterable<GetStateRequest | GetStateRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [GetStateRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, GetStateRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<GetStateRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateRequest.decode(p)];
+        }
+      } else {
+        yield* [GetStateRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(_: any): GetStateRequest {
+    return {};
+  },
+
+  toJSON(_: GetStateRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetStateRequest>, I>>(base?: I): GetStateRequest {
+    return GetStateRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetStateRequest>, I>>(_: I): GetStateRequest {
+    const message = createBaseGetStateRequest();
+    return message;
+  },
+};
+
+function createBaseGetStateResponse(): GetStateResponse {
+  return { state: undefined };
+}
+
+export const GetStateResponse: MessageFns<GetStateResponse> = {
+  encode(message: GetStateResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.state !== undefined) {
+      State.encode(message.state, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetStateResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetStateResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.state = State.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<GetStateResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<GetStateResponse | GetStateResponse[]> | Iterable<GetStateResponse | GetStateResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [GetStateResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, GetStateResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<GetStateResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateResponse.decode(p)];
+        }
+      } else {
+        yield* [GetStateResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): GetStateResponse {
+    return { state: isSet(object.state) ? State.fromJSON(object.state) : undefined };
+  },
+
+  toJSON(message: GetStateResponse): unknown {
+    const obj: any = {};
+    if (message.state !== undefined) {
+      obj.state = State.toJSON(message.state);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetStateResponse>, I>>(base?: I): GetStateResponse {
+    return GetStateResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetStateResponse>, I>>(object: I): GetStateResponse {
+    const message = createBaseGetStateResponse();
+    message.state = (object.state !== undefined && object.state !== null) ? State.fromPartial(object.state) : undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
   : Partial<T>;
 
 type KeysOfUnion<T> = T extends T ? keyof T : never;
-export type Exact<P, I extends P> = P extends Builtin
-  ? P
-  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
-        Exclude<keyof I, KeysOfUnion<P>>,
-        never
-      >;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 
 function isSet(value: any): boolean {
   return value !== null && value !== undefined;
 }
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/receiver/receiver_service.ts b/front/src/proto/receiver/receiver_service.ts
index 12eee16..23d7d66 100644
--- a/front/src/proto/receiver/receiver_service.ts
+++ b/front/src/proto/receiver/receiver_service.ts
@@ -1,21 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: receiver/receiver_service.proto
+
 /* eslint-disable */
-import { SubmitFlagsRequest, SubmitFlagsResponse } from "./receiver.js";
 
 export const protobufPackage = "receiver";
-
-/** TODO: options. */
-export type ReceiverServiceDefinition = typeof ReceiverServiceDefinition;
-export const ReceiverServiceDefinition = {
-  name: "ReceiverService",
-  fullName: "receiver.ReceiverService",
-  methods: {
-    submitFlags: {
-      name: "SubmitFlags",
-      requestType: SubmitFlagsRequest,
-      requestStream: false,
-      responseType: SubmitFlagsResponse,
-      responseStream: false,
-      options: {},
-    },
-  },
-} as const;
diff --git a/front/src/proto/scoreboard/scoreboard.ts b/front/src/proto/scoreboard/scoreboard.ts
new file mode 100644
index 0000000..e223ee6
--- /dev/null
+++ b/front/src/proto/scoreboard/scoreboard.ts
@@ -0,0 +1,397 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: scoreboard/scoreboard.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { TeamServiceState_CheckStatus } from "../slac/slac";
+
+export const protobufPackage = "scoreboard";
+
+export interface Scoreboard {
+  teamServiceStates: Scoreboard_TeamServiceState[];
+}
+
+export interface Scoreboard_TeamServiceState {
+  teamId: string;
+  serviceId: string;
+  /** From slac. */
+  checksTotal: string;
+  checksPassed: string;
+  checkStatuses: TeamServiceState_CheckStatus[];
+  /** From receiver. */
+  points: number;
+  flagsStolen: string;
+  flagsLost: string;
+}
+
+function createBaseScoreboard(): Scoreboard {
+  return { teamServiceStates: [] };
+}
+
+export const Scoreboard: MessageFns<Scoreboard> = {
+  encode(message: Scoreboard, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.teamServiceStates) {
+      Scoreboard_TeamServiceState.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Scoreboard {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseScoreboard();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.teamServiceStates.push(Scoreboard_TeamServiceState.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Scoreboard, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Scoreboard | Scoreboard[]> | Iterable<Scoreboard | Scoreboard[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Scoreboard.encode(p).finish()];
+        }
+      } else {
+        yield* [Scoreboard.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Scoreboard>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Scoreboard> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Scoreboard.decode(p)];
+        }
+      } else {
+        yield* [Scoreboard.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Scoreboard {
+    return {
+      teamServiceStates: globalThis.Array.isArray(object?.teamServiceStates)
+        ? object.teamServiceStates.map((e: any) => Scoreboard_TeamServiceState.fromJSON(e))
+        : globalThis.Array.isArray(object?.team_service_states)
+        ? object.team_service_states.map((e: any) => Scoreboard_TeamServiceState.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: Scoreboard): unknown {
+    const obj: any = {};
+    if (message.teamServiceStates?.length) {
+      obj.teamServiceStates = message.teamServiceStates.map((e) => Scoreboard_TeamServiceState.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Scoreboard>, I>>(base?: I): Scoreboard {
+    return Scoreboard.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Scoreboard>, I>>(object: I): Scoreboard {
+    const message = createBaseScoreboard();
+    message.teamServiceStates = object.teamServiceStates?.map((e) => Scoreboard_TeamServiceState.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseScoreboard_TeamServiceState(): Scoreboard_TeamServiceState {
+  return {
+    teamId: "0",
+    serviceId: "0",
+    checksTotal: "0",
+    checksPassed: "0",
+    checkStatuses: [],
+    points: 0,
+    flagsStolen: "0",
+    flagsLost: "0",
+  };
+}
+
+export const Scoreboard_TeamServiceState: MessageFns<Scoreboard_TeamServiceState> = {
+  encode(message: Scoreboard_TeamServiceState, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.teamId !== "0") {
+      writer.uint32(8).int64(message.teamId);
+    }
+    if (message.serviceId !== "0") {
+      writer.uint32(16).int64(message.serviceId);
+    }
+    if (message.checksTotal !== "0") {
+      writer.uint32(24).int64(message.checksTotal);
+    }
+    if (message.checksPassed !== "0") {
+      writer.uint32(32).int64(message.checksPassed);
+    }
+    for (const v of message.checkStatuses) {
+      TeamServiceState_CheckStatus.encode(v!, writer.uint32(42).fork()).join();
+    }
+    if (message.points !== 0) {
+      writer.uint32(49).double(message.points);
+    }
+    if (message.flagsStolen !== "0") {
+      writer.uint32(56).int64(message.flagsStolen);
+    }
+    if (message.flagsLost !== "0") {
+      writer.uint32(64).int64(message.flagsLost);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Scoreboard_TeamServiceState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseScoreboard_TeamServiceState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.teamId = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.serviceId = reader.int64().toString();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.checksTotal = reader.int64().toString();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.checksPassed = reader.int64().toString();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.checkStatuses.push(TeamServiceState_CheckStatus.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 49) {
+            break;
+          }
+
+          message.points = reader.double();
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+
+          message.flagsStolen = reader.int64().toString();
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+
+          message.flagsLost = reader.int64().toString();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<Scoreboard_TeamServiceState, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<Scoreboard_TeamServiceState | Scoreboard_TeamServiceState[]>
+      | Iterable<Scoreboard_TeamServiceState | Scoreboard_TeamServiceState[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Scoreboard_TeamServiceState.encode(p).finish()];
+        }
+      } else {
+        yield* [Scoreboard_TeamServiceState.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Scoreboard_TeamServiceState>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<Scoreboard_TeamServiceState> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [Scoreboard_TeamServiceState.decode(p)];
+        }
+      } else {
+        yield* [Scoreboard_TeamServiceState.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): Scoreboard_TeamServiceState {
+    return {
+      teamId: isSet(object.teamId)
+        ? globalThis.String(object.teamId)
+        : isSet(object.team_id)
+        ? globalThis.String(object.team_id)
+        : "0",
+      serviceId: isSet(object.serviceId)
+        ? globalThis.String(object.serviceId)
+        : isSet(object.service_id)
+        ? globalThis.String(object.service_id)
+        : "0",
+      checksTotal: isSet(object.checksTotal)
+        ? globalThis.String(object.checksTotal)
+        : isSet(object.checks_total)
+        ? globalThis.String(object.checks_total)
+        : "0",
+      checksPassed: isSet(object.checksPassed)
+        ? globalThis.String(object.checksPassed)
+        : isSet(object.checks_passed)
+        ? globalThis.String(object.checks_passed)
+        : "0",
+      checkStatuses: globalThis.Array.isArray(object?.checkStatuses)
+        ? object.checkStatuses.map((e: any) => TeamServiceState_CheckStatus.fromJSON(e))
+        : globalThis.Array.isArray(object?.check_statuses)
+        ? object.check_statuses.map((e: any) => TeamServiceState_CheckStatus.fromJSON(e))
+        : [],
+      points: isSet(object.points) ? globalThis.Number(object.points) : 0,
+      flagsStolen: isSet(object.flagsStolen)
+        ? globalThis.String(object.flagsStolen)
+        : isSet(object.flags_stolen)
+        ? globalThis.String(object.flags_stolen)
+        : "0",
+      flagsLost: isSet(object.flagsLost)
+        ? globalThis.String(object.flagsLost)
+        : isSet(object.flags_lost)
+        ? globalThis.String(object.flags_lost)
+        : "0",
+    };
+  },
+
+  toJSON(message: Scoreboard_TeamServiceState): unknown {
+    const obj: any = {};
+    if (message.teamId !== "0") {
+      obj.teamId = message.teamId;
+    }
+    if (message.serviceId !== "0") {
+      obj.serviceId = message.serviceId;
+    }
+    if (message.checksTotal !== "0") {
+      obj.checksTotal = message.checksTotal;
+    }
+    if (message.checksPassed !== "0") {
+      obj.checksPassed = message.checksPassed;
+    }
+    if (message.checkStatuses?.length) {
+      obj.checkStatuses = message.checkStatuses.map((e) => TeamServiceState_CheckStatus.toJSON(e));
+    }
+    if (message.points !== 0) {
+      obj.points = message.points;
+    }
+    if (message.flagsStolen !== "0") {
+      obj.flagsStolen = message.flagsStolen;
+    }
+    if (message.flagsLost !== "0") {
+      obj.flagsLost = message.flagsLost;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Scoreboard_TeamServiceState>, I>>(base?: I): Scoreboard_TeamServiceState {
+    return Scoreboard_TeamServiceState.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Scoreboard_TeamServiceState>, I>>(object: I): Scoreboard_TeamServiceState {
+    const message = createBaseScoreboard_TeamServiceState();
+    message.teamId = object.teamId ?? "0";
+    message.serviceId = object.serviceId ?? "0";
+    message.checksTotal = object.checksTotal ?? "0";
+    message.checksPassed = object.checksPassed ?? "0";
+    message.checkStatuses = object.checkStatuses?.map((e) => TeamServiceState_CheckStatus.fromPartial(e)) || [];
+    message.points = object.points ?? 0;
+    message.flagsStolen = object.flagsStolen ?? "0";
+    message.flagsLost = object.flagsLost ?? "0";
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/slac/slac.ts b/front/src/proto/slac/slac.ts
new file mode 100644
index 0000000..004ab22
--- /dev/null
+++ b/front/src/proto/slac/slac.ts
@@ -0,0 +1,612 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: slac/slac.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Status, statusFromJSON, statusToJSON } from "../checker/checker";
+
+export const protobufPackage = "slac";
+
+export interface TeamServiceState {
+  teamId: string;
+  serviceId: string;
+  checksTotal: string;
+  checksPassed: string;
+  checkStatuses: TeamServiceState_CheckStatus[];
+}
+
+export interface TeamServiceState_CheckStatus {
+  status: Status;
+  message: string;
+}
+
+export interface State {
+  teamServiceStates: TeamServiceState[];
+}
+
+export interface GetStateRequest {
+}
+
+export interface GetStateResponse {
+  state: State | undefined;
+}
+
+function createBaseTeamServiceState(): TeamServiceState {
+  return { teamId: "0", serviceId: "0", checksTotal: "0", checksPassed: "0", checkStatuses: [] };
+}
+
+export const TeamServiceState: MessageFns<TeamServiceState> = {
+  encode(message: TeamServiceState, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.teamId !== "0") {
+      writer.uint32(8).int64(message.teamId);
+    }
+    if (message.serviceId !== "0") {
+      writer.uint32(16).int64(message.serviceId);
+    }
+    if (message.checksTotal !== "0") {
+      writer.uint32(24).int64(message.checksTotal);
+    }
+    if (message.checksPassed !== "0") {
+      writer.uint32(32).int64(message.checksPassed);
+    }
+    for (const v of message.checkStatuses) {
+      TeamServiceState_CheckStatus.encode(v!, writer.uint32(42).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TeamServiceState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTeamServiceState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.teamId = reader.int64().toString();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.serviceId = reader.int64().toString();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.checksTotal = reader.int64().toString();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.checksPassed = reader.int64().toString();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.checkStatuses.push(TeamServiceState_CheckStatus.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<TeamServiceState, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<TeamServiceState | TeamServiceState[]> | Iterable<TeamServiceState | TeamServiceState[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [TeamServiceState.encode(p).finish()];
+        }
+      } else {
+        yield* [TeamServiceState.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, TeamServiceState>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<TeamServiceState> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [TeamServiceState.decode(p)];
+        }
+      } else {
+        yield* [TeamServiceState.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): TeamServiceState {
+    return {
+      teamId: isSet(object.teamId)
+        ? globalThis.String(object.teamId)
+        : isSet(object.team_id)
+        ? globalThis.String(object.team_id)
+        : "0",
+      serviceId: isSet(object.serviceId)
+        ? globalThis.String(object.serviceId)
+        : isSet(object.service_id)
+        ? globalThis.String(object.service_id)
+        : "0",
+      checksTotal: isSet(object.checksTotal)
+        ? globalThis.String(object.checksTotal)
+        : isSet(object.checks_total)
+        ? globalThis.String(object.checks_total)
+        : "0",
+      checksPassed: isSet(object.checksPassed)
+        ? globalThis.String(object.checksPassed)
+        : isSet(object.checks_passed)
+        ? globalThis.String(object.checks_passed)
+        : "0",
+      checkStatuses: globalThis.Array.isArray(object?.checkStatuses)
+        ? object.checkStatuses.map((e: any) => TeamServiceState_CheckStatus.fromJSON(e))
+        : globalThis.Array.isArray(object?.check_statuses)
+        ? object.check_statuses.map((e: any) => TeamServiceState_CheckStatus.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: TeamServiceState): unknown {
+    const obj: any = {};
+    if (message.teamId !== "0") {
+      obj.teamId = message.teamId;
+    }
+    if (message.serviceId !== "0") {
+      obj.serviceId = message.serviceId;
+    }
+    if (message.checksTotal !== "0") {
+      obj.checksTotal = message.checksTotal;
+    }
+    if (message.checksPassed !== "0") {
+      obj.checksPassed = message.checksPassed;
+    }
+    if (message.checkStatuses?.length) {
+      obj.checkStatuses = message.checkStatuses.map((e) => TeamServiceState_CheckStatus.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TeamServiceState>, I>>(base?: I): TeamServiceState {
+    return TeamServiceState.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TeamServiceState>, I>>(object: I): TeamServiceState {
+    const message = createBaseTeamServiceState();
+    message.teamId = object.teamId ?? "0";
+    message.serviceId = object.serviceId ?? "0";
+    message.checksTotal = object.checksTotal ?? "0";
+    message.checksPassed = object.checksPassed ?? "0";
+    message.checkStatuses = object.checkStatuses?.map((e) => TeamServiceState_CheckStatus.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseTeamServiceState_CheckStatus(): TeamServiceState_CheckStatus {
+  return { status: 0, message: "" };
+}
+
+export const TeamServiceState_CheckStatus: MessageFns<TeamServiceState_CheckStatus> = {
+  encode(message: TeamServiceState_CheckStatus, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== 0) {
+      writer.uint32(8).int32(message.status);
+    }
+    if (message.message !== "") {
+      writer.uint32(18).string(message.message);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TeamServiceState_CheckStatus {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTeamServiceState_CheckStatus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.status = reader.int32() as any;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<TeamServiceState_CheckStatus, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<TeamServiceState_CheckStatus | TeamServiceState_CheckStatus[]>
+      | Iterable<TeamServiceState_CheckStatus | TeamServiceState_CheckStatus[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [TeamServiceState_CheckStatus.encode(p).finish()];
+        }
+      } else {
+        yield* [TeamServiceState_CheckStatus.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, TeamServiceState_CheckStatus>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<TeamServiceState_CheckStatus> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [TeamServiceState_CheckStatus.decode(p)];
+        }
+      } else {
+        yield* [TeamServiceState_CheckStatus.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): TeamServiceState_CheckStatus {
+    return {
+      status: isSet(object.status) ? statusFromJSON(object.status) : 0,
+      message: isSet(object.message) ? globalThis.String(object.message) : "",
+    };
+  },
+
+  toJSON(message: TeamServiceState_CheckStatus): unknown {
+    const obj: any = {};
+    if (message.status !== 0) {
+      obj.status = statusToJSON(message.status);
+    }
+    if (message.message !== "") {
+      obj.message = message.message;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TeamServiceState_CheckStatus>, I>>(base?: I): TeamServiceState_CheckStatus {
+    return TeamServiceState_CheckStatus.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TeamServiceState_CheckStatus>, I>>(object: I): TeamServiceState_CheckStatus {
+    const message = createBaseTeamServiceState_CheckStatus();
+    message.status = object.status ?? 0;
+    message.message = object.message ?? "";
+    return message;
+  },
+};
+
+function createBaseState(): State {
+  return { teamServiceStates: [] };
+}
+
+export const State: MessageFns<State> = {
+  encode(message: State, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.teamServiceStates) {
+      TeamServiceState.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): State {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.teamServiceStates.push(TeamServiceState.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<State, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<State | State[]> | Iterable<State | State[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [State.encode(p).finish()];
+        }
+      } else {
+        yield* [State.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, State>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<State> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [State.decode(p)];
+        }
+      } else {
+        yield* [State.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): State {
+    return {
+      teamServiceStates: globalThis.Array.isArray(object?.teamServiceStates)
+        ? object.teamServiceStates.map((e: any) => TeamServiceState.fromJSON(e))
+        : globalThis.Array.isArray(object?.team_service_states)
+        ? object.team_service_states.map((e: any) => TeamServiceState.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: State): unknown {
+    const obj: any = {};
+    if (message.teamServiceStates?.length) {
+      obj.teamServiceStates = message.teamServiceStates.map((e) => TeamServiceState.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<State>, I>>(base?: I): State {
+    return State.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<State>, I>>(object: I): State {
+    const message = createBaseState();
+    message.teamServiceStates = object.teamServiceStates?.map((e) => TeamServiceState.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseGetStateRequest(): GetStateRequest {
+  return {};
+}
+
+export const GetStateRequest: MessageFns<GetStateRequest> = {
+  encode(_: GetStateRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetStateRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetStateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<GetStateRequest, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<GetStateRequest | GetStateRequest[]> | Iterable<GetStateRequest | GetStateRequest[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateRequest.encode(p).finish()];
+        }
+      } else {
+        yield* [GetStateRequest.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, GetStateRequest>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<GetStateRequest> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateRequest.decode(p)];
+        }
+      } else {
+        yield* [GetStateRequest.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(_: any): GetStateRequest {
+    return {};
+  },
+
+  toJSON(_: GetStateRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetStateRequest>, I>>(base?: I): GetStateRequest {
+    return GetStateRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetStateRequest>, I>>(_: I): GetStateRequest {
+    const message = createBaseGetStateRequest();
+    return message;
+  },
+};
+
+function createBaseGetStateResponse(): GetStateResponse {
+  return { state: undefined };
+}
+
+export const GetStateResponse: MessageFns<GetStateResponse> = {
+  encode(message: GetStateResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.state !== undefined) {
+      State.encode(message.state, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetStateResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetStateResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.state = State.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  // encodeTransform encodes a source of message objects.
+  // Transform<GetStateResponse, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<GetStateResponse | GetStateResponse[]> | Iterable<GetStateResponse | GetStateResponse[]>,
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateResponse.encode(p).finish()];
+        }
+      } else {
+        yield* [GetStateResponse.encode(pkt as any).finish()];
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, GetStateResponse>
+  async *decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<GetStateResponse> {
+    for await (const pkt of source) {
+      if (globalThis.Array.isArray(pkt)) {
+        for (const p of (pkt as any)) {
+          yield* [GetStateResponse.decode(p)];
+        }
+      } else {
+        yield* [GetStateResponse.decode(pkt as any)];
+      }
+    }
+  },
+
+  fromJSON(object: any): GetStateResponse {
+    return { state: isSet(object.state) ? State.fromJSON(object.state) : undefined };
+  },
+
+  toJSON(message: GetStateResponse): unknown {
+    const obj: any = {};
+    if (message.state !== undefined) {
+      obj.state = State.toJSON(message.state);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetStateResponse>, I>>(base?: I): GetStateResponse {
+    return GetStateResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetStateResponse>, I>>(object: I): GetStateResponse {
+    const message = createBaseGetStateResponse();
+    message.state = (object.state !== undefined && object.state !== null) ? State.fromPartial(object.state) : undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  encodeTransform(source: AsyncIterable<T | T[]> | Iterable<T | T[]>): AsyncIterable<Uint8Array>;
+  decodeTransform(
+    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+  ): AsyncIterable<T>;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
diff --git a/front/src/proto/slac/slac_service.ts b/front/src/proto/slac/slac_service.ts
new file mode 100644
index 0000000..40260cc
--- /dev/null
+++ b/front/src/proto/slac/slac_service.ts
@@ -0,0 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.1
+//   protoc               unknown
+// source: slac/slac_service.proto
+
+/* eslint-disable */
+
+export const protobufPackage = "slac";
diff --git a/front/src/style.css b/front/src/style.css
deleted file mode 100644
index f1e543c..0000000
--- a/front/src/style.css
+++ /dev/null
@@ -1,86 +0,0 @@
-:root {
-    font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
-    font-size: 16px;
-    line-height: 24px;
-    font-weight: 400;
-
-    color-scheme: light dark;
-    color: rgba(255, 255, 255, 0.87);
-    background-color: #242424;
-
-    font-synthesis: none;
-    text-rendering: optimizeLegibility;
-    -webkit-font-smoothing: antialiased;
-    -moz-osx-font-smoothing: grayscale;
-    -webkit-text-size-adjust: 100%;
-}
-
-a {
-    font-weight: 500;
-    color: #646cff;
-    text-decoration: inherit;
-}
-
-a:hover {
-    color: #535bf2;
-}
-
-body {
-    margin: 0;
-    display: flex;
-    place-items: center;
-    min-width: 320px;
-    min-height: 100vh;
-}
-
-h1 {
-    font-size: 3.2em;
-    line-height: 1.1;
-}
-
-button {
-    border-radius: 8px;
-    border: 1px solid transparent;
-    padding: 0.6em 1.2em;
-    font-size: 1em;
-    font-weight: 500;
-    font-family: inherit;
-    background-color: #1a1a1a;
-    cursor: pointer;
-    transition: border-color 0.25s;
-}
-
-button:hover {
-    border-color: #646cff;
-}
-
-button:focus,
-button:focus-visible {
-    outline: 4px auto -webkit-focus-ring-color;
-}
-
-.card {
-    padding: 2em;
-}
-
-#app {
-    max-width: 1280px;
-    margin: 0 auto;
-    padding: 2rem;
-    text-align: center;
-}
-
-@media (prefers-color-scheme: light) {
-    :root {
-        color: #213547;
-        background-color: #ffffff;
-    }
-
-    a:hover {
-        color: #747bff;
-    }
-
-    button {
-        background-color: #f9f9f9;
-    }
-}
diff --git a/front/src/theme.ts b/front/src/theme.ts
new file mode 100644
index 0000000..4156496
--- /dev/null
+++ b/front/src/theme.ts
@@ -0,0 +1,85 @@
+import '@mui/material/styles';
+import { createTheme } from '@mui/material/styles';
+
+declare module '@mui/material/styles' {
+  // eslint-disable-next-line no-unused-vars
+  interface Theme {
+    name: string;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  interface ThemeOptions {
+    name: string;
+  }
+
+  interface Palette {
+    statusUp: Palette['primary'];
+    statusCorrupt: Palette['primary'];
+    statusMumble: Palette['primary'];
+    statusDown: Palette['primary'];
+    statusCheckFailed: Palette['primary'];
+    statusUnspecified: Palette['primary'];
+  }
+
+  interface PaletteOptions {
+    statusUp: PaletteOptions['primary'];
+    statusCorrupt: PaletteOptions['primary'];
+    statusMumble: PaletteOptions['primary'];
+    statusDown: PaletteOptions['primary'];
+    statusCheckFailed: PaletteOptions['primary'];
+    statusUnspecified: PaletteOptions['primary'];
+  }
+}
+
+let theme = createTheme({ name: 'ForcAD' });
+
+theme = createTheme(theme, {
+  palette: {
+    statusUp: theme.palette.augmentColor({
+      color: {
+        main: '#7dfc74',
+      },
+      name: 'status_up',
+    }),
+    statusCorrupt: theme.palette.augmentColor({
+      color: {
+        main: '#5191ff',
+      },
+      name: 'status_corrupt',
+    }),
+    statusMumble: theme.palette.augmentColor({
+      color: {
+        main: '#ff9114',
+      },
+      name: 'status_mumble',
+    }),
+    statusDown: {
+      ...theme.palette.augmentColor({
+        color: {
+          main: '#ff5b5b',
+        },
+        name: 'status_down',
+      }),
+      contrastText: '#000000',
+    },
+    statusCheckFailed: {
+      ...theme.palette.augmentColor({
+        color: {
+          main: '#ffff00',
+        },
+        name: 'status_check_failed',
+      }),
+      contrastText: '#000000',
+    },
+    statusUnspecified: {
+      ...theme.palette.augmentColor({
+        color: {
+          main: '#ffffff',
+        },
+        name: 'status_unspecified',
+      }),
+    },
+  },
+});
+
+export default theme;
diff --git a/front/src/vite-env.d.ts b/front/src/vite-env.d.ts
index 6e9586b..11f02fe 100644
--- a/front/src/vite-env.d.ts
+++ b/front/src/vite-env.d.ts
@@ -1,11 +1 @@
 /// <reference types="vite/client" />
-
-declare module "*.vue" {
-  import type { DefineComponent } from "vue";
-  const component: DefineComponent<
-    Record<string, never>,
-    Record<string, never>,
-    unknown
-  >;
-  export default component;
-}
diff --git a/front/tsconfig.app.json b/front/tsconfig.app.json
new file mode 100644
index 0000000..166bcfa
--- /dev/null
+++ b/front/tsconfig.app.json
@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}
diff --git a/front/tsconfig.json b/front/tsconfig.json
index 222c555..ea9d0cd 100644
--- a/front/tsconfig.json
+++ b/front/tsconfig.json
@@ -1,18 +1,11 @@
 {
-    "compilerOptions": {
-        "target": "ESNext",
-        "useDefineForClassFields": true,
-        "module": "ESNext",
-        "moduleResolution": "Node",
-        "strict": true,
-        "jsx": "preserve",
-        "sourceMap": true,
-        "resolveJsonModule": true,
-        "isolatedModules": true,
-        "esModuleInterop": true,
-        "lib": ["ESNext", "DOM"],
-        "skipLibCheck": true
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
     },
-    "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"],
-    "references": [{"path": "./tsconfig.node.json"}]
+    {
+      "path": "./tsconfig.node.json"
+    }
+  ]
 }
diff --git a/front/tsconfig.node.json b/front/tsconfig.node.json
index 13b35d0..98c487b 100644
--- a/front/tsconfig.node.json
+++ b/front/tsconfig.node.json
@@ -1,9 +1,22 @@
 {
-    "compilerOptions": {
-        "composite": true,
-        "module": "ESNext",
-        "moduleResolution": "Node",
-        "allowSyntheticDefaultImports": true
-    },
-    "include": ["vite.config.ts"]
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
 }
diff --git a/front/vite.config.ts b/front/vite.config.ts
index c90547b..246c6f4 100644
--- a/front/vite.config.ts
+++ b/front/vite.config.ts
@@ -1,13 +1,12 @@
-import { defineConfig } from "vite";
-import vue from "@vitejs/plugin-vue";
-import path from "node:path";
-
-// https://vitejs.dev/config/
+import react from '@vitejs/plugin-react';
+import path from 'node:path';
+import { defineConfig } from 'vite';
+// https://vite.dev/config/
 export default defineConfig({
-  plugins: [vue()],
+  plugins: [react()],
   resolve: {
     alias: {
-      "@": path.resolve(__dirname, "./src"),
+      '@': path.resolve(__dirname, 'src'),
     },
   },
 });
diff --git a/front/yarn.lock b/front/yarn.lock
deleted file mode 100644
index 320845e..0000000
--- a/front/yarn.lock
+++ /dev/null
@@ -1,1483 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-"@babel/parser@^7.16.4":
-  version "7.18.9"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.18.9.tgz#f2dde0c682ccc264a9a8595efd030a5cc8fd2539"
-  integrity sha512-9uJveS9eY9DJ0t64YbIBZICtJy8a5QrDEVdiLCG97fVLpDTpGX7t8mMSb6OWw6Lrnjqj4O8zwjELX3dhoMgiBg==
-
-"@eslint/eslintrc@^1.3.0":
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-1.3.0.tgz#29f92c30bb3e771e4a2048c95fa6855392dfac4f"
-  integrity sha512-UWW0TMTmk2d7hLcWD1/e2g5HDM/HQ3csaLSqXCfqwh4uNDuNqlaKWXmEsL4Cs41Z0KnILNvwbHAah3C2yt06kw==
-  dependencies:
-    ajv "^6.12.4"
-    debug "^4.3.2"
-    espree "^9.3.2"
-    globals "^13.15.0"
-    ignore "^5.2.0"
-    import-fresh "^3.2.1"
-    js-yaml "^4.1.0"
-    minimatch "^3.1.2"
-    strip-json-comments "^3.1.1"
-
-"@humanwhocodes/config-array@^0.9.2":
-  version "0.9.5"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.9.5.tgz#2cbaf9a89460da24b5ca6531b8bbfc23e1df50c7"
-  integrity sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==
-  dependencies:
-    "@humanwhocodes/object-schema" "^1.2.1"
-    debug "^4.1.1"
-    minimatch "^3.0.4"
-
-"@humanwhocodes/object-schema@^1.2.1":
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
-  integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
-
-"@improbable-eng/grpc-web@^0.15.0":
-  version "0.15.0"
-  resolved "https://registry.yarnpkg.com/@improbable-eng/grpc-web/-/grpc-web-0.15.0.tgz#3e47e9fdd90381a74abd4b7d26e67422a2a04bef"
-  integrity sha512-ERft9/0/8CmYalqOVnJnpdDry28q+j+nAlFFARdjyxXDJ+Mhgv9+F600QC8BR9ygOfrXRlAk6CvST2j+JCpQPg==
-  dependencies:
-    browser-headers "^0.4.1"
-
-"@nodelib/fs.scandir@2.1.5":
-  version "2.1.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
-  integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
-  dependencies:
-    "@nodelib/fs.stat" "2.0.5"
-    run-parallel "^1.1.9"
-
-"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b"
-  integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
-
-"@nodelib/fs.walk@^1.2.3":
-  version "1.2.8"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a"
-  integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
-  dependencies:
-    "@nodelib/fs.scandir" "2.1.5"
-    fastq "^1.6.0"
-
-"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf"
-  integrity sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==
-
-"@protobufjs/base64@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735"
-  integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==
-
-"@protobufjs/codegen@^2.0.4":
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb"
-  integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==
-
-"@protobufjs/eventemitter@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70"
-  integrity sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==
-
-"@protobufjs/fetch@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45"
-  integrity sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==
-  dependencies:
-    "@protobufjs/aspromise" "^1.1.1"
-    "@protobufjs/inquire" "^1.1.0"
-
-"@protobufjs/float@^1.0.2":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1"
-  integrity sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==
-
-"@protobufjs/inquire@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089"
-  integrity sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==
-
-"@protobufjs/path@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d"
-  integrity sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==
-
-"@protobufjs/pool@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54"
-  integrity sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==
-
-"@protobufjs/utf8@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570"
-  integrity sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==
-
-"@rushstack/eslint-patch@^1.1.4":
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/@rushstack/eslint-patch/-/eslint-patch-1.1.4.tgz#0c8b74c50f29ee44f423f7416829c0bf8bb5eb27"
-  integrity sha512-LwzQKA4vzIct1zNZzBmRKI9QuNpLgTQMEjsQLf3BXuGYb3QPTP4Yjf6mkdX+X1mYttZ808QpOwAzZjv28kq7DA==
-
-"@types/json-schema@^7.0.9":
-  version "7.0.11"
-  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3"
-  integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==
-
-"@types/long@^4.0.1":
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.2.tgz#b74129719fc8d11c01868010082d483b7545591a"
-  integrity sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==
-
-"@types/node@>=13.7.0", "@types/node@^18.6.1":
-  version "18.6.1"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-18.6.1.tgz#828e4785ccca13f44e2fb6852ae0ef11e3e20ba5"
-  integrity sha512-z+2vB6yDt1fNwKOeGbckpmirO+VBDuQqecXkgeIqDlaOtmKn6hPR/viQ8cxCfqLU4fTlvM3+YjM367TukWdxpg==
-
-"@typescript-eslint/eslint-plugin@^5.0.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.31.0.tgz#cae1967b1e569e6171bbc6bec2afa4e0c8efccfe"
-  integrity sha512-VKW4JPHzG5yhYQrQ1AzXgVgX8ZAJEvCz0QI6mLRX4tf7rnFfh5D8SKm0Pq6w5PyNfAWJk6sv313+nEt3ohWMBQ==
-  dependencies:
-    "@typescript-eslint/scope-manager" "5.31.0"
-    "@typescript-eslint/type-utils" "5.31.0"
-    "@typescript-eslint/utils" "5.31.0"
-    debug "^4.3.4"
-    functional-red-black-tree "^1.0.1"
-    ignore "^5.2.0"
-    regexpp "^3.2.0"
-    semver "^7.3.7"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/parser@^5.0.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.31.0.tgz#7f42d7dcc68a0a6d80a0f3d9a65063aee7bb8d2c"
-  integrity sha512-UStjQiZ9OFTFReTrN+iGrC6O/ko9LVDhreEK5S3edmXgR396JGq7CoX2TWIptqt/ESzU2iRKXAHfSF2WJFcWHw==
-  dependencies:
-    "@typescript-eslint/scope-manager" "5.31.0"
-    "@typescript-eslint/types" "5.31.0"
-    "@typescript-eslint/typescript-estree" "5.31.0"
-    debug "^4.3.4"
-
-"@typescript-eslint/scope-manager@5.31.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.31.0.tgz#f47a794ba84d9b818ab7f8f44fff55a61016c606"
-  integrity sha512-8jfEzBYDBG88rcXFxajdVavGxb5/XKXyvWgvD8Qix3EEJLCFIdVloJw+r9ww0wbyNLOTYyBsR+4ALNGdlalLLg==
-  dependencies:
-    "@typescript-eslint/types" "5.31.0"
-    "@typescript-eslint/visitor-keys" "5.31.0"
-
-"@typescript-eslint/type-utils@5.31.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.31.0.tgz#70a0b7201360b5adbddb0c36080495aa08f6f3d9"
-  integrity sha512-7ZYqFbvEvYXFn9ax02GsPcEOmuWNg+14HIf4q+oUuLnMbpJ6eHAivCg7tZMVwzrIuzX3QCeAOqKoyMZCv5xe+w==
-  dependencies:
-    "@typescript-eslint/utils" "5.31.0"
-    debug "^4.3.4"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/types@5.31.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.31.0.tgz#7aa389122b64b18e473c1672fb3b8310e5f07a9a"
-  integrity sha512-/f/rMaEseux+I4wmR6mfpM2wvtNZb1p9hAV77hWfuKc3pmaANp5dLAZSiE3/8oXTYTt3uV9KW5yZKJsMievp6g==
-
-"@typescript-eslint/typescript-estree@5.31.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.31.0.tgz#eb92970c9d6e3946690d50c346fb9b1d745ee882"
-  integrity sha512-3S625TMcARX71wBc2qubHaoUwMEn+l9TCsaIzYI/ET31Xm2c9YQ+zhGgpydjorwQO9pLfR/6peTzS/0G3J/hDw==
-  dependencies:
-    "@typescript-eslint/types" "5.31.0"
-    "@typescript-eslint/visitor-keys" "5.31.0"
-    debug "^4.3.4"
-    globby "^11.1.0"
-    is-glob "^4.0.3"
-    semver "^7.3.7"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/utils@5.31.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.31.0.tgz#e146fa00dca948bfe547d665b2138a2dc1b79acd"
-  integrity sha512-kcVPdQS6VIpVTQ7QnGNKMFtdJdvnStkqS5LeALr4rcwx11G6OWb2HB17NMPnlRHvaZP38hL9iK8DdE9Fne7NYg==
-  dependencies:
-    "@types/json-schema" "^7.0.9"
-    "@typescript-eslint/scope-manager" "5.31.0"
-    "@typescript-eslint/types" "5.31.0"
-    "@typescript-eslint/typescript-estree" "5.31.0"
-    eslint-scope "^5.1.1"
-    eslint-utils "^3.0.0"
-
-"@typescript-eslint/visitor-keys@5.31.0":
-  version "5.31.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.31.0.tgz#b0eca264df01ce85dceb76aebff3784629258f54"
-  integrity sha512-ZK0jVxSjS4gnPirpVjXHz7mgdOsZUHzNYSfTw2yPa3agfbt9YfqaBiBZFSSxeBWnpWkzCxTfUpnzA3Vily/CSg==
-  dependencies:
-    "@typescript-eslint/types" "5.31.0"
-    eslint-visitor-keys "^3.3.0"
-
-"@vitejs/plugin-vue@^3.0.0":
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/@vitejs/plugin-vue/-/plugin-vue-3.0.1.tgz#b6af8f782485374bbb5fe09edf067a845bf4caae"
-  integrity sha512-Ll9JgxG7ONIz/XZv3dssfoMUDu9qAnlJ+km+pBA0teYSXzwPCIzS/e1bmwNYl5dcQGs677D21amgfYAnzMl17A==
-
-"@volar/code-gen@0.38.9":
-  version "0.38.9"
-  resolved "https://registry.yarnpkg.com/@volar/code-gen/-/code-gen-0.38.9.tgz#8fed2c6a472c8f11ce695b08789bcc22b08e7fa6"
-  integrity sha512-n6LClucfA+37rQeskvh9vDoZV1VvCVNy++MAPKj2dT4FT+Fbmty/SDQqnsEBtdEe6E3OQctFvA/IcKsx3Mns0A==
-  dependencies:
-    "@volar/source-map" "0.38.9"
-
-"@volar/source-map@0.38.9":
-  version "0.38.9"
-  resolved "https://registry.yarnpkg.com/@volar/source-map/-/source-map-0.38.9.tgz#935d6def4b4342e8e2d63cd8e6bf9bf1155c58d8"
-  integrity sha512-ba0UFoHDYry+vwKdgkWJ6xlQT+8TFtZg1zj9tSjj4PykW1JZDuM0xplMotLun4h3YOoYfY9K1huY5gvxmrNLIw==
-
-"@volar/vue-code-gen@0.38.9":
-  version "0.38.9"
-  resolved "https://registry.yarnpkg.com/@volar/vue-code-gen/-/vue-code-gen-0.38.9.tgz#878f00fec82a2fc300396d70e26b0ea29952f740"
-  integrity sha512-tzj7AoarFBKl7e41MR006ncrEmNPHALuk8aG4WdDIaG387X5//5KhWC5Ff3ZfB2InGSeNT+CVUd74M0gS20rjA==
-  dependencies:
-    "@volar/code-gen" "0.38.9"
-    "@volar/source-map" "0.38.9"
-    "@vue/compiler-core" "^3.2.37"
-    "@vue/compiler-dom" "^3.2.37"
-    "@vue/shared" "^3.2.37"
-
-"@volar/vue-typescript@0.38.9":
-  version "0.38.9"
-  resolved "https://registry.yarnpkg.com/@volar/vue-typescript/-/vue-typescript-0.38.9.tgz#e5dfdc6f0d6dbea683647cd477fafbd483983b35"
-  integrity sha512-iJMQGU91ADi98u8V1vXd2UBmELDAaeSP0ZJaFjwosClQdKlJQYc6MlxxKfXBZisHqfbhdtrGRyaryulnYtliZw==
-  dependencies:
-    "@volar/code-gen" "0.38.9"
-    "@volar/source-map" "0.38.9"
-    "@volar/vue-code-gen" "0.38.9"
-    "@vue/compiler-sfc" "^3.2.37"
-    "@vue/reactivity" "^3.2.37"
-
-"@vue/compiler-core@3.2.37", "@vue/compiler-core@^3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/compiler-core/-/compiler-core-3.2.37.tgz#b3c42e04c0e0f2c496ff1784e543fbefe91e215a"
-  integrity sha512-81KhEjo7YAOh0vQJoSmAD68wLfYqJvoiD4ulyedzF+OEk/bk6/hx3fTNVfuzugIIaTrOx4PGx6pAiBRe5e9Zmg==
-  dependencies:
-    "@babel/parser" "^7.16.4"
-    "@vue/shared" "3.2.37"
-    estree-walker "^2.0.2"
-    source-map "^0.6.1"
-
-"@vue/compiler-dom@3.2.37", "@vue/compiler-dom@^3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/compiler-dom/-/compiler-dom-3.2.37.tgz#10d2427a789e7c707c872da9d678c82a0c6582b5"
-  integrity sha512-yxJLH167fucHKxaqXpYk7x8z7mMEnXOw3G2q62FTkmsvNxu4FQSu5+3UMb+L7fjKa26DEzhrmCxAgFLLIzVfqQ==
-  dependencies:
-    "@vue/compiler-core" "3.2.37"
-    "@vue/shared" "3.2.37"
-
-"@vue/compiler-sfc@3.2.37", "@vue/compiler-sfc@^3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/compiler-sfc/-/compiler-sfc-3.2.37.tgz#3103af3da2f40286edcd85ea495dcb35bc7f5ff4"
-  integrity sha512-+7i/2+9LYlpqDv+KTtWhOZH+pa8/HnX/905MdVmAcI/mPQOBwkHHIzrsEsucyOIZQYMkXUiTkmZq5am/NyXKkg==
-  dependencies:
-    "@babel/parser" "^7.16.4"
-    "@vue/compiler-core" "3.2.37"
-    "@vue/compiler-dom" "3.2.37"
-    "@vue/compiler-ssr" "3.2.37"
-    "@vue/reactivity-transform" "3.2.37"
-    "@vue/shared" "3.2.37"
-    estree-walker "^2.0.2"
-    magic-string "^0.25.7"
-    postcss "^8.1.10"
-    source-map "^0.6.1"
-
-"@vue/compiler-ssr@3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/compiler-ssr/-/compiler-ssr-3.2.37.tgz#4899d19f3a5fafd61524a9d1aee8eb0505313cff"
-  integrity sha512-7mQJD7HdXxQjktmsWp/J67lThEIcxLemz1Vb5I6rYJHR5vI+lON3nPGOH3ubmbvYGt8xEUaAr1j7/tIFWiEOqw==
-  dependencies:
-    "@vue/compiler-dom" "3.2.37"
-    "@vue/shared" "3.2.37"
-
-"@vue/eslint-config-prettier@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@vue/eslint-config-prettier/-/eslint-config-prettier-7.0.0.tgz#44ab55ca22401102b57795c59428e9dade72be34"
-  integrity sha512-/CTc6ML3Wta1tCe1gUeO0EYnVXfo3nJXsIhZ8WJr3sov+cGASr6yuiibJTL6lmIBm7GobopToOuB3B6AWyV0Iw==
-  dependencies:
-    eslint-config-prettier "^8.3.0"
-    eslint-plugin-prettier "^4.0.0"
-
-"@vue/eslint-config-typescript@^11.0.0":
-  version "11.0.0"
-  resolved "https://registry.yarnpkg.com/@vue/eslint-config-typescript/-/eslint-config-typescript-11.0.0.tgz#bac0cb2d381625b5bf568d2025acffc0fd09113e"
-  integrity sha512-txuRzxnQVmtUvvy9UyWUy9sHWXNeRPGmSPqP53hRtaiUeCTAondI9Ho9GQYI/8/eWljYOST7iA4Aa8sANBkWaA==
-  dependencies:
-    "@typescript-eslint/eslint-plugin" "^5.0.0"
-    "@typescript-eslint/parser" "^5.0.0"
-    vue-eslint-parser "^9.0.0"
-
-"@vue/reactivity-transform@3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/reactivity-transform/-/reactivity-transform-3.2.37.tgz#0caa47c4344df4ae59f5a05dde2a8758829f8eca"
-  integrity sha512-IWopkKEb+8qpu/1eMKVeXrK0NLw9HicGviJzhJDEyfxTR9e1WtpnnbYkJWurX6WwoFP0sz10xQg8yL8lgskAZg==
-  dependencies:
-    "@babel/parser" "^7.16.4"
-    "@vue/compiler-core" "3.2.37"
-    "@vue/shared" "3.2.37"
-    estree-walker "^2.0.2"
-    magic-string "^0.25.7"
-
-"@vue/reactivity@3.2.37", "@vue/reactivity@^3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/reactivity/-/reactivity-3.2.37.tgz#5bc3847ac58828e2b78526e08219e0a1089f8848"
-  integrity sha512-/7WRafBOshOc6m3F7plwzPeCu/RCVv9uMpOwa/5PiY1Zz+WLVRWiy0MYKwmg19KBdGtFWsmZ4cD+LOdVPcs52A==
-  dependencies:
-    "@vue/shared" "3.2.37"
-
-"@vue/runtime-core@3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/runtime-core/-/runtime-core-3.2.37.tgz#7ba7c54bb56e5d70edfc2f05766e1ca8519966e3"
-  integrity sha512-JPcd9kFyEdXLl/i0ClS7lwgcs0QpUAWj+SKX2ZC3ANKi1U4DOtiEr6cRqFXsPwY5u1L9fAjkinIdB8Rz3FoYNQ==
-  dependencies:
-    "@vue/reactivity" "3.2.37"
-    "@vue/shared" "3.2.37"
-
-"@vue/runtime-dom@3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/runtime-dom/-/runtime-dom-3.2.37.tgz#002bdc8228fa63949317756fb1e92cdd3f9f4bbd"
-  integrity sha512-HimKdh9BepShW6YozwRKAYjYQWg9mQn63RGEiSswMbW+ssIht1MILYlVGkAGGQbkhSh31PCdoUcfiu4apXJoPw==
-  dependencies:
-    "@vue/runtime-core" "3.2.37"
-    "@vue/shared" "3.2.37"
-    csstype "^2.6.8"
-
-"@vue/server-renderer@3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/server-renderer/-/server-renderer-3.2.37.tgz#840a29c8dcc29bddd9b5f5ffa22b95c0e72afdfc"
-  integrity sha512-kLITEJvaYgZQ2h47hIzPh2K3jG8c1zCVbp/o/bzQOyvzaKiCquKS7AaioPI28GNxIsE/zSx+EwWYsNxDCX95MA==
-  dependencies:
-    "@vue/compiler-ssr" "3.2.37"
-    "@vue/shared" "3.2.37"
-
-"@vue/shared@3.2.37", "@vue/shared@^3.2.37":
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/@vue/shared/-/shared-3.2.37.tgz#8e6adc3f2759af52f0e85863dfb0b711ecc5c702"
-  integrity sha512-4rSJemR2NQIo9Klm1vabqWjD8rs/ZaJSzMxkMNeJS6lHiUjjUeYFbooN19NgFjztubEKh3WlZUeOLVdbbUWHsw==
-
-abort-controller-x@^0.2.6:
-  version "0.2.7"
-  resolved "https://registry.yarnpkg.com/abort-controller-x/-/abort-controller-x-0.2.7.tgz#6fa9be5b278b9c533d4d078d0ba660d40683907e"
-  integrity sha512-hq/lt8yODKrwuZa69GhSTl2l2kcrus2khZ7OjD6Bmqmx6tbW6dnV8cVGnkkdLCWnjXpgSx8zjQo+HUc9mvoQ/w==
-  dependencies:
-    node-abort-controller "^1.2.1 || ^2.0.0"
-
-acorn-jsx@^5.3.2:
-  version "5.3.2"
-  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
-  integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
-
-acorn@^8.7.1:
-  version "8.8.0"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.0.tgz#88c0187620435c7f6015803f5539dae05a9dbea8"
-  integrity sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==
-
-ajv@^6.10.0, ajv@^6.12.4:
-  version "6.12.6"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
-  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
-  dependencies:
-    fast-deep-equal "^3.1.1"
-    fast-json-stable-stringify "^2.0.0"
-    json-schema-traverse "^0.4.1"
-    uri-js "^4.2.2"
-
-ansi-regex@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
-  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
-
-ansi-styles@^4.1.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
-  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
-  dependencies:
-    color-convert "^2.0.1"
-
-argparse@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
-  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
-
-array-union@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
-  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
-
-balanced-match@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
-  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
-
-boolbase@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz#68dff5fbe60c51eb37725ea9e3ed310dcc1e776e"
-  integrity sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==
-
-brace-expansion@^1.1.7:
-  version "1.1.11"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
-  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
-  dependencies:
-    balanced-match "^1.0.0"
-    concat-map "0.0.1"
-
-braces@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
-  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
-  dependencies:
-    fill-range "^7.0.1"
-
-browser-headers@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/browser-headers/-/browser-headers-0.4.1.tgz#4308a7ad3b240f4203dbb45acedb38dc2d65dd02"
-  integrity sha512-CA9hsySZVo9371qEHjHZtYxV2cFtVj5Wj/ZHi8ooEsrtm4vOnl9Y9HmyYWk9q+05d7K3rdoAE0j3MVEFVvtQtg==
-
-callsites@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
-  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
-
-chalk@^4.0.0:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
-  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-color-convert@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
-  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
-  dependencies:
-    color-name "~1.1.4"
-
-color-name@~1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
-  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
-
-concat-map@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
-  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
-
-cross-spawn@^7.0.2:
-  version "7.0.3"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
-  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
-  dependencies:
-    path-key "^3.1.0"
-    shebang-command "^2.0.0"
-    which "^2.0.1"
-
-cssesc@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz#37741919903b868565e1c09ea747445cd18983ee"
-  integrity sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==
-
-csstype@^2.6.8:
-  version "2.6.20"
-  resolved "https://registry.yarnpkg.com/csstype/-/csstype-2.6.20.tgz#9229c65ea0b260cf4d3d997cb06288e36a8d6dda"
-  integrity sha512-/WwNkdXfckNgw6S5R125rrW8ez139lBHWouiBvX8dfMFtcn6V81REDqnH7+CRpRipfYlyU1CmOnOxrmGcFOjeA==
-
-debug@^4.1.1, debug@^4.3.2, debug@^4.3.4:
-  version "4.3.4"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
-  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
-  dependencies:
-    ms "2.1.2"
-
-deep-is@^0.1.3:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
-  integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
-
-dir-glob@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
-  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
-  dependencies:
-    path-type "^4.0.0"
-
-doctrine@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
-  integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
-  dependencies:
-    esutils "^2.0.2"
-
-esbuild-android-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-android-64/-/esbuild-android-64-0.14.50.tgz#a46fc80fa2007690e647680d837483a750a3097f"
-  integrity sha512-H7iUEm7gUJHzidsBlFPGF6FTExazcgXL/46xxLo6i6bMtPim6ZmXyTccS8yOMpy6HAC6dPZ/JCQqrkkin69n6Q==
-
-esbuild-android-arm64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-android-arm64/-/esbuild-android-arm64-0.14.50.tgz#bdda7851fa7f5f770d6ff0ad593a8945d3a0fcdd"
-  integrity sha512-NFaoqEwa+OYfoYVpQWDMdKII7wZZkAjtJFo1WdnBeCYlYikvUhTnf2aPwPu5qEAw/ie1NYK0yn3cafwP+kP+OQ==
-
-esbuild-darwin-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-darwin-64/-/esbuild-darwin-64-0.14.50.tgz#f0535435f9760766f30db14a991ee5ca94c022a4"
-  integrity sha512-gDQsCvGnZiJv9cfdO48QqxkRV8oKAXgR2CGp7TdIpccwFdJMHf8hyIJhMW/05b/HJjET/26Us27Jx91BFfEVSA==
-
-esbuild-darwin-arm64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.14.50.tgz#76a41a40e8947a15ae62970e9ed2853883c4b16c"
-  integrity sha512-36nNs5OjKIb/Q50Sgp8+rYW/PqirRiFN0NFc9hEvgPzNJxeJedktXwzfJSln4EcRFRh5Vz4IlqFRScp+aiBBzA==
-
-esbuild-freebsd-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-freebsd-64/-/esbuild-freebsd-64-0.14.50.tgz#2ed6633c17ed42c20a1bd68e82c4bbc75ea4fb57"
-  integrity sha512-/1pHHCUem8e/R86/uR+4v5diI2CtBdiWKiqGuPa9b/0x3Nwdh5AOH7lj+8823C6uX1e0ufwkSLkS+aFZiBCWxA==
-
-esbuild-freebsd-arm64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.14.50.tgz#cb115f4cdafe9cdbe58875ba482fccc54d32aa43"
-  integrity sha512-iKwUVMQztnPZe5pUYHdMkRc9aSpvoV1mkuHlCoPtxZA3V+Kg/ptpzkcSY+fKd0kuom+l6Rc93k0UPVkP7xoqrw==
-
-esbuild-linux-32@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-32/-/esbuild-linux-32-0.14.50.tgz#fe2b724994dcf1d4e48dc4832ff008ad7d00bcfd"
-  integrity sha512-sWUwvf3uz7dFOpLzYuih+WQ7dRycrBWHCdoXJ4I4XdMxEHCECd8b7a9N9u7FzT6XR2gHPk9EzvchQUtiEMRwqw==
-
-esbuild-linux-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-64/-/esbuild-linux-64-0.14.50.tgz#7851ab5151df9501a2187bd4909c594ad232b623"
-  integrity sha512-u0PQxPhaeI629t4Y3EEcQ0wmWG+tC/LpP2K7yDFvwuPq0jSQ8SIN+ARNYfRjGW15O2we3XJvklbGV0wRuUCPig==
-
-esbuild-linux-arm64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-arm64/-/esbuild-linux-arm64-0.14.50.tgz#76a76afef484a0512f1fbbcc762edd705dee8892"
-  integrity sha512-ZyfoNgsTftD7Rp5S7La5auomKdNeB3Ck+kSKXC4pp96VnHyYGjHHXWIlcbH8i+efRn9brszo1/Thl1qn8RqmhQ==
-
-esbuild-linux-arm@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-arm/-/esbuild-linux-arm-0.14.50.tgz#6d7a8c0712091b0c3a668dd5d8b5c924adbaeb12"
-  integrity sha512-VALZq13bhmFJYFE/mLEb+9A0w5vo8z+YDVOWeaf9vOTrSC31RohRIwtxXBnVJ7YKLYfEMzcgFYf+OFln3Y0cWg==
-
-esbuild-linux-mips64le@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.14.50.tgz#43426909c1884c5dc6b40765673a08a7ec1d2064"
-  integrity sha512-ygo31Vxn/WrmjKCHkBoutOlFG5yM9J2UhzHb0oWD9O61dGg+Hzjz9hjf5cmM7FBhAzdpOdEWHIrVOg2YAi6rTw==
-
-esbuild-linux-ppc64le@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.14.50.tgz#c754ea3da1dd180c6e9b6b508dc18ce983d92b11"
-  integrity sha512-xWCKU5UaiTUT6Wz/O7GKP9KWdfbsb7vhfgQzRfX4ahh5NZV4ozZ4+SdzYG8WxetsLy84UzLX3Pi++xpVn1OkFQ==
-
-esbuild-linux-riscv64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.14.50.tgz#f3b2dd3c4c2b91bf191d3b98a9819c8aa6f5ad7f"
-  integrity sha512-0+dsneSEihZTopoO9B6Z6K4j3uI7EdxBP7YSF5rTwUgCID+wHD3vM1gGT0m+pjCW+NOacU9kH/WE9N686FHAJg==
-
-esbuild-linux-s390x@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-linux-s390x/-/esbuild-linux-s390x-0.14.50.tgz#3dfbc4578b2a81995caabb79df2b628ea86a5390"
-  integrity sha512-tVjqcu8o0P9H4StwbIhL1sQYm5mWATlodKB6dpEZFkcyTI8kfIGWiWcrGmkNGH2i1kBUOsdlBafPxR3nzp3TDA==
-
-esbuild-netbsd-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-netbsd-64/-/esbuild-netbsd-64-0.14.50.tgz#17dbf51eaa48d983e794b588d195415410ef8c85"
-  integrity sha512-0R/glfqAQ2q6MHDf7YJw/TulibugjizBxyPvZIcorH0Mb7vSimdHy0XF5uCba5CKt+r4wjax1mvO9lZ4jiAhEg==
-
-esbuild-openbsd-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-openbsd-64/-/esbuild-openbsd-64-0.14.50.tgz#cf6b1a50c8cf67b0725aaa4bce9773976168c50e"
-  integrity sha512-7PAtmrR5mDOFubXIkuxYQ4bdNS6XCK8AIIHUiZxq1kL8cFIH5731jPcXQ4JNy/wbj1C9sZ8rzD8BIM80Tqk29w==
-
-esbuild-sunos-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-sunos-64/-/esbuild-sunos-64-0.14.50.tgz#f705ae0dd914c3b45dc43319c4f532216c3d841f"
-  integrity sha512-gBxNY/wyptvD7PkHIYcq7se6SQEXcSC8Y7mE0FJB+CGgssEWf6vBPfTTZ2b6BWKnmaP6P6qb7s/KRIV5T2PxsQ==
-
-esbuild-windows-32@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-windows-32/-/esbuild-windows-32-0.14.50.tgz#6364905a99c1e6c1e2fe7bfccebd958131b1cd6c"
-  integrity sha512-MOOe6J9cqe/iW1qbIVYSAqzJFh0p2LBLhVUIWdMVnNUNjvg2/4QNX4oT4IzgDeldU+Bym9/Tn6+DxvUHJXL5Zw==
-
-esbuild-windows-64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-windows-64/-/esbuild-windows-64-0.14.50.tgz#56603cb6367e30d14098deb77de6aa18d76dd89b"
-  integrity sha512-r/qE5Ex3w1jjGv/JlpPoWB365ldkppUlnizhMxJgojp907ZF1PgLTuW207kgzZcSCXyquL9qJkMsY+MRtaZ5yQ==
-
-esbuild-windows-arm64@0.14.50:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild-windows-arm64/-/esbuild-windows-arm64-0.14.50.tgz#e7ddde6a97194051a5a4ac05f4f5900e922a7ea5"
-  integrity sha512-EMS4lQnsIe12ZyAinOINx7eq2mjpDdhGZZWDwPZE/yUTN9cnc2Ze/xUTYIAyaJqrqQda3LnDpADKpvLvol6ENQ==
-
-esbuild@^0.14.47:
-  version "0.14.50"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.14.50.tgz#7a665392c8df94bf6e1ae1e999966a5ee62c6cbc"
-  integrity sha512-SbC3k35Ih2IC6trhbMYW7hYeGdjPKf9atTKwBUHqMCYFZZ9z8zhuvfnZihsnJypl74FjiAKjBRqFkBkAd0rS/w==
-  optionalDependencies:
-    esbuild-android-64 "0.14.50"
-    esbuild-android-arm64 "0.14.50"
-    esbuild-darwin-64 "0.14.50"
-    esbuild-darwin-arm64 "0.14.50"
-    esbuild-freebsd-64 "0.14.50"
-    esbuild-freebsd-arm64 "0.14.50"
-    esbuild-linux-32 "0.14.50"
-    esbuild-linux-64 "0.14.50"
-    esbuild-linux-arm "0.14.50"
-    esbuild-linux-arm64 "0.14.50"
-    esbuild-linux-mips64le "0.14.50"
-    esbuild-linux-ppc64le "0.14.50"
-    esbuild-linux-riscv64 "0.14.50"
-    esbuild-linux-s390x "0.14.50"
-    esbuild-netbsd-64 "0.14.50"
-    esbuild-openbsd-64 "0.14.50"
-    esbuild-sunos-64 "0.14.50"
-    esbuild-windows-32 "0.14.50"
-    esbuild-windows-64 "0.14.50"
-    esbuild-windows-arm64 "0.14.50"
-
-escape-string-regexp@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
-  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
-
-eslint-config-prettier@^8.3.0:
-  version "8.5.0"
-  resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-8.5.0.tgz#5a81680ec934beca02c7b1a61cf8ca34b66feab1"
-  integrity sha512-obmWKLUNCnhtQRKc+tmnYuQl0pFU1ibYJQ5BGhTVB08bHe9wC8qUeG7c08dj9XX+AuPj1YSGSQIHl1pnDHZR0Q==
-
-eslint-plugin-prettier@^4.0.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-4.2.1.tgz#651cbb88b1dab98bfd42f017a12fa6b2d993f94b"
-  integrity sha512-f/0rXLXUt0oFYs8ra4w49wYZBG5GKZpAYsJSm6rnYL5uVDjd+zowwMwVZHnAjf4edNrKpCDYfXDgmRE/Ak7QyQ==
-  dependencies:
-    prettier-linter-helpers "^1.0.0"
-
-eslint-plugin-vue@^9.3.0:
-  version "9.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-vue/-/eslint-plugin-vue-9.3.0.tgz#c3f5ce515dae387e062428725c5cf96098d9da0b"
-  integrity sha512-iscKKkBZgm6fGZwFt6poRoWC0Wy2dQOlwUPW++CiPoQiw1enctV2Hj5DBzzjJZfyqs+FAXhgzL4q0Ww03AgSmQ==
-  dependencies:
-    eslint-utils "^3.0.0"
-    natural-compare "^1.4.0"
-    nth-check "^2.0.1"
-    postcss-selector-parser "^6.0.9"
-    semver "^7.3.5"
-    vue-eslint-parser "^9.0.1"
-    xml-name-validator "^4.0.0"
-
-eslint-scope@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
-  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^4.1.1"
-
-eslint-scope@^7.1.1:
-  version "7.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.1.1.tgz#fff34894c2f65e5226d3041ac480b4513a163642"
-  integrity sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^5.2.0"
-
-eslint-utils@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672"
-  integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==
-  dependencies:
-    eslint-visitor-keys "^2.0.0"
-
-eslint-visitor-keys@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303"
-  integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==
-
-eslint-visitor-keys@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826"
-  integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==
-
-eslint@^8.20.0:
-  version "8.20.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.20.0.tgz#048ac56aa18529967da8354a478be4ec0a2bc81b"
-  integrity sha512-d4ixhz5SKCa1D6SCPrivP7yYVi7nyD6A4vs6HIAul9ujBzcEmZVM3/0NN/yu5nKhmO1wjp5xQ46iRfmDGlOviA==
-  dependencies:
-    "@eslint/eslintrc" "^1.3.0"
-    "@humanwhocodes/config-array" "^0.9.2"
-    ajv "^6.10.0"
-    chalk "^4.0.0"
-    cross-spawn "^7.0.2"
-    debug "^4.3.2"
-    doctrine "^3.0.0"
-    escape-string-regexp "^4.0.0"
-    eslint-scope "^7.1.1"
-    eslint-utils "^3.0.0"
-    eslint-visitor-keys "^3.3.0"
-    espree "^9.3.2"
-    esquery "^1.4.0"
-    esutils "^2.0.2"
-    fast-deep-equal "^3.1.3"
-    file-entry-cache "^6.0.1"
-    functional-red-black-tree "^1.0.1"
-    glob-parent "^6.0.1"
-    globals "^13.15.0"
-    ignore "^5.2.0"
-    import-fresh "^3.0.0"
-    imurmurhash "^0.1.4"
-    is-glob "^4.0.0"
-    js-yaml "^4.1.0"
-    json-stable-stringify-without-jsonify "^1.0.1"
-    levn "^0.4.1"
-    lodash.merge "^4.6.2"
-    minimatch "^3.1.2"
-    natural-compare "^1.4.0"
-    optionator "^0.9.1"
-    regexpp "^3.2.0"
-    strip-ansi "^6.0.1"
-    strip-json-comments "^3.1.0"
-    text-table "^0.2.0"
-    v8-compile-cache "^2.0.3"
-
-espree@^9.3.1, espree@^9.3.2:
-  version "9.3.2"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-9.3.2.tgz#f58f77bd334731182801ced3380a8cc859091596"
-  integrity sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA==
-  dependencies:
-    acorn "^8.7.1"
-    acorn-jsx "^5.3.2"
-    eslint-visitor-keys "^3.3.0"
-
-esquery@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5"
-  integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==
-  dependencies:
-    estraverse "^5.1.0"
-
-esrecurse@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
-  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
-  dependencies:
-    estraverse "^5.2.0"
-
-estraverse@^4.1.1:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
-  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
-
-estraverse@^5.1.0, estraverse@^5.2.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
-  integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
-
-estree-walker@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
-  integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
-
-esutils@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
-  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
-
-fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
-  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
-
-fast-diff@^1.1.2:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.2.0.tgz#73ee11982d86caaf7959828d519cfe927fac5f03"
-  integrity sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==
-
-fast-glob@^3.2.9:
-  version "3.2.11"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.11.tgz#a1172ad95ceb8a16e20caa5c5e56480e5129c1d9"
-  integrity sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.2"
-    merge2 "^1.3.0"
-    micromatch "^4.0.4"
-
-fast-json-stable-stringify@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
-  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
-
-fast-levenshtein@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
-  integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==
-
-fastq@^1.6.0:
-  version "1.13.0"
-  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.13.0.tgz#616760f88a7526bdfc596b7cab8c18938c36b98c"
-  integrity sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==
-  dependencies:
-    reusify "^1.0.4"
-
-file-entry-cache@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
-  integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
-  dependencies:
-    flat-cache "^3.0.4"
-
-fill-range@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
-  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
-  dependencies:
-    to-regex-range "^5.0.1"
-
-flat-cache@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11"
-  integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
-  dependencies:
-    flatted "^3.1.0"
-    rimraf "^3.0.2"
-
-flatted@^3.1.0:
-  version "3.2.6"
-  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.6.tgz#022e9218c637f9f3fc9c35ab9c9193f05add60b2"
-  integrity sha512-0sQoMh9s0BYsm+12Huy/rkKxVu4R1+r96YX5cG44rHV0pQ6iC3Q+mkoMFaGWObMFYQxCVT+ssG1ksneA2MI9KQ==
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
-  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
-
-fsevents@~2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
-  integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
-
-function-bind@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
-  integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
-
-functional-red-black-tree@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
-  integrity sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g==
-
-glob-parent@^5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
-  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
-  dependencies:
-    is-glob "^4.0.1"
-
-glob-parent@^6.0.1:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
-  integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
-  dependencies:
-    is-glob "^4.0.3"
-
-glob@^7.1.3:
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
-  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.1.1"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-globals@^13.15.0:
-  version "13.17.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-13.17.0.tgz#902eb1e680a41da93945adbdcb5a9f361ba69bd4"
-  integrity sha512-1C+6nQRb1GwGMKm2dH/E7enFAMxGTmGI7/dEdhy/DNelv85w9B72t3uc5frtMNXIbzrarJJ/lTCjcaZwbLJmyw==
-  dependencies:
-    type-fest "^0.20.2"
-
-globby@^11.1.0:
-  version "11.1.0"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
-  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.2.9"
-    ignore "^5.2.0"
-    merge2 "^1.4.1"
-    slash "^3.0.0"
-
-google-protobuf@^3.20.1:
-  version "3.20.1"
-  resolved "https://registry.yarnpkg.com/google-protobuf/-/google-protobuf-3.20.1.tgz#1b255c2b59bcda7c399df46c65206aa3c7a0ce8b"
-  integrity sha512-XMf1+O32FjYIV3CYu6Tuh5PNbfNEU5Xu22X+Xkdb/DUexFlCzhvv7d5Iirm4AOwn8lv4al1YvIhzGrg2j9Zfzw==
-
-has-flag@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
-  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
-
-has@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
-  integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
-  dependencies:
-    function-bind "^1.1.1"
-
-ignore@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.0.tgz#6d3bac8fa7fe0d45d9f9be7bac2fc279577e345a"
-  integrity sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==
-
-import-fresh@^3.0.0, import-fresh@^3.2.1:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
-  dependencies:
-    parent-module "^1.0.0"
-    resolve-from "^4.0.0"
-
-imurmurhash@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
-  integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
-
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
-  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
-  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
-
-is-core-module@^2.9.0:
-  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.9.0.tgz#e1c34429cd51c6dd9e09e0799e396e27b19a9c69"
-  integrity sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==
-  dependencies:
-    has "^1.0.3"
-
-is-extglob@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
-  integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
-
-is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
-  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
-  dependencies:
-    is-extglob "^2.1.1"
-
-is-number@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
-  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
-
-isexe@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
-  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
-
-js-base64@^3.7.2:
-  version "3.7.2"
-  resolved "https://registry.yarnpkg.com/js-base64/-/js-base64-3.7.2.tgz#816d11d81a8aff241603d19ce5761e13e41d7745"
-  integrity sha512-NnRs6dsyqUXejqk/yv2aiXlAvOs56sLkX6nUdeaNezI5LFFLlsZjOThmwnrcwh5ZZRwZlCMnVAY3CvhIhoVEKQ==
-
-js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
-  dependencies:
-    argparse "^2.0.1"
-
-json-schema-traverse@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
-  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
-
-json-stable-stringify-without-jsonify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
-  integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
-
-levn@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
-  integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
-  dependencies:
-    prelude-ls "^1.2.1"
-    type-check "~0.4.0"
-
-lodash.merge@^4.6.2:
-  version "4.6.2"
-  resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
-  integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
-
-lodash@^4.17.21:
-  version "4.17.21"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
-  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
-
-long@^5.0.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/long/-/long-5.2.0.tgz#2696dadf4b4da2ce3f6f6b89186085d94d52fd61"
-  integrity sha512-9RTUNjK60eJbx3uz+TEGF7fUr29ZDxR5QzXcyDpeSfeH28S9ycINflOgOlppit5U+4kNTe83KQnMEerw7GmE8w==
-
-lru-cache@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
-  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
-  dependencies:
-    yallist "^4.0.0"
-
-magic-string@^0.25.7:
-  version "0.25.9"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.9.tgz#de7f9faf91ef8a1c91d02c2e5314c8277dbcdd1c"
-  integrity sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==
-  dependencies:
-    sourcemap-codec "^1.4.8"
-
-merge2@^1.3.0, merge2@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
-  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
-
-micromatch@^4.0.4:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
-  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
-  dependencies:
-    braces "^3.0.2"
-    picomatch "^2.3.1"
-
-minimatch@^3.0.4, minimatch@^3.1.1, minimatch@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
-  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-ms@2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
-  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
-
-nanoid@^3.3.4:
-  version "3.3.4"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.4.tgz#730b67e3cd09e2deacf03c027c81c9d9dbc5e8ab"
-  integrity sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==
-
-natural-compare@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
-  integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
-
-nice-grpc-common@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/nice-grpc-common/-/nice-grpc-common-1.1.0.tgz#cebfd36f840c08f253ddf6de6ed4389fa5cdb05b"
-  integrity sha512-klxJ/lxMyH1KkT02woMBWL3A7BQSTH5jGodJIpNbbv7WKeFBWJaEtT6p7kZJBhGYXtSsQ+TyMU1EJR9BH14YfQ==
-  dependencies:
-    node-abort-controller "^2.0.0"
-    ts-error "^1.0.6"
-
-nice-grpc-web@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/nice-grpc-web/-/nice-grpc-web-1.1.0.tgz#e057697afb91dad2c5776aab220ed600385c58a9"
-  integrity sha512-EqSuzDdNS2ABS2Hy7SRfdxZCsRibJtuy6oynn2MRNizKk+hLtI0YPMeJ2kRrOdYS4rsJgdM02nLXyVcYl4grkw==
-  dependencies:
-    "@improbable-eng/grpc-web" "^0.15.0"
-    abort-controller-x "^0.2.6"
-    js-base64 "^3.7.2"
-    nice-grpc-common "^1.1.0"
-    node-abort-controller "^2.0.0"
-
-"node-abort-controller@^1.2.1 || ^2.0.0", node-abort-controller@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/node-abort-controller/-/node-abort-controller-2.0.0.tgz#800e0d250d3b977175e48df4f74c2d3960076a79"
-  integrity sha512-L8RfEgjBTHAISTuagw51PprVAqNZoG6KSB6LQ6H1bskMVkFs5E71IyjauLBv3XbuomJlguWF/VnRHdJ1gqiAqA==
-
-nth-check@^2.0.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-2.1.1.tgz#c9eab428effce36cd6b92c924bdb000ef1f1ed1d"
-  integrity sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==
-  dependencies:
-    boolbase "^1.0.0"
-
-once@^1.3.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
-  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
-  dependencies:
-    wrappy "1"
-
-optionator@^0.9.1:
-  version "0.9.1"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499"
-  integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==
-  dependencies:
-    deep-is "^0.1.3"
-    fast-levenshtein "^2.0.6"
-    levn "^0.4.1"
-    prelude-ls "^1.2.1"
-    type-check "^0.4.0"
-    word-wrap "^1.2.3"
-
-parent-module@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
-  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
-  dependencies:
-    callsites "^3.0.0"
-
-path-is-absolute@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
-  integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
-
-path-key@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
-  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
-
-path-parse@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
-  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
-
-path-type@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
-  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
-
-picocolors@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
-  integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
-
-picomatch@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
-  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
-
-postcss-selector-parser@^6.0.9:
-  version "6.0.10"
-  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz#79b61e2c0d1bfc2602d549e11d0876256f8df88d"
-  integrity sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==
-  dependencies:
-    cssesc "^3.0.0"
-    util-deprecate "^1.0.2"
-
-postcss@^8.1.10, postcss@^8.4.14:
-  version "8.4.14"
-  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.14.tgz#ee9274d5622b4858c1007a74d76e42e56fd21caf"
-  integrity sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==
-  dependencies:
-    nanoid "^3.3.4"
-    picocolors "^1.0.0"
-    source-map-js "^1.0.2"
-
-prelude-ls@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
-  integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
-
-prettier-linter-helpers@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b"
-  integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==
-  dependencies:
-    fast-diff "^1.1.2"
-
-prettier@^2.7.1:
-  version "2.7.1"
-  resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.7.1.tgz#e235806850d057f97bb08368a4f7d899f7760c64"
-  integrity sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==
-
-protobufjs@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-7.0.0.tgz#8c678e1351fd926178fce5a4213913e8d990974f"
-  integrity sha512-ffNIEm+quOcYtQvHdW406v1NQmZSuqVklxsXk076BtuFnlYZfigLU+JOMrTD8TUOyqHYbRI/fSVNvgd25YeN3w==
-  dependencies:
-    "@protobufjs/aspromise" "^1.1.2"
-    "@protobufjs/base64" "^1.1.2"
-    "@protobufjs/codegen" "^2.0.4"
-    "@protobufjs/eventemitter" "^1.1.0"
-    "@protobufjs/fetch" "^1.1.0"
-    "@protobufjs/float" "^1.0.2"
-    "@protobufjs/inquire" "^1.1.0"
-    "@protobufjs/path" "^1.1.2"
-    "@protobufjs/pool" "^1.1.0"
-    "@protobufjs/utf8" "^1.1.0"
-    "@types/long" "^4.0.1"
-    "@types/node" ">=13.7.0"
-    long "^5.0.0"
-
-punycode@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
-  integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
-
-queue-microtask@^1.2.2:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
-  integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
-
-regexpp@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2"
-  integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==
-
-resolve-from@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
-  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
-
-resolve@^1.22.1:
-  version "1.22.1"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.1.tgz#27cb2ebb53f91abb49470a928bba7558066ac177"
-  integrity sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==
-  dependencies:
-    is-core-module "^2.9.0"
-    path-parse "^1.0.7"
-    supports-preserve-symlinks-flag "^1.0.0"
-
-reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
-
-rimraf@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
-  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
-  dependencies:
-    glob "^7.1.3"
-
-rollup@^2.75.6:
-  version "2.77.2"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.77.2.tgz#6b6075c55f9cc2040a5912e6e062151e42e2c4e3"
-  integrity sha512-m/4YzYgLcpMQbxX3NmAqDvwLATZzxt8bIegO78FZLl+lAgKJBd1DRAOeEiZcKOIOPjxE6ewHWHNgGEalFXuz1g==
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-run-parallel@^1.1.9:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
-  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
-  dependencies:
-    queue-microtask "^1.2.2"
-
-semver@^7.3.5, semver@^7.3.6, semver@^7.3.7:
-  version "7.3.7"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f"
-  integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==
-  dependencies:
-    lru-cache "^6.0.0"
-
-shebang-command@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
-  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
-  dependencies:
-    shebang-regex "^3.0.0"
-
-shebang-regex@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
-  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
-
-slash@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
-  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
-
-source-map-js@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.0.2.tgz#adbc361d9c62df380125e7f161f71c826f1e490c"
-  integrity sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==
-
-source-map@^0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
-sourcemap-codec@^1.4.8:
-  version "1.4.8"
-  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
-  integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
-
-strip-ansi@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
-  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
-  dependencies:
-    ansi-regex "^5.0.1"
-
-strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
-  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
-
-supports-color@^7.1.0:
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
-  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-preserve-symlinks-flag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
-  integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
-
-text-table@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
-  integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
-
-to-regex-range@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
-  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
-  dependencies:
-    is-number "^7.0.0"
-
-ts-error@^1.0.6:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/ts-error/-/ts-error-1.0.6.tgz#277496f2a28de6c184cfce8dfd5cdd03a4e6b0fc"
-  integrity sha512-tLJxacIQUM82IR7JO1UUkKlYuUTmoY9HBJAmNWFzheSlDS5SPMcNIepejHJa4BpPQLAcbRhRf3GDJzyj6rbKvA==
-
-tslib@^1.8.1:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
-  integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
-
-tsutils@^3.21.0:
-  version "3.21.0"
-  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
-  integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
-  dependencies:
-    tslib "^1.8.1"
-
-type-check@^0.4.0, type-check@~0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
-  integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
-  dependencies:
-    prelude-ls "^1.2.1"
-
-type-fest@^0.20.2:
-  version "0.20.2"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
-  integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
-
-typescript@^4.6.4:
-  version "4.7.4"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.7.4.tgz#1a88596d1cf47d59507a1bcdfb5b9dfe4d488235"
-  integrity sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==
-
-uri-js@^4.2.2:
-  version "4.4.1"
-  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
-  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
-  dependencies:
-    punycode "^2.1.0"
-
-util-deprecate@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
-  integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
-
-v8-compile-cache@^2.0.3:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
-  integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
-
-vite@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-3.0.3.tgz#c7b2ed9505a36a04be1d5d23aea4ea6fc028043f"
-  integrity sha512-sDIpIcl3mv1NUaSzZwiXGEy1ZoWwwC2vkxUHY6yiDacR6zf//ZFuBJrozO62gedpE43pmxnLATNR5IYUdAEkMQ==
-  dependencies:
-    esbuild "^0.14.47"
-    postcss "^8.4.14"
-    resolve "^1.22.1"
-    rollup "^2.75.6"
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-vue-eslint-parser@^9.0.0, vue-eslint-parser@^9.0.1:
-  version "9.0.3"
-  resolved "https://registry.yarnpkg.com/vue-eslint-parser/-/vue-eslint-parser-9.0.3.tgz#0c17a89e0932cc94fa6a79f0726697e13bfe3c96"
-  integrity sha512-yL+ZDb+9T0ELG4VIFo/2anAOz8SvBdlqEnQnvJ3M7Scq56DvtjY0VY88bByRZB0D4J0u8olBcfrXTVONXsh4og==
-  dependencies:
-    debug "^4.3.4"
-    eslint-scope "^7.1.1"
-    eslint-visitor-keys "^3.3.0"
-    espree "^9.3.1"
-    esquery "^1.4.0"
-    lodash "^4.17.21"
-    semver "^7.3.6"
-
-vue-tsc@^0.38.4:
-  version "0.38.9"
-  resolved "https://registry.yarnpkg.com/vue-tsc/-/vue-tsc-0.38.9.tgz#9e945937667f704325328db8af1cc6bc7314b85e"
-  integrity sha512-Yoy5phgvGqyF98Fb4mYqboR4Q149jrdcGv5kSmufXJUq++RZJ2iMVG0g6zl+v3t4ORVWkQmRpsV4x2szufZ0LQ==
-  dependencies:
-    "@volar/vue-typescript" "0.38.9"
-
-vue@^3.2.37:
-  version "3.2.37"
-  resolved "https://registry.yarnpkg.com/vue/-/vue-3.2.37.tgz#da220ccb618d78579d25b06c7c21498ca4e5452e"
-  integrity sha512-bOKEZxrm8Eh+fveCqS1/NkG/n6aMidsI6hahas7pa0w/l7jkbssJVsRhVDs07IdDq7h9KHswZOgItnwJAgtVtQ==
-  dependencies:
-    "@vue/compiler-dom" "3.2.37"
-    "@vue/compiler-sfc" "3.2.37"
-    "@vue/runtime-dom" "3.2.37"
-    "@vue/server-renderer" "3.2.37"
-    "@vue/shared" "3.2.37"
-
-which@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
-  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
-  dependencies:
-    isexe "^2.0.0"
-
-word-wrap@^1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
-  integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
-
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
-  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
-
-xml-name-validator@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-4.0.0.tgz#79a006e2e63149a8600f15430f0a4725d1524835"
-  integrity sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw==
-
-yallist@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
-  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
diff --git a/go.mod b/go.mod
index 013c884..bb4f612 100644
--- a/go.mod
+++ b/go.mod
@@ -1,23 +1,115 @@
 module github.com/c4t-but-s4d/fastad
 
-go 1.21
+go 1.25.5
 
 require (
+	github.com/centrifugal/centrifuge v0.33.5
+	github.com/centrifugal/centrifuge-go v0.10.3
+	github.com/creasty/defaults v1.8.0
+	github.com/google/uuid v1.6.0
+	github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1
+	github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.2.0
 	github.com/improbable-eng/grpc-web v0.15.0
-	github.com/sirupsen/logrus v1.9.3
-	golang.org/x/net v0.15.0
-	google.golang.org/grpc v1.58.1
-	google.golang.org/protobuf v1.31.0
+	github.com/labstack/echo-contrib v0.18.0
+	github.com/labstack/echo/v4 v4.15.0
+	github.com/mitchellh/mapstructure v1.5.0
+	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10
+	github.com/prometheus/client_golang v1.23.2
+	github.com/samber/lo v1.47.0
+	github.com/sirupsen/logrus v1.9.0
+	github.com/spf13/cobra v1.10.2
+	github.com/spf13/pflag v1.0.10
+	github.com/spf13/viper v1.21.0
+	github.com/stretchr/testify v1.11.1
+	github.com/uber-go/tally/v4 v4.1.16
+	github.com/uptrace/bun v1.2.6
+	github.com/uptrace/bun/dialect/pgdialect v1.2.6
+	github.com/uptrace/bun/driver/pgdriver v1.2.6
+	github.com/urfave/cli/v2 v2.27.5
+	go.temporal.io/api v1.40.0
+	go.temporal.io/sdk v1.30.0
+	go.temporal.io/sdk/contrib/tally v0.2.0
+	go.uber.org/atomic v1.11.0
+	go.uber.org/zap v1.27.0
+	golang.org/x/net v0.49.0
+	golang.org/x/sync v0.19.0
+	google.golang.org/grpc v1.78.0
+	google.golang.org/protobuf v1.36.11
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
-	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
+	github.com/FZambia/eagle v0.1.0 // indirect
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/buger/jsonparser v1.1.1 // indirect
+	github.com/cenkalti/backoff/v4 v4.1.1 // indirect
+	github.com/centrifugal/protocol v0.13.4 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/klauspost/compress v1.17.0 // indirect
-	github.com/rs/cors v1.10.0 // indirect
-	golang.org/x/sys v0.12.0 // indirect
-	golang.org/x/text v0.13.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230913181813-007df8e322eb // indirect
-	nhooyr.io/websocket v1.8.7 // indirect
+	github.com/dolthub/maphash v0.1.0 // indirect
+	github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/gammazero/deque v0.2.1 // indirect
+	github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/mock v1.6.0 // indirect
+	github.com/gorilla/websocket v1.5.0 // indirect
+	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/jpillora/backoff v1.0.0 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/labstack/gommon v0.4.2 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/maypok86/otter v1.2.4 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/nexus-rpc/sdk-go v0.0.11 // indirect
+	github.com/pborman/uuid v1.2.1 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/common v0.67.5 // indirect
+	github.com/prometheus/procfs v0.19.2 // indirect
+	github.com/puzpuzpuz/xsync/v3 v3.4.0 // indirect
+	github.com/redis/rueidis v1.0.51 // indirect
+	github.com/robfig/cron v1.2.0 // indirect
+	github.com/rs/cors v1.7.0 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/sagikazarmark/locafero v0.11.0 // indirect
+	github.com/segmentio/asm v1.2.0 // indirect
+	github.com/segmentio/encoding v0.4.1 // indirect
+	github.com/shadowspore/fossil-delta v0.0.0-20240102155221-e3a8590b820b // indirect
+	github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
+	github.com/spf13/afero v1.15.0 // indirect
+	github.com/spf13/cast v1.10.0 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc // indirect
+	github.com/twmb/murmur3 v1.1.5 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect
+	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.9-0.20240816141633-0a40785b4f41 // indirect
+	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
+	go.uber.org/multierr v1.10.0 // indirect
+	go.yaml.in/yaml/v2 v2.4.3 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	golang.org/x/crypto v0.47.0 // indirect
+	golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect
+	golang.org/x/sys v0.40.0 // indirect
+	golang.org/x/text v0.33.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20251029180050-ab9386a59fda // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda // indirect
+	mellium.im/sasl v0.3.2 // indirect
+	nhooyr.io/websocket v1.8.6 // indirect
 )
diff --git a/go.sum b/go.sum
index f122d53..e776faa 100644
--- a/go.sum
+++ b/go.sum
@@ -3,7 +3,10 @@ cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/FZambia/eagle v0.1.0 h1:9gyX6x+xjoIfglgyPTcYm7dvY7FJ93us1QY5De4CyXA=
+github.com/FZambia/eagle v0.1.0/go.mod h1:YjGSPVkQTNcVLfzEUQJNgW9ScPR0K4u/Ky0yeFa4oDA=
 github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
 github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
@@ -13,6 +16,7 @@ github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuy
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
@@ -22,33 +26,59 @@ github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6l
 github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU=
 github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g=
+github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
+github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+github.com/cactus/go-statsd-client/statsd v0.0.0-20200423205355-cb0885a1018c/go.mod h1:l/bIBLeOl9eX+wxJAzxS4TveKRtAqlyDpHjhkfO0MEI=
+github.com/cactus/go-statsd-client/v5 v5.0.0/go.mod h1:COEvJ1E+/E2L4q6QE5CkjWPi4eeDw9maJBMIuMPBZbY=
 github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/cenkalti/backoff/v4 v4.1.1 h1:G2HAfAmvm/GcKan2oOQpBXOd2tT2G57ZnZGWa1PxPBQ=
 github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw=
-github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
-github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/centrifugal/centrifuge v0.33.5 h1:vN0iAbYar80rLw5VhTKsn/19nXiYeEXjSwy6PWLKWZU=
+github.com/centrifugal/centrifuge v0.33.5/go.mod h1:qByx68JcOJmF0svRIwcHsq8XVYsjptyTHJr/3P/JmRs=
+github.com/centrifugal/centrifuge-go v0.10.3 h1:VGr1SAHCaPtpv59g+xmdlTc/+Aq6WXxCEx/tHzjJcTg=
+github.com/centrifugal/centrifuge-go v0.10.3/go.mod h1:Y3axffakQFPLPkfvPWd980KW9T3PWSiuj74jUiyQQ4w=
+github.com/centrifugal/protocol v0.13.4 h1:I0YxXtFNfn/ndDIZp5RkkqQcSSNH7DNPUbXKYtJXDzs=
+github.com/centrifugal/protocol v0.13.4/go.mod h1:7V5vI30VcoxJe4UD87xi7bOsvI0bmEhvbQuMjrFM2L4=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
 github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.6 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0=
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/creasty/defaults v1.8.0 h1:z27FJxCAa0JKt3utc0sCImAEb+spPucmKoOdLHvHYKk=
+github.com/creasty/defaults v1.8.0/go.mod h1:iGzKe6pbEHnpMPtfDXZEr0NVxWnPTjb1bbDy08fPzYM=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f h1:U5y3Y5UE0w7amNe7Z5G/twsBW0KEalRQXZzf8ufSh9I=
 github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f/go.mod h1:xH/i4TFMt8koVQZ6WFms69WAsDWr2XsYL3Hkl7jkoLE=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dolthub/maphash v0.1.0 h1:bsQ7JsF4FkkWyrP3oCnFJgrCUAFbFf3kOl4L/QxPDyQ=
+github.com/dolthub/maphash v0.1.0/go.mod h1:gkg4Ch4CdCDu5h6PMriVLawB7koZ+5ijb9puGMV50a4=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
@@ -58,11 +88,21 @@ github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4s
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a h1:yDWHCSQ40h88yih2JAcL6Ls/kVkSE8GFACTGVnMPruw=
+github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a/go.mod h1:7Ga40egUymuWXxAe151lTNnCv97MddSOVsjpPPkityA=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4=
 github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/gammazero/deque v0.2.1 h1:qSdsbG6pgp6nL7A0+K/B7s12mcCY/5l5SIUpMOl+dC0=
+github.com/gammazero/deque v0.2.1/go.mod h1:LFroj8x4cMYCukHJDbxFCkT+r9AndaJnFMuZDV34tuU=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
@@ -72,9 +112,14 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
@@ -84,20 +129,29 @@ github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1
 github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro=
+github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
 github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
 github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
 github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
 github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
 github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
 github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
+github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -112,8 +166,9 @@ github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QD
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
@@ -122,23 +177,40 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+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/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
-github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
 github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-middleware v1.2.2/go.mod h1:EaizFBKfUKtMIF5iaDEhniwNedqGo9FuLFzppDr3uwI=
+github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8=
+github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1 h1:qnpSQwGEnkcRpTqNOIR6bJbR0gAorgP9CSALpRcKoAA=
+github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1/go.mod h1:lXGCsh6c22WGtjr+qGHj1otzZpV/1kwTMAqkwZsnWRU=
+github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.2.0 h1:kQ0NI7W1B3HwiN5gAYtY+XFItDPbLBwYRxAqbFTyDes=
+github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.2.0/go.mod h1:zrT2dxOAjNFPRGjTUe2Xmb4q4YdUwVvQFV6xiCSf+z0=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I=
 github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
 github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -164,43 +236,73 @@ github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmK
 github.com/improbable-eng/grpc-web v0.15.0 h1:BN+7z6uNXZ1tQGcNAuaU1YjsLTApzkjt2tzCixLaUPQ=
 github.com/improbable-eng/grpc-web v0.15.0/go.mod h1:1sy9HKV4Jt9aEs9JSnkWlRJPuPtwNr0l57L4f878wP8=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.17.0 h1:Rnbp4K9EjcDuVuHtd0dgA4qNuv9yKDYKK1ulpJwgrqM=
-github.com/klauspost/compress v1.17.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/labstack/echo-contrib v0.18.0 h1:mgn4sdnEUUxH7E3bDGplIKkZ+syDZvafbIhuf7hPs3I=
+github.com/labstack/echo-contrib v0.18.0/go.mod h1:8r/++U/Fw/QniApFnzunLanKaviPfBX7fX7/2QX0qOk=
+github.com/labstack/echo/v4 v4.15.0 h1:hoRTKWcnR5STXZFe9BmYun9AMTNeSbjHi2vtDuADJ24=
+github.com/labstack/echo/v4 v4.15.0/go.mod h1:xmw1clThob0BSVRX1CRQkGQ/vjwcpOMjQZSZa9fKA/c=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
 github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
 github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/maypok86/otter v1.2.4 h1:HhW1Pq6VdJkmWwcZZq19BlEQkHtI8xgsQzBVXJU0nfc=
+github.com/maypok86/otter v1.2.4/go.mod h1:mKLfoI7v1HOmQMwFgX4QkRk23mX6ge3RDvjdHOWG4R4=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
@@ -209,12 +311,17 @@ github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS4
 github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+SVif2QVs3tOP0zanoHgBEVAwHxUSIzRqU=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -226,12 +333,17 @@ github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzE
 github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
 github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/nexus-rpc/sdk-go v0.0.11 h1:qH3Us3spfp50t5ca775V1va2eE6z1zMQDZY4mvbw0CI=
+github.com/nexus-rpc/sdk-go v0.0.11/go.mod h1:TpfkM2Cw0Rlk9drGkoiSMpFqflKTiQLWUNyKJjF8mKQ=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs=
 github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
 github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
+github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
 github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
 github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis=
 github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74=
@@ -244,93 +356,225 @@ github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnh
 github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
+github.com/pborman/uuid v1.2.1 h1:+ZZIw58t/ozdjRaXh/3awHfmWRbzYxJoAdNJxe/3pvw=
+github.com/pborman/uuid v1.2.1/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac=
 github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
+github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
+github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
+github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
+github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4=
+github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.3.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.19.2 h1:zUMhqEW66Ex7OXIiDkll3tl9a1ZdilUOd/F6ZXw4Vws=
+github.com/prometheus/procfs v0.19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw=
+github.com/puzpuzpuz/xsync/v3 v3.4.0 h1:DuVBAdXuGFHv8adVXjWWZ63pJq+NRXOWVXlKDBZ+mJ4=
+github.com/puzpuzpuz/xsync/v3 v3.4.0/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/redis/rueidis v1.0.51 h1:NZ1KIncPIQtjrp+GDLynrLKBiPU106EN5cJHOFSqvDM=
+github.com/redis/rueidis v1.0.51/go.mod h1:by+34b0cFXndxtYmPAHpoTHO5NkosDlBvhexoTURIxM=
+github.com/robfig/cron v1.2.0 h1:ZjScXvvxeQ63Dbyxy76Fj3AT3Ut0aKsyd2/tl3DTMuQ=
+github.com/robfig/cron v1.2.0/go.mod h1:JGuDeoQd7Z6yL4zQhZ3OPEVHB7fL6Ka6skscFHfmt2k=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
-github.com/rs/cors v1.10.0 h1:62NOS1h+r8p1mW6FM0FSB0exioXLhd/sh15KpjWBZ+8=
-github.com/rs/cors v1.10.0/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
+github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
+github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc=
+github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU=
 github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
+github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
+github.com/segmentio/encoding v0.4.1 h1:KLGaLSW0jrmhB58Nn4+98spfvPvmo4Ci1P/WIQ9wn7w=
+github.com/segmentio/encoding v0.4.1/go.mod h1:/d03Cd8PoaDeceuhUUUQWjU0KhWjrmYrWPgtJHYZSnI=
+github.com/shadowspore/fossil-delta v0.0.0-20240102155221-e3a8590b820b h1:SCYeryKXBVdW38167VyumGakH+7E4Wxe6b/zxmQxwyM=
+github.com/shadowspore/fossil-delta v0.0.0-20240102155221-e3a8590b820b/go.mod h1:daNLfX/GJKuZyN4HkMf0h8dVmTmgRbBSkd9bFQyGNIo=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
+github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
 github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY=
+github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
+github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
+github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
+github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
+github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
 github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
+github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
 github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
 github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
 github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc h1:9lRDQMhESg+zvGYmW5DyG0UqvY96Bu5QYsTLvCHdrgo=
+github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc/go.mod h1:bciPuU6GHm1iF1pBvUfxfsH0Wmnc2VbpgvbI9ZWuIRs=
+github.com/twmb/murmur3 v1.1.5 h1:i9OLS9fkuLzBXjt6dptlAEyk58fJsSTXbRg3SgVyqgk=
+github.com/twmb/murmur3 v1.1.5/go.mod h1:Qq/R7NUyOfr65zD+6Q5IHKsJLwP7exErjN6lyyq3OSQ=
+github.com/uber-go/tally/v4 v4.1.1/go.mod h1:aXeSTDMl4tNosyf6rdU8jlgScHyjEGGtfJ/uwCIf/vM=
+github.com/uber-go/tally/v4 v4.1.16 h1:by2hveWRh/cUReButk6ns1sHK/hiKry7BuOV6iY16XI=
+github.com/uber-go/tally/v4 v4.1.16/go.mod h1:RW5DgqsyEPs0lA4b0YNf4zKj7DveKHd73hnO6zVlyW0=
 github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
 github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/uptrace/bun v1.2.6 h1:lyGBQAhNiClchb97HA2cBnDeRxwTRLhSIgiFPXVisV8=
+github.com/uptrace/bun v1.2.6/go.mod h1:xMgnVFf+/5xsrFBU34HjDJmzZnXbVuNEt/Ih56I8qBU=
+github.com/uptrace/bun/dialect/pgdialect v1.2.6 h1:iNd1YLx619K+sZK+dRcWPzluurXYK1QwIkp9FEfNB/8=
+github.com/uptrace/bun/dialect/pgdialect v1.2.6/go.mod h1:OL7d3qZLxKYP8kxNhMg3IheN1pDR3UScGjoUP+ivxJQ=
+github.com/uptrace/bun/driver/pgdriver v1.2.6 h1:dD7ckqIhVDayfYTwMKZ0dJM9AZfNJNBu5Cg/8g0EMOk=
+github.com/uptrace/bun/driver/pgdriver v1.2.6/go.mod h1:ChrVrMZlRzPQHTP4QCm/p1FfQqgnYXWlES0GS9qjWEY=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/urfave/cli/v2 v2.27.5 h1:WoHEJLdsXr6dDWoJgMq/CboDmyY/8HMMH1fTECbih+w=
+github.com/urfave/cli/v2 v2.27.5/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8=
+github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok=
+github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
+github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
+github.com/wk8/go-ordered-map/v2 v2.1.9-0.20240816141633-0a40785b4f41 h1:rnB8ZLMeAr3VcqjfRkAm27qb8y6zFKNfuHvy1Gfe7KI=
+github.com/wk8/go-ordered-map/v2 v2.1.9-0.20240816141633-0a40785b4f41/go.mod h1:DbzwytT4g/odXquuOCqroKvtxxldI4nb3nuesHF/Exo=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+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.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
+go.temporal.io/api v1.5.0/go.mod h1:BqKxEJJYdxb5dqf0ODfzfMxh8UEQ5L3zKS51FiIYYkA=
+go.temporal.io/api v1.40.0 h1:rH3HvUUCFr0oecQTBW5tI6DdDQsX2Xb6OFVgt/bvLto=
+go.temporal.io/api v1.40.0/go.mod h1:1WwYUMo6lao8yl0371xWUm13paHExN5ATYT/B7QtFis=
+go.temporal.io/sdk v1.12.0/go.mod h1:lSp3lH1lI0TyOsus0arnO3FYvjVXBZGi/G7DjnAnm6o=
+go.temporal.io/sdk v1.30.0 h1:7jzSFZYk+tQ2kIYEP+dvrM7AW9EsCEP52JHCjVGuwbI=
+go.temporal.io/sdk v1.30.0/go.mod h1:Pv45F/fVDgWKx+jhix5t/dGgqROVaI+VjPLd3CHWqq0=
+go.temporal.io/sdk/contrib/tally v0.2.0 h1:XnTJIQcjOv+WuCJ1u8Ve2nq+s2H4i/fys34MnWDRrOo=
+go.temporal.io/sdk/contrib/tally v0.2.0/go.mod h1:1kpSuCms/tHeJQDPuuKkaBsMqfHnIIRnCtUYlPNXxuE=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+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.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
+go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
+go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
+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.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
@@ -338,9 +582,13 @@ golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
+golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -348,10 +596,14 @@ golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvx
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
 golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -368,19 +620,30 @@ golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200421231249-e086a090c8fd/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.15.0 h1:ugBLEUaxABaB5AJqW9enI0ACdci2RUd4eP51NTBvuJ8=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/net v0.0.0-20210913180222-943fd674d43e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+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/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -405,20 +668,34 @@ golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210910150752-751e447fb3d0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
+golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -431,26 +708,41 @@ golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBn
 golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+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/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230913181813-007df8e322eb h1:Isk1sSH7bovx8Rti2wZK0UZF6oraBDK74uoyLEEVFN0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230913181813-007df8e322eb/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M=
+google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
+google.golang.org/genproto/googleapis/api v0.0.0-20251029180050-ab9386a59fda h1:+2XxjfsAu6vqFxwGBRcHiMaDCuZiqXGDUDVWVtrFAnE=
+google.golang.org/genproto/googleapis/api v0.0.0-20251029180050-ab9386a59fda/go.mod h1:fDMmzKV90WSg1NbozdqrE64fkuTv6mlq2zxo9ad+3yo=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda h1:i/Q+bfisr7gq6feoJnS/DlpdwEL4ihp41fvRiM3Ork0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
+google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
@@ -464,8 +756,11 @@ google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
 google.golang.org/grpc v1.32.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.58.1 h1:OL+Vz23DTtrrldqHK49FUOPHyY75rvFqJfXC84NYW58=
-google.golang.org/grpc v1.58.1/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
+google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
+google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
+google.golang.org/grpc v1.78.0 h1:K1XZG/yGDJnzMdd/uZHAkVqJE+xIDOcmdSFZkBUicNc=
+google.golang.org/grpc v1.78.0/go.mod h1:I47qjTo4OKbMkjA/aOOwxDIiPSBofUtQUI5EfpWvW7U=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -478,36 +773,45 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
-google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/validator.v2 v2.0.0-20200605151824-2b28d334fa05/go.mod h1:o4V0GXN9/CAmCsvJ0oXYZvrZOe7syiDZSN1GWGZTGzc=
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+mellium.im/sasl v0.3.2 h1:PT6Xp7ccn9XaXAnJ03FcEjmAn7kK1x7aoXV6F+Vmrl0=
+mellium.im/sasl v0.3.2/go.mod h1:NKXDi1zkr+BlMHLQjY3ofYuU4KSPFxknb8mfEu6SveY=
+nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k=
 nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=
-nhooyr.io/websocket v1.8.7 h1:usjR2uOr/zjjkVMy0lW+PPohFok7PCow5sDjLgX4P4g=
-nhooyr.io/websocket v1.8.7/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
 sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=
diff --git a/internal/centutil/client_producer.go b/internal/centutil/client_producer.go
new file mode 100644
index 0000000..8bff1e6
--- /dev/null
+++ b/internal/centutil/client_producer.go
@@ -0,0 +1,108 @@
+package centutil
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/centrifugal/centrifuge-go"
+	"go.uber.org/zap"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+)
+
+var _ Producer = (*ClientProducer)(nil)
+
+type ClientProducer struct {
+	client       *centrifuge.Client
+	channel      string
+	disconnected chan struct{}
+
+	logger *zap.Logger
+}
+
+func NewClientProducer(address, channel, name, token string) (*ClientProducer, error) {
+	rawData, err := json.Marshal(clientData{Name: name})
+	if err != nil {
+		return nil, fmt.Errorf("marshaling client data: %w", err)
+	}
+
+	client := centrifuge.NewJsonClient(address, centrifuge.Config{
+		Token:             token,
+		Data:              rawData,
+		Name:              name,
+		EnableCompression: true,
+	})
+
+	p := &ClientProducer{
+		client:       client,
+		channel:      channel,
+		disconnected: make(chan struct{}),
+		logger: zap.L().Named("centrifuge_client").With(
+			zap.String("channel", channel),
+		),
+	}
+	if err := p.init(); err != nil {
+		return nil, fmt.Errorf("initializing ClientProducer: %w", err)
+	}
+
+	return p, nil
+}
+
+func (p *ClientProducer) Run(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		p.client.Close()
+		p.logger.Debug("client closed, waiting for disconnect")
+		<-p.disconnected
+		return nil
+	case <-p.disconnected:
+		p.logger.Error("disconnected from centrifuge")
+		return errors.New("premature disconnect")
+	}
+}
+
+func (p *ClientProducer) PublishProto(ctx context.Context, msg proto.Message) error {
+	raw, err := protojson.MarshalOptions{EmitUnpopulated: true}.Marshal(msg)
+	if err != nil {
+		return fmt.Errorf("marshaling message: %w", err)
+	}
+	if _, err := p.client.Publish(ctx, p.channel, raw); err != nil {
+		return fmt.Errorf("publishing message: %w", err)
+	}
+	return nil
+}
+
+func (p *ClientProducer) init() error {
+	p.client.OnError(func(event centrifuge.ErrorEvent) {
+		p.logger.Error("error", zap.Error(event.Error))
+	})
+
+	p.client.OnDisconnected(func(event centrifuge.DisconnectedEvent) {
+		p.logger.Debug(
+			"disconnected",
+			zap.Uint32("code", event.Code),
+			zap.String("reason", event.Reason),
+		)
+		close(p.disconnected)
+	})
+
+	if err := p.client.Connect(); err != nil {
+		return fmt.Errorf("connecting to centrifuge: %w", err)
+	}
+
+	return nil
+}
+
+type clientData struct {
+	Name string `json:"name"`
+}
+
+func ClientNameFromData(data []byte) (string, error) {
+	var d clientData
+	if err := json.Unmarshal(data, &d); err != nil {
+		return "", fmt.Errorf("unmarshaling client data: %w", err)
+	}
+	return d.Name, nil
+}
diff --git a/internal/centutil/node_producer.go b/internal/centutil/node_producer.go
new file mode 100644
index 0000000..9c4d3e6
--- /dev/null
+++ b/internal/centutil/node_producer.go
@@ -0,0 +1,35 @@
+package centutil
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/centrifugal/centrifuge"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+)
+
+var _ Producer = (*NodeProducer)(nil)
+
+type NodeProducer struct {
+	channel string
+	node    *centrifuge.Node
+}
+
+func NewNodeProducer(node *centrifuge.Node, channel string) *NodeProducer {
+	return &NodeProducer{
+		channel: channel,
+		node:    node,
+	}
+}
+
+func (p *NodeProducer) PublishProto(_ context.Context, msg proto.Message) error {
+	raw, err := protojson.MarshalOptions{EmitUnpopulated: true}.Marshal(msg)
+	if err != nil {
+		return fmt.Errorf("marshaling message: %w", err)
+	}
+	if _, err := p.node.Publish(p.channel, raw); err != nil {
+		return fmt.Errorf("publishing message: %w", err)
+	}
+	return nil
+}
diff --git a/internal/centutil/producer.go b/internal/centutil/producer.go
new file mode 100644
index 0000000..2e73d9e
--- /dev/null
+++ b/internal/centutil/producer.go
@@ -0,0 +1,11 @@
+package centutil
+
+import (
+	"context"
+
+	"google.golang.org/protobuf/proto"
+)
+
+type Producer interface {
+	PublishProto(ctx context.Context, msg proto.Message) error
+}
diff --git a/internal/checkers/actions.go b/internal/checkers/actions.go
new file mode 100644
index 0000000..136aa31
--- /dev/null
+++ b/internal/checkers/actions.go
@@ -0,0 +1,164 @@
+package checkers
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/c4t-but-s4d/fastad/pkg/modelsutil"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+// TODO: add process reaper to avoid zombies.
+
+const (
+	checkAction = "check"
+	putAction   = "put"
+	getAction   = "get"
+)
+
+const checkerKillDelay = time.Second * 3
+
+func RunCheckAction(
+	ctx context.Context,
+	params *CheckActivityParameters,
+) *Verdict {
+	return RunAction(
+		ctx,
+		params.Service.GetChecker().GetPath(),
+		checkerpb.Action_ACTION_CHECK,
+		[]string{checkAction, params.Team.GetAddress()},
+		modelsutil.ServiceCheckerTimeout(params.Service, checkerpb.Action_ACTION_CHECK),
+	)
+}
+
+func RunPutAction(
+	ctx context.Context,
+	params *PutActivityParameters,
+) *Verdict {
+	return RunAction(
+		ctx,
+		params.FlagInfo.Service.GetChecker().GetPath(),
+		checkerpb.Action_ACTION_PUT,
+		[]string{
+			putAction,
+			params.FlagInfo.Team.GetAddress(),
+			params.FlagInfo.Flag.Private,
+			params.FlagInfo.Flag.Flag,
+			"1", // TODO: vulns.
+		},
+		modelsutil.ServiceCheckerTimeout(params.FlagInfo.Service, checkerpb.Action_ACTION_PUT),
+	)
+}
+
+func RunGetAction(
+	ctx context.Context,
+	params *GetActivityParameters,
+) *Verdict {
+	return RunAction(
+		ctx,
+		params.Service.GetChecker().GetPath(),
+		checkerpb.Action_ACTION_GET,
+		[]string{
+			getAction,
+			params.Team.GetAddress(),
+			params.Flag.Private,
+			params.Flag.Flag,
+			"1", // TODO: vulns.
+		},
+		modelsutil.ServiceCheckerTimeout(params.Service, checkerpb.Action_ACTION_GET),
+	)
+}
+
+func RunAction(
+	ctx context.Context,
+	checkerPath string,
+	action checkerpb.Action,
+	args []string,
+	softTimeout time.Duration,
+) *Verdict {
+	ctx, cancel := context.WithTimeout(ctx, softTimeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, checkerPath, args...)
+	cmd.Cancel = func() error {
+		if err := cmd.Process.Signal(syscall.SIGTERM); err != nil {
+			return fmt.Errorf("sending SIGTERM to process: %w", err)
+		}
+		return nil
+	}
+	cmd.WaitDelay = checkerKillDelay
+
+	// TODO: limit buffer size.
+	stdout := bytes.Buffer{}
+	stderr := bytes.Buffer{}
+
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	verdict := &Verdict{
+		Action:  action,
+		Command: cmd.String(),
+	}
+
+	err := cmd.Run()
+	var procErr *exec.ExitError
+	switch {
+	case errors.Is(err, context.DeadlineExceeded):
+		verdict.Status = checkerpb.Status_STATUS_DOWN
+		verdict.Public = "timeout"
+		// TODO: truncate.
+		verdict.Private = fmt.Sprintf("err: %v\nstdout: %s\nstderr: %s", err, stdout.String(), stderr.String())
+
+	case errors.As(err, &procErr):
+		switch procErr.ExitCode() {
+		case 101:
+			verdict.Status = checkerpb.Status_STATUS_UP
+			verdict.Public = stdout.String()
+			verdict.Private = stderr.String()
+		case 102:
+			verdict.Status = checkerpb.Status_STATUS_CORRUPT
+			verdict.Public = stdout.String()
+			verdict.Private = stderr.String()
+		case 103:
+			verdict.Status = checkerpb.Status_STATUS_MUMBLE
+			verdict.Public = stdout.String()
+			verdict.Private = stderr.String()
+		case 104:
+			verdict.Status = checkerpb.Status_STATUS_DOWN
+			verdict.Public = stdout.String()
+			verdict.Private = stderr.String()
+		default:
+			verdict.Status = checkerpb.Status_STATUS_CHECK_FAILED
+			verdict.Public = "checker misbehaving"
+			verdict.Private = fmt.Sprintf(
+				"err: %v, code: %v\nstdout: %s\nstderr: %s",
+				err,
+				procErr.ExitCode(),
+				stdout.String(),
+				stderr.String(),
+			)
+		}
+
+	default:
+		verdict.Status = checkerpb.Status_STATUS_CHECK_FAILED
+		verdict.Public = "checker misbehaving"
+		// TODO: truncate.
+		verdict.Private = fmt.Sprintf(
+			"err: %v\nstdout: %s\nstderr: %s",
+			err,
+			stdout.String(),
+			stderr.String(),
+		)
+	}
+
+	verdict.Public = strings.TrimRight(verdict.Public, "\n\r")
+	verdict.Private = strings.TrimRight(verdict.Private, "\n\r")
+
+	return verdict
+}
diff --git a/internal/checkers/activity_check.go b/internal/checkers/activity_check.go
new file mode 100644
index 0000000..7f79196
--- /dev/null
+++ b/internal/checkers/activity_check.go
@@ -0,0 +1,51 @@
+package checkers
+
+import (
+	"context"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const CheckActivityName = "Check"
+
+type CheckActivity struct{}
+
+func NewCheckActivity() *CheckActivity {
+	return &CheckActivity{}
+}
+
+type CheckActivityParameters struct {
+	GameState *gspb.GameState
+	Team      *teamspb.Team
+	Service   *servicespb.Service
+}
+
+type CheckActivityResult struct {
+	Verdict *Verdict
+}
+
+func (*CheckActivity) ActivityDefinition(
+	ctx context.Context,
+	params *CheckActivityParameters,
+) (*CheckActivityResult, error) {
+	logger := log.With(
+		activity.GetLogger(ctx),
+		"team", params.Team.GetId(),
+		"service", params.Service.GetId(),
+		"action", checkerpb.Action_ACTION_CHECK,
+		"activity", CheckActivityName,
+	)
+
+	logger.Info("starting")
+
+	verdict := RunCheckAction(ctx, params)
+	logger.Info("finished", "verdict", verdict)
+
+	return &CheckActivityResult{Verdict: verdict}, nil
+}
diff --git a/internal/checkers/activity_extract_last_put.go b/internal/checkers/activity_extract_last_put.go
new file mode 100644
index 0000000..4d569e0
--- /dev/null
+++ b/internal/checkers/activity_extract_last_put.go
@@ -0,0 +1,52 @@
+package checkers
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+const GetLastExecutionActivityName = "GetLastExecution"
+
+type GetLastExecutionActivity struct {
+	checkersController *Controller
+}
+
+func NewGetLastExecutionActivity(checkersController *Controller) *GetLastExecutionActivity {
+	return &GetLastExecutionActivity{checkersController: checkersController}
+}
+
+type GetLastExecutionActivityParameters struct {
+	Action    checkerpb.Action
+	TeamID    int
+	ServiceID int
+}
+
+type GetLastExecutionActivityResult struct {
+	Execution *models.CheckerExecution
+}
+
+func (a *GetLastExecutionActivity) ActivityDefinition(
+	ctx context.Context,
+	params *GetLastExecutionActivityParameters,
+) (*GetLastExecutionActivityResult, error) {
+	lastPutExecution, err := a.checkersController.GetLastExecution(
+		ctx,
+		params.TeamID,
+		params.ServiceID,
+		params.Action,
+	)
+	if errors.Is(err, ErrExecutionNotFound) {
+		return &GetLastExecutionActivityResult{Execution: nil}, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("getting last execution: %w", err)
+	}
+
+	return &GetLastExecutionActivityResult{
+		Execution: lastPutExecution,
+	}, nil
+}
diff --git a/internal/checkers/activity_fetch_data.go b/internal/checkers/activity_fetch_data.go
new file mode 100644
index 0000000..72086b4
--- /dev/null
+++ b/internal/checkers/activity_fetch_data.go
@@ -0,0 +1,75 @@
+package checkers
+
+import (
+	"context"
+	"fmt"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const FetchDataActivityName = "FetchData"
+
+type FetchDataActivity struct {
+	teamsClient     *teams.Client
+	servicesClient  *services.Client
+	gameStateClient *gamestate.Client
+}
+
+func NewFetchDataActivity(
+	teamsClient *teams.Client,
+	servicesClient *services.Client,
+	gameStateClient *gamestate.Client,
+) *FetchDataActivity {
+	return &FetchDataActivity{
+		teamsClient:     teamsClient,
+		servicesClient:  servicesClient,
+		gameStateClient: gameStateClient,
+	}
+}
+
+type FetchDataActivityParameters struct{}
+
+type FetchDataActivityResult struct {
+	GameState *gspb.GameState
+	Teams     []*teamspb.Team
+	Services  []*servicespb.Service
+}
+
+func (a *FetchDataActivity) ActivityDefinition(
+	ctx context.Context,
+	_ *FetchDataActivityParameters,
+) (*FetchDataActivityResult, error) {
+	logger := log.With(activity.GetLogger(ctx), "activity", FetchDataActivityName)
+
+	gs, err := a.gameStateClient.Get(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("getting game state: %w", err)
+	}
+	logger.Info("fetched game state", "game_state", gs)
+
+	teamsList, err := a.teamsClient.List(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("getting teams: %w", err)
+	}
+	logger.Info("fetched teams", "teams", teamsList)
+
+	servicesList, err := a.servicesClient.List(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("getting services: %w", err)
+	}
+	logger.Info("fetched services", "services", servicesList)
+
+	return &FetchDataActivityResult{
+		GameState: gs,
+		Teams:     teamsList,
+		Services:  servicesList,
+	}, nil
+}
diff --git a/internal/checkers/activity_get.go b/internal/checkers/activity_get.go
new file mode 100644
index 0000000..24e41a2
--- /dev/null
+++ b/internal/checkers/activity_get.go
@@ -0,0 +1,49 @@
+package checkers
+
+import (
+	"context"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const GetActivityName = "Get"
+
+type GetActivity struct{}
+
+func NewGetActivity() *GetActivity {
+	return &GetActivity{}
+}
+
+type GetActivityParameters struct {
+	GameState *gspb.GameState
+	Team      *teamspb.Team
+	Service   *servicespb.Service
+	Flag      *models.Flag
+}
+
+type GetActivityResult struct {
+	Verdict *Verdict
+}
+
+func (*GetActivity) ActivityDefinition(ctx context.Context, params *GetActivityParameters) (*GetActivityResult, error) {
+	logger := log.With(
+		activity.GetLogger(ctx),
+		"team", params.Team.GetId(),
+		"service", params.Service.GetId(),
+		"action", checkerpb.Action_ACTION_GET,
+		"activity", GetActivityName,
+	)
+
+	logger.Info("starting")
+	verdict := RunGetAction(ctx, params)
+	logger.Info("finished", "verdict", verdict)
+
+	return &GetActivityResult{Verdict: verdict}, nil
+}
diff --git a/internal/checkers/activity_pick_get_flag.go b/internal/checkers/activity_pick_get_flag.go
new file mode 100644
index 0000000..41eeb06
--- /dev/null
+++ b/internal/checkers/activity_pick_get_flag.go
@@ -0,0 +1,65 @@
+package checkers
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+const PickGetFlagActivityName = "PickGetFlag"
+
+type PickGetFlagActivity struct {
+	checkersController *Controller
+}
+
+func NewPickGetFlagActivity(checkersController *Controller) *PickGetFlagActivity {
+	return &PickGetFlagActivity{checkersController: checkersController}
+}
+
+type PickGetFlagActivityParameters struct {
+	TeamID             int
+	ServiceID          int
+	RunningRound       uint64
+	FlagLifetimeRounds uint64
+}
+
+type PickGetFlagActivityResult struct {
+	Flag *models.Flag
+}
+
+func (a *PickGetFlagActivity) ActivityDefinition(
+	ctx context.Context,
+	params *PickGetFlagActivityParameters,
+) (*PickGetFlagActivityResult, error) {
+	logger := log.With(
+		activity.GetLogger(ctx),
+		"team", params.TeamID,
+		"service", params.ServiceID,
+		"activity", PickGetFlagActivityName,
+	)
+
+	logger.Info("picking flag")
+
+	flag, err := a.checkersController.PickFlag(
+		ctx,
+		params.TeamID,
+		params.ServiceID,
+		params.RunningRound,
+		params.FlagLifetimeRounds,
+	)
+	if errors.Is(err, ErrFlagNotFound) {
+		logger.Info("no flag available")
+		return &PickGetFlagActivityResult{Flag: nil}, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("picking flag: %w", err)
+	}
+
+	logger.Info("picked flag", "flag", flag)
+	return &PickGetFlagActivityResult{Flag: flag}, nil
+}
diff --git a/internal/checkers/activity_prepare_round_data.go b/internal/checkers/activity_prepare_round_data.go
new file mode 100644
index 0000000..4ae7e04
--- /dev/null
+++ b/internal/checkers/activity_prepare_round_data.go
@@ -0,0 +1,143 @@
+package checkers
+
+import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"math/big"
+	"strings"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/modelsutil"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const PrepareRoundActivityName = "PrepareRound"
+
+type PrepareRoundActivity struct {
+	checkersController *Controller
+	gameStateClient    *gamestate.Client
+}
+
+func NewPrepareRoundActivity(
+	checkersController *Controller,
+	gameStateClient *gamestate.Client,
+) *PrepareRoundActivity {
+	return &PrepareRoundActivity{
+		checkersController: checkersController,
+		gameStateClient:    gameStateClient,
+	}
+}
+
+type PrepareRoundActivityParameters struct {
+	GameState *gspb.GameState
+	Teams     []*teamspb.Team
+	Services  []*servicespb.Service
+}
+
+type FQFlagInfo struct {
+	Team    *teamspb.Team
+	Service *servicespb.Service
+	Flag    *models.Flag
+}
+
+type PrepareRoundActivityResult struct {
+	Flags []*FQFlagInfo
+}
+
+func (a *PrepareRoundActivity) ActivityDefinition(ctx context.Context, params *PrepareRoundActivityParameters) (*PrepareRoundActivityResult, error) {
+	logger := log.With(
+		activity.GetLogger(ctx),
+		"activity", PrepareRoundActivityName,
+		"running_round", params.GameState.GetRunningRound(),
+	)
+
+	logger.Info("starting")
+	flags, err := a.prepareRoundPutState(ctx, params, logger)
+	if err != nil {
+		return nil, fmt.Errorf("preparing round put state: %w", err)
+	}
+	logger.Info("finished")
+
+	return &PrepareRoundActivityResult{Flags: flags}, nil
+}
+
+func (a *PrepareRoundActivity) prepareRoundPutState(
+	ctx context.Context,
+	params *PrepareRoundActivityParameters,
+	logger log.Logger,
+) ([]*FQFlagInfo, error) {
+	logger.Info("updating round", "round", params.GameState.GetRunningRound())
+	if _, err := a.gameStateClient.UpdateRound(ctx, &gspb.UpdateRoundRequest{
+		RunningRound:      params.GameState.GetRunningRound(),
+		RunningRoundStart: params.GameState.GetRunningRoundStart(),
+	}); err != nil {
+		return nil, fmt.Errorf("updating round: %w", err)
+	}
+
+	logger.Info(
+		"preparing flags for teams and services",
+		"teams", len(params.Teams),
+		"services", len(params.Services),
+	)
+
+	flags := make([]*FQFlagInfo, 0, len(params.Teams)*len(params.Services))
+	flagModels := make([]*models.Flag, 0, len(params.Teams)*len(params.Services))
+	for _, team := range params.Teams {
+		for _, service := range params.Services {
+			for range modelsutil.ServiceCheckerRunCount(service, checkerpb.Action_ACTION_PUT) {
+				flag := &models.Flag{
+					Flag:      generateFlag(service),
+					TeamID:    int(team.GetId()),
+					ServiceID: int(service.GetId()),
+					Round:     params.GameState.GetRunningRound(),
+					CreatedAt: params.GameState.GetRunningRoundStart().AsTime(),
+				}
+				flags = append(flags, &FQFlagInfo{
+					Team:    team,
+					Service: service,
+					Flag:    flag,
+				})
+				flagModels = append(flagModels, flag)
+			}
+		}
+	}
+
+	if len(flagModels) == 0 {
+		logger.Warn("no flags to insert")
+		return flags, nil
+	}
+
+	logger.Info("inserting flags", "flags", len(flagModels))
+
+	if err := a.checkersController.AddFlags(ctx, flagModels); err != nil {
+		return nil, fmt.Errorf("adding flags: %w", err)
+	}
+
+	logger.Info("inserted flags", "flags", len(flagModels))
+
+	return flags, nil
+}
+
+func generateFlag(service *servicespb.Service) string {
+	const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	const length = 30
+	var result [length]byte
+
+	for i := range result {
+		randomIndex, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
+		if err != nil {
+			panic(err)
+		}
+		result[i] = charset[randomIndex.Int64()]
+	}
+
+	return strings.ToUpper(service.GetName()[:1]) + string(result[:]) + "="
+}
diff --git a/internal/checkers/activity_put.go b/internal/checkers/activity_put.go
new file mode 100644
index 0000000..02e2024
--- /dev/null
+++ b/internal/checkers/activity_put.go
@@ -0,0 +1,45 @@
+package checkers
+
+import (
+	"context"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+const PutActivityName = "Put"
+
+type PutActivity struct{}
+
+func NewPutActivity() *PutActivity {
+	return &PutActivity{}
+}
+
+type PutActivityParameters struct {
+	FlagInfo *FQFlagInfo
+}
+
+type PutActivityResult struct {
+	FlagInfo *FQFlagInfo
+	Verdict  *Verdict
+}
+
+func (a *PutActivity) ActivityDefinition(ctx context.Context, params *PutActivityParameters) (*PutActivityResult, error) {
+	logger := log.With(
+		activity.GetLogger(ctx),
+		"team", params.FlagInfo.Team.GetId(),
+		"service", params.FlagInfo.Service.GetId(),
+		"action", checkerpb.Action_ACTION_PUT,
+	)
+
+	logger.Info("starting")
+	verdict := RunPutAction(ctx, params)
+	logger.Info("finished", "verdict", verdict)
+
+	return &PutActivityResult{
+		FlagInfo: params.FlagInfo,
+		Verdict:  verdict,
+	}, nil
+}
diff --git a/internal/checkers/activity_save_round_data.go b/internal/checkers/activity_save_round_data.go
new file mode 100644
index 0000000..5c92c1c
--- /dev/null
+++ b/internal/checkers/activity_save_round_data.go
@@ -0,0 +1,51 @@
+package checkers
+
+import (
+	"context"
+	"fmt"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+)
+
+const SaveRoundDataActivityName = "SaveRoundData"
+
+type SaveRoundDataActivity struct {
+	checkersController *Controller
+}
+
+func NewSaveRoundDataActivity(checkersController *Controller) *SaveRoundDataActivity {
+	return &SaveRoundDataActivity{
+		checkersController: checkersController,
+	}
+}
+
+type SaveRoundDataActivityParameters struct {
+	RunningRound       uint64
+	FlagLifetimeRounds uint64
+	PutResults         []*PutActivityResult
+}
+
+type SaveRoundDataActivityResult struct{}
+
+func (s *SaveRoundDataActivity) ActivityDefinition(ctx context.Context, params *SaveRoundDataActivityParameters) (*SaveRoundDataActivityResult, error) {
+	logger := log.With(
+		activity.GetLogger(ctx),
+		"activity", SaveRoundDataActivityName,
+	)
+
+	logger.Info("saving data for put results", "put_results", len(params.PutResults))
+
+	if err := s.checkersController.SavePutExecutions(ctx, params.PutResults); err != nil {
+		return nil, fmt.Errorf("adding checker executions: %w", err)
+	}
+	if err := s.checkersController.SaveAttackDataSnapshot(
+		ctx,
+		params.RunningRound,
+		params.FlagLifetimeRounds,
+	); err != nil {
+		return nil, fmt.Errorf("saving attack data snapshot: %w", err)
+	}
+
+	return &SaveRoundDataActivityResult{}, nil
+}
diff --git a/internal/checkers/activity_save_verdict.go b/internal/checkers/activity_save_verdict.go
new file mode 100644
index 0000000..83bfbe1
--- /dev/null
+++ b/internal/checkers/activity_save_verdict.go
@@ -0,0 +1,61 @@
+package checkers
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/log"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+const SaveVerdictActivityName = "SaveVerdict"
+
+type SaveVerdictActivity struct {
+	checkersController *Controller
+}
+
+func NewSaveVerdictActivity(checkersController *Controller) *SaveVerdictActivity {
+	return &SaveVerdictActivity{
+		checkersController: checkersController,
+	}
+}
+
+type SaveVerdictActivityParameters struct {
+	TeamID    int
+	ServiceID int
+	Verdict   *Verdict
+}
+
+type SaveVerdictActivityResult struct{}
+
+func (s *SaveVerdictActivity) ActivityDefinition(ctx context.Context, params *SaveVerdictActivityParameters) (*SaveRoundDataActivityResult, error) {
+	logger := log.With(
+		activity.GetLogger(ctx),
+		"team", params.TeamID,
+		"service", params.ServiceID,
+		"action", params.Verdict.Action,
+		"activity", SaveVerdictActivityName,
+	)
+
+	logger.Info("saving verdict", "verdict", params.Verdict)
+	execution := &models.CheckerExecution{
+		ExecutionID: uuid.NewString(),
+		TeamID:      params.TeamID,
+		ServiceID:   params.ServiceID,
+		Action:      params.Verdict.Action,
+		Status:      params.Verdict.Status,
+		Public:      params.Verdict.Public,
+		Private:     params.Verdict.Private,
+		Command:     params.Verdict.Command,
+		CreatedAt:   time.Now(),
+	}
+	if err := s.checkersController.AddCheckerExecutions(ctx, execution); err != nil {
+		return nil, fmt.Errorf("adding checker executions: %w", err)
+	}
+
+	return &SaveRoundDataActivityResult{}, nil
+}
diff --git a/internal/checkers/config.go b/internal/checkers/config.go
new file mode 100644
index 0000000..7e97cd4
--- /dev/null
+++ b/internal/checkers/config.go
@@ -0,0 +1,17 @@
+package checkers
+
+import (
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+)
+
+type Config struct {
+	Installation string `mapstructure:"installation" default:"checkers/worker"`
+
+	MetricsAddress string `mapstructure:"metrics_address" default:":3006"`
+
+	IntercomToken string `mapstructure:"intercom_token"`
+
+	DataService config.DataService `mapstructure:"data_service"`
+	Temporal    config.Temporal    `mapstructure:"temporal"`
+	Postgres    config.Postgres    `mapstructure:"postgres"`
+}
diff --git a/internal/checkers/controller.go b/internal/checkers/controller.go
new file mode 100644
index 0000000..bce03ba
--- /dev/null
+++ b/internal/checkers/controller.go
@@ -0,0 +1,251 @@
+package checkers
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/samber/lo"
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+var (
+	ErrFlagNotFound      = errors.New("flag not found")
+	ErrExecutionNotFound = errors.New("execution not found")
+)
+
+type Controller struct {
+	db      *bun.DB
+	metrics *Metrics
+}
+
+func NewController(db *bun.DB, metrics *Metrics) *Controller {
+	return &Controller{db: db, metrics: metrics}
+}
+
+func (c *Controller) AddFlags(ctx context.Context, flags []*models.Flag) error {
+	if _, err := c.db.NewInsert().Model(&flags).Exec(ctx); err != nil {
+		return fmt.Errorf("inserting flags: %w", err)
+	}
+	return nil
+}
+
+func (c *Controller) SavePutExecutions(ctx context.Context, putResults []*PutActivityResult) error {
+	var flagsToRemove []int
+	flagsToMark := make([]*models.Flag, 0, len(putResults))
+	executions := make([]*models.CheckerExecution, 0, len(putResults))
+	for _, putResult := range putResults {
+		execution := &models.CheckerExecution{
+			ExecutionID: fmt.Sprintf("put-flag-%d", putResult.FlagInfo.Flag.ID),
+			TeamID:      int(putResult.FlagInfo.Team.GetId()),
+			ServiceID:   int(putResult.FlagInfo.Service.GetId()),
+			Action:      checkerpb.Action_ACTION_PUT,
+			Status:      putResult.Verdict.Status,
+			Public:      putResult.Verdict.Public,
+			Private:     putResult.Verdict.Private,
+			Command:     putResult.Verdict.Command,
+		}
+		executions = append(executions, execution)
+		if putResult.Verdict.Status != checkerpb.Status_STATUS_UP {
+			flagsToRemove = append(flagsToRemove, putResult.FlagInfo.Flag.ID)
+		} else {
+			flagsToMark = append(flagsToMark, &models.Flag{
+				ID:          putResult.FlagInfo.Flag.ID,
+				Public:      putResult.Verdict.Public,
+				Private:     putResult.Verdict.Private,
+				PutFinished: true,
+			})
+		}
+	}
+
+	if len(executions) == 0 {
+		return nil
+	}
+
+	if err := c.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		if _, err := tx.
+			NewInsert().
+			Model(&executions).
+			On("CONFLICT (execution_id) DO NOTHING").
+			Exec(ctx); err != nil {
+			return fmt.Errorf("inserting executions: %w", err)
+		}
+
+		if len(flagsToRemove) > 0 {
+			if _, err := tx.
+				NewDelete().
+				Model(&models.Flag{}).
+				Where("id IN (?) AND not put_finished", bun.In(flagsToRemove)).
+				Exec(ctx); err != nil {
+				return fmt.Errorf("deleting flags: %w", err)
+			}
+		}
+
+		if len(flagsToMark) > 0 {
+			for _, chunk := range lo.Chunk(flagsToMark, 200) {
+				if _, err := tx.
+					NewUpdate().
+					Model(&chunk).
+					Column("public", "private", "put_finished").
+					Bulk().
+					Exec(ctx); err != nil {
+					return fmt.Errorf("updating flags: %w", err)
+				}
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return fmt.Errorf("in tx: %w", err)
+	}
+
+	for _, exec := range executions {
+		c.metrics.ObserveExecution(exec.Action, exec.Status, exec.ServiceID)
+	}
+
+	return nil
+}
+
+func (c *Controller) SaveAttackDataSnapshot(ctx context.Context, runningRound, lifetimeRounds uint64) error {
+	minRound := uint64(0)
+	if runningRound > lifetimeRounds {
+		minRound = runningRound - lifetimeRounds
+	}
+
+	var validFlags []*models.Flag
+	if err := c.db.NewSelect().
+		Model(&validFlags).
+		Where(
+			"round >= ? AND f.put_finished is true",
+			minRound,
+		).
+		Order("f.round").
+		Scan(ctx); err != nil {
+		return fmt.Errorf("getting valid flags: %w", err)
+	}
+
+	type teamServiceKey struct {
+		teamID, serviceID int
+	}
+	validFlagsMap := lo.GroupBy(validFlags, func(flag *models.Flag) teamServiceKey {
+		return teamServiceKey{flag.TeamID, flag.ServiceID}
+	})
+
+	var teams []*models.Team
+	if err := c.db.NewSelect().
+		Model(&teams).
+		Scan(ctx); err != nil {
+		return fmt.Errorf("getting teams: %w", err)
+	}
+
+	var services []*models.Service
+	if err := c.db.NewSelect().
+		Model(&services).
+		Scan(ctx); err != nil {
+		return fmt.Errorf("getting services: %w", err)
+	}
+
+	attackDataPayload := make(models.AttackDataPayload)
+	for _, service := range services {
+		attackDataPayload[service.Name] = make(models.ServiceAttackData)
+		for _, team := range teams {
+			attackDataPayload[service.Name][team.Address] = []string{}
+			key := teamServiceKey{team.ID, service.ID}
+			for _, flag := range validFlagsMap[key] {
+				attackDataPayload[service.Name][team.Address] = append(
+					attackDataPayload[service.Name][team.Address],
+					flag.Public,
+				)
+			}
+		}
+	}
+
+	snapshot := &models.AttackDataSnapshot{
+		CreatedAt: time.Now(),
+		Round:     runningRound,
+		Payload:   attackDataPayload,
+	}
+	if _, err := c.db.NewInsert().Model(snapshot).Exec(ctx); err != nil {
+		return fmt.Errorf("inserting snapshot: %w", err)
+	}
+
+	return nil
+}
+
+func (c *Controller) AddCheckerExecutions(ctx context.Context, executions ...*models.CheckerExecution) error {
+	if _, err := c.db.
+		NewInsert().
+		Model(&executions).
+		On("CONFLICT (execution_id) DO NOTHING").
+		Exec(ctx); err != nil {
+		return fmt.Errorf("inserting executions: %w", err)
+	}
+
+	for _, exec := range executions {
+		c.metrics.ObserveExecution(exec.Action, exec.Status, exec.ServiceID)
+	}
+
+	return nil
+}
+
+func (c *Controller) PickFlag(
+	ctx context.Context,
+	teamID, serviceID int,
+	runningRound, lifetimeRounds uint64,
+) (*models.Flag, error) {
+	minRound := uint64(0)
+	if runningRound > lifetimeRounds {
+		minRound = runningRound - lifetimeRounds
+	}
+
+	var flag models.Flag
+	if err := c.db.
+		NewSelect().
+		Model(&flag).
+		Where(
+			"team_id = ? AND service_id = ? AND round >= ? AND put_finished is true",
+			teamID,
+			serviceID,
+			minRound,
+		).
+		OrderExpr("RANDOM()").
+		Scan(ctx); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrFlagNotFound
+		}
+		return nil, fmt.Errorf("picking flag: %w", err)
+	}
+
+	return &flag, nil
+}
+
+func (c *Controller) GetLastExecution(
+	ctx context.Context,
+	teamID, serviceID int,
+	action checkerpb.Action,
+) (*models.CheckerExecution, error) {
+	var execution models.CheckerExecution
+	if err := c.db.
+		NewSelect().
+		Model(&execution).
+		Where(
+			"team_id = ? AND service_id = ? AND action = ?",
+			teamID,
+			serviceID,
+			action,
+		).
+		OrderExpr("created_at DESC").
+		Scan(ctx); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrExecutionNotFound
+		}
+		return nil, fmt.Errorf("getting last put execution: %w", err)
+	}
+
+	return &execution, nil
+}
diff --git a/internal/checkers/metrics.go b/internal/checkers/metrics.go
new file mode 100644
index 0000000..23bb460
--- /dev/null
+++ b/internal/checkers/metrics.go
@@ -0,0 +1,50 @@
+package checkers
+
+import (
+	"strconv"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+type Metrics struct {
+	ExecutionsTotal *prometheus.CounterVec
+	ExecutionStatus *prometheus.CounterVec
+}
+
+func NewMetrics(installation string) *Metrics {
+	constLabels := prometheus.Labels{}
+	if installation != "" {
+		constLabels["installation"] = installation
+	}
+
+	return &Metrics{
+		ExecutionsTotal: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_checker_executions_total",
+				Help:        "Total number of checker executions",
+				ConstLabels: constLabels,
+			},
+			[]string{"action", "service_id"},
+		),
+		ExecutionStatus: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_checker_execution_status_total",
+				Help:        "Checker execution results by status",
+				ConstLabels: constLabels,
+			},
+			[]string{"action", "status", "service_id"},
+		),
+	}
+}
+
+func (m *Metrics) ObserveExecution(action checkerpb.Action, status checkerpb.Status, serviceID int) {
+	serviceIDStr := strconv.Itoa(serviceID)
+	actionStr := action.String()
+	statusStr := status.String()
+
+	m.ExecutionsTotal.WithLabelValues(actionStr, serviceIDStr).Inc()
+	m.ExecutionStatus.WithLabelValues(actionStr, statusStr, serviceIDStr).Inc()
+}
diff --git a/internal/checkers/verdict.go b/internal/checkers/verdict.go
new file mode 100644
index 0000000..bdc6950
--- /dev/null
+++ b/internal/checkers/verdict.go
@@ -0,0 +1,23 @@
+package checkers
+
+import (
+	"fmt"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+type Verdict struct {
+	Action  checkerpb.Action
+	Status  checkerpb.Status
+	Public  string
+	Private string
+	Command string
+}
+
+func (v *Verdict) String() string {
+	return fmt.Sprintf("%v %v", v.Action, v.Status)
+}
+
+func (v *Verdict) IsUp() bool {
+	return v.Status == checkerpb.Status_STATUS_UP
+}
diff --git a/internal/checkers/verdict_test.go b/internal/checkers/verdict_test.go
new file mode 100644
index 0000000..2e62eeb
--- /dev/null
+++ b/internal/checkers/verdict_test.go
@@ -0,0 +1,166 @@
+package checkers_test
+
+import (
+	"testing"
+
+	"github.com/c4t-but-s4d/fastad/internal/checkers"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+func TestVerdict_String(t *testing.T) {
+	tests := []struct {
+		name     string
+		verdict  checkers.Verdict
+		expected string
+	}{
+		{
+			name: "check up",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_UP,
+			},
+			expected: "ACTION_CHECK STATUS_UP",
+		},
+		{
+			name: "put mumble",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_PUT,
+				Status: checkerpb.Status_STATUS_MUMBLE,
+			},
+			expected: "ACTION_PUT STATUS_MUMBLE",
+		},
+		{
+			name: "get corrupt",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_GET,
+				Status: checkerpb.Status_STATUS_CORRUPT,
+			},
+			expected: "ACTION_GET STATUS_CORRUPT",
+		},
+		{
+			name: "check down",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_DOWN,
+			},
+			expected: "ACTION_CHECK STATUS_DOWN",
+		},
+		{
+			name: "check failed",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_CHECK_FAILED,
+			},
+			expected: "ACTION_CHECK STATUS_CHECK_FAILED",
+		},
+		{
+			name: "unspecified",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_UNSPECIFIED,
+				Status: checkerpb.Status_STATUS_UNSPECIFIED,
+			},
+			expected: "ACTION_UNSPECIFIED STATUS_UNSPECIFIED",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.verdict.String()
+			if result != tt.expected {
+				t.Errorf("Verdict.String() = %q, want %q", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestVerdict_IsUp(t *testing.T) {
+	tests := []struct {
+		name    string
+		verdict checkers.Verdict
+		want    bool
+	}{
+		{
+			name: "status up returns true",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_UP,
+			},
+			want: true,
+		},
+		{
+			name: "status mumble returns false",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_MUMBLE,
+			},
+			want: false,
+		},
+		{
+			name: "status corrupt returns false",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_GET,
+				Status: checkerpb.Status_STATUS_CORRUPT,
+			},
+			want: false,
+		},
+		{
+			name: "status down returns false",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_DOWN,
+			},
+			want: false,
+		},
+		{
+			name: "status check_failed returns false",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_CHECK_FAILED,
+			},
+			want: false,
+		},
+		{
+			name: "status unspecified returns false",
+			verdict: checkers.Verdict{
+				Action: checkerpb.Action_ACTION_CHECK,
+				Status: checkerpb.Status_STATUS_UNSPECIFIED,
+			},
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.verdict.IsUp(); got != tt.want {
+				t.Errorf("Verdict.IsUp() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestVerdict_Fields(t *testing.T) {
+	// Test that all fields can be set and accessed
+	verdict := checkers.Verdict{
+		Action:  checkerpb.Action_ACTION_PUT,
+		Status:  checkerpb.Status_STATUS_UP,
+		Public:  "flag stored successfully",
+		Private: "internal error details",
+		Command: "put flag ABC123",
+	}
+
+	if verdict.Action != checkerpb.Action_ACTION_PUT {
+		t.Errorf("Action = %v, want %v", verdict.Action, checkerpb.Action_ACTION_PUT)
+	}
+	if verdict.Status != checkerpb.Status_STATUS_UP {
+		t.Errorf("Status = %v, want %v", verdict.Status, checkerpb.Status_STATUS_UP)
+	}
+	if verdict.Public != "flag stored successfully" {
+		t.Errorf("Public = %q, want %q", verdict.Public, "flag stored successfully")
+	}
+	if verdict.Private != "internal error details" {
+		t.Errorf("Private = %q, want %q", verdict.Private, "internal error details")
+	}
+	if verdict.Command != "put flag ABC123" {
+		t.Errorf("Command = %q, want %q", verdict.Command, "put flag ABC123")
+	}
+}
diff --git a/internal/checkers/workflow_check.go b/internal/checkers/workflow_check.go
new file mode 100644
index 0000000..2042294
--- /dev/null
+++ b/internal/checkers/workflow_check.go
@@ -0,0 +1,107 @@
+package checkers
+
+import (
+	"fmt"
+	"time"
+
+	"go.temporal.io/sdk/log"
+	"go.temporal.io/sdk/workflow"
+
+	"github.com/c4t-but-s4d/fastad/pkg/modelsutil"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const CheckWorkflowName = "CheckWorkflow"
+
+type CheckWorkflowParameters struct {
+	GameState *gspb.GameState
+	Team      *teamspb.Team
+	Service   *servicespb.Service
+}
+
+func CheckWorkflowDefinition(ctx workflow.Context, params CheckWorkflowParameters) error {
+	logger := log.With(
+		workflow.GetLogger(ctx),
+		"team", params.Team.GetId(),
+		"service", params.Service.GetId(),
+		"action", checkerpb.Action_ACTION_CHECK,
+	)
+
+	logger.Debug("starting")
+
+	laoCtx := workflow.WithLocalActivityOptions(ctx, workflow.LocalActivityOptions{
+		ScheduleToCloseTimeout: time.Second * 3,
+	})
+
+	var verdict *Verdict
+
+	var getExecutionResult *GetLastExecutionActivityResult
+	if err := workflow.ExecuteLocalActivity(
+		laoCtx,
+		GetLastExecutionActivityName,
+		&GetLastExecutionActivityParameters{
+			Action:    checkerpb.Action_ACTION_PUT,
+			TeamID:    int(params.Team.GetId()),
+			ServiceID: int(params.Service.GetId()),
+		},
+	).Get(ctx, &getExecutionResult); err != nil {
+		logger.Error("running get last execution activity", "error", err)
+	}
+
+	if lastPut := getExecutionResult.Execution; lastPut != nil && lastPut.Status != checkerpb.Status_STATUS_UP {
+		verdict = &Verdict{
+			Action:  checkerpb.Action_ACTION_CHECK,
+			Status:  lastPut.Status,
+			Public:  "last flag PUT failed",
+			Private: fmt.Sprintf("last put execution id: %v", lastPut.ID),
+		}
+		logger.Debug("last put failed", "verdict", verdict)
+	} else {
+		checkerTimeout := modelsutil.ServiceCheckerTimeout(params.Service, checkerpb.Action_ACTION_CHECK)
+		checkActivityCtx := workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
+			ScheduleToCloseTimeout: checkerTimeout + checkerKillDelay*2,
+		})
+
+		var checkResult CheckActivityResult
+		if err := workflow.ExecuteActivity(
+			checkActivityCtx,
+			CheckActivityName,
+			&CheckActivityParameters{
+				GameState: params.GameState,
+				Team:      params.Team,
+				Service:   params.Service,
+			},
+		).Get(ctx, &checkResult); err != nil {
+			logger.Error("running activity", "error", err)
+			checkResult.Verdict = &Verdict{
+				Action:  checkerpb.Action_ACTION_CHECK,
+				Status:  checkerpb.Status_STATUS_CHECK_FAILED,
+				Public:  "checker error",
+				Private: fmt.Sprintf("running activity: %v", err),
+			}
+		}
+
+		verdict = checkResult.Verdict
+		logger.Debug("checker finished, saving verdict", "verdict", verdict)
+	}
+
+	if err := workflow.ExecuteLocalActivity(
+		laoCtx,
+		SaveVerdictActivityName,
+		&SaveVerdictActivityParameters{
+			TeamID:    int(params.Team.GetId()),
+			ServiceID: int(params.Service.GetId()),
+			Verdict:   verdict,
+		},
+	).Get(ctx, nil); err != nil {
+		logger.Error("running save verdict activity", "error", err)
+		return fmt.Errorf("save verdict: %w", err)
+	}
+
+	logger.Debug("check finished", "verdict", verdict)
+
+	return nil
+}
diff --git a/internal/checkers/workflow_get.go b/internal/checkers/workflow_get.go
new file mode 100644
index 0000000..8f266da
--- /dev/null
+++ b/internal/checkers/workflow_get.go
@@ -0,0 +1,137 @@
+package checkers
+
+import (
+	"fmt"
+	"time"
+
+	"go.temporal.io/sdk/log"
+	"go.temporal.io/sdk/workflow"
+
+	"github.com/c4t-but-s4d/fastad/pkg/modelsutil"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const GetWorkflowName = "GetWorkflow"
+
+type GetWorkflowParameters struct {
+	GameState *gspb.GameState
+	Team      *teamspb.Team
+	Service   *servicespb.Service
+}
+
+func GetWorkflowDefinition(ctx workflow.Context, params GetWorkflowParameters) error {
+	logger := log.With(
+		workflow.GetLogger(ctx),
+		"team", params.Team.GetId(),
+		"service", params.Service.GetId(),
+		"action", checkerpb.Action_ACTION_GET,
+	)
+
+	logger.Debug("starting workflow")
+
+	lao := workflow.LocalActivityOptions{
+		ScheduleToCloseTimeout: time.Second * 3,
+	}
+	laoCtx := workflow.WithLocalActivityOptions(ctx, lao)
+
+	var verdict *Verdict
+
+	var getExecutionResult *GetLastExecutionActivityResult
+	if err := workflow.ExecuteLocalActivity(
+		laoCtx,
+		GetLastExecutionActivityName,
+		&GetLastExecutionActivityParameters{
+			Action:    checkerpb.Action_ACTION_PUT,
+			TeamID:    int(params.Team.GetId()),
+			ServiceID: int(params.Service.GetId()),
+		},
+	).Get(ctx, &getExecutionResult); err != nil {
+		logger.Error("running get last execution activity", "error", err)
+		getExecutionResult = &GetLastExecutionActivityResult{}
+	}
+
+	if lastPut := getExecutionResult.Execution; lastPut != nil && lastPut.Status != checkerpb.Status_STATUS_UP {
+		verdict = &Verdict{
+			Action:  checkerpb.Action_ACTION_GET,
+			Status:  lastPut.Status,
+			Public:  "last flag PUT failed",
+			Private: fmt.Sprintf("last put execution id: %v", lastPut.ID),
+		}
+		logger.Debug("last put failed, failing")
+	} else {
+		var pickFlagResult *PickGetFlagActivityResult
+		if err := workflow.ExecuteLocalActivity(
+			laoCtx,
+			PickGetFlagActivityName,
+			&PickGetFlagActivityParameters{
+				TeamID:             int(params.Team.GetId()),
+				ServiceID:          int(params.Service.GetId()),
+				RunningRound:       params.GameState.GetRunningRound(),
+				FlagLifetimeRounds: params.GameState.GetFlagLifetimeRounds(),
+			},
+		).Get(ctx, &pickFlagResult); err != nil {
+			logger.Error("running pick flag activity", "error", err)
+			pickFlagResult = &PickGetFlagActivityResult{}
+		}
+
+		logger.Debug("picked flag", "flag", pickFlagResult.Flag)
+
+		if pickFlagResult.Flag == nil {
+			verdict = &Verdict{
+				Action:  checkerpb.Action_ACTION_GET,
+				Status:  checkerpb.Status_STATUS_CORRUPT,
+				Public:  "no flags to get",
+				Private: "unable to pick live flag",
+			}
+			logger.Debug("no flags available, failing")
+		} else {
+			checkerTimeout := modelsutil.ServiceCheckerTimeout(params.Service, checkerpb.Action_ACTION_GET)
+			getActivityCtx := workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
+				ScheduleToCloseTimeout: checkerTimeout + checkerKillDelay*2,
+			})
+
+			var getResult GetActivityResult
+			if err := workflow.ExecuteActivity(
+				getActivityCtx,
+				GetActivityName,
+				&GetActivityParameters{
+					GameState: params.GameState,
+					Team:      params.Team,
+					Service:   params.Service,
+					Flag:      pickFlagResult.Flag,
+				},
+			).Get(ctx, &getResult); err != nil {
+				logger.Error("running activity", "error", err)
+				getResult.Verdict = &Verdict{
+					Action:  checkerpb.Action_ACTION_GET,
+					Status:  checkerpb.Status_STATUS_CHECK_FAILED,
+					Public:  "checker error",
+					Private: fmt.Sprintf("running activity: %v", err),
+				}
+			}
+
+			verdict = getResult.Verdict
+			logger.Debug("checker finished, saving verdict", "verdict", verdict)
+		}
+	}
+
+	if err := workflow.ExecuteLocalActivity(
+		laoCtx,
+		SaveVerdictActivityName,
+		&SaveVerdictActivityParameters{
+			TeamID:    int(params.Team.GetId()),
+			ServiceID: int(params.Service.GetId()),
+			Verdict:   verdict,
+		},
+	).Get(ctx, nil); err != nil {
+		logger.Error("running save verdict activity", "error", err)
+		return fmt.Errorf("save verdict: %w", err)
+	}
+
+	logger.Debug("get finished", "verdict", verdict)
+
+	return nil
+}
diff --git a/internal/checkers/workflow_round.go b/internal/checkers/workflow_round.go
new file mode 100644
index 0000000..2089703
--- /dev/null
+++ b/internal/checkers/workflow_round.go
@@ -0,0 +1,129 @@
+package checkers
+
+import (
+	"fmt"
+	"time"
+
+	"go.temporal.io/sdk/workflow"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"github.com/c4t-but-s4d/fastad/pkg/modelsutil"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+const RoundWorkflowName = "RoundWorkflow"
+
+type RoundWorkflowParameters struct{}
+
+func RoundWorkflowDefinition(ctx workflow.Context, _ RoundWorkflowParameters) error {
+	logger := workflow.GetLogger(ctx)
+	logger.Info("starting workflow")
+
+	lao := workflow.LocalActivityOptions{
+		ScheduleToCloseTimeout: time.Second * 3,
+	}
+	laoCtx := workflow.WithLocalActivityOptions(ctx, lao)
+
+	var fetchDataResult *FetchDataActivityResult
+	if err := workflow.ExecuteLocalActivity(
+		laoCtx,
+		FetchDataActivityName,
+		&FetchDataActivityParameters{},
+	).Get(ctx, &fetchDataResult); err != nil {
+		logger.Error("running fetch data activity", "error", err)
+		return fmt.Errorf("fetch data: %w", err)
+	}
+
+	logger.Info(
+		"fetched current data",
+		"teams",
+		len(fetchDataResult.Teams),
+		"services",
+		len(fetchDataResult.Services),
+		"round",
+		fetchDataResult.GameState.GetRunningRound(),
+	)
+
+	fetchDataResult.GameState.RunningRound++
+	fetchDataResult.GameState.RunningRoundStart = timestamppb.New(workflow.Now(ctx))
+
+	var prepareStateResult *PrepareRoundActivityResult
+	if err := workflow.ExecuteLocalActivity(
+		laoCtx,
+		PrepareRoundActivityName,
+		&PrepareRoundActivityParameters{
+			GameState: fetchDataResult.GameState,
+			Teams:     fetchDataResult.Teams,
+			Services:  fetchDataResult.Services,
+		},
+	).Get(ctx, &prepareStateResult); err != nil {
+		logger.Error("running prepare state activity", "error", err)
+		return fmt.Errorf("prepare state: %w", err)
+	}
+
+	putsCount := len(fetchDataResult.Teams) * len(fetchDataResult.Services)
+	putResultsChan := workflow.NewBufferedChannel(ctx, putsCount)
+
+	wg := workflow.NewWaitGroup(ctx)
+	for _, flagInfo := range prepareStateResult.Flags {
+		wg.Add(1)
+		workflow.Go(ctx, func(ctx workflow.Context) {
+			defer wg.Done()
+
+			checkerTimeout := modelsutil.ServiceCheckerTimeout(flagInfo.Service, checkerpb.Action_ACTION_PUT)
+			putActivityCtx := workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
+				ScheduleToCloseTimeout: checkerTimeout + checkerKillDelay*2,
+			})
+
+			var putResult *PutActivityResult
+			if err := workflow.ExecuteActivity(
+				putActivityCtx,
+				PutActivityName,
+				PutActivityParameters{
+					FlagInfo: flagInfo,
+				},
+			).Get(ctx, &putResult); err != nil {
+				logger.Error("error in put", "team", flagInfo.Team, "service", flagInfo.Service, "error", err)
+				putResult = &PutActivityResult{
+					Verdict: &Verdict{
+						Action:  checkerpb.Action_ACTION_PUT,
+						Status:  checkerpb.Status_STATUS_CHECK_FAILED,
+						Public:  "internal error",
+						Private: fmt.Sprintf("put activity err: %v", err),
+					},
+					FlagInfo: flagInfo,
+				}
+			}
+
+			putResultsChan.Send(ctx, putResult)
+		})
+	}
+
+	putResults := make([]*PutActivityResult, 0, putsCount)
+	for range putsCount {
+		var putResult *PutActivityResult
+		putResultsChan.Receive(ctx, &putResult)
+		putResults = append(putResults, putResult)
+	}
+
+	wg.Wait(ctx)
+
+	logger.Info("finished puts, saving results", "put_results", len(putResults))
+
+	if err := workflow.ExecuteLocalActivity(
+		laoCtx,
+		SaveRoundDataActivityName,
+		&SaveRoundDataActivityParameters{
+			RunningRound:       fetchDataResult.GameState.GetRunningRound(),
+			FlagLifetimeRounds: fetchDataResult.GameState.GetFlagLifetimeRounds(),
+			PutResults:         putResults,
+		},
+	).Get(ctx, nil); err != nil {
+		logger.Error("running save round data activity", "error", err)
+		return fmt.Errorf("save round data: %w", err)
+	}
+
+	logger.Info("finished round", "round", fetchDataResult.GameState.GetRoundDuration())
+
+	return nil
+}
diff --git a/internal/dataservice/config.go b/internal/dataservice/config.go
new file mode 100644
index 0000000..1455321
--- /dev/null
+++ b/internal/dataservice/config.go
@@ -0,0 +1,16 @@
+package dataservice
+
+import (
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+)
+
+type Config struct {
+	Installation string `mapstructure:"installation" default:"dataservice"`
+
+	IntercomToken string `mapstructure:"intercom_token"`
+
+	ListenAddress  string `mapstructure:"listen_address" default:":8004"`
+	MetricsAddress string `mapstructure:"metrics_address" default:":3004"`
+
+	Postgres config.Postgres `mapstructure:"postgres"`
+}
diff --git a/internal/dataservice/gamestate/controller.go b/internal/dataservice/gamestate/controller.go
new file mode 100644
index 0000000..b13fe73
--- /dev/null
+++ b/internal/dataservice/gamestate/controller.go
@@ -0,0 +1,187 @@
+package gamestate
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/uptrace/bun"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/internal/version"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+)
+
+const VersionKey = "game_state"
+
+type Controller struct {
+	Versions *version.Controller
+
+	db *bun.DB
+}
+
+func NewController(db *bun.DB, versionController *version.Controller) *Controller {
+	return &Controller{
+		Versions: versionController,
+
+		db: db,
+	}
+}
+
+func (c *Controller) Get(ctx context.Context) (*models.GameState, error) {
+	var gs models.GameState
+	if err := c.db.NewSelect().Model(&gs).Scan(ctx); err != nil {
+		return nil, fmt.Errorf("getting game state: %w", err)
+	}
+	return &gs, nil
+}
+
+func (c *Controller) Create(ctx context.Context, req *gspb.CreateRequest) (*models.GameState, int, error) {
+	var newVersion int
+	gs := models.NewGameStateFromProto(req.GetGameState())
+	if err := c.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		var err error
+		if newVersion, err = c.Versions.Increment(ctx, tx, VersionKey); err != nil {
+			return fmt.Errorf("incrementing version: %w", err)
+		}
+		if newVersion > 1 {
+			return status.Error(codes.FailedPrecondition, "game state already exists")
+		}
+		gs.ID = 1
+		if err := tx.NewInsert().Model(gs).Returning("*").Scan(ctx); err != nil {
+			return fmt.Errorf("inserting game state: %w", err)
+		}
+
+		return nil
+	}); err != nil {
+		return nil, 0, fmt.Errorf("in transaction: %w", err)
+	}
+
+	return gs, newVersion, nil
+}
+
+func (c *Controller) Update(ctx context.Context, req *gspb.UpdateRequest) (*models.GameState, int, error) {
+	var newVersion int
+	var gs *models.GameState
+	if err := c.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		var err error
+		if gs, newVersion, err = c.updateImpl(ctx, tx, func(query *bun.UpdateQuery) *bun.UpdateQuery {
+			if req.GetStartTime() != nil {
+				query = query.Set("start_time = ?", req.GetStartTime().AsTime())
+			}
+			if req.GetEndTime() != nil {
+				if req.GetEndTime().AsTime().IsZero() {
+					query = query.Set("end_time = NULL")
+				} else {
+					query = query.Set("end_time = ?", req.GetEndTime().AsTime())
+				}
+			}
+
+			if req.TotalRounds != nil {
+				if req.GetTotalRounds() > 0 {
+					query = query.Set("total_rounds = ?", req.GetTotalRounds())
+				} else {
+					query = query.Set("total_rounds = NULL")
+				}
+			}
+
+			if req.GetStatus() != gspb.GameStatus_GAME_STATUS_UNSPECIFIED {
+				query = query.Set("status = ?", req.GetStatus())
+			}
+
+			if req.GetFlagLifetimeRounds() > 0 {
+				query = query.Set("flag_lifetime_rounds = ?", req.GetFlagLifetimeRounds())
+			}
+
+			if req.GetRoundDuration().AsDuration() > 0 {
+				query = query.Set("round_duration = ?", req.GetRoundDuration().AsDuration())
+			}
+
+			if req.Hardness != nil {
+				query = query.Set("hardness = ?", req.GetHardness())
+			}
+
+			if req.Inflation != nil {
+				query = query.Set("inflation = ?", req.GetInflation())
+			}
+
+			return query
+		}); err != nil {
+			return fmt.Errorf("updating game state: %w", err)
+		}
+		return nil
+	}); err != nil {
+		return nil, 0, fmt.Errorf("in transaction: %w", err)
+	}
+
+	return gs, newVersion, nil
+}
+
+func (c *Controller) UpdateRound(ctx context.Context, req *gspb.UpdateRoundRequest) (*models.GameState, int, error) {
+	var newVersion int
+	var gs *models.GameState
+	if err := c.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		var err error
+		if gs, newVersion, err = c.updateImpl(ctx, tx, func(query *bun.UpdateQuery) *bun.UpdateQuery {
+			return query.
+				Set("running_round = ?", req.GetRunningRound()).
+				Set("running_round_start = ?", req.GetRunningRoundStart().AsTime())
+		}); err != nil {
+			return fmt.Errorf("updating game state: %w", err)
+		}
+		return nil
+	}); err != nil {
+		return nil, 0, fmt.Errorf("in transaction: %w", err)
+	}
+
+	return gs, newVersion, nil
+}
+
+func (c *Controller) FinishGame(ctx context.Context) (*models.GameState, int, error) {
+	var newVersion int
+	var gs *models.GameState
+	if err := c.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		var err error
+		if gs, newVersion, err = c.updateImpl(ctx, tx, func(query *bun.UpdateQuery) *bun.UpdateQuery {
+			return query.Set("status = ?", gspb.GameStatus_GAME_STATUS_FINISHED)
+		}); err != nil {
+			return fmt.Errorf("updating game state: %w", err)
+		}
+		return nil
+	}); err != nil {
+		return nil, 0, fmt.Errorf("in transaction: %w", err)
+	}
+
+	return gs, newVersion, nil
+}
+
+func (c *Controller) updateImpl(
+	ctx context.Context,
+	tx bun.Tx,
+	queryMod func(query *bun.UpdateQuery) *bun.UpdateQuery,
+) (*models.GameState, int, error) {
+	if err := tx.
+		NewSelect().
+		Model(&models.GameState{}).
+		Where("id = 1").
+		For("UPDATE").
+		Scan(ctx); err != nil {
+		return nil, 0, fmt.Errorf("locking game state: %w", err)
+	}
+
+	var gs models.GameState
+	query := tx.NewUpdate().Model(&gs).Where("id = 1").Returning("*")
+	query = queryMod(query)
+
+	if err := query.Scan(ctx); err != nil {
+		return nil, 0, fmt.Errorf("updating game state: %w", err)
+	}
+
+	newVersion, err := c.Versions.Increment(ctx, tx, VersionKey)
+	if err != nil {
+		return nil, 0, fmt.Errorf("incrementing version: %w", err)
+	}
+	return &gs, newVersion, nil
+}
diff --git a/internal/dataservice/gamestate/service.go b/internal/dataservice/gamestate/service.go
new file mode 100644
index 0000000..92f8fa8
--- /dev/null
+++ b/internal/dataservice/gamestate/service.go
@@ -0,0 +1,118 @@
+package gamestate
+
+import (
+	"context"
+	"fmt"
+
+	"go.uber.org/zap"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/internal/version"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+)
+
+type Service struct {
+	gspb.UnimplementedGameStateServiceServer
+
+	controller *Controller
+}
+
+func NewService(controller *Controller) *Service {
+	return &Service{controller: controller}
+}
+
+func (s *Service) Get(ctx context.Context, req *gspb.GetRequest) (*gspb.GetResponse, error) {
+	zap.L().Debug("GameStateService/Get", zap.Any("request", req))
+
+	gotVersion, err := s.controller.Versions.Get(ctx, VersionKey)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "getting version: %v", err)
+	}
+
+	requestedVersion := int(req.GetVersion().GetVersion())
+	if requestedVersion > gotVersion {
+		return nil, status.Errorf(codes.FailedPrecondition, "requested version is greater than current")
+	}
+	if requestedVersion == gotVersion {
+		return &gspb.GetResponse{Version: version.NewVersionProto(gotVersion)}, nil
+	}
+
+	state, err := s.controller.Get(ctx)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "getting game state: %v", err)
+	}
+
+	return &gspb.GetResponse{
+		GameState: state.ToProto(),
+		Version:   version.NewVersionProto(gotVersion),
+	}, nil
+}
+
+func (s *Service) Create(ctx context.Context, req *gspb.CreateRequest) (*gspb.CreateResponse, error) {
+	zap.L().Debug("GameStateService/Create", zap.Any("request", req))
+
+	if err := s.validateCreateRequest(req); err != nil {
+		return nil, fmt.Errorf("validating request: %w", err)
+	}
+
+	gs, newVersion, err := s.controller.Create(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("creating game state: %w", err)
+	}
+
+	return &gspb.CreateResponse{
+		GameState: gs.ToProto(),
+		Version:   version.NewVersionProto(newVersion),
+	}, nil
+}
+
+func (s *Service) Update(ctx context.Context, req *gspb.UpdateRequest) (*gspb.UpdateResponse, error) {
+	zap.L().Debug("GameStateService/Update", zap.Any("request", req))
+
+	if err := s.validateUpdateRequest(req); err != nil {
+		return nil, fmt.Errorf("validating request: %w", err)
+	}
+
+	gs, newVersion, err := s.controller.Update(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("updating game state: %w", err)
+	}
+
+	return &gspb.UpdateResponse{
+		GameState: gs.ToProto(),
+		Version:   version.NewVersionProto(newVersion),
+	}, nil
+}
+
+func (s *Service) UpdateRound(ctx context.Context, req *gspb.UpdateRoundRequest) (*gspb.UpdateRoundResponse, error) {
+	zap.L().Debug("GameStateService/UpdateRound", zap.Any("request", req))
+
+	if err := s.validateUpdateRoundRequest(req); err != nil {
+		return nil, fmt.Errorf("validating request: %w", err)
+	}
+
+	gs, newVersion, err := s.controller.UpdateRound(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("updating round: %w", err)
+	}
+
+	return &gspb.UpdateRoundResponse{
+		GameState: gs.ToProto(),
+		Version:   version.NewVersionProto(newVersion),
+	}, nil
+}
+
+func (s *Service) FinishGame(ctx context.Context, req *gspb.FinishGameRequest) (*gspb.FinishGameResponse, error) {
+	zap.L().Debug("GameStateService/FinishGame", zap.Any("request", req))
+
+	gs, newVersion, err := s.controller.FinishGame(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("finishing game: %w", err)
+	}
+
+	return &gspb.FinishGameResponse{
+		GameState: gs.ToProto(),
+		Version:   version.NewVersionProto(newVersion),
+	}, nil
+}
diff --git a/internal/dataservice/gamestate/validate.go b/internal/dataservice/gamestate/validate.go
new file mode 100644
index 0000000..109e7f3
--- /dev/null
+++ b/internal/dataservice/gamestate/validate.go
@@ -0,0 +1,54 @@
+package gamestate
+
+import (
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+)
+
+func (s *Service) validateCreateRequest(req *gspb.CreateRequest) error {
+	if req.GetGameState() == nil {
+		return status.Error(codes.InvalidArgument, "game_state required")
+	}
+	gs := req.GetGameState()
+	if gs.GetStartTime() == nil {
+		return status.Error(codes.InvalidArgument, "start_time required")
+	}
+	if end := gs.GetEndTime(); end != nil && end.AsTime().Before(gs.GetStartTime().AsTime()) {
+		return status.Error(codes.InvalidArgument, "end_time is before start time")
+	}
+	if gs.GetRoundDuration().AsDuration() == 0 {
+		return status.Error(codes.InvalidArgument, "round_duration required")
+	}
+	if gs.GetFlagLifetimeRounds() == 0 {
+		return status.Error(codes.InvalidArgument, "flag_lifetime_rounds required")
+	}
+	return nil
+}
+
+func (s *Service) validateUpdateRequest(req *gspb.UpdateRequest) error {
+	startTime := req.GetStartTime()
+	endTime := req.GetEndTime()
+	if startTime != nil && endTime != nil && !endTime.AsTime().IsZero() && endTime.AsTime().Before(startTime.AsTime()) {
+		return status.Error(codes.InvalidArgument, "end_time is before start time")
+	}
+
+	if rd := req.GetRoundDuration(); rd != nil && rd.AsDuration() == 0 {
+		return status.Error(codes.InvalidArgument, "round_duration must be non-zero")
+	}
+	if req.FlagLifetimeRounds != nil && req.GetFlagLifetimeRounds() == 0 {
+		return status.Error(codes.InvalidArgument, "flag_lifetime_rounds must be non-zero")
+	}
+	return nil
+}
+
+func (s *Service) validateUpdateRoundRequest(req *gspb.UpdateRoundRequest) error {
+	if req.GetRunningRound() == 0 {
+		return status.Error(codes.InvalidArgument, "running_round required")
+	}
+	if req.GetRunningRoundStart() == nil {
+		return status.Error(codes.InvalidArgument, "running_round_start required")
+	}
+	return nil
+}
diff --git a/internal/dataservice/services/controller.go b/internal/dataservice/services/controller.go
new file mode 100644
index 0000000..9acba4f
--- /dev/null
+++ b/internal/dataservice/services/controller.go
@@ -0,0 +1,104 @@
+package services
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/internal/version"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+const VersionKey = "services"
+
+type Controller struct {
+	Versions *version.Controller
+
+	db *bun.DB
+}
+
+func NewController(db *bun.DB, versionController *version.Controller) *Controller {
+	return &Controller{
+		Versions: versionController,
+
+		db: db,
+	}
+}
+
+func (c *Controller) List(ctx context.Context) ([]*models.Service, error) {
+	var services []*models.Service
+	if err := c.db.NewSelect().Model(&services).Scan(ctx); err != nil {
+		return nil, fmt.Errorf("getting services: %w", err)
+	}
+	return services, nil
+}
+
+func (c *Controller) CreateBatch(ctx context.Context, services []*models.Service) error {
+	if len(services) == 0 {
+		return nil
+	}
+
+	if err := c.db.RunInTx(
+		ctx,
+		&sql.TxOptions{},
+		func(ctx context.Context, tx bun.Tx) error {
+			if err := tx.
+				NewInsert().
+				Model(&services).
+				On("CONFLICT (name) DO UPDATE").
+				Set("checker_type = EXCLUDED.checker_type").
+				Set("checker_path = EXCLUDED.checker_path").
+				Set("default_score = EXCLUDED.default_score").
+				Set("default_timeout = EXCLUDED.default_timeout").
+				Set("actions = EXCLUDED.actions").
+				Returning("*").
+				Scan(ctx); err != nil {
+				return fmt.Errorf("inserting services: %w", err)
+			}
+			if _, err := c.Versions.Increment(ctx, tx, VersionKey); err != nil {
+				return fmt.Errorf("incrementing version: %w", err)
+			}
+			return nil
+		},
+	); err != nil {
+		return fmt.Errorf("in transaction: %w", err)
+	}
+	return nil
+}
+
+func (c *Controller) Update(ctx context.Context, req *servicespb.UpdateRequest) (*models.Service, int, error) {
+	var service models.Service
+	var newVersion int
+	if err := c.db.RunInTx(
+		ctx,
+		&sql.TxOptions{},
+		func(ctx context.Context, tx bun.Tx) error {
+			query := c.db.NewUpdate().
+				Model(&models.Service{}).
+				Where("id = ?", req.GetId()).
+				Returning("*")
+
+			if req.Disabled != nil {
+				query.Set("disabled = ?", req.GetDisabled())
+			}
+
+			if err := query.Model(&service).Scan(ctx); err != nil {
+				return fmt.Errorf("updating service: %w", err)
+			}
+
+			var err error
+			if newVersion, err = c.Versions.Increment(ctx, tx, VersionKey); err != nil {
+				return fmt.Errorf("incrementing version: %w", err)
+			}
+
+			return nil
+		},
+	); err != nil {
+		return nil, 0, fmt.Errorf("in transaction: %w", err)
+	}
+
+	return &service, newVersion, nil
+}
diff --git a/internal/dataservice/services/service.go b/internal/dataservice/services/service.go
new file mode 100644
index 0000000..d449569
--- /dev/null
+++ b/internal/dataservice/services/service.go
@@ -0,0 +1,98 @@
+package services
+
+import (
+	"context"
+
+	"github.com/samber/lo"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/internal/version"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+type Service struct {
+	servicespb.UnimplementedServicesServiceServer
+
+	controller *Controller
+}
+
+func NewService(controller *Controller) *Service {
+	return &Service{
+		controller: controller,
+	}
+}
+
+func (s *Service) List(ctx context.Context, req *servicespb.ListRequest) (*servicespb.ListResponse, error) {
+	zap.L().Debug("ServicesService/List", zap.Any("request", req))
+
+	gotVersion, err := s.controller.Versions.Get(ctx, VersionKey)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "getting version: %v", err)
+	}
+
+	requestedVersion := int(req.GetVersion().GetVersion())
+	if requestedVersion > gotVersion {
+		return nil, status.Errorf(codes.FailedPrecondition, "requested version is greater than current")
+	}
+	if requestedVersion == gotVersion {
+		return &servicespb.ListResponse{Version: version.NewVersionProto(gotVersion)}, nil
+	}
+
+	services, err := s.controller.List(ctx)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "getting services: %v", err)
+	}
+
+	return &servicespb.ListResponse{
+		Services: lo.Map(services, func(service *models.Service, _ int) *servicespb.Service {
+			return service.ToProto()
+		}),
+		Version: version.NewVersionProto(gotVersion),
+	}, nil
+}
+
+func (s *Service) CreateBatch(ctx context.Context, req *servicespb.CreateBatchRequest) (*servicespb.CreateBatchResponse, error) {
+	zap.L().Debug("ServicesService/CreateBatch", zap.Any("request", req))
+
+	if err := s.validateCreateBatch(req); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "validating request: %v", err)
+	}
+
+	services := lo.Map(req.GetServices(), func(service *servicespb.Service, _ int) *models.Service {
+		serviceModel := models.NewServiceFromProto(service)
+		serviceModel.ID = 0
+		return serviceModel
+	})
+
+	if err := s.controller.CreateBatch(ctx, services); err != nil {
+		return nil, status.Errorf(codes.Internal, "creating services: %v", err)
+	}
+
+	result := lo.Map(services, func(service *models.Service, _ int) *servicespb.Service {
+		return service.ToProto()
+	})
+	return &servicespb.CreateBatchResponse{
+		Services: result,
+	}, nil
+}
+
+func (s *Service) Update(ctx context.Context, req *servicespb.UpdateRequest) (*servicespb.UpdateResponse, error) {
+	zap.L().Debug("ServicesService/Update", zap.Any("request", req))
+
+	if err := s.validateUpdateRequest(req); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "validating request: %v", err)
+	}
+
+	service, newVersion, err := s.controller.Update(ctx, req)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "updating service: %v", err)
+	}
+
+	return &servicespb.UpdateResponse{
+		Service: service.ToProto(),
+		Version: version.NewVersionProto(newVersion),
+	}, nil
+}
diff --git a/internal/dataservice/services/validate.go b/internal/dataservice/services/validate.go
new file mode 100644
index 0000000..2386f65
--- /dev/null
+++ b/internal/dataservice/services/validate.go
@@ -0,0 +1,46 @@
+package services
+
+import (
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+func (s *Service) validateCreateBatch(req *servicespb.CreateBatchRequest) error {
+	if len(req.GetServices()) == 0 {
+		return status.Errorf(codes.InvalidArgument, "services required")
+	}
+	for i, service := range req.GetServices() {
+		if service.GetName() == "" {
+			return status.Errorf(codes.InvalidArgument, "services.%d: name required", i)
+		}
+		if service.GetChecker() == nil {
+			return status.Errorf(codes.InvalidArgument, "services.%d: checker required", i)
+		}
+		checker := service.GetChecker()
+		if checker.GetType() == checkerpb.Type_TYPE_UNSPECIFIED {
+			return status.Errorf(codes.InvalidArgument, "services.%d.checker: type required", i)
+		}
+		if checker.GetPath() == "" {
+			return status.Errorf(codes.InvalidArgument, "services.%d.checker: path required", i)
+		}
+		if checker.GetDefaultTimeout().AsDuration() == 0 {
+			return status.Errorf(codes.InvalidArgument, "services.%d.checker: default_timeout required", i)
+		}
+		for j, action := range checker.GetActions() {
+			if action.GetAction() == checkerpb.Action_ACTION_UNSPECIFIED {
+				return status.Errorf(codes.InvalidArgument, "services.%d.checker.actions.%d: action required", i, j)
+			}
+		}
+	}
+	return nil
+}
+
+func (s *Service) validateUpdateRequest(req *servicespb.UpdateRequest) error {
+	if req.GetId() == 0 {
+		return status.Error(codes.InvalidArgument, "id required")
+	}
+	return nil
+}
diff --git a/internal/dataservice/teams/controller.go b/internal/dataservice/teams/controller.go
new file mode 100644
index 0000000..8b28ba9
--- /dev/null
+++ b/internal/dataservice/teams/controller.go
@@ -0,0 +1,112 @@
+package teams
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/internal/version"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const VersionKey = "teams"
+
+type Controller struct {
+	Versions *version.Controller
+
+	db *bun.DB
+}
+
+func NewController(db *bun.DB, versionController *version.Controller) *Controller {
+	return &Controller{
+		Versions: versionController,
+
+		db: db,
+	}
+}
+
+func (c *Controller) List(ctx context.Context) ([]*models.Team, error) {
+	var teams []*models.Team
+	if err := c.db.NewSelect().Model(&teams).Scan(ctx); err != nil {
+		return nil, fmt.Errorf("getting teams: %w", err)
+	}
+	return teams, nil
+}
+
+func (c *Controller) CreateBatch(ctx context.Context, teams []*models.Team) error {
+	if len(teams) == 0 {
+		return nil
+	}
+
+	if err := c.db.RunInTx(
+		ctx,
+		&sql.TxOptions{},
+		func(ctx context.Context, tx bun.Tx) error {
+			if err := c.db.
+				NewInsert().
+				Model(&teams).
+				On("CONFLICT (name) DO UPDATE").
+				Set("address = EXCLUDED.address").
+				Set("token = EXCLUDED.token").
+				Set("labels = EXCLUDED.labels").
+				Returning("*").
+				Scan(ctx); err != nil {
+				return fmt.Errorf("inserting teams: %w", err)
+			}
+			if _, err := c.Versions.Increment(ctx, tx, VersionKey); err != nil {
+				return fmt.Errorf("incrementing version: %w", err)
+			}
+			return nil
+		},
+	); err != nil {
+		return fmt.Errorf("in transaction: %w", err)
+	}
+
+	return nil
+}
+
+func (c *Controller) Update(ctx context.Context, req *teamspb.UpdateRequest) (*models.Team, int, error) {
+	var team models.Team
+	var newVersion int
+	if err := c.db.RunInTx(
+		ctx,
+		&sql.TxOptions{},
+		func(ctx context.Context, tx bun.Tx) error {
+			query := c.db.NewUpdate().
+				Model(&models.Team{}).
+				Where("id = ?", req.GetId()).
+				Returning("*")
+
+			if req.GetName() != "" {
+				query.Set("name = ?", req.GetName())
+			}
+			if req.GetAddress() != "" {
+				query.Set("address = ?", req.GetAddress())
+			}
+			if req.GetToken() != "" {
+				query.Set("token = ?", req.GetToken())
+			}
+			if req.GetAvatarUrl() != "" {
+				query.Set("avatar_url = ?", req.GetAvatarUrl())
+			}
+
+			if err := query.Model(&team).Scan(ctx); err != nil {
+				return fmt.Errorf("updating team: %w", err)
+			}
+
+			var err error
+			if newVersion, err = c.Versions.Increment(ctx, tx, VersionKey); err != nil {
+				return fmt.Errorf("incrementing version: %w", err)
+			}
+
+			return nil
+		},
+	); err != nil {
+		return nil, 0, fmt.Errorf("in transaction: %w", err)
+	}
+
+	return &team, newVersion, nil
+}
diff --git a/internal/dataservice/teams/service.go b/internal/dataservice/teams/service.go
new file mode 100644
index 0000000..54d08b0
--- /dev/null
+++ b/internal/dataservice/teams/service.go
@@ -0,0 +1,101 @@
+package teams
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/samber/lo"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/internal/version"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+type Service struct {
+	teamspb.UnimplementedTeamsServiceServer
+
+	controller *Controller
+}
+
+func NewService(controller *Controller) *Service {
+	return &Service{
+		controller: controller,
+	}
+}
+
+func (s *Service) List(ctx context.Context, req *teamspb.ListRequest) (*teamspb.ListResponse, error) {
+	zap.L().Debug("TeamsService/List", zap.Any("request", req))
+
+	gotVersion, err := s.controller.Versions.Get(ctx, VersionKey)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "getting version: %v", err)
+	}
+
+	requestedVersion := int(req.GetVersion().GetVersion())
+	if requestedVersion > gotVersion {
+		return nil, status.Errorf(codes.FailedPrecondition, "requested version is greater than current")
+	}
+	if requestedVersion == gotVersion {
+		return &teamspb.ListResponse{Version: version.NewVersionProto(gotVersion)}, nil
+	}
+
+	teams, err := s.controller.List(ctx)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "getting teams: %v", err)
+	}
+
+	return &teamspb.ListResponse{
+		Teams: lo.Map(teams, func(team *models.Team, _ int) *teamspb.Team {
+			return team.ToProto()
+		}),
+		Version: version.NewVersionProto(gotVersion),
+	}, nil
+}
+
+func (s *Service) CreateBatch(ctx context.Context, req *teamspb.CreateBatchRequest) (*teamspb.CreateBatchResponse, error) {
+	zap.L().Debug("TeamsService/CreateBatch", zap.Any("request", req))
+
+	if err := s.validateCreateBatchRequest(req); err != nil {
+		return nil, fmt.Errorf("validating request: %w", err)
+	}
+
+	teams := lo.Map(req.GetTeams(), func(team *teamspb.Team, _ int) *models.Team {
+		teamModel := models.NewTeamFromProto(team)
+		teamModel.ID = 0
+		teamModel.Token = uuid.NewString()
+		return teamModel
+	})
+
+	if err := s.controller.CreateBatch(ctx, teams); err != nil {
+		return nil, status.Errorf(codes.Internal, "creating teams: %v", err)
+	}
+
+	result := lo.Map(teams, func(team *models.Team, _ int) *teamspb.Team {
+		return team.ToProto()
+	})
+	return &teamspb.CreateBatchResponse{
+		Teams: result,
+	}, nil
+}
+
+func (s *Service) Update(ctx context.Context, req *teamspb.UpdateRequest) (*teamspb.UpdateResponse, error) {
+	zap.L().Debug("TeamsService/Update", zap.Any("request", req))
+
+	if err := s.validateUpdateRequest(req); err != nil {
+		return nil, fmt.Errorf("validating request: %w", err)
+	}
+
+	team, newVersion, err := s.controller.Update(ctx, req)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "updating team: %v", err)
+	}
+
+	return &teamspb.UpdateResponse{
+		Team:    team.ToProto(),
+		Version: version.NewVersionProto(newVersion),
+	}, nil
+}
diff --git a/internal/dataservice/teams/validate.go b/internal/dataservice/teams/validate.go
new file mode 100644
index 0000000..f4af302
--- /dev/null
+++ b/internal/dataservice/teams/validate.go
@@ -0,0 +1,30 @@
+package teams
+
+import (
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+func (s *Service) validateCreateBatchRequest(req *teamspb.CreateBatchRequest) error {
+	if len(req.GetTeams()) == 0 {
+		return status.Error(codes.InvalidArgument, "teams required")
+	}
+	for i, team := range req.GetTeams() {
+		if team.GetName() == "" {
+			return status.Errorf(codes.InvalidArgument, "teams.%d: name required", i)
+		}
+		if team.GetAddress() == "" {
+			return status.Errorf(codes.InvalidArgument, "teams.%d: address required", i)
+		}
+	}
+	return nil
+}
+
+func (s *Service) validateUpdateRequest(req *teamspb.UpdateRequest) error {
+	if req.GetId() == 0 {
+		return status.Error(codes.InvalidArgument, "id required")
+	}
+	return nil
+}
diff --git a/internal/gameconfig/checker_action.go b/internal/gameconfig/checker_action.go
new file mode 100644
index 0000000..1d6cb37
--- /dev/null
+++ b/internal/gameconfig/checker_action.go
@@ -0,0 +1,39 @@
+package gameconfig
+
+import (
+	"fmt"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+type CheckerAction checkerpb.Action
+
+//goland:noinspection GoMixedReceiverTypes
+func (a *CheckerAction) UnmarshalYAML(value *yaml.Node) error {
+	var s string
+	if err := value.Decode(&s); err != nil {
+		return fmt.Errorf("decoding checker action as string: %w", err)
+	}
+
+	enumName := fmt.Sprintf("ACTION_%s", strings.ToUpper(s))
+	enumValue, ok := checkerpb.Action_value[enumName]
+	if !ok || enumValue == 0 {
+		return fmt.Errorf("unknown checker action: %s", s)
+	}
+
+	*a = CheckerAction(enumValue)
+	return nil
+}
+
+//goland:noinspection GoMixedReceiverTypes
+func (a CheckerAction) MarshalYAML() (any, error) {
+	enumName, ok := checkerpb.Action_name[int32(a)]
+	if !ok {
+		return nil, fmt.Errorf("unknown checker action: %d", a)
+	}
+
+	return strings.ToLower(strings.TrimPrefix(enumName, "ACTION_")), nil
+}
diff --git a/internal/gameconfig/checker_type.go b/internal/gameconfig/checker_type.go
new file mode 100644
index 0000000..24a78a6
--- /dev/null
+++ b/internal/gameconfig/checker_type.go
@@ -0,0 +1,44 @@
+package gameconfig
+
+import (
+	"fmt"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+type CheckerType checkerpb.Type
+
+//goland:noinspection GoMixedReceiverTypes
+func (t *CheckerType) UnmarshalYAML(value *yaml.Node) error {
+	var s string
+	if err := value.Decode(&s); err != nil {
+		return fmt.Errorf("decoding checker type as string: %w", err)
+	}
+
+	if s == "" {
+		*t = CheckerType(checkerpb.Type_TYPE_LEGACY)
+		return nil
+	}
+
+	enumName := fmt.Sprintf("TYPE_%s", strings.ToUpper(s))
+	enumValue, ok := checkerpb.Type_value[enumName]
+	if !ok || enumValue == 0 {
+		return fmt.Errorf("unknown checker type: %s", s)
+	}
+
+	*t = CheckerType(enumValue)
+	return nil
+}
+
+//goland:noinspection GoMixedReceiverTypes
+func (t CheckerType) MarshalYAML() (any, error) {
+	enumName, ok := checkerpb.Type_name[int32(t)]
+	if !ok {
+		return nil, fmt.Errorf("unknown checker type: %d", t)
+	}
+
+	return strings.ToLower(strings.TrimPrefix(enumName, "TYPE_")), nil
+}
diff --git a/internal/gameconfig/config.go b/internal/gameconfig/config.go
new file mode 100644
index 0000000..17b8d1c
--- /dev/null
+++ b/internal/gameconfig/config.go
@@ -0,0 +1,295 @@
+package gameconfig
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/samber/lo"
+	"go.uber.org/zap"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"gopkg.in/yaml.v3"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+type Game struct {
+	StartTime   time.Time  `yaml:"start_time"`
+	EndTime     *time.Time `yaml:"end_time"`
+	TotalRounds uint32     `yaml:"total_rounds"`
+
+	FlagLifetimeRounds uint32        `yaml:"flag_lifetime_rounds"`
+	RoundDuration      time.Duration `yaml:"round_duration"`
+	Hardness           float64       `yaml:"hardness"`
+	Inflation          bool          `yaml:"inflation"`
+
+	CheckersBasePath string `yaml:"checkers_base_path"`
+}
+
+func (g *Game) Validate() error {
+	if g.StartTime.IsZero() {
+		return errors.New("start_time required")
+	}
+	if g.EndTime != nil && g.EndTime.Before(g.StartTime) {
+		return errors.New("end_time is before start_time")
+	}
+	if g.Hardness <= 0 {
+		return errors.New("hardness must be positive")
+	}
+	if g.CheckersBasePath == "" {
+		g.CheckersBasePath = "checkers"
+	}
+	return nil
+}
+
+func (g *Game) ToCreateRequestProto() *gspb.CreateRequest {
+	res := &gspb.CreateRequest{
+		GameState: &gspb.GameState{
+			StartTime:   timestamppb.New(g.StartTime),
+			TotalRounds: uint64(g.TotalRounds),
+
+			FlagLifetimeRounds: uint64(g.FlagLifetimeRounds),
+			RoundDuration:      durationpb.New(g.RoundDuration),
+			Hardness:           g.Hardness,
+			Inflation:          g.Inflation,
+			Status:             gspb.GameStatus_GAME_STATUS_NOT_STARTED,
+		},
+	}
+
+	if g.EndTime != nil {
+		res.GameState.EndTime = timestamppb.New(*g.EndTime)
+	}
+
+	return res
+}
+
+type Team struct {
+	Name    string            `yaml:"name"`
+	Address string            `yaml:"address"`
+	Labels  map[string]string `yaml:"labels"`
+}
+
+func (t *Team) Validate() error {
+	if t.Name == "" {
+		return errors.New("name required")
+	}
+	if t.Address == "" {
+		return errors.New("address required")
+	}
+	return nil
+}
+
+func (t *Team) ToProto() *teamspb.Team {
+	return &teamspb.Team{
+		Name:    t.Name,
+		Address: t.Address,
+		Labels:  t.Labels,
+	}
+}
+
+type CheckerActionConfig struct {
+	Count   int           `yaml:"count"`
+	Timeout time.Duration `yaml:"timeout"`
+}
+
+type Checker struct {
+	Type CheckerType `yaml:"type"`
+	Path string      `yaml:"path"`
+
+	DefaultTimeout time.Duration                         `yaml:"default_timeout"`
+	Actions        map[CheckerAction]CheckerActionConfig `yaml:"actions"`
+}
+
+func (c *Checker) Validate() error {
+	if c.Type == CheckerType(checkerpb.Type_TYPE_UNSPECIFIED) {
+		c.Type = CheckerType(checkerpb.Type_TYPE_LEGACY)
+	}
+	if c.Path == "" {
+		return errors.New("path required")
+	}
+	if c.DefaultTimeout == 0 {
+		return errors.New("default_timeout required")
+	}
+	return nil
+}
+
+type Service struct {
+	Name         string  `yaml:"name"`
+	DefaultScore float64 `yaml:"default_score"`
+
+	Checker *Checker `yaml:"checker"`
+}
+
+func (s *Service) Validate() error {
+	if s.Name == "" {
+		return errors.New("name required")
+	}
+	if s.DefaultScore == 0 {
+		return errors.New("default_score required")
+	}
+	if s.Checker == nil {
+		s.Checker = &Checker{}
+	}
+	if err := s.Checker.Validate(); err != nil {
+		return fmt.Errorf("checker: %w", err)
+	}
+	return nil
+}
+
+func (s *Service) ToProto() *servicespb.Service {
+	return &servicespb.Service{
+		Name:         s.Name,
+		DefaultScore: s.DefaultScore,
+		Checker: &servicespb.Service_Checker{
+			Type:           checkerpb.Type(s.Checker.Type),
+			Path:           s.Checker.Path,
+			DefaultTimeout: durationpb.New(s.Checker.DefaultTimeout),
+			Actions: lo.MapToSlice(
+				s.Checker.Actions,
+				func(action CheckerAction, actionConfig CheckerActionConfig) *servicespb.Service_Checker_Action {
+					return &servicespb.Service_Checker_Action{
+						Action:   checkerpb.Action(action),
+						RunCount: int64(actionConfig.Count),
+						Timeout:  durationpb.New(actionConfig.Timeout),
+					}
+				},
+			),
+		},
+	}
+}
+
+type FastAD struct {
+	ListenPort    int    `yaml:"listen_port"`
+	LogLevel      string `yaml:"log_level"`
+	IntercomToken string `yaml:"intercom_token"`
+}
+
+func (f *FastAD) Validate() error {
+	if f.ListenPort == 0 {
+		f.ListenPort = 8080
+	}
+	if f.LogLevel == "" {
+		f.LogLevel = "info"
+	}
+	if f.IntercomToken == "" {
+		f.IntercomToken = uuid.NewString()
+		zap.L().Info(
+			"intercom token not provided, generated",
+			zap.String("token", f.IntercomToken),
+		)
+	}
+	return nil
+}
+
+type Admin struct {
+	Username string `yaml:"username"`
+	Password string `yaml:"password"`
+}
+
+func (a *Admin) Validate() error {
+	if a.Username == "" {
+		return errors.New("username required")
+	}
+	if a.Password == "" {
+		return errors.New("password required")
+	}
+	return nil
+}
+
+type Database struct {
+	ExternalDSN         string `yaml:"external_dsn"`
+	TemporalExternalDSN string `yaml:"temporal_external_dsn"`
+}
+
+type GameConfig struct {
+	FastAD   *FastAD   `yaml:"fastad"`
+	Admin    *Admin    `yaml:"admin"`
+	Database *Database `yaml:"database"`
+
+	Game     *Game      `yaml:"game"`
+	Teams    []*Team    `yaml:"teams"`
+	Services []*Service `yaml:"services"`
+}
+
+func (c *GameConfig) Validate() error {
+	if c.FastAD == nil {
+		c.FastAD = &FastAD{}
+	}
+	if err := c.FastAD.Validate(); err != nil {
+		return fmt.Errorf("fastad: %w", err)
+	}
+	if c.Game == nil {
+		return errors.New("game required")
+	}
+	if err := c.Game.Validate(); err != nil {
+		return fmt.Errorf("game: %w", err)
+	}
+
+	if c.Admin == nil {
+		c.Admin = &Admin{
+			Username: "fastad",
+			Password: strings.ReplaceAll(uuid.NewString(), "-", ""),
+		}
+		zap.L().Info(
+			"admin credentials not provided, generated",
+			zap.String("username", c.Admin.Username),
+			zap.String("password", c.Admin.Password),
+		)
+	} else if err := c.Admin.Validate(); err != nil {
+		return fmt.Errorf("admin: %w", err)
+	}
+
+	for i, team := range c.Teams {
+		if team == nil {
+			return fmt.Errorf("team %d: nil", i)
+		}
+		if err := team.Validate(); err != nil {
+			return fmt.Errorf("team %d: %w", i, err)
+		}
+	}
+
+	for i, service := range c.Services {
+		if service == nil {
+			return fmt.Errorf("service %d: nil", i)
+		}
+		if err := service.Validate(); err != nil {
+			return fmt.Errorf("service %d: %w", i, err)
+		}
+	}
+	return nil
+}
+
+func ReadGeneratedConfig() (*GameConfig, error) {
+	root, err := GetFastADRoot()
+	if err != nil {
+		return nil, fmt.Errorf("getting fastad root: %w", err)
+	}
+
+	gameConfig := filepath.Join(root, GeneratedDir, GeneratedGameConfig)
+	configContent, err := os.ReadFile(gameConfig)
+	if errors.Is(err, fs.ErrNotExist) {
+		return nil, fmt.Errorf(
+			"game was not initialized, run 'fastad init' first (config at %s missing)",
+			gameConfig,
+		)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("reading game config: %w", err)
+	}
+
+	var cfg GameConfig
+	if err := yaml.Unmarshal(configContent, &cfg); err != nil {
+		return nil, fmt.Errorf("unmarshaling game config: %w", err)
+	}
+
+	return &cfg, nil
+}
diff --git a/internal/gameconfig/config_test.go b/internal/gameconfig/config_test.go
new file mode 100644
index 0000000..7e31a27
--- /dev/null
+++ b/internal/gameconfig/config_test.go
@@ -0,0 +1,404 @@
+package gameconfig_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+)
+
+func TestGame_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		game    gameconfig.Game
+		wantErr string
+	}{
+		{
+			name:    "missing start_time",
+			game:    gameconfig.Game{Hardness: 10},
+			wantErr: "start_time required",
+		},
+		{
+			name: "end_time before start_time",
+			game: gameconfig.Game{
+				StartTime: time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC),
+				EndTime:   ptrTime(time.Date(2025, 1, 1, 10, 0, 0, 0, time.UTC)),
+				Hardness:  10,
+			},
+			wantErr: "end_time is before start_time",
+		},
+		{
+			name: "zero hardness",
+			game: gameconfig.Game{
+				StartTime: time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC),
+				Hardness:  0,
+			},
+			wantErr: "hardness must be positive",
+		},
+		{
+			name: "negative hardness",
+			game: gameconfig.Game{
+				StartTime: time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC),
+				Hardness:  -5,
+			},
+			wantErr: "hardness must be positive",
+		},
+		{
+			name: "valid game with defaults",
+			game: gameconfig.Game{
+				StartTime: time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC),
+				Hardness:  10,
+			},
+			wantErr: "",
+		},
+		{
+			name: "valid game with end_time",
+			game: gameconfig.Game{
+				StartTime: time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC),
+				EndTime:   ptrTime(time.Date(2025, 1, 1, 18, 0, 0, 0, time.UTC)),
+				Hardness:  10,
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.game.Validate()
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestGame_Validate_DefaultCheckersBasePath(t *testing.T) {
+	g := gameconfig.Game{
+		StartTime:        time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC),
+		Hardness:         10,
+		CheckersBasePath: "",
+	}
+
+	err := g.Validate()
+	require.NoError(t, err)
+	assert.Equal(t, "checkers", g.CheckersBasePath)
+}
+
+func TestTeam_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		team    gameconfig.Team
+		wantErr string
+	}{
+		{
+			name:    "missing name",
+			team:    gameconfig.Team{Address: "10.0.0.1"},
+			wantErr: "name required",
+		},
+		{
+			name:    "missing address",
+			team:    gameconfig.Team{Name: "Team A"},
+			wantErr: "address required",
+		},
+		{
+			name: "valid team",
+			team: gameconfig.Team{
+				Name:    "Team A",
+				Address: "10.0.0.1",
+			},
+			wantErr: "",
+		},
+		{
+			name: "valid team with labels",
+			team: gameconfig.Team{
+				Name:    "Team A",
+				Address: "10.0.0.1",
+				Labels:  map[string]string{"country": "US"},
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.team.Validate()
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestChecker_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		checker gameconfig.Checker
+		wantErr string
+	}{
+		{
+			name:    "missing path",
+			checker: gameconfig.Checker{DefaultTimeout: time.Second * 30},
+			wantErr: "path required",
+		},
+		{
+			name:    "missing default_timeout",
+			checker: gameconfig.Checker{Path: "checker.py"},
+			wantErr: "default_timeout required",
+		},
+		{
+			name: "valid checker",
+			checker: gameconfig.Checker{
+				Path:           "checker.py",
+				DefaultTimeout: time.Second * 30,
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.checker.Validate()
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestService_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		service gameconfig.Service
+		wantErr string
+	}{
+		{
+			name:    "missing name",
+			service: gameconfig.Service{DefaultScore: 2500},
+			wantErr: "name required",
+		},
+		{
+			name:    "missing default_score",
+			service: gameconfig.Service{Name: "test"},
+			wantErr: "default_score required",
+		},
+		{
+			name: "missing checker",
+			service: gameconfig.Service{
+				Name:         "test",
+				DefaultScore: 2500,
+			},
+			wantErr: "path required",
+		},
+		{
+			name: "valid service",
+			service: gameconfig.Service{
+				Name:         "test",
+				DefaultScore: 2500,
+				Checker: &gameconfig.Checker{
+					Path:           "checker.py",
+					DefaultTimeout: time.Second * 30,
+				},
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.service.Validate()
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestFastAD_Validate(t *testing.T) {
+	t.Run("defaults are set", func(t *testing.T) {
+		f := gameconfig.FastAD{}
+		err := f.Validate()
+		require.NoError(t, err)
+
+		assert.Equal(t, 8080, f.ListenPort)
+		assert.Equal(t, "info", f.LogLevel)
+		assert.NotEmpty(t, f.IntercomToken)
+	})
+
+	t.Run("preserves existing values", func(t *testing.T) {
+		f := gameconfig.FastAD{
+			ListenPort:    9090,
+			LogLevel:      "debug",
+			IntercomToken: "my-token",
+		}
+		err := f.Validate()
+		require.NoError(t, err)
+
+		assert.Equal(t, 9090, f.ListenPort)
+		assert.Equal(t, "debug", f.LogLevel)
+		assert.Equal(t, "my-token", f.IntercomToken)
+	})
+}
+
+func TestAdmin_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		admin   gameconfig.Admin
+		wantErr string
+	}{
+		{
+			name:    "missing username",
+			admin:   gameconfig.Admin{Password: "secret"},
+			wantErr: "username required",
+		},
+		{
+			name:    "missing password",
+			admin:   gameconfig.Admin{Username: "admin"},
+			wantErr: "password required",
+		},
+		{
+			name: "valid admin",
+			admin: gameconfig.Admin{
+				Username: "admin",
+				Password: "secret",
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.admin.Validate()
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestGameConfig_Validate(t *testing.T) {
+	validGame := &gameconfig.Game{
+		StartTime: time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC),
+		Hardness:  10,
+	}
+
+	validTeam := &gameconfig.Team{
+		Name:    "Team A",
+		Address: "10.0.0.1",
+	}
+
+	validService := &gameconfig.Service{
+		Name:         "test",
+		DefaultScore: 2500,
+		Checker: &gameconfig.Checker{
+			Path:           "checker.py",
+			DefaultTimeout: time.Second * 30,
+		},
+	}
+
+	t.Run("missing game", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{}
+		err := cfg.Validate()
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "game required")
+	})
+
+	t.Run("invalid game", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{
+			Game: &gameconfig.Game{},
+		}
+		err := cfg.Validate()
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "game:")
+	})
+
+	t.Run("nil team in list", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{
+			Game:  validGame,
+			Teams: []*gameconfig.Team{nil},
+		}
+		err := cfg.Validate()
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "team 0: nil")
+	})
+
+	t.Run("invalid team", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{
+			Game:  validGame,
+			Teams: []*gameconfig.Team{{Name: ""}},
+		}
+		err := cfg.Validate()
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "team 0:")
+	})
+
+	t.Run("nil service in list", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{
+			Game:     validGame,
+			Teams:    []*gameconfig.Team{validTeam},
+			Services: []*gameconfig.Service{nil},
+		}
+		err := cfg.Validate()
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "service 0: nil")
+	})
+
+	t.Run("invalid service", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{
+			Game:     validGame,
+			Teams:    []*gameconfig.Team{validTeam},
+			Services: []*gameconfig.Service{{Name: ""}},
+		}
+		err := cfg.Validate()
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "service 0:")
+	})
+
+	t.Run("auto-generates admin credentials", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{
+			Game:     validGame,
+			Teams:    []*gameconfig.Team{validTeam},
+			Services: []*gameconfig.Service{validService},
+		}
+		err := cfg.Validate()
+		require.NoError(t, err)
+		assert.Equal(t, "fastad", cfg.Admin.Username)
+		assert.NotEmpty(t, cfg.Admin.Password)
+		assert.NotContains(t, cfg.Admin.Password, "-")
+	})
+
+	t.Run("valid config", func(t *testing.T) {
+		cfg := &gameconfig.GameConfig{
+			Game: validGame,
+			Admin: &gameconfig.Admin{
+				Username: "admin",
+				Password: "secret",
+			},
+			Teams:    []*gameconfig.Team{validTeam},
+			Services: []*gameconfig.Service{validService},
+		}
+		err := cfg.Validate()
+		require.NoError(t, err)
+	})
+}
+
+func ptrTime(t time.Time) *time.Time {
+	return &t
+}
diff --git a/internal/gameconfig/repo_root.go b/internal/gameconfig/repo_root.go
new file mode 100644
index 0000000..9859809
--- /dev/null
+++ b/internal/gameconfig/repo_root.go
@@ -0,0 +1,32 @@
+package gameconfig
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+const (
+	GeneratedDir        = ".generated"
+	GeneratedGameConfig = "game.yaml"
+)
+
+func GetFastADRoot() (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("getting current working directory: %w", err)
+	}
+
+	for {
+		if _, err := os.Stat(filepath.Join(cwd, ".fastad_root")); err == nil {
+			return cwd, nil
+		}
+
+		if cwd == "/" {
+			return "", errors.New("fastad root not found")
+		}
+
+		cwd = filepath.Dir(cwd)
+	}
+}
diff --git a/internal/handlers/board.go b/internal/handlers/board.go
new file mode 100644
index 0000000..7cbac71
--- /dev/null
+++ b/internal/handlers/board.go
@@ -0,0 +1,67 @@
+package handlers
+
+import (
+	"cmp"
+	"fmt"
+	"net/http"
+	"slices"
+
+	"github.com/labstack/echo/v4"
+	"github.com/samber/lo"
+)
+
+func (s *Service) HandleGetScoreboard() echo.HandlerFunc {
+	return func(c echo.Context) error {
+		bs, err := s.boardBuilder.GetState()
+		if err != nil {
+			return fmt.Errorf("getting scoreboard state: %w", err)
+		}
+
+		return ProtoJSON(c, http.StatusOK, bs.Scoreboard)
+	}
+}
+
+func (s *Service) HandleGetCTFTimeScoreboard() echo.HandlerFunc {
+	type ctftimeTeamState struct {
+		Pos   int     `json:"pos"`
+		Team  string  `json:"team"`
+		Score float64 `json:"score"`
+	}
+
+	type response struct {
+		Standings []*ctftimeTeamState `json:"standings"`
+	}
+
+	return func(c echo.Context) error {
+		bs, err := s.boardBuilder.GetState()
+		if err != nil {
+			return fmt.Errorf("building scoreboard state: %w", err)
+		}
+
+		teamStates := make(map[int64]*ctftimeTeamState)
+		for _, team := range bs.Teams {
+			teamStates[team.GetId()] = &ctftimeTeamState{
+				Team:  team.GetName(),
+				Score: 0,
+			}
+		}
+		for _, tss := range bs.Scoreboard.GetTeamServiceStates() {
+			sla := 0.0
+			if total := tss.GetChecksTotal(); total > 0 {
+				sla = float64(tss.GetChecksPassed()) / float64(total)
+			}
+			teamStates[tss.GetTeamId()].Score += tss.GetPoints() * sla
+		}
+
+		teamStatesList := lo.Values(teamStates)
+		slices.SortFunc(teamStatesList, func(t1, t2 *ctftimeTeamState) int {
+			return cmp.Compare(t2.Score, t1.Score)
+		})
+
+		for i, teamState := range teamStatesList {
+			teamState.Pos = i + 1
+		}
+
+		return c.JSON(http.StatusOK, response{Standings: teamStatesList})
+	}
+}
diff --git a/internal/handlers/board_builder.go b/internal/handlers/board_builder.go
new file mode 100644
index 0000000..b495267
--- /dev/null
+++ b/internal/handlers/board_builder.go
@@ -0,0 +1,193 @@
+package handlers
+
+import (
+	"cmp"
+	"context"
+	"fmt"
+	"slices"
+	"sync"
+	"time"
+
+	"github.com/samber/lo"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/internal/centutil"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	"github.com/c4t-but-s4d/fastad/pkg/httpext"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+	scoreboardpb "github.com/c4t-but-s4d/fastad/pkg/proto/scoreboard"
+	slacpb "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+)
+
+const scoreboardRefreshInterval = 2 * time.Second
+
+type ScoreboardState struct {
+	Teams      []*teamspb.Team
+	Services   []*servicespb.Service
+	Scoreboard *scoreboardpb.Scoreboard
+}
+
+type BoardBuilder struct {
+	teamsClient    *teams.Client
+	servicesClient *services.Client
+	receiverClient receiverpb.ReceiverServiceClient
+	slacClient     slacpb.SlacServiceClient
+
+	producer centutil.Producer
+
+	mu sync.RWMutex
+	// Never modify these fields, only replace them with new values.
+	// References to these fields are returned to the caller.
+	teamsCache      []*teamspb.Team
+	servicesCache   []*servicespb.Service
+	scoreboardCache *scoreboardpb.Scoreboard
+
+	logger *zap.Logger
+}
+
+func NewBoardBuilder(
+	teamsClient *teams.Client,
+	servicesClient *services.Client,
+	receiverClient receiverpb.ReceiverServiceClient,
+	slacClient slacpb.SlacServiceClient,
+	producer centutil.Producer,
+) *BoardBuilder {
+	return &BoardBuilder{
+		teamsClient:    teamsClient,
+		servicesClient: servicesClient,
+		receiverClient: receiverClient,
+		slacClient:     slacClient,
+		producer:       producer,
+
+		logger: zap.L().Named("board_builder"),
+	}
+}
+
+func (b *BoardBuilder) Run(ctx context.Context) {
+	ticker := time.NewTicker(scoreboardRefreshInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			b.logger.Debug("scoreboard refreshed")
+			if err := b.refresh(ctx); err != nil {
+				b.logger.Error("refreshing scoreboard", zap.Error(err))
+				break
+			}
+			b.logger.Debug("scoreboard refreshed")
+
+			state, err := b.GetState()
+			if err != nil {
+				b.logger.Error("getting state", zap.Error(err))
+				break
+			}
+
+			b.logger.Debug("publishing state")
+			if err := b.producer.PublishProto(ctx, state.Scoreboard); err != nil {
+				b.logger.Error("publishing state", zap.Error(err))
+			}
+		}
+	}
+}
+
+func (b *BoardBuilder) GetState() (*ScoreboardState, error) {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return &ScoreboardState{
+		Teams:      b.teamsCache,
+		Services:   b.servicesCache,
+		Scoreboard: b.scoreboardCache,
+	}, nil
+}
+
+func (b *BoardBuilder) refresh(ctx context.Context) error {
+	teamsList, err := b.teamsClient.List(ctx)
+	if err != nil {
+		return fmt.Errorf("listing teams: %w", err)
+	}
+
+	servicesList, err := b.servicesClient.List(ctx)
+	if err != nil {
+		return fmt.Errorf("listing services: %w", err)
+	}
+
+	sb, err := b.buildScoreboard(ctx, teamsList, servicesList)
+	if err != nil {
+		return fmt.Errorf("building scoreboard state: %w", err)
+	}
+
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.teamsCache = teamsList
+	b.servicesCache = servicesList
+	b.scoreboardCache = sb
+
+	return nil
+}
+
+func (b *BoardBuilder) buildScoreboard(
+	ctx context.Context,
+	teams []*teamspb.Team,
+	services []*servicespb.Service,
+) (*scoreboardpb.Scoreboard, error) {
+	sbMap := make(map[teamServiceKey]*scoreboardpb.Scoreboard_TeamServiceState)
+	for _, team := range teams {
+		for _, service := range services {
+			key := teamServiceKey{TeamID: team.GetId(), ServiceID: service.GetId()}
+			sbMap[key] = &scoreboardpb.Scoreboard_TeamServiceState{
+				TeamId:    team.GetId(),
+				ServiceId: service.GetId(),
+				Points:    service.GetDefaultScore(),
+			}
+		}
+	}
+
+	slaState, err := b.slacClient.GetState(ctx, &slacpb.GetStateRequest{})
+	if err != nil {
+		return nil, httpext.NewErrorFromStatus(err, "getting slac state")
+	}
+
+	receiverState, err := b.receiverClient.GetState(ctx, &receiverpb.GetStateRequest{})
+	if err != nil {
+		return nil, httpext.NewErrorFromStatus(err, "getting receiver state")
+	}
+
+	for _, tss := range slaState.GetState().GetTeamServiceStates() {
+		key := teamServiceKey{TeamID: tss.GetTeamId(), ServiceID: tss.GetServiceId()}
+		if sbs, ok := sbMap[key]; ok {
+			sbs.ChecksTotal = tss.GetChecksTotal()
+			sbs.ChecksPassed = tss.GetChecksPassed()
+			sbs.CheckStatuses = tss.GetCheckStatuses()
+		}
+	}
+
+	for _, tss := range receiverState.GetState().GetTeamServices() {
+		key := teamServiceKey{TeamID: tss.GetTeamId(), ServiceID: tss.GetServiceId()}
+		if sbs, ok := sbMap[key]; ok {
+			sbs.FlagsStolen = tss.GetFlagsStolen()
+			sbs.FlagsLost = tss.GetFlagsLost()
+			sbs.Points = tss.GetPoints()
+		}
+	}
+
+	states := lo.Values(sbMap)
+	slices.SortFunc(states, func(a, b *scoreboardpb.Scoreboard_TeamServiceState) int {
+		return cmp.Or(
+			cmp.Compare(b.GetPoints(), a.GetPoints()),
+			cmp.Compare(a.GetTeamId(), b.GetTeamId()),
+			cmp.Compare(a.GetServiceId(), b.GetServiceId()),
+		)
+	})
+	return &scoreboardpb.Scoreboard{TeamServiceStates: states}, nil
+}
+
+type teamServiceKey struct {
+	TeamID    int64
+	ServiceID int64
+}
diff --git a/internal/handlers/config.go b/internal/handlers/config.go
new file mode 100644
index 0000000..901e620
--- /dev/null
+++ b/internal/handlers/config.go
@@ -0,0 +1,22 @@
+package handlers
+
+import (
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+)
+
+type Config struct {
+	Installation string `mapstructure:"installation" default:"api"`
+
+	ListenAddress  string `mapstructure:"listen_address" default:":8001"`
+	MetricsAddress string `mapstructure:"metrics_address" default:":3001"`
+
+	IntercomToken string `mapstructure:"intercom_token"`
+
+	Postgres    config.Postgres    `mapstructure:"postgres"`
+	DataService config.DataService `mapstructure:"data_service"`
+
+	ScoreboardChannel string `mapstructure:"scoreboard_channel" default:"scoreboard"`
+
+	ReceiverAddress string `mapstructure:"receiver_address" default:"localhost:8002"`
+	SlacAddress     string `mapstructure:"slac_address" default:"localhost:8003"`
+}
diff --git a/internal/handlers/flags.go b/internal/handlers/flags.go
new file mode 100644
index 0000000..d599063
--- /dev/null
+++ b/internal/handlers/flags.go
@@ -0,0 +1,42 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/c4t-but-s4d/fastad/pkg/httpext"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+)
+
+func (s *Service) HandleSubmitFlags() echo.HandlerFunc {
+	type request struct {
+		Flags []string `json:"flags"`
+	}
+
+	return func(c echo.Context) error {
+		ctx := c.Request().Context()
+
+		var req request
+		if err := c.Bind(&req); err != nil {
+			return httpext.NewErrorf(http.StatusBadRequest, "binding request: %v", err)
+		}
+
+		if len(req.Flags) == 0 {
+			return echo.NewHTTPError(http.StatusBadRequest, "flags are required")
+		}
+
+		resp, err := s.receiverClient.SubmitFlags(
+			ctx,
+			&receiverpb.SubmitFlagsRequest{
+				Flags:     req.Flags,
+				TeamToken: c.Request().Header.Get(TeamTokenHeader),
+			},
+		)
+		if err != nil {
+			return httpext.NewErrorFromStatus(err, "submitting flags")
+		}
+
+		return ProtoJSON(c, http.StatusOK, resp)
+	}
+}
diff --git a/internal/handlers/game.go b/internal/handlers/game.go
new file mode 100644
index 0000000..16105cd
--- /dev/null
+++ b/internal/handlers/game.go
@@ -0,0 +1,58 @@
+package handlers
+
+import (
+	"database/sql"
+	"errors"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/pkg/httpext"
+)
+
+func (s *Service) HandleGetGameState() echo.HandlerFunc {
+	type request struct {
+		Format string `query:"format"`
+	}
+
+	return func(c echo.Context) error {
+		ctx := httpext.ContextFromEcho(c)
+
+		var req request
+		if err := c.Bind(&req); err != nil {
+			return httpext.NewErrorf(http.StatusBadRequest, "parsing request: %v", err)
+		}
+
+		gs, err := s.gameStateClient.Get(ctx)
+		if err != nil {
+			return httpext.NewErrorFromStatus(err, "getting game state")
+		}
+
+		switch req.Format {
+		case "proto":
+			return ProtoRaw(c, http.StatusOK, gs)
+		default:
+			return ProtoJSON(c, http.StatusOK, gs)
+		}
+	}
+}
+
+func (s *Service) HandleGetAttackData() echo.HandlerFunc {
+	return func(c echo.Context) error {
+		ctx := httpext.ContextFromEcho(c)
+
+		var lastSnapshot models.AttackDataSnapshot
+		if err := s.db.NewSelect().
+			Model(&lastSnapshot).
+			OrderExpr("created_at DESC").
+			Scan(ctx); err != nil {
+			if errors.Is(err, sql.ErrNoRows) {
+				return httpext.NewErrorf(http.StatusNotFound, "no attack data snapshots")
+			}
+			return httpext.NewErrorFromStatus(err, "getting last attack data snapshot")
+		}
+
+		return c.JSON(http.StatusOK, lastSnapshot.Payload)
+	}
+}
diff --git a/internal/handlers/service.go b/internal/handlers/service.go
new file mode 100644
index 0000000..37d556d
--- /dev/null
+++ b/internal/handlers/service.go
@@ -0,0 +1,154 @@
+package handlers
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/centrifugal/centrifuge"
+	"github.com/labstack/echo/v4"
+	"github.com/uptrace/bun"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/internal/centutil"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+	slacpb "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+)
+
+type Service struct {
+	config *Config
+
+	db              *bun.DB
+	centNode        *centrifuge.Node
+	teamsClient     *teams.Client
+	servicesClient  *services.Client
+	gameStateClient *gamestate.Client
+	receiverClient  receiverpb.ReceiverServiceClient
+	slacClient      slacpb.SlacServiceClient
+
+	boardBuilder *BoardBuilder
+}
+
+func NewService(
+	cfg *Config,
+	db *bun.DB,
+	centNode *centrifuge.Node,
+	teamsClient *teams.Client,
+	servicesClient *services.Client,
+	gameStateClient *gamestate.Client,
+	receiverClient receiverpb.ReceiverServiceClient,
+	slacClient slacpb.SlacServiceClient,
+	boardBuilder *BoardBuilder,
+) *Service {
+	return &Service{
+		config: cfg,
+
+		db:              db,
+		centNode:        centNode,
+		teamsClient:     teamsClient,
+		servicesClient:  servicesClient,
+		gameStateClient: gameStateClient,
+		receiverClient:  receiverClient,
+		slacClient:      slacClient,
+
+		boardBuilder: boardBuilder,
+	}
+}
+
+func (s *Service) RegisterRoutes(e *echo.Echo) {
+	apiGroup := e.Group("/api")
+	apiGroup.GET("/teams", s.HandleTeamsList())
+	// Team is determined by header, not path param.
+	apiGroup.PUT("/teams", s.HandleTeamUpdate())
+	apiGroup.GET("/teams/:team_id/history", s.HandleTeamHistory())
+	apiGroup.GET("/services", s.HandleServicesList())
+	apiGroup.GET("/scoreboard", s.HandleGetScoreboard())
+	apiGroup.GET("/ctftime", s.HandleGetCTFTimeScoreboard())
+	apiGroup.GET("/game", s.HandleGetGameState())
+
+	// Global handlers.
+	e.GET("/attack_data", s.HandleGetAttackData())
+	e.POST("/flags", s.HandleSubmitFlags())
+
+	wsHandler := centrifuge.NewWebsocketHandler(s.centNode, centrifuge.WebsocketConfig{
+		CheckOrigin: func(*http.Request) bool {
+			return true
+		},
+	})
+	e.Any("/centrifuge/websocket", echo.WrapHandler(wsHandler))
+}
+
+func (s *Service) RegisterNode() {
+	s.centNode.OnConnecting(func(_ context.Context, e centrifuge.ConnectEvent) (centrifuge.ConnectReply, error) {
+		// Anonymous user.
+		if e.Token == "" {
+			return centrifuge.ConnectReply{
+				Credentials: &centrifuge.Credentials{
+					UserID: "",
+				},
+			}, nil
+		}
+
+		// Intercom user.
+		if e.Token != s.config.IntercomToken {
+			return centrifuge.ConnectReply{}, centrifuge.DisconnectInvalidToken
+		}
+
+		userID, err := centutil.ClientNameFromData(e.Data)
+		if err != nil {
+			return centrifuge.ConnectReply{}, centrifuge.DisconnectBadRequest
+		}
+
+		return centrifuge.ConnectReply{
+			Credentials: &centrifuge.Credentials{
+				UserID: userID,
+			},
+		}, nil
+	})
+
+	s.centNode.OnConnect(func(client *centrifuge.Client) {
+		logger := zap.L().With(
+			zap.String("client_id", client.ID()),
+			zap.String("user_id", client.UserID()),
+		)
+
+		transportName := client.Transport().Name()
+		transportProto := client.Transport().Protocol()
+		logger.Debug(
+			"client connected",
+			zap.String("transport", transportName),
+			zap.String("proto", string(transportProto)),
+		)
+
+		// Allow all subscriptions.
+		client.OnSubscribe(func(event centrifuge.SubscribeEvent, callback centrifuge.SubscribeCallback) {
+			logger.Debug(
+				"client subscribed",
+				zap.String("channel", event.Channel),
+			)
+			callback(centrifuge.SubscribeReply{}, nil)
+		})
+
+		// Only allow publishing for authenticated users.
+		if client.UserID() != "" {
+			client.OnPublish(func(event centrifuge.PublishEvent, callback centrifuge.PublishCallback) {
+				logger.Debug(
+					"publish event",
+					zap.Any("channel", event.Channel),
+					zap.ByteString("data", event.Data),
+				)
+				callback(centrifuge.PublishReply{}, nil)
+			})
+		}
+
+		client.OnDisconnect(func(e centrifuge.DisconnectEvent) {
+			logger.Debug(
+				"client disconnected",
+				zap.Uint32("code", e.Code),
+				zap.String("reason", e.Reason),
+			)
+		})
+	})
+}
diff --git a/internal/handlers/services.go b/internal/handlers/services.go
new file mode 100644
index 0000000..1a66954
--- /dev/null
+++ b/internal/handlers/services.go
@@ -0,0 +1,32 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/samber/lo"
+
+	"github.com/c4t-but-s4d/fastad/pkg/httpext"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+func (s *Service) HandleServicesList() echo.HandlerFunc {
+	return func(c echo.Context) error {
+		ctx := httpext.ContextFromEcho(c)
+
+		services, err := s.servicesClient.List(ctx)
+		if err != nil {
+			return httpext.NewErrorFromStatus(err, "listing services")
+		}
+
+		resp := &servicespb.Service_Batch{
+			Services: lo.Map(services, func(service *servicespb.Service, _ int) *servicespb.Service {
+				serviceCloned := service.CloneVT()
+				serviceCloned.Checker = nil
+				return serviceCloned
+			}),
+		}
+
+		return ProtoJSON(c, http.StatusOK, resp)
+	}
+}
diff --git a/internal/handlers/teams.go b/internal/handlers/teams.go
new file mode 100644
index 0000000..9fac3ae
--- /dev/null
+++ b/internal/handlers/teams.go
@@ -0,0 +1,137 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/samber/lo"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/pkg/httpext"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+func (s *Service) HandleTeamsList() echo.HandlerFunc {
+	return func(c echo.Context) error {
+		ctx := httpext.ContextFromEcho(c)
+
+		teams, err := s.teamsClient.List(ctx)
+		if err != nil {
+			return httpext.NewErrorFromStatus(err, "listing teams")
+		}
+
+		resp := &teamspb.Team_Batch{
+			Teams: lo.Map(teams, func(team *teamspb.Team, _ int) *teamspb.Team {
+				teamCloned := team.CloneVT()
+				teamCloned.Token = ""
+				return teamCloned
+			}),
+		}
+
+		return ProtoJSON(c, http.StatusOK, resp)
+	}
+}
+
+func (s *Service) HandleTeamHistory() echo.HandlerFunc {
+	type request struct {
+		TeamID    int `param:"team_id"`
+		ServiceID int `query:"service_id"`
+		Limit     int `query:"limit"`
+	}
+
+	const (
+		defaultLimit = 100
+		maxLimit     = 500
+	)
+
+	// TODO: cache this handler.
+	return func(c echo.Context) error {
+		ctx := httpext.ContextFromEcho(c)
+
+		req := new(request)
+		if err := c.Bind(req); err != nil {
+			return httpext.NewErrorf(
+				http.StatusBadRequest,
+				"binding request: %v",
+				err,
+			)
+		}
+
+		if req.TeamID == 0 {
+			return httpext.NewErrorf(http.StatusBadRequest, "team_id is required")
+		}
+
+		limit := req.Limit
+		if limit <= 0 {
+			limit = defaultLimit
+		}
+
+		query := s.db.
+			NewSelect().
+			Model(&models.CheckerExecution{}).
+			Where("team_id = ?", req.TeamID).
+			OrderExpr("created_at DESC").
+			Limit(min(maxLimit, limit))
+
+		if req.ServiceID != 0 {
+			query.Where("service_id = ?", req.ServiceID)
+		}
+
+		var executions []*models.CheckerExecution
+		if err := query.Scan(ctx, &executions); err != nil {
+			return httpext.NewErrorf(
+				http.StatusInternalServerError,
+				"listing executions: %v",
+				err,
+			)
+		}
+
+		resp := &checkerpb.Execution_Batch{
+			Executions: lo.Map(
+				executions,
+				func(execution *models.CheckerExecution, _ int) *checkerpb.Execution {
+					execution.Private = ""
+					execution.Command = ""
+					return execution.ToProto()
+				},
+			),
+		}
+
+		return ProtoJSON(c, http.StatusOK, resp)
+	}
+}
+
+func (s *Service) HandleTeamUpdate() echo.HandlerFunc {
+	type request struct {
+		AvatarURL *string `json:"avatar_url"`
+	}
+
+	return func(c echo.Context) error {
+		ctx := httpext.ContextFromEcho(c)
+
+		req := new(request)
+		if err := c.Bind(req); err != nil {
+			return httpext.NewErrorf(http.StatusBadRequest, "binding request: %v", err)
+		}
+
+		teamToken := c.Request().Header.Get(TeamTokenHeader)
+		currentTeam, err := s.teamsClient.GetByToken(ctx, teamToken)
+		if err != nil {
+			return httpext.NewErrorFromStatus(err, "getting current team")
+		}
+
+		updateReq := &teamspb.UpdateRequest{Id: currentTeam.GetId()}
+		if req.AvatarURL != nil {
+			updateReq.AvatarUrl = *req.AvatarURL
+		}
+		team, err := s.teamsClient.Update(ctx, updateReq)
+		if err != nil {
+			return httpext.NewErrorFromStatus(err, "updating team")
+		}
+
+		team.Token = ""
+
+		return ProtoJSON(c, http.StatusOK, team)
+	}
+}
diff --git a/internal/handlers/util.go b/internal/handlers/util.go
new file mode 100644
index 0000000..42d727d
--- /dev/null
+++ b/internal/handlers/util.go
@@ -0,0 +1,39 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/c4t-but-s4d/fastad/pkg/httpext"
+)
+
+const TeamTokenHeader = "X-Team-Token"
+
+func ProtoJSON(c echo.Context, code int, msg proto.Message) error {
+	raw, err := protojson.MarshalOptions{EmitUnpopulated: true}.Marshal(msg)
+	if err != nil {
+		return httpext.NewErrorf(
+			http.StatusInternalServerError,
+			"marshaling proto json: %v",
+			err,
+		)
+	}
+
+	return c.JSONBlob(code, raw)
+}
+
+func ProtoRaw(c echo.Context, code int, msg proto.Message) error {
+	raw, err := proto.Marshal(msg)
+	if err != nil {
+		return httpext.NewErrorf(
+			http.StatusInternalServerError,
+			"marshaling teams: %v",
+			err,
+		)
+	}
+
+	return c.Blob(code, "application/octet-stream", raw)
+}
diff --git a/internal/models/attack.go b/internal/models/attack.go
new file mode 100644
index 0000000..2a0f9b4
--- /dev/null
+++ b/internal/models/attack.go
@@ -0,0 +1,43 @@
+package models
+
+import (
+	"time"
+
+	"github.com/uptrace/bun"
+
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+)
+
+type Attack struct {
+	bun.BaseModel `bun:"attacks,alias:a"`
+
+	ID        int       `bun:"id,pk,autoincrement"`
+	CreatedAt time.Time `bun:"created_at,notnull"`
+
+	ServiceID int `bun:"service_id,notnull"`
+
+	AttackerID int `bun:"attacker_id,notnull,unique:attacker_flag_id"`
+	VictimID   int `bun:"victim_id,notnull"`
+	FlagID     int `bun:"flag_id,notnull,unique:attacker_flag_id"`
+
+	AttackerDelta float64 `bun:"attacker_delta,notnull"`
+	VictimDelta   float64 `bun:"victim_delta,notnull"`
+
+	RequestID string `bun:"request_id,notnull,type:uuid"`
+
+	// Foreign keys.
+	Service  *Service `bun:"rel:belongs-to,join:service_id=id"`
+	Attacker *Team    `bun:"rel:belongs-to,join:attacker_id=id"`
+	Victim   *Team    `bun:"rel:belongs-to,join:victim_id=id"`
+	Flag     *Flag    `bun:"rel:belongs-to,join:flag_id=id"`
+}
+
+func (a *Attack) ToNotificationProto() *receiverpb.AttackNotification {
+	return &receiverpb.AttackNotification{
+		ServiceId:     int64(a.ServiceID),
+		AttackerId:    int64(a.AttackerID),
+		VictimId:      int64(a.VictimID),
+		AttackerDelta: a.AttackerDelta,
+		VictimDelta:   a.VictimDelta,
+	}
+}
diff --git a/internal/models/attack_data_snapshot.go b/internal/models/attack_data_snapshot.go
new file mode 100644
index 0000000..9883be3
--- /dev/null
+++ b/internal/models/attack_data_snapshot.go
@@ -0,0 +1,21 @@
+package models
+
+import (
+	"time"
+
+	"github.com/uptrace/bun"
+)
+
+type (
+	ServiceAttackData map[string][]string          // map[team.address][]flag.public
+	AttackDataPayload map[string]ServiceAttackData // map[service.name]map[team.address][]flag.public
+)
+
+type AttackDataSnapshot struct {
+	bun.BaseModel `bun:"attack_data_snapshots,alias:ads"`
+
+	ID        int               `bun:"id,pk,autoincrement"`
+	CreatedAt time.Time         `bun:"created_at,notnull"`
+	Round     uint64            `bun:"round,notnull"`
+	Payload   AttackDataPayload `bun:"payload,type:jsonb,notnull"`
+}
diff --git a/internal/models/checker_execution.go b/internal/models/checker_execution.go
new file mode 100644
index 0000000..8d97f86
--- /dev/null
+++ b/internal/models/checker_execution.go
@@ -0,0 +1,46 @@
+package models
+
+import (
+	"time"
+
+	"github.com/uptrace/bun"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+)
+
+type CheckerExecution struct {
+	bun.BaseModel `bun:"checker_executions,alias:ce"`
+
+	ID int `bun:"id,pk,autoincrement"`
+
+	ExecutionID string `bun:"execution_id,notnull,unique"`
+	TeamID      int    `bun:"team_id,notnull"`
+	ServiceID   int    `bun:"service_id,notnull"`
+
+	Action checkerpb.Action `bun:"action,notnull"`
+	Status checkerpb.Status `bun:"status,notnull"`
+
+	Public  string `bun:"public"`
+	Private string `bun:"private"`
+	Command string `bun:"command"`
+
+	CreatedAt time.Time `bun:"created_at,nullzero,notnull,default:current_timestamp"`
+
+	// Foreign keys.
+	Team    *Team    `bun:"rel:belongs-to,join:team_id=id"`
+	Service *Service `bun:"rel:belongs-to,join:service_id=id"`
+}
+
+func (e *CheckerExecution) ToProto() *checkerpb.Execution {
+	return &checkerpb.Execution{
+		TeamId:    int64(e.TeamID),
+		ServiceId: int64(e.ServiceID),
+		Action:    e.Action,
+		Status:    e.Status,
+		Public:    e.Public,
+		Private:   e.Private,
+		Command:   e.Command,
+		CreatedAt: timestamppb.New(e.CreatedAt),
+	}
+}
diff --git a/internal/models/flag.go b/internal/models/flag.go
new file mode 100644
index 0000000..69579ab
--- /dev/null
+++ b/internal/models/flag.go
@@ -0,0 +1,30 @@
+package models
+
+import (
+	"time"
+
+	"github.com/uptrace/bun"
+)
+
+type Flag struct {
+	bun.BaseModel `bun:"flags,alias:f"`
+
+	ID   int    `bun:"id,pk,autoincrement"`
+	Flag string `bun:"flag,notnull,unique"`
+
+	PutFinished bool   `bun:"put_finished,notnull,default:false"`
+	Public      string `bun:"public"`
+	Private     string `bun:"private"`
+
+	Round uint64 `bun:"round,notnull"`
+
+	TeamID    int `bun:"team_id,notnull"`
+	ServiceID int `bun:"service_id,notnull"`
+
+	// CreatedAt is set to round workflow start.
+	CreatedAt time.Time `bun:"created_at,nullzero,notnull"`
+
+	// Foreign keys.
+	Team    *Team    `bun:"rel:belongs-to,join:team_id=id"`
+	Service *Service `bun:"rel:belongs-to,join:service_id=id"`
+}
diff --git a/internal/models/game_state.go b/internal/models/game_state.go
new file mode 100644
index 0000000..a5d9b0a
--- /dev/null
+++ b/internal/models/game_state.go
@@ -0,0 +1,77 @@
+package models
+
+import (
+	"time"
+
+	"github.com/samber/lo"
+	"github.com/uptrace/bun"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+)
+
+type GameState struct {
+	bun.BaseModel `bun:"game_state,alias:gs"`
+
+	ID int `bun:"id,pk"`
+
+	StartTime   time.Time  `bun:"start_time,notnull"`
+	EndTime     *time.Time `bun:"end_time"`
+	TotalRounds uint64     `bun:"total_rounds"`
+
+	Status gspb.GameStatus `bun:"status,notnull,default:1"`
+
+	FlagLifetimeRounds uint64        `bun:"flag_lifetime_rounds,notnull"`
+	RoundDuration      time.Duration `bun:"round_duration,notnull"`
+
+	Hardness  float64 `bun:"hardness,notnull"`
+	Inflation bool    `bun:"inflation"`
+
+	RunningRound      uint64    `bun:"running_round"`
+	RunningRoundStart time.Time `bun:"running_round_start"`
+}
+
+func NewGameStateFromProto(gs *gspb.GameState) *GameState {
+	res := &GameState{
+		StartTime:   gs.GetStartTime().AsTime(),
+		TotalRounds: gs.GetTotalRounds(),
+
+		Status: gs.GetStatus(),
+
+		FlagLifetimeRounds: gs.GetFlagLifetimeRounds(),
+		RoundDuration:      gs.GetRoundDuration().AsDuration(),
+
+		RunningRound:      gs.GetRunningRound(),
+		RunningRoundStart: gs.GetRunningRoundStart().AsTime(),
+
+		Hardness:  gs.GetHardness(),
+		Inflation: gs.GetInflation(),
+	}
+	if gs.GetEndTime() != nil {
+		res.EndTime = lo.ToPtr(gs.GetEndTime().AsTime())
+	}
+	return res
+}
+
+func (gs *GameState) ToProto() *gspb.GameState {
+	res := &gspb.GameState{
+		StartTime:   timestamppb.New(gs.StartTime),
+		TotalRounds: gs.TotalRounds,
+
+		Status: gs.Status,
+
+		FlagLifetimeRounds: gs.FlagLifetimeRounds,
+		RoundDuration:      durationpb.New(gs.RoundDuration),
+
+		RunningRound:      gs.RunningRound,
+		RunningRoundStart: timestamppb.New(gs.RunningRoundStart),
+
+		Hardness:  gs.Hardness,
+		Inflation: gs.Inflation,
+	}
+	if gs.EndTime != nil {
+		res.EndTime = timestamppb.New(*gs.EndTime)
+	}
+	return res
+}
diff --git a/internal/models/processor_state.go b/internal/models/processor_state.go
new file mode 100644
index 0000000..042cd0f
--- /dev/null
+++ b/internal/models/processor_state.go
@@ -0,0 +1,17 @@
+package models
+
+import (
+	"time"
+
+	"github.com/uptrace/bun"
+)
+
+type SlacProcessedItem struct {
+	bun.BaseModel `bun:"slac_processed_items,alias:spi"`
+
+	ID                 int       `bun:"id,pk,autoincrement"`
+	CheckerExecutionID int       `bun:"checker_execution_id,unique"`
+	ProcessedAt        time.Time `bun:"processed_at"`
+
+	CheckerExecution *CheckerExecution `bun:"rel:belongs-to,join:checker_execution_id=id"`
+}
diff --git a/internal/models/scheduler_state.go b/internal/models/scheduler_state.go
new file mode 100644
index 0000000..4758027
--- /dev/null
+++ b/internal/models/scheduler_state.go
@@ -0,0 +1,14 @@
+package models
+
+import (
+	"time"
+
+	"github.com/uptrace/bun"
+)
+
+type SchedulerState struct {
+	bun.BaseModel `bun:"scheduler_states,alias:ss"`
+
+	SchedulerID     string    `bun:"scheduler_id,pk"`
+	ExpectedNextRun time.Time `bun:"expected_next_run"`
+}
diff --git a/internal/models/service.go b/internal/models/service.go
new file mode 100644
index 0000000..5972369
--- /dev/null
+++ b/internal/models/service.go
@@ -0,0 +1,87 @@
+package models
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/samber/lo"
+	"github.com/uptrace/bun"
+	"google.golang.org/protobuf/types/known/durationpb"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+type ServiceActionConfig struct {
+	Timeout  time.Duration `json:"timeout"`
+	RunCount int           `json:"run_count"`
+}
+
+type Service struct {
+	bun.BaseModel `bun:"services,alias:s"`
+
+	ID   int    `bun:"id,pk,autoincrement"`
+	Name string `bun:"name,notnull,unique"`
+
+	CheckerType checkerpb.Type `bun:"checker_type,notnull"`
+	CheckerPath string         `bun:"checker_path,notnull"`
+
+	DefaultScore float64 `bun:"default_score,notnull"`
+
+	DefaultTimeout time.Duration                             `bun:"default_timeout,notnull"`
+	Actions        map[checkerpb.Action]*ServiceActionConfig `bun:"actions,type:jsonb,notnull"`
+
+	Disabled bool `bun:"disabled,notnull"`
+
+	// TODO: vulns format.
+	// Places int
+}
+
+func (s *Service) String() string {
+	return fmt.Sprintf("Service(name=%s)", s.Name)
+}
+
+func (s *Service) ToProto() *servicespb.Service {
+	return &servicespb.Service{
+		Id:   int64(s.ID),
+		Name: s.Name,
+		Checker: &servicespb.Service_Checker{
+			Type:           s.CheckerType,
+			Path:           s.CheckerPath,
+			DefaultTimeout: durationpb.New(s.DefaultTimeout),
+			Actions: lo.MapToSlice(s.Actions, func(action checkerpb.Action, actionConfig *ServiceActionConfig) *servicespb.Service_Checker_Action {
+				return &servicespb.Service_Checker_Action{
+					Action:   action,
+					RunCount: int64(actionConfig.RunCount),
+					Timeout:  durationpb.New(actionConfig.Timeout),
+				}
+			}),
+		},
+
+		DefaultScore: s.DefaultScore,
+		Disabled:     s.Disabled,
+	}
+}
+
+func NewServiceFromProto(p *servicespb.Service) *Service {
+	return &Service{
+		ID:   int(p.GetId()),
+		Name: p.GetName(),
+
+		CheckerType:    p.GetChecker().GetType(),
+		CheckerPath:    p.GetChecker().GetPath(),
+		DefaultTimeout: p.GetChecker().GetDefaultTimeout().AsDuration(),
+		Actions: lo.SliceToMap(
+			p.GetChecker().GetActions(),
+			func(t *servicespb.Service_Checker_Action) (checkerpb.Action, *ServiceActionConfig) {
+				return t.GetAction(), &ServiceActionConfig{
+					Timeout:  t.GetTimeout().AsDuration(),
+					RunCount: int(t.GetRunCount()),
+				}
+			},
+		),
+
+		DefaultScore: p.GetDefaultScore(),
+		Disabled:     p.GetDisabled(),
+	}
+}
diff --git a/internal/models/team.go b/internal/models/team.go
new file mode 100644
index 0000000..11c4126
--- /dev/null
+++ b/internal/models/team.go
@@ -0,0 +1,46 @@
+package models
+
+import (
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+type Team struct {
+	bun.BaseModel `bun:"teams,alias:t"`
+
+	ID        int               `bun:"id,pk,autoincrement"`
+	Name      string            `bun:"name,notnull,unique"`
+	Address   string            `bun:"address,notnull"`
+	Token     string            `bun:"token,notnull"`
+	Labels    map[string]string `bun:"labels,type:jsonb,notnull"`
+	AvatarURL string            `bun:"avatar_url"`
+}
+
+func (t *Team) String() string {
+	return fmt.Sprintf("Team(name=%s, ip=%s)", t.Name, t.Address)
+}
+
+func (t *Team) ToProto() *teamspb.Team {
+	return &teamspb.Team{
+		Id:        int64(t.ID),
+		Name:      t.Name,
+		Address:   t.Address,
+		Token:     t.Token,
+		Labels:    t.Labels,
+		AvatarUrl: t.AvatarURL,
+	}
+}
+
+func NewTeamFromProto(team *teamspb.Team) *Team {
+	return &Team{
+		ID:        int(team.GetId()),
+		Name:      team.GetName(),
+		Address:   team.GetAddress(),
+		Token:     team.GetToken(),
+		Labels:    team.GetLabels(),
+		AvatarURL: team.GetAvatarUrl(),
+	}
+}
diff --git a/internal/models/version.go b/internal/models/version.go
new file mode 100644
index 0000000..a185597
--- /dev/null
+++ b/internal/models/version.go
@@ -0,0 +1,10 @@
+package models
+
+import "github.com/uptrace/bun"
+
+type Version struct {
+	bun.BaseModel `bun:"versions,alias:v"`
+
+	Name    string `bun:"name,pk"`
+	Version int    `bun:"version,notnull"`
+}
diff --git a/internal/pinger/pinger.go b/internal/pinger/pinger.go
index 05f7b7d..f303a90 100644
--- a/internal/pinger/pinger.go
+++ b/internal/pinger/pinger.go
@@ -11,7 +11,7 @@ func New() *Service {
 }
 
 type Service struct {
-	*pingerpb.UnimplementedPingerServiceServer
+	pingerpb.UnimplementedPingerServiceServer
 }
 
 func (*Service) Ping(context.Context, *pingerpb.PingRequest) (*pingerpb.PingResponse, error) {
diff --git a/internal/receiver/config.go b/internal/receiver/config.go
new file mode 100644
index 0000000..1719829
--- /dev/null
+++ b/internal/receiver/config.go
@@ -0,0 +1,19 @@
+package receiver
+
+import (
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+)
+
+type Config struct {
+	Installation string `mapstructure:"installation" default:"receiver"`
+
+	ListenAddress  string `mapstructure:"listen_address" default:":8002"`
+	MetricsAddress string `mapstructure:"metrics_address" default:":3002"`
+
+	Channel       string `mapstructure:"channel" default:"attacks"`
+	IntercomToken string `mapstructure:"intercom_token"`
+
+	Postgres         config.Postgres         `mapstructure:"postgres"`
+	DataService      config.DataService      `mapstructure:"data_service"`
+	CentrifugeClient config.CentrifugeClient `mapstructure:"centrifuge_client"`
+}
diff --git a/internal/receiver/metrics.go b/internal/receiver/metrics.go
new file mode 100644
index 0000000..35b8cad
--- /dev/null
+++ b/internal/receiver/metrics.go
@@ -0,0 +1,121 @@
+package receiver
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+)
+
+type Metrics struct {
+	FlagsSubmitted       *prometheus.CounterVec
+	FlagsProcessed       *prometheus.CounterVec
+	FlagVerdictsDetailed *prometheus.CounterVec
+	AttacksByAttacker    *prometheus.CounterVec
+	AttacksByVictim      *prometheus.CounterVec
+	PointsByService      *prometheus.CounterVec
+	ProcessingTime       *prometheus.HistogramVec
+	SubmissionBatchSize  prometheus.Histogram
+}
+
+func NewMetrics(installation string) *Metrics {
+	constLabels := prometheus.Labels{}
+	if installation != "" {
+		constLabels["installation"] = installation
+	}
+
+	return &Metrics{
+		FlagsSubmitted: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_flags_submitted_total",
+				Help:        "Total number of flags submitted",
+				ConstLabels: constLabels,
+			},
+			[]string{"team_id", "team_name"},
+		),
+		FlagsProcessed: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_flags_processed_total",
+				Help:        "Total number of flags processed by verdict",
+				ConstLabels: constLabels,
+			},
+			[]string{"verdict", "service_id", "service_name"},
+		),
+		FlagVerdictsDetailed: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_flag_verdicts_detailed_total",
+				Help:        "Detailed flag verdicts with attacker, victim, service, and verdict",
+				ConstLabels: constLabels,
+			},
+			[]string{"attacker_id", "attacker_name", "victim_id", "victim_name", "service_id", "service_name", "verdict"},
+		),
+		AttacksByAttacker: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_attacks_by_attacker_total",
+				Help:        "Total successful attacks by attacker team",
+				ConstLabels: constLabels,
+			},
+			[]string{"attacker_id", "attacker_name", "service_id", "service_name"},
+		),
+		AttacksByVictim: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_attacks_by_victim_total",
+				Help:        "Total attacks received by victim team",
+				ConstLabels: constLabels,
+			},
+			[]string{"victim_id", "victim_name", "service_id", "service_name"},
+		),
+		PointsByService: promauto.NewCounterVec(
+			prometheus.CounterOpts{
+				Name:        "fastad_points_transferred_total",
+				Help:        "Total points transferred by service",
+				ConstLabels: constLabels,
+			},
+			[]string{"service_id", "service_name"},
+		),
+		ProcessingTime: promauto.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Name:        "fastad_flag_processing_seconds",
+				Help:        "Time to process flag submission request",
+				ConstLabels: constLabels,
+				Buckets:     prometheus.ExponentialBucketsRange(0.0001, 5, 20),
+			},
+			[]string{"verdict_summary"},
+		),
+		SubmissionBatchSize: promauto.NewHistogram(
+			prometheus.HistogramOpts{
+				Name:        "fastad_flag_submission_batch_size",
+				Help:        "Number of flags per submission request",
+				ConstLabels: constLabels,
+				Buckets:     prometheus.ExponentialBuckets(1, 2, 8),
+			},
+		),
+	}
+}
+
+func (m *Metrics) ObserveSubmission(teamID, teamName string, flagCount int) {
+	m.FlagsSubmitted.WithLabelValues(teamID, teamName).Add(float64(flagCount))
+	m.SubmissionBatchSize.Observe(float64(flagCount))
+}
+
+func (m *Metrics) ObserveVerdict(verdict receiverpb.FlagResponse_Verdict, serviceID, serviceName string) {
+	m.FlagsProcessed.WithLabelValues(verdict.String(), serviceID, serviceName).Inc()
+}
+
+func (m *Metrics) ObserveVerdictDetailed(attackerID, attackerName, victimID, victimName, serviceID, serviceName string, verdict receiverpb.FlagResponse_Verdict) {
+	m.FlagVerdictsDetailed.WithLabelValues(attackerID, attackerName, victimID, victimName, serviceID, serviceName, verdict.String()).Inc()
+}
+
+func (m *Metrics) ObserveAttack(attackerID, attackerName, victimID, victimName, serviceID, serviceName string, points float64) {
+	m.AttacksByAttacker.WithLabelValues(attackerID, attackerName, serviceID, serviceName).Inc()
+	m.AttacksByVictim.WithLabelValues(victimID, victimName, serviceID, serviceName).Inc()
+	m.PointsByService.WithLabelValues(serviceID, serviceName).Add(points)
+}
+
+func (m *Metrics) ObserveProcessingTime(seconds float64, hasAccepted bool) {
+	summary := "rejected"
+	if hasAccepted {
+		summary = "accepted"
+	}
+	m.ProcessingTime.WithLabelValues(summary).Observe(seconds)
+}
diff --git a/internal/receiver/receiver.go b/internal/receiver/receiver.go
index 6f3227e..228747e 100644
--- a/internal/receiver/receiver.go
+++ b/internal/receiver/receiver.go
@@ -2,21 +2,443 @@ package receiver
 
 import (
 	"context"
+	"database/sql"
+	"fmt"
+	"strconv"
+	"sync"
+	"time"
 
-	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
-
+	"github.com/google/uuid"
+	"github.com/samber/lo"
+	"github.com/uptrace/bun"
+	"go.uber.org/zap"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/internal/centutil"
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
 )
 
-func New() *Service {
-	return &Service{}
-}
+const maxFlagsInRequest = 100
+
+const (
+	invalidFlagMessage    = "invalid flag"
+	oldFlagMessage        = "flag is too old"
+	ownFlagMessage        = "flag is your own"
+	serviceInvalidMessage = "service is invalid or disabled"
+	duplicateFlagMessage  = "flag already submitted"
+	notReadyFlagMessage   = "flag is not ready"
+)
 
 type Service struct {
-	*receiverpb.UnimplementedReceiverServiceServer
+	receiverpb.UnimplementedReceiverServiceServer
+
+	db              *bun.DB
+	teamsClient     *teams.Client
+	servicesClient  *services.Client
+	gameStateClient *gamestate.Client
+	producer        centutil.Producer
+	metrics         *Metrics
+
+	stateMu sync.Mutex
+	state   *State
+}
+
+func New(
+	db *bun.DB,
+	teamsClient *teams.Client,
+	servicesClient *services.Client,
+	gameStateClient *gamestate.Client,
+	producer centutil.Producer,
+	metrics *Metrics,
+) *Service {
+	return &Service{
+		db:              db,
+		teamsClient:     teamsClient,
+		servicesClient:  servicesClient,
+		gameStateClient: gameStateClient,
+		state:           NewState(),
+		producer:        producer,
+		metrics:         metrics,
+	}
+}
+
+func (s *Service) SubmitFlags(ctx context.Context, req *receiverpb.SubmitFlagsRequest) (*receiverpb.SubmitFlagsResponse, error) {
+	start := time.Now()
+	zap.L().Debug("Receiver/SubmitFlags", zap.Any("request", req))
+
+	if len(req.GetFlags()) == 0 {
+		return nil, status.Error(codes.InvalidArgument, "no flags")
+	}
+	if len(req.GetFlags()) > maxFlagsInRequest {
+		return nil, status.Errorf(codes.InvalidArgument, "too many flags (max %d)", maxFlagsInRequest)
+	}
+	if req.GetTeamToken() == "" {
+		return nil, status.Error(codes.InvalidArgument, "team token is required")
+	}
+
+	gameState, err := s.gameStateClient.Get(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("fetching game state: %w", err)
+	}
+
+	switch gameState.GetStatus() {
+	case gspb.GameStatus_GAME_STATUS_PAUSED:
+		return nil, status.Error(codes.Unavailable, "game is paused")
+	case gspb.GameStatus_GAME_STATUS_FINISHED:
+		return nil, status.Error(codes.FailedPrecondition, "game is finished")
+	case gspb.GameStatus_GAME_STATUS_NOT_STARTED:
+		return nil, status.Error(codes.FailedPrecondition, "game has not started")
+	case gspb.GameStatus_GAME_STATUS_UNSPECIFIED:
+		return nil, status.Error(codes.FailedPrecondition, "game state is unspecified")
+	case gspb.GameStatus_GAME_STATUS_RUNNING:
+		// Game is running, allow flag submission
+	}
+	// Also check end time even if status is RUNNING
+	if gameState.GetEndTime() != nil && time.Now().After(gameState.GetEndTime().AsTime()) {
+		return nil, status.Error(codes.FailedPrecondition, "game is finished")
+	}
+
+	serviceList, err := s.servicesClient.List(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("fetching services: %w", err)
+	}
+	serviceByID := lo.KeyBy(serviceList, func(srv *servicespb.Service) int {
+		return int(srv.GetId())
+	})
+
+	teamList, err := s.teamsClient.List(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("fetching teams: %w", err)
+	}
+	teamByID := lo.KeyBy(teamList, func(t *teamspb.Team) int {
+		return int(t.GetId())
+	})
+
+	attacker, ok := lo.Find(teamList, func(t *teamspb.Team) bool {
+		return t.GetToken() == req.GetTeamToken()
+	})
+	if !ok {
+		return nil, status.Error(codes.NotFound, "team not found")
+	}
+
+	attacksRequestID := uuid.NewString()
+
+	var addedAttacks []*models.Attack
+
+	uniqueFlags := lo.Uniq(req.GetFlags())
+	resp := &receiverpb.SubmitFlagsResponse{}
+	if err := s.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		var flagModels []*models.Flag
+		if err := tx.
+			NewSelect().
+			Model(&models.Flag{}).
+			ExcludeColumn("public", "private").
+			Where("flag IN (?)", bun.In(uniqueFlags)).
+			Scan(ctx, &flagModels); err != nil {
+			return fmt.Errorf("selecting flags: %w", err)
+		}
+
+		flagByID := lo.KeyBy(flagModels, func(flag *models.Flag) int {
+			return flag.ID
+		})
+
+		haveFlags := lo.Map(flagModels, func(item *models.Flag, _ int) string {
+			return item.Flag
+		})
+		missingFlags, _ := lo.Difference(uniqueFlags, haveFlags)
+		for _, flag := range missingFlags {
+			resp.Responses = append(resp.Responses, &receiverpb.FlagResponse{
+				Flag:    flag,
+				Verdict: receiverpb.FlagResponse_VERDICT_INVALID,
+				Message: invalidFlagMessage,
+			})
+		}
+
+		attacksToAdd := make([]*models.Attack, 0, len(flagModels))
+		attackFlagIDs := make([]int, 0, len(flagModels))
+		for _, flag := range flagModels {
+			baseResponse := &receiverpb.FlagResponse{
+				Flag:      flag.Flag,
+				ServiceId: int64(flag.ServiceID),
+				VictimId:  int64(flag.TeamID),
+			}
+
+			if service, ok := serviceByID[flag.ServiceID]; !ok || service.GetDisabled() {
+				baseResponse.Verdict = receiverpb.FlagResponse_VERDICT_INVALID
+				baseResponse.Message = serviceInvalidMessage
+				resp.Responses = append(resp.Responses, baseResponse)
+				continue
+			}
+
+			if flag.TeamID == int(attacker.GetId()) {
+				baseResponse.Verdict = receiverpb.FlagResponse_VERDICT_OWN
+				baseResponse.Message = ownFlagMessage
+				resp.Responses = append(resp.Responses, baseResponse)
+				continue
+			}
+
+			if gameState.GetRunningRound()-flag.Round > gameState.GetFlagLifetimeRounds() {
+				baseResponse.Verdict = receiverpb.FlagResponse_VERDICT_OLD
+				baseResponse.Message = oldFlagMessage
+				resp.Responses = append(resp.Responses, baseResponse)
+				continue
+			}
+
+			// Allow players to resubmit the flag later when the put is finished.
+			if !flag.PutFinished {
+				baseResponse.Verdict = receiverpb.FlagResponse_VERDICT_FLAG_NOT_READY
+				baseResponse.Message = notReadyFlagMessage
+				resp.Responses = append(resp.Responses, baseResponse)
+				continue
+			}
+
+			attacksToAdd = append(attacksToAdd, &models.Attack{
+				ServiceID:  flag.ServiceID,
+				AttackerID: int(attacker.GetId()),
+				VictimID:   flag.TeamID,
+				FlagID:     flag.ID,
+				RequestID:  attacksRequestID,
+			})
+			attackFlagIDs = append(attackFlagIDs, flag.ID)
+		}
+
+		if len(attacksToAdd) == 0 {
+			return nil
+		}
+
+		if _, err := tx.
+			NewInsert().
+			Model(&attacksToAdd).
+			On("CONFLICT (attacker_id, flag_id) DO NOTHING").
+			Returning("id, flag_id").
+			Exec(ctx); err != nil {
+			return fmt.Errorf("inserting attacks: %w", err)
+		}
+
+		// Filter to only keep actually inserted attacks (have valid DB ID).
+		// Attacks that hit ON CONFLICT DO NOTHING keep ID=0.
+		insertedAttacks := lo.Filter(attacksToAdd, func(a *models.Attack, _ int) bool {
+			return a.ID > 0
+		})
+
+		insertedAttackFlagIDs := lo.Map(insertedAttacks, func(attack *models.Attack, _ int) int {
+			return attack.FlagID
+		})
+
+		duplicateFlagIDs, _ := lo.Difference(attackFlagIDs, insertedAttackFlagIDs)
+		for _, flagID := range duplicateFlagIDs {
+			flag := flagByID[flagID]
+			resp.Responses = append(resp.Responses, &receiverpb.FlagResponse{
+				Flag:      flag.Flag,
+				Verdict:   receiverpb.FlagResponse_VERDICT_DUPLICATE,
+				ServiceId: int64(flag.ServiceID),
+				VictimId:  int64(flag.TeamID),
+				Message:   duplicateFlagMessage,
+			})
+		}
+
+		// Early return if no attacks were actually inserted (all were duplicates).
+		if len(insertedAttacks) == 0 {
+			return nil
+		}
+
+		s.stateMu.Lock()
+		defer s.stateMu.Unlock()
+
+		savedState := s.state.Clone()
+		shouldRollbackState := true
+		defer func() {
+			if shouldRollbackState {
+				s.state = savedState
+			}
+		}()
+
+		for i, attack := range insertedAttacks {
+			if err := s.state.ProcessAttack(gameState, serviceByID[attack.ServiceID], attack); err != nil {
+				return fmt.Errorf("applying attack #%d: %w", i, err)
+			}
+
+			resp.Responses = append(resp.Responses, &receiverpb.FlagResponse{
+				Flag:    flagByID[attack.FlagID].Flag,
+				Verdict: receiverpb.FlagResponse_VERDICT_ACCEPTED,
+				Message: fmt.Sprintf(
+					"attacked team %d and gained %.4f points",
+					attack.VictimID,
+					attack.AttackerDelta,
+				),
+				ServiceId:     int64(attack.ServiceID),
+				VictimId:      int64(attack.VictimID),
+				AttackerDelta: attack.AttackerDelta,
+				VictimDelta:   attack.VictimDelta,
+			})
+		}
+
+		if _, err := tx.
+			NewUpdate().
+			Model(&insertedAttacks).
+			Column("attacker_delta", "victim_delta").
+			Bulk().
+			Exec(ctx); err != nil {
+			return fmt.Errorf("updating attacks' deltas: %w", err)
+		}
+
+		// Intentionally ignoring the potential issue of a missing state rollback in
+		// the improbable case all queries in tx finish but the tx is reverted afterward.
+		shouldRollbackState = false
+		addedAttacks = insertedAttacks
+
+		return nil
+	}); err != nil {
+		return nil, fmt.Errorf("in transaction: %w", err)
+	}
+
+	if len(addedAttacks) > 0 {
+		notification := &receiverpb.AttackNotification_Batch{
+			Attacks: lo.Map(addedAttacks, func(attack *models.Attack, _ int) *receiverpb.AttackNotification {
+				return attack.ToNotificationProto()
+			}),
+		}
+		if err := s.producer.PublishProto(ctx, notification); err != nil {
+			zap.L().Error("publishing attack notification", zap.Error(err))
+		}
+	}
+
+	s.observeMetrics(resp, attacker, teamByID, serviceByID, addedAttacks, time.Since(start).Seconds())
+
+	return resp, nil
+}
+
+func (s *Service) observeMetrics(
+	resp *receiverpb.SubmitFlagsResponse,
+	attacker *teamspb.Team,
+	teamByID map[int]*teamspb.Team,
+	serviceByID map[int]*servicespb.Service,
+	addedAttacks []*models.Attack,
+	durationSeconds float64,
+) {
+	attackerIDStr := strconv.FormatInt(attacker.GetId(), 10)
+	attackerName := attacker.GetName()
+	s.metrics.ObserveSubmission(attackerIDStr, attackerName, len(resp.GetResponses()))
+
+	hasAccepted := false
+	for _, r := range resp.GetResponses() {
+		serviceID := strconv.FormatInt(r.GetServiceId(), 10)
+		serviceName := ""
+		if svc, ok := serviceByID[int(r.GetServiceId())]; ok {
+			serviceName = svc.GetName()
+		}
+
+		victimID := strconv.FormatInt(r.GetVictimId(), 10)
+		victimName := ""
+		if team, ok := teamByID[int(r.GetVictimId())]; ok {
+			victimName = team.GetName()
+		}
+
+		s.metrics.ObserveVerdict(r.GetVerdict(), serviceID, serviceName)
+		s.metrics.ObserveVerdictDetailed(attackerIDStr, attackerName, victimID, victimName, serviceID, serviceName, r.GetVerdict())
+		if r.GetVerdict() == receiverpb.FlagResponse_VERDICT_ACCEPTED {
+			hasAccepted = true
+		}
+	}
+
+	for _, attack := range addedAttacks {
+		victimIDStr := strconv.Itoa(attack.VictimID)
+		victimName := ""
+		if team, ok := teamByID[attack.VictimID]; ok {
+			victimName = team.GetName()
+		}
+
+		serviceIDStr := strconv.Itoa(attack.ServiceID)
+		serviceName := ""
+		if svc, ok := serviceByID[attack.ServiceID]; ok {
+			serviceName = svc.GetName()
+		}
+
+		s.metrics.ObserveAttack(
+			attackerIDStr,
+			attackerName,
+			victimIDStr,
+			victimName,
+			serviceIDStr,
+			serviceName,
+			attack.AttackerDelta,
+		)
+	}
+
+	s.metrics.ObserveProcessingTime(durationSeconds, hasAccepted)
 }
 
-func (s *Service) SubmitFlags(context.Context, *receiverpb.SubmitFlagsRequest) (*receiverpb.SubmitFlagsResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "not implemented yet")
+func (s *Service) GetState(context.Context, *receiverpb.GetStateRequest) (*receiverpb.GetStateResponse, error) {
+	s.stateMu.Lock()
+	defer s.stateMu.Unlock()
+
+	return &receiverpb.GetStateResponse{
+		State: s.state.ToProto(),
+	}, nil
+}
+
+func (s *Service) RestoreState(ctx context.Context) error {
+	serviceList, err := s.servicesClient.List(ctx)
+	if err != nil {
+		return fmt.Errorf("fetching services: %w", err)
+	}
+
+	servicesByID := lo.KeyBy(serviceList, func(service *servicespb.Service) int {
+		return int(service.GetId())
+	})
+
+	start := time.Now()
+
+	if err := s.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		attackCount, err := tx.NewSelect().Model(&models.Attack{}).Count(ctx)
+		if err != nil {
+			return fmt.Errorf("counting attacks: %w", err)
+		}
+
+		zap.L().Info("restoring state from attacks", zap.Int("attack_count", attackCount))
+
+		lastID := -1
+		for {
+			const batchSize = 1000
+			var batch []*models.Attack
+			if err := tx.
+				NewSelect().
+				Model(&models.Attack{}).
+				Where("id > ?", lastID).
+				Order("id").
+				Limit(batchSize).
+				Scan(ctx, &batch); err != nil {
+				return fmt.Errorf("fetching attacks batch: %w", err)
+			}
+			if len(batch) == 0 {
+				break
+			}
+			lastID = batch[len(batch)-1].ID
+
+			zap.L().Info("applying batch of attacks", zap.Int("batch_size", len(batch)))
+			if err := s.state.ApplyRaw(servicesByID, batch...); err != nil {
+				return fmt.Errorf("applying batch of %d attacks to state: %w", len(batch), err)
+			}
+
+			if len(batch) < batchSize {
+				break
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return fmt.Errorf("in tx: %w", err)
+	}
+
+	zap.L().Info("state restored", zap.Duration("duration", time.Since(start)))
+
+	return nil
 }
diff --git a/internal/receiver/state.go b/internal/receiver/state.go
new file mode 100644
index 0000000..5b9b86a
--- /dev/null
+++ b/internal/receiver/state.go
@@ -0,0 +1,175 @@
+package receiver
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/samber/lo"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+)
+
+type TeamServiceState struct {
+	TeamID      int     `json:"team_id"`
+	Points      float64 `json:"points"`
+	FlagsStolen int     `json:"flags_stolen"`
+	FlagsLost   int     `json:"flags_lost"`
+}
+
+func (s *TeamServiceState) ToProto(serviceID int) *receiverpb.State_TeamService {
+	return &receiverpb.State_TeamService{
+		TeamId:      int64(s.TeamID),
+		ServiceId:   int64(serviceID),
+		Points:      s.Points,
+		FlagsStolen: int64(s.FlagsStolen),
+		FlagsLost:   int64(s.FlagsLost),
+	}
+}
+
+func (s *TeamServiceState) Clone() *TeamServiceState {
+	return &TeamServiceState{
+		Points:      s.Points,
+		FlagsStolen: s.FlagsStolen,
+		FlagsLost:   s.FlagsLost,
+	}
+}
+
+type ServiceState struct {
+	ServiceID    int                       `json:"service_id"`
+	DefaultScore float64                   `json:"default_score"`
+	TeamStates   map[int]*TeamServiceState `json:"team_states"`
+}
+
+func newServiceState(service *servicespb.Service) *ServiceState {
+	return &ServiceState{
+		ServiceID:    int(service.GetId()),
+		DefaultScore: service.GetDefaultScore(),
+		TeamStates:   make(map[int]*TeamServiceState),
+	}
+}
+
+func (s *ServiceState) Clone() *ServiceState {
+	return &ServiceState{
+		ServiceID:    s.ServiceID,
+		DefaultScore: s.DefaultScore,
+		TeamStates: lo.MapEntries(s.TeamStates, func(key int, value *TeamServiceState) (int, *TeamServiceState) {
+			return key, value.Clone()
+		}),
+	}
+}
+
+func (s *ServiceState) Apply(gs *gspb.GameState, attack *models.Attack) error {
+	attackerState := s.getOrCreate(attack.AttackerID)
+	victimState := s.getOrCreate(attack.VictimID)
+
+	attackerScore := attackerState.Points
+	victimScore := victimState.Points
+
+	hardness := gs.GetHardness()
+	scale := 50 * math.Sqrt(hardness)
+	norm := math.Log(math.Log(hardness)) / 12
+	ratingDelta := math.Sqrt(attackerScore) - math.Sqrt(victimScore)
+	ratingDeltaNorm := ratingDelta * norm
+	attackerDelta := scale / (1 + math.Exp(ratingDeltaNorm))
+	victimDelta := -min(victimScore, attackerDelta)
+	if !gs.GetInflation() {
+		attackerDelta = min(attackerDelta, -victimDelta)
+	}
+	attack.AttackerDelta = attackerDelta
+	attack.VictimDelta = victimDelta
+
+	attackerState.Points += attackerDelta
+	attackerState.FlagsStolen++
+
+	victimState.Points += victimDelta
+	victimState.FlagsLost++
+
+	return nil
+}
+
+func (s *ServiceState) ApplyRaw(attacks ...*models.Attack) {
+	for _, attack := range attacks {
+		attackerState := s.getOrCreate(attack.AttackerID)
+		victimState := s.getOrCreate(attack.VictimID)
+
+		attackerState.Points += attack.AttackerDelta
+		attackerState.FlagsStolen++
+
+		victimState.Points += attack.VictimDelta
+		victimState.FlagsLost++
+	}
+}
+
+func (s *ServiceState) ToProto() []*receiverpb.State_TeamService {
+	return lo.MapToSlice(s.TeamStates, func(_ int, value *TeamServiceState) *receiverpb.State_TeamService {
+		return value.ToProto(s.ServiceID)
+	})
+}
+
+func (s *ServiceState) getOrCreate(teamID int) *TeamServiceState {
+	res, ok := s.TeamStates[teamID]
+	if !ok {
+		res = &TeamServiceState{TeamID: teamID, Points: s.DefaultScore}
+		s.TeamStates[teamID] = res
+	}
+	return res
+}
+
+type State struct {
+	ServiceStates map[int64]*ServiceState
+}
+
+func NewState() *State {
+	return &State{
+		ServiceStates: make(map[int64]*ServiceState),
+	}
+}
+
+func (s *State) ProcessAttack(gs *gspb.GameState, service *servicespb.Service, attack *models.Attack) error {
+	return s.getOrCreate(service).Apply(gs, attack)
+}
+
+func (s *State) ApplyRaw(services map[int]*servicespb.Service, attacks ...*models.Attack) error {
+	attacksByService := lo.GroupBy(attacks, func(attack *models.Attack) int {
+		return attack.ServiceID
+	})
+
+	for serviceID, serviceAttacks := range attacksByService {
+		service, ok := services[serviceID]
+		if !ok {
+			return fmt.Errorf("missing service id %d", serviceID)
+		}
+		s.getOrCreate(service).ApplyRaw(serviceAttacks...)
+	}
+
+	return nil
+}
+
+func (s *State) Clone() *State {
+	res := &State{
+		ServiceStates: lo.MapEntries(s.ServiceStates, func(key int64, value *ServiceState) (int64, *ServiceState) {
+			return key, value.Clone()
+		}),
+	}
+	return res
+}
+
+func (s *State) ToProto() *receiverpb.State {
+	return &receiverpb.State{
+		TeamServices: lo.Flatten(lo.MapToSlice(s.ServiceStates, func(_ int64, value *ServiceState) []*receiverpb.State_TeamService {
+			return value.ToProto()
+		})),
+	}
+}
+
+func (s *State) getOrCreate(service *servicespb.Service) *ServiceState {
+	ss, ok := s.ServiceStates[service.GetId()]
+	if !ok {
+		ss = newServiceState(service)
+		s.ServiceStates[service.GetId()] = ss
+	}
+	return ss
+}
diff --git a/internal/receiver/state_test.go b/internal/receiver/state_test.go
new file mode 100644
index 0000000..1d6ad20
--- /dev/null
+++ b/internal/receiver/state_test.go
@@ -0,0 +1,429 @@
+package receiver_test
+
+import (
+	"math"
+	"testing"
+
+	"google.golang.org/protobuf/types/known/durationpb"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/internal/receiver"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+func TestNewState(t *testing.T) {
+	state := receiver.NewState()
+
+	if state == nil {
+		t.Fatal("NewState returned nil")
+	}
+	if state.ServiceStates == nil {
+		t.Fatal("ServiceStates map is nil")
+	}
+	if len(state.ServiceStates) != 0 {
+		t.Errorf("expected empty ServiceStates, got %d entries", len(state.ServiceStates))
+	}
+}
+
+func TestState_Clone(t *testing.T) {
+	// Create a state with some data
+	state := receiver.NewState()
+
+	service := &servicespb.Service{
+		Id:           1,
+		DefaultScore: 1000.0,
+	}
+
+	gs := &gspb.GameState{
+		Hardness:      100.0,
+		Inflation:     true,
+		RoundDuration: durationpb.New(60),
+	}
+
+	attack := &models.Attack{
+		ServiceID:  1,
+		AttackerID: 10,
+		VictimID:   20,
+	}
+
+	if err := state.ProcessAttack(gs, service, attack); err != nil {
+		t.Fatalf("ProcessAttack failed: %v", err)
+	}
+
+	// Clone the state
+	cloned := state.Clone()
+
+	// Verify clone is not the same object
+	if cloned == state {
+		t.Error("Clone returned the same object")
+	}
+
+	// Verify cloned state has the same data
+	if len(cloned.ServiceStates) != len(state.ServiceStates) {
+		t.Errorf("expected %d service states, got %d", len(state.ServiceStates), len(cloned.ServiceStates))
+	}
+
+	// Modify the original and verify clone is unaffected
+	attack2 := &models.Attack{
+		ServiceID:  1,
+		AttackerID: 30,
+		VictimID:   40,
+	}
+	if err := state.ProcessAttack(gs, service, attack2); err != nil {
+		t.Fatalf("ProcessAttack failed: %v", err)
+	}
+
+	// Check clone wasn't modified
+	clonedServiceState := cloned.ServiceStates[1]
+	if clonedServiceState == nil {
+		t.Fatal("cloned service state is nil")
+	}
+
+	if len(clonedServiceState.TeamStates) != 2 {
+		t.Errorf("expected 2 team states in clone, got %d", len(clonedServiceState.TeamStates))
+	}
+}
+
+func TestState_ProcessAttack(t *testing.T) {
+	tests := []struct {
+		name          string
+		gs            *gspb.GameState
+		service       *servicespb.Service
+		attack        *models.Attack
+		wantErr       bool
+		checkAttacker func(t *testing.T, attack *models.Attack)
+	}{
+		{
+			name: "basic attack with equal scores",
+			gs: &gspb.GameState{
+				Hardness:  100.0,
+				Inflation: true,
+			},
+			service: &servicespb.Service{
+				Id:           1,
+				DefaultScore: 1000.0,
+			},
+			attack: &models.Attack{
+				ServiceID:  1,
+				AttackerID: 1,
+				VictimID:   2,
+			},
+			wantErr: false,
+			checkAttacker: func(t *testing.T, attack *models.Attack) {
+				t.Helper()
+				// With equal scores and hardness=100, attacker delta should be positive
+				if attack.AttackerDelta <= 0 {
+					t.Errorf("expected positive attacker delta, got %v", attack.AttackerDelta)
+				}
+				// Victim delta should be negative or zero
+				if attack.VictimDelta > 0 {
+					t.Errorf("expected non-positive victim delta, got %v", attack.VictimDelta)
+				}
+			},
+		},
+		{
+			name: "attack without inflation",
+			gs: &gspb.GameState{
+				Hardness:  100.0,
+				Inflation: false,
+			},
+			service: &servicespb.Service{
+				Id:           1,
+				DefaultScore: 1000.0,
+			},
+			attack: &models.Attack{
+				ServiceID:  1,
+				AttackerID: 1,
+				VictimID:   2,
+			},
+			wantErr: false,
+			checkAttacker: func(t *testing.T, attack *models.Attack) {
+				t.Helper()
+				// Without inflation, attacker_delta <= -victim_delta
+				if attack.AttackerDelta > -attack.VictimDelta {
+					t.Errorf("without inflation, attacker delta (%v) should be <= -victim delta (%v)",
+						attack.AttackerDelta, -attack.VictimDelta)
+				}
+			},
+		},
+		{
+			name: "high hardness multiplier",
+			gs: &gspb.GameState{
+				Hardness:  10000.0,
+				Inflation: true,
+			},
+			service: &servicespb.Service{
+				Id:           1,
+				DefaultScore: 1000.0,
+			},
+			attack: &models.Attack{
+				ServiceID:  1,
+				AttackerID: 1,
+				VictimID:   2,
+			},
+			wantErr: false,
+			checkAttacker: func(t *testing.T, attack *models.Attack) {
+				t.Helper()
+				// Higher hardness should give higher deltas
+				if attack.AttackerDelta <= 0 {
+					t.Errorf("expected positive attacker delta with high hardness, got %v", attack.AttackerDelta)
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			state := receiver.NewState()
+
+			err := state.ProcessAttack(tt.gs, tt.service, tt.attack)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ProcessAttack() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if tt.checkAttacker != nil {
+				tt.checkAttacker(t, tt.attack)
+			}
+		})
+	}
+}
+
+func TestState_ApplyRaw(t *testing.T) {
+	state := receiver.NewState()
+
+	services := map[int]*servicespb.Service{
+		1: {Id: 1, DefaultScore: 1000.0},
+		2: {Id: 2, DefaultScore: 500.0},
+	}
+
+	attacks := []*models.Attack{
+		{ServiceID: 1, AttackerID: 10, VictimID: 20, AttackerDelta: 100.0, VictimDelta: -50.0},
+		{ServiceID: 1, AttackerID: 10, VictimID: 30, AttackerDelta: 80.0, VictimDelta: -40.0},
+		{ServiceID: 2, AttackerID: 20, VictimID: 10, AttackerDelta: 60.0, VictimDelta: -30.0},
+	}
+
+	if err := state.ApplyRaw(services, attacks...); err != nil {
+		t.Fatalf("ApplyRaw failed: %v", err)
+	}
+
+	// Verify service 1 state
+	svc1State := state.ServiceStates[1]
+	if svc1State == nil {
+		t.Fatal("service 1 state is nil")
+	}
+
+	// Team 10: attacked twice, +100 +80 = 180 stolen points, 2 flags stolen
+	team10Svc1 := svc1State.TeamStates[10]
+	if team10Svc1 == nil {
+		t.Fatal("team 10 service 1 state is nil")
+	}
+	expectedPoints := 1000.0 + 100.0 + 80.0
+	if math.Abs(team10Svc1.Points-expectedPoints) > 0.001 {
+		t.Errorf("team 10 service 1 points: expected %v, got %v", expectedPoints, team10Svc1.Points)
+	}
+	if team10Svc1.FlagsStolen != 2 {
+		t.Errorf("team 10 service 1 flags stolen: expected 2, got %d", team10Svc1.FlagsStolen)
+	}
+
+	// Team 20: lost 1 flag in service 1, -50 points
+	team20Svc1 := svc1State.TeamStates[20]
+	if team20Svc1 == nil {
+		t.Fatal("team 20 service 1 state is nil")
+	}
+	expectedPoints = 1000.0 - 50.0
+	if math.Abs(team20Svc1.Points-expectedPoints) > 0.001 {
+		t.Errorf("team 20 service 1 points: expected %v, got %v", expectedPoints, team20Svc1.Points)
+	}
+	if team20Svc1.FlagsLost != 1 {
+		t.Errorf("team 20 service 1 flags lost: expected 1, got %d", team20Svc1.FlagsLost)
+	}
+
+	// Verify service 2 state
+	svc2State := state.ServiceStates[2]
+	if svc2State == nil {
+		t.Fatal("service 2 state is nil")
+	}
+
+	// Team 20: attacked once in service 2, +60 points
+	team20Svc2 := svc2State.TeamStates[20]
+	if team20Svc2 == nil {
+		t.Fatal("team 20 service 2 state is nil")
+	}
+	expectedPoints = 500.0 + 60.0
+	if math.Abs(team20Svc2.Points-expectedPoints) > 0.001 {
+		t.Errorf("team 20 service 2 points: expected %v, got %v", expectedPoints, team20Svc2.Points)
+	}
+}
+
+func TestState_ApplyRaw_MissingService(t *testing.T) {
+	state := receiver.NewState()
+
+	services := map[int]*servicespb.Service{
+		1: {Id: 1, DefaultScore: 1000.0},
+	}
+
+	attacks := []*models.Attack{
+		{ServiceID: 99, AttackerID: 10, VictimID: 20, AttackerDelta: 100.0, VictimDelta: -50.0},
+	}
+
+	err := state.ApplyRaw(services, attacks...)
+	if err == nil {
+		t.Error("expected error for missing service, got nil")
+	}
+}
+
+func TestState_ToProto(t *testing.T) {
+	state := receiver.NewState()
+
+	services := map[int]*servicespb.Service{
+		1: {Id: 1, DefaultScore: 1000.0},
+	}
+
+	attacks := []*models.Attack{
+		{ServiceID: 1, AttackerID: 10, VictimID: 20, AttackerDelta: 100.0, VictimDelta: -50.0},
+	}
+
+	if err := state.ApplyRaw(services, attacks...); err != nil {
+		t.Fatalf("ApplyRaw failed: %v", err)
+	}
+
+	proto := state.ToProto()
+	if proto == nil {
+		t.Fatal("ToProto returned nil")
+	}
+
+	// Should have 2 team-service entries (attacker and victim)
+	if len(proto.GetTeamServices()) != 2 {
+		t.Errorf("expected 2 team services, got %d", len(proto.GetTeamServices()))
+	}
+}
+
+func TestTeamServiceState_Clone(t *testing.T) {
+	// We can't directly access TeamServiceState, but we can verify through State.Clone
+	state := receiver.NewState()
+
+	services := map[int]*servicespb.Service{
+		1: {Id: 1, DefaultScore: 1000.0},
+	}
+
+	attacks := []*models.Attack{
+		{ServiceID: 1, AttackerID: 10, VictimID: 20, AttackerDelta: 100.0, VictimDelta: -50.0},
+	}
+
+	if err := state.ApplyRaw(services, attacks...); err != nil {
+		t.Fatalf("ApplyRaw failed: %v", err)
+	}
+
+	cloned := state.Clone()
+
+	// Modify original
+	moreAttacks := []*models.Attack{
+		{ServiceID: 1, AttackerID: 10, VictimID: 30, AttackerDelta: 200.0, VictimDelta: -100.0},
+	}
+	if err := state.ApplyRaw(services, moreAttacks...); err != nil {
+		t.Fatalf("ApplyRaw failed: %v", err)
+	}
+
+	// Verify cloned state wasn't modified
+	clonedTeam10 := cloned.ServiceStates[1].TeamStates[10]
+	originalTeam10 := state.ServiceStates[1].TeamStates[10]
+
+	if clonedTeam10.FlagsStolen == originalTeam10.FlagsStolen {
+		t.Error("cloned state was modified when original was changed")
+	}
+	if clonedTeam10.FlagsStolen != 1 {
+		t.Errorf("cloned team 10 flags stolen: expected 1, got %d", clonedTeam10.FlagsStolen)
+	}
+}
+
+func TestScoringFormula(t *testing.T) {
+	// Test that the scoring formula produces expected results in specific scenarios
+	tests := []struct {
+		name              string
+		hardness          float64
+		inflation         bool
+		attackerScore     float64
+		victimScore       float64
+		wantAttackerRange [2]float64 // min, max expected range
+		wantVictimRange   [2]float64
+	}{
+		{
+			name:              "equal scores",
+			hardness:          100.0,
+			inflation:         true,
+			attackerScore:     1000.0,
+			victimScore:       1000.0,
+			wantAttackerRange: [2]float64{200, 300}, // Approx half of scale
+			wantVictimRange:   [2]float64{-300, -200},
+		},
+		{
+			name:              "attacker stronger",
+			hardness:          100.0,
+			inflation:         true,
+			attackerScore:     2000.0,
+			victimScore:       500.0,
+			wantAttackerRange: [2]float64{100, 300}, // Lower due to rating advantage
+			wantVictimRange:   [2]float64{-300, -100},
+		},
+		{
+			name:              "attacker weaker",
+			hardness:          100.0,
+			inflation:         true,
+			attackerScore:     500.0,
+			victimScore:       2000.0,
+			wantAttackerRange: [2]float64{300, 500}, // Higher due to rating disadvantage
+			wantVictimRange:   [2]float64{-500, -300},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			state := receiver.NewState()
+
+			// Pre-populate scores
+			services := map[int]*servicespb.Service{
+				1: {Id: 1, DefaultScore: tt.attackerScore},
+			}
+
+			gs := &gspb.GameState{
+				Hardness:  tt.hardness,
+				Inflation: tt.inflation,
+			}
+
+			service := services[1]
+
+			// Set up initial state with attacker having different score than default
+			if tt.attackerScore != tt.victimScore {
+				// First establish the victim's score
+				initialAttack := &models.Attack{
+					ServiceID:  1,
+					AttackerID: 2,
+					VictimID:   2,
+				}
+				if err := state.ProcessAttack(gs, service, initialAttack); err != nil {
+					t.Fatalf("ProcessAttack failed: %v", err)
+				}
+			}
+
+			// For simplicity, let's just test with default scores
+			freshState := receiver.NewState()
+			attack := &models.Attack{
+				ServiceID:  1,
+				AttackerID: 1,
+				VictimID:   2,
+			}
+
+			service.DefaultScore = tt.attackerScore
+			if err := freshState.ProcessAttack(gs, service, attack); err != nil {
+				t.Fatalf("ProcessAttack failed: %v", err)
+			}
+
+			if attack.AttackerDelta < tt.wantAttackerRange[0] || attack.AttackerDelta > tt.wantAttackerRange[1] {
+				t.Logf("attacker delta %v outside expected range [%v, %v]",
+					attack.AttackerDelta, tt.wantAttackerRange[0], tt.wantAttackerRange[1])
+			}
+		})
+	}
+}
diff --git a/internal/scheduler/check_manager.go b/internal/scheduler/check_manager.go
new file mode 100644
index 0000000..fa11a5f
--- /dev/null
+++ b/internal/scheduler/check_manager.go
@@ -0,0 +1,222 @@
+package scheduler
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/uptrace/bun"
+	"go.temporal.io/sdk/client"
+	"go.uber.org/atomic"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/teams"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const CheckManagerRefreshInterval = 5 * time.Second
+
+type teamServiceKey struct {
+	teamID    int64
+	serviceID int64
+	action    checkerpb.Action
+}
+
+func (k teamServiceKey) logFields() []zap.Field {
+	return []zap.Field{
+		zap.Int64("team_id", k.teamID),
+		zap.Int64("service_id", k.serviceID),
+		zap.String("action", k.action.String()),
+	}
+}
+
+type CheckManager struct {
+	activeSchedulers map[teamServiceKey]*CheckScheduler
+	cancellers       map[teamServiceKey]context.CancelFunc
+	dones            map[teamServiceKey]chan struct{}
+
+	db              *bun.DB
+	gameStateClient *gamestate.Client
+	teamsClient     *teams.Client
+	servicesClient  *services.Client
+	temporalClient  client.Client
+
+	gameState *atomic.Pointer[gspb.GameState]
+	teams     []*teamspb.Team
+	services  []*servicespb.Service
+
+	logger *zap.Logger
+}
+
+func NewCheckManager(
+	db *bun.DB,
+	gameStateClient *gamestate.Client,
+	teamsClient *teams.Client,
+	servicesClient *services.Client,
+	temporalClient client.Client,
+	logger *zap.Logger,
+) *CheckManager {
+	return &CheckManager{
+		activeSchedulers: make(map[teamServiceKey]*CheckScheduler),
+		cancellers:       make(map[teamServiceKey]context.CancelFunc),
+		dones:            make(map[teamServiceKey]chan struct{}),
+
+		db:              db,
+		gameStateClient: gameStateClient,
+		teamsClient:     teamsClient,
+		servicesClient:  servicesClient,
+		temporalClient:  temporalClient,
+
+		gameState: atomic.NewPointer[gspb.GameState](nil),
+
+		logger: logger.Named("check_manager"),
+	}
+}
+
+func (m *CheckManager) Run(ctx context.Context) error {
+	if err := m.refreshData(ctx); err != nil {
+		return fmt.Errorf("refreshing data: %w", err)
+	}
+
+	refreshTicker := time.NewTicker(CheckManagerRefreshInterval)
+	defer refreshTicker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case <-refreshTicker.C:
+			if err := m.refreshData(ctx); err != nil {
+				m.logger.Error("refreshing data", zap.Error(err))
+			}
+		}
+	}
+}
+
+func (m *CheckManager) syncSchedulers(ctx context.Context) error {
+	needKeys := make(map[teamServiceKey]struct{})
+
+	for _, team := range m.teams {
+		for _, service := range m.services {
+			for _, action := range []checkerpb.Action{checkerpb.Action_ACTION_CHECK, checkerpb.Action_ACTION_GET} {
+				key := teamServiceKey{
+					teamID:    team.GetId(),
+					serviceID: service.GetId(),
+					action:    action,
+				}
+				needKeys[key] = struct{}{}
+
+				logger := m.logger.With(key.logFields()...)
+
+				if current, ok := m.activeSchedulers[key]; ok {
+					logger.Debug("scheduler already exists")
+
+					if current.Team.EqualVT(team) && current.Service.EqualVT(service) {
+						continue
+					}
+
+					logger.Debug("scheduler needs update")
+					m.cancellers[key]()
+					delete(m.activeSchedulers, key)
+					delete(m.cancellers, key)
+
+					logger.Debug("waiting for scheduler to finish")
+					select {
+					case <-m.dones[key]:
+					case <-ctx.Done():
+						return nil
+					}
+					logger.Debug("scheduler finished")
+					delete(m.dones, key)
+				}
+
+				checkScheduler, err := NewCheckScheduler(
+					team,
+					service,
+					action,
+					m.gameState,
+					m.db,
+					m.temporalClient,
+				)
+				if err != nil {
+					return fmt.Errorf("creating check scheduler: %w", err)
+				}
+				m.activeSchedulers[key] = checkScheduler
+
+				runCtx, cancel := context.WithCancel(ctx)
+				m.cancellers[key] = cancel
+				m.dones[key] = make(chan struct{})
+
+				go func() {
+					defer close(m.dones[key])
+					checkScheduler.Run(runCtx)
+				}()
+				logger.Info("scheduler started")
+			}
+		}
+	}
+
+	for key := range m.activeSchedulers {
+		if _, ok := needKeys[key]; !ok {
+			logger := m.logger.With(key.logFields()...)
+			logger.Debug("scheduler needs to be removed")
+
+			m.cancellers[key]()
+			delete(m.activeSchedulers, key)
+			delete(m.cancellers, key)
+
+			logger.Debug("waiting for scheduler to finish")
+			select {
+			case <-m.dones[key]:
+			case <-ctx.Done():
+				return nil
+			}
+			logger.Debug("scheduler finished")
+			delete(m.dones, key)
+		}
+	}
+
+	return nil
+}
+
+func (m *CheckManager) refreshData(ctx context.Context) error {
+	gs, err := m.gameStateClient.Get(ctx)
+	if err != nil {
+		if status.Code(err) == codes.Unavailable {
+			m.gameState.Store(nil)
+			return nil
+		}
+		return fmt.Errorf("getting game state: %w", err)
+	}
+	m.gameState.Store(gs)
+
+	if gs.GetStatus() != gspb.GameStatus_GAME_STATUS_RUNNING {
+		m.logger.Info("game is not running, skipping scheduler sync", zap.String("status", gs.GetStatus().String()))
+		return nil
+	}
+
+	teamsList, err := m.teamsClient.List(ctx)
+	if err != nil {
+		return fmt.Errorf("getting teams: %w", err)
+	}
+	m.teams = teamsList
+
+	servicesList, err := m.servicesClient.List(ctx)
+	if err != nil {
+		return fmt.Errorf("getting services: %w", err)
+	}
+	m.services = servicesList
+
+	if err := m.syncSchedulers(ctx); err != nil {
+		return fmt.Errorf("syncing schedulers: %w", err)
+	}
+
+	return nil
+}
diff --git a/internal/scheduler/check_scheduler.go b/internal/scheduler/check_scheduler.go
new file mode 100644
index 0000000..b671a7c
--- /dev/null
+++ b/internal/scheduler/check_scheduler.go
@@ -0,0 +1,261 @@
+package scheduler
+
+import (
+	"context"
+	safeRand "crypto/rand"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	"math/rand/v2"
+	"time"
+
+	"github.com/uptrace/bun"
+	"go.temporal.io/api/enums/v1"
+	"go.temporal.io/sdk/client"
+	"go.uber.org/atomic"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/internal/checkers"
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/pkg/modelsutil"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+const CheckSchedulerInterval = 1 * time.Second
+
+type CheckScheduler struct {
+	Team    *teamspb.Team
+	Service *servicespb.Service
+	Action  checkerpb.Action // Either CHECK or GET.
+
+	gameState *atomic.Pointer[gspb.GameState]
+
+	schedulerID  string
+	workflowID   string
+	workflowName string
+
+	db             *bun.DB
+	temporalClient client.Client
+	rnd            *rand.Rand
+	checkerTimeout time.Duration
+
+	logger *zap.Logger
+}
+
+func NewCheckScheduler(
+	team *teamspb.Team,
+	service *servicespb.Service,
+	action checkerpb.Action,
+	gameState *atomic.Pointer[gspb.GameState],
+	db *bun.DB,
+	temporalClient client.Client,
+) (*CheckScheduler, error) {
+	s := &CheckScheduler{
+		Team:    team,
+		Service: service,
+		Action:  action,
+
+		gameState: gameState,
+
+		schedulerID: fmt.Sprintf("check_scheduler_%s_%d_%d", action, team.GetId(), service.GetId()),
+		workflowID:  fmt.Sprintf("check_workflow_%s_%d_%d", action, team.GetId(), service.GetId()),
+
+		db:             db,
+		temporalClient: temporalClient,
+		checkerTimeout: modelsutil.ServiceCheckerTimeout(service, action),
+
+		logger: zap.L().Named("check_scheduler").With(
+			zap.Int64("team_id", team.GetId()),
+			zap.Int64("service_id", service.GetId()),
+			zap.String("action", action.String()),
+		),
+	}
+
+	switch action {
+	case checkerpb.Action_ACTION_CHECK:
+		s.workflowName = checkers.CheckWorkflowName
+	case checkerpb.Action_ACTION_GET:
+		s.workflowName = checkers.GetWorkflowName
+	default:
+		return nil, fmt.Errorf("unknown action: %v", action)
+	}
+
+	var seed [32]byte
+	if _, err := io.ReadFull(safeRand.Reader, seed[:]); err != nil {
+		return nil, fmt.Errorf("reading random seed: %w", err)
+	}
+	//nolint:gosec // Non-secure generator is OK here.
+	s.rnd = rand.New(rand.NewChaCha8(seed))
+
+	return s, nil
+}
+
+func (s *CheckScheduler) Run(ctx context.Context) {
+	t := time.NewTicker(CheckSchedulerInterval)
+	defer t.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.C:
+			gs := s.gameState.Load()
+
+			if gs.GetStatus() != gspb.GameStatus_GAME_STATUS_RUNNING {
+				s.logger.Debug("game is not running, skipping check", zap.String("status", gs.GetStatus().String()))
+				if err := s.skipRun(ctx); err != nil {
+					s.logger.Error("skipping scheduler run", zap.Error(err))
+				}
+				continue
+			}
+
+			if gs.GetStartTime().AsTime().After(time.Now()) {
+				s.logger.Debug("game has not started yet, skipping check")
+				if err := s.skipRun(ctx); err != nil {
+					s.logger.Error("skipping scheduler run", zap.Error(err))
+				}
+				continue
+			}
+
+			if s.Action == checkerpb.Action_ACTION_GET && gs.GetRunningRound() <= 1 {
+				s.logger.Debug("skipping GET check on the first round")
+				if err := s.skipRun(ctx); err != nil {
+					s.logger.Error("skipping scheduler run", zap.Error(err))
+				}
+				continue
+			}
+
+			if err := s.TryRunCheck(ctx, gs); err != nil {
+				s.logger.Error("running check", zap.Error(err))
+			}
+		}
+	}
+}
+
+func (s *CheckScheduler) TryRunCheck(ctx context.Context, gs *gspb.GameState) error {
+	now := time.Now()
+
+	var state models.SchedulerState
+	err := s.db.
+		NewSelect().
+		Model(&state).
+		Where("scheduler_id = ?", s.schedulerID).
+		Scan(ctx)
+	if errors.Is(err, sql.ErrNoRows) {
+		s.logger.Debug("no scheduler state found, initializing")
+		state = models.SchedulerState{
+			SchedulerID:     s.schedulerID,
+			ExpectedNextRun: now,
+		}
+		if _, err := s.db.NewInsert().Model(&state).Exec(ctx); err != nil {
+			return fmt.Errorf("inserting initial scheduler state: %w", err)
+		}
+	} else if err != nil {
+		return fmt.Errorf("getting scheduler state: %w", err)
+	}
+
+	lowerInterval := s.checkerTimeout
+	upperInterval := 2 * s.checkerTimeout
+
+	if now.Before(state.ExpectedNextRun) {
+		if state.ExpectedNextRun.Sub(now) > upperInterval {
+			s.logger.Debug(
+				"check is not ready yet, but expected start is too far away",
+				zap.Time("expected_next_run", state.ExpectedNextRun),
+				zap.Duration("checker_timeout", s.checkerTimeout),
+			)
+		} else {
+			s.logger.Debug(
+				"check is not ready yet",
+				zap.Time("expected_next_run", state.ExpectedNextRun),
+				zap.Duration("checker_timeout", s.checkerTimeout),
+			)
+			return nil
+		}
+	}
+
+	s.logger.Info("running workflow")
+	workflowRun, err := s.temporalClient.ExecuteWorkflow(
+		ctx,
+		client.StartWorkflowOptions{
+			// TODO: split the queues for rounds and checks in production.
+			TaskQueue:                                "checkers",
+			ID:                                       s.workflowID,
+			WorkflowIDConflictPolicy:                 enums.WORKFLOW_ID_CONFLICT_POLICY_FAIL,
+			WorkflowIDReusePolicy:                    enums.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE,
+			WorkflowExecutionErrorWhenAlreadyStarted: true,
+		},
+		s.workflowName,
+		s.workflowParams(gs),
+	)
+	if err != nil {
+		return fmt.Errorf("executing workflow: %w", err)
+	}
+
+	s.logger.Info("workflow started, waiting", zap.String("workflow_id", workflowRun.GetID()))
+
+	if err := workflowRun.Get(ctx, nil); err != nil {
+		return fmt.Errorf("waiting for workflow: %w", err)
+	}
+
+	delay := s.randomDelay(lowerInterval, upperInterval)
+	nextRun := state.ExpectedNextRun.Add(delay)
+	if nextRun.Sub(now) > upperInterval {
+		nextRun = now.Add(delay)
+	}
+	s.logger.Info("workflow completed, updating scheduler state", zap.Time("next_run", nextRun))
+	if _, err := s.db.
+		NewUpdate().
+		Model(&state).
+		WherePK().
+		Set("expected_next_run = ?", nextRun).
+		Exec(ctx); err != nil {
+		return fmt.Errorf("updating scheduler state: %w", err)
+	}
+
+	return nil
+}
+
+func (s *CheckScheduler) skipRun(ctx context.Context) error {
+	if _, err := s.db.
+		NewInsert().
+		Model(&models.SchedulerState{
+			SchedulerID:     s.schedulerID,
+			ExpectedNextRun: time.Now().Add(CheckSchedulerInterval),
+		}).
+		On("CONFLICT (scheduler_id) DO UPDATE").
+		Set("expected_next_run = excluded.expected_next_run").
+		Exec(ctx); err != nil {
+		return fmt.Errorf("inserting scheduler state: %w", err)
+	}
+	return nil
+}
+
+func (s *CheckScheduler) randomDelay(minDelay, maxDelay time.Duration) time.Duration {
+	minN := minDelay.Nanoseconds()
+	maxN := maxDelay.Nanoseconds()
+	return time.Duration(s.rnd.Int64N(maxN-minN) + minN)
+}
+
+func (s *CheckScheduler) workflowParams(gs *gspb.GameState) any {
+	switch s.Action {
+	case checkerpb.Action_ACTION_CHECK:
+		return checkers.CheckWorkflowParameters{
+			GameState: gs,
+			Team:      s.Team,
+			Service:   s.Service,
+		}
+	case checkerpb.Action_ACTION_GET:
+		return checkers.GetWorkflowParameters{
+			GameState: gs,
+			Team:      s.Team,
+			Service:   s.Service,
+		}
+	default:
+		panic(fmt.Errorf("unknown action: %v", s.Action))
+	}
+}
diff --git a/internal/scheduler/config.go b/internal/scheduler/config.go
new file mode 100644
index 0000000..2a470b2
--- /dev/null
+++ b/internal/scheduler/config.go
@@ -0,0 +1,17 @@
+package scheduler
+
+import (
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+)
+
+type Config struct {
+	Installation string `mapstructure:"installation" default:"scheduler"`
+
+	MetricsAddress string `mapstructure:"metrics_address" default:":3005"`
+
+	IntercomToken string `mapstructure:"intercom_token"`
+
+	Postgres    config.Postgres    `mapstructure:"postgres"`
+	Temporal    config.Temporal    `mapstructure:"temporal"`
+	DataService config.DataService `mapstructure:"data_service"`
+}
diff --git a/internal/scheduler/round_scheduler.go b/internal/scheduler/round_scheduler.go
new file mode 100644
index 0000000..3f79d08
--- /dev/null
+++ b/internal/scheduler/round_scheduler.go
@@ -0,0 +1,281 @@
+package scheduler
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/uptrace/bun"
+	"go.temporal.io/api/enums/v1"
+	"go.temporal.io/sdk/client"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/internal/checkers"
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	"github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+)
+
+const RoundSchedulerID = "round_scheduler"
+
+const (
+	RoundLateThreshold       = 5 * time.Second
+	CheckRoundInterval       = 1 * time.Second
+	RefreshGameStateInterval = 5 * time.Second
+)
+
+const RoundWorkflowID = "round_workflow"
+
+type RoundScheduler struct {
+	gameStateClient *gamestate.Client
+	temporalClient  client.Client
+
+	db *bun.DB
+
+	gameState *gspb.GameState
+
+	logger *zap.Logger
+}
+
+func NewRoundScheduler(
+	temporalClient client.Client,
+	gameStateClient *gamestate.Client,
+	db *bun.DB,
+	logger *zap.Logger,
+) *RoundScheduler {
+	return &RoundScheduler{
+		temporalClient:  temporalClient,
+		gameStateClient: gameStateClient,
+
+		db: db,
+
+		logger: logger.Named("round_scheduler"),
+	}
+}
+
+func (s *RoundScheduler) Run(ctx context.Context) error {
+	if err := s.refreshGameState(ctx); err != nil {
+		return fmt.Errorf("fetching initial game state: %w", err)
+	}
+
+	refreshTicker := time.NewTicker(RefreshGameStateInterval)
+	defer refreshTicker.Stop()
+
+	checkTicker := time.NewTicker(CheckRoundInterval)
+	defer checkTicker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case <-checkTicker.C:
+			if s.gameState == nil {
+				s.logger.Info("game state is not initialized, skipping round update")
+				continue
+			}
+
+			switch s.gameState.GetStatus() {
+			case gspb.GameStatus_GAME_STATUS_NOT_STARTED:
+				if !s.gameState.GetStartTime().AsTime().After(time.Now()) {
+					s.logger.Info("start_time reached, transitioning game to RUNNING")
+					if err := s.startGame(ctx); err != nil {
+						s.logger.Error("starting game", zap.Error(err))
+					}
+					if err := s.refreshGameState(ctx); err != nil {
+						s.logger.Error("refreshing game state after start", zap.Error(err))
+					}
+				} else {
+					s.logger.Info("game has not started yet, waiting for start_time")
+				}
+				if err := s.skipRun(ctx); err != nil {
+					s.logger.Error("skipping scheduler run", zap.Error(err))
+				}
+				continue
+
+			case gspb.GameStatus_GAME_STATUS_PAUSED:
+				s.logger.Info("game is paused, skipping round update")
+				if err := s.skipRun(ctx); err != nil {
+					s.logger.Error("skipping scheduler run", zap.Error(err))
+				}
+				continue
+
+			case gspb.GameStatus_GAME_STATUS_FINISHED:
+				s.logger.Info("game is finished, skipping round update")
+				if err := s.skipRun(ctx); err != nil {
+					s.logger.Error("skipping scheduler run", zap.Error(err))
+				}
+				continue
+
+			case gspb.GameStatus_GAME_STATUS_RUNNING:
+
+			default:
+				s.logger.Warn("unknown game status, skipping round update", zap.String("status", s.gameState.GetStatus().String()))
+				if err := s.skipRun(ctx); err != nil {
+					s.logger.Error("skipping scheduler run", zap.Error(err))
+				}
+				continue
+			}
+
+			if s.gameState.GetTotalRounds() > 0 && s.gameState.GetRunningRound() >= s.gameState.GetTotalRounds() {
+				s.logger.Info("finishing game, skipping round update")
+				if err := s.finishGame(ctx); err != nil {
+					s.logger.Error("finishing game", zap.Error(err))
+				}
+				continue
+			}
+
+			if s.gameState.GetEndTime() != nil && time.Now().After(s.gameState.GetEndTime().AsTime()) {
+				s.logger.Info("finishing game, skipping round update")
+				if err := s.finishGame(ctx); err != nil {
+					s.logger.Error("finishing game", zap.Error(err))
+				}
+				continue
+			}
+
+			if err := s.TryRunRound(ctx); err != nil {
+				s.logger.Error("running round scheduler", zap.Error(err))
+			}
+
+			if err := s.refreshGameState(ctx); err != nil {
+				s.logger.Error("refreshing game state", zap.Error(err))
+			}
+		case <-refreshTicker.C:
+			if err := s.refreshGameState(ctx); err != nil {
+				s.logger.Error("refreshing game state", zap.Error(err))
+				continue
+			}
+		}
+	}
+}
+
+func (s *RoundScheduler) TryRunRound(ctx context.Context) error {
+	now := time.Now()
+
+	var state models.SchedulerState
+	err := s.db.
+		NewSelect().
+		Model(&state).
+		Where("scheduler_id = ?", RoundSchedulerID).
+		Scan(ctx)
+	if errors.Is(err, sql.ErrNoRows) {
+		s.logger.Debug("no scheduler state found, initializing")
+		state = models.SchedulerState{
+			SchedulerID:     RoundSchedulerID,
+			ExpectedNextRun: now,
+		}
+		if _, err := s.db.NewInsert().Model(&state).Exec(ctx); err != nil {
+			return fmt.Errorf("inserting initial scheduler state: %w", err)
+		}
+	} else if err != nil {
+		return fmt.Errorf("getting scheduler state: %w", err)
+	}
+
+	roundDuration := s.gameState.GetRoundDuration().AsDuration()
+	s.logger.Debug(
+		"checking if ready to run round",
+		zap.Duration("round_duration", roundDuration),
+		zap.Time("expected_start", state.ExpectedNextRun),
+	)
+
+	if now.Before(state.ExpectedNextRun) {
+		s.logger.Debug(
+			"not ready to run round",
+			zap.Time("expected_start", state.ExpectedNextRun),
+			zap.Duration("round_duration", roundDuration),
+		)
+		return nil
+	}
+
+	if lag := now.Sub(state.ExpectedNextRun); lag > RoundLateThreshold {
+		s.logger.Debug(
+			"rounds are running late, trying to catch up",
+			zap.Duration("round_duration", roundDuration),
+			zap.Time("expected_start", state.ExpectedNextRun),
+			zap.Duration("lag", lag),
+		)
+	}
+
+	s.logger.Info("running round workflow")
+	workflowRun, err := s.temporalClient.ExecuteWorkflow(
+		ctx,
+		client.StartWorkflowOptions{
+			TaskQueue:                                "checkers",
+			ID:                                       RoundWorkflowID,
+			WorkflowIDConflictPolicy:                 enums.WORKFLOW_ID_CONFLICT_POLICY_FAIL,
+			WorkflowIDReusePolicy:                    enums.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE,
+			WorkflowExecutionErrorWhenAlreadyStarted: true,
+		},
+		checkers.RoundWorkflowName,
+		checkers.RoundWorkflowParameters{},
+	)
+	if err != nil {
+		return fmt.Errorf("executing workflow: %w", err)
+	}
+
+	s.logger.Info("workflow started, waiting for completion", zap.String("run_id", workflowRun.GetRunID()))
+
+	if err := workflowRun.Get(ctx, nil); err != nil {
+		return fmt.Errorf("waiting for workflow: %w", err)
+	}
+
+	nextRun := state.ExpectedNextRun.Add(roundDuration)
+	s.logger.Info("workflow completed, updating scheduler state", zap.Time("next_run", nextRun))
+	if _, err := s.db.
+		NewUpdate().
+		Model(&state).
+		WherePK().
+		Set("expected_next_run = ?", nextRun).
+		Exec(ctx); err != nil {
+		return fmt.Errorf("updating scheduler state: %w", err)
+	}
+
+	return nil
+}
+
+func (s *RoundScheduler) skipRun(ctx context.Context) error {
+	if _, err := s.db.
+		NewInsert().
+		Model(&models.SchedulerState{
+			SchedulerID:     RoundSchedulerID,
+			ExpectedNextRun: time.Now().Add(CheckRoundInterval),
+		}).
+		On("CONFLICT (scheduler_id) DO UPDATE").
+		Set("expected_next_run = excluded.expected_next_run").
+		Exec(ctx); err != nil {
+		return fmt.Errorf("inserting scheduler state: %w", err)
+	}
+	return nil
+}
+
+func (s *RoundScheduler) refreshGameState(ctx context.Context) error {
+	gs, err := s.gameStateClient.Get(ctx)
+	if err != nil {
+		if status.Code(err) == codes.Unavailable {
+			s.gameState = nil
+			return nil
+		}
+		return fmt.Errorf("getting game state: %w", err)
+	}
+	s.gameState = gs
+	return nil
+}
+
+func (s *RoundScheduler) finishGame(ctx context.Context) error {
+	if _, err := s.gameStateClient.FinishGame(ctx); err != nil {
+		return fmt.Errorf("finishing game: %w", err)
+	}
+	return nil
+}
+
+func (s *RoundScheduler) startGame(ctx context.Context) error {
+	if _, err := s.gameStateClient.Update(ctx, &gspb.UpdateRequest{
+		Status: gspb.GameStatus_GAME_STATUS_RUNNING,
+	}); err != nil {
+		return fmt.Errorf("starting game: %w", err)
+	}
+	return nil
+}
diff --git a/internal/slac/config.go b/internal/slac/config.go
new file mode 100644
index 0000000..fa96c9a
--- /dev/null
+++ b/internal/slac/config.go
@@ -0,0 +1,24 @@
+package slac
+
+import (
+	"time"
+
+	"github.com/c4t-but-s4d/fastad/pkg/config"
+)
+
+type Config struct {
+	Installation string `mapstructure:"installation" default:"slac"`
+
+	ListenAddress  string `mapstructure:"listen_address" default:":8003"`
+	MetricsAddress string `mapstructure:"metrics_address" default:":3003"`
+
+	IntercomToken string `mapstructure:"intercom_token"`
+
+	Postgres config.Postgres `mapstructure:"postgres"`
+
+	CheckInterval            time.Duration `mapstructure:"check_interval" default:"1s"`
+	BatchSize                int           `mapstructure:"batch_size" default:"1000"`
+	ExecutionTXCreateTimeout time.Duration `mapstructure:"execution_tx_create_timeout" default:"5m"`
+	ProcessorStateThreshold  time.Duration `mapstructure:"processor_state_threshold" default:"1m"`
+	TimeCorrectionThreshold  time.Duration `mapstructure:"time_correction_threshold" default:"1m"`
+}
diff --git a/internal/slac/service.go b/internal/slac/service.go
new file mode 100644
index 0000000..b171aa4
--- /dev/null
+++ b/internal/slac/service.go
@@ -0,0 +1,194 @@
+package slac
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"github.com/uptrace/bun"
+	"go.uber.org/atomic"
+	"go.uber.org/zap"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	slacpb "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+)
+
+type Service struct {
+	slacpb.UnimplementedSlacServiceServer
+
+	db     *bun.DB
+	config *Config
+	logger *zap.Logger
+
+	state *atomic.Pointer[State]
+
+	lastProcessorIteration time.Time
+}
+
+func NewService(db *bun.DB, cfg *Config) *Service {
+	return &Service{
+		db:     db,
+		config: cfg,
+
+		state:  atomic.NewPointer(NewState()),
+		logger: zap.L().Named("slac"),
+	}
+}
+
+func (s *Service) GetState(context.Context, *slacpb.GetStateRequest) (*slacpb.GetStateResponse, error) {
+	return &slacpb.GetStateResponse{State: s.state.Load().ToProto()}, nil
+}
+
+func (s *Service) Run(ctx context.Context) {
+	t := time.NewTicker(s.config.CheckInterval)
+	defer t.Stop()
+
+	for {
+		select {
+		case <-t.C:
+			s.logger.Debug("checking")
+			start := time.Now()
+			if err := s.Check(ctx); err != nil {
+				s.logger.Error("check failed", zap.Error(err))
+			}
+			s.logger.Debug("checked", zap.Duration("duration", time.Since(start)))
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (s *Service) Check(ctx context.Context) error {
+	stateClone := s.state.Load().Clone()
+
+	if err := s.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		for {
+			var batch []*models.CheckerExecution
+			query := tx.
+				NewSelect().
+				Model(&batch).
+				Join("LEFT OUTER JOIN slac_processed_items spi ON spi.checker_execution_id = ce.id").
+				Where("spi.id IS NULL").
+				Order("ce.id ASC").
+				Limit(s.config.BatchSize)
+
+			if !s.lastProcessorIteration.IsZero() {
+				// We only need to look through the last executions.
+				// Some executions can reappear in the "ids holes" if the transaction
+				// that inserted them was stuck for some reason.
+				// ExecutionTXCreateTimeout is the estimate of this "stuck" time.
+				// We select only executions that were created after the last check
+				// minus the timeout and minus the threshold ProcessorStateThreshold (just to be safe).
+				// This way JOIN with RIGHT IS NULL filter performs better and is
+				// simpler than the EXCEPT subquery.
+
+				threshold := s.lastProcessorIteration.
+					Add(-s.config.ProcessorStateThreshold).
+					Add(-s.config.ExecutionTXCreateTimeout)
+				query = query.Where("created_at > ?", threshold)
+			}
+
+			if err := query.Scan(ctx); err != nil {
+				return fmt.Errorf("selecting executions: %w", err)
+			}
+
+			if len(batch) == 0 {
+				break
+			}
+
+			itemsToInsert := make([]*models.SlacProcessedItem, 0, len(batch))
+			s.logger.Debug("processing executions batch", zap.Int("batch_size", len(batch)))
+			for _, execution := range batch {
+				stateClone.Apply(execution)
+				itemsToInsert = append(itemsToInsert, &models.SlacProcessedItem{
+					CheckerExecutionID: execution.ID,
+					ProcessedAt:        time.Now(),
+				})
+			}
+
+			if _, err := tx.NewInsert().Model(&itemsToInsert).Exec(ctx); err != nil {
+				return fmt.Errorf("inserting states: %w", err)
+			}
+
+			if len(batch) < s.config.BatchSize {
+				break
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return fmt.Errorf("in tx: %w", err)
+	}
+
+	s.logger.Sugar().Debugf("current state: %+v", stateClone)
+
+	s.state.Store(stateClone)
+	s.lastProcessorIteration = time.Now()
+
+	return nil
+}
+
+func (s *Service) RestoreState(ctx context.Context) error {
+	start := time.Now()
+
+	state := s.state.Load()
+	if err := s.db.RunInTx(ctx, &sql.TxOptions{}, func(ctx context.Context, tx bun.Tx) error {
+		processedExecutionsCount, err := tx.
+			NewSelect().
+			Model(&models.SlacProcessedItem{}).
+			Count(ctx)
+		if err != nil {
+			return fmt.Errorf("counting executions: %w", err)
+		}
+
+		s.logger.Info("restoring state from processed executions", zap.Int("executions_count", processedExecutionsCount))
+
+		if processedExecutionsCount == 0 {
+			return nil
+		}
+
+		lastID := -1
+		for {
+			const batchSize = 1000
+
+			var batch []*models.SlacProcessedItem
+			if err := tx.
+				NewSelect().
+				Model(&models.SlacProcessedItem{}).
+				// No need for INNER JOIN as we pretty much know that all processed executions exist.
+				Relation("CheckerExecution").
+				Where("spi.id > ?", lastID).
+				Order("spi.id").
+				Limit(batchSize).
+				Scan(ctx, &batch); err != nil {
+				return fmt.Errorf("fetching processed executions batch: %w", err)
+			}
+
+			if len(batch) == 0 {
+				break
+			}
+			lastID = batch[len(batch)-1].ID
+			s.lastProcessorIteration = batch[len(batch)-1].ProcessedAt
+
+			s.logger.Info("applying batch of executions", zap.Int("batch_size", len(batch)))
+			for _, item := range batch {
+				state.Apply(item.CheckerExecution)
+			}
+
+			if len(batch) < batchSize {
+				break
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return fmt.Errorf("in tx: %w", err)
+	}
+
+	s.logger.Info("state restored", zap.Duration("duration", time.Since(start)))
+
+	s.state.Store(state)
+
+	return nil
+}
diff --git a/internal/slac/state.go b/internal/slac/state.go
new file mode 100644
index 0000000..5395463
--- /dev/null
+++ b/internal/slac/state.go
@@ -0,0 +1,72 @@
+package slac
+
+import (
+	"github.com/samber/lo"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	slacpb "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+)
+
+const keepLastChecks = 3
+
+type TeamServiceKey struct {
+	TeamID    int
+	ServiceID int
+}
+
+type State struct {
+	TeamServiceStates map[TeamServiceKey]*slacpb.TeamServiceState
+}
+
+func NewState() *State {
+	return &State{
+		TeamServiceStates: make(map[TeamServiceKey]*slacpb.TeamServiceState),
+	}
+}
+
+func (s *State) Apply(execution *models.CheckerExecution) {
+	key := TeamServiceKey{
+		TeamID:    execution.TeamID,
+		ServiceID: execution.ServiceID,
+	}
+
+	tss, ok := s.TeamServiceStates[key]
+
+	if !ok {
+		tss = &slacpb.TeamServiceState{
+			TeamId:    int64(execution.TeamID),
+			ServiceId: int64(execution.ServiceID),
+		}
+		s.TeamServiceStates[key] = tss
+	}
+
+	tss.ChecksTotal++
+	if execution.Status == checkerpb.Status_STATUS_UP {
+		tss.ChecksPassed++
+	}
+	tss.CheckStatuses = append(tss.GetCheckStatuses(), &slacpb.TeamServiceState_CheckStatus{
+		Status:  execution.Status,
+		Message: execution.Public,
+	})
+	if len(tss.GetCheckStatuses()) > keepLastChecks {
+		tss.CheckStatuses = tss.GetCheckStatuses()[len(tss.GetCheckStatuses())-keepLastChecks:]
+	}
+}
+
+func (s *State) Clone() *State {
+	return &State{
+		TeamServiceStates: lo.MapValues(
+			s.TeamServiceStates,
+			func(value *slacpb.TeamServiceState, _ TeamServiceKey) *slacpb.TeamServiceState {
+				return value.CloneVT()
+			},
+		),
+	}
+}
+
+func (s *State) ToProto() *slacpb.State {
+	return &slacpb.State{
+		TeamServiceStates: lo.Values(s.TeamServiceStates),
+	}
+}
diff --git a/internal/version/controller.go b/internal/version/controller.go
new file mode 100644
index 0000000..b8b787f
--- /dev/null
+++ b/internal/version/controller.go
@@ -0,0 +1,54 @@
+package version
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"github.com/uptrace/bun"
+
+	"github.com/c4t-but-s4d/fastad/internal/models"
+)
+
+type Controller struct {
+	db *bun.DB
+}
+
+func NewController(db *bun.DB) *Controller {
+	return &Controller{db: db}
+}
+
+func (c *Controller) Get(ctx context.Context, name string) (int, error) {
+	var v models.Version
+	err := c.db.
+		NewSelect().
+		Model(&v).
+		Where("name = ?", name).
+		Scan(ctx)
+	if errors.Is(err, sql.ErrNoRows) {
+		return 0, nil
+	}
+	if err != nil {
+		return 0, fmt.Errorf("getting version: %w", err)
+	}
+	return v.Version, nil
+}
+
+func (c *Controller) Increment(ctx context.Context, tx bun.Tx, name string) (int, error) {
+	v := &models.Version{
+		Name:    name,
+		Version: 1,
+	}
+	if err := tx.
+		NewInsert().
+		Model(v).
+		On("CONFLICT (name) DO UPDATE").
+		Set("version = v.version + 1").
+		Returning("version").
+		Scan(ctx); err != nil {
+		return 0, fmt.Errorf("inserting version: %w", err)
+	}
+
+	return v.Version, nil
+}
diff --git a/internal/version/utils.go b/internal/version/utils.go
new file mode 100644
index 0000000..ac56e0f
--- /dev/null
+++ b/internal/version/utils.go
@@ -0,0 +1,9 @@
+package version
+
+import versionpb "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+
+func NewVersionProto(version int) *versionpb.Version {
+	return &versionpb.Version{
+		Version: int64(version),
+	}
+}
diff --git a/mise.toml b/mise.toml
new file mode 100644
index 0000000..123ce08
--- /dev/null
+++ b/mise.toml
@@ -0,0 +1,4 @@
+[tools]
+golang = "1.25.5"
+golangci-lint = "2.8.0"
+node = "22.14.0"
diff --git a/pkg/apiwait/grpc.go b/pkg/apiwait/grpc.go
new file mode 100644
index 0000000..cc1abbd
--- /dev/null
+++ b/pkg/apiwait/grpc.go
@@ -0,0 +1,41 @@
+package apiwait
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+// GRPC waits for a gRPC server to become available at the given address.
+// It attempts to establish a TCP connection to verify the server is listening.
+func GRPC(ctx context.Context, address string) error {
+	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	zap.L().Debug("waiting for gRPC server", zap.String("address", address))
+
+	dialer := net.Dialer{}
+	for {
+		if ctx.Err() != nil {
+			return fmt.Errorf("waiting for gRPC server at %s: %w", address, ctx.Err())
+		}
+
+		conn, err := dialer.DialContext(ctx, "tcp", address)
+		if err != nil {
+			zap.L().Debug(
+				"gRPC server not ready",
+				zap.String("address", address),
+				zap.Error(err),
+			)
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+
+		_ = conn.Close()
+		zap.L().Debug("gRPC server is ready", zap.String("address", address))
+		return nil
+	}
+}
diff --git a/pkg/apiwait/http.go b/pkg/apiwait/http.go
new file mode 100644
index 0000000..5063791
--- /dev/null
+++ b/pkg/apiwait/http.go
@@ -0,0 +1,51 @@
+package apiwait
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+// HTTP waits for an HTTP server to become available at the given address.
+// It polls /health until it gets a 200 OK response.
+func HTTP(ctx context.Context, address string) error {
+	ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
+	defer cancel()
+
+	url := fmt.Sprintf("http://%s/healthcheck", address)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return fmt.Errorf("creating request: %w", err)
+	}
+
+	zap.L().Debug("checking health", zap.String("url", url))
+
+	client := http.Client{}
+	for {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		resp, err := client.Do(req)
+		if err != nil {
+			time.Sleep(time.Second)
+			continue
+		}
+		zap.L().Debug(
+			"health check",
+			zap.String("url", url),
+			zap.Int("status", resp.StatusCode),
+		)
+		_ = resp.Body.Close()
+		if resp.StatusCode == http.StatusOK {
+			return nil
+		}
+		if resp.StatusCode >= 500 {
+			time.Sleep(time.Second)
+			continue
+		}
+		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+}
diff --git a/pkg/baseconfig/options.go b/pkg/baseconfig/options.go
new file mode 100644
index 0000000..93ed38c
--- /dev/null
+++ b/pkg/baseconfig/options.go
@@ -0,0 +1,21 @@
+package baseconfig
+
+type SetupConfig struct {
+	envPrefix string
+}
+
+func GetSetupConfig(opts ...SetupOption) *SetupConfig {
+	cfg := &SetupConfig{}
+	for _, opt := range opts {
+		opt(cfg)
+	}
+	return cfg
+}
+
+type SetupOption func(cfg *SetupConfig)
+
+func WithEnvPrefix(envPrefix string) SetupOption {
+	return func(cfg *SetupConfig) {
+		cfg.envPrefix = envPrefix
+	}
+}
diff --git a/pkg/baseconfig/setup.go b/pkg/baseconfig/setup.go
new file mode 100644
index 0000000..9b43b35
--- /dev/null
+++ b/pkg/baseconfig/setup.go
@@ -0,0 +1,70 @@
+package baseconfig
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/creasty/defaults"
+	"github.com/mitchellh/mapstructure"
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
+	"go.uber.org/zap"
+)
+
+func NewViper(envPrefix string) (*viper.Viper, error) {
+	v := viper.NewWithOptions(viper.ExperimentalBindStruct())
+
+	if err := v.BindPFlags(pflag.CommandLine); err != nil {
+		return nil, fmt.Errorf("binding pflags: %w", err)
+	}
+	v.SetEnvPrefix(envPrefix)
+	v.AutomaticEnv()
+	v.SetEnvKeyReplacer(
+		strings.NewReplacer(
+			"-", "_",
+			".", "_",
+		),
+	)
+
+	return v, nil
+}
+
+func Setup[T any](v *viper.Viper, cfg T) (t T, err error) {
+	if err := defaults.Set(cfg); err != nil {
+		return t, fmt.Errorf("setting defaults: %w", err)
+	}
+
+	if err := v.Unmarshal(
+		cfg,
+		viper.DecodeHook(
+			mapstructure.ComposeDecodeHookFunc(
+				mapstructure.TextUnmarshallerHookFunc(),
+				mapstructure.StringToTimeDurationHookFunc(),
+			),
+		),
+	); err != nil {
+		return t, fmt.Errorf("unmarshaling config: %w", err)
+	}
+
+	return cfg, nil
+}
+
+func SetupAll[T any](cfg *T, opts ...SetupOption) (*T, error) {
+	setupConfig := GetSetupConfig(opts...)
+
+	v, err := NewViper(setupConfig.envPrefix)
+	if err != nil {
+		return nil, fmt.Errorf("creating viper: %w", err)
+	}
+
+	return Setup(v, cfg)
+}
+
+func MustSetupAll[T any](cfg *T, opts ...SetupOption) *T {
+	t, err := SetupAll[T](cfg, opts...)
+	if err != nil {
+		zap.L().Fatal("error setting up config", zap.Error(err))
+	}
+
+	return t
+}
diff --git a/pkg/clients/cache/cache.go b/pkg/clients/cache/cache.go
new file mode 100644
index 0000000..d755bd5
--- /dev/null
+++ b/pkg/clients/cache/cache.go
@@ -0,0 +1,83 @@
+package cache
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/c4t-but-s4d/fastad/pkg/clients/metrics"
+	versionpb "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+)
+
+// Fetcher defines how to fetch versioned data from the server.
+// If the provided version matches the server's version, implementations should
+// return (zero value, currentVersion, nil) to indicate a cache hit.
+// If versions differ, return (data, newVersion, nil).
+type Fetcher[T any] interface {
+	Fetch(ctx context.Context, version *versionpb.Version) (T, *versionpb.Version, error)
+}
+
+// FetcherFunc is a function adapter for the Fetcher interface.
+type FetcherFunc[T any] func(ctx context.Context, version *versionpb.Version) (T, *versionpb.Version, error)
+
+func (f FetcherFunc[T]) Fetch(ctx context.Context, version *versionpb.Version) (T, *versionpb.Version, error) {
+	return f(ctx, version)
+}
+
+// VersionedCache is a generic client-side cache with version-based invalidation.
+// It uses optimistic versioning: the server returns data only when versions differ.
+type VersionedCache[T any] struct {
+	fetcher Fetcher[T]
+
+	mu      sync.Mutex
+	version *versionpb.Version
+	data    T
+
+	metrics *metrics.CacheMetrics
+}
+
+// NewVersionedCache creates a new versioned cache.
+// The fetcher is called to retrieve data when the cache needs refreshing.
+// Installation and clientName are used for metrics labels.
+func NewVersionedCache[T any](fetcher Fetcher[T], installation, clientName string) *VersionedCache[T] {
+	return &VersionedCache[T]{
+		fetcher: fetcher,
+		metrics: metrics.NewCacheMetrics(installation, clientName),
+	}
+}
+
+// Get returns the cached data, refreshing from the server if needed.
+// Thread-safe for concurrent access.
+func (c *VersionedCache[T]) Get(ctx context.Context) (T, error) {
+	if err := c.refresh(ctx); err != nil {
+		var zero T
+		return zero, fmt.Errorf("refreshing cache: %w", err)
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.data, nil
+}
+
+// refresh fetches data from the server if the version has changed.
+func (c *VersionedCache[T]) refresh(ctx context.Context) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	data, newVersion, err := c.fetcher.Fetch(ctx, c.version)
+	if err != nil {
+		return fmt.Errorf("fetching data: %w", err)
+	}
+
+	// Version matched - cache hit (server returned empty data)
+	if c.version.EqualVT(newVersion) {
+		c.metrics.Hit()
+		return nil
+	}
+
+	// Version changed - cache miss (server returned fresh data)
+	c.metrics.Miss()
+	c.version = newVersion
+	c.data = data
+	return nil
+}
diff --git a/pkg/clients/cache/cache_test.go b/pkg/clients/cache/cache_test.go
new file mode 100644
index 0000000..ff62887
--- /dev/null
+++ b/pkg/clients/cache/cache_test.go
@@ -0,0 +1,197 @@
+package cache_test
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/c4t-but-s4d/fastad/pkg/clients/cache"
+	versionpb "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+)
+
+func newVersion(v int64) *versionpb.Version {
+	return &versionpb.Version{Version: v}
+}
+
+func TestVersionedCache_Get_CacheMiss(t *testing.T) {
+	fetchCount := 0
+	fetcher := cache.FetcherFunc[string](func(_ context.Context, _ *versionpb.Version) (string, *versionpb.Version, error) {
+		fetchCount++
+		return "data", newVersion(1), nil
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "cache_miss")
+
+	result, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, "data", result)
+	assert.Equal(t, 1, fetchCount)
+}
+
+func TestVersionedCache_Get_CacheHit(t *testing.T) {
+	fetchCount := 0
+	fetcher := cache.FetcherFunc[string](func(_ context.Context, version *versionpb.Version) (string, *versionpb.Version, error) {
+		fetchCount++
+		// First call: return data with version 1
+		// Subsequent calls: version matches, return same version (simulating server behavior)
+		if version == nil {
+			return "data", newVersion(1), nil
+		}
+		// Server returns same version = cache hit (no data needed)
+		return "", version, nil
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "cache_hit")
+
+	// First call - cache miss
+	result1, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, "data", result1)
+	assert.Equal(t, 1, fetchCount)
+
+	// Second call - cache hit (version matches)
+	result2, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, "data", result2) // Returns cached data
+	assert.Equal(t, 2, fetchCount)   // Fetcher was called but returned same version
+}
+
+func TestVersionedCache_Get_VersionChange(t *testing.T) {
+	currentVersion := int64(1)
+	fetcher := cache.FetcherFunc[string](func(_ context.Context, version *versionpb.Version) (string, *versionpb.Version, error) {
+		v := atomic.LoadInt64(&currentVersion)
+		if version != nil && version.GetVersion() == v {
+			return "", version, nil
+		}
+		return "data-v" + string(rune('0'+v)), newVersion(v), nil
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "version_change")
+
+	// First fetch
+	result1, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, "data-v1", result1)
+
+	// Same version - should return cached
+	result2, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, "data-v1", result2)
+
+	// Bump version
+	atomic.StoreInt64(&currentVersion, 2)
+
+	// Should get new data
+	result3, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, "data-v2", result3)
+}
+
+func TestVersionedCache_Get_FetchError(t *testing.T) {
+	expectedErr := errors.New("fetch failed")
+	fetcher := cache.FetcherFunc[string](func(_ context.Context, _ *versionpb.Version) (string, *versionpb.Version, error) {
+		return "", nil, expectedErr
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "fetch_error")
+
+	result, err := c.Get(context.Background())
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "fetch failed")
+	assert.Empty(t, result)
+}
+
+func TestVersionedCache_Get_Concurrent(t *testing.T) {
+	var fetchCount atomic.Int32
+	fetcher := cache.FetcherFunc[int](func(_ context.Context, version *versionpb.Version) (int, *versionpb.Version, error) {
+		fetchCount.Add(1)
+		if version != nil && version.GetVersion() == 1 {
+			return 0, version, nil
+		}
+		return 42, newVersion(1), nil
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "concurrent")
+
+	const goroutines = 100
+	var wg sync.WaitGroup
+	wg.Add(goroutines)
+
+	results := make([]int, 0, goroutines)
+	errs := make([]error, 0, goroutines)
+	var mu sync.Mutex
+
+	for range goroutines {
+		go func() {
+			defer wg.Done()
+			result, err := c.Get(context.Background())
+			mu.Lock()
+			results = append(results, result)
+			errs = append(errs, err)
+			mu.Unlock()
+		}()
+	}
+
+	wg.Wait()
+
+	// All should succeed with same value
+	for i := range goroutines {
+		require.NoError(t, errs[i])
+		assert.Equal(t, 42, results[i])
+	}
+}
+
+func TestVersionedCache_Get_NilData(t *testing.T) {
+	fetcher := cache.FetcherFunc[*string](func(_ context.Context, _ *versionpb.Version) (*string, *versionpb.Version, error) {
+		return nil, newVersion(1), nil
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "nil_data")
+
+	result, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Nil(t, result)
+}
+
+func TestVersionedCache_Get_SliceData(t *testing.T) {
+	fetcher := cache.FetcherFunc[[]string](func(_ context.Context, version *versionpb.Version) ([]string, *versionpb.Version, error) {
+		if version != nil && version.GetVersion() == 1 {
+			return nil, version, nil
+		}
+		return []string{"a", "b", "c"}, newVersion(1), nil
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "slice_data")
+
+	result, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, []string{"a", "b", "c"}, result)
+
+	// Second call should return cached slice
+	result2, err := c.Get(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, []string{"a", "b", "c"}, result2)
+}
+
+func TestVersionedCache_ContextCancellation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel() // Cancel immediately
+
+	fetcher := cache.FetcherFunc[string](func(ctx context.Context, _ *versionpb.Version) (string, *versionpb.Version, error) {
+		if ctx.Err() != nil {
+			return "", nil, ctx.Err()
+		}
+		return "data", newVersion(1), nil
+	})
+
+	c := cache.NewVersionedCache(fetcher, "test", "ctx_cancel")
+
+	_, err := c.Get(ctx)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, context.Canceled)
+}
diff --git a/pkg/clients/gamestate/client.go b/pkg/clients/gamestate/client.go
new file mode 100644
index 0000000..c846e95
--- /dev/null
+++ b/pkg/clients/gamestate/client.go
@@ -0,0 +1,85 @@
+package gamestate
+
+import (
+	"context"
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/pkg/clients/cache"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	versionpb "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+)
+
+var ErrStateUnavailable = status.Error(codes.Unavailable, "game state is unavailable")
+
+type Client struct {
+	grpc  gspb.GameStateServiceClient
+	cache *cache.VersionedCache[*gspb.GameState]
+}
+
+func NewClient(c gspb.GameStateServiceClient, installation string) *Client {
+	client := &Client{grpc: c}
+	client.cache = cache.NewVersionedCache(
+		cache.FetcherFunc[*gspb.GameState](client.fetch),
+		installation,
+		"gamestate",
+	)
+	return client
+}
+
+func (c *Client) fetch(ctx context.Context, version *versionpb.Version) (*gspb.GameState, *versionpb.Version, error) {
+	resp, err := c.grpc.Get(ctx, &gspb.GetRequest{Version: version})
+	if err != nil {
+		return nil, nil, fmt.Errorf("getting state: %w", err)
+	}
+	return resp.GetGameState(), resp.GetVersion(), nil
+}
+
+func (c *Client) Get(ctx context.Context) (*gspb.GameState, error) {
+	state, err := c.cache.Get(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("getting cached state: %w", err)
+	}
+	if state == nil {
+		return nil, ErrStateUnavailable
+	}
+	return state, nil
+}
+
+func (c *Client) Create(ctx context.Context, req *gspb.CreateRequest) (*gspb.GameState, error) {
+	resp, err := c.grpc.Create(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("creating state: %w", err)
+	}
+	return resp.GetGameState(), nil
+}
+
+func (c *Client) Update(ctx context.Context, req *gspb.UpdateRequest) (*gspb.GameState, error) {
+	resp, err := c.grpc.Update(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("updating state: %w", err)
+	}
+	return resp.GetGameState(), nil
+}
+
+func (c *Client) UpdateRound(ctx context.Context, req *gspb.UpdateRoundRequest) (*gspb.GameState, error) {
+	resp, err := c.grpc.UpdateRound(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("updating round: %w", err)
+	}
+	return resp.GetGameState(), nil
+}
+
+func (c *Client) FinishGame(ctx context.Context) (*gspb.GameState, error) {
+	resp, err := c.grpc.FinishGame(ctx, &gspb.FinishGameRequest{})
+	if err != nil {
+		return nil, fmt.Errorf("finishing game: %w", err)
+	}
+	return resp.GetGameState(), nil
+}
+
+func (c *Client) RawClient() gspb.GameStateServiceClient {
+	return c.grpc
+}
diff --git a/pkg/clients/metrics/metrics.go b/pkg/clients/metrics/metrics.go
new file mode 100644
index 0000000..0ab311d
--- /dev/null
+++ b/pkg/clients/metrics/metrics.go
@@ -0,0 +1,64 @@
+package metrics
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+type CacheMetrics struct {
+	hits   prometheus.Counter
+	misses prometheus.Counter
+}
+
+var (
+	metricsCache = make(map[string]*CacheMetrics)
+	metricsMu    sync.Mutex
+)
+
+func NewCacheMetrics(installation, client string) *CacheMetrics {
+	key := installation + "/" + client
+
+	metricsMu.Lock()
+	defer metricsMu.Unlock()
+
+	if existing, ok := metricsCache[key]; ok {
+		return existing
+	}
+
+	constLabels := prometheus.Labels{"client": client}
+	if installation != "" {
+		constLabels["installation"] = installation
+	}
+
+	m := &CacheMetrics{
+		hits: promauto.NewCounter(
+			prometheus.CounterOpts{
+				Name:        "fastad_client_cache_hits_total",
+				Help:        "Total number of client cache hits (version matched, no data fetch)",
+				ConstLabels: constLabels,
+			},
+		),
+		misses: promauto.NewCounter(
+			prometheus.CounterOpts{
+				Name:        "fastad_client_cache_misses_total",
+				Help:        "Total number of client cache misses (version mismatch, data fetched)",
+				ConstLabels: constLabels,
+			},
+		),
+	}
+
+	metricsCache[key] = m
+	return m
+}
+
+// Hit records a cache hit.
+func (m *CacheMetrics) Hit() {
+	m.hits.Inc()
+}
+
+// Miss records a cache miss.
+func (m *CacheMetrics) Miss() {
+	m.misses.Inc()
+}
diff --git a/pkg/clients/services/client.go b/pkg/clients/services/client.go
new file mode 100644
index 0000000..1d4592a
--- /dev/null
+++ b/pkg/clients/services/client.go
@@ -0,0 +1,69 @@
+package services
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/c4t-but-s4d/fastad/pkg/clients/cache"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	versionpb "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+)
+
+type Client struct {
+	grpc  servicespb.ServicesServiceClient
+	cache *cache.VersionedCache[[]*servicespb.Service]
+}
+
+func NewClient(c servicespb.ServicesServiceClient, installation string) *Client {
+	client := &Client{grpc: c}
+	client.cache = cache.NewVersionedCache(
+		cache.FetcherFunc[[]*servicespb.Service](client.fetch),
+		installation,
+		"services",
+	)
+	return client
+}
+
+func (c *Client) fetch(ctx context.Context, version *versionpb.Version) ([]*servicespb.Service, *versionpb.Version, error) {
+	resp, err := c.grpc.List(ctx, &servicespb.ListRequest{Version: version})
+	if err != nil {
+		return nil, nil, fmt.Errorf("getting services: %w", err)
+	}
+	return resp.GetServices(), resp.GetVersion(), nil
+}
+
+func (c *Client) List(ctx context.Context) ([]*servicespb.Service, error) {
+	services, err := c.cache.Get(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("getting cached services: %w", err)
+	}
+	return services, nil
+}
+
+func (c *Client) CreateBatch(ctx context.Context, services []*servicespb.Service) ([]*servicespb.Service, error) {
+	resp, err := c.grpc.CreateBatch(ctx, &servicespb.CreateBatchRequest{Services: services})
+	if err != nil {
+		return nil, fmt.Errorf("making api request: %w", err)
+	}
+
+	// Force cache refresh after write
+	if _, err := c.cache.Get(ctx); err != nil {
+		return nil, fmt.Errorf("refreshing cache: %w", err)
+	}
+
+	return resp.GetServices(), nil
+}
+
+func (c *Client) Update(ctx context.Context, req *servicespb.UpdateRequest) (*servicespb.Service, error) {
+	resp, err := c.grpc.Update(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("making api request: %w", err)
+	}
+
+	// Force cache refresh after write
+	if _, err := c.cache.Get(ctx); err != nil {
+		return nil, fmt.Errorf("refreshing cache: %w", err)
+	}
+
+	return resp.GetService(), nil
+}
diff --git a/pkg/clients/teams/client.go b/pkg/clients/teams/client.go
new file mode 100644
index 0000000..5446481
--- /dev/null
+++ b/pkg/clients/teams/client.go
@@ -0,0 +1,107 @@
+package teams
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/samber/lo"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/c4t-but-s4d/fastad/pkg/clients/cache"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+	versionpb "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+)
+
+type Client struct {
+	grpc  teamspb.TeamsServiceClient
+	cache *cache.VersionedCache[[]*teamspb.Team]
+
+	// Secondary index for fast token lookup.
+	// Updated lazily when List is called.
+	indexMu      sync.RWMutex
+	teamsByToken map[string]*teamspb.Team
+}
+
+func NewClient(c teamspb.TeamsServiceClient, installation string) *Client {
+	client := &Client{
+		grpc:         c,
+		teamsByToken: make(map[string]*teamspb.Team),
+	}
+	client.cache = cache.NewVersionedCache(
+		cache.FetcherFunc[[]*teamspb.Team](client.fetch),
+		installation,
+		"teams",
+	)
+	return client
+}
+
+func (c *Client) fetch(ctx context.Context, version *versionpb.Version) ([]*teamspb.Team, *versionpb.Version, error) {
+	resp, err := c.grpc.List(ctx, &teamspb.ListRequest{Version: version})
+	if err != nil {
+		return nil, nil, fmt.Errorf("getting teams: %w", err)
+	}
+	return resp.GetTeams(), resp.GetVersion(), nil
+}
+
+func (c *Client) List(ctx context.Context) ([]*teamspb.Team, error) {
+	teams, err := c.cache.Get(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("getting cached teams: %w", err)
+	}
+	c.updateIndex(teams)
+	return teams, nil
+}
+
+func (c *Client) GetByToken(ctx context.Context, token string) (*teamspb.Team, error) {
+	// Ensure cache is fresh and index is updated
+	if _, err := c.List(ctx); err != nil {
+		return nil, err
+	}
+
+	c.indexMu.RLock()
+	team := c.teamsByToken[token]
+	c.indexMu.RUnlock()
+
+	if team == nil {
+		return nil, status.Error(codes.NotFound, "team not found")
+	}
+	return team, nil
+}
+
+func (c *Client) CreateBatch(ctx context.Context, teams []*teamspb.Team) ([]*teamspb.Team, error) {
+	resp, err := c.grpc.CreateBatch(ctx, &teamspb.CreateBatchRequest{Teams: teams})
+	if err != nil {
+		return nil, fmt.Errorf("making api request: %w", err)
+	}
+
+	// Force cache refresh after write
+	if _, err := c.List(ctx); err != nil {
+		return nil, fmt.Errorf("refreshing cache: %w", err)
+	}
+
+	return resp.GetTeams(), nil
+}
+
+func (c *Client) Update(ctx context.Context, req *teamspb.UpdateRequest) (*teamspb.Team, error) {
+	resp, err := c.grpc.Update(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("making api request: %w", err)
+	}
+
+	// Force cache refresh after write
+	if _, err := c.List(ctx); err != nil {
+		return nil, fmt.Errorf("refreshing cache: %w", err)
+	}
+
+	return resp.GetTeam(), nil
+}
+
+func (c *Client) updateIndex(teams []*teamspb.Team) {
+	c.indexMu.Lock()
+	defer c.indexMu.Unlock()
+	c.teamsByToken = lo.KeyBy(teams, func(team *teamspb.Team) string {
+		return team.GetToken()
+	})
+}
diff --git a/pkg/config/centrifuge.go b/pkg/config/centrifuge.go
new file mode 100644
index 0000000..e2b5d10
--- /dev/null
+++ b/pkg/config/centrifuge.go
@@ -0,0 +1,5 @@
+package config
+
+type CentrifugeClient struct {
+	Address string `mapstructure:"address" default:"ws://127.0.0.1:8001/centrifuge/websocket"`
+}
diff --git a/pkg/config/data_service.go b/pkg/config/data_service.go
new file mode 100644
index 0000000..3a1276e
--- /dev/null
+++ b/pkg/config/data_service.go
@@ -0,0 +1,5 @@
+package config
+
+type DataService struct {
+	Address string `mapstructure:"address" default:"127.0.0.1:8004"`
+}
diff --git a/pkg/config/postgres.go b/pkg/config/postgres.go
new file mode 100644
index 0000000..7a41b3b
--- /dev/null
+++ b/pkg/config/postgres.go
@@ -0,0 +1,56 @@
+package config
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/dialect/pgdialect"
+	"github.com/uptrace/bun/driver/pgdriver"
+
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+)
+
+type Postgres struct {
+	DSN       string `mapstructure:"dsn"`
+	Host      string `mapstructure:"host" default:"127.0.0.1"`
+	Port      int    `mapstructure:"port" default:"5433"`
+	User      string `mapstructure:"user" default:"fastad"`
+	Password  string `mapstructure:"password" default:"fastad"`
+	Database  string `mapstructure:"database" default:"fastad"`
+	EnableSSL bool   `mapstructure:"enable_ssl"`
+
+	MaxIdleConns    int           `mapstructure:"max_idle_conns" default:"10"`
+	MaxOpenConns    int           `mapstructure:"max_open_conns" default:"10"`
+	ConnMaxIdleTime time.Duration `mapstructure:"conn_max_idle_time" default:"5m"`
+	ConnMaxLifetime time.Duration `mapstructure:"conn_max_lifetime" default:"10m"`
+}
+
+func (p *Postgres) BunDB() *bun.DB {
+	var opts []pgdriver.Option
+	if p.DSN != "" {
+		opts = append(opts, pgdriver.WithDSN(p.DSN))
+	} else {
+		opts = append(opts,
+			pgdriver.WithAddr(fmt.Sprintf("%s:%d", p.Host, p.Port)),
+			pgdriver.WithDatabase(p.Database),
+			pgdriver.WithUser(p.User),
+			pgdriver.WithPassword(p.Password),
+			pgdriver.WithInsecure(!p.EnableSSL),
+		)
+	}
+
+	pgConn := pgdriver.NewConnector(opts...)
+
+	sqlDB := sql.OpenDB(pgConn)
+	sqlDB.SetMaxIdleConns(p.MaxIdleConns)
+	sqlDB.SetMaxOpenConns(p.MaxOpenConns)
+	sqlDB.SetConnMaxIdleTime(p.ConnMaxIdleTime)
+	sqlDB.SetConnMaxLifetime(p.ConnMaxLifetime)
+
+	db := bun.NewDB(sqlDB, pgdialect.New())
+	logging.AddBunQueryHook(db)
+
+	return db
+}
diff --git a/pkg/config/temporal.go b/pkg/config/temporal.go
new file mode 100644
index 0000000..f594534
--- /dev/null
+++ b/pkg/config/temporal.go
@@ -0,0 +1,5 @@
+package config
+
+type Temporal struct {
+	Address string `mapstructure:"address" default:"127.0.0.1:7233"`
+}
diff --git a/pkg/grpcext/auth.go b/pkg/grpcext/auth.go
new file mode 100644
index 0000000..a8ce4b7
--- /dev/null
+++ b/pkg/grpcext/auth.go
@@ -0,0 +1,100 @@
+package grpcext
+
+import (
+	"context"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+)
+
+const authKey = "authorization"
+
+type ServerTokenInterceptor struct {
+	token string
+}
+
+func NewServerTokenInterceptor(token string) *ServerTokenInterceptor {
+	return &ServerTokenInterceptor{token: token}
+}
+
+func (ti *ServerTokenInterceptor) authorize(ctx context.Context, _ string) error {
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return status.Errorf(codes.Unauthenticated, "metadata is not provided")
+	}
+	values := md[authKey]
+	if len(values) != 1 {
+		return status.Errorf(codes.Unauthenticated, "authorization token is not provided")
+	}
+	if ti.token != values[0] {
+		return status.Errorf(codes.Unauthenticated, "invalid token provided")
+	}
+	return nil
+}
+
+func (ti *ServerTokenInterceptor) Unary() grpc.UnaryServerInterceptor {
+	return func(
+		ctx context.Context,
+		req any,
+		info *grpc.UnaryServerInfo,
+		handler grpc.UnaryHandler,
+	) (any, error) {
+		if err := ti.authorize(ctx, info.FullMethod); err != nil {
+			return nil, err
+		}
+		return handler(ctx, req)
+	}
+}
+
+func (ti *ServerTokenInterceptor) Stream() grpc.StreamServerInterceptor {
+	return func(
+		srv any,
+		stream grpc.ServerStream,
+		info *grpc.StreamServerInfo,
+		handler grpc.StreamHandler,
+	) error {
+		if err := ti.authorize(stream.Context(), info.FullMethod); err != nil {
+			return err
+		}
+		return handler(srv, stream)
+	}
+}
+
+type ClientTokenInterceptor struct {
+	token string
+}
+
+func NewClientTokenInterceptor(token string) *ClientTokenInterceptor {
+	return &ClientTokenInterceptor{token: token}
+}
+
+func (ti *ClientTokenInterceptor) Unary() grpc.UnaryClientInterceptor {
+	return func(
+		ctx context.Context,
+		method string,
+		req any,
+		reply any,
+		cc *grpc.ClientConn,
+		invoker grpc.UnaryInvoker,
+		opts ...grpc.CallOption,
+	) error {
+		ctx = metadata.AppendToOutgoingContext(ctx, authKey, ti.token)
+		return invoker(ctx, method, req, reply, cc, opts...)
+	}
+}
+
+func (ti *ClientTokenInterceptor) Stream() grpc.StreamClientInterceptor {
+	return func(
+		ctx context.Context,
+		desc *grpc.StreamDesc,
+		cc *grpc.ClientConn,
+		method string,
+		streamer grpc.Streamer,
+		opts ...grpc.CallOption,
+	) (grpc.ClientStream, error) {
+		ctx = metadata.AppendToOutgoingContext(ctx, authKey, ti.token)
+		return streamer(ctx, desc, cc, method, opts...)
+	}
+}
diff --git a/pkg/grpcext/client.go b/pkg/grpcext/client.go
new file mode 100644
index 0000000..40427ff
--- /dev/null
+++ b/pkg/grpcext/client.go
@@ -0,0 +1,34 @@
+package grpcext
+
+import (
+	"fmt"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/encoding/gzip"
+)
+
+func AuthDialOptions(token string) []grpc.DialOption {
+	clientInterceptor := NewClientTokenInterceptor(token)
+
+	return []grpc.DialOption{
+		grpc.WithUnaryInterceptor(clientInterceptor.Unary()),
+		grpc.WithStreamInterceptor(clientInterceptor.Stream()),
+	}
+}
+
+func Dial(address, userAgent string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
+	opts = append(
+		opts,
+		grpc.WithUserAgent(userAgent),
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithDefaultCallOptions(
+			grpc.UseCompressor(gzip.Name),
+		),
+	)
+	conn, err := grpc.NewClient(address, opts...)
+	if err != nil {
+		return nil, fmt.Errorf("dialing %s: %w", address, err)
+	}
+	return conn, nil
+}
diff --git a/pkg/grpcext/run.go b/pkg/grpcext/run.go
new file mode 100644
index 0000000..233d75e
--- /dev/null
+++ b/pkg/grpcext/run.go
@@ -0,0 +1,59 @@
+package grpcext
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+)
+
+func RunServer(runCtx, shutdownCtx context.Context, server *grpc.Server, addr string) error {
+	logger := zap.L().With(zap.String("address", addr))
+
+	var lc net.ListenConfig
+	lis, err := lc.Listen(runCtx, "tcp", addr)
+	if err != nil {
+		return fmt.Errorf("listening: %w", err)
+	}
+
+	var wg sync.WaitGroup
+	defer wg.Wait()
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		const stopTimeout = 5 * time.Second
+
+		<-runCtx.Done()
+
+		logger.Info("stopping gRPC server")
+		ctx, cancel := context.WithTimeout(shutdownCtx, stopTimeout)
+		defer cancel()
+
+		stopped := make(chan struct{})
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer close(stopped)
+			server.GracefulStop()
+		}()
+
+		select {
+		case <-stopped:
+			logger.Info("gRPC server stopped gracefully")
+		case <-ctx.Done():
+			server.Stop()
+			logger.Warn("gRPC server stopped forcefully")
+		}
+	}()
+
+	logger.Info("serving gRPC")
+	if err := server.Serve(lis); err != nil {
+		return fmt.Errorf("serving: %w", err)
+	}
+	return nil
+}
diff --git a/pkg/grpcext/server.go b/pkg/grpcext/server.go
new file mode 100644
index 0000000..9264b09
--- /dev/null
+++ b/pkg/grpcext/server.go
@@ -0,0 +1,132 @@
+package grpcext
+
+import (
+	"runtime/debug"
+
+	grpcprom "github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus"
+	grpclog "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/logging"
+	"github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/recovery"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/reflection"
+	"google.golang.org/grpc/status"
+
+	// Enable gzip compression.
+	_ "google.golang.org/grpc/encoding/gzip"
+
+	"github.com/c4t-but-s4d/fastad/internal/pinger"
+	"github.com/c4t-but-s4d/fastad/pkg/logging"
+	pingerpb "github.com/c4t-but-s4d/fastad/pkg/proto/pinger"
+)
+
+type ServerConfig struct {
+	installation string
+	token        string
+}
+
+func GetServerConfig(opts ...ServerOption) *ServerConfig {
+	cfg := &ServerConfig{
+		installation: "unknown",
+	}
+	for _, opt := range opts {
+		opt(cfg)
+	}
+	return cfg
+}
+
+type ServerOption func(*ServerConfig)
+
+func WithServerInstallation(name string) ServerOption {
+	return func(cfg *ServerConfig) {
+		cfg.installation = name
+	}
+}
+
+func WithServerTokenAuth(token string) ServerOption {
+	return func(cfg *ServerConfig) {
+		cfg.token = token
+	}
+}
+
+func NewServer(opts ...ServerOption) *grpc.Server {
+	cfg := GetServerConfig(opts...)
+
+	rpcLogger := zap.L().Named("grpc_server").With(
+		zap.String("installation", cfg.installation),
+	)
+
+	var coounterOpts []grpcprom.CounterOption
+	histogramOpts := []grpcprom.HistogramOption{
+		grpcprom.WithHistogramBuckets(
+			prometheus.ExponentialBucketsRange(0.001, 120, 30),
+		),
+	}
+	if cfg.installation != "" {
+		coounterOpts = append(
+			coounterOpts,
+			grpcprom.WithConstLabels(prometheus.Labels{"installation": cfg.installation}),
+		)
+		histogramOpts = append(
+			histogramOpts,
+			grpcprom.WithHistogramConstLabels(prometheus.Labels{"installation": cfg.installation}),
+		)
+	}
+
+	srvMetrics := grpcprom.NewServerMetrics(
+		grpcprom.WithServerHandlingTimeHistogram(histogramOpts...),
+		grpcprom.WithServerCounterOptions(coounterOpts...),
+	)
+	prometheus.MustRegister(srvMetrics)
+
+	panicsCounterOpts := prometheus.CounterOpts{
+		Name: "grpc_server_panics_recovered_total",
+		Help: "Total number of gRPC requests recovered from internal panic.",
+	}
+	if cfg.installation != "" {
+		panicsCounterOpts.ConstLabels = map[string]string{"installation": cfg.installation}
+	}
+
+	panicsTotal := promauto.NewCounter(panicsCounterOpts)
+	grpcPanicRecoveryHandler := func(p any) (err error) {
+		panicsTotal.Inc()
+		rpcLogger.Error("recovered from panic", zap.Any("panic", p), zap.ByteString("stack", debug.Stack()))
+		return status.Errorf(codes.Internal, "%s", p)
+	}
+
+	unaryInterceptors := []grpc.UnaryServerInterceptor{
+		srvMetrics.UnaryServerInterceptor(), // TODO: exemplars.
+		grpclog.UnaryServerInterceptor(
+			logging.InterceptorLogger(rpcLogger),
+			grpclog.WithLevels(logging.GRPCCodeToLevel),
+		), // TODO: tracing.
+		recovery.UnaryServerInterceptor(recovery.WithRecoveryHandler(grpcPanicRecoveryHandler)),
+		UnwrapStatusUnaryServerInterceptor(),
+	}
+
+	streamInterceptors := []grpc.StreamServerInterceptor{
+		srvMetrics.StreamServerInterceptor(), // TODO: exemplars.
+		grpclog.StreamServerInterceptor(
+			logging.InterceptorLogger(rpcLogger),
+			grpclog.WithLevels(logging.GRPCCodeToLevel),
+		), // TODO: tracing.
+		recovery.StreamServerInterceptor(recovery.WithRecoveryHandler(grpcPanicRecoveryHandler)),
+		UnwrapStatusStreamServerInterceptor(),
+	}
+
+	if cfg.token != "" {
+		authInterceptor := NewServerTokenInterceptor(cfg.token)
+		unaryInterceptors = append(unaryInterceptors, authInterceptor.Unary())
+		streamInterceptors = append(streamInterceptors, authInterceptor.Stream())
+	}
+
+	s := grpc.NewServer(
+		grpc.ChainUnaryInterceptor(unaryInterceptors...),
+		grpc.ChainStreamInterceptor(streamInterceptors...),
+	)
+	reflection.Register(s)
+	pingerpb.RegisterPingerServiceServer(s, pinger.New())
+	return s
+}
diff --git a/pkg/grpcext/unwrap.go b/pkg/grpcext/unwrap.go
new file mode 100644
index 0000000..c362c75
--- /dev/null
+++ b/pkg/grpcext/unwrap.go
@@ -0,0 +1,64 @@
+package grpcext
+
+import (
+	"context"
+	"errors"
+	"io"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/status"
+)
+
+func UnwrapStatusUnaryServerInterceptor() grpc.UnaryServerInterceptor {
+	return func(ctx context.Context, req any, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp any, err error) {
+		resp, err = handler(ctx, req)
+		return resp, unwrapError(err)
+	}
+}
+
+func UnwrapStatusStreamServerInterceptor() grpc.StreamServerInterceptor {
+	return func(srv any, ss grpc.ServerStream, _ *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		return unwrapError(handler(srv, ss))
+	}
+}
+
+func UnwrapStatusUnaryClientInterceptor() grpc.UnaryClientInterceptor {
+	return func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+		return unwrapError(invoker(ctx, method, req, reply, cc, opts...))
+	}
+}
+
+func UnwrapStatusStreamClientInterceptor() grpc.StreamClientInterceptor {
+	return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
+		clientStream, err := streamer(ctx, desc, cc, method, opts...)
+		stream := &unwrappingStream{clientStream}
+		return stream, unwrapError(err)
+	}
+}
+
+type unwrappingStream struct {
+	grpc.ClientStream
+}
+
+func (s *unwrappingStream) SendMsg(m any) error {
+	return unwrapError(s.ClientStream.SendMsg(m))
+}
+
+func (s *unwrappingStream) RecvMsg(m any) error {
+	err := s.ClientStream.RecvMsg(m)
+	if err == nil || errors.Is(err, io.EOF) {
+		//nolint:wrapcheck // We don't want to wrap EOF.
+		return err
+	}
+	return unwrapError(err)
+}
+
+func unwrapError(err error) error {
+	if err == nil {
+		return nil
+	}
+	if st, ok := status.FromError(err); ok {
+		return st.Err()
+	}
+	return status.FromContextError(err).Err()
+}
diff --git a/pkg/httpext/context.go b/pkg/httpext/context.go
new file mode 100644
index 0000000..6bdf749
--- /dev/null
+++ b/pkg/httpext/context.go
@@ -0,0 +1,29 @@
+package httpext
+
+import (
+	"context"
+
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/metadata"
+)
+
+func ContextFromEcho(c echo.Context) context.Context {
+	return metadata.NewIncomingContext(
+		c.Request().Context(),
+		metadata.Pairs(RequestIDContextKey, RequestID(c)),
+	)
+}
+
+func RequestID(c echo.Context) string {
+	if requestID := c.Get(RequestIDContextKey); requestID != nil {
+		if requestIDStr, ok := requestID.(string); ok {
+			return requestIDStr
+		}
+	}
+	panic("request id unset")
+}
+
+func EchoContextLogger(c echo.Context) *zap.Logger {
+	return zap.L().With(zap.String(RequestIDContextKey, RequestID(c)))
+}
diff --git a/pkg/httpext/convert.go b/pkg/httpext/convert.go
new file mode 100644
index 0000000..e2e432b
--- /dev/null
+++ b/pkg/httpext/convert.go
@@ -0,0 +1,57 @@
+package httpext
+
+import (
+	"net/http"
+
+	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func StatusFromGRPCCode(code codes.Code) int {
+	switch code {
+	case codes.OK:
+		return http.StatusOK
+	case codes.Unknown:
+		return http.StatusInternalServerError
+	case codes.InvalidArgument:
+		return http.StatusBadRequest
+	case codes.DeadlineExceeded:
+		return http.StatusRequestTimeout
+	case codes.NotFound:
+		return http.StatusNotFound
+	case codes.AlreadyExists:
+		return http.StatusBadRequest
+	case codes.PermissionDenied:
+		return http.StatusForbidden
+	case codes.ResourceExhausted:
+		return http.StatusTooManyRequests
+	case codes.FailedPrecondition:
+		return http.StatusPreconditionFailed
+	case codes.Aborted:
+		return http.StatusInternalServerError
+	case codes.OutOfRange:
+		return http.StatusRequestedRangeNotSatisfiable
+	case codes.Unimplemented:
+		return http.StatusNotImplemented
+	case codes.Internal:
+		return http.StatusInternalServerError
+	case codes.Unavailable:
+		return http.StatusServiceUnavailable
+	case codes.DataLoss:
+		return http.StatusInternalServerError
+	case codes.Unauthenticated:
+		return http.StatusUnauthorized
+	default:
+		logrus.WithField("code", code).Warn("unknown gRPC code")
+		return http.StatusInternalServerError
+	}
+}
+
+func StatusFromGRPC(s *status.Status) int {
+	return StatusFromGRPCCode(s.Code())
+}
+
+func StatusFromError(err error) int {
+	return StatusFromGRPCCode(status.Code(err))
+}
diff --git a/pkg/httpext/error.go b/pkg/httpext/error.go
new file mode 100644
index 0000000..6560f2b
--- /dev/null
+++ b/pkg/httpext/error.go
@@ -0,0 +1,120 @@
+package httpext
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/status"
+)
+
+type Error struct {
+	code    int
+	message string
+}
+
+func NewError(code int, msg string) *Error {
+	return &Error{
+		code:    code,
+		message: msg,
+	}
+}
+
+func NewErrorf(code int, format string, a ...any) *Error {
+	return NewError(code, fmt.Sprintf(format, a...))
+}
+
+func NewErrorFromStatus(err error, msg string) *Error {
+	if st, ok := status.FromError(err); ok {
+		return NewError(StatusFromGRPC(st), fmt.Sprintf("%s: %v", msg, st.Message()))
+	}
+
+	return &Error{
+		code:    http.StatusInternalServerError,
+		message: fmt.Sprintf("%s: %v", msg, err),
+	}
+}
+
+func NewErrorFromStatusf(err error, format string, a ...any) *Error {
+	return NewErrorFromStatus(err, fmt.Sprintf(format, a...))
+}
+
+func (e *Error) Error() string {
+	return e.message
+}
+
+func ErrorHandler() echo.HTTPErrorHandler {
+	return func(err error, c echo.Context) {
+		logger := EchoContextLogger(c)
+
+		var (
+			e  *Error
+			he *echo.HTTPError
+		)
+
+		switch {
+		case errors.As(err, &e):
+			if e.code/100 == 5 {
+				logger.Warn(
+					"internal error",
+					zap.Error(err),
+					zap.String("message", e.message),
+					zap.Int("status", e.code),
+				)
+			} else {
+				logger.Debug(
+					"client error",
+					zap.Error(err),
+					zap.String("message", e.message),
+					zap.Int("status", e.code),
+				)
+			}
+
+			if err := c.JSON(e.code, map[string]string{"error": e.message}); err != nil {
+				c.Logger().Error(err)
+			}
+
+		case errors.As(err, &he):
+			if he.Internal != nil {
+				var herr *echo.HTTPError
+				if errors.As(he.Internal, &herr) {
+					he = herr
+				}
+			}
+
+			f := logger.Debug
+			if he.Code/100 == 5 {
+				f = logger.Warn
+			}
+			f(
+				"unexpected error",
+				zap.Error(err),
+				zap.Any("message", he.Message),
+				zap.Int("status", he.Code),
+			)
+			if c.Request().Method == http.MethodHead {
+				if err := c.NoContent(he.Code); err != nil {
+					c.Logger().Error(err)
+				}
+			} else {
+				if msg, ok := he.Message.(string); ok {
+					if err := c.JSON(he.Code, map[string]string{"error": msg}); err != nil {
+						c.Logger().Error(err)
+					}
+				} else {
+					if err := c.JSON(he.Code, map[string]string{"error": http.StatusText(he.Code)}); err != nil {
+						c.Logger().Error(err)
+					}
+				}
+			}
+
+		default:
+			logger.Error("unexpected error", zap.Error(err))
+			if err := c.JSON(http.StatusInternalServerError, map[string]string{"error": "unknown error"}); err != nil {
+				c.Logger().Error(err)
+			}
+		}
+	}
+}
diff --git a/pkg/httpext/health.go b/pkg/httpext/health.go
new file mode 100644
index 0000000..621515f
--- /dev/null
+++ b/pkg/httpext/health.go
@@ -0,0 +1,13 @@
+package httpext
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+)
+
+func HealthHandler() echo.HandlerFunc {
+	return func(c echo.Context) error {
+		return c.String(http.StatusOK, "OK")
+	}
+}
diff --git a/pkg/httpext/middleware.go b/pkg/httpext/middleware.go
new file mode 100644
index 0000000..b6d255e
--- /dev/null
+++ b/pkg/httpext/middleware.go
@@ -0,0 +1,24 @@
+package httpext
+
+import (
+	"github.com/google/uuid"
+	"github.com/labstack/echo/v4"
+)
+
+const RequestIDContextKey = "request_id"
+
+func RequestIDMiddleware() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			req := c.Request()
+			res := c.Response()
+			rid := req.Header.Get(echo.HeaderXRequestID)
+			if rid == "" {
+				rid = uuid.NewString()
+			}
+			res.Header().Set(echo.HeaderXRequestID, rid)
+			c.Set(RequestIDContextKey, rid)
+			return next(c)
+		}
+	}
+}
diff --git a/pkg/logging/bun_hook.go b/pkg/logging/bun_hook.go
new file mode 100644
index 0000000..401755e
--- /dev/null
+++ b/pkg/logging/bun_hook.go
@@ -0,0 +1,69 @@
+package logging
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"time"
+
+	"github.com/uptrace/bun"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+const (
+	OperationFieldName     = "operation"
+	OperationTimeFieldName = "operation_time_ms"
+	SlowQueryThreshold     = time.Millisecond * 100
+)
+
+type QueryHook struct {
+	bun.QueryHook
+
+	logger *zap.Logger
+}
+
+func NewQueryHook(logger *zap.Logger) QueryHook {
+	return QueryHook{logger: logger.WithOptions(zap.AddCallerSkip(6))}
+}
+
+func (qh QueryHook) BeforeQuery(ctx context.Context, _ *bun.QueryEvent) context.Context {
+	return ctx
+}
+
+func (qh QueryHook) AfterQuery(_ context.Context, event *bun.QueryEvent) {
+	queryDuration := time.Since(event.StartTime)
+	fields := []zapcore.Field{
+		zap.String(OperationFieldName, event.Operation()),
+		zap.Int64(OperationTimeFieldName, queryDuration.Milliseconds()),
+	}
+
+	// Errors will always be logged
+	if event.Err != nil {
+		fields = append(fields, zap.Error(event.Err))
+
+		if isBenignSQLError(event.Err) {
+			qh.logger.Debug(event.Query, fields...)
+			return
+		}
+
+		qh.logger.Error(event.Query, fields...)
+		return
+	}
+
+	// Queries over a slow time duration
+	// will be logged as debug
+	if queryDuration >= SlowQueryThreshold {
+		qh.logger.Warn(event.Query, fields...)
+	} else {
+		qh.logger.Debug(event.Query, fields...)
+	}
+}
+
+func AddBunQueryHook(db *bun.DB) {
+	db.AddQueryHook(NewQueryHook(zap.L()))
+}
+
+func isBenignSQLError(err error) bool {
+	return errors.Is(err, sql.ErrNoRows)
+}
diff --git a/pkg/logging/config.go b/pkg/logging/config.go
new file mode 100644
index 0000000..c37edfc
--- /dev/null
+++ b/pkg/logging/config.go
@@ -0,0 +1,5 @@
+package logging
+
+type Config struct {
+	Level string `mapstructure:"level"`
+}
diff --git a/pkg/logging/grpc_interceptor.go b/pkg/logging/grpc_interceptor.go
new file mode 100644
index 0000000..f0344b9
--- /dev/null
+++ b/pkg/logging/grpc_interceptor.go
@@ -0,0 +1,73 @@
+package logging
+
+import (
+	"context"
+	"fmt"
+
+	grpclog "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/logging"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/codes"
+)
+
+// InterceptorLogger adapts zap logger to interceptor logger.
+// This code is simple enough to be copied and not imported.
+func InterceptorLogger(l *zap.Logger) grpclog.Logger {
+	return grpclog.LoggerFunc(func(_ context.Context, lvl grpclog.Level, msg string, fields ...any) {
+		f := make([]zap.Field, 0, len(fields)/2)
+
+		for i := 0; i < len(fields); i += 2 {
+			key := fields[i]
+			keyStr, ok := key.(string)
+			if !ok || i+1 >= len(fields) {
+				continue
+			}
+			value := fields[i+1]
+
+			switch v := value.(type) {
+			case string:
+				f = append(f, zap.String(keyStr, v))
+			case int:
+				f = append(f, zap.Int(keyStr, v))
+			case bool:
+				f = append(f, zap.Bool(keyStr, v))
+			default:
+				f = append(f, zap.Any(keyStr, v))
+			}
+		}
+
+		logger := l.WithOptions(zap.AddCallerSkip(1)).With(f...)
+
+		switch lvl {
+		case grpclog.LevelDebug:
+			logger.Debug(msg)
+		case grpclog.LevelInfo:
+			logger.Info(msg)
+		case grpclog.LevelWarn:
+			logger.Warn(msg)
+		case grpclog.LevelError:
+			logger.Error(msg)
+		default:
+			panic(fmt.Sprintf("unknown level %v", lvl))
+		}
+	})
+}
+
+func GRPCCodeToLevel(code codes.Code) grpclog.Level {
+	switch code {
+	case codes.OK:
+		return grpclog.LevelDebug
+
+	case codes.NotFound, codes.Canceled, codes.AlreadyExists, codes.InvalidArgument, codes.Unauthenticated:
+		return grpclog.LevelInfo
+
+	case codes.DeadlineExceeded, codes.PermissionDenied, codes.ResourceExhausted, codes.FailedPrecondition, codes.Aborted,
+		codes.OutOfRange, codes.Unavailable:
+		return grpclog.LevelWarn
+
+	case codes.Unknown, codes.Unimplemented, codes.Internal, codes.DataLoss:
+		return grpclog.LevelError
+
+	default:
+		return grpclog.LevelError
+	}
+}
diff --git a/pkg/logging/init.go b/pkg/logging/init.go
new file mode 100644
index 0000000..05c8133
--- /dev/null
+++ b/pkg/logging/init.go
@@ -0,0 +1,68 @@
+package logging
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"syscall"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+
+	"github.com/c4t-but-s4d/fastad/pkg/baseconfig"
+)
+
+var initOnce sync.Once
+
+type CheckedCloser interface {
+	Close()
+}
+
+type checkedCloserImpl func()
+
+func (c checkedCloserImpl) Close() {
+	c()
+}
+
+func Init() CheckedCloser {
+	initOnce.Do(func() {
+		cfg := baseconfig.MustSetupAll(&Config{}, baseconfig.WithEnvPrefix("FASTAD_LOG"))
+		level := parseLogLevel(cfg.Level, zap.InfoLevel)
+
+		devEncoder := zap.NewDevelopmentEncoderConfig()
+		devEncoder.EncodeTime = zapcore.ISO8601TimeEncoder
+		devEncoder.EncodeLevel = zapcore.CapitalColorLevelEncoder
+
+		consoleEncoder := zapcore.NewConsoleEncoder(devEncoder)
+
+		stderr := zapcore.Lock(os.Stderr)
+		core := zapcore.NewCore(consoleEncoder, stderr, level)
+
+		zap.ReplaceGlobals(zap.New(core, zap.WithCaller(true)))
+	})
+
+	return checkedCloserImpl(func() {
+		if err := zap.L().Sync(); err != nil && !errors.Is(err, syscall.ENOTTY) {
+			fmt.Fprintf(os.Stderr, "failed to sync logger: %v\n", err)
+		}
+	})
+}
+
+func parseLogLevel(levelStr string, defaultLevel zapcore.Level) zapcore.Level {
+	switch strings.ToLower(levelStr) {
+	case "debug":
+		return zap.DebugLevel
+	case "info":
+		return zap.InfoLevel
+	case "warn", "warning":
+		return zap.WarnLevel
+	case "error":
+		return zap.ErrorLevel
+	case "panic", "fatal":
+		return zap.FatalLevel
+	default:
+		return defaultLevel
+	}
+}
diff --git a/pkg/logging/init_test.go b/pkg/logging/init_test.go
new file mode 100644
index 0000000..1ae1fc1
--- /dev/null
+++ b/pkg/logging/init_test.go
@@ -0,0 +1,133 @@
+//nolint:testpackage // Testing unexported function parseLogLevel
+package logging
+
+import (
+	"testing"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+func TestParseLogLevel(t *testing.T) {
+	tests := []struct {
+		name         string
+		levelStr     string
+		defaultLevel zapcore.Level
+		want         zapcore.Level
+	}{
+		// Valid level strings
+		{
+			name:         "debug level",
+			levelStr:     "debug",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.DebugLevel,
+		},
+		{
+			name:         "DEBUG level uppercase",
+			levelStr:     "DEBUG",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.DebugLevel,
+		},
+		{
+			name:         "Debug level mixed case",
+			levelStr:     "Debug",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.DebugLevel,
+		},
+		{
+			name:         "info level",
+			levelStr:     "info",
+			defaultLevel: zap.DebugLevel,
+			want:         zap.InfoLevel,
+		},
+		{
+			name:         "warn level",
+			levelStr:     "warn",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.WarnLevel,
+		},
+		{
+			name:         "warning level alias",
+			levelStr:     "warning",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.WarnLevel,
+		},
+		{
+			name:         "error level",
+			levelStr:     "error",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.ErrorLevel,
+		},
+		{
+			name:         "panic level maps to fatal",
+			levelStr:     "panic",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.FatalLevel,
+		},
+		{
+			name:         "fatal level",
+			levelStr:     "fatal",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.FatalLevel,
+		},
+		// Invalid level strings - should return default
+		{
+			name:         "empty string returns default",
+			levelStr:     "",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.InfoLevel,
+		},
+		{
+			name:         "unknown level returns default",
+			levelStr:     "unknown",
+			defaultLevel: zap.WarnLevel,
+			want:         zap.WarnLevel,
+		},
+		{
+			name:         "typo level returns default",
+			levelStr:     "debuf",
+			defaultLevel: zap.ErrorLevel,
+			want:         zap.ErrorLevel,
+		},
+		{
+			name:         "numeric string returns default",
+			levelStr:     "123",
+			defaultLevel: zap.InfoLevel,
+			want:         zap.InfoLevel,
+		},
+		{
+			name:         "whitespace returns default",
+			levelStr:     "   ",
+			defaultLevel: zap.DebugLevel,
+			want:         zap.DebugLevel,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseLogLevel(tt.levelStr, tt.defaultLevel)
+			if got != tt.want {
+				t.Errorf("parseLogLevel(%q, %v) = %v, want %v",
+					tt.levelStr, tt.defaultLevel, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCheckedCloserImpl(t *testing.T) {
+	// Test that the closer implementation works
+	called := false
+	closer := checkedCloserImpl(func() {
+		called = true
+	})
+
+	closer.Close()
+
+	if !called {
+		t.Error("expected closer function to be called")
+	}
+}
+
+func TestCheckedCloser_Interface(_ *testing.T) {
+	var _ CheckedCloser = checkedCloserImpl(func() {})
+}
diff --git a/pkg/logging/temporal_adapter.go b/pkg/logging/temporal_adapter.go
new file mode 100644
index 0000000..38ab025
--- /dev/null
+++ b/pkg/logging/temporal_adapter.go
@@ -0,0 +1,44 @@
+package logging
+
+import (
+	"go.temporal.io/sdk/log"
+	"go.uber.org/zap"
+)
+
+var (
+	_ log.Logger          = TemporalAdapter{}
+	_ log.WithSkipCallers = TemporalAdapter{}
+	_ log.WithLogger      = TemporalAdapter{}
+)
+
+type TemporalAdapter struct {
+	impl *zap.SugaredLogger
+}
+
+func NewTemporalAdapter(logger *zap.Logger) TemporalAdapter {
+	return TemporalAdapter{impl: logger.WithOptions(zap.AddCallerSkip(1)).Sugar()}
+}
+
+func (a TemporalAdapter) With(keyvals ...any) log.Logger {
+	return TemporalAdapter{impl: a.impl.With(keyvals...)}
+}
+
+func (a TemporalAdapter) WithCallerSkip(i int) log.Logger {
+	return TemporalAdapter{impl: a.impl.WithOptions(zap.AddCallerSkip(i))}
+}
+
+func (a TemporalAdapter) Debug(msg string, keyvals ...any) {
+	a.impl.Debugw(msg, keyvals...)
+}
+
+func (a TemporalAdapter) Info(msg string, keyvals ...any) {
+	a.impl.Infow(msg, keyvals...)
+}
+
+func (a TemporalAdapter) Warn(msg string, keyvals ...any) {
+	a.impl.Warnw(msg, keyvals...)
+}
+
+func (a TemporalAdapter) Error(msg string, keyvals ...any) {
+	a.impl.Errorw(msg, keyvals...)
+}
diff --git a/pkg/metrics/server.go b/pkg/metrics/server.go
new file mode 100644
index 0000000..83e3f73
--- /dev/null
+++ b/pkg/metrics/server.go
@@ -0,0 +1,39 @@
+package metrics
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"go.uber.org/zap"
+)
+
+func RunServer(runCtx, shutdownCtx context.Context, addr string) {
+	logger := zap.L().With(
+		zap.String("service", "metrics"),
+		zap.String("address", addr),
+	)
+
+	logger.Info("starting server")
+
+	m := http.NewServeMux()
+	m.Handle("/metrics", promhttp.Handler())
+	s := &http.Server{
+		Addr:              addr,
+		Handler:           m,
+		ReadHeaderTimeout: time.Second * 10,
+	}
+
+	go func() {
+		<-runCtx.Done()
+		if err := s.Shutdown(shutdownCtx); err != nil {
+			logger.Error("error shutting down server", zap.Error(err))
+		}
+	}()
+
+	if err := s.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		logger.Error("running server", zap.Error(err))
+	}
+}
diff --git a/pkg/metrics/temporal.go b/pkg/metrics/temporal.go
new file mode 100644
index 0000000..aaddc95
--- /dev/null
+++ b/pkg/metrics/temporal.go
@@ -0,0 +1,47 @@
+package metrics
+
+import (
+	"fmt"
+	"time"
+
+	prom "github.com/prometheus/client_golang/prometheus"
+	"github.com/uber-go/tally/v4"
+	"github.com/uber-go/tally/v4/prometheus"
+	"go.temporal.io/sdk/client"
+	sdktally "go.temporal.io/sdk/contrib/tally"
+	"go.uber.org/zap"
+)
+
+func TemporalHandler(addr string) (client.MetricsHandler, error) {
+	scope, err := newPrometheusScope(prometheus.Configuration{
+		ListenAddress: addr,
+		TimerType:     "histogram",
+	})
+	if err != nil {
+		return nil, fmt.Errorf("creating prometheus scope: %w", err)
+	}
+	return sdktally.NewMetricsHandler(scope), nil
+}
+
+func newPrometheusScope(c prometheus.Configuration) (tally.Scope, error) {
+	reporter, err := c.NewReporter(
+		prometheus.ConfigurationOptions{
+			Registry: prom.NewRegistry(),
+			OnError: func(err error) {
+				zap.L().Error("error in prometheus reporter", zap.Error(err))
+			},
+		},
+	)
+	if err != nil {
+		return nil, fmt.Errorf("creating prometheus reporter: %w", err)
+	}
+	scopeOpts := tally.ScopeOptions{
+		CachedReporter:  reporter,
+		Separator:       prometheus.DefaultSeparator,
+		SanitizeOptions: &sdktally.PrometheusSanitizeOptions,
+	}
+	scope, _ := tally.NewRootScope(scopeOpts, time.Second)
+	scope = sdktally.NewPrometheusNamingScope(scope)
+
+	return scope, nil
+}
diff --git a/pkg/modelsutil/services.go b/pkg/modelsutil/services.go
new file mode 100644
index 0000000..a8a7c49
--- /dev/null
+++ b/pkg/modelsutil/services.go
@@ -0,0 +1,32 @@
+package modelsutil
+
+import (
+	"time"
+
+	"github.com/samber/lo"
+
+	"github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	"github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+const defaultRunCount = 1
+
+func ServiceCheckerTimeout(service *services.Service, action checker.Action) time.Duration {
+	actionCfg, ok := lo.Find(service.GetChecker().GetActions(), func(item *services.Service_Checker_Action) bool {
+		return item.GetAction() == action
+	})
+	if !ok || actionCfg.GetTimeout().AsDuration() == 0 {
+		return service.GetChecker().GetDefaultTimeout().AsDuration()
+	}
+	return actionCfg.GetTimeout().AsDuration()
+}
+
+func ServiceCheckerRunCount(service *services.Service, action checker.Action) int {
+	actionCfg, ok := lo.Find(service.GetChecker().GetActions(), func(item *services.Service_Checker_Action) bool {
+		return item.GetAction() == action
+	})
+	if !ok || actionCfg.GetRunCount() == 0 {
+		return defaultRunCount
+	}
+	return int(actionCfg.GetRunCount())
+}
diff --git a/internal/multiproto/wrapper.go b/pkg/multiproto/wrapper.go
similarity index 100%
rename from internal/multiproto/wrapper.go
rename to pkg/multiproto/wrapper.go
diff --git a/pkg/proto/checker/checker.pb.go b/pkg/proto/checker/checker.pb.go
new file mode 100644
index 0000000..c149d43
--- /dev/null
+++ b/pkg/proto/checker/checker.pb.go
@@ -0,0 +1,421 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: checker/checker.proto
+
+package checker
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type Action int32
+
+const (
+	Action_ACTION_UNSPECIFIED Action = 0
+	Action_ACTION_CHECK       Action = 1
+	Action_ACTION_PUT         Action = 2
+	Action_ACTION_GET         Action = 3
+)
+
+// Enum value maps for Action.
+var (
+	Action_name = map[int32]string{
+		0: "ACTION_UNSPECIFIED",
+		1: "ACTION_CHECK",
+		2: "ACTION_PUT",
+		3: "ACTION_GET",
+	}
+	Action_value = map[string]int32{
+		"ACTION_UNSPECIFIED": 0,
+		"ACTION_CHECK":       1,
+		"ACTION_PUT":         2,
+		"ACTION_GET":         3,
+	}
+)
+
+func (x Action) Enum() *Action {
+	p := new(Action)
+	*p = x
+	return p
+}
+
+func (x Action) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Action) Descriptor() protoreflect.EnumDescriptor {
+	return file_checker_checker_proto_enumTypes[0].Descriptor()
+}
+
+func (Action) Type() protoreflect.EnumType {
+	return &file_checker_checker_proto_enumTypes[0]
+}
+
+func (x Action) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Action.Descriptor instead.
+func (Action) EnumDescriptor() ([]byte, []int) {
+	return file_checker_checker_proto_rawDescGZIP(), []int{0}
+}
+
+type Status int32
+
+const (
+	Status_STATUS_UNSPECIFIED  Status = 0
+	Status_STATUS_UP           Status = 1
+	Status_STATUS_MUMBLE       Status = 2
+	Status_STATUS_CORRUPT      Status = 3
+	Status_STATUS_DOWN         Status = 4
+	Status_STATUS_CHECK_FAILED Status = 5
+)
+
+// Enum value maps for Status.
+var (
+	Status_name = map[int32]string{
+		0: "STATUS_UNSPECIFIED",
+		1: "STATUS_UP",
+		2: "STATUS_MUMBLE",
+		3: "STATUS_CORRUPT",
+		4: "STATUS_DOWN",
+		5: "STATUS_CHECK_FAILED",
+	}
+	Status_value = map[string]int32{
+		"STATUS_UNSPECIFIED":  0,
+		"STATUS_UP":           1,
+		"STATUS_MUMBLE":       2,
+		"STATUS_CORRUPT":      3,
+		"STATUS_DOWN":         4,
+		"STATUS_CHECK_FAILED": 5,
+	}
+)
+
+func (x Status) Enum() *Status {
+	p := new(Status)
+	*p = x
+	return p
+}
+
+func (x Status) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Status) Descriptor() protoreflect.EnumDescriptor {
+	return file_checker_checker_proto_enumTypes[1].Descriptor()
+}
+
+func (Status) Type() protoreflect.EnumType {
+	return &file_checker_checker_proto_enumTypes[1]
+}
+
+func (x Status) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Status.Descriptor instead.
+func (Status) EnumDescriptor() ([]byte, []int) {
+	return file_checker_checker_proto_rawDescGZIP(), []int{1}
+}
+
+type Type int32
+
+const (
+	Type_TYPE_UNSPECIFIED Type = 0
+	Type_TYPE_LEGACY      Type = 1
+)
+
+// Enum value maps for Type.
+var (
+	Type_name = map[int32]string{
+		0: "TYPE_UNSPECIFIED",
+		1: "TYPE_LEGACY",
+	}
+	Type_value = map[string]int32{
+		"TYPE_UNSPECIFIED": 0,
+		"TYPE_LEGACY":      1,
+	}
+)
+
+func (x Type) Enum() *Type {
+	p := new(Type)
+	*p = x
+	return p
+}
+
+func (x Type) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_checker_checker_proto_enumTypes[2].Descriptor()
+}
+
+func (Type) Type() protoreflect.EnumType {
+	return &file_checker_checker_proto_enumTypes[2]
+}
+
+func (x Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Type.Descriptor instead.
+func (Type) EnumDescriptor() ([]byte, []int) {
+	return file_checker_checker_proto_rawDescGZIP(), []int{2}
+}
+
+type Execution struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	TeamId        int64                  `protobuf:"varint,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"`
+	ServiceId     int64                  `protobuf:"varint,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
+	Action        Action                 `protobuf:"varint,3,opt,name=action,proto3,enum=checker.Action" json:"action,omitempty"`
+	Status        Status                 `protobuf:"varint,4,opt,name=status,proto3,enum=checker.Status" json:"status,omitempty"`
+	Public        string                 `protobuf:"bytes,5,opt,name=public,proto3" json:"public,omitempty"`
+	Private       string                 `protobuf:"bytes,6,opt,name=private,proto3" json:"private,omitempty"`
+	Command       string                 `protobuf:"bytes,7,opt,name=command,proto3" json:"command,omitempty"`
+	CreatedAt     *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Execution) Reset() {
+	*x = Execution{}
+	mi := &file_checker_checker_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Execution) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Execution) ProtoMessage() {}
+
+func (x *Execution) ProtoReflect() protoreflect.Message {
+	mi := &file_checker_checker_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Execution.ProtoReflect.Descriptor instead.
+func (*Execution) Descriptor() ([]byte, []int) {
+	return file_checker_checker_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Execution) GetTeamId() int64 {
+	if x != nil {
+		return x.TeamId
+	}
+	return 0
+}
+
+func (x *Execution) GetServiceId() int64 {
+	if x != nil {
+		return x.ServiceId
+	}
+	return 0
+}
+
+func (x *Execution) GetAction() Action {
+	if x != nil {
+		return x.Action
+	}
+	return Action_ACTION_UNSPECIFIED
+}
+
+func (x *Execution) GetStatus() Status {
+	if x != nil {
+		return x.Status
+	}
+	return Status_STATUS_UNSPECIFIED
+}
+
+func (x *Execution) GetPublic() string {
+	if x != nil {
+		return x.Public
+	}
+	return ""
+}
+
+func (x *Execution) GetPrivate() string {
+	if x != nil {
+		return x.Private
+	}
+	return ""
+}
+
+func (x *Execution) GetCommand() string {
+	if x != nil {
+		return x.Command
+	}
+	return ""
+}
+
+func (x *Execution) GetCreatedAt() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CreatedAt
+	}
+	return nil
+}
+
+type Execution_Batch struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Executions    []*Execution           `protobuf:"bytes,1,rep,name=executions,proto3" json:"executions,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Execution_Batch) Reset() {
+	*x = Execution_Batch{}
+	mi := &file_checker_checker_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Execution_Batch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Execution_Batch) ProtoMessage() {}
+
+func (x *Execution_Batch) ProtoReflect() protoreflect.Message {
+	mi := &file_checker_checker_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Execution_Batch.ProtoReflect.Descriptor instead.
+func (*Execution_Batch) Descriptor() ([]byte, []int) {
+	return file_checker_checker_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *Execution_Batch) GetExecutions() []*Execution {
+	if x != nil {
+		return x.Executions
+	}
+	return nil
+}
+
+var File_checker_checker_proto protoreflect.FileDescriptor
+
+const file_checker_checker_proto_rawDesc = "" +
+	"\n" +
+	"\x15checker/checker.proto\x12\achecker\x1a\x1fgoogle/protobuf/timestamp.proto\"\xd9\x02\n" +
+	"\tExecution\x12\x17\n" +
+	"\ateam_id\x18\x01 \x01(\x03R\x06teamId\x12\x1d\n" +
+	"\n" +
+	"service_id\x18\x02 \x01(\x03R\tserviceId\x12'\n" +
+	"\x06action\x18\x03 \x01(\x0e2\x0f.checker.ActionR\x06action\x12'\n" +
+	"\x06status\x18\x04 \x01(\x0e2\x0f.checker.StatusR\x06status\x12\x16\n" +
+	"\x06public\x18\x05 \x01(\tR\x06public\x12\x18\n" +
+	"\aprivate\x18\x06 \x01(\tR\aprivate\x12\x18\n" +
+	"\acommand\x18\a \x01(\tR\acommand\x129\n" +
+	"\n" +
+	"created_at\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x1a;\n" +
+	"\x05Batch\x122\n" +
+	"\n" +
+	"executions\x18\x01 \x03(\v2\x12.checker.ExecutionR\n" +
+	"executions*R\n" +
+	"\x06Action\x12\x16\n" +
+	"\x12ACTION_UNSPECIFIED\x10\x00\x12\x10\n" +
+	"\fACTION_CHECK\x10\x01\x12\x0e\n" +
+	"\n" +
+	"ACTION_PUT\x10\x02\x12\x0e\n" +
+	"\n" +
+	"ACTION_GET\x10\x03*\x80\x01\n" +
+	"\x06Status\x12\x16\n" +
+	"\x12STATUS_UNSPECIFIED\x10\x00\x12\r\n" +
+	"\tSTATUS_UP\x10\x01\x12\x11\n" +
+	"\rSTATUS_MUMBLE\x10\x02\x12\x12\n" +
+	"\x0eSTATUS_CORRUPT\x10\x03\x12\x0f\n" +
+	"\vSTATUS_DOWN\x10\x04\x12\x17\n" +
+	"\x13STATUS_CHECK_FAILED\x10\x05*-\n" +
+	"\x04Type\x12\x14\n" +
+	"\x10TYPE_UNSPECIFIED\x10\x00\x12\x0f\n" +
+	"\vTYPE_LEGACY\x10\x01B\x88\x01\n" +
+	"\vcom.checkerB\fCheckerProtoP\x01Z/github.com/c4t-but-s4d/fastad/pkg/proto/checker\xa2\x02\x03CXX\xaa\x02\aChecker\xca\x02\aChecker\xe2\x02\x13Checker\\GPBMetadata\xea\x02\aCheckerb\x06proto3"
+
+var (
+	file_checker_checker_proto_rawDescOnce sync.Once
+	file_checker_checker_proto_rawDescData []byte
+)
+
+func file_checker_checker_proto_rawDescGZIP() []byte {
+	file_checker_checker_proto_rawDescOnce.Do(func() {
+		file_checker_checker_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_checker_checker_proto_rawDesc), len(file_checker_checker_proto_rawDesc)))
+	})
+	return file_checker_checker_proto_rawDescData
+}
+
+var file_checker_checker_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
+var file_checker_checker_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_checker_checker_proto_goTypes = []any{
+	(Action)(0),                   // 0: checker.Action
+	(Status)(0),                   // 1: checker.Status
+	(Type)(0),                     // 2: checker.Type
+	(*Execution)(nil),             // 3: checker.Execution
+	(*Execution_Batch)(nil),       // 4: checker.Execution.Batch
+	(*timestamppb.Timestamp)(nil), // 5: google.protobuf.Timestamp
+}
+var file_checker_checker_proto_depIdxs = []int32{
+	0, // 0: checker.Execution.action:type_name -> checker.Action
+	1, // 1: checker.Execution.status:type_name -> checker.Status
+	5, // 2: checker.Execution.created_at:type_name -> google.protobuf.Timestamp
+	3, // 3: checker.Execution.Batch.executions:type_name -> checker.Execution
+	4, // [4:4] is the sub-list for method output_type
+	4, // [4:4] is the sub-list for method input_type
+	4, // [4:4] is the sub-list for extension type_name
+	4, // [4:4] is the sub-list for extension extendee
+	0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_checker_checker_proto_init() }
+func file_checker_checker_proto_init() {
+	if File_checker_checker_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_checker_checker_proto_rawDesc), len(file_checker_checker_proto_rawDesc)),
+			NumEnums:      3,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_checker_checker_proto_goTypes,
+		DependencyIndexes: file_checker_checker_proto_depIdxs,
+		EnumInfos:         file_checker_checker_proto_enumTypes,
+		MessageInfos:      file_checker_checker_proto_msgTypes,
+	}.Build()
+	File_checker_checker_proto = out.File
+	file_checker_checker_proto_goTypes = nil
+	file_checker_checker_proto_depIdxs = nil
+}
diff --git a/pkg/proto/checker/checker_vtproto.pb.go b/pkg/proto/checker/checker_vtproto.pb.go
new file mode 100644
index 0000000..aedfb35
--- /dev/null
+++ b/pkg/proto/checker/checker_vtproto.pb.go
@@ -0,0 +1,140 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: checker/checker.proto
+
+package checker
+
+import (
+	timestamppb1 "github.com/planetscale/vtprotobuf/types/known/timestamppb"
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *Execution_Batch) CloneVT() *Execution_Batch {
+	if m == nil {
+		return (*Execution_Batch)(nil)
+	}
+	r := new(Execution_Batch)
+	if rhs := m.Executions; rhs != nil {
+		tmpContainer := make([]*Execution, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Executions = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Execution_Batch) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Execution) CloneVT() *Execution {
+	if m == nil {
+		return (*Execution)(nil)
+	}
+	r := new(Execution)
+	r.TeamId = m.TeamId
+	r.ServiceId = m.ServiceId
+	r.Action = m.Action
+	r.Status = m.Status
+	r.Public = m.Public
+	r.Private = m.Private
+	r.Command = m.Command
+	r.CreatedAt = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.CreatedAt).CloneVT())
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Execution) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *Execution_Batch) EqualVT(that *Execution_Batch) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Executions) != len(that.Executions) {
+		return false
+	}
+	for i, vx := range this.Executions {
+		vy := that.Executions[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Execution{}
+			}
+			if q == nil {
+				q = &Execution{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Execution_Batch) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Execution_Batch)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *Execution) EqualVT(that *Execution) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.TeamId != that.TeamId {
+		return false
+	}
+	if this.ServiceId != that.ServiceId {
+		return false
+	}
+	if this.Action != that.Action {
+		return false
+	}
+	if this.Status != that.Status {
+		return false
+	}
+	if this.Public != that.Public {
+		return false
+	}
+	if this.Private != that.Private {
+		return false
+	}
+	if this.Command != that.Command {
+		return false
+	}
+	if !(*timestamppb1.Timestamp)(this.CreatedAt).EqualVT((*timestamppb1.Timestamp)(that.CreatedAt)) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Execution) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Execution)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/data/game_state/game_state.pb.go b/pkg/proto/data/game_state/game_state.pb.go
new file mode 100644
index 0000000..b342e73
--- /dev/null
+++ b/pkg/proto/data/game_state/game_state.pb.go
@@ -0,0 +1,892 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: data/game_state/game_state.proto
+
+package game_state
+
+import (
+	version "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type GameStatus int32
+
+const (
+	GameStatus_GAME_STATUS_UNSPECIFIED GameStatus = 0
+	GameStatus_GAME_STATUS_NOT_STARTED GameStatus = 1
+	GameStatus_GAME_STATUS_RUNNING     GameStatus = 2
+	GameStatus_GAME_STATUS_PAUSED      GameStatus = 3
+	GameStatus_GAME_STATUS_FINISHED    GameStatus = 4
+)
+
+// Enum value maps for GameStatus.
+var (
+	GameStatus_name = map[int32]string{
+		0: "GAME_STATUS_UNSPECIFIED",
+		1: "GAME_STATUS_NOT_STARTED",
+		2: "GAME_STATUS_RUNNING",
+		3: "GAME_STATUS_PAUSED",
+		4: "GAME_STATUS_FINISHED",
+	}
+	GameStatus_value = map[string]int32{
+		"GAME_STATUS_UNSPECIFIED": 0,
+		"GAME_STATUS_NOT_STARTED": 1,
+		"GAME_STATUS_RUNNING":     2,
+		"GAME_STATUS_PAUSED":      3,
+		"GAME_STATUS_FINISHED":    4,
+	}
+)
+
+func (x GameStatus) Enum() *GameStatus {
+	p := new(GameStatus)
+	*p = x
+	return p
+}
+
+func (x GameStatus) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (GameStatus) Descriptor() protoreflect.EnumDescriptor {
+	return file_data_game_state_game_state_proto_enumTypes[0].Descriptor()
+}
+
+func (GameStatus) Type() protoreflect.EnumType {
+	return &file_data_game_state_game_state_proto_enumTypes[0]
+}
+
+func (x GameStatus) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use GameStatus.Descriptor instead.
+func (GameStatus) EnumDescriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{0}
+}
+
+type GameState struct {
+	state              protoimpl.MessageState `protogen:"open.v1"`
+	StartTime          *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
+	EndTime            *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
+	TotalRounds        uint64                 `protobuf:"varint,3,opt,name=total_rounds,json=totalRounds,proto3" json:"total_rounds,omitempty"`
+	Status             GameStatus             `protobuf:"varint,4,opt,name=status,proto3,enum=data.game_state.GameStatus" json:"status,omitempty"`
+	FlagLifetimeRounds uint64                 `protobuf:"varint,5,opt,name=flag_lifetime_rounds,json=flagLifetimeRounds,proto3" json:"flag_lifetime_rounds,omitempty"`
+	RoundDuration      *durationpb.Duration   `protobuf:"bytes,6,opt,name=round_duration,json=roundDuration,proto3" json:"round_duration,omitempty"`
+	RunningRound       uint64                 `protobuf:"varint,7,opt,name=running_round,json=runningRound,proto3" json:"running_round,omitempty"`
+	RunningRoundStart  *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=running_round_start,json=runningRoundStart,proto3" json:"running_round_start,omitempty"`
+	Hardness           float64                `protobuf:"fixed64,9,opt,name=hardness,proto3" json:"hardness,omitempty"`
+	Inflation          bool                   `protobuf:"varint,10,opt,name=inflation,proto3" json:"inflation,omitempty"`
+	unknownFields      protoimpl.UnknownFields
+	sizeCache          protoimpl.SizeCache
+}
+
+func (x *GameState) Reset() {
+	*x = GameState{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GameState) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GameState) ProtoMessage() {}
+
+func (x *GameState) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GameState.ProtoReflect.Descriptor instead.
+func (*GameState) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *GameState) GetStartTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.StartTime
+	}
+	return nil
+}
+
+func (x *GameState) GetEndTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.EndTime
+	}
+	return nil
+}
+
+func (x *GameState) GetTotalRounds() uint64 {
+	if x != nil {
+		return x.TotalRounds
+	}
+	return 0
+}
+
+func (x *GameState) GetStatus() GameStatus {
+	if x != nil {
+		return x.Status
+	}
+	return GameStatus_GAME_STATUS_UNSPECIFIED
+}
+
+func (x *GameState) GetFlagLifetimeRounds() uint64 {
+	if x != nil {
+		return x.FlagLifetimeRounds
+	}
+	return 0
+}
+
+func (x *GameState) GetRoundDuration() *durationpb.Duration {
+	if x != nil {
+		return x.RoundDuration
+	}
+	return nil
+}
+
+func (x *GameState) GetRunningRound() uint64 {
+	if x != nil {
+		return x.RunningRound
+	}
+	return 0
+}
+
+func (x *GameState) GetRunningRoundStart() *timestamppb.Timestamp {
+	if x != nil {
+		return x.RunningRoundStart
+	}
+	return nil
+}
+
+func (x *GameState) GetHardness() float64 {
+	if x != nil {
+		return x.Hardness
+	}
+	return 0
+}
+
+func (x *GameState) GetInflation() bool {
+	if x != nil {
+		return x.Inflation
+	}
+	return false
+}
+
+type GetRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Version       *version.Version       `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetRequest) Reset() {
+	*x = GetRequest{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetRequest) ProtoMessage() {}
+
+func (x *GetRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetRequest.ProtoReflect.Descriptor instead.
+func (*GetRequest) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *GetRequest) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type GetResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	GameState     *GameState             `protobuf:"bytes,1,opt,name=game_state,json=gameState,proto3" json:"game_state,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetResponse) Reset() {
+	*x = GetResponse{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetResponse) ProtoMessage() {}
+
+func (x *GetResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetResponse.ProtoReflect.Descriptor instead.
+func (*GetResponse) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *GetResponse) GetGameState() *GameState {
+	if x != nil {
+		return x.GameState
+	}
+	return nil
+}
+
+func (x *GetResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type UpdateRequest struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
+	// Zero time means no end time.
+	EndTime            *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
+	TotalRounds        *uint64                `protobuf:"varint,3,opt,name=total_rounds,json=totalRounds,proto3,oneof" json:"total_rounds,omitempty"`
+	Status             GameStatus             `protobuf:"varint,4,opt,name=status,proto3,enum=data.game_state.GameStatus" json:"status,omitempty"`
+	FlagLifetimeRounds *uint64                `protobuf:"varint,5,opt,name=flag_lifetime_rounds,json=flagLifetimeRounds,proto3,oneof" json:"flag_lifetime_rounds,omitempty"`
+	RoundDuration      *durationpb.Duration   `protobuf:"bytes,6,opt,name=round_duration,json=roundDuration,proto3" json:"round_duration,omitempty"`
+	Hardness           *float64               `protobuf:"fixed64,7,opt,name=hardness,proto3,oneof" json:"hardness,omitempty"`
+	Inflation          *bool                  `protobuf:"varint,8,opt,name=inflation,proto3,oneof" json:"inflation,omitempty"`
+	unknownFields      protoimpl.UnknownFields
+	sizeCache          protoimpl.SizeCache
+}
+
+func (x *UpdateRequest) Reset() {
+	*x = UpdateRequest{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateRequest) ProtoMessage() {}
+
+func (x *UpdateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[3]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateRequest.ProtoReflect.Descriptor instead.
+func (*UpdateRequest) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *UpdateRequest) GetStartTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.StartTime
+	}
+	return nil
+}
+
+func (x *UpdateRequest) GetEndTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.EndTime
+	}
+	return nil
+}
+
+func (x *UpdateRequest) GetTotalRounds() uint64 {
+	if x != nil && x.TotalRounds != nil {
+		return *x.TotalRounds
+	}
+	return 0
+}
+
+func (x *UpdateRequest) GetStatus() GameStatus {
+	if x != nil {
+		return x.Status
+	}
+	return GameStatus_GAME_STATUS_UNSPECIFIED
+}
+
+func (x *UpdateRequest) GetFlagLifetimeRounds() uint64 {
+	if x != nil && x.FlagLifetimeRounds != nil {
+		return *x.FlagLifetimeRounds
+	}
+	return 0
+}
+
+func (x *UpdateRequest) GetRoundDuration() *durationpb.Duration {
+	if x != nil {
+		return x.RoundDuration
+	}
+	return nil
+}
+
+func (x *UpdateRequest) GetHardness() float64 {
+	if x != nil && x.Hardness != nil {
+		return *x.Hardness
+	}
+	return 0
+}
+
+func (x *UpdateRequest) GetInflation() bool {
+	if x != nil && x.Inflation != nil {
+		return *x.Inflation
+	}
+	return false
+}
+
+type UpdateResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	GameState     *GameState             `protobuf:"bytes,1,opt,name=game_state,json=gameState,proto3" json:"game_state,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UpdateResponse) Reset() {
+	*x = UpdateResponse{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateResponse) ProtoMessage() {}
+
+func (x *UpdateResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[4]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateResponse.ProtoReflect.Descriptor instead.
+func (*UpdateResponse) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *UpdateResponse) GetGameState() *GameState {
+	if x != nil {
+		return x.GameState
+	}
+	return nil
+}
+
+func (x *UpdateResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type UpdateRoundRequest struct {
+	state             protoimpl.MessageState `protogen:"open.v1"`
+	RunningRound      uint64                 `protobuf:"varint,1,opt,name=running_round,json=runningRound,proto3" json:"running_round,omitempty"`
+	RunningRoundStart *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=running_round_start,json=runningRoundStart,proto3" json:"running_round_start,omitempty"`
+	unknownFields     protoimpl.UnknownFields
+	sizeCache         protoimpl.SizeCache
+}
+
+func (x *UpdateRoundRequest) Reset() {
+	*x = UpdateRoundRequest{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateRoundRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateRoundRequest) ProtoMessage() {}
+
+func (x *UpdateRoundRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateRoundRequest.ProtoReflect.Descriptor instead.
+func (*UpdateRoundRequest) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *UpdateRoundRequest) GetRunningRound() uint64 {
+	if x != nil {
+		return x.RunningRound
+	}
+	return 0
+}
+
+func (x *UpdateRoundRequest) GetRunningRoundStart() *timestamppb.Timestamp {
+	if x != nil {
+		return x.RunningRoundStart
+	}
+	return nil
+}
+
+type UpdateRoundResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	GameState     *GameState             `protobuf:"bytes,1,opt,name=game_state,json=gameState,proto3" json:"game_state,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UpdateRoundResponse) Reset() {
+	*x = UpdateRoundResponse{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateRoundResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateRoundResponse) ProtoMessage() {}
+
+func (x *UpdateRoundResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[6]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateRoundResponse.ProtoReflect.Descriptor instead.
+func (*UpdateRoundResponse) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *UpdateRoundResponse) GetGameState() *GameState {
+	if x != nil {
+		return x.GameState
+	}
+	return nil
+}
+
+func (x *UpdateRoundResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type FinishGameRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *FinishGameRequest) Reset() {
+	*x = FinishGameRequest{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *FinishGameRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FinishGameRequest) ProtoMessage() {}
+
+func (x *FinishGameRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[7]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FinishGameRequest.ProtoReflect.Descriptor instead.
+func (*FinishGameRequest) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{7}
+}
+
+type FinishGameResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	GameState     *GameState             `protobuf:"bytes,1,opt,name=game_state,json=gameState,proto3" json:"game_state,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *FinishGameResponse) Reset() {
+	*x = FinishGameResponse{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *FinishGameResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FinishGameResponse) ProtoMessage() {}
+
+func (x *FinishGameResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[8]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FinishGameResponse.ProtoReflect.Descriptor instead.
+func (*FinishGameResponse) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *FinishGameResponse) GetGameState() *GameState {
+	if x != nil {
+		return x.GameState
+	}
+	return nil
+}
+
+func (x *FinishGameResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type CreateRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	GameState     *GameState             `protobuf:"bytes,1,opt,name=game_state,json=gameState,proto3" json:"game_state,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CreateRequest) Reset() {
+	*x = CreateRequest{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CreateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateRequest) ProtoMessage() {}
+
+func (x *CreateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[9]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateRequest.ProtoReflect.Descriptor instead.
+func (*CreateRequest) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *CreateRequest) GetGameState() *GameState {
+	if x != nil {
+		return x.GameState
+	}
+	return nil
+}
+
+type CreateResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	GameState     *GameState             `protobuf:"bytes,1,opt,name=game_state,json=gameState,proto3" json:"game_state,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CreateResponse) Reset() {
+	*x = CreateResponse{}
+	mi := &file_data_game_state_game_state_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CreateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateResponse) ProtoMessage() {}
+
+func (x *CreateResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_game_state_game_state_proto_msgTypes[10]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateResponse.ProtoReflect.Descriptor instead.
+func (*CreateResponse) Descriptor() ([]byte, []int) {
+	return file_data_game_state_game_state_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *CreateResponse) GetGameState() *GameState {
+	if x != nil {
+		return x.GameState
+	}
+	return nil
+}
+
+func (x *CreateResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+var File_data_game_state_game_state_proto protoreflect.FileDescriptor
+
+const file_data_game_state_game_state_proto_rawDesc = "" +
+	"\n" +
+	" data/game_state/game_state.proto\x12\x0fdata.game_state\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1adata/version/version.proto\"\xf4\x03\n" +
+	"\tGameState\x129\n" +
+	"\n" +
+	"start_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
+	"\bend_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12!\n" +
+	"\ftotal_rounds\x18\x03 \x01(\x04R\vtotalRounds\x123\n" +
+	"\x06status\x18\x04 \x01(\x0e2\x1b.data.game_state.GameStatusR\x06status\x120\n" +
+	"\x14flag_lifetime_rounds\x18\x05 \x01(\x04R\x12flagLifetimeRounds\x12@\n" +
+	"\x0eround_duration\x18\x06 \x01(\v2\x19.google.protobuf.DurationR\rroundDuration\x12#\n" +
+	"\rrunning_round\x18\a \x01(\x04R\frunningRound\x12J\n" +
+	"\x13running_round_start\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x11runningRoundStart\x12\x1a\n" +
+	"\bhardness\x18\t \x01(\x01R\bhardness\x12\x1c\n" +
+	"\tinflation\x18\n" +
+	" \x01(\bR\tinflation\"=\n" +
+	"\n" +
+	"GetRequest\x12/\n" +
+	"\aversion\x18\x01 \x01(\v2\x15.data.version.VersionR\aversion\"y\n" +
+	"\vGetResponse\x129\n" +
+	"\n" +
+	"game_state\x18\x01 \x01(\v2\x1a.data.game_state.GameStateR\tgameState\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversion\"\xe0\x03\n" +
+	"\rUpdateRequest\x129\n" +
+	"\n" +
+	"start_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
+	"\bend_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12&\n" +
+	"\ftotal_rounds\x18\x03 \x01(\x04H\x00R\vtotalRounds\x88\x01\x01\x123\n" +
+	"\x06status\x18\x04 \x01(\x0e2\x1b.data.game_state.GameStatusR\x06status\x125\n" +
+	"\x14flag_lifetime_rounds\x18\x05 \x01(\x04H\x01R\x12flagLifetimeRounds\x88\x01\x01\x12@\n" +
+	"\x0eround_duration\x18\x06 \x01(\v2\x19.google.protobuf.DurationR\rroundDuration\x12\x1f\n" +
+	"\bhardness\x18\a \x01(\x01H\x02R\bhardness\x88\x01\x01\x12!\n" +
+	"\tinflation\x18\b \x01(\bH\x03R\tinflation\x88\x01\x01B\x0f\n" +
+	"\r_total_roundsB\x17\n" +
+	"\x15_flag_lifetime_roundsB\v\n" +
+	"\t_hardnessB\f\n" +
+	"\n" +
+	"_inflation\"|\n" +
+	"\x0eUpdateResponse\x129\n" +
+	"\n" +
+	"game_state\x18\x01 \x01(\v2\x1a.data.game_state.GameStateR\tgameState\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversion\"\x85\x01\n" +
+	"\x12UpdateRoundRequest\x12#\n" +
+	"\rrunning_round\x18\x01 \x01(\x04R\frunningRound\x12J\n" +
+	"\x13running_round_start\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x11runningRoundStart\"\x81\x01\n" +
+	"\x13UpdateRoundResponse\x129\n" +
+	"\n" +
+	"game_state\x18\x01 \x01(\v2\x1a.data.game_state.GameStateR\tgameState\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversion\"\x13\n" +
+	"\x11FinishGameRequest\"\x80\x01\n" +
+	"\x12FinishGameResponse\x129\n" +
+	"\n" +
+	"game_state\x18\x01 \x01(\v2\x1a.data.game_state.GameStateR\tgameState\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversion\"J\n" +
+	"\rCreateRequest\x129\n" +
+	"\n" +
+	"game_state\x18\x01 \x01(\v2\x1a.data.game_state.GameStateR\tgameState\"|\n" +
+	"\x0eCreateResponse\x129\n" +
+	"\n" +
+	"game_state\x18\x01 \x01(\v2\x1a.data.game_state.GameStateR\tgameState\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversion*\x91\x01\n" +
+	"\n" +
+	"GameStatus\x12\x1b\n" +
+	"\x17GAME_STATUS_UNSPECIFIED\x10\x00\x12\x1b\n" +
+	"\x17GAME_STATUS_NOT_STARTED\x10\x01\x12\x17\n" +
+	"\x13GAME_STATUS_RUNNING\x10\x02\x12\x16\n" +
+	"\x12GAME_STATUS_PAUSED\x10\x03\x12\x18\n" +
+	"\x14GAME_STATUS_FINISHED\x10\x04B\xb7\x01\n" +
+	"\x13com.data.game_stateB\x0eGameStateProtoP\x01Z7github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state\xa2\x02\x03DGX\xaa\x02\x0eData.GameState\xca\x02\x0eData\\GameState\xe2\x02\x1aData\\GameState\\GPBMetadata\xea\x02\x0fData::GameStateb\x06proto3"
+
+var (
+	file_data_game_state_game_state_proto_rawDescOnce sync.Once
+	file_data_game_state_game_state_proto_rawDescData []byte
+)
+
+func file_data_game_state_game_state_proto_rawDescGZIP() []byte {
+	file_data_game_state_game_state_proto_rawDescOnce.Do(func() {
+		file_data_game_state_game_state_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_data_game_state_game_state_proto_rawDesc), len(file_data_game_state_game_state_proto_rawDesc)))
+	})
+	return file_data_game_state_game_state_proto_rawDescData
+}
+
+var file_data_game_state_game_state_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_data_game_state_game_state_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
+var file_data_game_state_game_state_proto_goTypes = []any{
+	(GameStatus)(0),               // 0: data.game_state.GameStatus
+	(*GameState)(nil),             // 1: data.game_state.GameState
+	(*GetRequest)(nil),            // 2: data.game_state.GetRequest
+	(*GetResponse)(nil),           // 3: data.game_state.GetResponse
+	(*UpdateRequest)(nil),         // 4: data.game_state.UpdateRequest
+	(*UpdateResponse)(nil),        // 5: data.game_state.UpdateResponse
+	(*UpdateRoundRequest)(nil),    // 6: data.game_state.UpdateRoundRequest
+	(*UpdateRoundResponse)(nil),   // 7: data.game_state.UpdateRoundResponse
+	(*FinishGameRequest)(nil),     // 8: data.game_state.FinishGameRequest
+	(*FinishGameResponse)(nil),    // 9: data.game_state.FinishGameResponse
+	(*CreateRequest)(nil),         // 10: data.game_state.CreateRequest
+	(*CreateResponse)(nil),        // 11: data.game_state.CreateResponse
+	(*timestamppb.Timestamp)(nil), // 12: google.protobuf.Timestamp
+	(*durationpb.Duration)(nil),   // 13: google.protobuf.Duration
+	(*version.Version)(nil),       // 14: data.version.Version
+}
+var file_data_game_state_game_state_proto_depIdxs = []int32{
+	12, // 0: data.game_state.GameState.start_time:type_name -> google.protobuf.Timestamp
+	12, // 1: data.game_state.GameState.end_time:type_name -> google.protobuf.Timestamp
+	0,  // 2: data.game_state.GameState.status:type_name -> data.game_state.GameStatus
+	13, // 3: data.game_state.GameState.round_duration:type_name -> google.protobuf.Duration
+	12, // 4: data.game_state.GameState.running_round_start:type_name -> google.protobuf.Timestamp
+	14, // 5: data.game_state.GetRequest.version:type_name -> data.version.Version
+	1,  // 6: data.game_state.GetResponse.game_state:type_name -> data.game_state.GameState
+	14, // 7: data.game_state.GetResponse.version:type_name -> data.version.Version
+	12, // 8: data.game_state.UpdateRequest.start_time:type_name -> google.protobuf.Timestamp
+	12, // 9: data.game_state.UpdateRequest.end_time:type_name -> google.protobuf.Timestamp
+	0,  // 10: data.game_state.UpdateRequest.status:type_name -> data.game_state.GameStatus
+	13, // 11: data.game_state.UpdateRequest.round_duration:type_name -> google.protobuf.Duration
+	1,  // 12: data.game_state.UpdateResponse.game_state:type_name -> data.game_state.GameState
+	14, // 13: data.game_state.UpdateResponse.version:type_name -> data.version.Version
+	12, // 14: data.game_state.UpdateRoundRequest.running_round_start:type_name -> google.protobuf.Timestamp
+	1,  // 15: data.game_state.UpdateRoundResponse.game_state:type_name -> data.game_state.GameState
+	14, // 16: data.game_state.UpdateRoundResponse.version:type_name -> data.version.Version
+	1,  // 17: data.game_state.FinishGameResponse.game_state:type_name -> data.game_state.GameState
+	14, // 18: data.game_state.FinishGameResponse.version:type_name -> data.version.Version
+	1,  // 19: data.game_state.CreateRequest.game_state:type_name -> data.game_state.GameState
+	1,  // 20: data.game_state.CreateResponse.game_state:type_name -> data.game_state.GameState
+	14, // 21: data.game_state.CreateResponse.version:type_name -> data.version.Version
+	22, // [22:22] is the sub-list for method output_type
+	22, // [22:22] is the sub-list for method input_type
+	22, // [22:22] is the sub-list for extension type_name
+	22, // [22:22] is the sub-list for extension extendee
+	0,  // [0:22] is the sub-list for field type_name
+}
+
+func init() { file_data_game_state_game_state_proto_init() }
+func file_data_game_state_game_state_proto_init() {
+	if File_data_game_state_game_state_proto != nil {
+		return
+	}
+	file_data_game_state_game_state_proto_msgTypes[3].OneofWrappers = []any{}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_data_game_state_game_state_proto_rawDesc), len(file_data_game_state_game_state_proto_rawDesc)),
+			NumEnums:      1,
+			NumMessages:   11,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_data_game_state_game_state_proto_goTypes,
+		DependencyIndexes: file_data_game_state_game_state_proto_depIdxs,
+		EnumInfos:         file_data_game_state_game_state_proto_enumTypes,
+		MessageInfos:      file_data_game_state_game_state_proto_msgTypes,
+	}.Build()
+	File_data_game_state_game_state_proto = out.File
+	file_data_game_state_game_state_proto_goTypes = nil
+	file_data_game_state_game_state_proto_depIdxs = nil
+}
diff --git a/pkg/proto/data/game_state/game_state_service.pb.go b/pkg/proto/data/game_state/game_state_service.pb.go
new file mode 100644
index 0000000..2d3c06b
--- /dev/null
+++ b/pkg/proto/data/game_state/game_state_service.pb.go
@@ -0,0 +1,89 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: data/game_state/game_state_service.proto
+
+package game_state
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+var File_data_game_state_game_state_service_proto protoreflect.FileDescriptor
+
+const file_data_game_state_game_state_service_proto_rawDesc = "" +
+	"\n" +
+	"(data/game_state/game_state_service.proto\x12\x0fdata.game_state\x1a data/game_state/game_state.proto2\x9b\x03\n" +
+	"\x10GameStateService\x12@\n" +
+	"\x03Get\x12\x1b.data.game_state.GetRequest\x1a\x1c.data.game_state.GetResponse\x12I\n" +
+	"\x06Create\x12\x1e.data.game_state.CreateRequest\x1a\x1f.data.game_state.CreateResponse\x12I\n" +
+	"\x06Update\x12\x1e.data.game_state.UpdateRequest\x1a\x1f.data.game_state.UpdateResponse\x12X\n" +
+	"\vUpdateRound\x12#.data.game_state.UpdateRoundRequest\x1a$.data.game_state.UpdateRoundResponse\x12U\n" +
+	"\n" +
+	"FinishGame\x12\".data.game_state.FinishGameRequest\x1a#.data.game_state.FinishGameResponseB\xbe\x01\n" +
+	"\x13com.data.game_stateB\x15GameStateServiceProtoP\x01Z7github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state\xa2\x02\x03DGX\xaa\x02\x0eData.GameState\xca\x02\x0eData\\GameState\xe2\x02\x1aData\\GameState\\GPBMetadata\xea\x02\x0fData::GameStateb\x06proto3"
+
+var file_data_game_state_game_state_service_proto_goTypes = []any{
+	(*GetRequest)(nil),          // 0: data.game_state.GetRequest
+	(*CreateRequest)(nil),       // 1: data.game_state.CreateRequest
+	(*UpdateRequest)(nil),       // 2: data.game_state.UpdateRequest
+	(*UpdateRoundRequest)(nil),  // 3: data.game_state.UpdateRoundRequest
+	(*FinishGameRequest)(nil),   // 4: data.game_state.FinishGameRequest
+	(*GetResponse)(nil),         // 5: data.game_state.GetResponse
+	(*CreateResponse)(nil),      // 6: data.game_state.CreateResponse
+	(*UpdateResponse)(nil),      // 7: data.game_state.UpdateResponse
+	(*UpdateRoundResponse)(nil), // 8: data.game_state.UpdateRoundResponse
+	(*FinishGameResponse)(nil),  // 9: data.game_state.FinishGameResponse
+}
+var file_data_game_state_game_state_service_proto_depIdxs = []int32{
+	0, // 0: data.game_state.GameStateService.Get:input_type -> data.game_state.GetRequest
+	1, // 1: data.game_state.GameStateService.Create:input_type -> data.game_state.CreateRequest
+	2, // 2: data.game_state.GameStateService.Update:input_type -> data.game_state.UpdateRequest
+	3, // 3: data.game_state.GameStateService.UpdateRound:input_type -> data.game_state.UpdateRoundRequest
+	4, // 4: data.game_state.GameStateService.FinishGame:input_type -> data.game_state.FinishGameRequest
+	5, // 5: data.game_state.GameStateService.Get:output_type -> data.game_state.GetResponse
+	6, // 6: data.game_state.GameStateService.Create:output_type -> data.game_state.CreateResponse
+	7, // 7: data.game_state.GameStateService.Update:output_type -> data.game_state.UpdateResponse
+	8, // 8: data.game_state.GameStateService.UpdateRound:output_type -> data.game_state.UpdateRoundResponse
+	9, // 9: data.game_state.GameStateService.FinishGame:output_type -> data.game_state.FinishGameResponse
+	5, // [5:10] is the sub-list for method output_type
+	0, // [0:5] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_data_game_state_game_state_service_proto_init() }
+func file_data_game_state_game_state_service_proto_init() {
+	if File_data_game_state_game_state_service_proto != nil {
+		return
+	}
+	file_data_game_state_game_state_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_data_game_state_game_state_service_proto_rawDesc), len(file_data_game_state_game_state_service_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_data_game_state_game_state_service_proto_goTypes,
+		DependencyIndexes: file_data_game_state_game_state_service_proto_depIdxs,
+	}.Build()
+	File_data_game_state_game_state_service_proto = out.File
+	file_data_game_state_game_state_service_proto_goTypes = nil
+	file_data_game_state_game_state_service_proto_depIdxs = nil
+}
diff --git a/pkg/proto/data/game_state/game_state_service_grpc.pb.go b/pkg/proto/data/game_state/game_state_service_grpc.pb.go
new file mode 100644
index 0000000..9f01a27
--- /dev/null
+++ b/pkg/proto/data/game_state/game_state_service_grpc.pb.go
@@ -0,0 +1,273 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.6.0
+// - protoc             (unknown)
+// source: data/game_state/game_state_service.proto
+
+package game_state
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	GameStateService_Get_FullMethodName         = "/data.game_state.GameStateService/Get"
+	GameStateService_Create_FullMethodName      = "/data.game_state.GameStateService/Create"
+	GameStateService_Update_FullMethodName      = "/data.game_state.GameStateService/Update"
+	GameStateService_UpdateRound_FullMethodName = "/data.game_state.GameStateService/UpdateRound"
+	GameStateService_FinishGame_FullMethodName  = "/data.game_state.GameStateService/FinishGame"
+)
+
+// GameStateServiceClient is the client API for GameStateService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type GameStateServiceClient interface {
+	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
+	Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error)
+	Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
+	UpdateRound(ctx context.Context, in *UpdateRoundRequest, opts ...grpc.CallOption) (*UpdateRoundResponse, error)
+	FinishGame(ctx context.Context, in *FinishGameRequest, opts ...grpc.CallOption) (*FinishGameResponse, error)
+}
+
+type gameStateServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewGameStateServiceClient(cc grpc.ClientConnInterface) GameStateServiceClient {
+	return &gameStateServiceClient{cc}
+}
+
+func (c *gameStateServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(GetResponse)
+	err := c.cc.Invoke(ctx, GameStateService_Get_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *gameStateServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(CreateResponse)
+	err := c.cc.Invoke(ctx, GameStateService_Create_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *gameStateServiceClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(UpdateResponse)
+	err := c.cc.Invoke(ctx, GameStateService_Update_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *gameStateServiceClient) UpdateRound(ctx context.Context, in *UpdateRoundRequest, opts ...grpc.CallOption) (*UpdateRoundResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(UpdateRoundResponse)
+	err := c.cc.Invoke(ctx, GameStateService_UpdateRound_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *gameStateServiceClient) FinishGame(ctx context.Context, in *FinishGameRequest, opts ...grpc.CallOption) (*FinishGameResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(FinishGameResponse)
+	err := c.cc.Invoke(ctx, GameStateService_FinishGame_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// GameStateServiceServer is the server API for GameStateService service.
+// All implementations must embed UnimplementedGameStateServiceServer
+// for forward compatibility.
+type GameStateServiceServer interface {
+	Get(context.Context, *GetRequest) (*GetResponse, error)
+	Create(context.Context, *CreateRequest) (*CreateResponse, error)
+	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
+	UpdateRound(context.Context, *UpdateRoundRequest) (*UpdateRoundResponse, error)
+	FinishGame(context.Context, *FinishGameRequest) (*FinishGameResponse, error)
+	mustEmbedUnimplementedGameStateServiceServer()
+}
+
+// UnimplementedGameStateServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedGameStateServiceServer struct{}
+
+func (UnimplementedGameStateServiceServer) Get(context.Context, *GetRequest) (*GetResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Get not implemented")
+}
+func (UnimplementedGameStateServiceServer) Create(context.Context, *CreateRequest) (*CreateResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Create not implemented")
+}
+func (UnimplementedGameStateServiceServer) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Update not implemented")
+}
+func (UnimplementedGameStateServiceServer) UpdateRound(context.Context, *UpdateRoundRequest) (*UpdateRoundResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method UpdateRound not implemented")
+}
+func (UnimplementedGameStateServiceServer) FinishGame(context.Context, *FinishGameRequest) (*FinishGameResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method FinishGame not implemented")
+}
+func (UnimplementedGameStateServiceServer) mustEmbedUnimplementedGameStateServiceServer() {}
+func (UnimplementedGameStateServiceServer) testEmbeddedByValue()                          {}
+
+// UnsafeGameStateServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to GameStateServiceServer will
+// result in compilation errors.
+type UnsafeGameStateServiceServer interface {
+	mustEmbedUnimplementedGameStateServiceServer()
+}
+
+func RegisterGameStateServiceServer(s grpc.ServiceRegistrar, srv GameStateServiceServer) {
+	// If the following call panics, it indicates UnimplementedGameStateServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&GameStateService_ServiceDesc, srv)
+}
+
+func _GameStateService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GameStateServiceServer).Get(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GameStateService_Get_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GameStateServiceServer).Get(ctx, req.(*GetRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _GameStateService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GameStateServiceServer).Create(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GameStateService_Create_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GameStateServiceServer).Create(ctx, req.(*CreateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _GameStateService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GameStateServiceServer).Update(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GameStateService_Update_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GameStateServiceServer).Update(ctx, req.(*UpdateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _GameStateService_UpdateRound_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateRoundRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GameStateServiceServer).UpdateRound(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GameStateService_UpdateRound_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GameStateServiceServer).UpdateRound(ctx, req.(*UpdateRoundRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _GameStateService_FinishGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FinishGameRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GameStateServiceServer).FinishGame(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GameStateService_FinishGame_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GameStateServiceServer).FinishGame(ctx, req.(*FinishGameRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// GameStateService_ServiceDesc is the grpc.ServiceDesc for GameStateService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var GameStateService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "data.game_state.GameStateService",
+	HandlerType: (*GameStateServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Get",
+			Handler:    _GameStateService_Get_Handler,
+		},
+		{
+			MethodName: "Create",
+			Handler:    _GameStateService_Create_Handler,
+		},
+		{
+			MethodName: "Update",
+			Handler:    _GameStateService_Update_Handler,
+		},
+		{
+			MethodName: "UpdateRound",
+			Handler:    _GameStateService_UpdateRound_Handler,
+		},
+		{
+			MethodName: "FinishGame",
+			Handler:    _GameStateService_FinishGame_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "data/game_state/game_state_service.proto",
+}
diff --git a/pkg/proto/data/game_state/game_state_vtproto.pb.go b/pkg/proto/data/game_state/game_state_vtproto.pb.go
new file mode 100644
index 0000000..d25282c
--- /dev/null
+++ b/pkg/proto/data/game_state/game_state_vtproto.pb.go
@@ -0,0 +1,514 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: data/game_state/game_state.proto
+
+package game_state
+
+import (
+	durationpb1 "github.com/planetscale/vtprotobuf/types/known/durationpb"
+	timestamppb1 "github.com/planetscale/vtprotobuf/types/known/timestamppb"
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *GameState) CloneVT() *GameState {
+	if m == nil {
+		return (*GameState)(nil)
+	}
+	r := new(GameState)
+	r.StartTime = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.StartTime).CloneVT())
+	r.EndTime = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.EndTime).CloneVT())
+	r.TotalRounds = m.TotalRounds
+	r.Status = m.Status
+	r.FlagLifetimeRounds = m.FlagLifetimeRounds
+	r.RoundDuration = (*durationpb.Duration)((*durationpb1.Duration)(m.RoundDuration).CloneVT())
+	r.RunningRound = m.RunningRound
+	r.RunningRoundStart = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.RunningRoundStart).CloneVT())
+	r.Hardness = m.Hardness
+	r.Inflation = m.Inflation
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *GameState) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *GetRequest) CloneVT() *GetRequest {
+	if m == nil {
+		return (*GetRequest)(nil)
+	}
+	r := new(GetRequest)
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *GetRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *GetResponse) CloneVT() *GetResponse {
+	if m == nil {
+		return (*GetResponse)(nil)
+	}
+	r := new(GetResponse)
+	r.GameState = m.GameState.CloneVT()
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *GetResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateRequest) CloneVT() *UpdateRequest {
+	if m == nil {
+		return (*UpdateRequest)(nil)
+	}
+	r := new(UpdateRequest)
+	r.StartTime = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.StartTime).CloneVT())
+	r.EndTime = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.EndTime).CloneVT())
+	r.Status = m.Status
+	r.RoundDuration = (*durationpb.Duration)((*durationpb1.Duration)(m.RoundDuration).CloneVT())
+	if rhs := m.TotalRounds; rhs != nil {
+		tmpVal := *rhs
+		r.TotalRounds = &tmpVal
+	}
+	if rhs := m.FlagLifetimeRounds; rhs != nil {
+		tmpVal := *rhs
+		r.FlagLifetimeRounds = &tmpVal
+	}
+	if rhs := m.Hardness; rhs != nil {
+		tmpVal := *rhs
+		r.Hardness = &tmpVal
+	}
+	if rhs := m.Inflation; rhs != nil {
+		tmpVal := *rhs
+		r.Inflation = &tmpVal
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateResponse) CloneVT() *UpdateResponse {
+	if m == nil {
+		return (*UpdateResponse)(nil)
+	}
+	r := new(UpdateResponse)
+	r.GameState = m.GameState.CloneVT()
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateRoundRequest) CloneVT() *UpdateRoundRequest {
+	if m == nil {
+		return (*UpdateRoundRequest)(nil)
+	}
+	r := new(UpdateRoundRequest)
+	r.RunningRound = m.RunningRound
+	r.RunningRoundStart = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.RunningRoundStart).CloneVT())
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateRoundRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateRoundResponse) CloneVT() *UpdateRoundResponse {
+	if m == nil {
+		return (*UpdateRoundResponse)(nil)
+	}
+	r := new(UpdateRoundResponse)
+	r.GameState = m.GameState.CloneVT()
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateRoundResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *FinishGameRequest) CloneVT() *FinishGameRequest {
+	if m == nil {
+		return (*FinishGameRequest)(nil)
+	}
+	r := new(FinishGameRequest)
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *FinishGameRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *FinishGameResponse) CloneVT() *FinishGameResponse {
+	if m == nil {
+		return (*FinishGameResponse)(nil)
+	}
+	r := new(FinishGameResponse)
+	r.GameState = m.GameState.CloneVT()
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *FinishGameResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *CreateRequest) CloneVT() *CreateRequest {
+	if m == nil {
+		return (*CreateRequest)(nil)
+	}
+	r := new(CreateRequest)
+	r.GameState = m.GameState.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CreateRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *CreateResponse) CloneVT() *CreateResponse {
+	if m == nil {
+		return (*CreateResponse)(nil)
+	}
+	r := new(CreateResponse)
+	r.GameState = m.GameState.CloneVT()
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CreateResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *GameState) EqualVT(that *GameState) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !(*timestamppb1.Timestamp)(this.StartTime).EqualVT((*timestamppb1.Timestamp)(that.StartTime)) {
+		return false
+	}
+	if !(*timestamppb1.Timestamp)(this.EndTime).EqualVT((*timestamppb1.Timestamp)(that.EndTime)) {
+		return false
+	}
+	if this.TotalRounds != that.TotalRounds {
+		return false
+	}
+	if this.Status != that.Status {
+		return false
+	}
+	if this.FlagLifetimeRounds != that.FlagLifetimeRounds {
+		return false
+	}
+	if !(*durationpb1.Duration)(this.RoundDuration).EqualVT((*durationpb1.Duration)(that.RoundDuration)) {
+		return false
+	}
+	if this.RunningRound != that.RunningRound {
+		return false
+	}
+	if !(*timestamppb1.Timestamp)(this.RunningRoundStart).EqualVT((*timestamppb1.Timestamp)(that.RunningRoundStart)) {
+		return false
+	}
+	if this.Hardness != that.Hardness {
+		return false
+	}
+	if this.Inflation != that.Inflation {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *GameState) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*GameState)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *GetRequest) EqualVT(that *GetRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *GetRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*GetRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *GetResponse) EqualVT(that *GetResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.GameState.EqualVT(that.GameState) {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *GetResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*GetResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateRequest) EqualVT(that *UpdateRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !(*timestamppb1.Timestamp)(this.StartTime).EqualVT((*timestamppb1.Timestamp)(that.StartTime)) {
+		return false
+	}
+	if !(*timestamppb1.Timestamp)(this.EndTime).EqualVT((*timestamppb1.Timestamp)(that.EndTime)) {
+		return false
+	}
+	if p, q := this.TotalRounds, that.TotalRounds; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
+		return false
+	}
+	if this.Status != that.Status {
+		return false
+	}
+	if p, q := this.FlagLifetimeRounds, that.FlagLifetimeRounds; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
+		return false
+	}
+	if !(*durationpb1.Duration)(this.RoundDuration).EqualVT((*durationpb1.Duration)(that.RoundDuration)) {
+		return false
+	}
+	if p, q := this.Hardness, that.Hardness; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
+		return false
+	}
+	if p, q := this.Inflation, that.Inflation; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateResponse) EqualVT(that *UpdateResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.GameState.EqualVT(that.GameState) {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateRoundRequest) EqualVT(that *UpdateRoundRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.RunningRound != that.RunningRound {
+		return false
+	}
+	if !(*timestamppb1.Timestamp)(this.RunningRoundStart).EqualVT((*timestamppb1.Timestamp)(that.RunningRoundStart)) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateRoundRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateRoundRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateRoundResponse) EqualVT(that *UpdateRoundResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.GameState.EqualVT(that.GameState) {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateRoundResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateRoundResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *FinishGameRequest) EqualVT(that *FinishGameRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *FinishGameRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*FinishGameRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *FinishGameResponse) EqualVT(that *FinishGameResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.GameState.EqualVT(that.GameState) {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *FinishGameResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*FinishGameResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *CreateRequest) EqualVT(that *CreateRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.GameState.EqualVT(that.GameState) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *CreateRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CreateRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *CreateResponse) EqualVT(that *CreateResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.GameState.EqualVT(that.GameState) {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *CreateResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CreateResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/data/services/services.pb.go b/pkg/proto/data/services/services.pb.go
new file mode 100644
index 0000000..6de86da
--- /dev/null
+++ b/pkg/proto/data/services/services.pb.go
@@ -0,0 +1,677 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: data/services/services.proto
+
+package services
+
+import (
+	checker "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	version "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type Service struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Id            int64                  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	Name          string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Checker       *Service_Checker       `protobuf:"bytes,3,opt,name=checker,proto3" json:"checker,omitempty"`
+	DefaultScore  float64                `protobuf:"fixed64,4,opt,name=default_score,json=defaultScore,proto3" json:"default_score,omitempty"`
+	Disabled      bool                   `protobuf:"varint,5,opt,name=disabled,proto3" json:"disabled,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Service) Reset() {
+	*x = Service{}
+	mi := &file_data_services_services_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Service) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Service) ProtoMessage() {}
+
+func (x *Service) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Service.ProtoReflect.Descriptor instead.
+func (*Service) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Service) GetId() int64 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *Service) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *Service) GetChecker() *Service_Checker {
+	if x != nil {
+		return x.Checker
+	}
+	return nil
+}
+
+func (x *Service) GetDefaultScore() float64 {
+	if x != nil {
+		return x.DefaultScore
+	}
+	return 0
+}
+
+func (x *Service) GetDisabled() bool {
+	if x != nil {
+		return x.Disabled
+	}
+	return false
+}
+
+type ListRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Version       *version.Version       `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ListRequest) Reset() {
+	*x = ListRequest{}
+	mi := &file_data_services_services_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ListRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListRequest) ProtoMessage() {}
+
+func (x *ListRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListRequest.ProtoReflect.Descriptor instead.
+func (*ListRequest) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ListRequest) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type ListResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Services      []*Service             `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ListResponse) Reset() {
+	*x = ListResponse{}
+	mi := &file_data_services_services_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ListResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListResponse) ProtoMessage() {}
+
+func (x *ListResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListResponse.ProtoReflect.Descriptor instead.
+func (*ListResponse) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ListResponse) GetServices() []*Service {
+	if x != nil {
+		return x.Services
+	}
+	return nil
+}
+
+func (x *ListResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type CreateBatchRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Services      []*Service             `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CreateBatchRequest) Reset() {
+	*x = CreateBatchRequest{}
+	mi := &file_data_services_services_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CreateBatchRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateBatchRequest) ProtoMessage() {}
+
+func (x *CreateBatchRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[3]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateBatchRequest.ProtoReflect.Descriptor instead.
+func (*CreateBatchRequest) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *CreateBatchRequest) GetServices() []*Service {
+	if x != nil {
+		return x.Services
+	}
+	return nil
+}
+
+type CreateBatchResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Services      []*Service             `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CreateBatchResponse) Reset() {
+	*x = CreateBatchResponse{}
+	mi := &file_data_services_services_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CreateBatchResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateBatchResponse) ProtoMessage() {}
+
+func (x *CreateBatchResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[4]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateBatchResponse.ProtoReflect.Descriptor instead.
+func (*CreateBatchResponse) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *CreateBatchResponse) GetServices() []*Service {
+	if x != nil {
+		return x.Services
+	}
+	return nil
+}
+
+type UpdateRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Id            int64                  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	Disabled      *bool                  `protobuf:"varint,2,opt,name=disabled,proto3,oneof" json:"disabled,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UpdateRequest) Reset() {
+	*x = UpdateRequest{}
+	mi := &file_data_services_services_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateRequest) ProtoMessage() {}
+
+func (x *UpdateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateRequest.ProtoReflect.Descriptor instead.
+func (*UpdateRequest) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *UpdateRequest) GetId() int64 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *UpdateRequest) GetDisabled() bool {
+	if x != nil && x.Disabled != nil {
+		return *x.Disabled
+	}
+	return false
+}
+
+type UpdateResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Service       *Service               `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UpdateResponse) Reset() {
+	*x = UpdateResponse{}
+	mi := &file_data_services_services_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateResponse) ProtoMessage() {}
+
+func (x *UpdateResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[6]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateResponse.ProtoReflect.Descriptor instead.
+func (*UpdateResponse) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *UpdateResponse) GetService() *Service {
+	if x != nil {
+		return x.Service
+	}
+	return nil
+}
+
+func (x *UpdateResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type Service_Batch struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Services      []*Service             `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Service_Batch) Reset() {
+	*x = Service_Batch{}
+	mi := &file_data_services_services_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Service_Batch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Service_Batch) ProtoMessage() {}
+
+func (x *Service_Batch) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[7]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Service_Batch.ProtoReflect.Descriptor instead.
+func (*Service_Batch) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *Service_Batch) GetServices() []*Service {
+	if x != nil {
+		return x.Services
+	}
+	return nil
+}
+
+type Service_Checker struct {
+	state          protoimpl.MessageState    `protogen:"open.v1"`
+	Type           checker.Type              `protobuf:"varint,1,opt,name=type,proto3,enum=checker.Type" json:"type,omitempty"`
+	Path           string                    `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+	DefaultTimeout *durationpb.Duration      `protobuf:"bytes,3,opt,name=default_timeout,json=defaultTimeout,proto3" json:"default_timeout,omitempty"`
+	Actions        []*Service_Checker_Action `protobuf:"bytes,4,rep,name=actions,proto3" json:"actions,omitempty"`
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
+}
+
+func (x *Service_Checker) Reset() {
+	*x = Service_Checker{}
+	mi := &file_data_services_services_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Service_Checker) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Service_Checker) ProtoMessage() {}
+
+func (x *Service_Checker) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[8]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Service_Checker.ProtoReflect.Descriptor instead.
+func (*Service_Checker) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{0, 1}
+}
+
+func (x *Service_Checker) GetType() checker.Type {
+	if x != nil {
+		return x.Type
+	}
+	return checker.Type(0)
+}
+
+func (x *Service_Checker) GetPath() string {
+	if x != nil {
+		return x.Path
+	}
+	return ""
+}
+
+func (x *Service_Checker) GetDefaultTimeout() *durationpb.Duration {
+	if x != nil {
+		return x.DefaultTimeout
+	}
+	return nil
+}
+
+func (x *Service_Checker) GetActions() []*Service_Checker_Action {
+	if x != nil {
+		return x.Actions
+	}
+	return nil
+}
+
+type Service_Checker_Action struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Action        checker.Action         `protobuf:"varint,1,opt,name=action,proto3,enum=checker.Action" json:"action,omitempty"`
+	Timeout       *durationpb.Duration   `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
+	RunCount      int64                  `protobuf:"varint,3,opt,name=run_count,json=runCount,proto3" json:"run_count,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Service_Checker_Action) Reset() {
+	*x = Service_Checker_Action{}
+	mi := &file_data_services_services_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Service_Checker_Action) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Service_Checker_Action) ProtoMessage() {}
+
+func (x *Service_Checker_Action) ProtoReflect() protoreflect.Message {
+	mi := &file_data_services_services_proto_msgTypes[9]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Service_Checker_Action.ProtoReflect.Descriptor instead.
+func (*Service_Checker_Action) Descriptor() ([]byte, []int) {
+	return file_data_services_services_proto_rawDescGZIP(), []int{0, 1, 0}
+}
+
+func (x *Service_Checker_Action) GetAction() checker.Action {
+	if x != nil {
+		return x.Action
+	}
+	return checker.Action(0)
+}
+
+func (x *Service_Checker_Action) GetTimeout() *durationpb.Duration {
+	if x != nil {
+		return x.Timeout
+	}
+	return nil
+}
+
+func (x *Service_Checker_Action) GetRunCount() int64 {
+	if x != nil {
+		return x.RunCount
+	}
+	return 0
+}
+
+var File_data_services_services_proto protoreflect.FileDescriptor
+
+const file_data_services_services_proto_rawDesc = "" +
+	"\n" +
+	"\x1cdata/services/services.proto\x12\rdata.services\x1a\x1egoogle/protobuf/duration.proto\x1a\x15checker/checker.proto\x1a\x1adata/version/version.proto\"\xb3\x04\n" +
+	"\aService\x12\x0e\n" +
+	"\x02id\x18\x01 \x01(\x03R\x02id\x12\x12\n" +
+	"\x04name\x18\x02 \x01(\tR\x04name\x128\n" +
+	"\achecker\x18\x03 \x01(\v2\x1e.data.services.Service.CheckerR\achecker\x12#\n" +
+	"\rdefault_score\x18\x04 \x01(\x01R\fdefaultScore\x12\x1a\n" +
+	"\bdisabled\x18\x05 \x01(\bR\bdisabled\x1a;\n" +
+	"\x05Batch\x122\n" +
+	"\bservices\x18\x01 \x03(\v2\x16.data.services.ServiceR\bservices\x1a\xcb\x02\n" +
+	"\aChecker\x12!\n" +
+	"\x04type\x18\x01 \x01(\x0e2\r.checker.TypeR\x04type\x12\x12\n" +
+	"\x04path\x18\x02 \x01(\tR\x04path\x12B\n" +
+	"\x0fdefault_timeout\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\x0edefaultTimeout\x12?\n" +
+	"\aactions\x18\x04 \x03(\v2%.data.services.Service.Checker.ActionR\aactions\x1a\x83\x01\n" +
+	"\x06Action\x12'\n" +
+	"\x06action\x18\x01 \x01(\x0e2\x0f.checker.ActionR\x06action\x123\n" +
+	"\atimeout\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\atimeout\x12\x1b\n" +
+	"\trun_count\x18\x03 \x01(\x03R\brunCount\">\n" +
+	"\vListRequest\x12/\n" +
+	"\aversion\x18\x01 \x01(\v2\x15.data.version.VersionR\aversion\"s\n" +
+	"\fListResponse\x122\n" +
+	"\bservices\x18\x01 \x03(\v2\x16.data.services.ServiceR\bservices\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversion\"H\n" +
+	"\x12CreateBatchRequest\x122\n" +
+	"\bservices\x18\x01 \x03(\v2\x16.data.services.ServiceR\bservices\"I\n" +
+	"\x13CreateBatchResponse\x122\n" +
+	"\bservices\x18\x01 \x03(\v2\x16.data.services.ServiceR\bservices\"M\n" +
+	"\rUpdateRequest\x12\x0e\n" +
+	"\x02id\x18\x01 \x01(\x03R\x02id\x12\x1f\n" +
+	"\bdisabled\x18\x02 \x01(\bH\x00R\bdisabled\x88\x01\x01B\v\n" +
+	"\t_disabled\"s\n" +
+	"\x0eUpdateResponse\x120\n" +
+	"\aservice\x18\x01 \x01(\v2\x16.data.services.ServiceR\aservice\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversionB\xae\x01\n" +
+	"\x11com.data.servicesB\rServicesProtoP\x01Z5github.com/c4t-but-s4d/fastad/pkg/proto/data/services\xa2\x02\x03DSX\xaa\x02\rData.Services\xca\x02\rData\\Services\xe2\x02\x19Data\\Services\\GPBMetadata\xea\x02\x0eData::Servicesb\x06proto3"
+
+var (
+	file_data_services_services_proto_rawDescOnce sync.Once
+	file_data_services_services_proto_rawDescData []byte
+)
+
+func file_data_services_services_proto_rawDescGZIP() []byte {
+	file_data_services_services_proto_rawDescOnce.Do(func() {
+		file_data_services_services_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_data_services_services_proto_rawDesc), len(file_data_services_services_proto_rawDesc)))
+	})
+	return file_data_services_services_proto_rawDescData
+}
+
+var file_data_services_services_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
+var file_data_services_services_proto_goTypes = []any{
+	(*Service)(nil),                // 0: data.services.Service
+	(*ListRequest)(nil),            // 1: data.services.ListRequest
+	(*ListResponse)(nil),           // 2: data.services.ListResponse
+	(*CreateBatchRequest)(nil),     // 3: data.services.CreateBatchRequest
+	(*CreateBatchResponse)(nil),    // 4: data.services.CreateBatchResponse
+	(*UpdateRequest)(nil),          // 5: data.services.UpdateRequest
+	(*UpdateResponse)(nil),         // 6: data.services.UpdateResponse
+	(*Service_Batch)(nil),          // 7: data.services.Service.Batch
+	(*Service_Checker)(nil),        // 8: data.services.Service.Checker
+	(*Service_Checker_Action)(nil), // 9: data.services.Service.Checker.Action
+	(*version.Version)(nil),        // 10: data.version.Version
+	(checker.Type)(0),              // 11: checker.Type
+	(*durationpb.Duration)(nil),    // 12: google.protobuf.Duration
+	(checker.Action)(0),            // 13: checker.Action
+}
+var file_data_services_services_proto_depIdxs = []int32{
+	8,  // 0: data.services.Service.checker:type_name -> data.services.Service.Checker
+	10, // 1: data.services.ListRequest.version:type_name -> data.version.Version
+	0,  // 2: data.services.ListResponse.services:type_name -> data.services.Service
+	10, // 3: data.services.ListResponse.version:type_name -> data.version.Version
+	0,  // 4: data.services.CreateBatchRequest.services:type_name -> data.services.Service
+	0,  // 5: data.services.CreateBatchResponse.services:type_name -> data.services.Service
+	0,  // 6: data.services.UpdateResponse.service:type_name -> data.services.Service
+	10, // 7: data.services.UpdateResponse.version:type_name -> data.version.Version
+	0,  // 8: data.services.Service.Batch.services:type_name -> data.services.Service
+	11, // 9: data.services.Service.Checker.type:type_name -> checker.Type
+	12, // 10: data.services.Service.Checker.default_timeout:type_name -> google.protobuf.Duration
+	9,  // 11: data.services.Service.Checker.actions:type_name -> data.services.Service.Checker.Action
+	13, // 12: data.services.Service.Checker.Action.action:type_name -> checker.Action
+	12, // 13: data.services.Service.Checker.Action.timeout:type_name -> google.protobuf.Duration
+	14, // [14:14] is the sub-list for method output_type
+	14, // [14:14] is the sub-list for method input_type
+	14, // [14:14] is the sub-list for extension type_name
+	14, // [14:14] is the sub-list for extension extendee
+	0,  // [0:14] is the sub-list for field type_name
+}
+
+func init() { file_data_services_services_proto_init() }
+func file_data_services_services_proto_init() {
+	if File_data_services_services_proto != nil {
+		return
+	}
+	file_data_services_services_proto_msgTypes[5].OneofWrappers = []any{}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_data_services_services_proto_rawDesc), len(file_data_services_services_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   10,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_data_services_services_proto_goTypes,
+		DependencyIndexes: file_data_services_services_proto_depIdxs,
+		MessageInfos:      file_data_services_services_proto_msgTypes,
+	}.Build()
+	File_data_services_services_proto = out.File
+	file_data_services_services_proto_goTypes = nil
+	file_data_services_services_proto_depIdxs = nil
+}
diff --git a/pkg/proto/data/services/services_service.pb.go b/pkg/proto/data/services/services_service.pb.go
new file mode 100644
index 0000000..f2c310c
--- /dev/null
+++ b/pkg/proto/data/services/services_service.pb.go
@@ -0,0 +1,78 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: data/services/services_service.proto
+
+package services
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+var File_data_services_services_service_proto protoreflect.FileDescriptor
+
+const file_data_services_services_service_proto_rawDesc = "" +
+	"\n" +
+	"$data/services/services_service.proto\x12\rdata.services\x1a\x1cdata/services/services.proto2\xef\x01\n" +
+	"\x0fServicesService\x12?\n" +
+	"\x04List\x12\x1a.data.services.ListRequest\x1a\x1b.data.services.ListResponse\x12T\n" +
+	"\vCreateBatch\x12!.data.services.CreateBatchRequest\x1a\".data.services.CreateBatchResponse\x12E\n" +
+	"\x06Update\x12\x1c.data.services.UpdateRequest\x1a\x1d.data.services.UpdateResponseB\xb5\x01\n" +
+	"\x11com.data.servicesB\x14ServicesServiceProtoP\x01Z5github.com/c4t-but-s4d/fastad/pkg/proto/data/services\xa2\x02\x03DSX\xaa\x02\rData.Services\xca\x02\rData\\Services\xe2\x02\x19Data\\Services\\GPBMetadata\xea\x02\x0eData::Servicesb\x06proto3"
+
+var file_data_services_services_service_proto_goTypes = []any{
+	(*ListRequest)(nil),         // 0: data.services.ListRequest
+	(*CreateBatchRequest)(nil),  // 1: data.services.CreateBatchRequest
+	(*UpdateRequest)(nil),       // 2: data.services.UpdateRequest
+	(*ListResponse)(nil),        // 3: data.services.ListResponse
+	(*CreateBatchResponse)(nil), // 4: data.services.CreateBatchResponse
+	(*UpdateResponse)(nil),      // 5: data.services.UpdateResponse
+}
+var file_data_services_services_service_proto_depIdxs = []int32{
+	0, // 0: data.services.ServicesService.List:input_type -> data.services.ListRequest
+	1, // 1: data.services.ServicesService.CreateBatch:input_type -> data.services.CreateBatchRequest
+	2, // 2: data.services.ServicesService.Update:input_type -> data.services.UpdateRequest
+	3, // 3: data.services.ServicesService.List:output_type -> data.services.ListResponse
+	4, // 4: data.services.ServicesService.CreateBatch:output_type -> data.services.CreateBatchResponse
+	5, // 5: data.services.ServicesService.Update:output_type -> data.services.UpdateResponse
+	3, // [3:6] is the sub-list for method output_type
+	0, // [0:3] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_data_services_services_service_proto_init() }
+func file_data_services_services_service_proto_init() {
+	if File_data_services_services_service_proto != nil {
+		return
+	}
+	file_data_services_services_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_data_services_services_service_proto_rawDesc), len(file_data_services_services_service_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_data_services_services_service_proto_goTypes,
+		DependencyIndexes: file_data_services_services_service_proto_depIdxs,
+	}.Build()
+	File_data_services_services_service_proto = out.File
+	file_data_services_services_service_proto_goTypes = nil
+	file_data_services_services_service_proto_depIdxs = nil
+}
diff --git a/pkg/proto/data/services/services_service_grpc.pb.go b/pkg/proto/data/services/services_service_grpc.pb.go
new file mode 100644
index 0000000..78bc890
--- /dev/null
+++ b/pkg/proto/data/services/services_service_grpc.pb.go
@@ -0,0 +1,197 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.6.0
+// - protoc             (unknown)
+// source: data/services/services_service.proto
+
+package services
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	ServicesService_List_FullMethodName        = "/data.services.ServicesService/List"
+	ServicesService_CreateBatch_FullMethodName = "/data.services.ServicesService/CreateBatch"
+	ServicesService_Update_FullMethodName      = "/data.services.ServicesService/Update"
+)
+
+// ServicesServiceClient is the client API for ServicesService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type ServicesServiceClient interface {
+	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
+	CreateBatch(ctx context.Context, in *CreateBatchRequest, opts ...grpc.CallOption) (*CreateBatchResponse, error)
+	Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
+}
+
+type servicesServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewServicesServiceClient(cc grpc.ClientConnInterface) ServicesServiceClient {
+	return &servicesServiceClient{cc}
+}
+
+func (c *servicesServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ListResponse)
+	err := c.cc.Invoke(ctx, ServicesService_List_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *servicesServiceClient) CreateBatch(ctx context.Context, in *CreateBatchRequest, opts ...grpc.CallOption) (*CreateBatchResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(CreateBatchResponse)
+	err := c.cc.Invoke(ctx, ServicesService_CreateBatch_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *servicesServiceClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(UpdateResponse)
+	err := c.cc.Invoke(ctx, ServicesService_Update_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// ServicesServiceServer is the server API for ServicesService service.
+// All implementations must embed UnimplementedServicesServiceServer
+// for forward compatibility.
+type ServicesServiceServer interface {
+	List(context.Context, *ListRequest) (*ListResponse, error)
+	CreateBatch(context.Context, *CreateBatchRequest) (*CreateBatchResponse, error)
+	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
+	mustEmbedUnimplementedServicesServiceServer()
+}
+
+// UnimplementedServicesServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedServicesServiceServer struct{}
+
+func (UnimplementedServicesServiceServer) List(context.Context, *ListRequest) (*ListResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method List not implemented")
+}
+func (UnimplementedServicesServiceServer) CreateBatch(context.Context, *CreateBatchRequest) (*CreateBatchResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method CreateBatch not implemented")
+}
+func (UnimplementedServicesServiceServer) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Update not implemented")
+}
+func (UnimplementedServicesServiceServer) mustEmbedUnimplementedServicesServiceServer() {}
+func (UnimplementedServicesServiceServer) testEmbeddedByValue()                         {}
+
+// UnsafeServicesServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to ServicesServiceServer will
+// result in compilation errors.
+type UnsafeServicesServiceServer interface {
+	mustEmbedUnimplementedServicesServiceServer()
+}
+
+func RegisterServicesServiceServer(s grpc.ServiceRegistrar, srv ServicesServiceServer) {
+	// If the following call panics, it indicates UnimplementedServicesServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&ServicesService_ServiceDesc, srv)
+}
+
+func _ServicesService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ServicesServiceServer).List(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: ServicesService_List_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ServicesServiceServer).List(ctx, req.(*ListRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _ServicesService_CreateBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateBatchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ServicesServiceServer).CreateBatch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: ServicesService_CreateBatch_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ServicesServiceServer).CreateBatch(ctx, req.(*CreateBatchRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _ServicesService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ServicesServiceServer).Update(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: ServicesService_Update_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ServicesServiceServer).Update(ctx, req.(*UpdateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// ServicesService_ServiceDesc is the grpc.ServiceDesc for ServicesService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var ServicesService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "data.services.ServicesService",
+	HandlerType: (*ServicesServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "List",
+			Handler:    _ServicesService_List_Handler,
+		},
+		{
+			MethodName: "CreateBatch",
+			Handler:    _ServicesService_CreateBatch_Handler,
+		},
+		{
+			MethodName: "Update",
+			Handler:    _ServicesService_Update_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "data/services/services_service.proto",
+}
diff --git a/pkg/proto/data/services/services_vtproto.pb.go b/pkg/proto/data/services/services_vtproto.pb.go
new file mode 100644
index 0000000..8c6c319
--- /dev/null
+++ b/pkg/proto/data/services/services_vtproto.pb.go
@@ -0,0 +1,531 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: data/services/services.proto
+
+package services
+
+import (
+	durationpb1 "github.com/planetscale/vtprotobuf/types/known/durationpb"
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *Service_Batch) CloneVT() *Service_Batch {
+	if m == nil {
+		return (*Service_Batch)(nil)
+	}
+	r := new(Service_Batch)
+	if rhs := m.Services; rhs != nil {
+		tmpContainer := make([]*Service, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Services = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Service_Batch) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Service_Checker_Action) CloneVT() *Service_Checker_Action {
+	if m == nil {
+		return (*Service_Checker_Action)(nil)
+	}
+	r := new(Service_Checker_Action)
+	r.Action = m.Action
+	r.Timeout = (*durationpb.Duration)((*durationpb1.Duration)(m.Timeout).CloneVT())
+	r.RunCount = m.RunCount
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Service_Checker_Action) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Service_Checker) CloneVT() *Service_Checker {
+	if m == nil {
+		return (*Service_Checker)(nil)
+	}
+	r := new(Service_Checker)
+	r.Type = m.Type
+	r.Path = m.Path
+	r.DefaultTimeout = (*durationpb.Duration)((*durationpb1.Duration)(m.DefaultTimeout).CloneVT())
+	if rhs := m.Actions; rhs != nil {
+		tmpContainer := make([]*Service_Checker_Action, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Actions = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Service_Checker) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Service) CloneVT() *Service {
+	if m == nil {
+		return (*Service)(nil)
+	}
+	r := new(Service)
+	r.Id = m.Id
+	r.Name = m.Name
+	r.Checker = m.Checker.CloneVT()
+	r.DefaultScore = m.DefaultScore
+	r.Disabled = m.Disabled
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Service) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *ListRequest) CloneVT() *ListRequest {
+	if m == nil {
+		return (*ListRequest)(nil)
+	}
+	r := new(ListRequest)
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *ListRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *ListResponse) CloneVT() *ListResponse {
+	if m == nil {
+		return (*ListResponse)(nil)
+	}
+	r := new(ListResponse)
+	r.Version = m.Version.CloneVT()
+	if rhs := m.Services; rhs != nil {
+		tmpContainer := make([]*Service, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Services = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *ListResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *CreateBatchRequest) CloneVT() *CreateBatchRequest {
+	if m == nil {
+		return (*CreateBatchRequest)(nil)
+	}
+	r := new(CreateBatchRequest)
+	if rhs := m.Services; rhs != nil {
+		tmpContainer := make([]*Service, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Services = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CreateBatchRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *CreateBatchResponse) CloneVT() *CreateBatchResponse {
+	if m == nil {
+		return (*CreateBatchResponse)(nil)
+	}
+	r := new(CreateBatchResponse)
+	if rhs := m.Services; rhs != nil {
+		tmpContainer := make([]*Service, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Services = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CreateBatchResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateRequest) CloneVT() *UpdateRequest {
+	if m == nil {
+		return (*UpdateRequest)(nil)
+	}
+	r := new(UpdateRequest)
+	r.Id = m.Id
+	if rhs := m.Disabled; rhs != nil {
+		tmpVal := *rhs
+		r.Disabled = &tmpVal
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateResponse) CloneVT() *UpdateResponse {
+	if m == nil {
+		return (*UpdateResponse)(nil)
+	}
+	r := new(UpdateResponse)
+	r.Service = m.Service.CloneVT()
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *Service_Batch) EqualVT(that *Service_Batch) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Services) != len(that.Services) {
+		return false
+	}
+	for i, vx := range this.Services {
+		vy := that.Services[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Service{}
+			}
+			if q == nil {
+				q = &Service{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Service_Batch) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Service_Batch)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *Service_Checker_Action) EqualVT(that *Service_Checker_Action) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Action != that.Action {
+		return false
+	}
+	if !(*durationpb1.Duration)(this.Timeout).EqualVT((*durationpb1.Duration)(that.Timeout)) {
+		return false
+	}
+	if this.RunCount != that.RunCount {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Service_Checker_Action) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Service_Checker_Action)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *Service_Checker) EqualVT(that *Service_Checker) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Type != that.Type {
+		return false
+	}
+	if this.Path != that.Path {
+		return false
+	}
+	if !(*durationpb1.Duration)(this.DefaultTimeout).EqualVT((*durationpb1.Duration)(that.DefaultTimeout)) {
+		return false
+	}
+	if len(this.Actions) != len(that.Actions) {
+		return false
+	}
+	for i, vx := range this.Actions {
+		vy := that.Actions[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Service_Checker_Action{}
+			}
+			if q == nil {
+				q = &Service_Checker_Action{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Service_Checker) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Service_Checker)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *Service) EqualVT(that *Service) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Id != that.Id {
+		return false
+	}
+	if this.Name != that.Name {
+		return false
+	}
+	if !this.Checker.EqualVT(that.Checker) {
+		return false
+	}
+	if this.DefaultScore != that.DefaultScore {
+		return false
+	}
+	if this.Disabled != that.Disabled {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Service) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Service)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *ListRequest) EqualVT(that *ListRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *ListRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*ListRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *ListResponse) EqualVT(that *ListResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Services) != len(that.Services) {
+		return false
+	}
+	for i, vx := range this.Services {
+		vy := that.Services[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Service{}
+			}
+			if q == nil {
+				q = &Service{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *ListResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*ListResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *CreateBatchRequest) EqualVT(that *CreateBatchRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Services) != len(that.Services) {
+		return false
+	}
+	for i, vx := range this.Services {
+		vy := that.Services[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Service{}
+			}
+			if q == nil {
+				q = &Service{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *CreateBatchRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CreateBatchRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *CreateBatchResponse) EqualVT(that *CreateBatchResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Services) != len(that.Services) {
+		return false
+	}
+	for i, vx := range this.Services {
+		vy := that.Services[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Service{}
+			}
+			if q == nil {
+				q = &Service{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *CreateBatchResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CreateBatchResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateRequest) EqualVT(that *UpdateRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Id != that.Id {
+		return false
+	}
+	if p, q := this.Disabled, that.Disabled; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateResponse) EqualVT(that *UpdateResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.Service.EqualVT(that.Service) {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/data/teams/teams.pb.go b/pkg/proto/data/teams/teams.pb.go
new file mode 100644
index 0000000..376dd52
--- /dev/null
+++ b/pkg/proto/data/teams/teams.pb.go
@@ -0,0 +1,572 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: data/teams/teams.proto
+
+package teams
+
+import (
+	version "github.com/c4t-but-s4d/fastad/pkg/proto/data/version"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type Team struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Id            int64                  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	Name          string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Address       string                 `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
+	Token         string                 `protobuf:"bytes,4,opt,name=token,proto3" json:"token,omitempty"`
+	Labels        map[string]string      `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	AvatarUrl     string                 `protobuf:"bytes,6,opt,name=avatar_url,json=avatarUrl,proto3" json:"avatar_url,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Team) Reset() {
+	*x = Team{}
+	mi := &file_data_teams_teams_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Team) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Team) ProtoMessage() {}
+
+func (x *Team) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Team.ProtoReflect.Descriptor instead.
+func (*Team) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Team) GetId() int64 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *Team) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *Team) GetAddress() string {
+	if x != nil {
+		return x.Address
+	}
+	return ""
+}
+
+func (x *Team) GetToken() string {
+	if x != nil {
+		return x.Token
+	}
+	return ""
+}
+
+func (x *Team) GetLabels() map[string]string {
+	if x != nil {
+		return x.Labels
+	}
+	return nil
+}
+
+func (x *Team) GetAvatarUrl() string {
+	if x != nil {
+		return x.AvatarUrl
+	}
+	return ""
+}
+
+type ListRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Version       *version.Version       `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ListRequest) Reset() {
+	*x = ListRequest{}
+	mi := &file_data_teams_teams_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ListRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListRequest) ProtoMessage() {}
+
+func (x *ListRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListRequest.ProtoReflect.Descriptor instead.
+func (*ListRequest) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ListRequest) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type ListResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Teams         []*Team                `protobuf:"bytes,1,rep,name=teams,proto3" json:"teams,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ListResponse) Reset() {
+	*x = ListResponse{}
+	mi := &file_data_teams_teams_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ListResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListResponse) ProtoMessage() {}
+
+func (x *ListResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListResponse.ProtoReflect.Descriptor instead.
+func (*ListResponse) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ListResponse) GetTeams() []*Team {
+	if x != nil {
+		return x.Teams
+	}
+	return nil
+}
+
+func (x *ListResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type CreateBatchRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Teams         []*Team                `protobuf:"bytes,1,rep,name=teams,proto3" json:"teams,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CreateBatchRequest) Reset() {
+	*x = CreateBatchRequest{}
+	mi := &file_data_teams_teams_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CreateBatchRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateBatchRequest) ProtoMessage() {}
+
+func (x *CreateBatchRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[3]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateBatchRequest.ProtoReflect.Descriptor instead.
+func (*CreateBatchRequest) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *CreateBatchRequest) GetTeams() []*Team {
+	if x != nil {
+		return x.Teams
+	}
+	return nil
+}
+
+type CreateBatchResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Teams         []*Team                `protobuf:"bytes,1,rep,name=teams,proto3" json:"teams,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CreateBatchResponse) Reset() {
+	*x = CreateBatchResponse{}
+	mi := &file_data_teams_teams_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CreateBatchResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateBatchResponse) ProtoMessage() {}
+
+func (x *CreateBatchResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[4]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateBatchResponse.ProtoReflect.Descriptor instead.
+func (*CreateBatchResponse) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *CreateBatchResponse) GetTeams() []*Team {
+	if x != nil {
+		return x.Teams
+	}
+	return nil
+}
+
+type UpdateRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Id            int64                  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	Name          string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Address       string                 `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
+	Token         string                 `protobuf:"bytes,4,opt,name=token,proto3" json:"token,omitempty"`
+	AvatarUrl     string                 `protobuf:"bytes,5,opt,name=avatar_url,json=avatarUrl,proto3" json:"avatar_url,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UpdateRequest) Reset() {
+	*x = UpdateRequest{}
+	mi := &file_data_teams_teams_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateRequest) ProtoMessage() {}
+
+func (x *UpdateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateRequest.ProtoReflect.Descriptor instead.
+func (*UpdateRequest) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *UpdateRequest) GetId() int64 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *UpdateRequest) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *UpdateRequest) GetAddress() string {
+	if x != nil {
+		return x.Address
+	}
+	return ""
+}
+
+func (x *UpdateRequest) GetToken() string {
+	if x != nil {
+		return x.Token
+	}
+	return ""
+}
+
+func (x *UpdateRequest) GetAvatarUrl() string {
+	if x != nil {
+		return x.AvatarUrl
+	}
+	return ""
+}
+
+type UpdateResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Team          *Team                  `protobuf:"bytes,1,opt,name=team,proto3" json:"team,omitempty"`
+	Version       *version.Version       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UpdateResponse) Reset() {
+	*x = UpdateResponse{}
+	mi := &file_data_teams_teams_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UpdateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateResponse) ProtoMessage() {}
+
+func (x *UpdateResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[6]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateResponse.ProtoReflect.Descriptor instead.
+func (*UpdateResponse) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *UpdateResponse) GetTeam() *Team {
+	if x != nil {
+		return x.Team
+	}
+	return nil
+}
+
+func (x *UpdateResponse) GetVersion() *version.Version {
+	if x != nil {
+		return x.Version
+	}
+	return nil
+}
+
+type Team_Batch struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Teams         []*Team                `protobuf:"bytes,1,rep,name=teams,proto3" json:"teams,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Team_Batch) Reset() {
+	*x = Team_Batch{}
+	mi := &file_data_teams_teams_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Team_Batch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Team_Batch) ProtoMessage() {}
+
+func (x *Team_Batch) ProtoReflect() protoreflect.Message {
+	mi := &file_data_teams_teams_proto_msgTypes[7]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Team_Batch.ProtoReflect.Descriptor instead.
+func (*Team_Batch) Descriptor() ([]byte, []int) {
+	return file_data_teams_teams_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *Team_Batch) GetTeams() []*Team {
+	if x != nil {
+		return x.Teams
+	}
+	return nil
+}
+
+var File_data_teams_teams_proto protoreflect.FileDescriptor
+
+const file_data_teams_teams_proto_rawDesc = "" +
+	"\n" +
+	"\x16data/teams/teams.proto\x12\n" +
+	"data.teams\x1a\x1adata/version/version.proto\"\x9b\x02\n" +
+	"\x04Team\x12\x0e\n" +
+	"\x02id\x18\x01 \x01(\x03R\x02id\x12\x12\n" +
+	"\x04name\x18\x02 \x01(\tR\x04name\x12\x18\n" +
+	"\aaddress\x18\x03 \x01(\tR\aaddress\x12\x14\n" +
+	"\x05token\x18\x04 \x01(\tR\x05token\x124\n" +
+	"\x06labels\x18\x05 \x03(\v2\x1c.data.teams.Team.LabelsEntryR\x06labels\x12\x1d\n" +
+	"\n" +
+	"avatar_url\x18\x06 \x01(\tR\tavatarUrl\x1a/\n" +
+	"\x05Batch\x12&\n" +
+	"\x05teams\x18\x01 \x03(\v2\x10.data.teams.TeamR\x05teams\x1a9\n" +
+	"\vLabelsEntry\x12\x10\n" +
+	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
+	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\">\n" +
+	"\vListRequest\x12/\n" +
+	"\aversion\x18\x01 \x01(\v2\x15.data.version.VersionR\aversion\"g\n" +
+	"\fListResponse\x12&\n" +
+	"\x05teams\x18\x01 \x03(\v2\x10.data.teams.TeamR\x05teams\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversion\"<\n" +
+	"\x12CreateBatchRequest\x12&\n" +
+	"\x05teams\x18\x01 \x03(\v2\x10.data.teams.TeamR\x05teams\"=\n" +
+	"\x13CreateBatchResponse\x12&\n" +
+	"\x05teams\x18\x01 \x03(\v2\x10.data.teams.TeamR\x05teams\"\x82\x01\n" +
+	"\rUpdateRequest\x12\x0e\n" +
+	"\x02id\x18\x01 \x01(\x03R\x02id\x12\x12\n" +
+	"\x04name\x18\x02 \x01(\tR\x04name\x12\x18\n" +
+	"\aaddress\x18\x03 \x01(\tR\aaddress\x12\x14\n" +
+	"\x05token\x18\x04 \x01(\tR\x05token\x12\x1d\n" +
+	"\n" +
+	"avatar_url\x18\x05 \x01(\tR\tavatarUrl\"g\n" +
+	"\x0eUpdateResponse\x12$\n" +
+	"\x04team\x18\x01 \x01(\v2\x10.data.teams.TeamR\x04team\x12/\n" +
+	"\aversion\x18\x02 \x01(\v2\x15.data.version.VersionR\aversionB\x99\x01\n" +
+	"\x0ecom.data.teamsB\n" +
+	"TeamsProtoP\x01Z2github.com/c4t-but-s4d/fastad/pkg/proto/data/teams\xa2\x02\x03DTX\xaa\x02\n" +
+	"Data.Teams\xca\x02\n" +
+	"Data\\Teams\xe2\x02\x16Data\\Teams\\GPBMetadata\xea\x02\vData::Teamsb\x06proto3"
+
+var (
+	file_data_teams_teams_proto_rawDescOnce sync.Once
+	file_data_teams_teams_proto_rawDescData []byte
+)
+
+func file_data_teams_teams_proto_rawDescGZIP() []byte {
+	file_data_teams_teams_proto_rawDescOnce.Do(func() {
+		file_data_teams_teams_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_data_teams_teams_proto_rawDesc), len(file_data_teams_teams_proto_rawDesc)))
+	})
+	return file_data_teams_teams_proto_rawDescData
+}
+
+var file_data_teams_teams_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
+var file_data_teams_teams_proto_goTypes = []any{
+	(*Team)(nil),                // 0: data.teams.Team
+	(*ListRequest)(nil),         // 1: data.teams.ListRequest
+	(*ListResponse)(nil),        // 2: data.teams.ListResponse
+	(*CreateBatchRequest)(nil),  // 3: data.teams.CreateBatchRequest
+	(*CreateBatchResponse)(nil), // 4: data.teams.CreateBatchResponse
+	(*UpdateRequest)(nil),       // 5: data.teams.UpdateRequest
+	(*UpdateResponse)(nil),      // 6: data.teams.UpdateResponse
+	(*Team_Batch)(nil),          // 7: data.teams.Team.Batch
+	nil,                         // 8: data.teams.Team.LabelsEntry
+	(*version.Version)(nil),     // 9: data.version.Version
+}
+var file_data_teams_teams_proto_depIdxs = []int32{
+	8, // 0: data.teams.Team.labels:type_name -> data.teams.Team.LabelsEntry
+	9, // 1: data.teams.ListRequest.version:type_name -> data.version.Version
+	0, // 2: data.teams.ListResponse.teams:type_name -> data.teams.Team
+	9, // 3: data.teams.ListResponse.version:type_name -> data.version.Version
+	0, // 4: data.teams.CreateBatchRequest.teams:type_name -> data.teams.Team
+	0, // 5: data.teams.CreateBatchResponse.teams:type_name -> data.teams.Team
+	0, // 6: data.teams.UpdateResponse.team:type_name -> data.teams.Team
+	9, // 7: data.teams.UpdateResponse.version:type_name -> data.version.Version
+	0, // 8: data.teams.Team.Batch.teams:type_name -> data.teams.Team
+	9, // [9:9] is the sub-list for method output_type
+	9, // [9:9] is the sub-list for method input_type
+	9, // [9:9] is the sub-list for extension type_name
+	9, // [9:9] is the sub-list for extension extendee
+	0, // [0:9] is the sub-list for field type_name
+}
+
+func init() { file_data_teams_teams_proto_init() }
+func file_data_teams_teams_proto_init() {
+	if File_data_teams_teams_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_data_teams_teams_proto_rawDesc), len(file_data_teams_teams_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   9,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_data_teams_teams_proto_goTypes,
+		DependencyIndexes: file_data_teams_teams_proto_depIdxs,
+		MessageInfos:      file_data_teams_teams_proto_msgTypes,
+	}.Build()
+	File_data_teams_teams_proto = out.File
+	file_data_teams_teams_proto_goTypes = nil
+	file_data_teams_teams_proto_depIdxs = nil
+}
diff --git a/pkg/proto/data/teams/teams_service.pb.go b/pkg/proto/data/teams/teams_service.pb.go
new file mode 100644
index 0000000..e321a34
--- /dev/null
+++ b/pkg/proto/data/teams/teams_service.pb.go
@@ -0,0 +1,81 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: data/teams/teams_service.proto
+
+package teams
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+var File_data_teams_teams_service_proto protoreflect.FileDescriptor
+
+const file_data_teams_teams_service_proto_rawDesc = "" +
+	"\n" +
+	"\x1edata/teams/teams_service.proto\x12\n" +
+	"data.teams\x1a\x16data/teams/teams.proto2\xda\x01\n" +
+	"\fTeamsService\x129\n" +
+	"\x04List\x12\x17.data.teams.ListRequest\x1a\x18.data.teams.ListResponse\x12N\n" +
+	"\vCreateBatch\x12\x1e.data.teams.CreateBatchRequest\x1a\x1f.data.teams.CreateBatchResponse\x12?\n" +
+	"\x06Update\x12\x19.data.teams.UpdateRequest\x1a\x1a.data.teams.UpdateResponseB\xa0\x01\n" +
+	"\x0ecom.data.teamsB\x11TeamsServiceProtoP\x01Z2github.com/c4t-but-s4d/fastad/pkg/proto/data/teams\xa2\x02\x03DTX\xaa\x02\n" +
+	"Data.Teams\xca\x02\n" +
+	"Data\\Teams\xe2\x02\x16Data\\Teams\\GPBMetadata\xea\x02\vData::Teamsb\x06proto3"
+
+var file_data_teams_teams_service_proto_goTypes = []any{
+	(*ListRequest)(nil),         // 0: data.teams.ListRequest
+	(*CreateBatchRequest)(nil),  // 1: data.teams.CreateBatchRequest
+	(*UpdateRequest)(nil),       // 2: data.teams.UpdateRequest
+	(*ListResponse)(nil),        // 3: data.teams.ListResponse
+	(*CreateBatchResponse)(nil), // 4: data.teams.CreateBatchResponse
+	(*UpdateResponse)(nil),      // 5: data.teams.UpdateResponse
+}
+var file_data_teams_teams_service_proto_depIdxs = []int32{
+	0, // 0: data.teams.TeamsService.List:input_type -> data.teams.ListRequest
+	1, // 1: data.teams.TeamsService.CreateBatch:input_type -> data.teams.CreateBatchRequest
+	2, // 2: data.teams.TeamsService.Update:input_type -> data.teams.UpdateRequest
+	3, // 3: data.teams.TeamsService.List:output_type -> data.teams.ListResponse
+	4, // 4: data.teams.TeamsService.CreateBatch:output_type -> data.teams.CreateBatchResponse
+	5, // 5: data.teams.TeamsService.Update:output_type -> data.teams.UpdateResponse
+	3, // [3:6] is the sub-list for method output_type
+	0, // [0:3] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_data_teams_teams_service_proto_init() }
+func file_data_teams_teams_service_proto_init() {
+	if File_data_teams_teams_service_proto != nil {
+		return
+	}
+	file_data_teams_teams_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_data_teams_teams_service_proto_rawDesc), len(file_data_teams_teams_service_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_data_teams_teams_service_proto_goTypes,
+		DependencyIndexes: file_data_teams_teams_service_proto_depIdxs,
+	}.Build()
+	File_data_teams_teams_service_proto = out.File
+	file_data_teams_teams_service_proto_goTypes = nil
+	file_data_teams_teams_service_proto_depIdxs = nil
+}
diff --git a/pkg/proto/data/teams/teams_service_grpc.pb.go b/pkg/proto/data/teams/teams_service_grpc.pb.go
new file mode 100644
index 0000000..6597ae1
--- /dev/null
+++ b/pkg/proto/data/teams/teams_service_grpc.pb.go
@@ -0,0 +1,197 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.6.0
+// - protoc             (unknown)
+// source: data/teams/teams_service.proto
+
+package teams
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	TeamsService_List_FullMethodName        = "/data.teams.TeamsService/List"
+	TeamsService_CreateBatch_FullMethodName = "/data.teams.TeamsService/CreateBatch"
+	TeamsService_Update_FullMethodName      = "/data.teams.TeamsService/Update"
+)
+
+// TeamsServiceClient is the client API for TeamsService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type TeamsServiceClient interface {
+	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
+	CreateBatch(ctx context.Context, in *CreateBatchRequest, opts ...grpc.CallOption) (*CreateBatchResponse, error)
+	Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
+}
+
+type teamsServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewTeamsServiceClient(cc grpc.ClientConnInterface) TeamsServiceClient {
+	return &teamsServiceClient{cc}
+}
+
+func (c *teamsServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ListResponse)
+	err := c.cc.Invoke(ctx, TeamsService_List_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *teamsServiceClient) CreateBatch(ctx context.Context, in *CreateBatchRequest, opts ...grpc.CallOption) (*CreateBatchResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(CreateBatchResponse)
+	err := c.cc.Invoke(ctx, TeamsService_CreateBatch_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *teamsServiceClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(UpdateResponse)
+	err := c.cc.Invoke(ctx, TeamsService_Update_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// TeamsServiceServer is the server API for TeamsService service.
+// All implementations must embed UnimplementedTeamsServiceServer
+// for forward compatibility.
+type TeamsServiceServer interface {
+	List(context.Context, *ListRequest) (*ListResponse, error)
+	CreateBatch(context.Context, *CreateBatchRequest) (*CreateBatchResponse, error)
+	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
+	mustEmbedUnimplementedTeamsServiceServer()
+}
+
+// UnimplementedTeamsServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedTeamsServiceServer struct{}
+
+func (UnimplementedTeamsServiceServer) List(context.Context, *ListRequest) (*ListResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method List not implemented")
+}
+func (UnimplementedTeamsServiceServer) CreateBatch(context.Context, *CreateBatchRequest) (*CreateBatchResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method CreateBatch not implemented")
+}
+func (UnimplementedTeamsServiceServer) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Update not implemented")
+}
+func (UnimplementedTeamsServiceServer) mustEmbedUnimplementedTeamsServiceServer() {}
+func (UnimplementedTeamsServiceServer) testEmbeddedByValue()                      {}
+
+// UnsafeTeamsServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to TeamsServiceServer will
+// result in compilation errors.
+type UnsafeTeamsServiceServer interface {
+	mustEmbedUnimplementedTeamsServiceServer()
+}
+
+func RegisterTeamsServiceServer(s grpc.ServiceRegistrar, srv TeamsServiceServer) {
+	// If the following call panics, it indicates UnimplementedTeamsServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&TeamsService_ServiceDesc, srv)
+}
+
+func _TeamsService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TeamsServiceServer).List(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: TeamsService_List_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TeamsServiceServer).List(ctx, req.(*ListRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TeamsService_CreateBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateBatchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TeamsServiceServer).CreateBatch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: TeamsService_CreateBatch_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TeamsServiceServer).CreateBatch(ctx, req.(*CreateBatchRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TeamsService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TeamsServiceServer).Update(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: TeamsService_Update_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TeamsServiceServer).Update(ctx, req.(*UpdateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// TeamsService_ServiceDesc is the grpc.ServiceDesc for TeamsService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var TeamsService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "data.teams.TeamsService",
+	HandlerType: (*TeamsServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "List",
+			Handler:    _TeamsService_List_Handler,
+		},
+		{
+			MethodName: "CreateBatch",
+			Handler:    _TeamsService_CreateBatch_Handler,
+		},
+		{
+			MethodName: "Update",
+			Handler:    _TeamsService_Update_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "data/teams/teams_service.proto",
+}
diff --git a/pkg/proto/data/teams/teams_vtproto.pb.go b/pkg/proto/data/teams/teams_vtproto.pb.go
new file mode 100644
index 0000000..e90d979
--- /dev/null
+++ b/pkg/proto/data/teams/teams_vtproto.pb.go
@@ -0,0 +1,445 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: data/teams/teams.proto
+
+package teams
+
+import (
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *Team_Batch) CloneVT() *Team_Batch {
+	if m == nil {
+		return (*Team_Batch)(nil)
+	}
+	r := new(Team_Batch)
+	if rhs := m.Teams; rhs != nil {
+		tmpContainer := make([]*Team, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Teams = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Team_Batch) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Team) CloneVT() *Team {
+	if m == nil {
+		return (*Team)(nil)
+	}
+	r := new(Team)
+	r.Id = m.Id
+	r.Name = m.Name
+	r.Address = m.Address
+	r.Token = m.Token
+	r.AvatarUrl = m.AvatarUrl
+	if rhs := m.Labels; rhs != nil {
+		tmpContainer := make(map[string]string, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v
+		}
+		r.Labels = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Team) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *ListRequest) CloneVT() *ListRequest {
+	if m == nil {
+		return (*ListRequest)(nil)
+	}
+	r := new(ListRequest)
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *ListRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *ListResponse) CloneVT() *ListResponse {
+	if m == nil {
+		return (*ListResponse)(nil)
+	}
+	r := new(ListResponse)
+	r.Version = m.Version.CloneVT()
+	if rhs := m.Teams; rhs != nil {
+		tmpContainer := make([]*Team, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Teams = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *ListResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *CreateBatchRequest) CloneVT() *CreateBatchRequest {
+	if m == nil {
+		return (*CreateBatchRequest)(nil)
+	}
+	r := new(CreateBatchRequest)
+	if rhs := m.Teams; rhs != nil {
+		tmpContainer := make([]*Team, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Teams = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CreateBatchRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *CreateBatchResponse) CloneVT() *CreateBatchResponse {
+	if m == nil {
+		return (*CreateBatchResponse)(nil)
+	}
+	r := new(CreateBatchResponse)
+	if rhs := m.Teams; rhs != nil {
+		tmpContainer := make([]*Team, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Teams = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CreateBatchResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateRequest) CloneVT() *UpdateRequest {
+	if m == nil {
+		return (*UpdateRequest)(nil)
+	}
+	r := new(UpdateRequest)
+	r.Id = m.Id
+	r.Name = m.Name
+	r.Address = m.Address
+	r.Token = m.Token
+	r.AvatarUrl = m.AvatarUrl
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *UpdateResponse) CloneVT() *UpdateResponse {
+	if m == nil {
+		return (*UpdateResponse)(nil)
+	}
+	r := new(UpdateResponse)
+	r.Team = m.Team.CloneVT()
+	r.Version = m.Version.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *UpdateResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *Team_Batch) EqualVT(that *Team_Batch) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Teams) != len(that.Teams) {
+		return false
+	}
+	for i, vx := range this.Teams {
+		vy := that.Teams[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Team{}
+			}
+			if q == nil {
+				q = &Team{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Team_Batch) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Team_Batch)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *Team) EqualVT(that *Team) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Id != that.Id {
+		return false
+	}
+	if this.Name != that.Name {
+		return false
+	}
+	if this.Address != that.Address {
+		return false
+	}
+	if this.Token != that.Token {
+		return false
+	}
+	if len(this.Labels) != len(that.Labels) {
+		return false
+	}
+	for i, vx := range this.Labels {
+		vy, ok := that.Labels[i]
+		if !ok {
+			return false
+		}
+		if vx != vy {
+			return false
+		}
+	}
+	if this.AvatarUrl != that.AvatarUrl {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Team) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Team)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *ListRequest) EqualVT(that *ListRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *ListRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*ListRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *ListResponse) EqualVT(that *ListResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Teams) != len(that.Teams) {
+		return false
+	}
+	for i, vx := range this.Teams {
+		vy := that.Teams[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Team{}
+			}
+			if q == nil {
+				q = &Team{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *ListResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*ListResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *CreateBatchRequest) EqualVT(that *CreateBatchRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Teams) != len(that.Teams) {
+		return false
+	}
+	for i, vx := range this.Teams {
+		vy := that.Teams[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Team{}
+			}
+			if q == nil {
+				q = &Team{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *CreateBatchRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CreateBatchRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *CreateBatchResponse) EqualVT(that *CreateBatchResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Teams) != len(that.Teams) {
+		return false
+	}
+	for i, vx := range this.Teams {
+		vy := that.Teams[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Team{}
+			}
+			if q == nil {
+				q = &Team{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *CreateBatchResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CreateBatchResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateRequest) EqualVT(that *UpdateRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Id != that.Id {
+		return false
+	}
+	if this.Name != that.Name {
+		return false
+	}
+	if this.Address != that.Address {
+		return false
+	}
+	if this.Token != that.Token {
+		return false
+	}
+	if this.AvatarUrl != that.AvatarUrl {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *UpdateResponse) EqualVT(that *UpdateResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.Team.EqualVT(that.Team) {
+		return false
+	}
+	if !this.Version.EqualVT(that.Version) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *UpdateResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*UpdateResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/data/version/version.pb.go b/pkg/proto/data/version/version.pb.go
new file mode 100644
index 0000000..e892827
--- /dev/null
+++ b/pkg/proto/data/version/version.pb.go
@@ -0,0 +1,123 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: data/version/version.proto
+
+package version
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type Version struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Version       int64                  `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Version) Reset() {
+	*x = Version{}
+	mi := &file_data_version_version_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Version) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Version) ProtoMessage() {}
+
+func (x *Version) ProtoReflect() protoreflect.Message {
+	mi := &file_data_version_version_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Version.ProtoReflect.Descriptor instead.
+func (*Version) Descriptor() ([]byte, []int) {
+	return file_data_version_version_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Version) GetVersion() int64 {
+	if x != nil {
+		return x.Version
+	}
+	return 0
+}
+
+var File_data_version_version_proto protoreflect.FileDescriptor
+
+const file_data_version_version_proto_rawDesc = "" +
+	"\n" +
+	"\x1adata/version/version.proto\x12\fdata.version\"#\n" +
+	"\aVersion\x12\x18\n" +
+	"\aversion\x18\x01 \x01(\x03R\aversionB\xa7\x01\n" +
+	"\x10com.data.versionB\fVersionProtoP\x01Z4github.com/c4t-but-s4d/fastad/pkg/proto/data/version\xa2\x02\x03DVX\xaa\x02\fData.Version\xca\x02\fData\\Version\xe2\x02\x18Data\\Version\\GPBMetadata\xea\x02\rData::Versionb\x06proto3"
+
+var (
+	file_data_version_version_proto_rawDescOnce sync.Once
+	file_data_version_version_proto_rawDescData []byte
+)
+
+func file_data_version_version_proto_rawDescGZIP() []byte {
+	file_data_version_version_proto_rawDescOnce.Do(func() {
+		file_data_version_version_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_data_version_version_proto_rawDesc), len(file_data_version_version_proto_rawDesc)))
+	})
+	return file_data_version_version_proto_rawDescData
+}
+
+var file_data_version_version_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_data_version_version_proto_goTypes = []any{
+	(*Version)(nil), // 0: data.version.Version
+}
+var file_data_version_version_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_data_version_version_proto_init() }
+func file_data_version_version_proto_init() {
+	if File_data_version_version_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_data_version_version_proto_rawDesc), len(file_data_version_version_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_data_version_version_proto_goTypes,
+		DependencyIndexes: file_data_version_version_proto_depIdxs,
+		MessageInfos:      file_data_version_version_proto_msgTypes,
+	}.Build()
+	File_data_version_version_proto = out.File
+	file_data_version_version_proto_goTypes = nil
+	file_data_version_version_proto_depIdxs = nil
+}
diff --git a/pkg/proto/data/version/version_vtproto.pb.go b/pkg/proto/data/version/version_vtproto.pb.go
new file mode 100644
index 0000000..6e2718b
--- /dev/null
+++ b/pkg/proto/data/version/version_vtproto.pb.go
@@ -0,0 +1,54 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: data/version/version.proto
+
+package version
+
+import (
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *Version) CloneVT() *Version {
+	if m == nil {
+		return (*Version)(nil)
+	}
+	r := new(Version)
+	r.Version = m.Version
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Version) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *Version) EqualVT(that *Version) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Version != that.Version {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Version) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Version)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/pinger/pinger.pb.go b/pkg/proto/pinger/pinger.pb.go
index ccd7ee7..1d2a564 100644
--- a/pkg/proto/pinger/pinger.pb.go
+++ b/pkg/proto/pinger/pinger.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.28.0-devel
+// 	protoc-gen-go v1.36.11
 // 	protoc        (unknown)
 // source: pinger/pinger.proto
 
@@ -11,6 +11,7 @@ import (
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
+	unsafe "unsafe"
 )
 
 const (
@@ -21,18 +22,16 @@ const (
 )
 
 type PingRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
 	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *PingRequest) Reset() {
 	*x = PingRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_pinger_pinger_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
+	mi := &file_pinger_pinger_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
 func (x *PingRequest) String() string {
@@ -43,7 +42,7 @@ func (*PingRequest) ProtoMessage() {}
 
 func (x *PingRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_pinger_pinger_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
@@ -59,18 +58,16 @@ func (*PingRequest) Descriptor() ([]byte, []int) {
 }
 
 type PingResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
 	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *PingResponse) Reset() {
 	*x = PingResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_pinger_pinger_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
+	mi := &file_pinger_pinger_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
 func (x *PingResponse) String() string {
@@ -81,7 +78,7 @@ func (*PingResponse) ProtoMessage() {}
 
 func (x *PingResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_pinger_pinger_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
@@ -98,34 +95,28 @@ func (*PingResponse) Descriptor() ([]byte, []int) {
 
 var File_pinger_pinger_proto protoreflect.FileDescriptor
 
-var file_pinger_pinger_proto_rawDesc = []byte{
-	0x0a, 0x13, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x2f, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x22, 0x0d, 0x0a,
-	0x0b, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x0e, 0x0a, 0x0c,
-	0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x5f, 0x0a, 0x0a,
-	0x63, 0x6f, 0x6d, 0x2e, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x42, 0x0b, 0x50, 0x69, 0x6e, 0x67,
-	0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x0c, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2f, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x50, 0x58, 0x58, 0xaa, 0x02, 0x06,
-	0x50, 0x69, 0x6e, 0x67, 0x65, 0x72, 0xca, 0x02, 0x06, 0x50, 0x69, 0x6e, 0x67, 0x65, 0x72, 0xe2,
-	0x02, 0x12, 0x50, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
-	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x06, 0x50, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x62, 0x06, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
+const file_pinger_pinger_proto_rawDesc = "" +
+	"\n" +
+	"\x13pinger/pinger.proto\x12\x06pinger\"\r\n" +
+	"\vPingRequest\"\x0e\n" +
+	"\fPingResponseB\x81\x01\n" +
+	"\n" +
+	"com.pingerB\vPingerProtoP\x01Z.github.com/c4t-but-s4d/fastad/pkg/proto/pinger\xa2\x02\x03PXX\xaa\x02\x06Pinger\xca\x02\x06Pinger\xe2\x02\x12Pinger\\GPBMetadata\xea\x02\x06Pingerb\x06proto3"
 
 var (
 	file_pinger_pinger_proto_rawDescOnce sync.Once
-	file_pinger_pinger_proto_rawDescData = file_pinger_pinger_proto_rawDesc
+	file_pinger_pinger_proto_rawDescData []byte
 )
 
 func file_pinger_pinger_proto_rawDescGZIP() []byte {
 	file_pinger_pinger_proto_rawDescOnce.Do(func() {
-		file_pinger_pinger_proto_rawDescData = protoimpl.X.CompressGZIP(file_pinger_pinger_proto_rawDescData)
+		file_pinger_pinger_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_pinger_pinger_proto_rawDesc), len(file_pinger_pinger_proto_rawDesc)))
 	})
 	return file_pinger_pinger_proto_rawDescData
 }
 
 var file_pinger_pinger_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
-var file_pinger_pinger_proto_goTypes = []interface{}{
+var file_pinger_pinger_proto_goTypes = []any{
 	(*PingRequest)(nil),  // 0: pinger.PingRequest
 	(*PingResponse)(nil), // 1: pinger.PingResponse
 }
@@ -142,37 +133,11 @@ func file_pinger_pinger_proto_init() {
 	if File_pinger_pinger_proto != nil {
 		return
 	}
-	if !protoimpl.UnsafeEnabled {
-		file_pinger_pinger_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PingRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_pinger_pinger_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PingResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_pinger_pinger_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_pinger_pinger_proto_rawDesc), len(file_pinger_pinger_proto_rawDesc)),
 			NumEnums:      0,
 			NumMessages:   2,
 			NumExtensions: 0,
@@ -183,7 +148,6 @@ func file_pinger_pinger_proto_init() {
 		MessageInfos:      file_pinger_pinger_proto_msgTypes,
 	}.Build()
 	File_pinger_pinger_proto = out.File
-	file_pinger_pinger_proto_rawDesc = nil
 	file_pinger_pinger_proto_goTypes = nil
 	file_pinger_pinger_proto_depIdxs = nil
 }
diff --git a/pkg/proto/pinger/pinger_service.pb.go b/pkg/proto/pinger/pinger_service.pb.go
index 7f4f679..abd39b5 100644
--- a/pkg/proto/pinger/pinger_service.pb.go
+++ b/pkg/proto/pinger/pinger_service.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.28.0-devel
+// 	protoc-gen-go v1.36.11
 // 	protoc        (unknown)
 // source: pinger/pinger_service.proto
 
@@ -10,6 +10,7 @@ import (
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
+	unsafe "unsafe"
 )
 
 const (
@@ -21,25 +22,15 @@ const (
 
 var File_pinger_pinger_service_proto protoreflect.FileDescriptor
 
-var file_pinger_pinger_service_proto_rawDesc = []byte{
-	0x0a, 0x1b, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x2f, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x5f,
-	0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x70,
-	0x69, 0x6e, 0x67, 0x65, 0x72, 0x1a, 0x13, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x2f, 0x70, 0x69,
-	0x6e, 0x67, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x42, 0x0a, 0x0d, 0x50, 0x69,
-	0x6e, 0x67, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x31, 0x0a, 0x04, 0x50,
-	0x69, 0x6e, 0x67, 0x12, 0x13, 0x2e, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x6e,
-	0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x70, 0x69, 0x6e, 0x67, 0x65,
-	0x72, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x66,
-	0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x42, 0x12, 0x50, 0x69,
-	0x6e, 0x67, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f,
-	0x50, 0x01, 0x5a, 0x0c, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x69, 0x6e, 0x67, 0x65, 0x72,
-	0xa2, 0x02, 0x03, 0x50, 0x58, 0x58, 0xaa, 0x02, 0x06, 0x50, 0x69, 0x6e, 0x67, 0x65, 0x72, 0xca,
-	0x02, 0x06, 0x50, 0x69, 0x6e, 0x67, 0x65, 0x72, 0xe2, 0x02, 0x12, 0x50, 0x69, 0x6e, 0x67, 0x65,
-	0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x06,
-	0x50, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
+const file_pinger_pinger_service_proto_rawDesc = "" +
+	"\n" +
+	"\x1bpinger/pinger_service.proto\x12\x06pinger\x1a\x13pinger/pinger.proto2B\n" +
+	"\rPingerService\x121\n" +
+	"\x04Ping\x12\x13.pinger.PingRequest\x1a\x14.pinger.PingResponseB\x88\x01\n" +
+	"\n" +
+	"com.pingerB\x12PingerServiceProtoP\x01Z.github.com/c4t-but-s4d/fastad/pkg/proto/pinger\xa2\x02\x03PXX\xaa\x02\x06Pinger\xca\x02\x06Pinger\xe2\x02\x12Pinger\\GPBMetadata\xea\x02\x06Pingerb\x06proto3"
 
-var file_pinger_pinger_service_proto_goTypes = []interface{}{
+var file_pinger_pinger_service_proto_goTypes = []any{
 	(*PingRequest)(nil),  // 0: pinger.PingRequest
 	(*PingResponse)(nil), // 1: pinger.PingResponse
 }
@@ -63,7 +54,7 @@ func file_pinger_pinger_service_proto_init() {
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_pinger_pinger_service_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_pinger_pinger_service_proto_rawDesc), len(file_pinger_pinger_service_proto_rawDesc)),
 			NumEnums:      0,
 			NumMessages:   0,
 			NumExtensions: 0,
@@ -73,7 +64,6 @@ func file_pinger_pinger_service_proto_init() {
 		DependencyIndexes: file_pinger_pinger_service_proto_depIdxs,
 	}.Build()
 	File_pinger_pinger_service_proto = out.File
-	file_pinger_pinger_service_proto_rawDesc = nil
 	file_pinger_pinger_service_proto_goTypes = nil
 	file_pinger_pinger_service_proto_depIdxs = nil
 }
diff --git a/pkg/proto/pinger/pinger_service_grpc.pb.go b/pkg/proto/pinger/pinger_service_grpc.pb.go
index ef4b919..fb8d1bd 100644
--- a/pkg/proto/pinger/pinger_service_grpc.pb.go
+++ b/pkg/proto/pinger/pinger_service_grpc.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.6.0
 // - protoc             (unknown)
 // source: pinger/pinger_service.proto
 
@@ -15,8 +15,12 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	PingerService_Ping_FullMethodName = "/pinger.PingerService/Ping"
+)
 
 // PingerServiceClient is the client API for PingerService service.
 //
@@ -34,8 +38,9 @@ func NewPingerServiceClient(cc grpc.ClientConnInterface) PingerServiceClient {
 }
 
 func (c *pingerServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(PingResponse)
-	err := c.cc.Invoke(ctx, "/pinger.PingerService/Ping", in, out, opts...)
+	err := c.cc.Invoke(ctx, PingerService_Ping_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -44,20 +49,24 @@ func (c *pingerServiceClient) Ping(ctx context.Context, in *PingRequest, opts ..
 
 // PingerServiceServer is the server API for PingerService service.
 // All implementations must embed UnimplementedPingerServiceServer
-// for forward compatibility
+// for forward compatibility.
 type PingerServiceServer interface {
 	Ping(context.Context, *PingRequest) (*PingResponse, error)
 	mustEmbedUnimplementedPingerServiceServer()
 }
 
-// UnimplementedPingerServiceServer must be embedded to have forward compatible implementations.
-type UnimplementedPingerServiceServer struct {
-}
+// UnimplementedPingerServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedPingerServiceServer struct{}
 
 func (UnimplementedPingerServiceServer) Ping(context.Context, *PingRequest) (*PingResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
+	return nil, status.Error(codes.Unimplemented, "method Ping not implemented")
 }
 func (UnimplementedPingerServiceServer) mustEmbedUnimplementedPingerServiceServer() {}
+func (UnimplementedPingerServiceServer) testEmbeddedByValue()                       {}
 
 // UnsafePingerServiceServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to PingerServiceServer will
@@ -67,6 +76,13 @@ type UnsafePingerServiceServer interface {
 }
 
 func RegisterPingerServiceServer(s grpc.ServiceRegistrar, srv PingerServiceServer) {
+	// If the following call panics, it indicates UnimplementedPingerServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
 	s.RegisterService(&PingerService_ServiceDesc, srv)
 }
 
@@ -80,7 +96,7 @@ func _PingerService_Ping_Handler(srv interface{}, ctx context.Context, dec func(
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/pinger.PingerService/Ping",
+		FullMethod: PingerService_Ping_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(PingerServiceServer).Ping(ctx, req.(*PingRequest))
diff --git a/pkg/proto/pinger/pinger_vtproto.pb.go b/pkg/proto/pinger/pinger_vtproto.pb.go
new file mode 100644
index 0000000..d36dfea
--- /dev/null
+++ b/pkg/proto/pinger/pinger_vtproto.pb.go
@@ -0,0 +1,82 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: pinger/pinger.proto
+
+package pinger
+
+import (
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *PingRequest) CloneVT() *PingRequest {
+	if m == nil {
+		return (*PingRequest)(nil)
+	}
+	r := new(PingRequest)
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *PingRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *PingResponse) CloneVT() *PingResponse {
+	if m == nil {
+		return (*PingResponse)(nil)
+	}
+	r := new(PingResponse)
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *PingResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *PingRequest) EqualVT(that *PingRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *PingRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*PingRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *PingResponse) EqualVT(that *PingResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *PingResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*PingResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/receiver/receiver.pb.go b/pkg/proto/receiver/receiver.pb.go
index 96e4409..955c747 100644
--- a/pkg/proto/receiver/receiver.pb.go
+++ b/pkg/proto/receiver/receiver.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.28.0-devel
+// 	protoc-gen-go v1.36.11
 // 	protoc        (unknown)
 // source: receiver/receiver.proto
 
@@ -11,6 +11,7 @@ import (
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
+	unsafe "unsafe"
 )
 
 const (
@@ -23,11 +24,13 @@ const (
 type FlagResponse_Verdict int32
 
 const (
-	FlagResponse_VERDICT_UNSPECIFIED FlagResponse_Verdict = 0
-	FlagResponse_VERDICT_ACCEPTED    FlagResponse_Verdict = 1
-	FlagResponse_VERDICT_OWN         FlagResponse_Verdict = 2
-	FlagResponse_VERDICT_OLD         FlagResponse_Verdict = 3
-	FlagResponse_VERDICT_INVALID     FlagResponse_Verdict = 4
+	FlagResponse_VERDICT_UNSPECIFIED    FlagResponse_Verdict = 0
+	FlagResponse_VERDICT_ACCEPTED       FlagResponse_Verdict = 1
+	FlagResponse_VERDICT_OWN            FlagResponse_Verdict = 2
+	FlagResponse_VERDICT_OLD            FlagResponse_Verdict = 3
+	FlagResponse_VERDICT_INVALID        FlagResponse_Verdict = 4
+	FlagResponse_VERDICT_DUPLICATE      FlagResponse_Verdict = 5
+	FlagResponse_VERDICT_FLAG_NOT_READY FlagResponse_Verdict = 6
 )
 
 // Enum value maps for FlagResponse_Verdict.
@@ -38,13 +41,17 @@ var (
 		2: "VERDICT_OWN",
 		3: "VERDICT_OLD",
 		4: "VERDICT_INVALID",
+		5: "VERDICT_DUPLICATE",
+		6: "VERDICT_FLAG_NOT_READY",
 	}
 	FlagResponse_Verdict_value = map[string]int32{
-		"VERDICT_UNSPECIFIED": 0,
-		"VERDICT_ACCEPTED":    1,
-		"VERDICT_OWN":         2,
-		"VERDICT_OLD":         3,
-		"VERDICT_INVALID":     4,
+		"VERDICT_UNSPECIFIED":    0,
+		"VERDICT_ACCEPTED":       1,
+		"VERDICT_OWN":            2,
+		"VERDICT_OLD":            3,
+		"VERDICT_INVALID":        4,
+		"VERDICT_DUPLICATE":      5,
+		"VERDICT_FLAG_NOT_READY": 6,
 	}
 )
 
@@ -76,20 +83,18 @@ func (FlagResponse_Verdict) EnumDescriptor() ([]byte, []int) {
 }
 
 type SubmitFlagsRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Flags         []string               `protobuf:"bytes,1,rep,name=flags,proto3" json:"flags,omitempty"`
+	TeamToken     string                 `protobuf:"bytes,2,opt,name=team_token,json=teamToken,proto3" json:"team_token,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	Flags []string `protobuf:"bytes,1,rep,name=flags,proto3" json:"flags,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *SubmitFlagsRequest) Reset() {
 	*x = SubmitFlagsRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_receiver_receiver_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
+	mi := &file_receiver_receiver_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
 func (x *SubmitFlagsRequest) String() string {
@@ -100,7 +105,7 @@ func (*SubmitFlagsRequest) ProtoMessage() {}
 
 func (x *SubmitFlagsRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_receiver_receiver_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
@@ -122,24 +127,31 @@ func (x *SubmitFlagsRequest) GetFlags() []string {
 	return nil
 }
 
+func (x *SubmitFlagsRequest) GetTeamToken() string {
+	if x != nil {
+		return x.TeamToken
+	}
+	return ""
+}
+
 type FlagResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Flag          string                 `protobuf:"bytes,1,opt,name=flag,proto3" json:"flag,omitempty"`
+	Verdict       FlagResponse_Verdict   `protobuf:"varint,2,opt,name=verdict,proto3,enum=receiver.FlagResponse_Verdict" json:"verdict,omitempty"`
+	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
+	VictimId      int64                  `protobuf:"varint,4,opt,name=victim_id,json=victimId,proto3" json:"victim_id,omitempty"`
+	ServiceId     int64                  `protobuf:"varint,5,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
+	AttackerDelta float64                `protobuf:"fixed64,6,opt,name=attacker_delta,json=attackerDelta,proto3" json:"attacker_delta,omitempty"`
+	VictimDelta   float64                `protobuf:"fixed64,7,opt,name=victim_delta,json=victimDelta,proto3" json:"victim_delta,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	Flag       string               `protobuf:"bytes,1,opt,name=flag,proto3" json:"flag,omitempty"`
-	Verdict    FlagResponse_Verdict `protobuf:"varint,2,opt,name=verdict,proto3,enum=receiver.FlagResponse_Verdict" json:"verdict,omitempty"`
-	Message    string               `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
-	FlagPoints float64              `protobuf:"fixed64,4,opt,name=flag_points,json=flagPoints,proto3" json:"flag_points,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *FlagResponse) Reset() {
 	*x = FlagResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_receiver_receiver_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
+	mi := &file_receiver_receiver_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
 func (x *FlagResponse) String() string {
@@ -150,7 +162,7 @@ func (*FlagResponse) ProtoMessage() {}
 
 func (x *FlagResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_receiver_receiver_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
@@ -186,28 +198,166 @@ func (x *FlagResponse) GetMessage() string {
 	return ""
 }
 
-func (x *FlagResponse) GetFlagPoints() float64 {
+func (x *FlagResponse) GetVictimId() int64 {
 	if x != nil {
-		return x.FlagPoints
+		return x.VictimId
 	}
 	return 0
 }
 
-type SubmitFlagsResponse struct {
-	state         protoimpl.MessageState
+func (x *FlagResponse) GetServiceId() int64 {
+	if x != nil {
+		return x.ServiceId
+	}
+	return 0
+}
+
+func (x *FlagResponse) GetAttackerDelta() float64 {
+	if x != nil {
+		return x.AttackerDelta
+	}
+	return 0
+}
+
+func (x *FlagResponse) GetVictimDelta() float64 {
+	if x != nil {
+		return x.VictimDelta
+	}
+	return 0
+}
+
+type AttackNotification struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	AttackerId    int64                  `protobuf:"varint,1,opt,name=attacker_id,json=attackerId,proto3" json:"attacker_id,omitempty"`
+	VictimId      int64                  `protobuf:"varint,2,opt,name=victim_id,json=victimId,proto3" json:"victim_id,omitempty"`
+	ServiceId     int64                  `protobuf:"varint,3,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
+	AttackerDelta float64                `protobuf:"fixed64,4,opt,name=attacker_delta,json=attackerDelta,proto3" json:"attacker_delta,omitempty"`
+	VictimDelta   float64                `protobuf:"fixed64,5,opt,name=victim_delta,json=victimDelta,proto3" json:"victim_delta,omitempty"`
+	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AttackNotification) Reset() {
+	*x = AttackNotification{}
+	mi := &file_receiver_receiver_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AttackNotification) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AttackNotification) ProtoMessage() {}
+
+func (x *AttackNotification) ProtoReflect() protoreflect.Message {
+	mi := &file_receiver_receiver_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AttackNotification.ProtoReflect.Descriptor instead.
+func (*AttackNotification) Descriptor() ([]byte, []int) {
+	return file_receiver_receiver_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *AttackNotification) GetAttackerId() int64 {
+	if x != nil {
+		return x.AttackerId
+	}
+	return 0
+}
+
+func (x *AttackNotification) GetVictimId() int64 {
+	if x != nil {
+		return x.VictimId
+	}
+	return 0
+}
+
+func (x *AttackNotification) GetServiceId() int64 {
+	if x != nil {
+		return x.ServiceId
+	}
+	return 0
+}
+
+func (x *AttackNotification) GetAttackerDelta() float64 {
+	if x != nil {
+		return x.AttackerDelta
+	}
+	return 0
+}
+
+func (x *AttackNotification) GetVictimDelta() float64 {
+	if x != nil {
+		return x.VictimDelta
+	}
+	return 0
+}
+
+type State struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	TeamServices  []*State_TeamService   `protobuf:"bytes,1,rep,name=team_services,json=teamServices,proto3" json:"team_services,omitempty"`
 	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
 
-	Responses []*FlagResponse `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
+func (x *State) Reset() {
+	*x = State{}
+	mi := &file_receiver_receiver_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
-func (x *SubmitFlagsResponse) Reset() {
-	*x = SubmitFlagsResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_receiver_receiver_proto_msgTypes[2]
+func (x *State) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*State) ProtoMessage() {}
+
+func (x *State) ProtoReflect() protoreflect.Message {
+	mi := &file_receiver_receiver_proto_msgTypes[3]
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use State.ProtoReflect.Descriptor instead.
+func (*State) Descriptor() ([]byte, []int) {
+	return file_receiver_receiver_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *State) GetTeamServices() []*State_TeamService {
+	if x != nil {
+		return x.TeamServices
+	}
+	return nil
+}
+
+type SubmitFlagsResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Responses     []*FlagResponse        `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *SubmitFlagsResponse) Reset() {
+	*x = SubmitFlagsResponse{}
+	mi := &file_receiver_receiver_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
 func (x *SubmitFlagsResponse) String() string {
@@ -217,8 +367,8 @@ func (x *SubmitFlagsResponse) String() string {
 func (*SubmitFlagsResponse) ProtoMessage() {}
 
 func (x *SubmitFlagsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_receiver_receiver_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
+	mi := &file_receiver_receiver_proto_msgTypes[4]
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
@@ -230,7 +380,7 @@ func (x *SubmitFlagsResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SubmitFlagsResponse.ProtoReflect.Descriptor instead.
 func (*SubmitFlagsResponse) Descriptor() ([]byte, []int) {
-	return file_receiver_receiver_proto_rawDescGZIP(), []int{2}
+	return file_receiver_receiver_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *SubmitFlagsResponse) GetResponses() []*FlagResponse {
@@ -240,73 +390,296 @@ func (x *SubmitFlagsResponse) GetResponses() []*FlagResponse {
 	return nil
 }
 
-var File_receiver_receiver_proto protoreflect.FileDescriptor
+type GetStateRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
 
-var file_receiver_receiver_proto_rawDesc = []byte{
-	0x0a, 0x17, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x63, 0x65, 0x69,
-	0x76, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69,
-	0x76, 0x65, 0x72, 0x22, 0x2a, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x46, 0x6c, 0x61,
-	0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6c, 0x61,
-	0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x22,
-	0x88, 0x02, 0x0a, 0x0c, 0x46, 0x6c, 0x61, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x12, 0x0a, 0x04, 0x66, 0x6c, 0x61, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
-	0x66, 0x6c, 0x61, 0x67, 0x12, 0x38, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x64, 0x69, 0x63, 0x74, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
-	0x2e, 0x46, 0x6c, 0x61, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x56, 0x65,
-	0x72, 0x64, 0x69, 0x63, 0x74, 0x52, 0x07, 0x76, 0x65, 0x72, 0x64, 0x69, 0x63, 0x74, 0x12, 0x18,
-	0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x6c, 0x61, 0x67,
-	0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x66,
-	0x6c, 0x61, 0x67, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x6f, 0x0a, 0x07, 0x56, 0x65, 0x72,
-	0x64, 0x69, 0x63, 0x74, 0x12, 0x17, 0x0a, 0x13, 0x56, 0x45, 0x52, 0x44, 0x49, 0x43, 0x54, 0x5f,
-	0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x14, 0x0a,
-	0x10, 0x56, 0x45, 0x52, 0x44, 0x49, 0x43, 0x54, 0x5f, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x45,
-	0x44, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x56, 0x45, 0x52, 0x44, 0x49, 0x43, 0x54, 0x5f, 0x4f,
-	0x57, 0x4e, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x56, 0x45, 0x52, 0x44, 0x49, 0x43, 0x54, 0x5f,
-	0x4f, 0x4c, 0x44, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x56, 0x45, 0x52, 0x44, 0x49, 0x43, 0x54,
-	0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x10, 0x04, 0x22, 0x4b, 0x0a, 0x13, 0x53, 0x75,
-	0x62, 0x6d, 0x69, 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x34, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x01,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2e,
-	0x46, 0x6c, 0x61, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x09, 0x72, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x42, 0x6d, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x2e, 0x72,
-	0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x42, 0x0d, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65,
-	0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x0e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
-	0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x52, 0x58, 0x58, 0xaa, 0x02,
-	0x08, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xca, 0x02, 0x08, 0x52, 0x65, 0x63, 0x65,
-	0x69, 0x76, 0x65, 0x72, 0xe2, 0x02, 0x14, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x5c,
-	0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x08, 0x52, 0x65,
-	0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+func (x *GetStateRequest) Reset() {
+	*x = GetStateRequest{}
+	mi := &file_receiver_receiver_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
+func (x *GetStateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetStateRequest) ProtoMessage() {}
+
+func (x *GetStateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_receiver_receiver_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetStateRequest.ProtoReflect.Descriptor instead.
+func (*GetStateRequest) Descriptor() ([]byte, []int) {
+	return file_receiver_receiver_proto_rawDescGZIP(), []int{5}
+}
+
+type GetStateResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	State         *State                 `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetStateResponse) Reset() {
+	*x = GetStateResponse{}
+	mi := &file_receiver_receiver_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetStateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetStateResponse) ProtoMessage() {}
+
+func (x *GetStateResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_receiver_receiver_proto_msgTypes[6]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetStateResponse.ProtoReflect.Descriptor instead.
+func (*GetStateResponse) Descriptor() ([]byte, []int) {
+	return file_receiver_receiver_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *GetStateResponse) GetState() *State {
+	if x != nil {
+		return x.State
+	}
+	return nil
+}
+
+type AttackNotification_Batch struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Attacks       []*AttackNotification  `protobuf:"bytes,1,rep,name=attacks,proto3" json:"attacks,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AttackNotification_Batch) Reset() {
+	*x = AttackNotification_Batch{}
+	mi := &file_receiver_receiver_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AttackNotification_Batch) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AttackNotification_Batch) ProtoMessage() {}
+
+func (x *AttackNotification_Batch) ProtoReflect() protoreflect.Message {
+	mi := &file_receiver_receiver_proto_msgTypes[7]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AttackNotification_Batch.ProtoReflect.Descriptor instead.
+func (*AttackNotification_Batch) Descriptor() ([]byte, []int) {
+	return file_receiver_receiver_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *AttackNotification_Batch) GetAttacks() []*AttackNotification {
+	if x != nil {
+		return x.Attacks
+	}
+	return nil
+}
+
+type State_TeamService struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	TeamId        int64                  `protobuf:"varint,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"`
+	ServiceId     int64                  `protobuf:"varint,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
+	Points        float64                `protobuf:"fixed64,3,opt,name=points,proto3" json:"points,omitempty"`
+	FlagsStolen   int64                  `protobuf:"varint,4,opt,name=flags_stolen,json=flagsStolen,proto3" json:"flags_stolen,omitempty"`
+	FlagsLost     int64                  `protobuf:"varint,5,opt,name=flags_lost,json=flagsLost,proto3" json:"flags_lost,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *State_TeamService) Reset() {
+	*x = State_TeamService{}
+	mi := &file_receiver_receiver_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *State_TeamService) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*State_TeamService) ProtoMessage() {}
+
+func (x *State_TeamService) ProtoReflect() protoreflect.Message {
+	mi := &file_receiver_receiver_proto_msgTypes[8]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use State_TeamService.ProtoReflect.Descriptor instead.
+func (*State_TeamService) Descriptor() ([]byte, []int) {
+	return file_receiver_receiver_proto_rawDescGZIP(), []int{3, 0}
+}
+
+func (x *State_TeamService) GetTeamId() int64 {
+	if x != nil {
+		return x.TeamId
+	}
+	return 0
+}
+
+func (x *State_TeamService) GetServiceId() int64 {
+	if x != nil {
+		return x.ServiceId
+	}
+	return 0
+}
+
+func (x *State_TeamService) GetPoints() float64 {
+	if x != nil {
+		return x.Points
+	}
+	return 0
+}
+
+func (x *State_TeamService) GetFlagsStolen() int64 {
+	if x != nil {
+		return x.FlagsStolen
+	}
+	return 0
+}
+
+func (x *State_TeamService) GetFlagsLost() int64 {
+	if x != nil {
+		return x.FlagsLost
+	}
+	return 0
+}
+
+var File_receiver_receiver_proto protoreflect.FileDescriptor
+
+const file_receiver_receiver_proto_rawDesc = "" +
+	"\n" +
+	"\x17receiver/receiver.proto\x12\breceiver\"I\n" +
+	"\x12SubmitFlagsRequest\x12\x14\n" +
+	"\x05flags\x18\x01 \x03(\tR\x05flags\x12\x1d\n" +
+	"\n" +
+	"team_token\x18\x02 \x01(\tR\tteamToken\"\xa1\x03\n" +
+	"\fFlagResponse\x12\x12\n" +
+	"\x04flag\x18\x01 \x01(\tR\x04flag\x128\n" +
+	"\averdict\x18\x02 \x01(\x0e2\x1e.receiver.FlagResponse.VerdictR\averdict\x12\x18\n" +
+	"\amessage\x18\x03 \x01(\tR\amessage\x12\x1b\n" +
+	"\tvictim_id\x18\x04 \x01(\x03R\bvictimId\x12\x1d\n" +
+	"\n" +
+	"service_id\x18\x05 \x01(\x03R\tserviceId\x12%\n" +
+	"\x0eattacker_delta\x18\x06 \x01(\x01R\rattackerDelta\x12!\n" +
+	"\fvictim_delta\x18\a \x01(\x01R\vvictimDelta\"\xa2\x01\n" +
+	"\aVerdict\x12\x17\n" +
+	"\x13VERDICT_UNSPECIFIED\x10\x00\x12\x14\n" +
+	"\x10VERDICT_ACCEPTED\x10\x01\x12\x0f\n" +
+	"\vVERDICT_OWN\x10\x02\x12\x0f\n" +
+	"\vVERDICT_OLD\x10\x03\x12\x13\n" +
+	"\x0fVERDICT_INVALID\x10\x04\x12\x15\n" +
+	"\x11VERDICT_DUPLICATE\x10\x05\x12\x1a\n" +
+	"\x16VERDICT_FLAG_NOT_READY\x10\x06\"\xfc\x01\n" +
+	"\x12AttackNotification\x12\x1f\n" +
+	"\vattacker_id\x18\x01 \x01(\x03R\n" +
+	"attackerId\x12\x1b\n" +
+	"\tvictim_id\x18\x02 \x01(\x03R\bvictimId\x12\x1d\n" +
+	"\n" +
+	"service_id\x18\x03 \x01(\x03R\tserviceId\x12%\n" +
+	"\x0eattacker_delta\x18\x04 \x01(\x01R\rattackerDelta\x12!\n" +
+	"\fvictim_delta\x18\x05 \x01(\x01R\vvictimDelta\x1a?\n" +
+	"\x05Batch\x126\n" +
+	"\aattacks\x18\x01 \x03(\v2\x1c.receiver.AttackNotificationR\aattacks\"\xeb\x01\n" +
+	"\x05State\x12@\n" +
+	"\rteam_services\x18\x01 \x03(\v2\x1b.receiver.State.TeamServiceR\fteamServices\x1a\x9f\x01\n" +
+	"\vTeamService\x12\x17\n" +
+	"\ateam_id\x18\x01 \x01(\x03R\x06teamId\x12\x1d\n" +
+	"\n" +
+	"service_id\x18\x02 \x01(\x03R\tserviceId\x12\x16\n" +
+	"\x06points\x18\x03 \x01(\x01R\x06points\x12!\n" +
+	"\fflags_stolen\x18\x04 \x01(\x03R\vflagsStolen\x12\x1d\n" +
+	"\n" +
+	"flags_lost\x18\x05 \x01(\x03R\tflagsLost\"K\n" +
+	"\x13SubmitFlagsResponse\x124\n" +
+	"\tresponses\x18\x01 \x03(\v2\x16.receiver.FlagResponseR\tresponses\"\x11\n" +
+	"\x0fGetStateRequest\"9\n" +
+	"\x10GetStateResponse\x12%\n" +
+	"\x05state\x18\x01 \x01(\v2\x0f.receiver.StateR\x05stateB\x8f\x01\n" +
+	"\fcom.receiverB\rReceiverProtoP\x01Z0github.com/c4t-but-s4d/fastad/pkg/proto/receiver\xa2\x02\x03RXX\xaa\x02\bReceiver\xca\x02\bReceiver\xe2\x02\x14Receiver\\GPBMetadata\xea\x02\bReceiverb\x06proto3"
+
 var (
 	file_receiver_receiver_proto_rawDescOnce sync.Once
-	file_receiver_receiver_proto_rawDescData = file_receiver_receiver_proto_rawDesc
+	file_receiver_receiver_proto_rawDescData []byte
 )
 
 func file_receiver_receiver_proto_rawDescGZIP() []byte {
 	file_receiver_receiver_proto_rawDescOnce.Do(func() {
-		file_receiver_receiver_proto_rawDescData = protoimpl.X.CompressGZIP(file_receiver_receiver_proto_rawDescData)
+		file_receiver_receiver_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_receiver_receiver_proto_rawDesc), len(file_receiver_receiver_proto_rawDesc)))
 	})
 	return file_receiver_receiver_proto_rawDescData
 }
 
 var file_receiver_receiver_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_receiver_receiver_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
-var file_receiver_receiver_proto_goTypes = []interface{}{
-	(FlagResponse_Verdict)(0),   // 0: receiver.FlagResponse.Verdict
-	(*SubmitFlagsRequest)(nil),  // 1: receiver.SubmitFlagsRequest
-	(*FlagResponse)(nil),        // 2: receiver.FlagResponse
-	(*SubmitFlagsResponse)(nil), // 3: receiver.SubmitFlagsResponse
+var file_receiver_receiver_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
+var file_receiver_receiver_proto_goTypes = []any{
+	(FlagResponse_Verdict)(0),        // 0: receiver.FlagResponse.Verdict
+	(*SubmitFlagsRequest)(nil),       // 1: receiver.SubmitFlagsRequest
+	(*FlagResponse)(nil),             // 2: receiver.FlagResponse
+	(*AttackNotification)(nil),       // 3: receiver.AttackNotification
+	(*State)(nil),                    // 4: receiver.State
+	(*SubmitFlagsResponse)(nil),      // 5: receiver.SubmitFlagsResponse
+	(*GetStateRequest)(nil),          // 6: receiver.GetStateRequest
+	(*GetStateResponse)(nil),         // 7: receiver.GetStateResponse
+	(*AttackNotification_Batch)(nil), // 8: receiver.AttackNotification.Batch
+	(*State_TeamService)(nil),        // 9: receiver.State.TeamService
 }
 var file_receiver_receiver_proto_depIdxs = []int32{
 	0, // 0: receiver.FlagResponse.verdict:type_name -> receiver.FlagResponse.Verdict
-	2, // 1: receiver.SubmitFlagsResponse.responses:type_name -> receiver.FlagResponse
-	2, // [2:2] is the sub-list for method output_type
-	2, // [2:2] is the sub-list for method input_type
-	2, // [2:2] is the sub-list for extension type_name
-	2, // [2:2] is the sub-list for extension extendee
-	0, // [0:2] is the sub-list for field type_name
+	9, // 1: receiver.State.team_services:type_name -> receiver.State.TeamService
+	2, // 2: receiver.SubmitFlagsResponse.responses:type_name -> receiver.FlagResponse
+	4, // 3: receiver.GetStateResponse.state:type_name -> receiver.State
+	3, // 4: receiver.AttackNotification.Batch.attacks:type_name -> receiver.AttackNotification
+	5, // [5:5] is the sub-list for method output_type
+	5, // [5:5] is the sub-list for method input_type
+	5, // [5:5] is the sub-list for extension type_name
+	5, // [5:5] is the sub-list for extension extendee
+	0, // [0:5] is the sub-list for field type_name
 }
 
 func init() { file_receiver_receiver_proto_init() }
@@ -314,51 +687,13 @@ func file_receiver_receiver_proto_init() {
 	if File_receiver_receiver_proto != nil {
 		return
 	}
-	if !protoimpl.UnsafeEnabled {
-		file_receiver_receiver_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SubmitFlagsRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_receiver_receiver_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FlagResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_receiver_receiver_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SubmitFlagsResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_receiver_receiver_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_receiver_receiver_proto_rawDesc), len(file_receiver_receiver_proto_rawDesc)),
 			NumEnums:      1,
-			NumMessages:   3,
+			NumMessages:   9,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
@@ -368,7 +703,6 @@ func file_receiver_receiver_proto_init() {
 		MessageInfos:      file_receiver_receiver_proto_msgTypes,
 	}.Build()
 	File_receiver_receiver_proto = out.File
-	file_receiver_receiver_proto_rawDesc = nil
 	file_receiver_receiver_proto_goTypes = nil
 	file_receiver_receiver_proto_depIdxs = nil
 }
diff --git a/pkg/proto/receiver/receiver_service.pb.go b/pkg/proto/receiver/receiver_service.pb.go
index de26b45..f401db3 100644
--- a/pkg/proto/receiver/receiver_service.pb.go
+++ b/pkg/proto/receiver/receiver_service.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.28.0-devel
+// 	protoc-gen-go v1.36.11
 // 	protoc        (unknown)
 // source: receiver/receiver_service.proto
 
@@ -10,6 +10,7 @@ import (
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
+	unsafe "unsafe"
 )
 
 const (
@@ -21,37 +22,27 @@ const (
 
 var File_receiver_receiver_service_proto protoreflect.FileDescriptor
 
-var file_receiver_receiver_service_proto_rawDesc = []byte{
-	0x0a, 0x1f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x63, 0x65, 0x69,
-	0x76, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x12, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x1a, 0x17, 0x72, 0x65, 0x63,
-	0x65, 0x69, 0x76, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x5d, 0x0a, 0x0f, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
-	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x4a, 0x0a, 0x0b, 0x53, 0x75, 0x62, 0x6d, 0x69,
-	0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x1c, 0x2e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65,
-	0x72, 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2e,
-	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x42, 0x74, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x2e, 0x72, 0x65, 0x63, 0x65, 0x69,
-	0x76, 0x65, 0x72, 0x42, 0x14, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x53, 0x65, 0x72,
-	0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x0e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x2f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x52, 0x58,
-	0x58, 0xaa, 0x02, 0x08, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xca, 0x02, 0x08, 0x52,
-	0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xe2, 0x02, 0x14, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76,
-	0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02,
-	0x08, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x33,
-}
+const file_receiver_receiver_service_proto_rawDesc = "" +
+	"\n" +
+	"\x1freceiver/receiver_service.proto\x12\breceiver\x1a\x17receiver/receiver.proto2\xa0\x01\n" +
+	"\x0fReceiverService\x12J\n" +
+	"\vSubmitFlags\x12\x1c.receiver.SubmitFlagsRequest\x1a\x1d.receiver.SubmitFlagsResponse\x12A\n" +
+	"\bGetState\x12\x19.receiver.GetStateRequest\x1a\x1a.receiver.GetStateResponseB\x96\x01\n" +
+	"\fcom.receiverB\x14ReceiverServiceProtoP\x01Z0github.com/c4t-but-s4d/fastad/pkg/proto/receiver\xa2\x02\x03RXX\xaa\x02\bReceiver\xca\x02\bReceiver\xe2\x02\x14Receiver\\GPBMetadata\xea\x02\bReceiverb\x06proto3"
 
-var file_receiver_receiver_service_proto_goTypes = []interface{}{
+var file_receiver_receiver_service_proto_goTypes = []any{
 	(*SubmitFlagsRequest)(nil),  // 0: receiver.SubmitFlagsRequest
-	(*SubmitFlagsResponse)(nil), // 1: receiver.SubmitFlagsResponse
+	(*GetStateRequest)(nil),     // 1: receiver.GetStateRequest
+	(*SubmitFlagsResponse)(nil), // 2: receiver.SubmitFlagsResponse
+	(*GetStateResponse)(nil),    // 3: receiver.GetStateResponse
 }
 var file_receiver_receiver_service_proto_depIdxs = []int32{
 	0, // 0: receiver.ReceiverService.SubmitFlags:input_type -> receiver.SubmitFlagsRequest
-	1, // 1: receiver.ReceiverService.SubmitFlags:output_type -> receiver.SubmitFlagsResponse
-	1, // [1:2] is the sub-list for method output_type
-	0, // [0:1] is the sub-list for method input_type
+	1, // 1: receiver.ReceiverService.GetState:input_type -> receiver.GetStateRequest
+	2, // 2: receiver.ReceiverService.SubmitFlags:output_type -> receiver.SubmitFlagsResponse
+	3, // 3: receiver.ReceiverService.GetState:output_type -> receiver.GetStateResponse
+	2, // [2:4] is the sub-list for method output_type
+	0, // [0:2] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
 	0, // [0:0] is the sub-list for extension extendee
 	0, // [0:0] is the sub-list for field type_name
@@ -67,7 +58,7 @@ func file_receiver_receiver_service_proto_init() {
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_receiver_receiver_service_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_receiver_receiver_service_proto_rawDesc), len(file_receiver_receiver_service_proto_rawDesc)),
 			NumEnums:      0,
 			NumMessages:   0,
 			NumExtensions: 0,
@@ -77,7 +68,6 @@ func file_receiver_receiver_service_proto_init() {
 		DependencyIndexes: file_receiver_receiver_service_proto_depIdxs,
 	}.Build()
 	File_receiver_receiver_service_proto = out.File
-	file_receiver_receiver_service_proto_rawDesc = nil
 	file_receiver_receiver_service_proto_goTypes = nil
 	file_receiver_receiver_service_proto_depIdxs = nil
 }
diff --git a/pkg/proto/receiver/receiver_service_grpc.pb.go b/pkg/proto/receiver/receiver_service_grpc.pb.go
index 49c2f9a..4e4a005 100644
--- a/pkg/proto/receiver/receiver_service_grpc.pb.go
+++ b/pkg/proto/receiver/receiver_service_grpc.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.6.0
 // - protoc             (unknown)
 // source: receiver/receiver_service.proto
 
@@ -15,14 +15,20 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	ReceiverService_SubmitFlags_FullMethodName = "/receiver.ReceiverService/SubmitFlags"
+	ReceiverService_GetState_FullMethodName    = "/receiver.ReceiverService/GetState"
+)
 
 // ReceiverServiceClient is the client API for ReceiverService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type ReceiverServiceClient interface {
 	SubmitFlags(ctx context.Context, in *SubmitFlagsRequest, opts ...grpc.CallOption) (*SubmitFlagsResponse, error)
+	GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error)
 }
 
 type receiverServiceClient struct {
@@ -34,8 +40,19 @@ func NewReceiverServiceClient(cc grpc.ClientConnInterface) ReceiverServiceClient
 }
 
 func (c *receiverServiceClient) SubmitFlags(ctx context.Context, in *SubmitFlagsRequest, opts ...grpc.CallOption) (*SubmitFlagsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(SubmitFlagsResponse)
-	err := c.cc.Invoke(ctx, "/receiver.ReceiverService/SubmitFlags", in, out, opts...)
+	err := c.cc.Invoke(ctx, ReceiverService_SubmitFlags_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *receiverServiceClient) GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(GetStateResponse)
+	err := c.cc.Invoke(ctx, ReceiverService_GetState_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -44,20 +61,28 @@ func (c *receiverServiceClient) SubmitFlags(ctx context.Context, in *SubmitFlags
 
 // ReceiverServiceServer is the server API for ReceiverService service.
 // All implementations must embed UnimplementedReceiverServiceServer
-// for forward compatibility
+// for forward compatibility.
 type ReceiverServiceServer interface {
 	SubmitFlags(context.Context, *SubmitFlagsRequest) (*SubmitFlagsResponse, error)
+	GetState(context.Context, *GetStateRequest) (*GetStateResponse, error)
 	mustEmbedUnimplementedReceiverServiceServer()
 }
 
-// UnimplementedReceiverServiceServer must be embedded to have forward compatible implementations.
-type UnimplementedReceiverServiceServer struct {
-}
+// UnimplementedReceiverServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedReceiverServiceServer struct{}
 
 func (UnimplementedReceiverServiceServer) SubmitFlags(context.Context, *SubmitFlagsRequest) (*SubmitFlagsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method SubmitFlags not implemented")
+	return nil, status.Error(codes.Unimplemented, "method SubmitFlags not implemented")
+}
+func (UnimplementedReceiverServiceServer) GetState(context.Context, *GetStateRequest) (*GetStateResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetState not implemented")
 }
 func (UnimplementedReceiverServiceServer) mustEmbedUnimplementedReceiverServiceServer() {}
+func (UnimplementedReceiverServiceServer) testEmbeddedByValue()                         {}
 
 // UnsafeReceiverServiceServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to ReceiverServiceServer will
@@ -67,6 +92,13 @@ type UnsafeReceiverServiceServer interface {
 }
 
 func RegisterReceiverServiceServer(s grpc.ServiceRegistrar, srv ReceiverServiceServer) {
+	// If the following call panics, it indicates UnimplementedReceiverServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
 	s.RegisterService(&ReceiverService_ServiceDesc, srv)
 }
 
@@ -80,7 +112,7 @@ func _ReceiverService_SubmitFlags_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/receiver.ReceiverService/SubmitFlags",
+		FullMethod: ReceiverService_SubmitFlags_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ReceiverServiceServer).SubmitFlags(ctx, req.(*SubmitFlagsRequest))
@@ -88,6 +120,24 @@ func _ReceiverService_SubmitFlags_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _ReceiverService_GetState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetStateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReceiverServiceServer).GetState(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: ReceiverService_GetState_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReceiverServiceServer).GetState(ctx, req.(*GetStateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // ReceiverService_ServiceDesc is the grpc.ServiceDesc for ReceiverService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -99,6 +149,10 @@ var ReceiverService_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "SubmitFlags",
 			Handler:    _ReceiverService_SubmitFlags_Handler,
 		},
+		{
+			MethodName: "GetState",
+			Handler:    _ReceiverService_GetState_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "receiver/receiver_service.proto",
diff --git a/pkg/proto/receiver/receiver_vtproto.pb.go b/pkg/proto/receiver/receiver_vtproto.pb.go
new file mode 100644
index 0000000..2b85e86
--- /dev/null
+++ b/pkg/proto/receiver/receiver_vtproto.pb.go
@@ -0,0 +1,468 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: receiver/receiver.proto
+
+package receiver
+
+import (
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *SubmitFlagsRequest) CloneVT() *SubmitFlagsRequest {
+	if m == nil {
+		return (*SubmitFlagsRequest)(nil)
+	}
+	r := new(SubmitFlagsRequest)
+	r.TeamToken = m.TeamToken
+	if rhs := m.Flags; rhs != nil {
+		tmpContainer := make([]string, len(rhs))
+		copy(tmpContainer, rhs)
+		r.Flags = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *SubmitFlagsRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *FlagResponse) CloneVT() *FlagResponse {
+	if m == nil {
+		return (*FlagResponse)(nil)
+	}
+	r := new(FlagResponse)
+	r.Flag = m.Flag
+	r.Verdict = m.Verdict
+	r.Message = m.Message
+	r.VictimId = m.VictimId
+	r.ServiceId = m.ServiceId
+	r.AttackerDelta = m.AttackerDelta
+	r.VictimDelta = m.VictimDelta
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *FlagResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *AttackNotification_Batch) CloneVT() *AttackNotification_Batch {
+	if m == nil {
+		return (*AttackNotification_Batch)(nil)
+	}
+	r := new(AttackNotification_Batch)
+	if rhs := m.Attacks; rhs != nil {
+		tmpContainer := make([]*AttackNotification, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Attacks = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *AttackNotification_Batch) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *AttackNotification) CloneVT() *AttackNotification {
+	if m == nil {
+		return (*AttackNotification)(nil)
+	}
+	r := new(AttackNotification)
+	r.AttackerId = m.AttackerId
+	r.VictimId = m.VictimId
+	r.ServiceId = m.ServiceId
+	r.AttackerDelta = m.AttackerDelta
+	r.VictimDelta = m.VictimDelta
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *AttackNotification) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *State_TeamService) CloneVT() *State_TeamService {
+	if m == nil {
+		return (*State_TeamService)(nil)
+	}
+	r := new(State_TeamService)
+	r.TeamId = m.TeamId
+	r.ServiceId = m.ServiceId
+	r.Points = m.Points
+	r.FlagsStolen = m.FlagsStolen
+	r.FlagsLost = m.FlagsLost
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *State_TeamService) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *State) CloneVT() *State {
+	if m == nil {
+		return (*State)(nil)
+	}
+	r := new(State)
+	if rhs := m.TeamServices; rhs != nil {
+		tmpContainer := make([]*State_TeamService, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.TeamServices = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *State) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *SubmitFlagsResponse) CloneVT() *SubmitFlagsResponse {
+	if m == nil {
+		return (*SubmitFlagsResponse)(nil)
+	}
+	r := new(SubmitFlagsResponse)
+	if rhs := m.Responses; rhs != nil {
+		tmpContainer := make([]*FlagResponse, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Responses = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *SubmitFlagsResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *GetStateRequest) CloneVT() *GetStateRequest {
+	if m == nil {
+		return (*GetStateRequest)(nil)
+	}
+	r := new(GetStateRequest)
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *GetStateRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *GetStateResponse) CloneVT() *GetStateResponse {
+	if m == nil {
+		return (*GetStateResponse)(nil)
+	}
+	r := new(GetStateResponse)
+	r.State = m.State.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *GetStateResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *SubmitFlagsRequest) EqualVT(that *SubmitFlagsRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Flags) != len(that.Flags) {
+		return false
+	}
+	for i, vx := range this.Flags {
+		vy := that.Flags[i]
+		if vx != vy {
+			return false
+		}
+	}
+	if this.TeamToken != that.TeamToken {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *SubmitFlagsRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*SubmitFlagsRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *FlagResponse) EqualVT(that *FlagResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Flag != that.Flag {
+		return false
+	}
+	if this.Verdict != that.Verdict {
+		return false
+	}
+	if this.Message != that.Message {
+		return false
+	}
+	if this.VictimId != that.VictimId {
+		return false
+	}
+	if this.ServiceId != that.ServiceId {
+		return false
+	}
+	if this.AttackerDelta != that.AttackerDelta {
+		return false
+	}
+	if this.VictimDelta != that.VictimDelta {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *FlagResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*FlagResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *AttackNotification_Batch) EqualVT(that *AttackNotification_Batch) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Attacks) != len(that.Attacks) {
+		return false
+	}
+	for i, vx := range this.Attacks {
+		vy := that.Attacks[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &AttackNotification{}
+			}
+			if q == nil {
+				q = &AttackNotification{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *AttackNotification_Batch) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*AttackNotification_Batch)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *AttackNotification) EqualVT(that *AttackNotification) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.AttackerId != that.AttackerId {
+		return false
+	}
+	if this.VictimId != that.VictimId {
+		return false
+	}
+	if this.ServiceId != that.ServiceId {
+		return false
+	}
+	if this.AttackerDelta != that.AttackerDelta {
+		return false
+	}
+	if this.VictimDelta != that.VictimDelta {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *AttackNotification) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*AttackNotification)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *State_TeamService) EqualVT(that *State_TeamService) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.TeamId != that.TeamId {
+		return false
+	}
+	if this.ServiceId != that.ServiceId {
+		return false
+	}
+	if this.Points != that.Points {
+		return false
+	}
+	if this.FlagsStolen != that.FlagsStolen {
+		return false
+	}
+	if this.FlagsLost != that.FlagsLost {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *State_TeamService) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*State_TeamService)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *State) EqualVT(that *State) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.TeamServices) != len(that.TeamServices) {
+		return false
+	}
+	for i, vx := range this.TeamServices {
+		vy := that.TeamServices[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &State_TeamService{}
+			}
+			if q == nil {
+				q = &State_TeamService{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *State) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*State)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *SubmitFlagsResponse) EqualVT(that *SubmitFlagsResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Responses) != len(that.Responses) {
+		return false
+	}
+	for i, vx := range this.Responses {
+		vy := that.Responses[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &FlagResponse{}
+			}
+			if q == nil {
+				q = &FlagResponse{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *SubmitFlagsResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*SubmitFlagsResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *GetStateRequest) EqualVT(that *GetStateRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *GetStateRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*GetStateRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *GetStateResponse) EqualVT(that *GetStateResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.State.EqualVT(that.State) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *GetStateResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*GetStateResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/scoreboard/scoreboard.pb.go b/pkg/proto/scoreboard/scoreboard.pb.go
new file mode 100644
index 0000000..c2abc48
--- /dev/null
+++ b/pkg/proto/scoreboard/scoreboard.pb.go
@@ -0,0 +1,246 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: scoreboard/scoreboard.proto
+
+package scoreboard
+
+import (
+	slac "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type Scoreboard struct {
+	state             protoimpl.MessageState         `protogen:"open.v1"`
+	TeamServiceStates []*Scoreboard_TeamServiceState `protobuf:"bytes,1,rep,name=team_service_states,json=teamServiceStates,proto3" json:"team_service_states,omitempty"`
+	unknownFields     protoimpl.UnknownFields
+	sizeCache         protoimpl.SizeCache
+}
+
+func (x *Scoreboard) Reset() {
+	*x = Scoreboard{}
+	mi := &file_scoreboard_scoreboard_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Scoreboard) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Scoreboard) ProtoMessage() {}
+
+func (x *Scoreboard) ProtoReflect() protoreflect.Message {
+	mi := &file_scoreboard_scoreboard_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Scoreboard.ProtoReflect.Descriptor instead.
+func (*Scoreboard) Descriptor() ([]byte, []int) {
+	return file_scoreboard_scoreboard_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Scoreboard) GetTeamServiceStates() []*Scoreboard_TeamServiceState {
+	if x != nil {
+		return x.TeamServiceStates
+	}
+	return nil
+}
+
+type Scoreboard_TeamServiceState struct {
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	TeamId    int64                  `protobuf:"varint,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"`
+	ServiceId int64                  `protobuf:"varint,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
+	// From slac.
+	ChecksTotal   int64                                `protobuf:"varint,3,opt,name=checks_total,json=checksTotal,proto3" json:"checks_total,omitempty"`
+	ChecksPassed  int64                                `protobuf:"varint,4,opt,name=checks_passed,json=checksPassed,proto3" json:"checks_passed,omitempty"`
+	CheckStatuses []*slac.TeamServiceState_CheckStatus `protobuf:"bytes,5,rep,name=check_statuses,json=checkStatuses,proto3" json:"check_statuses,omitempty"`
+	// From receiver.
+	Points        float64 `protobuf:"fixed64,6,opt,name=points,proto3" json:"points,omitempty"`
+	FlagsStolen   int64   `protobuf:"varint,7,opt,name=flags_stolen,json=flagsStolen,proto3" json:"flags_stolen,omitempty"`
+	FlagsLost     int64   `protobuf:"varint,8,opt,name=flags_lost,json=flagsLost,proto3" json:"flags_lost,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Scoreboard_TeamServiceState) Reset() {
+	*x = Scoreboard_TeamServiceState{}
+	mi := &file_scoreboard_scoreboard_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Scoreboard_TeamServiceState) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Scoreboard_TeamServiceState) ProtoMessage() {}
+
+func (x *Scoreboard_TeamServiceState) ProtoReflect() protoreflect.Message {
+	mi := &file_scoreboard_scoreboard_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Scoreboard_TeamServiceState.ProtoReflect.Descriptor instead.
+func (*Scoreboard_TeamServiceState) Descriptor() ([]byte, []int) {
+	return file_scoreboard_scoreboard_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *Scoreboard_TeamServiceState) GetTeamId() int64 {
+	if x != nil {
+		return x.TeamId
+	}
+	return 0
+}
+
+func (x *Scoreboard_TeamServiceState) GetServiceId() int64 {
+	if x != nil {
+		return x.ServiceId
+	}
+	return 0
+}
+
+func (x *Scoreboard_TeamServiceState) GetChecksTotal() int64 {
+	if x != nil {
+		return x.ChecksTotal
+	}
+	return 0
+}
+
+func (x *Scoreboard_TeamServiceState) GetChecksPassed() int64 {
+	if x != nil {
+		return x.ChecksPassed
+	}
+	return 0
+}
+
+func (x *Scoreboard_TeamServiceState) GetCheckStatuses() []*slac.TeamServiceState_CheckStatus {
+	if x != nil {
+		return x.CheckStatuses
+	}
+	return nil
+}
+
+func (x *Scoreboard_TeamServiceState) GetPoints() float64 {
+	if x != nil {
+		return x.Points
+	}
+	return 0
+}
+
+func (x *Scoreboard_TeamServiceState) GetFlagsStolen() int64 {
+	if x != nil {
+		return x.FlagsStolen
+	}
+	return 0
+}
+
+func (x *Scoreboard_TeamServiceState) GetFlagsLost() int64 {
+	if x != nil {
+		return x.FlagsLost
+	}
+	return 0
+}
+
+var File_scoreboard_scoreboard_proto protoreflect.FileDescriptor
+
+const file_scoreboard_scoreboard_proto_rawDesc = "" +
+	"\n" +
+	"\x1bscoreboard/scoreboard.proto\x12\n" +
+	"scoreboard\x1a\x0fslac/slac.proto\"\x9f\x03\n" +
+	"\n" +
+	"Scoreboard\x12W\n" +
+	"\x13team_service_states\x18\x01 \x03(\v2'.scoreboard.Scoreboard.TeamServiceStateR\x11teamServiceStates\x1a\xb7\x02\n" +
+	"\x10TeamServiceState\x12\x17\n" +
+	"\ateam_id\x18\x01 \x01(\x03R\x06teamId\x12\x1d\n" +
+	"\n" +
+	"service_id\x18\x02 \x01(\x03R\tserviceId\x12!\n" +
+	"\fchecks_total\x18\x03 \x01(\x03R\vchecksTotal\x12#\n" +
+	"\rchecks_passed\x18\x04 \x01(\x03R\fchecksPassed\x12I\n" +
+	"\x0echeck_statuses\x18\x05 \x03(\v2\".slac.TeamServiceState.CheckStatusR\rcheckStatuses\x12\x16\n" +
+	"\x06points\x18\x06 \x01(\x01R\x06points\x12!\n" +
+	"\fflags_stolen\x18\a \x01(\x03R\vflagsStolen\x12\x1d\n" +
+	"\n" +
+	"flags_lost\x18\b \x01(\x03R\tflagsLostB\x9d\x01\n" +
+	"\x0ecom.scoreboardB\x0fScoreboardProtoP\x01Z2github.com/c4t-but-s4d/fastad/pkg/proto/scoreboard\xa2\x02\x03SXX\xaa\x02\n" +
+	"Scoreboard\xca\x02\n" +
+	"Scoreboard\xe2\x02\x16Scoreboard\\GPBMetadata\xea\x02\n" +
+	"Scoreboardb\x06proto3"
+
+var (
+	file_scoreboard_scoreboard_proto_rawDescOnce sync.Once
+	file_scoreboard_scoreboard_proto_rawDescData []byte
+)
+
+func file_scoreboard_scoreboard_proto_rawDescGZIP() []byte {
+	file_scoreboard_scoreboard_proto_rawDescOnce.Do(func() {
+		file_scoreboard_scoreboard_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_scoreboard_scoreboard_proto_rawDesc), len(file_scoreboard_scoreboard_proto_rawDesc)))
+	})
+	return file_scoreboard_scoreboard_proto_rawDescData
+}
+
+var file_scoreboard_scoreboard_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_scoreboard_scoreboard_proto_goTypes = []any{
+	(*Scoreboard)(nil),                        // 0: scoreboard.Scoreboard
+	(*Scoreboard_TeamServiceState)(nil),       // 1: scoreboard.Scoreboard.TeamServiceState
+	(*slac.TeamServiceState_CheckStatus)(nil), // 2: slac.TeamServiceState.CheckStatus
+}
+var file_scoreboard_scoreboard_proto_depIdxs = []int32{
+	1, // 0: scoreboard.Scoreboard.team_service_states:type_name -> scoreboard.Scoreboard.TeamServiceState
+	2, // 1: scoreboard.Scoreboard.TeamServiceState.check_statuses:type_name -> slac.TeamServiceState.CheckStatus
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	2, // [2:2] is the sub-list for extension extendee
+	0, // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_scoreboard_scoreboard_proto_init() }
+func file_scoreboard_scoreboard_proto_init() {
+	if File_scoreboard_scoreboard_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_scoreboard_scoreboard_proto_rawDesc), len(file_scoreboard_scoreboard_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_scoreboard_scoreboard_proto_goTypes,
+		DependencyIndexes: file_scoreboard_scoreboard_proto_depIdxs,
+		MessageInfos:      file_scoreboard_scoreboard_proto_msgTypes,
+	}.Build()
+	File_scoreboard_scoreboard_proto = out.File
+	file_scoreboard_scoreboard_proto_goTypes = nil
+	file_scoreboard_scoreboard_proto_depIdxs = nil
+}
diff --git a/pkg/proto/scoreboard/scoreboard_vtproto.pb.go b/pkg/proto/scoreboard/scoreboard_vtproto.pb.go
new file mode 100644
index 0000000..f109111
--- /dev/null
+++ b/pkg/proto/scoreboard/scoreboard_vtproto.pb.go
@@ -0,0 +1,159 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: scoreboard/scoreboard.proto
+
+package scoreboard
+
+import (
+	slac "github.com/c4t-but-s4d/fastad/pkg/proto/slac"
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *Scoreboard_TeamServiceState) CloneVT() *Scoreboard_TeamServiceState {
+	if m == nil {
+		return (*Scoreboard_TeamServiceState)(nil)
+	}
+	r := new(Scoreboard_TeamServiceState)
+	r.TeamId = m.TeamId
+	r.ServiceId = m.ServiceId
+	r.ChecksTotal = m.ChecksTotal
+	r.ChecksPassed = m.ChecksPassed
+	r.Points = m.Points
+	r.FlagsStolen = m.FlagsStolen
+	r.FlagsLost = m.FlagsLost
+	if rhs := m.CheckStatuses; rhs != nil {
+		tmpContainer := make([]*slac.TeamServiceState_CheckStatus, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.CheckStatuses = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Scoreboard_TeamServiceState) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Scoreboard) CloneVT() *Scoreboard {
+	if m == nil {
+		return (*Scoreboard)(nil)
+	}
+	r := new(Scoreboard)
+	if rhs := m.TeamServiceStates; rhs != nil {
+		tmpContainer := make([]*Scoreboard_TeamServiceState, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.TeamServiceStates = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Scoreboard) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *Scoreboard_TeamServiceState) EqualVT(that *Scoreboard_TeamServiceState) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.TeamId != that.TeamId {
+		return false
+	}
+	if this.ServiceId != that.ServiceId {
+		return false
+	}
+	if this.ChecksTotal != that.ChecksTotal {
+		return false
+	}
+	if this.ChecksPassed != that.ChecksPassed {
+		return false
+	}
+	if len(this.CheckStatuses) != len(that.CheckStatuses) {
+		return false
+	}
+	for i, vx := range this.CheckStatuses {
+		vy := that.CheckStatuses[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &slac.TeamServiceState_CheckStatus{}
+			}
+			if q == nil {
+				q = &slac.TeamServiceState_CheckStatus{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	if this.Points != that.Points {
+		return false
+	}
+	if this.FlagsStolen != that.FlagsStolen {
+		return false
+	}
+	if this.FlagsLost != that.FlagsLost {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Scoreboard_TeamServiceState) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Scoreboard_TeamServiceState)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *Scoreboard) EqualVT(that *Scoreboard) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.TeamServiceStates) != len(that.TeamServiceStates) {
+		return false
+	}
+	for i, vx := range this.TeamServiceStates {
+		vy := that.TeamServiceStates[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Scoreboard_TeamServiceState{}
+			}
+			if q == nil {
+				q = &Scoreboard_TeamServiceState{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Scoreboard) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Scoreboard)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/proto/slac/slac.pb.go b/pkg/proto/slac/slac.pb.go
new file mode 100644
index 0000000..928f9f8
--- /dev/null
+++ b/pkg/proto/slac/slac.pb.go
@@ -0,0 +1,354 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: slac/slac.proto
+
+package slac
+
+import (
+	checker "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type TeamServiceState struct {
+	state         protoimpl.MessageState          `protogen:"open.v1"`
+	TeamId        int64                           `protobuf:"varint,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"`
+	ServiceId     int64                           `protobuf:"varint,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
+	ChecksTotal   int64                           `protobuf:"varint,3,opt,name=checks_total,json=checksTotal,proto3" json:"checks_total,omitempty"`
+	ChecksPassed  int64                           `protobuf:"varint,4,opt,name=checks_passed,json=checksPassed,proto3" json:"checks_passed,omitempty"`
+	CheckStatuses []*TeamServiceState_CheckStatus `protobuf:"bytes,5,rep,name=check_statuses,json=checkStatuses,proto3" json:"check_statuses,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TeamServiceState) Reset() {
+	*x = TeamServiceState{}
+	mi := &file_slac_slac_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TeamServiceState) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TeamServiceState) ProtoMessage() {}
+
+func (x *TeamServiceState) ProtoReflect() protoreflect.Message {
+	mi := &file_slac_slac_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TeamServiceState.ProtoReflect.Descriptor instead.
+func (*TeamServiceState) Descriptor() ([]byte, []int) {
+	return file_slac_slac_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *TeamServiceState) GetTeamId() int64 {
+	if x != nil {
+		return x.TeamId
+	}
+	return 0
+}
+
+func (x *TeamServiceState) GetServiceId() int64 {
+	if x != nil {
+		return x.ServiceId
+	}
+	return 0
+}
+
+func (x *TeamServiceState) GetChecksTotal() int64 {
+	if x != nil {
+		return x.ChecksTotal
+	}
+	return 0
+}
+
+func (x *TeamServiceState) GetChecksPassed() int64 {
+	if x != nil {
+		return x.ChecksPassed
+	}
+	return 0
+}
+
+func (x *TeamServiceState) GetCheckStatuses() []*TeamServiceState_CheckStatus {
+	if x != nil {
+		return x.CheckStatuses
+	}
+	return nil
+}
+
+type State struct {
+	state             protoimpl.MessageState `protogen:"open.v1"`
+	TeamServiceStates []*TeamServiceState    `protobuf:"bytes,1,rep,name=team_service_states,json=teamServiceStates,proto3" json:"team_service_states,omitempty"`
+	unknownFields     protoimpl.UnknownFields
+	sizeCache         protoimpl.SizeCache
+}
+
+func (x *State) Reset() {
+	*x = State{}
+	mi := &file_slac_slac_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *State) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*State) ProtoMessage() {}
+
+func (x *State) ProtoReflect() protoreflect.Message {
+	mi := &file_slac_slac_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use State.ProtoReflect.Descriptor instead.
+func (*State) Descriptor() ([]byte, []int) {
+	return file_slac_slac_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *State) GetTeamServiceStates() []*TeamServiceState {
+	if x != nil {
+		return x.TeamServiceStates
+	}
+	return nil
+}
+
+type GetStateRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetStateRequest) Reset() {
+	*x = GetStateRequest{}
+	mi := &file_slac_slac_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetStateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetStateRequest) ProtoMessage() {}
+
+func (x *GetStateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_slac_slac_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetStateRequest.ProtoReflect.Descriptor instead.
+func (*GetStateRequest) Descriptor() ([]byte, []int) {
+	return file_slac_slac_proto_rawDescGZIP(), []int{2}
+}
+
+type GetStateResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	State         *State                 `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetStateResponse) Reset() {
+	*x = GetStateResponse{}
+	mi := &file_slac_slac_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetStateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetStateResponse) ProtoMessage() {}
+
+func (x *GetStateResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_slac_slac_proto_msgTypes[3]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetStateResponse.ProtoReflect.Descriptor instead.
+func (*GetStateResponse) Descriptor() ([]byte, []int) {
+	return file_slac_slac_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *GetStateResponse) GetState() *State {
+	if x != nil {
+		return x.State
+	}
+	return nil
+}
+
+type TeamServiceState_CheckStatus struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Status        checker.Status         `protobuf:"varint,1,opt,name=status,proto3,enum=checker.Status" json:"status,omitempty"`
+	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TeamServiceState_CheckStatus) Reset() {
+	*x = TeamServiceState_CheckStatus{}
+	mi := &file_slac_slac_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TeamServiceState_CheckStatus) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TeamServiceState_CheckStatus) ProtoMessage() {}
+
+func (x *TeamServiceState_CheckStatus) ProtoReflect() protoreflect.Message {
+	mi := &file_slac_slac_proto_msgTypes[4]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TeamServiceState_CheckStatus.ProtoReflect.Descriptor instead.
+func (*TeamServiceState_CheckStatus) Descriptor() ([]byte, []int) {
+	return file_slac_slac_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *TeamServiceState_CheckStatus) GetStatus() checker.Status {
+	if x != nil {
+		return x.Status
+	}
+	return checker.Status(0)
+}
+
+func (x *TeamServiceState_CheckStatus) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+var File_slac_slac_proto protoreflect.FileDescriptor
+
+const file_slac_slac_proto_rawDesc = "" +
+	"\n" +
+	"\x0fslac/slac.proto\x12\x04slac\x1a\x15checker/checker.proto\"\xaf\x02\n" +
+	"\x10TeamServiceState\x12\x17\n" +
+	"\ateam_id\x18\x01 \x01(\x03R\x06teamId\x12\x1d\n" +
+	"\n" +
+	"service_id\x18\x02 \x01(\x03R\tserviceId\x12!\n" +
+	"\fchecks_total\x18\x03 \x01(\x03R\vchecksTotal\x12#\n" +
+	"\rchecks_passed\x18\x04 \x01(\x03R\fchecksPassed\x12I\n" +
+	"\x0echeck_statuses\x18\x05 \x03(\v2\".slac.TeamServiceState.CheckStatusR\rcheckStatuses\x1aP\n" +
+	"\vCheckStatus\x12'\n" +
+	"\x06status\x18\x01 \x01(\x0e2\x0f.checker.StatusR\x06status\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\"O\n" +
+	"\x05State\x12F\n" +
+	"\x13team_service_states\x18\x01 \x03(\v2\x16.slac.TeamServiceStateR\x11teamServiceStates\"\x11\n" +
+	"\x0fGetStateRequest\"5\n" +
+	"\x10GetStateResponse\x12!\n" +
+	"\x05state\x18\x01 \x01(\v2\v.slac.StateR\x05stateBs\n" +
+	"\bcom.slacB\tSlacProtoP\x01Z,github.com/c4t-but-s4d/fastad/pkg/proto/slac\xa2\x02\x03SXX\xaa\x02\x04Slac\xca\x02\x04Slac\xe2\x02\x10Slac\\GPBMetadata\xea\x02\x04Slacb\x06proto3"
+
+var (
+	file_slac_slac_proto_rawDescOnce sync.Once
+	file_slac_slac_proto_rawDescData []byte
+)
+
+func file_slac_slac_proto_rawDescGZIP() []byte {
+	file_slac_slac_proto_rawDescOnce.Do(func() {
+		file_slac_slac_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_slac_slac_proto_rawDesc), len(file_slac_slac_proto_rawDesc)))
+	})
+	return file_slac_slac_proto_rawDescData
+}
+
+var file_slac_slac_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_slac_slac_proto_goTypes = []any{
+	(*TeamServiceState)(nil),             // 0: slac.TeamServiceState
+	(*State)(nil),                        // 1: slac.State
+	(*GetStateRequest)(nil),              // 2: slac.GetStateRequest
+	(*GetStateResponse)(nil),             // 3: slac.GetStateResponse
+	(*TeamServiceState_CheckStatus)(nil), // 4: slac.TeamServiceState.CheckStatus
+	(checker.Status)(0),                  // 5: checker.Status
+}
+var file_slac_slac_proto_depIdxs = []int32{
+	4, // 0: slac.TeamServiceState.check_statuses:type_name -> slac.TeamServiceState.CheckStatus
+	0, // 1: slac.State.team_service_states:type_name -> slac.TeamServiceState
+	1, // 2: slac.GetStateResponse.state:type_name -> slac.State
+	5, // 3: slac.TeamServiceState.CheckStatus.status:type_name -> checker.Status
+	4, // [4:4] is the sub-list for method output_type
+	4, // [4:4] is the sub-list for method input_type
+	4, // [4:4] is the sub-list for extension type_name
+	4, // [4:4] is the sub-list for extension extendee
+	0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_slac_slac_proto_init() }
+func file_slac_slac_proto_init() {
+	if File_slac_slac_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_slac_slac_proto_rawDesc), len(file_slac_slac_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   5,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_slac_slac_proto_goTypes,
+		DependencyIndexes: file_slac_slac_proto_depIdxs,
+		MessageInfos:      file_slac_slac_proto_msgTypes,
+	}.Build()
+	File_slac_slac_proto = out.File
+	file_slac_slac_proto_goTypes = nil
+	file_slac_slac_proto_depIdxs = nil
+}
diff --git a/pkg/proto/slac/slac_service.pb.go b/pkg/proto/slac/slac_service.pb.go
new file mode 100644
index 0000000..f947281
--- /dev/null
+++ b/pkg/proto/slac/slac_service.pb.go
@@ -0,0 +1,68 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        (unknown)
+// source: slac/slac_service.proto
+
+package slac
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+var File_slac_slac_service_proto protoreflect.FileDescriptor
+
+const file_slac_slac_service_proto_rawDesc = "" +
+	"\n" +
+	"\x17slac/slac_service.proto\x12\x04slac\x1a\x0fslac/slac.proto2H\n" +
+	"\vSlacService\x129\n" +
+	"\bGetState\x12\x15.slac.GetStateRequest\x1a\x16.slac.GetStateResponseBz\n" +
+	"\bcom.slacB\x10SlacServiceProtoP\x01Z,github.com/c4t-but-s4d/fastad/pkg/proto/slac\xa2\x02\x03SXX\xaa\x02\x04Slac\xca\x02\x04Slac\xe2\x02\x10Slac\\GPBMetadata\xea\x02\x04Slacb\x06proto3"
+
+var file_slac_slac_service_proto_goTypes = []any{
+	(*GetStateRequest)(nil),  // 0: slac.GetStateRequest
+	(*GetStateResponse)(nil), // 1: slac.GetStateResponse
+}
+var file_slac_slac_service_proto_depIdxs = []int32{
+	0, // 0: slac.SlacService.GetState:input_type -> slac.GetStateRequest
+	1, // 1: slac.SlacService.GetState:output_type -> slac.GetStateResponse
+	1, // [1:2] is the sub-list for method output_type
+	0, // [0:1] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_slac_slac_service_proto_init() }
+func file_slac_slac_service_proto_init() {
+	if File_slac_slac_service_proto != nil {
+		return
+	}
+	file_slac_slac_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_slac_slac_service_proto_rawDesc), len(file_slac_slac_service_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_slac_slac_service_proto_goTypes,
+		DependencyIndexes: file_slac_slac_service_proto_depIdxs,
+	}.Build()
+	File_slac_slac_service_proto = out.File
+	file_slac_slac_service_proto_goTypes = nil
+	file_slac_slac_service_proto_depIdxs = nil
+}
diff --git a/pkg/proto/slac/slac_service_grpc.pb.go b/pkg/proto/slac/slac_service_grpc.pb.go
new file mode 100644
index 0000000..ab57877
--- /dev/null
+++ b/pkg/proto/slac/slac_service_grpc.pb.go
@@ -0,0 +1,121 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.6.0
+// - protoc             (unknown)
+// source: slac/slac_service.proto
+
+package slac
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	SlacService_GetState_FullMethodName = "/slac.SlacService/GetState"
+)
+
+// SlacServiceClient is the client API for SlacService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type SlacServiceClient interface {
+	GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error)
+}
+
+type slacServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewSlacServiceClient(cc grpc.ClientConnInterface) SlacServiceClient {
+	return &slacServiceClient{cc}
+}
+
+func (c *slacServiceClient) GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(GetStateResponse)
+	err := c.cc.Invoke(ctx, SlacService_GetState_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// SlacServiceServer is the server API for SlacService service.
+// All implementations must embed UnimplementedSlacServiceServer
+// for forward compatibility.
+type SlacServiceServer interface {
+	GetState(context.Context, *GetStateRequest) (*GetStateResponse, error)
+	mustEmbedUnimplementedSlacServiceServer()
+}
+
+// UnimplementedSlacServiceServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedSlacServiceServer struct{}
+
+func (UnimplementedSlacServiceServer) GetState(context.Context, *GetStateRequest) (*GetStateResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetState not implemented")
+}
+func (UnimplementedSlacServiceServer) mustEmbedUnimplementedSlacServiceServer() {}
+func (UnimplementedSlacServiceServer) testEmbeddedByValue()                     {}
+
+// UnsafeSlacServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to SlacServiceServer will
+// result in compilation errors.
+type UnsafeSlacServiceServer interface {
+	mustEmbedUnimplementedSlacServiceServer()
+}
+
+func RegisterSlacServiceServer(s grpc.ServiceRegistrar, srv SlacServiceServer) {
+	// If the following call panics, it indicates UnimplementedSlacServiceServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&SlacService_ServiceDesc, srv)
+}
+
+func _SlacService_GetState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetStateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SlacServiceServer).GetState(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: SlacService_GetState_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SlacServiceServer).GetState(ctx, req.(*GetStateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// SlacService_ServiceDesc is the grpc.ServiceDesc for SlacService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var SlacService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "slac.SlacService",
+	HandlerType: (*SlacServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetState",
+			Handler:    _SlacService_GetState_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "slac/slac_service.proto",
+}
diff --git a/pkg/proto/slac/slac_vtproto.pb.go b/pkg/proto/slac/slac_vtproto.pb.go
new file mode 100644
index 0000000..7d1d73f
--- /dev/null
+++ b/pkg/proto/slac/slac_vtproto.pb.go
@@ -0,0 +1,254 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.6.0
+// source: slac/slac.proto
+
+package slac
+
+import (
+	proto "google.golang.org/protobuf/proto"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (m *TeamServiceState_CheckStatus) CloneVT() *TeamServiceState_CheckStatus {
+	if m == nil {
+		return (*TeamServiceState_CheckStatus)(nil)
+	}
+	r := new(TeamServiceState_CheckStatus)
+	r.Status = m.Status
+	r.Message = m.Message
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *TeamServiceState_CheckStatus) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *TeamServiceState) CloneVT() *TeamServiceState {
+	if m == nil {
+		return (*TeamServiceState)(nil)
+	}
+	r := new(TeamServiceState)
+	r.TeamId = m.TeamId
+	r.ServiceId = m.ServiceId
+	r.ChecksTotal = m.ChecksTotal
+	r.ChecksPassed = m.ChecksPassed
+	if rhs := m.CheckStatuses; rhs != nil {
+		tmpContainer := make([]*TeamServiceState_CheckStatus, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.CheckStatuses = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *TeamServiceState) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *State) CloneVT() *State {
+	if m == nil {
+		return (*State)(nil)
+	}
+	r := new(State)
+	if rhs := m.TeamServiceStates; rhs != nil {
+		tmpContainer := make([]*TeamServiceState, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.TeamServiceStates = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *State) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *GetStateRequest) CloneVT() *GetStateRequest {
+	if m == nil {
+		return (*GetStateRequest)(nil)
+	}
+	r := new(GetStateRequest)
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *GetStateRequest) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *GetStateResponse) CloneVT() *GetStateResponse {
+	if m == nil {
+		return (*GetStateResponse)(nil)
+	}
+	r := new(GetStateResponse)
+	r.State = m.State.CloneVT()
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *GetStateResponse) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (this *TeamServiceState_CheckStatus) EqualVT(that *TeamServiceState_CheckStatus) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Status != that.Status {
+		return false
+	}
+	if this.Message != that.Message {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *TeamServiceState_CheckStatus) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*TeamServiceState_CheckStatus)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *TeamServiceState) EqualVT(that *TeamServiceState) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.TeamId != that.TeamId {
+		return false
+	}
+	if this.ServiceId != that.ServiceId {
+		return false
+	}
+	if this.ChecksTotal != that.ChecksTotal {
+		return false
+	}
+	if this.ChecksPassed != that.ChecksPassed {
+		return false
+	}
+	if len(this.CheckStatuses) != len(that.CheckStatuses) {
+		return false
+	}
+	for i, vx := range this.CheckStatuses {
+		vy := that.CheckStatuses[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &TeamServiceState_CheckStatus{}
+			}
+			if q == nil {
+				q = &TeamServiceState_CheckStatus{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *TeamServiceState) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*TeamServiceState)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *State) EqualVT(that *State) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.TeamServiceStates) != len(that.TeamServiceStates) {
+		return false
+	}
+	for i, vx := range this.TeamServiceStates {
+		vy := that.TeamServiceStates[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &TeamServiceState{}
+			}
+			if q == nil {
+				q = &TeamServiceState{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *State) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*State)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *GetStateRequest) EqualVT(that *GetStateRequest) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *GetStateRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*GetStateRequest)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+func (this *GetStateResponse) EqualVT(that *GetStateResponse) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if !this.State.EqualVT(that.State) {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *GetStateResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*GetStateResponse)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
diff --git a/pkg/stop/stop.go b/pkg/stop/stop.go
new file mode 100644
index 0000000..93e31aa
--- /dev/null
+++ b/pkg/stop/stop.go
@@ -0,0 +1,43 @@
+package stop
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+// SetupCtx returns two contexts: runCtx and shutdownCtx.
+// RunCtx is used to run the program until the first ^C (interrupt signal) is received.
+// ShutdownCtx is used to handle the shutdown process until the second ^C is received.
+func SetupCtx() (context.Context, context.Context, context.CancelFunc) {
+	runCtx, runCancel := context.WithCancel(context.Background())
+	shutdownCtx, shutdownCancel := context.WithCancel(context.Background())
+
+	ch := make(chan os.Signal, 2) //nolint:mnd // 2 is the number of signals we are interested in
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		select {
+		case <-ch:
+			runCancel()
+		case <-runCtx.Done():
+		}
+
+		if shutdownCtx.Err() == nil {
+			go func() {
+				select {
+				case <-ch:
+					shutdownCancel()
+				case <-shutdownCtx.Done():
+				}
+			}()
+		}
+	}()
+
+	return runCtx, shutdownCtx, func() {
+		shutdownCancel()
+		runCancel()
+		signal.Stop(ch)
+	}
+}
diff --git a/pkg/viperext/cobra.go b/pkg/viperext/cobra.go
new file mode 100644
index 0000000..033da58
--- /dev/null
+++ b/pkg/viperext/cobra.go
@@ -0,0 +1,28 @@
+package viperext
+
+import (
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
+	"go.uber.org/zap"
+)
+
+func RunBindCommandFlags(v *viper.Viper, cmd *cobra.Command) {
+	zap.L().Debug("binding command flags", zap.String("command", cmd.Name()))
+
+	cmd.Flags().VisitAll(func(f *pflag.Flag) {
+		normName := strings.ReplaceAll(f.Name, "-", "_")
+		if err := v.BindPFlag(normName, f); err != nil {
+			zap.L().Fatal("binding flag failed", zap.String("flag", f.Name), zap.Error(err))
+		}
+	})
+
+	cmd.PersistentFlags().VisitAll(func(f *pflag.Flag) {
+		normName := strings.ReplaceAll(f.Name, "-", "_")
+		if err := v.BindPFlag(normName, f); err != nil {
+			zap.L().Fatal("binding persistent flag failed", zap.String("flag", f.Name), zap.Error(err))
+		}
+	})
+}
diff --git a/pkg/viperext/cobra_test.go b/pkg/viperext/cobra_test.go
new file mode 100644
index 0000000..368ca7c
--- /dev/null
+++ b/pkg/viperext/cobra_test.go
@@ -0,0 +1,113 @@
+package viperext_test
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/c4t-but-s4d/fastad/pkg/viperext"
+)
+
+func TestRunBindCommandFlags(t *testing.T) {
+	t.Run("binds regular flags", func(t *testing.T) {
+		v := viper.New()
+		cmd := &cobra.Command{Use: "test"}
+		cmd.Flags().String("my-flag", "default", "test flag")
+
+		err := cmd.ParseFlags([]string{"--my-flag", "custom-value"})
+		require.NoError(t, err)
+
+		viperext.RunBindCommandFlags(v, cmd)
+
+		assert.Equal(t, "custom-value", v.GetString("my_flag"))
+	})
+
+	t.Run("binds persistent flags", func(t *testing.T) {
+		v := viper.New()
+		cmd := &cobra.Command{Use: "test"}
+		cmd.PersistentFlags().String("persistent-flag", "default", "test flag")
+
+		err := cmd.ParseFlags([]string{"--persistent-flag", "persistent-value"})
+		require.NoError(t, err)
+
+		viperext.RunBindCommandFlags(v, cmd)
+
+		assert.Equal(t, "persistent-value", v.GetString("persistent_flag"))
+	})
+
+	t.Run("normalizes flag names with dashes to underscores", func(t *testing.T) {
+		v := viper.New()
+		cmd := &cobra.Command{Use: "test"}
+		cmd.Flags().String("kebab-case-flag", "default", "test flag")
+
+		err := cmd.ParseFlags([]string{"--kebab-case-flag", "value"})
+		require.NoError(t, err)
+
+		viperext.RunBindCommandFlags(v, cmd)
+
+		assert.Equal(t, "value", v.GetString("kebab_case_flag"))
+	})
+
+	t.Run("binds multiple flags", func(t *testing.T) {
+		v := viper.New()
+		cmd := &cobra.Command{Use: "test"}
+		cmd.Flags().String("flag-one", "", "first flag")
+		cmd.Flags().Int("flag-two", 0, "second flag")
+		cmd.Flags().Bool("flag-three", false, "third flag")
+
+		err := cmd.ParseFlags([]string{
+			"--flag-one", "value1",
+			"--flag-two", "42",
+			"--flag-three",
+		})
+		require.NoError(t, err)
+
+		viperext.RunBindCommandFlags(v, cmd)
+
+		assert.Equal(t, "value1", v.GetString("flag_one"))
+		assert.Equal(t, 42, v.GetInt("flag_two"))
+		assert.True(t, v.GetBool("flag_three"))
+	})
+
+	t.Run("uses default values when flag not provided", func(t *testing.T) {
+		v := viper.New()
+		cmd := &cobra.Command{Use: "test"}
+		cmd.Flags().String("my-flag", "default-value", "test flag")
+
+		viperext.RunBindCommandFlags(v, cmd)
+
+		assert.Equal(t, "default-value", v.GetString("my_flag"))
+	})
+}
+
+func TestNewViper(t *testing.T) {
+	t.Run("creates viper with env prefix", func(t *testing.T) {
+		t.Setenv("TEST_PREFIX_MY_VAR", "env-value")
+
+		v, err := viperext.NewViper("TEST_PREFIX")
+		require.NoError(t, err)
+
+		assert.Equal(t, "env-value", v.GetString("my_var"))
+	})
+
+	t.Run("replaces dashes with underscores in env names", func(t *testing.T) {
+		t.Setenv("TEST_PREFIX_MY_DASHED_VAR", "dashed-value")
+
+		v, err := viperext.NewViper("TEST_PREFIX")
+		require.NoError(t, err)
+
+		assert.Equal(t, "dashed-value", v.GetString("my-dashed-var"))
+	})
+
+	t.Run("replaces dots with underscores in env names", func(t *testing.T) {
+		t.Setenv("TEST_PREFIX_MY_DOTTED_VAR", "dotted-value")
+
+		v, err := viperext.NewViper("TEST_PREFIX")
+		require.NoError(t, err)
+
+		assert.Equal(t, "dotted-value", v.GetString("my.dotted.var"))
+	})
+}
diff --git a/pkg/viperext/config.go b/pkg/viperext/config.go
new file mode 100644
index 0000000..8bf5487
--- /dev/null
+++ b/pkg/viperext/config.go
@@ -0,0 +1,27 @@
+package viperext
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
+)
+
+func NewViper(envPrefix string) (*viper.Viper, error) {
+	v := viper.NewWithOptions(viper.ExperimentalBindStruct())
+
+	if err := v.BindPFlags(pflag.CommandLine); err != nil {
+		return nil, fmt.Errorf("binding pflags: %w", err)
+	}
+	v.SetEnvPrefix(envPrefix)
+	v.AutomaticEnv()
+	v.SetEnvKeyReplacer(
+		strings.NewReplacer(
+			"-", "_",
+			".", "_",
+		),
+	)
+
+	return v, nil
+}
diff --git a/pkg/viperext/nested_flags_test.go b/pkg/viperext/nested_flags_test.go
new file mode 100644
index 0000000..92a927f
--- /dev/null
+++ b/pkg/viperext/nested_flags_test.go
@@ -0,0 +1,261 @@
+package viperext_test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/c4t-but-s4d/fastad/pkg/viperext"
+)
+
+func TestMain(m *testing.M) {
+	cobra.EnableTraverseRunHooks = true
+	os.Exit(m.Run())
+}
+
+func TestNestedSubcommandsFlagBinding(t *testing.T) {
+	v := viper.New()
+
+	var capturedSettings map[string]any
+	var preRunOrder []string
+
+	rootCmd := &cobra.Command{
+		Use: "root",
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			preRunOrder = append(preRunOrder, "root")
+			viperext.RunBindCommandFlags(v, cmd)
+			return nil
+		},
+	}
+	rootCmd.PersistentFlags().String("root-flag", "root-default", "Root persistent flag")
+	rootCmd.PersistentFlags().Bool("verbose", false, "Verbose output")
+
+	level1Cmd := &cobra.Command{
+		Use: "level1",
+		PersistentPreRunE: func(_ *cobra.Command, _ []string) error {
+			preRunOrder = append(preRunOrder, "level1")
+			return nil
+		},
+	}
+	level1Cmd.PersistentFlags().String("level1-flag", "level1-default", "Level1 persistent flag")
+	level1Cmd.PersistentFlags().Int("level1-count", 0, "Level1 count")
+
+	level2Cmd := &cobra.Command{
+		Use: "level2",
+		PersistentPreRunE: func(_ *cobra.Command, _ []string) error {
+			preRunOrder = append(preRunOrder, "level2")
+			return nil
+		},
+	}
+	level2Cmd.PersistentFlags().String("level2-flag", "level2-default", "Level2 persistent flag")
+
+	level3Cmd := &cobra.Command{
+		Use: "level3",
+		PreRunE: func(_ *cobra.Command, _ []string) error {
+			preRunOrder = append(preRunOrder, "level3-prerun")
+			return nil
+		},
+		RunE: func(_ *cobra.Command, _ []string) error {
+			preRunOrder = append(preRunOrder, "level3-run")
+			capturedSettings = v.AllSettings()
+			return nil
+		},
+	}
+	level3Cmd.Flags().String("level3-flag", "level3-default", "Level3 local flag")
+	level3Cmd.Flags().Bool("dry-run", false, "Dry run mode")
+
+	level2Cmd.AddCommand(level3Cmd)
+	level1Cmd.AddCommand(level2Cmd)
+	rootCmd.AddCommand(level1Cmd)
+
+	rootCmd.SetArgs([]string{
+		"level1", "level2", "level3",
+		"--root-flag", "custom-root",
+		"--verbose",
+		"--level1-flag", "custom-level1",
+		"--level1-count", "42",
+		"--level2-flag", "custom-level2",
+		"--level3-flag", "custom-level3",
+		"--dry-run",
+	})
+
+	err := rootCmd.ExecuteContext(context.Background())
+	require.NoError(t, err)
+
+	t.Run("all hooks executed in order", func(t *testing.T) {
+		assert.Equal(t, []string{
+			"root",
+			"level1",
+			"level2",
+			"level3-prerun",
+			"level3-run",
+		}, preRunOrder)
+	})
+
+	t.Run("root persistent flags bound", func(t *testing.T) {
+		assert.Equal(t, "custom-root", capturedSettings["root_flag"])
+		assert.Equal(t, true, capturedSettings["verbose"])
+	})
+
+	t.Run("level1 persistent flags bound", func(t *testing.T) {
+		assert.Equal(t, "custom-level1", capturedSettings["level1_flag"])
+		assert.Equal(t, 42, capturedSettings["level1_count"])
+	})
+
+	t.Run("level2 persistent flags bound", func(t *testing.T) {
+		assert.Equal(t, "custom-level2", capturedSettings["level2_flag"])
+	})
+
+	t.Run("level3 local flags bound", func(t *testing.T) {
+		assert.Equal(t, "custom-level3", capturedSettings["level3_flag"])
+		assert.Equal(t, true, capturedSettings["dry_run"])
+	})
+
+	t.Run("viper has all expected keys", func(t *testing.T) {
+		expectedKeys := []string{
+			"root_flag",
+			"verbose",
+			"level1_flag",
+			"level1_count",
+			"level2_flag",
+			"level3_flag",
+			"dry_run",
+		}
+		for _, key := range expectedKeys {
+			_, exists := capturedSettings[key]
+			assert.True(t, exists, "expected key %q to exist in viper settings", key)
+		}
+	})
+}
+
+func TestNestedSubcommandsWithDefaults(t *testing.T) {
+	v := viper.New()
+
+	var capturedSettings map[string]any
+
+	rootCmd := &cobra.Command{
+		Use: "root",
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			viperext.RunBindCommandFlags(v, cmd)
+			return nil
+		},
+	}
+	rootCmd.PersistentFlags().String("root-flag", "root-default", "Root flag")
+
+	childCmd := &cobra.Command{
+		Use: "child",
+		RunE: func(_ *cobra.Command, _ []string) error {
+			capturedSettings = v.AllSettings()
+			return nil
+		},
+	}
+	childCmd.Flags().String("child-flag", "child-default", "Child flag")
+
+	rootCmd.AddCommand(childCmd)
+
+	rootCmd.SetArgs([]string{"child"})
+
+	err := rootCmd.ExecuteContext(context.Background())
+	require.NoError(t, err)
+
+	t.Run("default values are captured", func(t *testing.T) {
+		assert.Equal(t, "root-default", capturedSettings["root_flag"])
+		assert.Equal(t, "child-default", capturedSettings["child_flag"])
+	})
+}
+
+func TestNestedSubcommandsWithEnvOverride(t *testing.T) {
+	v := viper.New()
+	v.SetEnvPrefix("TEST")
+	v.AutomaticEnv()
+
+	t.Setenv("TEST_ROOT_FLAG", "env-value")
+
+	var capturedSettings map[string]any
+
+	rootCmd := &cobra.Command{
+		Use: "root",
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			viperext.RunBindCommandFlags(v, cmd)
+			return nil
+		},
+	}
+	rootCmd.PersistentFlags().String("root-flag", "default", "Root flag")
+
+	childCmd := &cobra.Command{
+		Use: "child",
+		RunE: func(_ *cobra.Command, _ []string) error {
+			capturedSettings = v.AllSettings()
+			return nil
+		},
+	}
+
+	rootCmd.AddCommand(childCmd)
+	rootCmd.SetArgs([]string{"child"})
+
+	err := rootCmd.ExecuteContext(context.Background())
+	require.NoError(t, err)
+
+	t.Run("env variable overrides default", func(t *testing.T) {
+		assert.Equal(t, "env-value", capturedSettings["root_flag"])
+	})
+}
+
+func TestIntermediateCommandExecution(t *testing.T) {
+	v := viper.New()
+
+	var capturedSettings map[string]any
+	var executedCommand string
+
+	rootCmd := &cobra.Command{
+		Use: "root",
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			viperext.RunBindCommandFlags(v, cmd)
+			return nil
+		},
+	}
+	rootCmd.PersistentFlags().String("root-flag", "root-default", "Root flag")
+
+	level1Cmd := &cobra.Command{
+		Use: "level1",
+		RunE: func(_ *cobra.Command, _ []string) error {
+			executedCommand = "level1"
+			capturedSettings = v.AllSettings()
+			return nil
+		},
+	}
+	level1Cmd.PersistentFlags().String("level1-flag", "level1-default", "Level1 flag")
+
+	level2Cmd := &cobra.Command{
+		Use: "level2",
+		RunE: func(_ *cobra.Command, _ []string) error {
+			executedCommand = "level2"
+			capturedSettings = v.AllSettings()
+			return nil
+		},
+	}
+	level2Cmd.Flags().String("level2-flag", "level2-default", "Level2 flag")
+
+	level1Cmd.AddCommand(level2Cmd)
+	rootCmd.AddCommand(level1Cmd)
+
+	t.Run("executing intermediate command binds its flags", func(t *testing.T) {
+		v = viper.New()
+		capturedSettings = nil
+
+		rootCmd.SetArgs([]string{"level1", "--root-flag", "r", "--level1-flag", "l1"})
+		err := rootCmd.ExecuteContext(context.Background())
+		require.NoError(t, err)
+
+		assert.Equal(t, "level1", executedCommand)
+		assert.Equal(t, "r", capturedSettings["root_flag"])
+		assert.Equal(t, "l1", capturedSettings["level1_flag"])
+		_, hasLevel2 := capturedSettings["level2_flag"]
+		assert.False(t, hasLevel2, "level2 flag should not be bound when executing level1")
+	})
+}
diff --git a/proto/board/.keep b/proto/board/.keep
deleted file mode 100644
index e69de29..0000000
diff --git a/proto/buf.gen.yaml b/proto/buf.gen.yaml
index a5eb0df..72cfb16 100644
--- a/proto/buf.gen.yaml
+++ b/proto/buf.gen.yaml
@@ -1,18 +1,31 @@
-version: v1
+version: v2
 managed:
   enabled: true
-  go_package_prefix:
-    default: proto
+  override:
+  - file_option: go_package_prefix
+    value: "github.com/c4t-but-s4d/fastad/pkg/proto"
 plugins:
-  - remote: buf.build/protocolbuffers/plugins/go
-    out: ../pkg
-  - remote: buf.build/grpc/plugins/go
-    out: ../pkg
-  - remote: buf.build/stephenh/plugins/ts-proto
-    out: ../front/src/proto
-    opt:
-      - ts_proto_opt=env=node
-      - ts_proto_opt=oneof=unions
-      - ts_proto_opt=unrecognizedEnum=false
-      - ts_proto_opt=enumsAsLiterals=true
-      - ts_proto_opt=outputServices=nice-grpc,outputServices=generic-definitions
+- remote: buf.build/protocolbuffers/go
+  out: ../pkg/proto
+  opt:
+    - paths=source_relative
+- remote: buf.build/grpc/go
+  out: ../pkg/proto
+  opt:
+    - paths=source_relative
+- remote: buf.build/community/planetscale-vtprotobuf:v0.6.0
+  out: ../pkg/proto
+  opt:
+    - paths=source_relative
+    - features=clone+equal
+- remote: buf.build/community/stephenh-ts-proto
+  out: ../front/src/proto
+  opt:
+    - env=browser
+    - oneof=unions
+    - unrecognizedEnum=false
+    - enumsAsLiterals=true
+    - outputServices=false
+    - useAsyncIterable=true
+    - esModuleInterop=true
+    - forceLong=string
diff --git a/proto/buf.yaml b/proto/buf.yaml
index db7f5f8..4e11f82 100644
--- a/proto/buf.yaml
+++ b/proto/buf.yaml
@@ -1,9 +1,14 @@
-version: v1
+version: v2
+lint:
+  use:
+  - STANDARD
+  except:
+  - FIELD_NOT_REQUIRED
+  - PACKAGE_NO_IMPORT_CYCLE
+  - PACKAGE_VERSION_SUFFIX
+  disallow_comment_ignores: true
 breaking:
   use:
     - WIRE_JSON
-lint:
-  use:
-    - DEFAULT
   except:
-    - PACKAGE_VERSION_SUFFIX
+  - FIELD_SAME_DEFAULT
diff --git a/proto/checker/checker.proto b/proto/checker/checker.proto
new file mode 100644
index 0000000..b3dd663
--- /dev/null
+++ b/proto/checker/checker.proto
@@ -0,0 +1,43 @@
+syntax = "proto3";
+
+package checker;
+
+import "google/protobuf/timestamp.proto";
+
+enum Action {
+  ACTION_UNSPECIFIED = 0;
+  ACTION_CHECK = 1;
+  ACTION_PUT = 2;
+  ACTION_GET = 3;
+}
+
+enum Status {
+  STATUS_UNSPECIFIED = 0;
+  STATUS_UP = 1;
+  STATUS_MUMBLE = 2;
+  STATUS_CORRUPT = 3;
+  STATUS_DOWN = 4;
+  STATUS_CHECK_FAILED = 5;
+}
+
+enum Type {
+  TYPE_UNSPECIFIED = 0;
+  TYPE_LEGACY = 1;
+}
+
+message Execution {
+  message Batch {
+    repeated Execution executions = 1;
+  }
+
+  int64 team_id = 1;
+  int64 service_id = 2;
+  Action action = 3;
+  Status status = 4;
+
+  string public = 5;
+  string private = 6;
+  string command = 7;
+
+  google.protobuf.Timestamp created_at = 8;
+}
diff --git a/proto/data/game_state/game_state.proto b/proto/data/game_state/game_state.proto
new file mode 100644
index 0000000..0f69bd4
--- /dev/null
+++ b/proto/data/game_state/game_state.proto
@@ -0,0 +1,91 @@
+syntax = "proto3";
+
+package data.game_state;
+
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/duration.proto";
+
+import "data/version/version.proto";
+
+enum GameStatus {
+  GAME_STATUS_UNSPECIFIED = 0;
+  GAME_STATUS_NOT_STARTED = 1;
+  GAME_STATUS_RUNNING = 2;
+  GAME_STATUS_PAUSED = 3;
+  GAME_STATUS_FINISHED = 4;
+}
+
+message GameState {
+  google.protobuf.Timestamp start_time = 1;
+  google.protobuf.Timestamp end_time = 2;
+  uint64 total_rounds = 3;
+
+  GameStatus status = 4;
+
+  uint64 flag_lifetime_rounds = 5;
+  google.protobuf.Duration round_duration = 6;
+
+  uint64 running_round = 7;
+  google.protobuf.Timestamp running_round_start = 8;
+
+  double hardness = 9;
+  bool inflation = 10;
+}
+
+message GetRequest {
+  data.version.Version version = 1;
+}
+
+message GetResponse {
+  data.game_state.GameState game_state = 1;
+  data.version.Version version = 2;
+}
+
+message UpdateRequest {
+  google.protobuf.Timestamp start_time = 1;
+
+  // Zero time means no end time.
+  google.protobuf.Timestamp end_time = 2;
+
+  optional uint64 total_rounds = 3;
+
+  GameStatus status = 4;
+
+  optional uint64 flag_lifetime_rounds = 5;
+  google.protobuf.Duration round_duration = 6;
+
+  optional double hardness = 7;
+  optional bool inflation = 8;
+}
+
+message UpdateResponse {
+  data.game_state.GameState game_state = 1;
+  data.version.Version version = 2;
+}
+
+message UpdateRoundRequest {
+  uint64 running_round = 1;
+  google.protobuf.Timestamp running_round_start = 2;
+}
+
+message UpdateRoundResponse {
+  data.game_state.GameState game_state = 1;
+  data.version.Version version = 2;
+}
+
+message FinishGameRequest {
+}
+
+message FinishGameResponse {
+  data.game_state.GameState game_state = 1;
+  data.version.Version version = 2;
+}
+
+message CreateRequest {
+  GameState game_state = 1;
+}
+
+message CreateResponse {
+  data.game_state.GameState game_state = 1;
+  data.version.Version version = 2;
+}
diff --git a/proto/data/game_state/game_state_service.proto b/proto/data/game_state/game_state_service.proto
new file mode 100644
index 0000000..618babe
--- /dev/null
+++ b/proto/data/game_state/game_state_service.proto
@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package data.game_state;
+
+import "data/game_state/game_state.proto";
+
+service GameStateService {
+    rpc Get(data.game_state.GetRequest) returns (data.game_state.GetResponse);
+
+    rpc Create(data.game_state.CreateRequest) returns (data.game_state.CreateResponse);
+
+    rpc Update(data.game_state.UpdateRequest) returns (data.game_state.UpdateResponse);
+
+    rpc UpdateRound(data.game_state.UpdateRoundRequest) returns (data.game_state.UpdateRoundResponse);
+
+    rpc FinishGame(data.game_state.FinishGameRequest) returns (data.game_state.FinishGameResponse);
+}
diff --git a/proto/data/services/services.proto b/proto/data/services/services.proto
new file mode 100644
index 0000000..78f7fe4
--- /dev/null
+++ b/proto/data/services/services.proto
@@ -0,0 +1,64 @@
+syntax = "proto3";
+
+package data.services;
+
+import "google/protobuf/duration.proto";
+
+import "checker/checker.proto";
+import "data/version/version.proto";
+
+message Service {
+  message Batch {
+    repeated Service services = 1;
+  }
+
+  message Checker {
+    message Action {
+      checker.Action action = 1;
+      google.protobuf.Duration timeout = 2;
+      int64 run_count = 3;
+    }
+
+    checker.Type type = 1;
+    string path = 2;
+
+    google.protobuf.Duration default_timeout = 3;
+    repeated Action actions = 4;
+  }
+
+  int64 id = 1;
+  string name = 2;
+
+  data.services.Service.Checker checker = 3;
+
+  double default_score = 4;
+
+  bool disabled = 5;
+}
+
+message ListRequest {
+  data.version.Version version = 1;
+}
+
+message ListResponse {
+  repeated Service services = 1;
+  data.version.Version version = 2;
+}
+
+message CreateBatchRequest {
+  repeated Service services = 1;
+}
+
+message CreateBatchResponse {
+  repeated Service services = 1;
+}
+
+message UpdateRequest {
+  int64 id = 1;
+  optional bool disabled = 2;
+}
+
+message UpdateResponse {
+  Service service = 1;
+  data.version.Version version = 2;
+}
diff --git a/proto/data/services/services_service.proto b/proto/data/services/services_service.proto
new file mode 100644
index 0000000..f6b592c
--- /dev/null
+++ b/proto/data/services/services_service.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+package data.services;
+
+import "data/services/services.proto";
+
+service ServicesService {
+    rpc List(data.services.ListRequest) returns (data.services.ListResponse);
+
+    rpc CreateBatch(data.services.CreateBatchRequest) returns (data.services.CreateBatchResponse);
+
+    rpc Update(data.services.UpdateRequest) returns (data.services.UpdateResponse);
+}
diff --git a/proto/data/teams/teams.proto b/proto/data/teams/teams.proto
new file mode 100644
index 0000000..35c71e0
--- /dev/null
+++ b/proto/data/teams/teams.proto
@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package data.teams;
+
+import "data/version/version.proto";
+
+message Team {
+  message Batch {
+    repeated Team teams = 1;
+  }
+
+  int64 id = 1;
+  string name = 2;
+  string address = 3;
+  string token = 4;
+  map<string, string> labels = 5;
+  string avatar_url = 6;
+}
+
+message ListRequest {
+  data.version.Version version = 1;
+}
+
+message ListResponse {
+  repeated Team teams = 1;
+  data.version.Version version = 2;
+}
+
+message CreateBatchRequest {
+  repeated Team teams = 1;
+}
+
+message CreateBatchResponse {
+  repeated Team teams = 1;
+}
+
+message UpdateRequest {
+  int64 id = 1;
+  string name = 2;
+  string address = 3;
+  string token = 4;
+  string avatar_url = 5;
+}
+
+message UpdateResponse {
+  Team team = 1;
+  data.version.Version version = 2;
+}
diff --git a/proto/data/teams/teams_service.proto b/proto/data/teams/teams_service.proto
new file mode 100644
index 0000000..b11e21e
--- /dev/null
+++ b/proto/data/teams/teams_service.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+package data.teams;
+
+import "data/teams/teams.proto";
+
+service TeamsService {
+    rpc List(data.teams.ListRequest) returns (data.teams.ListResponse);
+
+    rpc CreateBatch(data.teams.CreateBatchRequest) returns (data.teams.CreateBatchResponse);
+
+    rpc Update(data.teams.UpdateRequest) returns (data.teams.UpdateResponse);
+}
diff --git a/proto/data/version/version.proto b/proto/data/version/version.proto
new file mode 100644
index 0000000..5e5eb74
--- /dev/null
+++ b/proto/data/version/version.proto
@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package data.version;
+
+message Version {
+  int64 version = 1;
+}
diff --git a/proto/pinger/pinger.proto b/proto/pinger/pinger.proto
index 9988f3d..faeb4c9 100644
--- a/proto/pinger/pinger.proto
+++ b/proto/pinger/pinger.proto
@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package pinger;
-option go_package = "github.com/c4t-but-s4d/fastad/pkg/proto/pinger";
 
 message PingRequest {}
 
diff --git a/proto/pinger/pinger_service.proto b/proto/pinger/pinger_service.proto
index ef27549..6e6f642 100644
--- a/proto/pinger/pinger_service.proto
+++ b/proto/pinger/pinger_service.proto
@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 package pinger;
-option go_package = "github.com/c4t-but-s4d/fastad/pkg/proto/pinger";
 
 import "pinger/pinger.proto";
 
diff --git a/proto/receiver/receiver.proto b/proto/receiver/receiver.proto
index f07c550..9a2beb2 100644
--- a/proto/receiver/receiver.proto
+++ b/proto/receiver/receiver.proto
@@ -1,29 +1,63 @@
 syntax = "proto3";
 
 package receiver;
-option go_package = "github.com/c4t-but-s4d/fastad/pkg/proto/receiver";
 
 message SubmitFlagsRequest {
-    repeated string flags = 1;
+  repeated string flags = 1;
+  string team_token = 2;
 }
 
 message FlagResponse {
-    enum Verdict {
-        VERDICT_UNSPECIFIED = 0;
-        VERDICT_ACCEPTED = 1;
-        VERDICT_OWN = 2;
-        VERDICT_OLD = 3;
-        VERDICT_INVALID = 4;
-    }
-
-    string flag = 1;
-    FlagResponse.Verdict verdict = 2;
-    string message = 3;
-    double flag_points = 4;
-
-    // Next: 5
+  enum Verdict {
+    VERDICT_UNSPECIFIED = 0;
+    VERDICT_ACCEPTED = 1;
+    VERDICT_OWN = 2;
+    VERDICT_OLD = 3;
+    VERDICT_INVALID = 4;
+    VERDICT_DUPLICATE = 5;
+    VERDICT_FLAG_NOT_READY = 6;
+  }
+
+  string flag = 1;
+  FlagResponse.Verdict verdict = 2;
+  string message = 3;
+  int64 victim_id = 4;
+  int64 service_id = 5;
+  double attacker_delta = 6;
+  double victim_delta = 7;
+}
+
+message AttackNotification {
+  message Batch {
+    repeated AttackNotification attacks = 1;
+  }
+
+  int64 attacker_id = 1;
+  int64 victim_id = 2;
+  int64 service_id = 3;
+  double attacker_delta = 4;
+  double victim_delta = 5;
+}
+
+message State {
+  message TeamService {
+    int64 team_id = 1;
+    int64 service_id = 2;
+    double points = 3;
+    int64 flags_stolen = 4;
+    int64 flags_lost = 5;
+  }
+
+  repeated TeamService team_services = 1;
 }
 
 message SubmitFlagsResponse {
-    repeated FlagResponse responses = 1;
+  repeated FlagResponse responses = 1;
+}
+
+message GetStateRequest {
+}
+
+message GetStateResponse {
+  State state = 1;
 }
diff --git a/proto/receiver/receiver_service.proto b/proto/receiver/receiver_service.proto
index 5eaa3d4..c3c57dc 100644
--- a/proto/receiver/receiver_service.proto
+++ b/proto/receiver/receiver_service.proto
@@ -1,11 +1,11 @@
 syntax = "proto3";
 
 package receiver;
-option go_package = "github.com/c4t-but-s4d/fastad/pkg/proto/receiver";
 
 import "receiver/receiver.proto";
 
-// TODO: options.
 service ReceiverService {
-    rpc SubmitFlags(SubmitFlagsRequest) returns (SubmitFlagsResponse);
+  rpc SubmitFlags(SubmitFlagsRequest) returns (SubmitFlagsResponse);
+
+  rpc GetState(GetStateRequest) returns (GetStateResponse);
 }
diff --git a/proto/scoreboard/scoreboard.proto b/proto/scoreboard/scoreboard.proto
new file mode 100644
index 0000000..630d628
--- /dev/null
+++ b/proto/scoreboard/scoreboard.proto
@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+package scoreboard;
+
+import "slac/slac.proto";
+
+message Scoreboard {
+  message TeamServiceState {
+    int64 team_id = 1;
+    int64 service_id = 2;
+
+    // From slac.
+    int64 checks_total = 3;
+    int64 checks_passed = 4;
+    repeated slac.TeamServiceState.CheckStatus check_statuses = 5;
+
+    // From receiver.
+    double points = 6;
+    int64 flags_stolen = 7;
+    int64 flags_lost = 8;
+  }
+
+  repeated TeamServiceState team_service_states = 1;
+}
diff --git a/proto/slac/slac.proto b/proto/slac/slac.proto
new file mode 100644
index 0000000..b41e3d3
--- /dev/null
+++ b/proto/slac/slac.proto
@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package slac;
+
+import "checker/checker.proto";
+
+message TeamServiceState {
+  message CheckStatus {
+    checker.Status status = 1;
+    string message = 2;
+  }
+
+  int64 team_id = 1;
+  int64 service_id = 2;
+  int64 checks_total = 3;
+  int64 checks_passed = 4;
+  repeated CheckStatus check_statuses = 5;
+}
+
+message State {
+  repeated TeamServiceState team_service_states = 1;
+}
+
+message GetStateRequest {
+}
+
+message GetStateResponse {
+  State state = 1;
+}
diff --git a/proto/slac/slac_service.proto b/proto/slac/slac_service.proto
new file mode 100644
index 0000000..5bebb33
--- /dev/null
+++ b/proto/slac/slac_service.proto
@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+package slac;
+
+import "slac/slac.proto";
+
+service SlacService {
+  rpc GetState(GetStateRequest) returns (GetStateResponse);
+}
diff --git a/tests/e2e/e2e_production_test.go b/tests/e2e/e2e_production_test.go
new file mode 100644
index 0000000..28c9b4b
--- /dev/null
+++ b/tests/e2e/e2e_production_test.go
@@ -0,0 +1,50 @@
+//go:build e2e && e2e_production
+
+package e2e
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+func TestE2EProductionPreset(t *testing.T) {
+	sharedState := NewSharedTestState(t, "production")
+	defer sharedState.TearDown()
+
+	t.Run("TeamsSuite", func(t *testing.T) {
+		s := &TeamsSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("ServicesSuite", func(t *testing.T) {
+		s := &ServicesSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("GameStateSuite", func(t *testing.T) {
+		s := &GameStateSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("ScoreboardSuite", func(t *testing.T) {
+		s := &ScoreboardSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("FlagsSuite", func(t *testing.T) {
+		s := &FlagsSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("CentrifugeSuite", func(t *testing.T) {
+		s := &CentrifugeSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+}
diff --git a/tests/e2e/e2e_running_test.go b/tests/e2e/e2e_running_test.go
new file mode 100644
index 0000000..f66462e
--- /dev/null
+++ b/tests/e2e/e2e_running_test.go
@@ -0,0 +1,69 @@
+//go:build e2e_running
+
+package e2e
+
+import (
+	"io"
+	"net/http"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const defaultBaseURL = "http://localhost:8080"
+
+func TestE2EWithRunningGame(t *testing.T) {
+	baseURL := os.Getenv("E2E_BASE_URL")
+	if baseURL == "" {
+		baseURL = defaultBaseURL
+	}
+
+	t.Run("HealthCheck", func(t *testing.T) {
+		resp, err := http.Get(baseURL + "/healthcheck")
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+	})
+
+	t.Run("TeamsAPI", func(t *testing.T) {
+		resp, err := http.Get(baseURL + "/api/teams")
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, _ := io.ReadAll(resp.Body)
+		t.Logf("Teams: %s", string(body))
+	})
+
+	t.Run("ServicesAPI", func(t *testing.T) {
+		resp, err := http.Get(baseURL + "/api/services")
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, _ := io.ReadAll(resp.Body)
+		t.Logf("Services: %s", string(body))
+	})
+
+	t.Run("GameStateAPI", func(t *testing.T) {
+		resp, err := http.Get(baseURL + "/api/game")
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, _ := io.ReadAll(resp.Body)
+		t.Logf("Game State: %s", string(body))
+	})
+
+	t.Run("ScoreboardAPI", func(t *testing.T) {
+		resp, err := http.Get(baseURL + "/api/scoreboard")
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, _ := io.ReadAll(resp.Body)
+		t.Logf("Scoreboard: %s", string(body))
+	})
+}
diff --git a/tests/e2e/e2e_simple_test.go b/tests/e2e/e2e_simple_test.go
new file mode 100644
index 0000000..04dbdc5
--- /dev/null
+++ b/tests/e2e/e2e_simple_test.go
@@ -0,0 +1,50 @@
+//go:build e2e && e2e_simple
+
+package e2e
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+func TestE2ESimplePreset(t *testing.T) {
+	sharedState := NewSharedTestState(t, "simple")
+	defer sharedState.TearDown()
+
+	t.Run("TeamsSuite", func(t *testing.T) {
+		s := &TeamsSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("ServicesSuite", func(t *testing.T) {
+		s := &ServicesSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("GameStateSuite", func(t *testing.T) {
+		s := &GameStateSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("ScoreboardSuite", func(t *testing.T) {
+		s := &ScoreboardSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("FlagsSuite", func(t *testing.T) {
+		s := &FlagsSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+
+	t.Run("CentrifugeSuite", func(t *testing.T) {
+		s := &CentrifugeSuite{}
+		s.sharedState = sharedState
+		suite.Run(t, s)
+	})
+}
diff --git a/tests/e2e/fastad_test.yaml b/tests/e2e/fastad_test.yaml
new file mode 100644
index 0000000..325e466
--- /dev/null
+++ b/tests/e2e/fastad_test.yaml
@@ -0,0 +1,48 @@
+fastad:
+  listen_port: 8080
+  log_level: debug
+  intercom_token: "test-intercom-token-12345"
+
+admin:
+  username: admin
+  password: testpassword123
+
+game:
+  start_time: "2020-01-01T00:00:00Z"
+  round_duration: 10s
+  flag_lifetime_rounds: 5
+  hardness: 10.0
+  inflation: false
+  checkers_base_path: tests/service
+
+teams:
+  - name: Team Alpha
+    address: 10.60.1.1
+    labels:
+      country: US
+
+  - name: Team Beta
+    address: 10.60.1.2
+    labels:
+      country: DE
+
+  - name: Team Gamma
+    address: 10.60.1.3
+
+services:
+  - name: test_service
+    default_score: 2500.0
+    checker:
+      type: legacy
+      path: checker.py
+      default_timeout: 30s
+      actions:
+        check:
+          count: 1
+          timeout: 15s
+        put:
+          count: 1
+          timeout: 30s
+        get:
+          count: 1
+          timeout: 30s
diff --git a/tests/e2e/suite_base_test.go b/tests/e2e/suite_base_test.go
new file mode 100644
index 0000000..bfa02e5
--- /dev/null
+++ b/tests/e2e/suite_base_test.go
@@ -0,0 +1,524 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/dialect/pgdialect"
+	"github.com/uptrace/bun/driver/pgdriver"
+	"google.golang.org/grpc"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/c4t-but-s4d/fastad/internal/gameconfig"
+	"github.com/c4t-but-s4d/fastad/internal/models"
+	gamestateClient "github.com/c4t-but-s4d/fastad/pkg/clients/gamestate"
+	servicesClient "github.com/c4t-but-s4d/fastad/pkg/clients/services"
+	"github.com/c4t-but-s4d/fastad/pkg/grpcext"
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+	scoreboardpb "github.com/c4t-but-s4d/fastad/pkg/proto/scoreboard"
+)
+
+const (
+	baseURL      = "http://localhost:8080"
+	grpcAddress  = "localhost:8080" // gRPC is served on same port as HTTP (multiplexed via h2c)
+	testTimeout  = 5 * time.Minute
+	pollInterval = 2 * time.Second
+	dbDSN        = "postgres://fastad:fastad@localhost:5433/fastad?sslmode=disable"
+)
+
+type teamToken struct {
+	ID    int64  `json:"id"`
+	Name  string `json:"name"`
+	Token string `json:"token"`
+}
+
+type SharedTestState struct {
+	t          *testing.T
+	rootDir    string
+	preset     string
+	db         *bun.DB
+	grpcConn   *grpc.ClientConn
+	gsClient   *gamestateClient.Client
+	svcClient  *servicesClient.Client
+	teams      []*teamspb.Team
+	teamTokens []teamToken
+	services   []*servicespb.Service
+}
+
+func NewSharedTestState(t *testing.T, preset string) *SharedTestState {
+	s := &SharedTestState{
+		t:      t,
+		preset: preset,
+	}
+	s.rootDir = s.findRootDir()
+	s.initGame()
+	s.startGame()
+	s.waitForHealthy()
+	s.waitForGameRunning()
+	s.connectDB()
+	s.connectGRPC()
+	s.loadTeams()
+	s.loadTeamTokens()
+	s.loadServices()
+	return s
+}
+
+func (s *SharedTestState) TearDown() {
+	s.t.Log("Tearing down test environment...")
+
+	if s.grpcConn != nil {
+		if err := s.grpcConn.Close(); err != nil {
+			s.t.Logf("Warning: failed to close gRPC connection: %v", err)
+		}
+	}
+
+	if s.db != nil {
+		if err := s.db.Close(); err != nil {
+			s.t.Logf("Warning: failed to close DB: %v", err)
+		}
+	}
+
+	cmd := exec.Command("go", "run", "./cmd/fastad", "reset")
+	cmd.Dir = s.rootDir
+
+	if output, err := cmd.CombinedOutput(); err != nil {
+		s.t.Logf("Warning: failed to tear down: %v\nOutput: %s", err, output)
+	}
+}
+
+func (s *SharedTestState) findRootDir() string {
+	dir, err := os.Getwd()
+	require.NoError(s.t, err)
+
+	for {
+		if _, err := os.Stat(filepath.Join(dir, ".fastad_root")); err == nil {
+			return dir
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			s.t.Fatal("Could not find FastAD root directory")
+		}
+		dir = parent
+	}
+}
+
+func (s *SharedTestState) initGame() {
+	s.t.Log("Initializing game with preset:", s.preset)
+
+	testConfigPath := filepath.Join(s.rootDir, "tests", "e2e", "fastad_test.yaml")
+
+	cmd := exec.Command(
+		"go", "run", "./cmd/fastad",
+		"init",
+		"--game-config", testConfigPath,
+		"--preset", s.preset,
+		"--force",
+	)
+	cmd.Dir = s.rootDir
+	cmd.Env = append(os.Environ(), "FASTAD_LOG_LEVEL=debug")
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		s.t.Fatalf("Failed to initialize game: %v\nOutput: %s", err, output)
+	}
+	s.t.Log("Game initialized successfully")
+}
+
+func (s *SharedTestState) startGame() {
+	s.t.Log("Starting game services...")
+
+	cmd := exec.Command(
+		"go", "run", "./cmd/fastad",
+		"run",
+	)
+	cmd.Dir = s.rootDir
+	cmd.Env = append(os.Environ(), "FASTAD_LOG_LEVEL=debug")
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		s.t.Fatalf("Failed to start game: %v\nOutput: %s", err, output)
+	}
+	s.t.Log("Game started successfully")
+}
+
+func (s *SharedTestState) waitForHealthy() {
+	s.t.Log("Waiting for services to become healthy...")
+
+	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
+	defer cancel()
+
+	for {
+		select {
+		case <-ctx.Done():
+			s.t.Fatal("Timeout waiting for services to become healthy")
+		default:
+		}
+
+		resp, err := http.Get(baseURL + "/healthcheck")
+		if err == nil && resp.StatusCode == http.StatusOK {
+			resp.Body.Close()
+			s.t.Log("Services are healthy")
+			return
+		}
+		if resp != nil {
+			resp.Body.Close()
+		}
+
+		time.Sleep(pollInterval)
+	}
+}
+
+func (s *SharedTestState) waitForGameRunning() {
+	s.t.Log("Waiting for game to transition to RUNNING...")
+
+	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
+	defer cancel()
+
+	for {
+		select {
+		case <-ctx.Done():
+			s.t.Fatal("Timeout waiting for game to become RUNNING")
+		default:
+		}
+
+		resp, err := http.Get(baseURL + "/api/game")
+		if err == nil && resp.StatusCode == http.StatusOK {
+			body, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+
+			var gs gspb.GameState
+			if err := protojson.Unmarshal(body, &gs); err == nil {
+				if gs.GetStatus() == gspb.GameStatus_GAME_STATUS_RUNNING {
+					s.t.Log("Game is RUNNING")
+					return
+				}
+				s.t.Logf("Game status is %s, waiting...", gs.GetStatus())
+			}
+		}
+		if resp != nil {
+			resp.Body.Close()
+		}
+
+		time.Sleep(pollInterval)
+	}
+}
+
+func (s *SharedTestState) connectDB() {
+	s.t.Log("Connecting to database...")
+
+	sqlDB := sql.OpenDB(pgdriver.NewConnector(pgdriver.WithDSN(dbDSN)))
+	s.db = bun.NewDB(sqlDB, pgdialect.New())
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	if err := s.db.PingContext(ctx); err != nil {
+		s.t.Fatalf("Failed to connect to database: %v", err)
+	}
+
+	s.t.Log("Database connected successfully")
+}
+
+func (s *SharedTestState) connectGRPC() {
+	s.t.Log("Connecting to gRPC...")
+
+	cfg, err := gameconfig.ReadGeneratedConfig()
+	if err != nil {
+		s.t.Fatalf("Failed to read generated config: %v", err)
+	}
+
+	conn, err := grpcext.Dial(
+		grpcAddress,
+		"e2e-tests",
+		grpcext.AuthDialOptions(cfg.FastAD.IntercomToken)...,
+	)
+	if err != nil {
+		s.t.Fatalf("Failed to connect to gRPC: %v", err)
+	}
+	s.grpcConn = conn
+
+	s.gsClient = gamestateClient.NewClient(gspb.NewGameStateServiceClient(conn), "e2e-tests")
+	s.svcClient = servicesClient.NewClient(servicespb.NewServicesServiceClient(conn), "e2e-tests")
+
+	s.t.Log("gRPC connected successfully")
+}
+
+func (s *SharedTestState) loadTeams() {
+	s.t.Log("Loading teams...")
+
+	resp, err := http.Get(baseURL + "/api/teams")
+	require.NoError(s.t, err)
+	defer resp.Body.Close()
+
+	require.Equal(s.t, http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	require.NoError(s.t, err)
+
+	var teamsResp teamspb.Team_Batch
+	err = protojson.Unmarshal(body, &teamsResp)
+	require.NoError(s.t, err)
+
+	s.teams = teamsResp.GetTeams()
+	s.t.Logf("Loaded %d teams", len(s.teams))
+}
+
+func (s *SharedTestState) loadTeamTokens() {
+	s.t.Log("Loading team tokens...")
+
+	cmd := exec.Command("go", "run", "./cmd/fastad", "tokens", "--format", "json")
+	cmd.Dir = s.rootDir
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		s.t.Logf("Warning: Failed to get team tokens: %v\nStderr: %s", err, stderr.String())
+		return
+	}
+
+	if err := json.Unmarshal(stdout.Bytes(), &s.teamTokens); err != nil {
+		s.t.Logf("Warning: Failed to parse tokens: %v\nStdout: %s", err, stdout.String())
+		return
+	}
+
+	s.t.Logf("Loaded %d team tokens", len(s.teamTokens))
+}
+
+func (s *SharedTestState) loadServices() {
+	s.t.Log("Loading services...")
+
+	resp, err := http.Get(baseURL + "/api/services")
+	require.NoError(s.t, err)
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	require.NoError(s.t, err)
+
+	var servicesResp servicespb.Service_Batch
+	err = protojson.Unmarshal(body, &servicesResp)
+	require.NoError(s.t, err)
+
+	s.services = servicesResp.GetServices()
+	s.t.Logf("Loaded %d services", len(s.services))
+}
+
+type BaseSuite struct {
+	suite.Suite
+	sharedState *SharedTestState
+}
+
+func (s *BaseSuite) SetupSuite() {
+	if s.sharedState == nil {
+		s.T().Fatal("sharedState must be set before running suite")
+	}
+}
+
+func (s *BaseSuite) TearDownSuite() {
+}
+
+func (s *BaseSuite) rootDir() string {
+	return s.sharedState.rootDir
+}
+
+func (s *BaseSuite) db() *bun.DB {
+	return s.sharedState.db
+}
+
+func (s *BaseSuite) gsClient() *gamestateClient.Client {
+	return s.sharedState.gsClient
+}
+
+func (s *BaseSuite) svcClient() *servicesClient.Client {
+	return s.sharedState.svcClient
+}
+
+func (s *BaseSuite) teams() []*teamspb.Team {
+	return s.sharedState.teams
+}
+
+func (s *BaseSuite) teamTokens() []teamToken {
+	return s.sharedState.teamTokens
+}
+
+func (s *BaseSuite) services() []*servicespb.Service {
+	return s.sharedState.services
+}
+
+func (s *BaseSuite) GetGameState() *gspb.GameState {
+	s.T().Helper()
+	resp, err := http.Get(baseURL + "/api/game")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var gs gspb.GameState
+	err = protojson.Unmarshal(body, &gs)
+	s.Require().NoError(err)
+
+	return &gs
+}
+
+func (s *BaseSuite) GetCurrentRound() uint64 {
+	s.T().Helper()
+	return s.GetGameState().GetRunningRound()
+}
+
+func (s *BaseSuite) GetScoreboard() *scoreboardpb.Scoreboard {
+	s.T().Helper()
+	resp, err := http.Get(baseURL + "/api/scoreboard")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var sb scoreboardpb.Scoreboard
+	err = protojson.Unmarshal(body, &sb)
+	s.Require().NoError(err)
+
+	return &sb
+}
+
+func (s *BaseSuite) GetTeamServiceState(sb *scoreboardpb.Scoreboard, teamID, serviceID int64) *scoreboardpb.Scoreboard_TeamServiceState {
+	for _, state := range sb.GetTeamServiceStates() {
+		if state.GetTeamId() == teamID && state.GetServiceId() == serviceID {
+			return state
+		}
+	}
+	return nil
+}
+
+func (s *BaseSuite) SubmitFlags(token string, flags []string) *receiverpb.SubmitFlagsResponse {
+	s.T().Helper()
+	flagsJSON := `["` + strings.Join(flags, `","`) + `"]`
+	body := []byte(`{"flags":` + flagsJSON + `}`)
+
+	req, err := http.NewRequest(http.MethodPost, baseURL+"/flags", bytes.NewReader(body))
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", token)
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	if resp.StatusCode != http.StatusOK {
+		s.T().Logf("Flag submission failed with status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	var flagsResp receiverpb.SubmitFlagsResponse
+	err = protojson.Unmarshal(respBody, &flagsResp)
+	s.Require().NoError(err, "Failed to unmarshal response: %s", string(respBody))
+
+	return &flagsResp
+}
+
+func (s *BaseSuite) InsertTestFlag(teamID int, serviceID int, round uint64, putFinished bool) *models.Flag {
+	s.T().Helper()
+	ctx := context.Background()
+
+	flag := &models.Flag{
+		Flag:        fmt.Sprintf("TEST_%s_%d_%d_%d=", s.randomString(20), teamID, serviceID, round),
+		TeamID:      teamID,
+		ServiceID:   serviceID,
+		Round:       round,
+		PutFinished: putFinished,
+		CreatedAt:   time.Now(),
+	}
+
+	_, err := s.db().NewInsert().Model(flag).Exec(ctx)
+	s.Require().NoError(err, "Failed to insert test flag")
+
+	return flag
+}
+
+func (s *BaseSuite) InsertCheckerExecution(teamID, serviceID int, action checkerpb.Action, status checkerpb.Status, publicMsg string) *models.CheckerExecution {
+	s.T().Helper()
+	ctx := context.Background()
+
+	exec := &models.CheckerExecution{
+		ExecutionID: uuid.New().String(),
+		TeamID:      teamID,
+		ServiceID:   serviceID,
+		Action:      action,
+		Status:      status,
+		Public:      publicMsg,
+		CreatedAt:   time.Now(),
+	}
+
+	_, err := s.db().NewInsert().Model(exec).Exec(ctx)
+	s.Require().NoError(err, "Failed to insert checker execution")
+
+	return exec
+}
+
+func (s *BaseSuite) WaitForRoundIncrement(initialRound uint64, timeout time.Duration) uint64 {
+	s.T().Helper()
+	var currentRound uint64
+	require.Eventually(s.T(), func() bool {
+		currentRound = s.GetCurrentRound()
+		return currentRound > initialRound
+	}, timeout, time.Second, "Round should increment from %d", initialRound)
+	return currentRound
+}
+
+func (s *BaseSuite) randomString(n int) string {
+	const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	b := make([]byte, n)
+	if _, err := rand.Read(b); err != nil {
+		s.T().Fatalf("Failed to generate random string: %v", err)
+	}
+	for i := range b {
+		b[i] = letters[b[i]%byte(len(letters))]
+	}
+	return string(b)
+}
+
+func (s *BaseSuite) SetGameStatus(status gspb.GameStatus) {
+	s.T().Helper()
+	ctx := context.Background()
+	_, err := s.gsClient().Update(ctx, &gspb.UpdateRequest{
+		Status: status,
+	})
+	s.Require().NoError(err, "Failed to set game status=%s", status)
+}
+
+func (s *BaseSuite) SetServiceDisabled(serviceID int, disabled bool) {
+	s.T().Helper()
+	ctx := context.Background()
+	_, err := s.svcClient().Update(ctx, &servicespb.UpdateRequest{
+		Id:       int64(serviceID),
+		Disabled: proto.Bool(disabled),
+	})
+	s.Require().NoError(err, "Failed to set service %d disabled=%v via API", serviceID, disabled)
+}
diff --git a/tests/e2e/suite_centrifuge_test.go b/tests/e2e/suite_centrifuge_test.go
new file mode 100644
index 0000000..fe0d124
--- /dev/null
+++ b/tests/e2e/suite_centrifuge_test.go
@@ -0,0 +1,189 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"sync"
+	"time"
+
+	"github.com/centrifugal/centrifuge-go"
+	"google.golang.org/protobuf/encoding/protojson"
+
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+	scoreboardpb "github.com/c4t-but-s4d/fastad/pkg/proto/scoreboard"
+)
+
+const centrifugeURL = "ws://localhost:8080/centrifuge/websocket"
+
+type CentrifugeSuite struct {
+	BaseSuite
+}
+
+func (s *CentrifugeSuite) TestScoreboardSubscriptionAndUpdates() {
+	client := centrifuge.NewJsonClient(centrifugeURL, centrifuge.Config{})
+
+	var receivedUpdate bool
+	var scoreboard *scoreboardpb.Scoreboard
+	updateChan := make(chan struct{}, 1)
+
+	sub, err := client.NewSubscription("scoreboard")
+	s.Require().NoError(err, "Failed to create subscription")
+
+	sub.OnPublication(func(e centrifuge.PublicationEvent) {
+		var sb scoreboardpb.Scoreboard
+		if err := protojson.Unmarshal(e.Data, &sb); err != nil {
+			s.T().Logf("Failed to unmarshal scoreboard: %v", err)
+			return
+		}
+		scoreboard = &sb
+		receivedUpdate = true
+		select {
+		case updateChan <- struct{}{}:
+		default:
+		}
+	})
+
+	err = client.Connect()
+	s.Require().NoError(err, "Failed to connect")
+
+	err = sub.Subscribe()
+	s.Require().NoError(err, "Failed to subscribe")
+
+	select {
+	case <-updateChan:
+	case <-time.After(10 * time.Second):
+		s.T().Fatal("Timeout waiting for scoreboard update")
+	}
+
+	s.Assert().True(receivedUpdate, "Should receive scoreboard update")
+	s.Assert().NotNil(scoreboard, "Scoreboard should not be nil")
+	s.Assert().NotEmpty(scoreboard.GetTeamServiceStates(), "Scoreboard should have team service states")
+
+	for _, state := range scoreboard.GetTeamServiceStates() {
+		s.Assert().Greater(state.GetTeamId(), int64(0), "TeamId should be positive")
+		s.Assert().Greater(state.GetServiceId(), int64(0), "ServiceId should be positive")
+	}
+
+	client.Close()
+}
+
+func (s *CentrifugeSuite) TestAttackNotificationOnFlagSubmission() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+	s.Require().NotNil(s.db(), "Database connection required")
+
+	client := centrifuge.NewJsonClient(centrifugeURL, centrifuge.Config{})
+
+	var receivedNotification bool
+	var attackBatch *receiverpb.AttackNotification_Batch
+	notificationChan := make(chan struct{}, 1)
+
+	sub, err := client.NewSubscription("attacks")
+	s.Require().NoError(err, "Failed to create subscription")
+
+	sub.OnPublication(func(e centrifuge.PublicationEvent) {
+		var batch receiverpb.AttackNotification_Batch
+		if err := protojson.Unmarshal(e.Data, &batch); err != nil {
+			s.T().Logf("Failed to unmarshal attack notification: %v", err)
+			return
+		}
+		attackBatch = &batch
+		receivedNotification = true
+		select {
+		case notificationChan <- struct{}{}:
+		default:
+		}
+	})
+
+	err = client.Connect()
+	s.Require().NoError(err, "Failed to connect")
+
+	err = sub.Subscribe()
+	s.Require().NoError(err, "Failed to subscribe")
+
+	time.Sleep(500 * time.Millisecond)
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, true)
+
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp.GetResponses(), 1)
+	s.Require().Equal(receiverpb.FlagResponse_VERDICT_ACCEPTED, resp.GetResponses()[0].GetVerdict(),
+		"Flag should be accepted")
+
+	select {
+	case <-notificationChan:
+	case <-time.After(10 * time.Second):
+		s.T().Fatal("Timeout waiting for attack notification")
+	}
+
+	s.Assert().True(receivedNotification, "Should receive attack notification")
+	s.Assert().NotNil(attackBatch, "Attack batch should not be nil")
+	s.Assert().NotEmpty(attackBatch.GetAttacks(), "Should have at least one attack notification")
+
+	attack := attackBatch.GetAttacks()[0]
+	s.Assert().Equal(int64(s.teamTokens()[0].ID), attack.GetAttackerId(), "Attacker team ID should match")
+	s.Assert().Equal(int64(victimTeamID), attack.GetVictimId(), "Victim team ID should match")
+	s.Assert().Equal(int64(serviceID), attack.GetServiceId(), "Service ID should match")
+
+	client.Close()
+}
+
+func (s *CentrifugeSuite) TestMultipleScoreboardUpdates() {
+	client := centrifuge.NewJsonClient(centrifugeURL, centrifuge.Config{})
+
+	var updates []*scoreboardpb.Scoreboard
+	var mu sync.Mutex
+	updateChan := make(chan struct{}, 10)
+
+	sub, err := client.NewSubscription("scoreboard")
+	s.Require().NoError(err, "Failed to create subscription")
+
+	sub.OnPublication(func(e centrifuge.PublicationEvent) {
+		var sb scoreboardpb.Scoreboard
+		if err := protojson.Unmarshal(e.Data, &sb); err != nil {
+			s.T().Logf("Failed to unmarshal scoreboard: %v", err)
+			return
+		}
+		mu.Lock()
+		updates = append(updates, &sb)
+		mu.Unlock()
+		select {
+		case updateChan <- struct{}{}:
+		default:
+		}
+	})
+
+	err = client.Connect()
+	s.Require().NoError(err, "Failed to connect")
+
+	err = sub.Subscribe()
+	s.Require().NoError(err, "Failed to subscribe")
+
+	timeout := time.After(15 * time.Second)
+	updateCount := 0
+
+	for updateCount < 3 {
+		select {
+		case <-updateChan:
+			updateCount++
+			s.T().Logf("Received scoreboard update %d", updateCount)
+		case <-timeout:
+			s.T().Fatalf("Timeout waiting for scoreboard updates, received %d", updateCount)
+		}
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+
+	s.Assert().GreaterOrEqual(len(updates), 3, "Should receive at least 3 scoreboard updates")
+
+	for i, sb := range updates {
+		s.Assert().NotEmpty(sb.GetTeamServiceStates(), "Update %d should have team service states", i)
+	}
+
+	client.Close()
+}
diff --git a/tests/e2e/suite_flags_test.go b/tests/e2e/suite_flags_test.go
new file mode 100644
index 0000000..3b087d1
--- /dev/null
+++ b/tests/e2e/suite_flags_test.go
@@ -0,0 +1,423 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"time"
+
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+	receiverpb "github.com/c4t-but-s4d/fastad/pkg/proto/receiver"
+)
+
+type FlagsSuite struct {
+	BaseSuite
+}
+
+func (s *FlagsSuite) TestSubmitInvalidFlag() {
+	s.Require().NotEmpty(s.teamTokens(), "Team tokens required")
+
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{"INVALID_FLAG_12345"})
+	s.Require().Len(resp.GetResponses(), 1)
+
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_INVALID, resp.GetResponses()[0].GetVerdict())
+	s.Assert().Equal("INVALID_FLAG_12345", resp.GetResponses()[0].GetFlag())
+}
+
+func (s *FlagsSuite) TestSubmitEmptyFlags() {
+	s.Require().NotEmpty(s.teamTokens(), "Team tokens required")
+
+	req, err := http.NewRequest(
+		"POST",
+		baseURL+"/flags",
+		bytes.NewReader([]byte(`{"flags":[]}`)),
+	)
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", s.teamTokens()[0].Token)
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusBadRequest, resp.StatusCode)
+}
+
+func (s *FlagsSuite) TestSubmitTooManyFlags() {
+	s.Require().NotEmpty(s.teamTokens(), "Team tokens required")
+
+	// Generate 101 flags (exceeds maxFlagsInRequest = 100)
+	flags := make([]string, 101)
+	for i := range flags {
+		flags[i] = "FLAG_" + string(rune('A'+i%26)) + string(rune('0'+i/26))
+	}
+
+	flagsJSON, err := json.Marshal(map[string][]string{"flags": flags})
+	s.Require().NoError(err)
+
+	req, err := http.NewRequest(
+		"POST",
+		baseURL+"/flags",
+		bytes.NewReader(flagsJSON),
+	)
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", s.teamTokens()[0].Token)
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusBadRequest, resp.StatusCode,
+		"Submitting >100 flags should return BadRequest")
+}
+
+func (s *FlagsSuite) TestSubmitWithoutToken() {
+	req, err := http.NewRequest(
+		"POST",
+		baseURL+"/flags",
+		bytes.NewReader([]byte(`{"flags":["test"]}`)),
+	)
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusBadRequest, resp.StatusCode)
+}
+
+func (s *FlagsSuite) TestSubmitWithInvalidToken() {
+	req, err := http.NewRequest(
+		"POST",
+		baseURL+"/flags",
+		bytes.NewReader([]byte(`{"flags":["test"]}`)),
+	)
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", "invalid-token-12345")
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	// Invalid token returns 404 (team not found)
+	s.Assert().Equal(http.StatusNotFound, resp.StatusCode)
+}
+
+func (s *FlagsSuite) TestSubmitMultipleInvalidFlags() {
+	s.Require().NotEmpty(s.teamTokens(), "Team tokens required")
+
+	flags := []string{"FLAG1", "FLAG2", "FLAG3"}
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, flags)
+
+	s.Assert().Len(resp.GetResponses(), 3)
+	for i, r := range resp.GetResponses() {
+		s.Assert().Equal(receiverpb.FlagResponse_VERDICT_INVALID, r.GetVerdict(), "Flag %d should be invalid", i)
+	}
+}
+
+func (s *FlagsSuite) TestSubmitDuplicateFlagsInSameRequest() {
+	s.Require().NotEmpty(s.teamTokens(), "Team tokens required")
+
+	flags := []string{"SAME_FLAG", "SAME_FLAG"}
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, flags)
+
+	s.Assert().Len(resp.GetResponses(), 1, "API should deduplicate identical flags")
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_INVALID, resp.GetResponses()[0].GetVerdict())
+}
+
+func (s *FlagsSuite) TestSubmitValidFlag() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+	s.Require().NotNil(s.db(), "Database connection required")
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, true)
+
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp.GetResponses(), 1)
+
+	flagResp := resp.GetResponses()[0]
+	s.Assert().Equal(flag.Flag, flagResp.GetFlag())
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_ACCEPTED, flagResp.GetVerdict(),
+		"Expected VERDICT_ACCEPTED, got %v: %s", flagResp.GetVerdict(), flagResp.GetMessage())
+	s.Assert().Greater(flagResp.GetAttackerDelta(), float64(0), "Attacker should gain points")
+}
+
+func (s *FlagsSuite) TestSubmitOwnFlag() {
+	s.Require().NotEmpty(s.teamTokens(), "Team tokens required")
+	s.Require().NotEmpty(s.services(), "Services required")
+	s.Require().NotNil(s.db(), "Database connection required")
+
+	serviceID := int(s.services()[0].GetId())
+	attackerTeamID := int(s.teamTokens()[0].ID)
+	currentRound := s.GetCurrentRound()
+
+	flag := s.InsertTestFlag(attackerTeamID, serviceID, currentRound, true)
+
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp.GetResponses(), 1)
+
+	flagResp := resp.GetResponses()[0]
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_OWN, flagResp.GetVerdict(),
+		"Expected VERDICT_OWN for own flag, got %v: %s", flagResp.GetVerdict(), flagResp.GetMessage())
+}
+
+func (s *FlagsSuite) TestSubmitOldFlag() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+	s.Require().NotNil(s.db(), "Database connection required")
+
+	gs := s.GetGameState()
+	flagLifetime := gs.GetFlagLifetimeRounds()
+	currentRound := s.GetCurrentRound()
+
+	if currentRound <= flagLifetime {
+		s.T().Skipf("Current round %d <= lifetime %d, cannot test old flags yet", currentRound, flagLifetime)
+	}
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+
+	oldRound := uint64(0)
+	oldFlag := s.InsertTestFlag(victimTeamID, serviceID, oldRound, true)
+
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{oldFlag.Flag})
+	s.Require().Len(resp.GetResponses(), 1)
+
+	flagResp := resp.GetResponses()[0]
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_OLD, flagResp.GetVerdict(),
+		"Expected VERDICT_OLD for expired flag from round %d (current: %d, lifetime: %d), got %v: %s",
+		oldRound, currentRound, flagLifetime, flagResp.GetVerdict(), flagResp.GetMessage())
+}
+
+func (s *FlagsSuite) TestSubmitDuplicateValidFlag() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+	s.Require().NotNil(s.db(), "Database connection required")
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, true)
+
+	// First submission
+	resp1 := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp1.GetResponses(), 1)
+	s.Require().Equal(receiverpb.FlagResponse_VERDICT_ACCEPTED, resp1.GetResponses()[0].GetVerdict(),
+		"First submission should be accepted")
+
+	// Second submission (duplicate)
+	resp2 := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp2.GetResponses(), 1)
+
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_DUPLICATE, resp2.GetResponses()[0].GetVerdict(),
+		"Re-submitting same flag should return DUPLICATE")
+}
+
+func (s *FlagsSuite) TestScoreboardUpdatesOnFlagSubmission() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+	s.Require().NotNil(s.db(), "Database connection required")
+
+	currentRound := s.GetCurrentRound()
+	serviceID := int64(s.services()[0].GetId())
+	attackerID := int64(s.teamTokens()[0].ID)
+	victimID := int64(s.teamTokens()[1].ID)
+
+	// Get scoreboard state before
+	sbBefore := s.GetScoreboard()
+	attackerStateBefore := s.GetTeamServiceState(sbBefore, attackerID, serviceID)
+	victimStateBefore := s.GetTeamServiceState(sbBefore, victimID, serviceID)
+
+	var attackerStolenBefore, victimLostBefore int64
+	var attackerPointsBefore float64
+	if attackerStateBefore != nil {
+		attackerStolenBefore = attackerStateBefore.GetFlagsStolen()
+		attackerPointsBefore = attackerStateBefore.GetPoints()
+	}
+	if victimStateBefore != nil {
+		victimLostBefore = victimStateBefore.GetFlagsLost()
+	}
+
+	// Insert and submit flag
+	flag := s.InsertTestFlag(int(victimID), int(serviceID), currentRound, true)
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp.GetResponses(), 1)
+	s.Require().Equal(receiverpb.FlagResponse_VERDICT_ACCEPTED, resp.GetResponses()[0].GetVerdict())
+
+	// Wait for scoreboard update
+	s.Require().Eventually(func() bool {
+		sbAfter := s.GetScoreboard()
+		attackerStateAfter := s.GetTeamServiceState(sbAfter, attackerID, serviceID)
+		if attackerStateAfter == nil {
+			return false
+		}
+		return attackerStateAfter.GetFlagsStolen() > attackerStolenBefore
+	}, 10*time.Second, 500*time.Millisecond, "Attacker's FlagsStolen should increase")
+
+	// Verify scoreboard changes
+	sbAfter := s.GetScoreboard()
+	attackerStateAfter := s.GetTeamServiceState(sbAfter, attackerID, serviceID)
+	victimStateAfter := s.GetTeamServiceState(sbAfter, victimID, serviceID)
+
+	s.Require().NotNil(attackerStateAfter, "Attacker should have scoreboard entry")
+	s.Require().NotNil(victimStateAfter, "Victim should have scoreboard entry")
+
+	s.Assert().Greater(attackerStateAfter.GetFlagsStolen(), attackerStolenBefore,
+		"Attacker FlagsStolen should increase: before=%d, after=%d",
+		attackerStolenBefore, attackerStateAfter.GetFlagsStolen())
+
+	s.Assert().Greater(victimStateAfter.GetFlagsLost(), victimLostBefore,
+		"Victim FlagsLost should increase: before=%d, after=%d",
+		victimLostBefore, victimStateAfter.GetFlagsLost())
+
+	s.Assert().Greater(attackerStateAfter.GetPoints(), attackerPointsBefore,
+		"Attacker points should increase: before=%.2f, after=%.2f",
+		attackerPointsBefore, attackerStateAfter.GetPoints())
+}
+
+func (s *FlagsSuite) TestFlagNotPutFinished() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+	s.Require().NotNil(s.db(), "Database connection required")
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	// Insert flag with put_finished = false
+	flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, false)
+
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp.GetResponses(), 1)
+
+	flagResp := resp.GetResponses()[0]
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_FLAG_NOT_READY, flagResp.GetVerdict(),
+		"Flag with put_finished=false should be FLAG_NOT_READY, got %v: %s",
+		flagResp.GetVerdict(), flagResp.GetMessage())
+}
+
+func (s *FlagsSuite) TestAttackDataEndpoint() {
+	resp, err := http.Get(baseURL + "/attack_data")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	s.Assert().True(len(body) >= 0, "Attack data endpoint should be accessible")
+}
+
+func (s *FlagsSuite) TestFlagSubmissionWhenGamePaused() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	s.SetGameStatus(gspb.GameStatus_GAME_STATUS_PAUSED)
+	defer s.SetGameStatus(gspb.GameStatus_GAME_STATUS_RUNNING)
+
+	s.Require().Eventually(func() bool {
+		return s.GetGameState().GetStatus() == gspb.GameStatus_GAME_STATUS_PAUSED
+	}, 5*time.Second, 100*time.Millisecond, "Game should be paused")
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, true)
+
+	req, err := http.NewRequest(
+		"POST",
+		baseURL+"/flags",
+		bytes.NewReader([]byte(`{"flags":["`+flag.Flag+`"]}`)),
+	)
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", s.teamTokens()[0].Token)
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusServiceUnavailable, resp.StatusCode,
+		"Flag submission should fail when game is paused")
+}
+
+func (s *FlagsSuite) TestFlagSubmissionWhenGameFinished() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	s.SetGameStatus(gspb.GameStatus_GAME_STATUS_FINISHED)
+	defer s.SetGameStatus(gspb.GameStatus_GAME_STATUS_RUNNING)
+
+	s.Require().Eventually(func() bool {
+		return s.GetGameState().GetStatus() == gspb.GameStatus_GAME_STATUS_FINISHED
+	}, 5*time.Second, 100*time.Millisecond, "Game should be finished")
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, true)
+
+	req, err := http.NewRequest(
+		"POST",
+		baseURL+"/flags",
+		bytes.NewReader([]byte(`{"flags":["`+flag.Flag+`"]}`)),
+	)
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", s.teamTokens()[0].Token)
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusPreconditionFailed, resp.StatusCode,
+		"Flag submission should fail when game is finished")
+}
+
+func (s *FlagsSuite) TestFlagSubmissionForDisabledService() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 team tokens")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	s.SetServiceDisabled(serviceID, true)
+	defer s.SetServiceDisabled(serviceID, false)
+
+	s.Require().Eventually(func() bool {
+		resp, err := http.Get(baseURL + "/api/services")
+		if err != nil {
+			return false
+		}
+		defer resp.Body.Close()
+		body, _ := io.ReadAll(resp.Body)
+		return bytes.Contains(body, []byte(`"disabled":true`))
+	}, 5*time.Second, 100*time.Millisecond, "Service should be disabled")
+
+	flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, true)
+
+	resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+	s.Require().Len(resp.GetResponses(), 1)
+
+	flagResp := resp.GetResponses()[0]
+	s.Assert().Equal(receiverpb.FlagResponse_VERDICT_INVALID, flagResp.GetVerdict(),
+		"Flag submission should return INVALID for disabled service, got %v: %s",
+		flagResp.GetVerdict(), flagResp.GetMessage())
+	s.Assert().Contains(flagResp.GetMessage(), "disabled",
+		"Message should mention service is disabled")
+}
diff --git a/tests/e2e/suite_gamestate_test.go b/tests/e2e/suite_gamestate_test.go
new file mode 100644
index 0000000..4d557ed
--- /dev/null
+++ b/tests/e2e/suite_gamestate_test.go
@@ -0,0 +1,69 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"io"
+	"net/http"
+	"time"
+
+	"google.golang.org/protobuf/encoding/protojson"
+
+	gspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/game_state"
+)
+
+type GameStateSuite struct {
+	BaseSuite
+}
+
+func (s *GameStateSuite) TestGetGameStateJSON() {
+	resp, err := http.Get(baseURL + "/api/game")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var gs gspb.GameState
+	err = protojson.Unmarshal(body, &gs)
+	s.Require().NoError(err)
+
+	s.Assert().Equal(10.0, gs.GetHardness(), "Hardness should match config")
+	s.Assert().False(gs.GetInflation(), "Inflation should match config")
+	s.Assert().Equal(gspb.GameStatus_GAME_STATUS_RUNNING, gs.GetStatus(), "Game should be running")
+	s.Assert().Equal(uint64(5), gs.GetFlagLifetimeRounds(), "Flag lifetime should match config")
+	s.Assert().NotNil(gs.GetStartTime(), "Start time should be set")
+	s.Assert().NotNil(gs.GetRoundDuration(), "Round duration should be set")
+
+	expectedDuration := 10 * time.Second
+	s.Assert().Equal(expectedDuration.Seconds(), float64(gs.GetRoundDuration().GetSeconds()),
+		"Round duration should be 10 seconds as configured")
+}
+
+func (s *GameStateSuite) TestGetGameStateProtoFormat() {
+	resp, err := http.Get(baseURL + "/api/game?format=proto")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+	s.Assert().Equal("application/octet-stream", resp.Header.Get("Content-Type"))
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+	s.Assert().NotEmpty(body, "Proto response should not be empty")
+}
+
+func (s *GameStateSuite) TestRoundsIncrement() {
+	var initialRound uint64
+
+	s.Require().Eventually(func() bool {
+		initialRound = s.GetCurrentRound()
+		return initialRound > 0
+	}, 30*time.Second, time.Second, "Game should start with round > 0")
+
+	currentRound := s.WaitForRoundIncrement(initialRound, 30*time.Second)
+
+	s.Assert().Greater(currentRound, initialRound, "Round should have incremented")
+}
diff --git a/tests/e2e/suite_scoreboard_test.go b/tests/e2e/suite_scoreboard_test.go
new file mode 100644
index 0000000..594c6e6
--- /dev/null
+++ b/tests/e2e/suite_scoreboard_test.go
@@ -0,0 +1,277 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"sort"
+	"time"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	scoreboardpb "github.com/c4t-but-s4d/fastad/pkg/proto/scoreboard"
+)
+
+type ScoreboardSuite struct {
+	BaseSuite
+}
+
+func (s *ScoreboardSuite) TestGetScoreboard() {
+	var states []*scoreboardpb.Scoreboard_TeamServiceState
+
+	s.Require().Eventually(func() bool {
+		sb := s.GetScoreboard()
+		states = sb.GetTeamServiceStates()
+		return len(states) == 3
+	}, 30*time.Second, 2*time.Second, "Expected 3 team-service states (3 teams x 1 service)")
+
+	for _, state := range states {
+		s.Assert().Greater(state.GetTeamId(), int64(0))
+		s.Assert().Greater(state.GetServiceId(), int64(0))
+		s.Assert().GreaterOrEqual(state.GetPoints(), float64(0))
+		s.Assert().GreaterOrEqual(state.GetChecksTotal(), int64(0))
+		s.Assert().GreaterOrEqual(state.GetChecksPassed(), int64(0))
+		s.Assert().GreaterOrEqual(state.GetFlagsStolen(), int64(0))
+		s.Assert().GreaterOrEqual(state.GetFlagsLost(), int64(0))
+	}
+}
+
+func (s *ScoreboardSuite) TestGetCTFTimeScoreboard() {
+	resp, err := http.Get(baseURL + "/api/ctftime")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var ctftimeResp struct {
+		Standings []struct {
+			Pos   int     `json:"pos"`
+			Team  string  `json:"team"`
+			Score float64 `json:"score"`
+		} `json:"standings"`
+	}
+	err = json.Unmarshal(body, &ctftimeResp)
+	s.Require().NoError(err)
+
+	s.Assert().NotNil(ctftimeResp.Standings)
+	s.Assert().Len(ctftimeResp.Standings, 3, "Should have 3 teams in standings")
+
+	for i, standing := range ctftimeResp.Standings {
+		s.Assert().Equal(i+1, standing.Pos, "Position should be 1-indexed")
+		s.Assert().NotEmpty(standing.Team, "Team name should not be empty")
+	}
+}
+
+func (s *ScoreboardSuite) TestScoreboardTeamsAreSortedByScore() {
+	s.Require().GreaterOrEqual(len(s.teamTokens()), 2, "Need at least 2 teams")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	serviceID := int(s.services()[0].GetId())
+	victimTeamID := int(s.teamTokens()[1].ID)
+	currentRound := s.GetCurrentRound()
+
+	for i := 0; i < 3; i++ {
+		flag := s.InsertTestFlag(victimTeamID, serviceID, currentRound, true)
+		resp := s.SubmitFlags(s.teamTokens()[0].Token, []string{flag.Flag})
+		s.Require().Len(resp.GetResponses(), 1)
+	}
+
+	attackerID := int64(s.teamTokens()[0].ID)
+	var states []*scoreboardpb.Scoreboard_TeamServiceState
+	s.Require().Eventually(func() bool {
+		sb := s.GetScoreboard()
+		states = sb.GetTeamServiceStates()
+		for _, state := range states {
+			if state.GetTeamId() == attackerID && state.GetFlagsStolen() >= 3 {
+				return true
+			}
+		}
+		return false
+	}, 10*time.Second, 500*time.Millisecond, "Attacker should have stolen flags reflected in scoreboard")
+
+	type teamScore struct {
+		teamID int64
+		points float64
+	}
+	var scores []teamScore
+	for _, state := range states {
+		scores = append(scores, teamScore{teamID: state.GetTeamId(), points: state.GetPoints()})
+	}
+
+	isSorted := sort.SliceIsSorted(scores, func(i, j int) bool {
+		return scores[i].points >= scores[j].points
+	})
+
+	s.Assert().True(isSorted || len(scores) <= 1, "Teams should be sorted by score (descending)")
+}
+
+func (s *ScoreboardSuite) TestChecksAreBeingRecorded() {
+	var totalChecks int64
+
+	s.Require().Eventually(func() bool {
+		sb := s.GetScoreboard()
+		totalChecks = 0
+		for _, state := range sb.GetTeamServiceStates() {
+			totalChecks += state.GetChecksTotal()
+		}
+		return totalChecks > 0
+	}, 60*time.Second, 2*time.Second, "Checks should be recorded")
+}
+
+func (s *ScoreboardSuite) TestScoreboardUpdatesOnRoundProgression() {
+	sbBefore := s.GetScoreboard()
+	var totalChecksBefore int64
+	for _, state := range sbBefore.GetTeamServiceStates() {
+		totalChecksBefore += state.GetChecksTotal()
+	}
+
+	initialRound := s.GetCurrentRound()
+	s.WaitForRoundIncrement(initialRound, 30*time.Second)
+
+	var totalChecksAfter int64
+	s.Require().Eventually(func() bool {
+		sbAfter := s.GetScoreboard()
+		totalChecksAfter = 0
+		for _, state := range sbAfter.GetTeamServiceStates() {
+			totalChecksAfter += state.GetChecksTotal()
+		}
+		return totalChecksAfter > totalChecksBefore
+	}, 30*time.Second, time.Second, "Total checks should increase after round progression")
+}
+
+func (s *ScoreboardSuite) TestSLACalculationWithUpStatus() {
+	s.Require().NotEmpty(s.teams(), "Teams required")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	teamID := int(s.teams()[0].GetId())
+	serviceID := int(s.services()[0].GetId())
+
+	sbBefore := s.GetScoreboard()
+	stateBefore := s.GetTeamServiceState(sbBefore, int64(teamID), int64(serviceID))
+
+	var checksPassedBefore int64
+	if stateBefore != nil {
+		checksPassedBefore = stateBefore.GetChecksPassed()
+	}
+
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_UP, "Service is up")
+
+	var checksPassedAfter int64
+	s.Require().Eventually(func() bool {
+		sbAfter := s.GetScoreboard()
+		stateAfter := s.GetTeamServiceState(sbAfter, int64(teamID), int64(serviceID))
+		if stateAfter == nil {
+			return false
+		}
+		checksPassedAfter = stateAfter.GetChecksPassed()
+		return checksPassedAfter > checksPassedBefore
+	}, 30*time.Second, time.Second, "ChecksPassed should increase after STATUS_UP execution")
+}
+
+func (s *ScoreboardSuite) TestSLACalculationWithDownStatus() {
+	s.Require().NotEmpty(s.teams(), "Teams required")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	teamID := int(s.teams()[0].GetId())
+	serviceID := int(s.services()[0].GetId())
+
+	sbBefore := s.GetScoreboard()
+	stateBefore := s.GetTeamServiceState(sbBefore, int64(teamID), int64(serviceID))
+
+	var checksTotalBefore, checksPassedBefore int64
+	if stateBefore != nil {
+		checksTotalBefore = stateBefore.GetChecksTotal()
+		checksPassedBefore = stateBefore.GetChecksPassed()
+	}
+
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_DOWN, "Connection error")
+
+	var checksTotalAfter, checksPassedAfter int64
+	s.Require().Eventually(func() bool {
+		sbAfter := s.GetScoreboard()
+		stateAfter := s.GetTeamServiceState(sbAfter, int64(teamID), int64(serviceID))
+		if stateAfter == nil {
+			return false
+		}
+		checksTotalAfter = stateAfter.GetChecksTotal()
+		checksPassedAfter = stateAfter.GetChecksPassed()
+		return checksTotalAfter > checksTotalBefore
+	}, 30*time.Second, time.Second, "ChecksTotal should increase after STATUS_DOWN execution")
+
+	s.Assert().Equal(checksPassedBefore, checksPassedAfter,
+		"ChecksPassed should NOT increase after STATUS_DOWN: before=%d, after=%d",
+		checksPassedBefore, checksPassedAfter)
+}
+
+func (s *ScoreboardSuite) TestSLADecreasesWithFailedChecks() {
+	s.Require().NotEmpty(s.teams(), "Teams required")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	teamID := int(s.teams()[0].GetId())
+	serviceID := int(s.services()[0].GetId())
+
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_UP, "Up 1")
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_UP, "Up 2")
+
+	var stateBeforeDown *scoreboardpb.Scoreboard_TeamServiceState
+	s.Require().Eventually(func() bool {
+		sbBeforeDown := s.GetScoreboard()
+		stateBeforeDown = s.GetTeamServiceState(sbBeforeDown, int64(teamID), int64(serviceID))
+		return stateBeforeDown != nil && stateBeforeDown.GetChecksPassed() >= 2
+	}, 10*time.Second, 500*time.Millisecond, "Checks should be reflected in scoreboard")
+
+	slaBeforeDown := float64(0)
+	if stateBeforeDown.GetChecksTotal() > 0 {
+		slaBeforeDown = float64(stateBeforeDown.GetChecksPassed()) / float64(stateBeforeDown.GetChecksTotal())
+	}
+
+	checksTotalBefore := stateBeforeDown.GetChecksTotal()
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_DOWN, "Down 1")
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_DOWN, "Down 2")
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_DOWN, "Down 3")
+
+	var stateAfterDown *scoreboardpb.Scoreboard_TeamServiceState
+	s.Require().Eventually(func() bool {
+		sbAfterDown := s.GetScoreboard()
+		stateAfterDown = s.GetTeamServiceState(sbAfterDown, int64(teamID), int64(serviceID))
+		return stateAfterDown != nil && stateAfterDown.GetChecksTotal() >= checksTotalBefore+3
+	}, 10*time.Second, 500*time.Millisecond, "Down checks should be reflected in scoreboard")
+
+	slaAfterDown := float64(0)
+	if stateAfterDown.GetChecksTotal() > 0 {
+		slaAfterDown = float64(stateAfterDown.GetChecksPassed()) / float64(stateAfterDown.GetChecksTotal())
+	}
+
+	s.Assert().Less(slaAfterDown, slaBeforeDown,
+		"SLA should decrease after failed checks: before=%.4f, after=%.4f",
+		slaBeforeDown, slaAfterDown)
+}
+
+func (s *ScoreboardSuite) TestCheckStatusHistory() {
+	s.Require().NotEmpty(s.teams(), "Teams required")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	var sb *scoreboardpb.Scoreboard
+	s.Require().Eventually(func() bool {
+		sb = s.GetScoreboard()
+		if len(sb.GetTeamServiceStates()) == 0 {
+			return false
+		}
+		for _, state := range sb.GetTeamServiceStates() {
+			if len(state.GetCheckStatuses()) > 0 {
+				return true
+			}
+		}
+		return false
+	}, 60*time.Second, 2*time.Second, "Should have check status history")
+
+	for _, state := range sb.GetTeamServiceStates() {
+		statuses := state.GetCheckStatuses()
+		s.Assert().LessOrEqual(len(statuses), 3,
+			"Should keep at most 3 check statuses, got %d", len(statuses))
+	}
+}
diff --git a/tests/e2e/suite_services_test.go b/tests/e2e/suite_services_test.go
new file mode 100644
index 0000000..8dacb02
--- /dev/null
+++ b/tests/e2e/suite_services_test.go
@@ -0,0 +1,40 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"io"
+	"net/http"
+
+	"google.golang.org/protobuf/encoding/protojson"
+
+	servicespb "github.com/c4t-but-s4d/fastad/pkg/proto/data/services"
+)
+
+type ServicesSuite struct {
+	BaseSuite
+}
+
+func (s *ServicesSuite) TestListServices() {
+	resp, err := http.Get(baseURL + "/api/services")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var servicesResp servicespb.Service_Batch
+	err = protojson.Unmarshal(body, &servicesResp)
+	s.Require().NoError(err)
+
+	services := servicesResp.GetServices()
+	s.Assert().Len(services, 1, "Expected 1 service")
+
+	service := services[0]
+	s.Assert().Equal("test_service", service.GetName())
+	s.Assert().Greater(service.GetId(), int64(0), "Service should have positive ID")
+	s.Assert().Nil(service.GetChecker(), "Checker config should be stripped from API response")
+	s.Assert().Equal(float64(2500), service.GetDefaultScore(), "Service should have default score of 2500")
+}
diff --git a/tests/e2e/suite_teams_test.go b/tests/e2e/suite_teams_test.go
new file mode 100644
index 0000000..537865f
--- /dev/null
+++ b/tests/e2e/suite_teams_test.go
@@ -0,0 +1,203 @@
+//go:build e2e
+
+package e2e
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+
+	"google.golang.org/protobuf/encoding/protojson"
+
+	checkerpb "github.com/c4t-but-s4d/fastad/pkg/proto/checker"
+	teamspb "github.com/c4t-but-s4d/fastad/pkg/proto/data/teams"
+)
+
+type TeamsSuite struct {
+	BaseSuite
+}
+
+func (s *TeamsSuite) TestListTeams() {
+	resp, err := http.Get(baseURL + "/api/teams")
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var teamsResp teamspb.Team_Batch
+	err = protojson.Unmarshal(body, &teamsResp)
+	s.Require().NoError(err)
+
+	teams := teamsResp.GetTeams()
+	s.Assert().Len(teams, 3, "Expected 3 teams")
+
+	teamNames := make([]string, len(teams))
+	for i, team := range teams {
+		teamNames[i] = team.GetName()
+		s.Assert().Empty(team.GetToken(), "Team token should be stripped from API response")
+		s.Assert().NotEmpty(team.GetAddress(), "Team should have an address")
+		s.Assert().Greater(team.GetId(), int64(0), "Team should have positive ID")
+	}
+
+	s.Assert().Contains(teamNames, "Team Alpha")
+	s.Assert().Contains(teamNames, "Team Beta")
+	s.Assert().Contains(teamNames, "Team Gamma")
+}
+
+func (s *TeamsSuite) TestUpdateTeamAvatar() {
+	s.Require().NotEmpty(s.teamTokens(), "Team tokens required")
+
+	newAvatarURL := "https://example.com/avatar.png"
+	body := fmt.Sprintf(`{"avatar_url": "%s"}`, newAvatarURL)
+
+	req, err := http.NewRequest(http.MethodPut, baseURL+"/api/teams", bytes.NewReader([]byte(body)))
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", s.teamTokens()[0].Token)
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	respBody, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var team teamspb.Team
+	err = protojson.Unmarshal(respBody, &team)
+	s.Require().NoError(err)
+
+	s.Assert().Equal(newAvatarURL, team.GetAvatarUrl())
+}
+
+func (s *TeamsSuite) TestUpdateTeamAvatarWithoutToken() {
+	body := `{"avatar_url": "https://example.com/avatar.png"}`
+
+	req, err := http.NewRequest(http.MethodPut, baseURL+"/api/teams", bytes.NewReader([]byte(body)))
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusNotFound, resp.StatusCode)
+}
+
+func (s *TeamsSuite) TestUpdateTeamAvatarWithInvalidToken() {
+	body := `{"avatar_url": "https://example.com/avatar.png"}`
+
+	req, err := http.NewRequest(http.MethodPut, baseURL+"/api/teams", bytes.NewReader([]byte(body)))
+	s.Require().NoError(err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Team-Token", "invalid-token-12345")
+
+	resp, err := http.DefaultClient.Do(req)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusNotFound, resp.StatusCode)
+}
+
+func (s *TeamsSuite) TestGetTeamHistoryShowsCheckerResults() {
+	s.Require().NotEmpty(s.teams(), "Teams required")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	teamID := int(s.teams()[0].GetId())
+	serviceID := int(s.services()[0].GetId())
+
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_UP, "Test check")
+
+	url := fmt.Sprintf("%s/api/teams/%d/history", baseURL, teamID)
+	resp, err := http.Get(url)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var historyResp checkerpb.Execution_Batch
+	err = protojson.Unmarshal(body, &historyResp)
+	s.Require().NoError(err)
+
+	s.Assert().NotEmpty(historyResp.GetExecutions(), "History should contain executions")
+
+	for _, exec := range historyResp.GetExecutions() {
+		s.Assert().Empty(exec.GetPrivate(), "Private field should be stripped")
+	}
+}
+
+func (s *TeamsSuite) TestGetTeamHistoryWithServiceFilter() {
+	s.Require().NotEmpty(s.teams(), "Teams required")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	teamID := int(s.teams()[0].GetId())
+	serviceID := int(s.services()[0].GetId())
+
+	s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_UP, "Filtered check")
+
+	url := fmt.Sprintf("%s/api/teams/%d/history?service_id=%d", baseURL, teamID, serviceID)
+	resp, err := http.Get(url)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var historyResp checkerpb.Execution_Batch
+	err = protojson.Unmarshal(body, &historyResp)
+	s.Require().NoError(err)
+
+	for _, exec := range historyResp.GetExecutions() {
+		s.Assert().Equal(int64(serviceID), exec.GetServiceId(),
+			"All executions should be for the filtered service")
+	}
+}
+
+func (s *TeamsSuite) TestGetTeamHistoryWithLimit() {
+	s.Require().NotEmpty(s.teams(), "Teams required")
+	s.Require().NotEmpty(s.services(), "Services required")
+
+	teamID := int(s.teams()[0].GetId())
+	serviceID := int(s.services()[0].GetId())
+
+	for i := 0; i < 10; i++ {
+		s.InsertCheckerExecution(teamID, serviceID, checkerpb.Action_ACTION_CHECK, checkerpb.Status_STATUS_UP, fmt.Sprintf("Check %d", i))
+	}
+
+	limit := 5
+	url := fmt.Sprintf("%s/api/teams/%d/history?limit=%d", baseURL, teamID, limit)
+	resp, err := http.Get(url)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	s.Require().NoError(err)
+
+	var historyResp checkerpb.Execution_Batch
+	err = protojson.Unmarshal(body, &historyResp)
+	s.Require().NoError(err)
+
+	s.Assert().LessOrEqual(len(historyResp.GetExecutions()), limit,
+		"Should return at most %d executions", limit)
+}
+
+func (s *TeamsSuite) TestGetTeamHistoryForNonExistentTeam() {
+	url := fmt.Sprintf("%s/api/teams/99999/history", baseURL)
+	resp, err := http.Get(url)
+	s.Require().NoError(err)
+	defer resp.Body.Close()
+
+	s.Assert().Equal(http.StatusOK, resp.StatusCode)
+}
diff --git a/tests/manual/live.py b/tests/manual/live.py
new file mode 100644
index 0000000..fbb9120
--- /dev/null
+++ b/tests/manual/live.py
@@ -0,0 +1,152 @@
+import asyncio
+import logging
+import signal
+
+from centrifuge import (
+    Client,
+    ClientEventHandler,
+    ConnectedContext,
+    ConnectingContext,
+    DisconnectedContext,
+    ErrorContext,
+    JoinContext,
+    LeaveContext,
+    PublicationContext,
+    SubscribedContext,
+    SubscribingContext,
+    SubscriptionErrorContext,
+    UnsubscribedContext,
+    SubscriptionEventHandler,
+    ServerSubscribedContext,
+    ServerSubscribingContext,
+    ServerUnsubscribedContext,
+    ServerPublicationContext,
+    ServerJoinContext,
+    ServerLeaveContext,
+)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+# Configure centrifuge-python logger.
+cf_logger = logging.getLogger("centrifuge")
+cf_logger.setLevel(logging.DEBUG)
+
+
+class ClientEventLoggerHandler(ClientEventHandler):
+    """Check out comments of ClientEventHandler methods to see when they are called."""
+
+    async def on_connecting(self, ctx: ConnectingContext) -> None:
+        logging.info("connecting: %s", ctx)
+
+    async def on_connected(self, ctx: ConnectedContext) -> None:
+        logging.info("connected: %s", ctx)
+
+    async def on_disconnected(self, ctx: DisconnectedContext) -> None:
+        logging.info("disconnected: %s", ctx)
+
+    async def on_error(self, ctx: ErrorContext) -> None:
+        logging.error("client error: %s", ctx)
+
+    async def on_subscribed(self, ctx: ServerSubscribedContext) -> None:
+        logging.info("subscribed server-side sub: %s", ctx)
+
+    async def on_subscribing(self, ctx: ServerSubscribingContext) -> None:
+        logging.info("subscribing server-side sub: %s", ctx)
+
+    async def on_unsubscribed(self, ctx: ServerUnsubscribedContext) -> None:
+        logging.info("unsubscribed from server-side sub: %s", ctx)
+
+    async def on_publication(self, ctx: ServerPublicationContext) -> None:
+        logging.info("publication from server-side sub: %s", ctx.pub.data)
+
+    async def on_join(self, ctx: ServerJoinContext) -> None:
+        logging.info("join in server-side sub: %s", ctx)
+
+    async def on_leave(self, ctx: ServerLeaveContext) -> None:
+        logging.info("leave in server-side sub: %s", ctx)
+
+
+class SubscriptionEventLoggerHandler(SubscriptionEventHandler):
+    """Check out comments of SubscriptionEventHandler methods to see when they are called."""
+
+    def __init__(self, channel: str = None):
+        self.channel = channel
+
+    async def on_subscribing(self, ctx: SubscribingContext) -> None:
+        logging.info("[%s] subscribing: %s", self.channel, ctx)
+
+    async def on_subscribed(self, ctx: SubscribedContext) -> None:
+        logging.info("[%s] subscribed: %s", self.channel, ctx)
+
+    async def on_unsubscribed(self, ctx: UnsubscribedContext) -> None:
+        logging.info("[%s] unsubscribed: %s", self.channel, ctx)
+
+    async def on_publication(self, ctx: PublicationContext) -> None:
+        logging.info("[%s] publication: %s", self.channel, ctx.pub.data)
+
+    async def on_join(self, ctx: JoinContext) -> None:
+        logging.info("join: %s", ctx)
+
+    async def on_leave(self, ctx: LeaveContext) -> None:
+        logging.info("leave: %s", ctx)
+
+    async def on_error(self, ctx: SubscriptionErrorContext) -> None:
+        logging.error("[%s] subscription error: %s", self.channel, ctx)
+
+
+def run_example():
+    client = Client(
+        "ws://localhost:8001/centrifuge/websocket",
+        events=ClientEventLoggerHandler(),
+        use_protobuf=False,
+    )
+
+    attacks_sub = client.new_subscription(
+        "attacks",
+        events=SubscriptionEventLoggerHandler("attacks"),
+    )
+
+    scoreboard_sub = client.new_subscription(
+        "scoreboard",
+        events=SubscriptionEventLoggerHandler("scoreboard"),
+    )
+
+    async def run():
+        await client.connect()
+        await attacks_sub.subscribe()
+        await scoreboard_sub.subscribe()
+
+        logging.info("all done, client connection is still alive, press Ctrl+C to exit")
+
+    asyncio.ensure_future(run())
+    loop = asyncio.get_event_loop()
+
+    async def shutdown(received_signal):
+        logging.info("received exit signal %s...", received_signal.name)
+        await client.disconnect()
+
+        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+        for task in tasks:
+            task.cancel()
+
+        logging.info("Cancelling outstanding tasks")
+        await asyncio.gather(*tasks, return_exceptions=True)
+        loop.stop()
+
+    signals = (signal.SIGTERM, signal.SIGINT)
+    for s in signals:
+        loop.add_signal_handler(
+            s, lambda received_signal=s: asyncio.create_task(shutdown(received_signal))
+        )
+
+    try:
+        loop.run_forever()
+    finally:
+        loop.close()
+        logging.info("successfully completed service shutdown")
+
+
+if __name__ == "__main__":
+    run_example()
diff --git a/tests/service/Dockerfile b/tests/service/Dockerfile
new file mode 100644
index 0000000..3d28d33
--- /dev/null
+++ b/tests/service/Dockerfile
@@ -0,0 +1,10 @@
+FROM golang:1.24.2-alpine
+
+WORKDIR /app
+COPY . .
+
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    go build -o /app/service /app/main.go
+
+CMD ["/app/service"]
diff --git a/tests/service/checker.py b/tests/service/checker.py
new file mode 100755
index 0000000..dd64147
--- /dev/null
+++ b/tests/service/checker.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+
+import sys
+
+from pathlib import Path
+
+BASE_DIR = Path(__file__).absolute().resolve().parent
+sys.path.insert(0, str(BASE_DIR))
+
+from test_service_lib import *
+
+
+class Checker(BaseChecker):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mch = CheckMachine(self)
+
+    def action(self, action, *args, **kwargs):
+        try:
+            super().action(action, *args, **kwargs)
+        except requests.exceptions.ConnectionError:
+            self.cquit(
+                Status.DOWN,
+                'Connection error',
+                'Got requests connection error',
+            )
+
+    def check(self):
+        self.mch.ping()
+        self.cquit(Status.OK)
+
+    def put(self, flag_id, flag, vuln):
+        new_id = self.mch.put_flag(flag, vuln)
+        self.cquit(Status.OK, new_id)
+
+    def get(self, flag_id, flag, vuln):
+        got_flag = self.mch.get_flag(flag_id, vuln, status=Status.CORRUPT)
+        self.assert_eq(got_flag, flag, 'Could not get flag', status=Status.CORRUPT)
+        self.cquit(Status.OK)
+
+
+if __name__ == '__main__':
+    c = Checker(sys.argv[2])
+    try:
+        c.action(sys.argv[1], *sys.argv[3:])
+    except c.get_check_finished_exception():
+        cquit(Status(c.status), c.public, c.private)
diff --git a/tests/service/compose.yml b/tests/service/compose.yml
new file mode 100644
index 0000000..82627f0
--- /dev/null
+++ b/tests/service/compose.yml
@@ -0,0 +1,6 @@
+services:
+  service:
+    build: .
+    restart: no
+    ports:
+      - "1323:1323"
diff --git a/tests/service/go.mod b/tests/service/go.mod
new file mode 100644
index 0000000..3d44a80
--- /dev/null
+++ b/tests/service/go.mod
@@ -0,0 +1,17 @@
+module testservice
+
+go 1.23.4
+
+require github.com/labstack/echo/v4 v4.13.3
+
+require (
+	github.com/labstack/gommon v0.4.2 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	golang.org/x/crypto v0.31.0 // indirect
+	golang.org/x/net v0.33.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
+)
diff --git a/tests/service/go.sum b/tests/service/go.sum
new file mode 100644
index 0000000..a37c9e3
--- /dev/null
+++ b/tests/service/go.sum
@@ -0,0 +1,31 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY=
+github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/tests/service/main.go b/tests/service/main.go
new file mode 100644
index 0000000..6d5d08e
--- /dev/null
+++ b/tests/service/main.go
@@ -0,0 +1,62 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"sync"
+
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/gommon/log"
+)
+
+func main() {
+	e := echo.New()
+
+	mu := sync.Mutex{}
+	flags := map[string]string{}
+	e.GET("/ping/", func(c echo.Context) error {
+		return c.String(http.StatusOK, "pong")
+	})
+
+	e.POST("/put/", func(c echo.Context) error {
+		var req struct {
+			FlagID string `json:"id"`
+			Vuln   string `json:"vuln"`
+			Flag   string `json:"flag"`
+		}
+		if err := c.Bind(&req); err != nil {
+			return c.String(http.StatusBadRequest, "bad request")
+		}
+
+		mu.Lock()
+		defer mu.Unlock()
+		e.Logger.Infof("flag: %s, vuln: %s, id: %s", req.Flag, req.Vuln, req.FlagID)
+		flags[fmt.Sprintf("%s:%s", req.FlagID, req.Vuln)] = req.Flag
+
+		return c.NoContent(http.StatusOK)
+	})
+
+	e.GET("/get/", func(c echo.Context) error {
+		var req struct {
+			FlagID string `query:"id"`
+			Vuln   string `query:"vuln"`
+		}
+		if err := c.Bind(&req); err != nil {
+			return c.String(http.StatusBadRequest, "bad request")
+		}
+
+		mu.Lock()
+		defer mu.Unlock()
+
+		flag, ok := flags[fmt.Sprintf("%s:%s", req.FlagID, req.Vuln)]
+		e.Logger.Infof("flag: %s, ok: %v, vuln: %s, id: %s", flag, ok, req.Vuln, req.FlagID)
+		if !ok {
+			return c.String(http.StatusNotFound, "not found")
+		}
+
+		return c.JSON(http.StatusOK, map[string]string{"flag": flag})
+	})
+
+	e.Logger.SetLevel(log.INFO)
+	e.Logger.Fatal(e.Start(":1323"))
+}
diff --git a/tests/service/requirements.txt b/tests/service/requirements.txt
new file mode 100644
index 0000000..5f1a935
--- /dev/null
+++ b/tests/service/requirements.txt
@@ -0,0 +1 @@
+checklib==0.7.0
diff --git a/tests/service/test_service_lib.py b/tests/service/test_service_lib.py
new file mode 100644
index 0000000..04f371d
--- /dev/null
+++ b/tests/service/test_service_lib.py
@@ -0,0 +1,47 @@
+import requests
+from checklib import *
+
+PORT = 1323
+
+
+class CheckMachine:
+
+    def __init__(self, checker):
+        self.checker = checker
+
+    def ping(self):
+        r = requests.get(f'http://{self.checker.host}:{PORT}/ping/', timeout=2)
+        self.checker.check_response(r, 'Check failed')
+
+    def put_flag(self, flag, vuln):
+        new_id = rnd_string(10)
+        r = requests.post(
+            f'http://{self.checker.host}:{PORT}/put/',
+            json={
+                'id': new_id,
+                'vuln': vuln,
+                'flag': flag,
+            },
+            timeout=2,
+        )
+        self.checker.check_response(r, 'Could not put flag')
+
+        return new_id
+
+    def get_flag(self, flag_id, vuln, status=Status.MUMBLE):
+        r = requests.get(
+            f'http://{self.checker.host}:{PORT}/get/',
+            params={
+                'id': flag_id,
+                'vuln': vuln,
+            },
+            timeout=2,
+        )
+        self.checker.check_response(r, 'Could not get flag', status=status)
+        data = self.checker.get_json(r, 'Invalid response from /get/', status=status)
+        self.checker.assert_in(
+            'flag', data,
+            'Could not get flag',
+            status=status,
+        )
+        return data['flag']