@jgengine/core 0.6.0 → 0.8.0

package/dist/board/timelineBoard.d.ts

@@ -0,0 +1,36 @@
+export interface TimelineSlotConfig {
+    id: string;
+    cooldownMs: number;
+    enabled?: boolean;
+    offsetMs?: number;
+}
+export interface TimelineSlot {
+    readonly id: string;
+    readonly cooldownMs: number;
+    readonly remainingMs: number;
+    readonly enabled: boolean;
+}
+export interface TimelineBoardState {
+    readonly slots: readonly TimelineSlot[];
+    readonly elapsedMs: number;
+}
+export interface TimelineFire {
+    slotId: string;
+    slotIndex: number;
+    atMs: number;
+}
+export interface TimelineTickResult {
+    state: TimelineBoardState;
+    fires: readonly TimelineFire[];
+}
+export declare function createTimelineBoardState(slots: readonly TimelineSlotConfig[]): TimelineBoardState;
+export declare function tickTimeline(state: TimelineBoardState, dtMs: number): TimelineTickResult;
+export declare function setSlotEnabled(state: TimelineBoardState, slotId: string, enabled: boolean): TimelineBoardState;
+export declare function resetSlot(state: TimelineBoardState, slotId: string, remainingMs?: number): TimelineBoardState;
+export interface TimelineBoard {
+    state(): TimelineBoardState;
+    tick(dtMs: number): readonly TimelineFire[];
+    setEnabled(slotId: string, enabled: boolean): void;
+    reset(slotId?: string, remainingMs?: number): void;
+}
+export declare function createTimelineBoard(slots: readonly TimelineSlotConfig[]): TimelineBoard;

package/dist/board/timelineBoard.js

@@ -0,0 +1,70 @@
+export function createTimelineBoardState(slots) {
+    const seen = new Set();
+    const built = [];
+    for (const slot of slots) {
+        if (slot.cooldownMs <= 0)
+            throw new Error(`timeline slot "${slot.id}" needs a positive cooldown`);
+        if (seen.has(slot.id))
+            throw new Error(`duplicate timeline slot id: ${slot.id}`);
+        seen.add(slot.id);
+        built.push({
+            id: slot.id,
+            cooldownMs: slot.cooldownMs,
+            remainingMs: slot.offsetMs ?? slot.cooldownMs,
+            enabled: slot.enabled ?? true,
+        });
+    }
+    return { slots: built, elapsedMs: 0 };
+}
+export function tickTimeline(state, dtMs) {
+    if (dtMs <= 0)
+        return { state, fires: [] };
+    const fires = [];
+    const nextSlots = state.slots.map((slot, slotIndex) => {
+        if (!slot.enabled)
+            return slot;
+        let remaining = slot.remainingMs;
+        let t = remaining;
+        while (t <= dtMs) {
+            fires.push({ slotId: slot.id, slotIndex, atMs: state.elapsedMs + t });
+            t += slot.cooldownMs;
+        }
+        remaining = t - dtMs;
+        return { ...slot, remainingMs: remaining };
+    });
+    fires.sort((a, b) => (a.atMs === b.atMs ? a.slotIndex - b.slotIndex : a.atMs - b.atMs));
+    return {
+        state: { slots: nextSlots, elapsedMs: state.elapsedMs + dtMs },
+        fires,
+    };
+}
+export function setSlotEnabled(state, slotId, enabled) {
+    return {
+        ...state,
+        slots: state.slots.map((slot) => (slot.id === slotId ? { ...slot, enabled } : slot)),
+    };
+}
+export function resetSlot(state, slotId, remainingMs) {
+    return {
+        ...state,
+        slots: state.slots.map((slot) => slot.id === slotId ? { ...slot, remainingMs: remainingMs ?? slot.cooldownMs } : slot),
+    };
+}
+export function createTimelineBoard(slots) {
+    const initial = slots;
+    let state = createTimelineBoardState(slots);
+    return {
+        state: () => state,
+        tick(dtMs) {
+            const result = tickTimeline(state, dtMs);
+            state = result.state;
+            return result.fires;
+        },
+        setEnabled(slotId, enabled) {
+            state = setSlotEnabled(state, slotId, enabled);
+        },
+        reset(slotId, remainingMs) {
+            state = slotId === undefined ? createTimelineBoardState(initial) : resetSlot(state, slotId, remainingMs);
+        },
+    };
+}

