@lovelace_lol/polymer 0.0.6 → 0.0.8

package/src/polymer/gaze/state.cljs

@@ -1,202 +0,0 @@
-(ns polymer.gaze.state
-  (:require [polymer.gaze.domain :as domain]))
-
-;; Gaze state is a local ledger of attention targets and accepted look requests.
-;; It is serializable diagnostic data; high-frequency eye/head execution belongs
-;; in the downstream movement agency that consumes Gaze requests.
-
-(def default-config
-  {:enabled true
-   :eyesEnabled true
-   :headEnabled true
-   :headFollowEyes true
-   :mirrored false
-   :smoothFactor 0.25
-   :minDelta 0.01
-   :transitionDurationMs 300
-   :eyeIntensity 1.0
-   :headIntensity 0.5
-   :coalesceMs 16})
-
-(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)))
-     :eyesEnabled (boolean (input-value input :eyesEnabled :eyes-enabled (:eyesEnabled default-config)))
-     :headEnabled (boolean (input-value input :headEnabled :head-enabled (:headEnabled default-config)))
-     :headFollowEyes (boolean (input-value input :headFollowEyes :head-follow-eyes (:headFollowEyes default-config)))
-     :mirrored (boolean (input-value input :mirrored :mirrored (:mirrored default-config)))
-     :smoothFactor (domain/clamp 0 1
-                                 (domain/number-or (input-value input :smoothFactor :smooth-factor nil)
-                                                   (:smoothFactor default-config)))
-     :minDelta (domain/clamp 0 1
-                             (domain/number-or (input-value input :minDelta :min-delta nil)
-                                               (:minDelta default-config)))
-     :transitionDurationMs (int (domain/clamp 50 3000
-                                              (domain/number-or
-                                               (input-value input :transitionDurationMs :transition-duration-ms nil)
-                                               (:transitionDurationMs 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)))
-     :coalesceMs (int (domain/clamp 0 1000
-                                    (domain/number-or (input-value input :coalesceMs :coalesce-ms nil)
-                                                      (:coalesceMs default-config))))}))
-
-(defn default-state
-  [config]
-  {:agency "gaze"
-   :status "idle"
-   :mode "manual"
-   :active false
-   :rawTarget domain/zero-target
-   :target domain/zero-target
-   :baseTarget domain/zero-target
-   :cameraRelativeOffset domain/zero-target
-   :lastCameraFact nil
-   :lastRequestedTarget domain/zero-target
-   :pendingRequest nil
-   :lastRequest nil
-   :lastIgnored nil
-   :lastPlan nil
-   :lastEvent nil
-   :receivedCount 0
-   :plannedCount 0
-   :requestedCount 0
-   :ignoredCount 0
-   :resetCount 0
-   :cancelCount 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 reset-state
-  [state]
-  (default-state (:config state)))
-
-(defn set-mode
-  [state mode now-ms]
-  (assoc state
-         :mode (or mode "manual")
-         :lastEvent {:type "gaze.status"
-                     :status (:status state)
-                     :mode (or mode "manual")
-                     :at now-ms}))
-
-(defn set-active
-  [state active now-ms]
-  (assoc state
-         :active (boolean active)
-         :lastEvent {:type "gaze.status"
-                     :status (:status state)
-                     :active (boolean active)
-                     :at now-ms}))
-
-(defn set-enabled
-  [state enabled now-ms]
-  (assoc-in (assoc state
-                   :lastEvent {:type "gaze.status"
-                               :status (if enabled "enabled" "disabled")
-                               :at now-ms})
-            [:config :enabled]
-            (boolean enabled)))
-
-(defn record-plan
-  [state plan]
-  (-> state
-      (assoc :status "planning"
-             :rawTarget (:rawTarget plan)
-             :target (:target plan)
-             :baseTarget (or (:baseTarget plan) (:target plan))
-             :cameraRelativeOffset (or (:cameraRelativeOffset plan)
-                                       (:cameraRelativeOffset state))
-             :lastCameraFact (or (:cameraFact plan)
-                                 (:lastCameraFact state))
-             :lastPlan plan
-             :lastEvent {:type "gaze.targetPlanned"
-                         :requestId (:requestId plan)
-                         :at (:createdAt plan)})
-      (update :receivedCount inc)
-      (update :plannedCount inc)))
-
-(defn record-pending
-  [state request]
-  (assoc state
-         :status "pending"
-         :pendingRequest request
-         :lastEvent {:type "gaze.requestQueued"
-                     :requestId (:requestId request)
-                     :at (:queuedAt request)}))
-
-(defn record-requested
-  [state request published-at]
-  (-> state
-      (assoc :status "requested"
-             :pendingRequest nil
-             :lastRequest (assoc request :publishedAt published-at)
-             :lastRequestedTarget (:target request)
-             :lastEvent {:type "eyeHeadTracking.requestGaze"
-                         :requestId (:requestId request)
-                         :at published-at})
-      (update :requestedCount inc)))
-
-(defn record-ignored
-  [state ignored]
-  (-> state
-      (assoc :status "ignored"
-             :lastIgnored ignored
-             :lastEvent {:type "gaze.targetIgnored"
-                         :reason (:reason ignored)
-                         :requestId (:requestId ignored)
-                         :at (:ignoredAt ignored)})
-      (update :ignoredCount inc)))
-
-(defn record-reset
-  [state request]
-  (-> state
-      (assoc :status "reset"
-             :rawTarget domain/zero-target
-             :target domain/zero-target
-             :baseTarget domain/zero-target
-             :cameraRelativeOffset domain/zero-target
-             :lastCameraFact nil
-             :lastRequestedTarget domain/zero-target
-             :pendingRequest nil
-             :lastRequest request
-             :lastEvent {:type "eyeHeadTracking.requestReset"
-                         :requestId (:requestId request)
-                         :at (:requestedAt request)})
-      (update :resetCount inc)))
-
-(defn record-cancel
-  [state request]
-  (-> state
-      (assoc :status "cancelled"
-             :pendingRequest nil
-             :lastEvent {:type "eyeHeadTracking.requestCancel"
-                         :requestId (:requestId request)
-                         :at (:requestedAt request)})
-      (update :cancelCount inc)))

package/src/polymer/gesture/agency.cljs

@@ -1,185 +0,0 @@
-(ns polymer.gesture.agency
-  (:require [polymer.gesture.goap :as goap]
-            [polymer.gesture.scheduler :as scheduler]
-            [polymer.gesture.snippet :as snippet]
-            [polymer.gesture.state :as state]
-            [polymer.stream :as stream]))
-
-;; Gesture consumes authored arm/hand gesture snapshots and emits animation
-;; intent. It does not own host persistence, host UI state, scene bones, or the
-;; animation runtime.
-
-(defn js-command [type value]
-  #js {:type type :value value})
-
-(defn plan-error-message [plan]
-  (let [step (or (some #(when (= "fail" (:op %)) %) (:steps plan))
-                 (first (:steps plan)))]
-    (case (:reason step)
-      "unsupported-command" (str "Gesture plan failed: unsupported command " (:commandType step))
-      "missing-emoji" "Gesture playEmoji command requires emoji"
-      "missing-gesture" "Gesture command requires gestureId"
-      "missing-goal" "Gesture goal command requires a gesture goal, intent, tag, scope, emoji, or effector constraint"
-      "unknown-gesture" (str "Unknown gesture: " (:gestureId step))
-      "gesture-has-no-motion" (str "Gesture has no bone motion: " (:gestureId step))
-      "empty-library" "Gesture plan failed: gesture library is empty"
-      "no-gesture-candidate" "Gesture plan failed: no gesture matched the goal"
-      (str "Gesture plan failed: " (:reason step)))))
-
-(defn should-emit-plan? [plan]
-  (or (false? (:ok plan))
-      (not (:noop plan))
-      (contains? goap/playable-command-types (get-in plan [:goal :type]))))
-
-(defn public-plan [plan]
-  (-> plan
-      (dissoc :gesture)
-      (update :goal dissoc :gesture :activeSnippets :config)))
-
-(defn create-gesture-agency [config]
-  (let [input-stream (stream/create-stream)
-        event-stream (stream/create-stream)
-        state-atom (atom (state/config->state config))
-        disposed? (atom false)
-        agency-scheduler (atom nil)
-        emit-input (:emit input-stream)
-        emit-event (:emit event-stream)]
-    (letfn [(complete-active! [name]
-              (when (get-in @state-atom [:activeSnippets name])
-                (remove-active! [name] "completed")))
-
-            (emit-plan! [plan]
-              (when (should-emit-plan? plan)
-                (emit-event {:type "gesturePlanCreated"
-                             :agency "gesture"
-                             :plan (public-plan plan)})))
-
-            (remove-active! [names reason]
-              (let [removed-at (state/now-ms)]
-                ((:remove-many @agency-scheduler) names reason)
-                (doseq [name names]
-                  (swap! state-atom state/record-remove name reason removed-at)
-                  (emit-event {:type "gestureRemoved"
-                               :agency "gesture"
-                               :name name
-                               :reason reason
-                               :removedAt removed-at}))))
-
-            (schedule-gesture! [gesture context]
-              (let [context (or context {})
-                    snippet-data (snippet/build-gesture-snippet gesture
-                                                                (:config @state-atom)
-                                                                context)]
-                (if snippet-data
-                  (do
-                    ((:schedule @agency-scheduler) snippet-data {:autoPlay true})
-                    (let [scheduled-at (state/now-ms)]
-                      (swap! state-atom state/record-schedule gesture snippet-data scheduled-at)
-                      (emit-event {:type "gestureScheduled"
-                                   :agency "gesture"
-                                   :gestureId (:id gesture)
-                                   :gestureName (:name gesture)
-                                   :emoji (:emoji gesture)
-                                   :scope (:scope gesture)
-                                   :affectedBones (:affectedBones gesture)
-                                   :name (:name snippet-data)
-                                   :trigger (:trigger context)
-                                   :intent (:intent context)
-                                   :scheduledAt scheduled-at}))
-                    snippet-data)
-                  (emit-event {:type "error"
-                               :agency "gesture"
-                               :message (str "Gesture produced no animation channels: " (:id gesture))}))))
-
-            (dispatch! [command]
-              (when-not @disposed?
-                (let [payload (state/js-data command)
-                      type (:type payload)
-                      now (state/now-ms)
-                      plan (goap/plan-command payload @state-atom now)]
-                  (emit-input {:type "command"
-                               :agency "gesture"
-                               :command payload})
-                  (emit-plan! plan)
-                  (if (false? (:ok plan))
-                    (emit-event {:type "error"
-                                 :agency "gesture"
-                                 :message (plan-error-message plan)})
-                    (case type
-                      "configure"
-                      (do
-                        (swap! state-atom state/configure (:config payload))
-                        (emit-event {:type "gestureConfigChanged"
-                                     :agency "gesture"
-                                     :state (state/visible-state-map @state-atom)}))
-
-                      "loadGestures"
-                      (let [loaded-at (state/now-ms)]
-                        (swap! state-atom state/load-gestures
-                               (or (:gestures payload)
-                                   (:characterGestures payload)
-                                   (:gestureLibrary payload))
-                               (or (:emojiMappings payload) (:gestureEmojiMappings payload))
-                               loaded-at)
-                        (emit-event {:type "gestureLibraryUpdated"
-                                     :agency "gesture"
-                                     :gestureCount (count (:gestures @state-atom))
-                                     :emojiCount (count (:emojiMappings @state-atom))
-                                     :updatedAt loaded-at}))
-
-                      ("playGesture" "playEmoji" "gesture.goal" "performGestureGoal" "playGoal")
-                      (when-not (:noop plan)
-                        (doseq [step (:steps plan)]
-                          (when (= "remove-active-gestures" (:op step))
-                            (remove-active! (:names step) (:reason step))))
-                        (schedule-gesture! (:gesture plan) (merge payload (:context plan))))
-
-                      "stopGesture"
-                      (remove-active! (:removeNames plan) (:removeReason plan))
-
-                      "stopAll"
-                      (remove-active! (:removeNames plan) (:removeReason plan))
-
-                      "reset"
-                      (do
-                        (remove-active! (:removeNames plan) (:removeReason plan))
-                        (reset! state-atom (state/config->state nil))
-                        (emit-event {:type "gestureConfigChanged"
-                                     :agency "gesture"
-                                     :state (state/visible-state-map @state-atom)}))
-
-                      (emit-event {:type "error"
-                                   :agency "gesture"
-                                   :message (str "Unknown Gesture command: " type)}))))))]
-      (reset! agency-scheduler
-              (scheduler/create-scheduler
-               {:emit-event emit-event
-                :on-complete complete-active!}))
-      #js {:dispatch dispatch!
-           :snapshot (fn [] (state/visible-state @state-atom))
-           :schedulerQueue (fn [] (clj->js ((:queue @agency-scheduler))))
-           :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))
-           :configure (fn [next-config] (dispatch! #js {:type "configure" :config next-config}))
-           :loadGestures (fn
-                           ([gestures] (dispatch! #js {:type "loadGestures" :gestures gestures}))
-                           ([gestures emoji-mappings]
-                            (dispatch! #js {:type "loadGestures"
-                                            :gestures gestures
-                                            :emojiMappings emoji-mappings})))
-           :playGesture (fn [gesture-id] (dispatch! #js {:type "playGesture" :gestureId gesture-id}))
-           :playEmoji (fn [emoji] (dispatch! #js {:type "playEmoji" :emoji emoji}))
-           :performGoal (fn [goal] (dispatch! #js {:type "gesture.goal" :goal goal}))
-           :stopGesture (fn [gesture-id] (dispatch! #js {:type "stopGesture" :gestureId gesture-id}))
-           :stopAll (fn [] (dispatch! #js {:type "stopAll"}))
-           :reset (fn [] (dispatch! #js {:type "reset"}))
-           :dispose (fn []
-                      (when-not @disposed?
-                        (reset! disposed? true)
-                        ((:dispose @agency-scheduler))
-                        ((:dispose input-stream))
-                        ((:dispose event-stream))))})))