diff --git a/scribble-doc/scribblings/scribble/class-diagrams.rkt b/scribble-doc/scribblings/scribble/class-diagrams.rkt
index 5f13dff7e6..dacdbd57b1 100644
--- a/scribble-doc/scribblings/scribble/class-diagrams.rkt
+++ b/scribble-doc/scribblings/scribble/class-diagrams.rkt
@@ -1,12 +1,12 @@
 #lang racket/base
-(require (prefix-in etc: mzlib/etc)
+(require racket/class
+         racket/contract
+         racket/draw
+         racket/runtime-path
          texpict/mrpict
+         (prefix-in etc: mzlib/etc)
          (only-in pict pin-line pin-arrow-line)
          (except-in texpict/utils pin-line pin-arrow-line)
-         racket/class
-         racket/runtime-path
-         racket/draw
-         racket/contract
          (only-in racket/list last))
 
 (define the-font-size 12)
@@ -70,41 +70,33 @@
   (unless (even? (length args))
     (error 'method-spec "expected a list of types and argument names, but found ~a arguments"
            (length args)))
-  (let ([first-line
-         (hbl-append
-          (type-spec range)
-          (normal-font " ")
-          (var-font name)
-          (cond
-            [(null? args)
-             (normal-font "()")]
-            [else
-             (hbl-append
-              (normal-font "(")
-              (let loop ([args args])
-                (let* ([type (car args)]
-                       [param (cadr args)]
-                       [single-arg 
-                        (if param 
-                            (hbl-append (type-spec type)
-                                        (normal-font " ")
-                                        (var-font param))
-                            (type-spec type))])
-                  
-                  (cond
-                    [(null? (cddr args))
-                     (hbl-append single-arg (normal-font ")"))]
-                    [else
-                     (hbl-append single-arg
-                                 (normal-font ", ")
-                                 (loop (cddr args)))]))))])
-          (if body
-              (hbl-append (normal-font " {"))
-              (blank)))])
-    (if body
-        (vl-append first-line
-                   (hbl-append (blank 8 0) body (normal-font "}")))
-        first-line)))
+  (define first-line
+    (hbl-append
+     (type-spec range)
+     (normal-font " ")
+     (var-font name)
+     (cond
+       [(null? args) (normal-font "()")]
+       [else
+        (hbl-append
+         (normal-font "(")
+         (let loop ([args args])
+           (define type (car args))
+           (define param (cadr args))
+           (define single-arg
+             (if param
+                 (hbl-append (type-spec type) (normal-font " ") (var-font param))
+                 (type-spec type)))
+           
+           (cond
+             [(null? (cddr args)) (hbl-append single-arg (normal-font ")"))]
+             [else (hbl-append single-arg (normal-font ", ") (loop (cddr args)))])))])
+     (if body
+         (hbl-append (normal-font " {"))
+         (blank))))
+  (if body
+      (vl-append first-line (hbl-append (blank 8 0) body (normal-font "}")))
+      first-line))
              
 (define (type-spec str)
   (cond
@@ -126,35 +118,32 @@
 
 ;; class-box : pict (or/c #f (listof pict)) (or/c #f (listof pict)) -> pict
 (define (class-box name fields methods)
-  (let* ([mk-blank (λ () (blank 0 (+ class-box-margin class-box-margin)))])
-    (cond
-      [(and methods fields)
-       (let* ([top-spacer (mk-blank)]
-              [bottom-spacer (mk-blank)]
-              [main (vl-append name 
-                               top-spacer
-                               (if (null? fields)
-                                   (blank 0 4)
-                                   (apply vl-append fields))
-                               bottom-spacer
-                               (if (null? methods)
-                                   (blank 0 4)
-                                   (apply vl-append methods)))])
-         (add-hline
-          (add-hline (frame (inset main class-box-margin))
-                     top-spacer)
-          bottom-spacer))]
-      [fields
-       (let* ([top-spacer (mk-blank)]
-              [main (vl-append name 
-                               top-spacer
-                               (if (null? fields)
-                                   (blank)
-                                   (apply vl-append fields)))])
-         (add-hline (frame (inset main class-box-margin))
-                    top-spacer))]
-      [methods (class-box name methods fields)]
-      [else (frame (inset name class-box-margin))])))
+  (define (mk-blank)
+    (blank 0 (+ class-box-margin class-box-margin)))
+  (cond
+    [(and methods fields)
+     (let* ([top-spacer (mk-blank)]
+            [bottom-spacer (mk-blank)]
+            [main (vl-append name
+                             top-spacer
+                             (if (null? fields)
+                                 (blank 0 4)
+                                 (apply vl-append fields))
+                             bottom-spacer
+                             (if (null? methods)
+                                 (blank 0 4)
+                                 (apply vl-append methods)))])
+       (add-hline (add-hline (frame (inset main class-box-margin)) top-spacer) bottom-spacer))]
+    [fields
+     (let* ([top-spacer (mk-blank)]
+            [main (vl-append name
+                             top-spacer
+                             (if (null? fields)
+                                 (blank)
+                                 (apply vl-append fields)))])
+       (add-hline (frame (inset main class-box-margin)) top-spacer))]
+    [methods (class-box name methods fields)]
+    [else (frame (inset name class-box-margin))]))
 
 (define (add-hline main sub)
   (let-values ([(x y) (cc-find main sub)])
@@ -438,7 +427,7 @@
     (define-values (main3 dot3) (add-dot-junction main2 dot2 cc-find finish-class ct-find))
     (connect-dots #t main3 dot1 dot2 dot3)))
 
-(define connect-dots-contract (->* (boolean? pict? pict?) () #:rest (listof pict?) (values pict?)))
+(define connect-dots-contract (-> boolean? pict? pict? pict? ... (values pict?)))
 
 (provide type-link-color)
 (provide/contract
diff --git a/scribble-doc/scribblings/scribble/utils.rkt b/scribble-doc/scribblings/scribble/utils.rkt
index 417c6e433a..40e146516a 100644
--- a/scribble-doc/scribblings/scribble/utils.rkt
+++ b/scribble-doc/scribblings/scribble/utils.rkt
@@ -49,22 +49,20 @@
                     [pos base]
                     [second #f]
                     [accum null])
-           (if (null? e)
-             (datum->syntax
-              p (reverse accum)
-              (list (syntax-source p) (syntax-line p) base (add1 base)
-                    (- pos base))
-              p)
-             (let* ([v ((norm-spacing (if (= line (syntax-line (car e)))
-                                        pos
-                                        (or second pos)))
-                        (car e))]
-                    [next-pos (+ (syntax-column v) (syntax-span v) 1)])
-               (loop (cdr e)
-                     (syntax-line v)
-                     next-pos
-                     (or second next-pos)
-                     (cons v accum)))))]
+           (cond
+             [(null? e)
+              (datum->syntax p
+                             (reverse accum)
+                             (list (syntax-source p) (syntax-line p) base (add1 base) (- pos base))
+                             p)]
+             [else
+              (define v
+                ((norm-spacing (if (= line (syntax-line (car e)))
+                                   pos
+                                   (or second pos)))
+                 (car e)))
+              (define next-pos (+ (syntax-column v) (syntax-span v) 1))
+              (loop (cdr e) (syntax-line v) next-pos (or second next-pos) (cons v accum))]))]
         [else (datum->syntax
                p (syntax-e p)
                (list (syntax-source p) (syntax-line p) base (add1 base) 1)
@@ -77,32 +75,33 @@
     (port-count-lines! p)
     (let loop ([r '()] [newlines? #f])
       (regexp-match? #px#"^[[:space:]]*" p)
-      (let* ([p1  (file-position p)]
-             [stx (scribble:read-syntax #f p)]
-             [p2  (file-position p)])
-        (if (not (eof-object? stx))
+      (define p1 (file-position p))
+      (define stx (scribble:read-syntax #f p))
+      (define p2 (file-position p))
+      (if (not (eof-object? stx))
           (let ([str (substring lines p1 p2)])
-            (loop (cons (list str stx) r)
-                  (or newlines? (regexp-match? #rx#"\n" str))))
+            (loop (cons (list str stx) r) (or newlines? (regexp-match? #rx#"\n" str))))
           (let* ([r (reverse r)]
                  [r (if newlines?
-                      (cdr (apply append (map (lambda (x) (list #f x)) r)))
-                      r)])
-            (make-table
-             plain
-             (map (lambda (x)
-                    (let ([@expr (if x (litchar/lines (car x)) "")]
-                          [sexpr (if x
-                                   (racket:to-paragraph
-                                    ((norm-spacing 0) (cadr x)))
-                                   "")]
-                          [reads-as (if x reads-as "")])
-                      (map as-flow (list spacer @expr reads-as sexpr))))
-                  r))))))))
+                        (cdr (apply append (map (lambda (x) (list #f x)) r)))
+                        r)])
+            (make-table plain
+                        (map (lambda (x)
+                               (let ([@expr (if x
+                                                (litchar/lines (car x))
+                                                "")]
+                                     [sexpr (if x
+                                                (racket:to-paragraph ((norm-spacing 0) (cadr x)))
+                                                "")]
+                                     [reads-as (if x reads-as "")])
+                                 (map as-flow (list spacer @expr reads-as sexpr))))
+                             r)))))))
 
 ;; stuff for the scribble/text examples
 
-(require racket/list (for-syntax racket/base racket/list))
+(require (for-syntax racket/base
+                     racket/list)
+         racket/list)
 
 (define max-textsample-width 45)
 
@@ -112,12 +111,12 @@
   (define strs2 (split out-text))
   (define strsm (map (compose split cdr) more))
   (define (str->elts str)
-    (let ([spaces (regexp-match-positions #rx"(?:^| ) +" str)])
-      (if spaces
+    (define spaces (regexp-match-positions #rx"(?:^| ) +" str))
+    (if spaces
         (list* (str->elts (substring str 0 (caar spaces)))
                (smaller (hspace (- (cdar spaces) (caar spaces))))
                (str->elts (substring str (cdar spaces))))
-        (list (smaller (make-element 'tt str))))))
+        (list (smaller (make-element 'tt str)))))
   (define (make-line str)
     (list (as-flow (if (equal? str "")
                        (smaller (hspace 1))
@@ -129,15 +128,16 @@
                   (filebox file t)
                   t))))
   (define filenames (map car more))
-  (define indent (let ([d (- max-textsample-width
-                             (for*/fold ([m 0])
-                                        ([s (in-list (cons strs1 strsm))]
-                                         [s (in-list s)])
-                               (max m (string-length s))))])
-                   (if (negative? d)
-                     (error 'textsample-verbatim-boxes
-                            "left box too wide for sample at line ~s" line)
-                     (make-element 'tt (list (hspace d))))))
+  (define d
+    (- max-textsample-width
+       (for*/fold ([m 0])
+                  ([s (in-list (cons strs1 strsm))]
+                   [s (in-list s)])
+         (max m (string-length s)))))
+  (define indent
+    (if (negative? d)
+        (error 'textsample-verbatim-boxes "left box too wide for sample at line ~s" line)
+        (make-element 'tt (list (hspace d)))))
   ;; Note: the font-size property is reset for every table, so we need it
   ;; everywhere there's text, and they don't accumulate for nested tables
   (values
@@ -186,11 +186,9 @@
        (and (string? (syntax-e #'sep)) (regexp-match? sep-rx (syntax-e #'sep)))
        (let ([m (cond [(regexp-match sep-rx (syntax-e #'sep)) => cadr]
                       [else #f])])
-         (if (and m (not (regexp-match? file-rx m)))
-           (raise-syntax-error #f "bad filename specified" stx #'sep)
-           (loop #'xs
-                 (list (and m (datum->syntax #'sep m #'sep #'sep)))
-                 (cons (reverse text) texts))))]
+         (when (and m (not (regexp-match? file-rx m)))
+           (raise-syntax-error #f "bad filename specified" stx #'sep))
+         (loop #'xs (list (and m (datum->syntax #'sep m #'sep #'sep))) (cons (reverse text) texts)))]
       [(x . xs) (loop #'xs (cons #'x text) texts)]
       [() (let ([texts (reverse (cons (reverse text) texts))]
                 [line  (syntax-line stx)])
diff --git a/scribble-lib/scriblib/figure.rkt b/scribble-lib/scriblib/figure.rkt
index ff250b9585..fde186e560 100644
--- a/scribble-lib/scriblib/figure.rkt
+++ b/scribble-lib/scriblib/figure.rkt
@@ -1,13 +1,13 @@
 #lang racket/base
 (require racket/contract/base
-         scribble/manual
          scribble/core
          scribble/decode
          scribble/html-properties
          scribble/latex-properties
+         scribble/manual
+         scribble/private/lang-parameters
          setup/main-collects
-         "private/counter.rkt"
-         scribble/private/lang-parameters)
+         "private/counter.rkt")
 
 (provide figure
          figure*
diff --git a/scribble-lib/scriblib/footnote.rkt b/scribble-lib/scriblib/footnote.rkt
index c40ad6972f..bfa31617fa 100644
--- a/scribble-lib/scriblib/footnote.rkt
+++ b/scribble-lib/scriblib/footnote.rkt
@@ -1,10 +1,10 @@
 #lang racket/base
 
-(require scribble/core
+(require racket/promise
+         scribble/core
          scribble/decode
          scribble/html-properties
          scribble/latex-properties
-         racket/promise
          setup/main-collects
          "private/counter.rkt")
 
@@ -44,27 +44,19 @@
     (define (footnote-part . text) (do-footnote-part footnotes id))))
 
 (define (do-footnote footnotes id text)
-  (let ([tag (generated-tag)]
-        [content (decode-content text)])
-    (make-traverse-element
-     (lambda (get set)
-       (set id (cons (cons
-                      (make-element footnote-target-style
-                                    (make-element
-                                     'superscript
-                                     (counter-target footnotes tag #f)))
+  (define tag (generated-tag))
+  (define content (decode-content text))
+  (make-traverse-element
+   (lambda (get set)
+     (set id
+          (cons (cons (make-element footnote-target-style
+                                    (make-element 'superscript (counter-target footnotes tag #f)))
                       content)
-                     (get id null)))
-       (make-element footnote-style
-                     (list
-                      (make-element 
-                       footnote-ref-style
-                       (make-element
-                        'superscript
-                        (counter-ref footnotes tag #f)))
-                      (make-element
-                       footnote-content-style
-                       content)))))))
+                (get id null)))
+     (make-element footnote-style
+                   (list (make-element footnote-ref-style
+                                       (make-element 'superscript (counter-ref footnotes tag #f)))
+                         (make-element footnote-content-style content))))))
 
 (define (do-footnote-part footnotes id)
   (make-part
@@ -78,9 +70,6 @@
      (lambda (get set)
        (make-compound-paragraph
         footnote-block-style
-        (map (lambda (content)
-               (make-paragraph
-                footnote-block-content-style
-                content))
-             (reverse (get id null)))))))
+        (for/list ([content (in-list (reverse (get id null)))])
+          (make-paragraph footnote-block-content-style content))))))
    null))
diff --git a/scribble-lib/scriblib/gui-eval.rkt b/scribble-lib/scriblib/gui-eval.rkt
index 69b3ee3576..a1dc5eb652 100644
--- a/scribble-lib/scriblib/gui-eval.rkt
+++ b/scribble-lib/scriblib/gui-eval.rkt
@@ -1,39 +1,37 @@
 #lang racket/base
 
-(require scribble/eval
-         scribble/core
-         scribble/scheme
+(require (for-syntax racket/base)
          racket/class
          racket/file
          racket/runtime-path
+         racket/sandbox
          racket/serialize
-         "private/gui-eval-exn.rkt"
          racket/system
-         racket/sandbox
-         (for-syntax racket/base))
+         scribble/core
+         scribble/eval
+         scribble/scheme
+         "private/gui-eval-exn.rkt")
 
-(define-syntax define-mr
-  (syntax-rules ()
-    [(_ mr orig)
-     (begin
-       (provide mr)
-       (define-syntax (mr stx)
-         (syntax-case stx ()
-           [(_ #:eval+opts the-eval get-predicate? get-render get-get-width get-get-height x (... ...))
-            #'(let ([the-eval-x the-eval])
-                (parameterize ([scribble-eval-handler (gui-eval-handler the-eval-x
-                                                                        get-predicate?
-                                                                        get-render
-                                                                        get-get-width
-                                                                        get-get-height)])
-                  (orig #:eval the-eval-x x (... ...))))]
-           [(_ x (... ...))
-            #'(parameterize ([scribble-eval-handler (gui-eval-handler gui-eval
-                                                                      (λ () (gui-eval 'pict?))
-                                                                      (λ () (gui-eval 'draw-pict))
-                                                                      (λ () (gui-eval 'pict-width))
-                                                                      (λ () (gui-eval 'pict-height)))])
-                (orig #:eval gui-eval x (... ...)))])))]))
+(define-syntax-rule (define-mr mr orig)
+  (begin
+    (provide mr)
+    (define-syntax (mr stx)
+      (syntax-case stx ()
+        [(_ #:eval+opts the-eval get-predicate? get-render get-get-width get-get-height x (... ...))
+         #'(let ([the-eval-x the-eval])
+             (parameterize ([scribble-eval-handler (gui-eval-handler the-eval-x
+                                                                     get-predicate?
+                                                                     get-render
+                                                                     get-get-width
+                                                                     get-get-height)])
+               (orig #:eval the-eval-x x (... ...))))]
+        [(_ x (... ...))
+         #'(parameterize ([scribble-eval-handler (gui-eval-handler gui-eval
+                                                                   (λ () (gui-eval 'pict?))
+                                                                   (λ () (gui-eval 'draw-pict))
+                                                                   (λ () (gui-eval 'pict-width))
+                                                                   (λ () (gui-eval 'pict-height)))])
+             (orig #:eval gui-eval x (... ...)))]))))
 
 (define gui-eval (make-base-eval #:pretty-print? #f))
 
@@ -68,61 +66,63 @@
                                    "exprs.dat"))
 
 (define gui-eval-handler
-  (if mred?
-      (let ([eh (scribble-eval-handler)]
-            [log-file (open-output-file exprs-dat-file #:exists 'truncate/replace)])
-        (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
-          (lambda (ev catching-exns? expr)
-            (write (serialize (if (syntax? expr) (syntax->datum expr) expr)) log-file)
-            (newline log-file)
-            (flush-output log-file)
-            (let ([result
-                   (with-handlers ([exn:fail?
-                                    (lambda (exn)
-                                      (make-gui-exn (exn-message exn)))])
-                     ;; put the call to fixup-picts in the handlers
-                     ;; so that errors in the user-supplied predicates & 
-                     ;; conversion functions show up in the rendered output
-                     (fixup-picts (get-predicate?) (get-render) (get-get-width) (get-get-height)
-                                  (eh ev catching-exns? expr)))])
-              (write (serialize result) log-file)
-              (newline log-file)
-              (flush-output log-file)
-              (if (gui-exn? result)
-                  (raise (make-exn:fail
-                          (gui-exn-message result)
-                          (current-continuation-marks)))
-                  result)))))
-      (let ([log-file (with-handlers ([exn:fail:filesystem?
-                                       (lambda (exn)
-                                         (open-input-string ""))])
-                        (open-input-file exprs-dat-file))])
-        (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
-          (lambda (ev catching-exns? expr)
-            (with-handlers ([exn:fail? (lambda (exn)
-                                         (if catching-exns?
-                                             (raise exn)
-                                             (void)))])
-              (let ([v (read log-file)])
-                (if (eof-object? v)
-                    (error "expression not in log file")
-                    (let ([v (deserialize v)])
-                      (if (equal? v (if (syntax? expr)
-                                        (syntax->datum expr)
-                                        expr))
-                          (let ([v (read log-file)])
-                            (if (eof-object? v)
-                                (error "expression result missing in log file")
-                                (let ([v (deserialize v)])
-                                  (if (gui-exn? v)
-                                      (raise (make-exn:fail
-                                              (gui-exn-message v)
-                                              (current-continuation-marks)))
-                                      v))))
-                          (error 'mreval
-                                 "expression does not match log file: ~e versus: ~e"
-                                 expr
-                                 v)))))))))))
+  (cond
+    [mred?
+     (define eh (scribble-eval-handler))
+     (define log-file (open-output-file exprs-dat-file #:exists 'truncate/replace))
+     (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
+       (lambda (ev catching-exns? expr)
+         (write (serialize (if (syntax? expr)
+                               (syntax->datum expr)
+                               expr))
+                log-file)
+         (newline log-file)
+         (flush-output log-file)
+         (let ([result (with-handlers ([exn:fail? (lambda (exn) (make-gui-exn (exn-message exn)))])
+                         ;; put the call to fixup-picts in the handlers
+                         ;; so that errors in the user-supplied predicates &
+                         ;; conversion functions show up in the rendered output
+                         (fixup-picts (get-predicate?)
+                                      (get-render)
+                                      (get-get-width)
+                                      (get-get-height)
+                                      (eh ev catching-exns? expr)))])
+           (write (serialize result) log-file)
+           (newline log-file)
+           (flush-output log-file)
+           (if (gui-exn? result)
+               (raise (make-exn:fail (gui-exn-message result) (current-continuation-marks)))
+               result))))]
+    [else
+     (define log-file
+       (with-handlers ([exn:fail:filesystem? (lambda (exn) (open-input-string ""))])
+         (open-input-file exprs-dat-file)))
+     (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
+       (lambda (ev catching-exns? expr)
+         (with-handlers ([exn:fail? (lambda (exn)
+                                      (if catching-exns?
+                                          (raise exn)
+                                          (void)))])
+           (let ([v (read log-file)])
+             (if (eof-object? v)
+                 (error "expression not in log file")
+                 (let ([v (deserialize v)])
+                   (if (equal? v
+                               (if (syntax? expr)
+                                   (syntax->datum expr)
+                                   expr))
+                       (let ([v (read log-file)])
+                         (if (eof-object? v)
+                             (error "expression result missing in log file")
+                             (let ([v (deserialize v)])
+                               (if (gui-exn? v)
+                                   (raise (make-exn:fail (gui-exn-message v)
+                                                         (current-continuation-marks)))
+                                   v))))
+                       (error 'mreval
+                              "expression does not match log file: ~e versus: ~e"
+                              expr
+                              v))))))))]))
 
 (define image-counter 0)
 
@@ -133,41 +133,40 @@
   (let loop ([v v])
     (cond
       [(predicate? v)
-       (let ([fn (build-string-path img-dir
-                                    (format "img~a.png" image-counter))])
-         (set! image-counter (add1 image-counter))
-         (let ([dc (let ([pss (make-object (gui-eval 'ps-setup%))])
-                     (send pss set-mode 'file)
-                     (send pss set-file (path-replace-suffix fn #".pdf"))
-                     (parameterize ([(gui-eval 'current-ps-setup) pss])
-                       (let ([xb (box 0)]
-                             [yb (box 0)])
-                         (send pss get-scaling xb yb)
-                         (new (gui-eval 'pdf-dc%) 
-                              [interactive #f]
-                              [width (* (unbox xb) (get-width v))]
-                              [height (* (unbox yb) (get-height v))]))))])
-           (send dc start-doc "Image")
-           (send dc start-page)
-           (render v dc 0 0)
-           (send dc end-page)
-           (send dc end-doc))
-         (let* ([bm (make-object (gui-eval 'bitmap%)
+       (define fn (build-string-path img-dir (format "img~a.png" image-counter)))
+       (set! image-counter (add1 image-counter))
+       (let ([dc (let ([pss (make-object (gui-eval 'ps-setup%))])
+                   (send pss set-mode 'file)
+                   (send pss set-file (path-replace-suffix fn #".pdf"))
+                   (parameterize ([(gui-eval 'current-ps-setup) pss])
+                     (let ([xb (box 0)]
+                           [yb (box 0)])
+                       (send pss get-scaling xb yb)
+                       (new (gui-eval 'pdf-dc%)
+                            [interactive #f]
+                            [width (* (unbox xb) (get-width v))]
+                            [height (* (unbox yb) (get-height v))]))))])
+         (send dc start-doc "Image")
+         (send dc start-page)
+         (render v dc 0 0)
+         (send dc end-page)
+         (send dc end-doc))
+       (define bm
+         (make-object (gui-eval 'bitmap%)
                       (inexact->exact (ceiling (get-width v)))
-                      (inexact->exact (ceiling (get-height v))))]
-                [dc (make-object (gui-eval 'bitmap-dc%) bm)])
-           (send dc set-smoothing 'aligned)
-           (send dc clear)
-           (render v dc 0 0)
-           (send bm save-file fn 'png)
-           (make-image-element
-            #f
-            (list "[image]")
-            ;; Be sure to use a string rather than a path, because
-            ;; it gets recorded in "exprs.dat".
-            (path->string (path-replace-suffix fn #""))
-            '(".pdf" ".png")
-            1.0)))]
+                      (inexact->exact (ceiling (get-height v)))))
+       (define dc (make-object (gui-eval 'bitmap-dc%) bm))
+       (send dc set-smoothing 'aligned)
+       (send dc clear)
+       (render v dc 0 0)
+       (send bm save-file fn 'png)
+       (make-image-element #f
+                           (list "[image]")
+                           ;; Be sure to use a string rather than a path, because
+                           ;; it gets recorded in "exprs.dat".
+                           (path->string (path-replace-suffix fn #""))
+                           '(".pdf" ".png")
+                           1.0)]
       [(pair? v) (cons (loop (car v))
                        (loop (cdr v)))]
       [(serializable? v) v]
diff --git a/scribble-lib/scriblib/render-cond.rkt b/scribble-lib/scriblib/render-cond.rkt
index b76eabd8ea..afe7422069 100644
--- a/scribble-lib/scriblib/render-cond.rkt
+++ b/scribble-lib/scriblib/render-cond.rkt
@@ -1,6 +1,6 @@
 #lang racket/base
-(require scribble/core
-         (for-syntax racket/base))
+(require (for-syntax racket/base)
+         scribble/core)
 
 (provide cond-element
          cond-block)