diff --git a/examples/clj/src/example/server.clj b/examples/clj/src/example/server.clj
index 2be6b49..179f74f 100644
--- a/examples/clj/src/example/server.clj
+++ b/examples/clj/src/example/server.clj
@@ -3,30 +3,27 @@
   simple ongoing application performance monitoring.
 
   Note that a similar pattern can also be used for Cljs apps.
-
   See the Tufte README for more info!"
-
   {:author "Peter Taoussanis (@ptaoussanis)"}
   (:require
    [clojure.string     :as str]
    [ring.middleware.defaults]
    [ring.adapter.jetty]
-   [compojure.core     :as comp :refer (defroutes GET POST)]
+   [compojure.core     :as comp :refer [defroutes GET POST]]
    [compojure.route    :as route]
    [hiccup.core        :as hiccup]
-   [taoensso.encore    :as enc :refer (have have?)]
+   [taoensso.encore    :as enc :refer [have have?]]
    [taoensso.tufte     :as tufte]))
 
 (enc/defonce stats-accumulator
-  "On eval, will register a Tufte handler to accumulate the results from
-  all unfiltered `profile` data. Deref this to get the accumulated data.
-
-  (tufte/profile {:id :endpoint1} ...)
-  (tufte/profile {:id :endpoint2} ...)
-  ...
-  @stats-accumulator => Return accumulated performance stats"
+  "Accumulates results from all unfiltered `profile` calls.
+  Deref this to get the accumulated data."
+  (tufte/stats-accumulator))
 
-  (tufte/add-accumulating-handler! {:ns-pattern "*"}))
+;; Register handler for `profile` results
+(tufte/add-handler! :my-accumulating-handler
+  (tufte/accumulating-handler stats-accumulator)
+  {:ns-filter "*"})
 
 (defroutes ring-routes
   (GET "/" ring-req
diff --git a/examples/cljs/src/example/hello.cljs b/examples/cljs/src/example/hello.cljs
index 2dab7ab..b9aec40 100644
--- a/examples/cljs/src/example/hello.cljs
+++ b/examples/cljs/src/example/hello.cljs
@@ -1,8 +1,9 @@
 (ns example.hello
   (:require [taoensso.tufte :as tufte
-             :refer-macros (defnp p profiled profile)]))
+             :refer [defnp p profiled profile]]))
 
-(tufte/add-basic-println-handler! {})
+(tufte/add-handler! :my-print-handler
+  (tufte/print-handler))
 
 (defn get-x [] (+ 1 1))
 (defn get-y [] (+ 2 2))
