diff --git a/collects/tests/unstable/values.rkt b/collects/tests/unstable/values.rkt
new file mode 100644
index 0000000000..f0502df648
--- /dev/null
+++ b/collects/tests/unstable/values.rkt
@@ -0,0 +1,60 @@
+#lang racket
+
+(require rackunit rackunit/text-ui unstable/values "helpers.rkt")
+
+(run-tests
+ (test-suite "values.ss"
+   (test-suite "map2"
+     (test-case "numerator and denominator"
+       (let*-values ([(ns ds)
+                      (map2
+                       (lambda (r)
+                         (values (numerator r) (denominator r)))
+                       (list 1/2 3/4 5/6))])
+         (check-equal? (list ns ds) (list '(1 3 5) '(2 4 6))))))
+   (test-suite "map/values"
+     (test-case "complex numerator and denominator"
+       (let*-values ([(rns rds ins ids)
+                      (map/values
+                       4
+                       (lambda (c)
+                         (values (numerator (real-part c))
+                                 (denominator (real-part c))
+                                 (numerator (imag-part c))
+                                 (denominator (imag-part c))))
+                       (list 1/2+3/4i 5/6+7/8i))])
+         (check-equal? (list rns rds ins ids)
+                       (list '(1 5) '(2 6) '(3 7) '(4 8)))))
+     (test-case "multiple lists"
+       (let*-values ([(as bs cs)
+                      (map/values 3 values '(1 2 3) '(4 5 6) '(7 8 9))])
+         (check-equal? as '(1 2 3))
+         (check-equal? bs '(4 5 6))
+         (check-equal? cs '(7 8 9)))))
+   (test-suite "foldl/values"
+     (test-case "sum, product, and last"
+       (let*-values ([(sum prod last)
+                      (foldl/values
+                       (lambda (next sum prod last)
+                         (values (+ next sum)
+                                 (* next prod)
+                                 next))
+                       (list 0 1 #f)
+                       (list 1 2 3 4))])
+         (check-equal? (list sum prod last)
+                       (list 10 24 4)))))
+   (test-suite "foldr/values"
+     (test-case "sum, product, and last"
+       (let*-values ([(sum prod last)
+                      (foldr/values
+                       (lambda (next sum prod last)
+                         (values (+ next sum)
+                                 (* next prod)
+                                 next))
+                       (list 0 1 #f)
+                       (list 1 2 3 4))])
+         (check-equal? (list sum prod last)
+                       (list 10 24 1)))))
+   (test-suite "values->list"
+     (test-case "1 2 3 4"
+       (check-equal? (values->list (values 1 2 3 4)) (list 1 2 3 4))))))
diff --git a/collects/unstable/cce/reference/manual.scrbl b/collects/unstable/cce/reference/manual.scrbl
index f278f78a8d..1866a1c930 100644
--- a/collects/unstable/cce/reference/manual.scrbl
+++ b/collects/unstable/cce/reference/manual.scrbl
@@ -10,8 +10,6 @@
 
 @table-of-contents[]
 
-@include-section["values.scrbl"]
-
 @include-section["regexp.scrbl"]
 @include-section["web.scrbl"]
 
diff --git a/collects/unstable/cce/test/test-main.ss b/collects/unstable/cce/test/test-main.ss
index 1c9859ba34..842aae451d 100644
--- a/collects/unstable/cce/test/test-main.ss
+++ b/collects/unstable/cce/test/test-main.ss
@@ -17,7 +17,6 @@
          "test-scribble.ss"
          "test-set.ss"
          "test-syntax.ss"
-         "test-values.ss"
          "test-web.ss")
 
 (run-tests
@@ -38,5 +37,4 @@
    scribble-suite
    set-suite
    syntax-suite
-   values-suite
    web-suite))
diff --git a/collects/unstable/cce/test/test-values.ss b/collects/unstable/cce/test/test-values.ss
deleted file mode 100644
index 9871560b61..0000000000
--- a/collects/unstable/cce/test/test-values.ss
+++ /dev/null
@@ -1,63 +0,0 @@
-#lang scheme
-
-(require "checks.ss"
-         "../values.ss")
-
-(provide values-suite)
-
-(define values-suite
-  (test-suite "values.ss"
-    (test-suite "map2"
-      (test-case "numerator and denominator"
-        (let*-values ([(ns ds)
-                       (map2
-                        (lambda (r)
-                          (values (numerator r) (denominator r)))
-                        (list 1/2 3/4 5/6))])
-          (check-equal? (list ns ds) (list '(1 3 5) '(2 4 6))))))
-    (test-suite "map/values"
-      (test-case "complex numerator and denominator"
-        (let*-values ([(rns rds ins ids)
-                       (map/values
-                        4
-                        (lambda (c)
-                          (values (numerator (real-part c))
-                                  (denominator (real-part c))
-                                  (numerator (imag-part c))
-                                  (denominator (imag-part c))))
-                        (list 1/2+3/4i 5/6+7/8i))])
-          (check-equal? (list rns rds ins ids)
-                        (list '(1 5) '(2 6) '(3 7) '(4 8)))))
-      (test-case "multiple lists"
-        (let*-values ([(as bs cs)
-                       (map/values 3 values '(1 2 3) '(4 5 6) '(7 8 9))])
-          (check-equal? as '(1 2 3))
-          (check-equal? bs '(4 5 6))
-          (check-equal? cs '(7 8 9)))))
-    (test-suite "foldl/values"
-      (test-case "sum, product, and last"
-        (let*-values ([(sum prod last)
-                       (foldl/values
-                        (lambda (next sum prod last)
-                          (values (+ next sum)
-                                  (* next prod)
-                                  next))
-                        (list 0 1 #f)
-                        (list 1 2 3 4))])
-          (check-equal? (list sum prod last)
-                        (list 10 24 4)))))
-    (test-suite "foldr/values"
-      (test-case "sum, product, and last"
-        (let*-values ([(sum prod last)
-                       (foldr/values
-                        (lambda (next sum prod last)
-                          (values (+ next sum)
-                                  (* next prod)
-                                  next))
-                        (list 0 1 #f)
-                        (list 1 2 3 4))])
-          (check-equal? (list sum prod last)
-                        (list 10 24 1)))))
-    (test-suite "values->list"
-      (test-case "1 2 3 4"
-        (check-equal? (values->list (values 1 2 3 4)) (list 1 2 3 4))))))
diff --git a/collects/unstable/scribblings/unstable.scrbl b/collects/unstable/scribblings/unstable.scrbl
index 20eadebe43..f63a5c5cdc 100644
--- a/collects/unstable/scribblings/unstable.scrbl
+++ b/collects/unstable/scribblings/unstable.scrbl
@@ -86,6 +86,7 @@ Keep documentation and tests up to date.
 @include-section["struct.scrbl"]
 @include-section["syntax.scrbl"]
 @include-section["text.scrbl"]
+@include-section["values.scrbl"]
 @include-section["poly-c.scrbl"]
 @include-section["mutated-vars.scrbl"]
 @include-section["find.scrbl"]
diff --git a/collects/unstable/cce/reference/values.scrbl b/collects/unstable/scribblings/values.scrbl
similarity index 81%
rename from collects/unstable/cce/reference/values.scrbl
rename to collects/unstable/scribblings/values.scrbl
index 4c4caa0da2..3660f4d2ed 100644
--- a/collects/unstable/cce/reference/values.scrbl
+++ b/collects/unstable/scribblings/values.scrbl
@@ -1,13 +1,11 @@
-#lang scribble/doc
-@(require scribble/manual
-          scribble/eval
-          "../scribble.ss"
-          "eval.ss")
-@(require (for-label scheme unstable/cce/values))
+#lang scribble/manual
+@(require scribble/eval "utils.rkt" (for-label racket unstable/values))
 
-@title[#:style 'quiet #:tag "cce-values"]{Multiple Values}
+@title{Multiple Values}
 
-@defmodule[unstable/cce/values]
+@defmodule[unstable/values]
+
+@unstable[@author+email["Carl Eastlund" "cce@racket-lang.org"]]
 
 This module provides tools for manipulating functions and expressions that
 produce multiple values.
@@ -17,7 +15,7 @@ produce multiple values.
 Produces a list of the values returned by @scheme[expr].
 
 @defexamples[
-#:eval (evaluator 'unstable/cce/values)
+#:eval (eval/require 'unstable/values)
 (values->list (values 1 2 3))
 ]
 
@@ -30,7 +28,7 @@ Produces a pair of lists of the respective values of @scheme[f] applied to the
 elements in @scheme[lst ...] sequentially.
 
 @defexamples[
-#:eval (evaluator 'unstable/cce/values)
+#:eval (eval/require 'unstable/values)
 (map2 (lambda (x) (values (+ x 1) (- x 1))) (list 1 2 3))
 ]
 
@@ -46,7 +44,7 @@ Produces lists of the respective values of @scheme[f] applied to the elements in
 @scheme[lst ...] sequentially.
 
 @defexamples[
-#:eval (evaluator 'unstable/cce/values)
+#:eval (eval/require 'unstable/values)
 (map/values
  3
  (lambda (x)
@@ -74,7 +72,7 @@ multiple-valued function @scheme[f]; @scheme[foldr/values] traverses the lists
 right to left and @scheme[foldl/values] traverses left to right.
 
 @defexamples[
-#:eval (evaluator 'unstable/cce/values)
+#:eval (eval/require 'unstable/values)
 (define (add/cons a b c d)
   (values (+ a c) (cons b d)))
 (foldr/values add/cons (list 0 null)
diff --git a/collects/unstable/cce/values.ss b/collects/unstable/values.rkt
similarity index 96%
rename from collects/unstable/cce/values.ss
rename to collects/unstable/values.rkt
index a622c4ed0f..3d0de8d271 100644
--- a/collects/unstable/cce/values.ss
+++ b/collects/unstable/values.rkt
@@ -1,5 +1,5 @@
-#lang scheme/base
-(require (for-syntax scheme/base))
+#lang racket/base
+(require (for-syntax racket/base))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;