@kradle/challenges-sdk 0.11.0 → 0.13.0

package/MIGRATION-0.13.md

@@ -0,0 +1,109 @@
+# Migration to 0.13: from the object spec to the builder
+
+0.13 replaces `defineChallenge(config, spec)` with one object of handlers by a root declaration and steps. This guide maps the old API to the new one. The rules of a challenge do not change; where they run does.
+
+## The shape
+
+```ts
+// no-compile
+// 0.12
+export default defineChallenge(config, {
+	life: "respawn",
+	duration: minutes(2),
+	player: () => ({ pigs: 0 }),
+	start(g) { ... },
+	on: { entityRemoved(g, e) { ... } },
+	end: (g) => ...,
+	winners: Win.scoreAtLeast(2),
+	onOver(g, { winners }) { ... },
+});
+
+// 0.13
+const challenge = defineChallenge(config, {
+	state: { player: () => ({ pigs: 0 }) },
+	life: "respawn",
+	duration: "2m",
+});
+export default challenge
+	.start((g) => { ... })
+	.on({ entityRemoved(g, e) { ... } })
+	.outcome({ scores: (_g, p) => p.state.pigs, endWhen: (g) => ..., winners: winBy.scoreAtLeast(2) })
+	.onOver((g, result) => { ... });
+```
+
+The root declaration holds data and the state initializers: `state`, `life`, `duration`, `world`, `zones`, `timers`, `votes` (with their options), `phases` (the names), `initialPhase`, `markers`. Every handler is a step.
+
+## The table
+
+| 0.12 | 0.13 |
+|---|---|
+| `game: () => ({...})`, `player: () => ({...})`, `players: {...}` at the top level | `state: { game, player, players }`; the initializers receive `(init)` / `(p, init)` with `init = { params, random, players, locations }` and the observed player (`p.pos` is set) |
+| `g.game.x`, `p.x` (custom fields on the player) | `g.state.x`, `p.state.x` |
+| `p.score = n` | `g.setScore(p, n)` / `g.addScore(p, d)`, or `outcome.scores: (g, p) => ...` (derived after every event; then the writes are refused) |
+| `end: (g) => bool` | `outcome.endWhen` |
+| `winners`, `endState` | `outcome.winners`, `outcome.endState` |
+| `Win.topScore()` | `winBy.highestScore()`. One default changed: every eligible player at score 0 wins (0.12 gave no winner below `min: 1`). The eligible set is the active players in both versions. `winBy.highestScore({ min: 1 })` keeps the old rule. `{ among: (g) => g.players }` is the form of an old custom `eligible: () => true`; it is not the old default. |
+| `Win.scoreAtLeast(n)` | `winBy.scoreAtLeast(n)`. The eligible set is the active players now; `winBy.scoreAtLeast(n, { among: (g) => g.players })` keeps an eliminated player who reached `n`. |
+| `Win.*({ eligible: (p) => ... })` | `{ among: (g) => g.players.filter((p) => ...) }` |
+| `End.allEliminated` | `(g) => g.activePlayers.length === 0` |
+| `onOver(g, { winners })` | `.onOver((g, result) => ...)`: a notification context (messages, metrics), `result.winners`, `result.endState`, `result.reason`, `result.isWinner(p)` |
+| `judgeContext: (g) => ...` | `.judgeContext((g, result) => ...)` |
+| `setup(g) {...}`, `start(g) {...}`, `at: [...]`, `every: [...]`, `on: {...}` | `.setup(fn)`, `.start(fn)`, `.at([...])`, `.every([...])`, `.on({...})` (several `.on()` calls add up) |
+| `phases: { A: { duration, next, enter, exit, at, every, on } }` | `phases: ["A", "B"]` + `initialPhase` in the root; `.phase("A", { duration?, next, until?, enter?, exit?, at?, every?, on? })` per phase; `next` is required |
+| `g.goTo("B")` | `g.startPhase("B")`; applied after the event's handlers returned |
+| `g.goTo("END")`, `g.end(endState?)` | `g.endGame(endState?)`: an unconditional end. `g.endPhase()` is new: it follows the phase's `next`, which may be another phase |
+| a phase without `duration` = unbounded | a phase without `duration` and `until` lasts one tick; use `until` or leave it manual (no `.phase()` step) |
+| `g.active` | `g.activePlayers`; `p.isActive` |
+| `g.role(r)`, `g.one(r)` | `g.playersWithRole(r)`, `g.playerWithRole(r)` (throws unless exactly one) |
+| `p.number` | `p.seatNumber` |
+| `g.others` | removed |
+| `g.count(p, item)` | `g.countItems(p, item)` |
+| `g.contents(name \| at)`, `containers: {...}` in the spec | `g.containerContents(at)` for any container; no declaration |
+| `g.rand(lo, hi)`, `g.pick`, `g.shuffle` | `g.random.int(lo, hi)`, `g.random.pick`, `g.random.shuffle`, `g.random.weighted`; `init.random` in the initializers |
+| `g.setblock(at, block, nbt?)` | `g.setBlock(at, block)` with `block` an id or `{ id, props?, blockEntity? }` |
+| `g.give(p, item, count, nbt)` | `g.give(p, item, count?)` with `item` an id or `{ id, count?, name?, lore?, enchantments?, damage?, snbt? }` |
+| `g.effect(p, id, seconds, amplifier)` | `g.effect(p, { id, duration, amplifier? })` |
+| `g.title(to, title, subtitle, times)` | `g.title(to, { title, subtitle?, fadeIn?, stay?, fadeOut? })` |
+| `g.log(player \| null, message, data)` | `g.log(message, { player?, data? })` |
+| `g.store(name, value, player?)` | `g.setMetric(name, value, { player? })` (the wire action is `metric`) |
+| `g.blockStateAt(at)` (a string) | `g.blockStateAt(at)` (`{ id, props }`); `g.blockMatches(at, match)`. The block events carry `{ id, props }` too, and a function `BlockMatch` receives it, not a string |
+| `g.findBlocks(box, match, limit)` | `g.findBlocks(box, match, { limit })` |
+| `g.summon(type, at, nbt)` | `g.summon(type, at, { nbt })` (a string third argument is ignored) |
+| `g.worldBorder({ seconds: n })` | `g.worldBorder({ over: seconds(n) })` or `{ over: "10s" }` (`seconds` is ignored) |
+| `g.container(at, [{ item, count, nbt, slot? }])` | `g.container(at, [{ id, count, snbt }])`: the items fill the slots in order; there is no slot selection |
+| `p.slots[i].item` | `p.slots[i].id` |
+| `onOver(g, { winnerPlayers })` | `result.isWinner(p)` over `g.players` |
+| `g.dt` | removed: keep the last tick in the state and use `g.tick` differences |
+| `g.phase === "END"` after the end | the last phase stays in `g.phase`; the end is `g.status === "OVER"` (`result.phase` names it) |
+| `g.phaseRemaining` without a duration (`Number.MAX_SAFE_INTEGER`) | `null` |
+| `g.blockCount`, `g.findBlocks` on an unloaded chunk (zero, empty) | they throw `block_unknown`; pass `{ partial: true }` for the old behavior; `g.regionLoaded(box)` |
+| `votes: { room: { final, phases: [...], open } }` + `votingOptions` in `config.ts` | `votes: { room: { options: [...], final?, allowEliminated?, accept? } }` in the root; `g.openVote` / `g.closeVote` / `g.resetVote` in the phase; `votingOptions` leaves `config.ts` |
+| `g.openVote(id)` (a reset) | `g.resetVote(id)`; `g.openVote(id)` opens a round (throws on an open one) |
+| `on.move` with `maxY`, `minY` | `on.move` with `from`, `to` (one sample per tick) |
+| `announce: { deaths, gameOver }`; the SDK's "=== GAME OVER ===" lines | removed: the SDK prints nothing; say it in `onOver` |
+| `mirror: {...}` | removed: the mirror holds every loaded chunk |
+| `effectFailed { kind, detail }` | `{ kind, detail, effect?, batch? }`; `g.batch(name, fn)` + `on.batchDone` |
+| `ContextOf<typeof config, typeof state>`, `typeof challenge.ctx` | `CtxOf<typeof challenge>`, `ReadCtxOf`, `SetupCtxOf`, `PlayerIn<G>`, from the root const |
+| `game.state.status === "LOBBY"` (in a test) | `game.status === "CONNECTING"` (the author context has no `status` field in 0.12; a rule reads `g.status` now) |
+| `Game.begin(seed, roster)` without positions | `begin` supplies a position per participant (`at` to choose); `g.state` is the shared data, `g.reducerState` the whole state; `Fake.has` is `setInventory`; `g.all("store")` is `g.all("metric")` |
+
+## Helpers
+
+Name the root call in a const and type the helpers from it. A helper typed from a whole chain expression and used inside that chain is circular.
+
+```ts
+// no-compile
+const challenge = defineChallenge(config, decl);
+type G = CtxOf<typeof challenge>;
+type R = ReadCtxOf<typeof challenge>;
+const classify = (g: R) => (g.state.done ? "done" : "timeout");
+export default challenge.start(begin).outcome({ endState: classify });
+```
+
+A root predicate (`votes.room.accept`) cannot call a helper typed from the challenge: type it independently.
+
+## Checks the compiler now does
+
+- A phase name, a zone, a timer, a vote id, an option or an end state that is not declared does not compile.
+- A pure callback (`outcome.*`, `judgeContext`, `until`, a functional `duration` or `next`, `accept`) cannot write state or queue an effect.
+- `p.score` is read-only; observations are read-only.

