@kradle/challenges-sdk 0.11.0 → 0.13.0

package/dist/runtime/reducer.js

@@ -0,0 +1,2025 @@
+"use strict";
+// The reducer: one locked definition, one `init()` per run, one `reduce(state,
+// event)` per engine event. Everything a rule sees comes through a context
+// built for the reduction; everything a rule asks for leaves as actions.
+//
+// Lifecycle (see the design notes in the repository's docs):
+// - CONNECTING until every participant is connected and has a position; then
+//   the state initializers run, then `setup` (batches) or the game starts.
+// - A phase or end request from a callback is recorded on the reduction and
+//   applied after the callback returns: exit once, enter once.
+// - After every event's handlers, one checkpoint: derived scores, the phase's
+//   `until`, the phase timeout, the game duration and `endWhen`. A game end
+//   drops a staged phase change.
+// - Finalization: exit, final scores, winners and end state, a frozen result,
+//   the game-over hook, the judge data, `game_over`.
+// - An author error rolls the reduction back and ends the run as
+//   `error_challenge` without another author callback.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TRANSITIONS_PER_EVENT = exports.MAX_FILL_VOLUME = exports.MAX_BATCH_EFFECTS = void 0;
+exports.assertJson = assertJson;
+exports.parseBlockState = parseBlockState;
+exports.blockSpecString = blockSpecString;
+exports.splitBatches = splitBatches;
+exports.createReducer = createReducer;
+const errors_js_1 = require("./errors.js");
+const time_js_1 = require("./time.js");
+const types_js_1 = require("./types.js");
+const world_js_1 = require("./world.js");
+// ---------------------------------------------------------------- limits
+/** Effects per batch the engine accepts. The setup is split under it. */
+exports.MAX_BATCH_EFFECTS = 4096;
+/** Blocks one batch may fill in total. The setup is split under it. */
+exports.MAX_FILL_VOLUME = 32768;
+/** Phase transitions one event may chain (enter requests included). */
+exports.MAX_TRANSITIONS_PER_EVENT = 8;
+const SETUP_BATCH_TIMEOUT_TICKS = 30 * 20;
+// ---------------------------------------------------------------- small helpers
+/** 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 (0, errors_js_1.apiError)("state_not_json", `${path} is ${v}; state must be JSON`, { path });
+            return;
+        }
+        if (typeof v !== "object")
+            throw (0, errors_js_1.apiError)("state_not_json", `${path} is a ${typeof v}; state must be JSON`, { path });
+        if (VIEWS.has(v)) {
+            throw (0, errors_js_1.apiError)("state_not_json", `${path} holds a read-only view (a player, an observation, g.params); store its data (\`p.name\`, \`{ ...p.pos }\`)`, { path });
+        }
+        const prior = seen.get(v);
+        if (prior !== undefined)
+            throw (0, errors_js_1.apiError)("state_shared", `${path} is shared with ${prior}; return a fresh object`, { path });
+        seen.set(v, path);
+        const proto = Object.getPrototypeOf(v);
+        if (!Array.isArray(v) && proto !== Object.prototype && proto !== null) {
+            throw (0, errors_js_1.apiError)("state_not_json", `${path} is a ${v.constructor?.name ?? "class instance"}; use plain objects and arrays`, { path });
+        }
+        for (const [k, x] of Object.entries(v))
+            walk(x, `${path}.${k}`);
+    };
+    walk(value, what);
+}
+/**
+ * Freezes every object and array under `value`, in place. A frozen parent does not stop the walk: an
+ * author's own shallow `Object.freeze` must not shelter its children. `seen` guards against cycles.
+ */
+function deepFreeze(value, seen = new WeakSet()) {
+    if (value === null || typeof value !== "object" || seen.has(value))
+        return;
+    seen.add(value);
+    Object.freeze(value);
+    for (const x of Object.values(value))
+        deepFreeze(x, seen);
+}
+const posKey = (at) => `${Math.floor(at.x)},${Math.floor(at.y)},${Math.floor(at.z)}`;
+/** `minecraft:oak_stairs[facing=east,half=bottom]` -> `{ id, props }`. */
+function parseBlockState(state) {
+    const i = state.indexOf("[");
+    if (i < 0)
+        return { id: state, props: {} };
+    const props = {};
+    for (const pair of state.slice(i + 1, -1).split(",")) {
+        const eq = pair.indexOf("=");
+        if (eq > 0)
+            props[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    return { id: state.slice(0, i), props };
+}
+/** `{ id, props }` -> `minecraft:oak_stairs[facing=east]`. */
+function blockSpecString(spec) {
+    if (typeof spec === "string")
+        return spec;
+    const entries = Object.entries(spec.props ?? {});
+    if (entries.length === 0)
+        return spec.id;
+    return `${spec.id}[${entries.map(([k, v]) => `${k}=${v}`).join(",")}]`;
+}
+/** An author's block predicate as a predicate over the mirror's state strings. */
+function blockPredicate(match) {
+    if (typeof match === "function")
+        return (state) => match(parseBlockState(state));
+    if (typeof match === "string") {
+        if (match.includes("["))
+            return (state) => state === match;
+        return (state) => (0, world_js_1.blockIdOf)(state) === match;
+    }
+    const want = Object.entries(match.props ?? {});
+    return (state) => {
+        if ((0, world_js_1.blockIdOf)(state) !== match.id)
+            return false;
+        if (want.length === 0)
+            return true;
+        const have = parseBlockState(state).props;
+        return want.every(([k, v]) => have[k] === v);
+    };
+}
+/** The SNBT of an item request's metadata, merged with its raw `snbt`. Empty string when there is none. */
+function itemNbt(req) {
+    if (typeof req === "string")
+        return undefined;
+    const parts = [];
+    if (req.enchantments && Object.keys(req.enchantments).length > 0) {
+        const list = Object.entries(req.enchantments).map(([id, lvl]) => `{id:"${id}",lvl:${lvl}s}`);
+        parts.push(`Enchantments:[${list.join(",")}]`);
+    }
+    const display = [];
+    // A JSON text in a single-quoted SNBT string: `\` and `'` escaped.
+    const quoted = (text) => `'${JSON.stringify({ text }).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+    if (req.name !== undefined)
+        display.push(`Name:${quoted(req.name)}`);
+    if (req.lore && req.lore.length > 0)
+        display.push(`Lore:[${req.lore.map(quoted).join(",")}]`);
+    if (display.length > 0)
+        parts.push(`display:{${display.join(",")}}`);
+    if (req.damage !== undefined)
+        parts.push(`Damage:${req.damage}`);
+    if (parts.length === 0)
+        return req.snbt;
+    const own = `{${parts.join(",")}}`;
+    if (!req.snbt)
+        return own;
+    // Two SNBT compounds: splice the raw one's body into ours.
+    const body = req.snbt.trim().replace(/^\{/, "").replace(/\}$/, "");
+    return body ? `{${parts.join(",")},${body}}` : own;
+}
+function itemMatches(stack, match) {
+    if (typeof match === "string")
+        return stack.id === match;
+    if (stack.id !== match.id)
+        return false;
+    if (match.name !== undefined && stack.name !== match.name)
+        return false;
+    if (match.damage !== undefined && stack.damage !== match.damage)
+        return false;
+    if (match.lore !== undefined && JSON.stringify(stack.lore ?? []) !== JSON.stringify(match.lore))
+        return false;
+    if (match.enchantments !== undefined) {
+        for (const [id, lvl] of Object.entries(match.enchantments))
+            if (stack.enchantments?.[id] !== lvl)
+                return false;
+    }
+    return true;
+}
+function stackOf(sl) {
+    if (!sl.item || !sl.count)
+        return null;
+    return compact({
+        id: sl.item,
+        count: sl.count,
+        name: sl.name,
+        lore: sl.lore ? [...sl.lore] : undefined,
+        enchantments: sl.enchantments ? { ...sl.enchantments } : undefined,
+        damage: sl.damage,
+    });
+}
+function countsOf(slots) {
+    const counts = {};
+    for (const st of Object.values(slots))
+        counts[st.id] = (counts[st.id] ?? 0) + st.count;
+    return counts;
+}
+function fillVolume(e) {
+    if (e.kind !== "fill")
+        return 0;
+    const { lo, hi } = (0, world_js_1.bounds)({ from: e.from, to: e.to });
+    return (hi.x - lo.x + 1) * (hi.y - lo.y + 1) * (hi.z - lo.z + 1);
+}
+/** Splits the setup effects into batches under the engine's limits, in order. */
+function splitBatches(effects) {
+    const out = [];
+    let current = [];
+    let volume = 0;
+    for (const e of effects) {
+        const v = fillVolume(e);
+        if (v > exports.MAX_FILL_VOLUME) {
+            throw (0, errors_js_1.apiError)("fill_too_large", `a fill of ${v} blocks exceeds ${exports.MAX_FILL_VOLUME}; split it`, { path: "setup" });
+        }
+        if (current.length >= exports.MAX_BATCH_EFFECTS || volume + v > exports.MAX_FILL_VOLUME) {
+            out.push(current);
+            current = [];
+            volume = 0;
+        }
+        current.push(e);
+        volume += v;
+    }
+    if (current.length > 0 || out.length === 0)
+        out.push(current);
+    return out;
+}
+const missingCapabilities = (have) => ["move", "damage", "death", "mirror"].filter((c) => !have.includes(c));
+/** The non-enumerable derived fields of a player object: `isActive`. Survives a JSON round trip by re-attachment. */
+function attachDerived(p) {
+    Object.defineProperty(p, "isActive", {
+        get() {
+            return !this.eliminated;
+        },
+        enumerable: false,
+        configurable: true,
+    });
+    return p;
+}
+// ---------------------------------------------------------------- views
+/** Every view handed to an author callback: the state must never hold one. */
+const VIEWS = new WeakSet();
+function refuseWrite(what) {
+    throw (0, errors_js_1.apiError)("read_only", `${what} is read-only in this callback`, { path: what });
+}
+/**
+ * The traps of a view over `target`. The Proxy's own target is an empty shadow (an array for an
+ * array), never the live object: the invariants of a frozen property then never force a raw child
+ * out, so a parent the author froze themself still hands out views. `read` maps a nested value.
+ */
+function viewTraps(target, what, read) {
+    return {
+        get: (_t, key, receiver) => read(key, Reflect.get(target, key, receiver), receiver),
+        has: (_t, key) => key in target,
+        ownKeys: () => Reflect.ownKeys(target),
+        getOwnPropertyDescriptor(shadow, key) {
+            const d = Reflect.getOwnPropertyDescriptor(target, key);
+            if (d === undefined)
+                return undefined;
+            // The shadow's own non-configurable property (an array's `length`, always writable there) keeps
+            // its shape; every other property is reported configurable, so a frozen live object binds nothing.
+            const own = Reflect.getOwnPropertyDescriptor(shadow, key);
+            if (own !== undefined && own.configurable === false) {
+                return { ...d, configurable: false, writable: own.writable ?? true, value: read(key, d.value, undefined) };
+            }
+            if ("value" in d)
+                return { ...d, configurable: true, value: read(key, d.value, undefined) };
+            return { ...d, configurable: true };
+        },
+        getPrototypeOf: () => Object.getPrototypeOf(target),
+        set: (_t, key) => refuseWrite(`${what}.${String(key)}`),
+        deleteProperty: (_t, key) => refuseWrite(`${what}.${String(key)}`),
+        defineProperty: (_t, key) => refuseWrite(`${what}.${String(key)}`),
+        preventExtensions: () => refuseWrite(what),
+        setPrototypeOf: () => refuseWrite(what),
+    };
+}
+const shadowOf = (target) => (Array.isArray(target) ? [] : {});
+/**
+ * A deep read-only view of an object: every nested object is a view too, and a write throws
+ * `read_only`. One view per target and reduction, so identities hold inside a callback. A view kept
+ * after the reduction reads the published state, which is frozen.
+ */
+function readView(r, target, what) {
+    const cached = r.views.read.get(target);
+    if (cached)
+        return cached;
+    const view = new Proxy(shadowOf(target), viewTraps(target, what, (_key, v) => (v !== null && typeof v === "object" ? readView(r, v, what) : v)));
+    VIEWS.add(view);
+    r.views.read.set(target, view);
+    return view;
+}
+/**
+ * A participant as a callback sees it. The observations (`pos`, `slots`, `score`, ...) are read-only
+ * in every mode; `state` is writable in a handler and read-only in a pure callback. While a derived
+ * score pass runs, `score` reads the vector under evaluation (`r.scoreOverlay`).
+ */
+function playerView(r, p, writable) {
+    const cache = writable ? r.views.player : r.views.read;
+    const cached = cache.get(p);
+    if (cached)
+        return cached;
+    const view = new Proxy(shadowOf(p), viewTraps(p, "p", (key, v) => {
+        if (key === "score" && r.scoreOverlay !== null)
+            return r.scoreOverlay[p.name] ?? p.score;
+        if (v === null || typeof v !== "object")
+            return v;
+        if (key === "state" && writable)
+            return v;
+        return readView(r, v, `p.${String(key)}`);
+    }));
+    VIEWS.add(view);
+    cache.set(p, view);
+    return view;
+}
+/**
+ * A plain deep copy of a value an author handed back: views become plain objects, so the copy can
+ * be validated as JSON, stored on an action or sent across the worker boundary.
+ */
+function snapshot(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== "object")
+        return value;
+    const prior = seen.get(value);
+    if (prior !== undefined)
+        return prior;
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const x of value)
+            out.push(snapshot(x, seen));
+        return out;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null)
+        return value; // a class instance: assertJson names it
+    const out = {};
+    seen.set(value, out);
+    for (const [k, v] of Object.entries(value))
+        out[k] = snapshot(v, seen);
+    return out;
+}
+/** An event payload with every player replaced by its handler view. Frozen observations pass through. */
+function viewPayload(r, value) {
+    if (value === null || typeof value !== "object" || Object.isFrozen(value))
+        return value;
+    const asPlayer = value;
+    if (typeof asPlayer.name === "string" && r.s.players[asPlayer.name] === value)
+        return playerView(r, asPlayer, true);
+    if (Array.isArray(value))
+        return value.map((x) => viewPayload(r, x));
+    const out = {};
+    for (const [k, v] of Object.entries(value))
+        out[k] = viewPayload(r, v);
+    return out;
+}
+function createReducer(def) {
+    const config = def.config;
+    const roleNames = Object.keys(config.roles);
+    const declaredZones = Object.keys(def.zones);
+    const derivedScores = def.outcome.scores !== undefined;
+    const paramDefaults = () => Object.fromEntries(Object.entries(config.params ?? {}).map(([k, p]) => [k, p.default]));
+    const endStateNames = () => Array.isArray(config.endStates) ? [...config.endStates] : Object.keys(config.endStates ?? {});
+    const voteIds = Object.keys(def.votes);
+    const init = () => ({
+        seed: 0,
+        rng: 0,
+        params: paramDefaults(),
+        capabilities: [],
+        locations: {},
+        markers: [],
+        status: "CONNECTING",
+        initialized: false,
+        tick: 0,
+        dt: 0,
+        startTick: 0,
+        setup: null,
+        phase: null,
+        phaseStartTick: 0,
+        phaseEntries: 0,
+        phaseDuration: null,
+        fired: {},
+        every: {},
+        timers: {},
+        nextGen: 0,
+        players: {},
+        game: {},
+        votes: Object.fromEntries(voteIds.map((id) => [id, { open: false, round: 0, cast: {} }])),
+        walks: {},
+        batches: {},
+        containers: {},
+        world: (0, world_js_1.emptyWorld)(),
+        nextId: 0,
+        winners: [],
+        endState: "",
+        reason: null,
+        frozen: null,
+    });
+    // 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;
+        const s = { ...JSON.parse(JSON.stringify(rest)), world };
+        for (const p of Object.values(s.players))
+            attachDerived(p);
+        return s;
+    };
+    // ------------------------------------------------------------ callbacks
+    /** A Promise-like return is an author error: callbacks are synchronous. */
+    function assertSync(out, what) {
+        if (out !== null && typeof out === "object" && typeof out.then === "function") {
+            out.catch(() => undefined);
+            throw (0, errors_js_1.apiError)("async_callback", `${what} returned a Promise; callbacks are synchronous`);
+        }
+    }
+    /** Runs an author callback under a frame; a Promise-like return is an author error. */
+    function run(r, kind, fn, ...args) {
+        if (typeof fn !== "function")
+            return undefined;
+        const prev = r.frame;
+        r.frame = { kind };
+        try {
+            const out = fn(...args);
+            assertSync(out, "a challenge callback");
+            return out;
+        }
+        finally {
+            r.frame = prev;
+        }
+    }
+    const phaseSpec = (s) => (s.phase === null ? undefined : def.phaseSpecs[s.phase]);
+    // ------------------------------------------------------------ contexts
+    /** A seeded generator over the reduction's state. `close()` shuts this instance (the init one, after the initializers). */
+    function makeRandom(r, whenClosed) {
+        const s = r.s;
+        let closed = false;
+        const draw = () => {
+            if (r.closed || closed)
+                throw (0, errors_js_1.apiError)("ctx_closed", `${whenClosed}: this random source is closed`);
+            const x = mulberry(s.rng);
+            s.rng = x.rng;
+            return x.u;
+        };
+        const random = {
+            int(lo, hi) {
+                if (!Number.isFinite(lo) || !Number.isFinite(hi) || hi < lo)
+                    throw (0, errors_js_1.apiError)("bad_range", `random.int(${lo}, ${hi}): lo must be <= hi`);
+                return lo + Math.floor(draw() * (hi - lo + 1));
+            },
+            pick(items) {
+                if (items.length === 0)
+                    return undefined;
+                return items[Math.floor(draw() * items.length)];
+            },
+            shuffle(items) {
+                const out = [...items];
+                for (let i = out.length - 1; i > 0; i--) {
+                    const j = Math.floor(draw() * (i + 1));
+                    [out[i], out[j]] = [out[j], out[i]];
+                }
+                return out;
+            },
+            weighted(items) {
+                const total = items.reduce((n, it) => n + Math.max(0, it.weight), 0);
+                if (total <= 0)
+                    return undefined;
+                let x = draw() * total;
+                for (const it of items) {
+                    x -= Math.max(0, it.weight);
+                    if (x < 0)
+                        return it.value;
+                }
+                return items[items.length - 1]?.value;
+            },
+        };
+        return {
+            random,
+            close: () => {
+                closed = true;
+            },
+        };
+    }
+    function makeCtx(r, mode) {
+        const s = r.s;
+        const writable = mode === "setup" || mode === "full";
+        const guard = (op, allowed) => {
+            if (r.closed)
+                throw (0, errors_js_1.apiError)("ctx_closed", `${op}: the reduction ended; a context does not survive its callback`);
+            if (!allowed.includes(mode)) {
+                throw (0, errors_js_1.apiError)("read_only", `${op} is not available in a ${mode} callback`, { path: op });
+            }
+        };
+        const write = (op) => guard(op, ["setup", "full"]);
+        const notify = (op) => guard(op, ["notify", "setup", "full"]);
+        const flow = (op) => guard(op, ["full"]);
+        const push = (raw) => {
+            // A plain copy: an author's argument may be a view (`p.pos`, `g.params.box`).
+            const effect = compact(snapshot(raw));
+            if (r.batch)
+                r.batch.push(effect);
+            else
+                r.actions.push({ type: "effect", effect });
+        };
+        const targets = (to) => to === "all" ? [undefined] : (Array.isArray(to) ? to : [to]).map((p) => p.name);
+        const players = () => Object.values(s.players)
+            .sort((a, b) => a.seatNumber - b.seatNumber)
+            .map((p) => playerView(r, p, writable));
+        const requestGuard = (op) => {
+            flow(op);
+            if (r.frame.kind === "exit")
+                throw (0, errors_js_1.apiError)("request_in_exit", `${op}: no phase or end request inside exit`);
+            if (r.frame.kind !== "handler")
+                throw (0, errors_js_1.apiError)("read_only", `${op} is not available in a ${r.frame.kind} callback`);
+            if (s.status !== "PLAYING")
+                throw (0, errors_js_1.apiError)("lifecycle", `${op}: the game is not running (status ${s.status})`);
+        };
+        const voteState = (voteId) => {
+            const v = s.votes[voteId];
+            if (!v)
+                throw (0, errors_js_1.notDeclared)("votes", voteId, voteIds);
+            return v;
+        };
+        const { random } = makeRandom(r, "g.random");
+        const g = {
+            get state() {
+                return writable ? s.game : readView(r, s.game, "g.state");
+            },
+            get params() {
+                return readView(r, s.params, "g.params");
+            },
+            get players() {
+                return players();
+            },
+            get activePlayers() {
+                return players().filter((p) => !p.eliminated);
+            },
+            player(name) {
+                const p = s.players[name];
+                return p ? playerView(r, p, writable) : undefined;
+            },
+            playersWithRole: (role) => players().filter((p) => p.role === role),
+            playerWithRole(role) {
+                if (!roleNames.includes(role))
+                    throw (0, errors_js_1.notDeclared)("roles", role, roleNames);
+                const found = players().filter((p) => p.role === role);
+                if (found.length !== 1) {
+                    throw (0, errors_js_1.apiError)("role_count", `playerWithRole("${role}"): ${found.length} participants have that role, not 1`, {
+                        path: "roles",
+                        value: role,
+                    });
+                }
+                return found[0];
+            },
+            get tick() {
+                return s.tick;
+            },
+            get elapsed() {
+                return (s.frozen ? s.frozen.elapsed : s.tick - s.startTick);
+            },
+            get status() {
+                return s.status;
+            },
+            get phase() {
+                return s.phase;
+            },
+            get phaseEntry() {
+                return s.phase === null ? 0 : s.phaseEntries;
+            },
+            get phaseElapsed() {
+                return (s.frozen ? s.frozen.phaseElapsed : s.phase === null ? 0 : s.tick - s.phaseStartTick);
+            },
+            get phaseRemaining() {
+                if (s.phaseDuration === null)
+                    return null;
+                return Math.max(0, s.phaseDuration - (s.tick - s.phaseStartTick));
+            },
+            location(name) {
+                const at = s.locations[name];
+                if (!at)
+                    throw (0, errors_js_1.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] })),
+            inZone(p, zone) {
+                if (typeof zone === "string") {
+                    if (!declaredZones.includes(zone))
+                        throw (0, errors_js_1.notDeclared)("zones", zone, declaredZones);
+                    return p.zones.includes(zone);
+                }
+                return p.pos !== null && (0, world_js_1.inBox)(p.pos, zone);
+            },
+            countItems(p, match) {
+                let n = 0;
+                for (const st of Object.values(p.slots))
+                    if (itemMatches(st, match))
+                        n += st.count;
+                return n;
+            },
+            blockAt: (at) => (0, world_js_1.blockAt)(s.world, at),
+            blockStateAt(at) {
+                const state = (0, world_js_1.blockStateAt)(s.world, at);
+                return state === undefined ? undefined : parseBlockState(state);
+            },
+            blockMatches(at, match) {
+                const state = (0, world_js_1.blockStateAt)(s.world, at);
+                if (state === undefined) {
+                    throw (0, errors_js_1.unavailableError)("block_unknown", `blockMatches: the chunk of ${posKey(at)} is not loaded`);
+                }
+                return blockPredicate(match)(state);
+            },
+            blockCount(box, match, opts) {
+                if (!opts?.partial && !(0, world_js_1.regionLoaded)(s.world, box)) {
+                    throw (0, errors_js_1.unavailableError)("block_unknown", "blockCount: a chunk of the box is not loaded (pass { partial: true } to count what is)");
+                }
+                return (0, world_js_1.blockCount)(s.world, box, blockPredicate(match));
+            },
+            findBlocks(box, match, opts) {
+                if (!opts?.partial && !(0, world_js_1.regionLoaded)(s.world, box)) {
+                    throw (0, errors_js_1.unavailableError)("block_unknown", "findBlocks: a chunk of the box is not loaded (pass { partial: true } to search what is)");
+                }
+                return (0, world_js_1.findBlocks)(s.world, box, blockPredicate(match), opts?.limit);
+            },
+            regionLoaded: (box) => (0, world_js_1.regionLoaded)(s.world, box),
+            get worldTime() {
+                return s.world.time;
+            },
+            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;
+            },
+            containerContents(at) {
+                const c = s.containers[posKey(at)];
+                return c ? countsOf(c.slots) : undefined;
+            },
+            votes: (voteId) => ({ ...voteState(voteId).cast }),
+            vote: (p, voteId) => voteState(voteId).cast[p.name],
+            voteOpen: (voteId) => voteState(voteId).open,
+            tally(voteId) {
+                const v = voteState(voteId);
+                const counts = {};
+                for (const option of Object.values(v.cast))
+                    counts[option] = (counts[option] ?? 0) + 1;
+                const best = Math.max(0, ...Object.values(counts));
+                const leaders = best === 0 ? [] : Object.keys(counts).filter((o) => counts[o] === best);
+                const abstaining = players().filter((p) => !p.eliminated && v.cast[p.name] === undefined);
+                return { counts, leaders, abstaining };
+            },
+            // ---- notifications
+            say(message) {
+                notify("say");
+                push({ kind: "announce", message });
+            },
+            tell(to, message) {
+                notify("tell");
+                for (const name of targets(to))
+                    push({ kind: "announce", message, to: name });
+            },
+            title(to, options) {
+                notify("title");
+                const times = options.fadeIn !== undefined || options.stay !== undefined || options.fadeOut !== undefined
+                    ? {
+                        fadeIn: options.fadeIn === undefined ? 10 : (0, time_js_1.toTicks)(options.fadeIn),
+                        stay: options.stay === undefined ? 70 : (0, time_js_1.toTicks)(options.stay),
+                        fadeOut: options.fadeOut === undefined ? 20 : (0, time_js_1.toTicks)(options.fadeOut),
+                    }
+                    : undefined;
+                for (const name of targets(to))
+                    push({ kind: "title", player: name, title: options.title, subtitle: options.subtitle, times });
+            },
+            log(message, opts) {
+                notify("log");
+                r.actions.push(compact({ type: "log", player: opts?.player?.name, message, data: snapshot(opts?.data) }));
+            },
+            setMetric(name, value, opts) {
+                notify("setMetric");
+                if (!Number.isFinite(value))
+                    throw (0, errors_js_1.apiError)("bad_metric", `setMetric("${name}"): ${value} is not finite`);
+                r.actions.push(compact({ type: "metric", name, value, player: opts?.player?.name }));
+            },
+            achievement(player, id) {
+                notify("achievement");
+                r.actions.push({ type: "log", player: player.name, message: `ACHIEVEMENT:${id}`, data: { achievement: id } });
+            },
+            // ---- state writes
+            setScore(p, score) {
+                write("setScore");
+                if (derivedScores) {
+                    throw (0, errors_js_1.apiError)("score_derived", "setScore: outcome.scores computes the scores; a manual write is refused");
+                }
+                if (!Number.isFinite(score))
+                    throw (0, errors_js_1.apiError)("bad_score", `setScore: ${score} is not finite`);
+                (s.players[p.name] ?? p).score = score;
+            },
+            addScore(p, delta) {
+                write("addScore");
+                if (derivedScores) {
+                    throw (0, errors_js_1.apiError)("score_derived", "addScore: outcome.scores computes the scores; a manual write is refused");
+                }
+                if (!Number.isFinite(delta))
+                    throw (0, errors_js_1.apiError)("bad_score", `addScore: ${delta} is not finite`);
+                const target = s.players[p.name] ?? p;
+                target.score += delta;
+            },
+            eliminate(p) {
+                write("eliminate");
+                const target = s.players[p.name] ?? p;
+                if (target.eliminated)
+                    return;
+                target.eliminated = true;
+                push({ kind: "eliminate", player: p.name });
+            },
+            get random() {
+                write("random");
+                return random;
+            },
+            // ---- effects
+            give(p, item, count) {
+                write("give");
+                const id = typeof item === "string" ? item : item.id;
+                const n = count ?? (typeof item === "string" ? 1 : (item.count ?? 1));
+                push({ kind: "give", player: p.name, item: id, count: n, nbt: itemNbt(item) });
+            },
+            clear(p, item, count) {
+                write("clear");
+                push({ kind: "clear", player: p.name, item, count });
+            },
+            effect(p, options) {
+                write("effect");
+                push({
+                    kind: "effect",
+                    player: p.name,
+                    effect: options.id,
+                    seconds: Math.max(1, Math.round((0, time_js_1.toTicks)(options.duration) / 20)),
+                    amplifier: options.amplifier ?? 0,
+                });
+            },
+            teleport(p, to) {
+                write("teleport");
+                push({ kind: "teleport", player: p.name, to: { ...to } });
+            },
+            kill(p) {
+                write("kill");
+                push({ kind: "kill", player: p.name });
+            },
+            gamemode(p, mode) {
+                write("gamemode");
+                push({ kind: "gamemode", player: p.name, mode });
+            },
+            attribute(p, attribute, value) {
+                write("attribute");
+                push({ kind: "attribute", player: p.name, attribute, value });
+            },
+            fill(from, to, block) {
+                write("fill");
+                push({ kind: "fill", from: { ...from }, to: { ...to }, block: blockSpecString(block) });
+            },
+            setBlock(at, block) {
+                write("setBlock");
+                const nbt = typeof block === "string" ? undefined : block.blockEntity;
+                push({ kind: "setblock", at: { ...at }, block: blockSpecString(block), nbt });
+            },
+            summon(entity, at, opts) {
+                write("summon");
+                push({ kind: "summon", entity, at: { ...at }, nbt: opts?.nbt });
+            },
+            killEntities(entities) {
+                write("killEntities");
+                push({ kind: "kill_entities", entities });
+            },
+            time(value) {
+                write("time");
+                push({ kind: "time", value });
+            },
+            gamerule(rule, value) {
+                write("gamerule");
+                push({ kind: "gamerule", rule, value });
+            },
+            setSpawn(at) {
+                write("setSpawn");
+                push({ kind: "spawn", at: { ...at } });
+            },
+            worldBorder(opts) {
+                write("worldBorder");
+                push({
+                    kind: "worldborder",
+                    center: opts.center,
+                    size: opts.size,
+                    seconds: opts.over === undefined ? undefined : (0, time_js_1.toTicks)(opts.over) / 20,
+                });
+            },
+            container(at, items) {
+                write("container");
+                const out = items.map((it) => typeof it === "string"
+                    ? { item: it, count: 1 }
+                    : compact({
+                        item: it.id,
+                        count: it.count ?? 1,
+                        nbt: itemNbt(it),
+                        name: it.name,
+                        lore: it.lore,
+                        enchantments: it.enchantments,
+                        damage: it.damage,
+                    }));
+                push({ kind: "container", at: { ...at }, items: out });
+            },
+            command(cmd) {
+                write("command");
+                r.actions.push({ type: "log", message: `raw command: ${cmd}` });
+                push({ kind: "command", cmd });
+            },
+            // ---- flow
+            startPhase(name) {
+                requestGuard("startPhase");
+                if (!def.phases.includes(name))
+                    throw (0, errors_js_1.notDeclared)("phases", name, def.phases);
+                if (r.req.end)
+                    throw (0, errors_js_1.apiError)("end_requested", "startPhase: the game end is already requested");
+                // One transition per event group: a second request, from this callback or another handler of the same event, is an error.
+                if (r.req.phase !== null)
+                    throw (0, errors_js_1.apiError)("phase_twice", "startPhase: one phase transition per callback");
+                r.req.phase = { target: name };
+            },
+            endPhase() {
+                requestGuard("endPhase");
+                if (s.phase === null)
+                    throw (0, errors_js_1.apiError)("phase_none", "endPhase: no phase is active");
+                if (!def.phaseSpecs[s.phase]) {
+                    throw (0, errors_js_1.apiError)("phase_no_next", `endPhase: the phase "${s.phase}" has no .phase() step, so no next`, {
+                        path: `phases.${s.phase}`,
+                    });
+                }
+                if (r.req.end)
+                    throw (0, errors_js_1.apiError)("end_requested", "endPhase: the game end is already requested");
+                if (r.req.phase !== null)
+                    throw (0, errors_js_1.apiError)("phase_twice", "endPhase: one phase transition per callback");
+                r.req.phase = { next: true };
+            },
+            endGame(endState) {
+                requestGuard("endGame");
+                if (endState !== undefined && !endStateNames().includes(endState)) {
+                    throw (0, errors_js_1.notDeclared)("endStates", endState, endStateNames());
+                }
+                if (r.req.end)
+                    return;
+                r.req.end = { reason: "call", endState };
+                r.req.phase = null;
+            },
+            schedule(name, after) {
+                flow("schedule");
+                if (def.timers && !def.timers.includes(name))
+                    throw (0, errors_js_1.notDeclared)("timers", name, def.timers);
+                s.timers[name] = { due: s.tick + (0, time_js_1.toTicks)(after), gen: ++s.nextGen };
+            },
+            cancel(name) {
+                flow("cancel");
+                delete s.timers[name];
+            },
+            openVote(voteId) {
+                flow("openVote");
+                const v = voteState(voteId);
+                if (v.open)
+                    throw (0, errors_js_1.apiError)("vote_open", `openVote("${voteId}"): a round is open; close it or reset it`);
+                v.open = true;
+                v.round += 1;
+                v.cast = {};
+                r.actions.push({ type: "vote_round", voteId, open: true, round: v.round });
+            },
+            closeVote(voteId) {
+                flow("closeVote");
+                const v = voteState(voteId);
+                if (!v.open)
+                    return;
+                v.open = false;
+                r.actions.push({ type: "vote_round", voteId, open: false, round: v.round });
+            },
+            resetVote(voteId) {
+                flow("resetVote");
+                const v = voteState(voteId);
+                v.cast = {};
+                // A reset is a new round for the arena: a request stamped with the old round is refused.
+                v.round += 1;
+                r.actions.push({ type: "vote_round", voteId, open: v.open, round: v.round });
+            },
+            walk(p, to, opts) {
+                flow("walk");
+                for (const [id, w] of Object.entries(s.walks))
+                    if (w.player === p.name)
+                        delete s.walks[id];
+                const id = `walk:${s.nextId++}`;
+                const fallback = opts?.fallback ?? "teleport";
+                s.walks[id] = { player: p.name, fallback, ...to };
+                r.actions.push({ type: "walk", id, player: p.name, to: { ...to }, fallback });
+            },
+            batch(name, fn) {
+                flow("batch");
+                if (r.batch)
+                    throw (0, errors_js_1.apiError)("batch_nested", "batch: a batch cannot open inside another");
+                if (Object.values(s.batches).includes(name)) {
+                    throw (0, errors_js_1.apiError)("batch_pending", `batch("${name}"): a batch with that name is pending`, { value: name });
+                }
+                const effects = [];
+                r.batch = effects;
+                try {
+                    assertSync(fn(), `batch("${name}")`);
+                }
+                finally {
+                    r.batch = null;
+                }
+                // The transport id is unique for the run; the public name repeats once its batch is done.
+                const id = `batch:${s.nextId++}`;
+                s.batches[id] = name;
+                r.actions.push({ type: "batch", id, effects });
+            },
+        };
+        return g;
+    }
+    // ------------------------------------------------------------ dispatch
+    /** One event to the ordered global group, then, in the same entry, to the phase's handler. */
+    function fire(r, key, payload) {
+        const s = r.s;
+        if (r.req.end || s.status !== "PLAYING")
+            return;
+        const entry = s.phaseEntries;
+        const g = ctxOf(r, "full");
+        const e = viewPayload(r, payload);
+        for (const set of def.on) {
+            if (r.req.end)
+                break;
+            const h = set[key];
+            if (h)
+                run(r, "handler", h, g, e);
+        }
+        resolvePhaseRequest(r);
+        if (r.req.end || s.phaseEntries !== entry)
+            return;
+        const local = phaseSpec(s)?.on?.[key];
+        if (local)
+            run(r, "handler", local, g, e);
+        resolvePhaseRequest(r);
+    }
+    /** The contexts of a reduction, one per mode, built on first use. */
+    const ctxCache = new WeakMap();
+    function ctxOf(r, mode) {
+        let cache = ctxCache.get(r);
+        if (!cache) {
+            cache = {};
+            ctxCache.set(r, cache);
+        }
+        let ctx = cache[mode];
+        if (!ctx) {
+            ctx = makeCtx(r, mode);
+            cache[mode] = ctx;
+        }
+        return ctx;
+    }
+    function clearPhaseWork(s) {
+        const prefix = `phase:${s.phaseEntries}:`;
+        for (const key of Object.keys(s.fired))
+            if (key.startsWith(prefix))
+                delete s.fired[key];
+        for (const key of Object.keys(s.every))
+            if (key.startsWith(prefix))
+                delete s.every[key];
+    }
+    function resolveNext(r, spec) {
+        const next = typeof spec.next === "function" ? run(r, "pure", spec.next, ctxOf(r, "read")) : spec.next;
+        if (next === undefined)
+            throw (0, errors_js_1.apiError)("phase_no_next", "the phase's next returned nothing");
+        if (next !== "END" && !def.phases.includes(next))
+            throw (0, errors_js_1.notDeclared)("phases", String(next), def.phases);
+        return next;
+    }
+    /** Applies the pending phase request: exit once, enter once; a chained request from `enter` loops under the budget. */
+    function resolvePhaseRequest(r) {
+        const s = r.s;
+        while (r.req.phase !== null && r.req.end === null) {
+            const request = r.req.phase;
+            r.req.phase = null;
+            const target = "next" in request ? resolveNext(r, phaseSpec(s)) : request.target;
+            if (target === "END") {
+                r.req.end = { reason: "phase" };
+                return;
+            }
+            if (r.req.budget === 0) {
+                throw (0, errors_js_1.apiError)("phase_chain", `more than ${exports.MAX_TRANSITIONS_PER_EVENT} phase transitions in one event`);
+            }
+            r.req.budget -= 1;
+            if (s.phase !== null)
+                run(r, "exit", phaseSpec(s)?.exit, ctxOf(r, "full"));
+            clearPhaseWork(s);
+            s.phase = target;
+            s.phaseStartTick = s.tick;
+            s.phaseEntries += 1;
+            const spec = def.phaseSpecs[target];
+            s.phaseDuration = null;
+            if (spec?.duration !== undefined) {
+                const d = typeof spec.duration === "function"
+                    ? run(r, "pure", spec.duration, ctxOf(r, "read"))
+                    : spec.duration;
+                if (d === undefined)
+                    throw (0, errors_js_1.apiError)("bad_duration", `phases.${target}.duration returned nothing`);
+                const t = (0, time_js_1.toTicks)(d);
+                if (t < 1)
+                    throw (0, errors_js_1.apiError)("bad_duration", `phases.${target}.duration is ${t} ticks; at least 1`);
+                s.phaseDuration = t;
+            }
+            (spec?.every ?? []).forEach((_e, i) => {
+                s.every[`phase:${s.phaseEntries}:every:${i}`] = s.tick;
+            });
+            run(r, "handler", spec?.enter, ctxOf(r, "full"));
+        }
+    }
+    // ------------------------------------------------------------ scores, checkpoint, finalization
+    /** The derived-score vector from the committed baseline: `outcome.scores` reads the previous scores as `p.score`. */
+    function scoreVector(r) {
+        const list = Object.values(r.s.players).sort((a, b) => a.seatNumber - b.seatNumber);
+        const g = ctxOf(r, "read");
+        const vector = {};
+        r.scoreOverlay = r.previousScores;
+        try {
+            for (const p of list) {
+                const v = run(r, "pure", def.outcome.scores, g, playerView(r, p, false));
+                if (typeof v !== "number" || !Number.isFinite(v)) {
+                    throw (0, errors_js_1.apiError)("bad_score", `outcome.scores returned ${String(v)} for ${p.name}; a finite number is required`);
+                }
+                vector[p.name] = v;
+            }
+        }
+        finally {
+            r.scoreOverlay = null;
+        }
+        return vector;
+    }
+    /** The candidate pass of the checkpoint: `until` and `endWhen` read it as `p.score`; nothing is committed. */
+    function candidateScores(r) {
+        if (!derivedScores)
+            return;
+        r.candidate = scoreVector(r);
+        r.scoreOverlay = r.candidate;
+    }
+    /**
+     * The one commit per reduction. `recompute` when a transition (exit, enter) changed the state after
+     * the candidate pass, or at the end of the game: the final vector comes from the same baseline.
+     */
+    function commitScores(r, recompute) {
+        if (!derivedScores)
+            return;
+        const vector = recompute || r.candidate === null ? scoreVector(r) : r.candidate;
+        r.candidate = null;
+        r.scoreOverlay = null;
+        for (const p of Object.values(r.s.players))
+            p.score = vector[p.name] ?? p.score;
+    }
+    /** The checkpoint after every event's handlers (PLAYING only). */
+    function checkpoint(r) {
+        const s = r.s;
+        if (s.status !== "PLAYING" || r.req.end)
+            return;
+        candidateScores(r);
+        // The phase's own end, staged: until, a pass-through on a later tick, or the timeout.
+        let staged = false;
+        const spec = phaseSpec(s);
+        if (spec) {
+            if (spec.until) {
+                staged = run(r, "pure", spec.until, ctxOf(r, "read")) === true;
+            }
+            else if (r.isTick && s.phaseDuration === null && s.tick > s.phaseStartTick) {
+                staged = true;
+            }
+            if (!staged && r.isTick && s.phaseDuration !== null && s.tick - s.phaseStartTick >= s.phaseDuration) {
+                staged = true;
+            }
+        }
+        // The game's end, on the pre-transition phase: it wins over the staged phase change.
+        if (def.duration !== undefined && s.tick - s.startTick >= def.duration) {
+            r.req.end = { reason: "time" };
+        }
+        else if (def.outcome.endWhen &&
+            run(r, "pure", def.outcome.endWhen, ctxOf(r, "read")) === true) {
+            r.req.end = { reason: "rule" };
+        }
+        // From here on `p.score` reads the committed scores again: exit and enter see the same values on every end path.
+        r.scoreOverlay = null;
+        if (r.req.end)
+            return;
+        if (staged) {
+            r.req.phase = { next: true };
+            resolvePhaseRequest(r);
+            if (r.req.end)
+                return;
+        }
+        commitScores(r, staged);
+    }
+    /** The end of the game: exit, final scores, winners and end state, the frozen result, the hooks, game_over. */
+    function finalize(r) {
+        const s = r.s;
+        const end = r.req.end;
+        if (!end || s.status === "OVER")
+            return;
+        if (s.phase !== null)
+            run(r, "exit", phaseSpec(s)?.exit, ctxOf(r, "full"));
+        commitScores(r, true);
+        const gRead = ctxOf(r, "read");
+        const names = new Set(Object.keys(s.players));
+        const rawWinners = (run(r, "pure", def.outcome.winners, gRead) ?? []).map((p) => p.name);
+        const winners = [];
+        for (const name of rawWinners) {
+            if (!names.has(name))
+                throw (0, errors_js_1.apiError)("bad_winner", `outcome.winners named "${name}", not a participant`);
+            if (!winners.includes(name))
+                winners.push(name);
+        }
+        let endState = end.endState ?? run(r, "pure", def.outcome.endState, gRead) ?? "";
+        if (endState !== "" && !endStateNames().includes(endState)) {
+            throw (0, errors_js_1.notDeclared)("endStates", endState, endStateNames());
+        }
+        endState = String(endState);
+        const elapsed = s.tick - s.startTick;
+        const phaseElapsed = s.phase === null ? 0 : s.tick - s.phaseStartTick;
+        s.frozen = { elapsed, phaseElapsed };
+        const won = new Set(winners);
+        const result = Object.freeze({
+            winners: Object.freeze([...winners]),
+            endState: endState,
+            reason: end.reason,
+            phase: s.phase,
+            elapsed: elapsed,
+            phaseElapsed: phaseElapsed,
+            isWinner: (p) => won.has(p.name),
+        });
+        s.status = "OVER";
+        s.endState = endState;
+        s.winners = winners;
+        s.reason = end.reason;
+        run(r, "notify", def.onOver, ctxOf(r, "notify"), result);
+        const judge = snapshot(run(r, "pure", def.judgeContext, gRead, result));
+        const gameOver = { type: "game_over", winners, endState, reason: end.reason };
+        if (judge !== undefined) {
+            if (judge === null || typeof judge !== "object" || Array.isArray(judge)) {
+                throw (0, errors_js_1.apiError)("bad_judge_context", "judgeContext must return an object");
+            }
+            assertJson(judge, "judgeContext");
+            gameOver.judgeContext = judge;
+        }
+        r.actions.push(gameOver);
+    }
+    /** The SDK's own terminal result: no author callback runs. */
+    function failRun(s, actions, endState, message, data) {
+        actions.push(compact({ type: "log", message, data }));
+        if (s.status === "OVER")
+            return;
+        s.status = "OVER";
+        s.endState = endState;
+        s.winners = [];
+        s.reason = "error";
+        s.frozen = { elapsed: s.tick - s.startTick, phaseElapsed: s.phase === null ? 0 : s.tick - s.phaseStartTick };
+        actions.push({ type: "game_over", winners: [], endState, reason: "error" });
+    }
+    // ------------------------------------------------------------ lifecycle
+    function worldGlobals() {
+        if (!def.world)
+            return [];
+        const w = def.world;
+        const out = [];
+        if (w.spawn)
+            out.push({ kind: "spawn", at: { ...w.spawn } });
+        if (w.time !== false)
+            out.push({ kind: "time", value: w.time });
+        out.push({ kind: "gamerule", rule: "doDaylightCycle", value: w.daylightCycle });
+        out.push({ kind: "gamerule", rule: "doMobSpawning", value: w.mobSpawning });
+        out.push({ kind: "gamerule", rule: "naturalRegeneration", value: w.naturalRegeneration });
+        return out;
+    }
+    function worldPlayers(s) {
+        if (!def.world || def.world.maxHealth === false)
+            return [];
+        return Object.values(s.players).map((p) => ({
+            kind: "attribute",
+            player: p.name,
+            attribute: "minecraft:generic.max_health",
+            value: def.world?.maxHealth,
+        }));
+    }
+    /** The state initializers, once, with the observed players. */
+    function initialize(r) {
+        const s = r.s;
+        const { random, close: closeRandom } = makeRandom(r, "init.random");
+        const roster = Object.values(s.players).sort((a, b) => a.seatNumber - b.seatNumber);
+        // Every player has a position here: `allReady` gates this call.
+        // One argument object per call, with its own copies of the data: an initializer may keep
+        // `init.locations.hub` in its state, and two states never share an object.
+        const initArg = () => ({
+            params: snapshot(s.params),
+            random,
+            players: roster.map((p) => playerView(r, p, false)),
+            locations: snapshot(s.locations),
+        });
+        s.game = (run(r, "init", def.state.game, initArg()) ?? {});
+        for (const p of roster) {
+            const forRole = def.state.players?.[p.role];
+            const observed = playerView(r, p, false);
+            const own = forRole
+                ? run(r, "init", forRole, observed, initArg())
+                : run(r, "init", def.state.player, observed, initArg());
+            p.state = (own ?? {});
+        }
+        closeRandom();
+        s.initialized = true;
+        assertJson({ game: s.game, players: Object.fromEntries(roster.map((p) => [p.name, p.state])) }, "state");
+    }
+    function sendSetupBatch(r, effects, index) {
+        r.actions.push({ type: "batch", id: `setup:${index}`, effects });
+        if (r.s.setup)
+            r.s.setup.sentTick = r.s.tick;
+    }
+    /** After the initializers: the setup batches, or straight into the game. */
+    function leaveConnecting(r) {
+        const s = r.s;
+        initialize(r);
+        if (!def.setup) {
+            play(r);
+            return;
+        }
+        const effects = [...worldGlobals()];
+        r.batch = effects;
+        try {
+            run(r, "setup", def.setup, ctxOf(r, "setup"));
+        }
+        finally {
+            r.batch = null;
+        }
+        const batches = splitBatches(effects);
+        s.status = "SETUP";
+        // The batch list rides in the state until the last confirmation: every SETUP tick clones it (bounded by the batch limits).
+        s.setup = { batches, confirmed: 0, sentTick: s.tick };
+        sendSetupBatch(r, batches[0], 0);
+    }
+    function play(r) {
+        const s = r.s;
+        s.status = "PLAYING";
+        s.startTick = s.tick;
+        for (const p of Object.values(s.players)) {
+            p.alive = true;
+            p.deaths = 0;
+            p.kills = 0;
+        }
+        const head = def.setup ? worldPlayers(s) : [...worldGlobals(), ...worldPlayers(s)];
+        for (const e of head)
+            r.actions.push({ type: "effect", effect: e });
+        def.every.forEach((_e, i) => {
+            s.every[`every:${i}`] = s.tick;
+        });
+        s.phase = null;
+        run(r, "handler", def.start, ctxOf(r, "full"));
+        resolvePhaseRequest(r);
+        if (r.req.end)
+            return;
+        if (s.phase === null && def.phases.length > 0) {
+            r.req.phase = { target: def.initialPhase ?? def.phases[0] };
+            resolvePhaseRequest(r);
+        }
+    }
+    /** The connect-and-position condition for the current connection of every participant. */
+    const allReady = (s) => {
+        const roster = Object.values(s.players);
+        return roster.length > 0 && roster.every((p) => p.connected && p.sampled && p.pos !== null);
+    };
+    function onTick(r) {
+        const s = r.s;
+        if (s.status === "CONNECTING") {
+            if (!s.initialized && allReady(s))
+                leaveConnecting(r);
+            return;
+        }
+        if (s.status === "SETUP") {
+            if (s.setup && s.tick - s.setup.sentTick > SETUP_BATCH_TIMEOUT_TICKS) {
+                failRun(s, r.actions, "error_setup", "the engine did not confirm a setup batch in 30 s");
+            }
+            return;
+        }
+        if (s.status !== "PLAYING")
+            return;
+        const g = ctxOf(r, "full");
+        const work = [];
+        let order = 0;
+        def.at.forEach((st, i) => {
+            const key = `at:${i}`;
+            const due = s.startTick + (0, time_js_1.toTicks)(st.at);
+            if (s.tick >= due && !s.fired[key])
+                work.push({
+                    due,
+                    order: order++,
+                    scope: "global",
+                    entry: 0,
+                    run: () => {
+                        s.fired[key] = true;
+                        run(r, "handler", st.run, g);
+                    },
+                });
+        });
+        def.every.forEach((st, i) => {
+            const key = `every:${i}`;
+            const due = (s.every[key] ?? s.startTick) + (0, time_js_1.toTicks)(st.interval);
+            if (s.tick >= due)
+                work.push({
+                    due,
+                    order: order++,
+                    scope: "global",
+                    entry: 0,
+                    run: () => {
+                        s.every[key] = s.tick;
+                        run(r, "handler", st.run, g);
+                    },
+                });
+        });
+        const spec = phaseSpec(s);
+        if (spec) {
+            const entry = s.phaseEntries;
+            (spec.at ?? []).forEach((st, i) => {
+                const key = `phase:${entry}:${i}`;
+                let offset;
+                if ("remaining" in st && st.remaining !== undefined) {
+                    if (s.phaseDuration === null)
+                        return;
+                    offset = s.phaseDuration - (0, time_js_1.toTicks)(st.remaining);
+                }
+                else
+                    offset = (0, time_js_1.toTicks)(st.elapsed);
+                const due = s.phaseStartTick + offset;
+                if (s.tick >= due && !s.fired[key])
+                    work.push({
+                        due,
+                        order: order++,
+                        scope: "phase",
+                        entry,
+                        run: () => {
+                            s.fired[key] = true;
+                            run(r, "handler", st.run, g);
+                        },
+                    });
+            });
+            (spec.every ?? []).forEach((st, i) => {
+                const key = `phase:${entry}:every:${i}`;
+                const due = (s.every[key] ?? s.phaseStartTick) + (0, time_js_1.toTicks)(st.interval);
+                if (s.tick >= due)
+                    work.push({
+                        due,
+                        order: order++,
+                        scope: "phase",
+                        entry,
+                        run: () => {
+                            s.every[key] = s.tick;
+                            run(r, "handler", st.run, g);
+                        },
+                    });
+            });
+        }
+        for (const [name, t] of Object.entries(s.timers)) {
+            if (s.tick >= t.due) {
+                const gen = t.gen;
+                work.push({
+                    due: t.due,
+                    order: order++,
+                    scope: "timer",
+                    entry: 0,
+                    run: () => {
+                        // A sibling handler may have cancelled or rescheduled it on this same tick.
+                        if (s.timers[name]?.gen !== gen)
+                            return;
+                        delete s.timers[name];
+                        fire(r, "timer", { name });
+                    },
+                });
+            }
+        }
+        work.sort((a, b) => a.due - b.due || a.order - b.order);
+        for (const w of work) {
+            if (r.req.end)
+                return;
+            if (w.scope === "phase" && w.entry !== s.phaseEntries)
+                continue;
+            w.run();
+            resolvePhaseRequest(r);
+        }
+        if (r.req.end)
+            return;
+        fire(r, "tick", undefined);
+    }
+    /** 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 ?? { ...d.pos };
+            p.pos = { ...d.pos };
+            p.sampled = true;
+            move = { p, from, to: { ...d.pos } };
+        }
+        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 zonesAt(pos) {
+        if (!pos)
+            return [];
+        return declaredZones.filter((zone) => (0, world_js_1.inBox)(pos, def.zones[zone]));
+    }
+    /** The zone edges and the move of every player who moved this event, in roster order. */
+    function fireMoves(r, moves) {
+        const edges = moves
+            .sort((a, b) => a.p.seatNumber - b.p.seatNumber)
+            .map((m) => {
+            const before = m.p.zones;
+            const after = zonesAt(m.p.pos);
+            m.p.zones = after;
+            return { m, before, after };
+        });
+        if (r.s.status !== "PLAYING")
+            return;
+        for (const { m, before, after } of edges) {
+            for (const zone of after)
+                if (!before.includes(zone))
+                    fire(r, "zoneEntered", { player: m.p, zone });
+            for (const zone of before)
+                if (!after.includes(zone))
+                    fire(r, "zoneLeft", { player: m.p, zone });
+            fire(r, "move", { player: m.p, from: m.from, to: { ...m.to } });
+        }
+    }
+    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 applyContainer(r, e) {
+        const s = r.s;
+        const key = posKey(e.at);
+        const prev = s.containers[key];
+        const before = prev ? countsOf(prev.slots) : {};
+        if (e.removed) {
+            delete s.containers[key];
+            if (s.status !== "PLAYING" || !prev)
+                return;
+            const changes = Object.entries(before).map(([item, n]) => ({ item: item, delta: -n }));
+            fire(r, "container", { at: { ...e.at }, block: e.block, items: {}, changes, by: undefined, removed: true });
+            return;
+        }
+        const slots = { ...(prev?.slots ?? {}) };
+        for (const sl of e.slots) {
+            const st = stackOf(sl);
+            if (st)
+                slots[sl.slot] = st;
+            else
+                delete slots[sl.slot];
+        }
+        s.containers[key] = { block: e.block, slots };
+        if (s.status !== "PLAYING" || e.initial)
+            return;
+        const after = countsOf(slots);
+        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;
+        const by = e.by === undefined ? undefined : s.players[e.by];
+        fire(r, "container", { at: { ...e.at }, block: e.block, items: after, changes, by, removed: false });
+    }
+    /** Applies one event and dispatches its handlers. */
+    function step(r, e) {
+        const s = r.s;
+        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] }));
+                e.participants.forEach((p, i) => {
+                    s.players[p.name] = attachDerived({
+                        name: p.name,
+                        role: p.role,
+                        seatNumber: i + 1,
+                        human: p.human === true,
+                        connected: false,
+                        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: [],
+                        state: {},
+                        sampled: false,
+                    });
+                });
+                const unknownRoles = e.participants.filter((p) => !(p.role in config.roles));
+                if (unknownRoles.length > 0) {
+                    failRun(s, r.actions, "error_challenge", `unknown role: ${unknownRoles.map((p) => `${p.role} (${p.name})`).join(", ")}; the roles are ${roleNames.join(", ")}`);
+                    return;
+                }
+                const missing = missingCapabilities(e.capabilities);
+                if (def.setup && !e.capabilities.includes("batch"))
+                    missing.push("batch");
+                if (missing.length > 0) {
+                    failRun(s, r.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;
+                // A new connection needs a new sample before the roster counts as ready.
+                p.sampled = false;
+                if (e.uuid !== undefined)
+                    p.uuid = e.uuid;
+                if (e.gamemode !== undefined)
+                    p.gamemode = e.gamemode;
+                if (playing())
+                    fire(r, "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(r, "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(r, "left", { player: p });
+                break;
+            }
+            case "tick": {
+                r.isTick = true;
+                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);
+                }
+                fireMoves(r, moves);
+                onTick(r);
+                break;
+            }
+            case "effect_result": {
+                if (e.id.startsWith("setup:")) {
+                    // Only the pending batch counts: a duplicate, stale or unknown acknowledgement neither resends nor advances.
+                    if (s.status !== "SETUP" || !s.setup || e.id !== `setup:${s.setup.confirmed}`) {
+                        r.actions.push({ type: "log", message: `ignored effect_result for ${e.id}: not the pending setup batch` });
+                        return;
+                    }
+                    const index = s.setup.confirmed;
+                    if (!e.ok) {
+                        const detail = e.failed?.map((f) => `#${f.index} ${f.detail}`).join("; ") ?? e.detail ?? "unknown";
+                        failRun(s, r.actions, "error_setup", `setup batch ${index} failed: ${detail}`, {
+                            failed: (e.failed ?? []),
+                        });
+                        return;
+                    }
+                    s.setup.confirmed = index + 1;
+                    if (s.setup.confirmed < s.setup.batches.length) {
+                        sendSetupBatch(r, s.setup.batches[s.setup.confirmed], s.setup.confirmed);
+                        return;
+                    }
+                    s.setup = null;
+                    play(r);
+                    return;
+                }
+                const batchName = s.batches[e.id];
+                if (batchName !== undefined) {
+                    delete s.batches[e.id];
+                    if (playing())
+                        fire(r, "batchDone", { name: batchName, ok: e.ok, failed: e.failed ?? [] });
+                    return;
+                }
+                const w = s.walks[e.id];
+                if (w) {
+                    delete s.walks[e.id];
+                    if (!e.ok && w.fallback === "teleport") {
+                        r.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(r, "walkDone", { player: p, ok: e.ok });
+                }
+                break;
+            }
+            case "effect_failed":
+                r.actions.push({ type: "log", message: `effect failed: ${e.kind}: ${e.detail}` });
+                if (playing()) {
+                    fire(r, "effectFailed", {
+                        kind: e.kind,
+                        detail: e.detail,
+                        effect: e.effect,
+                        batch: e.batch && s.batches[e.batch.id] !== undefined
+                            ? { name: s.batches[e.batch.id], index: e.batch.index }
+                            : undefined,
+                    });
+                }
+                break;
+            case "player_moved": {
+                const p = resolve(e.name);
+                if (!p)
+                    return;
+                const move = applySample(p, { pos: e.to });
+                if (move)
+                    fireMoves(r, [move]);
+                if (s.status === "CONNECTING" && !s.initialized && allReady(s))
+                    leaveConnecting(r);
+                break;
+            }
+            case "player_damaged": {
+                const p = resolve(e.name);
+                if (!p || !playing())
+                    return;
+                fire(r, "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 (def.life === "single" && !p.eliminated) {
+                    p.eliminated = true;
+                    r.actions.push({ type: "effect", effect: { kind: "eliminate", player: p.name } });
+                }
+                fire(r, "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(r, "respawned", { player: p });
+                break;
+            }
+            case "item_picked_up": {
+                const p = resolve(e.name);
+                if (!p || !playing())
+                    return;
+                fire(r, "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) {
+                    const st = stackOf(sl);
+                    if (st)
+                        p.slots[sl.slot] = st;
+                    else
+                        delete p.slots[sl.slot];
+                }
+                const before = p.inventory;
+                const after = countsOf(p.slots);
+                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(r, "inventory", { player: p, item: item, count: after[item] ?? 0 });
+                    }
+                }
+                break;
+            }
+            case "container":
+                applyContainer(r, e);
+                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(r, "entitySpawned", { entity: (0, world_js_1.freezeObservation)(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);
+                if (playing())
+                    fire(r, "entityChanged", { entity: (0, world_js_1.freezeObservation)(next), was: (0, world_js_1.freezeObservation)(prev) });
+                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);
+                if (playing())
+                    fire(r, "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);
+                // The containers of the chunk are unknown now.
+                for (const key of Object.keys(s.containers)) {
+                    const [x, , z] = key.split(",").map(Number);
+                    if (x >> 4 === e.x && z >> 4 === e.z)
+                        delete s.containers[key];
+                }
+                break;
+            }
+            case "blocks_changed": {
+                s.world = (0, world_js_1.setBlocks)(s.world, e.changes);
+                if (playing()) {
+                    fire(r, "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);
+                if (playing()) {
+                    fire(r, "blocksChanged", {
+                        changes: [{ box: { from: { ...e.from }, to: { ...e.to } }, block: e.block, cause: "fill" }],
+                    });
+                }
+                break;
+            case "block_broken": {
+                s.world = (0, world_js_1.setBlocks)(s.world, [{ ...e.at, block: e.after ?? world_js_1.AIR }]);
+                const p = resolve(e.name);
+                if (p && playing())
+                    fire(r, "blockBroken", { player: p, at: { ...e.at }, block: parseBlockState(e.block) });
+                break;
+            }
+            case "block_placed": {
+                const changes = [{ ...e.at, block: e.block }, ...(e.others ?? []).map((o) => ({ ...o.at, block: o.block }))];
+                s.world = (0, world_js_1.setBlocks)(s.world, changes);
+                const p = resolve(e.name);
+                if (p && playing())
+                    fire(r, "blockPlaced", { player: p, at: { ...e.at }, block: parseBlockState(e.block) });
+                break;
+            }
+            case "block_used": {
+                const p = resolve(e.name);
+                if (p && playing())
+                    fire(r, "blockUsed", { player: p, at: { ...e.at }, block: parseBlockState(e.block), item: e.item });
+                break;
+            }
+            case "chat": {
+                const p = resolve(e.from);
+                if (p && playing())
+                    fire(r, "chat", { player: p, text: e.text });
+                break;
+            }
+            case "animation": {
+                const p = resolve(e.name);
+                if (p && playing())
+                    fire(r, "animation", { player: p, animation: e.animation });
+                break;
+            }
+            case "vote_attempt":
+                voteAttempt(r, e);
+                break;
+            case "custom": {
+                if (!playing())
+                    return;
+                fire(r, "custom", { name: e.name, player: resolve(e.player), data: e.data });
+                break;
+            }
+        }
+    }
+    function voteAttempt(r, e) {
+        const s = r.s;
+        const p = s.players[e.name];
+        const reject = (feedback) => {
+            r.actions.push(compact({
+                type: "vote_decision",
+                attemptId: e.attemptId,
+                accepted: false,
+                feedback,
+                round: s.votes[e.voteId]?.round,
+            }));
+        };
+        if (!p) {
+            reject("You are not a participant in this run.");
+            return;
+        }
+        if (s.status !== "PLAYING") {
+            reject("The game is not running.");
+            return;
+        }
+        const rule = def.votes[e.voteId];
+        const v = s.votes[e.voteId];
+        if (!rule || !v) {
+            reject(`"${e.voteId}" is not a vote in this challenge.`);
+            return;
+        }
+        if (!v.open) {
+            reject(`The vote "${e.voteId}" is closed.`);
+            return;
+        }
+        if (e.round === undefined) {
+            reject(`Your vote for "${e.voteId}" carries no round; the arena stamps every request with the round it saw.`);
+            return;
+        }
+        if (e.round !== v.round) {
+            reject(`Your vote for "${e.voteId}" was for an earlier round. Vote again.`);
+            return;
+        }
+        if (p.eliminated && !rule.allowEliminated) {
+            reject("You are out of the game; your vote is refused.");
+            return;
+        }
+        const isPlayerVote = e.voteId === types_js_1.PLAYER_VOTE;
+        const options = isPlayerVote
+            ? Object.values(s.players)
+                .filter((o) => (rule.allowSelf ? true : o.name !== p.name) && (rule.allowEliminated || !o.eliminated))
+                .map((o) => o.name)
+            : [...(rule.options ?? [])];
+        if (!options.includes(e.option)) {
+            reject(isPlayerVote
+                ? `"${e.option}" is not a player you can vote for. Players: ${options.join(", ")}.`
+                : `"${e.option}" is not an option for "${e.voteId}". Options: ${options.join(", ")}.`);
+            return;
+        }
+        const prior = v.cast[p.name];
+        if (prior !== undefined && rule.final !== false) {
+            reject(`You already voted "${prior}" for "${e.voteId}". Votes are final.`);
+            return;
+        }
+        if (rule.accept) {
+            const verdict = run(r, "pure", rule.accept, ctxOf(r, "read"), playerView(r, p, false), e.option);
+            if (verdict !== true) {
+                reject(typeof verdict === "string" ? verdict : "Your vote was refused.");
+                return;
+            }
+        }
+        v.cast[p.name] = e.option;
+        r.actions.push({ type: "vote_decision", attemptId: e.attemptId, accepted: true, round: v.round });
+        fire(r, "vote", { player: p, voteId: e.voteId, option: e.option });
+    }
+    // ------------------------------------------------------------ reduce
+    const reduce = (input, event) => {
+        if (input.status === "OVER")
+            return { state: input, actions: [] };
+        let r = {
+            s: clone(input),
+            actions: [],
+            batch: null,
+            previousScores: Object.fromEntries(Object.values(input.players).map((p) => [p.name, p.score])),
+            scoreOverlay: null,
+            candidate: null,
+            views: { read: new WeakMap(), player: new WeakMap() },
+            req: { phase: null, end: null, budget: exports.MAX_TRANSITIONS_PER_EVENT },
+            frame: { kind: "handler" },
+            closed: false,
+            isTick: false,
+        };
+        try {
+            step(r, event);
+            if (r.s.status === "PLAYING" && !r.req.end)
+                checkpoint(r);
+            if (r.req.end)
+                finalize(r);
+            assertJson({ game: r.s.game, players: Object.fromEntries(Object.values(r.s.players).map((p) => [p.name, p.state])) }, "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.
+            r.closed = true;
+            r = { ...r, s: clone(input), actions: [], batch: null, req: { phase: null, end: null, budget: 0 } };
+            if (event.type === "tick")
+                r.s.tick = event.serverTick;
+            const detail = err instanceof errors_js_1.ChallengeError ? err.toJSON() : { message: String(err?.message ?? err) };
+            failRun(r.s, r.actions, "error_challenge", `challenge error on ${event.type}: ${err.message}`, {
+                event: event,
+                error: detail,
+                category: (0, errors_js_1.categoryOf)(err),
+            });
+        }
+        r.closed = true;
+        const s = r.s;
+        // 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 = r.actions.filter((a) => a.type === "game_over");
+        const head = r.actions.filter((a) => a.type !== "game_over");
+        // Publication: nothing an author kept a reference to can change the published state. The mirror is
+        // skipped: no context exposes it (reads return values, observations enter frozen) and it is large.
+        for (const [k, v] of Object.entries(s))
+            if (k !== "world")
+                deepFreeze(v);
+        Object.freeze(s);
+        return { state: s, actions: [...head, ...scores, ...tail] };
+    };
+    return { init, reduce };
+}
+//# sourceMappingURL=reducer.js.map