@kradle/challenges-sdk 0.12.0 → 0.13.1

package/dist/runtime/wire.d.ts

@@ -0,0 +1,858 @@
+import type { ChunkMessage, EntityMove, EquipmentChange } from "./world.js";
+/** A position in the world: block coordinates when integer; a player's position has decimals. */
+export type Vec3 = {
+    /** East. */
+    x: number;
+    /** Up. */
+    y: number;
+    /** South. */
+    z: number;
+};
+/** Block coordinates, both corners inclusive. A player is in a box when the block at their feet is inside. */
+export type Box = {
+    /** One corner. */
+    from: Vec3;
+    /** The opposite corner. Either corner may hold the smaller coordinates. */
+    to: Vec3;
+};
+/** A JSON value: what the state, the log data and the custom events carry. */
+export type Json = null | boolean | number | string | Json[]
+/** An object of JSON values. */
+ | {
+    [key: string]: Json;
+};
+/** A block id (`minecraft:oak_fence`) or a block state string (`minecraft:oak_fence[north=true]`). */
+export type BlockId = `minecraft:${string}`;
+/** An item id: `minecraft:diamond`. */
+export type ItemId = `minecraft:${string}`;
+/** An entity type id: `minecraft:pig`. */
+export type EntityTypeId = `minecraft:${string}`;
+/** A status effect id: `minecraft:speed`. */
+export type EffectId = `minecraft:${string}`;
+/** A game mode, as `/gamemode` names it. */
+export type GameMode = "survival" | "creative" | "adventure" | "spectator";
+/** One entry of the run's roster, as `run_started` lists them. */
+export type Participant = {
+    /** The player's name, unique in the run. */
+    name: string;
+    /** The role id the run assigned. */
+    role: string;
+    /** `true` for a human; absent or `false` for an agent. */
+    human?: boolean;
+};
+/**
+ * A tagged entity the world carries (armor stands, markers): where a challenge finds its spawns and chest spots.
+ * `tags` are the entity's scoreboard tags.
+ */
+export type Marker = {
+    /** The entity type, e.g. `minecraft:armor_stand`. */
+    type: EntityTypeId;
+    /** The entity's position. */
+    at: Vec3;
+    /** The custom name, when one is set. */
+    name?: string | undefined;
+    /** The scoreboard tags. */
+    tags: string[];
+};
+/** The item metadata the engine samples and a request can set. */
+export interface ItemMeta {
+    /** The custom display name, when one is set. */
+    name?: string | undefined;
+    /** The lore lines, when set. */
+    lore?: string[] | undefined;
+    /** Enchantment id to level, e.g. `{ "minecraft:sharpness": 1 }`. */
+    enchantments?: Record<string, number> | undefined;
+    /** Damage taken by a tool or armor piece. */
+    damage?: number | undefined;
+}
+/** An observed stack: what a slot holds. */
+export interface ItemStack extends ItemMeta {
+    /** The item id. */
+    id: ItemId;
+    /** How many, 1 to the stack size. */
+    count: number;
+}
+/** A slot on the wire: no `item` means the slot is empty now. Slots 0-35 main (0-8 hotbar), 36-39 armor, 40 offhand. */
+export type SlotChange = {
+    /** The slot index. */
+    slot: number;
+    /** The item now in the slot; absent when the slot is empty now. */
+    item?: ItemId | undefined;
+    /** How many; absent with `item`. */
+    count?: number | undefined;
+} & ItemMeta;
+/** An item to put in a container slot. `nbt` is the SNBT the SDK built from the request's metadata and raw `snbt`. */
+export type ContainerItem = {
+    /** The slot index; the next free one when absent. */
+    slot?: number | undefined;
+    /** The item id. */
+    item: ItemId;
+    /** How many. */
+    count: number;
+    /** The item data (SNBT), when the request had metadata. */
+    nbt?: string | undefined;
+} & ItemMeta;
+/** Title timing in server ticks, as `/title times`. */
+export type TitleTimes = {
+    /** Fade-in ticks. */
+    fadeIn: number;
+    /** Ticks on the screen. */
+    stay: number;
+    /** Fade-out ticks. */
+    fadeOut: number;
+};
+/** What an engine can supply. The arena reports them in `run_started`; the SDK checks the challenge's needs against them. */
+export type Capability = "move" | "damage" | "death" | "pickup" | "inventory" | "blocks" | "zones" | "entities" | "custom" | "batch" | "query" | "walk" | "mirror" | "chat" | "lifecycle" | "requests" | "containers";
+/** Every capability. The harness reports them all in `run_started`. */
+export declare const ALL_CAPABILITIES: Capability[];
+/** One player's changed fields since the previous tick. One sample per server tick. */
+export type PlayerSample = {
+    /** The player's name. */
+    name: string;
+    /** `true` for a participant of the run; `false` for the watcher, a spectator or a human in the lobby. */
+    participant: boolean;
+    /** The server's entity id and the player's uuid, on the first sample. */
+    id?: number | undefined;
+    /** The player's uuid, on the first sample. */
+    uuid?: string | undefined;
+    /** The position, when it changed. */
+    pos?: Vec3 | undefined;
+    /** Degrees, Minecraft convention; sent with `pos`. */
+    yaw?: number | undefined;
+    /** Degrees; sent with `pos`. */
+    pitch?: number | undefined;
+    /** Degrees; sent with `pos`. */
+    headYaw?: number | undefined;
+    /** Half-hearts, when it changed. */
+    health?: number | undefined;
+    /** The food level, 0..20, when it changed. */
+    food?: number | undefined;
+    /** The game mode, when it changed. */
+    gamemode?: GameMode | undefined;
+    /** The item in the main hand, `null` for an empty hand; when it changed. */
+    held?: ItemId | null | undefined;
+    /** The equipment slots that changed. */
+    equipment?: EquipmentChange[] | undefined;
+    /** Whether the player is invisible, when it changed. */
+    invisible?: boolean | undefined;
+};
+/** An engine fact the arena feeds to `reduce`: the plugin's messages plus the arena's own. */
+export type Event = 
+/** The run starts: the seed, the roster, the resolved params, the engine's capabilities, the declared locations and the markers the engine read. */
+{
+    type: "run_started";
+    /** The run's random seed. */
+    seed: number;
+    /** The roster. */
+    participants: Participant[];
+    /** The resolved per-run parameters: the declaration's defaults under the job's overrides. */
+    params: Record<string, Json>;
+    /** What this engine supplies. */
+    capabilities: Capability[];
+    /** The declared locations' coordinates, by name. */
+    locations?: Record<string, Vec3> | undefined;
+    /** The marker entities the engine read, when the manifest asked for them. */
+    markers?: Marker[] | undefined;
+}
+/** One server tick: the players whose sample changed, the entities that moved, the time when it changed. */
+ | {
+    type: "tick";
+    /** The server's tick counter. */
+    serverTick: number;
+    /** Every online player whose sample changed since the previous tick; the first tick after configure has them all. */
+    players?: PlayerSample[] | undefined;
+    /** Entities that moved since the previous tick. */
+    entities?: EntityMove[] | undefined;
+    /** The world time of day, when it changed. */
+    time?: number | undefined;
+}
+/** A player entered the run's world (the operational roster: participant or not). */
+ | {
+    type: "player_joined";
+    /** The player's name. */
+    name: string;
+    /** `true` for a participant of the run. */
+    participant?: boolean | undefined;
+    /** The player's uuid. */
+    uuid?: string | undefined;
+    /** The server's entity id. */
+    id?: number | undefined;
+    /** The game mode on arrival. */
+    gamemode?: GameMode | undefined;
+}
+/** A player's game mode changed (a human made spectator in the lobby, a reducer effect applied). */
+ | {
+    type: "gamemode";
+    /** The player's name. */
+    name: string;
+    /** The game mode now. */
+    gamemode: GameMode;
+    /** The player's uuid. */
+    uuid?: string | undefined;
+    /** `true` for a participant of the run. */
+    participant?: boolean | undefined;
+}
+/** A player left the run's world. */
+ | {
+    type: "player_left";
+    /** The player's name. */
+    name: string;
+    /** `true` for a participant of the run. */
+    participant?: boolean | undefined;
+    /** The player's uuid. */
+    uuid?: string | undefined;
+    /** The server's entity id. */
+    id?: number | undefined;
+}
+/** One player's sample outside a tick: the harness sends these; the engine folds moves into ticks. */
+ | {
+    type: "player_moved";
+    /** The player's name. */
+    name: string;
+    /** The position now. */
+    to: Vec3;
+}
+/** A participant took damage; `attacker` when another player caused it. */
+ | {
+    type: "player_damaged";
+    /** The participant. */
+    name: string;
+    /** The damage, in half-hearts. */
+    amount: number;
+    /** The damage cause, as the server names it. */
+    cause: string;
+    /** The player who caused it, when one did. */
+    attacker?: string | undefined;
+}
+/** A participant died; `killer` when another player caused it. */
+ | {
+    type: "player_died";
+    /** The participant. */
+    name: string;
+    /** The death cause, as the server names it. */
+    cause: string;
+    /** The player who caused it, when one did. */
+    killer?: string | undefined;
+}
+/** A participant respawned. */
+ | {
+    type: "player_respawned";
+    /** The participant. */
+    name: string;
+}
+/** A participant picked an item up from the ground. */
+ | {
+    type: "item_picked_up";
+    /** The participant. */
+    name: string;
+    /** The item id. */
+    item: ItemId;
+    /** How many. */
+    count: number;
+    /** Where the item was. */
+    at: Vec3;
+}
+/** A participant's changed slots. No item = the slot is empty now. */
+ | {
+    type: "inventory";
+    /** The participant. */
+    name: string;
+    /** The slots that changed. */
+    slots: SlotChange[];
+}
+/** A participant broke a block: `block` is the state that was there, `after` what is there now. */
+ | {
+    type: "block_broken";
+    /** The participant. */
+    name: string;
+    /** The block position. */
+    at: Vec3;
+    /** The block state that was there. */
+    block: BlockId;
+    /** The block state there now, when it is not air. */
+    after?: BlockId | undefined;
+}
+/**
+ * A participant placed a block: `block` is the placed state, `replaced` the one before it.
+ * `others` lists the other blocks of a multi-block placement (a door's upper half, a bed's foot).
+ */
+ | {
+    type: "block_placed";
+    /** The participant. */
+    name: string;
+    /** The block position. */
+    at: Vec3;
+    /** The placed block state. */
+    block: BlockId;
+    /** The block state it replaced, when that was not air. */
+    replaced?: BlockId | undefined;
+    /** The other blocks of a multi-block placement. */
+    others?: Array<{
+        /** The block position. */
+        at: Vec3;
+        /** The placed block state. */
+        block: BlockId;
+        /** The block state it replaced, when that was not air. */
+        replaced?: BlockId | undefined;
+    }> | undefined;
+}
+/** A participant right-clicked a block; `item` is what the hand held. */
+ | {
+    type: "block_used";
+    /** The participant. */
+    name: string;
+    /** The block position. */
+    at: Vec3;
+    /** The block state. */
+    block: BlockId;
+    /** The item in the hand, when one. */
+    item?: ItemId | undefined;
+}
+/**
+ * A container's contents changed, or its first snapshot (`initial`), or the block is gone (`removed`):
+ * the changed slots only, like `inventory`. `by` names the player who moved the items when the engine
+ * knows it for certain, else it is absent.
+ */
+ | {
+    type: "container";
+    /** The container block. */
+    at: Vec3;
+    /** The container's block id. */
+    block: BlockId;
+    /** The slots that changed; every filled slot in the first snapshot. */
+    slots: SlotChange[];
+    /** The player who moved the items, when the engine is certain. */
+    by?: string | undefined;
+    /** `true` for the first snapshot of a container. */
+    initial?: boolean | undefined;
+    /** `true` when the container block is gone; `slots` is empty then. */
+    removed?: boolean | undefined;
+}
+/** A non-player entity appeared, with its first sample. */
+ | {
+    type: "entity_spawned";
+    /** The entity id, unique in the run. */
+    id: string;
+    /** The entity type id. */
+    entity: EntityTypeId;
+    /** The position. */
+    at: Vec3;
+    /** The scoreboard tags. */
+    tags?: string[] | undefined;
+    /** The custom name, when set. */
+    name?: string | undefined;
+    /** Half-hearts, for a living entity. */
+    health?: number | undefined;
+    /** The item id, for an item entity. */
+    item?: ItemId | undefined;
+    /** How many, for an item entity. */
+    count?: number | undefined;
+    /** The entity's uuid. */
+    uuid?: string | undefined;
+    /** Degrees, Minecraft convention. */
+    yaw?: number | undefined;
+    /** Degrees. */
+    pitch?: number | undefined;
+    /** Degrees. */
+    headYaw?: number | undefined;
+    /** The equipped items, by slot. */
+    equipment?: EquipmentChange[] | undefined;
+    /** Whether the entity is invisible. */
+    invisible?: boolean | undefined;
+    /** A villager's type, profession and level. */
+    villager?: {
+        /** The villager type (the biome variant). */
+        type: string;
+        /** The profession id. */
+        profession: string;
+        /** The trade level, 1 to 5. */
+        level: number;
+    } | undefined;
+}
+/** An entity's reported fields changed; a move rides the tick instead. */
+ | {
+    type: "entity_changed";
+    /** The entity id. */
+    id: string;
+    /** The scoreboard tags now. */
+    tags?: string[] | undefined;
+    /** The custom name now. */
+    name?: string | undefined;
+    /** Half-hearts now. */
+    health?: number | undefined;
+    /** The item id now, for an item entity. */
+    item?: ItemId | undefined;
+    /** How many now, for an item entity. */
+    count?: number | undefined;
+    /** The equipment slots that changed. */
+    equipment?: EquipmentChange[] | undefined;
+    /** Whether the entity is invisible now. */
+    invisible?: boolean | undefined;
+    /** A villager's type, profession and level now. */
+    villager?: {
+        /** The villager type (the biome variant). */
+        type: string;
+        /** The profession id. */
+        profession: string;
+        /** The trade level, 1 to 5. */
+        level: number;
+    } | undefined;
+}
+/** A player swung an arm. */
+ | {
+    type: "animation";
+    /** The player's name. */
+    name: string;
+    /** The arm: the main hand, or the off hand. */
+    animation: "swing" | "swing_off";
+}
+/** An entity left the world: it died (`killer` when a player did it) or the server removed it. */
+ | {
+    type: "entity_removed";
+    /** The entity id. */
+    id: string;
+    /** Why: it died, or the server removed it. */
+    cause: "died" | "removed";
+    /** The player who killed it, when one did. */
+    killer?: string | undefined;
+}
+/** A loaded chunk, whole. The engine sends every loaded chunk after configure and each chunk that loads later. */
+ | ({
+    /** The message type. */
+    type: "chunk";
+} & ChunkMessage)
+/** A chunk left the server: its blocks and containers are unknown until it loads again. */
+ | {
+    type: "chunk_unloaded";
+    /** The chunk x (block x >> 4). */
+    x: number;
+    /** The chunk z (block z >> 4). */
+    z: number;
+}
+/** Every block that changed this tick. `cause`: break, place, burn, fade, form, spread, grow, decay, ignite, entity, bucket, flow, piston, explode, effect. `by` when a player did it. */
+ | {
+    type: "blocks_changed";
+    /** The changed blocks, with their positions. */
+    changes: Array<Vec3 & {
+        /** The block state now. */
+        block: BlockId;
+        /** The block state before, when known. */
+        was?: BlockId | undefined;
+        /** What changed it. */
+        cause?: string | undefined;
+        /** The player who did it, when one did. */
+        by?: string | undefined;
+    }>;
+}
+/** The engine filled a box (a `fill` effect): one entry instead of one per block. */
+ | {
+    type: "blocks_filled";
+    /** One corner of the box. */
+    from: Vec3;
+    /** The opposite corner. */
+    to: Vec3;
+    /** The block state the box holds now. */
+    block: BlockId;
+}
+/** A public chat line. */
+ | {
+    type: "chat";
+    /** The player's name. */
+    from: string;
+    /** The line. */
+    text: string;
+    /** The player's uuid. */
+    uuid?: string | undefined;
+}
+/**
+ * The arena forwards every vote. The challenge decides; the arena stores accepted votes only.
+ * `round` is the round the arena saw in the last `vote_round` action when it accepted the request;
+ * a request without a round, or from an earlier round, is refused.
+ */
+ | {
+    type: "vote_attempt";
+    /** The request id; `vote_decision` echoes it. */
+    attemptId: string;
+    /** The voter. */
+    name: string;
+    /** The vote. */
+    voteId: string;
+    /** The chosen option, or the chosen player's name for the `player` vote. */
+    option: string;
+    /** The round the arena saw when it accepted the request. */
+    round?: number | undefined;
+}
+/** The engine ran a batch: `ok` when every effect applied; `failed` lists the ones that did not. */
+ | {
+    type: "effect_result";
+    /** The batch or walk id. */
+    id: string;
+    /** Whether every effect applied, or the walk arrived. */
+    ok: boolean;
+    /** The first failure's detail, when not ok. */
+    detail?: string | undefined;
+    /** The effects that did not apply. */
+    failed?: Array<{
+        /** The effect's index in the batch. */
+        index: number;
+        /** Why it failed. */
+        detail: string;
+    }> | undefined;
+}
+/** One effect the engine refused; `effect` echoes it, `batch` names the batch and the index when it was in one. */
+ | {
+    type: "effect_failed";
+    /** The effect kind. */
+    kind: string;
+    /** Why. */
+    detail: string;
+    /** The refused effect. */
+    effect?: Effect | undefined;
+    /** The batch it was in, when it was in one. */
+    batch?: {
+        /** The batch's transport id. */
+        id: string;
+        /** The effect's index in the batch. */
+        index: number;
+    } | undefined;
+}
+/** A server event the engine forwards by name. */
+ | {
+    type: "custom";
+    /** The event name. */
+    name: string;
+    /** The participant it is about, when one. */
+    player?: string | undefined;
+    /** The event's JSON data. */
+    data: Json;
+};
+/** A world change the challenge asks for. The arena runs it on the server through the plugin. */
+export type Effect = 
+/** Fills a box with one block state. */
+{
+    kind: "fill";
+    /** One corner of the box. */
+    from: Vec3;
+    /** The opposite corner. */
+    to: Vec3;
+    /** The block state to fill with. */
+    block: BlockId;
+}
+/** Sets one block; `nbt` is the block entity data (SNBT). */
+ | {
+    kind: "setblock";
+    /** The block position. */
+    at: Vec3;
+    /** The block state. */
+    block: BlockId;
+    /** The block entity data (SNBT), when set. */
+    nbt?: string | undefined;
+}
+/** Gives items to a player; `nbt` is the item data (SNBT). */
+ | {
+    kind: "give";
+    /** The participant. */
+    player: string;
+    /** The item id. */
+    item: ItemId;
+    /** How many. */
+    count: number;
+    /** The item data (SNBT), when set. */
+    nbt?: string | undefined;
+}
+/** Removes items from a player: one item up to `count`, or everything. */
+ | {
+    kind: "clear";
+    /** The participant. */
+    player: string;
+    /** The item to remove; absent removes everything. */
+    item?: ItemId | undefined;
+    /** At most this many; absent removes all of the item. */
+    count?: number | undefined;
+}
+/** Moves a player. */
+ | {
+    kind: "teleport";
+    /** The participant. */
+    player: string;
+    /** The destination. */
+    to: Vec3;
+}
+/** Applies a status effect for `seconds`. */
+ | {
+    kind: "effect";
+    /** The participant. */
+    player: string;
+    /** The status effect id. */
+    effect: EffectId;
+    /** How long, in seconds. */
+    seconds: number;
+    /** The level minus one: 0 is level I. */
+    amplifier: number;
+}
+/** Summons an entity; `nbt` is its data (SNBT). */
+ | {
+    kind: "summon";
+    /** The entity type id. */
+    entity: EntityTypeId;
+    /** Where. */
+    at: Vec3;
+    /** The entity data (SNBT), when set. */
+    nbt?: string | undefined;
+}
+/** Removes the non-player entities: of the listed types, or all. */
+ | {
+    kind: "kill_entities";
+    /** The entity types to remove; absent removes every non-player entity. */
+    entities?: EntityTypeId[] | undefined;
+}
+/** Kills a player. */
+ | {
+    kind: "kill";
+    /** The participant. */
+    player: string;
+}
+/** Sets a player's game mode. */
+ | {
+    kind: "gamemode";
+    /** The participant. */
+    player: string;
+    /** The game mode. */
+    mode: GameMode;
+}
+/** Sets a player attribute. */
+ | {
+    kind: "attribute";
+    /** The participant. */
+    player: string;
+    /** The attribute id, e.g. `minecraft:generic.movement_speed`. */
+    attribute: string;
+    /** The base value. */
+    value: number;
+}
+/** Sets the time of day. */
+ | {
+    kind: "time";
+    /** The time of day, by name. */
+    value: "day" | "noon" | "night" | "midnight";
+}
+/** Sets a game rule. */
+ | {
+    kind: "gamerule";
+    /** The game rule name. */
+    rule: string;
+    /** The value. */
+    value: boolean | number;
+}
+/** Shows a title, to one player or to all. */
+ | {
+    kind: "title";
+    /** The participant; absent shows it to all. */
+    player?: string | undefined;
+    /** The title line. */
+    title: string;
+    /** The subtitle line, when set. */
+    subtitle?: string | undefined;
+    /** The fade and stay times, in ticks; the server's defaults when absent. */
+    times?: TitleTimes | undefined;
+}
+/** Moves and resizes the world border over `seconds`. */
+ | {
+    kind: "worldborder";
+    /** The new center, when it moves. */
+    center?: {
+        /** East. */
+        x: number;
+        /** South. */
+        z: number;
+    } | undefined;
+    /** The new diameter, in blocks, when it changes. */
+    size?: number | undefined;
+    /** Over how many seconds the size changes; 0 or absent is at once. */
+    seconds?: number | undefined;
+}
+/** Replaces the contents of a container block. */
+ | {
+    kind: "container";
+    /** The container block. */
+    at: Vec3;
+    /** The new contents; every slot not listed is empty. */
+    items: ContainerItem[];
+}
+/** Sets the world spawn. */
+ | {
+    kind: "spawn";
+    /** The world spawn. */
+    at: Vec3;
+}
+/** Makes a player a spectator. */
+ | {
+    kind: "eliminate";
+    /** The participant. */
+    player: string;
+}
+/** A chat line, to one player (`to`) or to all. */
+ | {
+    kind: "announce";
+    /** The text. */
+    message: string;
+    /** The participant; absent sends it to all. */
+    to?: string | undefined;
+}
+/** A raw server command; the arena checks it against its gameplay allowlist. */
+ | {
+    kind: "command";
+    /** The command, without the leading slash. */
+    cmd: string;
+};
+/** Why a game ended, as `game_over` reports it. */
+export type EndReason = "rule" | "time" | "phase" | "call" | "error";
+/** What `reduce` returns for the arena: effects, batches, walks, vote answers, log lines, scores, metrics, the game end. */
+export type Action = 
+/** One effect, applied on the next tick. */
+{
+    type: "effect";
+    /** The effect. */
+    effect: Effect;
+}
+/** Applied in one server tick. The engine answers with `effect_result {id}`. The setup batches are `setup:<n>`. */
+ | {
+    type: "batch";
+    /** The transport id; `effect_result` echoes it. */
+    id: string;
+    /** The effects, applied in order in one server tick. */
+    effects: Effect[];
+}
+/** The arena walks the bot to `to`; `effect_result {id}` reports; a failed walk teleports unless `fallback` is `none`. */
+ | {
+    type: "walk";
+    /** The request id; `effect_result` echoes it when the walk ends. */
+    id: string;
+    /** The participant who walks. */
+    player: string;
+    /** The destination. */
+    to: Vec3;
+    /** What a failed walk does: a teleport to `to`, or nothing. */
+    fallback: "teleport" | "none";
+}
+/** The reducer's answer to a `vote_attempt`; `round` echoes the vote's current round, when the vote exists. */
+ | {
+    type: "vote_decision";
+    /** The `vote_attempt` this answers. */
+    attemptId: string;
+    /** Whether the vote counts. */
+    accepted: boolean;
+    /** The reason shown to the voter, when refused. */
+    feedback?: string | undefined;
+    /** The vote's current round, when the vote exists. */
+    round?: number | undefined;
+}
+/** A line in the run log, with JSON data. */
+ | {
+    type: "log";
+    /** The participant the line is about, when one. */
+    player?: string | undefined;
+    /** The text. */
+    message: string;
+    /** Structured data for the line. */
+    data?: Json | undefined;
+}
+/** A participant's score changed. The arena reports it to the run; the server never sees it. */
+ | {
+    type: "score";
+    /** The participant. */
+    player: string;
+    /** The new score. */
+    score: number;
+}
+/** A metric: the arena keeps the last value per name (global, or per player) and sends them with the run's end. */
+ | {
+    type: "metric";
+    /** The metric name. */
+    name: string;
+    /** The value; the last one per name is kept. */
+    value: number;
+    /** The participant the value is for; absent for a global metric. */
+    player?: string | undefined;
+}
+/** The state of a vote changed: the arena stamps later requests with `round` while `open`. */
+ | {
+    type: "vote_round";
+    /** The vote. */
+    voteId: string;
+    /** Whether casts are accepted now. */
+    open: boolean;
+    /** The round number, from 1; a reset starts a new one. */
+    round: number;
+}
+/** The game ended: the winners, the end state, why, and the judge data. */
+ | {
+    type: "game_over";
+    /** The winners' names; empty for no winner. */
+    winners: string[];
+    /** The end state the challenge declared; empty for none. */
+    endState: string;
+    /** Why the game ended. */
+    reason: EndReason;
+    /** The data `judgeContext` returned for the judge, when the challenge has one. */
+    judgeContext?: Record<string, Json> | undefined;
+};
+/** A vote as the manifest declares it: the bots pre-validate against `options`; the reducer decides. */
+export interface ManifestVote {
+    /** The options of a static vote; absent for the `player` vote (its options are the other participants). */
+    options?: string[] | undefined;
+    /** `true` (the default): one vote per round. */
+    final?: boolean | undefined;
+    /** Whether an eliminated player may vote. Default `false`. */
+    allowEliminated?: boolean | undefined;
+    /** The `player` vote: whether a player may vote for themself. Default `false`. */
+    allowSelf?: boolean | undefined;
+}
+/** What the arena and the backend read before the run. Generated from the locked definition. */
+export interface RuntimeManifest {
+    /** The protocol version. The arena and the backend refuse another value. */
+    runtime: 2;
+    /** The challenge's display name, from the configuration. */
+    name: string;
+    /** The death rule: `single` eliminates on the first death, `respawn` counts deaths. */
+    life: "single" | "respawn";
+    /** The role ids the rules know: the backend checks them against the challenge's configuration at activation. */
+    roles: string[];
+    /** The location names the configuration declares, when it declares any. */
+    locations?: string[] | undefined;
+    /** Tagged entities to read before the game; the engine preloads the chunks of `within`. */
+    markers?: {
+        /** The scoreboard tags that mark an entity. */
+        tags: string[];
+        /** The box the engine loads first, so far markers are found too. */
+        within?: Box | undefined;
+    } | undefined;
+    /** The votes, by id. The backend stores them with the artifact; the arena hands them to the bots. */
+    votes: Record<string, ManifestVote>;
+    /** The per-run parameters the configuration declares, with their defaults. A job may override a value. */
+    params: Record<string, {
+        /** The value type. */
+        type: "number" | "string" | "boolean";
+        /** The value when the job sets none. */
+        default: number | string | boolean;
+    }>;
+}
+/** The run's stage, as the reducer state records it. */
+export type Status = "CONNECTING" | "SETUP" | "PLAYING" | "OVER";
+/** The end states the SDK reports on its own: a failed setup, a thrown rule, facts the engine lacks. */
+export type SdkEndState = "error_setup" | "error_challenge" | "error_unsupported_facts";
+/** The shape every built challenge bundle exports as `default`: what the arena's worker calls. */
+export interface EngineChallenge {
+    /** The manifest; read before `init()`. */
+    readonly manifest: RuntimeManifest;
+    /** A fresh run state. */
+    init(): unknown;
+    /** One reduction: the next state and the actions for the engine. */
+    reduce(state: unknown, event: Event): {
+        /** The next state; the input is never changed. */
+        state: unknown;
+        /** What the engine and the arena apply, in order. */
+        actions: Action[];
+    };
+}
+//# sourceMappingURL=wire.d.ts.map