Return Point

Save your place in a Twitch stream. When you return, see what's changed and where each report came from.

Comment

Inspiration

Streams move quickly. Step away for a drink and you can come back to a boss fight on its third attempt, with no idea how it got there. Asking chat helps, but someone has to explain it again. I built Return Point to give viewers a way to keep their own place in a stream.

What it does

Click Save my place before stepping away. When you return, Return Point shows the activity, goal, attempt and Twitch category at your checkpoint beside the latest captured reports. Your checkpoint stays where you put it until you choose Mark caught up.

In the demo, Viewer A saves while the broadcaster is exploring the ruins. Viewer B saves later, during the boss fight. When the stream reaches attempt three, both see the same latest update, but each comparison starts at a different moment. Checkpoints stay in each viewer's browser; no viewer account is needed.

The broadcaster updates activity, goal and attempt through a control page. Broadcasters and moderators can also report activity with !now and add notes with !moment in Twitch chat. Category comes from Twitch. Return Point compares these reports; it does not watch gameplay or generate an AI recap.

You can open a value to check who reported it, the original command, and when it was sent and received. When a captured deletion or chat clear removes a report, the evidence already open on screen updates too. A missing source does not bring an older report back as current. Gaps in collection are shown alongside the comparison.

How I used Codex

I used OpenAI Codex to plan the checkpoint and event model, build the Twitch integration and React interface, and write and run the regression tests. Much of the work was deciding what a viewer should see when a report arrives late, disappears, or falls inside a collection gap.

One useful example was a bug in the five-minute moderation window after a stream ends. If the collector disconnected or restarted, it could stop listening before that window was over. With Codex, I changed recovery to use the stored broadcast end time and added tests for reconnecting, removing a source from an ended stream, and keeping the original deadline.

The app uses TypeScript and React on Cloudflare Workers. A SQLite-backed Durable Object keeps the channel's event journal. Twitch EventSub supplies reports and stream events; Helix checks stream availability and the current category. Small WebSocket notifications tell viewers when a fresh comparison is available.

Challenges and what we learned

A report can arrive after a newer one. Deleting a report can also leave a hole in what the app knows. Those cases needed clear rules: keep the reported time separate from the arrival time, remove withdrawn evidence, and leave uncertainty visible.

Twitch does not replay events missed during a disconnect. Reconnecting can recover some current metadata, but it cannot tell us everything that happened in the gap. The interface has to make that understandable without asking viewers to read an engineering report.

Testing it

The video comes from a real, controlled Twitch broadcast. I checked two independent checkpoints, different comparisons, source details, and chat-clear withdrawal in an evidence panel that was already open. A second clear also passed during the moderation window after the broadcast ended.

The final engineering candidate passed 78 unit/integration tests and 51 browser scenarios across Chromium, Firefox and WebKit in clean Linux CI. The build, production smoke checks, dependency audit and Cloudflare deployment bundles passed too. Hosted checks confirmed that the deployed files matched the build and that viewer notifications worked.

A separate local load test used 200 viewer connections and 500 reports for at least a minute. That gives a useful local measurement, not a hosted capacity guarantee. Keyboard, mobile and automated accessibility checks also passed; physical-device and screen-reader testing remain future work.

What's next

I want to put Return Point in front of viewers who have never seen it and find out whether the comparison helps them get back into a stream. I also want to work with a streamer or moderator to understand how much effort it takes to keep reports current. Those answers matter more than adding more features.

Try it out

  1. Open the public replay. The banner clearly identifies synthetic events.
  2. Select Save my place. Open Replay controls and advance one scene.
  3. Use Copy viewer B link and open the link in a private browser window. Save B's place there, then advance another scene in the controls.
  4. Return to both viewers. Their before values differ because their checkpoints differ. If already in the foreground, select New updates captured. Open View latest evidence for Activity.
  5. Continue through the replay for collection gaps, uncertain reconciliation and source withdrawal. The Mark caught up action moves only that viewer's checkpoint.

The live viewer shows actual Twitch reports while imakishima is broadcasting and an honest ended/waiting state between broadcasts. Judges can test the replay at any time without a Twitch account or stream.

For local execution use Node.js 24, npm ci, then npm run demo. Open http://localhost:3001/c/clockwork and http://localhost:3001/control. The replay requires no credentials and never connects to Twitch. Live configuration and deployment instructions are in the README and deployment guide.

Limitations

  • Activity, goal and attempt depend on maintained human reports. Category is Twitch metadata. No gameplay is inferred.
  • Missed EventSub notifications cannot be replayed. Reconciliation can restore current metadata with uncertain timing.
  • The collector parks after a five-minute offline grace period. Later chat deletions may be missed. Public source text expires after 24 hours; storage cleanup and backups have their own operational lifecycle.
  • Twitch's individual chat-message deletion endpoint excludes broadcaster messages; the real withdrawal demo uses chat clear. The historical source-14 deletion was not independently proved.
  • One broadcaster per deployment; Cloudflare Free quotas are shared by the account. No universal latency, arbitrary stream-duration or hosted-concurrency guarantee is made.
  • The original primary Codex build chat was accidentally deleted by the participant. Its ID is supplied truthfully, with this active hardening chat as additional evidence. Retrieval by judges is not guaranteed.

Built With

Share this project:

Updates

Submission history