@lovelace_lol/polymer 0.0.1

package/src/polymer/animation/state.cljs

@@ -0,0 +1,112 @@
+(ns polymer.animation.state)
+
+;; Animation state is the agency-local schedule ledger.
+;;
+;; The Animation agency owns this schedule state and directly talks to the
+;; injected animation runtime. Other agencies can inspect summary state and
+;; subscribe to events, but they do not reach through to runtime handles.
+
+(def default-state
+  {:agency "animation"
+   :scheduled {}
+   :scheduledCount 0
+   :startedCount 0
+   :seekCount 0
+   :updatedCount 0
+   :removedCount 0
+   :lastEvent nil})
+
+(defn finite-number? [value]
+  (and (number? value) (js/isFinite value)))
+
+(defn now-ms []
+  (.now js/Date))
+
+(defn snippet-name [snippet fallback]
+  ;; Snippets should normally come with stable names so the runtime can clean up
+  ;; the same clip later. Generate a fallback only for defensive JS interop.
+  (let [name (:name snippet)]
+    (if (and (string? name) (pos? (count name)))
+      name
+      fallback)))
+
+(defn snippet-duration-ms [snippet]
+  ;; Animation snippets use seconds. Timers use milliseconds. Non-finite or
+  ;; missing maxTime means there is no automatic cleanup timer.
+  (when-let [max-time (:maxTime snippet)]
+    (when (finite-number? max-time)
+      (* 1000 max-time))))
+
+(defn snippet-summary [snippet options source-agency requested-at]
+  ;; Store enough state for diagnostics without copying runtime handles into
+  ;; snapshots. Handles stay private inside the Animation agency.
+  {:name (:name snippet)
+   :sourceAgency source-agency
+   :snippetCategory (:snippetCategory snippet)
+   :snippetPriority (:snippetPriority snippet)
+   :maxTime (:maxTime snippet)
+   :loop (boolean (:loop snippet))
+   :autoPlay (boolean (:autoPlay options))
+   :requestedAt requested-at
+   :startedAt nil
+   :lastUpdateAt nil
+   :lastUpdateParams nil
+   :removedAt nil
+   :removeReason nil})
+
+(defn record-schedule [state snippet options source-agency requested-at]
+  (let [summary (snippet-summary snippet options source-agency requested-at)]
+    (-> state
+        (assoc-in [:scheduled (:name summary)] summary)
+        (update :scheduledCount inc)
+        (assoc :lastEvent {:type "animationSnippetScheduled"
+                           :name (:name summary)
+                           :sourceAgency source-agency
+                           :at requested-at}))))
+
+(defn record-start [state name source-agency started-at]
+  (-> state
+      (assoc-in [:scheduled name :startedAt] started-at)
+      (update :startedCount inc)
+      (assoc :lastEvent {:type "animationSnippetStarted"
+                         :name name
+                         :sourceAgency source-agency
+                         :at started-at})))
+
+(defn record-remove [state name source-agency removed-at reason]
+  (-> state
+      (update :scheduled dissoc name)
+      (update :removedCount inc)
+      (assoc :lastEvent {:type "animationSnippetRemoved"
+                         :name name
+                         :sourceAgency source-agency
+                         :reason reason
+                         :at removed-at})))
+
+(defn record-seek [state name source-agency seeked-at offset-sec]
+  ;; Seeking is still schedule state: the Animation agency owns the active
+  ;; snippet handles, so drift correction from LipSync comes here instead
+  ;; of reaching through LoomLarge or bypassing Polymer's agency boundary.
+  (-> state
+      (assoc-in [:scheduled name :lastSeekAt] seeked-at)
+      (assoc-in [:scheduled name :lastSeekOffsetSec] offset-sec)
+      (update :seekCount inc)
+      (assoc :lastEvent {:type "animationSnippetSeeked"
+                         :name name
+                         :sourceAgency source-agency
+                         :offsetSec offset-sec
+                         :at seeked-at})))
+
+(defn record-update [state name source-agency updated-at params]
+  (-> state
+      (assoc-in [:scheduled name :lastUpdateAt] updated-at)
+      (assoc-in [:scheduled name :lastUpdateParams] params)
+      (update :updatedCount inc)
+      (assoc :lastEvent {:type "animationSnippetUpdated"
+                         :name name
+                         :sourceAgency source-agency
+                         :params params
+                         :at updated-at})))
+
+(defn visible-state [state]
+  (clj->js state))

