domma-cms 1.8.46 → 1.9.1

package/plugins/crossword/lib/crossword.js

@@ -1,170 +0,0 @@
-/**
- * Crossword - the rules. PURE: no I/O, so the routes and the tests share them.
- *
- *   cleanPuzzle(input)            -> {puzzle, errors, unplaced}   what the admin saved, laid out by the server
- *   isOpen(puzzle, now)           -> {open, reason}
- *   publicPuzzle(puzzle)          -> the grid's shape and the clues - never a letter of the answers
- *   readCells(raw, puzzle)        -> the player's letters as rows, or null when malformed
- *   compare(cells, solution)      -> {wrong: [[r, c]], empty: n}
- *   catchUp / finish              -> the play, by the server's clock
- *
- * @module crossword/lib/crossword
- */
-
-import {GRACE_MS, leftOf, overdue} from '../../_lib/games/timing.js';
-import {MAX_WORDS, generate, shapeOf, solutionGrid} from '../public/lib/layout.js';
-
-export const STATUSES = ['draft', 'open', 'closed'];
-export const LIMITS = {clue: 300, answer: 40, timeLimit: 6 * 3600, penalty: 600};
-
-const str = (v, max) => String(v ?? '').replace(/\r\n?/g, '\n').trim().slice(0, max);
-const int = (v, min, max, dflt = 0) => {
-    const n = Math.round(Number(v));
-    return Number.isFinite(n) ? Math.max(min, Math.min(max, n)) : dflt;
-};
-const iso = (v) => {
-    const t = Date.parse(String(v || ''));
-    return Number.isFinite(t) ? new Date(t).toISOString() : '';
-};
-
-export function slugify(s) {
-    return String(s || '').normalize('NFKD').replace(/[̀-ͯ]/g, '').toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60);
-}
-
-/**
- * The puzzle as the admin saved it. The grid is laid out HERE from the words
- * and the seed (the same function the builder previews with), so a layout is
- * never taken from the browser.
- *
- * @returns {{puzzle: object, errors: Object<string, string>, unplaced: object[]}}
- */
-export function cleanPuzzle(input = {}) {
-    const errors = {};
-    const words = (Array.isArray(input.words) ? input.words : []).slice(0, MAX_WORDS)
-        .map(w => ({answer: str(w?.answer, LIMITS.answer), clue: str(w?.clue, LIMITS.clue)}))
-        .filter(w => w.answer || w.clue);
-    const puzzle = {
-        title: str(input.title, 120),
-        slug: slugify(input.slug || input.title),
-        intro: str(input.intro, 2000),
-        status: STATUSES.includes(input.status) ? input.status : 'draft',
-        opensAt: iso(input.opensAt),
-        closesAt: iso(input.closesAt),
-        timeLimit: int(input.timeLimit, 0, LIMITS.timeLimit),
-        checks: input.checks !== false,
-        checkPenalty: int(input.checkPenalty ?? 30, 0, LIMITS.penalty, 30),
-        wrongPenalty: int(input.wrongPenalty ?? 10, 0, LIMITS.penalty, 10),
-        leaderboard: input.leaderboard !== false,
-        leaderboardSize: int(input.leaderboardSize ?? 10, 3, 100, 10),
-        attemptsPerName: int(input.attemptsPerName, 0, 100),
-        seed: int(input.seed ?? 1, 1, 2 ** 31 - 1, 1),
-        words,
-        layout: {width: 0, height: 0, entries: []}
-    };
-    if (!puzzle.title) errors.title = 'Give the crossword a title.';
-    if (!puzzle.slug) errors.slug = 'Give the crossword a short name for its address (letters and numbers).';
-    if (puzzle.opensAt && puzzle.closesAt && puzzle.closesAt <= puzzle.opensAt) errors.closesAt = 'It has to close after it opens.';
-    words.forEach((w, i) => {
-        if (!w.answer) errors[`w${i + 1}`] ??= `Word ${i + 1} has a clue but no answer.`;
-        else if (!w.clue) errors[`w${i + 1}`] ??= `"${w.answer}" needs a clue.`;
-    });
-    const laid = generate(words.filter(w => w.answer && w.clue), {seed: puzzle.seed});
-    puzzle.layout = {width: laid.width, height: laid.height, entries: laid.entries};
-    if (puzzle.status === 'open' && laid.entries.length < 2) errors.words = 'Add at least two answers that cross before opening the crossword.';
-    return {puzzle, errors, unplaced: laid.unplaced};
-}
-
-export function isOpen(puzzle, now = Date.now()) {
-    if (!puzzle || puzzle.status === 'draft') return {open: false, reason: 'This crossword is not open yet.', state: 'draft'};
-    if (puzzle.status === 'closed') return {open: false, reason: 'This crossword has closed.', state: 'closed'};
-    if (puzzle.opensAt && Date.parse(puzzle.opensAt) > now) return {open: false, reason: 'This crossword opens soon.', state: 'scheduled', opensAt: puzzle.opensAt};
-    if (puzzle.closesAt && Date.parse(puzzle.closesAt) <= now) return {open: false, reason: 'This crossword has closed.', state: 'ended'};
-    if ((puzzle.layout?.entries?.length || 0) < 1) return {open: false, reason: 'This crossword is not ready yet.', state: 'empty'};
-    return {open: true, reason: '', state: 'open'};
-}
-
-/** What anyone may see: the shape, the numbers and the clues - no letters. */
-export function publicPuzzle(puzzle) {
-    const {width, height, entries} = puzzle.layout;
-    const grid = solutionGrid(puzzle.layout);
-    const clue = (e) => ({number: e.number, dir: e.dir, clue: e.clue, enumeration: e.enumeration, row: e.row, col: e.col, length: e.letters.length});
-    return {
-        width, height, shape: shapeOf(grid),
-        across: entries.filter(e => e.dir === 'across').map(clue),
-        down: entries.filter(e => e.dir === 'down').map(clue)
-    };
-}
-
-/**
- * The player's grid: `height` strings of `width` characters, a letter or a
- * space. Anything else (a black square they typed into, a wrong size) is null.
- */
-export function readCells(raw, puzzle) {
-    const {width, height} = puzzle.layout;
-    if (!Array.isArray(raw) || raw.length !== height) return null;
-    const rows = [];
-    for (const r of raw) {
-        const row = String(r ?? '').toUpperCase();
-        if (row.length !== width || !/^[A-Z ]*$/.test(row)) return null;
-        rows.push(row);
-    }
-    return rows;
-}
-
-/** Which squares are wrong (a letter that is not the answer's) and how many are still empty. */
-export function compare(cells, solution) {
-    const wrong = [];
-    let empty = 0;
-    solution.forEach((row, r) => row.forEach((ch, c) => {
-        if (!ch) return;
-        const given = cells[r][c];
-        if (given === ' ') empty++;
-        else if (given !== ch) wrong.push([r, c]);
-    }));
-    return {wrong, empty};
-}
-
-const limitMs = (puzzle) => (puzzle.timeLimit || 0) * 1000;
-
-/** Out of time while nobody asked: the play ends, off the board. */
-export function catchUp(puzzle, play, now = Date.now()) {
-    if (play.status !== 'playing' || !overdue(play.startedAt, limitMs(puzzle), now)) return false;
-    play.status = 'timeout';
-    play.finishedAt = new Date(now).toISOString();
-    play.timeMs = limitMs(puzzle);
-    return true;
-}
-
-/** Solved: the time is the server's, plus every penalty. */
-export function finish(play, now = Date.now()) {
-    play.status = 'finished';
-    play.finishedAt = new Date(now).toISOString();
-    play.score = 1;
-    play.timeMs = Math.max(0, now - Date.parse(play.startedAt)) + (play.state.penaltyMs || 0);
-    return play;
-}
-
-/** What the player may know of their play right now. */
-export function view(puzzle, play, now = Date.now()) {
-    const end = play.status === 'playing' ? now : Date.parse(play.finishedAt);
-    return {
-        status: play.status,
-        elapsedMs: Math.max(0, end - Date.parse(play.startedAt)),
-        penaltyMs: play.state.penaltyMs || 0,
-        checks: play.state.checks || 0,
-        totalLeftMs: play.status === 'playing' ? leftOf(play.startedAt, limitMs(puzzle), now) : null,
-        grace: GRACE_MS
-    };
-}
-
-/** The puzzle as a list row in the admin. */
-export function summary(puzzle, plays = []) {
-    const finished = plays.filter(p => p.status === 'finished');
-    return {
-        id: puzzle.id, title: puzzle.title, slug: puzzle.slug, status: puzzle.status,
-        words: puzzle.layout?.entries?.length || 0, size: `${puzzle.layout?.width || 0}×${puzzle.layout?.height || 0}`,
-        plays: plays.length, finished: finished.length,
-        fastest: finished.length ? Math.min(...finished.map(p => p.timeMs || 0)) : 0, updatedAt: puzzle.updatedAt || ''
-    };
-}

