@lovelace_lol/polymer 0.0.1

package/src/polymer/eye_head/service.cljs

@@ -0,0 +1,259 @@
+(ns polymer.eye-head.service
+  (:require [polymer.animation.service :as animation-service]
+            [polymer.eye-head.agency :as eye-head-agency]))
+
+;; Compatibility adapter for the JavaScript service API LoomLarge already uses.
+;; This is not the Eye/Head agency implementation. Movement work enters
+;; Polymer's Eye/Head agency first; this adapter only preserves the historical
+;; API while routing accepted animation requests into Polymer Animation.
+
+(def EYE_AUS
+  #js {:BOTH_LOOK_LEFT 61
+       :BOTH_LOOK_RIGHT 62
+       :BOTH_LOOK_UP 63
+       :BOTH_LOOK_DOWN 64
+       :BLINK 43
+       :WIDE 5
+       :SQUINT 7})
+
+(def HEAD_AUS
+  #js {:TURN_LEFT 51
+       :TURN_RIGHT 52
+       :TURN_UP 53
+       :TURN_DOWN 54
+       :TILT_LEFT 55
+       :TILT_RIGHT 56})
+
+(def DEFAULT_EYE_HEAD_CONFIG
+  #js {:gazeMode "engine"
+       :eyeTrackingEnabled false
+       :headTrackingEnabled false
+       :headFollowEyes true
+       :eyeIntensity 1.0
+       :headIntensity 0.5
+       :returnToNeutralEnabled false
+       :returnToNeutralDelay 3000
+       :returnToNeutralDuration 800
+       :useAnimationAgency true})
+
+(def DEFAULT_ANIMATION_KEYS
+  #js {:EYE_LOOK_LEFT "eyeHeadTracking/eyeLookLeft"
+       :EYE_LOOK_RIGHT "eyeHeadTracking/eyeLookRight"
+       :EYE_LOOK_UP "eyeHeadTracking/eyeLookUp"
+       :EYE_LOOK_DOWN "eyeHeadTracking/eyeLookDown"
+       :EYE_BLINK "eyeHeadTracking/eyeBlink"
+       :HEAD_TURN_LEFT "eyeHeadTracking/headTurnLeft"
+       :HEAD_TURN_RIGHT "eyeHeadTracking/headTurnRight"
+       :HEAD_TURN_UP "eyeHeadTracking/headTurnUp"
+       :HEAD_TURN_DOWN "eyeHeadTracking/headTurnDown"
+       :HEAD_TILT_LEFT "eyeHeadTracking/headTiltLeft"
+       :HEAD_TILT_RIGHT "eyeHeadTracking/headTiltRight"})
+
+(defn data-map [value]
+  (cond
+    (map? value) value
+    value (js->clj value :keywordize-keys true)
+    :else {}))
+
+(defn finite-number? [value]
+  (and (number? value) (js/isFinite value)))
+
+(defn number-or [value fallback]
+  (if (finite-number? value) value fallback))
+
+(defn js-call [target method-name & args]
+  (when target
+    (when-let [method (aget target method-name)]
+      (when (fn? method)
+        (.apply method target (to-array args))))))
+
+(defn runtime-prop [value property-name]
+  (cond
+    (map? value) (get value (keyword property-name))
+    value (aget value property-name)
+    :else nil))
+
+(defn normalize-target [target fallback]
+  (let [input (merge {:x 0 :y 0 :z 0} fallback (data-map target))]
+    {:x (max -1 (min 1 (number-or (:x input) 0)))
+     :y (max -1 (min 1 (number-or (:y input) 0)))
+     :z (number-or (:z input) 0)}))
+
+(defn service-config [config]
+  (let [input (data-map config)
+        transition (number-or (:agencyTransitionDuration input)
+                              (number-or (:transitionDurationMs input) 240))
+        neutral-duration (number-or (:returnToNeutralDuration input)
+                                    (number-or (:returnToCenterDurationMs input) 300))]
+    {:enabled true
+     :eyeTrackingEnabled (boolean (:eyeTrackingEnabled input))
+     :headTrackingEnabled (boolean (:headTrackingEnabled input))
+     :headFollowEyes (if (contains? input :headFollowEyes)
+                       (boolean (:headFollowEyes input))
+                       true)
+     :eyeIntensity (number-or (:eyeIntensity input) 1.0)
+     :headIntensity (number-or (:headIntensity input) 0.5)
+     :transitionDurationMs transition
+     :returnToCenterDurationMs neutral-duration
+     :coalesceMs (number-or (:coalesceMs input) 0)
+     :replaceExisting true}))
+
+(defn service-state [state-atom mode-atom]
+  (let [snapshot @state-atom
+        agency-state (data-map snapshot)
+        config (or (:config agency-state) {})
+        current-target (or (:currentTarget agency-state) {:x 0 :y 0 :z 0})]
+    #js {:eyeStatus (if (get config :eyeTrackingEnabled) "tracking" "idle")
+         :headStatus (if (get config :headTrackingEnabled) "tracking" "idle")
+         :currentGaze (clj->js current-target)
+         :targetGaze (clj->js current-target)
+         :eyeIntensity (number-or (:eyeIntensity config) 1.0)
+         :lastBlinkTime (:lastBlinkTime agency-state)
+         :headIntensity (number-or (:headIntensity config) 0.5)
+         :headFollowTimer nil
+         :isSpeaking (boolean (:isSpeaking agency-state))
+         :isListening (boolean (:isListening agency-state))
+         :returnToNeutralTimer nil
+         :lastGazeUpdateTime (or (:lastGazeUpdateTime agency-state) 0)
+         :mode @mode-atom}))
+
+(defn create-blink-snippet []
+  (let [name (str "eyeHeadTracking:blink:" (.now js/Date))]
+    {:name name
+     :curves {"43" [{:time 0.0 :intensity 0.0 :inherit true}
+                    {:time 0.045 :intensity 1.0}
+                    {:time 0.13 :intensity 0.0}]}
+     :channels [{:target {:type "au" :id 43}
+                 :keyframes [{:time 0.0 :intensity 0.0 :inherit true}
+                             {:time 0.045 :intensity 1.0}
+                             {:time 0.13 :intensity 0.0}]}]
+     :maxTime 0.13
+     :loop false
+     :snippetCategory "eyeHeadTracking"
+     :snippetPriority 25
+     :snippetBlendMode "additive"
+     :snippetPlaybackRate 1.0
+     :snippetIntensityScale 1.0}))
+
+(defn animation-target [config]
+  (or (runtime-prop config "animationAgency")
+      (when-let [engine (runtime-prop config "engine")]
+        (animation-service/createAnimationService engine))))
+
+(defn schedule-animation! [anim snippet options]
+  (or (js-call anim "schedule" (clj->js snippet) (clj->js options))
+      (js-call anim "scheduleSnippet" (clj->js snippet) (clj->js options))))
+
+(defn remove-animation! [anim name]
+  (or (js-call anim "remove" name)
+      (js-call anim "removeSnippet" name)))
+
+(defn createEyeHeadTrackingService
+  ([]
+   (createEyeHeadTrackingService nil nil))
+  ([config]
+   (createEyeHeadTrackingService config nil))
+  ([config callbacks]
+   (let [config-atom (atom (service-config config))
+         mode-atom (atom (or (:gazeMode (data-map config)) "manual"))
+         state-atom (atom (merge {:isSpeaking false
+                                  :isListening false
+                                  :lastBlinkTime nil
+                                  :lastGazeUpdateTime 0}
+                                 {:config @config-atom
+                                  :currentTarget {:x 0 :y 0 :z 0}}))
+         agency (eye-head-agency/create-eye-head-tracking-agency (clj->js @config-atom))
+         anim (animation-target config)
+         started? (atom false)
+         disposed? (atom false)
+         unsubscribers (atom [])]
+     (letfn [(dispatch! [command]
+               (when-not @disposed?
+                 (js-call agency "dispatch" (clj->js command))))
+             (configure! [next-config]
+               (swap! config-atom merge (service-config next-config))
+               (swap! state-atom assoc :config @config-atom)
+               (dispatch! {:type "configure" :config @config-atom}))
+             (route-event! [event]
+               (let [payload (data-map event)]
+                 (case (:type payload)
+                   "animation.requestScheduleSnippet"
+                   (schedule-animation! anim (:snippet payload) (or (:options payload) {:autoPlay true}))
+
+                   "animation.requestRemoveSnippet"
+                   (remove-animation! anim (:name payload))
+
+                   "error"
+                   (js-call callbacks "onError" (js/Error. (or (:message payload)
+                                                               "Eye/head tracking error")))
+
+                   nil)
+                 (when (= "animation.requestScheduleSnippet" (:type payload))
+                   (swap! state-atom assoc
+                          :currentTarget (get-in payload [:snippet :metadata :target] (:currentTarget @state-atom))
+                          :lastGazeUpdateTime (.now js/Date)))))
+             (teardown! []
+               (doseq [unsubscribe @unsubscribers]
+                 (unsubscribe))
+               (reset! unsubscribers []))]
+       (swap! unsubscribers conj (js-call agency "subscribeEvents" route-event!))
+       #js {:start (fn []
+                     (when-not @disposed?
+                       (reset! started? true)
+                       (dispatch! {:type "enable"})))
+            :stop (fn []
+                    (when-not @disposed?
+                      (reset! started? false)
+                      (dispatch! {:type "cancel" :reason "stopped"})))
+            :setGazeTarget (fn [target]
+                             (let [normalized (normalize-target target nil)]
+                               (swap! state-atom assoc
+                                      :currentTarget normalized
+                                      :lastGazeUpdateTime (.now js/Date))
+                               (dispatch! {:type "setTarget"
+                                           :target normalized
+                                           :mode @mode-atom})))
+            :resetToNeutral (fn
+                              ([] (dispatch! {:type "reset"}))
+                              ([duration-ms]
+                               (dispatch! {:type "reset" :durationMs duration-ms})))
+            :blink (fn []
+                     (when-not @disposed?
+                       (let [snippet (create-blink-snippet)]
+                         (swap! state-atom assoc :lastBlinkTime (.now js/Date))
+                         (schedule-animation! anim snippet {:autoPlay true
+                                                           :sourceAgency "eyeHeadTracking"}))))
+            :setSpeaking (fn [is-speaking]
+                           (swap! state-atom assoc :isSpeaking (boolean is-speaking))
+                           (if is-speaking
+                             (js-call callbacks "onHeadStart")
+                             (js-call callbacks "onHeadStop")))
+            :setListening (fn [is-listening]
+                            (swap! state-atom assoc :isListening (boolean is-listening))
+                            (if is-listening
+                              (js-call callbacks "onEyeStart")
+                              (js-call callbacks "onEyeStop")))
+            :setEyeBlendWeight (fn [_value] nil)
+            :setHeadBlendWeight (fn [_value] nil)
+            :updateConfig configure!
+            :getState (fn [] (service-state state-atom mode-atom))
+            :getMachineContext (fn []
+                                 #js {:config (clj->js @config-atom)
+                                      :mode @mode-atom
+                                      :target (clj->js (:currentTarget @state-atom))
+                                      :lastApplied (clj->js (:currentTarget @state-atom))
+                                      :status #js {:eye (if (:eyeTrackingEnabled @config-atom) "tracking" "idle")
+                                                   :head (if (:headTrackingEnabled @config-atom) "tracking" "idle")}})
+            :getSnippets (fn [] #js {:eye (js/Map.) :head (js/Map.)})
+            :setMode (fn [mode]
+                       (reset! mode-atom mode)
+                       (dispatch! {:type "configure" :config {:mode mode}}))
+            :getMode (fn [] @mode-atom)
+            :subscribeToWebcam (fn [_callback] (fn [] nil))
+            :getWebcamVideoElement (fn [] nil)
+            :isWebcamActive (fn [] false)
+            :dispose (fn []
+                       (when-not @disposed?
+                         (reset! disposed? true)
+                         (teardown!)
+                         (js-call agency "dispose")))}))))

