@jgengine/core 0.9.0 → 0.11.0

package/dist/render/postProcessing.js

@@ -0,0 +1,21 @@
+/**
+ * A cinematic "product shot" post preset — the full chain on (contact-AO, soft bloom, a warm film
+ * grade with vignette + a touch of grain + chromatic aberration). Meant for a `StudioStage` where a
+ * single parametric asset is framed on a backdrop, so every studio reads shipped, not intern-tier. DoF
+ * is left off by default (it needs a per-scene focus distance); set `dof` to enable it.
+ */
+export const STUDIO_STAGE_POST = {
+    toneMapping: "aces",
+    exposure: 1.05,
+    bloom: { strength: 0.28, radius: 0.6, threshold: 0.8 },
+    ao: { radius: 1.4, intensity: 2.2, distanceFalloff: 3, blend: 1 },
+    grade: {
+        lift: [0.008, 0.008, 0.014],
+        gain: [1.05, 1.02, 0.98],
+        gamma: 0.96,
+        saturation: 1.12,
+        vignette: 0,
+        grain: 0.006,
+        chromaticAberration: 0.001,
+    },
+};

package/dist/rules/predicate.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A declarative, serializable predicate AST evaluated against a plain fact bag. Predicates carry no
+ * closures, so they survive save/load and stay deterministic — the reusable condition seam that
+ * event-conditioned rules, quests, perks, and reactive AI gate on instead of hand-rolled callbacks.
+ */
+/** A leaf value a predicate can compare against — JSON-safe so predicates serialize cleanly. */
+export type PredicateValue = string | number | boolean | null;
+/** Dot path into a fact bag, e.g. `"hit.crit"` or `"attacker.team"`. */
+export type PredicatePath = string;
+/**
+ * One node of the predicate tree. Combinators (`all`/`any`/`not`) nest; leaf comparators read a
+ * dot path from the facts and compare it. `has` passes when the path resolves to a non-nullish value.
+ */
+export type Predicate = {
+    readonly all: readonly Predicate[];
+} | {
+    readonly any: readonly Predicate[];
+} | {
+    readonly not: Predicate;
+} | {
+    readonly eq: readonly [PredicatePath, PredicateValue];
+} | {
+    readonly ne: readonly [PredicatePath, PredicateValue];
+} | {
+    readonly gt: readonly [PredicatePath, number];
+} | {
+    readonly gte: readonly [PredicatePath, number];
+} | {
+    readonly lt: readonly [PredicatePath, number];
+} | {
+    readonly lte: readonly [PredicatePath, number];
+} | {
+    readonly in: readonly [PredicatePath, readonly PredicateValue[]];
+} | {
+    readonly has: PredicatePath;
+};
+/** Plain, serializable bag of facts a predicate reads by dot path. */
+export type PredicateFacts = Record<string, unknown>;
+/**
+ * Read a dot path out of a fact bag, descending only through plain objects. Returns `undefined` when
+ * any segment is missing or non-traversable. Bounded by the path's segment count.
+ *
+ * @capability declarative-predicate serializable data-driven conditions with no callbacks in saved content
+ */
+export declare function readPath(facts: PredicateFacts, path: PredicatePath): unknown;
+/**
+ * Evaluate a predicate against a fact bag. An omitted predicate matches unconditionally, so callers
+ * can treat "no condition" and "always" identically. Pure and deterministic — no allocation beyond
+ * path splits and no reliance on evaluation order between sibling clauses.
+ *
+ * @capability declarative-predicate serializable data-driven conditions with no callbacks in saved content
+ */
+export declare function evaluatePredicate(predicate: Predicate | undefined, facts: PredicateFacts): boolean;

package/dist/rules/predicate.js