diff --git a/examples/readme_examples.cljc b/examples/readme_examples.cljc
index 996d33c..ca2cfea 100644
--- a/examples/readme_examples.cljc
+++ b/examples/readme_examples.cljc
@@ -1,11 +1,12 @@
 (ns readme-examples
   "Basic examples that appear in the Truss README."
-  (:require [taoensso.tufte]))
+  (:require [taoensso.tufte :as tufte]))
 
 (comment
 
-(taoensso.tufte/refer-tufte) ; Setup Tufte's ns imports (works with clj only)
-(taoensso.tufte/add-basic-println-handler! {}) ; Send `profile` stats to `println`
+(tufte/refer-tufte) ; Setup Tufte's ns imports
+(tufte/add-handler! :my-print-handler
+  (tufte/print-handler)) ; Send `profile` stats to `print`
 
 ;;; Let's define a couple dummy fns to simulate doing some expensive work
 (defn get-x [] (Thread/sleep 500)             "x val")
@@ -31,11 +32,8 @@
 
 (comment
 
-(ns my-clj-ns ; Clojure namespace
-  (:require [taoensso.tufte :as tufte :refer (defnp p profiled profile)]))
-
-(ns my-cljs-ns ; ClojureScript namespace
-  (:require [taoensso.tufte :as tufte :refer-macros (defnp p profiled profile)]))
+(ns my-ns
+  (:require [taoensso.tufte :as tufte :refer [defnp p profiled profile]]))
 
 )
 
diff --git a/src/taoensso/tufte.cljc b/src/taoensso/tufte.cljc
index 8d22010..a96d1c8 100644
--- a/src/taoensso/tufte.cljc
+++ b/src/taoensso/tufte.cljc
@@ -6,292 +6,74 @@
 
     (profiled {} (p :my-fn (my-fn))) ; Returns [<body-result> <?pstats>]
     (profile  {} (p :my-fn (my-fn))) ; Returns  <body-result>, dispatches
-                                     ; ?pstats to any registered handlers.
+                                     ; pstats to any registered handlers.
 
-  Extensive facilities are provided for compile-time elision and runtime
-  filtering.
+  Provides extensive facilities for compile-time elision and runtime filtering.
 
   See the relevant docstrings for more info:
     `p`, `profiled`, `profile`, `add-handler!` ; Core API
 
-    (p        [opts & body] [id & body]) ; e.g. `(p ::my-pid (do-work))`
+    (p        [opts & body] [id & body]) ; e.g. `(p ::my-id (do-work))`
     (profiled [opts & body])             ; e.g. `(profiled {:level 2} (my-fn))`
     (profile  [opts & body])             ; e.g. `(profiled {:level 2} (my-fn))`
 
-    (add-handler! [handler-id ns-pattern handler-fn])
+    (add-handler! [handler-id handler-fn dispatch-opts])
 
   How/where to use this library:
     Tufte profiling is highly optimized: even without elision, you can usually
-    leave profiling enabled in production (e.g. for sampled profiling, or to
-    detect unusual performance behaviour). Tufte's stats maps are well suited
-    to programmatic monitoring.
-
-  Abbreviations, etc.
-    - form  id = pid = id given in `p`
-    - group id = gid = id given in `profile`"
+    leave profiling active in production (e.g. for sampled profiling, or to
+    detect unusual performance behaviour). Tufte's pstats data is well suited
+    to programmatic monitoring."
 
   {:author "Peter Taoussanis (@ptaoussanis)"}
-
+  (:refer-clojure :exclude [binding])
   (:require
-   [taoensso.encore      :as enc :refer [have have?]]
-   [taoensso.tufte.stats :as stats]
-
-   #?(:clj  [taoensso.tufte.impl  :as impl]
-      :cljs [taoensso.tufte.impl  :as impl :refer [PStats]]))
-
-  #?(:clj (:import [taoensso.tufte.impl PStats]))
+   [clojure.string          :as str]
+   [taoensso.encore         :as enc :refer [binding]]
+   [taoensso.encore.signals :as sigs]
+   [taoensso.tufte.stats    :as stats]
+   [taoensso.tufte.impl     :as impl
+    #?@(:cljs [:refer [PStats ProfilingSignal WrappedProfilingSignal]])])
+
+  #?(:clj  (:import [taoensso.tufte.impl PStats ProfilingSignal WrappedProfilingSignal]))
   #?(:cljs (:require-macros [taoensso.tufte :refer [profiled]])))
 
-(comment (remove-ns 'taoensso.tufte))
-
 (enc/assert-min-encore-version [3 128 0])
 
-;;;; Level filtering
-;; Terminology note: we distinguish between call/form and min levels to ensure
-;; that it's always possible to set min-level > any call-level to disable profiling.
-
-(defn- valid-call-level? [x] (if (#{0 1 2 3 4 5}   x) true false))
-(defn- valid-min-level?  [x] (if (#{0 1 2 3 4 5 6} x) true false))
-
-(def ^:private ^:const invalid-call-level-msg        "Invalid Tufte profiling level: should be int e/o #{0 1 2 3 4 5}")
-(def ^:private ^:const invalid-min-level-msg "Invalid minimum Tufte profiling level: should be int e/o #{0 1 2 3 4 5 6}")
-
-(defn- valid-call-level [x] (or (#{0 1 2 3 4 5}   x) (throw (ex-info invalid-call-level-msg {:given x :type (type x)}))))
-(defn- valid-min-level  [x] (or (#{0 1 2 3 4 5 6} x) (throw (ex-info invalid-min-level-msg  {:given x :type (type x)}))))
-(comment (enc/qb 1e5 (valid-call-level 4))) ; 7.82
-
-(def ^:dynamic *min-level*
-  "Integer e/o #{0 1 2 3 4 5 6}, or vector mapping ns-patterns to min-levels:
-    [[<ns-pattern> <min-level>] ... [\"*\" <default-min-level>]]
-
-  See `*ns-filter*` for example patterns."
-  2)
-
-;;;; Namespace filtering
-;; Terminology note: we distinguish loosely between `ns-filter` (which may be a
-;; fn or `ns-pattern`) and `ns-pattern` (subtype of `ns-filter`).
-
-(def ^:dynamic *ns-filter*
-  "(fn may-profile-ns? [ns]) predicate, or ns-pattern.
-  Example ns-patterns:
-    #{}, \"*\", \"foo.bar\", \"foo.bar.*\", #{\"foo\" \"bar.*\"},
-    {:allow #{\"foo\" \"bar.*\"} :deny #{\"foo.*.bar.*\"}}"
-  "*")
-
-(let [fn?         fn?
-      compile     (enc/fmemoize (fn [x] (enc/name-filter x)))
-      conform?*   (enc/fmemoize (fn [x ns] ((compile x) ns)))
-      ;; conform? (enc/fmemoize (fn [x ns] (if (fn? x) (x ns) ((compile x) ns))))
-      conform?
-      (fn [ns-filter ns]
-        (if (fn? ns-filter)
-          (ns-filter           ns) ; Intentionally uncached, can be handy
-          (conform?* ns-filter ns)))]
-
-  (defn- #?(:clj may-profile-ns? :cljs ^boolean may-profile-ns?)
-    "Implementation detail."
-    ([          ns] (if (conform? *ns-filter* ns) true false))
-    ([ns-filter ns] (if (conform?  ns-filter  ns) true false)))
-
-  (def ^:private ns->?min-level
-    "[[<ns-pattern> <min-level>] ... [\"*\" <default-min-level>]], ns -> ?min-level"
-    (enc/fmemoize
-      (fn [specs ns]
-        (enc/rsome
-          (fn [[ns-pattern min-level]]
-            (when (conform?* ns-pattern ns)
-              (valid-min-level min-level)))
-          specs)))))
-
-(comment
-  (enc/qb 1e6
-    (may-profile-ns? "taoensso.tufte")
-    (ns->?min-level [[#{"taoensso.*" "foo.bar"} 1] ["*" 2]] "foo.bar")) ; [162.85 136.88]
-
-  (binding [*ns-filter* "foo.baz"]    (profiled {} (p {:id "id"} "body")))
-  (binding [*ns-filter* "taoensso.*"] (profiled {} (p {:id "id"} "body"))))
-
-;;;; Combo filtering
-
-(let [valid-min-level valid-min-level
-      ns->?min-level  ns->?min-level]
-
-  (defn- get-min-level [default x ns]
-    (valid-min-level
-      (or
-        (if (vector? x) (ns->?min-level x ns) x)
-        default))))
-
-(comment
-  (get-min-level 6 [["foo" 2]] *ns*) ; Default to 6 (don't profile)
-  (let [ns *ns*] (enc/qb 1e6 (get-min-level *min-level* ns))) ; 260.34
-  (binding [*min-level* [["taoensso.*" 1] ["*" 4]]] (get-min-level "foo")))
-
-(let [valid-call-level valid-call-level
-      may-profile-ns?  may-profile-ns?
-      get-min-level    get-min-level]
-
-  (defn #?(:clj may-profile? :cljs ^boolean may-profile?)
-    "Implementation detail.
-    Returns true iff level and ns are runtime unfiltered."
-    ([level   ] (may-profile? level *ns*))
-    ([level ns]
-     (if (>= ^long (valid-call-level     level)
-             (long (get-min-level 6 *min-level* ns)))
-       (if (may-profile-ns? *ns-filter* ns) true false)
-       false))))
-
-(comment
-  (enc/qb 1e6 (may-profile? 2)) ; 468.24
-
-  (binding [*min-level* [["foo.bar" 1] ["*" 3]]
-            *ns-filter* "*"]
-    (may-profile? 2 "baz")))
-
-;;;; Compile-time filtering
-
-#?(:clj
-   (def ^:private compile-time-min-level
-     (when-let [level (enc/read-sys-val* [:taoensso.tufte.min-level.edn :taoensso.tufte.min-level :tufte.min-level])]
-       (valid-min-level level)
-       (do              level))))
-
-#?(:clj
-   (def ^:private compile-time-ns-filter
-     (let [ns-pattern (enc/read-sys-val* [:taoensso.tufte.ns-pattern.edn :taoensso.tufte.ns-pattern :tufte.ns-pattern])]
-       (or ns-pattern "*"))))
-
-#?(:clj
-   (defn -elide?
-     "Returns true iff level or ns are compile-time filtered.
-     Called only at macro-expansiom time."
-     [level-form ns-str-form]
-     (not
-       (and
-         (or ; Level okay
-           (nil? compile-time-min-level)
-           (not (valid-call-level? level-form)) ; Not a compile-time level const
-           (>= (long level-form) (long (get-min-level 6 compile-time-min-level ns-str-form))))
-
-         (or ; Namespace okay
-           (not (string? ns-str-form)) ; Not a compile-time ns-str const
-           (may-profile-ns? compile-time-ns-filter ns-str-form))))))
-
-;;;; Output handlers
-;; Handlers are used for `profile` output, let us nicely decouple stat
-;; creation and consumption.
-
-(defrecord HandlerVal [ns-str level ?id ?data pstats pstats-str_ ?file ?line])
-
-(def         handlers_ "{<handler-id> <handler-fn>}" impl/handlers_)
-(defn remove-handler! [handler-id] (set (keys (swap! handlers_ dissoc handler-id))))
-(defn    add-handler!
-  "Use this to register interest in stats output produced by `profile` calls.
-  Each registered `handler-fn` will be called as:
-
-    (handler-fn {:ns-str _ :level _ :?id _ :?data _ :pstats _ :pstats-str_ _})
-
-  Map args:
-    :ns-str      - Namespace string where `profile` call took place
-    :level       - Level e/o #{0 1 2 3 4 5}, given in `(profile {:level _} ...)`
-    :?id         - Optional group id,        given in `(profile {:id    _} ...)`
-    :?data       - Optional arb data,        given in `(profile {:data  _} ...)`
-    :pstats      - As in `(second (profiled ...))`. Derefable, mergeable.
-    :pstats-str_ - `(delay (format-pstats pstats))
-
-  Error handling (NB):
-    Handler errors will be silently swallowed. Please `try`/`catch` and
-    appropriately deal with (e.g. log) possible errors *within* `handler-fn`.
-
-  Async/blocking:
-    `handler-fn` should ideally be non-blocking, or reasonably cheap. Handler
-     dispatch occurs through a 1-thread 1k-buffer dropping queue.
-
-  Ns filtering:
-    Provide an optional `ns-pattern` arg to only call handler for matching
-    namespaces. See `*ns-filter*` for example patterns.
-
-  Handler ideas:
-    Save to a db, log, `put!` to an appropriate `core.async` channel, filter,
-    aggregate, use for a realtime analytics dashboard, examine for outliers
-    or unexpected output, ..."
-
-  ([handler-id handler-fn] (add-handler! handler-id nil handler-fn))
-  ([handler-id ns-pattern handler-fn]
-   (let [f
-         (if (or (nil? ns-pattern) (= ns-pattern "*"))
-           handler-fn
-           (let [nsf? (enc/name-filter ns-pattern)]
-             (fn [m]
-               (when (nsf? (get m :ns-str))
-                 (handler-fn m)))))]
-
-     (set (keys (swap! handlers_ assoc handler-id f))))))
-
-(declare format-pstats)
-
-(defn add-basic-println-handler!
-  "Adds a simple handler that logs `profile` stats output with `println`."
-  [{:keys [ns-pattern handler-id format-pstats-opts]
-    :or   {ns-pattern "*"
-           handler-id :basic-println}}]
-
-  (add-handler! handler-id ns-pattern
-    (fn [{:keys [?id ?data pstats]}]
-      (println
-        (str
-          (when ?id   (str "\nid: "   ?id))
-          (when ?data (str "\ndata: " ?data))
-          "\n" (format-pstats pstats format-pstats-opts))))))
-
-(defn format-id-abbr
-  "Returns a cached (fn [id]) => abbreviated id string.
-  Takes `n` (default 1), the number of namespace parts to keep unabbreviated.
-
-  Examples:
-    ((format-id-abbr)   :foo)                     => \"foo\"
-    ((format-id-abbr)   :example.hello/foo)       => \"e.hello/foo\"
-    ((format-id-abbr 1) :example.hello/foo)       => \"e.hello/foo\"
-    ((format-id-abbr 1) :example.hello.world/foo) => \"e.h.world/foo\"
-    ((format-id-abbr 2) :example.hello.world/foo) => \"e.hello.world/foo\"
-    ((format-id-abbr 0) :example.hello.world/foo) => \"e.h.w/foo\""
-
-  ([ ] (format-id-abbr 1))
-  ([n]
-   (let [n (long (enc/have enc/int? n))]
-     (enc/fmemoize
-       (fn [id]
-         (let [kw (if (keyword? id) id (keyword (enc/have string? id)))
-               ns-parts (pop (enc/explode-keyword kw))
-               cnt      (count ns-parts)
-               sb
-               (enc/reduce-indexed
-                 (fn [sb ^long idx in]
-                   (when-not (zero? idx) (enc/sb-append sb "."))
-                   (if (<= (- cnt idx) n)
-                     (enc/sb-append sb                        in)
-                     (enc/sb-append sb (enc/get-substr-by-idx in 0 1))))
-                 (enc/str-builder)
-                 ns-parts)]
-
-           (when (pos? cnt) (enc/sb-append sb "/"))
-           (do              (enc/sb-append sb (enc/str-replace (name kw) #"^defn_" "")))
-           (str sb)))))))
-
 (comment
-  ((format-id-abbr 1) :foo.bar/baz)
-  ((format-id-abbr 1) "foo.bar/baz"))
-
-;;;; Some low-level primitives
+  (remove-ns (symbol (str *ns*)))
+  (:api (enc/interns-overview)))
+
+;; TODO
+;; - Review encore/sigs integration, incl. terminology
+;; - Review docstrings (incl. default levels)
+;; - Update tests
+;; - Update README, wiki
+;; - Add CHANGELOG, migration info
+;;   - (Breaking) format-pstats output no longer ends with newline by default
+
+;;;; Shared signal API
+
+(sigs/def-api
+  {:sf-arity 3
+   :ct-sig-filter   impl/ct-sig-filter
+   :*rt-sig-filter* impl/*rt-sig-filter*
+   :*sig-handlers*  impl/*sig-handlers*
+   :lib-dispatch-opts
+   (assoc sigs/default-handler-dispatch-opts
+     :convey-bindings? false ; Handled manually
+     )})
+
+;;;; Low-level primitives
 
 (defn profiling? "Returns e/o #{nil :thread :dynamic}."
   [] (if impl/*pdata* :dynamic (when (impl/pdata-local-get) :thread)))
 
-(comment (enc/qb 1e6 (profiling?))) ; 49.69
+(comment (enc/qb 1e6 (profiling?))) ; 43.91
 
 (def ^:const ^:private default-nmax (long 8e5))
 (defn new-pdata
-  "Note: this is a low-level primitive for advanced users!
+  "Low-level primitive for advanced users.
   Returns a new pdata object for use with `with-profiling` and/or `capture-time!`.
   Deref to get pstats:
 
@@ -307,124 +89,187 @@
   pdata object will not be concurrently modified across threads. Concurrent
   modification will lead to bad data and/or exceptions!"
   ([] (new-pdata nil))
-  ([{:keys [dynamic? nmax] :or {dynamic? true nmax default-nmax}}]
+  ([{:keys [dynamic? nmax] :or {dynamic? true, nmax default-nmax}}]
    (if dynamic?
      (impl/new-pdata-dynamic nmax)
-     (impl/new-pdata-local   nmax))))
+     (impl/new-pdata-local   nmax)))
 
-(comment
-  @@(new-pdata)
+  ([dynamic? nmax]
+   (if dynamic?
+     (impl/new-pdata-dynamic (or nmax default-nmax))
+     (impl/new-pdata-local   (or nmax default-nmax)))))
 
-  ;; Note that dynamic pdata with non-dynamic `with-profiling` is fine:
-  (let [pd (new-pdata)
-        t0 (System/nanoTime)]
-    (with-profiling pd {}
-      (p :foo (Thread/sleep 100))
-      (capture-time! pd :bar (- t0 (System/nanoTime))))
-    @pd) ; => pstats
-  )
+(comment (let [pd (new-pdata)] [(enc/qb 1e6 (pd :foo 100 nil)) @(pd)])) ; 116
+
+(defn- valid-opts!        [caller x] (if (map? x)            x (throw (ex-info (str caller " opts must be a const (compile-time) map")              (enc/typed-val x)))))
+(defn- valid-opt:dynamic! [caller x] (if (enc/const-form? x) x (throw (ex-info (str caller " `:dynamic?` opt must be a const (compile-time) value") (enc/typed-val x)))))
 
 #?(:clj
    (defmacro with-profiling
-     "Note: this is a low-level primitive for advanced users!
-     Enables `p` forms in body and returns body's result.
+     "Low-level primitive for advanced users.
+     Executes body with profiling active, and returns <body-result>.
 
      If `:dynamic?` is false (default), body's evaluation MUST begin
-     and end without interruption on the same thread. In particular
-     this means that body MUST NOT contain any parking `core.async`
-     calls.
+     and end without interruption on the same thread. This means that
+     body CANNOT contain any parking IoC style (e.g. `core.async`)
+     macros.
 
      See `new-pdata` for more info on low-level primitives."
-     [pdata {:keys [dynamic? nmax] :or {nmax default-nmax}} & body]
+     [pdata {:keys [dynamic?]} & body]
+     (valid-opt:dynamic! 'tufte/with-profiling dynamic?)
      (if dynamic?
        `(binding [impl/*pdata* ~pdata] (do ~@body))
-       `(try
-          (impl/pdata-local-push ~pdata)
-          (do ~@body)
-          (finally (impl/pdata-local-pop))))))
+       `(binding [impl/*pdata*    nil] ; Ensure no dynamic parent (=>nesting) steals local captures
+          (try
+            (impl/pdata-local-push ~pdata)
+            (do ~@body)
+            (finally (impl/pdata-local-pop)))))))
+
+#?(:clj
+   (defmacro ^:private profiled*
+     "Unconditionally returns [<body-result> <pstats>]."
+     [caller dynamic? nmax run-form]
+     (valid-opt:dynamic! caller dynamic?)
+     (if dynamic?
+       `(let [pd# (impl/new-pdata-dynamic (or ~nmax default-nmax))] (binding [impl/*pdata* pd#] [~run-form @pd#]))
+       `(let [pd# (impl/new-pdata-local   (or ~nmax default-nmax))]
+          (binding [impl/*pdata* nil]
+            (try
+              (impl/pdata-local-push pd#)
+              [~run-form @pd#]
+              (finally (impl/pdata-local-pop))))))))
+
+(comment
+  @((new-pdata))
+  (let [pd (new-pdata)
+        t0 (System/nanoTime)]
+    ;; Dynamic pdata with non-dynamic `with-profiling` is fine:
+    (with-profiling pd {}
+      (pd :id1 100 nil)
+      (pd :id2 250 nil))
+    @(pd))
+
+  (profiled* 'tufte/caller true nil (do (Thread/sleep 1000) :return-val)))
 
 #?(:clj
    (defmacro capture-time!
-     "Note: this is a low-level primitive for advanced users!
-     Can be useful when tracking time across arbitrary thread boundaries or for
+     "Low-level primitive for advanced users.
+     Useful when tracking time across thread boundaries and/or for
      async jobs / callbacks / etc.
 
      See `new-pdata` for more info on low-level primitives.
      See also `capture-time!*`."
-     ([pdata id nano-secs-elapsed] `(impl/capture-time! ~pdata ~id ~nano-secs-elapsed ~(enc/get-source &form &env)))
+     ([pdata id nano-secs-elapsed] `(~pdata ~id ~nano-secs-elapsed ~(enc/get-source &form &env)))
      ([      id nano-secs-elapsed]
-      `(when-let [~'pd (or impl/*pdata* (impl/pdata-local-get))]
-         (impl/capture-time! ~'pd ~id ~nano-secs-elapsed ~(enc/get-source &form &env))))))
+      `(when-let [pd# (or impl/*pdata* (impl/pdata-local-get))]
+         (pd# ~id ~nano-secs-elapsed ~(enc/get-source &form &env))))))
 
 (defn capture-time!*
-  "Like `capture-time!` but: a function, and does not collect callsite location info."
-  ([pdata id nano-secs-elapsed] (impl/capture-time! pdata id nano-secs-elapsed nil))
+  "Like `capture-time!` but a function and does not collect callsite location info."
+  ([pdata id nano-secs-elapsed] (pdata id nano-secs-elapsed nil))
   ([      id nano-secs-elapsed]
    (when-let [pd (or impl/*pdata* (impl/pdata-local-get))]
-     (impl/capture-time! pd id nano-secs-elapsed nil))))
+     (pd id nano-secs-elapsed nil))))
 
 (comment
-  @(second
-     (profiled {}
-       (let [t0 (System/nanoTime)
-             _  (Thread/sleep 2200)
-             t1 (System/nanoTime)]
-         (capture-time! :foo (- t1 t0)))))
-
   (let [pd (new-pdata)]
-    (enc/qb 1e6 (capture-time! pd :foo 100))
-    @@pd)
+    (with-profiling pd {}
+      (let [t0 (System/nanoTime)
+            _  (Thread/sleep 2200)
+            t1 (System/nanoTime)]
+        (capture-time! :foo (- t1 t0))))
+    @(pd)))
+
+;;;; Main macros
+
+#?(:clj
+   (defmacro p
+     "Profiling spy.
+
+     Use this to wrap forms that should be timed during profiling:
+       - Always executes body and returns <body-result>.
+       - When profiling is active (via `profiled` or `profile`),
+         records body's execution time.
+
+     Options include:
+       `:id`    - Form id for this body in pstats (e.g. `::my-fn-call`)
+       `:level` - ∈ #{<int> :trace :debug :info :warn :error :fatal :report ...}"
+
+     {:arglists '([id & body] [{:keys [id level]} & body])}
+     [s1 & body]
+     (let [opts         (if (map? s1) s1 {:id s1})
+           level-form   (get opts :level 5)
+           id-form      (get opts :id)
+           location (or (get opts :location) (enc/get-source &form &env))]
+
+       ;; If level is present, it must be a valid compile-time level
+       ;; since this macro doesn't offer runtime level checking
+       (when level-form (sigs/valid-level level-form))
+
+       (when (or (nil? id-form) (empty? body))
+         (throw
+           (ex-info "`tufte/p` requires an id."
+             {:location location, :opts opts, :form `(~'p s1 ~@body)})))
+
+       (if-let [elide? (when-let [sf impl/ct-sig-filter] (not (sf (str *ns*) #_(enc/const-form id-form) (enc/const-form level-form))))]
+         `(do ~@body)
+         ;; Note no rt-sig-filter check
+         `(let [pd-dynamic# impl/*pdata*]
+            (if-let [pd#     (or pd-dynamic# (impl/pdata-local-get))]
+              (let  [t0#     (enc/now-nano*)
+                     result# (do ~@body)
+                     t1#     (enc/now-nano*)]
+                ;; Note that capture cost is excluded from p time
+                (pd# ~id-form (- t1# t0#) ~location)
+                result#)
+              (do ~@body)))))))
 
+(comment
   (let [pd (new-pdata)]
     (with-profiling pd {}
       (p :foo (Thread/sleep 100))
       (p :bar (Thread/sleep 200)))
-    @@pd))
-
-;;;; Core macros
-
-(defn- valid-compile-time-opts [dynamic? nmax]
-  (when-not (contains? #{false true} dynamic?) (throw (ex-info "[profile/d] `:dynamic?` opt must be compile-time bool value" {:value dynamic?})))
-  (when-not (integer? nmax)                    (throw (ex-info "[profile/d] `:nmax` opt must be compile-time integer value"  {:value nmax}))))
-
-(comment (valid-compile-time-opts 'sym 'sym))
+    @(pd)))
 
 #?(:clj
    (defmacro profiled
-     "Always executes body, and always returns [<body-result> <?pstats>].
+     "Use this to start profiling:
+       - Always executes body and returns [<body-result> <?pstats>].
+       - When profiling is unfiltered [*1], records execution time of all `p` forms.
 
-     When [ns level] unelided and [ns level `when`] unfiltered, executes body
-     with profiling active.
+     [*1] See `set-ns-filter!`, `set-id-filter!`, `set-min-level!`, etc.
 
-     Handy if you'd like to consume stats output directly.
-     Otherwise see `profile`.
+     Handy if you'd like to consume pstats directly, otherwise see `profile`.
 
      `pstats` objects are derefable and mergeable:
        - @pstats                 => {:clock {:keys [t0 t1 total]}, :stats {<id> {:keys [n sum ...]}}}
        - @(merge-pstats ps1 ps2) => {:clock {:keys [t0 t1 total]}, :stats {<id> {:keys [n sum ...]}}}
 
-     Full set of keys in `:stats` maps:
-       :n :min :max :mean :mad :sum :p25 :p50 :p75 :p90 :p95 :p99 :loc
+     Full set of keys in above `:stats` maps:
+       :n :min :max :mean :mad :sum :p25 :p50 :p75 :p90 :p95 :p99 :loc :last
 
        All values are numerical (longs or doubles), except for `:loc` which
-       is a map of `p` callsite location information, e.g.:
-         {:ns \"my-ns\", :file \"/tmp/my-ns.clj\", :line 122, :column 21}
+       is a map of `p` callsite location information, or set of such maps, e.g.:
+         #{{:ns \"my-ns\", :file \"/tmp/my-ns.clj\", :line 122, :column 21}}
 
-     Compile-time opts:
-       :dynamic? - Use multi-threaded profiling? ; Default is `false`
-       :nmax     - ~Max captures per id before compaction ; Default is 8e5
+     Options include:
+       `:dynamic?`   - Use multi-threaded profiling? (default false).
+       `:nmax`       - Max captures per `p` id before compaction (default 8e5).
+       `:id`         - Profiling id provided to handlers (e.g. `::my-profiling-id`).
 
-     Runtime opts:
-       :level    - e/o #{0 1 2 3 4 5} ; Default is `5`
-       :when     - Optional arbitrary conditional form (e.g. boolean expr)
+       `:level`      - Integer (default 5), must >= active minimum level to profile.
+       `:sample`     - Sample rate ∈ℝ[0,1], profile only this proportion of calls.
+       `:rate-limit` - {<limit-id> [<n-max-calls> <msecs-window>]} spec, profile
+                       only calls that don't exceed the specified limits.
+       `:when`       - Profile only when filter form (e.g. boolean expr) is truthy.
 
      Laziness in body:
        Lazy seqs and other forms of laziness (e.g. delays) in body will only
        contribute to profiling results if/when EVALUATION ACTUALLY OCCURS.
        This is intentional and a useful property. Compare:
 
-       (profiled {}  (delay (Thread/sleep 2000))) ; Doesn't count sleep
-       (profiled {} @(delay (Thread/sleep 2000))) ; Does    count sleep
+         (profiled {}  (delay (Thread/sleep 2000))) ; Doesn't count sleep
+         (profiled {} @(delay (Thread/sleep 2000))) ; Does    count sleep
 
      Async code in body:
        Execution time of any code in body that runs asynchronously on a
@@ -458,78 +303,77 @@
             include un/parking times, use `(profiled {:dynamic? true} ...)`
             instead."
 
+     {:arglists '([{:keys [id level sample-rate when rate-limit rate-limit-by]} & body])}
      [opts & body]
-     (let [ns-str (str *ns*)]
+     (let [opts (enc/merge-nx (valid-opts! 'tufte/profiled opts) {:level 5})
+           {:keys [location elide? allow?]}
+           (sigs/filterable-expansion
+             {:sf-arity 3
+              :ct-sig-filter     impl/ct-sig-filter
+              :*rt-sig-filter* `impl/*rt-sig-filter*}
 
-       (when-not (map? opts)
-         (throw
-           (ex-info "`tufte/profiled` requires a compile-time map as first arg."
-             {:ns-str ns-str :line (:line (meta &form))
-              :form (cons 'profiled (cons opts body))})))
-
-       (let [level-form (get opts :level    5)
-             dynamic?   (get opts :dynamic? false)
-             test-form  (get opts :when     true)
-             nmax       (get opts :nmax     default-nmax)
-
-             _ (valid-compile-time-opts dynamic? nmax)
-             nmax (long nmax)]
-
-         (when (integer? level-form) (valid-call-level level-form))
-
-         (if (-elide? level-form ns-str)
-           `[(do ~@body)]
-           (let [runtime-check
-                 (if (= test-form true) ; Common case
-                        `(may-profile? ~level-form ~ns-str)
-                   `(and (may-profile? ~level-form ~ns-str) ~test-form))]
-
-             (if dynamic?
-               `(if ~runtime-check
-                  (let [pd# (impl/new-pdata-dynamic ~nmax)]
-                    (binding [impl/*pdata* pd#]
-                      [(do ~@body) @pd#]))
-                  [(do ~@body)])
-
-               `(if ~runtime-check
-                  (let [pd# (impl/new-pdata-local ~nmax)]
-                    (binding [impl/*pdata* nil] ; Ensure no dynamic parent (=>nesting) steals local captures
-                      (try
-                        (impl/pdata-local-push pd#)
-                        [(do ~@body) @pd#]
-                        (finally (impl/pdata-local-pop)))))
-                  [(do ~@body)]))))))))
-
-(comment (enc/qb 1e6 (profiled {}))) ; 277.51
+             (assoc opts
+               :location* (get opts :location* (enc/get-source &form &env))
+               :level     (get opts :level 5)))
+
+           {:keys [dynamic? nmax]} opts]
+
+       (valid-opt:dynamic! 'tufte/profiled dynamic?)
+
+       (if elide?
+         `[(do ~@body)]
+         `((fn [] ; iffe-wrap
+             (let [body-fn# (fn [] ~@body)]
+               (enc/if-not ~allow?
+                 [(body-fn#)]
+                 (profiled* 'tufte/profiled ~dynamic? ~nmax (body-fn#))))))))))
+
+(comment
+  (enc/qb 1e6   (profiled {:allow? false}) (profiled {})) ; [37.25 172.27]
+  (macroexpand '(profiled {:allow? false})))
 
 #?(:clj
    (defmacro profile
-     "Always executes body, and always returns <body-result>.
+     "Use this to start profiling:
+       - Always executes body and returns <body-result>.
+       - When profiling is unfiltered [*1], records execution time of all `p` forms
+         and dispatches map [*2] to any registered handlers (see `add-handler!`).
+
+     [*1] See `set-ns-filter!`, `set-id-filter!`, `set-min-level!`, etc.
+     [*2] {:keys [instant id level ns line data pstats format-pstats-fn]}
 
-     When [ns level] unelided and [ns level `when`] unfiltered, executes body
-     with profiling active and dispatches stats to any registered handlers
-     (see `add-handler!`).
+     Decouples creation and consumption of pstats, handy if you'd like to
+     consume/aggregate pstats later/elsewhere. Otherwise see `profiled`.
 
-     Handy if you'd like to consume/aggregate stats output later/elsewhere.
-     Otherwise see `profiled`.
+     `pstats` objects are derefable and mergeable:
+       - @pstats                 => {:clock {:keys [t0 t1 total]}, :stats {<id> {:keys [n sum ...]}}}
+       - @(merge-pstats ps1 ps2) => {:clock {:keys [t0 t1 total]}, :stats {<id> {:keys [n sum ...]}}}
+
+     Full set of keys in above `:stats` maps:
+       :n :min :max :mean :mad :sum :p25 :p50 :p75 :p90 :p95 :p99 :loc :last
+
+       All values are numerical (longs or doubles), except for `:loc` which
+       is a map of `p` callsite location information, or set of such maps, e.g.:
+         #{{:ns \"my-ns\", :file \"/tmp/my-ns.clj\", :line 122, :column 21}}
 
-     Compile-time opts:
-       :dynamic? - Use multi-threaded profiling? ; Default is `false`
-       :nmax     - ~Max captures per id before compaction ; Default is 8e5
+     Options include:
+       `:dynamic?`   - Use multi-threaded profiling? (default false).
+       `:nmax`       - Max captures per `p` id before compaction (default 8e5).
+       `:id`         - Profiling id provided to handlers (e.g. `::my-profiling-id`).
 
-     Runtime opts:
-       :level    - e/o #{0 1 2 3 4 5} ; Default is `5`
-       :when     - Optional arbitrary conditional form (e.g. boolean expr)
-       :id       - Optional group id provided to handlers (e.g. `::my-stats-1`)
-       :data     - Optional arbitrary data provided to handlers
+       `:level`      - Integer (default 5), must >= active minimum level to profile.
+       `:sample`     - Sample rate ∈ℝ[0,1], profile only this proportion of calls.
+       `:rate-limit` - {<limit-id> [<n-max-calls> <msecs-window>]} spec, profile
+                       only calls that don't exceed the specified limits.
+       `:when`       - Profile only when filter form (e.g. boolean expr) is truthy.
 
      Laziness in body:
        Lazy seqs and other forms of laziness (e.g. delays) in body will only
        contribute to profiling results if/when EVALUATION ACTUALLY OCCURS.
        This is intentional and a useful property. Compare:
 
-       (profile {}  (delay (Thread/sleep 2000))) ; Doesn't count sleep
-       (profile {} @(delay (Thread/sleep 2000))) ; Does    count sleep
+         (profiled {}  (delay (Thread/sleep 2000))) ; Doesn't count sleep
+         (profiled {} @(delay (Thread/sleep 2000))) ; Does    count sleep
 
      Async code in body:
        Execution time of any code in body that runs asynchronously on a
@@ -563,131 +407,98 @@
             include un/parking times, use `(profiled {:dynamic? true} ...)`
             instead."
 
+     {:arglists '([{:keys [id level sample-rate when rate-limit rate-limit-by]} & body])}
      [opts & body]
-     (let [ns-str (str *ns*)]
-
-       (when-not (map? opts)
-         (throw
-           (ex-info "`tufte/profile` requires a compile-time map as first arg."
-             {:ns-str ns-str :line (:line (meta &form))
-              :form (cons 'profile (cons opts body))})))
-
-       (let [level-form (get opts :level 5)
-             id-form    (get opts :id)
-             data-form  (get opts :data)]
-
-         (when (integer? level-form) (valid-call-level level-form))
-
-         `(let [[result# pstats#] (profiled ~opts ~@body)]
-            (when pstats#
-              (impl/handle!
-                (HandlerVal. ~ns-str ~level-form ~id-form ~data-form
-                  pstats# (delay (format-pstats pstats#))
-                  ~*file* ~(:line (meta &form)))))
-            result#)))))
+     (let [opts (enc/merge-nx (valid-opts! 'tufte/profile opts) {:level 5})
+           {:keys [location elide? allow?]}
+           (sigs/filterable-expansion
+             {:sf-arity 3
+              :ct-sig-filter     impl/ct-sig-filter
+              :*rt-sig-filter* `impl/*rt-sig-filter*}
+
+             (assoc opts
+               :location* (get opts :location* (enc/get-source &form &env))
+               :bound-forms
+               {:ns    '__ns
+                :id    '__id
+                :level '__level}))
+
+           {:keys [dynamic? nmax]} opts]
+
+       (valid-opt:dynamic! 'tufte/profile dynamic?)
+
+       (if elide?
+         (do ~@body)
+
+         (let [{ns-form :ns} location
+               {level-form       :level
+                id-form          :id
+                data-form        :data
+                sample-rate-form :sample-rate}
+               opts
+
+               {:keys [format-pstats-opts]} opts]
+
+           `((fn [] ; iffe-wrap
+               (let [handlers# impl/*sig-handlers*
+                     body-fn#  (fn [] ~@body)
+                     ~'__ns    ~ns-form
+                     ~'__id    ~id-form
+                     ~'__level ~level-form]
+
+                 (enc/if-not (enc/and* handlers# ~allow?)
+                   (body-fn#)
+                   (let [inst# (enc/now-inst)
+                         [body-result# pstats#] (profiled* 'tufte/profiled ~dynamic? ~nmax (body-fn#))]
+                     (when pstats#
+                       (sigs/call-handlers! handlers#
+                         (WrappedProfilingSignal. ~'__ns ~'__id ~'__level
+                           (enc/bound-delay
+                             (ProfilingSignal. 1 inst# ~location
+                               ~'__id ~'__level ~sample-rate-form *ctx* ~data-form,
+                               body-result# pstats# (enc/fmemoize format-pstats))))))
+                     body-result#))))))))))
+
+
+(comment ; TODO
+  ;; Exclude #{:ctx :middleware} or fully implement?
+
+  ctx-form
+  (if-let [ctx+ (get opts :ctx+)]
+    `(taoensso.encore.signals/update-ctx *ctx* ~ctx+)
+    (get opts :ctx                      `*ctx*))
+
+  middleware-form
+  (if-let [middleware+ (get opts :middleware+)]
+    `(taoensso.encore/comp-middleware *middleware* ~middleware+)
+    (get opts :middleware            `*middleware*)))
 
 (comment
   (profiled {} "body")
   (profiled {:when (chance 0.5)} "body")
-  (profile  {:id ::my-id} "body"))
-
-#?(:clj
-   (defmacro p
-     "Profiling spy. Always executes body, and always returns <body-result>.
-
-     When [ns level] unelided and profiling is active, records execution
-     time of body.
-
-     Compile-time opts:
-      :id    - Form id for this body in stats output (e.g. `::my-fn-call`)
-      :level - e/o #{0 1 2 3 4 5} ; Default is `5`"
-
-     {:arglists '([id & body] [opts & body])}
-     [s1 & body]
-     (let [ns-str  (str *ns*)
-           opts    (if (map? s1) s1 {:level 5 :id s1})
-           level   (get opts :level)
-           id-form (get opts :id)
-           loc (or (get opts :loc) (enc/get-source &form &env))]
-
-       ;; If *any* level is present, it must be a valid compile-time level
-       ;; since this macro doesn't offer runtime level checking
-       (when level (valid-call-level level))
-
-       (when (nil? id-form)
-         (throw
-           (ex-info "`tufte/p` requires an id."
-             {:loc  loc
-              :opts opts
-              :form (cons 'p (cons s1 body))})))
-
-       (if (-elide? level ns-str)
-         `(do ~@body)
-         ;; Note no runtime `may-profile?` check
-         `(let [~'__pd-dynamic impl/*pdata*]
-            (if-let [~'__pd (or ~'__pd-dynamic (impl/pdata-local-get))]
-              (let [~'__t0     (enc/now-nano*)
-                    ~'__result (do ~@body)
-                    ~'__t1     (enc/now-nano*)]
-
-                ;; ~(println [id-form (:line loc)]) ; Debug location info
-
-                ;; Note that `capture-time!` expense is excl. from p time
-                (impl/capture-time! ~'__pd ~id-form (- ~'__t1 ~'__t0) ~loc )
-                ~'__result)
-
-              (do ~@body)))))))
-
-#?(:clj (defmacro pspy "`p` alias" [& args] (enc/keep-callsite `(p ~@args))))
-
-(comment
-  (p :p1 "body")
-  (profiled {} (p :p1))
-  (profiled {} (p {:level 5 :id :p1}))
-  (profiled {} (p (let [x :foo/id] x) "body"))
-  (enc/qb 1e5  (profiled {} 2 (p :p1))) ; 39.5
-  (enc/time-ms (profiled {} 2 (enc/qb 1e6 (p :p1)))) ; 3296
-  (profiled {:level 2 :when (chance 0.5)} (p :p1 "body"))
-  (profiled {} (p :foo (p :bar))))
+  (profile  {:id ::my-id} "body")
 
-;;;; Public user utils
+  (do      (profiled {} (p {:level 5 :id :p1})))
+  @(second (profiled {} (p (let [x :foo/id] x) "body")))
+  @(second (profiled {} (p :foo (p :bar))))
 
-(defn compile-ns-filter "Wraps `taoensso.encore/name-filter`."
-  [ns-pattern] (enc/name-filter ns-pattern))
+  (enc/qb 1e5  (profiled {} 2 (p :p1))) ; 25.39
+  (enc/time-ms (profiled {} 2 (dotimes [_ 3e6] (p :p1)))) ; 766
+  )
 
-(defn chance "Returns true with 0<`p`<1 probability."
-  [p] (< ^double (rand) (double p)))
+;;;; Utils
 
-#?(:clj
-   (defn refer-tufte
-     "(require '[taoensso.tufte :as tufte :refer [defnp p profiled profile]])"
-     [] (require '[taoensso.tufte :as tufte :refer [defnp p profiled profile]])))
-
-(comment (refer-tufte))
-
-(defn merge-pstats
-  "Statistics are lossless unless data to merge are very large."
-  ([       ] nil)
-  ([ps0    ] ps0)
-  ([ps0 ps1] (impl/merge-pstats ps0 ps1)))
+(enc/defaliases
+  enc/chance
+  impl/merge-pstats
+  impl/format-pstats
+  impl/format-grouped-pstats)
 
 (comment
   (let [[_ ps1] (profiled {} (p :p1))
         [_ ps2] (profiled {} (p :p1))]
-    (enc/qb 1e5 (merge-pstats ps1 ps2))))
-
-(defn format-pstats
-  "Formats given pstats to a string table.
-    Accounted < Clock => Some work was done that wasn't tracked by any p forms.
-    Accounted > Clock => Nested p forms, and/or parallel threads."
-  ([ps     ] (format-pstats ps nil))
-  ([ps opts]
-   (when ps
-     (let [{:keys [clock stats]} (if (instance? PStats ps) @ps ps)]
-       (stats/format-pstats (get clock :total) stats opts)))))
+    (enc/qb 1e5 (merge-pstats ps1 ps2))) ; 92.04
 
-(comment
-  ;; [:n :min :p25 :p50 :p75 :p90 :p95 :p99 :max :mean :mad :clock :sum]
   (println
     (str "\n"
       (format-pstats
@@ -698,16 +509,35 @@
             (do     (Thread/sleep 800))))
         {:columns [:clock :p50 :p95]}))))
 
+(defn format-id-abbr-fn
+  "Returns a cached (fn [id]) => abbreviated id with at most `n-full`
+  unabbreviated namespace parts.
+
+  Example:
+    ((format-id-abbr 0)  :foo.bar/baz)   => :f.b/baz
+    ((format-id-abbr 1)  'foo.bar/baz)   => 'f.bar/baz
+    ((format-id-abbr 2) \"foo.bar/baz\") => \"foo.bar/baz\""
+
+  ([      ] (format-id-abbr-fn 1))
+  ([n-full] (enc/fmemoize (partial enc/abbreviate-ns n-full))))
+
+#?(:clj
+   (defmacro refer-tufte
+          "(require '[taoensso.tufte :as tufte :refer [defnp p profiled profile]])"
+     [] `(require '~'[taoensso.tufte :as tufte :refer [defnp p profiled profile]])))
+
+(comment (refer-tufte))
+
 ;;;; fnp stuff
 
-(defn- fn-sigs [def? ?meta-pid ?fn-sym sigs loc]
-  (let [single-arity?    (vector? (first sigs))
-        sigs    (if single-arity? (list  sigs) sigs)
-        fn-sym  (or ?fn-sym (gensym))
+(defn- fn-sigs [def? ?meta-id ?fn-sym sigs location]
+  (let [single-arity?   (vector? (first sigs))
+        sigs   (if single-arity? (list  sigs) sigs)
+        fn-sym (or ?fn-sym (gensym))
 
         base-id
-        (if ?meta-pid
-          (enc/as-qname ?meta-pid)
+        (if ?meta-id
+          (enc/as-qname ?meta-id)
           (str *ns* "/" (if def? "defn_" "fn_") (name fn-sym)))
 
         get-ids
@@ -725,12 +555,12 @@
 
               (if ?prepost-map
                 (if-let [arity-id ?arity-id]
-                  `(~params ~?prepost-map (p {:id ~base-id, :loc ~loc} (p {:id ~arity-id, :loc ~loc} ~@body)))
-                  `(~params ~?prepost-map (p {:id ~base-id, :loc ~loc}                               ~@body)))
+                  `(~params ~?prepost-map (p {:id ~base-id, :location ~location} (p {:id ~arity-id, :location ~location} ~@body)))
+                  `(~params ~?prepost-map (p {:id ~base-id, :location ~location}                                         ~@body)))
 
                 (if-let [arity-id ?arity-id]
-                  `(~params               (p {:id ~base-id, :loc ~loc} (p {:id ~arity-id, :loc ~loc} ~@body)))
-                  `(~params               (p {:id ~base-id, :loc ~loc}                               ~@body))))))
+                  `(~params               (p {:id ~base-id, :location ~location} (p {:id ~arity-id, :location ~location} ~@body)))
+                  `(~params               (p {:id ~base-id, :location ~location}                                         ~@body))))))
 
           sigs)]
     new-sigs))
@@ -778,7 +608,7 @@
         [name doc-string? attr-map? ([params*] prepost-map? body)+ attr-map?])}
      [& sigs]
      (let [[fn-sym sigs] (enc/name-with-attrs (first sigs) (next sigs) {:private true})
-           new-sigs      (fn-sigs :def (:tufte/id (meta fn-sym)) fn-sym sigs
+           new-sigs      (fn-sigs :def (get (meta fn-sym) :tufte/id) fn-sym sigs
                            (enc/get-source &form &env))]
        `(defn ~fn-sym ~@new-sigs))))
 
@@ -790,154 +620,184 @@
                                        ([x y] (* x y))))
   (profiled {} (foo 5)))
 
-;;;; Stats accumulators (experimental)
+;;;; StatsAccumulator
 
-(defn- sacc-drain-and-merge! [pstats_] (enc/reset-in! pstats_ {}))
-(defn- sacc-add!             [pstats_ group-id ps]
-  (when (and group-id ps)
-    ;; Contention would be expensive, consumer should serialize:
-    (swap! pstats_ (fn [m] (assoc m group-id (impl/merge-pstats (get m group-id) ps))))
-    true))
-
-(deftype StatsAccumulator [pstats_] ; {<group-id> <pstats>}
-  #?@(:clj  [clojure.lang.IFn  (invoke [_ group-id ps] (sacc-add! pstats_ group-id ps))]
-      :cljs [             IFn (-invoke [_ group-id ps] (sacc-add! pstats_ group-id ps))])
-  #?@(:clj  [clojure.lang.IDeref  (deref [_] (sacc-drain-and-merge! pstats_))]
-      :cljs [             IDeref (-deref [_] (sacc-drain-and-merge! pstats_))]))
+(deftype StatsAccumulator [acc]
+  ;; `acc` - (latom {<profile-id> <pstats>})
+  #?(:clj clojure.lang.IDeref :cljs IDeref) (#?(:clj deref  :cljs -deref)  [_] (enc/reset-in! acc {})) ; Drain
+  #?(:clj clojure.lang.IFn    :cljs IFn)    (#?(:clj invoke :cljs -invoke) [_] (enc/reset-in! acc {})) ; Drain
+  (                                          #?(:clj invoke :cljs -invoke) [_ profile-id ps]
+   (when (and profile-id ps)
+     ;; Contention would be expensive so consumer should serialize calls
+     (acc profile-id #(impl/merge-pstats % ps))
+     true)))
 
 (defn stats-accumulator
-  "Alpha, subject to change.
-  Small util to help merge pstats from multiple runs or threads.
-
-  Returns a stateful StatsAccumulator (`sacc`) with:
-    - `(sacc <group-id> <pstats>)` ; Merges given pstats under given group id
-    - `@sacc`                      ; Drains accumulator and returns {<group-id> <merged-pstats>}
+  "Experimental, subject to change. Feedback welcome!
+  Small util to help merge pstats from multiple runs and/or threads.
 
-  Note that you may want some kind of async/buffer/serialization
-  mechanism in front of merge calls for performance (e.g. by using an agent).
+  Returns a stateful `StatsAccumulator` (`sacc`) with:
+    - (sacc <profile-id> <pstats>) ; Merges given pstats under given profile id
+    - @sacc                        ; Drains accumulator and returns drained
+                                   ; {<profile-id> <merged-pstats>}
 
-  See also `add-accumulating-handler!`, example clj project."
+  Note that for performance reasons, you'll likely want some kind of
+  async/buffer/serialization mechanism in front of merge calls.
 
-  [] (StatsAccumulator. (atom {})))
+  One common pattern using `handler:accumulating` is to create a
+  system-wide accumulator that you deref every n minutes/etc. to get
+  a view of system-wide performance over the period, e.g.:
 
-(comment
-  (enc/qb 1e6 (stats-accumulator)) ; 66.75
-  (let [sacc (stats-accumulator)]
-    (sacc :profiled1 (second (profiled {} (p :p1))))
-    (Thread/sleep 100)
-    (sacc :profiled2 (second (profiled {} (p :p2))))
-    [@sacc @sacc]))
-
-(defn add-accumulating-handler!
-  "Alpha, subject to change.
-
-  Creates a new StatsAccumulator (and agent in clj), then
-  registers a handler to accumulate `profile` output to the
-  StatsAccumulator using the agent.
-
-  Returns the StatsAccumulator. You can deref the result to
-  drain the accumulator and return {<group-id> <merged-pstats>}.
-
-  One common pattern is to deref the accumulator every n
-  minutes/etc. to get a view of total-system performance over
-  the period, e.g.:
-
-  (defonce my-sacc (add-accumulating-handler! {:ns-pattern \"*\"}))
-  (defonce my-sacc-drainer
-    ;; Will drain and print formatted stats every minute
-    (future
-      (while true
-        (when-let [m (not-empty @my-sacc)]
-          (println (format-grouped-pstats m)))
-        (Thread/sleep 60000))))
-
-  (profile ...) ; Used elsewhere in your application, e.g.
-                ; wrapping relevant Ring routes in a web application.
+    (defonce my-sacc (stats-accumulator) ; Create an accumulator
+    (add-handler! :my-sacc (handler:accumulating my-sacc)) ; Register handler
 
-  See also `format-grouped-pstats`, example clj project."
+    (defonce my-sacc-drainer
+      ;; Drain and print formatted stats every minute
+      (future
+        (while true
+          (when-let [m (not-empty @my-sacc)]
+            (println (format-grouped-pstats m)))
+          (Thread/sleep 60000))))
 
-  [{:keys [ns-pattern handler-id]
-    :or   {ns-pattern "*"
-           handler-id :accumulating}}]
+    (profile ...) ; Used elsewhere in your application, e.g.
+                  ; wrapping relevant Ring routes in a web application.
 
-  (let [sacc   (stats-accumulator)
-        agent_ #?(:clj (delay (agent nil :error-mode :continue)) :cljs nil)]
+  See example clj project for more details."
+  [] (StatsAccumulator. (enc/latom {})))
 
-    (add-handler! handler-id ns-pattern
-      (fn [{:keys [?id ?data pstats]}]
-        (let [id (or ?id :tufte/nil-id)]
-          #?(:clj (send @agent_ (fn [_] (sacc id pstats)))
-             :cljs                      (sacc id pstats)))))
+(comment
+  (enc/qb 1e6 (stats-accumulator)) ; 45.37
+  (let [sacc  (stats-accumulator)]
+    (sacc :profiled1 (second (profiled {} (p :p1 nil))))
+    (Thread/sleep 100)
+    (sacc :profiled2 (second (profiled {} (p :p2 nil))))
+    [@sacc @sacc]))
 
-    sacc))
+;;;; Handlers
+;; (fn ([psig]) ([])) => effects
+
+(defn- dummy-psig
+  ([] (dummy-psig nil))
+  ([to-merge]
+   (merge
+     {:inst (enc/now-inst), :location {:ns (str *ns*)}, :id ::my-id, :level 5, :data {:x 1}, :ctx {:y 1},
+      :pstats (second (profiled {} (p :p1 (p :p2 (p :p3 "foo")))))}
+     to-merge)))
+
+(defn handler:print
+  "Returns a handler fn for use with `add-handler!` that:
+    1. Formats `profile` pstats with `format-pstats`, and
+    2. Prints the resulting string table with `print`.
+
+  Options:
+    `:format-pstats-opts` - Opts map provided to `format-pstats` (default nil)
+    `:format-inst-fn`     - (fn format [instant]) => string (default ISO8601)"
+
+  {:added "vX.Y.Z (YYYY-MM-DD)"}
+  ([] (handler:print nil))
+  ([{:keys [format-inst-fn format-pstats-opts]
+     :or   {format-inst-fn (enc/format-inst-fn)}}]
+
+   (fn a-handler:print [psig]
+     (let [{:keys [inst location level id data ctx pstats format-pstats-fn]} psig]
+       (let [sb    (enc/str-builder)
+             s+spc (enc/sb-appender sb " ")]
+
+         (when inst  (when-let [ff format-inst-fn] (s+spc (ff inst))))
+         (when level (s+spc (sigs/format-level level)))
+         (do         (s+spc (enc/hostname)))
+         (do         (s+spc (sigs/format-location location)))
+         (when id    (s+spc (sigs/format-id (get location :ns) id)))
+
+         (enc/sb-append sb "\n<<< table <<<\n" (let [ff (or format-pstats-fn format-pstats)] (ff pstats format-pstats-opts)) "\n>>> table >>>")
+         (when-let [data (enc/not-empty-coll data)] (enc/sb-append sb "\n data: " (enc/pr-edn* data)))
+         (when-let [ctx  (enc/not-empty-coll ctx)]  (enc/sb-append sb "\n  ctx: " (enc/pr-edn* ctx)))
+
+         (enc/println (str sb)))))))
+
+(comment ((handler:print) (dummy-psig)))
+
+(defn handler:accumulating
+  "Takes a `StatsAccumulator` and returns a handler fn for use with
+  `add-handler!` that merges `profile` pstats into the given accumulator.
+
+  See `stats-accumulator` for more info."
+  {:added "vX.Y.Z (YYYY-MM-DD)"}
+  [^StatsAccumulator sacc]
+  (fn a-handler:accumulating [psig]
+    (let [{:keys [id pstats]} psig]
+      (sacc id pstats))))
 
 (comment
-  (def my-sacc (add-accumulating-handler! {:ns-pattern "*"}))
-  (future (profile {}         (p :p1 (Thread/sleep 900))))
-  (future (profile {:id :foo} (p :p1 (Thread/sleep 900))))
-  (future (profile {:id :bar} (p :p1 (Thread/sleep 500))))
-  (println (format-grouped-pstats @my-sacc {}
-             #_{:format-pstats-opts {:columns [:n]}})))
-
-(defn format-grouped-pstats
-  "Alpha, subject to change.
-  Takes a map of {<group-id> <PStats>} and formats a combined
-  output string using `format-pstats`.
-
-  See also example clj project."
-  ([m] (format-grouped-pstats m nil))
-  ([m {:keys [group-sort-fn format-pstats-opts]
-       :or   {group-sort-fn (fn [m] (get-in m [:clock :total] 0))}}]
-
-   (when m
-     (let [m ; {<group-id> <realised-pstats>}
-           (persistent!
-             (reduce-kv
-               (fn [m k v] (assoc! m k (enc/force-ref v)))
-               (transient m)
-               m))
-
-           sorted-group-ids
-           (sort-by (fn [id] (group-sort-fn (get m id)))
-             enc/rcompare (keys m))
-
-           ^long max-id-width
-           (reduce-kv
-             (fn [^long acc _ {:keys [clock stats]}]
-               (if-let [c (stats/get-max-id-width stats format-pstats-opts)]
-                 (if (> (long c) acc) c acc)
-                 acc))
-             0
-             m)]
-
-       (enc/str-join "\n\n"
-         (map (fn [id] (str id ",\n" (format-pstats (get m id) (assoc format-pstats-opts :max-id-width max-id-width)))))
-         sorted-group-ids)))))
+  (def my-sacc (stats-accumulator))
+  (add-handler! :my-sacc (handler:accumulating my-sacc))
 
-(comment
-  (future
-    (while true
-      (when-let [m (not-empty @my-sacc)]
-        (println (format-grouped-pstats m)))
-      (Thread/sleep 10000))))
+  (do
+    (future (profile {}         (p :p1 (Thread/sleep 900))))
+    (future (profile {:id :foo} (p :p1 (Thread/sleep 900))))
+    (future (profile {:id :bar} (p :p1 (Thread/sleep 500)))))
+
+  (println
+    (format-grouped-pstats @my-sacc
+      {:format-pstats-opts {:columns [:n]}})))
 
 ;;;; Deprecated
 
 (enc/deprecated
-  #?(:clj (defmacro ^:no-doc ^:deprecated with-min-level "Prefer `binding`." [level & body] `(binding [*min-level* ~level] ~@body)))
-  (defn             ^:no-doc ^:deprecated set-min-level! "Prefer `alter-var-root`." [level]
-    #?(:cljs (set!             *min-level*         level)
-       :clj  (alter-var-root #'*min-level* (fn [_] level))))
-
-  #?(:clj (defmacro ^:no-doc ^:deprecated with-ns-pattern  "Prefer `binding`." [ns-pattern & body] `(binding [*ns-filter* ~ns-pattern] ~@body)))
-  (defn             ^:no-doc ^:deprecated  set-ns-pattern! "Prefer `alter-var-root`." [ns-pattern]
-    #?(:cljs (set!             *ns-filter*         ns-pattern)
-       :clj  (alter-var-root #'*ns-filter* (fn [_] ns-pattern)))))
+  #?(:clj (defmacro ^:no-doc pspy            {:deprecated "vX.Y.Z (YYYY-MM-DD)" :doc "Prefer `p`."}              [& args]             (enc/keep-callsite `(p ~@args))))
+  #?(:clj (defmacro ^:no-doc with-ns-pattern {:deprecated "vX.Y.Z (YYYY-MM-DD)" :doc "Prefer `with-ns-filter`."} [ns-pattern & body] `(with-ns-filter ~ns-pattern (do ~@body))))
+  (defn             ^:no-doc set-ns-pattern! {:deprecated "vX.Y.Z (YYYY-MM-DD)" :doc "Prefer `set-ns-filter!`."} [ns-pattern]         (set-ns-filter!  ns-pattern))
+  (enc/def*         ^:no-doc format-id-abbr  {:deprecated "vX.Y.Z (YYYY-MM-DD)" :doc "Prefer `format-id-abbr-fn`."}                   format-id-abbr-fn)
+
+  (defn ^:no-doc add-legacy-handler!
+    "Prefer `add-handler!`.
+    Note that some handler arg key names have changed:
+      :ns-str -> :ns
+      :?id    -> :id
+      :?data  -> :data"
+    {:deprecated "vX.Y.Z (YYYY-MM-DD)"}
+    ([handler-id            handler-fn] (add-handler! handler-id nil handler-fn))
+    ([handler-id ns-pattern handler-fn]
+     (let [dispatch-opts
+           (when (and ns-pattern (not= ns-pattern "*"))
+             {:ns-filter ns-pattern})]
+
+       (add-handler! handler-id
+         (fn [psig]
+           (let [{:keys [ns id data]} psig]
+             (assoc psig
+               :ns-str ns
+               :?id    id
+               :?data  data)))))))
+
+  (defn ^:no-doc add-basic-println-handler!
+    "Prefer (add-handler! <handler-id> (handler:print {<handler-opts>}) <dispatch-opts>)."
+    {:deprecated "vX.Y.Z (YYYY-MM-DD)"}
+    [{:keys [ns-pattern handler-id format-pstats-opts]
+      :or   {ns-pattern "*"
+             handler-id :basic-println}}]
+
+    (let [handler-fn (handler:print {:format-pstats-opts format-pstats-opts})]
+      ^:deprecation-nowarn (add-legacy-handler! handler-id ns-pattern handler-fn)))
+
+  (defn ^:no-doc add-accumulating-handler!
+    "Prefer
+      (def my-sacc (stats-accumulator))
+      (add-handler! <handler-id> (handler:accumulating my-sacc) <dispatch-opts>)."
+    {:deprecated "vX.Y.Z (YYYY-MM-DD)"}
+    [{:keys [ns-pattern handler-id runner-opts]
+      :or   {ns-pattern "*"
+             handler-id :accumulating}}]
+
+    (let [sacc       (stats-accumulator)
+          handler-fn (handler:accumulating sacc)]
+      ^:deprecation-nowarn (add-legacy-handler! handler-id ns-pattern handler-fn)
+      sacc)))
 
 ;;;;
 
 (comment
-  (add-basic-println-handler! {})
+  (add-handler! :print (handler:print))
   (defn sleepy-threads []
     (dotimes [n 5]
       (Thread/sleep 100) ; Unaccounted
@@ -995,11 +855,3 @@
     (format-pstats
       (second
         (profiled {} (p :foo (Thread/sleep 100)))))))
-
-(comment ; Disjoint time union
-  (let [[_ ps1] (profiled {} (p :foo (Thread/sleep 100)))
-        _ (Thread/sleep 500)
-        [_ ps2] (profiled {} (p :foo (Thread/sleep 100)))]
-    (println (format-pstats (merge-pstats ps2 ps1)))
-    ;;@(merge-pstats ps2 ps1)
-    ))
diff --git a/src/taoensso/tufte/impl.cljc b/src/taoensso/tufte/impl.cljc
index 72786a1..1b7c6ae 100644
--- a/src/taoensso/tufte/impl.cljc
+++ b/src/taoensso/tufte/impl.cljc
@@ -1,112 +1,184 @@
 (ns ^:no-doc taoensso.tufte.impl
   "Private implementation details.
-  `profiled` -> [<result> <derefable-and-mergeable-pstats>].
-
-  Profiling consists of:
-    1. State init   ; On  thread
-    2. Capture      ; On  thread
-    3. State deref  ; On  thread
-    4. ?Merging     ; Off thread, on demand (deferred cost)
-    5. ?Realization ; Off thread, on demand (deferred cost)
-
-  Basic implementation:
-    - Capture [<id> <elapsed>]s into single mutable acc
-      - May compact acc      to id-times,  {<id> (<time>         ...)}
-      - May compact id-times to id-sstats, {<id> (<stats/sstats> ...)}
-    - Merge pours (read-only) acc0 + acc1 into id-times
-      - May compact id-times to id-sstats, {<id> (<stats/sstats> ...)}
-    - Realization:
-        - Generates {<id> <stats/sstats>} from id-times.
-        - Merges with id-sstats."
+  Ultimately returns `PStats` to be merged or derefed.
+
+  Flow:
+    1. Init pdata              ; On  thread
+    2. Capture times -> pdata  ; On  thread
+    3. Deref pdata -> pstats   ; On  thread
+    4. ?Merge pstats           ; Off thread, on demand (deferred cost)
+    5. ?Realize ?merged pstats ; Off thread, on demand (deferred cost)"
 
   (:require
    [clojure.string  :as str]
-   [taoensso.encore :as enc :refer-macros []]
-   [taoensso.tufte.stats :as stats])
-
-  #?(:clj
-     (:import [java.util LinkedList Stack]
-              [java.util.concurrent ArrayBlockingQueue]))
+   [taoensso.encore :as enc]
+   [taoensso.encore.signals :as sigs]
+   [taoensso.encore.stats   :as stats])
 
   #?(:cljs
      (:require-macros
-      [taoensso.tufte.impl :refer [mt-acc mt-add mt-count atom?]])))
+      [taoensso.tufte.impl :refer [mt-acc mt-add! mt-count]])))
+
+(comment
+  (remove-ns (symbol (str *ns*)))
+  (:api (enc/interns-overview)))
+
+;;;; Basic types
 
-;;;; Mutable accumulators
+(do
+  (deftype Time     [id ^long runtime location]) ; Runtime entry
+  (deftype TimeSpan [^long t0 ^long t1])         ; Accumulated during PStats merge
+  (deftype TimeAcc  [^long tsum ^long tmax])     ; Used during reductions, etc.
+  (deftype IdState  [id-times id-sstats]))       ; Used during reductions, etc.
 
-(deftype Time     [id ^long t location-info])
-(deftype TimeSpan [^long t0 ^long t1])
-(comment (enc/qb 1e6 (Time. :foo 1000 nil))) ; 33.59
+;;;; Mutable accumulators (for local-only profiling)
 
 #?(:clj
    (do
-     (defmacro ^:private mt-acc     [] `(enc/if-cljs (cljs.core/array) (LinkedList.)))
-     (defmacro ^:private mt-add [mt x] `(enc/if-cljs (.push   ~mt ~x) (.add  ~(with-meta mt {:tag 'LinkedList}) ~x)))
-     (defmacro ^:private mt-count [mt] `(enc/if-cljs (alength ~mt)    (.size ~(with-meta mt {:tag 'LinkedList}))))))
+     (defmacro ^:private mt-acc   [    ] (if (:ns &env) `(cljs.core/array)                             `(java.util.LinkedList.)))
+     (defmacro ^:private mt-add!  [mt x] (if (:ns &env) `(.push   ~mt ~x)  `(.add  ~(with-meta mt {:tag 'java.util.LinkedList}) ~x)))
+     (defmacro ^:private mt-count [mt  ] (if (:ns &env) `(alength ~mt)     `(.size ~(with-meta mt {:tag 'java.util.LinkedList}))))))
 
-(comment (enc/qb 1e6 (mt-acc) (atom nil))) ; [29.14 57.76]
+;;;; Main types
 
-;;;; PStats (Profiling Stats)
-;; API-level state we'll return from `profiled`: derefable, mergeable
+(defrecord RealizedPStats [^long t0 ^long t1 ^long clock-total stats clock])
+(deftype           PStats ; Profiling Stats
+  [^long nmax ^long t0 ^long t1 acc id-times id-sstats tspans realized_]
+  ;; - Public, mergeable, immutable version of `PData`
+  ;; - Deref to get `RealizedPStats`
+  ;; - All fields but `realized_` used to support merging
+
+  #?@(:clj  [clojure.lang.IDeref  (deref [this] @realized_)]
+      :cljs [             IDeref (-deref [this] @realized_)])
 
-(deftype PStats [pd ^long t1 tspans realized_]
-  #?@(:clj  [clojure.lang.IDeref    (deref     [_]           @realized_)]
-      :cljs [             IDeref   (-deref     [_]           @realized_)])
   #?@(:clj  [clojure.lang.IPending (isRealized [_] (realized? realized_))]
-      :cljs [             IPending (-realized? [_] (realized? realized_))]))
+      :cljs [             IPending (-realized? [_] (realized? realized_))])
 
-;;;; PData (Profiling Data)
-;; Implementation-level state while profiling,
-;;   - id-times:  ?{<id> (<time>         ...)}
-;;   - id-sstats: ?{<id> (<stats/sstats> ...)}
+  Object
+  (toString [x]
+    (enc/str-impl "taoensso.tufte.PStats" x
+      {:realized? (realized? realized_)})))
 
-(declare ^:private deref-pdata)
-(deftype PState [acc id-times id-sstats])
-(deftype  PData [^long nmax ^long t0 pstate_]
-  #?@(:clj  [clojure.lang.IDeref  (deref [this] (deref-pdata this))]
-      :cljs [             IDeref (-deref [this] (deref-pdata this))]))
+(enc/def-print-impl [x PStats] (str "#" x))
 
-(defn new-pdata-local   [^long nmax] (let [t0 (enc/now-nano*)] (PData. nmax t0 (volatile! (PState. (mt-acc)   nil nil)))))
-(defn new-pdata-dynamic [^long nmax] (let [t0 (enc/now-nano*)] (PData. nmax t0 (atom      (PState. (atom nil) nil nil)))))
+(declare
+  ^:private ^IdState compact-id-state
+  ^:private          deref-pstats)
 
-(comment (enc/qb 1e6 (new-pdata-local 10) (new-pdata-dynamic 10))) ; [98.18 138.28]
+#?(:clj
+   (let [cache_ (java.util.concurrent.ConcurrentHashMap.)]
+     ;; Tons of location duplicates in `Time`s, intern to save memory
+     (defn- interned [x] (when x (or (.get cache_ x) (.putIfAbsent cache_ x x) x)))))
+
+(comment (enc/qb 1e6 (interned "foo"))) ; 40.88
+
+(deftype PData ; Profiling Data (private)
+  [dynamic? ^long nmax ^long t0
+   #?(:clj ^:volatile-mutable acc         :cljs ^:mutable acc)
+   #?(:clj ^:volatile-mutable id-times    :cljs ^:mutable id-times)
+   #?(:clj ^:volatile-mutable id-sstats   :cljs ^:mutable id-sstats)
+   #?(:clj ^:volatile-mutable compacting? :cljs ^:mutable compacting?)]
+
+  ;; `acc`       - mutable accumulator or (latom ())
+  ;; `id-times`  - ?{<id> [<Time>               ...]}
+  ;; `id-sstats` - ?{<id> [<stats/SummaryStats> ...]}
+  ;;
+  ;; - Invoke [id nsecs location] to capture Time
+  ;; - Invoke [] to get immutable `PStats`
+
+  #?@(:clj  [clojure.lang.IDeref (deref  [this] (this))]
+      :cljs [             IDeref (-deref [this] (this))])
+
+  #?(:clj clojure.lang.IFn :cljs IFn)
+
+  ;; Captures time, compacting as necessary
+  (#?(:clj invoke :cljs -invoke) [this id nsecs-elapsed location]
+    (when-let [acc-snap acc]
+      (let [new-time (Time. id ^long nsecs-elapsed #?(:clj (interned location) :cljs location))]
+        (enc/when-let
+          [need-compaction?
+           (if dynamic?
+             (> (count (acc-snap #(conj % new-time))) nmax)
+             (do (mt-add! acc-snap new-time) (> (mt-count acc-snap) nmax)))
+
+           pulled-times
+           (if-not dynamic?
+             acc-snap
+             (and
+               (not compacting?) ; Irrelevant for Cljs
+               (loop []
+                 (let [times (acc-snap)]
+                   (when (and (not compacting?) (> (count times) nmax))
+                     (if (enc/-cas!? acc-snap times nil) times (recur)))))))]
+
+          (set! compacting? true)
+          (let [t0        (enc/now-nano*)
+                compacted (compact-id-state nmax id-times id-sstats pulled-times)]
+            ;; Safe to `set!` here even when `dynamic?` since we're protected by
+            ;; CAS against `acc-snap`. Note that for performance reasons we tolerate
+            ;; a theoretical risk of losing times under high contention when `nmax`
+            ;; is ridiculously, unrealistically small.
+            (set! id-times  (.-id-times  compacted))
+            (set! id-sstats (.-id-sstats compacted))
+            (when-not dynamic? (set! acc (mt-acc)))
+            (this :tufte/compaction (- (enc/now-nano*) t0) nil)
+            (set! compacting? false))))
+      true))
+
+  ;; PData->PStats
+  (#?(:clj invoke :cljs -invoke)
+    [_]
+    (when-let [acc-snap acc]
+      (set! acc nil)
+      (let [t1     (enc/now-nano*)
+            tspans [(TimeSpan. t0 t1)]]
+        (PStats.               nmax t0 t1 acc-snap id-times id-sstats tspans
+          (delay (deref-pstats nmax t0 t1 acc-snap id-times id-sstats tspans)))))))
 
-(declare ^:private deref-pstats)
-(defn- deref-pdata "PData->PStats" [^PData pd]
-  ;; NB (.-acc pd) should never be mutated from this point!
-  (let [t1     (enc/now-nano*)
-        t0     (.-t0 pd)
-        tspans (list (TimeSpan. t0 t1))]
+;;;;
 
-    (PStats. pd t1 tspans (delay (deref-pstats pd t1 tspans)))))
+(def ^:dynamic *pdata* "nnil iff dynamic profiling active" nil)
+(defn new-pdata-local   ^PData [^long nmax] (let [t0 (enc/now-nano*)] (PData. false nmax t0 (mt-acc)        nil nil false)))
+(defn new-pdata-dynamic ^PData [^long nmax] (let [t0 (enc/now-nano*)] (PData. true  nmax t0 (enc/latom nil) nil nil false)))
 
-(comment (enc/qb 1e6 @(new-pdata-local 10))) ; 245.08
+(comment
+  (enc/qb 1e6 (new-pdata-local 10) (new-pdata-dynamic 10)) ; [49.61 50.54]
 
-(def ^:dynamic *pdata* "nnil iff dynamic profiling active" nil)
+  (let [pd (new-pdata-local   10)] (pd :id1 100 nil) @(pd))
+  (let [pd (new-pdata-dynamic 10)] (pd :id1 100 nil) @(pd))
+
+  (let [pdl (new-pdata-local   5e6)
+        pdd (new-pdata-dynamic 5e6)]
+
+    (enc/qb 1e6 ; [44.97 67.81]
+      (pdl :id 100 nil)
+      (pdd :id 100 nil))))
+
+;;;; Local PData utils
 
 #?(:clj
    (let [;; Stack to support `profile/d` nesting
-         ^ThreadLocal stack-proxy (proxy [ThreadLocal] [] (initialValue [] (Stack.)))
+         ^ThreadLocal stack-proxy (proxy [ThreadLocal] [] (initialValue [] (java.util.Stack.)))
          ^ThreadLocal pdata-proxy (proxy [ThreadLocal] [])]
 
-     (defn pdata-local-get [] (.get pdata-proxy)) ; => nnil iff thread-local profiling active
+     (defn pdata-local-get "nnil iff thread-local profiling active" [] (.get pdata-proxy))
      (defn pdata-local-pop []
-       (let [^Stack stack (.get stack-proxy)]
+       (let [^java.util.Stack stack (.get stack-proxy)]
          (if-let [stashed (when-not (.empty stack) (.pop stack))]
            (do (.set pdata-proxy stashed) stashed)
            (do (.set pdata-proxy nil)     nil))))
 
      (defn pdata-local-push [v]
-       (let [^Stack stack  (.get stack-proxy)]
+       (let [^java.util.Stack stack  (.get stack-proxy)]
          (if-let [to-stash (.get pdata-proxy)]
            (do (.push stack to-stash) (.set pdata-proxy v) v)
            (do                        (.set pdata-proxy v) v)))))
 
-   :cljs ; Note single-threaded platform
-   (let [stack #js [] ; To support `profile/d` nesting
-         pdata_ (volatile! false)]
+   :cljs ; Single-threaded
+   (let [pdata_ (volatile! nil)
+         stack #js []]
 
-     (defn pdata-local-get [] @pdata_) ; => nnil iff thread-local profiling active
+     (defn pdata-local-get "nnil iff thread-local profiling active" [] @pdata_)
      (defn pdata-local-pop []
        (if-let [stashed (.pop stack)]
          (vreset! pdata_ stashed)
@@ -120,8 +192,8 @@
 (comment
   (pdata-local-push "foo")
   (pdata-local-pop)
-  (enc/qb 1e6 *pdata* (pdata-local-get)) ; [63.7 48.77]
-  (enc/qb 1e6  ; [507.58 74.62]
+  (enc/qb 1e6 *pdata* (pdata-local-get)) ; [22.03 41.5]
+  (enc/qb 1e6  ; [224.31 81.17]
     (binding [*pdata* "foo"])
     (try (pdata-local-push "foo") (finally (pdata-local-pop))))
 
@@ -129,62 +201,15 @@
     (pdata-local-push "pd1")
     (pdata-local-push "pd2")
     [(let [pd (pdata-local-get)] (pdata-local-pop) pd)
-     (let [pd (pdata-local-get)] (pdata-local-pop) pd)]))
+     (let [pd (pdata-local-get)] (pdata-local-pop) pd)])
 
-;;;; TimeSpan utils
+  (enc/qb 1e3 ; 12.71
+    (try
+      (pdata-local-push (new-pdata-local 1e7))
+      (dotimes [_ 1e3] ((pdata-local-get) :foo 1 nil))
+      (finally (pdata-local-pop)))))
 
-(deftype ElapsedTimeAcc [^long tsum ^long max-t1])
-(let [sort-tspans (fn [tspans] (sort-by (fn [^TimeSpan tspan] (.-t0 tspan)) tspans))]
-  (defn- tspans->tsum
-    "Returns `tsum` (elapsed time) given collection of `TimeSpan`s.
-    Based on https://codereview.stackexchange.com/a/126927."
-    ^long [tspans]
-    (if (empty? tspans)
-      0
-      (let [sorted-tspans (sort-tspans tspans)] ; O(n.logn)
-        (.-tsum ^ElapsedTimeAcc
-          (reduce
-            (fn [^ElapsedTimeAcc acc ^TimeSpan tspan]
-              (let [t1     (.-t1     tspan)
-                    max-t1 (.-max-t1 acc)]
-                (if (> t1 max-t1)
-                  (let [t0   (.-t0   tspan)
-                        tsum (.-tsum acc)]
-                    (ElapsedTimeAcc. (+ tsum (- t1 (Math/max t0 max-t1))) t1))
-                  acc)))
-            (ElapsedTimeAcc. 0 0)
-            sorted-tspans))))))
-
-(comment
-  (tspans->tsum nil)
-  (tspans->tsum [])
-  (tspans->tsum [(TimeSpan. 1   3) (TimeSpan. 3 6)])
-  (tspans->tsum [(TimeSpan. 3   6) (TimeSpan. 1 3)])
-  (tspans->tsum [(TimeSpan. 1  10) (TimeSpan. 3 6)])
-  (enc/qb 1e6
-    (tspans->tsum
-      [(TimeSpan. 10 14)
-       (TimeSpan.  4 18)
-       (TimeSpan. 19 20)
-       (TimeSpan. 19 20)
-       (TimeSpan. 13 20)])))
-
-(defn- fast-into [c0 c1] (if (> (count c0) (count c1)) (into c0 c1) (into c1 c0)))
-(comment (fast-into nil nil))
-
-(defn- merge-tspans [^long nmax ^long t1 tspans0 tspans1]
-  (let [tspans2 (fast-into tspans0 tspans1)]
-    (if (> (count tspans2) nmax) ; Compact, may lose some accuracy
-      (let [tsum (tspans->tsum tspans2)]
-        (list (TimeSpan. (- t1 tsum) t1)))
-      tspans2)))
-
-(comment
-  (merge-tspans 2 50
-    (list (TimeSpan. 1 10) (TimeSpan. 5  20))
-    (list (TimeSpan. 1 10) (TimeSpan. 20 50))))
-
-;;;;
+;;;; Compaction, etc.
 
 (defn- times-into-id-times
   "NB treats `from-times` as read-only (may be mutable `acc`)!"
@@ -194,15 +219,14 @@
       (persistent!
         (reduce
           (fn [m ^Time in]
-            (let [t   (.-t             in)
-                  id  (.-id            in)
-                  loc (.-location-info in)
-                  id* [id loc]]
+            (let [rt       (.-runtime  in)
+                  id       (.-id       in)
+                  location (.-location in)
+                  id*      [id location]]
 
-              ;; We'll use [id loc] as a pseudo id from here on in
-              ;; order to track location info. We'll then reverse
-              ;; the wrapping on final `deref-pstats`.
-              (assoc! m id* (conj (get m id*) t))))
+              ;; We'll use [id location] as a pseudo id to track location info.
+              ;; We'll then reverse the wrapping on final `deref-pstats`.
+              (assoc! m id* (conj (get m id*) rt))))
 
           (transient (or to-id-times {}))
           from-times))
@@ -213,37 +237,102 @@
   (times-into-id-times nil nil)
   (times-into-id-times {}  nil)
   (let [mt (mt-acc)]
-    (mt-add mt (Time. :foo 2 nil))
+    (mt-add! mt (Time. :foo 2 nil))
     (times-into-id-times {:foo '(1)} mt)))
 
+(defn- merge-sstats-when-needed [^long nmax sstats]
+  (if (<= (count sstats) nmax)
+    (do                                     sstats)
+    (list (reduce stats/summary-stats-merge sstats))))
+
+(defn- compact-id-state
+  ;; Note that compaction cost doesn't distort p times unless there's
+  ;; p nesting (where outer p time includes inner p's capture time).
+  ^IdState [nmax id-times id-sstats pulled-times]
+  (let [id-times (times-into-id-times id-times pulled-times)]
+    (reduce-kv
+      (fn [^IdState acc id times]
+        (if (<= (count times) ^long nmax)
+          acc
+          (let [id-times     (.-id-times  acc)
+                id-sstats    (.-id-sstats acc)
+                sstats<times (stats/summary-stats times)]
+
+            (IdState.
+              (assoc id-times  id nil)
+              (assoc id-sstats id
+                (merge-sstats-when-needed nmax
+                  (conj (get id-sstats id) sstats<times)))))))
+
+      (IdState. id-times id-sstats)
+      (do       id-times))))
+
+(defn- fast-into [c0 c1] (if (> (count c0) (count c1)) (into c0 c1) (into c1 c0)))
+(comment (fast-into nil nil))
+
+(let [tspans->tacc
+      (fn [tspans]
+        ;; Ref. <https://codereview.stackexchange.com/a/126927>
+        (let [sorted-tspans (sort-by (fn [^TimeSpan tspan] (.-t0 tspan)) tspans)] ; O(n.logn)
+          (reduce ; O(n)
+            (fn [^TimeAcc acc ^TimeSpan tspan]
+              (let [t1   (.-t1   tspan)
+                    tmax (.-tmax acc)]
+                (if (> t1 tmax)
+                  (let [t0   (.-t0   tspan)
+                        tsum (.-tsum acc)]
+                    (TimeAcc. (+ tsum (- t1 (Math/max t0 tmax))) t1))
+                  acc)))
+            (TimeAcc. 0 0)
+            sorted-tspans)))]
+
+  (defn- tspans->tsum
+    "Used for calculating total clock time when merging `PStats`."
+    ^long [tspans]
+    (if (= (count tspans) 1) ; Common case
+      (let [[^TimeSpan tspan1] tspans] (- (.-t1 tspan1) (.-t0 tspan1)))
+      (.-tsum ^TimeAcc (tspans->tacc tspans))))
+
+  (defn- merge-tspans [^long nmax tspans0 tspans1]
+    (let [tspans2 (fast-into tspans0 tspans1)]
+      (if (<= (count tspans2) nmax)
+        tspans2
+        ;; Compact (loses overlap info for future merges!)
+        (let [^TimeAcc tacc (tspans->tacc tspans2)
+              tsum (.-tsum tacc)
+              tmax (.-tmax tacc)]
+          [(TimeSpan. (- tmax tsum) tmax)])))))
+
+(comment
+  ;; [15 20 20]
+  [(tspans->tsum (merge-tspans 1e3 [(TimeSpan. 0 10)] [(TimeSpan. 15 20)]))
+   (tspans->tsum (merge-tspans 1e3 [(TimeSpan. 0 20)] [(TimeSpan. 10 15)]))
+   (tspans->tsum (merge-tspans 1e3 [(TimeSpan. 0 10)] [(TimeSpan.  5 20)]))])
+
+;;;; PStats realization
+
 (defn- deref-pstats
-  "PStats->{:clock _ :stats {<id> <stats/sstats-map>}} (API output)"
-  [^PData pd ^long t1 tspans]
-  (let [t0      (.-t0      pd)
-        pstate_ (.-pstate_ pd)
-        ^PState pstate (enc/force-ref pstate_)
-        id-times  (.-id-times  pstate)
-        id-sstats (.-id-sstats pstate)
-        id-times  (times-into-id-times id-times (.-acc pstate))
-
-        public-stats-output ; {<id*> <stats/sstats-map>}
+  ^RealizedPStats [nmax t0 t1 acc id-times id-sstats tspans]
+  (let [clock-total (tspans->tsum tspans)
+        id-times    (times-into-id-times id-times acc)
+        public-stats-map ; {<id*> <stats/sstats-map>}
         (when id-times
           (let [;;; Disposable internal state
-                id*-sstats_ (volatile! (transient {})) ; {<id*>  <sstats>}
-                id*-loc_    (volatile! (transient {})) ; {<id*> <map-or-set>}
+                id*-sstats_   (volatile! (transient {})) ; {<id*> <sstats>}
+                id*-location_ (volatile! (transient {})) ; {<id*> <map-or-set>}
                 ]
 
             (persistent!
               (reduce-kv
                 (fn [m id times]
-                  (let [[id* loc] id ; Reverse [id loc] wrapping done at `times-into-id-times`
+                  (let [[id* location] id ; Reverse [id location] wrapping done at `times-into-id-times`
 
                         sstats<times  (stats/summary-stats times)
                         sstats-merged (reduce stats/summary-stats-merge sstats<times
                                         (get id-sstats id))
 
-                        ;; Note that a single id* may have >1 locs and so >1
-                        ;; [id loc] entries in id-times. While uncommon, this is
+                        ;; Note that a single id* may have >1 locations and so >1
+                        ;; [id location] entries in id-times. While uncommon, this
                         ;; is sensible and supported.
 
                         ;; Final sstats merged from all locations for given id*
@@ -253,198 +342,351 @@
                           (do                            sstats-merged))
 
                         ;; Location (map or set) for given id*
-                        new-id*-loc
-                        (if-let [old (get @id*-loc_ id*)]
+                        new-id*-location
+                        (if-let [old (get @id*-location_ id*)]
                           (if (set? old)
-                            (conj old loc)
-                            (if (= old loc) old #{old loc}))
-                          loc)
+                            (conj old location)
+                            (if (= old location) old #{old location}))
+                          location)
 
-                        new-id*-entry (assoc @new-id*-sstats :loc new-id*-loc)]
+                        new-id*-entry (assoc @new-id*-sstats :loc new-id*-location)]
 
-                    (vswap! id*-sstats_ assoc!   id* new-id*-sstats)
-                    (vswap! id*-loc_    assoc!   id* new-id*-loc)
-                    (do                (assoc! m id* new-id*-entry))))
+                    (vswap! id*-sstats_   assoc!   id* new-id*-sstats)
+                    (vswap! id*-location_ assoc!   id* new-id*-location)
+                    (do                  (assoc! m id* new-id*-entry))))
 
                 (transient {})
                 id-times))))]
 
-    {:clock {:t0 t0 :t1 t1 :total (tspans->tsum tspans)}
-     :stats public-stats-output}))
+    ;; {:clock _ :stats {<id> <stats/sstats-map>}}
+    (RealizedPStats. t0 t1 clock-total public-stats-map
+      {:t0 t0 :t1 t1 :total clock-total})))
 
-(comment @@(new-pdata-local 10))
+;;;; PStats utils
 
-(defn- merge-sstats-when-needed [^long nmax sstats]
-  (if (<= (count sstats) nmax)
-    (do                                     sstats)
-    (list (reduce stats/summary-stats-merge sstats))))
-
-(defn merge-pstats "Compacting merge"
+(defn ^:public merge-pstats
+  "Merges given pstats, compacting as necessary.
+  Merged statistics are lossless unless data to merge are very large."
+  ([            ] nil)
+  ([     ps0    ] ps0)
   ([     ps0 ps1] (merge-pstats nil ps0 ps1))
   ([nmax ps0 ps1]
    (if ps0
      (if ps1
-       (let [^PStats ps0       ps0
-             ^PStats ps1       ps1
-             ^PData  pd0 (.-pd ps0)
-             ^PData  pd1 (.-pd ps1)
+       (let [^PStats ps0 ps0
+             ^PStats ps1 ps1
 
-             nmax (long (or nmax (.-nmax pd0)))
-             pd0-t0 (.-t0 pd0)
+             nmax   (long (or nmax (.-nmax ps0) (.-nmax ps1)))
+             ps0-t0 (.-t0 ps0)
              ps0-t1 (.-t1 ps0)
-             pd1-t0 (.-t0 pd1)
+             ps1-t0 (.-t0 ps1)
              ps1-t1 (.-t1 ps1)
 
-             pd2-t0  (if (< pd0-t0 pd1-t0) pd0-t0 pd1-t0)
-             ps2-t1  (if (> ps0-t1 ps1-t1) ps0-t1 ps1-t1)
-             tspans2 (merge-tspans nmax ps2-t1 (.-tspans ps0) (.-tspans ps1))
+             ps2-t0  (Math/min ps0-t0 ps1-t0)
+             ps2-t1  (Math/max ps0-t1 ps1-t1)
+             tspans2 (merge-tspans nmax (.-tspans ps0) (.-tspans ps1))
 
-             ^PState pd0-pstate (enc/force-ref (.-pstate_ pd0))
-             ^PState pd1-pstate (enc/force-ref (.-pstate_ pd1))
+             ps0-id-times  (times-into-id-times (.-id-times  ps0) (.-acc ps0))
+             ps1-id-times  (times-into-id-times (.-id-times  ps1) (.-acc ps1))
+             ps0-id-sstats                      (.-id-sstats ps0)
+             ps1-id-sstats                      (.-id-sstats ps1)
 
-             pd0-id-times  (times-into-id-times (.-id-times pd0-pstate) (.-acc pd0-pstate))
-             pd1-id-times  (times-into-id-times (.-id-times pd1-pstate) (.-acc pd1-pstate))
-             pd0-id-sstats (.-id-sstats pd0-pstate)
-             pd1-id-sstats (.-id-sstats pd1-pstate)
+             ;; All ids in ps0 or ps1
+             ps2-ids (keys (conj (or ps0-id-times {}) ps1-id-times))
 
-             ;; All ids in pd0 or pd1
-             pd2-ids (keys (conj (or pd0-id-times {}) pd1-id-times))
-
-             ;; Merge pd1 into pd0 to get pd2
-             [pd2-id-times pd2-id-sstats]
+             ;; ps2 = ps0 <- ps1
+             ^IdState ps2-id-state
              (reduce
-               (fn [[pd2-id-times pd2-id-sstats] id]
-                 (let [pd0-times  (get pd0-id-times  id)
-                       pd0-sstats (get pd0-id-sstats id)
-                       pd1-times  (get pd1-id-times  id)
-                       pd1-sstats (get pd1-id-sstats id)
+               (fn [^IdState acc id]
+                 (let [ps2-id-times  (.-id-times  acc)
+                       ps2-id-sstats (.-id-sstats acc)
+
+                       ps0-times  (get ps0-id-times  id)
+                       ps0-sstats (get ps0-id-sstats id)
+                       ps1-times  (get ps1-id-times  id)
+                       ps1-sstats (get ps1-id-sstats id)
 
-                       pd2-times  (fast-into pd0-times  pd1-times)
-                       pd2-sstats (fast-into pd0-sstats pd1-sstats)]
+                       ps2-times  (fast-into ps0-times  ps1-times)
+                       ps2-sstats (fast-into ps0-sstats ps1-sstats)]
 
-                   (if (<= (count pd2-times) nmax) ; Common case
-                     [(assoc pd2-id-times  id pd2-times)
-                      (assoc pd2-id-sstats id pd2-sstats)]
+                   (if (<= (count ps2-times) nmax) ; Common case
+                     (IdState.
+                       (assoc ps2-id-times  id ps2-times)
+                       (assoc ps2-id-sstats id ps2-sstats))
 
                      ;; Times need compaction
-                     (let [sstats<times (stats/summary-stats pd2-times)]
-                       [(assoc pd2-id-times  id nil)
-                        (assoc pd2-id-sstats id
-                          (merge-sstats-when-needed nmax
-                            (conj pd2-sstats sstats<times)))]))))
+                     (let [sstats<times (stats/summary-stats ps2-times)]
+                       (IdState.
+                         (assoc ps2-id-times  id nil)
+                         (assoc ps2-id-sstats id
+                           (merge-sstats-when-needed nmax
+                             (conj ps2-sstats sstats<times))))))))
 
-               [pd0-id-times pd0-id-sstats]
-               pd2-ids)
+               (IdState. ps0-id-times ps0-id-sstats)
+               ps2-ids)
 
-             pd2 (PData. nmax pd2-t0 (PState. nil pd2-id-times pd2-id-sstats))]
-         (PStats. pd2 ps2-t1 tspans2 (delay (deref-pstats pd2 ps2-t1 tspans2))))
+             ps2-id-times  (.-id-times  ps2-id-state)
+             ps2-id-sstats (.-id-sstats ps2-id-state)]
 
+         (PStats.               nmax ps2-t0 ps2-t1 nil ps2-id-times ps2-id-sstats tspans2
+           (delay (deref-pstats nmax ps2-t0 ps2-t1 nil ps2-id-times ps2-id-sstats tspans2))))
        ps0)
      ps1)))
 
-;;;; Time capture
-
-#?(:clj
-   (defmacro ^:private atom? [x]
-     `(enc/if-cljs
-        (instance?    cljs.core.Atom ~x)
-        (instance? clojure.lang.Atom ~x))))
-
-(declare ^:private compact-pstate)
-(defn capture-time! [^PData pd id ns-elapsed location-info]
-  (let [nmax    (.-nmax    pd)
-        pstate_ (.-pstate_ pd)
-        ^PState pstate @pstate_
-        acc (.-acc pstate)]
-
-    (if (atom? acc)
-
-      ;; Dynamic profiling
-      (let [new-time (Time. id ns-elapsed location-info)
-            ?pulled-times
-            (loop []
-              (let [old-times @acc
-                    new-times (conj old-times new-time)]
-                (if (<= (count new-times) nmax)
-                  (if (compare-and-set! acc old-times new-times) nil (recur))
-                  (if (compare-and-set! acc old-times nil) new-times (recur)))))]
-
-        (when-let [times ?pulled-times] ; Do compaction, rare
-          (let [t0 (enc/now-nano*)]
-            ;; Contention against `pstate_` unlikely since we just drained `acc`
-            (swap! pstate_ (fn [pstate] (compact-pstate pstate times nmax true)))
-            (recur pd :tufte/compaction (- (enc/now-nano*) t0) nil))))
-
-      (do ; Common case: thread-local profiling
-        (mt-add acc (Time. id ns-elapsed location-info))
-
-        (when (> (mt-count acc) nmax) ; Do compaction, rare
-          (let [t0 (enc/now-nano*)]
-            (vreset! pstate_ (compact-pstate pstate acc nmax false))
-            (recur pd :tufte/compaction (- (enc/now-nano*) t0) nil)))))))
-
-(defn- compact-pstate [^PState pstate pulled-times ^long nmax dynamic?]
-  ;; Note that compaction expense doesn't distort p times unless there's
-  ;; p nesting (where outer p time includes inner p's capture time).
-  (let [id-times  (.-id-times  pstate)
-        id-sstats (.-id-sstats pstate)
-        id-times  (times-into-id-times id-times pulled-times)
-
-        [id-times id-sstats]
-        (reduce-kv
-          (fn [acc id times]
-            (if (<= (count times) nmax)
-              acc
-              (let [[id-times id-sstats] acc
-                    sstats<times (stats/summary-stats times)]
-                [(assoc id-times  id nil)
-                 (assoc id-sstats id
-                   (merge-sstats-when-needed nmax
-                     (conj (get id-sstats id) sstats<times)))])))
-
-          [id-times id-sstats]
-          id-times)
-
-        new-acc (if dynamic? (.-acc pstate) (mt-acc))]
-
-    (PState. new-acc id-times id-sstats)))
+;;;; Formatting
+
+(def     all-format-columns [:n :min   :p25 :p50   :p75 :p90 :p95 :p99 :max :mean :mad :clock :sum])
+(def default-format-columns [:n :min #_:p25 :p50 #_:p75 :p90 :p95 :p99 :max :mean :mad :clock :sum])
+
+(let [migrate        {:n-calls :n, :total :sum} ; For back-compatibility
+      format-column? (set all-format-columns)
+      format-column  (fn [column] (enc/have format-column? (get migrate column column)))]
+
+  (defn- format-columns [columns]
+    (enc/cond
+      (identical? columns default-format-columns) default-format-columns
+      (identical? columns     all-format-columns)     all-format-columns
+      :else (mapv format-column columns))))
+
+(comment (enc/qb 1e6 (format-columns [:min :n-calls :total]))) ; 152.9
+
+;; id-sstats* => {<id> <sstats>} or {<id> <sstats-map>}
+(defn- get-max-id-width
+  [id-sstats*
+   {:keys [format-id-fn]
+    :or   {format-id-fn (fn [id] (str id))}}]
+
+  (when id-sstats*
+    (reduce-kv
+      (fn [^long acc id _sstats*]
+        (let [c (count (format-id-fn id))]
+          (if (> c acc) c acc)))
+      9 ; (count "Accounted")
+      id-sstats*)))
+
+(def ^:private format-n (enc/format-num-fn 0 0))
+
+(defn format-pstats*
+  "Given {<id> <sstats>} or {<id> <sstats-map>} pstats, returns a formatted
+  table string. Assumes nanosecond clock, and stats based on profiling id'd
+  nanosecond times."
+  [clock-total id-sstats*
+   {:keys [columns sort-fn format-id-fn max-id-width] :as opts
+    :or
+    {columns      default-format-columns
+     sort-fn      (fn [ss] (get (enc/force-ref ss) :sum))
+     format-id-fn (fn [id] (str id))}}]
+
+  (when id-sstats*
+    (let [columns (format-columns columns)
+          clock-total (long clock-total)
+          ^long accounted-total
+          (reduce-kv
+            (fn [^long acc _id ss]
+              (+ acc (long (get (enc/force-ref ss) :sum))))
+            0 id-sstats*)
+
+          sorted-ids
+          (sort-by
+            (fn [id] (sort-fn (get id-sstats* id)))
+            enc/rcompare
+            (keys id-sstats*))
+
+          ^long max-id-width
+          (or
+            max-id-width
+            (get-max-id-width id-sstats* opts))
+
+          column->pattern
+          {:id      {:heading "pId" :min-width max-id-width :align :left}
+           :n       {:heading "nCalls"}
+           :min     {:heading "Min"}
+           :p25     {:heading "25% ≤"}
+           :p50     {:heading "50% ≤"}
+           :p75     {:heading "75% ≤"}
+           :p90     {:heading "90% ≤"}
+           :p95     {:heading "95% ≤"}
+           :p99     {:heading "99% ≤"}
+           :max     {:heading "Max"}
+           :mean    {:heading "Mean"}
+           :mad     {:heading "MAD"   :min-width 5}
+           :sum     {:heading "Total" :min-width 6}
+           :clock   {:heading "Clock"}}
+
+          sb (enc/str-builder "")
+
+          append-col
+          (fn [column s]
+            (let [{:keys [min-width align]
+                   :or   {min-width 10 align :right}}
+                  (get column->pattern column)]
+
+              (enc/sb-append sb
+                (enc/format
+                  (str "%" (case align :left "-" :right "") min-width "s")
+                  s))))]
+
+      ; Write header rows
+      (doseq [column (into [:id] columns)]
+        (when-not (= :id column)
+          (enc/sb-append sb " "))
+        (append-col column (get-in column->pattern [column :heading])))
+
+      (enc/sb-append sb enc/newlines)
+
+      ; Write id rows
+      (doseq [id sorted-ids]
+        (let [ssm (enc/force-ref (get id-sstats* id))
+              {:keys [n sum mean mad]} ssm]
+
+          (append-col :id (format-id-fn id))
+          (doseq [column columns]
+            (enc/sb-append sb " ")
+            (case column
+              :n     (append-col column (format-n n))
+              :mean  (append-col column (enc/format-nsecs mean))
+              :mad   (append-col column (str "±" (enc/perc mad mean)        "%"))
+              :sum   (append-col column (str     (enc/perc sum clock-total) "%"))
+              :clock (append-col column (enc/format-nsecs sum))
+              (do    (append-col column (enc/format-nsecs (get ssm column))))))
+
+          (enc/sb-append sb enc/newline)))
+
+      ; Write accounted row
+      (enc/sb-append sb enc/newline)
+      (append-col :id "Accounted")
+      (doseq [column columns]
+        (enc/sb-append sb " ")
+        (case column
+          :sum   (append-col column    (str (enc/perc accounted-total clock-total) "%"))
+          :clock (append-col column (enc/format-nsecs accounted-total))
+          (do    (append-col column ""))))
+
+      ; Write clock row
+      (enc/sb-append sb enc/newline)
+      (append-col :id "Clock")
+      (doseq [column columns]
+        (enc/sb-append sb " ")
+        (case column
+          :sum   (append-col column "100%")
+          :clock (append-col column (enc/format-nsecs clock-total))
+          (do    (append-col column ""))))
+
+      ;; (enc/sb-append sb enc/newline)
+      (str sb))))
 
 (comment
-  (try
-    (pdata-local-push (new-pdata-local 1e7))
-    (enc/qb 1e6 (capture-time! (pdata-local-get) :foo 1 nil))
-    (finally (pdata-local-pop)))) ; 98.35
-
-;;;; Output handlers
+  (defn rand-vs [n & [max]]
+    (take n (repeatedly (partial rand-int (or max Integer/MAX_VALUE)))))
+
+  (println
+    (format-pstats (* 1e6 30)
+      {:foo (stats/summary-stats (rand-vs 1e4 20))
+       :bar (stats/summary-stats (rand-vs 1e2 50))
+       :baz (stats/summary-stats (rand-vs 1e5 30))}
+      {}) "\n"))
+
+(defn ^:public format-pstats
+  "Formats given pstats to a string table.
+    Accounted < Clock => Some work was done that wasn't tracked by any p forms.
+    Accounted > Clock => Nested p forms, and/or parallel threads."
+  ([ps     ] (format-pstats ps nil))
+  ([ps opts]
+   (when ps
+     (let [{:keys [clock stats]} (enc/force-ref ps)]
+       (format-pstats* (get clock :total) stats opts)))))
+
+(defn ^:public format-grouped-pstats
+  "Alpha, subject to change.
+  Takes a map of {<profile-id> <pstats>} and formats a combined
+  output string using `format-pstats`.
+
+  See also example Clj project."
+  ([m] (format-grouped-pstats m nil))
+  ([m {:keys [group-sort-fn format-pstats-opts]
+       :or   {group-sort-fn (fn [m] (get-in m [:clock :total] 0))}}]
+
+   (when m
+     (let [m ; {<profile-id> <realised-pstats>}
+           (persistent!
+             (reduce-kv
+               (fn [m k v] (assoc! m k (enc/force-ref v)))
+               (transient m)
+               m))
+
+           sorted-profile-ids
+           (sort-by (fn [id] (group-sort-fn (get m id)))
+             enc/rcompare (keys m))
+
+           ^long max-id-width
+           (reduce-kv
+             (fn [^long acc _ {:keys [clock stats]}]
+               (if-let [c (get-max-id-width stats format-pstats-opts)]
+                 (if (> (long c) acc) c acc)
+                 acc))
+             0 m)
+
+           sep (str "," enc/newline)
+           format-pstats-opts
+           (assoc format-pstats-opts
+             :max-id-width max-id-width)]
+
+       (enc/str-join enc/newlines
+         (map (fn [id] (str id sep (format-pstats (get m id) format-pstats-opts))))
+         sorted-profile-ids)))))
+
+;;;; Signals
+;; - Filtering relevant for `profiled`, `profile`
+;; - Handling  relevant for `profiled` only
+
+(enc/defonce ^:dynamic *sig-handlers* "?[<wrapped-handler-fn>]" nil)
+
+(defrecord ProfilingSignal
+  ;; Fields based on `taoensso.telemere.impl/Signal`
+  [schema inst location, id level sample-rate ctx data, body-result pstats format-pstats-fn]
+  Object (toString [psig] (str "taoensso.tufte.ProfilingSignal" (into {} psig))))
+
+(defrecord WrappedProfilingSignal [ns id level psig_]
+  sigs/IFilterableSignal
+  (allow-signal? [_ sig-filter] (sig-filter ns id level))
+  (signal-value  [_ handler-sample-rate]
+    (sigs/signal-with-combined-sample-rate handler-sample-rate
+      (force psig_))))
+
+;; NB intentionally verbose constructors for readability, to support extra keys
+(do     (enc/def-print-impl [x ProfilingSignal] (str "#taoensso.tufte.ProfilingSignal"      (pr-str (into {} x)))))
+#?(:clj (enc/def-print-dup  [x ProfilingSignal] (str "#taoensso.tufte.impl.ProfilingSignal" (pr-str (into {} x)))))
 
-(enc/defonce handlers_ "{<hid> <handler-fn>}" (atom nil))
-
-#?(:clj
-   (enc/defonce ^:private ^ArrayBlockingQueue handler-queue
-     "While user handlers should ideally be non-blocking, we'll use a queue
-     here to be safe + make sure we never tie up the execution thread."
-     (ArrayBlockingQueue. 1024)))
-
-(defn- handle-blocking! [m]
-  (enc/run-kv!
-    (fn [id f]
-      (enc/catching (f m) e
-        (enc/catching ; Esp. nb for Cljs
-          (println (str "WARNING: Uncaught Tufte `" id "` handler error\n" e)))))
-    @handlers_))
-
-#?(:clj  (declare ^:private handler-thread_))
-#?(:cljs (defn handle! [m] (handle-blocking! m) nil))
-#?(:clj  (defn handle! [m] (.offer handler-queue m) @handler-thread_ nil))
 #?(:clj
-   (defonce ^:private handler-thread_
-     (delay
-       (let [f (fn []
-                 (loop []
-                   (let [m (.take handler-queue)]
-                     ;; Note: just drop if no registered handlers
-                     (handle-blocking! m)
-                     (recur))))]
-         (doto (Thread. f)
-           (.setDaemon true)
-           (.start))))))
+   (let [base      (enc/get-env {:as :edn} [:taoensso.tufte/ct-filters<.platform><.edn>])
+         ns-filter (enc/get-env {:as :edn} [:taoensso.tufte/ct-ns-filter<.platform><.edn> :taoensso.tufte/ns-pattern])
+         id-filter (enc/get-env {:as :edn} [:taoensso.tufte/ct-id-filter<.platform><.edn>])
+         min-level (enc/get-env {:as :edn} [:taoensso.tufte/ct-min-level<.platform><.edn> :taoensso.tufte/min-level])]
+
+     (enc/defonce ct-sig-filter
+       "`SigFilter` used for compile-time elision, or nil."
+       (sigs/sig-filter
+         {:ns-filter (or ns-filter (get base :ns-filter))
+          :id-filter (or id-filter (get base :id-filter))
+          :min-level (or min-level (get base :min-level))}))))
+
+(let [base      (enc/get-env {:as :edn} [:taoensso.tufte/rt-filters<.platform><.edn>])
+      ns-filter (enc/get-env {:as :edn} [:taoensso.tufte/rt-ns-filter<.platform><.edn>])
+      id-filter (enc/get-env {:as :edn} [:taoensso.tufte/rt-id-filter<.platform><.edn>])
+      min-level (enc/get-env {:as :edn} [:taoensso.tufte/rt-min-level<.platform><.edn>])]
+
+  (enc/defonce ^:dynamic *rt-sig-filter*
+    "`SigFilter` used for runtime filtering, or nil."
+    (sigs/sig-filter
+      {:ns-filter (or ns-filter (get base :ns-filter))
+       :id-filter (or id-filter (get base :id-filter))
+       :min-level (or min-level (get base :min-level))})))
+
+(comment (enc/get-env {:as :edn, :return :explain} :taoensso.tufte/rt-filters<.platform><.edn>))
+
+(defn psig-level-fn [level-or-fn]
+  (if-let [x level-or-fn]
+    (if (fn? x) x (fn [psig-level] x))
+    (do           (fn [psig-level] psig-level))))
+
+(comment ((psig-level-fn :info) :debug))
diff --git a/src/taoensso/tufte/stats.cljc b/src/taoensso/tufte/stats.cljc
deleted file mode 100644
index 4bbb22f..0000000
--- a/src/taoensso/tufte/stats.cljc
+++ /dev/null
@@ -1,774 +0,0 @@
-(ns ^:no-doc taoensso.tufte.stats
-  "Stats stuff.
-  Private ns, implementation detail."
-  (:require
-   [clojure.string  :as str]
-   [taoensso.encore :as enc  :refer [have have? have!]]
-   #?(:cljs [goog.array]))
-
-  #?(:clj (:import [java.util LinkedList])))
-
-(comment
-  (remove-ns 'taoensso.tufte.stats)
-  (:public (enc/interns-overview)))
-
-;;;; TODO
-;; - Add SummaryStatsRolling (rolling by max len and/or date)?
-
-;;;;
-
-#?(:clj (let [c (Class/forName "[J")] (defn longs?   "Returns true iff given long array"   [x] (instance? c x))))
-#?(:clj (let [c (Class/forName "[D")] (defn doubles? "Returns true iff given double array" [x] (instance? c x))))
-
-;;;; Sorted nums
-
-(deftype SortedLongs [^longs a]
-  #?@(:clj
-      [Object               (toString [_] (str "SortedLongs[len=" (alength a) "]"))
-       clojure.lang.Counted (count    [_]                         (alength a))
-       clojure.lang.Indexed
-       (nth [_ idx] (aget a idx))
-       (nth [_ idx not-found]
-         (let [max-idx (dec (alength a))]
-           (enc/cond
-             (> idx max-idx) not-found
-             (< idx max-idx) not-found
-             :else (aget a idx))))
-
-       clojure.lang.IReduceInit
-       (reduce [_ f init]
-         #_(areduce a i acc init (f acc (aget a i)))
-         (reduce (fn [acc idx]   (f acc (aget a idx)))
-           init (range (alength a))))]
-
-      :cljs
-      [Object   (toString [_] (str "SortedLongs[len=" (alength a) "]"))
-       ICounted (-count   [_]                         (alength a))
-       IIndexed
-       (-nth [_ idx] (aget a idx))
-       (-nth [_ idx not-found]
-         (let [max-idx (dec (alength a))]
-           (enc/cond
-             (> idx max-idx) not-found
-             (< idx max-idx) not-found
-             :else (aget a idx))))
-
-       IReduce
-       (-reduce [_ f init]
-         #_(areduce a i acc init (f acc (aget a i)))
-         (reduce (fn [acc i]     (f acc (aget a i)))
-           init (range (alength a))))]))
-
-(deftype SortedDoubles [^doubles a]
-  #?@(:clj
-      [Object               (toString [_] (str "SortedDoubles[len=" (alength a) "]"))
-       clojure.lang.Counted (count    [_]                           (alength a))
-       clojure.lang.Indexed
-       (nth [_ idx] (aget a idx))
-       (nth [_ idx not-found]
-         (let [max-idx (dec (alength a))]
-           (enc/cond
-             (> idx max-idx) not-found
-             (< idx max-idx) not-found
-             :else (aget a idx))))
-
-       clojure.lang.IReduceInit
-       (reduce [_ f init]
-         #_(areduce a i acc init (f acc (aget a i)))
-         (reduce (fn [acc idx]   (f acc (aget a idx)))
-           init (range (alength a))))]
-
-      :cljs
-      [Object   (toString [_] (str "SortedDoubles[len=" (alength a) "]"))
-       ICounted (-count   [_]                           (alength a))
-       IIndexed
-       (-nth [_ idx] (aget a idx))
-       (-nth [_ idx not-found]
-         (let [max-idx (dec (alength a))]
-           (enc/cond
-             (> idx max-idx) not-found
-             (< idx max-idx) not-found
-             :else (aget a idx))))
-
-       IReduce
-       (-reduce [_ f init]
-         #_(areduce a i acc init (f acc (aget a i)))
-         (reduce (fn [acc i]     (f acc (aget a i)))
-           init (range (alength a))))]))
-
-(defn sorted-longs?   [x] (instance? SortedLongs   x))
-(defn sorted-doubles? [x] (instance? SortedDoubles x))
-(defn sorted-nums?    [x] (or (sorted-longs? x) (sorted-doubles? x)))
-
-(defn sorted-longs
-  "Returns `SortedLongs` given `SortedLongs`, `SortedDoubles`, or num seq."
-  (^SortedLongs [                nums] (sorted-longs false nums))
-  (^SortedLongs [allow-mutation? nums]
-   (enc/cond
-     (sorted-longs?   nums)                                               nums
-     (sorted-doubles? nums) (SortedLongs. (long-array (.-a ^SortedDoubles nums)))
-     :else
-     #?(:clj
-        (let [^longs a (if (longs? nums) (if allow-mutation? nums (aclone ^longs nums)) (long-array nums))]
-          (java.util.Arrays/sort a) ; O(n.log(n)) on JDK 7+
-          (SortedLongs.          a))
-
-        :cljs
-        (let [a (if (array? nums) (if allow-mutation? nums (aclone nums)) (to-array nums))]
-          (goog.array/sort a)
-          (SortedLongs.    a))))))
-
-(defn sorted-doubles
-  "Returns `SortedDoubles` given `SortedDoubles`, `SortedLongs`, or num seq."
-  (^SortedDoubles [                nums] (sorted-doubles false nums))
-  (^SortedDoubles [allow-mutation? nums]
-   (enc/cond
-     (sorted-doubles? nums)                                                 nums
-     (sorted-longs?   nums) (SortedDoubles. (double-array (.-a ^SortedLongs nums)))
-     :else
-     #?(:clj
-        (let [^doubles a (if (doubles? nums) (if allow-mutation? nums (aclone ^doubles nums)) (double-array nums))]
-          (java.util.Arrays/sort a) ; O(n.log_n) on JDK 7+
-          (SortedDoubles.        a))
-
-        :cljs
-        (let [a (if (array? nums) (if allow-mutation? nums (aclone nums)) (to-array nums))]
-          (goog.array/sort a)
-          (SortedDoubles.  a))))))
-
-(comment (into [] (sorted-doubles (sorted-longs [3 1 2]))))
-
-(defn- fast-first [x]
-  #?(:cljs (nth x 0 nil)
-     :clj
-     (if (instance? LinkedList x)
-       (.peekFirst ^LinkedList x)
-       (nth x 0 nil))))
-
-(defn- float-num? [x]
-  #?(:clj  (float? x)
-     :cljs (and (number? x) (not (== (js/parseFloat x) (js/parseInt x 10))))))
-
-(defn sorted-nums
-  "Returns `SortedLongs` or `SortedDoubles`,
-    given `SortedLongs`, `SortedDoubles`, or num seq."
-  ([                nums] (sorted-nums false nums))
-  ([allow-mutation? nums]
-   [nums]
-   (enc/cond
-     (sorted-longs?   nums) nums
-     (sorted-doubles? nums) nums
-     (when-let [n1 (fast-first nums)] (float-num? n1)) (sorted-doubles allow-mutation? nums)
-     :else                                             (sorted-longs   allow-mutation? nums))))
-
-(comment (sorted-nums [1.0 2]))
-
-;;;; Percentiles
-
-(defn- weighted-nth
-  "Returns interpolated nth numerical value."
-  [idx nums]
-  (let [idx       (double     idx)
-        idx-floor (Math/floor idx)
-        idx-ceil  (Math/ceil  idx)]
-
-    (if (== idx-ceil idx-floor)
-      (nth nums (int idx))
-
-      ;; Generalization of (floor+ceil)/2
-      (let [weight-floor (- idx-ceil idx)
-            weight-ceil  (- 1 weight-floor)]
-        (+
-          (* weight-floor (double (nth nums (int idx-floor))))
-          (* weight-ceil  (double (nth nums (int idx-ceil)))))))))
-
-(comment (weighted-nth 0.5 [1 5]))
-
-(defn percentile
-  "Returns ?element."
-  [pnum nums]
-  (let [snums   (sorted-nums nums)
-        max-idx (dec (count snums))]
-    (when (>= max-idx 0)
-      (nth snums (Math/round (* max-idx (enc/as-pnum! pnum)))))))
-
-(comment (percentile 0.8 (range 101)))
-
-(defn percentiles
-  "Returns ?[min p25 p50 p75 p90 p95 p99 max] elements in:
-    - O(1) for Sorted types (SortedLongs, SortedDoubles),
-    - O(n.log_n) otherwise."
-  [nums]
-  (let [snums   (sorted-nums nums)
-        max-idx (dec (count snums))]
-    (when (>= max-idx 0)
-      [(nth snums 0)
-       (nth snums (Math/round (* max-idx 0.25)))
-       (nth snums (Math/round (* max-idx 0.50)))
-       (nth snums (Math/round (* max-idx 0.75)))
-       (nth snums (Math/round (* max-idx 0.90)))
-       (nth snums (Math/round (* max-idx 0.95)))
-       (nth snums (Math/round (* max-idx 0.99)))
-       (nth snums                max-idx)])))
-
-(comment
-  (percentiles (range 101))
-  (percentiles [1 2 3]))
-
-;;;;
-
-(defn bessel-correction ^double [n ^double add] (+ (double n) add))
-
-(defn rf-sum          ^double [^double acc ^double in] (+ acc in))
-(defn rf-sum-variance ^double [^double xbar ^double acc x]
-  (+ acc (Math/pow (- (double x) xbar) 2.0)))
-
-(defn rf-sum-abs-deviation ^double [^double central-point ^double acc x]
-  (+ acc (Math/abs (- (double x) central-point))))
-
-;;;; SummaryStats
-
-(declare ^:private deref-sstats)
-(deftype SummaryStats
-    ;; - Field names chosen to avoid shadowing.
-    ;; - Includes -sum data to support merging.
-    ;; - Doubles used as general type to avoid boxing.
-    [^boolean xfloats?
-     ^long    nx
-     ^double  xsum
-     ^double  xmin
-     ^double  xmax
-     ^double  xlast
-     ^double  p25
-     ^double  p50
-     ^double  p75
-     ^double  p90
-     ^double  p95
-     ^double  p99
-     ;;       xmean
-     ;;       xvar
-     ;;       xmad
-     ^double  xvar-sum
-     ^double  xmad-sum]
-
-  Object (toString [_] (str "SummaryStats[n=" nx "]"))
-  #?@(:clj  [clojure.lang.IDeref ( deref [this] (deref-sstats this))]
-      :cljs [             IDeref (-deref [this] (deref-sstats this))]))
-
-(defn- deref-sstats [^SummaryStats ss]
-  (let [fin (if (.-xfloats? ss) double #(Math/round (double %)))
-        nx  (.-nx ss)]
-    (assert (pos? nx))
-    (with-meta
-      {:n           nx
-       :sum     (fin (.-xsum  ss))
-       :min     (fin (.-xmin  ss))
-       :max     (fin (.-xmax  ss))
-       :last    (fin (.-xlast ss))
-       :p25     (fin (.-p25   ss))
-       :p50     (fin (.-p50   ss))
-       :p75     (fin (.-p75   ss))
-       :p90     (fin (.-p90   ss))
-       :p95     (fin (.-p95   ss))
-       :p99     (fin (.-p99   ss))
-
-       :mean    (/ (.-xsum     ss) nx)
-       :var     (/ (.-xvar-sum ss) nx) ; Currently w/o bessel-correction
-       :mad     (/ (.-xmad-sum ss) nx)
-
-       :var-sum (.-xvar-sum ss)
-       :mad-sum (.-xmad-sum ss)}
-
-      {:floats? (.-xfloats? ss)})))
-
-(defn ^:public summary-stats?
-  "Returns true iff given a SummaryStats argument."
-  [x] (instance? SummaryStats x))
-
-(defn ^:public summary-stats
-  "Given a coll of numbers or previously dereffed SummaryStats map,
-  returns a new mergeable ?SummaryStats with:
-    (deref ss) => {:keys [n sum min max p25 ... p99 mean var mad]}
-
-  See also `summary-stats-merge`."
-  {:arglists '([nums-or-ss-map])}
-  ([     x] (summary-stats nil x))
-  ([opts x]
-   (when x
-     (enc/cond
-       (summary-stats? x) x
-       (map?           x)
-       (let [{:keys [n sum min max last p25 p50 p75 p90 p95 p99
-                     #_mean #_var #_mad var-sum mad-sum]} x
-
-             floats?
-             (enc/cond
-               :if-let [e (find opts     :floats?)] (val e)
-               :if-let [e (find (meta x) :floats?)] (val e)
-               :else (float-num? sum))]
-
-         (SummaryStats. floats?
-           n sum min max last p25 p50 p75 p90 p95 p99 var-sum mad-sum))
-
-       :else
-       (let [snums
-             (if-let [e (find opts :floats?)]
-               (if (val e)
-                 (sorted-doubles true x)
-                 (sorted-longs   true x))
-               (sorted-nums      true x))
-
-             nx (count snums)]
-
-         (when (pos? nx)
-           (let [[xmin p25 p50 p75 p90 p95 p99 xmax] (percentiles snums)
-                 xsum  (double (reduce rf-sum 0.0 snums))
-                 xbar  (/ xsum nx)
-                 xlast (nth snums (dec nx))
-                 [^double xvar-sum ^double xmad-sum]
-                 (enc/reduce-multi
-                   (partial rf-sum-variance      xbar) 0.0
-                   (partial rf-sum-abs-deviation xbar) 0.0
-                   snums)]
-
-             (SummaryStats. (sorted-doubles? snums)
-               nx xsum xmin xmax xlast p25 p50 p75 p90 p95 p99
-               xvar-sum xmad-sum))))))))
-
-(comment @(summary-stats [1 2 3]))
-
-(defn ^:public summary-stats-merge
-  "Given one or more SummaryStats, returns a new ?SummaryStats with:
-    (summary-stats-merge
-       (summary-stats nums1)
-       (summary-stats nums2))
-
-    an approximatation of (summary-stats (merge nums1 nums2))
-
-  Useful when you want summary stats for a large coll of numbers for which
-  it would be infeasible/expensive to keep all numbers for accurate merging."
-  ([ss1    ] ss1)
-  ([ss1 ss2]
-   (if ss1
-     (if ss2
-       (let [^SummaryStats ss1 ss1
-             ^SummaryStats ss2 ss2
-
-             nx1 (.-nx ss1)
-             nx2 (.-nx ss2)
-
-             _ (assert (pos? nx1))
-             _ (assert (pos? nx2))
-
-             xfloats1? (.-xfloats? ss1)
-             xsum1     (.-xsum     ss1)
-             xmin1     (.-xmin     ss1)
-             xmax1     (.-xmax     ss1)
-             p25-1     (.-p25      ss1)
-             p50-1     (.-p50      ss1)
-             p75-1     (.-p75      ss1)
-             p90-1     (.-p90      ss1)
-             p95-1     (.-p95      ss1)
-             p99-1     (.-p99      ss1)
-             xvar-sum1 (.-xvar-sum ss1)
-             xmad-sum1 (.-xmad-sum ss1)
-
-             xfloats2? (.-xfloats? ss2)
-             xsum2     (.-xsum     ss2)
-             xmin2     (.-xmin     ss2)
-             xmax2     (.-xmax     ss2)
-             xlast2    (.-xlast    ss2)
-             p25-2     (.-p25      ss2)
-             p50-2     (.-p50      ss2)
-             p75-2     (.-p75      ss2)
-             p90-2     (.-p90      ss2)
-             p95-2     (.-p95      ss2)
-             p99-2     (.-p99      ss2)
-             xvar-sum2 (.-xvar-sum ss2)
-             xmad-sum2 (.-xmad-sum ss2)
-
-             xfloats3? (or xfloats1? xfloats2?)
-             nx3       (+ nx1 nx2)
-             nx1-ratio (/ (double nx1) (double nx3))
-             nx2-ratio (/ (double nx2) (double nx3))
-
-             xsum3 (+ xsum1 xsum2)
-             xmin3 (if (< xmin1 xmin2) xmin1 xmin2)
-             xmax3 (if (> xmax1 xmax2) xmax1 xmax2)
-             ;; xbar3 (/ xsum3 nx3)
-
-             ;; Batched "online" calculation here is better= the standard
-             ;; Knuth/Welford method, Ref. http://goo.gl/QLSfOc,
-             ;;                            http://goo.gl/mx5eSK.
-             ;; No apparent advantage in using `xbar3` asap.
-             xvar-sum3 (+ xvar-sum1 xvar-sum2)
-             xmad-sum3 (+ xmad-sum1 xmad-sum2)
-
-             ;; These are pretty rough approximations. More sophisticated
-             ;; approaches not worth the extra cost/effort in our case.
-             p25-3 (+ (* nx1-ratio p25-1) (* nx2-ratio p25-2))
-             p50-3 (+ (* nx1-ratio p50-1) (* nx2-ratio p50-2))
-             p75-3 (+ (* nx1-ratio p75-1) (* nx2-ratio p75-2))
-             p90-3 (+ (* nx1-ratio p90-1) (* nx2-ratio p90-2))
-             p95-3 (+ (* nx1-ratio p95-1) (* nx2-ratio p95-2))
-             p99-3 (+ (* nx1-ratio p99-1) (* nx2-ratio p99-2))]
-
-         (SummaryStats. xfloats3?
-           nx3 xsum3 xmin3 xmax3 xlast2 p25-3 p50-3 p75-3 p90-3 p95-3 p99-3
-           xvar-sum3 xmad-sum3))
-       ss1)
-     ss2)))
-
-;;;; Stateful SummaryStats
-
-(defn- buf-new
-  ([    ] #?(:clj (LinkedList.) :cljs (array)))
-  ([init]
-   #?(:clj  (if init (LinkedList. init) (LinkedList.))
-      :cljs (if init (array       init) (array)))))
-
-(defn- buf-add [buf x]
-  #?(:clj  (.add ^LinkedList buf x)
-     :cljs (.push            buf x)))
-
-(defn- buf-len ^long [buf]
-  #?(:clj  (.size ^LinkedList buf)
-     :cljs (alength           buf)))
-
-(defprotocol ISummaryStatsBuffered
-  ;; TODO Later generalize protocol for other stateful SummaryStats types?
-  (ssb-deref [_] [_ flush-buffer?] "Returns current ?sstats.")
-  (ssb-clear [_]   "Clears all internal state and returns nil.")
-  (ssb-flush [_]   "Flushes internal buffer and returns newly merged sstats or nil.")
-  (ssb-push  [_ n] "Adds given num to internal buffer."))
-
-(defn ^:public summary-stats-clear!
-  "Clears internal state (incl. stats and buffers, etc.) for given
-  stateful SummaryStats instance and returns nil."
-  [stateful-summary-stats]
-  (ssb-clear stateful-summary-stats))
-
-(deftype SummaryStatsBuffered [sstats_ buf_ buf-size merge-counter merge-cb]
-  Object
-  (toString [_] ; "SummaryStatsBuffered[n=1, pending=8, merged=0]"
-    (str
-      "SummaryStatsBuffered[n=" (get @sstats_ :n 0)
-      ", pending=" (buf-len @buf_)
-      (when-let [mc merge-counter] (str ", merged=" @mc))
-      "]"))
-
-  #?@(:clj  [clojure.lang.IDeref ( deref [this] (ssb-deref this))]
-      :cljs [             IDeref (-deref [this] (ssb-deref this))])
-
-  #?@(:clj  [clojure.lang.IFn ( invoke [this n] (ssb-push this n))]
-      :cljs [             IFn (-invoke [this n] (ssb-push this n))])
-
-  ISummaryStatsBuffered
-  (ssb-deref [this              ] (ssb-deref this true))
-  (ssb-deref [this flush-buffer?] (or (and flush-buffer? (ssb-flush this)) @sstats_))
-  (ssb-clear [_]
-    #?(:clj (locking buf_ (reset! buf_ (buf-new)))
-       :cljs              (reset! buf_ (buf-new)))
-
-    (reset! sstats_ nil)
-    (when-let [mc merge-counter] (mc :set 0))
-    nil)
-
-  (ssb-flush [this]
-    (let [[drained]
-          #?(:clj (locking buf_ (reset-vals! buf_ (buf-new nil)))
-             :cljs              (reset-vals! buf_ (buf-new nil)))]
-
-      (if (== (buf-len drained) 0)
-        nil
-        (let [t0             (when merge-cb (enc/now-nano*))
-              _              (when-let [mc merge-counter] (mc))
-              sstats-drained (summary-stats drained)
-
-              sstats-merged ; Only drainer will update, so should be no contention
-              (swap! sstats_ summary-stats-merge sstats-drained)]
-
-          (when merge-cb ; Handy for profilers, etc.
-            (merge-cb this (- (enc/now-nano*) ^long t0)))
-
-          sstats-merged))))
-
-  (ssb-push [this n]
-    #?(:clj (locking buf_ (buf-add @buf_ n))
-       :cljs              (buf-add @buf_ n))
-
-    (when-let [^long nmax buf-size]
-      (when (> (buf-len @buf_) nmax)
-        (ssb-flush this)))
-
-    nil))
-
-(defn ^:public summary-stats-buffered
-  "Returns a new stateful SummaryStatsBuffered with:
-    (ssb <num>) => Adds given number to internal buffer.
-    (deref ssb) => Flushes buffer if necessary, and returns a mergeable
-                   ?SummaryStats. Deref again to get a map of summary
-                   stats for all numbers ever added to ssb:
-                     {:keys [n sum min max p25 ... p99 mean var mad]}.
-
-  Useful for summarizing a (possibly infinite) stream of numbers.
-
-  Options:
-    :buffer-size - The maximum number of numbers that may be buffered
-                   before next (ssb <num>) call will block to flush
-                   buffer and merge with any existing summary stats.
-
-                   Larger buffers mean better performance and more
-                   accurate stats, at the cost of more memory use
-                   while buffering.
-
-    :buffer-init - Initial buffer content, useful for persistent ssb.
-    :sstats-init - Initial summary stats,  useful for persistent ssb."
-
-  ([] (summary-stats-buffered nil))
-  ([{:keys [buffer-size buffer-init sstats-init merge-cb]
-     :or   {buffer-size 1e5}
-     :as   opts}]
-
-   (SummaryStatsBuffered.
-     (atom (summary-stats sstats-init))
-     (atom       (buf-new buffer-init))
-     (long                buffer-size)
-     (enc/counter)
-     merge-cb ; Undocumented
-     )))
-
-(defn summary-stats-buffered-fast
-  "Returns fastest possible SummaryStatsBuffered."
-  [^long buffer-size merge-cb]
-  (SummaryStatsBuffered.
-     (atom nil)
-     (atom (buf-new))
-     buffer-size
-     nil
-     merge-cb))
-
-(comment
-  (let [ssb (summary-stats-buffered {:buffer-size 10})] ; 266 qb
-    [(enc/qb 1e6 (ssb (rand-int 1000))) (str ssb) @@ssb]))
-
-(defn summary-stats-buffered?
-  "Returns true iff given a SummaryStatsBuffered instance."
-  [x] (instance? SummaryStatsBuffered x))
-
-(defn summary-stats-stateful?
-  "Returns true iff given a stateful SummaryStats instance."
-  [x] (summary-stats-buffered? x))
-
-;;;; Print methods
-
-#?(:clj
-   (enc/deftype-print-methods
-     SortedLongs SortedDoubles
-     SummaryStats
-     SummaryStatsBuffered))
-
-;;;; Formatting
-
-(defn- perc [n d] (str (Math/round (* (/ (double n) (double d)) 100.0)) "%"))
-(comment [(perc 1 1) (perc 1 100) (perc 12 44)])
-
-(def ^:dynamic *fmt-opts* {:decimal-separator ".", :thousands-separator ","})
-(defn- fmt-num [precision n]
-  ;; Impln is inefficient but sufficient, and consistent between clj/s
-  (let [n (enc/roundn precision n)
-        neg?       (neg?     n)
-        n-abs      (Math/abs n)
-        n-int-part (long n-abs)
-        fmt-opts   *fmt-opts*]
-    (str
-      (when neg? "-")
-      (->>
-        (str n-int-part)
-        (reverse)
-        (partition 3 3 "")
-        (mapv str/join)
-        (str/join (get fmt-opts :thousands-separator))
-        (str/reverse))
-      
-      (when-let [n-dec-part (and (pos? (long precision)) (- n-abs n-int-part))]
-        (str (get fmt-opts :decimal-separator)
-          (enc/get-substr-by-len (str n-dec-part "000000")
-            2 precision))))))
-
-(comment
-  (fmt-num 0 123123123.5555) ; "123,123,124"
-  (fmt-num 2 123123123.5555) ; "123,123,123.56"
-  (fmt-num 2 123123123)      ; "123,123,123.00"
-  (fmt-num 3 123)            ; "123"
-  )
-
-(defn- fmt-nsecs [nanosecs]
-  (let [ns (double nanosecs)]
-    (cond
-      (>= ns 6e10) (str (fmt-num 2 (/ ns 6e10)) "m")
-      (>= ns 1e9)  (str (fmt-num 2 (/ ns 1e9))  "s")
-      (>= ns 1e6)  (str (fmt-num 0 (/ ns 1e6))  "ms")
-      (>= ns 1e3)  (str (fmt-num 0 (/ ns 1e3))  "μs")
-      :else        (str (fmt-num 0    ns)       "ns"))))
-
-(comment (fmt-nsecs 1e3))
-
-(def     all-format-columns [:n :min   :p25 :p50   :p75 :p90 :p95 :p99 :max :mean :mad :clock :sum])
-(def default-format-columns [:n :min #_:p25 :p50 #_:p75 :p90 :p95 :p99 :max :mean :mad :clock :sum])
-
-(let [migrate        {:n-calls :n, :total :sum} ; For back-compatibility
-      format-column? (set all-format-columns)
-      format-column  (fn [column] (have format-column? (get migrate column column)))]
-
-  (defn- format-columns [columns]
-    (enc/cond
-      (identical? columns default-format-columns) default-format-columns
-      (identical? columns     all-format-columns)     all-format-columns
-      :else (mapv format-column columns))))
-
-(comment (enc/qb 1e6 (format-columns [:min :n-calls :total])))
-
-(def default-format-id-fn (fn [id] (str id)))
-
-;; id-sstats* => {<id> <sstats>} or {<id> <sstats-map>}
-
-(defn get-max-id-width
-  [id-sstats*
-   {:keys [format-id-fn]
-    :or   {format-id-fn default-format-id-fn}}]
-
-  (when id-sstats*
-    (reduce-kv
-      (fn [^long acc id _sstats*]
-        (let [c (count (format-id-fn id))]
-          (if (> c acc) c acc)))
-      9 ; (count "Accounted")
-      id-sstats*)))
-
-(defn format-pstats
-  "Given {<id> <sstats>} or {<id> <sstats-map>} pstats, returns a formatted
-  table string. Assumes nanosecond clock, and stats based on profiling id'd
-  nanosecond times."
-  [clock-total id-sstats*
-   {:keys [columns sort-fn format-id-fn max-id-width] :as opts
-    :or   {columns      default-format-columns
-           sort-fn      (fn [ss] (get (enc/force-ref ss) :sum))
-           format-id-fn default-format-id-fn}}]
-
-  (when id-sstats*
-    (let [columns (format-columns columns)
-          clock-total (long clock-total)
-          ^long accounted-total
-          (reduce-kv
-            (fn [^long acc _id ss]
-              (+ acc (long (get (enc/force-ref ss) :sum))))
-            0 id-sstats*)
-
-          sorted-ids
-          (sort-by
-            (fn [id] (sort-fn (get id-sstats* id)))
-            enc/rcompare
-            (keys id-sstats*))
-
-          ^long max-id-width
-          (or
-            max-id-width
-            (get-max-id-width id-sstats* opts))
-
-          column->pattern
-          {:id      {:heading "pId" :min-width max-id-width :align :left}
-           :n       {:heading "nCalls"}
-           :min     {:heading "Min"}
-           :p25     {:heading "25% ≤"}
-           :p50     {:heading "50% ≤"}
-           :p75     {:heading "75% ≤"}
-           :p90     {:heading "90% ≤"}
-           :p95     {:heading "95% ≤"}
-           :p99     {:heading "99% ≤"}
-           :max     {:heading "Max"}
-           :mean    {:heading "Mean"}
-           :mad     {:heading "MAD"   :min-width 5}
-           :sum     {:heading "Total" :min-width 6}
-           :clock   {:heading "Clock"}}
-
-          sb (enc/str-builder "")
-
-          append-col
-          (fn [column s]
-            (let [{:keys [min-width align]
-                   :or   {min-width 10 align :right}}
-                  (get column->pattern column)]
-
-              (enc/sb-append sb
-                (enc/format
-                  (str "%" (case align :left "-" :right "") min-width "s")
-                  s))))]
-
-      ; Write header rows
-      (doseq [column (into [:id] columns)]
-        (when-not (= :id column)
-          (enc/sb-append sb " "))
-        (append-col column (get-in column->pattern [column :heading])))
-
-      (enc/sb-append sb "\n\n")
-
-      ; Write id rows
-      (doseq [id sorted-ids]
-        (let [ssm (enc/force-ref (get id-sstats* id))
-              {:keys [n sum mean mad]} ssm]
-
-          (append-col :id (format-id-fn id))
-          (doseq [column columns]
-            (enc/sb-append sb " ")
-            (case column
-              :n     (append-col column (fmt-num 0 n))
-              :mean  (append-col column (fmt-nsecs mean))
-              :mad   (append-col column (str "±" (perc mad mean)))
-              :sum   (append-col column (perc sum clock-total))
-              :clock (append-col column (fmt-nsecs sum))
-              (do    (append-col column (fmt-nsecs (get ssm column))))))
-
-          (enc/sb-append sb "\n")))
-
-      ; Write accounted row
-      (enc/sb-append sb "\n")
-      (append-col :id "Accounted")
-      (doseq [column columns]
-        (enc/sb-append sb " ")
-        (case column
-          :sum   (append-col column (perc accounted-total clock-total))
-          :clock (append-col column (fmt-nsecs accounted-total))
-          (do    (append-col column ""))))
-
-      ; Write clock row
-      (enc/sb-append sb "\n")
-      (append-col :id "Clock")
-      (doseq [column columns]
-        (enc/sb-append sb " ")
-        (case column
-          :sum   (append-col column "100%")
-          :clock (append-col column (fmt-nsecs clock-total))
-          (do    (append-col column ""))))
-
-      (enc/sb-append sb "\n")
-      (str sb))))
-
-(comment
-  (defn rand-vs [n & [max]]
-    (take n (repeatedly (partial rand-int (or max Integer/MAX_VALUE)))))
-
-  (println
-    (format-pstats (* 1e6 30)
-      {:foo (summary-stats (rand-vs 1e4 20))
-       :bar (summary-stats (rand-vs 1e2 50))
-       :baz (summary-stats (rand-vs 1e5 30))}
-      {}) "\n"))
-
-;;;; Aliases
-
-;; (enc/defalias sstats       summary-stats)
-;; (enc/defalias sstats-merge summary-stats-merge)
-
-(enc/deprecated
-  (enc/defalias ^:deprecated summary-stats-format format-pstats))
diff --git a/src/taoensso/tufte/telemere.cljc b/src/taoensso/tufte/telemere.cljc
new file mode 100644
index 0000000..4637cea
--- /dev/null
+++ b/src/taoensso/tufte/telemere.cljc
@@ -0,0 +1,50 @@
+(ns taoensso.tufte.telemere
+  "Handler for Telemere,
+    Ref. <https://www.taoensso.com/telemere>."
+  (:require
+   [taoensso.encore     :as enc]
+   [taoensso.tufte      :as tufte]
+   [taoensso.tufte.impl :as impl]
+   [taoensso.telemere   :as tel]))
+
+(defn handler:telemere
+  "Returns a handler fn for use with `add-handler!` that creates a Telemere signal with:
+    `:kind`     - `:tufte`
+    `:location` - Location of `profile` call
+    `:id`       - Id       of `profile` call
+    `:level`    - Level    of `profile` call (override with `:signal-level` opt)
+    `:data`     - {:keys [sample-rate ctx data pstats pstats-str_ ...]} `profile` info
+    `:msg_`     - pstats formatted as string table, may be a delay!
+
+  Options:
+    `:format-pstats-opts` - Opts map provided to `format-pstats` (default nil)
+    `:telemere-level`     - Telemere signal level or fn of profiling level
+                            (defaults to `profile` level)"
+
+  {:added "vX.Y.Z (YYYY-MM-DD)"}
+  ([] (handler:telemere nil))
+  ([{:keys [telemere-level format-pstats-opts]
+     :or   {telemere-level :info}}]
+
+   (let [level-fn (impl/psig-level-fn telemere-level)]
+     (fn a-handler:telemere [psig]
+       (let [{:keys [inst location id level data ctx pstats format-pstats-fn]} psig]
+         (taoensso.telemere/signal!
+           {:kind     :tufte
+            :location location
+            :inst     inst
+            :id       id
+            :level    (level-fn level)
+            :data     data #_psig
+            :psig     psig ; Won't be printed by default (good)
+            :msg      (delay
+                        (str "\n<<< table <<<\n"
+                          (let [ff (or format-pstats-fn impl/format-pstats)]
+                            (ff pstats format-pstats-opts)) "\n>>> table >>>"))
+            :ctx+
+            (fn [old]
+              (if (or (nil? old) (map? old))
+                (enc/merge-nx old ctx)
+                (do           old)))}))))))
+
+(comment ((handler:telemere) (#'tufte/dummy-psig)))
diff --git a/src/taoensso/tufte/timbre.cljc b/src/taoensso/tufte/timbre.cljc
index 55ec571..3dcdd94 100644
--- a/src/taoensso/tufte/timbre.cljc
+++ b/src/taoensso/tufte/timbre.cljc
@@ -1,33 +1,53 @@
 (ns taoensso.tufte.timbre
-  "Simple logging handler for integration with Timbre."
+  "Handler for Timbre,
+    Ref. <https://www.taoensso.com/timbre>."
   (:require
-            [taoensso.encore :as enc]
-            [taoensso.tufte  :as tufte]
-   #?(:clj  [taoensso.timbre :as timbre :refer        [log!]]
-      :cljs [taoensso.timbre :as timbre :refer-macros [log!]])))
+   [taoensso.encore         :as enc]
+   [taoensso.encore.signals :as sigs]
+   [taoensso.tufte          :as tufte]
+   [taoensso.tufte.impl     :as impl]
+   [taoensso.timbre         :as timbre]))
 
-(defn add-timbre-logging-handler!
-  "Adds a simple handler that logs `profile` stats output with Timbre.
+(defn handler:timbre
+  "Returns a handler fn for use with `add-handler!` that:
+    1. Formats `profile` pstats with `format-pstats`, and
+    2. Logs the resulting string table with Timbre.
 
-  `timbre-level` may be a fixed Timbre level (e.g. :info), or a
-  (fn [tufte-level]) -> timbre-level, e.g. {0 :trace 1 :debug ...}."
-  [{:keys [timbre-level ns-pattern handler-id]
-    :or   {timbre-level :info
-           ns-pattern "*"
-           handler-id :timbre}}]
+  Options:
+    `:format-pstats-opts` - Opts map provided to `format-pstats` (default nil)
+    `:timbre-level`       - Timbre level or fn of profiling level
+                            (defaults to `profile` level)"
 
-  (tufte/add-handler! handler-id ns-pattern
-    (fn [m]
-      (let [{:keys [ns-str level ?id ?data pstats pstats-str_ ?file ?line]} m
-            profile-opts (enc/assoc-some {:level level} :id ?id :data ?data)
-            timbre-level
-            (cond
-              (keyword? timbre-level) timbre-level
-              (ifn? timbre-level) (timbre-level level)
-              :else timbre-level)]
+  {:added "vX.Y.Z (YYYY-MM-DD)"}
+  ([] (handler:timbre nil))
+  ([{:keys [timbre-level format-pstats-opts]
+     :or   {timbre-level :info}}]
 
-        (log! timbre-level :p
-          [(str "Tufte `profile` output " profile-opts ":\n\n" @pstats-str_ "\n")]
-          {:?ns-str ns-str :?file ?file :?line ?line})))))
+   (let [level-fn (impl/psig-level-fn timbre-level)]
+     (fn a-handler:timbre [psig]
+       (let [{:keys [inst location id level data ctx pstats format-pstats-fn]} psig]
+         (timbre/log!
+           {:loc      #_location {:ns (get location :ns), :line (get location :line)} ; TODO Needs Timbre >= v6.6.1
+            :level    (level-fn level)
+            :instant  #?(:clj (enc/as-dt inst), :cljs inst)
+            :msg-type :p
+            :vargs
+            [(str
+               "Tufte pstats "
+               (when id (str (sigs/format-id (get location :ns) id) " ")) "-"
+               (str "\n<<< table <<<\n" (let [ff (or format-pstats-fn impl/format-pstats)] (ff pstats format-pstats-opts)) "\n>>> table >>>")
+               (when-let [data (enc/not-empty-coll data)] (str "\n data: " (enc/pr-edn* data)))
+               (when-let [ctx  (enc/not-empty-coll ctx)]  (str "\n  ctx: " (enc/pr-edn* ctx))))]}))))))
 
-(comment (add-timbre-logging-handler! {}))
+(comment ((handler:timbre) (#'tufte/dummy-psig)))
+
+(enc/deprecated
+  (defn ^:no-doc add-timbre-logging-handler!
+    "Prefer (add-handler! <handler-id> (handler:timbre) <dispatch-opts>)."
+    {:deprecated "vX.Y.Z (YYYY-MM-DD)"}
+    [{:keys [timbre-level ns-pattern handler-id]
+      :or   {ns-pattern "*"
+             handler-id :timbre}}]
+
+    (let [handler-fn (handler:timbre {:timbre-level timbre-level})]
+      ^:deprecation-nowarn (tufte/add-legacy-handler! handler-id ns-pattern handler-fn))))
diff --git a/test/taoensso/tufte_tests.cljc b/test/taoensso/tufte_tests.cljc
index 4509ca2..417b9a9 100644
--- a/test/taoensso/tufte_tests.cljc
+++ b/test/taoensso/tufte_tests.cljc
@@ -6,10 +6,9 @@
    [taoensso.tufte  :as tufte :refer [profiled profile p]]
 
    #?(:clj  [taoensso.tufte.impl  :as impl]
-      :cljs [taoensso.tufte.impl  :as impl :refer
-             [PState PData PStats TimeSpan]]))
+      :cljs [taoensso.tufte.impl  :as impl :refer [PStats PData TimeSpan]]))
 
-  #?(:clj  (:import [taoensso.tufte.impl PState PData PStats TimeSpan]))
+  #?(:clj  (:import [taoensso.tufte.impl PStats PData TimeSpan]))
   #?(:cljs (:require-macros
             [taoensso.tufte-tests
              :refer [looped nested-profiled]])))
@@ -68,8 +67,7 @@
 
        [(is (= r "foo"))
         (is (ps? ps))
-        (is (= (get-in @ps [:stats :foo :n]) 110))
-        (is (= (get-in @ps [:stats :bar :n]) 50))])
+        (is (enc/submap? @ps {:stats {:foo {:n 110} :bar {:n 50}}}))])
 
      (let [[r ps]
            (profiled {:dynamic? true}
@@ -79,8 +77,7 @@
 
        [(is (= r "foo"))
         (is (ps? ps))
-        (is (= (get-in @ps [:stats :foo :n]) 110))
-        (is (= (get-in @ps [:stats :bar :n]) 50))])
+        (is (enc/submap? @ps {:stats {:foo {:n 110} :bar {:n 50}}}))])
 
      (let [[r ps] (profiled {} (p :foo) (p ::foo) (p 'foo) (p `foo))]
        [(is (enc/submap? @ps {:stats {:foo {} ::foo {} 'foo {} `foo {}}})
@@ -100,8 +97,7 @@
 
        [(is (= r "foo"))
         (is (ps? ps))
-        (is (= (get-in @ps [:stats :foo :n]) 110))
-        (is (= (get-in @ps [:stats :bar :n]) 125))])
+        (is (enc/submap? @ps {:stats {:foo {:n 110} :bar {:n 125}}}))])
 
      (let [[r ps]
            (profiled {:dynamic? true}
@@ -111,8 +107,7 @@
 
        [(is (= r "foo"))
         (is (ps? ps))
-        (is (= (get-in @ps [:stats :foo :n]) 110))
-        (is (= (get-in @ps [:stats :bar :n]) 125))])]))
+        (is (enc/submap? @ps {:stats {:foo {:n 110} :bar {:n 125}}}))])]))
 
 #?(:clj
    (deftest capture-threaded
@@ -127,8 +122,7 @@
 
           [(is (= r "foo"))
            (is (ps? ps))
-           (is (= (get-in @ps [:stats :foo :n]) 1))
-           (is (= (get-in @ps [:stats :bar :n]) nil))])
+           (is (enc/submap? @ps {:stats {:foo {:n 1} :bar :submap/nx}}))])
 
         (let [[r ps]
               (profiled {:dynamic? true}
@@ -139,8 +133,7 @@
 
           [(is (= r "foo"))
            (is (ps? ps))
-           (is (= (get-in @ps [:stats :foo :n]) 2))
-           (is (= (get-in @ps [:stats :bar :n]) 1))])])))
+           (is (enc/submap? @ps {:stats {:foo {:n 2} :bar {:n 1}}}))])])))
 
 (deftest merging-basics
   [(testing "Merging/basics"
@@ -151,9 +144,7 @@
             [_ ps2] (profiled {:dynamic? true} (looped  30 (p :baz)))
             ps3 (reduce tufte/merge-pstats [nil ps0 nil nil ps1 ps2 nil])]
         [(is (ps? ps3))
-         (is (= (get-in @ps3 [:stats :foo :n]) 120))
-         (is (= (get-in @ps3 [:stats :bar :n]) 100))
-         (is (= (get-in @ps3 [:stats :baz :n])  30))])
+         (is (enc/submap? @ps3 {:stats {:foo {:n 120} :bar {:n 100} :baz {:n 30}}}))])
 
       ;; Invert dynamic/non-dynamic
       (let [[_ ps0] (profiled {}               (looped 100 (p :foo) (p :bar)))
@@ -161,9 +152,7 @@
             [_ ps2] (profiled {}               (looped  30 (p :baz)))
             ps3 (reduce tufte/merge-pstats [nil ps0 nil nil ps1 ps2 nil])]
         [(is (ps? ps3))
-         (is (= (get-in @ps3 [:stats :foo :n]) 120))
-         (is (= (get-in @ps3 [:stats :bar :n]) 100))
-         (is (= (get-in @ps3 [:stats :baz :n])  30))])])
+         (is (enc/submap? @ps3 {:stats {:foo {:n 120} :bar {:n 100} :baz {:n 30}}}))])])
 
    #?(:clj
       (testing "ps1 starting before ps0 should sum clock total correctly, Ref. #48"
@@ -183,11 +172,14 @@
 
        [(is (= r "qux"))
         (is (ps? ps))
-        (is (= (get-in @ps [:stats :foo :n]) 150))
-        (is (= (get-in @ps [:stats :bar :n])  50))
-        (is (= (get-in @ps [:stats :baz :n])  50))
-        (is (= (get-in @ps [:stats :tufte/compaction :n]) (/ 250 10)))
-        (is (= (count (.-acc ^PState @(.-pstate_ ^PData (.-pd ^PStats ps)))) 2))])
+        (is (enc/submap? @ps
+              {:stats
+               {:foo              {:n 150}
+                :bar              {:n  50}
+                :baz              {:n  50}
+                :tufte/compaction {:n (/ 250 10)}}}))
+
+        (is (= (count (.-acc ^PStats ps)) 2))])
 
      (let [[r ps]
            (profiled {:nmax 10 :dynamic? true}
@@ -197,11 +189,15 @@
 
        [(is (= r "qux"))
         (is (ps? ps))
-        (is (= (get-in @ps [:stats :foo :n]) 150))
-        (is (= (get-in @ps [:stats :bar :n])  50))
-        (is (= (get-in @ps [:stats :baz :n])  50))
-        (is (= (get-in @ps [:stats :tufte/compaction :n]) (/ 250 10)))
-        (is (= (count @(.-acc ^PState @(.-pstate_ ^PData (.-pd ^PStats ps)))) 2))])]))
+
+        (is (enc/submap? @ps
+              {:stats
+               {:foo              {:n 150}
+                :bar              {:n  50}
+                :baz              {:n  50}
+                :tufte/compaction {:n (/ 250 10)}}}))
+
+        (is (= (count @(.-acc ^PStats ps)) 2))])]))
 
 (deftest compaction-merge
   (testing "Compaction/merge"
@@ -216,10 +212,12 @@
         (is (= (get-in @ps1 [:stats :tufte/compaction :n]) nil))
         (is (= (get-in @ps2 [:stats :tufte/compaction :n]) 1))
 
-        (is (= (get-in @ps3 [:stats :foo :n]) 170))
-        (is (= (get-in @ps3 [:stats :bar :n])  60))
-        (is (= (get-in @ps3 [:stats :tufte/compaction :n]) 20)) ; Merging does uncounted compaction
-        ])
+        (is (= (enc/submap? @ps3
+                 {:stats
+                  {:foo              {:n 170}
+                   :bar              {:n  60}
+                   :tufte/compaction {:n  20}}}))
+          "Merging does uncounted compaction")])
 
      ;; Invert dynamic/non-dynamic
      (let [[_ ps0] (profiled {:nmax 10}       (looped 100 (p :foo)) (looped 50 (p :foo (p :bar))))
@@ -231,22 +229,25 @@
         (is (= (get-in @ps1 [:stats :tufte/compaction :n]) nil))
         (is (= (get-in @ps2 [:stats :tufte/compaction :n]) 1))
 
-        (is (= (get-in @ps3 [:stats :foo :n]) 170))
-        (is (= (get-in @ps3 [:stats :bar :n])  60))
-        (is (= (get-in @ps3 [:stats :tufte/compaction :n]) 20)) ; Merging does uncounted compaction
-        ])
+        (is (enc/submap? @ps3
+              {:stats
+               {:foo              {:n 170}
+                :bar              {:n  60}
+                :tufte/compaction {:n  20}}})
+          "Merging does uncounted compaction")])
 
      ;; [#54] merging PStats with times still (only) in accumulator
-     (let [[_ ps0] (profiled {:nmax 10} (p :foo))
+     (let [[_ ^PStats ps0] (profiled {:nmax 10} (p :foo))
            ps (enc/reduce-n (fn [ps _] (tufte/merge-pstats ps ps0)) nil 1000)]
 
-       [(is (<= (count (:foo (.-id-times  ^PState (.-pstate_ ^PData (.-pd ^PStats ps))))) 10))
-        (is (<= (count (:foo (.-id-sstats ^PState (.-pstate_ ^PData (.-pd ^PStats ps))))) 10))])]))
+       [(is (<= (count (:foo (.-id-times  ps0))) 10))
+        (is (<= (count (:foo (.-id-sstats ps0))) 10))])]))
 
 (defn- pstats-tspan [t0 t1]
-  (let [pd (PData. 8e5 t0 (PState. nil nil nil))
-        time-span [(TimeSpan. t0 t1)]]
-    (PStats. pd t1 time-span (delay (#'impl/deref-pstats pd t1 time-span)))))
+  (let [pd (PData. false 8e5 t0 nil nil nil false)
+        tspans [(TimeSpan. t0 t1)]]
+    (PStats. 8e5 t0 t1 nil nil nil tspans
+      (delay (#'impl/deref-pstats 8e5 t0 t1 nil nil nil tspans)))))
 
 (deftest merge-time-spans
   [(testing "Merge discrete time-spans"
@@ -281,12 +282,12 @@
 (defn add-test-handler! []
   #?(:clj
      (let [p_ (promise)]
-       (tufte/add-handler! :testing (fn [x] (p_ x)))
+       (tufte/add-handler! :testing (fn [x] (p_ x)) {})
        (fn [] (deref p_ 1000 nil)))
 
      :cljs
      (let [a_ (atom ::nil)]
-       (tufte/add-handler! :testing (fn [x] (compare-and-set! a_ ::nil x)))
+       (tufte/add-handler! :testing (fn [x] (compare-and-set! a_ ::nil x)) {})
        (fn [] (deref a_)))))
 
 (deftest profile-basics
@@ -299,8 +300,7 @@
 
        [(is (= r "foo"))
         (is (ps? ps))
-        (is (:clock @ps))
-        (is (nil? (:stats @ps)))])
+        (is (enc/submap? @ps {:clock :submap/ex :stats nil}))])
 
      (let [th (add-test-handler!)
            r  (profile {:dynamic? true} "foo")
@@ -309,8 +309,7 @@
 
        [(is (= r "foo"))
         (is (ps? ps))
-        (is (:clock @ps))
-        (is (nil? (:stats @ps)))])
+        (is (enc/submap? @ps {:clock :submap/ex :stats nil}))])
 
      #?(:clj
         (let [th (add-test-handler!)
@@ -320,9 +319,10 @@
 
           [(is (= r "bar"))
            (is (ps? ps))
-           (is (:clock @ps))
-           (is (= (get-in @ps [:stats :foo :n]) nil))
-           (is (= (get-in @ps [:stats :bar :n]) 1))
+           (is (enc/submap? @ps
+                 {:clock       :submap/ex
+                  :stats {:foo :submap/nx
+                          :bar {:n 1}}}))
            (is (string? @(:pstats-str_ m)))]))
 
      #?(:clj
@@ -333,9 +333,10 @@
 
           [(is (= r "bar"))
            (is (ps? ps))
-           (is (:clock @ps))
-           (is (= (get-in @ps [:stats :foo :n]) 1))
-           (is (= (get-in @ps [:stats :bar :n]) 1))
+           (is (enc/submap? @ps
+                 {:clock :submap/ex
+                  :stats {:foo {:n 1}
+                          :bar {:n 1}}}))
            (is (string? @(:pstats-str_ m)))]))
 
      (tufte/remove-handler! :testing)]))
@@ -385,24 +386,26 @@
 
     [;; Capture in `profiled`
      (let [[_ ps] (profiled {} (tufte/capture-time! :foo 100))]
-       (is (= (get-in @ps [:stats :foo :n]) 1)))
+       (is (enc/submap? @ps {:stats {:foo {:n 1}}})))
 
      ;; Capture to local pdata
      (let [n  (long 2e6)
            pd (tufte/new-pdata)
            _  (looped n (tufte/capture-time! pd :foo 100))]
-       (is (= (get-in @@pd [:stats :foo :n]) n)))
+       (is (enc/submap? @@pd {:stats {:foo {:n n}}})))
 
      #?(:clj
-        [;; Capture to dynamic pdata from separate threads
-         (let [n  (long 100)
-               pd (tufte/new-pdata {:dynamic? true :nmax 88})
+        [;; Capture to dynamic pdata from separate threads using a super low
+         ;; nmax to aggrevate possible contention. This test will show if any
+         ;; times were lost during compaction.
+         (let [n  (long 500)
+               pd (tufte/new-pdata {:dynamic? true :nmax 10}) ; Low nmax
                f1 (future (looped n (tufte/capture-time! pd :foo 100)))
                f2 (future (looped n (tufte/capture-time! pd :foo 100)))
                f3 (future (looped n (tufte/capture-time! pd :foo 100)))
                f4 (future (looped n (tufte/capture-time! pd :foo 100)))]
 
-           (do @f1 @f2 @f3 @f4)
+           [@f1 @f2 @f3 @f4] ; Block for futures to complete
            (is (= (get-in @@pd [:stats :foo :n]) (* 4 n))))
 
          ;; local `p`s against local pdata
@@ -412,9 +415,11 @@
                     (p :bar (Thread/sleep 200))
                     (tufte/capture-time! :baz 100))]
 
-           [(is (= (get-in @@pd [:stats :foo :n]) 1))
-            (is (= (get-in @@pd [:stats :bar :n]) 1))
-            (is (= (get-in @@pd [:stats :baz :n]) 1))])
+           [(is (enc/submap? @@pd
+                  {:stats
+                   {:foo {:n 1}
+                    :bar {:n 1}
+                    :baz {:n 1}}}))])
 
          ;; local `p`s against dynamic pdata
          (let [pd (tufte/new-pdata         {:dynamic? true})
@@ -423,9 +428,11 @@
                     (p :bar (Thread/sleep 200))
                     (tufte/capture-time! :baz 100))]
 
-           [(is (= (get-in @@pd [:stats :foo :n]) 1))
-            (is (= (get-in @@pd [:stats :bar :n]) 1))
-            (is (= (get-in @@pd [:stats :baz :n]) 1))])
+           [(is (enc/submap? @@pd
+                  {:stats
+                   {:foo {:n 1}
+                    :bar {:n 1}
+                    :baz {:n 1}}}))])
 
          ;; dynamic `p`s against dynamic pdata
          (let [pd (tufte/new-pdata         {:dynamic? true})
@@ -435,10 +442,11 @@
                     (tufte/capture-time! :baz 100))]
 
            (Thread/sleep 100)
-
-           [(is (= (get-in @@pd [:stats :foo :n]) 1))
-            (is (= (get-in @@pd [:stats :bar :n]) 1))
-            (is (= (get-in @@pd [:stats :baz :n]) 1))])])]))
+           [(is (enc/submap? @@pd
+                  {:stats
+                   {:foo {:n 1}
+                    :bar {:n 1}
+                    :baz {:n 1}}}))])])]))
 
 (deftest format-pstats
   [(testing "Basic format-pstats"
@@ -535,14 +543,6 @@
              (remove empty?)
              (take 2))))))])
 
-(deftest format-id-abbr-test
-  (testing "Format id abbr test"
-    [(is (= "foo"               ((tufte/format-id-abbr)   :foo)))
-     (is (= "e.hello/foo"       ((tufte/format-id-abbr)   :example.hello/defn_foo)))
-     (is (= "e.hello/foo"       ((tufte/format-id-abbr 1) :example.hello/defn_foo)))
-     (is (= "e.h.world/foo"     ((tufte/format-id-abbr 1) :example.hello.world/defn_foo)))
-     (is (= "e.hello.world/foo" ((tufte/format-id-abbr 2) :example.hello.world/defn_foo)))]))
-
 ;;;; Util macros
 
 (do
@@ -591,36 +591,38 @@
              (p :qux)))]
 
      [(is (enc/submap? @ps
-            {:stats {:foo {:loc {:line 589}}
-                     :bar {:loc {:line 589}}
-                     :baz {:loc {:line 590}}
-                     :qux {:loc {:line 591}}}}))])
+            (let [nref 589]
+              {:stats {:foo {:loc {:line nref}}
+                       :bar {:loc {:line nref}}
+                       :baz {:loc {:line (+ nref 1)}}
+                       :qux {:loc {:line (+ nref 2)}}}})))])
 
    (let [[r ps]
          (profiled {}
-           (p          :foo) ; Line 601
-           (p          :foo)
-           (p          :foo)
-           (tufte/pspy :foo))
+           (p :foo) ; Line 602
+           (p :foo)
+           (p :foo)
+           (p :foo))
 
          loc (get-in @ps [:stats :foo :loc])]
 
      [(is (set? loc) "id with >1 locations")
-      (is (= (into #{} (map :line) loc) #{601 602 603 604}))
+      (is (= (into #{} (map :line) loc) (let [nref 602] #{nref (+ nref 1) (+ nref 2) (+ nref 3)})))
       (is (enc/submap? @ps {:stats {:foo {:n 4}}}) "id's stats include all locations")])
 
    (let [[r ps] (profiled {} (run-test-fns))]
      [(is
         (enc/submap? @ps
-          {:stats {::defn_fn1 {:loc {:line 549}}
-                   ::defn_fn2 {:loc {:line 550}}
-                   :__fn3     {:loc {:line 551}}
-                   :__fn4     {:loc {:line 552}}
-                   :__fn4_1   {:loc {:line 552}}
-                   :__fn4_2   {:loc {:line 552}}
-                   ::defn_fn5 {:loc {:line 553}}
-                   ::fn_fn6   {:loc {:line 556}}
-                   :__fn7     {:loc {:line 557}}}}))])])
+          (let [nref 549]
+           {:stats {::defn_fn1 {:loc {:line    nref}}
+                    ::defn_fn2 {:loc {:line (+ nref 1)}}
+                    :__fn3     {:loc {:line (+ nref 2)}}
+                    :__fn4     {:loc {:line (+ nref 3)}}
+                    :__fn4_1   {:loc {:line (+ nref 3)}}
+                    :__fn4_2   {:loc {:line (+ nref 3)}}
+                    ::defn_fn5 {:loc {:line (+ nref 4)}}
+                    ::fn_fn6   {:loc {:line (+ nref 7)}}
+                    :__fn7     {:loc {:line (+ nref 8)}}}})))])])
 
 (comment (let [f1 (tufte/fnp foo [x] x #_(p :x x))]))