package/src/polymer/eye_head/snippet.cljs

@@ -0,0 +1,92 @@
+(ns polymer.eye-head.snippet)
+
+;; Eye/Head snippets use typed AU channels. Numeric curve keys remain for
+;; compatibility with older animation builds, while typed channels are the
+;; canonical contract for the current Animation agency.
+
+(def eye-yaw-left 61)
+(def eye-yaw-right 62)
+(def eye-pitch-up 63)
+(def eye-pitch-down 64)
+(def head-yaw-left 51)
+(def head-yaw-right 52)
+(def head-pitch-up 53)
+(def head-pitch-down 54)
+(def head-roll-left 55)
+(def head-roll-right 56)
+
+(defn seconds
+  [duration-ms]
+  (/ (max 1 duration-ms) 1000))
+
+(defn axis-curves
+  [negative-au positive-au value duration-sec]
+  (let [value (max -1 (min 1 value))
+        negative-value (if (neg? value) (js/Math.abs value) 0)
+        positive-value (if (pos? value) value 0)]
+    {(str negative-au) [{:time 0 :intensity 0 :inherit true}
+                        {:time duration-sec :intensity negative-value}]
+     (str positive-au) [{:time 0 :intensity 0 :inherit true}
+                        {:time duration-sec :intensity positive-value}]}))
+
+(defn au-channel
+  [au-id curve]
+  {:target {:type "au" :id au-id}
+   :keyframes curve})
+
+(defn curves->channels
+  [curves]
+  (into []
+        (map (fn [[au-id curve]]
+               (au-channel (js/parseInt au-id 10) curve)))
+        curves))
+
+(defn merge-curves
+  [& curve-maps]
+  (apply merge curve-maps))
+
+(defn build-eye-curves
+  [request]
+  (let [target (:target request)
+        duration-sec (seconds (:eyeDurationMs request))
+        yaw (* (:x target) (:eyeIntensity request))
+        pitch (* (:y target) (:eyeIntensity request))]
+    (merge-curves
+     (axis-curves eye-yaw-left eye-yaw-right yaw duration-sec)
+     (axis-curves eye-pitch-down eye-pitch-up pitch duration-sec))))
+
+(defn build-head-curves
+  [request]
+  (let [target (:target request)
+        duration-sec (seconds (:headDurationMs request))
+        yaw (* (:x target) (:headIntensity request))
+        pitch (* (:y target) (:headIntensity request))
+        roll (* (:headRoll request) (:headIntensity request))]
+    (merge-curves
+     (axis-curves head-yaw-left head-yaw-right yaw duration-sec)
+     (axis-curves head-pitch-down head-pitch-up pitch duration-sec)
+     (axis-curves head-roll-left head-roll-right roll duration-sec))))
+
+(defn build-gaze-snippet
+  [request config]
+  (let [eye-curves (when (:eyeEnabled request) (build-eye-curves request))
+        head-curves (when (and (:headEnabled request) (:headFollowEyes request))
+                      (build-head-curves request))
+        curves (merge-curves (or eye-curves {}) (or head-curves {}))
+        channels (curves->channels curves)
+        max-time (max (seconds (:eyeDurationMs request))
+                      (seconds (:headDurationMs request)))]
+    {:name (str "eyeHeadTracking:gaze:" (:requestId request))
+     :curves curves
+     :channels channels
+     :maxTime max-time
+     :loop false
+     :mixerClampWhenFinished true
+     :snippetPriority (:snippetPriority config)
+     :snippetPlaybackRate 1.0
+     :snippetIntensityScale 1.0
+     :metadata {:agency "eyeHeadTracking"
+                :sourceAgency (:sourceAgency request)
+                :requestId (:requestId request)
+                :mode (:mode request)
+                :target (:target request)}}))