package/src/polymer/blink/agency.cljs

@@ -0,0 +1,131 @@
+(ns polymer.blink.agency
+  (:require [polymer.blink.planner :as planner]
+            [polymer.blink.scheduler :as scheduler]
+            [polymer.blink.state :as state]
+            [polymer.stream :as stream]))
+
+;; Blink is the smallest useful agency, so it is the proving ground for the
+;; Polymer architecture:
+;;
+;; input   - commands coming from callers, workers, or later from other Polymer
+;;           agencies.
+;; events  - facts Blink observed or decided, such as a planned blink or a
+;;           cross-agency signal.
+;;
+;; The agency owns only local Blink state and timers. It does not know about
+;; UI components, legacy services, animation engines, DOM APIs, storage, audio,
+;; video, or HTTP.
+
+(defn js-command [type value]
+  #js {:type type :value value})
+
+(defn create-blink-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 [(record-plan! [plan]
+              ;; Planning mutates only Blink's local counters/timestamps, then
+              ;; leaves the runtime fact on the event stream. This is
+              ;; intentional: scheduled blink counters are diagnostics and
+              ;; agency-to-agency feedback, not render state. Publishing them
+              ;; through a render-facing stream would make UI controls update
+              ;; on every automatic blink.
+              (let [now-ms (or (:created-at plan) (.now js/Date))]
+                (swap! state-atom state/record-plan plan now-ms)))
+
+            (refresh-auto! []
+              (when-let [agency-scheduler @scheduler-atom]
+                ((:refresh-auto agency-scheduler))))
+
+            (stop-auto! []
+              (when-let [agency-scheduler @scheduler-atom]
+                ((:stop agency-scheduler))))
+
+            (run-action! [action]
+              (case (:op action)
+                :trigger
+                (when-let [agency-scheduler @scheduler-atom]
+                  ((:trigger agency-scheduler)
+                   (:reason action)
+                   (:options action)
+                   (:random-value action)
+                   (:now-ms action)))
+
+                :apply-state
+                (do
+                  (swap! state-atom state/apply-command (:payload action))
+                  (emit-event {:type "blinkConfigChanged"
+                               :agency "blink"
+                               :state @state-atom}))
+
+                :refresh-auto
+                (refresh-auto!)
+
+                :stop-auto
+                (stop-auto!)
+
+                :error
+                (emit-event {:type "error"
+                             :agency "blink"
+                             :message (:message action)})
+
+                (emit-event {:type "error"
+                             :agency "blink"
+                             :message (str "Unknown Blink planner action: " (:op action))})))
+
+            (dispatch! [command]
+              (when-not @disposed?
+                (let [payload (js->clj command :keywordize-keys true)
+                      now-ms (.now js/Date)
+                      random-value (js/Math.random)]
+                  ;; Input is observable so tests/workers can see the same
+                  ;; commands that the agency processes. This stream is not used
+                  ;; to cause side effects.
+                  (emit-input {:type "command"
+                               :agency "blink"
+                               :command payload})
+                  (doseq [action (planner/plan-command @state-atom payload random-value now-ms)]
+                    (run-action! action)))))]
+      (let [agency-scheduler (scheduler/create-scheduler
+                              {:state-atom state-atom
+                               :emit-event emit-event
+                               :record-plan! record-plan!})]
+        (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))
+             ;; Compatibility aliases expose the same domain event stream.
+             :subscribe (fn [listener] ((:subscribe event-stream) listener))
+             :subscribeStatus (fn [listener] ((:subscribe event-stream) listener))
+             :enable (fn [] (dispatch! (js-command "enable" true)))
+             :disable (fn [] (dispatch! (js-command "disable" false)))
+             :triggerBlink (fn
+                             ([] (dispatch! #js {:type "triggerBlink"}))
+                             ([options] (dispatch! #js {:type "triggerBlink" :options options})))
+             :setFrequency (fn [value] (dispatch! (js-command "setFrequency" value)))
+             :setDuration (fn [value] (dispatch! (js-command "setDuration" value)))
+             :setIntensity (fn [value] (dispatch! (js-command "setIntensity" value)))
+             :setRandomness (fn [value] (dispatch! (js-command "setRandomness" value)))
+             :setLeftEyeIntensity (fn [value] (dispatch! (js-command "setLeftEyeIntensity" value)))
+             :setRightEyeIntensity (fn [value] (dispatch! (js-command "setRightEyeIntensity" value)))
+             :setBurstEnabled (fn [value] (dispatch! (js-command "setBurstEnabled" value)))
+             :setBurstFrequency (fn [value] (dispatch! (js-command "setBurstFrequency" value)))
+             :setBurstCount (fn [value] (dispatch! (js-command "setBurstCount" value)))
+             :setBurstGap (fn [value] (dispatch! (js-command "setBurstGap" value)))
+             :reset (fn [] (dispatch! #js {:type "reset"}))
+             :schedulerQueue (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))))}))))

package/src/polymer/blink/planner.cljs

@@ -0,0 +1,115 @@
+(ns polymer.blink.planner
+  (:require [polymer.blink.state :as state]))
+
+;; The planner is pure decision logic. It turns incoming commands and blink
+;; opportunities into action maps for the agency/scheduler to execute. It does
+;; not mutate state, touch clocks, choose random values, or emit stream data.
+
+(def fast-blink-frequency-threshold 36)
+
+(defn random-factor [randomness random-value]
+  ;; Randomness stretches or shrinks the next automatic blink interval around
+  ;; the frequency-derived baseline.
+  (+ 1 (* (- random-value 0.5) randomness)))
+
+(defn next-interval-ms [blink-state random-value]
+  ;; Frequency is stored as blinks per minute, so the baseline interval is
+  ;; 60/frequency seconds. A disabled scheduler handles whether this value is
+  ;; used; the planner only answers the interval question.
+  (let [frequency (:frequency blink-state)]
+    (if (<= frequency 0)
+      nil
+      (* (/ 60 frequency) 1000 (random-factor (:randomness blink-state) random-value)))))
+
+(defn trigger-options [options]
+  ;; JS callers may omit options. Normalize once so the rest of the planner can
+  ;; stay in ordinary Clojure data.
+  (if options (js->clj options :keywordize-keys true) {}))
+
+(defn resolve-blink-count [blink-state reason options random-value]
+  ;; Manual triggers may request an exact burst count. Automatic triggers choose
+  ;; a burst only some of the time, controlled by burstFrequency.
+  (let [manual-count (:burstCount options)]
+    (cond
+      (state/finite-number? manual-count)
+      (int (state/clamp 1 8 manual-count))
+
+      (and (= reason "auto")
+           (:burstEnabled blink-state)
+           (< random-value (:burstFrequency blink-state)))
+      (:burstCount blink-state)
+
+      :else 1)))
+
+(defn make-plan [blink-state reason options random-value now-ms]
+  ;; A plan is the normalized, immutable description of one blink opportunity.
+  ;; Time and randomness are supplied by the scheduler/agency boundary so this
+  ;; function remains deterministic and easy to test.
+  (let [options (trigger-options options)
+        blink-count (resolve-blink-count blink-state reason options random-value)
+        duration (state/clamp 0.05 1 (state/number-or (:duration options) (:duration blink-state)))
+        gap (state/clamp 0.02 0.5 (state/number-or (:burstGap options) (:burstGap blink-state)))
+        intensity (state/clamp 0 1 (state/number-or (:intensity options) (:intensity blink-state)))]
+    {:agency "blink"
+     :name (str "polymer:blink:" now-ms)
+     :reason reason
+     :blink-count blink-count
+     :duration duration
+     :burst-gap gap
+     :intensity intensity
+     :created-at now-ms
+     :fast? (or (>= (:frequency blink-state) fast-blink-frequency-threshold)
+                (> blink-count 2))}))
+
+(def config-command-types
+  #{"setFrequency"
+    "setDuration"
+    "setIntensity"
+    "setRandomness"
+    "setLeftEyeIntensity"
+    "setRightEyeIntensity"
+    "setBurstEnabled"
+    "setBurstFrequency"
+    "setBurstCount"
+    "setBurstGap"
+    "configure"})
+
+(defn error-action [message]
+  {:op :error
+   :message message})
+
+(defn trigger-action [reason payload random-value now-ms]
+  {:op :trigger
+   :reason reason
+   :options (:options payload)
+   :random-value random-value
+   :now-ms now-ms})
+
+(defn apply-state-action [payload]
+  {:op :apply-state
+   :payload payload})
+
+(defn plan-command [blink-state payload random-value now-ms]
+  (let [type (:type payload)]
+    (cond
+      (= "triggerBlink" type)
+      [(trigger-action "manual" payload random-value now-ms)]
+
+      (= "requestBlink" type)
+      [(trigger-action (or (:reason payload) "request") payload random-value now-ms)]
+
+      (= "enable" type)
+      [(apply-state-action payload)
+       {:op :refresh-auto}]
+
+      (or (= "disable" type)
+          (= "reset" type))
+      [(apply-state-action payload)
+       {:op :stop-auto}]
+
+      (contains? config-command-types type)
+      [(apply-state-action payload)
+       {:op :refresh-auto}]
+
+      :else
+      [(error-action (str "Unknown Blink command: " type))])))

