@jgengine/core 0.6.0 → 0.8.0

package/dist/sensor/recordingBuffer.js

@@ -0,0 +1,61 @@
+function evict(frames, options) {
+    if (options.maxDurationSeconds !== undefined && frames.length > 0) {
+        const cutoff = frames[frames.length - 1].t - options.maxDurationSeconds;
+        let dropTo = 0;
+        while (dropTo < frames.length && frames[dropTo].t < cutoff)
+            dropTo += 1;
+        if (dropTo > 0)
+            frames.splice(0, dropTo);
+    }
+    if (options.maxFrames !== undefined && frames.length > options.maxFrames) {
+        frames.splice(0, frames.length - options.maxFrames);
+    }
+}
+/**
+ * A session-recording buffer for replay / photo mode / kill-cam: append
+ * timestamped snapshots (poses, camera state, whatever `T` is) on game-time,
+ * then seek/scrub the recording independent of the live sim. Frames are
+ * expected in non-decreasing `t` order (one push per tick); `seek`/`range`
+ * binary-search on that assumption.
+ */
+export function createRecordingBuffer(options = {}) {
+    const frames = [];
+    function floorIndex(t) {
+        let lo = 0;
+        let hi = frames.length - 1;
+        let result = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (frames[mid].t <= t) {
+                result = mid;
+                lo = mid + 1;
+            }
+            else {
+                hi = mid - 1;
+            }
+        }
+        return result;
+    }
+    return {
+        append(t, data) {
+            frames.push({ t, data });
+            evict(frames, options);
+        },
+        seek(t) {
+            const index = floorIndex(t);
+            return index === -1 ? null : frames[index];
+        },
+        range(fromT, toT) {
+            return frames.filter((frame) => frame.t >= fromT && frame.t <= toT);
+        },
+        clear() {
+            frames.length = 0;
+        },
+        duration() {
+            return frames.length === 0 ? 0 : frames[frames.length - 1].t - frames[0].t;
+        },
+        frames() {
+            return frames;
+        },
+    };
+}

package/dist/sensor/revealQuery.d.ts

@@ -0,0 +1,22 @@
+import type { EntityPosition } from "../scene/entityStore.js";
+export interface RevealHit {
+    instanceId: string;
+    distance: number;
+    tags: readonly string[];
+}
+export interface RevealQueryOptions {
+    resolvePosition: (instanceId: string) => EntityPosition | undefined;
+    resolveTags: (instanceId: string) => readonly string[];
+    candidates: () => string[];
+}
+export interface RevealQuery {
+    inRadius(center: EntityPosition | string, radius: number, tags: readonly string[]): RevealHit[];
+}
+/**
+ * `inRadius` already ignores occlusion; combat's AoE resolution is what layers a
+ * line-of-sight filter on top of it (see `effect({ at, radius, los })`). This is
+ * the same unfiltered radius query, scoped to catalog-declared tags and shaped
+ * for a vision readout (Dark Sight / detective-vision reveal) instead of damage
+ * resolution — it never consults an occluder, by design.
+ */
+export declare function createRevealQuery(options: RevealQueryOptions): RevealQuery;

package/dist/sensor/revealQuery.js

@@ -0,0 +1,36 @@
+import { distanceBetween } from "../scene/spatial.js";
+/**
+ * `inRadius` already ignores occlusion; combat's AoE resolution is what layers a
+ * line-of-sight filter on top of it (see `effect({ at, radius, los })`). This is
+ * the same unfiltered radius query, scoped to catalog-declared tags and shaped
+ * for a vision readout (Dark Sight / detective-vision reveal) instead of damage
+ * resolution — it never consults an occluder, by design.
+ */
+export function createRevealQuery(options) {
+    const { resolvePosition, resolveTags, candidates } = options;
+    return {
+        inRadius(center, radius, tags) {
+            const centerId = typeof center === "string" ? center : null;
+            const centerPosition = typeof center === "string" ? resolvePosition(center) : center;
+            if (centerPosition === undefined)
+                return [];
+            const hits = [];
+            for (const instanceId of candidates()) {
+                if (instanceId === centerId)
+                    continue;
+                const position = resolvePosition(instanceId);
+                if (position === undefined)
+                    continue;
+                const distance = distanceBetween(centerPosition, position);
+                if (distance > radius)
+                    continue;
+                const entityTags = resolveTags(instanceId);
+                if (tags.length > 0 && !tags.some((tag) => entityTags.includes(tag)))
+                    continue;
+                hits.push({ instanceId, distance, tags: entityTags });
+            }
+            hits.sort((a, b) => a.distance - b.distance);
+            return hits;
+        },
+    };
+}