package/src/polymer/eye_head/state.cljs

@@ -0,0 +1,167 @@
+(ns polymer.eye-head.state
+  (:require [polymer.eye-head.domain :as domain]))
+
+;; Eye/Head state tracks the local movement schedule. Runtime handles remain
+;; private to the Animation agency; this agency only records plain request and
+;; snippet metadata.
+
+(def default-config
+  {:enabled true
+   :eyeTrackingEnabled true
+   :headTrackingEnabled true
+   :headFollowEyes true
+   :eyeIntensity 1.0
+   :headIntensity 0.5
+   :headRoll 0
+   :eyePriority 20
+   :headPriority 15
+   :snippetPriority 20
+   :transitionDurationMs 240
+   :returnToCenterDurationMs 300
+   :coalesceMs 0
+   :replaceExisting true})
+
+(defn input-value
+  [input camel-key kebab-key fallback]
+  (let [camel (get input camel-key ::missing)
+        kebab (get input kebab-key ::missing)]
+    (cond
+      (not= camel ::missing) camel
+      (not= kebab ::missing) kebab
+      :else fallback)))
+
+(defn normalize-config
+  [config]
+  (let [input (merge default-config (domain/data-map config))]
+    {:enabled (boolean (input-value input :enabled :enabled (:enabled default-config)))
+     :eyeTrackingEnabled (boolean (input-value input :eyeTrackingEnabled :eye-tracking-enabled (:eyeTrackingEnabled default-config)))
+     :headTrackingEnabled (boolean (input-value input :headTrackingEnabled :head-tracking-enabled (:headTrackingEnabled default-config)))
+     :headFollowEyes (boolean (input-value input :headFollowEyes :head-follow-eyes (:headFollowEyes default-config)))
+     :eyeIntensity (domain/clamp 0 2
+                                  (domain/number-or (input-value input :eyeIntensity :eye-intensity nil)
+                                                    (:eyeIntensity default-config)))
+     :headIntensity (domain/clamp 0 2
+                                   (domain/number-or (input-value input :headIntensity :head-intensity nil)
+                                                     (:headIntensity default-config)))
+     :headRoll (domain/clamp -1 1
+                             (domain/number-or (input-value input :headRoll :head-roll nil)
+                                               (:headRoll default-config)))
+     :eyePriority (int (domain/clamp 0 100
+                                     (domain/number-or (input-value input :eyePriority :eye-priority nil)
+                                                       (:eyePriority default-config))))
+     :headPriority (int (domain/clamp 0 100
+                                      (domain/number-or (input-value input :headPriority :head-priority nil)
+                                                        (:headPriority default-config))))
+     :snippetPriority (int (domain/clamp 0 100
+                                         (domain/number-or (input-value input :snippetPriority :snippet-priority nil)
+                                                           (:snippetPriority default-config))))
+     :transitionDurationMs (int (domain/clamp 50 3000
+                                              (domain/number-or
+                                               (input-value input :transitionDurationMs :transition-duration-ms nil)
+                                               (:transitionDurationMs default-config))))
+     :returnToCenterDurationMs (int (domain/clamp 50 3000
+                                                  (domain/number-or
+                                                   (input-value input :returnToCenterDurationMs :return-to-center-duration-ms nil)
+                                                   (:returnToCenterDurationMs default-config))))
+     :coalesceMs (int (domain/clamp 0 1000
+                                    (domain/number-or (input-value input :coalesceMs :coalesce-ms nil)
+                                                      (:coalesceMs default-config))))
+     :replaceExisting (boolean (input-value input :replaceExisting :replace-existing (:replaceExisting default-config)))}))
+
+(defn default-state
+  [config]
+  {:agency "eyeHeadTracking"
+   :status "idle"
+   :mode "manual"
+   :currentTarget domain/zero-target
+   :pendingRequest nil
+   :lastRequest nil
+   :lastSnippet nil
+   :activeSnippetNames []
+   :lastIgnored nil
+   :lastPlan nil
+   :scheduledCount 0
+   :removedCount 0
+   :resetCount 0
+   :cancelCount 0
+   :ignoredCount 0
+   :config (normalize-config config)})
+
+(defn config->state
+  [config]
+  (default-state config))
+
+(defn visible-state
+  [state]
+  (clj->js state))
+
+(defn configure
+  [state config]
+  (assoc state :config (normalize-config (merge (:config state)
+                                                (domain/data-map config)))))
+
+(defn set-enabled
+  [state enabled]
+  (assoc-in state [:config :enabled] (boolean enabled)))
+
+(defn record-plan
+  [state plan]
+  (assoc state :lastPlan plan))
+
+(defn record-pending
+  [state request]
+  (assoc state
+         :status "pending"
+         :pendingRequest request))
+
+(defn record-scheduled
+  [state request snippet published-at]
+  (-> state
+      (assoc :status "tracking"
+             :mode (:mode request)
+             :currentTarget (:target request)
+             :pendingRequest nil
+             :lastRequest request
+             :lastSnippet snippet
+             :activeSnippetNames [(:name snippet)]
+             :lastPlan nil
+             :lastEvent {:type "animation.requestScheduleSnippet"
+                         :name (:name snippet)
+                         :requestId (:requestId request)
+                         :at published-at})
+      (update :scheduledCount inc)))
+
+(defn record-removed
+  [state name reason removed-at]
+  (-> state
+      (assoc :activeSnippetNames []
+             :lastEvent {:type "animation.requestRemoveSnippet"
+                         :name name
+                         :reason reason
+                         :at removed-at})
+      (update :removedCount inc)))
+
+(defn record-ignored
+  [state ignored]
+  (-> state
+      (assoc :status "ignored"
+             :lastIgnored ignored
+             :pendingRequest nil
+             :lastEvent ignored)
+      (update :ignoredCount inc)))
+
+(defn record-reset
+  [state request snippet published-at]
+  (-> (record-scheduled state request snippet published-at)
+      (assoc :status "reset"
+             :currentTarget domain/zero-target)
+      (update :resetCount inc)))
+
+(defn record-cancel
+  [state request]
+  (-> state
+      (assoc :status "cancelled"
+             :pendingRequest nil
+             :activeSnippetNames []
+             :lastEvent request)
+      (update :cancelCount inc)))

