@jgengine/core 0.10.0 → 0.12.0

package/dist/scene/vehicleSeat.js

@@ -0,0 +1,59 @@
+import { createMountController, MountController } from "./mount.js";
+/**
+ * Composes `scene/mount`'s control-transfer bookkeeping with the seat/camera/movement-mode transition
+ * every enter/exit-vehicle flow needs (#533.2): boarding resolves a free seat and reports the camera
+ * target, drive target, and rider movement-lock patch in one call; leaving computes a side-door
+ * placement next to the vehicle and reports the same triad in reverse. Pure — no entity/camera side
+ * effects — the caller applies `riderMovementPatch`/`placement`/`cameraTarget` via its own `ctx`.
+ */
+export class VehicleSeats {
+    controller;
+    constructor(controller) {
+        this.controller = controller ?? createMountController();
+    }
+    register(config) {
+        this.controller.register(config);
+    }
+    enter(riderId, vehicleId, options = {}) {
+        const result = this.controller.mount(riderId, vehicleId, options.seatId);
+        if (!result.ok)
+            return { ok: false, reason: result.reason };
+        return {
+            ok: true,
+            seat: result.seat,
+            cameraTarget: this.controller.cameraTarget(riderId),
+            driveTarget: this.controller.driveTarget(riderId),
+            riderMovementPatch: { frozen: true },
+        };
+    }
+    exit(riderId, vehiclePose, offset = {}) {
+        const vehicleId = this.controller.dismount(riderId);
+        if (vehicleId === null)
+            return { ok: false, reason: "not_seated" };
+        const distance = offset.distance ?? 2.2;
+        const sign = offset.side === "left" ? -1 : 1;
+        const side = vehiclePose.rotationY + (Math.PI / 2) * sign;
+        const x = vehiclePose.position[0] + Math.sin(side) * distance;
+        const z = vehiclePose.position[2] + Math.cos(side) * distance;
+        return {
+            ok: true,
+            vehicleId,
+            placement: { position: [x, vehiclePose.position[1], z], rotationY: vehiclePose.rotationY },
+            cameraTarget: riderId,
+            riderMovementPatch: { frozen: false },
+        };
+    }
+    isSeated(riderId) {
+        return this.controller.isSeated(riderId);
+    }
+    driverOf(vehicleId) {
+        return this.controller.driver(vehicleId);
+    }
+    get mounts() {
+        return this.controller;
+    }
+}
+/** Builds a {@link VehicleSeats}, optionally over an existing `MountController` to share its occupancy. */
+export function createVehicleSeats(controller) {
+    return new VehicleSeats(controller);
+}

package/dist/sensor/concealment.d.ts

@@ -1,5 +1,7 @@
 export type ColorHex = string;
+/** @internal */
 export declare function colorDistance(a: ColorHex, b: ColorHex): number;
