diff --git a/scribble-lib/scribble/core.rkt b/scribble-lib/scribble/core.rkt
index c7bc3bcb96..074c52f917 100644
--- a/scribble-lib/scribble/core.rkt
+++ b/scribble-lib/scribble/core.rkt
@@ -348,9 +348,9 @@
   (cond
    [(collect-info? i)
     (define p (hash-ref (collect-info-fp i) b #f))
-    (if (block? p)
-        p
-        (error 'traverse-block-block "no block computed for traverse-block: ~e" b))]
+    (unless (block? p)
+      (error 'traverse-block-block "no block computed for traverse-block: ~e" b))
+    p]
    [(resolve-info? i)
     (traverse-block-block b (resolve-info-ci i))]))
 
@@ -391,9 +391,9 @@
   (cond
    [(collect-info? i)
     (define c (hash-ref (collect-info-fp i) e #f))
-    (if (content? c)
-        c
-        (error 'traverse-block-block "no block computed for traverse-block: ~e" e))]
+    (unless (content? c)
+      (error 'traverse-block-block "no block computed for traverse-block: ~e" e))
+    c]
    [(resolve-info? i)
     (traverse-element-content e (resolve-info-ci i))]))
 
@@ -424,10 +424,10 @@
    (or (current-load-relative-directory) (current-directory)))
   #:transparent)
 
-(provide/contract
- (struct delayed-element ([resolve (any/c part? resolve-info? . -> . content?)]
-                          [sizer (-> any)]
-                          [plain (-> any)])))
+(provide (contract-out (struct delayed-element
+                               ([resolve (any/c part? resolve-info? . -> . content?)] [sizer (-> any)]
+                                                                                      [plain
+                                                                                       (-> any)]))))
 
 (module+ deserialize-info
   (provide deserialize-delayed-element))
@@ -473,10 +473,9 @@
    (or (current-load-relative-directory) (current-directory)))
   #:transparent)
 
-(provide/contract
- (struct part-relative-element ([collect (collect-info? . -> . content?)]
-                                [sizer (-> any)]
-                                [plain (-> any)])))
+(provide (contract-out (struct part-relative-element
+                               ([collect (collect-info? . -> . content?)] [sizer (-> any)]
+                                                                          [plain (-> any)]))))
 
 (module+ deserialize-info
   (provide deserialize-part-relative-element))
diff --git a/scribble-lib/scribble/markdown-render.rkt b/scribble-lib/scribble/markdown-render.rkt
index a75e358471..dc1f1381a9 100644
--- a/scribble-lib/scribble/markdown-render.rkt
+++ b/scribble-lib/scribble/markdown-render.rkt
@@ -104,26 +104,24 @@
           (displayln "```")]
 
         [else
-          (define strs (map (lambda (flows)
-                              (map (lambda (d)
-                                     (cond
-                                       [(eq? d 'cont) d]
-                                       [else
-                                        (define o (open-output-string))
-                                        (parameterize ([current-indent 0]
-                                                       [current-output-port o])
-                                          (render-block d part ht #f))
-                                        (regexp-split
-                                         #rx"\n"
-                                         (regexp-replace #rx"\n$" (get-output-string o) ""))]))
-                                   flows))
-                            flowss))
-          (define widths (map (lambda (col)
-                                (for/fold ([d 0]) ([i (in-list col)])
-                                  (if (eq? i 'cont)
-                                      0
-                                      (apply max d (map string-length i)))))
-                              (apply map list strs)))
+          (define strs (for/list ([flows (in-list flowss)])
+                         (map
+                          (lambda (d)
+                            (cond
+                              [(eq? d 'cont) d]
+                              [else
+                               (define o (open-output-string))
+                               (parameterize ([current-indent 0]
+                                              [current-output-port o])
+                                 (render-block d part ht #f))
+                               (regexp-split #rx"\n"
+                                             (regexp-replace #rx"\n$" (get-output-string o) ""))]))
+                          flows)))
+          (define widths (for/list ([col (in-list (apply map list strs))])
+                           (for/fold ([d 0]) ([i (in-list col)])
+                             (if (eq? i 'cont)
+                                 0
+                                 (apply max d (map string-length i))))))
           (define (x-length col)
             (if (eq? col 'cont) 0 (length col)))
           (for/fold ([indent? #f]) ([row (in-list strs)])
diff --git a/scribble-lib/scribble/srcdoc.rkt b/scribble-lib/scribble/srcdoc.rkt
index 8a8d306da4..1031ecd67f 100644
--- a/scribble-lib/scribble/srcdoc.rkt
+++ b/scribble-lib/scribble/srcdoc.rkt
@@ -74,18 +74,14 @@
     (syntax-local-introduce
      (syntax-shift-phase-level s #f)))
   (with-syntax ([((req ...) ...)
-                 (map (lambda (rs)
-                        (map (lambda (r)
-                               (syntax-case r ()
-                                 [(op arg ...)
-                                  (with-syntax ([(arg ...)
-                                                 (map shift-and-introduce
+                 (for/list ([rs (in-list (reverse requires))])
+                   (for/list ([r (in-list (syntax->list rs))])
+                     (syntax-case r ()
+                       [(op arg ...)
+                        (with-syntax ([(arg ...) (map shift-and-introduce
                                                       (syntax->list #'(arg ...)))])
-                                    #'(op arg ...))]
-                                 [else
-                                  (shift-and-introduce r)]))
-                             (syntax->list rs)))
-                      (reverse requires))]
+                          #'(op arg ...))]
+                       [else (shift-and-introduce r)])))]
                 [(expr ...)
                  (map shift-and-introduce (reverse doc-exprs))]
                 [doc-body
@@ -124,30 +120,19 @@
 (define-for-syntax (do-provide/doc stx modes)
   (let ([forms (list stx)])
     (with-syntax ([((for-provide/contract (req ...) d id) ...)
-                   (map (lambda (form)
-                          (syntax-case form ()
-                            [(id . _)
-                             (identifier? #'id)
-                             (let ([t (syntax-local-value #'id (lambda () #f))])
-                               (unless (provide/doc-transformer? t)
-                                 (raise-syntax-error
-                                  #f
-                                  "not bound as a provide/doc transformer"
-                                  stx
-                                  #'id))
-                               (let* ([i (make-syntax-introducer)]
-                                      [i2 (lambda (x) (syntax-local-introduce (i x)))])
-                                 (let-values ([(p/c d req/d id)
-                                               ((provide/doc-transformer-proc t)
-                                                (i (syntax-local-introduce form)))])
-                                   (list (i2 p/c) (i req/d) (i d) (i id)))))]
-                            [_
-                             (raise-syntax-error
-                              #f
-                              "not a provide/doc sub-form"
-                              stx
-                              form)]))
-                        forms)])
+                   (for/list ([form (in-list forms)])
+                     (syntax-case form ()
+                       [(id . _)
+                        (identifier? #'id)
+                        (let ([t (syntax-local-value #'id (lambda () #f))])
+                          (unless (provide/doc-transformer? t)
+                            (raise-syntax-error #f "not bound as a provide/doc transformer" stx #'id))
+                          (let* ([i (make-syntax-introducer)]
+                                 [i2 (lambda (x) (syntax-local-introduce (i x)))])
+                            (let-values ([(p/c d req/d id) ((provide/doc-transformer-proc t)
+                                                            (i (syntax-local-introduce form)))])
+                              (list (i2 p/c) (i req/d) (i d) (i id)))))]
+                       [_ (raise-syntax-error #f "not a provide/doc sub-form" stx form)]))])
       (with-syntax ([(p/c ...)
                      (map (lambda (form f)
                             (if (identifier? f)
@@ -359,44 +344,52 @@
                             
                             (let ([build-mandatories/optionals
                                    (λ (names contracts extras)
-                                     (let ([names-length (length names)]
-                                           [contracts-length (length contracts)])
-                                       (let loop ([contracts contracts]
-                                                  [names names]
-                                                  [extras extras])
-                                         (cond
-                                           [(and (null? names) (null? contracts)) '()]
-                                           [(or (null? names) (null? contracts))
-                                            (raise-syntax-error #f
-                                                                (format "mismatched ~a argument list count and domain contract count (~a)"
-                                                                        (if extras "optional" "mandatory")
-                                                                        (if (null? names)
-                                                                            "ran out of names"
-                                                                            "ran out of contracts"))
-                                                                stx)]
-                                           [else
-                                            (let ([fst-name (car names)]
-                                                  [fst-ctc (car contracts)])
-                                              (if (keyword? (syntax-e fst-ctc))
-                                                  (begin
-                                                    (unless (pair? (cdr contracts))
-                                                      (raise-syntax-error #f
-                                                                          "keyword not followed by a contract"
-                                                                          stx))
-                                                    (cons (if extras
-                                                              (list fst-ctc fst-name (cadr contracts) (car extras))
-                                                              (list fst-ctc fst-name (cadr contracts)))
-                                                          (loop (cddr contracts)
-                                                                (cdr names)
-                                                                (if extras
-                                                                    (cdr extras)
-                                                                    extras))))
-                                                  (cons (if extras 
-                                                            (list fst-name fst-ctc (car extras))
-                                                            (list fst-name fst-ctc))
-                                                        (loop (cdr contracts) (cdr names) (if extras
-                                                                                              (cdr extras)
-                                                                                              extras)))))]))))])
+                                     (length names)
+                                     (length contracts)
+                                     (let loop ([contracts contracts]
+                                                [names names]
+                                                [extras extras])
+                                       (cond
+                                         [(and (null? names) (null? contracts)) '()]
+                                         [(or (null? names) (null? contracts))
+                                          (raise-syntax-error
+                                           #f
+                                           (format
+                                            "mismatched ~a argument list count and domain contract count (~a)"
+                                            (if extras "optional" "mandatory")
+                                            (if (null? names)
+                                                "ran out of names"
+                                                "ran out of contracts"))
+                                           stx)]
+                                         [else
+                                          (let ([fst-name (car names)]
+                                                [fst-ctc (car contracts)])
+                                            (if (keyword? (syntax-e fst-ctc))
+                                                (begin
+                                                  (unless (pair? (cdr contracts))
+                                                    (raise-syntax-error
+                                                     #f
+                                                     "keyword not followed by a contract"
+                                                     stx))
+                                                  (cons (if extras
+                                                            (list fst-ctc
+                                                                  fst-name
+                                                                  (cadr contracts)
+                                                                  (car extras))
+                                                            (list fst-ctc fst-name (cadr contracts)))
+                                                        (loop (cddr contracts)
+                                                              (cdr names)
+                                                              (if extras
+                                                                  (cdr extras)
+                                                                  extras))))
+                                                (cons (if extras
+                                                          (list fst-name fst-ctc (car extras))
+                                                          (list fst-name fst-ctc))
+                                                      (loop (cdr contracts)
+                                                            (cdr names)
+                                                            (if extras
+                                                                (cdr extras)
+                                                                extras)))))])))])
                             
                               #`([(id #,@(build-mandatories/optionals (syntax->list #'(mandatory-names ...))
                                                                       (syntax->list #'(mandatory ...))
@@ -418,19 +411,22 @@
                                 [((x y) ...)
                                  (andmap identifier? (syntax->list #'(x ... y ...)))]
                                 [((x y) ...)
-                                 (for-each
-                                  (λ (var) 
-                                    (unless (identifier? var)
-                                      (raise-syntax-error #f "expected an identifier in the optional names" stx var)))
-                                  (syntax->list #'(x ... y ...)))]
+                                 (for ([var (in-list (syntax->list #'(x ... y ...)))])
+                                   (unless (identifier? var)
+                                     (raise-syntax-error
+                                      #f
+                                      "expected an identifier in the optional names"
+                                      stx
+                                      var)))]
                                 [(a ...)
-                                 (for-each
-                                  (λ (a)
-                                    (syntax-case stx ()
-                                      [(x y) (void)]
-                                      [other
-                                       (raise-syntax-error #f "expected an sequence of two idenfiers" stx #'other)]))
-                                  (syntax->list #'(a ...)))]))]
+                                 (for ([a (in-list (syntax->list #'(a ...)))])
+                                   (syntax-case stx ()
+                                     [(x y) (void)]
+                                     [other
+                                      (raise-syntax-error #f
+                                                          "expected an sequence of two idenfiers"
+                                                          stx
+                                                          #'other)]))]))]
                            [x
                             (raise-syntax-error
                              #f
@@ -506,12 +502,9 @@
                               "expected an identifier or sequence of two identifiers"
                               stx
                               #'struct-name)])
-       (for ([f (in-list (syntax->list #'(field-name ...)))])
-         (unless (identifier? f)
-           (raise-syntax-error #f 
-                               "expected an identifier"
-                               stx
-                               f)))
+       (for ([f (in-list (syntax->list #'(field-name ...)))]
+             #:unless (identifier? f))
+         (raise-syntax-error #f "expected an identifier" stx f))
        (define omit-constructor? #f)
        (define-values (ds-args desc)
          (let loop ([ds-args '()]
diff --git a/scribble-lib/scribble/text-render.rkt b/scribble-lib/scribble/text-render.rkt
index e524ea5f17..ab61e051a3 100644
--- a/scribble-lib/scribble/text-render.rkt
+++ b/scribble-lib/scribble/text-render.rkt
@@ -37,18 +37,14 @@
     (define/override (render-part d ht)
       (let ([number (collected-info-number (part-collected-info d ht))])
         (unless (part-style? d 'hidden)
-          (let ([s (format-number number '() #t)])
-            (unless (null? s)
-              (printf "~a~a" 
-                      (car s)
-                      (if (part-title-content d)
-                          " "
-                          "")))
-            (when (part-title-content d)
-              (render-content (part-title-content d) d ht))
-            (when (or (pair? number) (part-title-content d))
-              (newline)
-              (newline))))
+          (define s (format-number number '() #t))
+          (unless (null? s)
+            (printf "~a~a" (car s) (if (part-title-content d) " " "")))
+          (when (part-title-content d)
+            (render-content (part-title-content d) d ht))
+          (when (or (pair? number) (part-title-content d))
+            (newline)
+            (newline)))
         (render-flow (part-blocks d) d ht #f)
         (let loop ([pos 1]
                    [secs (part-parts d)]
@@ -88,88 +84,91 @@
                                             (regexp-replace #rx"\n$" (get-output-string o) "")))))
                                    flows))
                             flowss)]
-                 [extract-align
-                  (lambda (s)
-                    (define p (style-properties s))
-                    (cond
-                     [(member 'right p) 'right]
-                     [(member 'center p) 'center]
-                     [else 'left]))]
+                 [extract-align (lambda (s)
+                                  (define p (style-properties s))
+                                  (cond
+                                    [(member 'right p) 'right]
+                                    [(member 'center p) 'center]
+                                    [else 'left]))]
                  [alignss
                   (cond
-                   [(ormap (lambda (v) (and (table-cells? v) v)) (style-properties (table-style i)))
-                    => (lambda (tc)
-                         (for/list ([l (in-list (table-cells-styless tc))])
-                           (for/list ([s (in-list l)])
-                             (extract-align s))))]
-                   [(ormap (lambda (v) (and (table-columns? v) v)) (style-properties (table-style i)))
-                    => (lambda (tc)
-                         (make-list
-                          (length flowss)
-                          (for/list ([s (in-list (table-columns-styles tc))])
-                            (extract-align s))))]
-                   [else
-                    (if (null? flowss)
-                        null
-                        (make-list (length flowss) (make-list (length (car flowss)) 'left)))])]
-                 [extract-border
-                  (lambda (s)
-                    (define p (style-properties s))
-                    (cond
-                     [(memq 'border p) '#(#t #t #t #t)]
-                     [else
-                      (vector (memq 'left-border p) (memq 'right-border p)
-                              (memq 'top-border p) (memq 'bottom-border p))]))]
-                 [borderss
-                  ;; A border is (vector left? right? top? bottom?)
-                  (cond
-                   [(ormap (lambda (v) (and (table-cells? v) v)) (style-properties (table-style i)))
-                    => (lambda (tc)
-                         (for/list ([l (in-list (table-cells-styless tc))])
-                           (for/list ([s (in-list l)])
-                             (extract-border s))))]
-                   [(ormap (lambda (v) (and (table-columns? v) v)) (style-properties (table-style i)))
-                    => (lambda (tc)
-                         (make-list
-                          (length flowss)
-                          (for/list ([s (in-list (table-columns-styles tc))])
-                            (extract-border s))))]
-                   [else
-                    (if (null? flowss)
-                        null
-                        (make-list (length flowss) (make-list (length (car flowss)) '#(#f #f #f #f))))])]
+                    [(ormap (lambda (v) (and (table-cells? v) v)) (style-properties (table-style i)))
+                     =>
+                     (lambda (tc)
+                       (for/list ([l (in-list (table-cells-styless tc))])
+                         (for/list ([s (in-list l)])
+                           (extract-align s))))]
+                    [(ormap (lambda (v) (and (table-columns? v) v))
+                            (style-properties (table-style i)))
+                     =>
+                     (lambda (tc)
+                       (make-list (length flowss)
+                                  (for/list ([s (in-list (table-columns-styles tc))])
+                                    (extract-align s))))]
+                    [(null? flowss) null]
+                    [else (make-list (length flowss) (make-list (length (car flowss)) 'left))])]
+                 [extract-border (lambda (s)
+                                   (define p (style-properties s))
+                                   (cond
+                                     [(memq 'border p) '#(#t #t #t #t)]
+                                     [else
+                                      (vector (memq 'left-border p)
+                                              (memq 'right-border p)
+                                              (memq 'top-border p)
+                                              (memq 'bottom-border p))]))]
+                 ;; A border is (vector left? right? top? bottom?)
+                 [borderss (cond
+                             [(ormap (lambda (v) (and (table-cells? v) v))
+                                     (style-properties (table-style i)))
+                              =>
+                              (lambda (tc)
+                                (for/list ([l (in-list (table-cells-styless tc))])
+                                  (for/list ([s (in-list l)])
+                                    (extract-border s))))]
+                             [(ormap (lambda (v) (and (table-columns? v) v))
+                                     (style-properties (table-style i)))
+                              =>
+                              (lambda (tc)
+                                (make-list (length flowss)
+                                           (for/list ([s (in-list (table-columns-styles tc))])
+                                             (extract-border s))))]
+                             [(null? flowss) null]
+                             [else
+                              (make-list (length flowss)
+                                         (make-list (length (car flowss)) '#(#f #f #f #f)))])]
                  [border-left? (lambda (v) (vector-ref v 0))]
                  [border-right? (lambda (v) (vector-ref v 1))]
                  [border-top? (lambda (v) (vector-ref v 2))]
                  [border-bottom? (lambda (v) (vector-ref v 3))]
-                 [col-borders ; has only left and right
-                  (for/list ([i (in-range (length (car borderss)))])
-                    (for/fold ([v '#(#f #f)]) ([borders (in-list borderss)])
-                      (define v2 (list-ref borders i))
-                      (vector (or (border-left? v) (border-left? v2))
-                              (or (border-right? v) (border-right? v2)))))]
-                 [widths (map (lambda (col)
-                                (for/fold ([d 0]) ([i (in-list col)])
-                                  (if (eq? i 'cont)
-                                      d
-                                      (apply max d (map string-length i)))))
-                              (apply map list strs))]
-                 [x-length (lambda (col) (if (eq? col 'cont) 0 (length col)))])
-
+                 ; has only left and right
+                 [col-borders (for/list ([i (in-range (length (car borderss)))])
+                                (for/fold ([v '#(#f #f)]) ([borders (in-list borderss)])
+                                  (define v2 (list-ref borders i))
+                                  (vector (or (border-left? v) (border-left? v2))
+                                          (or (border-right? v) (border-right? v2)))))]
+                 [widths (for/list ([col (in-list (apply map list strs))])
+                           (for/fold ([d 0]) ([i (in-list col)])
+                             (if (eq? i 'cont)
+                                 d
+                                 (apply max d (map string-length i)))))]
+                 [x-length (lambda (col)
+                             (if (eq? col 'cont)
+                                 0
+                                 (length col)))])
+          
             (define (show-row-border prev-borders borders)
               (when (for/or ([prev-border (in-list prev-borders)]
                              [border (in-list borders)])
-                      (or (border-bottom? prev-border)
-                          (border-top? border)))
+                      (or (border-bottom? prev-border) (border-top? border)))
                 (define-values (end-h-border? end-v-border?)
                   (for/fold ([left-border? #f]
                              [prev-border? #f])
-                      ([w (in-list widths)]
-                       [prev-border (in-list prev-borders)]
-                       [border (in-list borders)]
-                       [col-border (in-list col-borders)])
-                    (define border? (or (and prev-border (border-bottom? prev-border))
-                                        (border-top? border)))
+                            ([w (in-list widths)]
+                             [prev-border (in-list prev-borders)]
+                             [border (in-list borders)]
+                             [col-border (in-list col-borders)])
+                    (define border?
+                      (or (and prev-border (border-bottom? prev-border)) (border-top? border)))
                     (when (or left-border? (border-left? col-border))
                       (display (if (or prev-border? border?) "-" " ")))
                     (display (make-string w (if border? #\- #\space)))
@@ -177,35 +176,40 @@
                 (when end-h-border?
                   (display (if end-v-border? "-" " ")))
                 (newline)))
-
-            (define-values (last-indent? last-borders)
-              (for/fold ([indent? #f] [prev-borders #f]) ([row (in-list strs)]
-                                                          [aligns (in-list alignss)]
-                                                          [borders (in-list borderss)])
+          
+            (define last-borders
+              (for/fold ([indent? #f]
+                         [prev-borders #f]
+                         #:result prev-borders)
+                        ([row (in-list strs)]
+                         [aligns (in-list alignss)]
+                         [borders (in-list borderss)])
                 (values
                  (let ([h (apply max 0 (map x-length row))])
                    (let ([row* (for/list ([i (in-range h)])
                                  (for/list ([col (in-list row)])
-                                   (if (i . < . (x-length col))
-                                       (list-ref col i)
-                                       (if (eq? col 'cont)
-                                           'cont
-                                           ""))))])
-                     (for/fold ([indent? indent?]) ([sub-row (in-list row*)]
-                                                    [pos (in-naturals)])
-                       (when indent? (indent))
-
+                                   (cond
+                                     [(i . < . (x-length col)) (list-ref col i)]
+                                     [(eq? col 'cont) 'cont]
+                                     [else ""])))])
+                     (for/fold ([indent? indent?])
+                               ([sub-row (in-list row*)]
+                                [pos (in-naturals)])
+                       (when indent?
+                         (indent))
+          
                        (when (zero? pos)
                          (show-row-border (or prev-borders (map (lambda (b) '#(#f #f #f #f)) borders))
                                           borders))
-
+          
                        (define-values (end-border? end-col-border?)
-                         (for/fold ([left-border? #f] [left-col-border? #f])
-                             ([col (in-list sub-row)]
-                              [w (in-list widths)]
-                              [align (in-list aligns)]
-                              [border (in-list borders)]
-                              [col-border (in-list col-borders)])
+                         (for/fold ([left-border? #f]
+                                    [left-col-border? #f])
+                                   ([col (in-list sub-row)]
+                                    [w (in-list widths)]
+                                    [align (in-list aligns)]
+                                    [border (in-list borders)]
+                                    [col-border (in-list col-borders)])
                            (when (or left-col-border? (border-left? col-border))
                              (display (if (and (or left-border? (border-left? border))
                                                (not (eq? col 'cont)))
@@ -220,16 +224,15 @@
                              (case align
                                [(left) (display (make-string gap #\space))]
                                [(center) (display (make-string (- gap (quotient gap 2)) #\space))]))
-                           (values (border-right? border)
-                                   (border-right? col-border))))
+                           (values (border-right? border) (border-right? col-border))))
                        (when end-col-border?
                          (display (if end-border? "|" " ")))
                        (newline)
                        #t)))
                  borders)))
-
+          
             (show-row-border last-borders (map (lambda (b) '#(#f #f #f #f)) last-borders))
-
+          
             null)))
 
     (define/override (render-itemization i part ht)
@@ -300,12 +303,12 @@
     (define/override (render-nested-flow i part ri starting-item?)
       (define s (nested-flow-style i))
       (unless (memq 'decorative (style-properties s))
-        (if (and s (or (eq? (style-name s) 'inset)
-                       (eq? (style-name s) 'code-inset)))
-            (begin (printf "  ")
-                   (parameterize ([current-indent (make-indent 2)])
-                     (super render-nested-flow i part ri starting-item?)))
-            (super render-nested-flow i part ri starting-item?))))
+        (cond
+          [(and s (or (eq? (style-name s) 'inset) (eq? (style-name s) 'code-inset)))
+           (printf "  ")
+           (parameterize ([current-indent (make-indent 2)])
+             (super render-nested-flow i part ri starting-item?))]
+          [else (super render-nested-flow i part ri starting-item?)])))
 
     (define/override (render-other i part ht)
       (cond