@jgengine/core 0.7.0 → 0.8.0

package/dist/scene/objectStore.js

@@ -1,6 +1,17 @@
 import { createObservableKeyedStore } from "../store/observableKeyedStore.js";
+const CELL_SIZE = 1;
+function cellIndexOf(value) {
+    return Math.floor(value / CELL_SIZE);
+}
+function cellKey(cx, cy, cz) {
+    return `${cx}:${cy}:${cz}`;
+}
+function cellKeyOf(position) {
+    return cellKey(cellIndexOf(position[0]), cellIndexOf(position[1]), cellIndexOf(position[2]));
+}
 export function createObjectStore() {
     const store = createObservableKeyedStore();
+    const cellIndex = new Map();
     let nextCounter = 1;
     function generateId() {
         let id = `object-${nextCounter}`;
@@ -11,31 +22,58 @@ export function createObjectStore() {
         nextCounter += 1;
         return id;
     }
+    function indexAdd(instanceId, position) {
+        const key = cellKeyOf(position);
+        let bucket = cellIndex.get(key);
+        if (bucket === undefined) {
+            bucket = new Set();
+            cellIndex.set(key, bucket);
+        }
+        bucket.add(instanceId);
+    }
+    function indexRemove(instanceId, position) {
+        const key = cellKeyOf(position);
+        const bucket = cellIndex.get(key);
+        if (bucket === undefined)
+            return;
+        bucket.delete(instanceId);
+        if (bucket.size === 0)
+            cellIndex.delete(key);
+    }
     return {
         place(catalogId, x, y, z, options = {}) {
             if (options.instanceId !== undefined && store.has(options.instanceId)) {
                 throw new Error(`Scene object id "${options.instanceId}" is already placed.`);
             }
             const instanceId = options.instanceId ?? generateId();
+            const position = [x, y, z];
             store.set(instanceId, {
                 instanceId,
                 catalogId,
-                position: [x, y, z],
+                position,
                 rotationY: options.rotation ?? 0,
                 ...(options.parentSpace !== undefined ? { parentSpace: options.parentSpace } : {}),
+                ...(options.visual !== undefined ? { visual: options.visual } : {}),
             });
+            indexAdd(instanceId, position);
             return instanceId;
         },
         remove(instanceId) {
-            const existed = store.has(instanceId);
+            const current = store.get(instanceId);
+            if (!current)
+                return false;
             store.delete(instanceId);
-            return existed;
+            indexRemove(instanceId, current.position);
+            return true;
         },
         move(instanceId, x, y, z) {
             const current = store.get(instanceId);
             if (!current)
                 return false;
-            store.set(instanceId, { ...current, position: [x, y, z] });
+            const position = [x, y, z];
+            store.set(instanceId, { ...current, position });
+            indexRemove(instanceId, current.position);
+            indexAdd(instanceId, position);
             return true;
         },
         rotate(instanceId, rotationY) {
@@ -45,6 +83,20 @@ export function createObjectStore() {
             store.set(instanceId, { ...current, rotationY });
             return true;
         },
+        setVisual(instanceId, visual) {
+            const current = store.get(instanceId);
+            if (!current)
+                return false;
+            store.set(instanceId, {
+                instanceId: current.instanceId,
+                catalogId: current.catalogId,
+                position: current.position,
+                rotationY: current.rotationY,
+                ...(current.parentSpace !== undefined ? { parentSpace: current.parentSpace } : {}),
+                ...(visual !== undefined ? { visual } : {}),
+            });
+            return true;
+        },
         get(instanceId) {
             return store.get(instanceId) ?? null;
         },
@@ -54,10 +106,57 @@ export function createObjectStore() {
                 return all;
             return all.filter((object) => object.parentSpace === filter.parentSpace);
         },
+        at(x, y, z, tolerance = 0) {
+            const minCx = cellIndexOf(x - tolerance);
+            const maxCx = cellIndexOf(x + tolerance);
+            const minCy = cellIndexOf(y - tolerance);
+            const maxCy = cellIndexOf(y + tolerance);
+            const minCz = cellIndexOf(z - tolerance);
+            const maxCz = cellIndexOf(z + tolerance);
+            const results = [];
+            for (let cx = minCx; cx <= maxCx; cx += 1) {
+                for (let cy = minCy; cy <= maxCy; cy += 1) {
+                    for (let cz = minCz; cz <= maxCz; cz += 1) {
+                        const bucket = cellIndex.get(cellKey(cx, cy, cz));
+                        if (bucket === undefined)
+                            continue;
+                        for (const instanceId of bucket) {
+                            const object = store.get(instanceId);
+                            if (object === undefined)
+                                continue;
+                            const dx = object.position[0] - x;
+                            const dy = object.position[1] - y;
+                            const dz = object.position[2] - z;
+                            if (Math.hypot(dx, dy, dz) <= tolerance)
+                                results.push(object);
+                        }
+                    }
+                }
+            }
+            return results;
+        },
+        inBox(min, max) {
+            const hits = [];
+            for (const bucket of cellIndex.values()) {
+                for (const instanceId of bucket) {
+                    const object = store.get(instanceId);
+                    if (object === undefined)
+                        continue;
+                    const [x, y, z] = object.position;
+                    if (x >= min[0] && x <= max[0] &&
+                        y >= min[1] && y <= max[1] &&
+                        z >= min[2] && z <= max[2]) {
+                        hits.push(object);
+                    }
+                }
+            }
+            return hits;
+        },
         clear() {
             for (const object of store.arraySnapshot()) {
                 store.delete(object.instanceId);
             }
+            cellIndex.clear();
         },
         subscribe(listener) {
             return store.subscribe(listener);
@@ -67,3 +166,9 @@ export function createObjectStore() {
         },
     };
 }
+export function objectVisualScale(visual) {
+    const scale = visual?.scale;
+    if (scale === undefined)
+        return [1, 1, 1];
+    return typeof scale === "number" ? [scale, scale, scale] : scale;
+}

package/dist/scene/paintLayer.d.ts

@@ -0,0 +1,15 @@
+export interface PaintStroke {
+    u: number;
+    v: number;
+    radius: number;
+    color: string;
+}
+export interface PaintLayer {
+    paint(instanceId: string, stroke: PaintStroke): void;
+    strokes(instanceId: string): readonly PaintStroke[];
+    paintedIds(): readonly string[];
+    clear(instanceId?: string): void;
+    version(instanceId: string): number;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createPaintLayer(): PaintLayer;

package/dist/scene/paintLayer.js

@@ -0,0 +1,53 @@
+export function createPaintLayer() {
+    const strokesByInstance = new Map();
+    const versionByInstance = new Map();
+    const listeners = new Set();
+    function bumpVersion(instanceId) {
+        versionByInstance.set(instanceId, (versionByInstance.get(instanceId) ?? 0) + 1);
+    }
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    return {
+        paint(instanceId, stroke) {
+            const list = strokesByInstance.get(instanceId);
+            if (list === undefined)
+                strokesByInstance.set(instanceId, [stroke]);
+            else
+                list.push(stroke);
+            bumpVersion(instanceId);
+            notify();
+        },
+        strokes(instanceId) {
+            return strokesByInstance.get(instanceId) ?? [];
+        },
+        paintedIds() {
+            return Array.from(strokesByInstance.keys());
+        },
+        clear(instanceId) {
+            if (instanceId === undefined) {
+                if (strokesByInstance.size === 0)
+                    return;
+                for (const id of strokesByInstance.keys())
+                    bumpVersion(id);
+                strokesByInstance.clear();
+                notify();
+                return;
+            }
+            if (!strokesByInstance.delete(instanceId))
+                return;
+            bumpVersion(instanceId);
+            notify();
+        },
+        version(instanceId) {
+            return versionByInstance.get(instanceId) ?? 0;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/scene/spatial.d.ts

@@ -18,10 +18,22 @@ export interface MoveTowardOptions {
     stopDistance?: number;
     dt: number;
 }
+export interface SpatialGridOptions {
+    /** Cell edge over the x/z plane; tune to ≈ the typical query radius so a query touches a handful of cells. */
+    cellSize: number;
+}
 export interface SpatialApiOptions {
     resolvePosition: (instanceId: string) => EntityPosition | undefined;
     candidates: () => string[];
     occluder?: (from: EntityPosition, to: EntityPosition) => boolean;
+    /**
+     * Opt-in broadphase acceleration for `inRadius`/`queryArc` over large candidate sets. When set,
+     * a uniform x/z cell index is built lazily from `candidates()` + `resolvePosition()` on first use
+     * and reused across calls until `invalidate()` is called — so many queries against one tick's
+     * frozen positions pay for one rebuild, not one linear scan each. Results are exactly the linear
+     * scan's results (same filtering; see `SpatialApi.invalidate` for the staleness contract).
+     */
+    grid?: SpatialGridOptions;
 }
 export interface SpatialApi {
     distance(aInstanceId: string, bInstanceId: string): number | null;
@@ -29,6 +41,15 @@ export interface SpatialApi {
     hasLineOfSight(fromInstanceId: string, toInstanceId: string): boolean;
     queryArc(options: QueryArcOptions): string[];
     moveToward(instanceId: string, target: EntityPosition | string, options: MoveTowardOptions): EntityPosition | null;
+    /**
+     * Marks the `grid` broadphase index stale so the next `inRadius`/`queryArc` call rebuilds it from
+     * `candidates()` and `resolvePosition()`. Call this after moving, spawning, or despawning a
+     * candidate; a candidate absent from the index at query time is never skipped (it falls back to
+     * an exact check), but a candidate that *moved* since the last rebuild can be missed until you
+     * invalidate — so treat "invalidate after any position change" as the contract, not an
+     * optimization. A no-op when no `grid` config was supplied. Safe to call every tick.
+     */
+    invalidate(): void;
 }
 export declare function distanceBetween(a: EntityPosition, b: EntityPosition): number;
 export declare function createSpatialApi(options: SpatialApiOptions): SpatialApi;

package/dist/scene/spatial.js

@@ -14,11 +14,62 @@ function forwardXZ(aim) {
     }
     return [Math.sin(aim.yaw), Math.cos(aim.yaw)];
 }
+function cellCoord(value, cellSize) {
+    return Math.floor(value / cellSize);
+}
+function gridCellKey(cx, cz) {
+    return `${cx}:${cz}`;
+}
 export function createSpatialApi(options) {
-    const { resolvePosition, candidates, occluder } = options;
+    const { resolvePosition, candidates, occluder, grid } = options;
+    const cellSize = grid?.cellSize;
+    let gridIndex = null;
+    let gridDirty = true;
     function resolveTarget(target) {
         return typeof target === "string" ? resolvePosition(target) : target;
     }
+    function ensureGrid() {
+        if (cellSize === undefined)
+            return null;
+        if (!gridDirty && gridIndex !== null)
+            return gridIndex;
+        const cells = new Map();
+        const indexed = new Set();
+        for (const instanceId of candidates()) {
+            const position = resolvePosition(instanceId);
+            if (position === undefined)
+                continue;
+            indexed.add(instanceId);
+            const key = gridCellKey(cellCoord(position[0], cellSize), cellCoord(position[2], cellSize));
+            let bucket = cells.get(key);
+            if (bucket === undefined) {
+                bucket = [];
+                cells.set(key, bucket);
+            }
+            bucket.push(instanceId);
+        }
+        gridIndex = { cells, indexed };
+        gridDirty = false;
+        return gridIndex;
+    }
+    function inRangeSet(index, centerX, centerZ, radius) {
+        const size = cellSize;
+        const cxMin = cellCoord(centerX - radius, size);
+        const cxMax = cellCoord(centerX + radius, size);
+        const czMin = cellCoord(centerZ - radius, size);
+        const czMax = cellCoord(centerZ + radius, size);
+        const near = new Set();
+        for (let cz = czMin; cz <= czMax; cz += 1) {
+            for (let cx = cxMin; cx <= cxMax; cx += 1) {
+                const bucket = index.cells.get(gridCellKey(cx, cz));
+                if (bucket === undefined)
+                    continue;
+                for (const id of bucket)
+                    near.add(id);
+            }
+        }
+        return near;
+    }
     return {
         distance(aInstanceId, bInstanceId) {
             const a = resolvePosition(aInstanceId);
@@ -32,11 +83,15 @@ export function createSpatialApi(options) {
             const centerPosition = resolveTarget(center);
             if (centerPosition === undefined)
                 return [];
+            const index = ensureGrid();
+            const near = index === null ? null : inRangeSet(index, centerPosition[0], centerPosition[2], radius);
             return candidates().filter((instanceId) => {
                 if (instanceId === centerId)
                     return false;
                 if (filter !== undefined && !filter(instanceId))
                     return false;
+                if (near !== null && index.indexed.has(instanceId) && !near.has(instanceId))
+                    return false;
                 const position = resolvePosition(instanceId);
                 return position !== undefined && distanceBetween(centerPosition, position) <= radius;
             });
@@ -58,9 +113,13 @@ export function createSpatialApi(options) {
             if (forward === null)
                 return [];
             const minDot = Math.cos((halfAngleDeg * Math.PI) / 180);
+            const index = ensureGrid();
+            const near = index === null ? null : inRangeSet(index, origin[0], origin[2], radius);
             return candidates().filter((instanceId) => {
                 if (instanceId === from)
                     return false;
+                if (near !== null && index.indexed.has(instanceId) && !near.has(instanceId))
+                    return false;
                 const position = resolvePosition(instanceId);
                 if (position === undefined)
                     return false;
@@ -75,6 +134,9 @@ export function createSpatialApi(options) {
                 return dot >= minDot;
             });
         },
+        invalidate() {
+            gridDirty = true;
+        },
         moveToward(instanceId, target, { speed, stopDistance = 0, dt }) {
             const current = resolvePosition(instanceId);
             const destination = resolveTarget(target);

package/dist/sensor/concealment.d.ts

@@ -0,0 +1,21 @@
+export type ColorHex = string;
+export declare function colorDistance(a: ColorHex, b: ColorHex): number;
+export declare function concealmentScore(entityColors: readonly ColorHex[], backgroundColors: readonly ColorHex[]): number;
+export interface ConcealmentTarget {
+    id: string;
+    entityColors: readonly ColorHex[];
+    backgroundColors: readonly ColorHex[];
+}
+export interface ConcealmentSample {
+    id: string;
+    score: number;
+    concealed: boolean;
+    dwellSeconds: number;
+}
+export interface ConcealmentSensor {
+    tick(targets: readonly ConcealmentTarget[], dt: number): ConcealmentSample[];
+    reset(id?: string): void;
+}
+export declare function createConcealmentSensor(config?: {
+    threshold?: number;
+}): ConcealmentSensor;

package/dist/sensor/concealment.js

@@ -0,0 +1,63 @@
+function parseHex(hex) {
+    const match = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim());
+    if (match === null)
+        return [0, 0, 0];
+    const value = parseInt(match[1], 16);
+    return [(value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff];
+}
+function redmean(a, b) {
+    const rmean = (a[0] + b[0]) / 2;
+    const dr = a[0] - b[0];
+    const dg = a[1] - b[1];
+    const db = a[2] - b[2];
+    return Math.sqrt((2 + rmean / 256) * dr * dr + 4 * dg * dg + (2 + (255 - rmean) / 256) * db * db);
+}
+const REDMEAN_MAX = redmean([0, 0, 0], [255, 255, 255]);
+export function colorDistance(a, b) {
+    const distance = redmean(parseHex(a), parseHex(b));
+    return REDMEAN_MAX === 0 ? 0 : Math.min(1, distance / REDMEAN_MAX);
+}
+export function concealmentScore(entityColors, backgroundColors) {
+    if (entityColors.length === 0 || backgroundColors.length === 0)
+        return 0;
+    let total = 0;
+    for (const entityColor of entityColors) {
+        let nearest = Number.POSITIVE_INFINITY;
+        for (const backgroundColor of backgroundColors) {
+            const distance = colorDistance(entityColor, backgroundColor);
+            if (distance < nearest)
+                nearest = distance;
+        }
+        total += nearest;
+    }
+    return 1 - total / entityColors.length;
+}
+export function createConcealmentSensor(config) {
+    const threshold = config?.threshold ?? 0.7;
+    const dwell = new Map();
+    return {
+        tick(targets, dt) {
+            const seen = new Set();
+            const samples = [];
+            for (const target of targets) {
+                seen.add(target.id);
+                const score = concealmentScore(target.entityColors, target.backgroundColors);
+                const concealed = score >= threshold;
+                const nextDwell = concealed ? (dwell.get(target.id) ?? 0) + dt : 0;
+                dwell.set(target.id, nextDwell);
+                samples.push({ id: target.id, score, concealed, dwellSeconds: nextDwell });
+            }
+            for (const id of dwell.keys()) {
+                if (!seen.has(id))
+                    dwell.delete(id);
+            }
+            return samples;
+        },
+        reset(id) {
+            if (id === undefined)
+                dwell.clear();
+            else
+                dwell.delete(id);
+        },
+    };
+}

package/dist/sensor/freezeMonitor.d.ts

@@ -0,0 +1,17 @@
+export interface FreezeSubject {
+    id: string;
+    groundSpeed: number;
+}
+export interface FreezeViolation {
+    id: string;
+    speed: number;
+    movedSeconds: number;
+}
+export interface FreezeMonitor {
+    tick(subjects: readonly FreezeSubject[], frozenIds: ReadonlySet<string>, dt: number): FreezeViolation[];
+    reset(id?: string): void;
+}
+export declare function createFreezeMonitor(config?: {
+    toleranceSpeed?: number;
+    graceSeconds?: number;
+}): FreezeMonitor;

package/dist/sensor/freezeMonitor.js

@@ -0,0 +1,35 @@
+export function createFreezeMonitor(config) {
+    const toleranceSpeed = config?.toleranceSpeed ?? 0.05;
+    const graceSeconds = config?.graceSeconds ?? 0;
+    const moved = new Map();
+    return {
+        tick(subjects, frozenIds, dt) {
+            const seen = new Set();
+            const violations = [];
+            for (const subject of subjects) {
+                seen.add(subject.id);
+                const shouldHoldStill = frozenIds.has(subject.id) && subject.groundSpeed > toleranceSpeed;
+                if (!shouldHoldStill) {
+                    moved.delete(subject.id);
+                    continue;
+                }
+                const movedSeconds = (moved.get(subject.id) ?? 0) + dt;
+                moved.set(subject.id, movedSeconds);
+                if (movedSeconds > graceSeconds) {
+                    violations.push({ id: subject.id, speed: subject.groundSpeed, movedSeconds });
+                }
+            }
+            for (const id of moved.keys()) {
+                if (!seen.has(id))
+                    moved.delete(id);
+            }
+            return violations;
+        },
+        reset(id) {
+            if (id === undefined)
+                moved.clear();
+            else
+                moved.delete(id);
+        },
+    };
+}

package/dist/session/roles.d.ts

@@ -0,0 +1,6 @@
+export interface RoleSpec {
+    id: string;
+    count?: number;
+    ratio?: number;
+}
+export declare function assignRoles(userIds: readonly string[], roles: readonly RoleSpec[], rng?: () => number): Record<string, string>;

package/dist/session/roles.js

@@ -0,0 +1,32 @@
+import { shuffleWithRng } from "../cards/cardPile.js";
+export function assignRoles(userIds, roles, rng = Math.random) {
+    if (roles.length === 0)
+        throw new Error("assignRoles needs at least one role");
+    const shuffled = shuffleWithRng(userIds, rng);
+    const assignment = {};
+    let index = 0;
+    const countRoles = roles.filter((role) => role.count !== undefined);
+    const ratioRoles = roles.filter((role) => role.count === undefined && role.ratio !== undefined);
+    const fillRole = roles.find((role) => role.count === undefined && role.ratio === undefined);
+    const fallbackRole = fillRole ?? roles[roles.length - 1];
+    for (const role of countRoles) {
+        const take = Math.max(0, Math.min(role.count, shuffled.length - index));
+        for (let i = 0; i < take; i += 1) {
+            assignment[shuffled[index]] = role.id;
+            index += 1;
+        }
+    }
+    for (const role of ratioRoles) {
+        const wanted = Math.round(role.ratio * shuffled.length);
+        const take = Math.max(0, Math.min(wanted, shuffled.length - index));
+        for (let i = 0; i < take; i += 1) {
+            assignment[shuffled[index]] = role.id;
+            index += 1;
+        }
+    }
+    while (index < shuffled.length) {
+        assignment[shuffled[index]] = fallbackRole.id;
+        index += 1;
+    }
+    return assignment;
+}

package/dist/session/roundState.d.ts

@@ -1,4 +1,5 @@
-export type RoundPhase = "buy" | "live" | "end";
+export type RoundPhase = string;
+/** Default phase-duration shape for the built-in buy/live/end cycle; pass a wider `Record<string, number>` when using a custom `phaseOrder`. */
 export interface RoundPhaseDurations {
     buy: number;
     live: number;
@@ -9,9 +10,24 @@ export interface LossBonusRule {
     step: number;
     max: number;
 }
-export interface RoundConfig {
-    phases: RoundPhaseDurations;
-    teams: readonly string[];
+/** A team entry with an optional role tag (e.g. "attacker", "defender") retrievable via `RoundState.roleOf`. */
+export interface RoundTeam {
+    id: string;
+    role?: string;
+}
+export interface RoundConfig<TPhase extends string = RoundPhase> {
+    /** Duration in seconds for each phase name in `phaseOrder` (or the default `RoundPhaseDurations` shape). */
+    phases: Record<TPhase, number>;
+    teams: readonly string[] | readonly RoundTeam[];
+    /**
+     * Overrides the default `["buy", "live", "end"]` cycle. Phases other than the first and last are
+     * "conclude-eligible": `concludeRound`/`evaluate` may settle the round only while the current phase
+     * is neither the first nor the last entry, matching the original buy (no conclude) / live (conclude) /
+     * end (no conclude, settles the round) roles. The cycle wraps from the last entry back to the first.
+     */
+    phaseOrder?: readonly TPhase[];
+    /** Evaluated by `evaluate()`; returning a team id concludes the round with that team as winner. */
+    winCondition?: (state: RoundSnapshot<TPhase>) => string | null;
     maxRounds?: number;
     winReward?: number;
     lossBonus?: LossBonusRule;
@@ -23,33 +39,41 @@ export interface RoundEconomy {
     won: boolean;
     lossStreak: number;
 }
-export interface RoundEvent {
+export interface RoundEvent<TPhase extends string = RoundPhase> {
     kind: RoundEventKind;
     round: number;
-    phase?: RoundPhase;
-    nextPhase?: RoundPhase;
+    phase?: TPhase;
+    nextPhase?: TPhase;
     winner?: string;
     economy?: RoundEconomy[];
 }
-export type PhaseEndHook = (endingPhase: RoundPhase, nextPhase: RoundPhase, round: number) => void;
-export interface RoundSnapshot {
+export type PhaseEndHook<TPhase extends string = RoundPhase> = (endingPhase: TPhase, nextPhase: TPhase, round: number) => void;
+export interface RoundSnapshot<TPhase extends string = RoundPhase> {
     round: number;
-    phase: RoundPhase;
+    phase: TPhase;
     timeLeft: number;
     scores: Record<string, number>;
     lossStreaks: Record<string, number>;
+    roles: Record<string, string | undefined>;
     matchOver: boolean;
 }
-export interface RoundState {
-    tick(dt: number): RoundEvent[];
-    concludeRound(winner: string): RoundEvent[];
-    onPhaseEnd(hook: PhaseEndHook): () => void;
-    phase(): RoundPhase;
+export interface RoundState<TPhase extends string = RoundPhase> {
+    tick(dt: number): RoundEvent<TPhase>[];
+    concludeRound(winner: string): RoundEvent<TPhase>[];
+    /** Calls `RoundConfig.winCondition` (a no-op when absent) and concludes the round if it returns a team id. */
+    evaluate(): RoundEvent<TPhase>[];
+    onPhaseEnd(hook: PhaseEndHook<TPhase>): () => void;
+    phase(): TPhase;
     round(): number;
     timeLeft(): number;
     score(team: string): number;
     economyFor(team: string): RoundEconomy;
-    snapshot(): RoundSnapshot;
+    /** The role tag configured for `team`, if any. */
+    roleOf(team: string): string | undefined;
+    snapshot(): RoundSnapshot<TPhase>;
 }
 export declare function lossBonusFor(rule: LossBonusRule | undefined, streak: number): number;
-export declare function createRoundState(config: RoundConfig): RoundState;
+export declare function createRoundState(config: RoundConfig<RoundPhase>): RoundState<RoundPhase>;
+export declare function createRoundState<TPhase extends string>(config: RoundConfig<TPhase> & {
+    phaseOrder: readonly TPhase[];
+}): RoundState<TPhase>;