package/src/polymer/blink/scheduler.cljs

@@ -0,0 +1,90 @@
+(ns polymer.blink.scheduler
+  (:require [polymer.blink.planner :as planner]
+            [polymer.blink.snippet :as snippet]))
+
+;; The scheduler is the only Blink namespace that owns timers.
+;;
+;; It still does not call animation engines directly. When a blink should play,
+;; it emits animation intent. The Polymer character network routes that intent
+;; to Polymer Animation, and only Polymer Animation talks to the animation
+;; runtime.
+
+(defn clear-timeout! [timer-atom]
+  (when-let [timer @timer-atom]
+    (js/clearTimeout timer)
+    (reset! timer-atom nil)))
+
+(defn create-scheduler [{:keys [state-atom emit-event record-plan!]}]
+  (let [auto-timer (atom nil)
+        queue (atom [])
+        disposed? (atom false)]
+    (letfn [(enqueue! [entry]
+              (let [queued (assoc entry
+                                  :agency "blink"
+                                  :queueIndex (count @queue)
+                                  :queuedAt (.now js/Date))]
+                (swap! queue conj queued)
+                queued))
+
+            (emit-plan! [plan snippet-data next-delay-ms]
+              ;; Domain events describe what Blink decided. They are not
+              ;; imperative requests. Other agencies can listen to them without
+              ;; causing side effects.
+              (emit-event {:type "blinkPlanned"
+                           :agency "blink"
+                           :plan plan
+                           :snippetName (:name snippet-data)
+                           :nextDelayMs next-delay-ms})
+              (when (:fast? plan)
+                ;; Cross-agency signals also live on the event stream. The
+                ;; Polymer character network routes this signal to the
+                ;; Prosodic agency, which decides how to express fast blinking.
+                (emit-event {:type "signal"
+                             :agency "blink"
+                             :signal "blink-fast"
+                             :plan plan})))
+
+            (trigger! [reason options random-value now-ms]
+              (when-not @disposed?
+                (let [plan (planner/make-plan @state-atom reason options random-value now-ms)
+                      snippet-data (snippet/build-blink-snippet plan)]
+                  (enqueue! {:type "blinkScheduled"
+                             :reason reason
+                             :snippetName (:name snippet-data)
+                             :burstCount (:burstCount plan)})
+                  (record-plan! plan)
+                  ;; Blink requests animation as data. The Polymer agency
+                  ;; network routes it to Animation instead of letting Blink
+                  ;; touch the animation runtime.
+                  (emit-event {:type "animation.requestScheduleSnippet"
+                               :agency "blink"
+                               :requestId (:name snippet-data)
+                               :snippet snippet-data
+                               :options {:autoPlay true}})
+                  (emit-plan! plan snippet-data nil)
+                  snippet-data)))
+
+            (schedule-next-auto! [extra-delay-ms]
+              (clear-timeout! auto-timer)
+              (when-not @disposed?
+                (let [blink-state @state-atom
+                      interval (planner/next-interval-ms blink-state (js/Math.random))]
+                  (when (and (:enabled blink-state) interval)
+                    (let [delay-ms (+ interval (or extra-delay-ms 0))]
+                      (reset! auto-timer
+                              (js/setTimeout
+                               (fn []
+                                 (reset! auto-timer nil)
+                                 (when-let [snippet-data (trigger! "auto" nil (js/Math.random) (.now js/Date))]
+                                   (let [extra-ms (max 0 (- (snippet/snippet-duration-ms snippet-data)
+                                                           (* 1000 (:duration @state-atom))))]
+                                     (schedule-next-auto! extra-ms))))
+                               delay-ms)))))))]
+      {:trigger trigger!
+       :refresh-auto (fn [] (schedule-next-auto! 0))
+       :stop (fn [] (clear-timeout! auto-timer))
+       :queue (fn [] @queue)
+       :dispose (fn []
+                  (reset! disposed? true)
+                  (clear-timeout! auto-timer)
+                  (reset! queue []))})))

