@jgengine/core 0.25.0 → 0.26.0

package/dist/combat/cover.js

@@ -0,0 +1,264 @@
+import { devtools } from "../devtools/devtools.js";
+const DEFAULT_STAND_OFF = 0.7;
+const DEFAULT_SPACING = 2;
+const DEFAULT_MIN_FACE = 1.2;
+const DEFAULT_MAX_PER_FACE = 3;
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+function addFace(out, solid, normalX, normalZ, tangentX, tangentZ, halfAlong, halfAcross, options) {
+    // A spot near a wall's end is not cover: a shooter at an angle sees around the corner, and a body
+    // does not stand exactly on the point. Keep stand points clear of the corners by roughly one body.
+    const edgeInset = Math.min(options.standOff + 0.4, halfAcross * 0.6);
+    const usable = halfAcross - edgeInset;
+    if (usable * 2 < options.minFaceLength || usable <= 0)
+        return;
+    const count = Math.max(1, Math.min(options.maxPerFace, Math.floor((usable * 2) / options.spacing) + 1));
+    const step = count === 1 ? 0 : (usable * 2) / (count - 1);
+    const faceX = solid.center[0] + normalX * halfAlong;
+    const faceZ = solid.center[2] + normalZ * halfAlong;
+    for (let i = 0; i < count; i += 1) {
+        const offset = count === 1 ? 0 : -usable + step * i;
+        const x = faceX + tangentX * offset + normalX * options.standOff;
+        const z = faceZ + tangentZ * offset + normalZ * options.standOff;
+        const y = options.yOf === undefined ? solid.center[1] - solid.halfExtents[1] : options.yOf(x, z);
+        const point = [x, y, z];
+        if (options.walkable !== undefined && !options.walkable(point))
+            continue;
+        out.push({
+            id: `${round(x)},${round(z)}|${round(normalX)},${round(normalZ)}`,
+            position: point,
+            normal: [normalX, normalZ],
+        });
+    }
+}
+/**
+ * Stand points on every vertical face of the supplied boxes: one row per face, spaced along it,
+ * `standOff` out from the surface. Geometry in, cover out — no authored coordinate list, so moving
+ * a wall in the editor moves its cover.
+ *
+ * @capability cover-points-from-solids derive stand-able cover positions from authored solid boxes
+ */
+export function coverPointsFromSolids(solids, options = {}) {
+    const resolved = {
+        standOff: Math.max(0, options.standOff ?? DEFAULT_STAND_OFF),
+        spacing: Math.max(0.2, options.spacing ?? DEFAULT_SPACING),
+        minFaceLength: Math.max(0, options.minFaceLength ?? DEFAULT_MIN_FACE),
+        maxPerFace: Math.max(1, Math.floor(options.maxPerFace ?? DEFAULT_MAX_PER_FACE)),
+        ...(options.yOf === undefined ? {} : { yOf: options.yOf }),
+        ...(options.walkable === undefined ? {} : { walkable: options.walkable }),
+    };
+    const out = [];
+    for (const solid of solids) {
+        const yaw = solid.rotationY ?? 0;
+        const cos = Math.cos(yaw);
+        const sin = Math.sin(yaw);
+        // Local +X and +Z in world XZ, matching the engine's rotationY convention.
+        const ux = cos;
+        const uz = -sin;
+        const vx = sin;
+        const vz = cos;
+        const [hx, , hz] = solid.halfExtents;
+        addFace(out, solid, ux, uz, vx, vz, hx, hz, resolved);
+        addFace(out, solid, -ux, -uz, vx, vz, hx, hz, resolved);
+        addFace(out, solid, vx, vz, ux, uz, hz, hx, resolved);
+        addFace(out, solid, -vx, -vz, ux, uz, hz, hx, resolved);
+    }
+    return out;
+}
+/**
+ * The `limit` nearest cover points within `radius`, nearest first, ties broken by id. A linear scan
+ * of the points the field holds; the field caps how many points exist.
+ *
+ * @capability cover-points-near bounded nearest-cover query
+ */
+export function coverPointsNear(points, position, radius, limit = Number.POSITIVE_INFINITY) {
+    const max = radius * radius;
+    const found = [];
+    for (const point of points) {
+        const dx = point.position[0] - position[0];
+        const dz = point.position[2] - position[2];
+        const distance = dx * dx + dz * dz;
+        if (distance <= max)
+            found.push({ point, distance });
+    }
+    found.sort((a, b) => a.distance - b.distance || (a.point.id < b.point.id ? -1 : a.point.id > b.point.id ? 1 : 0));
+    return found.slice(0, Math.max(0, Math.floor(limit))).map((entry) => entry.point);
+}
+/**
+ * Cover over authored boxes: derive the stand points once, re-derive them after an edit, and answer
+ * bounded nearest-cover queries. `walkable` is injected, so the seam checks the game's own ground
+ * test (`nav.findPolygon(point) !== null`) instead of assuming a flat floor.
+ *
+ * @capability cover-field authored-geometry cover with a bounded nearest query and rebuild on edit
+ */
+export function createCoverField(options) {
+    let solids = options.solids.map((solid) => ({ ...solid }));
+    let tunables = {
+        ...(options.standOff === undefined ? {} : { standOff: options.standOff }),
+        ...(options.spacing === undefined ? {} : { spacing: options.spacing }),
+        ...(options.minFaceLength === undefined ? {} : { minFaceLength: options.minFaceLength }),
+        ...(options.maxPerFace === undefined ? {} : { maxPerFace: options.maxPerFace }),
+        ...(options.yOf === undefined ? {} : { yOf: options.yOf }),
+        ...(options.walkable === undefined ? {} : { walkable: options.walkable }),
+    };
+    let derived = [];
+    let queries = 0;
+    function derive() {
+        derived = coverPointsFromSolids(solids, tunables);
+    }
+    derive();
+    function debugLine() {
+        return `${derived.length} points from ${solids.length} solids · ${queries} queries`;
+    }
+    const unregister = options.devtoolsName === undefined ? null : devtools.probes.register(options.devtoolsName, () => debugLine());
+    return {
+        near(position, radius, limit) {
+            queries += 1;
+            return coverPointsNear(derived, position, radius, limit);
+        },
+        points: () => derived,
+        count: () => derived.length,
+        rebuild(next) {
+            solids = next.map((solid) => ({ ...solid }));
+            derive();
+        },
+        retune(patch) {
+            tunables = { ...tunables, ...patch };
+            derive();
+        },
+        snapshot() {
+            return {
+                solids: solids.map((solid) => ({ ...solid })),
+                standOff: tunables.standOff ?? DEFAULT_STAND_OFF,
+                spacing: tunables.spacing ?? DEFAULT_SPACING,
+                minFaceLength: tunables.minFaceLength ?? DEFAULT_MIN_FACE,
+                maxPerFace: tunables.maxPerFace ?? DEFAULT_MAX_PER_FACE,
+            };
+        },
+        restore(next) {
+            solids = next.solids.map((solid) => ({ ...solid }));
+            tunables = {
+                ...tunables,
+                standOff: next.standOff,
+                spacing: next.spacing,
+                minFaceLength: next.minFaceLength,
+                maxPerFace: next.maxPerFace,
+            };
+            derive();
+        },
+        dispose() {
+            unregister?.();
+        },
+    };
+}
+const DEFAULT_WEIGHTS = { hidden: 3, range: 1, flank: 1, near: 0.6, crowding: 2, retreat: 0, path: 1.2 };
+function clamp01(value) {
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function wrapAngle(angle) {
+    let value = angle;
+    while (value > Math.PI)
+        value -= Math.PI * 2;
+    while (value < -Math.PI)
+        value += Math.PI * 2;
+    return value;
+}
+function flatDistance(a, b) {
+    return Math.hypot(a[0] - b[0], a[2] - b[2]);
+}
+/** True when the whole body at `point` is out of sight from `threat`, not just the point's centre. */
+function hiddenAt(point, threat, bodyRadius, blocked) {
+    if (!blocked(point, threat))
+        return false;
+    if (bodyRadius <= 0)
+        return true;
+    const dx = threat[0] - point[0];
+    const dz = threat[2] - point[2];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-6)
+        return true;
+    const px = (-dz / length) * bodyRadius;
+    const pz = (dx / length) * bodyRadius;
+    return blocked([point[0] + px, point[1], point[2] + pz], threat) && blocked([point[0] - px, point[1], point[2] - pz], threat);
+}
+/**
+ * Score one stand point against the threats the member remembers. `hidden` is the confidence-weighted
+ * share of remembered threats that cannot see the point, so a point that hides from the shooter that
+ * matters scores over one that hides from a fading one. Returns `null` when nothing it can hide from
+ * is worth considering.
+ *
+ * @capability cover-score threat-driven cover point scoring
+ */
+export function scoreCoverPoint(point, query) {
+    const minConfidence = query.minConfidence ?? 0.05;
+    const weights = { ...DEFAULT_WEIGHTS, ...query.weights };
+    const bodyRadius = Math.max(0, query.bodyRadius ?? 0.4);
+    let totalConfidence = 0;
+    let hidden = 0;
+    let nearest = Number.POSITIVE_INFINITY;
+    let strongest = null;
+    for (const threat of query.threats) {
+        if (threat.confidence < minConfidence)
+            continue;
+        totalConfidence += threat.confidence;
+        if (hiddenAt(point.position, threat.position, bodyRadius, query.blocked))
+            hidden += threat.confidence;
+        const distance = flatDistance(point.position, threat.position);
+        if (distance < nearest)
+            nearest = distance;
+        if (strongest === null || threat.confidence > strongest.confidence || (threat.confidence === strongest.confidence && threat.id < strongest.id)) {
+            strongest = threat;
+        }
+    }
+    if (strongest === null || totalConfidence <= 0)
+        return null;
+    const hiddenShare = hidden / totalConfidence;
+    if (query.hiddenOnly === true && hiddenShare <= 0)
+        return null;
+    const radius = Math.max(query.radius, 0.0001);
+    const range = clamp01(1 - Math.abs(nearest - query.preferredRange) / Math.max(query.preferredRange, 1));
+    const near = clamp01(1 - flatDistance(query.position, point.position) / radius);
+    const retreat = clamp01(nearest / radius);
+    let flank = 0;
+    const line = query.lineThrough ?? query.position;
+    const axisX = line[0] - strongest.position[0];
+    const axisZ = line[2] - strongest.position[2];
+    const axisLength = Math.hypot(axisX, axisZ);
+    if (axisLength > 0.0001) {
+        const dirX = point.position[0] - strongest.position[0];
+        const dirZ = point.position[2] - strongest.position[2];
+        const dirLength = Math.hypot(dirX, dirZ);
+        if (dirLength > 0.0001) {
+            const offset = Math.abs(wrapAngle(Math.atan2(dirX, dirZ) - Math.atan2(axisX, axisZ)));
+            flank = clamp01(1 - Math.abs(offset - (query.flankAngle ?? 0)) / Math.PI);
+        }
+    }
+    const crowding = query.taken?.has(point.id) === true ? 1 : 0;
+    const path = query.blocked(query.position, point.position) ? 1 : 0;
+    const score = weights.hidden * hiddenShare +
+        weights.range * range +
+        weights.flank * flank +
+        weights.near * near +
+        weights.retreat * retreat -
+        weights.crowding * crowding -
+        weights.path * path;
+    return { point, score, hidden: hiddenShare, range, flank, near, retreat, path };
+}
+/**
+ * The best of `points` under one {@link CoverQuery}, ties broken by point id. Pass the candidate set
+ * the injected query already bounded; this scores what it is given.
+ *
+ * @capability cover-select select cover by threat, role range and flank angle
+ */
+export function selectCover(points, query) {
+    let best = null;
+    for (const point of points) {
+        const choice = scoreCoverPoint(point, query);
+        if (choice === null)
+            continue;
+        if (best === null || choice.score > best.score || (choice.score === best.score && choice.point.id < best.point.id))
+            best = choice;
+    }
+    return best;
+}