@@ -0,0 +1,64 @@
+/**
+ * A declarative, serializable predicate AST evaluated against a plain fact bag. Predicates carry no
+ * closures, so they survive save/load and stay deterministic — the reusable condition seam that
+ * event-conditioned rules, quests, perks, and reactive AI gate on instead of hand-rolled callbacks.
+ */
+/**
+ * Read a dot path out of a fact bag, descending only through plain objects. Returns `undefined` when
+ * any segment is missing or non-traversable. Bounded by the path's segment count.
+ *
+ * @capability declarative-predicate serializable data-driven conditions with no callbacks in saved content
+ */
+export function readPath(facts, path) {
+    let current = facts;
+    for (const segment of path.split(".")) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/**
+ * Evaluate a predicate against a fact bag. An omitted predicate matches unconditionally, so callers
+ * can treat "no condition" and "always" identically. Pure and deterministic — no allocation beyond
+ * path splits and no reliance on evaluation order between sibling clauses.
+ *
+ * @capability declarative-predicate serializable data-driven conditions with no callbacks in saved content
+ */
+export function evaluatePredicate(predicate, facts) {
+    if (predicate === undefined)
+        return true;
+    if ("all" in predicate)
+        return predicate.all.every((child) => evaluatePredicate(child, facts));
+    if ("any" in predicate)
+        return predicate.any.some((child) => evaluatePredicate(child, facts));
+    if ("not" in predicate)
+        return !evaluatePredicate(predicate.not, facts);
+    if ("has" in predicate) {
+        const value = readPath(facts, predicate.has);
+        return value !== undefined && value !== null;
+    }
+    if ("eq" in predicate)
+        return readPath(facts, predicate.eq[0]) === predicate.eq[1];
+    if ("ne" in predicate)
+        return readPath(facts, predicate.ne[0]) !== predicate.ne[1];
+    if ("in" in predicate)
+        return predicate.in[1].includes(readPath(facts, predicate.in[0]));
+    if ("gt" in predicate) {
+        const value = asNumber(readPath(facts, predicate.gt[0]));
+        return value !== undefined && value > predicate.gt[1];
+    }
+    if ("gte" in predicate) {
+        const value = asNumber(readPath(facts, predicate.gte[0]));
+        return value !== undefined && value >= predicate.gte[1];
+    }
+    if ("lt" in predicate) {
+        const value = asNumber(readPath(facts, predicate.lt[0]));
+        return value !== undefined && value < predicate.lt[1];
+    }
+    const value = asNumber(readPath(facts, predicate.lte[0]));
+    return value !== undefined && value <= predicate.lte[1];
+}

package/dist/rules/ruleEffects.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A registration seam for the effect ids that triggered rules reference. Saved content names an
+ * effect by id; the game declares what that id means here (label for inspectors, optional param
+ * schema note) so authored rules validate against a known vocabulary instead of stringly-invented,
+ * un-inspectable callbacks. Mirrors the authored-trigger action registry for editor parity.
+ */
+import type { PredicateValue } from "./predicate.js";
+/** A declared effect a triggered rule may reference. Behavior lives in the game; this is metadata. */
+export interface RuleEffectDefinition {
+    /** Effect id used in {@link TriggeredRule.effect} references. */
+    id: string;
+    /** Human label for debug/inspector surfaces. */
+    label?: string;
+    /** Default params merged under a rule's own params, for authoring convenience. */
+    defaults?: Readonly<Record<string, PredicateValue>>;
+}
+/**
+ * Declare a rule effect id. Idempotent per id (last registration wins); call at module load next to
+ * catalogs so authored content and inspectors share one vocabulary.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export declare function registerRuleEffect(definition: RuleEffectDefinition): void;
+/**
+ * Look up a declared rule effect, or `undefined` when the id was never registered — lets callers
+ * reject unknown effect references in authored content.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export declare function getRuleEffect(id: string): RuleEffectDefinition | undefined;
+/**
+ * Every declared rule effect, for populating inspector dropdowns and validating a content set.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export declare function listRuleEffects(): RuleEffectDefinition[];
+/** Clear the rule-effect registry — tests only. @internal */
+export declare function clearRuleEffects(): void;

package/dist/rules/ruleEffects.js

@@ -0,0 +1,37 @@
+/**
+ * A registration seam for the effect ids that triggered rules reference. Saved content names an
+ * effect by id; the game declares what that id means here (label for inspectors, optional param
+ * schema note) so authored rules validate against a known vocabulary instead of stringly-invented,
+ * un-inspectable callbacks. Mirrors the authored-trigger action registry for editor parity.
+ */
+const registry = new Map();
+/**
+ * Declare a rule effect id. Idempotent per id (last registration wins); call at module load next to
+ * catalogs so authored content and inspectors share one vocabulary.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export function registerRuleEffect(definition) {
+    registry.set(definition.id, definition);
+}
+/**
+ * Look up a declared rule effect, or `undefined` when the id was never registered — lets callers
+ * reject unknown effect references in authored content.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export function getRuleEffect(id) {
+    return registry.get(id);
+}
+/**
+ * Every declared rule effect, for populating inspector dropdowns and validating a content set.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export function listRuleEffects() {
+    return [...registry.values()];
+}
+/** Clear the rule-effect registry — tests only. @internal */
+export function clearRuleEffects() {
+    registry.clear();
+}

package/dist/rules/triggeredRules.d.ts

@@ -0,0 +1,160 @@
+/**
+ * The reusable bridge from typed runtime events to effects. A triggered rule is pure data — which
+ * event it listens to, a declarative predicate over the event facts, how the affected target is
+ * resolved, an effect *reference* (never a callback), and how the resulting effect is gated, lived,
+ * and stacked. Affixes, talents, perks, quests, achievements, environment rules, and reactive AI all
+ * subscribe through this one seam instead of owning parallel trigger runtimes.
+ *
+ * Core stays decoupled from any specific effect system: `dispatch` returns provenance-rich firings
+ * and the game applies them to whatever effect/stat system it owns. Gate state (cooldowns, rate
+ * windows, remaining charges) and active timed effects serialize cleanly so future triggers survive
+ * save/load.
+ */
+import { type Predicate, type PredicateFacts, type PredicateValue } from "./predicate.js";
+/** Role slots an event exposes; a target selector resolves one of these to a concrete id. */
+export type TargetRole = "subject" | "object" | "source" | "owner";
+/**
+ * How a rule picks the id its effect lands on: a fixed event role, a dot path into the event facts,
+ * or a literal id. Data-only so it saves with the rule.
+ */
+export type TargetSelector = {
+    readonly role: TargetRole;
+} | {
+    readonly path: string;
+} | {
+    readonly literal: string;
+};
+/** A reference to an effect the game knows how to apply — id plus JSON-safe params, no closures. */
+export interface EffectRef {
+    readonly id: string;
+    readonly params?: Readonly<Record<string, PredicateValue>>;
+}
+/**
+ * How a repeated application of the same rule's effect on the same target combines with a live one:
+ * `refresh` re-arms the timer at one stack, `stack` adds a stack up to `maxStacks` and re-arms,
+ * `independent` keeps each application as its own instance with its own expiry, `ignore` drops the
+ * new application while one is already active.
+ */
+export type StackPolicy = "refresh" | "stack" | "independent" | "ignore";
+/** Bounded firing budget over a sliding time window. */
+export interface RateLimit {
+    readonly count: number;
+    readonly windowMs: number;
+}
+/**
+ * A declarative subscription from an event to an effect. Everything here is serializable content —
+ * the runtime reads it, it never embeds behavior. `effect` names an effect the game resolves; core
+ * only routes and gates.
+ */
+export interface TriggeredRule {
+    /** Stable id, unique within an engine. */
+    readonly id: string;
+    /** Event type this rule subscribes to. */
+    readonly event: string;
+    /** Owner/source identity (item instance, talent node, quest id) for provenance and bulk cleanup. */
+    readonly owner?: string;
+    /** Declarative gate over the event facts; omitted fires unconditionally. */
+    readonly when?: Predicate;
+    /** How the affected target id is resolved; defaults to the `subject` role. */
+    readonly target?: TargetSelector;
+    /** The effect to apply when the rule fires. */
+    readonly effect: EffectRef;
+    /** Minimum ms between fires of this rule against the same resolved target. */
+    readonly cooldownMs?: number;
+    /** Sliding-window firing cap across all targets. */
+    readonly rateLimit?: RateLimit;
+    /** Total fires before the rule is spent; omitted is unlimited. */
+    readonly charges?: number;
+    /** Lifetime of the applied effect in ms; omitted is instantaneous (no active instance kept). */
+    readonly durationMs?: number;
+    /** Stacking policy for repeat applications while an instance is live; defaults to `refresh`. */
+    readonly stacking?: StackPolicy;
+    /** Cap for the `stack` policy; defaults to 1 (i.e. behaves like `refresh` until raised). */
+    readonly maxStacks?: number;
+}
+/** A typed event handed to the engine; roles feed target resolution, facts feed the predicate. */
+export interface RuleEvent {
+    readonly type: string;
+    readonly subject?: string;
+    readonly object?: string;
+    readonly source?: string;
+    /** Fact bag the predicate and `{ path }` target selectors read. */
+    readonly facts?: PredicateFacts;
+}
+/** A live timed effect an engine is tracking until it expires or is cleaned up. */
+export interface ActiveEffect {
+    readonly instanceId: string;
+    readonly ruleId: string;
+    readonly effectId: string;
+    readonly owner: string | undefined;
+    readonly target: string;
+    readonly params: Readonly<Record<string, PredicateValue>> | undefined;
+    readonly appliedAt: number;
+    readonly expiresAt: number;
+    readonly stacks: number;
+}
+/** Reason a firing did not produce an effect — surfaced for debug inspection, never thrown. */
+export type FiringBlock = "predicate" | "no-target" | "cooldown" | "rate-limit" | "no-charges" | "stack-ignored";
+/**
+ * The outcome of matching one rule against one event. `applied` is the effect the caller should now
+ * run through its own effect system; a blocked firing reports why. Provenance (rule, owner, event,
+ * timestamp) rides along for auditability.
+ */
+export interface RuleFiring {
+    readonly ruleId: string;
+    readonly event: string;
+    readonly owner: string | undefined;
+    readonly target: string;
+    readonly effect: EffectRef;
+    readonly at: number;
+    /** Set when the firing produced/updated a timed instance. */
+    readonly instanceId?: string;
+    /** Stack count on the target after this firing (>= 1 for timed effects). */
+    readonly stacks?: number;
+    /** Absent when the effect was applied; set when the firing was gated out. */
+    readonly blocked?: FiringBlock;
+}
+/** Serializable runtime state — everything that changes future triggers. Rules travel with it. */
+export interface TriggeredRuleState {
+    seq: number;
+    rules: TriggeredRule[];
+    charges: Record<string, number>;
+    cooldowns: Record<string, number>;
+    windows: Record<string, number[]>;
+    active: ActiveEffect[];
+}
+/** A running set of triggered rules with gating, timed lifetimes, stacking, cleanup, and save/load. */
+export interface TriggeredRuleEngine {
+    /** Register or replace a rule by id. */
+    add(rule: TriggeredRule): void;
+    /** Drop a rule and any active effects it produced. */
+    remove(ruleId: string): void;
+    /** Drop every rule and active effect belonging to an owner (unequip, respec, entity removal). */
+    removeByOwner(owner: string): void;
+    /** Snapshot of registered rules in insertion order. */
+    rules(): readonly TriggeredRule[];
+    /** Match an event against all rules, gate, spawn/refresh timed effects, and return firings. */
+    dispatch(event: RuleEvent, now: number): readonly RuleFiring[];
+    /** Advance time and return the active effects that expired (and were removed) this tick. */
+    tick(now: number): readonly ActiveEffect[];
+    /** All live timed effects. */
+    active(): readonly ActiveEffect[];
+    /** Live timed effects landed on a given target. */
+    activeFor(target: string): readonly ActiveEffect[];
+    /** Drop all active timed effects but keep rules and gate state. */
+    clearActive(): void;
+    /** Reset gate state and active effects (respec/encounter reset) while keeping rules. */
+    reset(): void;
+    /** Serialize all future-affecting state. */
+    snapshot(): TriggeredRuleState;
+    /** Replace all state from a snapshot. */
+    hydrate(state: TriggeredRuleState): void;
+}
+/**
+ * Create an empty triggered-rule engine. Rules are added as data; dispatching an event returns the
+ * firings the caller applies to its own effect system. Time is caller-supplied (`now` in ms), so the
+ * engine is deterministic and drives equally from a fixed-step loop or a save-restored timeline.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export declare function createTriggeredRuleEngine(rules?: readonly TriggeredRule[]): TriggeredRuleEngine;

package/dist/rules/triggeredRules.js

@@ -0,0 +1,241 @@
+/**
+ * The reusable bridge from typed runtime events to effects. A triggered rule is pure data — which
+ * event it listens to, a declarative predicate over the event facts, how the affected target is
+ * resolved, an effect *reference* (never a callback), and how the resulting effect is gated, lived,
+ * and stacked. Affixes, talents, perks, quests, achievements, environment rules, and reactive AI all
+ * subscribe through this one seam instead of owning parallel trigger runtimes.
+ *
+ * Core stays decoupled from any specific effect system: `dispatch` returns provenance-rich firings
+ * and the game applies them to whatever effect/stat system it owns. Gate state (cooldowns, rate
+ * windows, remaining charges) and active timed effects serialize cleanly so future triggers survive
+ * save/load.
+ */
+import { evaluatePredicate, readPath } from "./predicate.js";
+function roleId(event, role, owner) {
+    switch (role) {
+        case "subject":
+            return event.subject;
+        case "object":
+            return event.object;
+        case "source":
+            return event.source;
+        case "owner":
+            return owner;
+    }
+}
+function resolveTarget(rule, event) {
+    const selector = rule.target ?? { role: "subject" };
+    if ("literal" in selector)
+        return selector.literal;
+    if ("path" in selector) {
+        const value = readPath(event.facts ?? {}, selector.path);
+        return typeof value === "string" ? value : undefined;
+    }
+    return roleId(event, selector.role, rule.owner);
+}
+function cooldownKey(ruleId, target) {
+    return `${ruleId}\u0000${target}`;
+}
+/**
+ * Create an empty triggered-rule engine. Rules are added as data; dispatching an event returns the
+ * firings the caller applies to its own effect system. Time is caller-supplied (`now` in ms), so the
+ * engine is deterministic and drives equally from a fixed-step loop or a save-restored timeline.
+ *
+ * @capability triggered-rules event-conditioned effects with declarative predicates, lifetimes, and stacking
+ */
+export function createTriggeredRuleEngine(rules = []) {
+    const ruleList = [];
+    const ruleIndex = new Map();
+    const remainingCharges = new Map();
+    const lastFire = new Map();
+    const fireWindows = new Map();
+    let active = [];
+    let seq = 0;
+    function indexRules() {
+        ruleIndex.clear();
+        for (let i = 0; i < ruleList.length; i++)
+            ruleIndex.set(ruleList[i].id, i);
+    }
+    function add(rule) {
+        const existing = ruleIndex.get(rule.id);
+        if (existing !== undefined)
+            ruleList[existing] = rule;
+        else
+            ruleList.push(rule);
+        indexRules();
+        if (rule.charges !== undefined)
+            remainingCharges.set(rule.id, rule.charges);
+        else
+            remainingCharges.delete(rule.id);
+    }
+    for (const rule of rules)
+        add(rule);
+    function dropRuleState(ruleId) {
+        remainingCharges.delete(ruleId);
+        fireWindows.delete(ruleId);
+        for (const key of [...lastFire.keys()]) {
+            if (key.startsWith(`${ruleId}\u0000`))
+                lastFire.delete(key);
+        }
+        active = active.filter((instance) => instance.ruleId !== ruleId);
+    }
+    function passesRate(rule, now) {
+        if (rule.rateLimit === undefined)
+            return true;
+        const window = fireWindows.get(rule.id) ?? [];
+        const cutoff = now - rule.rateLimit.windowMs;
+        const kept = window.filter((stamp) => stamp > cutoff);
+        fireWindows.set(rule.id, kept);
+        return kept.length < rule.rateLimit.count;
+    }
+    function recordFire(rule, target, now) {
+        lastFire.set(cooldownKey(rule.id, target), now);
+        if (rule.rateLimit !== undefined) {
+            const window = fireWindows.get(rule.id) ?? [];
+            window.push(now);
+            fireWindows.set(rule.id, window);
+        }
+        if (rule.charges !== undefined) {
+            remainingCharges.set(rule.id, (remainingCharges.get(rule.id) ?? 0) - 1);
+        }
+    }
+    function applyTimed(rule, target, now) {
+        const duration = rule.durationMs;
+        const policy = rule.stacking ?? "refresh";
+        const expiresAt = now + duration;
+        if (policy !== "independent") {
+            const current = active.find((instance) => instance.ruleId === rule.id && instance.target === target);
+            if (current !== undefined) {
+                if (policy === "ignore")
+                    return { blocked: "stack-ignored" };
+                const stacks = policy === "stack" ? Math.min(current.stacks + 1, Math.max(1, rule.maxStacks ?? 1)) : 1;
+                const updated = { ...current, expiresAt, stacks, appliedAt: now };
+                active = active.map((instance) => (instance === current ? updated : instance));
+                return { instanceId: updated.instanceId, stacks };
+            }
+        }
+        const instanceId = `${rule.id}#${seq++}`;
+        active.push({
+            instanceId,
+            ruleId: rule.id,
+            effectId: rule.effect.id,
+            owner: rule.owner,
+            target,
+            params: rule.effect.params,
+            appliedAt: now,
+            expiresAt,
+            stacks: 1,
+        });
+        return { instanceId, stacks: 1 };
+    }
+    function evaluate(rule, event, now) {
+        const base = { ruleId: rule.id, event: event.type, owner: rule.owner, effect: rule.effect, at: now };
+        if (!evaluatePredicate(rule.when, event.facts ?? {}))
+            return { ...base, target: "", blocked: "predicate" };
+        const target = resolveTarget(rule, event);
+        if (target === undefined || target === "")
+            return { ...base, target: "", blocked: "no-target" };
+        if (rule.charges !== undefined && (remainingCharges.get(rule.id) ?? 0) <= 0)
+            return { ...base, target, blocked: "no-charges" };
+        if (rule.cooldownMs !== undefined) {
+            const last = lastFire.get(cooldownKey(rule.id, target));
+            if (last !== undefined && now - last < rule.cooldownMs)
+                return { ...base, target, blocked: "cooldown" };
+        }
+        if (!passesRate(rule, now))
+            return { ...base, target, blocked: "rate-limit" };
+        if (rule.durationMs !== undefined) {
+            const outcome = applyTimed(rule, target, now);
+            if ("blocked" in outcome)
+                return { ...base, target, blocked: outcome.blocked };
+            recordFire(rule, target, now);
+            return { ...base, target, instanceId: outcome.instanceId, stacks: outcome.stacks };
+        }
+        recordFire(rule, target, now);
+        return { ...base, target };
+    }
+    return {
+        add,
+        remove(ruleId) {
+            const index = ruleIndex.get(ruleId);
+            if (index === undefined)
+                return;
+            ruleList.splice(index, 1);
+            indexRules();
+            dropRuleState(ruleId);
+        },
+        removeByOwner(owner) {
+            const removed = ruleList.filter((rule) => rule.owner === owner).map((rule) => rule.id);
+            if (removed.length === 0) {
+                active = active.filter((instance) => instance.owner !== owner);
+                return;
+            }
+            for (let i = ruleList.length - 1; i >= 0; i--) {
+                if (ruleList[i].owner === owner)
+                    ruleList.splice(i, 1);
+            }
+            indexRules();
+            for (const ruleId of removed)
+                dropRuleState(ruleId);
+            active = active.filter((instance) => instance.owner !== owner);
+        },
+        rules: () => ruleList.slice(),
+        dispatch(event, now) {
+            const firings = [];
+            for (const rule of ruleList) {
+                if (rule.event !== event.type)
+                    continue;
+                firings.push(evaluate(rule, event, now));
+            }
+            return firings;
+        },
+        tick(now) {
+            const expired = active.filter((instance) => instance.expiresAt <= now);
+            if (expired.length > 0)
+                active = active.filter((instance) => instance.expiresAt > now);
+            return expired;
+        },
+        active: () => active.slice(),
+        activeFor: (target) => active.filter((instance) => instance.target === target),
+        clearActive() {
+            active = [];
+        },
+        reset() {
+            remainingCharges.clear();
+            lastFire.clear();
+            fireWindows.clear();
+            active = [];
+            for (const rule of ruleList) {
+                if (rule.charges !== undefined)
+                    remainingCharges.set(rule.id, rule.charges);
+            }
+        },
+        snapshot() {
+            return {
+                seq,
+                rules: ruleList.map((rule) => ({ ...rule })),
+                charges: Object.fromEntries(remainingCharges),
+                cooldowns: Object.fromEntries(lastFire),
+                windows: Object.fromEntries([...fireWindows].map(([id, stamps]) => [id, stamps.slice()])),
+                active: active.map((instance) => ({ ...instance })),
+            };
+        },
+        hydrate(state) {
+            ruleList.length = 0;
+            for (const rule of state.rules)
+                ruleList.push({ ...rule });
+            indexRules();
+            remainingCharges.clear();
+            for (const [id, value] of Object.entries(state.charges))
+                remainingCharges.set(id, value);
+            lastFire.clear();
+            for (const [key, value] of Object.entries(state.cooldowns))
+                lastFire.set(key, value);
+            fireWindows.clear();
+            for (const [id, stamps] of Object.entries(state.windows))
+                fireWindows.set(id, stamps.slice());
+            active = state.active.map((instance) => ({ ...instance }));
+            seq = state.seq;
+        },
+    };
+}