package/src/polymer/blink/snippet.cljs

@@ -0,0 +1,50 @@
+(ns polymer.blink.snippet
+  (:require [polymer.blink.state :as state]))
+
+;; Snippet construction translates a Blink plan into animation data, but it does
+;; not schedule that animation. Polymer Animation consumes this plain map and
+;; decides how to schedule it against the injected animation runtime.
+
+(defn pulse-points [offset duration intensity]
+  ;; A blink is modeled as a close, brief hold, and open curve on AU 43. Burst
+  ;; blinks reuse the same shape at shifted offsets.
+  (let [close-time (* duration 0.35)
+        hold-time (* duration 0.1)
+        open-time (* duration 0.55)]
+    [{:time offset :intensity 0}
+     {:time (+ offset (* close-time 0.3)) :intensity (* intensity 0.4)}
+     {:time (+ offset close-time) :intensity intensity}
+     {:time (+ offset close-time hold-time) :intensity (* intensity 0.98)}
+     {:time (+ offset close-time hold-time (* open-time 0.5)) :intensity (* intensity 0.5)}
+     {:time (+ offset close-time hold-time (* open-time 0.85)) :intensity (* intensity 0.15)}
+     {:time (+ offset duration) :intensity 0}]))
+
+(defn build-blink-snippet [plan]
+  ;; Build one animation snippet even for n-blink bursts. This avoids overlapping
+  ;; several tiny snippets and gives the scheduler one duration to account for
+  ;; before the next automatic blink is planned.
+  (let [blink-count (:blink-count plan)
+        duration (:duration plan)
+        gap (:burst-gap plan)
+        intensity (:intensity plan)
+        max-time (+ (* blink-count duration) (* (max 0 (dec blink-count)) gap))
+        points (into []
+                     (mapcat (fn [index]
+                               (pulse-points (* index (+ duration gap)) duration intensity)))
+                     (range blink-count))]
+    {:name (:name plan)
+     :curves {"43" points}
+     :channels [{:target {:type "au" :id 43}
+                 :keyframes points}]
+     :maxTime max-time
+     :loop false
+     :snippetPriority 100
+     :snippetPlaybackRate 1
+     :snippetIntensityScale 1
+     :metadata {:agency "blink"
+                :blinkCount blink-count
+                :burst (> blink-count 1)}}))
+
+(defn snippet-duration-ms [snippet]
+  ;; Timer code works in milliseconds while snippets store maxTime in seconds.
+  (* 1000 (state/number-or (:maxTime snippet) 0)))