package/README.md

@@ -14,14 +14,14 @@ the CLI's README first.
 
 ```bash
 kradle init
-kradle challenge create my-challenge     # challenges/my-challenge/{challenge.ts,config.ts} + tests/my-challenge.test.ts
+kradle challenge create my-challenge     # challenges/my-challenge/{challenge.ts,config.ts,challenge.test.ts}
 kradle challenge test my-challenge       # the tests, inside the arena's sandbox
 kradle challenge build my-challenge      # the bundle, uploaded and activated
 kradle challenge run my-challenge        # a run in the cloud
 ```
 
 A manual installation is one dependency: `npm install @kradle/challenges-sdk@next`
-(0.11 stays under the npm tag `next` until the CLI release installs it).
+(the reducer SDK stays under the npm tag `next` until the CLI release installs it).
 Add `"type": "module"` to the project's `package.json`.
 
 ## Local development
@@ -42,121 +42,129 @@ Then run `kradle challenge test <slug>` in the consumer project.
 
 ## Writing a challenge
 
-One call. Every type is inferred from the initializers. Helper functions get
-their context type from the state object with `ContextOf`, before the
-challenge exists.
+One root call with the data and the state initializers, then steps for the
+behavior. Every type is inferred from the root: the phase names, the zones,
+the timers, the vote options, the roles and the end states of the config.
+Helpers take their context type from the root const with `CtxOf`.
 
 ```ts
-import { type ChallengeConfig, type ContextOf, defineChallenge, minutes, type PlayerIn, Win } from "@kradle/challenges-sdk";
+import { type ChallengeConfig, type CtxOf, defineChallenge, type PlayerIn, winBy } from "@kradle/challenges-sdk";
 
 export const config = {
 	name: "Hide and Seek",
 	challengeConfig: {},
 	roles: { hider: { description: "hides" }, seeker: { description: "seeks" } },
+	endStates: { all_found: "Every hider was found", time_up: "Time ran out" },
 } as const satisfies ChallengeConfig;
 
-const state = {
-	game: () => ({ found: [] as string[] }),
-	// State per role; `player` instead of `players` gives every role the same fields.
-	players: { hider: () => ({ hiddenAt: null as number | null }), seeker: () => ({ finds: 0 }) },
-	zones: { base: { from: { x: -5, y: 60, z: -5 }, to: { x: 5, y: 70, z: 5 } } },
-};
-type G = ContextOf<typeof config, typeof state>;
+const challenge = defineChallenge(config, {
+	state: {
+		game: () => ({ found: [] as string[] }),
+		// State per role; `player` instead of `players` gives every role the same fields.
+		players: { hider: () => ({ hidden: false }), seeker: () => ({ tags: 0 }) },
+	},
+	duration: "5m",
+	life: "respawn",
+	world: { time: "day" },
+	zones: { base: { from: { x: -5, y: -60, z: -5 }, to: { x: 5, y: -55, z: 5 } } },
+});
+type G = CtxOf<typeof challenge>;
 
+/** A helper: the seeker tags a hider. */
 function tag(g: G, seeker: PlayerIn<G>, hider: PlayerIn<G>): void {
-	if (seeker.role !== "seeker" || hider.role !== "hider") return; // the role narrows the fields
-	seeker.finds += 1;
-	seeker.score = seeker.finds;
-	g.game.found.push(hider.name);
-	g.eliminate(hider);
+	if (seeker.role !== "seeker" || hider.role !== "hider") return;
+	seeker.state.tags += 1;
+	g.state.found.push(hider.name);
+	g.say(`${seeker.name} found ${hider.name}!`);
 }
 
-export default defineChallenge(config, {
-	...state,
-	duration: minutes(3),
-	life: "respawn",
-	start(g) {
-		for (const h of g.role("hider")) g.tell(h, "Hide! The seekers are released in 30 seconds.");
-	},
-	on: {
-		zoneLeft(g, { player, zone }) {
-			if (zone === "base" && player.role === "hider") player.hiddenAt = g.elapsed;
-		},
-		damaged(g, { player, attacker }) {
-			if (attacker) tag(g, attacker, player);
-		},
-	},
-	end: (g) => g.role("hider").every((h) => h.eliminated),
-	winners: Win.topScore({ min: 1 }),
-});
+export default challenge
+	.start((g) => {
+		for (const p of g.playersWithRole("hider")) g.give(p, "minecraft:ender_pearl", 2);
+		g.say("Hiders, run! Seekers start in 30 seconds.");
+	})
+	.at([{ at: "30s", run: (g) => g.say("Seekers, go!") }])
+	.on({
+		damaged: (g, { player, attacker }) => attacker && tag(g, attacker, player),
+		zoneEntered: (g, { player, zone }) => zone === "base" && g.tell(player, "You are safe here."),
+	})
+	.outcome({
+		scores: (_g, p) => (p.role === "seeker" ? p.state.tags : 0),
+		endWhen: (g) => g.state.found.length === g.playersWithRole("hider").length,
+		winners: winBy.highestScore({ among: (g) => g.playersWithRole("seeker") }),
+		endState: (g) => (g.state.found.length === g.playersWithRole("hider").length ? "all_found" : "time_up"),
+	});
 ```
 