package/dist/session/contestedChannel.d.ts

@@ -0,0 +1,36 @@
+export type ContestedPhase = "idle" | "active" | "paused" | "contested" | "complete" | "interrupted";
+export type ContestReaction = "pause" | "decay";
+export interface ContestedChannelConfig {
+    duration: number;
+    interruptOnDamage?: boolean;
+    resetOnInterrupt?: boolean;
+    favorability?: Record<string, number>;
+    ratePerOccupant?: boolean;
+    contested?: ContestReaction;
+    decayRate?: number;
+}
+export type ContestedEventKind = "start" | "tick" | "contested" | "paused" | "complete" | "interrupted";
+export interface ContestedEvent {
+    kind: ContestedEventKind;
+    owner: string | null;
+    progress: number;
+    reason?: string;
+}
+export interface ContestedSnapshot {
+    phase: ContestedPhase;
+    progress: number;
+    owner: string | null;
+    remaining: number;
+}
+export interface ContestedChannel {
+    start(team: string): ContestedEvent | null;
+    tick(dt: number, occupants?: Record<string, number>): ContestedEvent[];
+    damage(reason?: string): ContestedEvent | null;
+    reset(): void;
+    progress(): number;
+    phase(): ContestedPhase;
+    owner(): string | null;
+    remaining(): number;
+    snapshot(): ContestedSnapshot;
+}
+export declare function createContestedChannel(config: ContestedChannelConfig): ContestedChannel;

package/dist/session/contestedChannel.js

@@ -0,0 +1,100 @@
+function occupantsOf(occupants, team) {
+    return occupants?.[team] ?? 0;
+}
+function anyContester(occupants, owner) {
+    if (occupants === undefined)
+        return false;
+    for (const [team, count] of Object.entries(occupants)) {
+        if (team !== owner && count > 0)
+            return true;
+    }
+    return false;
+}
+export function createContestedChannel(config) {
+    const duration = config.duration > 0 ? config.duration : Number.EPSILON;
+    const interruptOnDamage = config.interruptOnDamage ?? true;
+    const resetOnInterrupt = config.resetOnInterrupt ?? false;
+    const favorability = config.favorability ?? {};
+    const contested = config.contested ?? "pause";
+    const decayRate = config.decayRate !== undefined ? Math.abs(config.decayRate) : 1 / duration;
+    let phase = "idle";
+    let progress = 0;
+    let owner = null;
+    function fillRate(occupantCount) {
+        const multiplier = favorability[owner ?? ""] ?? 1;
+        const scale = config.ratePerOccupant ? Math.max(1, occupantCount) : 1;
+        return (multiplier * scale) / duration;
+    }
+    function snapshot() {
+        return { phase, progress, owner, remaining: Math.max(0, (1 - progress) * duration) };
+    }
+    function emit(kind, reason) {
+        const event = { kind, owner, progress };
+        if (reason !== undefined)
+            event.reason = reason;
+        return event;
+    }
+    return {
+        start(team) {
+            if (phase === "active" || phase === "contested" || phase === "paused")
+                return null;
+            owner = team;
+            progress = phase === "interrupted" && !resetOnInterrupt ? progress : 0;
+            phase = "active";
+            return emit("start");
+        },
+        tick(dt, occupants) {
+            if (dt <= 0)
+                return [];
+            if (phase !== "active" && phase !== "paused" && phase !== "contested")
+                return [];
+            if (owner === null)
+                return [];
+            const ownerCount = occupantsOf(occupants, owner);
+            if (occupants !== undefined && ownerCount <= 0) {
+                if (phase !== "paused") {
+                    phase = "paused";
+                    return [emit("paused", "owner-left")];
+                }
+                return [];
+            }
+            if (anyContester(occupants, owner)) {
+                if (contested === "pause") {
+                    const changed = phase !== "contested";
+                    phase = "contested";
+                    return changed ? [emit("contested")] : [];
+                }
+                progress = Math.max(0, progress - decayRate * dt);
+                phase = "contested";
+                return [emit("contested")];
+            }
+            phase = "active";
+            progress = Math.min(1, progress + fillRate(ownerCount) * dt);
+            if (progress >= 1) {
+                phase = "complete";
+                return [emit("tick"), emit("complete")];
+            }
+            return [emit("tick")];
+        },
+        damage(reason) {
+            if (phase !== "active" && phase !== "paused" && phase !== "contested")
+                return null;
+            if (!interruptOnDamage)
+                return null;
+            phase = "interrupted";
+            if (resetOnInterrupt)
+                progress = 0;
+            return emit("interrupted", reason ?? "damage");
+        },
+        reset() {
+            phase = "idle";
+            progress = 0;
+            owner = null;
+        },
+        progress: () => progress,
+        phase: () => phase,
+        owner: () => owner,
+        remaining: () => Math.max(0, (1 - progress) * duration),
+        snapshot,
+    };
+}

