One sorted set, five readings.

The five jobs in this scenario are all about codemojex entities, each carrying its own branded namespace. Codemojex.NotificationWorker mints a fresh NOT id with EchoData.BrandedId.generate!("NOT") for every re-enqueued occurrence.

• USR — a player account.
• RMM — a room, the chat where a game runs.
• RND — a round, one secret to guess.
• NOT — a notification job, minted fresh per occurrence.

Codemojex.NotificationWorker is the real worker. An EchoMQ.Consumer drains the cm.notify queue and handle/1 delivers each notice through the bot under three layers of control: fairness — a fair lane per chat via Codemojex.Notifier, so one chat’s burst cannot starve others; rate — a token from Codemojex.RateLimiter before each send, global about thirty a second, per-chat about one a second; and delivery — EchoBot.deliver/3 classifies the Telegram result, success acks, a transient failure re-enqueues with capped exponential backoff up to @max_attempts of six, a permanent failure acks-and-drops. The payload is JSON {chat, text, opts, id, attempt}. The five readings below are the chapter’s patterns assembled on top of that worker.

Pick a move to read which EchoMQ surface it calls and which sorted set it writes. Each move is a different reading of the same ZADD / range / rank machinery; the readout names the call and the score the move pours in.

Move 1 — the round-start reminder (R4.01). EchoMQ schedules a reminder for an absolute due time with EchoMQ.Jobs.enqueue_at(conn, queue, job_id, payload, run_at_ms). The job’s row is written state = scheduled and the branded JOB id is parked on emq:{cm.notify}:schedule, scored by the run-at millisecond. The @schedule Lua declares both keys and guards the id:

When the clock reaches the score, EchoMQ.Jobs.promote(conn, queue, batch) sweeps the due head with ZRANGEBYSCORE -inf now LIMIT 0 batch — now read from the server clock (redis.call('TIME')) — then ZREMs each due id and moves it to emq:{cm.notify}:pending. The mint-ordered id stays the sort key once promoted.

Move 2 — the daily standings digest (R4.02). A recurring schedule is a registration the bus sweeps: EchoMQ.Repeat.register(conn, queue, name, every_ms, template, first_in_ms). The @register Lua declares two {q}-hashtagged keys — emq:{cm.notify}:repeat, scored by next-run millisecond, and emq:{cm.notify}:repeat:<name>, the record hash carrying every_ms and the payload template — and guards with if redis.call('EXISTS', KEYS[2]) == 1 then return 0, so a second register of a live name answers :exists and changes nothing. That guard is what makes a reboot safe: a service re-registers all its schedules on boot, and a live name is a no-op rather than a second row. The pump reads due names with EchoMQ.Repeat.due/3, mints a fresh JOB id per occurrence, and calls EchoMQ.Repeat.advance/4 to re-score the name to now plus every_ms. The EchoMQ.Metronome per-queue beat drives that sweep.

Move 3 — the over-budget deferral (R4.03). The chapter packed a priority tier and an arrival counter into one score so a high-precedence job pops ahead. codemojex makes the same do-not-let-a-flood-starve-the-rest guarantee, but with fairness plus rate, not a packed priority score — the honest applied move. Codemojex.Notifier enqueues each notice on a fair lane per chat; before each send handle/1 takes a token from Codemojex.RateLimiter. When the bucket is empty, RateLimiter.take(chat) returns {:wait, ms} and the worker does not block the consumer: it re-enqueues the exact notification after the reported wait with EchoMQ.Jobs.enqueue_in(conn, queue, job_id, payload, delay_ms), and acks. The notice stays durable on the bus, deferred, not dropped. enqueue_in/6 is enqueue_at/6’s relative twin: the run-at score is computed wire-side from the server clock, so the delay is measured on the same clock promote/3 and reap/2 read. The composite-priority score (priority × 232 + arrival) is the alternative reading of the same set; the codemojex design is built on the fair lane and the token bucket instead.

Move 4 — the backed-off retry (R4.04). A delivery fails: Telegram returns a transient 429 or 5xx. EchoBot.deliver/3 classifies it {:retry, reason}, and while attempt < @max_attempts the worker re-enqueues the same notice with a growing delay so a struggling endpoint is not hammered. The reschedule re-uses the schedule set — enqueue_in/6 parks the job on emq:{cm.notify}:schedule at the backoff fire-time, and the same promote/3 sweep brings it back. The curve is EchoMQ.Backoff.delay_ms(policy, attempts), a pure function above the wire:

The {:jitter, inner} policy wraps any inner curve with a uniform draw in 0..inner_delay, the full-jitter form that spreads a retry storm so a batch that failed together does not re-fire in one synchronized spike. The host computes the literal delay; the wire takes a literal delay_ms and never computes a curve.

Move 5 — the ranking the digest carries (R4.05). The digest names the room’s top players. Codemojex.Scoring computes a player’s score from their guess — points = 100 - 20*d for each guessed emoji at distance d from its secret position, totalled over six positions out of @max 600, the percentage round(total / 600 * 100) computed never stored. A leaderboard that ranks players by that percentage is exactly this pattern applied to the score: ZADD board <percentage> <player>, and the top-N players are a ZREVRANGE board 0 N-1, a player’s standing a ZREVRANK. The rank is computed on read in O(log N), never stored.

Read back through the five moves and one structure stands behind all of them. The reminder scores by a run-at, the digest by a next-run, the deferral by a wait, the retry by a backoff delay, and the ranking by a percentage — five different numbers, one sorted set. The ZADD that writes the score, the range read that takes the due head, and the rank read are the same operations every time.

Every job in this scenario is durable while it waits: a scheduled notice, a deferred send, a backed-off retry all sit on emq:{cm.notify}:schedule in Valkey, surviving a worker crash and returned by the promote/3 sweep on recovery. Past the bus, the persistence floor takes the load that must outlive the volatile tiers — a notification archive, or an audit of every notice sent. That is a fold from the bus into the durable page tier: EchoStore’s native engine on CubDB, replicated off-box to Tigris behind a create-only commit fence. Durability is a dial the system turns; the enqueue hot path touches only the bus, never a database on the path of every send.