domma-cms 1.9.1 → 1.10.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.10.0] - 2026-10-24
+
+- **A new game every day, from a queue (rotation).** The Games library gains rotation, off until a site switches it on: a **Queued** status, a **Rotate** setting (Off, Every day, Every week) in a Rotation card above each Game's list, and the site's midnight opening the next queued game and moving the last one to an archive - still playable, never on a leaderboard. A restart never rotates twice; an empty queue leaves today's game up. `[quiz rotate /]` (and `[crossword rotate]`, `[word-search rotate]`) always shows today's game with the earlier ones below; notices when the queue runs low or empty. Fresh games from Domma arrive as drafts marked **From Domma**, with **Approve all**. `plugins/_lib/games/rotation.js`, `rotation-http.js`, `_lib/public/games/rotation.js`, `_lib/admin/games/rotation.js`; archive plays in `plays.js`. Quiz 1.5.0, Crossword 1.5.0, Word Search 1.2.0 and Daily Word 1.3.0 need this release.
+
 ## [1.9.1] - 2026-10-24
 
 - Columns support content alignment with [col left], [col center] / [col centre], [col right] or align="...". The Page editor offers a Content alignment selector for columns.

package/docs/DommaFeatures.md

@@ -38,8 +38,8 @@ Code was treated as the truth. Where docs disagree with it, the disagreement is
 | `calendar` | paid | 1.15.4 | Events calendar - month, day and list views, online meetings as a video call on your site (with the call's chat kept, and Add people during the call), call anyone now from a contact or an email, all-day and recurring events, sharing with people and roles, RSVPs and an iCal feed. |
 | `campaigns-pro` | paid | 1.0.2 | Marketing campaigns, one paid Tool: compose a message, send it to an audience imported from Contacts (shared with Surveys), schedule sends, attach an offer that closes by a date or a claim limit. Opens and clicks (cookieless), links tagged for Analytics, a linked Shop discount code, send a survey as a campaign, follow-up sequences, resend to non-openers, A/B subject tests, and a version-1 stats feed other Tools read. |
 | `contacts-pro` | paid | 0.12.0 | Contacts, with more to them: your own custom fields, birthdays and ages with the ones coming up and a reminder in the sidebar, and groups with their own emblem and colours. Share a contact, several, or a whole group with people or roles - to view, or to edit. Call a contact now on a video call on your site. Works over the same contacts as the built-in Tool, so nothing moves and nothing is lost. |
-| `crossword` | paid (giftable) | 1.4.0 | Crosswords on your site: type the answers and clues and the grid lays itself out (live preview, Another layout). Players type a name and race the server's clock, checks and wrong guesses cost time, fastest solvers on a leaderboard. Hints for a time penalty, personal best and Share, animations, export and import. Test it from the Tool - a test go never reaches the board. |
-| `daily-word` | paid (giftable) | 1.2.0 | One hidden word a day, the same for everyone: six guesses, each letter marked right place, in the word or not; real words only (a bundled dictionary, switchable), an archive of past days, streaks, Share as coloured squares, a calendar of what is coming. Fewest guesses tops the day's board, then the fastest. |
+| `crossword` | paid (giftable) | 1.5.0 | Crosswords on your site: type the answers and clues and the grid lays itself out (live preview, Another layout). Players type a name and race the server's clock, checks and wrong guesses cost time, fastest solvers on a leaderboard. Hints for a time penalty, personal best and Share, animations, export and import. Test it from the Tool - a test go never reaches the board. Rotation (a new quiz every day or week from a queue, off by default) and fresh quizzes from Domma for review. |
+| `daily-word` | paid (giftable) | 1.3.0 | One hidden word a day, the same for everyone: six guesses, each letter marked right place, in the word or not; real words only (a bundled dictionary, switchable), an archive of past days, streaks, Share as coloured squares, a calendar of what is coming. Fewest guesses tops the day's board, then the fastest. |
 | `data-transfer` | paid | 1.3.3 | Move collections between file and MongoDB storage, back them up and restore them (all or some, merged or replaced) - keeping every entry's id - and clone them (cloned entries get new ids, so references stay unambiguous). Every restore and transfer takes a safety snapshot first. |
 | `docs` | paid | 2.13.1 | Document editor: Home and editor screens, sharing with Viewers/Editors, public links, import/export, send to page/blog/email, edit lock, Trash, version history, templates. PDF documents (2.13): a PDF kept as it is, shown in the browser's viewer, searchable inside, versioned on replace. |
 | `docs-pro` | paid | 0.11.0 | Domma Spaces (publish a Docs folder at `/spaces` with a Kindle-style reader), Cloud copies (Google Drive, OneDrive, Dropbox, S3), Signatures (emailed signing links, typed or drawn, signed copy with a certificate page; 0.10: boxes placed on a PDF document's pages, the signed PDF stamped with pdf-lib), PDF tools (0.11: fill the PDF's own form, annotate, pages) and protected public links (expiry date, password). Adds to Docs. |
@@ -52,7 +52,7 @@ Code was treated as the truth. Where docs disagree with it, the disagreement is
 | `messages` | paid | 1.7.2 | Internal user-to-user and group messaging with real-time delivery and video calls (what is typed in a call lands in the conversation; ring another team member into a call) - conversations you can archive, mark unread and search, drafts kept per conversation, attachments, and an unread badge in the sidebar. |
 | `mongodb-adapter` | paid | 1.0.2 | Provision a dedicated MongoDB database per site. Credentials are managed centrally by the manager. |
 | `onboard-pro` | paid | 1.0.1 | Onboarding journeys, one paid Tool: read/form/details/manual steps, a personal link per person, signature steps through Docs Pro, admin-approved account steps (never an administrator), due dates, automatic nudges and auto-enrolment from a contact group, countersigned steps, waive-with-a-reason, and a funnel showing where people stop. |
-| `quiz` | paid (giftable) | 1.4.0 | Timed quizzes on your site: one or several right answers, true or false, or a typed answer, marked by the server so answers never reach the browser early. Name-only players, leaderboards by day, week, month and all time. Hints for a time penalty, personal best and Share, animations, export and import. Test it from the Tool - a test go never reaches the board. |
+| `quiz` | paid (giftable) | 1.5.0 | Timed quizzes on your site: one or several right answers, true or false, or a typed answer, marked by the server so answers never reach the browser early. Name-only players, leaderboards by day, week, month and all time. Hints for a time penalty, personal best and Share, animations, export and import. Test it from the Tool - a test go never reaches the board. Rotation (a new quiz every day or week from a queue, off by default) and fresh quizzes from Domma for review. |
 | `security` | free | 1.1.3 | Keeps a Domma CMS site safe: a health check of what is weak and how to fix it, sign-in lockout after repeated wrong passwords, password rules, a log of every sign-in, and blocking of the scanners that probe every site for WordPress, .env files and the like. |
 | `security-pro` | paid | 1.3.2 | Everything in Security, plus two-factor sign-in (authenticator apps, recovery codes, required per role), a firewall that bans scanners for longer each time they return, per-route rate limits, country rules for the admin, breached-password checks and every signed-in session in one place. |
 | `seo-pro` | paid | 0.6.2 | More for SEO: Google Search Console in the admin (with your own Google client) - searches, clicks, positions and where to win more; structured data for rich results (FAQ, how-to, product, event, local business); links worth adding between pages, pages competing for one search, readability, near duplicates and image checks; every title and description in one grid, and moving an old site's addresses across as redirects; a not-found log with one-click redirects; a scheduled check of every link; SEO history and notices. Adds to SEO, which is built into Domma CMS (0.90 and later). |
@@ -63,7 +63,7 @@ Code was treated as the truth. Where docs disagree with it, the disagreement is
 | `surveys` | paid | 1.5.1 | Targeted surveys over the Forms engine: shared audiences, tokenised invites, reminders, and per-survey statistics. |
 | `theme-roller` | paid | 1.1.3 | Make your own themes: start from any built-in theme, change its colours, fonts, spacing and borders with a live preview, and save it. Saved themes join the built-in ones everywhere a theme is chosen - the site, the admin, day and night, a region of a page. Needs Domma CMS 0.73 or later to use them. |
 | `waypoint-pro` | paid | 1.3.1 | Plan and track work: projects with their own workflows, issues on a board or in a list, a backlog planned into sprints with a burndown, and comments, mentions and watchers that tell the right people. |
-| `word-search` | paid (giftable) | 1.1.0 | Word searches on your site: type up to 40 words and the server lays out the letter grid (across, down, diagonal, backwards too if you like). Players drag, tap or use the keyboard to mark each word against the clock; wrong marks cost time, fastest full solve wins. Hints, personal best, Share, animations, export and import. |
+| `word-search` | paid (giftable) | 1.2.0 | Word searches on your site: type up to 40 words and the server lays out the letter grid (across, down, diagonal, backwards too if you like). Players drag, tap or use the keyboard to mark each word against the clock; wrong marks cost time, fastest full solve wins. Hints, personal best, Share, animations, export and import. |
 
 Versions are read from `dcms-marketplace/plugins/*/plugin.json` (every plugin folder except `_lib`).
 
@@ -2419,7 +2419,7 @@ Tier: paid (closed source) · Version: 0.4.0 · Requires: nothing; no MongoDB (w
 
 ### Games: Quiz (`quiz`), Crossword (`crossword`), Word Search (`word-search`) and Daily Word (`daily-word`)
 
-Tier: paid and giftable (the Manager can gift them for good or for a number of days) · Versions: Quiz 1.4.0, Crossword 1.4.0, Word Search 1.1.0, Daily Word 1.2.0 (need Domma CMS 1.9.0 for the shared games library and its motion files) · Sidebar: Tools > Games · Permissions: a Games group in the role editor
+Tier: paid and giftable (the Manager can gift them for good or for a number of days) · Versions: Quiz 1.5.0, Crossword 1.5.0, Word Search 1.2.0, Daily Word 1.3.0 (need Domma CMS 1.10.0 for rotation in the shared games library; 1.4.0/1.4.0/1.1.0/1.2.0 needed 1.9.0) · Sidebar: Tools > Games · Permissions: a Games group in the role editor
 
 All four share the engine's games library (`plugins/_lib/games`: plays, tokens, names, ranking, timing; `plugins/_lib/public/games`: player parts and motion; `plugins/_lib/admin/games/kit.js`: list, editor, test and plays screens). The server keeps the clock and marks every move; nothing that gives an answer reaches the browser before the play is finished. Name-only players, honeypot and rate limits, test plays from the Tool, a sidebar badge, notifications. The generic Collections API reaches a game's collections only with the game's `manage` action (`collectionAction` in plugin.json).
 
@@ -2457,6 +2457,8 @@ All four share the engine's games library (`plugins/_lib/games`: plays, tokens,
 - **Boards** - `board="show|hide|only"` on every game shortcode; a per-game **Leaderboard shows** period (`boardPeriod`) used when no period is asked for; `[games-leaderboards games="..." period="..." limit="..."]` puts every Game's boards on one page (each game registers the same handler, so it works with any of them installed). Board shortcodes on the page refresh when a game finishes.
 - **Personal best** on every finished screen; **Share** (no answers) on Quiz, Crossword and Word Search, coloured squares on Daily Word.
 - **Animations** - a per-game setting, on unless switched off: answers, letters and tiles pop or flip in, right and wrong answers pulse, found words pop along their line, finished screens and board rows pop in. Never under `prefers-reduced-motion` or `html.dm-reduced-motion`. Shared CSS and helpers: `plugins/_lib/public/games/motion.css` and `motion.js` (engine 1.9.0).
+- **Rotation** (Quiz 1.5.0, Crossword 1.5.0, Word Search 1.2.0; engine 1.10.0) - **off by default**. A game can be **Queued** (never shown to the public until its turn). **Rotate** Off / Every day / Every week (a weekday), in a Rotation card above each list: at the site's midnight the next queued game opens and the last one rotation opened closes into an archive - still playable, its plays (`archive: true`) never on a board, place or goes-per-name. Idempotent: `lastRotatedDay` in the Tool's `data/rotation.json`, plus a check that no game was already opened by rotation that day, so a restart at 00:00:30 never rotates twice; a one-minute timer in the Tool, no cron. An empty queue leaves today's game up. Drag to reorder the queue; take one out. `[quiz rotate /]` (and `[crossword rotate]`, `[word-search rotate]`) shows today's game with the earlier ones below; `[<game>-leaderboard rotate /]` today's board. Notices `queue-low` (under three days queued) and `queue-empty`. Engine: `plugins/_lib/games/rotation.js` (pure rules + runner), `rotation-http.js` (`GET/PUT /rotation`, `PUT /queue`, `POST /approve`, `POST /unqueue`, `GET /content/status`, `GET /public/rotation`), `_lib/public/games/rotation.js`, `_lib/admin/games/rotation.js`; tests `tests/plugins/games-rotation.test.js`.
+- **Fresh games from Domma** (the Manager's Games content, off by default per site) - quizzes, crosswords and word searches written by Claude (Haiku) on the site's theme (or one picked at random each night when it has none) arrive through `POST /import` with `{source: 'domma-content', status}` as **drafts marked From Domma** (or queued, with the site's auto-publish), and the admins get a `content-ready` notice. The Rotation card's **Show only these** and **Approve all**; Approve / Take out of the queue in each row's menu. Daily Word 1.3.0: **Top up** on a word set (off by default) takes common words picked by the Manager (no Claude, never repeated within two years) into `pending` for **Approve all** / **Discard** in the editor or the list's menu (`POST /content/words`, `POST /sets/:id/pending`). Only while the Tool asks for it: Rotate on, or a set with Top up.
 
 ### Other plugin directories
 
@@ -2555,6 +2557,7 @@ Later changes to these features are in the CHANGELOG (for example 0.92.1: row-le
 ### Plugins & the Marketplace platform
 
 - A games page: a Daily Word set with a month of answers, a Word Search and a Quiz on one page, with `[games-leaderboards]` below them; hints with a penalty, and moving a game to another site with Export and Import.
+- A page that never needs editing: queue a week of quizzes, switch Rotate on, put `[quiz rotate /]` on the page, and approve Domma's fresh quizzes as they arrive.
 - Gifting a Tool from the Manager: gift a Game for 30 days, extend it, make it for good, and end it.
 - Build your first plugin in 10 minutes: New plugin in the Marketplace, add a route and a screen in the code editor, restart, see it in the sidebar.
 - Add a custom shortcode and let its HTML through the sanitiser (`registerShortcode` + `registerSanitizeRules`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",

package/plugins/_lib/admin/games/games.css

@@ -1 +1 @@
-.gma{--gma-line: var(--dm-border, rgba(128, 128, 128, .3));--gma-soft: color-mix(in srgb, var(--dm-text) 5%, transparent);display:flex;flex-direction:column;gap:1rem;min-width:0}.gma [hidden]{display:none!important}.gma-screen{display:flex;flex-direction:column;gap:1rem;min-width:0}.gma-bar{display:flex;flex-wrap:wrap;gap:.5rem;align-items:center}.gma-spacer{flex:1}.gma-muted{color:var(--dm-text-muted)}.gma-note{margin:0;font-size:var(--dm-text-sm);color:var(--dm-text-muted)}.gma-error{color:var(--dm-danger);margin:0}.gma-danger-text{color:var(--dm-danger)!important}.gma-h{margin:0 0 .5rem;font-size:1rem;font-weight:600}.gma-card{border:1px solid var(--gma-line);border-radius:var(--dm-radius-md, 8px);padding:1rem;background:var(--dm-surface, transparent);display:flex;flex-direction:column;gap:.75rem;min-width:0}.gma-two{display:grid;grid-template-columns:minmax(0,2fr) minmax(16rem,1fr);gap:1rem;align-items:start}@media(max-width:1000px){.gma-two{grid-template-columns:minmax(0,1fr)}}.gma-chip{display:inline-flex;align-items:center;font-size:var(--dm-text-xs);font-weight:600;padding:.1rem .55rem;border-radius:999px;white-space:nowrap;background:color-mix(in srgb,var(--dm-text) 9%,transparent);color:var(--dm-text-muted);margin-left:.4rem}.gma-chip.is-success{background:color-mix(in srgb,var(--dm-success) 15%,transparent);color:var(--dm-success)}.gma-chip.is-warning{background:color-mix(in srgb,var(--dm-warning) 16%,transparent);color:color-mix(in srgb,var(--dm-warning) 55%,var(--dm-text))}.gma-chip.is-primary{background:color-mix(in srgb,var(--dm-primary) 14%,transparent);color:var(--dm-primary)}.gma-list{display:flex;flex-direction:column;gap:.5rem}.gma-row{display:flex;flex-wrap:wrap;align-items:center;gap:.75rem;padding:.75rem 1rem;border:1px solid var(--gma-line);border-radius:var(--dm-radius-md, 8px);background:var(--dm-surface, transparent)}.gma-row:hover{border-color:color-mix(in srgb,var(--dm-primary) 45%,var(--gma-line))}.gma-row-main{flex:1 1 16rem;min-width:0;display:flex;flex-direction:column;gap:.15rem}.gma-row-main a{font-weight:600;color:var(--dm-text);text-decoration:none}.gma-row-main a:hover{color:var(--dm-primary)}.gma-row-main small{color:var(--dm-text-muted)}.gma-row-actions{display:flex;flex-wrap:wrap;gap:.25rem}.gma-empty{display:flex;flex-direction:column;align-items:center;gap:.5rem;text-align:center;padding:2.5rem 1rem;color:var(--dm-text-muted)}.gma-empty strong{color:var(--dm-text)}.gma-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(14rem,1fr));gap:.25rem 1rem}.gma-field{margin:0;min-width:0}.gma-toggle{display:inline-flex;align-items:center;gap:.5rem;cursor:pointer;font-weight:500}.gma-shortcode{display:flex;gap:.5rem;align-items:center;flex-wrap:wrap}.gma-shortcode code{padding:.3rem .55rem;border-radius:6px;background:var(--gma-soft);font-size:var(--dm-text-sm)}.gma-save{position:sticky;bottom:0;z-index:5;display:flex;gap:.5rem;align-items:center;flex-wrap:wrap;padding:.75rem 1rem;border:1px solid var(--gma-line);border-radius:var(--dm-radius-md, 8px);background:var(--dm-background, var(--dm-surface))}.gma-save .is-dirty{color:color-mix(in srgb,var(--dm-warning) 60%,var(--dm-text));font-size:var(--dm-text-sm)}.gma-stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(9rem,1fr));gap:.75rem}.gma-stat{padding:.75rem 1rem}.gma-table-wrap{overflow-x:auto}.gma-table{width:100%;border-collapse:collapse;font-size:var(--dm-text-sm)}.gma-table th,.gma-table td{padding:.45rem .5rem;border-bottom:1px solid var(--gma-line);text-align:left;vertical-align:middle}.gma-table th{font-weight:600;color:var(--dm-text-muted)}.gma-table tr.is-hidden td{opacity:.55}.gma-num{text-align:right!important;font-variant-numeric:tabular-nums;white-space:nowrap}.gma-actions{white-space:nowrap;text-align:right!important}.gma-board{margin:0;padding:0;list-style:none;display:flex;flex-direction:column}.gma-board li{display:grid;grid-template-columns:2.6rem 1fr auto auto;gap:.5rem;padding:.35rem 0;border-bottom:1px solid var(--gma-line);align-items:center}.gma-board li:last-child{border-bottom:0}.gma-rank{font-weight:700}.gma-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.gma-row{cursor:pointer}.gma-row:focus-visible{outline:2px solid var(--dm-primary);outline-offset:2px}.gma-kebab{border:0;background:transparent;color:var(--dm-text-muted);font-size:1.1rem;line-height:1;padding:.25rem .5rem;border-radius:6px;cursor:pointer}.gma-kebab:hover{background:var(--gma-soft);color:var(--dm-text)}.gma-quiet{opacity:.6}.gma-quiet:hover{opacity:1}.gma-grip{cursor:grab;color:var(--dm-text-muted);display:inline-flex;padding:.2rem;touch-action:none}.gma-grip:active{cursor:grabbing}.gma-test-stage{border:1px dashed var(--gma-line);border-radius:var(--dm-radius-md, 8px);padding:.5rem 1rem;background:var(--gma-soft)}.gma-test-stage .gm-app{margin:.5rem auto}
+.gma{--gma-line: var(--dm-border, rgba(128, 128, 128, .3));--gma-soft: color-mix(in srgb, var(--dm-text) 5%, transparent);display:flex;flex-direction:column;gap:1rem;min-width:0}.gma [hidden]{display:none!important}.gma-screen{display:flex;flex-direction:column;gap:1rem;min-width:0}.gma-bar{display:flex;flex-wrap:wrap;gap:.5rem;align-items:center}.gma-spacer{flex:1}.gma-muted{color:var(--dm-text-muted)}.gma-note{margin:0;font-size:var(--dm-text-sm);color:var(--dm-text-muted)}.gma-error{color:var(--dm-danger);margin:0}.gma-danger-text{color:var(--dm-danger)!important}.gma-h{margin:0 0 .5rem;font-size:1rem;font-weight:600}.gma-card{border:1px solid var(--gma-line);border-radius:var(--dm-radius-md, 8px);padding:1rem;background:var(--dm-surface, transparent);display:flex;flex-direction:column;gap:.75rem;min-width:0}.gma-two{display:grid;grid-template-columns:minmax(0,2fr) minmax(16rem,1fr);gap:1rem;align-items:start}@media(max-width:1000px){.gma-two{grid-template-columns:minmax(0,1fr)}}.gma-chip{display:inline-flex;align-items:center;font-size:var(--dm-text-xs);font-weight:600;padding:.1rem .55rem;border-radius:999px;white-space:nowrap;background:color-mix(in srgb,var(--dm-text) 9%,transparent);color:var(--dm-text-muted);margin-left:.4rem}.gma-chip.is-success{background:color-mix(in srgb,var(--dm-success) 15%,transparent);color:var(--dm-success)}.gma-chip.is-warning{background:color-mix(in srgb,var(--dm-warning) 16%,transparent);color:color-mix(in srgb,var(--dm-warning) 55%,var(--dm-text))}.gma-chip.is-primary{background:color-mix(in srgb,var(--dm-primary) 14%,transparent);color:var(--dm-primary)}.gma-list{display:flex;flex-direction:column;gap:.5rem}.gma-row{display:flex;flex-wrap:wrap;align-items:center;gap:.75rem;padding:.75rem 1rem;border:1px solid var(--gma-line);border-radius:var(--dm-radius-md, 8px);background:var(--dm-surface, transparent)}.gma-row:hover{border-color:color-mix(in srgb,var(--dm-primary) 45%,var(--gma-line))}.gma-row-main{flex:1 1 16rem;min-width:0;display:flex;flex-direction:column;gap:.15rem}.gma-row-main a{font-weight:600;color:var(--dm-text);text-decoration:none}.gma-row-main a:hover{color:var(--dm-primary)}.gma-row-main small{color:var(--dm-text-muted)}.gma-row-actions{display:flex;flex-wrap:wrap;gap:.25rem}.gma-empty{display:flex;flex-direction:column;align-items:center;gap:.5rem;text-align:center;padding:2.5rem 1rem;color:var(--dm-text-muted)}.gma-empty strong{color:var(--dm-text)}.gma-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(14rem,1fr));gap:.25rem 1rem}.gma-field{margin:0;min-width:0}.gma-toggle{display:inline-flex;align-items:center;gap:.5rem;cursor:pointer;font-weight:500}.gma-shortcode{display:flex;gap:.5rem;align-items:center;flex-wrap:wrap}.gma-shortcode code{padding:.3rem .55rem;border-radius:6px;background:var(--gma-soft);font-size:var(--dm-text-sm)}.gma-save{position:sticky;bottom:0;z-index:5;display:flex;gap:.5rem;align-items:center;flex-wrap:wrap;padding:.75rem 1rem;border:1px solid var(--gma-line);border-radius:var(--dm-radius-md, 8px);background:var(--dm-background, var(--dm-surface))}.gma-save .is-dirty{color:color-mix(in srgb,var(--dm-warning) 60%,var(--dm-text));font-size:var(--dm-text-sm)}.gma-stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(9rem,1fr));gap:.75rem}.gma-stat{padding:.75rem 1rem}.gma-table-wrap{overflow-x:auto}.gma-table{width:100%;border-collapse:collapse;font-size:var(--dm-text-sm)}.gma-table th,.gma-table td{padding:.45rem .5rem;border-bottom:1px solid var(--gma-line);text-align:left;vertical-align:middle}.gma-table th{font-weight:600;color:var(--dm-text-muted)}.gma-table tr.is-hidden td{opacity:.55}.gma-num{text-align:right!important;font-variant-numeric:tabular-nums;white-space:nowrap}.gma-actions{white-space:nowrap;text-align:right!important}.gma-board{margin:0;padding:0;list-style:none;display:flex;flex-direction:column}.gma-board li{display:grid;grid-template-columns:2.6rem 1fr auto auto;gap:.5rem;padding:.35rem 0;border-bottom:1px solid var(--gma-line);align-items:center}.gma-board li:last-child{border-bottom:0}.gma-rank{font-weight:700}.gma-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.gma-row{cursor:pointer}.gma-row:focus-visible{outline:2px solid var(--dm-primary);outline-offset:2px}.gma-kebab{border:0;background:transparent;color:var(--dm-text-muted);font-size:1.1rem;line-height:1;padding:.25rem .5rem;border-radius:6px;cursor:pointer}.gma-kebab:hover{background:var(--gma-soft);color:var(--dm-text)}.gma-quiet{opacity:.6}.gma-quiet:hover{opacity:1}.gma-grip{cursor:grab;color:var(--dm-text-muted);display:inline-flex;padding:.2rem;touch-action:none}.gma-grip:active{cursor:grabbing}.gma-test-stage{border:1px dashed var(--gma-line);border-radius:var(--dm-radius-md, 8px);padding:.5rem 1rem;background:var(--gma-soft)}.gma-test-stage .gm-app{margin:.5rem auto}.gma-inline{display:inline-flex;align-items:center;gap:.4rem;font-size:var(--dm-text-sm)}.gma-inline .form-select{width:auto}.gma-waiting{display:flex;flex-wrap:wrap;gap:.5rem;align-items:center}.gma-queue{display:flex;flex-direction:column;gap:.25rem;margin-top:.25rem}.gma-qrow{display:flex;align-items:center;gap:.5rem;padding:.35rem .5rem;border:1px solid var(--gma-line);border-radius:6px;background:var(--dm-surface, transparent)}.gma-qnum{color:var(--dm-text-muted);font-variant-numeric:tabular-nums;min-width:1.6rem}.gma-qtitle{font-weight:600;color:var(--dm-text);text-decoration:none;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.gma-qtitle:hover{color:var(--dm-primary)}

package/plugins/_lib/admin/games/rotation.js

@@ -0,0 +1,174 @@
+/**
+ * Games admin - the Rotation card a rotating Tool shows above its list: the
+ * Rotate setting (Off by default), today's game, the queue (drag to reorder,
+ * take one out), and the games from Domma waiting for review (Approve all, or
+ * show only them in the list).
+ *
+ * Mounted BESIDE the list's own screen, never inside it (a second
+ * M.applyBindings inside a bound tree does not take). domma-reactive.
+ * Talks to the routes of `_lib/games/rotation-http.js`.
+ *
+ * @module _lib/admin/games/rotation
+ */
+
+import {errText, esc, ico, loadKit, request, sortableRows} from './kit.js';
+
+const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+const ROW = `
+<div class="gma-qrow" data-id="{{id}}">
+  <span class="gma-grip" title="Drag to move" aria-hidden="true">${ico('menu')}</span>
+  <span class="gma-qnum" data-bind-text="place"></span>
+  <a class="gma-qtitle" data-bind-href="href" data-bind-text="title"></a>
+  <span class="gma-chip is-primary" hidden data-bind-hidden="!fromDomma">From Domma</span>
+  <span class="gma-spacer"></span>
+  <button type="button" class="btn btn-xs btn-ghost gma-quiet" title="Take it out of the queue (back to draft)" data-on-click="$root.unqueue(id)">${ico('x')}</button>
+</div>`;
+
+const html = (help) => `
+<section class="gma-card gma-rotation">
+  <div class="gma-bar">
+    <h3 class="gma-h">Rotation</h3>
+    <span data-help-title="Rotation" data-help="${esc(help)}"></span>
+    <span class="gma-spacer"></span>
+    <label class="gma-inline">Rotate
+      <select class="form-select form-select-sm" data-part="mode" data-model="mode.value">
+        <option value="off">Off</option><option value="daily">Every day</option><option value="weekly">Every week</option>
+      </select>
+    </label>
+    <label class="gma-inline" hidden data-bind-hidden="mode.value !== 'weekly'">on
+      <select class="form-select form-select-sm" data-part="weekday" data-model="weekday.value">${WEEKDAYS.map((d, i) => `<option value="${i}">${d}</option>`).join('')}</select>
+    </label>
+  </div>
+  <p class="gma-note" data-bind-text="summary.value"></p>
+  <p class="gma-note" hidden data-bind-hidden="!shortcode">Put <code data-bind-text="shortcode"></code> on a page and it always shows today's game.</p>
+  <div class="gma-waiting" hidden data-bind-hidden="!waiting.value.length">
+    <span class="gma-chip is-primary" data-bind-text="waitingText.value"></span>
+    <button type="button" class="btn btn-sm btn-primary" data-on-click="approveAll" data-bind-disabled="busy.value">${ico('check')} Approve all</button>
+    <label class="gma-toggle"><input type="checkbox" data-part="only"> <span>Show only these</span></label>
+  </div>
+  <div hidden data-bind-hidden="!queue.value.length">
+    <p class="gma-note"><strong>The queue</strong> - the first opens next. Drag to change the order.</p>
+    <div class="gma-queue" data-part="queue" data-each="queue.value key=id"></div>
+  </div>
+  <p class="gma-note" hidden data-bind-hidden="queue.value.length">Nothing is queued. Set a game's status to Queued, or Approve one Domma made.</p>
+</section>`;
+
+/**
+ * @param {HTMLElement} host      an element of its own, outside the list's bound screen
+ * @param {object} o
+ * @param {string} o.api          '/plugins/quiz'
+ * @param {string} o.noun         'quiz'
+ * @param {string} o.nouns        'quizzes'
+ * @param {string} o.shortcode    '[quiz rotate /]'
+ * @param {(id: string) => string} o.href    a game's edit address
+ * @param {object} o.lifetime
+ * @param {() => any} [o.onChange]   the list reloads
+ * @returns {Promise<{fromDomma: object, reload: () => Promise<void>}>}
+ */
+export async function rotationPanel(host, {api, noun, nouns, shortcode, href, lifetime, onChange = () => {}}) {
+    const s = {
+        mode: M.observable('off'),
+        weekday: M.observable('1'),
+        summary: M.observable(''),
+        queue: M.observable([]),
+        waiting: M.observable([]),
+        waitingText: M.observable(''),
+        busy: M.observable(false),
+        fromDomma: M.observable(false),
+        shortcode
+    };
+    const helpText = `Rotate opens the next queued ${noun} at midnight (every day, or once a week) and closes the one before - it moves to the archive, still playable but off the leaderboard. Off by default: nothing changes until you switch it on. Queued ${nouns} are never shown to the public until their turn.`;
+
+    const draw = (r) => {
+        s.mode.value = r.settings.mode;
+        s.weekday.value = String(r.settings.weekday);
+        const o = r.outlook;
+        const today = r.current ? `Today: ${r.current.title}.` : (o.mode === 'off' ? '' : `No ${noun} rotated in yet.`);
+        const reach = o.mode === 'off' ? `Rotation is off. ${o.queued} ${o.queued === 1 ? noun : nouns} queued.`
+            : `${o.queued} queued - ${o.days} day${o.days === 1 ? '' : 's'} ahead.${o.empty ? ' The queue is empty, so today\'s stays up.' : o.low ? ' Running low.' : ''}`;
+        s.summary.value = [today, reach].filter(Boolean).join(' ');
+        s.queue.value = r.queue.map((g, i) => ({id: g.id, title: g.title, place: `${i + 1}.`, href: href(g.id), fromDomma: g.origin === 'domma'}));
+        s.waiting.value = r.waiting;
+        s.waitingText.value = `${r.waiting.length} ${r.waiting.length === 1 ? noun : nouns} from Domma to review`;
+        if (!r.waiting.length && s.fromDomma.peek()) { s.fromDomma.value = false; if (only) only.checked = false; }
+        queueMicrotask(() => { if (host.isConnected && typeof I !== 'undefined') I.scan(host); });
+    };
+
+    async function reload() {
+        try { draw(await request('GET', `${api}/rotation`)); } catch (err) { s.summary.value = `Rotation could not load: ${errText(err)}`; }
+    }
+
+    async function saveSetting() {
+        try {
+            const r = await request('PUT', `${api}/rotation`, {mode: s.mode.peek(), weekday: Number(s.weekday.peek())});
+            const m = r.settings.mode;
+            E.toast(m === 'off' ? 'Rotation is off.' : `Rotation is on: ${m === 'daily' ? 'every day' : `every ${WEEKDAYS[r.settings.weekday]}`}.${r.rotated?.opened ? ' The first queued game is open now.' : ''}`, {type: 'success'});
+            await reload();
+            if (r.rotated?.opened) onChange();
+        } catch (err) { E.toast(esc(errText(err)), {type: 'error'}); }
+    }
+
+    s.unqueue = async (id) => {
+        try {
+            await request('POST', `${api}/unqueue`, {id});
+            await reload();
+            onChange();
+        } catch (err) { E.toast(esc(errText(err)), {type: 'error'}); }
+    };
+
+    s.approveAll = async () => {
+        const n = s.waiting.peek().length;
+        if (!await E.confirm(`Add the ${n} ${n === 1 ? noun : nouns} from Domma to the end of the queue?`)) return;
+        s.busy.value = true;
+        try {
+            const r = await request('POST', `${api}/approve`, {all: true});
+            const skipped = r.skipped.length ? ` ${r.skipped.length} could not be queued: ${r.skipped.map(x => `${esc(x.title)} (${esc(x.error)})`).join('; ')}.` : '';
+            E.toast(`${r.approved.length} queued.${skipped}`, {type: r.skipped.length ? 'warning' : 'success'});
+            await reload();
+            onChange();
+        } catch (err) { E.toast(esc(errText(err)), {type: 'error'}); }
+        s.busy.value = false;
+    };
+
+    const kit = await loadKit();
+    host.innerHTML = html(helpText);
+    host.classList.add('gma-screen');
+    host.querySelector('[data-part="queue"]').innerHTML = ROW;
+    const only = host.querySelector('[data-part="only"]');
+    const onOnly = () => { s.fromDomma.value = only.checked; };
+    only.addEventListener('change', onOnly);
+    const disposeHelp = kit.helpPopovers(host, {position: 'bottom'});
+    const bindings = M.applyBindings(s, host, {methods: s});
+    // After the bindings, so the model already holds the new value.
+    const selects = [host.querySelector('[data-part="mode"]'), host.querySelector('[data-part="weekday"]')];
+    for (const sel of selects) sel.addEventListener('change', saveSetting);
+    sortableRows(host.querySelector('[data-part="queue"]'), {
+        items: '.gma-qrow', handle: '.gma-grip', lifetime,
+        onMove: async (from, to) => {
+            const ids = s.queue.peek().map(q => q.id);
+            const [moved] = ids.splice(from, 1);
+            ids.splice(to, 0, moved);
+            s.queue.value = ids.map((id, i) => ({...s.queue.peek().find(q => q.id === id), place: `${i + 1}.`}));
+            try { await request('PUT', `${api}/queue`, {ids}); } catch (err) { E.toast(esc(errText(err)), {type: 'error'}); await reload(); }
+        }
+    });
+    lifetime?.add(() => {
+        bindings?.dispose?.(); disposeHelp?.(); only.removeEventListener('change', onOnly);
+        for (const sel of selects) sel.removeEventListener('change', saveSetting);
+    });
+    await reload();
+    return {fromDomma: s.fromDomma, reload};
+}
+
+/** Approve one game (a draft) from a list's row menu: it joins the queue. */
+export async function approveOne(api, id) {
+    const r = await request('POST', `${api}/approve`, {ids: [id]});
+    if (r.skipped.length) throw new Error(r.skipped[0].error);
+    return r;
+}
+
+/** A list row's status, with Queued and the archive. */
+export const STATUS_LABEL = {draft: 'Draft', queued: 'Queued', open: 'Open', closed: 'Closed'};
+export const STATUS_TONE = {draft: '', queued: 'is-primary', open: 'is-success', closed: 'is-warning'};
+export const statusText = (g) => (g.status === 'closed' && g.rotatedOff ? 'Archived' : g.status === 'queued' && g.queuePlace ? `Queued #${g.queuePlace}` : STATUS_LABEL[g.status] || g.status);

package/plugins/_lib/games/plays.js

@@ -12,6 +12,10 @@
  * Writes go one at a time (`withLock`), so two answers sent at once cannot
  * both be marked.
  *
+ * An ARCHIVE play (`archive: true`) is a go at a game rotation has closed
+ * (_lib/games/rotation.js): played and timed like any other, listed for the
+ * admin, but never on a board, never a place, never counted for goes per name.
+ *
  * A TEST play (`test: true`) is an admin trying the game from its Tool. It
  * plays exactly like any other, but it is nobody's go: it never counts for a
  * board, a place, the goes-per-name limit, the badge or the admin's list of
@@ -27,6 +31,8 @@ import {placeOf, rankPlays} from './ranking.js';
 import {ABANDON_MS} from './timing.js';
 
 const flat = (e) => (e ? {id: e.id, ...e.data} : null);
+/** Plays that may stand on a board: not archive plays (tests are left out by forGame). */
+const onBoard = (p) => p?.archive !== true;
 
 export class PlayStore {
     /**
@@ -88,21 +94,21 @@ export class PlayStore {
     /** How many goes this name has had at this game (any state but hidden ones the admin removed). */
     async attemptsBy(gameId, name) {
         const key = nameKey(name);
-        return (await this.forGame(gameId)).filter(p => p.nameKey === key).length;
+        return (await this.forGame(gameId)).filter(p => p.nameKey === key && p.archive !== true).length;
     }
 
     /**
      * @param {{gameId: string, name: string, maxScore?: number, state?: object, userId?: string, test?: boolean}} play
-     *   `test`: an admin trying the game - see the module comment
+     *   `test`: an admin trying the game; `archive`: a go at a game rotation has closed - see the module comment
      * @returns {Promise<object>} the play, token included - for the player, once
      */
-    async start({gameId, name, maxScore = 0, state = {}, userId = '', test = false}) {
+    async start({gameId, name, maxScore = 0, state = {}, userId = '', test = false, archive = false}) {
         return this.withLock(async () => {
             const now = new Date().toISOString();
             const saved = await createEntry(this.slug, {
                 gameId, name, nameKey: nameKey(name), userId,
                 status: 'playing', startedAt: now, finishedAt: '', timeMs: 0, score: 0, maxScore,
-                hidden: false, ...(test ? {test: true} : {}), token: randomBytes(24).toString('base64url'), state
+                hidden: false, ...(test ? {test: true} : {}), ...(archive ? {archive: true} : {}), token: randomBytes(24).toString('base64url'), state
             }, {source: test ? 'admin' : 'public'});
             this.forget();
             return flat(saved);
@@ -159,11 +165,13 @@ export class PlayStore {
     }
 
     async board(gameId, {period = 'all', limit = 10} = {}) {
-        return rankPlays(await this.forGame(gameId), {order: this.order, period, limit});
+        return rankPlays((await this.forGame(gameId)).filter(onBoard), {order: this.order, period, limit});
     }
 
+    /** Where a play stands; 0 for an archive play, which is on no board. */
     async placeOf(play, period = 'all') {
-        return placeOf(play, await this.forGame(play.gameId), {order: this.order, period});
+        if (!onBoard(play)) return 0;
+        return placeOf(play, (await this.forGame(play.gameId)).filter(onBoard), {order: this.order, period});
     }
 
     /** A play as the admin sees it: everything but the key and the game's inner state. */

package/plugins/_lib/games/rotation-http.js

@@ -0,0 +1,105 @@
+/**
+ * Games - the rotation routes every rotating Tool mounts (Quiz, Crossword,
+ * Word Search), beside its own:
+ *
+ *   GET  /rotation          (read)    the Rotate setting, today's game, the queue, what waits for review
+ *   PUT  /rotation          (manage)  {mode: off|daily|weekly, weekday} - the setting
+ *   PUT  /queue             (manage)  {ids: [...]} - the queue's new order
+ *   POST /approve           (manage)  {ids: [...]} or {all: true} - Domma's drafts (or any draft named) into the queue
+ *   POST /unqueue           (manage)  {id} - a queued game back to draft
+ *   GET  /content/status    (manage)  what the Manager's content builder asks before making more
+ *   GET  /public/rotation   (anyone)  today's rotated game and the archive - slugs and titles only
+ *
+ * @module _lib/games/rotation-http
+ */
+
+import {fail, limited} from './http.js';
+import {contentStatus, currentOf, nextQueuePos, publicRotation, queueOf, queueOutlook, waitingOf} from './rotation.js';
+
+/** A game's record without what the collection keeps itself. */
+export const recordOf = ({id, createdAt, updatedAt, ...rest}) => rest;
+
+/**
+ * @param {object} fastify
+ * @param {object} o
+ * @param {(action: string) => object} o.can          route options for the Tool's permission
+ * @param {object} o.rotation                          createRotation()'s runner
+ * @param {() => Promise<object[]>} o.list             every game, flat
+ * @param {(id: string, record: object) => Promise<any>} o.save   write one game whole (no id/meta)
+ * @param {(game: object) => string[]} [o.usedOf]      what a game used (answers, words) for the builder's dedupe
+ * @param {(game: object) => string} [o.why]           why a game cannot be queued ('' when it can)
+ */
+export function mountRotationRoutes(fastify, {can, rotation, list, save, usedOf = () => [], why = () => ''}) {
+    const row = (g) => ({id: g.id, title: g.title, slug: g.slug, status: g.status, origin: g.origin || '', rotatedOn: g.rotatedOn || '', updatedAt: g.updatedAt || ''});
+
+    fastify.get('/rotation', can('read'), async () => {
+        const games = await list();
+        const {settings, lastRotatedDay} = await rotation.read();
+        const cur = currentOf(games);
+        return {settings, lastRotatedDay, outlook: queueOutlook(settings, games), current: cur ? row(cur) : null,
+            queue: queueOf(games).map(row), waiting: waitingOf(games).map(row)};
+    });
+
+    fastify.put('/rotation', can('manage'), async (request) => {
+        const settings = await rotation.saveSettings(request.body || {});
+        // Switching it on opens the first queued game now rather than at the next minute's look.
+        const done = settings.mode === 'off' ? null : await rotation.tick().catch(() => null);
+        return {settings, rotated: done};
+    });
+
+    // Every write below runs in the rotation's turn (rotation.run), reading the games inside it, so a
+    // midnight rotation and these never act on each other's stale copy.
+    fastify.put('/queue', can('manage'), async (request, reply) => {
+        const ids = Array.isArray(request.body?.ids) ? request.body.ids.map(String) : null;
+        if (!ids) return fail(reply, 400, 'Send the queue as a list of ids.');
+        await rotation.run(async () => {
+            const queued = queueOf(await list());
+            const order = [...ids.filter(id => queued.some(g => g.id === id)), ...queued.map(g => g.id).filter(id => !ids.includes(id))];
+            let n = 0;
+            for (const id of order) {
+                const g = queued.find(x => x.id === id);
+                n++;
+                if (Number(g.queuePos) !== n) await save(id, {...recordOf(g), queuePos: n});
+            }
+        });
+        return {queue: queueOf(await list()).map(row)};
+    });
+
+    fastify.post('/approve', can('manage'), async (request, reply) => {
+        const out = await rotation.run(async () => {
+            const games = await list();
+            const named = Array.isArray(request.body?.ids) ? request.body.ids.map(String) : [];
+            const wanted = request.body?.all === true ? waitingOf(games) : games.filter(g => g.status === 'draft' && named.includes(g.id));
+            if (!wanted.length) return null;
+            let pos = nextQueuePos(games);
+            const approved = [];
+            const skipped = [];
+            for (const g of wanted) {
+                const reason = why(g);
+                if (reason) { skipped.push({id: g.id, title: g.title, error: reason}); continue; }
+                await save(g.id, {...recordOf(g), status: 'queued', queuePos: pos++});
+                approved.push(row({...g, status: 'queued'}));
+            }
+            return {approved, skipped};
+        });
+        if (!out) return fail(reply, 400, 'There is nothing to approve.');
+        // Rotation on with an empty queue: the first approved opens now (outside the turn above - tick takes its own).
+        await rotation.tick().catch(() => null);
+        return out;
+    });
+
+    fastify.post('/unqueue', can('manage'), async (request, reply) => {
+        const done = await rotation.run(async () => {
+            const g = (await list()).find(x => x.id === String(request.body?.id || ''));
+            if (!g || g.status !== 'queued') return false;
+            const {queuePos, ...rest} = recordOf(g);
+            await save(g.id, {...rest, status: 'draft'});
+            return true;
+        });
+        return done ? {ok: true} : fail(reply, 404, 'That game is not in the queue.');
+    });
+
+    fastify.get('/content/status', can('manage'), async () => contentStatus((await rotation.read()).settings, await list(), {usedOf}));
+
+    fastify.get('/public/rotation', limited(120), async () => publicRotation(await list()));
+}

package/plugins/_lib/games/rotation.js

@@ -0,0 +1,323 @@
+/**
+ * Games - rotation: a new game every day (or every week) from a queue.
+ *
+ * A Tool with Rotate on opens the next QUEUED game at the site's day boundary
+ * and closes the one rotation opened before (its board and plays stay; it
+ * becomes an archived game - still playable, never on a board). Off is the
+ * default, and off does nothing at all.
+ *
+ * A game record carries, beside its own fields (server-owned; a save from the
+ * editor never sets them, the routes carry them over with `rotationFields`):
+ *
+ *   status     'queued' - waiting its turn (between draft and open; never shown to the public)
+ *   queuePos   its place in the queue (lower first)
+ *   rotatedOn  'YYYY-MM-DD' the day rotation opened it
+ *   rotatedOff 'YYYY-MM-DD' the day rotation closed it (an archived game)
+ *   origin     'domma' when the content builder made it; originAt
+ *
+ * The Tool's rotation file (`data/rotation.json`, beside its other runtime data)
+ * holds `{settings: {mode, weekday}, lastRotatedDay}`. `lastRotatedDay` is the
+ * guard against rotating twice: a restart at 00:00:30 reads it back and does
+ * nothing. A second guard covers a crash between the game writes and that file:
+ * a game already opened by rotation today means today's rotation happened.
+ *
+ * Days are the SITE'S day (the server's local time), as the leaderboards' "today"
+ * (_lib/games/ranking.js) and Daily Word.
+ *
+ * Pure parts first (tested on their own); `createRotation()` is the runner a
+ * Tool starts: a one-minute timer, no cron inside the site.
+ *
+ * @module _lib/games/rotation
+ */
+
+import path from 'node:path';
+import {createStore} from '../dataStore.js';
+
+export const ROTATE_MODES = ['off', 'daily', 'weekly'];
+export const ROTATE_LABELS = {off: 'Off', daily: 'Every day', weekly: 'Every week'};
+/** Fewer days than this queued raises the queue-low notice. */
+export const LOW_DAYS = 3;
+/** How often the runner looks at the clock. */
+export const TICK_MS = 60 * 1000;
+
+const pad = (n) => String(n).padStart(2, '0');
+const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+/** The site's day at `now` ('YYYY-MM-DD', local time). */
+export function dayOf(now = Date.now()) {
+    const d = new Date(now);
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+const utc = (day) => { const [y, m, d] = day.split('-').map(Number); return Date.UTC(y, m - 1, d); };
+const fromUtc = (t) => { const d = new Date(t); return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`; };
+/** 0 Sunday ... 6 Saturday, of a 'YYYY-MM-DD'. */
+export const weekdayOf = (day) => new Date(utc(day)).getUTCDay();
+export const addDays = (day, n) => fromUtc(utc(day) + Math.round(n) * 86400000);
+
+/** The Rotate setting, made safe. Off unless it says otherwise; the week starts on Monday (1). */
+export function cleanRotation(input = {}) {
+    const mode = ROTATE_MODES.includes(input?.mode) ? input.mode : 'off';
+    const w = Math.round(Number(input?.weekday));
+    return {mode, weekday: Number.isFinite(w) && w >= 0 && w <= 6 ? w : 1};
+}
+
+/**
+ * The last rotation day on or before today: today when daily, the latest
+ * chosen weekday when weekly, '' when off.
+ */
+export function boundaryDay(settings, now = Date.now()) {
+    const s = cleanRotation(settings);
+    if (s.mode === 'off') return '';
+    const today = dayOf(now);
+    if (s.mode === 'daily') return today;
+    return addDays(today, -((weekdayOf(today) - s.weekday + 7) % 7));
+}
+
+/** The day to rotate for now, or '' when it is not due (off, or already done for this boundary). */
+export function rotationDue(settings, state = {}, now = Date.now()) {
+    const day = boundaryDay(settings, now);
+    const last = DAY_RE.test(String(state?.lastRotatedDay || '')) ? state.lastRotatedDay : '';
+    return day && day > last ? day : '';
+}
+
+const byQueue = (a, b) => (Number(a.queuePos) || 0) - (Number(b.queuePos) || 0) || String(a.createdAt || '').localeCompare(String(b.createdAt || ''));
+
+/** The queued games in their turn. */
+export const queueOf = (games) => (games || []).filter(g => g && g.status === 'queued').sort(byQueue);
+
+/** The game rotation has open now (status open, opened by rotation, not closed by it). */
+export const currentOf = (games) => (games || []).filter(g => g && g.status === 'open' && g.rotatedOn && !g.rotatedOff)
+    .sort((a, b) => String(b.rotatedOn).localeCompare(String(a.rotatedOn)))[0] || null;
+
+/** A game rotation has closed: still playable, off the boards. */
+export const isArchived = (game) => Boolean(game && game.status === 'closed' && game.rotatedOff);
+
+/** May the public see it at all? Never a draft or a queued game. */
+export const isPublic = (game) => Boolean(game && game.status !== 'draft' && game.status !== 'queued');
+
+/** The next place at the back of the queue. */
+export const nextQueuePos = (games) => (games || []).reduce((m, g) => Math.max(m, Number(g?.queuePos) || 0), 0) + 1;
+
+/**
+ * What rotating on `day` does:
+ *   {already: true}             a game was opened by rotation on `day` - nothing to do
+ *   {empty: true, close: []}    nothing queued: leave today's game open, try again later
+ *   {close: [ids], open: id}    close what rotation had open, open the next queued
+ */
+export function planRotation(games, day) {
+    const list = games || [];
+    if (list.some(g => g && g.status === 'open' && g.rotatedOn === day && !g.rotatedOff)) return {already: true, close: [], open: null};
+    const next = queueOf(list)[0];
+    if (!next) return {empty: true, close: [], open: null};
+    const close = list.filter(g => g && g.status === 'open' && g.rotatedOn && !g.rotatedOff).map(g => g.id);
+    return {close, open: next.id};
+}
+
+/** The game as rotation closes it on `day`. */
+export const closedBy = (game, day) => ({...game, status: 'closed', rotatedOff: day});
+/** The game as rotation opens it on `day`: its own dates cleared, so the queue decides. */
+export const openedBy = (game, day) => ({...game, status: 'open', rotatedOn: day, rotatedOff: '', opensAt: '', closesAt: '', queuePos: 0});
+
+/** How many days the queue covers: one a game daily, seven weekly. */
+export function queueOutlook(settings, games) {
+    const s = cleanRotation(settings);
+    const queued = queueOf(games).length;
+    const days = s.mode === 'weekly' ? queued * 7 : queued;
+    return {mode: s.mode, queued, days, low: s.mode !== 'off' && queued > 0 && days < LOW_DAYS, empty: s.mode !== 'off' && queued === 0};
+}
+
+/** The server-owned rotation fields of a stored game, to carry over a save from the editor. */
+export function rotationFields(game) {
+    const out = {};
+    for (const k of ['queuePos', 'rotatedOn', 'rotatedOff', 'origin', 'originAt']) if (game?.[k] !== undefined && game[k] !== '') out[k] = game[k];
+    return out;
+}
+
+/**
+ * A save from the editor: the cleaned game plus the stored game's rotation
+ * fields. Turning a game to queued puts it at the back of the queue.
+ */
+export function withRotation(clean, stored, games) {
+    const out = {...clean, ...rotationFields(stored)};
+    // An editor opened before rotation moved this game (queued -> open at midnight, or open -> archived) would
+    // put it back in the queue on save. Rotation's move wins: a game it has opened is never re-queued from the editor.
+    if (clean.status === 'queued' && stored && stored.status !== 'queued' && stored.rotatedOn) out.status = stored.status;
+    if (out.status === 'queued' && stored?.status !== 'queued') out.queuePos = nextQueuePos(games);
+    if (out.status !== 'queued') delete out.queuePos;
+    return out;
+}
+
+/** What the public may know: today's rotated game and the archive (newest first). */
+export function publicRotation(games, {archiveMax = 60} = {}) {
+    const cur = currentOf(games);
+    const archive = (games || []).filter(isArchived)
+        .sort((a, b) => String(b.rotatedOff).localeCompare(String(a.rotatedOff)) || String(b.rotatedOn).localeCompare(String(a.rotatedOn)))
+        .slice(0, archiveMax)
+        .map(g => ({slug: g.slug, title: g.title, day: g.rotatedOn || '', until: g.rotatedOff}));
+    return {current: cur ? {slug: cur.slug, title: cur.title, day: cur.rotatedOn} : null, archive};
+}
+
+/**
+ * An admin's list row's rotation part: where it stands in the queue, whether
+ * Domma made it, when rotation opened or closed it.
+ */
+export function rotationSummary(game, games) {
+    const q = game.status === 'queued' ? queueOf(games).findIndex(g => g.id === game.id) + 1 : 0;
+    return {queuePlace: q, origin: game.origin || '', rotatedOn: game.rotatedOn || '', rotatedOff: game.rotatedOff || '', archived: isArchived(game)};
+}
+
+/**
+ * Games arriving from the Manager's content builder (`POST /import` with
+ * `{source: 'domma-content', status}`): drafts for review, or queued when the
+ * site has auto-publish on. Anything else imported is a draft, as before.
+ */
+export function importIntent(body) {
+    const fromDomma = body?.source === 'domma-content';
+    return {fromDomma, status: fromDomma && body?.status === 'queued' ? 'queued' : 'draft'};
+}
+
+/** Games made by Domma that wait for the admin's Approve. */
+export const waitingOf = (games) => (games || []).filter(g => g && g.origin === 'domma' && g.status === 'draft')
+    .sort((a, b) => String(a.originAt || a.createdAt || '').localeCompare(String(b.originAt || b.createdAt || '')) || String(a.createdAt || '').localeCompare(String(b.createdAt || '')));
+
+/**
+ * What the Manager asks before making more (GET /content/status): the Rotate
+ * setting, how far the queue reaches, how many wait for review, and what was used
+ * already (titles and the Tool's own `usedOf` - answers, words - for dedupe).
+ */
+export function contentStatus(settings, games, {usedOf = () => [], max = 400} = {}) {
+    const o = queueOutlook(settings, games);
+    const used = [];
+    for (const g of games || []) used.push(...(usedOf(g) || []));
+    return {
+        rotate: o.mode, queued: o.queued, days: o.days, waiting: waitingOf(games).length,
+        titles: [...new Set((games || []).map(g => g.title).filter(Boolean))].slice(-max),
+        used: [...new Set(used.map(String).filter(Boolean))].slice(-max)
+    };
+}
+
+// ---- The runner ------------------------------------------------------------------------
+
+/**
+ * One Tool's rotation: its settings file, the timer and the notices.
+ *
+ * @param {object} opts
+ * @param {string} opts.file        the rotation file (`<plugin>/data/rotation.json`)
+ * @param {() => Promise<object[]>} opts.list   every game, flat ({id, status, slug, title, ...})
+ * @param {(id: string, game: object) => Promise<any>} opts.save   write one game whole
+ * @param {object} [opts.log]
+ * @param {() => number} [opts.clock]   the time (tests move it; the site uses its own clock)
+ */
+export function createRotation({file, list, save, log = console, clock = Date.now}) {
+    const store = createStore(path.resolve(file));
+    let queue = Promise.resolve();
+    let timer = null;
+    let boot = null;
+    const locked = (fn) => {
+        const run = queue.then(fn, fn);
+        queue = run.catch(() => {});
+        return run;
+    };
+
+    const read = async () => {
+        const raw = await store.read();
+        return {settings: cleanRotation(raw.settings), lastRotatedDay: DAY_RE.test(String(raw.lastRotatedDay || '')) ? raw.lastRotatedDay : ''};
+    };
+
+    /** Rotate now if it is due. Answers what happened ({day, opened, closed} / {empty} / null). */
+    function tick(now = clock()) {
+        return locked(async () => {
+            const state = await read();
+            const day = rotationDue(state.settings, state, now);
+            if (!day) return null;
+            const games = await list();
+            const plan = planRotation(games, day);
+            if (plan.empty) return {day, empty: true};
+            if (!plan.already) {
+                const byId = new Map(games.map(g => [g.id, g]));
+                for (const id of plan.close) await save(id, closedBy(byId.get(id), day));
+                await save(plan.open, openedBy(byId.get(plan.open), day));
+                log.info?.(`[games] rotated on ${day}: opened ${byId.get(plan.open)?.slug}${plan.close.length ? `, closed ${plan.close.length}` : ''}`);
+            }
+            await store.write({...(await store.read()), settings: state.settings, lastRotatedDay: day});
+            return {day, opened: plan.open, closed: plan.close, already: Boolean(plan.already)};
+        });
+    }
+
+    return {
+        tick,
+        read,
+        /**
+         * Run `fn` in the rotation's turn: editor saves and the queue routes go through here, so a midnight
+         * rotation never interleaves with them. Never call tick() from inside `fn` (it waits for the same turn).
+         */
+        run: (fn) => locked(fn),
+        /** Save the Rotate setting. Switching it does not rotate by itself; the next tick does when due. */
+        async saveSettings(input) {
+            const settings = cleanRotation(input);
+            await locked(async () => store.write({...(await store.read()), settings}));
+            return settings;
+        },
+        /** The one-minute timer (and a first look shortly after boot). Never keeps the process alive. */
+        start() {
+            if (timer) return;
+            const run = () => tick(clock()).catch(err => log.warn?.(`[games] rotation: ${err.message}`));
+            boot = setTimeout(run, 5000);
+            timer = setInterval(run, TICK_MS);
+            boot.unref?.();
+            timer.unref?.();
+        },
+        stop() { clearTimeout(boot); clearInterval(timer); timer = null; }
+    };
+}
+
+/**
+ * The two notices of a Tool with rotation: `queue-low` (fewer than LOW_DAYS
+ * days queued) and `queue-empty` (rotation on, nothing queued). Both only when
+ * Rotate is on; both resolve when fixed.
+ */
+export function rotationNoticeSources({rotation, list, label, noun, nouns = `${noun}s`, link}) {
+    const status = async () => queueOutlook((await rotation.read()).settings, await list());
+    return [
+        {id: 'queue-low', label: `${label} queue running low`, severity: 'warning', defaultOn: true, every: 'daily', atBoot: true,
+            description: `${label} rotates and fewer than ${LOW_DAYS} days of ${nouns} are queued.`,
+            check: async (ctx) => {
+                const o = await status();
+                const key = `${noun}-queue-low`;
+                if (!o.low) { await ctx.resolve(key); return; }
+                await ctx.notify({title: `${label}: ${o.queued} ${o.queued === 1 ? noun : nouns} left in the queue`,
+                    body: `Rotation has ${o.days} day${o.days === 1 ? '' : 's'} left. Queue more so the page never goes stale.`,
+                    severity: 'warning', link, dedupeKey: key});
+            }},
+        {id: 'queue-empty', label: `${label} queue empty`, severity: 'warning', defaultOn: true, every: 'hourly', atBoot: true,
+            description: `${label} rotates but nothing is queued, so today's ${noun} stays up.`,
+            check: async (ctx) => {
+                const o = await status();
+                const key = `${noun}-queue-empty`;
+                if (!o.empty) { await ctx.resolve(key); return; }
+                await ctx.notify({title: `${label}: the queue is empty`,
+                    body: `Rotation is on but no ${noun} is queued, so the last one stays up. Queue one and it opens within a minute.`,
+                    severity: 'warning', link, dedupeKey: key});
+            }}
+    ];
+}
+
+/** The notice source for fresh games from Domma (registered by every Tool that takes them). */
+export const contentReadySource = (label) => ({id: 'content-ready', label: `${label}: new games from Domma`, severity: 'info', defaultOn: true,
+    description: `Domma has made new ${label} games for this site - to review, or already queued when auto-publish is on.`});
+
+/** Tell the admins what arrived. Never throws: a notice never breaks an import. */
+export function notifyContentReady(hooks, {label, noun, nouns = `${noun}s`, count, queued, link}) {
+    if (!count) return;
+    try {
+        const what = `${count} new ${count === 1 ? noun : nouns}`;
+        hooks?.notify?.({
+            title: queued ? `${label}: ${what} queued` : `${label}: ${what} to review`,
+            body: queued ? `Domma made ${what} for this site and put ${count === 1 ? 'it' : 'them'} in the queue.`
+                : `Domma made ${what} for this site. Look ${count === 1 ? 'it' : 'them'} over and Approve to queue ${count === 1 ? 'it' : 'them'}.`,
+            severity: 'info', link, source: 'content-ready', // One notice per arrival: two runs in a day that bring the same number are still two arrivals.
+            dedupeKey: `content-ready:${noun}:${Date.now()}`
+        });
+    } catch { /* a notice never breaks an import */ }
+}

package/plugins/_lib/public/games/rotation.js

@@ -0,0 +1,114 @@
+/**
+ * Games - a rotating game on a page: `[quiz rotate]` (and the same on every
+ * Game) shows whichever game rotation has open today, and the earlier ones
+ * underneath, still playable but off the leaderboard. So the page never needs
+ * editing.
+ *
+ * The Tool's player calls `mountRotation()` for a placeholder whose config says
+ * `rotate`; it asks `<api>/rotation` and mounts the game into a slot of its own
+ * with the Tool's ordinary `mountOne(slotEl)`, so the game is the same player
+ * as anywhere else. domma-reactive, text only through bindings.
+ *
+ * @module _lib/public/games/rotation
+ */
+
+import {request} from './games.js';
+
+const M = window.M;
+
+const TEMPLATE = `
+<p class="gm-muted" hidden data-bind-hidden="state.value !== 'loading'">Loading…</p>
+<section class="gm-card" hidden data-bind-hidden="state.value !== 'none'">
+  <p class="gm-muted" data-bind-text="noneText"></p>
+</section>
+<p class="gm-note gm-archive-note" hidden data-bind-hidden="!picked.value">
+  <span data-bind-text="pickedText.value"></span>
+  <button type="button" class="btn btn-sm btn-ghost" hidden data-bind-hidden="!hasToday.value" data-on-click="backToToday">Back to today's</button>
+</p>
+<div class="gm-rotation-slot"></div>
+<section class="gm-card gm-archive" hidden data-bind-hidden="!archive.value.length || boardOnly">
+  <h3 class="gm-title gm-archive-title" data-bind-text="archiveTitle"></h3>
+  <ul class="gm-archive-list" data-each="archive.value key=slug">
+    <li><button type="button" class="btn btn-sm btn-ghost" data-bind-text="label" data-bind-aria-pressed="current ? 'true' : 'false'" data-on-click="$root.pick(slug)"></button></li>
+  </ul>
+</section>`;
+
+const shortDay = (day) => {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(String(day || ''))) return '';
+    const [y, m, d] = day.split('-').map(Number);
+    const t = new Date(Date.UTC(y, m - 1, d));
+    return `${['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][t.getUTCDay()]} ${d} ${['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][m - 1]}`;
+};
+
+/**
+ * @param {HTMLElement} el      the placeholder
+ * @param {object} opts
+ * @param {string} opts.api     the Tool's public API ('/api/plugins/quiz/public')
+ * @param {string} opts.attr    the placeholder attribute the Tool's player reads ('data-quiz')
+ * @param {object} opts.cfg     the placeholder's config ({rotate: true, board})
+ * @param {(slot: HTMLElement) => any} opts.mountOne   the Tool's own mount for one game
+ * @param {string} opts.noun    'quiz', 'crossword'...
+ * @param {string} opts.nouns   'quizzes'...
+ */
+export async function mountRotation(el, {api, attr, cfg, mountOne, noun, nouns}) {
+    if (!M) return;
+    el.innerHTML = TEMPLATE;
+    const slot = el.querySelector('.gm-rotation-slot');
+    const s = {
+        state: M.observable('loading'),
+        picked: M.observable(''),
+        pickedText: M.observable(''),
+        hasToday: M.observable(false),
+        archive: M.observable([]),
+        boardOnly: cfg.board === 'only',
+        noneText: `No ${noun} today. Come back soon.`,
+        archiveTitle: `Earlier ${nouns}`
+    };
+    let today = null;
+    let mounted = null;
+    let list = [];
+
+    const show = (slug, archived) => {
+        mounted?.dispose?.();
+        slot.innerHTML = '';
+        const one = document.createElement('div');
+        one.className = el.className.replace(/\bgm-rotation\b/, '').trim() || 'gm-app';
+        one.setAttribute(attr, JSON.stringify({slug, board: archived ? 'hide' : (cfg.board || 'show')}));
+        one.dataset.gmMounted = '1';
+        slot.append(one);
+        mounted = mountOne(one) || null;
+        s.archive.value = list.map(a => ({...a, current: a.slug === slug}));
+    };
+
+    s.pick = (slug) => {
+        const a = list.find(x => x.slug === slug);
+        if (!a) return;
+        s.picked.value = slug;
+        s.pickedText.value = `${a.title}${a.day ? ` (${shortDay(a.day)})` : ''} - an earlier ${noun}. Play it for fun: it is not on the leaderboard.`;
+        show(slug, true);
+        el.scrollIntoView?.({block: 'start', behavior: 'smooth'});
+    };
+    s.backToToday = () => {
+        if (!today) return;
+        s.picked.value = '';
+        show(today.slug, false);
+    };
+
+    const bindings = M.applyBindings(s, el, {methods: s});
+    let r = null;
+    try { r = await request(`${api}/rotation`); } catch { /* shown as none */ }
+    list = (r?.archive || []).map(a => ({slug: a.slug, title: a.title, day: a.day, label: `${a.title}${a.day ? ` - ${shortDay(a.day)}` : ''}`, current: false}));
+    today = r?.current || null;
+    s.hasToday.value = Boolean(today);
+    s.archive.value = list;
+    if (today) { s.state.value = 'ready'; show(today.slug, false); }
+    else s.state.value = 'none';
+
+    const watch = new MutationObserver(() => { if (!el.isConnected) { mounted?.dispose?.(); bindings?.dispose?.(); watch.disconnect(); } });
+    watch.observe(document.body, {childList: true, subtree: true});
+}
+
+/** `[<game>-leaderboard rotate]`: today's rotated game's slug, or '' when none. */
+export async function rotationSlug(api) {
+    try { return (await request(`${api}/rotation`))?.current?.slug || ''; } catch { return ''; }
+}