package/src/polymer/gaze/agency.cljs

@@ -0,0 +1,85 @@
+(ns polymer.gaze.agency
+  (:require [polymer.gaze.domain :as domain]
+            [polymer.gaze.goap :as goap]
+            [polymer.gaze.scheduler :as scheduler]
+            [polymer.gaze.state :as state]
+            [polymer.stream :as stream]))
+
+;; Gaze converts attention and camera-relative facts into look-intent requests.
+;; It does not move eyes or head directly. The downstream movement agency owns
+;; the runtime side effects after accepting these request messages.
+
+(defn now-ms
+  []
+  (.now js/Date))
+
+(defn create-gaze-agency
+  [config]
+  (let [input-stream (stream/create-stream)
+        event-stream (stream/create-stream)
+        state-atom (atom (state/config->state config))
+        disposed? (atom false)
+        emit-input (:emit input-stream)
+        emit-event (:emit event-stream)
+        scheduler-atom (atom nil)]
+    (letfn [(dispatch! [command]
+              (when-not @disposed?
+                (let [payload (domain/data-map command)
+                      plan (goap/plan-command payload @state-atom (now-ms))]
+                  (emit-input {:type "command"
+                               :agency "gaze"
+                               :command payload})
+                  (swap! state-atom assoc :lastPlan plan)
+                  (when-let [agency-scheduler @scheduler-atom]
+                    ((:schedule agency-scheduler) plan)))))
+
+            (dispatch-type! [type]
+              (dispatch! #js {:type type}))]
+      (let [agency-scheduler (scheduler/create-scheduler
+                              {:state-atom state-atom
+                               :emit-event emit-event})]
+        (reset! scheduler-atom agency-scheduler)
+        #js {:dispatch dispatch!
+             :snapshot (fn [] (state/visible-state @state-atom))
+             :input (stream/writable-port input-stream dispatch!)
+             :events (stream/readable-port event-stream)
+             :subscribeInput (fn [listener] ((:subscribe input-stream) listener))
+             :subscribeEvents (fn [listener] ((:subscribe event-stream) listener))
+             :subscribe (fn [listener] ((:subscribe event-stream) listener))
+             :subscribeStatus (fn [listener] ((:subscribe event-stream) listener))
+             :setTarget (fn
+                          ([target] (dispatch! #js {:type "setTarget"
+                                                    :target target}))
+                          ([target options] (dispatch! #js {:type "setTarget"
+                                                            :target target
+                                                            :options options})))
+             :focusTarget (fn [target] (dispatch! #js {:type "focusTarget"
+                                                       :target target}))
+             :configure (fn [config] (dispatch! #js {:type "configure"
+                                                     :config config}))
+             :setMode (fn [mode] (dispatch! #js {:type "setMode"
+                                                 :mode mode}))
+             :setActive (fn [active] (dispatch! #js {:type "setActive"
+                                                     :active active}))
+             :enable (fn [] (dispatch-type! "enable"))
+             :disable (fn [] (dispatch-type! "disable"))
+             :reset (fn
+                      ([] (dispatch-type! "reset"))
+                      ([duration-ms] (dispatch! #js {:type "reset"
+                                                     :durationMs duration-ms})))
+             :cancel (fn
+                       ([] (dispatch-type! "cancel"))
+                       ([reason] (dispatch! #js {:type "cancel"
+                                                 :reason reason})))
+             :flush (fn []
+                      (when-let [agency-scheduler @scheduler-atom]
+                        ((:flush agency-scheduler))))
+             :queue (fn []
+                      (when-let [agency-scheduler @scheduler-atom]
+                        (clj->js ((:queue agency-scheduler)))))
+             :dispose (fn []
+                        (when-not @disposed?
+                          (reset! disposed? true)
+                          ((:dispose agency-scheduler))
+                          ((:dispose input-stream))
+                          ((:dispose event-stream))))}))))