AriaStreamLab 0.2.5

• Relative paths in an experiment file are relative to that file, whatever directory the
  command starts from: storage.root (before, ariastreamlab run resolved it against the
  current directory while the application used the file's folder, so the Sessions page did
  not list sessions recorded with run from elsewhere), device.profile.custom_json
  (before, the current directory) and, in a file reached through extends, its own
  processors_path and paths (before, the child's folder). ariastreamlab run examples/mock_experiment.json now writes to examples/sessions/.
• Replaying a recorded session writes the new session next to it; the frozen
  storage.root of an older session recorded with run (relative) pointed inside the
  recording, and that of a copied session at the other computer's disk.
• Stream parameters of the wrong type are configuration errors naming the key instead of a
  traceback ("period_ms": "5000"), and true or NaN are no longer accepted as numbers
  ("rate_hz": true passed as 1).
• A disabled stream entry switches its streams off instead of clashing with a group:
  "slam": {"enabled": false} and "slam_front_left": {} selects one camera of a preset's
  SLAM group (before: "configured twice"), and "slam_side_right": {"enabled": false} next
  to an enabled slam streams the other three.
• rgb at 2560x1920 above 10 fps is refused when the file is checked (the limit was only
  written in the description), and device.profile.mode: "custom" without custom_json
  likewise (before: at connect time, with the glasses on).
• Processor files are cached by path and reloaded when they change: two experiments with
  their own processors/filter.py in one application each get their own class, and an
  edited file is used by the next run without restarting. A configured processors_path
  no longer falls back to a file of the same name in the current directory. Manifests
  name the class as before.
• generic.downsample follows live parameter changes (the manifest recorded them but the
  old rate stayed in force), and gaze.project_to_rgb re-prepares its projection when its
  camera is changed live.

AriaStreamLab 0.2.4

• Lossless processing (max-speed replay, non-realtime mock) is now lossless and
  reproducible for processors with several inputs: secondary inputs use back-pressure
  instead of dropping their oldest samples, time-based joins wait for the data (not for a
  host-time timeout) and are never trimmed, and the join buffers are trimmed by time behind
  the primary. A raw secondary stream with nothing at a frame's time (a gap, or a stream
  that ended) stops holding the frame once the primary is 1 s of device time ahead.
• A processor returning something that is not an Emit/tuple or a list of them (a bare
  payload, a float) is counted as an error instead of silently ending its worker — which
  also hung a lossless replay for good; any unexpected error in a worker's loop is counted
  and the worker carries on.
• Quitting the app (closing the window, Ctrl-C in ariastreamlab app --browser or
  ariastreamlab design) waits for a session started from the browser to finalise; before,
  the process exited first and left its manifest at status: running.
• The experiment's logging section (level, format) is applied; it was ignored because
  the import-time defaults were never replaced. Reconfiguring keeps the session's
  logs/session.log handler.
• Live sessions: the device monitor survives unexpected errors (thermal mitigation reported
  without a temperature, an unparseable quality score, …) — before, one such error ended the
  thread and with it the stall detection that stops a session the glasses have stopped.
  The quality-stats parser no longer raises on a non-numeric score.
• Tests: the example-project tests no longer assume a non-realtime mock session is still
  running 0.3 s after it starts.
• Dashboard, sessions it did not start: Sessions → delete refuses the session attached to
  the dashboard whatever started it (ariastreamlab run, a notebook, a protocol script) —
  before, only a browser-started run was protected — and a session another process is still
  writing (manifest running, a file changed in the last 2 min). Run on Design and
  replay on Sessions refuse to start while any session is attached, instead of starting a
  second session against the same glasses and taking the dashboard over.
• Dashboard on the network (host: "0.0.0.0"): Design, Sessions and Setup — which
  read and write files, delete sessions, install packages and start sessions — answer only
  the computer running the experiment; other machines get the monitor. A warning is logged
  when the server listens beyond loopback, and the tutorial says what is exposed.
• Replay controls act at once: pause, seek, speed and stop interrupt the pacing wait
  instead of waiting for the next sample — across a multi-second hole in a recording they
  were dead for the whole gap (30 s at 0.25×) and stop() timed out. Seeking a paused replay
  keeps it paused at the target (it used to resume), and the position shows the target.
• Markers and intervals added during a replay (dashboard buttons, mark()/begin()/end()
  without at_ns) are stamped at the replay position; the host-clock estimate they used
  was wrong after a pause, a seek or at any speed other than 1×.
• VRS replay after a seek or with --start: sequence numbers continue from each stream's
  record index in the file instead of restarting at 0 (the statistics saw duplicates and
  the recorded sequence_number was wrong).
• Experiment.open() cleans up when it fails half-way (an unknown processor type, a
  storage or dashboard error): the statistics thread and whatever else had started are
  stopped, and a session directory that already exists is finalised as crashed instead of
  staying running.
• Experiment.wait() raises the error that ended a session started with start() (no
  glasses found, a source failure…); before, it returned True and a protocol loop went on
  annotating a session that had stopped.
• Ctrl-C ends a session normally (completed, with an "interrupted" warning) whether it was
  pressed during run() or in the protocol loop of a start()ed session; the latter used
  to mark it crashed.
• An Experiment is one session: open()/run() after close() raise instead of writing
  an empty "completed" session that carried the first one's statistics.
• Release workflow: a tag is published only after the whole CI suite (lint, types, import
  contracts, tests on Ubuntu and macOS, wheel build) passes on that tag; the tag must be
  vX.Y.Z and reaches the shell through an environment variable (a crafted tag name given
  to the manual re-publish could run commands); the workflow token is read-only except for
  the publishing job, and every third-party action is pinned to a commit.