package/dist/combat/damageRuntime.d.ts

@@ -0,0 +1,150 @@
+import type { StatusApplicationOutcome, StatusInstance } from "./statusApplication.js";
+import { readDamageTable, type DamageTableDef, type DamageTableRow } from "./damageTable.js";
+import { type HitZoneResolution, type HitZoneTable } from "./hitZones.js";
+import { type StatusDef, type StatusRuntimeState, type StatusTickEvent } from "./statusRuntime.js";
+/** What a target presents to the table: one resistance class and its armor points. */
+export interface TargetProfile {
+    /** Resistance class (`"flesh"`, `"shield"`, `"armor"`) the target presents. */
+    resistance: string;
+    /** Armor points before any carried armor-shred statuses. Default `0`. */
+    armor?: number;
+}
+/** One status a hit tries to apply, scaled against that status's own base chance and values. */
+export interface DamageStatusRequest {
+    id: string;
+    chanceScale?: number;
+    durationScale?: number;
+    magnitudeScale?: number;
+}
+/** One incoming hit: what struck, how hard, where it landed, and what statuses it carries. */
+export interface DamageRuntimeHitInput {
+    target: string;
+    type: string;
+    /** Damage before the zone multiplier, the table, and armor. */
+    base: number;
+    /** Hit zone id; omitted uses the table's `defaultZone`. */
+    zone?: string;
+    source?: string;
+    statuses?: readonly (string | DamageStatusRequest)[];
+}
+/** Every stage of one resolved hit, so a UI or a test can read why the final number is what it is. */
+export interface DamageRuntimeResolution {
+    target: string;
+    type: string;
+    base: number;
+    zone: HitZoneResolution;
+    /** Type × resistance multiplier before armor. */
+    multiplier: number;
+    /** Armor after carried shred statuses, never below zero. */
+    armor: number;
+    /** Fraction of the hit armor removes at `armor`. */
+    mitigation: number;
+    /** `base × zone.multiplier × multiplier × (1 − mitigation)`. */
+    damage: number;
+    statuses: StatusApplicationOutcome[];
+}
+/** A quoted time to kill for one fixed hit against one health pool. */
+export interface TimeToKill {
+    damagePerShot: number;
+    /** Hits needed, or `Infinity` when the hit deals nothing. */
+    shots: number;
+    /** Seconds from the first hit to the last: `(shots - 1) × intervalSeconds`. */
+    seconds: number;
+    intervalSeconds: number;
+}
+/** Serialized model state: registered targets, carried statuses, and the probe counters. */
+export interface DamageRuntimeState {
+    targets: Array<{
+        id: string;
+    } & TargetProfile>;
+    statuses: StatusRuntimeState;
+    hits: number;
+    crits: number;
+    dealt: number;
+    last: {
+        type: string;
+        base: number;
+        damage: number;
+        zone: string;
+        crit: boolean;
+    } | null;
+}
+/** Everything the model reads: the table, the zones, the status definitions, and the RNG. */
+export interface DamageRuntimeConfig {
+    table: DamageTableDef;
+    zones: HitZoneTable;
+    statuses?: readonly StatusDef[];
+    /** Stat id carried armor-shred statuses reduce. Default `"armor"`. */
+    armorStat?: string;
+    /** Injected `[0,1)` stream for crit rolls. Omitting it warns once and is not replayable. */
+    rng?: () => number;
+    /** Register a one-line devtools probe under this name. */
+    devtoolsName?: string;
+}
+/** In-play dials, all retunable without discarding registered targets or carried statuses. */
+export interface DamageRuntimeRetune {
+    table?: DamageTableDef;
+    zones?: HitZoneTable;
+    statuses?: readonly StatusDef[];
+    armorStat?: string;
+}
+/**
+ * A damage model: registered targets, the table/zones/statuses they are hit with, and carried
+ * status state. `hit` resolves a blow, `tick` runs status effects, `timeToKill` quotes a fight, and
+ * `table` reads the whole chart. State is plain data, so a save, a replay, or a worker can move it.
+ */
+export interface DamageRuntime {
+    /** Register or replace a target's resistance class and armor. */
+    registerTarget(id: string, profile: TargetProfile): void;
+    removeTarget(id: string): void;
+    target(id: string): TargetProfile | null;
+    /** Resolve one hit and apply any statuses it carries. */
+    hit(input: DamageRuntimeHitInput): DamageRuntimeResolution;
+    /** Apply one status directly (an ability, a hazard) without a damage hit. */
+    applyStatus(target: string, statusId: string, options?: DamageStatusRequest & {
+        source?: string;
+    }): StatusApplicationOutcome;
+    /** Advance carried statuses; damage ticks are resolved through this model's table and armor. */
+    tick(dtSeconds: number): StatusTickEvent[];
+    /** Quote a fixed hit against a health pool; pass `crit` explicitly so the number never depends on a roll. */
+    timeToKill(input: {
+        target: string;
+        type: string;
+        base: number;
+        hp: number;
+        intervalSeconds: number;
+        zone?: string;
+        crit?: boolean;
+    }): TimeToKill;
+    /** Read the whole table with armor mitigation, optionally at given armor values and base damage. */
+    table(read?: Parameters<typeof readDamageTable>[1]): DamageTableRow[];
+    retune(patch: DamageRuntimeRetune): void;
+    snapshot(): DamageRuntimeState;
+    restore(next: DamageRuntimeState): void;
+    /** Carried statuses, for a HUD or a test. */
+    statusesOf(targetId: string): readonly StatusInstance[];
+    stats(): {
+        targets: number;
+        hits: number;
+        crits: number;
+        statusTicks: number;
+        dealt: number;
+    };
+    /** Drop the devtools probe registered by `devtoolsName`. Safe to call twice. */
+    dispose(): void;
+}
+/** Raised when a hit names a target that was never registered — a wiring error, not a 0-damage hit.
+ * @capability damage-target-unknown reject a hit on a target with no registered resistance or armor profile
+ */
+export declare class UnknownTargetProfileError extends Error {
+    readonly target: string;
+    constructor(target: string);
+}
+/**
+ * Build a damage model from data. The number a hit lands is
+ * `base × zone multiplier × type multiplier × (1 − armor mitigation)`; statuses tick through the
+ * same table and armor, so a burn on an armored target is mitigated like a bullet.
+ *
+ * @capability damage-runtime resolve hits through a damage table, hit zones, and armor, and tick data-defined statuses with declared stacking
+ */
+export declare function createDamageRuntime(config: DamageRuntimeConfig): DamageRuntime;