+/** @internal */
 export declare function concealmentScore(entityColors: readonly ColorHex[], backgroundColors: readonly ColorHex[]): number;
 export interface ConcealmentTarget {
     id: string;
@@ -16,6 +18,7 @@ export interface ConcealmentSensor {
     tick(targets: readonly ConcealmentTarget[], dt: number): ConcealmentSample[];
     reset(id?: string): void;
 }
+/** @internal */
 export declare function createConcealmentSensor(config?: {
     threshold?: number;
 }): ConcealmentSensor;

package/dist/sensor/concealment.js

@@ -13,10 +13,12 @@ function redmean(a, b) {
     return Math.sqrt((2 + rmean / 256) * dr * dr + 4 * dg * dg + (2 + (255 - rmean) / 256) * db * db);
 }
 const REDMEAN_MAX = redmean([0, 0, 0], [255, 255, 255]);
+/** @internal */
 export function colorDistance(a, b) {
     const distance = redmean(parseHex(a), parseHex(b));
     return REDMEAN_MAX === 0 ? 0 : Math.min(1, distance / REDMEAN_MAX);
 }
+/** @internal */
 export function concealmentScore(entityColors, backgroundColors) {
     if (entityColors.length === 0 || backgroundColors.length === 0)
         return 0;
@@ -32,6 +34,7 @@ export function concealmentScore(entityColors, backgroundColors) {
     }
     return 1 - total / entityColors.length;
 }
+/** @internal */
 export function createConcealmentSensor(config) {
     const threshold = config?.threshold ?? 0.7;
     const dwell = new Map();

package/dist/sensor/freezeMonitor.d.ts

@@ -11,6 +11,7 @@ export interface FreezeMonitor {
     tick(subjects: readonly FreezeSubject[], frozenIds: ReadonlySet<string>, dt: number): FreezeViolation[];
     reset(id?: string): void;
 }
+/** @internal */
 export declare function createFreezeMonitor(config?: {
     toleranceSpeed?: number;
     graceSeconds?: number;

package/dist/sensor/freezeMonitor.js

@@ -1,3 +1,4 @@
+/** @internal */
 export function createFreezeMonitor(config) {
     const toleranceSpeed = config?.toleranceSpeed ?? 0.05;
     const graceSeconds = config?.graceSeconds ?? 0;

package/dist/sensor/frustumSensor.d.ts

@@ -26,7 +26,8 @@ export interface FrustumProjection {
  * Project a world point into the camera's view. Pure geometry — no three.js —
  * so a game can run "is this framed?" checks headlessly (photo-mode scoring,
  * server-side kill-cam validation) as well as from the live render camera.
- */
+  * @internal
+  */
 export declare function projectToView(camera: FrustumCamera, point: EntityPosition): FrustumProjection;
 export interface FramingConfig {
     /** World-unit distance from camera that reads as "ideally framed" size. Default 6. */
@@ -36,7 +37,9 @@ export interface FramingConfig {
     /** Weight of subject size (distance-to-ideal) in the framing score. Default 0.4. */
     sizeWeight?: number;
 }
-/** 0 (not framed) .. 1 (dead-center, ideal distance) framing quality for an in-view projection. */
+/** 0 (not framed) .. 1 (dead-center, ideal distance) framing quality for an in-view projection.
+ * @internal
+ */
 export declare function framingScore(projection: FrustumProjection, config?: FramingConfig): number;
 export interface FrustumSample {
     id: string;
@@ -56,5 +59,6 @@ export interface FrustumSensor {
  * A view-frustum sensor on a held camera object: which entities are in frame,
  * how well framed they are, and how long they've stayed on-screen (photo-mode
  * "is this subject framed", Content Warning-style monster-filming scoring).
- */
+  * @internal
+  */
 export declare function createFrustumSensor(config?: FramingConfig): FrustumSensor;

package/dist/sensor/frustumSensor.js

@@ -19,7 +19,8 @@ const WORLD_UP = [0, 1, 0];
  * Project a world point into the camera's view. Pure geometry — no three.js —
  * so a game can run "is this framed?" checks headlessly (photo-mode scoring,
  * server-side kill-cam validation) as well as from the live render camera.
- */
+  * @internal
+  */
 export function projectToView(camera, point) {
     const forward = normalize(subtract(camera.lookAt, camera.position));
     const relative = subtract(point, camera.position);
@@ -47,7 +48,9 @@ export function projectToView(camera, point) {
     const inView = Math.abs(screenX) <= 1 && Math.abs(screenY) <= 1;
     return { inView, distance, screenX, screenY };
 }
-/** 0 (not framed) .. 1 (dead-center, ideal distance) framing quality for an in-view projection. */
+/** 0 (not framed) .. 1 (dead-center, ideal distance) framing quality for an in-view projection.
+ * @internal
+ */
 export function framingScore(projection, config) {
     if (!projection.inView)
         return 0;
@@ -65,7 +68,8 @@ export function framingScore(projection, config) {
  * A view-frustum sensor on a held camera object: which entities are in frame,
  * how well framed they are, and how long they've stayed on-screen (photo-mode
  * "is this subject framed", Content Warning-style monster-filming scoring).
- */
+  * @internal
+  */
 export function createFrustumSensor(config) {
     const dwell = new Map();
     return {

package/dist/sensor/hiddenStateProbe.d.ts

@@ -25,7 +25,10 @@ export interface SensorReading {
  * `proximityPrompt` (a UI affordance), this reads world state the player has no
  * other way to see — the strongest in-range reading wins, mirroring how a real
  * handheld sensor needle settles on the loudest nearby source.
- */
+  * @internal
+  */
 export declare function probeHiddenState(origin: EntityPosition, sources: readonly HiddenStateSource[], options: SensorProbeOptions): SensorReading | null;
-/** All in-range readings for `variableId`, strongest first. */
+/** All in-range readings for `variableId`, strongest first.
+ * @internal
+ */
 export declare function probeHiddenStateAll(origin: EntityPosition, sources: readonly HiddenStateSource[], options: SensorProbeOptions): SensorReading[];

package/dist/sensor/hiddenStateProbe.js

@@ -12,12 +12,15 @@ function strengthAt(distance, range, falloff) {
  * `proximityPrompt` (a UI affordance), this reads world state the player has no
  * other way to see — the strongest in-range reading wins, mirroring how a real
  * handheld sensor needle settles on the loudest nearby source.
- */
+  * @internal
+  */
 export function probeHiddenState(origin, sources, options) {
     const readings = probeHiddenStateAll(origin, sources, options);
     return readings.length === 0 ? null : readings[0];
 }
-/** All in-range readings for `variableId`, strongest first. */
+/** All in-range readings for `variableId`, strongest first.
+ * @internal
+ */
 export function probeHiddenStateAll(origin, sources, options) {
     const { range, variableId, falloff = "linear" } = options;
     const readings = [];

package/dist/sensor/recordingBuffer.d.ts

@@ -31,5 +31,6 @@ export interface RecordingBuffer<T> {
  * 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.
- */
+  * @internal
+  */
 export declare function createRecordingBuffer<T>(options?: RecordingBufferOptions): RecordingBuffer<T>;

package/dist/sensor/recordingBuffer.js

@@ -17,7 +17,8 @@ function evict(frames, options) {
  * 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.
- */
+  * @internal
+  */
 export function createRecordingBuffer(options = {}) {
     const frames = [];
     function floorIndex(t) {

package/dist/sensor/replayLoop.d.ts

@@ -14,6 +14,7 @@ export interface ReplayLoop<T> {
     duration(): number;
     sample(t: number): T | null;
 }
+/** @internal */
 export declare function createReplayLoop<T>(buffer: RecordingBuffer<T>, options?: ReplayLoopOptions<T>): ReplayLoop<T>;
 export interface ReplayEntityDeps {
     has(id: string): boolean;
@@ -29,11 +30,14 @@ export interface RecordedPoseLike {
     position: readonly [number, number, number];
     rotationY?: number;
 }
-/** Linear pose blend for `ReplayLoopOptions.interpolate` — position lerp plus shortest-arc yaw. */
+/** Linear pose blend for `ReplayLoopOptions.interpolate` — position lerp plus shortest-arc yaw.
+ * @internal
+ */
 export declare function interpolateRecordedPose<T extends RecordedPoseLike>(before: T, after: T, alpha: number): T;
 /**
  * Reconcile a replayed pose against an entity store: spawns the ghost on the first non-null sample,
  * poses it while samples flow, despawns it through grace gaps or after the recording empties.
  * `deps` matches `ctx.scene.entity` structurally — pass `{ has: (id) => ctx.scene.entity.get(id) !== null, spawn, setPose, despawn }`.
- */
+  * @internal
+  */
 export declare function syncReplayEntity(deps: ReplayEntityDeps, id: string, pose: RecordedPoseLike | null, dt?: number): void;

package/dist/sensor/replayLoop.js

@@ -1,3 +1,4 @@
+/** @internal */
 export function createReplayLoop(buffer, options = {}) {
     const grace = Math.max(0, options.spawnGraceSeconds ?? 0);
     const interpolate = options.interpolate;
@@ -26,7 +27,9 @@ export function createReplayLoop(buffer, options = {}) {
         },
     };
 }
-/** Linear pose blend for `ReplayLoopOptions.interpolate` — position lerp plus shortest-arc yaw. */
+/** Linear pose blend for `ReplayLoopOptions.interpolate` — position lerp plus shortest-arc yaw.
+ * @internal
+ */
 export function interpolateRecordedPose(before, after, alpha) {
     let yawDelta = (after.rotationY ?? 0) - (before.rotationY ?? 0);
     while (yawDelta > Math.PI)
@@ -47,7 +50,8 @@ export function interpolateRecordedPose(before, after, alpha) {
  * Reconcile a replayed pose against an entity store: spawns the ghost on the first non-null sample,
  * poses it while samples flow, despawns it through grace gaps or after the recording empties.
  * `deps` matches `ctx.scene.entity` structurally — pass `{ has: (id) => ctx.scene.entity.get(id) !== null, spawn, setPose, despawn }`.
- */
+  * @internal
+  */
 export function syncReplayEntity(deps, id, pose, dt) {
     if (pose === null) {
         if (deps.has(id))

package/dist/sensor/revealQuery.d.ts

@@ -18,5 +18,6 @@ export interface RevealQuery {
  * 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.
- */
+  * @internal
+  */
 export declare function createRevealQuery(options: RevealQueryOptions): RevealQuery;

package/dist/sensor/revealQuery.js

@@ -5,7 +5,8 @@ import { distanceBetween } from "../scene/spatial.js";
  * 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.
- */
+  * @internal
+  */
 export function createRevealQuery(options) {
     const { resolvePosition, resolveTags, candidates } = options;
     return {

package/dist/sensor/visionCone.d.ts

@@ -9,11 +9,17 @@ export interface VisionConeConfig {
     /** Full cone opening angle in radians (matches `TelegraphShape`'s cone `angle`). */
     angle: number;
 }
-/** 2D segment intersection on the XZ plane (collinear overlaps count) — the LoS building block `revealQuery`/`frustumSensor` never shipped (#286.5). */
+/** 2D segment intersection on the XZ plane (collinear overlaps count) — the LoS building block `revealQuery`/`frustumSensor` never shipped (#286.5).
+ * @internal
+ */
 export declare function segmentsIntersect(a1: VisionPoint, a2: VisionPoint, b1: VisionPoint, b2: VisionPoint): boolean;
-/** True when no wall segment crosses the sight line. */
+/** True when no wall segment crosses the sight line.
+ * @internal
+ */
 export declare function hasWallLineOfSight(from: VisionPoint, to: VisionPoint, walls: readonly VisionWall[]): boolean;
-/** Angle + range test only — no occlusion. `heading` is engine yaw (radians, `atan2(dx, dz)`). */
+/** Angle + range test only — no occlusion. `heading` is engine yaw (radians, `atan2(dx, dz)`).
+ * @internal
+ */
 export declare function pointInCone(origin: VisionPoint, heading: number, config: VisionConeConfig, point: VisionPoint): boolean;
 export interface VisionTarget<TId extends string = string> {
     id: TId;
@@ -28,4 +34,5 @@ export interface VisionCone {
     canSee(origin: VisionPoint, heading: number, target: VisionPoint): boolean;
     visibleTargets<TId extends string>(origin: VisionPoint, heading: number, targets: readonly VisionTarget<TId>[]): TId[];
 }
+/** @internal */
 export declare function createVisionCone(config: VisionConeConfig, walls?: readonly VisionWall[]): VisionCone;

package/dist/sensor/visionCone.js

@@ -12,7 +12,9 @@ function onSegment(ax, az, bx, bz, cx, cz) {
         Math.min(az, bz) - 1e-9 <= cz &&
         cz <= Math.max(az, bz) + 1e-9);
 }
-/** 2D segment intersection on the XZ plane (collinear overlaps count) — the LoS building block `revealQuery`/`frustumSensor` never shipped (#286.5). */
+/** 2D segment intersection on the XZ plane (collinear overlaps count) — the LoS building block `revealQuery`/`frustumSensor` never shipped (#286.5).
+ * @internal
+ */
 export function segmentsIntersect(a1, a2, b1, b2) {
     const o1 = orientation(a1[0], a1[1], a2[0], a2[1], b1[0], b1[1]);
     const o2 = orientation(a1[0], a1[1], a2[0], a2[1], b2[0], b2[1]);
@@ -30,7 +32,9 @@ export function segmentsIntersect(a1, a2, b1, b2) {
         return true;
     return false;
 }
-/** True when no wall segment crosses the sight line. */
+/** True when no wall segment crosses the sight line.
+ * @internal
+ */
 export function hasWallLineOfSight(from, to, walls) {
     for (const wall of walls) {
         if (segmentsIntersect(from, to, wall.from, wall.to))
@@ -38,7 +42,9 @@ export function hasWallLineOfSight(from, to, walls) {
     }
     return true;
 }
-/** Angle + range test only — no occlusion. `heading` is engine yaw (radians, `atan2(dx, dz)`). */
+/** Angle + range test only — no occlusion. `heading` is engine yaw (radians, `atan2(dx, dz)`).
+ * @internal
+ */
 export function pointInCone(origin, heading, config, point) {
     const dx = point[0] - origin[0];
     const dz = point[1] - origin[1];
@@ -54,6 +60,7 @@ export function pointInCone(origin, heading, config, point) {
         delta += Math.PI * 2;
     return Math.abs(delta) <= config.angle / 2;
 }
+/** @internal */
 export function createVisionCone(config, walls = []) {
     function canSee(origin, heading, target) {
         return pointInCone(origin, heading, config, target) && hasWallLineOfSight(origin, target, walls);

package/dist/session/contestedChannel.d.ts

@@ -33,4 +33,5 @@ export interface ContestedChannel {
     remaining(): number;
     snapshot(): ContestedSnapshot;
 }
+/** @internal */
 export declare function createContestedChannel(config: ContestedChannelConfig): ContestedChannel;

package/dist/session/contestedChannel.js

@@ -10,6 +10,7 @@ function anyContester(occupants, owner) {
     }
     return false;
 }
+/** @internal */
 export function createContestedChannel(config) {
     const duration = config.duration > 0 ? config.duration : Number.EPSILON;
     const interruptOnDamage = config.interruptOnDamage ?? true;

package/dist/session/extraction.d.ts

@@ -51,4 +51,5 @@ export interface RaidSession {
     status(userId: string): RaidStatus;
     playerSnapshot(userId: string): RaidPlayerSnapshot;
 }
+/** @internal */
 export declare function createRaidSession(config: RaidSessionConfig): RaidSession;

package/dist/session/extraction.js

@@ -18,6 +18,7 @@ function mergeAll(containers) {
             out.push({ itemId, count });
     return out;
 }
+/** @internal */
 export function createRaidSession(config) {
     const points = new Map();
     for (const point of config.extracts)

package/dist/session/roles.d.ts

@@ -3,4 +3,10 @@ export interface RoleSpec {
     count?: number;
     ratio?: number;
 }
+/**
+ * Assign hidden or team roles across players by ratio — social-deduction and team-shuffle setups.
+ *
+ * @capability role-assign assign hidden or team roles to players by ratio
+  * @internal
+  */
 export declare function assignRoles(userIds: readonly string[], roles: readonly RoleSpec[], rng?: () => number): Record<string, string>;

package/dist/session/roles.js

@@ -1,4 +1,10 @@
 import { shuffleWithRng } from "../cards/cardPile.js";
+/**
+ * Assign hidden or team roles across players by ratio — social-deduction and team-shuffle setups.
+ *
+ * @capability role-assign assign hidden or team roles to players by ratio
+  * @internal
+  */
 export function assignRoles(userIds, roles, rng = Math.random) {
     if (roles.length === 0)
         throw new Error("assignRoles needs at least one role");

package/dist/session/roundState.d.ts

@@ -72,8 +72,16 @@ export interface RoundState<TPhase extends string = RoundPhase> {
     roleOf(team: string): string | undefined;
     snapshot(): RoundSnapshot<TPhase>;
 }
+/** @internal */
 export declare function lossBonusFor(rule: LossBonusRule | undefined, streak: number): number;
+/**
+ * Run a match as repeating buy/action/end round phases with per-round win rewards and loss-streak economy.
+ *
+ * @capability match-rounds run buy/action/end round phases with per-round economy
+  * @internal
+  */
 export declare function createRoundState(config: RoundConfig<RoundPhase>): RoundState<RoundPhase>;
+/** @internal */
 export declare function createRoundState<TPhase extends string>(config: RoundConfig<TPhase> & {
     phaseOrder: readonly TPhase[];
 }): RoundState<TPhase>;

package/dist/session/roundState.js

@@ -1,4 +1,5 @@
 const DEFAULT_PHASE_ORDER = ["buy", "live", "end"];
+/** @internal */
 export function lossBonusFor(rule, streak) {
     if (rule === undefined)
         return 0;
@@ -17,6 +18,7 @@ function isConcludable(order, phase) {
     const idx = order.indexOf(phase);
     return idx > 0 && idx < order.length - 1;
 }
+/** @internal */
 export function createRoundState(config) {
     const order = config.phaseOrder ?? DEFAULT_PHASE_ORDER;
     const durations = config.phases;

package/dist/settings/settingsModel.d.ts

@@ -67,6 +67,7 @@ export declare const SETTING_IDS: {
     readonly graphicsQuality: "graphics.quality";
     readonly graphicsShadows: "graphics.shadows";
     readonly graphicsUiScale: "graphics.uiScale";
+    readonly touchStyle: "controls.touchStyle";
 };
 export type GraphicsQuality = "low" | "medium" | "high";
 export declare const GRAPHICS_QUALITY_OPTIONS: readonly SettingOption[];

package/dist/settings/settingsModel.js

@@ -11,6 +11,7 @@ export const SETTING_IDS = {
     graphicsQuality: "graphics.quality",
     graphicsShadows: "graphics.shadows",
     graphicsUiScale: "graphics.uiScale",
+    touchStyle: "controls.touchStyle",
 };
 export const GRAPHICS_QUALITY_OPTIONS = [
     { value: "low", label: "Low" },

package/dist/stats/accumulatorMeter.d.ts

@@ -27,5 +27,11 @@ export interface AccumulatorMeter {
     reset(): void;
     tick(dtSeconds: number): void;
 }
+/** The highest tier id whose `at` threshold `value` has reached, or `null` below every tier — the pure lookup `createAccumulatorMeter`/`createEventMeter` call on every `add`/`tick`. */
 export declare function tierAt(value: number, tiers: readonly MeterTier[]): string | null;
+/**
+ * A raw accumulating gauge that crosses named tier thresholds as a value builds, with optional decay — the primitive under charge, rage, and combo meters.
+ *
+ * @capability charge-meter fill a gauge toward named tier thresholds as a value accumulates
+ */
 export declare function createAccumulatorMeter(config: AccumulatorMeterConfig): AccumulatorMeter;

package/dist/stats/accumulatorMeter.js

@@ -3,6 +3,7 @@ function sortedTiers(tiers) {
         return [];
     return [...tiers].sort((a, b) => a.at - b.at);
 }
+/** The highest tier id whose `at` threshold `value` has reached, or `null` below every tier — the pure lookup `createAccumulatorMeter`/`createEventMeter` call on every `add`/`tick`. */
 export function tierAt(value, tiers) {
     let current = null;
     for (const tier of tiers) {
@@ -13,6 +14,11 @@ export function tierAt(value, tiers) {
     }
     return current;
 }
+/**
+ * A raw accumulating gauge that crosses named tier thresholds as a value builds, with optional decay — the primitive under charge, rage, and combo meters.
+ *
+ * @capability charge-meter fill a gauge toward named tier thresholds as a value accumulates
+ */
 export function createAccumulatorMeter(config) {
     const mode = config.mode ?? "hold";
     const tiers = sortedTiers(config.tiers);

package/dist/stats/eventMeter.d.ts

@@ -31,4 +31,9 @@ export interface EventMeter {
     reset(): void;
     tick(dtSeconds: number): void;
 }
+/**
+ * A heat/hype gauge that rises as tagged events land and cools between them, firing when it fills or breaks — the streak/overdrive meter shooters and fighters hand-roll.
+ *
+ * @capability event-meter a heat/streak gauge that builds from repeated hits and cools down over time
+ */
 export declare function createEventMeter(config: EventMeterConfig): EventMeter;

package/dist/stats/eventMeter.js

@@ -2,6 +2,11 @@ import { createAccumulatorMeter, } from "./accumulatorMeter.js";
 function readyOf(meter, mode) {
     return mode === "hold" ? meter.broke() : meter.value() >= 0 && meter.fraction() >= 1;
 }
+/**
+ * A heat/hype gauge that rises as tagged events land and cools between them, firing when it fills or breaks — the streak/overdrive meter shooters and fighters hand-roll.
+ *
+ * @capability event-meter a heat/streak gauge that builds from repeated hits and cools down over time
+ */
 export function createEventMeter(config) {
     const mode = config.mode ?? "hold";
     const resets = new Set(config.resets ?? []);

package/dist/stats/rollCheck.d.ts

@@ -12,4 +12,9 @@ export interface CheckResult {
     success: boolean;
     critical: "success" | "failure" | null;
 }
+/**
+ * Resolve a tabletop-style pass/fail roll against a target number with modifiers and crit/fumble bands.
+ *
+ * @capability dice-check resolve a pass/fail roll against a target number with modifiers and crits
+ */
 export declare function rollCheck(input: CheckInput, rng?: () => number): CheckResult;

package/dist/stats/rollCheck.js

@@ -1,3 +1,8 @@
+/**
+ * Resolve a tabletop-style pass/fail roll against a target number with modifiers and crit/fumble bands.
+ *
+ * @capability dice-check resolve a pass/fail roll against a target number with modifiers and crits
+ */
 export function rollCheck(input, rng = Math.random) {
     const sides = input.diceSides ?? 20;
     const advantage = input.advantage ?? "normal";