package/plugins/crossword/lib/store.js

@@ -1,56 +0,0 @@
-/**
- * Crossword - where puzzles and plays are kept: the collections `crossword-puzzles` and
- * `crossword-plays` (made at every boot when missing; API access all off - a puzzle
- * holds its answers, a play the player's name).
- *
- * @module crossword/lib/store
- */
-
-import fs from 'node:fs/promises';
-import {createCollection, createEntry, deleteEntry, getCollection, getEntry, listEntries, updateEntry} from '../../../server/services/collections.js';
-import {PlayStore} from '../../_lib/games/plays.js';
-
-export const PUZZLES = 'crossword-puzzles';
-export const PLAYS = 'crossword-plays';
-
-export const plays = new PlayStore(PLAYS, {order: 'time'});
-
-export async function ensureCollections(log = console) {
-    for (const slug of [PUZZLES, PLAYS]) {
-        if (await getCollection(slug)) continue;
-        const schema = JSON.parse(await fs.readFile(new URL(`../collections/${slug}.json`, import.meta.url), 'utf8'));
-        await createCollection(schema);
-        log.info?.(`[crossword] Created collection: ${slug}`);
-    }
-}
-
-const flat = (e) => (e ? {id: e.id, ...e.data, createdAt: e.meta?.createdAt, updatedAt: e.meta?.updatedAt} : null);
-
-let cache = null;
-export async function allPuzzles() {
-    cache ??= listEntries(PUZZLES, {limit: 100000}).then(r => (r.entries || []).map(flat)).catch(() => []);
-    return cache;
-}
-const forget = () => { cache = null; };
-
-export const getPuzzle = async (id) => flat(await getEntry(PUZZLES, String(id)).catch(() => null));
-export const puzzleBySlug = async (slug) => (await allPuzzles()).find(q => q.slug === String(slug)) || null;
-
-/** A short name no other crossword has. */
-export async function uniqueSlug(slug, selfId = '') {
-    const taken = new Set((await allPuzzles()).filter(q => q.id !== selfId).map(q => q.slug));
-    if (!taken.has(slug)) return slug;
-    for (let n = 2; ; n++) if (!taken.has(`${slug}-${n}`)) return `${slug}-${n}`;
-}
-
-export async function savePuzzle(id, data) {
-    const saved = id ? await updateEntry(PUZZLES, id, data) : await createEntry(PUZZLES, data);
-    forget();
-    return flat(saved);
-}
-
-export async function removePuzzle(id) {
-    await deleteEntry(PUZZLES, String(id));
-    forget();
-    return plays.reset(String(id));
-}