package/dist/combat/damageRuntime.js

@@ -0,0 +1,208 @@
+import { devtools } from "../devtools/devtools.js";
+import { resolveRng } from "../random/resolveRng.js";
+import { assertDamageTable, readDamageTable, resolveTableDamage, } from "./damageTable.js";
+import { assertHitZoneTable, hitZoneMultiplier, resolveHitZone, } from "./hitZones.js";
+import { createStatusRuntime, } from "./statusRuntime.js";
+/** Raised when a hit names a target that was never registered — a wiring error, not a 0-damage hit.
+ * @capability damage-target-unknown reject a hit on a target with no registered resistance or armor profile
+ */
+export class UnknownTargetProfileError extends Error {
+    target;
+    constructor(target) {
+        super(`No damage profile registered for target: ${target}`);
+        this.name = "UnknownTargetProfileError";
+        this.target = target;
+    }
+}
+/**
+ * Build a damage model from data. The number a hit lands is
+ * `base × zone multiplier × type multiplier × (1 − armor mitigation)`; statuses tick through the
+ * same table and armor, so a burn on an armored target is mitigated like a bullet.
+ *
+ * @capability damage-runtime resolve hits through a damage table, hit zones, and armor, and tick data-defined statuses with declared stacking
+ */
+export function createDamageRuntime(config) {
+    assertDamageTable(config.table);
+    assertHitZoneTable(config.zones);
+    const rng = resolveRng(config.rng, "createDamageRuntime");
+    let table = config.table;
+    let zones = config.zones;
+    let armorStat = config.armorStat ?? "armor";
+    const targets = new Map();
+    let hits = 0;
+    let crits = 0;
+    let dealt = 0;
+    let statusTicks = 0;
+    let last = null;
+    let statusRuntime;
+    statusRuntime = createStatusRuntime({
+        statuses: config.statuses ?? [],
+        rng,
+        maxTicksPerCall: 8,
+        applyDamage: (tick) => resolveStatusDamage(tick),
+    });
+    function profileOf(targetId) {
+        const profile = targets.get(targetId);
+        if (profile === undefined)
+            throw new UnknownTargetProfileError(targetId);
+        return profile;
+    }
+    /** Base armor plus any carried shred, never negative. */
+    function armorOf(targetId, profile) {
+        return Math.max(0, (profile.armor ?? 0) + statusRuntime.statDelta(targetId, armorStat));
+    }
+    /** Resolve a raw amount through the type table and the target's effective armor. */
+    function scaleAt(targetId, type, base) {
+        const profile = profileOf(targetId);
+        const armor = armorOf(targetId, profile);
+        return { ...resolveTableDamage(table, { type, resistance: profile.resistance, armor, base }), armor };
+    }
+    function resolveStatusDamage(tick) {
+        if (!targets.has(tick.target))
+            return tick.amount;
+        return scaleAt(tick.target, tick.channel, tick.amount).damage ?? 0;
+    }
+    function probeLine() {
+        const l = last;
+        const tail = l === null
+            ? "no hits"
+            : `last ${l.type} ${l.base.toFixed(1)}→${l.damage.toFixed(1)} ${l.zone}${l.crit ? " crit" : ""}`;
+        return `${targets.size} targets · ${hits} hits ${crits} crits · ${statusTicks} status ticks · ${dealt.toFixed(0)} dealt · ${tail}`;
+    }
+    const unregister = config.devtoolsName === undefined
+        ? null
+        : devtools.probes.register(config.devtoolsName, () => probeLine());
+    return {
+        registerTarget(id, profile) {
+            targets.set(id, { resistance: profile.resistance, armor: Math.max(0, profile.armor ?? 0) });
+        },
+        removeTarget(id) {
+            targets.delete(id);
+            statusRuntime.clear(id);
+        },
+        target(id) {
+            const profile = targets.get(id);
+            return profile === undefined ? null : { ...profile };
+        },
+        hit(input) {
+            const zone = resolveHitZone(zones, input.zone, rng);
+            const row = scaleAt(input.target, input.type, input.base * zone.multiplier);
+            const applied = [];
+            for (const request of input.statuses ?? []) {
+                const statusId = typeof request === "string" ? request : request.id;
+                const options = typeof request === "string"
+                    ? {}
+                    : {
+                        ...(request.chanceScale !== undefined ? { chanceScale: request.chanceScale } : {}),
+                        ...(request.durationScale !== undefined ? { durationScale: request.durationScale } : {}),
+                        ...(request.magnitudeScale !== undefined ? { magnitudeScale: request.magnitudeScale } : {}),
+                    };
+                applied.push(statusRuntime.apply(input.target, statusId, {
+                    ...options,
+                    ...(input.source !== undefined ? { source: input.source } : {}),
+                }));
+            }
+            const damage = row.damage ?? 0;
+            hits += 1;
+            if (zone.crit)
+                crits += 1;
+            dealt += damage;
+            last = { type: input.type, base: input.base, damage, zone: zone.zone, crit: zone.crit };
+            return {
+                target: input.target,
+                type: input.type,
+                base: input.base,
+                zone,
+                multiplier: row.multiplier,
+                armor: row.armor,
+                mitigation: row.mitigation,
+                damage,
+                statuses: applied,
+            };
+        },
+        applyStatus(target, statusId, options) {
+            return statusRuntime.apply(target, statusId, options === undefined ? {} : { ...options });
+        },
+        tick(dtSeconds) {
+            const events = statusRuntime.tick(dtSeconds);
+            for (const event of events) {
+                if (event.kind === "damage") {
+                    statusTicks += 1;
+                    dealt += event.dealt;
+                }
+            }
+            return events;
+        },
+        timeToKill(input) {
+            const profile = profileOf(input.target);
+            const zoneResolved = hitZoneMultiplier(zones, input.zone, input.crit === true);
+            const row = resolveTableDamage(table, {
+                type: input.type,
+                resistance: profile.resistance,
+                armor: armorOf(input.target, profile),
+                base: input.base * zoneResolved.multiplier,
+            });
+            const damagePerShot = row.damage ?? 0;
+            const intervalSeconds = Math.max(0, input.intervalSeconds);
+            const shots = damagePerShot <= 0
+                ? Number.POSITIVE_INFINITY
+                // The epsilon keeps a hit that exactly empties the pool from reading as needing one more
+                // because of floating-point noise in the product of four factors.
+                : Math.ceil(Math.max(0, input.hp) / damagePerShot - 1e-9);
+            return {
+                damagePerShot,
+                shots,
+                seconds: Number.isFinite(shots) ? Math.max(0, shots - 1) * intervalSeconds : Number.POSITIVE_INFINITY,
+                intervalSeconds,
+            };
+        },
+        table(read) {
+            return readDamageTable(table, read);
+        },
+        retune(patch) {
+            if (patch.table !== undefined) {
+                assertDamageTable(patch.table);
+                table = patch.table;
+            }
+            if (patch.zones !== undefined) {
+                assertHitZoneTable(patch.zones);
+                zones = patch.zones;
+            }
+            if (patch.statuses !== undefined)
+                statusRuntime.retune(patch.statuses);
+            if (patch.armorStat !== undefined)
+                armorStat = patch.armorStat;
+        },
+        snapshot() {
+            return {
+                targets: [...targets.entries()].map(([id, profile]) => ({
+                    id,
+                    resistance: profile.resistance,
+                    armor: profile.armor ?? 0,
+                })),
+                statuses: statusRuntime.snapshot(),
+                hits,
+                crits,
+                dealt,
+                last: last === null ? null : { ...last },
+            };
+        },
+        restore(next) {
+            targets.clear();
+            for (const profile of next.targets) {
+                targets.set(profile.id, { resistance: profile.resistance, armor: profile.armor });
+            }
+            statusRuntime.restore(next.statuses);
+            hits = next.hits;
+            crits = next.crits;
+            dealt = next.dealt;
+            last = next.last === null ? null : { ...next.last };
+        },
+        statusesOf: (targetId) => statusRuntime.statusesOf(targetId),
+        stats: () => ({ targets: targets.size, hits, crits, statusTicks, dealt }),
+        dispose() {
+            statusRuntime.dispose();
+            unregister?.();
+        },
+    };
+}