@jgengine/core 0.7.0 → 0.8.0

package/dist/session/roundState.js

@@ -1,31 +1,47 @@
-const PHASE_ORDER = ["buy", "live", "end"];
+const DEFAULT_PHASE_ORDER = ["buy", "live", "end"];
 export function lossBonusFor(rule, streak) {
     if (rule === undefined)
         return 0;
     return Math.min(rule.max, rule.base + rule.step * Math.max(0, streak));
 }
+function normalizeTeams(teams) {
+    if (teams.length === 0)
+        return [{ id: "a" }, { id: "b" }];
+    const normalized = [];
+    for (const team of teams) {
+        normalized.push(typeof team === "string" ? { id: team } : team);
+    }
+    return normalized;
+}
+function isConcludable(order, phase) {
+    const idx = order.indexOf(phase);
+    return idx > 0 && idx < order.length - 1;
+}
 export function createRoundState(config) {
+    const order = config.phaseOrder ?? DEFAULT_PHASE_ORDER;
     const durations = config.phases;
-    const teams = config.teams.length > 0 ? [...config.teams] : ["a", "b"];
+    const teamRecords = normalizeTeams(config.teams);
+    const teamIds = teamRecords.map((t) => t.id);
+    const roles = {};
     const scores = {};
     const lossStreaks = {};
-    for (const team of teams) {
-        scores[team] = 0;
-        lossStreaks[team] = 0;
+    for (const team of teamRecords) {
+        roles[team.id] = team.role;
+        scores[team.id] = 0;
+        lossStreaks[team.id] = 0;
     }
     let round = 1;
-    let phase = "buy";
-    let timeLeft = durations.buy;
+    let phase = order[0];
+    let timeLeft = durations[phase] ?? 0;
     let matchOver = false;
     let pendingWinner = null;
     const hooks = new Set();
     function durationOf(next) {
-        return durations[next];
+        return durations[next] ?? 0;
     }
     function nextPhaseOf(current) {
-        if (current === "end")
-            return "buy";
-        return PHASE_ORDER[PHASE_ORDER.indexOf(current) + 1];
+        const idx = order.indexOf(current);
+        return idx >= order.length - 1 ? order[0] : order[idx + 1];
     }
     function economyFor(team) {
         const won = pendingWinner === team;
@@ -38,12 +54,12 @@ export function createRoundState(config) {
     }
     function settleEconomy(winner) {
         const economy = [];
-        for (const team of teams) {
+        for (const team of teamIds) {
             const won = team === winner;
             const reward = won ? config.winReward ?? 0 : lossBonusFor(config.lossBonus, lossStreaks[team]);
             economy.push({ team, reward, won, lossStreak: lossStreaks[team] });
         }
-        for (const team of teams) {
+        for (const team of teamIds) {
             if (team === winner)
                 lossStreaks[team] = 0;
             else
@@ -58,24 +74,48 @@ export function createRoundState(config) {
     }
     function endPhase(events) {
         const ending = phase;
-        if (ending === "end") {
+        if (ending === order[order.length - 1]) {
             if (config.maxRounds !== undefined && round >= config.maxRounds) {
                 matchOver = true;
-                events.push({ kind: "phase.end", round, phase: ending, nextPhase: "buy" });
+                events.push({ kind: "phase.end", round, phase: ending, nextPhase: order[0] });
                 events.push({ kind: "match.end", round });
                 for (const hook of hooks)
-                    hook(ending, "buy", round);
+                    hook(ending, order[0], round);
                 return;
             }
             round += 1;
             pendingWinner = null;
         }
         const next = nextPhaseOf(ending);
-        events.push({ kind: "phase.end", round: ending === "end" ? round - 1 : round, phase: ending, nextPhase: next });
+        const endedRound = ending === order[order.length - 1] ? round - 1 : round;
+        events.push({ kind: "phase.end", round: endedRound, phase: ending, nextPhase: next });
         for (const hook of hooks)
-            hook(ending, next, ending === "end" ? round - 1 : round);
+            hook(ending, next, endedRound);
         enter(next, events);
     }
+    function currentSnapshot() {
+        return {
+            round,
+            phase,
+            timeLeft: Math.max(0, timeLeft),
+            scores: { ...scores },
+            lossStreaks: { ...lossStreaks },
+            roles: { ...roles },
+            matchOver,
+        };
+    }
+    function concludeRoundImpl(winner) {
+        if (matchOver || !isConcludable(order, phase))
+            return [];
+        const events = [];
+        pendingWinner = winner;
+        scores[winner] = (scores[winner] ?? 0) + 1;
+        events.push({ kind: "round.win", round, winner });
+        const economy = settleEconomy(winner);
+        events.push({ kind: "round.economy", round, winner, economy });
+        endPhase(events);
+        return events;
+    }
     return {
         tick(dt) {
             if (dt <= 0 || matchOver)
@@ -83,9 +123,9 @@ export function createRoundState(config) {
             const events = [];
             timeLeft -= dt;
             let guard = 0;
-            while (timeLeft <= 0 && !matchOver && guard < PHASE_ORDER.length + 2) {
+            while (timeLeft <= 0 && !matchOver && guard < order.length + 2) {
                 const carry = timeLeft;
-                if (phase === "live")
+                if (isConcludable(order, phase))
                     pendingWinner = null;
                 endPhase(events);
                 if (!matchOver)
@@ -94,17 +134,12 @@ export function createRoundState(config) {
             }
             return events;
         },
-        concludeRound(winner) {
-            if (matchOver || phase !== "live")
+        concludeRound: concludeRoundImpl,
+        evaluate() {
+            if (config.winCondition === undefined)
                 return [];
-            const events = [];
-            pendingWinner = winner;
-            scores[winner] = (scores[winner] ?? 0) + 1;
-            events.push({ kind: "round.win", round, winner });
-            const economy = settleEconomy(winner);
-            events.push({ kind: "round.economy", round, winner, economy });
-            endPhase(events);
-            return events;
+            const winner = config.winCondition(currentSnapshot());
+            return winner === null ? [] : concludeRoundImpl(winner);
         },
         onPhaseEnd(hook) {
             hooks.add(hook);
@@ -117,13 +152,7 @@ export function createRoundState(config) {
         timeLeft: () => Math.max(0, timeLeft),
         score: (team) => scores[team] ?? 0,
         economyFor,
-        snapshot: () => ({
-            round,
-            phase,
-            timeLeft: Math.max(0, timeLeft),
-            scores: { ...scores },
-            lossStreaks: { ...lossStreaks },
-            matchOver,
-        }),
+        roleOf: (team) => roles[team],
+        snapshot: currentSnapshot,
     };
 }

package/dist/tactics/fallingGrid.d.ts

@@ -0,0 +1,62 @@
+export type FallingGridCell = readonly [number, number];
+export interface FallingGridConfig {
+    cols: number;
+    rows: number;
+    /** Milliseconds a grounded piece may sit before `lockExpired` fires. Defaults to 500. */
+    lockDelayMs?: number;
+}
+/** Elapsed grounded time for the lock-delay state machine. `null` means airborne / not timing. */
+export interface LockState {
+    elapsedMs: number;
+}
+export interface FallingGridSnapshot<TCell> {
+    cols: number;
+    rows: number;
+    cells: readonly (TCell | null)[];
+}
+export interface FallingGrid<TCell> {
+    readonly cols: number;
+    readonly rows: number;
+    occupied(col: number, row: number): boolean;
+    cellAt(col: number, row: number): TCell | null;
+    setCell(col: number, row: number, value: TCell): void;
+    clearCell(col: number, row: number): void;
+    /** Bounds + collision check for a footprint (`cells`, relative to `offset`). Rows above the grid (`row < 0`) are allowed through, mirroring a piece spawning above the visible board; only columns are bounds-checked there. */
+    canPlace(cells: readonly FallingGridCell[], offset: FallingGridCell): boolean;
+    /** Writes `value` into every in-bounds cell of the footprint if `canPlace` allows it. Cells above the grid are silently skipped. Returns whether the placement happened. */
+    place(cells: readonly FallingGridCell[], offset: FallingGridCell, value: TCell): boolean;
+    /** Row indices that are fully occupied, in ascending order. */
+    fullRows(): readonly number[];
+    /** Removes the given rows and shifts every row above them down, backfilling the top with empty rows. Returns the number of rows cleared. */
+    clearRows(rows: readonly number[]): number;
+    /** Column-gravity collapse: every occupied cell in each column falls to the lowest free row below it, preserving relative order. Returns the number of cells that moved. */
+    settle(): number;
+    /** Advances (or starts) a lock-delay timer while `grounded`, and clears it the instant the piece is airborne. */
+    advanceLock(state: LockState | null, grounded: boolean, dtMs: number): LockState | null;
+    /** Whether a lock-delay timer has run out `lockDelayMs`. */
+    lockExpired(state: LockState | null): boolean;
+    snapshot(): FallingGridSnapshot<TCell>;
+    /** Clears every cell back to empty. */
+    reset(): void;
+}
+export interface GravityIntervalConfig {
+    /** Interval at level 0, in milliseconds. Defaults to 800. */
+    baseMs?: number;
+    /** Milliseconds shaved off per level. Defaults to 70. */
+    perLevel?: number;
+    /** Floor the interval never drops below, in milliseconds. Defaults to 50. */
+    minMs?: number;
+}
+/**
+ * Gravity tick interval for a given level: linear speed-up with a floor, generalizing
+ * `Games/block-stacker`'s `gravityInterval` (`max(0.05, 0.8 - level * 0.07)` seconds) to milliseconds
+ * with configurable base/step/floor.
+ */
+export declare function gravityIntervalMs(level: number, config?: GravityIntervalConfig): number;
+/**
+ * A game-agnostic cell grid for gravity-driven falling-block mechanics: bounded occupancy,
+ * footprint placement/collision, line-clear collapse, column-gravity settle (for match-3/sand
+ * style cascades), and a pure lock-delay helper. Extracted from `Games/block-stacker`'s tetris
+ * logic so any falling-block game can adopt it instead of reimplementing the grid.
+ */
+export declare function createFallingGrid<TCell>(config: FallingGridConfig): FallingGrid<TCell>;

package/dist/tactics/fallingGrid.js

@@ -0,0 +1,158 @@
+/**
+ * Gravity tick interval for a given level: linear speed-up with a floor, generalizing
+ * `Games/block-stacker`'s `gravityInterval` (`max(0.05, 0.8 - level * 0.07)` seconds) to milliseconds
+ * with configurable base/step/floor.
+ */
+export function gravityIntervalMs(level, config = {}) {
+    const baseMs = config.baseMs ?? 800;
+    const perLevel = config.perLevel ?? 70;
+    const minMs = config.minMs ?? 50;
+    return Math.max(minMs, baseMs - level * perLevel);
+}
+/**
+ * A game-agnostic cell grid for gravity-driven falling-block mechanics: bounded occupancy,
+ * footprint placement/collision, line-clear collapse, column-gravity settle (for match-3/sand
+ * style cascades), and a pure lock-delay helper. Extracted from `Games/block-stacker`'s tetris
+ * logic so any falling-block game can adopt it instead of reimplementing the grid.
+ */
+export function createFallingGrid(config) {
+    const cols = config.cols;
+    const rows = config.rows;
+    const lockDelayMs = config.lockDelayMs ?? 500;
+    if (cols <= 0 || rows <= 0)
+        throw new Error("falling grid needs positive dimensions");
+    let cells = new Array(cols * rows).fill(null);
+    function index(col, row) {
+        return row * cols + col;
+    }
+    function inBounds(col, row) {
+        return col >= 0 && col < cols && row >= 0 && row < rows;
+    }
+    function cellAt(col, row) {
+        if (!inBounds(col, row))
+            return null;
+        return cells[index(col, row)] ?? null;
+    }
+    function occupied(col, row) {
+        return cellAt(col, row) !== null;
+    }
+    function setCell(col, row, value) {
+        if (!inBounds(col, row))
+            return;
+        cells[index(col, row)] = value;
+    }
+    function clearCell(col, row) {
+        if (!inBounds(col, row))
+            return;
+        cells[index(col, row)] = null;
+    }
+    function canPlace(footprint, offset) {
+        for (const [dc, dr] of footprint) {
+            const col = offset[0] + dc;
+            const row = offset[1] + dr;
+            if (col < 0 || col >= cols || row >= rows)
+                return false;
+            if (row >= 0 && occupied(col, row))
+                return false;
+        }
+        return true;
+    }
+    function place(footprint, offset, value) {
+        if (!canPlace(footprint, offset))
+            return false;
+        for (const [dc, dr] of footprint) {
+            const col = offset[0] + dc;
+            const row = offset[1] + dr;
+            if (row >= 0)
+                setCell(col, row, value);
+        }
+        return true;
+    }
+    function fullRows() {
+        const full = [];
+        for (let row = 0; row < rows; row += 1) {
+            let rowFull = true;
+            for (let col = 0; col < cols; col += 1) {
+                if (!occupied(col, row)) {
+                    rowFull = false;
+                    break;
+                }
+            }
+            if (rowFull)
+                full.push(row);
+        }
+        return full;
+    }
+    function clearRows(rowsToClear) {
+        const toClear = new Set(rowsToClear);
+        if (toClear.size === 0)
+            return 0;
+        const kept = [];
+        for (let row = 0; row < rows; row += 1) {
+            if (toClear.has(row))
+                continue;
+            kept.push(cells.slice(index(0, row), index(0, row) + cols));
+        }
+        const cleared = rows - kept.length;
+        const next = [];
+        for (let i = 0; i < cleared; i += 1)
+            next.push(...new Array(cols).fill(null));
+        for (const row of kept)
+            next.push(...row);
+        cells = next;
+        return cleared;
+    }
+    function settle() {
+        let moved = 0;
+        for (let col = 0; col < cols; col += 1) {
+            const values = [];
+            for (let row = 0; row < rows; row += 1) {
+                const value = cellAt(col, row);
+                if (value !== null)
+                    values.push({ row, value });
+            }
+            for (let row = 0; row < rows; row += 1)
+                clearCell(col, row);
+            const count = values.length;
+            for (let i = 0; i < count; i += 1) {
+                const newRow = rows - count + i;
+                const { row: oldRow, value } = values[i];
+                setCell(col, newRow, value);
+                if (oldRow !== newRow)
+                    moved += 1;
+            }
+        }
+        return moved;
+    }
+    function advanceLock(state, grounded, dtMs) {
+        if (!grounded)
+            return null;
+        return { elapsedMs: (state?.elapsedMs ?? 0) + dtMs };
+    }
+    function lockExpired(state) {
+        return state !== null && state.elapsedMs >= lockDelayMs;
+    }
+    function snapshot() {
+        return { cols, rows, cells: cells.slice() };
+    }
+    function reset() {
+        cells = new Array(cols * rows).fill(null);
+    }
+    return {
+        cols,
+        rows,
+        occupied,
+        cellAt,
+        setCell,
+        clearCell,
+        canPlace,
+        place,
+        fullRows,
+        clearRows,
+        settle,
+        advanceLock,
+        lockExpired,
+        snapshot,
+        reset,
+    };
+}

package/dist/tactics/tacticalGrid.d.ts

@@ -1,9 +1,16 @@
 export type Tile = readonly [number, number];
+/** Maps abstract `[col, row]` tiles onto world-space `[x, z]`, mirroring `navGrid`'s bounds+cellSize convention. */
+export interface TacticalGridWorldConfig {
+    /** World-space `[x, z]` of the min corner of tile `[0, 0]`. */
+    origin: readonly [number, number];
+    tileSize: number;
+}
 export interface TacticalGridConfig {
     width: number;
     height: number;
     blocked?: readonly Tile[];
     diagonal?: boolean;
+    world?: TacticalGridWorldConfig;
 }
 export interface ReachableOptions {
     passThrough?: readonly string[];
@@ -53,5 +60,9 @@ export interface TacticalGrid {
     push(id: string, direction: Tile, options?: PushOptions): PushResult;
     capture(): TacticalGridSnapshot;
     restore(snapshot: TacticalGridSnapshot): void;
+    /** World `[x, z]` to the containing tile, or `null` when outside the grid. Requires `config.world`. */
+    worldToTile(x: number, z: number): Tile | null;
+    /** A tile's world-space center. Requires `config.world`. */
+    tileToWorld(tile: Tile): readonly [number, number];
 }
 export declare function createTacticalGrid(config: TacticalGridConfig): TacticalGrid;

package/dist/tactics/tacticalGrid.js

@@ -12,9 +12,24 @@ export function createTacticalGrid(config) {
     const blocked = new Set((config.blocked ?? []).map(key));
     const occupants = new Map();
     const tiles = new Map();
+    const world = config.world;
     function inBounds(tile) {
         return tile[0] >= 0 && tile[0] < width && tile[1] >= 0 && tile[1] < height;
     }
+    function requireWorld() {
+        if (world === undefined)
+            throw new Error("tacticalGrid: worldToTile/tileToWorld require config.world.");
+        return world;
+    }
+    function worldToTile(x, z) {
+        const { origin, tileSize } = requireWorld();
+        const tile = [Math.floor((x - origin[0]) / tileSize), Math.floor((z - origin[1]) / tileSize)];
+        return inBounds(tile) ? tile : null;
+    }
+    function tileToWorld(tile) {
+        const { origin, tileSize } = requireWorld();
+        return [origin[0] + (tile[0] + 0.5) * tileSize, origin[1] + (tile[1] + 0.5) * tileSize];
+    }
     function isBlocked(tile) {
         return blocked.has(key(tile));
     }
@@ -223,6 +238,8 @@ export function createTacticalGrid(config) {
         reachable,
         path,
         push,
+        worldToTile,
+        tileToWorld,
         capture: () => {
             const occ = {};
             for (const [k, unitId] of occupants)

package/dist/time/simClock.d.ts

@@ -9,6 +9,10 @@ export interface TimeConfig {
     start?: number;
     /** Boot with the clock paused. Default false. */
     startPaused?: boolean;
+    /** In-world days per year, driving `calendar().year`/`dayOfYear`/`yearFraction`. Default 365. */
+    daysPerYear?: number;
+    /** Named season segments spanning the year in equal shares; when set, `calendar().season` names the current one. */
+    seasons?: readonly string[];
 }
 export interface CalendarTime {
     /** Total game-seconds since the world started. */
@@ -20,14 +24,24 @@ export interface CalendarTime {
     second: number;
     /** Progress through the current day, 0..1. */
     dayFraction: number;
+    /** 0-based year index, using `daysPerYear` (default 365). */
+    year: number;
+    /** 0-based day index within the current year. */
+    dayOfYear: number;
+    /** Progress through the current year, 0..1. */
+    yearFraction: number;
+    /** Current season name, present only when `TimeConfig.seasons` is configured. */
+    season?: string;
 }
 export interface ClockSnapshot {
     now: number;
     paused: boolean;
-    /** Effective multiplier applied to real time — 0 while paused. */
+    /** Speed-control multiplier — 0 while paused. The full game-time rate is `speed × timescale × scale`. */
     speed: number;
     /** The non-zero multiplier `play()` resumes to. */
     playSpeed: number;
+    /** Global slow-motion/fast-forward multiplier; 1 unless `setTimescale` was called. */
+    timescale: number;
     scale: number;
     speeds: readonly number[];
     calendar: CalendarTime;
@@ -47,6 +61,16 @@ export interface SimClock {
     setSpeed(multiplier: number): void;
     /** Step to the next configured speed (wraps); always unpauses. */
     cycleSpeed(): void;
+    /** Current global timescale multiplier; 1 by default. */
+    timescale(): number;
+    /**
+     * Global slow-motion/fast-forward multiplier composed with the speed control —
+     * `advance` returns `realDt × scale × speed × timescale`. `0` freezes game time
+     * without flipping pause state (`0.08` = bullet time, `2` = fast-forward); negative
+     * or non-finite values clamp to 0. Timescale is host-authoritative: in multiplayer
+     * it belongs to the host simulation, never to an individual client.
+     */
+    setTimescale(multiplier: number): void;
     /** Run `callback` once, `seconds` of game-time from now. Returns a cancel handle. */
     after(seconds: number, callback: () => void): () => void;
     /** Run `callback` every `seconds` of game-time. Returns a cancel handle. */

package/dist/time/simClock.js

@@ -7,9 +7,12 @@ export function createSimClock(options = {}) {
     const configuredSpeeds = config.speeds === undefined ? [1, 2, 3, 4] : config.speeds.filter((value) => value > 0);
     const speeds = configuredSpeeds.length > 0 ? configuredSpeeds : [1];
     const dayLength = config.dayLength !== undefined && config.dayLength > 0 ? config.dayLength : SECONDS_PER_GAME_DAY;
+    const daysPerYear = config.daysPerYear !== undefined && config.daysPerYear > 0 ? config.daysPerYear : 365;
+    const seasons = config.seasons;
     let now = config.start !== undefined && config.start > 0 ? config.start : 0;
     let paused = config.startPaused ?? false;
     let playSpeed = speeds[0];
+    let timescale = 1;
     let nextTimerId = 0;
     const timers = new Map();
     let displayMinute = minuteIndex(now, dayLength);
@@ -17,14 +20,26 @@ export function createSimClock(options = {}) {
         const day = Math.floor(now / dayLength);
         const dayFraction = (now - day * dayLength) / dayLength;
         const secondOfDay = dayFraction * 24 * 3600;
-        return {
+        const year = Math.floor(day / daysPerYear);
+        const dayOfYear = day - year * daysPerYear;
+        const yearFraction = (dayOfYear + dayFraction) / daysPerYear;
+        const result = {
             totalSeconds: now,
             day,
             hour: Math.floor(secondOfDay / 3600) % 24,
             minute: Math.floor(secondOfDay / 60) % 60,
             second: Math.floor(secondOfDay) % 60,
             dayFraction,
+            year,
+            dayOfYear,
+            yearFraction,
         };
+        if (seasons !== undefined && seasons.length > 0) {
+            const segmentLength = daysPerYear / seasons.length;
+            const index = Math.min(seasons.length - 1, Math.floor(dayOfYear / segmentLength));
+            result.season = seasons[index];
+        }
+        return result;
     }
     function fireDueTimers() {
         let fires = 0;
@@ -52,9 +67,9 @@ export function createSimClock(options = {}) {
         }
     }
     function advance(realDt) {
-        if (paused || realDt <= 0)
+        if (paused || realDt <= 0 || timescale === 0)
             return 0;
-        const gameDt = realDt * scale * playSpeed;
+        const gameDt = realDt * scale * playSpeed * timescale;
         now += gameDt;
         fireDueTimers();
         const minute = minuteIndex(now, dayLength);
@@ -91,6 +106,13 @@ export function createSimClock(options = {}) {
         const index = speeds.indexOf(playSpeed);
         setSpeed(speeds[(index + 1) % speeds.length]);
     }
+    function setTimescale(multiplier) {
+        const next = Number.isFinite(multiplier) && multiplier > 0 ? multiplier : 0;
+        if (next === timescale)
+            return;
+        timescale = next;
+        onChange();
+    }
     function register(due, interval, callback) {
         const id = nextTimerId;
         nextTimerId += 1;
@@ -108,6 +130,7 @@ export function createSimClock(options = {}) {
             paused,
             speed: paused ? 0 : playSpeed,
             playSpeed,
+            timescale,
             scale,
             speeds,
             calendar: calendar(),
@@ -119,6 +142,8 @@ export function createSimClock(options = {}) {
         toggle: () => (paused ? play() : pause()),
         setSpeed,
         cycleSpeed,
+        timescale: () => timescale,
+        setTimescale,
         after: (seconds, callback) => register(now + Math.max(0, seconds), null, callback),
         every: (seconds, callback) => {
             const interval = Math.max(Number.EPSILON, seconds);

package/dist/turn/intent.d.ts

@@ -0,0 +1,14 @@
+export interface DeclaredIntent<TKind extends string = string> {
+    kind: TKind;
+    magnitude?: number;
+    targetId?: string;
+    note?: string;
+}
+export interface IntentBoard<TKind extends string = string> {
+    declare(participantId: string, intent: DeclaredIntent<TKind>): void;
+    peek(participantId: string): DeclaredIntent<TKind> | null;
+    all(): readonly [string, DeclaredIntent<TKind>][];
+    consume(participantId: string): DeclaredIntent<TKind> | null;
+    clear(participantId?: string): void;
+}
+export declare function createIntentBoard<TKind extends string = string>(): IntentBoard<TKind>;

package/dist/turn/intent.js

@@ -0,0 +1,29 @@
+export function createIntentBoard() {
+    const intents = new Map();
+    return {
+        declare(participantId, intent) {
+            intents.set(participantId, { ...intent });
+        },
+        peek(participantId) {
+            const intent = intents.get(participantId);
+            return intent === undefined ? null : { ...intent };
+        },
+        all() {
+            return [...intents.entries()].map(([participantId, intent]) => [participantId, { ...intent }]);
+        },
+        consume(participantId) {
+            const intent = intents.get(participantId);
+            if (intent === undefined)
+                return null;
+            intents.delete(participantId);
+            return intent;
+        },
+        clear(participantId) {
+            if (participantId === undefined) {
+                intents.clear();
+                return;
+            }
+            intents.delete(participantId);
+        },
+    };
+}

package/dist/turn/turnLoop.d.ts

@@ -12,6 +12,8 @@ export interface TurnLoopConfig {
     commit?: {
         mode: CommitMode;
     };
+    onTurnStart?(participantId: string): void;
+    onTurnEnd?(participantId: string): void;
 }
 export interface PoolState {
     id: string;

package/dist/turn/turnLoop.js

@@ -27,6 +27,8 @@ export function createTurnLoop(config) {
     }
     for (const id of order)
         resetPools(id);
+    if (activeIndex >= 0)
+        config.onTurnStart?.(order[activeIndex]);
     function active() {
         return activeIndex >= 0 && activeIndex < order.length ? order[activeIndex] : null;
     }
@@ -48,6 +50,7 @@ export function createTurnLoop(config) {
             activeIndex = -1;
             return state();
         }
+        const previous = active();
         phaseIndex = 0;
         if (activeIndex < 0) {
             activeIndex = 0;
@@ -59,9 +62,13 @@ export function createTurnLoop(config) {
         else {
             activeIndex += 1;
         }
+        if (previous !== null)
+            config.onTurnEnd?.(previous);
         const current = active();
-        if (current !== null)
+        if (current !== null) {
             resetPools(current);
+            config.onTurnStart?.(current);
+        }
         return state();
     }
     function advancePhase() {