package/plugins/crossword/plugin.js

@@ -1,274 +0,0 @@
-/**
- * Crossword - the API (mounted at /api/plugins/crossword).
- *
- * Admin (the `crossword` permission; read to look, manage to change):
- *   GET  /count                         sidebar badge: crosswords finished today
- *   GET  /puzzles                       every crossword as a list row
- *   GET  /puzzles/:id · POST /puzzles · PUT /puzzles/:id · DELETE /puzzles/:id
- *   POST /puzzles/:id/copy              a copy, as a draft
- *   GET  /puzzles/:id/test              what the player's start screen shows, as if it were open
- *   POST /puzzles/:id/test              a TEST play of it as saved (draft or closed too) -> {playId, token, name, info};
- *                                       played through the /public/play routes, never on a board (see _lib/games/plays.js)
- *   GET  /puzzles/:id/plays · DELETE /puzzles/:id/plays · PUT /plays/:id · DELETE /plays/:id
- *   The grid is laid out on the server from the words and the seed (the builder previews with
- *   the same function, public/lib/layout.js); a save answers `unplaced` for words that did not fit.
- *
- * Players (no sign-in), under /public - the answers never leave the server:
- *   GET  /public/crossword/:slug               title, intro, the grid's size (the clues come with a play)
- *   GET  /public/crossword/:slug/leaderboard   ?period=&limit=
- *   POST /public/crossword/:slug/start         {name} -> {playId, token}
- *   GET  /public/play/:id                      the clock (elapsed, penalties, time left) and the grid's shape, numbers and clues
- *   POST /public/play/:id/check                {cells} -> the squares that are wrong (costs the check penalty)
- *   POST /public/play/:id/submit               {cells} -> solved (finished, timed) or not yet (wrong ones cost a penalty)
- *   GET  /public/play/:id/result               time, place; the solution
- * `cells` is the grid as rows of letters, a space for an empty square. The token goes in `X-Play-Token`.
- *
- * Shortcodes: [crossword id="<short name>" /] and [crossword-leaderboard id="<short name>" period="week" /].
- */
-
-import {cleanPlayerName} from '../_lib/games/names.js';
-import {boardQuery, fail, isBot, limited, mountPlayAdmin, testerName, todayBadge, tokenOf} from '../_lib/games/http.js';
-import {solutionGrid} from './public/lib/layout.js';
-import {catchUp, cleanPuzzle, compare, finish, isOpen, publicPuzzle, readCells, summary, view} from './lib/crossword.js';
-import {allPuzzles, ensureCollections, getPuzzle, plays, puzzleBySlug, removePuzzle, savePuzzle, uniqueSlug} from './lib/store.js';
-
-const esc = (s) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
-const slugAttr = (v) => String(v || '').toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 60);
-const secs = (ms) => Math.round(ms / 1000);
-
-function registerShortcodes(hooks) {
-    if (typeof hooks.registerShortcode !== 'function') return;
-    hooks.registerShortcode('crossword', (attrStr, _body, ctx) => {
-        const a = ctx.parseShortcodeAttrs(attrStr || '');
-        const slug = slugAttr(a.id || a.slug);
-        if (!slug) return '<p class="gm-muted">[crossword] needs id="the crossword\'s short name".</p>';
-        return `<div class="gm-app cw-app" data-crossword='${esc(JSON.stringify({slug}))}'><p class="gm-muted">Loading the crossword…</p></div>`;
-    });
-    // First: the engine matches [crossword…/] by prefix, so [crossword] would otherwise take this one too.
-    hooks.registerShortcode('crossword-leaderboard', (attrStr, _body, ctx) => {
-        const a = ctx.parseShortcodeAttrs(attrStr || '');
-        const id = slugAttr(a.id || a.slug);
-        if (!id) return '<p class="gm-muted">[crossword-leaderboard] needs id="the crossword\'s short name".</p>';
-        const cfg = {id, period: String(a.period || 'all'), limit: Math.max(1, Math.min(100, Number(a.limit) || 10)), title: String(a.title || 'Fastest solvers').slice(0, 80)};
-        return `<div class="cw-board" data-crossword-board='${esc(JSON.stringify(cfg))}'></div>`;
-    }, {priority: 5});
-}
-
-function publicInfo(puzzle) {
-    const state = isOpen(puzzle);
-    return {
-        slug: puzzle.slug, title: puzzle.title, intro: puzzle.intro, open: state.open, reason: state.reason, opensAt: state.opensAt || '',
-        timeLimit: puzzle.timeLimit, checks: puzzle.checks, checkPenalty: puzzle.checkPenalty, wrongPenalty: puzzle.wrongPenalty,
-        leaderboard: puzzle.leaderboard, leaderboardSize: puzzle.leaderboardSize, attemptsPerName: puzzle.attemptsPerName,
-        // Only the size before a start: the clues come with the play, so nobody studies them off the clock.
-        width: puzzle.layout.width, height: puzzle.layout.height, answers: puzzle.layout.entries.length
-    };
-}
-
-export default async function crosswordPlugin(fastify, options) {
-    const {authenticate, requirePermission} = options.auth;
-    const hooks = options.hooks || {};
-    const can = (action) => ({preHandler: [authenticate, requirePermission('crossword', action)]});
-
-    await ensureCollections(fastify.log);
-    registerShortcodes(hooks);
-
-    if (typeof hooks.registerNotificationSource === 'function') {
-        try {
-            hooks.registerNotificationSource({id: 'fastest', label: 'Crossword fastest solves', severity: 'info', defaultOn: true,
-                description: 'Someone has solved a crossword faster than anyone before.'});
-        } catch { /* older engine */ }
-    }
-
-    // ---- Admin ------------------------------------------------------------------
-
-    fastify.get('/count', can('read'), async () => todayBadge(plays, 'crossword'));
-
-    fastify.get('/puzzles', can('read'), async () => {
-        const everyPlay = await plays.all();
-        return {puzzles: (await allPuzzles()).map(p => summary(p, everyPlay.filter(x => x.gameId === p.id && x.test !== true)))
-            .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))};
-    });
-
-    fastify.get('/puzzles/:id', can('read'), async (request, reply) => {
-        const puzzle = await getPuzzle(request.params.id);
-        return puzzle || fail(reply, 404, 'That crossword is not here any more.');
-    });
-
-    async function save(request, reply, id) {
-        if (id && !await getPuzzle(id)) return fail(reply, 404, 'That crossword is not here any more.');
-        const {puzzle, errors, unplaced} = cleanPuzzle(request.body || {});
-        if (Object.keys(errors).length) return fail(reply, 400, Object.values(errors)[0], {errors});
-        puzzle.slug = await uniqueSlug(puzzle.slug, id || '');
-        const saved = await savePuzzle(id, puzzle);
-        return reply.code(id ? 200 : 201).send({...saved, unplaced});
-    }
-
-    fastify.post('/puzzles', can('manage'), (request, reply) => save(request, reply, ''));
-    fastify.put('/puzzles/:id', can('manage'), (request, reply) => save(request, reply, request.params.id));
-
-    fastify.post('/puzzles/:id/copy', can('manage'), async (request, reply) => {
-        const puzzle = await getPuzzle(request.params.id);
-        if (!puzzle) return fail(reply, 404, 'That crossword is not here any more.');
-        const {id, createdAt, updatedAt, ...rest} = puzzle;
-        const copy = {...rest, title: `${puzzle.title} (copy)`.slice(0, 120), status: 'draft', slug: await uniqueSlug(puzzle.slug)};
-        return reply.code(201).send(await savePuzzle('', copy));
-    });
-
-    fastify.delete('/puzzles/:id', can('manage'), async (request, reply) => {
-        if (!await getPuzzle(request.params.id)) return fail(reply, 404, 'That crossword is not here any more.');
-        return {ok: true, playsRemoved: await removePuzzle(request.params.id)};
-    });
-
-    mountPlayAdmin(fastify, {store: plays, base: '/puzzles', can, exists: async (id) => Boolean(await getPuzzle(id))});
-
-    // The admin tries the crossword from the Tool: the saved grid, whatever its status or dates, through
-    // the same player routes as anyone. The play is marked `test`, so it never counts anywhere.
-    const testInfo = (puzzle) => ({...publicInfo(puzzle), open: true, reason: ''});
-
-    fastify.get('/puzzles/:id/test', can('manage'), async (request, reply) => {
-        const puzzle = await getPuzzle(request.params.id);
-        if (!puzzle) return fail(reply, 404, 'That crossword is not here any more.');
-        return {info: testInfo(puzzle)};
-    });
-
-    fastify.post('/puzzles/:id/test', can('manage'), async (request, reply) => {
-        const puzzle = await getPuzzle(request.params.id);
-        if (!puzzle) return fail(reply, 404, 'That crossword is not here any more.');
-        if (!puzzle.layout?.entries?.length) return fail(reply, 409, 'Add answers and clues and save, then test it.', {code: 'empty'});
-        await plays.clearTests(puzzle.id);
-        const name = testerName(request);
-        const play = await plays.start({gameId: puzzle.id, name, maxScore: 1, state: {checks: 0, submits: 0, penaltyMs: 0},
-            userId: String(request.user?.id || ''), test: true});
-        return reply.code(201).send({playId: play.id, token: play.token, name, info: testInfo(puzzle)});
-    });
-
-    // ---- Players ----------------------------------------------------------------
-
-    const shownPuzzle = async (slug) => {
-        const puzzle = await puzzleBySlug(slug);
-        return puzzle && puzzle.status !== 'draft' ? puzzle : null;
-    };
-
-    fastify.get('/public/crossword/:slug', limited(120), async (request, reply) => {
-        const puzzle = await shownPuzzle(request.params.slug);
-        if (!puzzle) return fail(reply, 404, 'There is no crossword here.');
-        return publicInfo(puzzle);
-    });
-
-    fastify.get('/public/crossword/:slug/leaderboard', limited(120), async (request, reply) => {
-        const puzzle = await shownPuzzle(request.params.slug);
-        if (!puzzle || !puzzle.leaderboard) return fail(reply, 404, 'There is no leaderboard here.');
-        const {period, limit} = boardQuery(request.query, puzzle.leaderboardSize);
-        return {title: puzzle.title, period, rows: await plays.board(puzzle.id, {period, limit})};
-    });
-
-    fastify.post('/public/crossword/:slug/start', limited(20, 10), async (request, reply) => {
-        const puzzle = await shownPuzzle(request.params.slug);
-        if (!puzzle) return fail(reply, 404, 'There is no crossword here.');
-        const state = isOpen(puzzle);
-        if (!state.open) return fail(reply, 409, state.reason, {code: 'closed'});
-        if (isBot(request.body)) return fail(reply, 400, 'Something went wrong. Please try again.');
-        const {name, error} = cleanPlayerName(request.body?.name);
-        if (error) return fail(reply, 400, error, {code: 'name'});
-        if (puzzle.attemptsPerName && await plays.attemptsBy(puzzle.id, name) >= puzzle.attemptsPerName) {
-            return fail(reply, 409, puzzle.attemptsPerName === 1 ? `${name} has already had a go at this crossword.` : `${name} has already had ${puzzle.attemptsPerName} goes at this crossword.`, {code: 'attempts'});
-        }
-        const play = await plays.start({gameId: puzzle.id, name, maxScore: 1, state: {checks: 0, submits: 0, penaltyMs: 0}});
-        return reply.code(201).send({playId: play.id, token: play.token, name});
-    });
-
-    /** The play behind a request, up to date with the clock. Null after answering with the reason. */
-    /** The play went while this request was on its way (a reset, a delete, or the next test clearing it). */
-    const gone = (reply) => fail(reply, 404, 'That game is not here any more. Start again.', {code: 'gone'});
-
-    async function livePlay(request, reply) {
-        const opened = await plays.open(request.params.id, tokenOf(request));
-        if (!opened) { fail(reply, 404, 'That game is not here any more. Start again.', {code: 'gone'}); return null; }
-        const puzzle = await getPuzzle(opened.gameId);
-        if (!puzzle) { fail(reply, 404, 'That crossword is not here any more.', {code: 'gone'}); return null; }
-        const play = await plays.change(opened.id, (p) => (catchUp(puzzle, p) ? p : null));
-        if (!play) { gone(reply); return null; }
-        return {puzzle, play};
-    }
-
-    async function afterFinish(puzzle, play) {
-        try {
-            if (play.test || !puzzle.leaderboard || await plays.placeOf(play, 'all') !== 1) return;
-            hooks.notify?.({
-                title: `Fastest solve of "${puzzle.title}"`,
-                body: `${play.name} solved it in ${secs(play.timeMs)} seconds`,
-                severity: 'info', link: `#/plugins/crossword/plays/${puzzle.id}`, source: 'fastest', dedupeKey: `crossword-fastest:${play.id}`
-            });
-        } catch { /* a notice never breaks a play */ }
-    }
-
-    fastify.get('/public/play/:id', limited(240), async (request, reply) => {
-        const live = await livePlay(request, reply);
-        if (!live) return reply;
-        return {...view(live.puzzle, live.play), puzzle: publicPuzzle(live.puzzle)};
-    });
-
-    fastify.post('/public/play/:id/check', limited(60), async (request, reply) => {
-        const live = await livePlay(request, reply);
-        if (!live) return reply;
-        const {puzzle} = live;
-        if (!puzzle.checks) return fail(reply, 403, 'Checking is switched off for this crossword.', {code: 'no-checks'});
-        if (live.play.status !== 'playing') return fail(reply, 409, 'This game has finished.', {code: 'finished', play: view(puzzle, live.play)});
-        const cells = readCells(request.body?.cells, puzzle);
-        if (!cells) return fail(reply, 400, 'That grid does not fit this crossword.');
-        const {wrong, empty} = compare(cells, solutionGrid(puzzle.layout));
-        const play = await plays.change(live.play.id, (p) => {
-            p.state.checks = (p.state.checks || 0) + 1;
-            p.state.penaltyMs = (p.state.penaltyMs || 0) + puzzle.checkPenalty * 1000;
-            return p;
-        });
-        if (!play) return gone(reply);
-        return {wrong, empty, play: view(puzzle, play)};
-    });
-
-    fastify.post('/public/play/:id/submit', limited(30), async (request, reply) => {
-        const live = await livePlay(request, reply);
-        if (!live) return reply;
-        const {puzzle} = live;
-        if (live.play.status !== 'playing') return fail(reply, 409, live.play.status === 'timeout' ? 'Time ran out.' : 'This game has finished.', {code: 'finished', play: view(puzzle, live.play)});
-        const cells = readCells(request.body?.cells, puzzle);
-        if (!cells) return fail(reply, 400, 'That grid does not fit this crossword.');
-        const {wrong, empty} = compare(cells, solutionGrid(puzzle.layout));
-        const solved = !wrong.length && !empty;
-        const play = await plays.change(live.play.id, (p) => {
-            if (p.status !== 'playing') return null;
-            p.state.submits = (p.state.submits || 0) + 1;
-            // Guessing costs time: a full grid with mistakes adds the penalty. Empty squares are only pointed out.
-            if (!solved && !empty) p.state.penaltyMs = (p.state.penaltyMs || 0) + puzzle.wrongPenalty * 1000;
-            return solved ? finish(p) : p;
-        });
-        if (!play) return gone(reply);
-        if (solved) await afterFinish(puzzle, play);
-        return {
-            solved, empty, wrongCount: solved || empty ? 0 : wrong.length,
-            message: solved ? 'Solved!' : empty ? `${empty} square${empty === 1 ? ' is' : 's are'} still empty.`
-                : `Not quite: something is wrong.${puzzle.wrongPenalty ? ` That cost ${puzzle.wrongPenalty} seconds.` : ''}`,
-            play: view(puzzle, play)
-        };
-    });
-
-    fastify.get('/public/play/:id/result', limited(120), async (request, reply) => {
-        const live = await livePlay(request, reply);
-        if (!live) return reply;
-        const {puzzle, play} = live;
-        if (play.status === 'playing') return fail(reply, 409, 'This game has not finished yet.', {code: 'playing'});
-        const solved = play.status === 'finished';
-        return {
-            name: play.name, solved, timeMs: play.timeMs, penaltyMs: play.state.penaltyMs || 0, checks: play.state.checks || 0,
-            test: play.test === true,
-            place: solved && puzzle.leaderboard && !play.hidden && !play.test ? await plays.placeOf(play, 'all') : 0,
-            placeToday: solved && puzzle.leaderboard && !play.hidden && !play.test ? await plays.placeOf(play, 'today') : 0,
-            // A test is on no board; this is where it would have come.
-            wouldPlace: solved && puzzle.leaderboard && play.test ? await plays.placeOf(play, 'all') : 0,
-            leaderboard: puzzle.leaderboard,
-            // The answers only to someone who solved it: a timed-out play under another name must not be a way to read them.
-            solution: solved ? solutionGrid(puzzle.layout).map(row => row.map(ch => ch || ' ').join('')) : null
-        };
-    });
-}