-`@kradle/challenges-sdk` and `@kradle/challenges-sdk/runtime` are the same
-API. The concepts: roles, phases, timers, votes, end states, a judge. The state
-is plain JSON, and a run replays from its event log.
+`p.state` is the challenge's; every other field of a player (`pos`, `health`,
+`inventory`, `score`, ...) is an observation the SDK writes. The score changes
+through `outcome.scores` (derived after every event) or `g.setScore` /
+`g.addScore`, not both. Phases are declared by name in the root
+(`phases: ["BUILD", "FIGHT"]`) and get their behavior in `.phase(name, {...})`
+steps: a `duration`, a `next`, an `until` predicate, `enter`, `exit`, timed
+steps and handlers. `g.startPhase`, `g.endPhase` and `g.endGame` apply after
+the callback returns.
 
 ## Reading the world
 
-The rules read the world through a mirror the engine keeps up to date: every
-player (`g.players`, `g.others`, with `pos`, `yaw`, `pitch`, `headYaw`,
-`entityId`, `uuid`, `equipment`, `invisible`), every entity
-(`g.entities({ box, type, tag })`), every loaded chunk (`g.blockAt` for the id,
-`g.blockStateAt` for the full state, `g.blockCount`, `g.findBlocks`), the
-world time (`g.worldTime`), and each participant's inventory (`p.inventory`,
-`p.slots`, `g.count(p, item)`). Nothing is declared to the engine for that,
-except the chests a challenge reads: `containers: { delivery: { x, y, z } }` in
-the spec makes the engine report their contents; `g.contents("delivery")` gives
-the item counts and `on.container(g, { at, block, items, changes, by })` fires
-on every change. A report for an undeclared position is ignored.
-Zones are named boxes the SDK evaluates from the positions every tick;
-`g.inZone(p, box)` takes any box too. The `mirror` option narrows what the
-engine streams when a world is large. `src/runtime/examples/herding.ts` scores
-sheep inside a pen from the entity mirror and watches a fence gap through the
-block mirror.
-
-`typeof x.ctx` on a challenge is the same type; use it in tests. In the file that
-defines the challenge it works only for helpers called from inside a rule
-(`endState: (g) => classify(g)`): a helper passed as the property value
-(`endState: classify`) would make the challenge's type circular.
-`onOver(g, result)` runs once the result is final: `result.winners` (names), `result.winnerPlayers`, `result.isWinner(player)` and `result.endState`.
+The engine mirrors every loaded chunk, every entity and every container into
+the state; the SDK answers from that mirror:
 
