belt 0.4.4 → 0.4.6

data/lib/belt/docs/data_seeding.md

@@ -0,0 +1,129 @@
+# Data Seeding
+
+Belt provides two ways to get data into an environment without hand-crafting
+rows: copying data from another environment, and Rails-style seed files.
+
+## `belt db:copy` — copy data between environments
+
+Copies DynamoDB table contents from one environment into another, matching
+tables by name after stripping each environment's `<app>-<env>-` prefix.
+
+```bash
+belt db:copy prod dev            # copy prod data into dev
+belt db:copy prod dev --force    # overwrite dev tables even if non-empty
+```
+
+By default, destination tables that already contain data are skipped — safe
+to re-run against a live environment. `--force` overwrites them instead.
+
+### Cognito identity re-anchoring
+
+Cognito identities are **per-environment**: each environment has its own user
+pool, so the same person has a *different* `sub` in every environment. Any row
+that references a user by their `sub` (e.g. a membership's `cognito_sub`) has a
+reference that's meaningless in another environment — copy it verbatim and the
+row points at a user who doesn't exist in the destination pool, so it silently
+disappears (a copied project you can't see, a member who isn't there).
+
+`belt db:copy` handles this automatically:
+
+- The destination's own `users` table is **left untouched** — the destination
+  pool is authoritative for who its users are and what `sub` each one has.
+- For every other table, any row carrying both an `email` and a `cognito_sub`
+  has its `cognito_sub` **re-anchored** to the destination user with the same
+  email.
+- A row whose email has no destination user yet has its stale `cognito_sub`
+  **cleared**, so it reads as unclaimed (e.g. a pending invitation Belt binds
+  on that person's first login) rather than dangling.
+
+```bash
+belt db:copy prod dev                     # re-anchors identities (default)
+belt db:copy prod dev --no-remap-identity # copy cognito_sub refs verbatim
+```
+
+This relies on Belt's `cognito_authenticatable` convention: the users table is
+`<app>-<env>-users`, its primary key is `id` (the Cognito `sub`), it carries an
+`email`, and `cognito_sub` is the foreign-key attribute referencing it. The
+same re-anchoring runs in the nested (PR-preview) environment deploy hook.
+
+### Cross-account copies
+
+Source and destination environments often live in different AWS accounts
+(e.g. prod vs. dev). `belt db:copy` resolves the AWS profile for each side
+independently from `infrastructure/<env>/belt.rb` (`config.aws_profile`):
+
+```ruby
+# infrastructure/prod/belt.rb
+Belt.configure do |config|
+  config.aws_profile = "prod-readonly"
+end
+```
+
+Override either side explicitly if you don't want to rely on `belt.rb`:
+
+```bash
+belt db:copy prod dev --from-profile prod-readonly --to-profile dev
+```
+
+### How it works
+
+1. Lists tables under each environment's prefix (`<app>-<env>-`) using the
+   AWS CLI (`aws dynamodb list-tables`)
+2. Pairs up tables by matching suffix (e.g. `myapp-prod-posts` ↔ `myapp-dev-posts`)
+3. Scans the source table and `batch-write-item`s into the destination,
+   re-anchoring Cognito-sub foreign keys to the destination's users by email
+   (unless `--no-remap-identity`; see above)
+4. Skips (or overwrites, with `--force`) destination tables that already
+   have items
+
+This is the same mechanism used by nested (PR-preview) environment deploys
+to seed a preview environment's tables from its parent — `belt db:copy` just
+exposes it as a standalone command for any two environments.
+
+## `belt db:seed` — Rails-style seed file
+
+Mirrors `rails db:seed`. Loads `config/seeds.rb` in the same booted context
+`belt console` uses — your models (ActiveItem) are available, targeting the
+resolved environment's tables.
+
+```bash
+belt db:seed              # seeds dev, or $BELT_ENV if set
+belt db:seed dev01        # explicit environment
+belt db:seed prod         # prompts for confirmation, like belt console prod
+```
+
+`config/seeds.rb` is a plain Ruby file:
+
+```ruby
+# frozen_string_literal: true
+
+post = Post.create!(title: "Hello, world", body: "Seeded post")
+puts "Created post: #{post.id}"
+```
+
+### Safety
+
+`belt db:seed` refuses to run if the target environment's tables already
+have data, to avoid clobbering a live environment (or accidentally reseeding
+one that's already loaded). Pass `--force` to seed anyway:
+
+```bash
+belt db:seed dev01 --force
+```
+
+Because of this guard, seeds are typically run once against a fresh
+environment. If you want `seeds.rb` to be safely re-runnable regardless,
+write it idempotently (`find_or_create_by`-style) — `belt db:seed --force`
+does not enforce idempotency for you.
+
+### Scaffolding
+
+`belt new` generates a starter `config/seeds.rb` with usage notes and an
+example. Existing apps can add the file manually — it's just a plain Ruby
+file, no generator required.
+
+## See Also
+
+- `belt explain backups` — recovery-point snapshots, not data seeding
+- `belt explain console` — the app-booting mechanism `db:seed` reuses
+- `belt explain deployment` — nested environments and the parent → child copy hook

data/lib/belt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Belt
-  VERSION = '0.4.4'
+  VERSION = '0.4.6'
 end

data/lib/templates/new_app/config/seeds.rb.erb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Seed data for <%= @app_name %>. Run with:
+#
+#   belt db:seed              # seeds dev (or BELT_ENV)
+#   belt db:seed prod         # explicit environment (prompts for confirmation)
+#   BELT_ENV=dev01 belt db:seed
+#
+# This file is loaded in the same booted context as `belt console` — your
+# models (ActiveItem) are available, and they target the resolved
+# environment's DynamoDB tables (<%= @app_name %>-<env>-*).
+#
+# `belt db:seed` refuses to run against an environment that already has
+# data, to avoid clobbering something real. Pass --force to seed anyway.
+# Keep this file idempotent if you expect to re-run it (e.g. find_or_create
+# rather than create).
+#
+# Example:
+#
+#   post = Post.create!(
+#     title: "Hello, world",
+#     body: "This post was created by config/seeds.rb"
+#   )
+#   puts "Created post: #{post.id}"

data/references/cli.md

@@ -0,0 +1,76 @@
+# Belt CLI reference
+
+Run `belt --help` for the live list, or `belt <command> --help` for a specific
+command. `belt explain <topic>` gives conceptual docs. `BELT_ENV` sets the
+default environment so you can omit the `<env>` argument.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `belt new <app> [--frontend react]` | Create a new Belt app. `-v` lists every created file. |
+| `belt generate <thing> <name>` (alias `g`) | Generate `scaffold`, `model`, `controller`, `frontend`, `views`, `environment`, `dns`, `auth`, or a plugin generator. |
+| `belt destroy <thing> <name>` (alias `d`) | Remove what `generate` created. |
+| `belt routes [-g PATTERN] [-f json] [--namespace N]` | Show/inspect routes; generate Ruby route constants for the runtime router. |
+| `belt contracts [-g PATTERN] [-f json]` | Show API request/response contracts. |
+| `belt lambda-config [-e ENV] [-f json\|terraform]` | Show merged Lambda configuration. |
+| `belt console [env]` (alias `c`) | Interactive IRB with the app booted. `--run "expr"` for runner mode. |
+| `belt logs [lambda] [-f] [-s 5m] [-e env]` | Tail Lambda logs. |
+| `belt tasks [-g PATTERN] [-a]` (alias `-T`) | List rake tasks. Any rake task can be run directly: `belt lambda:build_layer`. |
+| `belt setup <state\|tables <env>\|frontend>` | Create S3 state bucket / generate DynamoDB tables / frontend infra. |
+| `belt doctor` | Check system deps + AWS config. |
+| `belt plugin new <name>` | Scaffold a Belt plugin gem. |
+| `belt explain <topic>` | Explain a concept (see topic list below). |
+| `belt deploy [env] [--auto] [--skip-backup] [--backup-only]` | Deploy to AWS (init → plan → apply, runs backups first if configured). |
+| `belt deploy frontend <env> [--frontend NAME]` | Build + deploy frontend(s). |
+| `belt dns <deploy\|add <env>\|show>` | Manage the root DNS zone. |
+| `belt frontend <env <env>\|list>` | Write `<frontend>/.env` from TF outputs, or list frontends. |
+| `belt server [--frontend NAME]` (alias `s`) | Start local dev server. |
+| `belt db:copy <from> <to> [--force]` | Copy DynamoDB data between environments. |
+| `belt db:seed [env] [--force]` | Run `config/seeds.rb` against an environment. |
+| `belt version` | Show Belt version. |
+
+### Terraform shorthand
+
+`belt <action> [env]` maps to Terraform: `init`, `plan`, `apply`, `destroy`,
+`output`. Example: `belt apply wups`, `belt output prod`.
+
+> ⚠ `belt destroy` is ambiguous: `belt destroy <env>` runs terraform destroy,
+> while `belt destroy scaffold post` removes generated code. Belt disambiguates
+> by argument shape.
+
+## `belt explain` topics
+
+`routing`, `controllers`, `models`, `deployment`, `generators`,
+`lambda_handler`, `observability`, `console`, `backups`, `data_seeding`,
+`plugins`, `structure`, `frontend`, `authentication`.
+
+## Standalone vs project commands
+
+These run anywhere (no Belt project needed): `new`, `version`, `doctor`,
+`explain`. All others chdir to the detected project root first.
+
+## Environment variables
+
+| Variable | Purpose |
+|---|---|
+| `BELT_ENV` | Default environment for env-scoped commands |
+| `ENVIRONMENT` | Verbose error responses (`dev*`, `local`, `test`) |
+| `BELT_METRICS_NAMESPACE` | CloudWatch metrics namespace (default `Belt`) |
+| `ACTION` | Service name for logging (falls back to function name) |
+| `ERROR_NOTIFICATION_TOPIC_ARN` | SNS topic for error alerts |
+| `CORS_ALLOWED_ORIGINS` | Comma-separated origins (overrides domain vars) |
+| `CUSTOMER_APP_DOMAIN` / `OPS_APP_DOMAIN` | CORS domains |
+
+## Common flows
+
+```bash
+belt new blog --frontend react
+belt generate scaffold post title:string content:text
+belt routes
+belt deploy dev
+belt deploy prod --auto
+belt console prod --run "Post.count"
+belt logs api -f -e prod
+belt db:copy prod dev
+```

data/references/controllers.md

@@ -0,0 +1,73 @@
+# BeltController
+
+`BeltController::Base` gives Rails-like callbacks, strong params, response
+helpers, and error handling. Run `belt explain controllers` for canonical docs.
+
+## Implicit responses
+
+Instance variables assigned in an action become the JSON body by default:
+
+```ruby
+def index
+  @posts = Post.all      # → { "posts": [ ... ] }
+end
+```
+
+Explicit helpers always override implicit assigns.
+
+## Callbacks
+
+```ruby
+before_action :authenticate_user!
+before_action :require_admin!, except: [:health]
+skip_before_action :authenticate_user!, only: [:health]
+```
+
+## Strong parameters
+
+```ruby
+params.require(:user).permit(:name, :email, address: [:street, :city])
+```
+
+## Response helpers
+
+```ruby
+success_response({ id: "123" })                 # 200 JSON + CORS
+success_response({ id: "123" }, :created)       # 201 (symbol or int)
+error_response("Not found", :not_found)         # 404 JSON error
+error_response("Nope", :unprocessable_entity)   # 422
+html_response("<h1>Hi</h1>")                     # 200 HTML + CORS
+head :no_content                                 # 204 empty
+response_status :created                         # 201 + implicit assigns
+```
+
+## Error handling
+
+```ruby
+rescue_from MyError, with: :handle_it
+
+def handle_it(exception, _context = {})
+  error_response(exception.message, 422)
+end
+```
+
+## Default format (JSON vs HTML)
+
+```ruby
+# App-wide (lambda/config/environment.rb)
+Belt.configure { |c| c.default_format = :json }   # default
+
+# Per-controller
+class PagesController < ApplicationController
+  self.default_format = :html   # implicitly renders views/<controller>/<action>.html.erb
+end
+```
+
+- `:json` (default): assigns → `success_response({ ... })`.
+- `:html`: Belt implicitly renders the ERB template. Missing template raises
+  `Belt::TemplateNotFound` (no silent JSON fallback).
+
+## Controller discovery
+
+No registration needed. Belt looks in the app namespace module first, then
+`Belt.all_controller_paths`.

data/references/deploy-and-ops.md

@@ -0,0 +1,77 @@
+# Deploy, environments, backups, seeding & observability
+
+Run `belt explain deployment`, `belt explain backups`, `belt explain
+data_seeding`, and `belt explain observability` for canonical docs.
+
+## Deploy lifecycle
+
+`belt deploy [env]` runs pre-deploy backups (if configured) → terraform init →
+plan → apply. The **conveyor-belt** Terraform provider packages Ruby into
+Lambdas, creates API Gateway routes from the routing DSL, generates IAM for
+DynamoDB access, and sets up CloudWatch log groups.
+
+```bash
+belt deploy dev
+belt deploy prod --auto          # skip confirmation
+belt deploy prod --skip-backup   # CI re-runs
+belt deploy prod --backup-only   # recovery point, no deploy
+```
+
+Provider config (Terraform):
+
+```hcl
+terraform {
+  required_providers {
+    conveyor-belt = { source = "stowzilla/conveyor-belt", version = "~> 0.0.1" }
+  }
+}
+```
+
+## Environments
+
+Each env has `infrastructure/<env>/` (main.tf, backend.tf, variables.tf,
+terraform.tfvars, outputs.tf, belt.rb). Create with `belt generate environment
+<name> [parent]`. Terraform shorthand: `belt init|plan|apply|destroy|output <env>`.
+Set `BELT_ENV` to omit the env arg.
+
+## Backups (pre-deploy, config-driven)
+
+`infrastructure/<env>/belt.rb`:
+
+```ruby
+Belt.configure do |config|
+  config.backups do
+    dynamodb :all                 # PITR check + on-demand snapshot per table
+    cognito  :users, :pool_config # export to backup bucket
+    s3       :legal_documents     # sync to backup bucket
+    retention snapshots: 90, cognito: 10, s3: 10
+  end
+end
+```
+
+Simple mode: `config.backups = true` (DynamoDB, all tables, 90-day retention).
+Omit the block entirely for lightweight dev envs. Belt auto-creates
+`<app>-backups-<env>` (versioned, public access blocked) on first run. Table
+names come from `terraform output`, so the first-ever deploy skips backups.
+
+## Data seeding
+
+```bash
+belt db:copy prod dev [--force]  # copy DynamoDB between envs (matches by stripped prefix)
+belt db:seed [env] [--force]     # run config/seeds.rb in the booted console context
+```
+
+`db:copy` skips non-empty destination tables by default. `db:seed` refuses to
+run against an env that already has data unless `--force`.
+
+## Observability
+
+`Belt::LambdaHandler` wires these global facades automatically:
+
+```ruby
+Belt::Observability::Logger.info("Something happened", user_id: "123")
+Belt::Observability::Metrics.track_event("OrderCreated", model: "Order")
+```
+
+Backed by `lambda_loadout` (structured logging + CloudWatch EMF metrics + error
+alerting via `ERROR_NOTIFICATION_TOPIC_ARN`).

data/references/models-and-auth.md

@@ -0,0 +1,71 @@
+# Models (ActiveItem) & Cognito authentication
+
+Run `belt explain models` and `belt explain authentication` for canonical docs.
+
+## ActiveItem (DynamoDB ORM)
+
+```ruby
+require "activeitem"
+
+class Post < ActiveItem::Base
+  self.primary_key = :id
+  attr_accessor :id, :user_id, :title, :body, :created_at
+
+  validates :title, presence: true
+  before_create { self.id ||= SecureRandom.uuid }
+end
+```
+
+Supports queries, validations, associations, and transactions. Query a GSI:
+
+```ruby
+Post.where(user_id: current_user.id, index: "UserIndex")
+Post.find(id)
+Post.create!(attrs)
+```
+
+Table schema is declared in `infrastructure/schema.tf.rb`:
+
+```ruby
+Belt.application.schema.define do
+  model :post do
+    partition_key :id, :string
+    global_secondary_index :UserIndex, partition_key: :user_id
+  end
+end
+```
+
+DynamoDB tables generated by Belt default to PITR enabled and (in prod)
+deletion protection enabled.
+
+## Authentication — Cognito owns auth, Belt owns the record
+
+```ruby
+class User < ApplicationRecord
+  cognito_authenticatable
+end
+```
+
+One line supplies: Cognito `sub` as primary key, identity attributes (`email`,
+`name`, `role`, `email_verified`, `last_seen_on`), an `EmailIndex` GSI,
+just-in-time provisioning from a token, and `#admin?` for platform staff.
+
+Controllers get helpers for free — no `include`, no config:
+
+| Helper | Meaning |
+|---|---|
+| `current_user` | User record or nil (memoized per request) |
+| `user_signed_in?` | Is there a Cognito identity on this request? |
+| `authenticate_user!` | `before_action` guard → 401 |
+| `cognito_admin?` | Does the token carry a staff Cognito group? |
+
+```ruby
+class ProfilesController < ApplicationController
+  before_action :authenticate_user!
+  def show = @profile = current_user
+end
+```
+
+`belt generate auth` creates the user pool **and** scaffolds the model + table.
+See `belt explain authentication` for the `after_cognito_sync` hook, platform
+staff handling, and both token shapes. Upgrading an existing app? See `UPGRADING.md`.

data/references/plugins.md

@@ -0,0 +1,64 @@
+# Authoring Belt plugins
+
+Belt stays lean; optional capabilities ship as **separate gems** that plug into
+the CLI and runtime. Run `belt explain plugins` for canonical docs. Reference
+implementations: `belt-messaging`, `belt-pay`.
+
+## Discovery contract (GeneratorRegistry)
+
+No central registry, no initializer. Belt discovers a generator when:
+
+1. The gem is in the app's `Gemfile` and bundled.
+2. It ships `lib/belt/generators/<name>_generator.rb`.
+3. The class is `Belt::Generators::<Name>Generator`.
+4. It implements `.run(args)` (required); optionally `.destroy(args)` and `.description`.
+
+After `bundle install`, `belt generate <name>` and `belt destroy <name>` just work.
+
+## Scaffold a plugin
+
+```bash
+belt plugin new notifications                       # → ./belt-notifications/
+belt plugin new pay --path ~/Code --summary "Stripe payments for Belt"
+```
+
+Point an app at a local plugin while developing:
+
+```ruby
+# app Gemfile
+gem "belt-notifications", path: "../belt-notifications"
+```
+
+`belt deploy` vendors `path:` gems into `vendor/cache` so conveyor-belt can
+package them.
+
+## Canonical layout
+
+```
+belt-messaging/
+├── belt-messaging.gemspec
+├── lib/
+│   ├── belt-messaging.rb              # require entrypoint
+│   └── belt/
+│       ├── messaging.rb               # Belt::Messaging API
+│       ├── messaging/{configuration,version}.rb
+│       ├── messaging/controllers/     # default controllers (optional)
+│       ├── messaging/templates/       # ERB for the generator
+│       └── generators/messaging_generator.rb   # ← auto-discovered
+└── spec/
+```
+
+**Runtime code stays in the gem.** Generators copy only what the host app must
+own — Terraform modules, Lambda entrypoints, optional controller overrides.
+Prefer gem defaults + `belt g <plugin> --controllers` over dumping everything
+into the app.
+
+## Generator checklist
+
+1. Terraform module → `infrastructure/modules/<name>/`
+2. Lambda config → `config/lambda/<name>.yml`
+3. Lambda entrypoint → `lambda/<name>.rb` via `Belt::LambdaHandler`
+4. Routes/schema injection when needed
+5. Optional `--controllers` for app-local overrides
+6. Matching `destroy` path
+7. `.description` + `--help`

data/references/routing.md

@@ -0,0 +1,78 @@
+# Belt routing DSL
+
+Routes live in `infrastructure/routes.tf.rb` and are read both by the
+**conveyor-belt** Terraform provider (for infra) and by `belt routes` (which
+generates the runtime route constants at `lambda/lib/routes/<namespace>_routes.rb`).
+
+Run `belt explain routing` for the canonical docs.
+
+## Four keywords
+
+| Keyword | Purpose | Changes which Lambda? |
+|---|---|---|
+| `gateway` | API Gateway + default Lambda | **Yes** — sets default for routes inside |
+| `function` | Route to a different Lambda | **Yes** — overrides gateway default |
+| `namespace` | Path prefix + controller module | No — code organization only |
+| `scope` | Path/module/auth grouping | No — grouping + shared options |
+
+**Critical:** `namespace` and `scope` are purely organizational. Only `gateway`
+and `function` determine the serving Lambda.
+
+```ruby
+Belt.application.routes.draw do
+  gateway :api, auth: :cognito do
+    resources :posts                    # lambda: api, /posts, posts controller
+
+    namespace :admin do
+      resources :users                  # /admin/users, admin/users controller
+    end
+
+    function :worker do
+      resources :jobs                   # lambda: worker, /jobs, jobs controller
+    end
+
+    scope path: 'v2', module: 'legacy' do
+      resources :widgets                # /v2/widgets, legacy/widgets controller
+    end
+  end
+end
+```
+
+## Nested resources
+
+```ruby
+resources :projects do
+  resource  :billing, only: [:show], tables: [:memberships]  # singular, no :id
+
+  resources :webhooks do
+    member     { post :test }      # POST /projects/:project_id/webhooks/:webhook_id/test
+  end
+
+  resources :surfaces do
+    collection { get :teams }      # GET /projects/:project_id/surfaces/teams
+    member     { put :assign }     # PUT /projects/:project_id/surfaces/:surface_id/assign
+  end
+
+  scope path: 'billing', controller: :billing, tables: [:memberships] do
+    get  '/', action: :show
+    post :checkout
+  end
+end
+```
+
+- **Action inference:** `post :checkout` uses `checkout` as both path segment and action.
+- **Controller inheritance:** `member`/`collection` inherit the parent resource's controller.
+- **`tables:`** declares DynamoDB access for IAM generation.
+
+## Request/response model inference (for `belt routes` / contracts)
+
+Resolution order (highest first):
+
+1. **Explicit per-route:** `put "/items/:id", request_model: :update_item`
+2. **Hash per-action:** `resources :items, request_model: { create: :create_item }`
+3. **Convention cascade** (POST/PUT/PATCH only):
+   - `:<verb>_<gateway>_<singular>` → e.g. `:create_customer_item`
+   - `:<verb>_<singular>` → e.g. `:create_item`
+
+**Response model:** singular of the resource name → `resources :items` looks for
+`model :item` in `contracts.rb`. Applies to all verbs. No match = no model documented.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.6
 platform: ruby
 authors:
 - Stowzilla
@@ -97,6 +97,7 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- SKILL.md
 - exe/belt
 - lib/belt.rb
 - lib/belt/action_router.rb
@@ -119,6 +120,8 @@ files:
 - lib/belt/cli/cognito_sharer.rb
 - lib/belt/cli/console_command.rb
 - lib/belt/cli/contracts_command.rb
+- lib/belt/cli/db_copy_command.rb
+- lib/belt/cli/db_seed_command.rb
 - lib/belt/cli/deploy_command.rb
 - lib/belt/cli/destroy_command.rb
 - lib/belt/cli/dns_command.rb
@@ -160,6 +163,7 @@ files:
 - lib/belt/docs/backups.md
 - lib/belt/docs/console.md
 - lib/belt/docs/controllers.md
+- lib/belt/docs/data_seeding.md
 - lib/belt/docs/deployment.md
 - lib/belt/docs/frontend.md
 - lib/belt/docs/generators.md
@@ -231,6 +235,7 @@ files:
 - lib/templates/new_app/config/contracts.rb.erb
 - lib/templates/new_app/config/lambda/api.yml.erb
 - lib/templates/new_app/config/routes.rb.erb
+- lib/templates/new_app/config/seeds.rb.erb
 - lib/templates/new_app/gitignore.erb
 - lib/templates/new_app/lambda/api.rb.erb
 - lib/templates/new_app/lambda/config/environment.rb.erb
@@ -258,6 +263,12 @@ files:
 - lib/templates/views/Index.jsx.erb
 - lib/templates/views/New.jsx.erb
 - lib/templates/views/Show.jsx.erb
+- references/cli.md
+- references/controllers.md
+- references/deploy-and-ops.md
+- references/models-and-auth.md
+- references/plugins.md
+- references/routing.md
 homepage: https://github.com/stowzilla/belt
 licenses:
 - MIT