@lovelace_lol/polymer 0.0.1

package/src/polymer/prosodic/agency.cljs

@@ -0,0 +1,196 @@
+(ns polymer.prosodic.agency
+  (:require [polymer.prosodic.goap :as goap]
+            [polymer.prosodic.scheduler :as scheduler]
+            [polymer.prosodic.snippet :as snippet]
+            [polymer.prosodic.state :as state]
+            [polymer.stream :as stream]))
+
+;; Prosodic Expression consumes speech/blink/conversation facts and emits
+;; animation intent. It does not own TTS, LipSync, host UI state, storage, or
+;; the animation runtime. The character network routes peer facts here, then
+;; routes Prosodic's animation requests to Polymer Animation.
+
+(defn js-command [type value]
+  #js {:type type :value value})
+
+(defn plan-error-message [plan]
+  (let [step (first (:steps plan))]
+    (case (:reason step)
+      "unsupported-command" (str "Prosodic plan failed: unsupported command " (:commandType step))
+      (str "Prosodic plan failed: " (:reason step)))))
+
+(defn should-emit-plan? [plan]
+  ;; Ignore/no-op plans are routine for word boundaries. Emitting every one
+  ;; would create noisy high-frequency diagnostics without changing behavior.
+  (or (false? (:ok plan))
+      (:gesture plan)
+      (some #{"record-conversation-fact" "remove-active-gestures"}
+            (map :op (:steps plan)))))
+
+(defn create-prosodic-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)
+        agency-scheduler (scheduler/create-scheduler {:emit-event emit-event})]
+    (letfn [(emit-plan! [plan]
+              (when (should-emit-plan? plan)
+                (emit-event {:type "prosodicPlanCreated"
+                             :agency "prosodic"
+                             :plan plan})))
+
+            (schedule-gesture! [gesture-kind context]
+              (when-let [snippet-data (snippet/build-gesture-snippet gesture-kind
+                                                                      (:config @state-atom)
+                                                                      context)]
+                ((:schedule-gesture agency-scheduler) snippet-data {:autoPlay true})
+                (let [scheduled-at (state/now-ms)]
+                  (swap! state-atom state/record-schedule (:name snippet-data) gesture-kind scheduled-at)
+                  (emit-event {:type "prosodicGestureScheduled"
+                               :agency "prosodic"
+                               :gesture gesture-kind
+                               :name (:name snippet-data)
+                               :word (:word context)
+                               :wordIndex (:wordIndex context)
+                               :scheduledAt scheduled-at}))
+                snippet-data))
+
+            (remove-active! [reason]
+              (let [active (:activeSnippets @state-atom)
+                    removed-at (state/now-ms)]
+                ((:remove-many agency-scheduler) active reason)
+                (doseq [name active]
+                  (swap! state-atom state/record-remove name reason removed-at))))
+
+            (stop-local! [reason]
+              (remove-active! reason)
+              (let [stopped-at (state/now-ms)]
+                (swap! state-atom state/clear-active reason stopped-at)
+                (emit-event {:type "prosodicStopped"
+                             :agency "prosodic"
+                             :reason reason
+                             :stoppedAt stopped-at})))
+
+            (execute-steps! [payload plan]
+              (doseq [step (:steps plan)]
+                (case (:op step)
+                  "apply-config"
+                  (do
+                    (swap! state-atom state/configure (:config payload))
+                    (emit-event {:type "prosodicConfigChanged"
+                                 :agency "prosodic"
+                                 :state @state-atom}))
+
+                  "clear-conversation-suppress"
+                  (swap! state-atom state/clear-conversation-suppress)
+
+                  "record-speech-start"
+                  (let [started-at (state/now-ms)]
+                    (swap! state-atom state/record-speech-start started-at (:name payload))
+                    (emit-event {:type "prosodicSpeechStarted"
+                                 :agency "prosodic"
+                                 :name (:name payload)
+                                 :startedAt started-at}))
+
+                  "record-speech-stop"
+                  (let [stopped-at (state/now-ms)
+                        reason (or (:reason payload) "requested")]
+                    (swap! state-atom state/clear-active reason stopped-at)
+                    (emit-event {:type "prosodicStopped"
+                                 :agency "prosodic"
+                                 :reason reason
+                                 :stoppedAt stopped-at}))
+
+                  "record-word-boundary"
+                  (let [word (state/clean-word (:word payload))
+                        word-index (int (state/number-or (:wordIndex payload)
+                                                         (:wordIndex @state-atom)))
+                        observed-at (state/now-ms)]
+                    (swap! state-atom state/record-word-boundary word word-index observed-at)
+                    (emit-event {:type "prosodicWordBoundary"
+                                 :agency "prosodic"
+                                 :word word
+                                 :wordIndex word-index
+                                 :observedAt observed-at}))
+
+                  "record-blink-fast-cue"
+                  (swap! state-atom state/record-blink-fast-cue (state/now-ms))
+
+                  "record-conversation-fact"
+                  (let [observed-at (state/now-ms)]
+                    (swap! state-atom state/record-conversation-fact payload observed-at)
+                    (emit-event {:type "prosodicConversationFact"
+                                 :agency "prosodic"
+                                 :conversationType (:type payload)
+                                 :text (:text payload)
+                                 :turnId (:turnId payload)
+                                 :observedAt observed-at}))
+
+                  "build-gesture-snippet"
+                  nil
+
+                  "schedule-animation"
+                  (when-let [gesture (:gesture plan)]
+                    (schedule-gesture! gesture
+                                       {:trigger (or (:type payload) "plan")
+                                        :word (state/clean-word (:word payload))
+                                        :wordIndex (int (state/number-or (:wordIndex payload)
+                                                                         (:wordIndex @state-atom)))}))
+
+                  "remove-active-gestures"
+                  (remove-active! (or (:reason payload) "requested"))
+
+                  "reset-state"
+                  (do
+                    (stop-local! "reset")
+                    (reset! state-atom (state/config->state nil))
+                    (emit-event {:type "prosodicConfigChanged"
+                                 :agency "prosodic"
+                                 :state @state-atom}))
+
+                  ("ignore" "fail")
+                  nil
+
+                  nil)))
+
+            (dispatch! [command]
+              (when-not @disposed?
+                (let [payload (js->clj command :keywordize-keys true)
+                      plan (goap/plan-command payload @state-atom)]
+                  (emit-input {:type "command"
+                               :agency "prosodic"
+                               :command payload})
+                  (emit-plan! plan)
+                  (if (false? (:ok plan))
+                    (emit-event {:type "error"
+                                 :agency "prosodic"
+                                 :message (plan-error-message plan)})
+                    (execute-steps! payload plan)))))]
+      #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}))
+           :speechStarted (fn [name] (dispatch! #js {:type "speechStarted" :name name}))
+           :wordBoundary (fn
+                           ([word] (dispatch! #js {:type "wordBoundary" :word word}))
+                           ([word word-index]
+                            (dispatch! #js {:type "wordBoundary"
+                                            :word word
+                                            :wordIndex word-index})))
+           :blinkFast (fn [] (dispatch! #js {:type "blinkFast"}))
+           :stop (fn [] (dispatch! #js {:type "stop"}))
+           :reset (fn [] (dispatch! #js {:type "reset"}))
+           :dispose (fn []
+                      (when-not @disposed?
+                        (reset! disposed? true)
+                        ((:dispose agency-scheduler))
+                        ((:dispose input-stream))
+                        ((:dispose event-stream))))})))

package/src/polymer/prosodic/goap.cljs

@@ -0,0 +1,122 @@
+(ns polymer.prosodic.goap
+  (:require [polymer.prosodic.state :as state]))
+
+;; Prosodic GOAP stays intentionally local. It answers whether a speech/blink
+;; or conversation fact should become a gesture plan. It does not build
+;; snippets, mutate state, or talk to Animation.
+
+(def supported-command-types
+  #{"configure"
+    "speechStarted"
+    "speechStopped"
+    "wordBoundary"
+    "blinkFast"
+    "conversation.userUtterance"
+    "conversation.agentUtterance"
+    "conversation.requestResponse"
+    "conversation.cancelRequested"
+    "stop"
+    "reset"})
+
+(defn command-goal [command world]
+  (let [type (:type command)
+        word (state/clean-word (:word command))
+        word-index (int (state/number-or (:wordIndex command) (:wordIndex world)))
+        last-conversation (:lastConversationFact world)]
+    {:type type
+     :enabled (get-in world [:config :enabled])
+     :speaking (:speaking world)
+     :word word
+     :wordIndex word-index
+     :hasWord (boolean word)
+     :blinkFastReady (state/blink-fast-cue-ready? world (state/now-ms))
+     :lastConversationType (:type last-conversation)
+     :conversationSuppressed? (= "conversation.cancelRequested"
+                                 (:type last-conversation))}))
+
+(defn word-gesture-kind [goal config]
+  ;; Local policy: speech cadence, biased by recent conversation context.
+  ;; Cancel suppresses gestures until speechStarted clears the fact.
+  (when-not (:conversationSuppressed? goal)
+    (let [cycle (:speechGestureEvery config)
+          mod-value (mod (:wordIndex goal) cycle)
+          conv (:lastConversationType goal)]
+      (cond
+        (and (= "conversation.userUtterance" conv)
+             (or (= mod-value 0) (= mod-value 1)))
+        "emphasis"
+
+        (= "conversation.requestResponse" conv)
+        (when (or (= mod-value 0) (= mod-value 4)) "contemplate")
+
+        (= mod-value 0) "emphasis"
+        (= mod-value 3) "nod"
+        (= mod-value 4) "contemplate"
+        :else nil))))
+
+(defn failure-step [goal]
+  (cond
+    (not (contains? supported-command-types (:type goal)))
+    {:op "fail" :reason "unsupported-command" :commandType (:type goal)}
+
+    (not (:enabled goal))
+    {:op "ignore" :reason "disabled"}
+
+    (and (= "wordBoundary" (:type goal)) (not (:hasWord goal)))
+    {:op "ignore" :reason "missing-word"}
+
+    (and (= "blinkFast" (:type goal)) (not (:blinkFastReady goal)))
+    {:op "ignore" :reason "cooldown"}
+
+    :else nil))
+
+(defn command-steps [goal config]
+  (if-let [failure (failure-step goal)]
+    [failure]
+    (case (:type goal)
+      "configure" [{:op "apply-config"}]
+      "speechStarted" [{:op "clear-conversation-suppress"}
+                       {:op "record-speech-start"}]
+      "speechStopped" [{:op "remove-active-gestures"}
+                       {:op "record-speech-stop"}]
+      "stop" [{:op "remove-active-gestures"}
+              {:op "record-speech-stop"}]
+      "reset" [{:op "remove-active-gestures"}
+               {:op "reset-state"}]
+      "blinkFast" [{:op "record-blink-fast-cue"}
+                   {:op "build-gesture-snippet" :gesture "blink-fast"}
+                   {:op "schedule-animation"}]
+      "conversation.userUtterance"
+      [{:op "record-conversation-fact"}
+       {:op "build-gesture-snippet" :gesture "contemplate"}
+       {:op "schedule-animation"}]
+      "conversation.agentUtterance"
+      [{:op "record-conversation-fact"}
+       {:op "build-gesture-snippet" :gesture "nod"}
+       {:op "schedule-animation"}]
+      "conversation.requestResponse"
+      [{:op "record-conversation-fact"}]
+      "conversation.cancelRequested" [{:op "record-conversation-fact"}
+                                      {:op "remove-active-gestures"}]
+      "wordBoundary" (if-let [gesture (word-gesture-kind goal config)]
+                       [{:op "record-word-boundary"}
+                        {:op "build-gesture-snippet" :gesture gesture}
+                        {:op "schedule-animation"}]
+                       [{:op "record-word-boundary"}
+                        {:op "ignore" :reason (if (:conversationSuppressed? goal)
+                                                "conversation-cancelled"
+                                                "no-gesture-for-word")}]))))
+
+(defn plan-ok? [steps]
+  (not= "fail" (:op (first steps))))
+
+(defn scheduled-gesture [steps]
+  (:gesture (some #(when (= "build-gesture-snippet" (:op %)) %) steps)))
+
+(defn plan-command [command world]
+  (let [goal (command-goal command world)
+        steps (command-steps goal (:config world))]
+    {:goal goal
+     :steps steps
+     :ok (plan-ok? steps)
+     :gesture (scheduled-gesture steps)}))

package/src/polymer/prosodic/scheduler.cljs

@@ -0,0 +1,99 @@
+(ns polymer.prosodic.scheduler)
+
+;; Prosodic has no provider, audio, DOM, or runtime side effect. Its scheduler
+;; still owns the ordered effector queue for this agency: schedule a gesture
+;; request, remove active gesture requests on stop/reset, and expose that queue
+;; for diagnostics/tests. Polymer Animation performs the runtime effect later.
+
+(defn now-ms []
+  (.now js/Date))
+
+(defn effector-target [channel]
+  (let [target (:target channel)]
+    (case (:type target)
+      "au" (case (:id target)
+             53 "head"
+             54 "head"
+             55 "head"
+             "face")
+      (:type target))))
+
+(def snippet-effectors-xf
+  ;; This is a small, valid transducer use: pure channel -> effector labels.
+  ;; It keeps queue diagnostics data-oriented without hiding control flow.
+  (comp
+   (map effector-target)
+   (remove nil?)
+   (distinct)))
+
+(defn snippet-effectors [snippet]
+  (into [] snippet-effectors-xf (:channels snippet)))
+
+(defn queue-entry [effect queue-index]
+  (assoc effect
+         :queueIndex queue-index
+         :queuedAt (now-ms)))
+
+(defn create-scheduler [{:keys [emit-event]}]
+  (let [queue (atom [])
+        disposed? (atom false)]
+    (letfn [(enqueue! [effect]
+              (let [entry (queue-entry effect (count @queue))]
+                (swap! queue conj entry)
+                entry))
+
+            (schedule-animation! [snippet-data options]
+              (let [effectors (snippet-effectors snippet-data)
+                    entry (enqueue! {:type "scheduleAnimation"
+                                     :agency "prosodic"
+                                     :requestId (:name snippet-data)
+                                     :snippetName (:name snippet-data)
+                                     :effectors effectors})]
+                (emit-event {:type "animation.requestScheduleSnippet"
+                             :agency "prosodic"
+                             :requestId (:requestId entry)
+                             :snippet snippet-data
+                             :options options
+                             :effectors effectors
+                             :queueIndex (:queueIndex entry)
+                             :queuedAt (:queuedAt entry)})
+                entry))
+
+            (remove-animation! [name reason]
+              (let [entry (enqueue! {:type "removeAnimation"
+                                     :agency "prosodic"
+                                     :requestId name
+                                     :name name
+                                     :reason reason})]
+                (emit-event {:type "animation.requestRemoveSnippet"
+                             :agency "prosodic"
+                             :requestId name
+                             :name name
+                             :reason reason
+                             :queueIndex (:queueIndex entry)
+                             :queuedAt (:queuedAt entry)})
+                entry))]
+      {:schedule-gesture
+       (fn [snippet-data options]
+         (when-not @disposed?
+           (schedule-animation! snippet-data options)))
+
+       :remove
+       (fn [name reason]
+         (when-not @disposed?
+           (remove-animation! name reason)))
+
+       :remove-many
+       (fn [names reason]
+         (when-not @disposed?
+           (doseq [name names]
+             (remove-animation! name reason))))
+
+       :queue
+       (fn []
+         @queue)
+
+       :dispose
+       (fn []
+         (reset! disposed? true)
+         (reset! queue []))})))

package/src/polymer/prosodic/snippet.cljs

@@ -0,0 +1,106 @@
+(ns polymer.prosodic.snippet
+  (:require [polymer.prosodic.state :as state]))
+
+;; Prosodic snippet construction is pure data mapping. The agency scheduler
+;; emits the resulting map to Polymer Animation; only Animation touches a
+;; runtime-specific effector.
+
+(defn au-channel [au-id curve]
+  {:target {:type "au" :id au-id}
+   :keyframes curve})
+
+(defn base-snippet [name curves max-time priority intensity metadata]
+  {:name name
+   :curves curves
+   :channels (mapv (fn [[au-id curve]]
+                     (au-channel (js/parseInt (str au-id) 10) curve))
+                   curves)
+   :maxTime max-time
+   :loop false
+   :snippetPriority priority
+   :snippetPlaybackRate 1
+   :snippetIntensityScale intensity
+   :metadata (merge {:agency "prosodic"} metadata)})
+
+(defn gesture-name [gesture-kind now]
+  (str "polymer:prosodic:" gesture-kind ":" now))
+
+(defn emphasis-snippet [now config context]
+  (base-snippet
+   (gesture-name "emphasis" now)
+   {"1" [{:time 0.0 :intensity 0}
+         {:time 0.15 :intensity 0.35}
+         {:time 0.45 :intensity 0.45}
+         {:time 0.75 :intensity 0}]
+    "2" [{:time 0.0 :intensity 0}
+         {:time 0.15 :intensity 0.25}
+         {:time 0.45 :intensity 0.35}
+         {:time 0.75 :intensity 0}]
+    "55" [{:time 0.0 :intensity 0}
+          {:time 0.25 :intensity 0.15}
+          {:time 0.65 :intensity 0.15}
+          {:time 0.95 :intensity 0}]}
+   0.95
+   (:priority config)
+   (* 0.8 (:intensity config))
+   (merge {:gesture "emphasis"} context)))
+
+(defn nod-snippet [now config context]
+  (base-snippet
+   (gesture-name "nod" now)
+   {"53" [{:time 0.0 :intensity 0}
+          {:time 0.15 :intensity 0.4}
+          {:time 0.4 :intensity 0.5}
+          {:time 0.75 :intensity 0}]}
+   0.75
+   (:priority config)
+   (* 0.9 (:intensity config))
+   (merge {:gesture "nod"} context)))
+
+(defn contemplate-snippet [now config context]
+  (base-snippet
+   (gesture-name "contemplate" now)
+   {"4" [{:time 0.0 :intensity 0}
+         {:time 0.2 :intensity 0.18}
+         {:time 0.6 :intensity 0.22}
+         {:time 1.0 :intensity 0}]
+    "1" [{:time 0.0 :intensity 0}
+         {:time 0.25 :intensity 0.12}
+         {:time 0.65 :intensity 0.12}
+         {:time 1.0 :intensity 0}]}
+   1.0
+   (:priority config)
+   (* 0.6 (:intensity config))
+   (merge {:gesture "contemplate"} context)))
+
+(defn blink-fast-snippet [now config context]
+  ;; Fast blinking gets a small downward head cue. It is no longer hard-coded
+  ;; in the character network; Blink emits a signal and Prosodic decides how to
+  ;; express that signal.
+  (base-snippet
+   (gesture-name "blink-fast" now)
+   {"1" [{:time 0 :intensity 0}
+         {:time 0.12 :intensity 0.26}
+         {:time 0.42 :intensity 0.34}
+         {:time 0.72 :intensity 0}]
+    "2" [{:time 0 :intensity 0}
+         {:time 0.12 :intensity 0.2}
+         {:time 0.42 :intensity 0.28}
+         {:time 0.72 :intensity 0}]
+    "54" [{:time 0 :intensity 0}
+          {:time 0.16 :intensity 0.16}
+          {:time 0.44 :intensity 0.2}
+          {:time 0.72 :intensity 0}]}
+   0.72
+   (max (:priority config) 35)
+   (* 0.75 (:intensity config))
+   (merge {:gesture "blink-fast" :trigger "blink-fast"} context)))
+
+(defn build-gesture-snippet [gesture-kind config context]
+  (let [now (state/now-ms)]
+    (case gesture-kind
+      "emphasis" (emphasis-snippet now config context)
+      "nod" (nod-snippet now config context)
+      "contemplate" (contemplate-snippet now config context)
+      "blink-fast" (blink-fast-snippet now config context)
+      nil)))

package/src/polymer/prosodic/state.cljs

@@ -0,0 +1,139 @@
+(ns polymer.prosodic.state)
+
+;; Prosodic state is a small local ledger. It records speech/prosody facts and
+;; active snippet names, but it never stores runtime handles. Runtime-specific
+;; handles are owned by Polymer Animation after Prosodic requests a gesture.
+
+(def default-config
+  {:enabled true
+   :intensity 1
+   :priority 30
+   :speechGestureEvery 6
+   :blinkFastCooldownMs 1200})
+
+(def default-state
+  {:agency "prosodic"
+   :speaking false
+   :wordIndex 0
+   :currentWord nil
+   :activeSnippets []
+   :scheduledCount 0
+   :removedCount 0
+   :conversationFactCount 0
+   :lastConversationFact nil
+   :lastGesture nil
+   :lastBlinkFastCueAt 0
+   :config default-config
+   :lastEvent nil})
+
+(defn now-ms []
+  (.now js/Date))
+
+(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]
+  (-> value (max lo) (min hi)))
+
+(defn js-config [config]
+  (if config (js->clj config :keywordize-keys true) {}))
+
+(defn sanitize-config [config]
+  ;; Clamp all public knobs in one pure function so commands from JS, workers,
+  ;; or other agencies share the same agency contract.
+  (let [merged (merge default-config config)]
+    {:enabled (boolean (:enabled merged))
+     :intensity (clamp 0 2 (number-or (:intensity merged) (:intensity default-config)))
+     :priority (int (clamp -1000 1000 (number-or (:priority merged) (:priority default-config))))
+     :speechGestureEvery (int (clamp 2 32 (number-or (:speechGestureEvery merged)
+                                                     (:speechGestureEvery default-config))))
+     :blinkFastCooldownMs (clamp 0 10000 (number-or (:blinkFastCooldownMs merged)
+                                                    (:blinkFastCooldownMs default-config)))}))
+
+(defn config->state [config]
+  (assoc default-state :config (sanitize-config (js-config config))))
+
+(defn configure [state config]
+  (update state :config #(sanitize-config (merge % (js-config config)))))
+
+(defn clean-word [word]
+  (when word
+    (let [value (.trim (str word))]
+      (when (pos? (count value)) value))))
+
+(defn record-speech-start [state started-at name]
+  (-> state
+      (assoc :speaking true
+             :currentWord nil
+             :wordIndex 0
+             :lastEvent {:type "prosodicSpeechStarted"
+                         :name name
+                         :at started-at})))
+
+(defn record-word-boundary [state word word-index observed-at]
+  (-> state
+      (assoc :currentWord word
+             :wordIndex (inc (or word-index (:wordIndex state) 0))
+             :lastEvent {:type "prosodicWordBoundary"
+                         :word word
+                         :wordIndex word-index
+                         :at observed-at})))
+
+(defn record-conversation-fact [state fact observed-at]
+  ;; Conversation facts are local planning context. GOAP may schedule a gesture
+  ;; from the same fact and later word boundaries can bias off lastConversationFact.
+  (-> state
+      (assoc :lastConversationFact (assoc fact :observedAt observed-at)
+             :lastEvent {:type "prosodicConversationFact"
+                         :conversationType (:type fact)
+                         :text (:text fact)
+                         :at observed-at})
+      (update :conversationFactCount inc)))
+
+(defn clear-conversation-suppress [state]
+  ;; speechStarted ends cancel-driven gesture suppression.
+  (cond-> state
+    (= "conversation.cancelRequested" (get-in state [:lastConversationFact :type]))
+    (assoc :lastConversationFact nil)))
+
+(defn record-schedule [state snippet-name gesture-kind scheduled-at]
+  (-> state
+      (update :activeSnippets #(vec (distinct (conj % snippet-name))))
+      (update :scheduledCount inc)
+      (assoc :lastGesture gesture-kind
+             :lastEvent {:type "prosodicGestureScheduled"
+                         :name snippet-name
+                         :gesture gesture-kind
+                         :at scheduled-at})))
+
+(defn record-remove [state snippet-name reason removed-at]
+  (-> state
+      (update :activeSnippets #(vec (remove #{snippet-name} %)))
+      (update :removedCount inc)
+      (assoc :lastEvent {:type "prosodicGestureRemoved"
+                         :name snippet-name
+                         :reason reason
+                         :at removed-at})))
+
+(defn clear-active [state reason stopped-at]
+  (-> state
+      (assoc :speaking false
+             :currentWord nil
+             :wordIndex 0
+             :activeSnippets []
+             :lastEvent {:type "prosodicStopped"
+                         :reason reason
+                         :at stopped-at})))
+
+(defn blink-fast-cue-ready? [state now]
+  (let [cooldown (get-in state [:config :blinkFastCooldownMs])]
+    (>= (- now (:lastBlinkFastCueAt state)) cooldown)))
+
+(defn record-blink-fast-cue [state now]
+  (assoc state :lastBlinkFastCueAt now))
+
+(defn visible-state [state]
+  (clj->js state))