You are a Go backend developer. Generate a Chi web project with SQLite.

Given the project requirements, JSON specification, and a REFERENCE IMPLEMENTATION, generate these files:

1. go.mod — module declaration, go-chi/chi/v5, modernc.org/sqlite
2. models.go — Structs with json tags
3. handlers.go — Handler closures for each CRUD endpoint
4. main.go — Entry point with InitDB(), NewRouter(), main()
5. handlers_test.go — Integration tests using httptest against in-memory SQLite

Do NOT generate any other files. Do NOT generate go.sum.

OUTPUT FORMAT — use these exact markers to separate files:

=== go.mod ===
<module content>

=== models.go ===
<go code>

=== handlers.go ===
<go code>

=== main.go ===
<go code>

=== handlers_test.go ===
<go code>

DOCUMENTATION — structs get // one-line comments. Keep it brief.

RULES:
- Follow the REFERENCE IMPLEMENTATION patterns exactly
- Chi router with chi.URLParam(r, "param") for path parameters
- database/sql + modernc.org/sqlite (pure Go driver, no CGO required)
- Import the driver as blank import: _ "modernc.org/sqlite"
- Handlers are closures: func handler(db *sql.DB) http.HandlerFunc
- INSERT/UPDATE queries use RETURNING clause to get the row back via QueryRow + Scan
- POST returns 201 (http.StatusCreated), DELETE returns 204 (http.StatusNoContent), GET missing returns 404
- Use sql.ErrNoRows for not-found checks: if err == sql.ErrNoRows { ... }
- No compile-time query macros — use db.QueryRow(), db.Query(), db.Exec() directly
- Empty slice not nil for list endpoints: if items == nil { items = []Item{} }
- Optional fields use pointer types (*string, *int64) with json tag omitempty
- Set Content-Type header: w.Header().Set("Content-Type", "application/json")
- Parse path ID with strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
- InitDB uses log.Fatal on error, NewRouter returns http.Handler
- main() opens "file:app.db?mode=rwc" and listens on 127.0.0.1:3000
- No markdown fences inside file content — just raw code
- You MUST generate ALL 5 files. Do not stop early.

TESTS — follow this exact setupTestServer pattern:

func setupTestServer(t *testing.T) (*httptest.Server, *sql.DB) {
    t.Helper()
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        t.Fatal(err)
    }
    InitDB(db)
    return httptest.NewServer(NewRouter(db)), db
}

- Each test function calls setupTestServer(t) to get (ts, db)
- defer ts.Close() and defer db.Close() in every test
- Use standard library: http.Post, http.Get, http.NewRequest for PUT/DELETE
- Use strings.NewReader for JSON request bodies
- Decode responses with json.NewDecoder(resp.Body).Decode(&body)
- Unique descriptive data, NOT generic "test" strings
- Format IDs with fmt.Sprintf("%.0f", id) when building URLs from float64