-## Testing
+- `g.blockAt(at)` (the id), `g.blockStateAt(at)` (`{ id, props }`), `g.blockMatches(at, match)`
+- `g.blockCount(box, match)`, `g.findBlocks(box, match)`: they throw when a chunk of the box is not loaded, unless `{ partial: true }`
+- `g.entities({ box?, type?, tag? })`, `g.entity(id)`
+- `g.containerContents(at)`: any chest or other container the mirror holds
+- `p.pos`, `p.inventory`, `p.zones`; `g.inZone(p, zone)`, `g.countItems(p, item)`
 
-Test without Minecraft with `@kradle/challenges-sdk/runtime/harness`:
+The handlers report the changes: `blockPlaced`, `blockBroken`, `blocksChanged`
+(every cause, a fill as one entry), `container`, `inventory`, `move`,
+`zoneEntered`, `zoneLeft`, `entitySpawned`, `entityChanged`, `entityRemoved`.
 
-```js
-const game = new Game(climb).begin(1, { alice: "climber", bob: "climber" });
-game.player("alice").moveTo({ y: -40 });
-game.at("2m");
-assert.deepEqual(game.state.winners, ["alice"]);
-game.replay();
+### Structures
+
+`@kradle/challenges-sdk/structures` turns text layers and a palette into a
+template. `placeStructure` builds it in the world; `compareStructure` reads
+the mirror and reports the cells that match, mismatch or sit in an unloaded
+chunk; `rotation: "any"` finds the orientation the players chose.
+
+```ts
+import { compareStructure, defineStructure, type StructureReads } from "@kradle/challenges-sdk/structures";
+
+const PILLAR = defineStructure({
+	layers: [["#"], ["#"], ["T"]],
+	palette: { "#": { place: "minecraft:stone_bricks" }, T: { place: "minecraft:torch" } },
+});
+export const pillarDone = (g: StructureReads, at: { x: number; y: number; z: number }) => compareStructure(g, PILLAR, at).complete;
 ```
 
-The arena runs the reducer inside a SES compartment: no clock, no random, no
-timers, no `process`, no network. The harness alone does not apply those limits.
-`kradle challenge test <slug>` builds the challenge and runs its tests against the
-built bundle inside that sandbox. Wrap the import with `sandboxed()`: the test
-then uses the bundle under the command, and the plain import elsewhere.
+## Testing
 
-```js
-import { Game, sandboxed } from "@kradle/challenges-sdk/runtime/harness";
-import climbSource from "../challenges/climb/challenge.ts";
+`@kradle/challenges-sdk/test` is a stand-in arena. A test feeds events, reads
+the actions, and checks the state; `replay()` proves determinism.
 
-const climb = await sandboxed(climbSource);
+```ts
+import { describe, expect, test } from "bun:test";
+import { Game, sandboxed, scores } from "@kradle/challenges-sdk/test";
+import source from "./challenge";
+
+const challenge = await sandboxed(source); // the bundle under `kradle challenge test`, the source otherwise
+
+test("a tag scores", () => {
+	const g = new Game(challenge).begin(1, { Alice: "seeker", Bob: "hider" });
+	g.player("Bob").hurt(1, "player", "Alice");
+	expect(scores(g)).toEqual({ Alice: 1, Bob: 0 });
+	expect(g.said()).toContain("Alice found Bob!");
+	expect(g.result()?.endState).toBe("all_found");
+	g.replay();
+});
 ```
 
