@lovelace_lol/polymer 0.0.7 → 0.0.9

package/src/polymer/eye_head/service.cljs

@@ -1,259 +0,0 @@
-(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

@@ -1,92 +0,0 @@
-(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

@@ -1,167 +0,0 @@
-(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

@@ -1,85 +0,0 @@
-(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))))}))))