package/dist/cards/cardPile.d.ts

@@ -0,0 +1,64 @@
+export type ZoneName = string;
+export interface CardPileConfig {
+    zones: readonly ZoneName[];
+    drawFrom?: ZoneName;
+    discardTo?: ZoneName;
+    handZone?: ZoneName;
+    handLimit?: number;
+    reshuffleFrom?: ZoneName;
+    onChange?: () => void;
+}
+export interface CardPileState {
+    readonly zones: Readonly<Record<ZoneName, readonly string[]>>;
+}
+export interface DrawResult {
+    state: CardPileState;
+    drawn: readonly string[];
+    reshuffled: boolean;
+}
+export type PileRejection = "unknown-zone" | "card-not-in-zone" | "hand-limit" | "empty-source";
+export interface PileMoveResult {
+    status: "ok";
+    state: CardPileState;
+}
+export interface PileMoveRejected {
+    status: "rejected";
+    reason: PileRejection;
+    detail?: string;
+}
+export type PileResult = PileMoveResult | PileMoveRejected;
+export declare function pileRng(seed: string | number): () => number;
+export declare function shuffleWithRng<T>(values: readonly T[], rng: () => number): T[];
+export declare function createCardPileState(config: CardPileConfig, initial?: Partial<Record<ZoneName, readonly string[]>>): CardPileState;
+export declare function zoneOf(state: CardPileState, cardId: string): ZoneName | null;
+export declare function countIn(state: CardPileState, zone: ZoneName): number;
+export declare function peek(state: CardPileState, zone: ZoneName, n?: number): readonly string[];
+export declare function shuffleZone(state: CardPileState, zone: ZoneName, seed: string | number): CardPileState;
+export declare function moveCards(state: CardPileState, ids: readonly string[], from: ZoneName, to: ZoneName, position?: "top" | "bottom"): PileResult;
+export declare function draw(state: CardPileState, n: number, options: {
+    from: ZoneName;
+    to: ZoneName;
+    handLimit?: number;
+    reshuffleFrom?: ZoneName;
+    seed?: string | number;
+}): DrawResult;
+export interface CardPile {
+    state(): CardPileState;
+    zones(): readonly ZoneName[];
+    count(zone: ZoneName): number;
+    peek(zone: ZoneName, n?: number): readonly string[];
+    zoneOf(cardId: string): ZoneName | null;
+    shuffle(zone: ZoneName | undefined, seed: string | number): void;
+    draw(n: number, options?: {
+        from?: ZoneName;
+        to?: ZoneName;
+    }): readonly string[];
+    discard(ids: readonly string[], options?: {
+        from?: ZoneName;
+        to?: ZoneName;
+    }): PileResult;
+    exhaust(ids: readonly string[], exhaustZone: ZoneName, from?: ZoneName): PileResult;
+    move(ids: readonly string[], from: ZoneName, to: ZoneName, position?: "top" | "bottom"): PileResult;
+    reset(next: CardPileState): void;
+}
+export declare function createCardPile(config: CardPileConfig, initial?: Partial<Record<ZoneName, readonly string[]>>): CardPile;

package/dist/cards/cardPile.js

