diff --git a/collects/net/doc/sendmail.scrbl b/collects/net/doc/sendmail.scrbl
index 9317719593..42ffaafd2d 100644
--- a/collects/net/doc/sendmail.scrbl
+++ b/collects/net/doc/sendmail.scrbl
@@ -39,13 +39,13 @@ that the sendmail process can complete.
 The @scheme[from] argument can be any value; of course, spoofing
 should be used with care.}
 
-@defproc[(send-mail-message/port [from string?]
-                                 [subject string?]
-                                 [to (listof string?)]
-                                 [cc (listof string?)]
-                                 [bcc (listof string?)]
-                                 [body (listof string?)]
-                                 [extra-header string?] ...)
+@defproc[(send-mail-message [from string?]
+                            [subject string?]
+                            [to (listof string?)]
+                            [cc (listof string?)]
+                            [bcc (listof string?)]
+                            [body (listof string?)]
+                            [extra-header string?] ...)
          void?]{
 
 Like @scheme[send-mail-message/port], but with @scheme[body] as a list
diff --git a/collects/scheme/private/kw.ss b/collects/scheme/private/kw.ss
index 27d0d12ae1..8179448812 100644
--- a/collects/scheme/private/kw.ss
+++ b/collects/scheme/private/kw.ss
@@ -10,7 +10,7 @@
                          "norm-define.ss"
                          "qqstx.ss"))
 
