@kar-mi/spirit-vale-tools-metrics 0.2.0

package/README.md

@@ -0,0 +1,60 @@
+# @kar-mi/spirit-vale-tools-metrics
+
+Shared rate-estimation primitives for Spirit Vale tools.
+
+> **Internal package.** This package is published only because the domain
+> packages (`combat`, `rewards`) depend on it at runtime; it is installed
+> automatically alongside them and is not a supported public API.
+
+## Install
+
+```sh
+bun add @kar-mi/spirit-vale-tools-metrics
+```
+
+## Usage
+
+`RateTracker` accumulates one metric — experience, coins, or anything else countable — into a
+running total, an exponentially-weighted per-second rate, and a bucketed timeline for graphing. It
+is value-agnostic, so a second instance fed a different metric behaves identically:
+
+```ts
+import { RateTracker } from "@kar-mi/spirit-vale-tools-metrics";
+
+const experience = new RateTracker();
+const coins = new RateTracker();
+
+experience.record(kill.experience, recordedAtMs);
+coins.record(kill.coins, recordedAtMs);
+
+const { total, perSecond, perHour, timeline } = experience.snapshot(Date.now());
+```
+
+`ewmaSeries` replays a snapshot's `timeline` to reconstruct `perSecond` over time, so a chart and
+the single number beside it stay in step:
+
+```ts
+import { ewmaSeries } from "@kar-mi/spirit-vale-tools-metrics";
+
+const points = ewmaSeries(timeline, { start: Date.now() - 600_000, end: Date.now() });
+```
+
+`EwmaRate` is the underlying O(1) estimator, used directly where the caller keeps its own timeline
+(the combat meter's `currentDps`). Recording a value of `v` adds `v / tau` to the rate, which then
+fades as `e^{-elapsed / tau}` — no window edge, and no discontinuity when an old event ages out.
+
+### Choosing a time constant
+
+A flat rolling window of width `W` and an EWMA of time constant `tau` have equal estimator variance
+when `W = 2 * tau`, and equal mean lag. A 5-second window is therefore reproduced by
+`tauSeconds: 2.5`. Sparse metrics want a much longer constant — `RateTracker` defaults to 20
+seconds, which keeps a single kill visible for about a minute.
+
+`rateAt(nowMs, rampFromMs)` corrects the cold start: an estimator rising from zero under-reads a
+steady stream by `1 - e^{-elapsed / tau}` (63% low at one tau). Pass the moment observation began
+for dense streams read from the first instant; omit it for sparse gains, where the ramp is
+indistinguishable from genuinely having earned nothing yet.
+
+## License
+
+See [LICENSE.txt](../../LICENSE.txt).

package/dist/bucket-timeline.d.ts

@@ -0,0 +1,24 @@
+export interface BucketTimelineOptions {
+    /** Width of each bucket. Defaults to one second. */
+    bucketMs?: number;
+    /** How much trailing history to retain. Defaults to one hour. */
+    retentionMs?: number;
+}
+export interface TimelineBucket {
+    atMs: number;
+    value: number;
+}
+/** A trailing FIFO of fixed-width buckets: the graphable history behind a rate, and its window sum. */
+export declare class BucketTimeline {
+    private readonly bucketMs;
+    private readonly retentionMs;
+    private readonly buckets;
+    constructor(options?: BucketTimelineOptions);
+    record(value: number, atMs: number): void;
+    /** Total of every retained bucket — i.e. the sum over the retention window as of `nowMs`. */
+    windowSum(nowMs: number): number;
+    points(nowMs: number): TimelineBucket[];
+    reset(): void;
+    private prune;
+}
+//# sourceMappingURL=bucket-timeline.d.ts.map

package/dist/bucket-timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bucket-timeline.d.ts","sourceRoot":"","sources":["../src/bucket-timeline.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,uGAAuG;AACvG,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAEhD,YAAY,OAAO,GAAE,qBAA0B,EAG9C;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAMxC;IAED,6FAA6F;IAC7F,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK/B;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAGtC;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,OAAO,CAAC,KAAK;CAId"}

package/dist/ewma-rate.d.ts

@@ -0,0 +1,37 @@
+/** Continuous-time exponentially-weighted rate estimator (a "leaky bucket"). */
+export interface EwmaRateOptions {
+    /** Decay time constant, in seconds. */
+    tauSeconds: number;
+}
+/** Cold-start correction for a `rateAt` read. See {@link EwmaRate.rateAt}. */
+export interface EwmaRamp {
+    /** The moment observation of this stream began. */
+    fromMs: number;
+    /** Floor on the elapsed time, so the first moments do not divide by a near-zero factor. Defaults to 1000ms. */
+    minimumMs?: number;
+}
+/** Durable state of an estimator, safe to persist and later restore. */
+export interface EwmaRateState {
+    rate: number;
+    updatedAtMs: number;
+    tauSeconds: number;
+}
+export declare class EwmaRate {
+    readonly tauSeconds: number;
+    private rate;
+    private updatedAtMs;
+    constructor(options: EwmaRateOptions);
+    /** A fresh estimator with the same time constant — for building a merge target from its sources. */
+    emptyLike(): EwmaRate;
+    record(value: number, atMs: number): void;
+    /** The estimated rate per second as of `nowMs`, decayed lazily without mutating state. */
+    rateAt(nowMs: number, ramp?: EwmaRamp): number;
+    reset(atMs: number): void;
+    state(): EwmaRateState;
+    /** Restores a persisted rate. The state's own `tauSeconds` must match, since the two only mean anything together. */
+    restore(state: EwmaRateState): void;
+    /** Folds `other` into this estimator. */
+    add(other: EwmaRate): void;
+    private decayTo;
+}
+//# sourceMappingURL=ewma-rate.d.ts.map

package/dist/ewma-rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ewma-rate.d.ts","sourceRoot":"","sources":["../src/ewma-rate.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,8EAA8E;AAC9E,MAAM,WAAW,QAAQ;IACvB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,+GAA+G;IAC/G,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,qBAAa,QAAQ;IACnB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,WAAW,CAAK;IAExB,YAAY,OAAO,EAAE,eAAe,EAKnC;IAED,oGAAoG;IACpG,SAAS,IAAI,QAAQ,CAEpB;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIxC;IAED,0FAA0F;IAC1F,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,MAAM,CAM7C;IAED,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAGxB;IAED,KAAK,IAAI,aAAa,CAErB;IAED,qHAAqH;IACrH,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAIlC;IAED,yCAAyC;IACzC,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAKzB;IAED,OAAO,CAAC,OAAO;CAKhB"}

package/dist/ewma-series.d.ts

@@ -0,0 +1,16 @@
+import type { TimelineBucket } from "./bucket-timeline.ts";
+export interface EwmaSeriesPoint {
+    time: number;
+    value: number;
+}
+export interface EwmaSeriesOptions {
+    /** Must match the tracker whose timeline is being replayed, or the chart will diverge from its `perSecond`. Defaults to 20 seconds. */
+    tauSeconds?: number;
+    /** Spacing between plotted points. Defaults to one second. */
+    stepMs?: number;
+}
+export declare function ewmaSeries(buckets: readonly TimelineBucket[], range: {
+    start: number;
+    end: number;
+}, options?: EwmaSeriesOptions): EwmaSeriesPoint[];
+//# sourceMappingURL=ewma-series.d.ts.map

package/dist/ewma-series.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ewma-series.d.ts","sourceRoot":"","sources":["../src/ewma-series.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAI3D,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,uIAAuI;IACvI,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACrC,OAAO,GAAE,iBAAsB,GAC9B,eAAe,EAAE,CAyBnB"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { BucketTimeline } from "./bucket-timeline.ts";
+export type { BucketTimelineOptions, TimelineBucket } from "./bucket-timeline.ts";
+export { EwmaRate } from "./ewma-rate.ts";
+export type { EwmaRamp, EwmaRateOptions, EwmaRateState } from "./ewma-rate.ts";
+export { ewmaSeries } from "./ewma-series.ts";
+export type { EwmaSeriesOptions, EwmaSeriesPoint } from "./ewma-series.ts";
+export { DEFAULT_RATE_TAU_SECONDS, RateTracker } from "./rate-tracker.ts";
+export type { RateCheckpoint, RateSnapshot, RateTrackerOptions } from "./rate-tracker.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC1E,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,203 @@
+// @bun
+// src/bucket-timeline.ts
+var DEFAULT_BUCKET_MS = 1000;
+var DEFAULT_RETENTION_MS = 60 * 60 * 1000;
+
+class BucketTimeline {
+  bucketMs;
+  retentionMs;
+  buckets = [];
+  constructor(options = {}) {
+    this.bucketMs = positiveFinite(options.bucketMs ?? DEFAULT_BUCKET_MS, "bucketMs");
+    this.retentionMs = positiveFinite(options.retentionMs ?? DEFAULT_RETENTION_MS, "retentionMs");
+  }
+  record(value, atMs) {
+    const bucketAtMs = Math.floor(atMs / this.bucketMs) * this.bucketMs;
+    const last = this.buckets.at(-1);
+    if (last && last.atMs === bucketAtMs)
+      last.value += value;
+    else
+      this.buckets.push({ atMs: bucketAtMs, value });
+    this.prune(atMs);
+  }
+  windowSum(nowMs) {
+    this.prune(nowMs);
+    let sum = 0;
+    for (const bucket of this.buckets)
+      sum += bucket.value;
+    return sum;
+  }
+  points(nowMs) {
+    this.prune(nowMs);
+    return this.buckets.map((bucket) => ({ ...bucket }));
+  }
+  reset() {
+    this.buckets.length = 0;
+  }
+  prune(nowMs) {
+    const cutoff = nowMs - this.retentionMs;
+    while (this.buckets.length > 0 && this.buckets[0].atMs < cutoff)
+      this.buckets.shift();
+  }
+}
+function positiveFinite(value, label) {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new Error(`${label} must be a positive finite number`);
+  return value;
+}
+// src/ewma-rate.ts
+var DEFAULT_MINIMUM_RAMP_MS = 1000;
+
+class EwmaRate {
+  tauSeconds;
+  rate = 0;
+  updatedAtMs = 0;
+  constructor(options) {
+    if (!Number.isFinite(options.tauSeconds) || options.tauSeconds <= 0) {
+      throw new Error("tauSeconds must be a positive finite number");
+    }
+    this.tauSeconds = options.tauSeconds;
+  }
+  emptyLike() {
+    return new EwmaRate({ tauSeconds: this.tauSeconds });
+  }
+  record(value, atMs) {
+    if (!(value > 0))
+      return;
+    this.decayTo(atMs);
+    this.rate += value / this.tauSeconds;
+  }
+  rateAt(nowMs, ramp) {
+    const decaySeconds = Math.max(0, nowMs - this.updatedAtMs) / 1000;
+    const decayed = this.rate * Math.exp(-decaySeconds / this.tauSeconds);
+    if (ramp === undefined)
+      return decayed;
+    const elapsedMs = Math.max(ramp.minimumMs ?? DEFAULT_MINIMUM_RAMP_MS, nowMs - ramp.fromMs);
+    return decayed / (1 - Math.exp(-elapsedMs / 1000 / this.tauSeconds));
+  }
+  reset(atMs) {
+    this.rate = 0;
+    this.updatedAtMs = atMs;
+  }
+  state() {
+    return { rate: this.rate, updatedAtMs: this.updatedAtMs, tauSeconds: this.tauSeconds };
+  }
+  restore(state) {
+    if (state.tauSeconds !== this.tauSeconds)
+      throw new Error("cannot restore state accumulated with a different tauSeconds");
+    this.rate = state.rate;
+    this.updatedAtMs = state.updatedAtMs;
+  }
+  add(other) {
+    if (other.tauSeconds !== this.tauSeconds)
+      throw new Error("cannot merge estimators with different tauSeconds");
+    const atMs = Math.max(this.updatedAtMs, other.updatedAtMs);
+    this.decayTo(atMs);
+    this.rate += other.rate * Math.exp(-Math.max(0, atMs - other.updatedAtMs) / 1000 / this.tauSeconds);
+  }
+  decayTo(atMs) {
+    const dtSeconds = Math.max(0, atMs - this.updatedAtMs) / 1000;
+    this.rate *= Math.exp(-dtSeconds / this.tauSeconds);
+    this.updatedAtMs = Math.max(this.updatedAtMs, atMs);
+  }
+}
+// src/rate-tracker.ts
+var DEFAULT_RATE_TAU_SECONDS = 20;
+
+class RateTracker {
+  total = 0;
+  watermarkMs = 0;
+  watermarkOccurrences = 0;
+  replayedAtWatermark = 0;
+  rate;
+  timeline;
+  constructor(options = {}) {
+    this.rate = new EwmaRate({ tauSeconds: options.tauSeconds ?? DEFAULT_RATE_TAU_SECONDS });
+    this.timeline = new BucketTimeline({
+      ...options.bucketMs === undefined ? {} : { bucketMs: options.bucketMs },
+      ...options.retentionMs === undefined ? {} : { retentionMs: options.retentionMs }
+    });
+  }
+  record(value, atMs) {
+    if (value <= 0 || atMs < this.watermarkMs)
+      return;
+    if (atMs > this.watermarkMs) {
+      this.watermarkMs = atMs;
+      this.watermarkOccurrences = 0;
+      this.replayedAtWatermark = 0;
+    }
+    this.replayedAtWatermark += 1;
+    if (this.replayedAtWatermark <= this.watermarkOccurrences)
+      return;
+    this.watermarkOccurrences = this.replayedAtWatermark;
+    this.total += value;
+    this.rate.record(value, atMs);
+    this.timeline.record(value, atMs);
+  }
+  reset(atMs) {
+    this.total = 0;
+    this.timeline.reset();
+    this.rate.reset(atMs);
+    if (atMs >= this.watermarkMs) {
+      this.watermarkMs = atMs;
+      this.watermarkOccurrences = 0;
+    }
+    this.replayedAtWatermark = 0;
+  }
+  restoreCheckpoint(checkpoint) {
+    this.total = Math.max(0, checkpoint.total);
+    this.watermarkMs = Math.max(0, checkpoint.watermarkMs);
+    this.watermarkOccurrences = Math.max(0, checkpoint.watermarkOccurrences);
+    this.replayedAtWatermark = 0;
+  }
+  currentTotal() {
+    return this.total;
+  }
+  currentCheckpoint() {
+    return { total: this.total, watermarkMs: this.watermarkMs, watermarkOccurrences: this.watermarkOccurrences };
+  }
+  snapshot(nowMs) {
+    return {
+      total: this.total,
+      perSecond: this.rate.rateAt(nowMs),
+      perHour: this.timeline.windowSum(nowMs),
+      timeline: this.timeline.points(nowMs)
+    };
+  }
+}
+
+// src/ewma-series.ts
+function ewmaSeries(buckets, range, options = {}) {
+  if (range.end <= range.start)
+    return [];
+  const stepMs = options.stepMs ?? 1000;
+  const rate = new EwmaRate({ tauSeconds: options.tauSeconds ?? DEFAULT_RATE_TAU_SECONDS });
+  rate.reset(buckets[0]?.atMs ?? range.start);
+  let bucketIndex = 0;
+  const consumeThrough = (toMs) => {
+    while (bucketIndex < buckets.length) {
+      const bucket = buckets[bucketIndex];
+      if (!bucket || bucket.atMs > toMs)
+        break;
+      rate.record(bucket.value, bucket.atMs);
+      bucketIndex += 1;
+    }
+    return rate.rateAt(toMs);
+  };
+  const points = [{ time: range.start, value: consumeThrough(range.start) }];
+  let next = Math.ceil(range.start / stepMs) * stepMs;
+  if (next <= range.start)
+    next += stepMs;
+  for (;next < range.end; next += stepMs) {
+    points.push({ time: next, value: consumeThrough(next) });
+  }
+  points.push({ time: range.end, value: consumeThrough(range.end) });
+  return points;
+}
+export {
+  BucketTimeline,
+  DEFAULT_RATE_TAU_SECONDS,
+  EwmaRate,
+  RateTracker,
+  ewmaSeries
+};

package/dist/rate-tracker.d.ts

@@ -0,0 +1,45 @@
+import type { TimelineBucket } from "./bucket-timeline.ts";
+/** Sparse gains (XP, coins) arrive seconds or minutes apart, so the rate is read far more often than it is updated and a short time constant would read as noise. */
+export declare const DEFAULT_RATE_TAU_SECONDS = 20;
+export interface RateTrackerOptions {
+    /** Decay constant for `perSecond`. Defaults to 20 seconds. */
+    tauSeconds?: number;
+    /** Width of the timeline buckets. Defaults to one second. */
+    bucketMs?: number;
+    /** Trailing history retained for `timeline` and summed into `perHour`. Defaults to one hour. */
+    retentionMs?: number;
+}
+export interface RateSnapshot {
+    /** Everything recorded since construction or the last `reset`. */
+    total: number;
+    /** Exponentially-weighted rate per second. */
+    perSecond: number;
+    /** Flat sum of the retention window — with the default hour of retention, the gain in the last hour. */
+    perHour: number;
+    timeline: TimelineBucket[];
+}
+/** Durable checkpoint of a tracker's progress, safe to persist and later restore with `restoreCheckpoint`. */
+export interface RateCheckpoint {
+    total: number;
+    watermarkMs: number;
+    /** How many gains were already counted at exactly `watermarkMs` — disambiguates gains that share a timestamp from a duplicate replay of the same gain. */
+    watermarkOccurrences: number;
+}
+export declare class RateTracker {
+    private total;
+    private watermarkMs;
+    private watermarkOccurrences;
+    private replayedAtWatermark;
+    private readonly rate;
+    private readonly timeline;
+    constructor(options?: RateTrackerOptions);
+    record(value: number, atMs: number): void;
+    /** `atMs` should be "now" — everything up to this moment is treated as already accounted for. */
+    reset(atMs: number): void;
+    /** Seeds the running total and watermark from a durable checkpoint without affecting the (in-memory-only) rate/timeline. */
+    restoreCheckpoint(checkpoint: RateCheckpoint): void;
+    currentTotal(): number;
+    currentCheckpoint(): RateCheckpoint;
+    snapshot(nowMs: number): RateSnapshot;
+}
+//# sourceMappingURL=rate-tracker.d.ts.map

package/dist/rate-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-tracker.d.ts","sourceRoot":"","sources":["../src/rate-tracker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,qKAAqK;AACrK,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,MAAM,WAAW,kBAAkB;IACjC,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,wGAAwG;IACxG,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED,8GAA8G;AAC9G,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,0JAA0J;IAC1J,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAE1C,YAAY,OAAO,GAAE,kBAAuB,EAM3C;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAaxC;IAED,iGAAiG;IACjG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CASxB;IAED,4HAA4H;IAC5H,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI,CAKlD;IAED,YAAY,IAAI,MAAM,CAErB;IAED,iBAAiB,IAAI,cAAc,CAElC;IAED,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAOpC;CACF"}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@kar-mi/spirit-vale-tools-metrics",
+  "version": "0.2.0",
+  "description": "Shared rate-estimation primitives for Spirit Vale tools.",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kar-mi/spirit-vale-tools.git",
+    "directory": "packages/metrics"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --format esm && bunx tsc --project ./tsconfig.build.json"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  }
+}