@@ -0,0 +1,175 @@
+function fnv1a(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function pileRng(seed) {
+    let a = (typeof seed === "number" ? seed >>> 0 : fnv1a(seed)) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function shuffleWithRng(values, rng) {
+    const out = values.slice();
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = Math.floor(rng() * (i + 1));
+        const tmp = out[i];
+        out[i] = out[j];
+        out[j] = tmp;
+    }
+    return out;
+}
+function assertZone(state, zone) {
+    if (!(zone in state.zones))
+        throw new Error(`unknown card-pile zone: ${zone}`);
+}
+export function createCardPileState(config, initial) {
+    if (config.zones.length === 0)
+        throw new Error("card pile needs at least one zone");
+    const zones = {};
+    for (const zone of config.zones)
+        zones[zone] = (initial?.[zone] ?? []).slice();
+    const guard = (zone, label) => {
+        if (zone !== undefined && !(zone in zones)) {
+            throw new Error(`${label} names an undeclared zone: ${zone}`);
+        }
+    };
+    guard(config.drawFrom, "drawFrom");
+    guard(config.discardTo, "discardTo");
+    guard(config.handZone, "handZone");
+    guard(config.reshuffleFrom, "reshuffleFrom");
+    return { zones };
+}
+export function zoneOf(state, cardId) {
+    for (const [zone, cards] of Object.entries(state.zones)) {
+        if (cards.includes(cardId))
+            return zone;
+    }
+    return null;
+}
+export function countIn(state, zone) {
+    assertZone(state, zone);
+    return state.zones[zone].length;
+}
+export function peek(state, zone, n = 1) {
+    assertZone(state, zone);
+    return state.zones[zone].slice(0, Math.max(0, n));
+}
+export function shuffleZone(state, zone, seed) {
+    assertZone(state, zone);
+    return { zones: { ...state.zones, [zone]: shuffleWithRng(state.zones[zone], pileRng(seed)) } };
+}
+export function moveCards(state, ids, from, to, position = "top") {
+    assertZone(state, from);
+    assertZone(state, to);
+    const source = state.zones[from];
+    for (const id of ids) {
+        if (!source.includes(id))
+            return { status: "rejected", reason: "card-not-in-zone", detail: id };
+    }
+    const idSet = new Set(ids);
+    const nextFrom = source.filter((id) => !idSet.has(id));
+    const dest = state.zones[to];
+    const nextTo = position === "top" ? [...ids, ...dest] : [...dest, ...ids];
+    return { status: "ok", state: { zones: { ...state.zones, [from]: nextFrom, [to]: nextTo } } };
+}
+export function draw(state, n, options) {
+    assertZone(state, options.from);
+    assertZone(state, options.to);
+    if (options.reshuffleFrom !== undefined)
+        assertZone(state, options.reshuffleFrom);
+    let current = state;
+    let reshuffled = false;
+    const drawn = [];
+    const wanted = Math.max(0, Math.floor(n));
+    for (let i = 0; i < wanted; i++) {
+        if (options.handLimit !== undefined && current.zones[options.to].length >= options.handLimit) {
+            break;
+        }
+        if (current.zones[options.from].length === 0) {
+            if (options.reshuffleFrom === undefined || current.zones[options.reshuffleFrom].length === 0) {
+                break;
+            }
+            const seed = options.seed ?? drawn.length + i;
+            const shuffledSource = shuffleWithRng(current.zones[options.reshuffleFrom], pileRng(seed));
+            current = {
+                zones: { ...current.zones, [options.from]: shuffledSource, [options.reshuffleFrom]: [] },
+            };
+            reshuffled = true;
+        }
+        const source = current.zones[options.from];
+        const top = source[0];
+        drawn.push(top);
+        current = {
+            zones: {
+                ...current.zones,
+                [options.from]: source.slice(1),
+                [options.to]: [...current.zones[options.to], top],
+            },
+        };
+    }
+    return { state: current, drawn, reshuffled };
+}
+export function createCardPile(config, initial) {
+    let state = createCardPileState(config, initial);
+    const drawFrom = config.drawFrom ?? config.zones[0];
+    const handZone = config.handZone ?? config.zones[Math.min(1, config.zones.length - 1)];
+    const discardTo = config.discardTo ?? config.zones[config.zones.length - 1];
+    return {
+        state: () => state,
+        zones: () => config.zones,
+        count: (zone) => countIn(state, zone),
+        peek: (zone, n) => peek(state, zone, n),
+        zoneOf: (cardId) => zoneOf(state, cardId),
+        shuffle(zone, seed) {
+            state = shuffleZone(state, zone ?? drawFrom, seed);
+            config.onChange?.();
+        },
+        draw(n, options) {
+            const result = draw(state, n, {
+                from: options?.from ?? drawFrom,
+                to: options?.to ?? handZone,
+                handLimit: config.handLimit,
+                reshuffleFrom: config.reshuffleFrom,
+            });
+            state = result.state;
+            config.onChange?.();
+            return result.drawn;
+        },
+        discard(ids, options) {
+            const result = moveCards(state, ids, options?.from ?? handZone, options?.to ?? discardTo, "top");
+            if (result.status === "ok") {
+                state = result.state;
+                config.onChange?.();
+            }
+            return result;
+        },
+        exhaust(ids, exhaustZone, from) {
+            const result = moveCards(state, ids, from ?? handZone, exhaustZone, "top");
+            if (result.status === "ok") {
+                state = result.state;
+                config.onChange?.();
+            }
+            return result;
+        },
+        move(ids, from, to, position) {
+            const result = moveCards(state, ids, from, to, position);
+            if (result.status === "ok") {
+                state = result.state;
+                config.onChange?.();
+            }
+            return result;
+        },
+        reset(next) {
+            state = next;
+            config.onChange?.();
+        },
+    };
+}

package/dist/cards/modifierPipeline.d.ts

@@ -0,0 +1,33 @@
+export interface Modifier<V> {
+    id: string;
+    source?: string;
+    apply: (value: V, context: PipelineContext<V>) => V;
+}
+export interface PipelineContext<V> {
+    base: V;
+    index: number;
+    trace: readonly TraceStep<V>[];
+}
+export interface TraceStep<V> {
+    id: string;
+    source?: string;
+    index: number;
+    before: V;
+    after: V;
+    changed: boolean;
+}
+export interface PipelineResult<V> {
+    base: V;
+    value: V;
+    trace: readonly TraceStep<V>[];
+}
+export declare function runPipeline<V>(base: V, modifiers: readonly Modifier<V>[], equals?: (a: V, b: V) => boolean): PipelineResult<V>;
+export interface ModifierPipeline<V> {
+    add(modifier: Modifier<V>): void;
+    insertAt(index: number, modifier: Modifier<V>): void;
+    remove(id: string): boolean;
+    clear(): void;
+    list(): readonly Modifier<V>[];
+    run(base: V): PipelineResult<V>;
+}
+export declare function createModifierPipeline<V>(initial?: readonly Modifier<V>[], equals?: (a: V, b: V) => boolean): ModifierPipeline<V>;

package/dist/cards/modifierPipeline.js

@@ -0,0 +1,48 @@
+export function runPipeline(base, modifiers, equals = Object.is) {
+    const trace = [];
+    let value = base;
+    let index = 0;
+    for (const modifier of modifiers) {
+        const before = value;
+        const after = modifier.apply(before, { base, index, trace });
+        trace.push({
+            id: modifier.id,
+            source: modifier.source,
+            index,
+            before,
+            after,
+            changed: !equals(before, after),
+        });
+        value = after;
+        index += 1;
+    }
+    return { base, value, trace };
+}
+export function createModifierPipeline(initial = [], equals = Object.is) {
+    const modifiers = initial.slice();
+    return {
+        add(modifier) {
+            modifiers.push(modifier);
+        },
+        insertAt(index, modifier) {
+            const clamped = Math.max(0, Math.min(modifiers.length, Math.floor(index)));
+            modifiers.splice(clamped, 0, modifier);
+        },
+        remove(id) {
+            const at = modifiers.findIndex((m) => m.id === id);
+            if (at === -1)
+                return false;
+            modifiers.splice(at, 1);
+            return true;
+        },
+        clear() {
+            modifiers.length = 0;
+        },
+        list() {
+            return modifiers.slice();
+        },
+        run(base) {
+            return runPipeline(base, modifiers, equals);
+        },
+    };
+}

package/dist/combat/abilityKit.d.ts

@@ -0,0 +1,47 @@
+export type AbilityCastType = "instant" | "projectile" | "channel" | "targeted";
+export type AbilitySlotState = "ready" | "cooldown" | "no-resource" | "just-cast";
+export interface AbilitySlotConfig {
+    id: string;
+    cooldownMs: number;
+    chargesMax?: number;
+    resourceCost?: number;
+    castType?: AbilityCastType;
+    flashMs?: number;
+}
+export interface AbilitySlotSnapshot {
+    id: string;
+    state: AbilitySlotState;
+    castType: AbilityCastType;
+    resourceCost: number;
+    charges: number;
+    chargesMax: number;
+    cooldownRemainingMs: number;
+    cooldownFraction: number;
+    justCast: boolean;
+    ready: boolean;
+}
+export type AbilityCastReason = "unknown-slot" | "cooldown" | "no-resource";
+export interface AbilitySlotRetune {
+    cooldownMs?: number;
+    resourceCost?: number;
+}
+export type AbilityCastResult = {
+    ok: true;
+    slot: AbilitySlotSnapshot;
+} | {
+    ok: false;
+    reason: AbilityCastReason;
+    slot: AbilitySlotSnapshot | null;
+};
+export interface AbilityKit {
+    slots(): readonly string[];
+    config(slotId: string): AbilitySlotConfig | null;
+    state(slotId: string, resourceAvailable?: number): AbilitySlotSnapshot | null;
+    snapshot(resourceAvailable?: number): AbilitySlotSnapshot[];
+    canCast(slotId: string, resourceAvailable?: number): AbilityCastResult;
+    cast(slotId: string, resourceAvailable?: number): AbilityCastResult;
+    tick(dtSeconds: number): void;
+    reset(slotId?: string): void;
+    retuneSlot(slotId: string, patch: AbilitySlotRetune): boolean;
+}
+export declare function createAbilityKit(configs: readonly AbilitySlotConfig[]): AbilityKit;

package/dist/combat/abilityKit.js

@@ -0,0 +1,139 @@
+const DEFAULT_FLASH_MS = 220;
+function normalizeConfig(config) {
+    return {
+        id: config.id,
+        cooldownMs: Math.max(0, config.cooldownMs),
+        chargesMax: Math.max(1, config.chargesMax ?? 1),
+        resourceCost: Math.max(0, config.resourceCost ?? 0),
+        castType: config.castType ?? "instant",
+        flashMs: Math.max(0, config.flashMs ?? DEFAULT_FLASH_MS),
+    };
+}
+function deriveState(runtime, resourceAvailable) {
+    if (runtime.flashRemainingMs > 0)
+        return "just-cast";
+    if (runtime.charges <= 0)
+        return "cooldown";
+    if (resourceAvailable < runtime.config.resourceCost)
+        return "no-resource";
+    return "ready";
+}
+function snapshotOf(runtime, resourceAvailable) {
+    const { config } = runtime;
+    const state = deriveState(runtime, resourceAvailable);
+    const cooldownFraction = config.cooldownMs <= 0 ? 0 : Math.max(0, Math.min(1, runtime.rechargeRemainingMs / config.cooldownMs));
+    return {
+        id: config.id,
+        state,
+        castType: config.castType,
+        resourceCost: config.resourceCost,
+        charges: runtime.charges,
+        chargesMax: config.chargesMax,
+        cooldownRemainingMs: runtime.rechargeRemainingMs,
+        cooldownFraction,
+        justCast: runtime.flashRemainingMs > 0,
+        ready: runtime.charges > 0 && resourceAvailable >= config.resourceCost,
+    };
+}
+export function createAbilityKit(configs) {
+    const runtimes = new Map();
+    const order = [];
+    for (const config of configs) {
+        const normalized = normalizeConfig(config);
+        if (runtimes.has(normalized.id))
+            throw new Error(`duplicate ability slot: ${normalized.id}`);
+        runtimes.set(normalized.id, {
+            config: normalized,
+            charges: normalized.chargesMax,
+            rechargeRemainingMs: 0,
+            flashRemainingMs: 0,
+        });
+        order.push(normalized.id);
+    }
+    function fail(slotId, reason, resourceAvailable) {
+        const runtime = runtimes.get(slotId);
+        return { ok: false, reason, slot: runtime ? snapshotOf(runtime, resourceAvailable) : null };
+    }
+    function evaluate(slotId, resourceAvailable) {
+        const runtime = runtimes.get(slotId);
+        if (runtime === undefined)
+            return fail(slotId, "unknown-slot", resourceAvailable);
+        if (runtime.charges <= 0)
+            return fail(slotId, "cooldown", resourceAvailable);
+        if (resourceAvailable < runtime.config.resourceCost)
+            return fail(slotId, "no-resource", resourceAvailable);
+        return { ok: true, slot: snapshotOf(runtime, resourceAvailable) };
+    }
+    return {
+        slots() {
+            return order.slice();
+        },
+        config(slotId) {
+            return runtimes.get(slotId)?.config ?? null;
+        },
+        state(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
+            const runtime = runtimes.get(slotId);
+            return runtime === undefined ? null : snapshotOf(runtime, resourceAvailable);
+        },
+        snapshot(resourceAvailable = Number.POSITIVE_INFINITY) {
+            return order.map((slotId) => snapshotOf(runtimes.get(slotId), resourceAvailable));
+        },
+        canCast(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
+            return evaluate(slotId, resourceAvailable);
+        },
+        cast(slotId, resourceAvailable = Number.POSITIVE_INFINITY) {
+            const result = evaluate(slotId, resourceAvailable);
+            if (!result.ok)
+                return result;
+            const runtime = runtimes.get(slotId);
+            runtime.charges -= 1;
+            if (runtime.rechargeRemainingMs <= 0)
+                runtime.rechargeRemainingMs = runtime.config.cooldownMs;
+            runtime.flashRemainingMs = runtime.config.flashMs;
+            return { ok: true, slot: snapshotOf(runtime, resourceAvailable) };
+        },
+        tick(dtSeconds) {
+            if (dtSeconds <= 0)
+                return;
+            const dtMs = dtSeconds * 1000;
+            for (const runtime of runtimes.values()) {
+                if (runtime.flashRemainingMs > 0)
+                    runtime.flashRemainingMs = Math.max(0, runtime.flashRemainingMs - dtMs);
+                if (runtime.charges >= runtime.config.chargesMax) {
+                    runtime.rechargeRemainingMs = 0;
+                    continue;
+                }
+                if (runtime.config.cooldownMs <= 0) {
+                    runtime.charges = runtime.config.chargesMax;
+                    runtime.rechargeRemainingMs = 0;
+                    continue;
+                }
+                let remaining = runtime.rechargeRemainingMs <= 0 ? runtime.config.cooldownMs : runtime.rechargeRemainingMs;
+                remaining -= dtMs;
+                while (remaining <= 0 && runtime.charges < runtime.config.chargesMax) {
+                    runtime.charges += 1;
+                    remaining += runtime.config.cooldownMs;
+                }
+                runtime.rechargeRemainingMs = runtime.charges >= runtime.config.chargesMax ? 0 : remaining;
+            }
+        },
+        reset(slotId) {
+            const targets = slotId === undefined ? runtimes.values() : [runtimes.get(slotId)].filter((r) => r !== undefined);
+            for (const runtime of targets) {
+                runtime.charges = runtime.config.chargesMax;
+                runtime.rechargeRemainingMs = 0;
+                runtime.flashRemainingMs = 0;
+            }
+        },
+        retuneSlot(slotId, patch) {
+            const runtime = runtimes.get(slotId);
+            if (runtime === undefined)
+                return false;
+            if (patch.cooldownMs !== undefined)
+                runtime.config.cooldownMs = Math.max(0, patch.cooldownMs);
+            if (patch.resourceCost !== undefined)
+                runtime.config.resourceCost = Math.max(0, patch.resourceCost);
+            return true;
+        },
+    };
+}

package/dist/combat/animationState.d.ts

@@ -0,0 +1,47 @@
+export type FramePhase = "windup" | "active" | "recovery" | "cancel";
+export interface FrameRange {
+    phase: FramePhase;
+    from: number;
+    to: number;
+}
+export interface AnimationClip {
+    id: string;
+    frames: number;
+    fps: number;
+    ranges: readonly FrameRange[];
+    loop?: boolean;
+}
+export interface AnimationSnapshot {
+    clipId: string;
+    frame: number;
+    elapsedMs: number;
+}
+export interface AnimationTickResult {
+    clipId: string | null;
+    frame: number;
+    entered: readonly FramePhase[];
+    exited: readonly FramePhase[];
+    completed: boolean;
+}
+export declare function clipDurationMs(clip: AnimationClip): number;
+export declare function frameAtMs(clip: AnimationClip, elapsedMs: number): number;
+export declare function phasesAtFrame(clip: AnimationClip, frame: number): FramePhase[];
+export declare function activeRangeAtFrame(clip: AnimationClip, frame: number): FrameRange | null;
+export interface AnimationState {
+    play(clipId: string): void;
+    stop(): void;
+    tick(dtSeconds: number): AnimationTickResult;
+    current(): AnimationSnapshot | null;
+    phases(): readonly FramePhase[];
+    inPhase(phase: FramePhase): boolean;
+    isActive(): boolean;
+    canCancel(): boolean;
+    activeWindowMs(): {
+        from: number;
+        to: number;
+    } | null;
+}
+export interface AnimationStateConfig {
+    clips: readonly AnimationClip[];
+}
+export declare function createAnimationState(config: AnimationStateConfig): AnimationState;