package/src/polymer/blink/state.cljs

@@ -0,0 +1,102 @@
+(ns polymer.blink.state)
+
+;; Blink state is ordinary immutable data. The agency owns one atom containing
+;; this state, but all transformations below are pure functions. Keeping clamps
+;; and defaults here makes the JS API forgiving without spreading validation
+;; across UI components.
+
+(def default-state
+  {:agency "blink"
+   :enabled false
+   :frequency 17
+   :duration 0.15
+   :intensity 1
+   :randomness 0.3
+   :leftEyeIntensity nil
+   :rightEyeIntensity nil
+   :burstEnabled true
+   :burstFrequency 0.08
+   :burstCount 2
+   :burstGap 0.08
+   :lastBlinkTime nil
+   :scheduledBlinkCount 0
+   :scheduledBurstCount 0})
+
+(defn clamp [lo hi value]
+  ;; Clamp numeric settings to the agency-supported range.
+  (-> value (max lo) (min hi)))
+
+(defn finite-number? [value]
+  ;; JS interop can pass NaN/Infinity. Treat those as invalid config values.
+  (and (number? value) (js/isFinite value)))
+
+(defn number-or [value fallback]
+  ;; Use a fallback for omitted, null, or non-finite settings.
+  (if (finite-number? value) value fallback))
+
+(defn maybe-intensity [value]
+  ;; Per-eye overrides are optional. nil means use the shared intensity.
+  (when (finite-number? value)
+    (clamp 0 1 value)))
+
+(defn sanitize-state [state]
+  ;; Every public configuration path flows through this sanitizer. That gives
+  ;; future callers one predictable state contract regardless of whether
+  ;; commands came from workers, tests, or another agency.
+  (-> state
+      (update :enabled boolean)
+      (update :frequency #(clamp 0 60 (number-or % (:frequency default-state))))
+      (update :duration #(clamp 0.05 1 (number-or % (:duration default-state))))
+      (update :intensity #(clamp 0 1 (number-or % (:intensity default-state))))
+      (update :randomness #(clamp 0 1 (number-or % (:randomness default-state))))
+      (update :leftEyeIntensity maybe-intensity)
+      (update :rightEyeIntensity maybe-intensity)
+      (update :burstEnabled boolean)
+      (update :burstFrequency #(clamp 0 1 (number-or % (:burstFrequency default-state))))
+      (update :burstCount #(int (clamp 1 8 (number-or % (:burstCount default-state)))))
+      (update :burstGap #(clamp 0.02 0.5 (number-or % (:burstGap default-state))))))
+
+(defn config->state [config]
+  ;; Convert optional JS config into the canonical CLJS map used internally.
+  (let [input (if config (js->clj config :keywordize-keys true) {})]
+    (sanitize-state (merge default-state input))))
+
+(defn visible-state [state]
+  ;; Public snapshots cross the package boundary as plain JavaScript data.
+  (clj->js state))
+
+(defn configure [state config]
+  ;; Partial configuration updates merge into current state, then sanitize.
+  (let [input (if config (js->clj config :keywordize-keys true) {})]
+    (sanitize-state (merge state input))))
+
+(defn apply-command [state payload]
+  ;; Command handling returns a new state map. Delay cancellation and emitted
+  ;; stream messages are handled by the agency/scheduler, not by these pure
+  ;; state functions.
+  (let [type (:type payload)]
+    (case type
+      "enable" (assoc state :enabled true)
+      "disable" (assoc state :enabled false)
+      "setFrequency" (sanitize-state (assoc state :frequency (:value payload)))
+      "setDuration" (sanitize-state (assoc state :duration (:value payload)))
+      "setIntensity" (sanitize-state (assoc state :intensity (:value payload)))
+      "setRandomness" (sanitize-state (assoc state :randomness (:value payload)))
+      "setLeftEyeIntensity" (sanitize-state (assoc state :leftEyeIntensity (:value payload)))
+      "setRightEyeIntensity" (sanitize-state (assoc state :rightEyeIntensity (:value payload)))
+      "setBurstEnabled" (sanitize-state (assoc state :burstEnabled (:value payload)))
+      "setBurstFrequency" (sanitize-state (assoc state :burstFrequency (:value payload)))
+      "setBurstCount" (sanitize-state (assoc state :burstCount (:value payload)))
+      "setBurstGap" (sanitize-state (assoc state :burstGap (:value payload)))
+      "configure" (configure state (:config payload))
+      "reset" default-state
+      state)))
+
+(defn record-plan [state plan now-ms]
+  ;; Called after the planner/scheduler accepts a blink plan. Counters are useful
+  ;; for UI, tests, and later agency-to-agency feedback.
+  (let [blink-count (:blink-count plan)]
+    (-> state
+        (assoc :lastBlinkTime now-ms)
+        (update :scheduledBlinkCount + blink-count)
+        (update :scheduledBurstCount + (if (> blink-count 1) 1 0)))))