@kradle/challenges-sdk 0.11.0 → 0.13.0

package/dist/runtime/sdk.js

@@ -1,1271 +0,0 @@
-"use strict";
-// Runtime SDK. A challenge is one pure function: reduce(state, event) -> {state, actions}.
-// The arena turns engine facts into events and turns actions into engine effects;
-// the event log is the record of the run, so a run replays from its log.
-//
-// This file is the engine contract (Event / Effect / Action) plus the authoring
-// layer, defineChallenge(config, spec), on top of the reducer. Nothing here
-// touches Minecraft: the code runs in a sandboxed worker in the arena and in the
-// author's tests, unchanged.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Win = exports.End = exports.WORLD_DEFAULTS = exports.ALL_CAPABILITIES = exports.asMinutes = exports.asSeconds = exports.subtractDuration = exports.addDuration = exports.minutes = exports.seconds = exports.ticks = exports.TICKS_PER_SECOND = exports.PLAYER_VOTE = exports.inBox = exports.bounds = exports.blockIdOf = exports.applyEquipment = void 0;
-exports.toTicks = toTicks;
-exports.defineChallenge = defineChallenge;
-const world_js_1 = require("./world.js");
-var world_js_2 = require("./world.js");
-Object.defineProperty(exports, "applyEquipment", { enumerable: true, get: function () { return world_js_2.applyEquipment; } });
-Object.defineProperty(exports, "blockIdOf", { enumerable: true, get: function () { return world_js_2.blockIdOf; } });
-Object.defineProperty(exports, "bounds", { enumerable: true, get: function () { return world_js_2.bounds; } });
-Object.defineProperty(exports, "inBox", { enumerable: true, get: function () { return world_js_2.inBox; } });
-/**
- * The vote `skills.voteForPlayer` casts in. Its options are the other participants' names, so it
- * needs no `votingOptions` entry: a challenge opens it with `votes: { player: {...} }`.
- */
-exports.PLAYER_VOTE = "player";
-exports.TICKS_PER_SECOND = 20;
-/** A whole, finite, non-negative number of ticks; a fraction rounds to the nearest tick. */
-function wholeTicks(n, what) {
-    if (!Number.isFinite(n))
-        throw new Error(`${what} is not a finite number`);
-    if (n < 0)
-        throw new Error(`${what} is negative; a duration is zero or more`);
-    return Math.round(n);
-}
-const ticks = (n) => wholeTicks(n, `ticks(${n})`);
-exports.ticks = ticks;
-const seconds = (n) => wholeTicks(n * exports.TICKS_PER_SECOND, `seconds(${n})`);
-exports.seconds = seconds;
-const minutes = (n) => wholeTicks(n * 60 * exports.TICKS_PER_SECOND, `minutes(${n})`);
-exports.minutes = minutes;
-/** The ticks of a duration: "35s", "2m", "40t" or a Ticks value. Throws on a negative, non-finite or malformed one. */
-function toTicks(d) {
-    if (typeof d === "number")
-        return wholeTicks(d, `${d}`);
-    const m = /^(-?\d+(?:\.\d+)?)([smt])$/.exec(d);
-    if (!m)
-        throw new Error(`"${d}" is not a duration; use "35s", "2m", "40t", seconds(), minutes() or ticks()`);
-    const n = Number(m[1]);
-    return wholeTicks(m[2] === "s" ? n * exports.TICKS_PER_SECOND : m[2] === "m" ? n * 60 * exports.TICKS_PER_SECOND : n, `"${d}"`);
-}
-/** `a + b`, as ticks. */
-const addDuration = (a, b) => (toTicks(a) + toTicks(b));
-exports.addDuration = addDuration;
-/** `a - b`, as ticks, clamped at zero: a countdown that passed its deadline reads 0, not an error. */
-const subtractDuration = (a, b) => Math.max(0, toTicks(a) - toTicks(b));
-exports.subtractDuration = subtractDuration;
-/** A duration in seconds (for messages): `asSeconds("90s")` is 90, `asSeconds(ticks(30))` is 1.5. */
-const asSeconds = (d) => toTicks(d) / exports.TICKS_PER_SECOND;
-exports.asSeconds = asSeconds;
-/** A duration in minutes (for messages): `asMinutes("90s")` is 1.5. */
-const asMinutes = (d) => toTicks(d) / (60 * exports.TICKS_PER_SECOND);
-exports.asMinutes = asMinutes;
-exports.ALL_CAPABILITIES = [
-    "move",
-    "damage",
-    "death",
-    "pickup",
-    "inventory",
-    "blocks",
-    "zones",
-    "entities",
-    "custom",
-    "batch",
-    "query",
-    "walk",
-    "mirror",
-    "chat",
-    "lifecycle",
-    "requests",
-    "containers",
-];
-exports.WORLD_DEFAULTS = {
-    time: "day",
-    daylightCycle: false,
-    mobSpawning: false,
-    naturalRegeneration: true,
-    maxHealth: 20,
-};
-exports.End = {
-    allEliminated: (g) => g.active.length === 0,
-};
-exports.Win = {
-    /** Highest score among the eligible players (default: still in the game), if it reaches `min` (default 1). Ties win together. */
-    topScore: (opts = {}) => (g) => {
-        const pool = g.players.filter(opts.eligible ?? ((p) => !p.eliminated));
-        if (pool.length === 0)
-            return [];
-        const best = Math.max(...pool.map((p) => p.score));
-        if (best < (opts.min ?? 1))
-            return [];
-        return pool.filter((p) => p.score === best);
-    },
-    scoreAtLeast: (min) => (g) => g.players.filter((p) => p.score >= min),
-};
-// ---------------------------------------------------------------- the reducer
-const SETUP_TIMEOUT_TICKS = 30 * exports.TICKS_PER_SECOND;
-/** Drops undefined-valued keys: wire objects carry only what JSON would carry. */
-function compact(o) {
-    for (const k of Object.keys(o))
-        if (o[k] === undefined)
-            delete o[k];
-    return o;
-}
-function mulberry(rng) {
-    const next = (rng + 0x6d2b79f5) >>> 0;
-    let t = next;
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    return { rng: next, u: ((t ^ (t >>> 14)) >>> 0) / 4294967296 };
-}
-/** JSON-only state: no functions, class instances, cycles, shared objects or non-finite numbers. */
-function assertJson(value, what) {
-    const seen = new Map();
-    const walk = (v, path) => {
-        if (v === null || v === undefined || typeof v === "boolean" || typeof v === "string")
-            return;
-        if (typeof v === "number") {
-            if (!Number.isFinite(v))
-                throw new Error(`${path} is ${v}; state must be JSON`);
-            return;
-        }
-        if (typeof v !== "object")
-            throw new Error(`${path} is a ${typeof v}; state must be JSON`);
-        const prior = seen.get(v);
-        if (prior !== undefined)
-            throw new Error(`${path} is shared with ${prior}; return a fresh object`);
-        seen.set(v, path);
-        const proto = Object.getPrototypeOf(v);
-        if (!Array.isArray(v) && proto !== Object.prototype && proto !== null) {
-            throw new Error(`${path} is a ${v.constructor?.name ?? "class instance"}; use plain objects and arrays`);
-        }
-        for (const [k, x] of Object.entries(v))
-            walk(x, `${path}.${k}`);
-    };
-    walk(value, what);
-}
-const missingCapabilities = (have) => ["move", "damage", "death", "mirror"].filter((c) => !have.includes(c));
-const containerKey = (at) => `${Math.floor(at.x)},${Math.floor(at.y)},${Math.floor(at.z)}`;
-function containerCounts(s, at) {
-    const c = s.containers[containerKey(at)];
-    if (!c)
-        return undefined;
-    const counts = {};
-    for (const st of Object.values(c.slots))
-        counts[st.item] = (counts[st.item] ?? 0) + st.count;
-    return counts;
-}
-function validateSpec(spec) {
-    if (spec.life !== "single" && spec.life !== "respawn") {
-        throw new Error(`life must be "single" or "respawn" (got ${JSON.stringify(spec.life)})`);
-    }
-    if (spec.duration !== undefined)
-        toTicks(spec.duration);
-    const phases = spec.phases ?? {};
-    const names = Object.keys(phases);
-    for (const [name, ph] of Object.entries(phases)) {
-        if (ph.duration !== undefined)
-            toTicks(ph.duration);
-        for (const st of ph.at ?? []) {
-            if ("remaining" in st && ph.duration === undefined) {
-                throw new Error(`phases.${name}.at: 'remaining' needs a 'duration'`);
-            }
-            if (!("remaining" in st) && !("elapsed" in st)) {
-                throw new Error(`phases.${name}.at: each step needs 'elapsed' or 'remaining'`);
-            }
-            toTicks("remaining" in st ? st.remaining : st.elapsed);
-        }
-        for (const ev of ph.every ?? [])
-            toTicks(ev.interval);
-        if (typeof ph.next === "string" && ph.next !== "END" && !names.includes(ph.next)) {
-            throw new Error(`phases.${name}.next: "${ph.next}" is not a phase (declared: ${names.join(", ") || "none"})`);
-        }
-    }
-    for (const st of spec.at ?? [])
-        toTicks(st.at);
-    for (const ev of spec.every ?? [])
-        toTicks(ev.interval);
-    for (const [voteId, rule] of Object.entries((spec.votes ?? {}))) {
-        for (const ph of rule?.phases ?? []) {
-            if (!names.includes(ph))
-                throw new Error(`votes.${voteId}.phases: "${ph}" is not a phase`);
-        }
-    }
-}
-function defineChallenge(config, spec) {
-    validateSpec(spec);
-    // The vote named player is the one skills.voteForPlayer casts in; its options are the other participants.
-    if (config.challengeConfig?.votingOptions && exports.PLAYER_VOTE in config.challengeConfig.votingOptions) {
-        throw new Error(`votingOptions.${exports.PLAYER_VOTE} is reserved: open it with votes: { ${exports.PLAYER_VOTE}: {...} }, without options`);
-    }
-    const phaseNames = Object.keys(spec.phases ?? {});
-    const firstPhase = (phaseNames[0] ?? "MAIN");
-    const phaseOf = (s) => s.phase === "END" ? undefined : spec.phases?.[s.phase];
-    const paramDefaults = () => Object.fromEntries(Object.entries(config.params ?? {}).map(([k, p]) => [k, p.default]));
-    const duration = spec.duration === undefined ? undefined : toTicks(spec.duration);
-    const world = spec.world === false ? null : { ...exports.WORLD_DEFAULTS, ...spec.world };
-    const declaredZones = Object.keys(spec.zones ?? {});
-    const zoneBoxes = (spec.zones ?? {});
-    const declaredTimers = spec.timers;
-    const notDeclared = (kind, name, declared) => new Error(`"${name}" is not declared in ${kind} (declared: ${declared.join(", ") || "none"})`);
-    const manifest = {
-        runtime: 1,
-        name: config.name,
-        life: spec.life,
-        roles: Object.keys(config.roles),
-    };
-    const declaredLocations = Object.keys(config.challengeConfig?.locations ?? {});
-    if (declaredLocations.length > 0)
-        manifest.locations = declaredLocations;
-    if (spec.mirror)
-        manifest.mirror = spec.mirror;
-    if (spec.markers)
-        manifest.markers = spec.markers;
-    if (spec.containers)
-        manifest.containers = Object.values(spec.containers).map((at) => ({ ...at }));
-    // The engine samples the declared positions only; a report for another block is out of contract and ignored.
-    const declaredContainers = new Set(Object.values(spec.containers ?? {}).map(containerKey));
-    const init = () => ({
-        seed: 0,
-        rng: 0,
-        params: paramDefaults(),
-        capabilities: [],
-        locations: {},
-        markers: [],
-        status: "LOBBY",
-        tick: 0,
-        dt: 0,
-        startTick: 0,
-        setupTick: 0,
-        phase: firstPhase,
-        phaseStartTick: 0,
-        phaseEntries: 0,
-        fired: {},
-        every: {},
-        timers: {},
-        players: {},
-        game: {},
-        votes: {},
-        walks: {},
-        containers: {},
-        world: (0, world_js_1.emptyWorld)(),
-        nextId: 0,
-        winners: [],
-        endState: "",
-    });
-    // One reduction: the context writes into `actions`, or into `batch` during setup.
-    function makeCtx(s, actions, batch) {
-        const push = (effect) => {
-            compact(effect);
-            if (batch)
-                batch.push(effect);
-            else
-                actions.push({ type: "effect", effect });
-        };
-        const targets = (to) => to === "all" ? [undefined] : (Array.isArray(to) ? to : [to]).map((p) => p.name);
-        const g = {
-            get game() {
-                return s.game;
-            },
-            get params() {
-                return s.params;
-            },
-            get players() {
-                return Object.values(s.players).sort((a, b) => a.number - b.number);
-            },
-            get active() {
-                return g.players.filter((p) => !p.eliminated);
-            },
-            player: (name) => s.players[name],
-            role: (role) => g.players.filter((p) => p.role === role),
-            one: (role) => g.players.find((p) => p.role === role),
-            get tick() {
-                return s.tick;
-            },
-            get dt() {
-                return s.dt;
-            },
-            get elapsed() {
-                return s.tick - s.startTick;
-            },
-            get phase() {
-                return s.phase;
-            },
-            get phaseElapsed() {
-                return s.tick - s.phaseStartTick;
-            },
-            get phaseRemaining() {
-                const d = phaseOf(s)?.duration;
-                return d === undefined ? Number.MAX_SAFE_INTEGER : Math.max(0, toTicks(d) - (s.tick - s.phaseStartTick));
-            },
-            location(name) {
-                const at = s.locations[name];
-                if (!at)
-                    throw notDeclared("challengeConfig.locations", name, Object.keys(s.locations));
-                return { ...at };
-            },
-            markers: (tag) => s.markers
-                .filter((m) => tag === undefined || m.tags.includes(tag))
-                .map((m) => ({ ...m, at: { ...m.at }, tags: [...m.tags] })),
-            contents: (target) => {
-                if (typeof target !== "string") {
-                    // A position that is not declared reads as nothing forever: refuse it, like an unknown name.
-                    if (!declaredContainers.has(containerKey(target))) {
-                        throw notDeclared("containers", containerKey(target), Object.keys(spec.containers ?? {}));
-                    }
-                    return containerCounts(s, target);
-                }
-                const at = spec.containers?.[target];
-                if (!at)
-                    throw notDeclared("containers", target, Object.keys(spec.containers ?? {}));
-                return containerCounts(s, at);
-            },
-            inZone(p, zone) {
-                if (typeof zone === "string") {
-                    if (!declaredZones.includes(zone))
-                        throw notDeclared("zones", zone, declaredZones);
-                    return p.zones.includes(zone);
-                }
-                return p.pos !== null && (0, world_js_1.inBox)(p.pos, zone);
-            },
-            count: (p, item) => p.inventory[item] ?? 0,
-            // Frozen at the boundary too: a state that went through JSON (a checkpoint,
-            // the harness) holds unfrozen copies.
-            get others() {
-                return Object.values(s.world.others).map(world_js_1.freezeObservation);
-            },
-            blockAt: (at) => (0, world_js_1.blockAt)(s.world, at),
-            blockStateAt: (at) => (0, world_js_1.blockStateAt)(s.world, at),
-            get worldTime() {
-                return s.world.time;
-            },
-            blockCount: (box, block) => (0, world_js_1.blockCount)(s.world, box, block),
-            findBlocks: (box, block, limit) => (0, world_js_1.findBlocks)(s.world, box, block, limit),
-            entities: (filter) => (0, world_js_1.entitiesIn)(s.world, filter).map(world_js_1.freezeObservation),
-            entity: (id) => {
-                const e = s.world.entities[id];
-                return e ? (0, world_js_1.freezeObservation)(e) : undefined;
-            },
-            votes: (voteId) => ({ ...(s.votes[voteId] ?? {}) }),
-            vote: (p, voteId) => s.votes[voteId]?.[p.name],
-            openVote(voteId) {
-                delete s.votes[voteId];
-            },
-            goTo(phase) {
-                if (s.status !== "PLAYING")
-                    return;
-                if (phase !== "END" && !(spec.phases && Object.hasOwn(spec.phases, phase))) {
-                    throw new Error(`goTo("${phase}"): not a declared phase (${Object.keys(spec.phases ?? {}).join(", ") || "none"})`);
-                }
-                const leaving = s.phase;
-                const entry = s.phaseEntries;
-                phaseOf(s)?.exit?.(g);
-                for (const key of Object.keys(s.fired))
-                    if (key.startsWith(`phase:${entry}:${leaving}:`))
-                        delete s.fired[key];
-                for (const key of Object.keys(s.every))
-                    if (key.startsWith(`phase:${entry}:${leaving}:`))
-                        delete s.every[key];
-                s.phase = phase;
-                s.phaseStartTick = s.tick;
-                s.phaseEntries += 1;
-                if (phase === "END") {
-                    finish(s, g, actions);
-                    return;
-                }
-                const ph = phaseOf(s);
-                (ph?.every ?? []).forEach((_e, i) => {
-                    s.every[`phase:${s.phaseEntries}:${phase}:every:${i}`] = s.tick;
-                });
-                ph?.enter?.(g);
-            },
-            end(endState) {
-                if (s.status !== "PLAYING")
-                    return;
-                finish(s, g, actions, endState);
-            },
-            eliminate(p) {
-                if (p.eliminated)
-                    return;
-                (s.players[p.name] ?? p).eliminated = true;
-                push({ kind: "eliminate", player: p.name });
-            },
-            schedule(name, after) {
-                if (declaredTimers && !declaredTimers.includes(name))
-                    throw notDeclared("timers", name, declaredTimers);
-                s.timers[name] = s.tick + toTicks(after);
-            },
-            cancel(name) {
-                delete s.timers[name];
-            },
-            rand(lo, hi) {
-                const r = mulberry(s.rng);
-                s.rng = r.rng;
-                return lo + Math.floor(r.u * (hi - lo + 1));
-            },
-            pick: (items) => items[g.rand(0, items.length - 1)],
-            shuffle(items) {
-                const out = [...items];
-                for (let i = out.length - 1; i > 0; i--) {
-                    const j = g.rand(0, i);
-                    [out[i], out[j]] = [out[j], out[i]];
-                }
-                return out;
-            },
-            say: (message) => push({ kind: "announce", message }),
-            tell(to, message) {
-                for (const name of targets(to))
-                    push({ kind: "announce", message, to: name });
-            },
-            title(to, title, subtitle, times) {
-                for (const name of targets(to))
-                    push({ kind: "title", player: name, title, subtitle, times });
-            },
-            log: (player, message, data) => actions.push(compact({ type: "log", player: player?.name, message, data })),
-            store: (name, value, player) => actions.push(compact({ type: "store", name, value, player: player?.name })),
-            achievement: (player, id) => actions.push({ type: "log", player: player.name, message: `ACHIEVEMENT:${id}`, data: { achievement: id } }),
-            give: (player, item, count = 1, nbt) => push({ kind: "give", player: player.name, item, count, nbt }),
-            clear: (player, item, count) => push({ kind: "clear", player: player.name, item, count }),
-            effect: (player, effect, seconds, amplifier = 0) => push({ kind: "effect", player: player.name, effect, seconds, amplifier }),
-            teleport: (player, to) => push({ kind: "teleport", player: player.name, to: { ...to } }),
-            walk(player, to, opts) {
-                // One pending walk per player: a new walk supersedes the old one.
-                for (const [id, w] of Object.entries(s.walks))
-                    if (w.player === player.name)
-                        delete s.walks[id];
-                const id = `walk:${s.nextId++}`;
-                const fallback = opts?.fallback ?? "teleport";
-                s.walks[id] = { player: player.name, fallback, ...to };
-                actions.push({ type: "walk", id, player: player.name, to: { ...to }, fallback });
-            },
-            kill: (player) => push({ kind: "kill", player: player.name }),
-            gamemode: (player, mode) => push({ kind: "gamemode", player: player.name, mode }),
-            attribute: (player, attribute, value) => push({ kind: "attribute", player: player.name, attribute, value }),
-            fill: (from, to, block) => push({ kind: "fill", from: { ...from }, to: { ...to }, block }),
-            setblock: (at, block, nbt) => push({ kind: "setblock", at: { ...at }, block, nbt }),
-            summon: (entity, at, nbt) => push({ kind: "summon", entity, at: { ...at }, nbt }),
-            killEntities: (entities) => push({ kind: "kill_entities", entities }),
-            time: (value) => push({ kind: "time", value }),
-            gamerule: (rule, value) => push({ kind: "gamerule", rule, value }),
-            setSpawn: (at) => push({ kind: "spawn", at: { ...at } }),
-            worldBorder: (opts) => push({ kind: "worldborder", center: opts.center, size: opts.size, seconds: opts.seconds }),
-            container: (at, items) => push({ kind: "container", at: { ...at }, items: items.map((i) => ({ ...i })) }),
-            command(cmd) {
-                actions.push({ type: "log", message: `raw command: ${cmd}` });
-                push({ kind: "command", cmd });
-            },
-        };
-        return g;
-    }
-    /** Global handlers first, then the current phase's. */
-    function fire(s, g, key, e) {
-        const global = spec.on?.[key];
-        if (global)
-            global(g, e);
-        if (s.status !== "PLAYING")
-            return;
-        const local = phaseOf(s)?.on?.[key];
-        if (local)
-            local(g, e);
-    }
-    function guard(actions, what, fallback, f) {
-        try {
-            return { value: f(), failed: false };
-        }
-        catch (err) {
-            actions.push({ type: "log", message: `challenge error in ${what}: ${err.message}` });
-            return { value: fallback, failed: true };
-        }
-    }
-    function over(s, g, actions, endState, winners) {
-        s.status = "OVER";
-        s.endState = endState;
-        s.winners = winners;
-        if (spec.onOver) {
-            const won = new Set(winners);
-            const result = {
-                winners: [...winners],
-                winnerPlayers: g.players.filter((p) => won.has(p.name)),
-                isWinner: (p) => won.has(p.name),
-                endState: endState,
-            };
-            guard(actions, "onOver", null, () => spec.onOver?.(g, result));
-        }
-        const judgeContext = spec.judgeContext;
-        const judge = judgeContext
-            ? guard(actions, "judgeContext", null, () => judgeContext(g))
-            : null;
-        if (spec.announce?.gameOver !== false) {
-            g.say("=== GAME OVER ===");
-            for (const w of winners)
-                g.say(`${w} has won the challenge!`);
-        }
-        const gameOver = { type: "game_over", winners, endState: s.endState };
-        if (judge && judge.value !== null)
-            gameOver.judgeContext = judge.value;
-        actions.push(gameOver);
-    }
-    // Author code runs only inside guards here, so a throw in winners/endState never loses game_over.
-    function finish(s, g, actions, endState) {
-        if (s.status !== "PLAYING")
-            return;
-        const winners = guard(actions, "winners", [], () => (spec.winners?.(g) ?? []).map((p) => p.name));
-        const state = endState !== undefined
-            ? { value: endState, failed: false }
-            : guard(actions, "endState", "", () => spec.endState?.(g) ?? "");
-        over(s, g, actions, winners.failed || state.failed ? "error_challenge" : state.value, winners.value);
-    }
-    function fail(s, g, actions, endState, message, data) {
-        actions.push(compact({ type: "log", message, data }));
-        if (s.status !== "OVER")
-            over(s, g, actions, endState, []);
-    }
-    function worldGlobals() {
-        if (!world)
-            return [];
-        const out = [];
-        if (world.spawn)
-            out.push({ kind: "spawn", at: { ...world.spawn } });
-        if (world.time !== false)
-            out.push({ kind: "time", value: world.time });
-        out.push({ kind: "gamerule", rule: "doDaylightCycle", value: world.daylightCycle });
-        out.push({ kind: "gamerule", rule: "doMobSpawning", value: world.mobSpawning });
-        out.push({ kind: "gamerule", rule: "naturalRegeneration", value: world.naturalRegeneration });
-        return out;
-    }
-    function worldPlayers(s) {
-        if (!world)
-            return [];
-        const out = [];
-        for (const p of Object.values(s.players)) {
-            if (world.maxHealth !== false) {
-                out.push({
-                    kind: "attribute",
-                    player: p.name,
-                    attribute: "minecraft:generic.max_health",
-                    value: world.maxHealth,
-                });
-            }
-        }
-        return out;
-    }
-    function play(s, g, actions) {
-        s.status = "PLAYING";
-        s.startTick = s.tick;
-        s.phaseStartTick = s.tick;
-        s.phaseEntries = 1;
-        for (const p of Object.values(s.players)) {
-            p.alive = true;
-            p.deaths = 0;
-            p.kills = 0;
-        }
-        const head = spec.setup ? worldPlayers(s) : [...worldGlobals(), ...worldPlayers(s)];
-        for (const e of head)
-            actions.push({ type: "effect", effect: e });
-        (spec.every ?? []).forEach((_e, i) => {
-            s.every[`every:${i}`] = s.tick;
-        });
-        spec.start?.(g);
-        const ph = phaseOf(s);
-        (ph?.every ?? []).forEach((_e, i) => {
-            s.every[`phase:1:${s.phase}:every:${i}`] = s.tick;
-        });
-        ph?.enter?.(g);
-    }
-    function onTick(s, g, actions) {
-        if (s.status === "LOBBY") {
-            const roster = Object.values(s.players);
-            if (roster.length === 0 || !roster.every((p) => p.connected))
-                return;
-            if (!spec.setup) {
-                play(s, g, actions);
-                return;
-            }
-            const batch = [...worldGlobals()];
-            spec.setup(makeCtx(s, actions, batch));
-            s.status = "SETUP";
-            s.setupTick = s.tick;
-            actions.push({ type: "batch", id: "setup", effects: batch });
-            return;
-        }
-        if (s.status === "SETUP") {
-            if (s.tick - s.setupTick > SETUP_TIMEOUT_TICKS) {
-                fail(s, g, actions, "error_setup", "the engine did not confirm the setup batch in 30 s");
-            }
-            return;
-        }
-        if (s.status !== "PLAYING")
-            return;
-        // Everything due on this tick, in due-tick order, one shot each.
-        const work = [];
-        let order = 0;
-        (spec.at ?? []).forEach((st, i) => {
-            const key = `at:${i}`;
-            const due = s.startTick + toTicks(st.at);
-            if (s.tick >= due && !s.fired[key])
-                work.push({
-                    due,
-                    order: order++,
-                    run: () => {
-                        s.fired[key] = true;
-                        st.run(g);
-                    },
-                });
-        });
-        (spec.every ?? []).forEach((st, i) => {
-            const key = `every:${i}`;
-            const interval = toTicks(st.interval);
-            const due = (s.every[key] ?? s.startTick) + interval;
-            if (s.tick >= due)
-                work.push({
-                    due,
-                    order: order++,
-                    run: () => {
-                        s.every[key] = s.tick;
-                        st.run(g);
-                    },
-                });
-        });
-        const ph = phaseOf(s);
-        if (ph) {
-            const entry = s.phaseEntries;
-            const name = s.phase;
-            const phaseDuration = ph.duration === undefined ? undefined : toTicks(ph.duration);
-            (ph.at ?? []).forEach((st, i) => {
-                const key = `phase:${entry}:${name}:${i}`;
-                const offset = "elapsed" in st ? toTicks(st.elapsed) : (phaseDuration ?? 0) - toTicks(st.remaining);
-                const due = s.phaseStartTick + offset;
-                if (s.tick >= due && !s.fired[key])
-                    work.push({
-                        due,
-                        order: order++,
-                        run: () => {
-                            s.fired[key] = true;
-                            st.run(g);
-                        },
-                    });
-            });
-            (ph.every ?? []).forEach((st, i) => {
-                const key = `phase:${entry}:${name}:every:${i}`;
-                const interval = toTicks(st.interval);
-                const due = (s.every[key] ?? s.phaseStartTick) + interval;
-                if (s.tick >= due)
-                    work.push({
-                        due,
-                        order: order++,
-                        run: () => {
-                            s.every[key] = s.tick;
-                            st.run(g);
-                        },
-                    });
-            });
-        }
-        for (const [name, due] of Object.entries(s.timers)) {
-            if (s.tick >= due) {
-                work.push({
-                    due,
-                    order: order++,
-                    run: () => {
-                        // A sibling handler may have cancelled or rescheduled it on this same tick.
-                        if (s.timers[name] !== due)
-                            return;
-                        delete s.timers[name];
-                        fire(s, g, "timer", { name: name });
-                    },
-                });
-            }
-        }
-        work.sort((a, b) => a.due - b.due || a.order - b.order);
-        const entryAtStart = s.phaseEntries;
-        for (const w of work) {
-            if (s.status !== "PLAYING")
-                return;
-            // A phase change drops the rest of the old phase's work; the new phase gets a clean tick.
-            if (s.phaseEntries !== entryAtStart)
-                break;
-            w.run();
-        }
-        if (s.status !== "PLAYING")
-            return;
-        // One transition per tick event: a late phase still gets its full duration.
-        const cur = phaseOf(s);
-        if (cur &&
-            s.phaseEntries === entryAtStart &&
-            cur.duration !== undefined &&
-            g.phaseElapsed >= toTicks(cur.duration)) {
-            g.goTo(typeof cur.next === "function" ? cur.next(g) : (cur.next ?? "END"));
-        }
-        if (s.status === "PLAYING") {
-            spec.on?.tick?.(g);
-            if (s.status === "PLAYING")
-                phaseOf(s)?.on?.tick?.(g);
-        }
-    }
-    /** The declared zones a position is in, in declaration order. */
-    function zonesAt(pos) {
-        if (!pos)
-            return [];
-        return declaredZones.filter((zone) => {
-            const box = zoneBoxes[zone];
-            return box !== undefined && (0, world_js_1.inBox)(pos, box);
-        });
-    }
-    /** The zone edges between two memberships, as events; nothing outside PLAYING. */
-    function fireZoneEdges(s, g, p, before, after) {
-        if (s.status !== "PLAYING")
-            return;
-        for (const zone of after)
-            if (!before.includes(zone))
-                fire(s, g, "zoneEntered", { player: p, zone: zone });
-        for (const zone of before)
-            if (!after.includes(zone))
-                fire(s, g, "zoneLeft", { player: p, zone: zone });
-    }
-    /** Re-evaluates the declared zones for one participant after a move. */
-    function updateZones(s, g, p) {
-        if (!p.pos)
-            return;
-        const before = p.zones;
-        const after = zonesAt(p.pos);
-        p.zones = after;
-        fireZoneEdges(s, g, p, before, after);
-    }
-    /** Applies one sample's fields; returns the move, for the events that fire once the whole tick applied. */
-    function applySample(p, d) {
-        let move = null;
-        if (d.pos) {
-            const from = p.pos;
-            p.pos = { ...d.pos };
-            move = { p, from, to: { ...d.pos }, maxY: d.maxY ?? d.pos.y, minY: d.minY ?? d.pos.y };
-        }
-        if (d.yaw !== undefined)
-            p.yaw = d.yaw;
-        if (d.pitch !== undefined)
-            p.pitch = d.pitch;
-        if (d.headYaw !== undefined)
-            p.headYaw = d.headYaw;
-        if (d.id !== undefined)
-            p.entityId = d.id;
-        if (d.uuid !== undefined)
-            p.uuid = d.uuid;
-        if (d.equipment)
-            p.equipment = (0, world_js_1.applyEquipment)(p.equipment, d.equipment);
-        if (d.invisible !== undefined)
-            p.invisible = d.invisible;
-        if (d.health !== undefined)
-            p.health = d.health;
-        if (d.food !== undefined)
-            p.food = d.food;
-        if (d.gamemode !== undefined)
-            p.gamemode = d.gamemode;
-        if (d.held !== undefined)
-            p.held = d.held;
-        return move;
-    }
-    function fireMove(s, g, m) {
-        updateZones(s, g, m.p);
-        if (s.status === "PLAYING") {
-            fire(s, g, "move", { player: m.p, from: m.from, to: { ...m.to }, maxY: m.maxY, minY: m.minY });
-        }
-    }
-    function samplePlayer(s, g, p, d) {
-        const move = applySample(p, d);
-        if (move)
-            fireMove(s, g, move);
-    }
-    function sampleOther(s, d) {
-        const prev = s.world.others[d.name];
-        s.world = (0, world_js_1.putOther)(s.world, compact({
-            name: d.name,
-            pos: d.pos ? { ...d.pos } : (prev?.pos ?? null),
-            health: d.health ?? prev?.health ?? 20,
-            food: d.food ?? prev?.food ?? 20,
-            gamemode: d.gamemode ?? prev?.gamemode ?? "survival",
-            held: d.held !== undefined ? d.held : (prev?.held ?? null),
-            uuid: d.uuid ?? prev?.uuid,
-            entityId: d.id ?? prev?.entityId,
-            yaw: d.yaw ?? prev?.yaw,
-            pitch: d.pitch ?? prev?.pitch,
-            headYaw: d.headYaw ?? prev?.headYaw,
-            equipment: d.equipment ? (0, world_js_1.applyEquipment)(prev?.equipment, d.equipment) : prev?.equipment,
-            invisible: d.invisible ?? prev?.invisible,
-        }));
-    }
-    function step(s, g, actions, e) {
-        const playing = () => s.status === "PLAYING";
-        const resolve = (name) => (name === undefined ? undefined : s.players[name]);
-        switch (e.type) {
-            case "run_started": {
-                s.seed = e.seed;
-                s.rng = e.seed >>> 0;
-                s.params = { ...paramDefaults(), ...e.params };
-                s.capabilities = e.capabilities;
-                s.locations = e.locations ?? {};
-                s.markers = (e.markers ?? []).map((m) => ({ ...m, at: { ...m.at }, tags: [...m.tags] }));
-                s.game = spec.game ? spec.game() : {};
-                e.participants.forEach((p, i) => {
-                    const roster = { name: p.name, role: p.role, number: i + 1, connected: false };
-                    const built = {
-                        alive: true,
-                        eliminated: false,
-                        deaths: 0,
-                        kills: 0,
-                        score: 0,
-                        pos: null,
-                        yaw: 0,
-                        pitch: 0,
-                        headYaw: 0,
-                        entityId: null,
-                        uuid: null,
-                        equipment: {},
-                        invisible: false,
-                        health: 20,
-                        food: 20,
-                        gamemode: "survival",
-                        held: null,
-                        slots: {},
-                        inventory: {},
-                        zones: [],
-                        human: p.human === true,
-                    };
-                    const forRole = spec.players?.[p.role];
-                    const own = forRole ? forRole(roster) : (spec.player?.(roster) ?? {});
-                    s.players[p.name] = { ...roster, ...built, ...own };
-                });
-                const unknownRoles = e.participants.filter((p) => !(p.role in config.roles));
-                if (unknownRoles.length > 0) {
-                    fail(s, g, actions, "error_challenge", `unknown role: ${unknownRoles.map((p) => `${p.role} (${p.name})`).join(", ")}; the roles are ${Object.keys(config.roles).join(", ")}`);
-                    return;
-                }
-                const missing = missingCapabilities(e.capabilities);
-                if (spec.setup && !e.capabilities.includes("batch"))
-                    missing.push("batch");
-                if (spec.containers && Object.keys(spec.containers).length > 0 && !e.capabilities.includes("containers")) {
-                    missing.push("containers");
-                }
-                if (missing.length > 0) {
-                    fail(s, g, actions, "error_unsupported_facts", `this engine cannot supply: ${missing.join(", ")}`, {
-                        missing,
-                    });
-                }
-                return;
-            }
-            case "player_joined": {
-                const p = resolve(e.name);
-                if (!p)
-                    return;
-                p.connected = true;
-                if (e.uuid !== undefined)
-                    p.uuid = e.uuid;
-                if (e.gamemode !== undefined)
-                    p.gamemode = e.gamemode;
-                if (playing())
-                    fire(s, g, "joined", { player: p });
-                break;
-            }
-            case "gamemode": {
-                const p = resolve(e.name);
-                if (!p) {
-                    const other = s.world.others[e.name];
-                    if (other)
-                        s.world = (0, world_js_1.putOther)(s.world, { ...other, gamemode: e.gamemode });
-                    return;
-                }
-                p.gamemode = e.gamemode;
-                if (playing())
-                    fire(s, g, "gamemode", { player: p, gamemode: e.gamemode });
-                break;
-            }
-            case "player_left": {
-                const p = resolve(e.name);
-                if (!p) {
-                    s.world = (0, world_js_1.removeOther)(s.world, e.name);
-                    return;
-                }
-                p.connected = false;
-                if (playing())
-                    fire(s, g, "left", { player: p });
-                break;
-            }
-            case "tick": {
-                // The whole tick applies first (the clock, the entities, every
-                // player's sample), then the derived events fire: a move or zone
-                // handler sees one consistent tick, whatever the order of the players.
-                s.dt = e.serverTick - s.tick;
-                s.tick = e.serverTick;
-                if (e.entities)
-                    s.world = (0, world_js_1.moveEntities)(s.world, e.entities);
-                if (e.time !== undefined && e.time !== s.world.time)
-                    s.world = { ...s.world, time: e.time };
-                const moves = [];
-                for (const d of e.players ?? []) {
-                    const p = resolve(d.name);
-                    if (p) {
-                        const move = applySample(p, d);
-                        if (move)
-                            moves.push(move);
-                    }
-                    else if (!d.participant)
-                        sampleOther(s, d);
-                }
-                // Every player's zone membership is complete before any handler runs:
-                // a move or zone handler that reads another player's zones sees this
-                // tick, not the one before, whatever the order of the samples.
-                const edges = moves.map((m) => {
-                    const before = m.p.zones;
-                    const after = zonesAt(m.p.pos);
-                    m.p.zones = after;
-                    return { m, before, after };
-                });
-                for (const { m, before, after } of edges) {
-                    fireZoneEdges(s, g, m.p, before, after);
-                    if (playing())
-                        fire(s, g, "move", { player: m.p, from: m.from, to: { ...m.to }, maxY: m.maxY, minY: m.minY });
-                }
-                onTick(s, g, actions);
-                break;
-            }
-            case "effect_result": {
-                if (e.id === "setup" && s.status === "SETUP") {
-                    if (e.ok)
-                        play(s, g, actions);
-                    else
-                        fail(s, g, actions, "error_setup", `setup batch failed: ${e.detail ?? "unknown"}`);
-                    return;
-                }
-                const w = s.walks[e.id];
-                if (w) {
-                    delete s.walks[e.id];
-                    if (!e.ok && w.fallback === "teleport") {
-                        actions.push({
-                            type: "effect",
-                            effect: { kind: "teleport", player: w.player, to: { x: w.x, y: w.y, z: w.z } },
-                        });
-                    }
-                    const p = resolve(w.player);
-                    if (p && playing())
-                        fire(s, g, "walkDone", { player: p, ok: e.ok });
-                }
-                break;
-            }
-            case "effect_failed":
-                actions.push({ type: "log", message: `effect failed: ${e.kind}: ${e.detail}` });
-                if (playing())
-                    fire(s, g, "effectFailed", { kind: e.kind, detail: e.detail });
-                break;
-            case "player_moved": {
-                const p = resolve(e.name);
-                if (!p)
-                    return;
-                samplePlayer(s, g, p, { pos: e.to, maxY: e.maxY, minY: e.minY });
-                break;
-            }
-            case "player_damaged": {
-                const p = resolve(e.name);
-                if (!p || !playing())
-                    return;
-                fire(s, g, "damaged", { player: p, amount: e.amount, cause: e.cause, attacker: resolve(e.attacker) });
-                break;
-            }
-            case "player_died": {
-                const p = resolve(e.name);
-                if (!p)
-                    return;
-                p.alive = false;
-                const killer = resolve(e.killer);
-                if (!playing())
-                    return;
-                p.deaths += 1;
-                if (killer && killer !== p)
-                    killer.kills += 1;
-                if (spec.life === "single")
-                    g.eliminate(p);
-                if (spec.announce?.deaths !== false)
-                    g.say(`${p.name} has died!`);
-                fire(s, g, "died", { player: p, cause: e.cause, killer });
-                break;
-            }
-            case "player_respawned": {
-                const p = resolve(e.name);
-                if (!p)
-                    return;
-                if (!p.eliminated)
-                    p.alive = true;
-                if (playing())
-                    fire(s, g, "respawned", { player: p });
-                break;
-            }
-            case "item_picked_up": {
-                const p = resolve(e.name);
-                if (!p || !playing())
-                    return;
-                fire(s, g, "pickup", { player: p, item: e.item, count: e.count, at: e.at });
-                break;
-            }
-            case "inventory": {
-                const p = resolve(e.name);
-                if (!p)
-                    return;
-                for (const sl of e.slots) {
-                    if (sl.item && sl.count)
-                        p.slots[sl.slot] = { item: sl.item, count: sl.count };
-                    else
-                        delete p.slots[sl.slot];
-                }
-                const before = p.inventory;
-                const after = {};
-                for (const st of Object.values(p.slots))
-                    after[st.item] = (after[st.item] ?? 0) + st.count;
-                p.inventory = after;
-                if (!playing())
-                    return;
-                for (const item of new Set([...Object.keys(before), ...Object.keys(after)])) {
-                    if ((before[item] ?? 0) !== (after[item] ?? 0)) {
-                        fire(s, g, "inventory", { player: p, item: item, count: after[item] ?? 0 });
-                    }
-                }
-                break;
-            }
-            case "container": {
-                const key = containerKey(e.at);
-                if (!declaredContainers.has(key))
-                    return;
-                const before = containerCounts(s, e.at) ?? {};
-                const slots = { ...(s.containers[key]?.slots ?? {}) };
-                for (const sl of e.slots) {
-                    if (sl.item && sl.count)
-                        slots[sl.slot] = { item: sl.item, count: sl.count };
-                    else
-                        delete slots[sl.slot];
-                }
-                s.containers[key] = { block: e.block, slots };
-                if (!playing() || e.initial)
-                    return;
-                const after = containerCounts(s, e.at) ?? {};
-                const changes = [];
-                for (const item of new Set([...Object.keys(before), ...Object.keys(after)])) {
-                    const delta = (after[item] ?? 0) - (before[item] ?? 0);
-                    if (delta !== 0)
-                        changes.push({ item: item, delta });
-                }
-                if (changes.length === 0)
-                    return;
-                fire(s, g, "container", { at: { ...e.at }, block: e.block, items: after, changes, by: resolve(e.by) });
-                break;
-            }
-            case "entity_spawned": {
-                const entity = compact({
-                    id: e.id,
-                    type: e.entity,
-                    pos: { ...e.at },
-                    tags: [...(e.tags ?? [])],
-                    name: e.name,
-                    health: e.health,
-                    item: e.item,
-                    count: e.count,
-                    uuid: e.uuid,
-                    yaw: e.yaw,
-                    pitch: e.pitch,
-                    headYaw: e.headYaw,
-                    equipment: e.equipment ? (0, world_js_1.applyEquipment)(undefined, e.equipment) : undefined,
-                    invisible: e.invisible,
-                    villager: e.villager ? { ...e.villager } : undefined,
-                });
-                s.world = (0, world_js_1.putEntity)(s.world, entity);
-                if (playing())
-                    fire(s, g, "entitySpawned", { entity });
-                break;
-            }
-            case "entity_changed": {
-                const prev = s.world.entities[e.id];
-                if (!prev)
-                    return;
-                const next = { ...prev };
-                if (e.tags)
-                    next.tags = [...e.tags];
-                if (e.name !== undefined)
-                    next.name = e.name ?? undefined;
-                if (e.health !== undefined)
-                    next.health = e.health;
-                if (e.item !== undefined)
-                    next.item = e.item;
-                if (e.count !== undefined)
-                    next.count = e.count;
-                if (e.equipment)
-                    next.equipment = (0, world_js_1.applyEquipment)(prev.equipment, e.equipment);
-                if (e.invisible !== undefined)
-                    next.invisible = e.invisible;
-                if (e.villager)
-                    next.villager = { ...e.villager };
-                s.world = (0, world_js_1.putEntity)(s.world, next);
-                break;
-            }
-            case "entity_removed": {
-                const prev = s.world.entities[e.id];
-                if (!prev)
-                    return;
-                s.world = (0, world_js_1.removeEntity)(s.world, e.id);
-                // Frozen like every other observation: the harness's state is a JSON copy, the arena's is frozen already.
-                if (playing())
-                    fire(s, g, "entityRemoved", { entity: (0, world_js_1.freezeObservation)(prev), cause: e.cause, killer: resolve(e.killer) });
-                break;
-            }
-            case "chunk":
-                s.world = (0, world_js_1.applyChunk)(s.world, e);
-                break;
-            case "chunk_unloaded":
-                s.world = (0, world_js_1.removeChunk)(s.world, e.x, e.z);
-                break;
-            case "blocks_changed": {
-                s.world = (0, world_js_1.setBlocks)(s.world, e.changes);
-                if (playing()) {
-                    fire(s, g, "blocksChanged", {
-                        changes: e.changes.map((c) => compact({ x: c.x, y: c.y, z: c.z, block: c.block, was: c.was, cause: c.cause, by: resolve(c.by) })),
-                    });
-                }
-                break;
-            }
-            case "blocks_filled":
-                s.world = (0, world_js_1.fillBlocks)(s.world, { from: e.from, to: e.to }, e.block);
-                break;
-            case "block_broken": {
-                const p = resolve(e.name);
-                if (p && playing())
-                    fire(s, g, "blockBroken", { player: p, at: e.at, block: e.block });
-                break;
-            }
-            case "block_placed": {
-                const p = resolve(e.name);
-                if (p && playing())
-                    fire(s, g, "blockPlaced", { player: p, at: e.at, block: e.block });
-                break;
-            }
-            case "block_used": {
-                const p = resolve(e.name);
-                if (p && playing())
-                    fire(s, g, "blockUsed", { player: p, at: e.at, block: e.block, item: e.item });
-                break;
-            }
-            case "chat": {
-                const p = resolve(e.from);
-                if (p && playing())
-                    fire(s, g, "chat", { player: p, text: e.text });
-                break;
-            }
-            case "animation": {
-                const p = resolve(e.name);
-                if (p && playing())
-                    fire(s, g, "animation", { player: p, animation: e.animation });
-                break;
-            }
-            case "vote_attempt": {
-                const p = resolve(e.name);
-                const reject = (feedback) => {
-                    actions.push({ type: "vote_decision", attemptId: e.attemptId, accepted: false, feedback });
-                };
-                if (!p) {
-                    reject("You are not a participant in this run.");
-                    return;
-                }
-                if (!playing()) {
-                    reject("The game is not running.");
-                    return;
-                }
-                const rule = spec.votes?.[e.voteId];
-                // The player vote has no configured options: the other participants are its options.
-                const options = e.voteId === exports.PLAYER_VOTE
-                    ? rule
-                        ? Object.keys(s.players).filter((name) => name !== p.name)
-                        : undefined
-                    : config.challengeConfig.votingOptions?.[e.voteId];
-                if (!options) {
-                    reject(`"${e.voteId}" is not a vote in this challenge.`);
-                    return;
-                }
-                if (!options.includes(e.option)) {
-                    reject(e.voteId === exports.PLAYER_VOTE
-                        ? `"${e.option}" is not another participant. Players: ${options.join(", ")}.`
-                        : `"${e.option}" is not an option for "${e.voteId}". Options: ${options.join(", ")}.`);
-                    return;
-                }
-                if (rule?.phases && !rule.phases.includes(s.phase)) {
-                    reject(`Votes for "${e.voteId}" are not open yet.`);
-                    return;
-                }
-                const prior = s.votes[e.voteId]?.[p.name];
-                if (prior !== undefined && rule?.final !== false) {
-                    reject(`You already voted "${prior}" for "${e.voteId}". Votes are final.`);
-                    return;
-                }
-                if (rule?.open) {
-                    const verdict = rule.open(g, p, e.option);
-                    if (verdict !== true) {
-                        reject(verdict);
-                        return;
-                    }
-                }
-                const round = s.votes[e.voteId] ?? {};
-                round[p.name] = e.option;
-                s.votes[e.voteId] = round;
-                actions.push({ type: "vote_decision", attemptId: e.attemptId, accepted: true });
-                fire(s, g, "vote", { player: p, voteId: e.voteId, option: e.option });
-                break;
-            }
-            case "custom": {
-                if (!playing())
-                    return;
-                fire(s, g, "custom", { name: e.name, player: resolve(e.player), data: e.data });
-                break;
-            }
-        }
-        if (s.status === "PLAYING" && ((duration !== undefined && g.elapsed >= duration) || spec.end?.(g))) {
-            finish(s, g, actions);
-        }
-    }
-    // JSON semantics, no shared references, except the world mirror: it is never
-    // changed in place, so the clone keeps the reference and an update copies what it touches.
-    const clone = (input) => {
-        const { world, ...rest } = input;
-        return { ...JSON.parse(JSON.stringify(rest)), world };
-    };
-    const reduce = (input, event) => {
-        let s = clone(input);
-        let actions = [];
-        let g = makeCtx(s, actions, null);
-        try {
-            step(s, g, actions, event);
-            assertJson({ game: s.game, players: s.players }, "state");
-        }
-        catch (err) {
-            // A challenge bug must neither kill the arena nor pass as a result. The crashed
-            // reduction's state and effects are dropped; only the SDK's own values remain.
-            s = clone(input);
-            actions = [];
-            g = makeCtx(s, actions, null);
-            if (event.type === "tick")
-                s.tick = event.serverTick;
-            fail(s, g, actions, "error_challenge", `challenge error on ${event.type}: ${err.message}`, {
-                event: event,
-            });
-        }
-        // The SDK reports `score`; the author never emits it.
-        const scores = [];
-        for (const p of Object.values(s.players)) {
-            if (input.players[p.name]?.score !== p.score)
-                scores.push({ type: "score", player: p.name, score: p.score });
-        }
-        const tail = actions.filter((a) => a.type === "game_over");
-        const head = actions.filter((a) => a.type !== "game_over");
-        return { state: s, actions: [...head, ...scores, ...tail] };
-    };
-    return {
-        config,
-        manifest,
-        zones: zoneBoxes,
-        init,
-        reduce,
-        get ctx() {
-            throw new Error("ctx is a type: write `typeof x.ctx`, and take `g` from a handler");
-        },
-    };
-}
-//# sourceMappingURL=sdk.js.map