@lovelace_lol/polymer 0.0.1

package/src/polymer/gaze/domain.cljs

@@ -0,0 +1,211 @@
+(ns polymer.gaze.domain)
+
+;; Gaze domain code is pure data transformation. It turns outside facts and
+;; goals into normalized targets and scores, but it never schedules work or
+;; talks to an animation/runtime API.
+
+(def zero-target {:x 0 :y 0 :z 0})
+
+(defn finite-number?
+  [value]
+  (and (number? value) (js/isFinite value)))
+
+(defn number-or
+  [value fallback]
+  (if (finite-number? value) value fallback))
+
+(defn clamp
+  [lo hi value]
+  (min hi (max lo value)))
+
+(defn data-map
+  [value]
+  (cond
+    (map? value) value
+    value (js->clj value :keywordize-keys true)
+    :else {}))
+
+(defn normalize-target
+  ([value] (normalize-target value zero-target))
+  ([value fallback]
+   (let [input (data-map value)
+         fallback (merge zero-target fallback)]
+     {:x (clamp -1 1 (number-or (:x input) (:x fallback)))
+      :y (clamp -1 1 (number-or (:y input) (:y fallback)))
+      :z (number-or (:z input) (:z fallback))})))
+
+(defn add-targets
+  [base offset]
+  {:x (clamp -1 1 (+ (:x base) (:x offset)))
+   :y (clamp -1 1 (+ (:y base) (:y offset)))
+   :z (number-or (:z base) 0)})
+
+(defn target-distance
+  [a b]
+  (js/Math.hypot (- (:x a) (:x b))
+                 (- (:y a) (:y b))))
+
+(defn mirror-target
+  [target mirrored?]
+  (if mirrored?
+    (update target :x -)
+    target))
+
+(defn smooth-alpha
+  [distance smooth-factor]
+  ;; This follows the Latticework experimental behavior: smoothFactor 1 means
+  ;; immediate target adoption, while lower values ease toward distant targets
+  ;; without letting a single update jump too far.
+  (let [base (max 0 smooth-factor)]
+    (if (>= base 1)
+      1
+      (min 0.7 (+ base (* distance 0.25))))))
+
+(defn smooth-target
+  [previous raw-target smooth-factor]
+  (let [distance (target-distance raw-target previous)
+        alpha (smooth-alpha distance smooth-factor)]
+    {:x (+ (:x previous) (* (- (:x raw-target) (:x previous)) alpha))
+     :y (+ (:y previous) (* (- (:y raw-target) (:y previous)) alpha))
+     :z (:z raw-target)}))
+
+(defn movement-duration-ms
+  [base-ms delta scale minimum-ms]
+  (int (js/Math.round (max minimum-ms (* base-ms (+ scale delta))))))
+
+(defn plan-target
+  [target previous-target config options now-ms]
+  (let [raw-target (mirror-target (normalize-target target) (:mirrored config))
+        smoothed-target (smooth-target previous-target
+                                       raw-target
+                                       (:smoothFactor config))
+        delta (target-distance smoothed-target previous-target)
+        force? (boolean (:force options))
+        base-duration (max 50 (:transitionDurationMs config))
+        eye-duration (movement-duration-ms base-duration delta 0.4 50)
+        head-duration (movement-duration-ms base-duration delta 0.6 80)]
+    {:agency "gaze"
+     :rawTarget raw-target
+     :target smoothed-target
+     :previousTarget previous-target
+     :delta delta
+     :accepted (or force? (>= delta (:minDelta config)))
+     :force force?
+     :eyeDurationMs eye-duration
+     :headDurationMs head-duration
+     :createdAt now-ms}))
+
+(defn candidate-target
+  [candidate]
+  (let [candidate (data-map candidate)]
+    (or (:target candidate)
+        (:gazeTarget candidate)
+        (:lookTarget candidate)
+        (when (or (contains? candidate :x)
+                  (contains? candidate :y))
+          candidate))))
+
+(defn candidate-score
+  [candidate]
+  (let [candidate (data-map candidate)]
+    (+ (number-or (:priority candidate) 0)
+       (number-or (:weight candidate) 0)
+       (number-or (:confidence candidate) 0))))
+
+(defn normalize-attention-candidate
+  [index candidate]
+  (when-let [target (candidate-target candidate)]
+    (let [candidate (data-map candidate)]
+      {:target (normalize-target target)
+       :source (or (:source candidate) (:agency candidate) "attention")
+       :label (or (:label candidate) (:id candidate) (str "candidate-" index))
+       :score (candidate-score candidate)
+       :priority (number-or (:priority candidate) 0)
+       :weight (number-or (:weight candidate) 0)
+       :confidence (number-or (:confidence candidate) 0)})))
+
+(defn attention-candidates
+  [payload]
+  (let [payload (data-map payload)
+        targets (:targets payload)]
+    (cond
+      (sequential? targets) targets
+      (:target payload) [payload]
+      :else [])))
+
+(defn choose-attention-target
+  [payload]
+  ;; A transducer is useful here because candidate extraction is a pure
+  ;; map/filter/reduce pipeline. The planner receives only the winning target
+  ;; fact instead of open-coding selection logic around scheduler state.
+  (let [candidates (attention-candidates payload)
+        normalized (into []
+                         (comp (map-indexed normalize-attention-candidate)
+                               (filter some?))
+                         candidates)]
+    (when (seq normalized)
+      (apply max-key :score normalized))))
+
+(def conversation-attention-policy
+  ;; Gaze owns conversation look-intent policy. The character network only
+  ;; forwards conversation.* facts; it must not invent geometry or options.
+  {"conversation.userUtterance" {:target {:x 0 :y 0.08 :z 0}
+                                 :priority 0.25
+                                 :confidence 0.5
+                                 :label "conversation-user"
+                                 :options {:eyeEnabled true
+                                           :headEnabled false}}
+   "conversation.agentUtterance" {:target {:x 0 :y 0.04 :z 0}
+                                  :priority 0.2
+                                  :confidence 0.4
+                                  :label "conversation-agent"
+                                  :options {:eyeEnabled true
+                                            :headEnabled false}}})
+
+(defn conversation-attention-command
+  [command]
+  (let [payload (data-map command)
+        type (:type payload)
+        policy (get conversation-attention-policy type)]
+    (when policy
+      {:type "attention.fact"
+       :source "conversation"
+       :turnId (:turnId payload)
+       :text (:text payload)
+       :options (:options policy)
+       :targets [(assoc (select-keys policy [:target :priority :confidence :label])
+                        :source "conversation")]})))
+
+(defn command-target
+  [command]
+  (let [payload (data-map command)
+        type (:type payload)]
+    (case type
+      "attention.fact"
+      (choose-attention-target payload)
+
+      ("conversation.userUtterance" "conversation.agentUtterance")
+      (when-let [attention (conversation-attention-command payload)]
+        (choose-attention-target attention))
+
+      "camera.fact"
+      (when-let [offset (:relativeOffset payload)]
+        {:target (normalize-target offset)
+         :source (or (:source payload) "cameraContext")
+         :label "camera-relative-offset"
+         :score 0.4})
+
+      ("camera.stale" "clearCameraOffset")
+      {:target zero-target
+       :source (or (:source payload) "cameraContext")
+       :label "camera-relative-clear"
+       :score 0.4}
+
+      (when-let [target (or (:target payload)
+                            (:gazeTarget payload)
+                            (:lookTarget payload)
+                            (:value payload))]
+        {:target (normalize-target target)
+         :source (or (:source payload) "command")
+         :label (or (:label payload) "direct")
+         :score (number-or (:priority payload) 0)}))))