package/plugins/crossword/plugin.json

@@ -1,79 +0,0 @@
-{
-  "name": "crossword",
-  "displayName": "Crossword",
-  "version": "1.1.0",
-  "tier": "free",
-  "minCmsVersion": "1.8.33",
-  "description": "Type answers and clues in the admin and the grid lays itself out. Put the crossword on any page: players type a name, solve against the clock, and the fastest go top of the leaderboard. The answers stay on the server until someone has solved it.",
-  "author": "Domma CMS",
-  "date": "2026-10-21",
-  "icon": "grid",
-  "permissions": [
-    {
-      "key": "crossword",
-      "label": "Crossword",
-      "group": "Plugins",
-      "icon": "grid",
-      "description": "See crosswords and who solved them (read), or make, change and remove crosswords and plays (manage).",
-      "actions": [
-        {
-          "key": "read",
-          "label": "See",
-          "description": "Open Crossword and see the crosswords, plays and leaderboards"
-        },
-        {
-          "key": "manage",
-          "label": "Manage",
-          "description": "Make, change and delete crosswords; hide or remove plays; reset a leaderboard"
-        }
-      ],
-      "grant": [
-        "admin"
-      ]
-    }
-  ],
-  "inject": {
-    "bodyEnd": "inject/body.html"
-  },
-  "admin": {
-    "css": [
-      "../_lib/admin/games/games.css",
-      "admin/css/index.css"
-    ],
-    "sidebar": [
-      {
-        "id": "crossword",
-        "text": "Crossword",
-        "icon": "grid",
-        "url": "#/plugins/crossword",
-        "section": "#/plugins/crossword",
-        "permission": "crossword",
-        "group": "Games",
-        "countUrl": "/api/plugins/crossword/count"
-      }
-    ],
-    "routes": [
-      {
-        "path": "/plugins/crossword",
-        "view": "plugin-crossword",
-        "title": "Crossword - Domma CMS"
-      },
-      {
-        "path": "/plugins/crossword/:a",
-        "view": "plugin-crossword",
-        "title": "Crossword - Domma CMS"
-      },
-      {
-        "path": "/plugins/crossword/:a/:b",
-        "view": "plugin-crossword",
-        "title": "Crossword - Domma CMS"
-      }
-    ],
-    "views": {
-      "plugin-crossword": {
-        "entry": "crossword/admin/views/crossword.js?v=1.1.0",
-        "exportName": "crosswordView"
-      }
-    }
-  }
-}