package/dist/session/extraction.d.ts

@@ -0,0 +1,54 @@
+import { type ConsolationPolicy, type ContainerSnapshot, type DeliveryEntry, type DeliveryQueue, type InsurancePolicy, type ItemStack } from "../inventory/storageTier.js";
+import { type ContestedChannel, type ContestedEvent } from "./contestedChannel.js";
+import type { RingPoint } from "./ring.js";
+export interface ExtractPoint {
+    id: string;
+    center: RingPoint;
+    radius: number;
+    holdSeconds: number;
+    favorability?: Record<string, number>;
+    interruptOnDamage?: boolean;
+}
+export interface RaidSessionConfig {
+    extracts: readonly ExtractPoint[];
+    insurance?: InsurancePolicy;
+    consolation?: ConsolationPolicy;
+}
+export type RaidStatus = "in-raid" | "extracting" | "extracted" | "dead";
+export interface ExtractionAttempt {
+    extractId: string;
+    channel: ContestedChannel;
+}
+export interface ExtractionResult {
+    userId: string;
+    extractId: string;
+    banked: readonly ItemStack[];
+}
+export interface DeathResult {
+    userId: string;
+    kept: readonly ItemStack[];
+    lost: readonly ItemStack[];
+    scheduled: DeliveryEntry | null;
+    consolationLoadoutId: string | null;
+}
+export interface RaidPlayerSnapshot {
+    status: RaidStatus;
+    extractId: string | null;
+    progress: number;
+    remaining: number;
+}
+export interface RaidSession {
+    beginExtract(userId: string, extractId: string, team?: string): ContestedEvent | null;
+    tickExtract(userId: string, dt: number, occupants?: Record<string, number>): ContestedEvent[];
+    damage(userId: string, reason?: string): ContestedEvent | null;
+    cancelExtract(userId: string): void;
+    resolveExtraction(userId: string, containers: readonly ContainerSnapshot[]): ExtractionResult;
+    resolveDeath(userId: string, containers: readonly ContainerSnapshot[], now: number, rng?: () => number): DeathResult;
+    claimDeliveries(now: number): readonly DeliveryEntry[];
+    pendingDeliveries(userId?: string): readonly DeliveryEntry[];
+    deliveries(): DeliveryQueue;
+    extractPoint(extractId: string): ExtractPoint | undefined;
+    status(userId: string): RaidStatus;
+    playerSnapshot(userId: string): RaidPlayerSnapshot;
+}
+export declare function createRaidSession(config: RaidSessionConfig): RaidSession;

package/dist/session/extraction.js