package/src/polymer/gaze/goap.cljs

@@ -0,0 +1,208 @@
+(ns polymer.gaze.goap
+  (:require [polymer.gaze.domain :as domain]))
+
+;; The Gaze planner is local GOAP-style decision logic. It decides whether a
+;; target fact should become a look request, but it does not publish streams or
+;; mutate scheduler queues.
+
+(def supported-command-types
+  #{"configure"
+    "setMode"
+    "set-mode"
+    "setActive"
+    "set-active"
+    "enable"
+    "disable"
+    "setTarget"
+    "set-target"
+    "focusTarget"
+    "attention.fact"
+    "conversation.userUtterance"
+    "conversation.agentUtterance"
+    "conversation.cancelRequested"
+    "camera.fact"
+    "camera.stale"
+    "clearCameraOffset"
+    "reset"
+    "cancel"})
+
+(defn command-type
+  [command]
+  (:type command))
+
+(defn request-id
+  [prefix now-ms]
+  (str prefix ":" now-ms ":" (rand-int 1000000)))
+
+(defn enabled-for-request?
+  [config options]
+  (and (:enabled config)
+       (or (if (contains? options :eyeEnabled)
+             (boolean (:eyeEnabled options))
+             (:eyesEnabled config))
+           (if (contains? options :headEnabled)
+             (boolean (:headEnabled options))
+             (:headEnabled config)))))
+
+(defn target-request
+  [plan state options source label]
+  {:type "eyeHeadTracking.requestGaze"
+   :agency "gaze"
+   :targetAgency "eyeHeadTracking"
+   :requestId (:requestId plan)
+   :source source
+   :label label
+   :mode (:mode state)
+   :target (:target plan)
+   :rawTarget (:rawTarget plan)
+   :previousTarget (:previousTarget plan)
+   :eyeEnabled (if (contains? options :eyeEnabled)
+                 (boolean (:eyeEnabled options))
+                 (get-in state [:config :eyesEnabled]))
+   :headEnabled (if (contains? options :headEnabled)
+                  (boolean (:headEnabled options))
+                  (get-in state [:config :headEnabled]))
+   :headFollowEyes (if (contains? options :headFollowEyes)
+                     (boolean (:headFollowEyes options))
+                     (get-in state [:config :headFollowEyes]))
+   :eyeIntensity (get-in state [:config :eyeIntensity])
+   :headIntensity (get-in state [:config :headIntensity])
+   :eyeDurationMs (:eyeDurationMs plan)
+   :headDurationMs (:headDurationMs plan)
+   :createdAt (:createdAt plan)})
+
+(defn target-steps
+  [command state now-ms]
+  (let [payload (domain/data-map command)
+        type (:type payload)
+        conversation-attention (when (#{"conversation.userUtterance"
+                                        "conversation.agentUtterance"}
+                                      type)
+                                 (domain/conversation-attention-command payload))
+        effective-payload (or conversation-attention payload)
+        options (domain/data-map (:options effective-payload))
+        target-fact (domain/command-target payload)
+        camera-command? (#{"camera.fact" "camera.stale" "clearCameraOffset"} type)]
+    (if-not target-fact
+      [{:op "fail"
+        :reason "missing-target"
+        :commandType type}]
+      (let [camera-offset (if camera-command?
+                            (:target target-fact)
+                            (:cameraRelativeOffset state))
+            base-target (if camera-command?
+                          (:baseTarget state)
+                          (:target target-fact))
+            adjusted-target (domain/add-targets base-target camera-offset)
+            plan (assoc (domain/plan-target adjusted-target
+                                            (:lastRequestedTarget state)
+                                            (:config state)
+                                            options
+                                            now-ms)
+                        :requestId (request-id "gaze" now-ms)
+                        :source (:source target-fact)
+                        :label (:label target-fact)
+                        :score (:score target-fact)
+                        :baseTarget base-target
+                        :cameraRelativeOffset camera-offset
+                        :cameraFact (when camera-command? payload))
+            request (target-request plan state options (:source target-fact) (:label target-fact))]
+        (cond
+          (not (enabled-for-request? (:config state) options))
+          [{:op "record-target" :plan plan}
+           {:op "publish-target-received" :plan plan}
+           {:op "ignore-target" :plan plan :reason "disabled"}]
+
+          (not (:accepted plan))
+          [{:op "record-target" :plan plan}
+           {:op "publish-target-received" :plan plan}
+           {:op "publish-target-planned" :plan plan}
+           {:op "ignore-target" :plan plan :reason "min-delta"}]
+
+          :else
+          [{:op "record-target" :plan plan}
+           {:op "publish-target-received" :plan plan}
+           {:op "publish-target-planned" :plan plan}
+           {:op "queue-request" :plan plan :request request}])))))
+
+(defn reset-steps
+  [command now-ms]
+  (let [payload (domain/data-map command)
+        request {:type "eyeHeadTracking.requestReset"
+                 :agency "gaze"
+                 :targetAgency "eyeHeadTracking"
+                 :requestId (request-id "gaze:reset" now-ms)
+                 :durationMs (domain/number-or (:durationMs payload)
+                                               (domain/number-or (:duration-ms payload) 300))
+                 :eyes (if (contains? payload :eyes) (boolean (:eyes payload)) true)
+                 :head (if (contains? payload :head) (boolean (:head payload)) true)
+                 :requestedAt now-ms}]
+    [{:op "request-reset" :request request}]))
+
+(defn cancel-steps
+  [command now-ms]
+  (let [payload (domain/data-map command)
+        request {:type "eyeHeadTracking.requestCancel"
+                 :agency "gaze"
+                 :targetAgency "eyeHeadTracking"
+                 :requestId (request-id "gaze:cancel" now-ms)
+                 :reason (or (:reason payload) "cancelled")
+                 :requestedAt now-ms}]
+    [{:op "request-cancel" :request request}]))
+
+(defn command-steps
+  [command state now-ms]
+  (let [type (command-type command)]
+    (cond
+      (not (contains? supported-command-types type))
+      [{:op "fail"
+        :reason "unsupported-command"
+        :commandType type}]
+
+      (= "configure" type)
+      [{:op "apply-config" :config (:config command)}
+       {:op "publish-status" :status (:status state) :reason "configured"}]
+
+      (#{"setMode" "set-mode"} type)
+      [{:op "set-mode" :mode (:mode command)}
+       {:op "publish-status" :status (:status state) :reason "mode"}]
+
+      (#{"setActive" "set-active"} type)
+      [{:op "set-active" :active (:active command)}
+       {:op "publish-status" :status (:status state) :reason "active"}]
+
+      (= "enable" type)
+      [{:op "set-enabled" :enabled true}
+       {:op "publish-status" :status "enabled" :reason "enabled"}]
+
+      (= "disable" type)
+      [{:op "set-enabled" :enabled false}
+       {:op "request-cancel"
+        :request {:type "eyeHeadTracking.requestCancel"
+                  :agency "gaze"
+                  :targetAgency "eyeHeadTracking"
+                  :requestId (request-id "gaze:disable" now-ms)
+                  :reason "disabled"
+                  :requestedAt now-ms}}
+       {:op "publish-status" :status "disabled" :reason "disabled"}]
+
+      (= "reset" type)
+      (reset-steps command now-ms)
+
+      (#{"cancel" "conversation.cancelRequested"} type)
+      (cancel-steps (cond-> command
+                      (= "conversation.cancelRequested" type)
+                      (assoc :reason (or (:reason command) "conversation-cancel")))
+                    now-ms)
+
+      :else
+      (target-steps command state now-ms))))
+
+(defn plan-command
+  [command state now-ms]
+  (let [steps (command-steps command state now-ms)]
+    {:agency "gaze"
+     :commandType (command-type command)
+     :createdAt now-ms
+     :ok (not= "fail" (:op (first steps)))
+     :steps steps}))

package/src/polymer/gaze/scheduler.cljs

@@ -0,0 +1,184 @@
+(ns polymer.gaze.scheduler
+  (:require [polymer.gaze.state :as state]))
+
+;; The Gaze scheduler owns ordering and coalescing for look requests. A burst of
+;; attention/camera updates should become one downstream request, not many
+;; overlapping eye/head movements.
+
+(defn now-ms
+  []
+  (.now js/Date))
+
+(defn clear-timeout!
+  [timeout-atom]
+  (when-let [timeout @timeout-atom]
+    (js/clearTimeout timeout)
+    (reset! timeout-atom nil)))
+
+(defn queue-entry
+  [step index]
+  (assoc step
+         :agency "gaze"
+         :queueIndex index
+         :queuedAt (now-ms)))
+
+(defn create-scheduler
+  [{:keys [state-atom emit-event]}]
+  (let [coalesce-timeout (atom nil)
+        pending-request (atom nil)
+        queue (atom [])
+        disposed? (atom false)]
+    (letfn [(enqueue! [step]
+              (let [entry (queue-entry step (count @queue))]
+                (swap! queue conj entry)
+                entry))
+
+            (publish-status! [status reason]
+              (emit-event (cond-> {:type "gaze.status"
+                                   :agency "gaze"
+                                   :status status
+                                   :mode (:mode @state-atom)
+                                   :active (:active @state-atom)
+                                   :enabled (get-in @state-atom [:config :enabled])
+                                   :at (now-ms)}
+                            reason (assoc :reason reason))))
+
+            (publish-request-now! []
+              (when-not @disposed?
+                (clear-timeout! coalesce-timeout)
+                (when-let [request @pending-request]
+                  (reset! pending-request nil)
+                  (enqueue! {:op "publish-request"
+                             :requestId (:requestId request)})
+                  (let [published-at (now-ms)]
+                    (swap! state-atom state/record-requested request published-at)
+                    (emit-event (assoc request :publishedAt published-at))))))
+
+            (queue-gaze-request! [request]
+              (when-not @disposed?
+                (let [queued-at (now-ms)
+                      request (assoc request :queuedAt queued-at)
+                      delay-ms (get-in @state-atom [:config :coalesceMs])]
+                  (reset! pending-request request)
+                  (swap! state-atom state/record-pending request)
+                  (clear-timeout! coalesce-timeout)
+                  (enqueue! {:op "coalesce-request"
+                             :requestId (:requestId request)
+                             :coalesceMs delay-ms})
+                  (if (pos? delay-ms)
+                    (reset! coalesce-timeout
+                            (js/setTimeout publish-request-now! delay-ms))
+                    (publish-request-now!)))))
+
+            (ignore-target! [plan reason]
+              (let [ignored {:type "gaze.targetIgnored"
+                             :agency "gaze"
+                             :requestId (:requestId plan)
+                             :rawTarget (:rawTarget plan)
+                             :target (:target plan)
+                             :reason reason
+                             :ignoredAt (now-ms)}]
+                (swap! state-atom state/record-ignored ignored)
+                (emit-event ignored)))
+
+            (cancel-pending! []
+              (clear-timeout! coalesce-timeout)
+              (reset! pending-request nil)
+              (swap! state-atom assoc :pendingRequest nil))
+
+            (execute-step! [step]
+              (enqueue! step)
+              (case (:op step)
+                "apply-config"
+                (do
+                  (swap! state-atom state/configure (:config step))
+                  (publish-status! (:status @state-atom) "configured"))
+
+                "set-mode"
+                (do
+                  (swap! state-atom state/set-mode (:mode step) (now-ms))
+                  (publish-status! (:status @state-atom) "mode"))
+
+                "set-active"
+                (do
+                  (swap! state-atom state/set-active (:active step) (now-ms))
+                  (publish-status! (:status @state-atom) "active"))
+
+                "set-enabled"
+                (do
+                  (swap! state-atom state/set-enabled (:enabled step) (now-ms))
+                  (publish-status! (if (:enabled step) "enabled" "disabled")
+                                   (if (:enabled step) "enabled" "disabled")))
+
+                "record-target"
+                (swap! state-atom state/record-plan (:plan step))
+
+                "publish-target-received"
+                (emit-event {:type "gaze.targetReceived"
+                             :agency "gaze"
+                             :requestId (get-in step [:plan :requestId])
+                             :rawTarget (get-in step [:plan :rawTarget])
+                             :source (get-in step [:plan :source])
+                             :label (get-in step [:plan :label])
+                             :at (now-ms)})
+
+                "publish-target-planned"
+                (emit-event {:type "gaze.targetPlanned"
+                             :agency "gaze"
+                             :requestId (get-in step [:plan :requestId])
+                             :rawTarget (get-in step [:plan :rawTarget])
+                             :target (get-in step [:plan :target])
+                             :delta (get-in step [:plan :delta])
+                             :eyeDurationMs (get-in step [:plan :eyeDurationMs])
+                             :headDurationMs (get-in step [:plan :headDurationMs])
+                             :at (now-ms)})
+
+                "ignore-target"
+                (ignore-target! (:plan step) (:reason step))
+
+                "queue-request"
+                (queue-gaze-request! (:request step))
+
+                "request-reset"
+                (do
+                  (cancel-pending!)
+                  (swap! state-atom state/record-reset (:request step))
+                  (emit-event (:request step)))
+
+                "request-cancel"
+                (do
+                  (cancel-pending!)
+                  (swap! state-atom state/record-cancel (:request step))
+                  (emit-event (:request step)))
+
+                "fail"
+                (emit-event {:type "error"
+                             :agency "gaze"
+                             :message (:reason step)
+                             :commandType (:commandType step)})
+
+                nil))]
+      {:schedule
+       (fn [plan]
+         (when-not @disposed?
+           (doseq [step (:steps plan)]
+             (execute-step! step))))
+
+       :flush
+       (fn []
+         (publish-request-now!))
+
+       :reset
+       (fn []
+         (cancel-pending!)
+         (reset! queue []))
+
+       :queue
+       (fn []
+         @queue)
+
+       :dispose
+       (fn []
+         (reset! disposed? true)
+         (cancel-pending!)
+         (reset! queue []))})))