package/plugins/crossword/public/crossword.css

@@ -1,36 +0,0 @@
-/* Crossword - the player. Shared pieces (cards, clocks, leaderboard) are in /plugins/_lib/public/games/games.css. */
-.cw-app { max-width: 1040px; }
-.cw-live { position: absolute; left: -9999px; }
-.cw-clocks { display: inline-flex; align-items: center; gap: .5rem; }
-.cw-current { margin: 0 0 .75rem; padding: .5rem .75rem; border-radius: 8px; font-weight: 600;
-    background: color-mix(in srgb, var(--gm-accent) 14%, transparent); }
-
-.cw-layout { display: grid; grid-template-columns: auto minmax(14rem, 1fr); gap: 1.25rem; align-items: start; }
-@media (max-width: 760px) { .cw-layout { grid-template-columns: 1fr; } }
-.cw-grid-wrap { overflow-x: auto; max-width: 100%; }
-/* A crossword is black and white whatever the theme: light squares, dark blocks, the theme's accent for the cursor. */
-.cw-grid { --cw-size: clamp(1.6rem, calc((100vw - 4rem) / var(--cw-cols, 15)), 2.4rem); --cw-ink: #111827; --cw-paper: #ffffff;
-    display: inline-flex; flex-direction: column; border: 2px solid var(--cw-ink); background: var(--cw-ink); }
-.cw-row { display: flex; }
-.cw-cell { position: relative; width: var(--cw-size); height: var(--cw-size); box-sizing: border-box;
-    border: 1px solid #9ca3af; background: var(--cw-paper); }
-.cw-cell.is-block { background: var(--cw-ink); border-color: var(--cw-ink); }
-.cw-cell.is-word { background: color-mix(in srgb, var(--gm-accent) 22%, var(--cw-paper)); }
-.cw-cell.is-cursor { background: color-mix(in srgb, var(--gm-accent) 55%, var(--cw-paper)); }
-.cw-cell.is-wrong .cw-input { color: #dc2626; text-decoration: line-through; }
-.cw-num { position: absolute; top: 1px; left: 2px; font-size: calc(var(--cw-size) * .28); line-height: 1; pointer-events: none; color: #4b5563; }
-.cw-input { width: 100%; height: 100%; border: 0; padding: 0; margin: 0; background: transparent; text-align: center; text-transform: uppercase;
-    font: 700 calc(var(--cw-size) * .55)/1 var(--dm-font-sans, inherit); color: var(--cw-ink); caret-color: transparent; cursor: pointer; }
-.cw-input:focus { outline: none; }
-.cw-input[readonly] { cursor: default; }
-
-.cw-clues { display: grid; grid-template-columns: 1fr; gap: 1rem; max-height: 34rem; overflow: auto; }
-@media (min-width: 1000px) { .cw-clues { grid-template-columns: 1fr 1fr; } }
-.cw-clues h3 { margin: 0 0 .35rem; font-size: 1rem; text-transform: uppercase; letter-spacing: .05em; }
-.cw-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: .1rem; }
-.cw-clue { display: block; width: 100%; text-align: left; font: inherit; color: inherit; background: none; border: 0; padding: .3rem .45rem; border-radius: 6px; cursor: pointer; }
-.cw-clue:hover { background: var(--gm-soft); }
-.cw-list li.is-on .cw-clue { background: color-mix(in srgb, var(--gm-accent) 20%, transparent); }
-.cw-message.is-bad { color: var(--gm-bad); font-weight: 600; }
-.cw-message.is-good { color: var(--gm-good); font-weight: 600; }
-.cw-result { margin-bottom: 1rem; }