-  (#%provide new-lambda
+  (#%provide new-lambda new-λ
              new-define
              new-app
              (rename *make-keyword-procedure make-keyword-procedure)
@@ -280,165 +280,168 @@
             #f "bad argument sequence" stx (syntax args))]))))
   
   ;; The new `lambda' form:
-  (define-syntax (new-lambda stx)
-    (syntax-case stx ()
-      [(_ args body1 body ...)
-       (if (simple-args? #'args)
-           ;; Use plain old `lambda':
-           (syntax/loc stx
-             (lambda args body1 body ...))
-           ;; Handle keyword or optional arguments:
-           (with-syntax ([((plain-id ...)
-                           (opt-id ...)
-                           ([id opt-expr kind] ...)
-                           ([kw kw-id kw-req] ...)
-                           need-kw
-                           rest)
-                          (parse-formals stx #'args)])
-             (let ([dup-id (check-duplicate-identifier (syntax->list #'(id ... . rest)))])
-               (when dup-id
-                 (raise-syntax-error
-                  #f
-                  "duplicate argument identifier"
-                  stx
-                  dup-id)))
-             (let* ([kws (syntax->list #'(kw ...))]
-                    [opts (syntax->list #'(opt-id ...))]
-                    [ids (syntax->list #'(id ...))]
-                    [plain-ids (syntax->list #'(plain-id ...))]
-                    [kw-reqs (syntax->list #'(kw-req ...))]
-                    [kw-args (generate-temporaries kws)]     ; to hold supplied value
-                    [kw-arg?s (generate-temporaries kws)]    ; to indicated whether it was supplied
-                    [opt-args (generate-temporaries opts)]   ; supplied value
-                    [opt-arg?s (generate-temporaries opts)]  ; whether supplied
-                    [needed-kws (sort (syntax->list #'need-kw)
-                                      (lambda (a b) (keyword<? (syntax-e a) (syntax-e b))))]
-                    [sorted-kws (sort (map list kws kw-args kw-arg?s kw-reqs)
-                                      (lambda (a b) (keyword<? (syntax-e (car a))
-                                                               (syntax-e (car b)))))])
-               (with-syntax ([(kw-arg ...) kw-args]
-                             [(kw-arg? ...) (let loop ([kw-arg?s kw-arg?s]
-                                                       [kw-reqs kw-reqs])
-                                              (cond
-                                                [(null? kw-arg?s) null]
-                                                [(not (syntax-e (car kw-reqs)))
-                                                 (cons (car kw-arg?s) (loop (cdr kw-arg?s) (cdr kw-reqs)))]
-                                                [else (loop (cdr kw-arg?s) (cdr kw-reqs))]))]
-                             [kws-sorted sorted-kws]
-                             [(opt-arg ...) opt-args]
-                             [(opt-arg? ...) opt-arg?s]
-                             [(new-plain-id  ...) (generate-temporaries #'(plain-id ...))]
-                             [new-rest (if (null? (syntax-e #'rest))
-                                           '()
-                                           '(new-rest))]
-                             [(rest-id) (if (null? (syntax-e #'rest))
-                                            '(())
-                                            #'rest)]
-                             [rest-empty (if (null? (syntax-e #'rest))
-                                             '()
-                                             '(null))])
-                 (let ([with-core 
-                        (lambda (result)
-                          ;; body of procedure, where all keyword and optional
-                          ;; argments come in as a pair of arguments (value and
-                          ;; whether the value is valid):
-                          (syntax-property
-                           (quasisyntax/loc stx
-                             ;; We need to push the certificates way down, so that
-                             ;; the `class' macro (for example) can pull it apart
-                             ;; enough to insert an additional argument.
-                             (let #,(syntax-property
-                                     #`(#,(syntax-property
-                                           #`[core 
-                                              #,(syntax-property
-                                                 #`(lambda #,(syntax-property
-                                                              #`(given-kws given-args
-                                                                           new-plain-id ... 
-                                                                           opt-arg ...
-                                                                           opt-arg? ...
-                                                                           . new-rest)
-                                                              'certify-mode
-                                                              'transparent)
-                                                     ;; sort out the arguments into the user-supplied bindings,
-                                                     ;; evaluating default-values expressions as needed:
-                                                     (let-kws given-kws given-args kws-sorted
-                                                              (let-maybe ([id opt-expr kind] ... . rest)
-                                                                         (kw-arg ...) (kw-arg? ...)
-                                                                         (opt-arg ...) (opt-arg? ...)
-                                                                         (new-plain-id ... . new-rest)
-                                                                         ;; the original body, finally:
-                                                                         body1 body ...)))
-                                                 'certify-mode
-                                                 'transparent)]
-                                           'certify-mode
-                                           'transparent))
-                                     'certify-mode
-                                     'transparent)
-                               ;; entry points use `core':
-                               #,result))
-                           'certify-mode
-                           'transparent))]
-                       [mk-no-kws
-                        (lambda ()
-                          ;; entry point without keywords:
-                          (syntax/loc stx
-                            (opt-cases (core null null) ([opt-id opt-arg opt-arg?] ...) (plain-id ...) 
-                                       () (rest-empty rest-id . rest)
-                                       ())))]
-                       [mk-with-kws
-                        (lambda ()
-                          ;; entry point with keywords:
-                          (if (and (null? opts)
-                                   (null? #'new-rest))
-                              #'core
-                              (syntax/loc stx
-                                (opt-cases (core) ([opt-id opt-arg opt-arg?] ...) (given-kws given-args plain-id ...) 
-                                           () (rest-empty rest-id . rest)
-                                           ()))))]
-                       [mk-kw-arity-stub
-                        (lambda ()
-                          ;; struct-type entry point for no keywords when a keyword is required
-                          (syntax/loc stx
-                            (fail-opt-cases (missing-kw) (opt-id ...) (self plain-id ...) 
-                                            () (rest-id . rest)
-                                            ())))])
-                   (cond
-                     [(null? kws)
-                      ;; just the no-kw part
-                      (with-core (mk-no-kws))]
-                     [(null? needed-kws)
-                      ;; both parts dispatch to core
-                      (with-core
-                       (with-syntax ([kws (map car sorted-kws)]
-                                     [no-kws (let ([p (mk-no-kws)]
-                                                   [n (syntax-local-infer-name stx)])
-                                               (if n
-                                                   #`(let ([#,n #,p]) #,n)
-                                                   p))]
-                                     [with-kws (mk-with-kws)])
-                         (syntax/loc stx
-                           (make-optional-keyword-procedure
-                            with-kws
-                            null
-                            'kws
-                            no-kws))))]
-                     [else
-                      ;; just the keywords part dispatches to core,
-                      ;; and the other part dispatches to failure
-                      (with-core
-                       (with-syntax ([kws (map car sorted-kws)]
-                                     [needed-kws needed-kws]
-                                     [no-kws (mk-no-kws)]
-                                     [with-kws (mk-with-kws)]
-                                     [mk-id (with-syntax ([n (syntax-local-infer-name stx)]
-                                                          [call-fail (mk-kw-arity-stub)])
-                                              (syntax-local-lift-expression
-                                               #'(make-required 'n call-fail)))])
-                         (syntax/loc stx
-                           (mk-id
-                            with-kws
-                            'needed-kws
-                            'kws))))]))))))]))
+  (define-syntaxes (new-lambda new-λ)
+    (let ([new-lambda
+           (lambda (stx)
+             (syntax-case stx ()
+               [(_ args body1 body ...)
+                (if (simple-args? #'args)
+                    ;; Use plain old `lambda':
+                    (syntax/loc stx
+                      (lambda args body1 body ...))
+                    ;; Handle keyword or optional arguments:
+                    (with-syntax ([((plain-id ...)
+                                    (opt-id ...)
+                                    ([id opt-expr kind] ...)
+                                    ([kw kw-id kw-req] ...)
+                                    need-kw
+                                    rest)
+                                   (parse-formals stx #'args)])
+                      (let ([dup-id (check-duplicate-identifier (syntax->list #'(id ... . rest)))])
+                        (when dup-id
+                          (raise-syntax-error
+                           #f
+                           "duplicate argument identifier"
+                           stx
+                           dup-id)))
+                      (let* ([kws (syntax->list #'(kw ...))]
+                             [opts (syntax->list #'(opt-id ...))]
+                             [ids (syntax->list #'(id ...))]
+                             [plain-ids (syntax->list #'(plain-id ...))]
+                             [kw-reqs (syntax->list #'(kw-req ...))]
+                             [kw-args (generate-temporaries kws)]     ; to hold supplied value
+                             [kw-arg?s (generate-temporaries kws)]    ; to indicated whether it was supplied
+                             [opt-args (generate-temporaries opts)]   ; supplied value
+                             [opt-arg?s (generate-temporaries opts)]  ; whether supplied
+                             [needed-kws (sort (syntax->list #'need-kw)
+                                               (lambda (a b) (keyword<? (syntax-e a) (syntax-e b))))]
+                             [sorted-kws (sort (map list kws kw-args kw-arg?s kw-reqs)
+                                               (lambda (a b) (keyword<? (syntax-e (car a))
+                                                                        (syntax-e (car b)))))])
+                        (with-syntax ([(kw-arg ...) kw-args]
+                                      [(kw-arg? ...) (let loop ([kw-arg?s kw-arg?s]
+                                                                [kw-reqs kw-reqs])
+                                                       (cond
+                                                        [(null? kw-arg?s) null]
+                                                        [(not (syntax-e (car kw-reqs)))
+                                                         (cons (car kw-arg?s) (loop (cdr kw-arg?s) (cdr kw-reqs)))]
+                                                        [else (loop (cdr kw-arg?s) (cdr kw-reqs))]))]
+                                      [kws-sorted sorted-kws]
+                                      [(opt-arg ...) opt-args]
+                                      [(opt-arg? ...) opt-arg?s]
+                                      [(new-plain-id  ...) (generate-temporaries #'(plain-id ...))]
+                                      [new-rest (if (null? (syntax-e #'rest))
+                                                    '()
+                                                    '(new-rest))]
+                                      [(rest-id) (if (null? (syntax-e #'rest))
+                                                     '(())
+                                                     #'rest)]
+                                      [rest-empty (if (null? (syntax-e #'rest))
+                                                      '()
+                                                      '(null))])
+                          (let ([with-core 
+                                 (lambda (result)
+                                   ;; body of procedure, where all keyword and optional
+                                   ;; argments come in as a pair of arguments (value and
+                                   ;; whether the value is valid):
+                                   (syntax-property
+                                    (quasisyntax/loc stx
+                                      ;; We need to push the certificates way down, so that
+                                      ;; the `class' macro (for example) can pull it apart
+                                      ;; enough to insert an additional argument.
+                                      (let #,(syntax-property
+                                              #`(#,(syntax-property
+                                                    #`[core 
+                                                       #,(syntax-property
+                                                          #`(lambda #,(syntax-property
+                                                                       #`(given-kws given-args
+                                                                                    new-plain-id ... 
+                                                                                    opt-arg ...
+                                                                                    opt-arg? ...
+                                                                                    . new-rest)
+                                                                       'certify-mode
+                                                                       'transparent)
+                                                              ;; sort out the arguments into the user-supplied bindings,
+                                                              ;; evaluating default-values expressions as needed:
+                                                              (let-kws given-kws given-args kws-sorted
+                                                                       (let-maybe ([id opt-expr kind] ... . rest)
+                                                                                  (kw-arg ...) (kw-arg? ...)
+                                                                                  (opt-arg ...) (opt-arg? ...)
+                                                                                  (new-plain-id ... . new-rest)
+                                                                                  ;; the original body, finally:
+                                                                                  body1 body ...)))
+                                                          'certify-mode
+                                                          'transparent)]
+                                                    'certify-mode
+                                                    'transparent))
+                                              'certify-mode
+                                              'transparent)
+                                        ;; entry points use `core':
+                                        #,result))
+                                    'certify-mode
+                                    'transparent))]
+                                [mk-no-kws
+                                 (lambda ()
+                                   ;; entry point without keywords:
+                                   (syntax/loc stx
+                                     (opt-cases (core null null) ([opt-id opt-arg opt-arg?] ...) (plain-id ...) 
+                                                () (rest-empty rest-id . rest)
+                                                ())))]
+                                [mk-with-kws
+                                 (lambda ()
+                                   ;; entry point with keywords:
+                                   (if (and (null? opts)
+                                            (null? #'new-rest))
+                                       #'core
+                                       (syntax/loc stx
+                                         (opt-cases (core) ([opt-id opt-arg opt-arg?] ...) (given-kws given-args plain-id ...) 
+                                                    () (rest-empty rest-id . rest)
+                                                    ()))))]
+                                [mk-kw-arity-stub
+                                 (lambda ()
+                                   ;; struct-type entry point for no keywords when a keyword is required
+                                   (syntax/loc stx
+                                     (fail-opt-cases (missing-kw) (opt-id ...) (self plain-id ...) 
+                                                     () (rest-id . rest)
+                                                     ())))])
+                            (cond
+                             [(null? kws)
+                              ;; just the no-kw part
+                              (with-core (mk-no-kws))]
+                             [(null? needed-kws)
+                              ;; both parts dispatch to core
+                              (with-core
+                               (with-syntax ([kws (map car sorted-kws)]
+                                             [no-kws (let ([p (mk-no-kws)]
+                                                           [n (syntax-local-infer-name stx)])
+                                                       (if n
+                                                           #`(let ([#,n #,p]) #,n)
+                                                           p))]
+                                             [with-kws (mk-with-kws)])
+                                 (syntax/loc stx
+                                   (make-optional-keyword-procedure
+                                    with-kws
+                                    null
+                                    'kws
+                                    no-kws))))]
+                             [else
+                              ;; just the keywords part dispatches to core,
+                              ;; and the other part dispatches to failure
+                              (with-core
+                               (with-syntax ([kws (map car sorted-kws)]
+                                             [needed-kws needed-kws]
+                                             [no-kws (mk-no-kws)]
+                                             [with-kws (mk-with-kws)]
+                                             [mk-id (with-syntax ([n (syntax-local-infer-name stx)]
+                                                                  [call-fail (mk-kw-arity-stub)])
+                                                      (syntax-local-lift-expression
+                                                       #'(make-required 'n call-fail)))])
+                                 (syntax/loc stx
+                                   (mk-id
+                                    with-kws
+                                    'needed-kws
+                                    'kws))))]))))))]))])
+      (values new-lambda new-lambda)))
   
   (define (missing-kw proc . args)
     (apply
diff --git a/collects/scheme/private/pre-base.ss b/collects/scheme/private/pre-base.ss
index b7d935558a..eb53bee392 100644
--- a/collects/scheme/private/pre-base.ss
+++ b/collects/scheme/private/pre-base.ss
@@ -30,7 +30,7 @@
              (all-from "define.ss")
              (all-from-except "letstx-scheme.ss" -define -define-syntax -define-struct)
              (rename new-lambda lambda)
-             (rename new-lambda λ)
+             (rename new-λ λ)
              (rename new-define define)
              (rename new-app #%app)
              (rename #%app #%plain-app)
diff --git a/collects/scribble/base-render.ss b/collects/scribble/base-render.ss
index 5006a34503..86951b1261 100644
--- a/collects/scribble/base-render.ss
+++ b/collects/scribble/base-render.ss
@@ -119,11 +119,11 @@
             (hash-table-for-each (collect-info-ht p-ci)
                                  (lambda (k v)
                                    (when (cadr k)
-                                     (hash-table-put! (collect-info-ht ci)
-                                                      (if prefix
-                                                          (convert-key prefix k)
-                                                          k)
-                                                      v)))))))
+                                     (collect-put! ci
+                                                   (if prefix
+                                                       (convert-key prefix k)
+                                                       k)
+                                                   v)))))))
 
       (define/private (convert-key prefix k)
         (case (car k)
diff --git a/collects/scribble/manual.ss b/collects/scribble/manual.ss
index b3796e40c2..c347a05796 100644
--- a/collects/scribble/manual.ss
+++ b/collects/scribble/manual.ss
@@ -780,7 +780,7 @@
                            (table? (car (splice-run box)))
                            (eq? 'boxed (table-style (car (splice-run box)))))
                 (error 'deftogether "element is not a boxing splice containing a single table: ~e" box))
-              (list (make-flow (list (make-table #f (table-flowss (car (splice-run box))))))))
+              (list (make-flow (list (make-table "together" (table-flowss (car (splice-run box))))))))
             boxes))
       (parameterize ([current-variable-list
                       (apply append (map box-splice-var-list boxes))])
diff --git a/collects/scribble/scribble.css b/collects/scribble/scribble.css
index 4ab5f22088..371915853b 100644
--- a/collects/scribble/scribble.css
+++ b/collects/scribble/scribble.css
@@ -253,6 +253,10 @@
                  background-color: #E8E8FF;
                }
 
+               .together { 
+                 width: 100%;
+               }
+
                .prototype td { 
                  vertical-align: top;
                }
diff --git a/collects/scribble/struct.ss b/collects/scribble/struct.ss
index f11475f86c..a4616ee867 100644
--- a/collects/scribble/struct.ss
+++ b/collects/scribble/struct.ss
@@ -15,9 +15,12 @@
 
 
   (define (collect-put! ci key val)
-    (hash-table-put! (collect-info-ht ci)
-                     key
-                     val))
+    (let ([ht (collect-info-ht ci)])
+      (when (hash-table-get ht key #f)
+        (fprintf (current-error-port)
+                 "WARNING: collected information for key multiple times: ~e\n"
+                 key))
+      (hash-table-put! ht key val)))
 
   (define (resolve-get/where part ri key)
     (let ([key (tag-key key ri)])
diff --git a/collects/scribblings/gui/editor-overview.scrbl b/collects/scribblings/gui/editor-overview.scrbl
index 0017f26d15..7897943940 100644
--- a/collects/scribblings/gui/editor-overview.scrbl
+++ b/collects/scribblings/gui/editor-overview.scrbl
@@ -82,11 +82,11 @@ Now, the standard cut and paste operations work, and the user can even
  on the outside of the box is rearranged as the box changes
  sizes. Note that the box itself can be copied and pasted.
 
-The content of an editor is made up of @deftech{snips}. An embedded
- editor is a single snip from the embedding editor's point-of-view. To
- encode immediate text, a snip can be a single character, but more
- often a snip is a sequence of adjacent characters on the same
- line. The @method[text% find-snip] method extracts a snip
+The content of an editor is made up of @defterm{@tech{snips}}. An
+ embedded editor is a single snip from the embedding editor's
+ point-of-view. To encode immediate text, a snip can be a single
+ character, but more often a snip is a sequence of adjacent characters
+ on the same line. The @method[text% find-snip] method extracts a snip
  from a text editor:
 
 @schemeblock[
@@ -396,15 +396,15 @@ Graceful and extensible encoding of snips requires that
  @item{Some editors may require additional information to be stored
  about a snip; this information is orthogonal to the type-specific
  information stored by the snip itself. For example, a pasteboard
- needs to remember a snip's @techlink{location}, while a text editor does not
- need this information.  If data is being cut and pasted from one
- pasteboard to another, then information about relative @techlink{location}s
- needs to be maintained, but this information should not inhibit
- pasting into an editor. Extra data is associated with a snip through
- @deftech{editor data} objects, instances of the
- @scheme[editor-data%] class; decoding requires that each editor data
- object has an @deftech{editor data class}, an instance of the
- @scheme[editor-data-class%] class.}
+ needs to remember a snip's @techlink{location}, while a text editor
+ does not need this information.  If data is being cut and pasted from
+ one pasteboard to another, then information about relative
+ @techlink{location}s needs to be maintained, but this information
+ should not inhibit pasting into an editor. Extra data is associated
+ with a snip through @deftech{editor data} objects, which are
+ instances of the @scheme[editor-data%] class; decoding requires that
+ each editor data object has an @deftech{editor data class}, which is
+ an instance of the @scheme[editor-data-class%] class.}
 
 }
 
@@ -415,7 +415,7 @@ Snip classes, snip data, and snip data classes solve problems related
 
 @subsubsection[#:tag "editorsnipclasses"]{Snip Classes}
 
-Each snip can be associated to a @deftech{snip class}. This ``class''
+Each snip can be associated to a @tech{snip class}. This ``class''
  is not a class description in the programmer's language; it is an
  object which provides a way to create new snips of the appropriate
  type from an encoded snip specification.
@@ -455,12 +455,12 @@ A snip class's name can also be just @scheme["(lib ...)"], which is
 While a snip belongs to an editor, the editor may store extra
  information about a snip in some specialized way. When the snip is to
  be encoded, this extra information needs to be put into an
- @deftech{editor data} object so that the extra information can be
+ @tech{editor data} object so that the extra information can be
  encoded as well.  In a text editor, extra information can be
  associated with ranges of @techlink{item}s, as well as snips.
 
 Just as a snip must be associated with a snip class to be decoded (see
- @|snipclassdiscuss|), an editor data object needs an @deftech{editor
+ @|snipclassdiscuss|), an editor data object needs an @tech{editor
  data class} for decoding. Every editor data class object can be added
  to the eventspace-specific @deftech{editor data class list}, returned
  by @scheme[get-the-editor-data-class-list]. Alternatively, like snip
diff --git a/collects/scribblings/gui/guide.scrbl b/collects/scribblings/gui/guide.scrbl
index 0e8b02cec5..22fe87efc5 100644
--- a/collects/scribblings/gui/guide.scrbl
+++ b/collects/scribblings/gui/guide.scrbl
@@ -8,17 +8,17 @@ For documentation purposes, the MrEd toolbox is organized into three
 
 @itemize{
 
- @item{The @deftech{windowing} toolbox, for implementing form-filling
+ @item{The @deftech{windowing toolbox}, for implementing form-filling
  GUI programs (such as a database query window) using buttons, menus,
  text fields, and events. The windowing toolbox is described in
  @secref["windowing-overview"].}
 
- @item{The @deftech{drawing} toolbox, for drawing pictures or
+ @item{The @deftech{drawing toolbox}, for drawing pictures or
  implementing dynamic GUI programs (such as a video game) using
  drawing canvases, pens, and brushes. The drawing toolbox is
  described in @secref["drawing-overview"].}
 
- @item{The @deftech{editor} toolbox, for developing traditional text
+ @item{The @deftech{editor toolbox}, for developing traditional text
  editors, editors that mix text and graphics, or free-form layout
  editors (such as a word processor, HTML editor, or icon-based file
  browser).  The editor toolbox is described in
diff --git a/collects/scribblings/gui/win-overview.scrbl b/collects/scribblings/gui/win-overview.scrbl
index 7000caab8e..5e00e16ef0 100644
--- a/collects/scribblings/gui/win-overview.scrbl
+++ b/collects/scribblings/gui/win-overview.scrbl
@@ -109,7 +109,7 @@ In addition to dispatching events, the GUI classes also handle the
  graphical layout of windows. Our example frame demonstrates a simple
  layout; the frame's elements are lined up top-to-bottom. In general,
  a programmer specifies the layout of a window by assigning each GUI
- element to a parent @deftech{container}. A vertical container, such
+ element to a parent @tech{container}. A vertical container, such
  as a frame, arranges its children in a column, and a horizontal
  container arranges its children in a row. A container can be a child
  of another container; for example, to place two buttons side-by-side
@@ -296,9 +296,9 @@ Menu bars, menus, and menu items are graphical elements, but not areas
   @item{@scheme[separator-menu-item%] --- a @deftech{separator} is
   an unselectable line in a menu or popup menu.}
 
-  @item{@scheme[menu-item%] --- a @deftech{menu item} is a selectable
-  text item in a menu. When the item is selected, its callback procedure
-  is invoked.}
+  @item{@scheme[menu-item%] --- a @deftech{plain menu item} is a
+  selectable text item in a menu. When the item is selected, its
+  callback procedure is invoked.}
 
   @item{@scheme[checkable-menu-item%] --- a @deftech{checkable menu
   item} is a text item in a menu; the user selects a checkable menu
@@ -405,7 +405,7 @@ Each @tech{containee}, or child, has the following properties:
 
  @item{horizontal and vertical @deftech{stretchability} (on or off); and}
 
- @item{horizontal and vertical @deftech{margins}.}
+ @item{horizontal and vertical @tech{margins}.}
 
 }
 
@@ -822,7 +822,7 @@ Although a programmer has no direct control over the order in which
 
 @subsection[#:tag "espacethreads"]{Eventspaces and Threads}
 
-When a new eventspace is created, a corresponding @deftech{handler
+When a new eventspace is created, a corresponding @tech{handler
  thread} is created for the eventspace. When the system dispatches an
  event for an eventspace, it always does so in the eventspace's
  handler thread. A handler procedure can create new threads that run
diff --git a/collects/scribblings/gui/wxme.scrbl b/collects/scribblings/gui/wxme.scrbl
index 5548f1c6d2..2837aaf9df 100644
--- a/collects/scribblings/gui/wxme.scrbl
+++ b/collects/scribblings/gui/wxme.scrbl
@@ -435,7 +435,7 @@ special comment contains the comment text.}
 A text-mode reader for XML boxes.}]
 
 
-@defclass[comment-editor% editor% (readable<%>)]{
+@defclass[xml-editor% editor% (readable<%>)]{
 
 Instantiated for DrScheme XML boxes in a @tech{WXME} stream for text
 mode.
@@ -469,7 +469,7 @@ Scheme boxes.}
 A text-mode reader for Scheme boxes.}]
 
 
-@defclass[comment-editor% editor% (readable<%>)]{
+@defclass[scheme-editor% editor% (readable<%>)]{
 
 Instantiated for DrScheme Scheme boxes in a @tech{WXME} stream for text
 mode.
@@ -493,15 +493,15 @@ Generates an S-expression for the code in the box.}
 
 @section{DrScheme Text Boxes}
 
-@defmodule[wxme/scheme]
+@defmodule[wxme/text]
 
-@in[wxme/scheme
+@in[wxme/text
 @defthing[reader (is-a?/c snip-reader<%>)]{
 
 A text-mode reader for text boxes.}]
 
 
-@defclass[comment-editor% editor% (readable<%>)]{
+@defclass[text-editor% editor% (readable<%>)]{
 
 Instantiated for DrScheme text boxes in a @tech{WXME} stream for text
 mode.
diff --git a/collects/scribblings/guide/guide.scrbl b/collects/scribblings/guide/guide.scrbl
index 788e730036..88104bf539 100644
--- a/collects/scribblings/guide/guide.scrbl
+++ b/collects/scribblings/guide/guide.scrbl
@@ -92,7 +92,7 @@ printed output.
 
 
 @; ----------------------------------------------------------------------
-@section[#:tag "macros"]{Reader Extension}
+@section[#:tag "reader"]{Reader Extension}
 
 @; ----------------------------------------------------------------------
 @section[#:tag "security"]{Security}
diff --git a/collects/scribblings/guide/namespaces.scrbl b/collects/scribblings/guide/namespaces.scrbl
index b34870e6c8..5f021e5b32 100644
--- a/collects/scribblings/guide/namespaces.scrbl
+++ b/collects/scribblings/guide/namespaces.scrbl
@@ -93,8 +93,8 @@ initial module mapping, further modules can be loaded.
 
 A namespace created with @scheme[make-base-empty-namespace] is
 suitable for many basic dynamic tasks. For example, suppose that a
-@schememodname[my-dsl] library implements a domain-specific language in
-which you want to execute commands from a user-specified file. A
+@schememodfont{my-dsl} library implements a domain-specific language
+in which you want to execute commands from a user-specified file. A
 namespace created with @scheme[make-base-empty-namespace] is enough to
 get started:
 
diff --git a/collects/scribblings/inside/ports.scrbl b/collects/scribblings/inside/ports.scrbl
index 3a492ef8a0..840ca1a71b 100644
--- a/collects/scribblings/inside/ports.scrbl
+++ b/collects/scribblings/inside/ports.scrbl
@@ -815,7 +815,7 @@ is made if @var{copy} is not 0. The string @var{bytes} should contain
 nul terminator in addition. If @var{len} is negative, then the
 nul-terminated length of @var{bytes} is used for the length.}
 
-@function[(Scheme_Object* scheme_make_sized_path
+@function[(Scheme_Object* scheme_make_sized_offset_path
            [char* bytes]
            [long d]
            [long len]
diff --git a/collects/scribblings/quick/quick.scrbl b/collects/scribblings/quick/quick.scrbl
index 79b243404b..28cfc19ce1 100644
--- a/collects/scribblings/quick/quick.scrbl
+++ b/collects/scribblings/quick/quick.scrbl
@@ -517,12 +517,13 @@ interfaces. The API for Scheme's GUI and graphics system is expressed
 in terms of objects and classes.
 
 The class system itself is implemented by the
-@schememodname[scheme/class] library, and the @schememodname[mred]
-library provides the GUI and drawing classes. By convention, the MrEd
-classes are given names that end with @scheme[%]:
+@schememodname[scheme/class] library, and the
+@schememodname[scheme/gui/base] library provides the GUI and drawing
+classes. By convention, the classes are given names that end with
+@scheme[%]:
 
 @mr-defs+int[
-[(require scheme/class mred)
+[(require scheme/class scheme/gui/base)
  (define f (new frame% [label "My Art"]
                        [width 300]
                        [height 300]
@@ -539,8 +540,8 @@ such as @scheme[show], with arguments after the method name; the
 argument @scheme[#t] in this case is the boolean constant ``true.''
 
 Pictures generated with @schememodname[slideshow] encapsulate a
-function that uses MrEd's drawing commands to render the picture to a
-drawing context, such as a canvas in a frame. The
+function that uses the graphics toolbox's drawing commands to render
+the picture to a drawing context, such as a canvas in a frame. The
 @scheme[make-pict-drawer] function from @schememodname[slideshow]
 exposes a picture's drawing function. We can use
 @scheme[make-pict-drawer] in a canvas-painting callback to draw a
diff --git a/collects/scribblings/reference/class.scrbl b/collects/scribblings/reference/class.scrbl
index 747fa5cea7..b05a677c37 100644
--- a/collects/scribblings/reference/class.scrbl
+++ b/collects/scribblings/reference/class.scrbl
@@ -90,10 +90,11 @@ A @deftech{class} specifies
 
 }
 
-An @deftech{object} is a collection of bindings for fields that are
-instantiated according to a class description.
+In the context of the class system, an @defterm{object} is a
+collection of bindings for fields that are instantiated according to a
+class description.
 
-The object system allows a program to define a new class (a
+The class system allows a program to define a new class (a
 @deftech{derived class}) in terms of an existing class (the
 @deftech{superclass}) using inheritance, overriding, and augmenting:
 
diff --git a/collects/scribblings/reference/control-lib.scrbl b/collects/scribblings/reference/control-lib.scrbl
index 6ce45ebc36..7f154aa906 100644
--- a/collects/scribblings/reference/control-lib.scrbl
+++ b/collects/scribblings/reference/control-lib.scrbl
@@ -16,7 +16,7 @@ work sensibly together. Many are redundant; for example,
  
 @deftogether[(
 @defform[(% expr)]
-@defform[(% expr handler-expr)]
+@defform/none[(% expr handler-expr)]
 @defproc[(fcontrol [v any/c]) any]
 )]{
 
diff --git a/collects/scribblings/reference/encodings.scrbl b/collects/scribblings/reference/encodings.scrbl
index 492ebdea6d..b0c1a1e0d4 100644
--- a/collects/scribblings/reference/encodings.scrbl
+++ b/collects/scribblings/reference/encodings.scrbl
@@ -76,7 +76,7 @@ UTF-8 for encoding.
 
 @defparam[current-locale locale (or/c string? false/c)]{
 
-A parameter that determines the current @deftech{locale} for
+A parameter that determines the current @tech{locale} for
 procedures such as @scheme[string-locale-ci=?].
 
 When locale sensitivity is disabled by setting the parameter to
diff --git a/collects/scribblings/reference/help.scrbl b/collects/scribblings/reference/help.scrbl
index a1aa43a7e8..4e266d2059 100644
--- a/collects/scribblings/reference/help.scrbl
+++ b/collects/scribblings/reference/help.scrbl
@@ -17,9 +17,9 @@ arguments. It is not provided by @scheme[scheme] or
 
 @deftogether[(
 @defidform[help]
-@defform[(help id)]
-@defform[(help id #:from module-path)]
-@defform[(help #:search datum ...)]
+@defform/none[(help id)]
+@defform/none[(help id #:from module-path)]
+@defform/none[(help #:search datum ...)]
 )]{
 
 Searches the documentation, and opens a web browser (using the user's
diff --git a/collects/scribblings/reference/memory.scrbl b/collects/scribblings/reference/memory.scrbl
index 3cc8208271..2181b34908 100644
--- a/collects/scribblings/reference/memory.scrbl
+++ b/collects/scribblings/reference/memory.scrbl
@@ -9,13 +9,14 @@
 
 A @deftech{weak box} is similar to a normal box (see
 @secref["boxes"]), but when the garbage collector (see
-@secref["gc-model"]) can prove that the content value of a weak box
-is only reachable via weak references, the content of the weak box is
-replaced with @scheme[#f]. A @deftech{weak reference} is a reference
-through a weak box, through a key reference in a weak hash table (see
-@secref["hashtables"]), through a value in an ephemeron where the
-value can be replaced by @scheme[#f] (see @secref["ephemerons"]), or
-through a custodian (see @secref["custodians"]).
+@secref["gc-model"]) can prove that the content value of a weak box is
+only reachable via weak references, the content of the weak box is
+replaced with @scheme[#f]. A @defterm{@tech{weak reference}} is a
+reference through a weak box, through a key reference in a weak hash
+table (see @secref["hashtables"]), through a value in an ephemeron
+where the value can be replaced by @scheme[#f] (see
+@secref["ephemerons"]), or through a custodian (see
+@secref["custodians"]).
 
 @defproc[(make-weak-box [v any/c]) weak-box?]{
 
diff --git a/collects/scribblings/reference/port-lib.scrbl b/collects/scribblings/reference/port-lib.scrbl
index 485f9fccf6..82e1e6e259 100644
--- a/collects/scribblings/reference/port-lib.scrbl
+++ b/collects/scribblings/reference/port-lib.scrbl
@@ -2,7 +2,7 @@
 @require["mz.ss"
          (for-label scheme/port)]
 
-@title[#:tag "customport"]{More Port Constructors and Events}
+@title{More Port Constructors and Events}
 
 @note-lib[scheme/port]
 
diff --git a/collects/scribblings/reference/stx-certs.scrbl b/collects/scribblings/reference/stx-certs.scrbl
index 9f8d8847b5..0b548fa43e 100644
--- a/collects/scribblings/reference/stx-certs.scrbl
+++ b/collects/scribblings/reference/stx-certs.scrbl
@@ -10,8 +10,8 @@ module name (see @secref["modpathidx"]), an @tech{inspector} (see
 is attached as either an @deftech{active certificate} or an
 @deftech{inactive certificate}.
 
-The @scheme[datum->syntax] procedure never transfers an
-@deftech{active certificate} from one syntax object to another. The
+The @scheme[datum->syntax] procedure never transfers an @tech{active
+certificate} from one syntax object to another. The
 @scheme[syntax-recertify] procedure can be used to transfer a
 certificate from one syntax object to another, but only if the
 certificate's key is provided, or if a sufficiently powerful inspector
diff --git a/collects/scribblings/reference/stx-expand.scrbl b/collects/scribblings/reference/stx-expand.scrbl
index 378db10126..e6ab0d2eeb 100644
--- a/collects/scribblings/reference/stx-expand.scrbl
+++ b/collects/scribblings/reference/stx-expand.scrbl
@@ -1,7 +1,7 @@
 #lang scribble/doc
 @require["mz.ss"]
 
-@title[#:tag "expansion"]{Expanding Top-Level Forms}
+@title{Expanding Top-Level Forms}
 
 
 @defproc[(expand [top-level-form any/c]) syntax?]{
diff --git a/collects/scribblings/reference/stx-props.scrbl b/collects/scribblings/reference/stx-props.scrbl
index cb024afffb..ae5fde7418 100644
--- a/collects/scribblings/reference/stx-props.scrbl
+++ b/collects/scribblings/reference/stx-props.scrbl
@@ -98,19 +98,18 @@ information on properties and byte codes.
 
 @;------------------------------------------------------------------------
 
-@defproc[(syntax-property [stx syntax?][key any/c][v any/c])
-         syntax?]{
+@defproc*[([(syntax-property [stx syntax?][key any/c][v any/c])
+            syntax?]
+           [(syntax-property [stx syntax?][key any/c]) any])]{
 
-Extends @scheme[stx] by associating an arbitrary property value
-@scheme[v] with the key @scheme[key]; the result is a new syntax
-object with the association (while @scheme[stx] itself is unchanged).}
+The three-argument form extends @scheme[stx] by associating an
+arbitrary property value @scheme[v] with the key @scheme[key]; the
+result is a new syntax object with the association (while @scheme[stx]
+itself is unchanged).
 
-
-@defproc[(syntax-property [stx syntax?][key any/c]) any]{
-
-Returns an arbitrary property value associated to @scheme[stx] with
-the key @scheme[key], or @scheme[#f] if no value is associated to
-@scheme[stx] for @scheme[key].}
+The two-argument form returns an arbitrary property value associated
+to @scheme[stx] with the key @scheme[key], or @scheme[#f] if no value
+is associated to @scheme[stx] for @scheme[key].}
 
 
 @defproc[(syntax-property-symbol-keys [stx syntax?]) list?]{
diff --git a/collects/scribblings/reference/syntax-model.scrbl b/collects/scribblings/reference/syntax-model.scrbl
index ad6f1c31ea..c372759127 100644
--- a/collects/scribblings/reference/syntax-model.scrbl
+++ b/collects/scribblings/reference/syntax-model.scrbl
@@ -458,7 +458,7 @@ time, rather than run time (though the two times can overlap), though
 the binding itself is introduced with @tech{phase level} 0 (i.e., in
 the @tech{base environment}).
 
-The @deftech{value} for the binding is obtained by evaluating the
+The @tech{value} for the binding is obtained by evaluating the
 expression in the @scheme[define-syntaxes] form. This expression must
 be @tech{expand}ed (i.e. parsed) before it can be evaluated, and it is
 expanded at @tech{phase level} 1 (i.e., in the @tech{transformer
diff --git a/collects/scribblings/reference/syntax.scrbl b/collects/scribblings/reference/syntax.scrbl
index 4a249e9d8f..5f210ec080 100644
--- a/collects/scribblings/reference/syntax.scrbl
+++ b/collects/scribblings/reference/syntax.scrbl
@@ -331,7 +331,7 @@ the procedure body.
 (let ([f (lambda (x #:arg y) (list y x))])
  (list (f 1 #:arg 2)
        (f #:arg 2 1)))
-]}
+]
 
 When compiling a @scheme[lambda] or @scheme[case-lambda] expression,
 Scheme looks for a @indexed-scheme['method-arity-error] property
@@ -343,7 +343,7 @@ will hide the first argument, if one was provided. (Hiding the first
 argument is useful when the procedure implements a method, where the
 first argument is implicit in the original source). The property
 affects only the format of @scheme[exn:fail:contract:arity]
-exceptions, not the result of @scheme[procedure-arity].
+exceptions, not the result of @scheme[procedure-arity].}
 
 
 @defform/subs[(case-lambda [formals body ...+] ...)
diff --git a/collects/scribblings/reference/thread-cells.scrbl b/collects/scribblings/reference/thread-cells.scrbl
index ca4bf4063f..a2eb0bb1da 100644
--- a/collects/scribblings/reference/thread-cells.scrbl
+++ b/collects/scribblings/reference/thread-cells.scrbl
@@ -3,8 +3,8 @@
 
 @title[#:tag "threadcells"]{Thread Cells}
 
-A @deftech{thread cell} contains a thread-specific value; that is, it
-contains a specific value for each thread, but it may contain
+A @defterm{@tech{thread cell}} contains a thread-specific value; that
+is, it contains a specific value for each thread, but it may contain
 different values for different threads. A thread cell is created with
 a default value that is used for all existing threads. When the cell's
 content is changed with @scheme[thread-cell-set!], the cell's value
@@ -12,12 +12,12 @@ changes only for the current thread. Similarly,
 @scheme[thread-cell-ref] obtains the value of the cell that is
 specific to the current thread.
 
-A thread cell's value can be @deftech{preserved}, which means that
-when a new thread is created, the cell's initial value for the new
-thread is the same as the creating thread's current value. If a thread
-cell is non-preserved, then the cell's initial value for a newly
-created thread is the default value (which was supplied when the cell
-was created).
+A thread cell's value can be @defterm{@tech{preserved}}, which means
+that when a new thread is created, the cell's initial value for the
+new thread is the same as the creating thread's current value. If a
+thread cell is non-preserved, then the cell's initial value for a
+newly created thread is the default value (which was supplied when the
+cell was created).
 
 Within the current thread, the current values of all preserved threads
 cells can be captured through
diff --git a/collects/scribblings/scribble/how-to.scrbl b/collects/scribblings/scribble/how-to.scrbl
index 4bec9e8e4d..09e785f011 100644
--- a/collects/scribblings/scribble/how-to.scrbl
+++ b/collects/scribblings/scribble/how-to.scrbl
@@ -49,7 +49,7 @@ EOS
 
   @item{Run @exec{setup-plt} to build your documentation. For a
         collection, optionally supply @Flag{l} followed by the
-        collection name to limit the build process to the collection.}
+        collection name to limit the build process to that collection.}
 
   @item{The generated documentation is
         @filepath{compiled/doc/manual/index.html} within the
@@ -57,9 +57,9 @@ EOS
 
         If you want the output to be relative to the PLT Scheme
         documentation directory (which is recommend only for those who
-        produce the ``official'' PLT Scheme distribution), add the
-        @scheme['main-doc] option to the @scheme[scribblings]
-        definition in @filepath{info.ss}.}
+        produce the ``official'' PLT Scheme distribution, and even
+        then only in certain cases), add the @scheme['main-doc] option
+        to the @scheme[scribblings] definition in @filepath{info.ss}.}
 
 }
 
@@ -92,14 +92,14 @@ one must be present. No spaces are allowed between
 A @nonterm{cmd} or @nonterm{datum} is a Scheme datum, while a
 @nonterm{text-body} is itself in text mode.
 
-The expansion of a @litchar["@"] form into Scheme code is
+The expansion of @litchar["@"]@nonterm{cmd} into Scheme code is
 
 @schemeblock[
-  @nonterm{cmd}
+  #, @nonterm{cmd}
 ]
 
-if neither @litchar["["] @litchar["]"] nor @litchar["{"] @litchar["}"]
-are used, otherwise
+When either @litchar["["] @litchar["]"] or @litchar["{"] @litchar["}"]
+are used, the expansion is
 
 @schemeblock[
   (#, @nonterm{cmd} #, @kleenestar{@nonterm{datum}} #, @kleenestar{@nonterm{parsed-body}})
diff --git a/collects/scribblings/scribble/manual.scrbl b/collects/scribblings/scribble/manual.scrbl
index ec9fa2007d..f149da00cd 100644
--- a/collects/scribblings/scribble/manual.scrbl
+++ b/collects/scribblings/scribble/manual.scrbl
@@ -662,7 +662,7 @@ output, a hyperlink underline appears even when the mouse is not over
 the link.}
 
 @; ------------------------------------------------------------------------
-@section{Indexing}
+@section[#:tag "manual-indexing"]{Indexing}
 
 @defform[(indexed-scheme datum ...)]{
 
@@ -801,7 +801,7 @@ correspond to the documented name of the binding and the primary
 modules that export the documented name (but this list is not
 exhaustive, because new modules can re-export the binding).}
 
-@defstruct[(procedure-index-desc exported-index-desc) ()]{
+@defstruct[(form-index-desc exported-index-desc) ()]{
 
 Indicates that the index entry corresponds to the definition of a
 syntactic form via @scheme[defform] and company.}
diff --git a/collects/scribblings/slideshow/slides.scrbl b/collects/scribblings/slideshow/slides.scrbl
index 8148b9cea4..4c469c4221 100644
--- a/collects/scribblings/slideshow/slides.scrbl
+++ b/collects/scribblings/slideshow/slides.scrbl
@@ -377,6 +377,12 @@ Parameter that controls the amount of space used between lines by
 @scheme[para], @scheme[item], and @scheme[subitem].}
 
 
+@defparam[current-para-width n nonnegative-exact-integer?]{
+
+Parameter that controls the width of a pict created by
+@scheme[para], @scheme[item], and @scheme[subitem].}
+
+
 @defparam[current-title-color color (or/c string? (is-a?/c color%))]{
 
 Parameter used by the default @scheme[current-titlet] to colorize the