@@ -0,0 +1,108 @@
+import { createDeliveryQueue, insureLost, partitionOnDeath, resolveConsolation, } from "../inventory/storageTier.js";
+import { createContestedChannel, } from "./contestedChannel.js";
+function mergeAll(containers) {
+    const totals = new Map();
+    for (const container of containers) {
+        for (const stack of container.items) {
+            totals.set(stack.itemId, (totals.get(stack.itemId) ?? 0) + stack.count);
+        }
+    }
+    const out = [];
+    for (const [itemId, count] of totals)
+        if (count > 0)
+            out.push({ itemId, count });
+    return out;
+}
+export function createRaidSession(config) {
+    const points = new Map();
+    for (const point of config.extracts)
+        points.set(point.id, point);
+    const attempts = new Map();
+    const statuses = new Map();
+    const queue = createDeliveryQueue();
+    function statusOf(userId) {
+        return statuses.get(userId) ?? "in-raid";
+    }
+    return {
+        beginExtract(userId, extractId, team) {
+            const point = points.get(extractId);
+            if (point === undefined)
+                return null;
+            if (statusOf(userId) === "extracted" || statusOf(userId) === "dead")
+                return null;
+            const channel = createContestedChannel({
+                duration: point.holdSeconds,
+                interruptOnDamage: point.interruptOnDamage ?? true,
+                favorability: point.favorability,
+            });
+            const event = channel.start(team ?? userId);
+            attempts.set(userId, { extractId, channel });
+            statuses.set(userId, "extracting");
+            return event;
+        },
+        tickExtract(userId, dt, occupants) {
+            const attempt = attempts.get(userId);
+            if (attempt === undefined)
+                return [];
+            const events = attempt.channel.tick(dt, occupants);
+            if (attempt.channel.phase() === "complete")
+                statuses.set(userId, "extracted");
+            return events;
+        },
+        damage(userId, reason) {
+            const attempt = attempts.get(userId);
+            if (attempt === undefined)
+                return null;
+            const event = attempt.channel.damage(reason);
+            if (attempt.channel.phase() === "interrupted")
+                statuses.set(userId, "in-raid");
+            return event;
+        },
+        cancelExtract(userId) {
+            attempts.delete(userId);
+            if (statusOf(userId) === "extracting")
+                statuses.set(userId, "in-raid");
+        },
+        resolveExtraction(userId, containers) {
+            const attempt = attempts.get(userId);
+            const extractId = attempt?.extractId ?? "";
+            attempts.delete(userId);
+            statuses.set(userId, "extracted");
+            return { userId, extractId, banked: mergeAll(containers) };
+        },
+        resolveDeath(userId, containers, now, rng) {
+            attempts.delete(userId);
+            statuses.set(userId, "dead");
+            const partition = partitionOnDeath(containers);
+            let scheduled = null;
+            if (config.insurance !== undefined) {
+                const insured = insureLost(partition.lost, config.insurance, userId, now, rng);
+                if (insured !== null)
+                    scheduled = queue.schedule(insured);
+            }
+            const consolation = config.consolation !== undefined ? resolveConsolation(config.consolation, partition) : null;
+            return {
+                userId,
+                kept: partition.kept,
+                lost: partition.lost,
+                scheduled,
+                consolationLoadoutId: consolation?.loadoutId ?? null,
+            };
+        },
+        claimDeliveries: (now) => queue.claimDue(now),
+        pendingDeliveries: (userId) => queue.pending(userId),
+        deliveries: () => queue,
+        extractPoint: (extractId) => points.get(extractId),
+        status: statusOf,
+        playerSnapshot: (userId) => {
+            const attempt = attempts.get(userId);
+            const channel = attempt?.channel;
+            return {
+                status: statusOf(userId),
+                extractId: attempt?.extractId ?? null,
+                progress: channel?.progress() ?? 0,
+                remaining: channel?.remaining() ?? 0,
+            };
+        },
+    };
+}

package/dist/session/ring.d.ts

@@ -0,0 +1,36 @@
+export type RingPoint = [number, number];
+export interface RingPhase {
+    startTime: number;
+    shrinkDuration: number;
+    fromRadius: number;
+    toRadius: number;
+    damagePerSecond: number;
+    center?: RingPoint;
+}
+export interface RingConfig {
+    center: RingPoint;
+    phases: readonly RingPhase[];
+}
+export interface RingSample {
+    center: RingPoint;
+    radius: number;
+    damagePerSecond: number;
+    phase: number;
+    shrinking: boolean;
+}
+export interface RingHit {
+    id: string;
+    damage: number;
+    distanceOutside: number;
+}
+export interface Ring {
+    at(time: number): RingSample;
+    isOutside(time: number, position: RingPoint): boolean;
+    distanceOutside(time: number, position: RingPoint): number;
+    damageOutside(time: number, dt: number, positions: Iterable<{
+        id: string;
+        position: RingPoint;
+    }>): RingHit[];
+}
+export declare function ringSampleAt(config: RingConfig, time: number): RingSample;
+export declare function createRing(config: RingConfig): Ring;

package/dist/session/ring.js