-`sandboxed()` reads `KRADLE_CHALLENGE_BUNDLE`, the bundle path the command sets,
-and refuses a bundle that holds a different challenge name. It is async (`ses`
-loads as an ES module), so await it at the top of the test file. A rule that calls
-`Date.now()` or `Math.random()` passes in the plain harness and fails under the
-command, as it fails in the arena; use `g.tick`, `g.elapsed`, `g.rand()` and
-`g.schedule()` instead. The loader itself is
-`@kradle/challenges-sdk/runtime/sandbox` (`lockdownOnce()`, `loadBundle()`,
-`loadBundleFile()`) for a test runner of your own. Call it in a dedicated
-process: the lockdown changes the intrinsics of the whole process. Under the
-command a `Game` on the imported source throws: the command wants the bundle,
-and it counts the Games built on it (`KRADLE_CHALLENGE_EVIDENCE`) as its proof
-that the rules ran inside the sandbox.
+`Game.begin` supplies a position per participant (or takes `at`), sends the
+joins and confirms the setup batches. `g.player(name)` scripts a player
+(`moveTo`, `says`, `vote`, `hurt`, `dies`, `setInventory`, `places`, ...); the
+game feeds the mirror (`terrain`, `setBlocks`, `spawnEntity`, `container`) and
+answers the engine's side (`walkResult`, `batchResult`). `kradle challenge test
+<slug>` runs the same file against the built bundle under the arena's sandbox.
 
 ## Build and run
 

package/dist/engine.d.ts

@@ -0,0 +1,8 @@
+export type { AnyChallenge } from "./runtime/builder.js";
+export { ChallengeError, type ErrorCategory, categoryOf } from "./runtime/errors.js";
+export { MAX_BATCH_EFFECTS, MAX_FILL_VOLUME, type State, assertJson, parseBlockState, splitBatches } from "./runtime/reducer.js";
+export { type Duration, type Ticks, toTicks } from "./runtime/time.js";
+export type { Action, BlockId, Box, Capability, ContainerItem, Effect, EffectId, EndReason, EngineChallenge, EntityTypeId, Event, GameMode, ItemId, ItemMeta, ItemStack, Json, ManifestVote, Marker, Participant, PlayerSample, RuntimeManifest, SdkEndState, SlotChange, Status, TitleTimes, Vec3, } from "./runtime/wire.js";
+export { ALL_CAPABILITIES } from "./runtime/wire.js";
+export type { ChunkMessage, Entity, EntityMove, Equipment, EquipmentChange, EquipmentSlot, Equipped, WorldState } from "./runtime/world.js";
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACrF,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,KAAK,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACjI,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACvE,YAAY,EACX,MAAM,EACN,OAAO,EACP,GAAG,EACH,UAAU,EACV,aAAa,EACb,MAAM,EACN,QAAQ,EACR,SAAS,EACT,eAAe,EACf,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,WAAW,EACX,YAAY,EACZ,eAAe,EACf,WAAW,EACX,UAAU,EACV,MAAM,EACN,UAAU,EACV,IAAI,GACJ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/engine.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_CAPABILITIES = exports.toTicks = exports.splitBatches = exports.parseBlockState = exports.assertJson = exports.MAX_FILL_VOLUME = exports.MAX_BATCH_EFFECTS = exports.categoryOf = exports.ChallengeError = void 0;
+var errors_js_1 = require("./runtime/errors.js");
+Object.defineProperty(exports, "ChallengeError", { enumerable: true, get: function () { return errors_js_1.ChallengeError; } });
+Object.defineProperty(exports, "categoryOf", { enumerable: true, get: function () { return errors_js_1.categoryOf; } });
+var reducer_js_1 = require("./runtime/reducer.js");
+Object.defineProperty(exports, "MAX_BATCH_EFFECTS", { enumerable: true, get: function () { return reducer_js_1.MAX_BATCH_EFFECTS; } });
+Object.defineProperty(exports, "MAX_FILL_VOLUME", { enumerable: true, get: function () { return reducer_js_1.MAX_FILL_VOLUME; } });
+Object.defineProperty(exports, "assertJson", { enumerable: true, get: function () { return reducer_js_1.assertJson; } });
+Object.defineProperty(exports, "parseBlockState", { enumerable: true, get: function () { return reducer_js_1.parseBlockState; } });
+Object.defineProperty(exports, "splitBatches", { enumerable: true, get: function () { return reducer_js_1.splitBatches; } });
+var time_js_1 = require("./runtime/time.js");
+Object.defineProperty(exports, "toTicks", { enumerable: true, get: function () { return time_js_1.toTicks; } });
+var wire_js_1 = require("./runtime/wire.js");
+Object.defineProperty(exports, "ALL_CAPABILITIES", { enumerable: true, get: function () { return wire_js_1.ALL_CAPABILITIES; } });
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":";;;AAGA,iDAAqF;AAA5E,2GAAA,cAAc,OAAA;AAAsB,uGAAA,UAAU,OAAA;AACvD,mDAAiI;AAAxH,+GAAA,iBAAiB,OAAA;AAAE,6GAAA,eAAe,OAAA;AAAc,wGAAA,UAAU,OAAA;AAAE,6GAAA,eAAe,OAAA;AAAE,0GAAA,YAAY,OAAA;AAClG,6CAAuE;AAAnC,kGAAA,OAAO,OAAA;AA6B3C,6CAAqD;AAA5C,2GAAA,gBAAgB,OAAA"}

package/dist/index.d.ts

@@ -1,2 +1,20 @@
-export * from "./runtime/sdk.js";
+export { type AnyChallenge, type Challenge, defineChallenge } from "./runtime/builder.js";
+export { ChallengeError, type ErrorCategory } from "./runtime/errors.js";
+export { MAX_BATCH_EFFECTS, MAX_FILL_VOLUME, MAX_TRANSITIONS_PER_EVENT } from "./runtime/reducer.js";
+export { winBy } from "./runtime/rules.js";
+export { addDuration, asMinutes, asSeconds, type Duration, minutes, seconds, subtractDuration, TICKS_PER_SECOND, type Ticks, ticks, toTicks, } from "./runtime/time.js";
+export type { BlockMatch, BlockPos, BlockSpec, BlockState, ChallengeApi, ChallengeConfig, Ctx, CtxOf, Decl, DeepReadonly, EndStateOf, Handlers, Init, ItemMatch, ItemRequest, LocationOf, NotifyCtx, NotifyCtxOf, ObservedPlayer, OptionFor, Outcome, ParamSpec, ParamsOf, PhaseSpec, PhaseStep, Player, PlayerIn, PlayerOf, Random, ReadCtx, ReadCtxOf, ReadPlayer, ReadPlayerOf, Result, RoleOf, Roster, SetupCtx, SetupCtxOf, StateDecl, TitleOptions, To, VoteIdOf, VoteRule, World, } from "./runtime/types.js";
+export { PLAYER_VOTE, WORLD_DEFAULTS } from "./runtime/types.js";
+export type { BlockId, Box, EffectId, EndReason, EntityTypeId, GameMode, ItemId, ItemMeta, ItemStack, Json, Marker, SdkEndState, Status, Vec3, } from "./runtime/wire.js";
+export { blockIdOf, bounds, type Entity, type EntityFilter, type Equipment, inBox } from "./runtime/world.js";
+import type { BlockPos } from "./runtime/types.js";
+import type { Vec3 } from "./runtime/wire.js";
+/** The integer block position of a continuous position: each axis floored. */
+export declare const toBlockPos: (v: Vec3) => BlockPos;
+/** The position one block under `at`. On a slab or in water this is not the supporting block. */
+export declare const below: (at: Vec3) => BlockPos;
+/** The position one block over `at`. */
+export declare const above: (at: Vec3) => BlockPos;
+/** `at` moved by `d` on each axis. */
+export declare const offset: (at: Vec3, d: Partial<Vec3>) => Vec3;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACrG,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EACN,WAAW,EACX,SAAS,EACT,SAAS,EACT,KAAK,QAAQ,EACb,OAAO,EACP,OAAO,EACP,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,KAAK,EACV,KAAK,EACL,OAAO,GACP,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,UAAU,EACV,YAAY,EACZ,eAAe,EACf,GAAG,EACH,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,IAAI,EACJ,SAAS,EACT,WAAW,EACX,UAAU,EACV,SAAS,EACT,WAAW,EACX,cAAc,EACd,SAAS,EACT,OAAO,EACP,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,EACT,UAAU,EACV,YAAY,EACZ,MAAM,EACN,MAAM,EACN,MAAM,EACN,QAAQ,EACR,UAAU,EACV,SAAS,EACT,YAAY,EACZ,EAAE,EACF,QAAQ,EACR,QAAQ,EACR,KAAK,GACL,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACjE,YAAY,EACX,OAAO,EACP,GAAG,EACH,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,MAAM,EACN,WAAW,EACX,MAAM,EACN,IAAI,GACJ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE9G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,8EAA8E;AAC9E,eAAO,MAAM,UAAU,GAAI,GAAG,IAAI,KAAG,QAA4E,CAAC;AAClH,iGAAiG;AACjG,eAAO,MAAM,KAAK,GAAI,IAAI,IAAI,KAAG,QAAmF,CAAC;AACrH,wCAAwC;AACxC,eAAO,MAAM,KAAK,GAAI,IAAI,IAAI,KAAG,QAAmF,CAAC;AACrH,sCAAsC;AACtC,eAAO,MAAM,MAAM,GAAI,IAAI,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,KAAG,IAA8E,CAAC"}

package/dist/index.js

@@ -1,19 +1,45 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-// The reducer SDK is the package: `@kradle/challenges-sdk` and `@kradle/challenges-sdk/runtime` are the same API.
-__exportStar(require("./runtime/sdk.js"), exports);
+exports.offset = exports.above = exports.below = exports.toBlockPos = exports.inBox = exports.bounds = exports.blockIdOf = exports.WORLD_DEFAULTS = exports.PLAYER_VOTE = exports.toTicks = exports.ticks = exports.TICKS_PER_SECOND = exports.subtractDuration = exports.seconds = exports.minutes = exports.asSeconds = exports.asMinutes = exports.addDuration = exports.winBy = exports.MAX_TRANSITIONS_PER_EVENT = exports.MAX_FILL_VOLUME = exports.MAX_BATCH_EFFECTS = exports.ChallengeError = exports.defineChallenge = void 0;
+// The author API: `@kradle/challenges-sdk`. The engine protocol is `@kradle/challenges-sdk/engine`,
+// the test kit `@kradle/challenges-sdk/test`.
+var builder_js_1 = require("./runtime/builder.js");
+Object.defineProperty(exports, "defineChallenge", { enumerable: true, get: function () { return builder_js_1.defineChallenge; } });
+var errors_js_1 = require("./runtime/errors.js");
+Object.defineProperty(exports, "ChallengeError", { enumerable: true, get: function () { return errors_js_1.ChallengeError; } });
+var reducer_js_1 = require("./runtime/reducer.js");
+Object.defineProperty(exports, "MAX_BATCH_EFFECTS", { enumerable: true, get: function () { return reducer_js_1.MAX_BATCH_EFFECTS; } });
+Object.defineProperty(exports, "MAX_FILL_VOLUME", { enumerable: true, get: function () { return reducer_js_1.MAX_FILL_VOLUME; } });
+Object.defineProperty(exports, "MAX_TRANSITIONS_PER_EVENT", { enumerable: true, get: function () { return reducer_js_1.MAX_TRANSITIONS_PER_EVENT; } });
+var rules_js_1 = require("./runtime/rules.js");
+Object.defineProperty(exports, "winBy", { enumerable: true, get: function () { return rules_js_1.winBy; } });
+var time_js_1 = require("./runtime/time.js");
+Object.defineProperty(exports, "addDuration", { enumerable: true, get: function () { return time_js_1.addDuration; } });
+Object.defineProperty(exports, "asMinutes", { enumerable: true, get: function () { return time_js_1.asMinutes; } });
+Object.defineProperty(exports, "asSeconds", { enumerable: true, get: function () { return time_js_1.asSeconds; } });
+Object.defineProperty(exports, "minutes", { enumerable: true, get: function () { return time_js_1.minutes; } });
+Object.defineProperty(exports, "seconds", { enumerable: true, get: function () { return time_js_1.seconds; } });
+Object.defineProperty(exports, "subtractDuration", { enumerable: true, get: function () { return time_js_1.subtractDuration; } });
+Object.defineProperty(exports, "TICKS_PER_SECOND", { enumerable: true, get: function () { return time_js_1.TICKS_PER_SECOND; } });
+Object.defineProperty(exports, "ticks", { enumerable: true, get: function () { return time_js_1.ticks; } });
+Object.defineProperty(exports, "toTicks", { enumerable: true, get: function () { return time_js_1.toTicks; } });
+var types_js_1 = require("./runtime/types.js");
+Object.defineProperty(exports, "PLAYER_VOTE", { enumerable: true, get: function () { return types_js_1.PLAYER_VOTE; } });
+Object.defineProperty(exports, "WORLD_DEFAULTS", { enumerable: true, get: function () { return types_js_1.WORLD_DEFAULTS; } });
+var world_js_1 = require("./runtime/world.js");
+Object.defineProperty(exports, "blockIdOf", { enumerable: true, get: function () { return world_js_1.blockIdOf; } });
+Object.defineProperty(exports, "bounds", { enumerable: true, get: function () { return world_js_1.bounds; } });
+Object.defineProperty(exports, "inBox", { enumerable: true, get: function () { return world_js_1.inBox; } });
+/** The integer block position of a continuous position: each axis floored. */
+const toBlockPos = (v) => ({ x: Math.floor(v.x), y: Math.floor(v.y), z: Math.floor(v.z) });
+exports.toBlockPos = toBlockPos;
+/** The position one block under `at`. On a slab or in water this is not the supporting block. */
+const below = (at) => ({ x: Math.floor(at.x), y: Math.floor(at.y) - 1, z: Math.floor(at.z) });
+exports.below = below;
+/** The position one block over `at`. */
+const above = (at) => ({ x: Math.floor(at.x), y: Math.floor(at.y) + 1, z: Math.floor(at.z) });
+exports.above = above;
+/** `at` moved by `d` on each axis. */
+const offset = (at, d) => ({ x: at.x + (d.x ?? 0), y: at.y + (d.y ?? 0), z: at.z + (d.z ?? 0) });
+exports.offset = offset;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kHAAkH;AAClH,mDAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,oGAAoG;AACpG,8CAA8C;AAC9C,mDAA0F;AAA9C,6GAAA,eAAe,OAAA;AAC3D,iDAAyE;AAAhE,2GAAA,cAAc,OAAA;AACvB,mDAAqG;AAA5F,+GAAA,iBAAiB,OAAA;AAAE,6GAAA,eAAe,OAAA;AAAE,uHAAA,yBAAyB,OAAA;AACtE,+CAA2C;AAAlC,iGAAA,KAAK,OAAA;AACd,6CAY2B;AAX1B,sGAAA,WAAW,OAAA;AACX,oGAAA,SAAS,OAAA;AACT,oGAAA,SAAS,OAAA;AAET,kGAAA,OAAO,OAAA;AACP,kGAAA,OAAO,OAAA;AACP,2GAAA,gBAAgB,OAAA;AAChB,2GAAA,gBAAgB,OAAA;AAEhB,gGAAA,KAAK,OAAA;AACL,kGAAA,OAAO,OAAA;AAgDR,+CAAiE;AAAxD,uGAAA,WAAW,OAAA;AAAE,0GAAA,cAAc,OAAA;AAiBpC,+CAA8G;AAArG,qGAAA,SAAS,OAAA;AAAE,kGAAA,MAAM,OAAA;AAAkD,iGAAA,KAAK,OAAA;AAIjF,8EAA8E;AACvE,MAAM,UAAU,GAAG,CAAC,CAAO,EAAY,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAArG,QAAA,UAAU,cAA2F;AAClH,iGAAiG;AAC1F,MAAM,KAAK,GAAG,CAAC,EAAQ,EAAY,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAAxG,QAAA,KAAK,SAAmG;AACrH,wCAAwC;AACjC,MAAM,KAAK,GAAG,CAAC,EAAQ,EAAY,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAAxG,QAAA,KAAK,SAAmG;AACrH,sCAAsC;AAC/B,MAAM,MAAM,GAAG,CAAC,EAAQ,EAAE,CAAgB,EAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;AAAtH,QAAA,MAAM,UAAgH"}

package/dist/runtime/builder.d.ts

@@ -0,0 +1,33 @@
+import { type State } from "./reducer.js";
+import type { ChallengeApi, ChallengeConfig, Decl, Handlers, Outcome, PhaseSpec, PlayerMap, ResolvePlayers, VotesDecl } from "./types.js";
+import type { Action, Event, RuntimeManifest } from "./wire.js";
+/** A challenge as the arena and the harness use it: the API plus `init`, `reduce` and the manifest. */
+export interface Challenge<C extends ChallengeConfig, G, PM extends PlayerMap<C>, Ph extends string, Z extends string, T extends string, V extends VotesDecl> extends ChallengeApi<C, G, PM, Ph, Z, T, V> {
+    /** The manifest the arena and the backend read. Reading it locks the definition. */
+    readonly manifest: RuntimeManifest;
+    /** True once the definition is locked (`init()` or `manifest` was used). */
+    readonly locked: boolean;
+    /** A fresh run state. Locks the definition on the first call. */
+    init(): State;
+    /** One reduction: the next state and the actions for the engine. Never mutates `state`. */
+    reduce(state: State, event: Event): {
+        /** The next state, frozen; the input is never changed. */
+        state: State;
+        /** What the engine and the arena apply, in order. */
+        actions: Action[];
+    };
+}
+/**
+ * The shape every built challenge bundle exports as `default`: any challenge, whatever its config and names.
+ * `any` on purpose: a concrete challenge (literal phase names, typed options) is not assignable to one typed
+ * with `string`, because the callbacks are contravariant in those names.
+ */
+export type AnyChallenge = Challenge<any, any, any, any, any, any, any>;
+/**
+ * Defines a challenge. The root declaration carries the data and the state initializers; the
+ * steps carry the behavior. `init()` or the first `manifest` read locks the definition.
+ */
+export declare function defineChallenge<const C extends ChallengeConfig, G extends object = Record<string, never>, P extends object = Record<string, never>, PS extends Partial<Record<RoleOfC<C>, object>> = Record<never, never>, const Ph extends string = never, const Z extends string = never, const T extends string = never, const V extends VotesDecl = Record<never, never>>(config: C, decl: Decl<C, G, P, PS, Ph, Z, T, V>): Challenge<C, G, ResolvePlayers<C, P, PS>, Ph, Z, T, V>;
+type RoleOfC<C extends ChallengeConfig> = keyof C["roles"] & string;
+export type { Handlers, Outcome, PhaseSpec };
+//# sourceMappingURL=builder.d.ts.map

package/dist/runtime/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/runtime/builder.ts"],"names":[],"mappings":"AAYA,OAAO,EAAwF,KAAK,KAAK,EAAE,MAAM,cAAc,CAAC;AAEhI,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,SAAS,EACT,SAAS,EACT,cAAc,EACd,SAAS,EAET,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,MAAM,EAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAIrE,uGAAuG;AACvG,MAAM,WAAW,SAAS,CACzB,CAAC,SAAS,eAAe,EACzB,CAAC,EACD,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EACvB,EAAE,SAAS,MAAM,EACjB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,SAAS,CAClB,SAAQ,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC5C,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,iEAAiE;IACjE,IAAI,IAAI,KAAK,CAAC;IACd,2FAA2F;IAC3F,MAAM,CACL,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,KAAK,GACV;QACF,0DAA0D;QAC1D,KAAK,EAAE,KAAK,CAAC;QACb,qDAAqD;QACrD,OAAO,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AA4HxE;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,KAAK,CAAC,CAAC,SAAS,eAAe,EAC/B,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACxC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACxC,EAAE,SAAS,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EACrE,KAAK,CAAC,EAAE,SAAS,MAAM,GAAG,KAAK,EAC/B,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,KAAK,EAC9B,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,KAAK,EAC9B,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC/C,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAoMzG;AAED,KAAK,OAAO,CAAC,CAAC,SAAS,eAAe,IAAI,MAAM,CAAC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC;AAGpE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC"}