anchor.diff:              (handler-case (let ((process (eval (read))))
                               (add-process process current-kell))
                 (end-of-file () (return))
  -              (error (c) (handle-error c))))
  +              (kiln-error (c) (handle-error c))))
           (mapc #'destroy-thread kilns)
           (clear-events)))))
   
  
positive.code:             (when (and trigger matched-processes)
                (trigger-process trigger substitutions)
                (mapc #'activate-continuation matched-processes))))
        (error (c) (handle-error c)))))
  
  (defun find-triggers-matching-message (name kell)
    "Collect down-patterns from parent kell, up-patterns from subkells, and local-
  
negative.code: (in-package #:kilns)
  
  (defvar *top-kell*)
  
  (define-condition kiln-error (error)
    ()
    (:documentation "This is used to distinguish errors that happen in kilns from
                     errors in the implementation."))
  
  (define-condition duplicate-kell-name-error (kiln-error)
    ((name :initarg :name))
    (:report (lambda (condition stream)
               (format stream
                       "Can't have two kells with the same name (~a) in the same kell."
                       (slot-value condition 'name)))))
  
  (define-condition no-such-kell-error (kiln-error)
    ((name :initarg :name)
     (container :initarg :container))
    (:report (lambda (condition stream)
               (format stream "No kell named ~a within ~a"
                       (slot-value condition 'name)
                       (slot-value condition 'container)))))
  
  (let ((lock (make-lock "print-lock")))
    (defun printk (&rest arguments)
  