@@ -0,0 +1,88 @@
+function lerp(from, to, t) {
+    return from + (to - from) * t;
+}
+function lerpPoint(from, to, t) {
+    return [lerp(from[0], to[0], t), lerp(from[1], to[1], t)];
+}
+function distance(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+export function ringSampleAt(config, time) {
+    const phases = config.phases;
+    if (phases.length === 0) {
+        return { center: config.center, radius: 0, damagePerSecond: 0, phase: -1, shrinking: false };
+    }
+    const first = phases[0];
+    if (time < first.startTime) {
+        return {
+            center: config.center,
+            radius: first.fromRadius,
+            damagePerSecond: 0,
+            phase: -1,
+            shrinking: false,
+        };
+    }
+    let index = 0;
+    for (let i = 0; i < phases.length; i += 1) {
+        if (time >= phases[i].startTime)
+            index = i;
+        else
+            break;
+    }
+    const phase = phases[index];
+    const prevCenter = index === 0 ? config.center : centerAfter(config, index - 1);
+    const target = phase.center ?? prevCenter;
+    const elapsed = time - phase.startTime;
+    if (elapsed < phase.shrinkDuration && phase.shrinkDuration > 0) {
+        const t = elapsed / phase.shrinkDuration;
+        return {
+            center: lerpPoint(prevCenter, target, t),
+            radius: lerp(phase.fromRadius, phase.toRadius, t),
+            damagePerSecond: phase.damagePerSecond,
+            phase: index,
+            shrinking: true,
+        };
+    }
+    return {
+        center: target,
+        radius: phase.toRadius,
+        damagePerSecond: phase.damagePerSecond,
+        phase: index,
+        shrinking: false,
+    };
+}
+function centerAfter(config, index) {
+    let center = config.center;
+    for (let i = 0; i <= index; i += 1) {
+        const phase = config.phases[i];
+        if (phase.center !== undefined)
+            center = phase.center;
+    }
+    return center;
+}
+export function createRing(config) {
+    return {
+        at: (time) => ringSampleAt(config, time),
+        isOutside: (time, position) => {
+            const sample = ringSampleAt(config, time);
+            return distance(position, sample.center) > sample.radius;
+        },
+        distanceOutside: (time, position) => {
+            const sample = ringSampleAt(config, time);
+            return Math.max(0, distance(position, sample.center) - sample.radius);
+        },
+        damageOutside: (time, dt, positions) => {
+            const sample = ringSampleAt(config, time);
+            const hits = [];
+            if (dt <= 0 || sample.damagePerSecond <= 0)
+                return hits;
+            for (const { id, position } of positions) {
+                const distanceOutside = distance(position, sample.center) - sample.radius;
+                if (distanceOutside > 0) {
+                    hits.push({ id, damage: sample.damagePerSecond * dt, distanceOutside });
+                }
+            }
+            return hits;
+        },
+    };
+}

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

@@ -0,0 +1,79 @@
+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;
+    end: number;
+}
+export interface LossBonusRule {
+    base: number;
+    step: number;
+    max: number;
+}
+/** 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;
+}
+export type RoundEventKind = "phase.start" | "phase.end" | "round.win" | "round.economy" | "match.end";
+export interface RoundEconomy {
+    team: string;
+    reward: number;
+    won: boolean;
+    lossStreak: number;
+}
+export interface RoundEvent<TPhase extends string = RoundPhase> {
+    kind: RoundEventKind;
+    round: number;
+    phase?: TPhase;
+    nextPhase?: TPhase;
+    winner?: string;
+    economy?: RoundEconomy[];
+}
+export type PhaseEndHook<TPhase extends string = RoundPhase> = (endingPhase: TPhase, nextPhase: TPhase, round: number) => void;
+export interface RoundSnapshot<TPhase extends string = RoundPhase> {
+    round: number;
+    phase: TPhase;
+    timeLeft: number;
+    scores: Record<string, number>;
+    lossStreaks: Record<string, number>;
+    roles: Record<string, string | undefined>;
+    matchOver: boolean;
+}
+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;
+    /** 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<RoundPhase>): RoundState<RoundPhase>;
+export declare function createRoundState<TPhase extends string>(config: RoundConfig<TPhase> & {
+    phaseOrder: readonly TPhase[];
+}): RoundState<TPhase>;