@logg/signals 0.2.0 → 0.4.0

package/README.md

@@ -2,7 +2,9 @@
 
 Universal event tracking SDK for Logg Signals. Track events from web, React Native, and Node.js applications.
 
-**Version 0.2.0**
+Also ships an embeddable on-device recommender as a separate entry point — see [On-Device Recommender](#on-device-recommender-loggsignalsreco).
+
+**Version 0.3.0**
 
 ## Features
 
@@ -12,7 +14,7 @@ Universal event tracking SDK for Logg Signals. Track events from web, React Nati
 ✅ **Persistent storage** - Uses localStorage, AsyncStorage, or memory as fallback  
 ✅ **Retry logic** - Exponential backoff for failed requests  
 ✅ **Auto metadata** - Automatically collects browser/device information  
-✅ **Small bundle** - <5KB gzipped  
+✅ **Small bundle** - <5KB gzipped (tracking entry; recommender is a separate opt-in entry)  
 
 ## Installation
 
@@ -455,6 +457,96 @@ function trackUserEvent(event: Omit<EventData, 'userId'>) {
 }
 ```
 
+## On-Device Recommender (`@logg/signals/reco`)
+
+A pure-TypeScript, zero-dependency recommendation engine that runs entirely on
+the client — ship it inside a React Native bundle, a web app, or a Node
+process. The backend hands the app a flat catalog (a few thousand items × a
+few feature columns); the device ranks it live as the user scrolls, dwells,
+taps, and favourites.
+
+It lives at its own entry point so tracking-only consumers don't pay for it:
+
+```typescript
+import { Recommender, DualBucketRecommender, SIGNALS } from '@logg/signals/reco';
+import type { BaseItem, Schema } from '@logg/signals/reco';
+```
+
+Two engines ship behind the same surface — pick at construction time:
+
+| Engine | Class | Best for |
+|---|---|---|
+| v1 | `Recommender` | Probabilistic exploration, smoother defaults |
+| v2 | `DualBucketRecommender` | Explicit liked/disliked separation, tighter exploit |
+
+The library is **domain-agnostic and generic over your item shape**. You bring
+an item type extending `BaseItem` (only `id` is required) and a `Schema<T>`
+that extracts categorical feature values from each item — the engine has no
+built-in vocabulary of brands, prices, or categories.
+
+```typescript
+import { Recommender, SIGNALS, logDecadeBucket, type BaseItem, type Schema } from '@logg/signals/reco';
+
+interface Listing extends BaseItem {
+  brand: string | null;
+  category: string | null;
+  price_cents: number | null;
+  popularity: number;
+}
+
+const schema = {
+  brand: { extract: (i: Listing) => i.brand, capacity: 4, weight: 0.4 },
+  category: { extract: (i: Listing) => i.category, capacity: 2, weight: 0.2 },
+  price_band: {
+    extract: (i: Listing) => (i.price_cents != null ? logDecadeBucket(i.price_cents / 100) : null),
+    weight: 0.4,
+  },
+} satisfies Schema<Listing>;
+
+const reco = new Recommender(catalog, {
+  schema,
+  popularity: (i) => i.popularity, // optional cold-start prior
+});
+
+reco.prime(usersCollection);          // pre-warm from a known collection
+reco.setOwned(['id-1', 'id-2']);      // excluded from results
+
+reco.engage(item, SIGNALS.view);      // saw and scrolled past
+reco.engage(item, SIGNALS.collect);   // added to collection
+reco.engage(item, -3);                // strong negative — caller picks any magnitude
+
+const { items, scores, diagnostics } = reco.recommend(20);
+```
+
+Methods shared by both engines: `prime()`, `engage()`, `recommend()`,
+`setOwned()`, `clearSeen()`, `reset()`, `seenCount()`. The dual engine adds
+`setSampleSize(k)` to tune explore vs. exploit.
+
+### Weighted scoring (dual engine) — `0.4.0`
+
+By default `DualBucketRecommender` ranks candidates by the sum of raw slot
+powers, which ignores each feature's schema `weight` and lets a
+low-cardinality feature (e.g. one dominant `category`) outweigh a
+high-cardinality one (e.g. `brand`) purely by accumulated mass. Pass
+`weightedScoring: true` to instead weight each feature by its schema `weight`
+and normalize a value's power to its share of the bucket (an ε-floored share,
+the same scheme the v1 engine uses):
+
+```typescript
+const reco = new DualBucketRecommender(catalog, { schema, weightedScoring: true });
+```
+
+This makes schema weights authoritative and removes the cardinality bias. It
+is **off by default** to preserve existing v2 ranking. Note the scale change:
+with the flag on, `net` / `diagnostics.bestNet` move from unbounded raw power
+to roughly `[−Σweight, +Σweight]` (≈ `[−1, 1]` when weights sum to 1), so any
+consumer comparing `bestNet` against a raw-power threshold must rescale.
+
+Advanced primitives (slot tables, interest state, bucket admission, the
+weighted sampler, the dual-bucket `bucketContribution`, and `seededRng` for
+deterministic tests) are exported from the same entry for callers building
+custom pipelines or CLIs on top.
+
 ## License
 
 MIT

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/index.js

@@ -18,8 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   AsyncStorageAdapter: () => AsyncStorageAdapter,
   EventQueue: () => EventQueue,
   LocalStorageAdapter: () => LocalStorageAdapter,
@@ -27,7 +27,7 @@ __export(index_exports, {
   Signals: () => Signals,
   getDefaultStorageAdapter: () => getDefaultStorageAdapter
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/utils/helpers.ts
 function uuid() {

package/dist/index.mjs

@@ -1,9 +1,6 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import {
+  __require
+} from "./chunk-Y6FXYEAI.mjs";
 
 // src/utils/helpers.ts
 function uuid() {

package/dist/reco.d.mts

@@ -0,0 +1,219 @@
+interface BaseItem {
+    id: string;
+}
+interface FeatureConfig<T extends BaseItem> {
+    extract: (item: T) => string | null;
+    capacity?: number;
+    challengerCapacity?: number;
+    epsilon?: number;
+    weight?: number;
+    decrementCap?: number;
+}
+type Schema<T extends BaseItem> = Record<string, FeatureConfig<T>>;
+declare const DEFAULT_CAPACITY = 3;
+declare const DEFAULT_DECREMENT_CAP = 4;
+declare const DEFAULT_EPSILON = 0.1;
+declare const SIGNALS: {
+    readonly view: 0.5;
+    readonly click: 2;
+    readonly dwell: 3;
+    readonly collect: 8;
+    readonly skip: -1;
+};
+type SignalName = keyof typeof SIGNALS;
+interface Slot {
+    value: string;
+    power: number;
+}
+
+interface SlotTableConfig {
+    capacity: number;
+    challengerCapacity: number;
+    epsilon: number;
+}
+declare const DEFAULT_SLOT_CONFIG: SlotTableConfig;
+interface SlotTableState {
+    slots: Slot[];
+    challengers: Slot[];
+}
+declare function emptyState(): SlotTableState;
+declare function observe(state: SlotTableState, value: string, weight: number, config?: SlotTableConfig): void;
+declare function decay(state: SlotTableState, factor: number): void;
+declare function contribution$1(state: SlotTableState, value: string | null, config?: SlotTableConfig): number;
+declare function isEmpty$1(state: SlotTableState): boolean;
+
+interface InterestConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    popularity?: (item: T) => number;
+    popularityWeight: number;
+    decayFactor: number;
+    decayEvery: number;
+}
+declare const DEFAULT_INTEREST_CONFIG: Omit<InterestConfig<BaseItem>, 'schema'>;
+type InterestState = {
+    tables: Record<string, SlotTableState>;
+    eventsSinceDecay: number;
+    totalEvents: number;
+};
+declare function emptyInterest<T extends BaseItem>(schema: Schema<T>): InterestState;
+declare function applyEvent<T extends BaseItem>(state: InterestState, item: T, magnitude: number, config: InterestConfig<T>): void;
+declare function scoreItem$1<T extends BaseItem>(state: InterestState, item: T, popularityNorm: number, config: InterestConfig<T>): number;
+declare function isCold$1(state: InterestState): boolean;
+declare function describe$1(state: InterestState, top?: number): Record<string, Array<[string, number]>>;
+
+type RNG = () => number;
+declare const defaultRng: RNG;
+declare function weightedSampleWithoutReplacement<T>(pool: T[], weight: (item: T) => number, count: number, rng?: RNG): T[];
+declare function seededRng(seed: number): RNG;
+
+interface RecommenderConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    popularity?: (item: T) => number;
+    popularityWeight?: number;
+    decayFactor?: number;
+    decayEvery?: number;
+    seenWindow?: number;
+    batchSize?: number;
+    rng?: RNG;
+}
+interface ResolvedConfig$1<T extends BaseItem> {
+    interest: InterestConfig<T>;
+    popularity: ((item: T) => number) | null;
+    seenWindow: number;
+    batchSize: number;
+    rng: RNG;
+}
+interface RecommendDiagnostics {
+    cold: boolean;
+    candidates: number;
+    excluded_seen: number;
+    excluded_owned: number;
+}
+interface RecommendResult<T extends BaseItem> {
+    items: T[];
+    scores: number[];
+    diagnostics: RecommendDiagnostics;
+}
+declare class Recommender<T extends BaseItem> {
+    readonly catalog: T[];
+    readonly byId: Map<string, T>;
+    readonly interest: InterestState;
+    readonly config: ResolvedConfig$1<T>;
+    readonly maxPopularity: number;
+    private ownedIds;
+    private seenOrder;
+    private seen;
+    constructor(catalog: T[], config: RecommenderConfig<T>);
+    setOwned(ids: Iterable<string>): void;
+    prime(items: T[], magnitudePerItem?: number): void;
+    engage(item: T, score: number): void;
+    recommend(count?: number): RecommendResult<T>;
+    seenCount(): number;
+    clearSeen(): void;
+    private markSeen;
+    reset(): void;
+}
+
+interface BucketState {
+    slots: Slot[];
+    pointer: number;
+}
+interface BucketConfig {
+    capacity: number;
+    decrementCap: number;
+}
+declare function emptyBucket(): BucketState;
+declare function admit(state: BucketState, value: string, score: number, config?: BucketConfig): void;
+declare function powerOf(state: BucketState, value: string | null): number;
+declare function contribution(state: BucketState, value: string | null, epsilon: number): number;
+declare function isEmpty(state: BucketState): boolean;
+
+interface DualInterestConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    weightedScoring?: boolean;
+}
+interface DualBucketState {
+    liked: Record<string, BucketState>;
+    disliked: Record<string, BucketState>;
+    totalEvents: number;
+}
+declare function emptyDualState<T extends BaseItem>(schema: Schema<T>): DualBucketState;
+declare function engagePositive<T extends BaseItem>(state: DualBucketState, item: T, magnitude: number, config: DualInterestConfig<T>): void;
+declare function engageNegative<T extends BaseItem>(state: DualBucketState, item: T, magnitude: number, config: DualInterestConfig<T>): void;
+interface ItemScore {
+    liked: number;
+    disliked: number;
+    net: number;
+    byFeature: Array<{
+        key: string;
+        value: string | null;
+        liked: number;
+        disliked: number;
+    }>;
+}
+declare function scoreItem<T extends BaseItem>(state: DualBucketState, item: T, config: DualInterestConfig<T>): ItemScore;
+declare function isCold(state: DualBucketState): boolean;
+declare function describe(state: DualBucketState, top?: number): {
+    liked: Record<string, [string, number][]>;
+    disliked: Record<string, [string, number][]>;
+};
+
+interface DualRecommenderConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    sampleSize?: number;
+    shuffleThreshold?: number;
+    weightedScoring?: boolean;
+    rng?: RNG;
+}
+interface ResolvedConfig<T extends BaseItem> {
+    interest: DualInterestConfig<T>;
+    sampleSize: number;
+    shuffleThreshold: number;
+    rng: RNG;
+}
+interface DualRecommendDiagnostics<T extends BaseItem> {
+    cold: boolean;
+    candidatesPool: number;
+    sampleSize: number;
+    bestNet: number;
+    bestLiked: number;
+    bestDisliked: number;
+    freshPagesIssued: number;
+    breakdown: ItemScore['byFeature'] | null;
+    runnersUp: Array<{
+        item: T;
+        net: number;
+        liked: number;
+        disliked: number;
+    }>;
+}
+interface DualRecommendResult<T extends BaseItem> {
+    items: T[];
+    scores: number[];
+    diagnostics: DualRecommendDiagnostics<T>;
+}
+declare class DualBucketRecommender<T extends BaseItem> {
+    readonly catalog: T[];
+    readonly byId: Map<string, T>;
+    readonly interest: DualBucketState;
+    readonly config: ResolvedConfig<T>;
+    private ownedIds;
+    private seen;
+    private freshPagesIssued;
+    constructor(catalog: T[], config: DualRecommenderConfig<T>);
+    setOwned(ids: Iterable<string>): void;
+    setSampleSize(k: number): void;
+    prime(items: T[], magnitudePerItem?: number): void;
+    engage(item: T, score: number): void;
+    recommend(count?: number): DualRecommendResult<T>;
+    private pickOne;
+    private candidatePool;
+    seenCount(): number;
+    clearSeen(): void;
+    reset(): void;
+}
+
+declare function logDecadeBucket(value: number | null, multiplier?: number, prefix?: string): string | null;
+declare function yearBucket(year: number | null, bandSize?: number): string | null;
+
+export { type BaseItem, type BucketConfig, type BucketState, DEFAULT_CAPACITY, DEFAULT_DECREMENT_CAP, DEFAULT_EPSILON, DEFAULT_INTEREST_CONFIG, DEFAULT_SLOT_CONFIG, DualBucketRecommender, type DualBucketState, type DualInterestConfig, type ItemScore as DualItemScore, type DualRecommendDiagnostics, type DualRecommendResult, type DualRecommenderConfig, type FeatureConfig, type InterestConfig, type InterestState, type RNG, type RecommendDiagnostics, type RecommendResult, Recommender, type RecommenderConfig, SIGNALS, type Schema, type SignalName, type Slot, type SlotTableConfig, type SlotTableState, admit, applyEvent, contribution as bucketContribution, contribution$1 as contribution, decay, defaultRng, describe$1 as describe, describe as describeDual, emptyBucket, emptyDualState, emptyInterest, emptyState, engageNegative, engagePositive, isCold$1 as isCold, isCold as isColdDual, isEmpty$1 as isEmpty, isEmpty as isEmptyBucket, logDecadeBucket, observe, powerOf, scoreItem$1 as scoreItem, scoreItem as scoreItemDual, seededRng, weightedSampleWithoutReplacement, yearBucket };

package/dist/reco.d.ts

@@ -0,0 +1,219 @@
+interface BaseItem {
+    id: string;
+}
+interface FeatureConfig<T extends BaseItem> {
+    extract: (item: T) => string | null;
+    capacity?: number;
+    challengerCapacity?: number;
+    epsilon?: number;
+    weight?: number;
+    decrementCap?: number;
+}
+type Schema<T extends BaseItem> = Record<string, FeatureConfig<T>>;
+declare const DEFAULT_CAPACITY = 3;
+declare const DEFAULT_DECREMENT_CAP = 4;
+declare const DEFAULT_EPSILON = 0.1;
+declare const SIGNALS: {
+    readonly view: 0.5;
+    readonly click: 2;
+    readonly dwell: 3;
+    readonly collect: 8;
+    readonly skip: -1;
+};
+type SignalName = keyof typeof SIGNALS;
+interface Slot {
+    value: string;
+    power: number;
+}
+
+interface SlotTableConfig {
+    capacity: number;
+    challengerCapacity: number;
+    epsilon: number;
+}
+declare const DEFAULT_SLOT_CONFIG: SlotTableConfig;
+interface SlotTableState {
+    slots: Slot[];
+    challengers: Slot[];
+}
+declare function emptyState(): SlotTableState;
+declare function observe(state: SlotTableState, value: string, weight: number, config?: SlotTableConfig): void;
+declare function decay(state: SlotTableState, factor: number): void;
+declare function contribution$1(state: SlotTableState, value: string | null, config?: SlotTableConfig): number;
+declare function isEmpty$1(state: SlotTableState): boolean;
+
+interface InterestConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    popularity?: (item: T) => number;
+    popularityWeight: number;
+    decayFactor: number;
+    decayEvery: number;
+}
+declare const DEFAULT_INTEREST_CONFIG: Omit<InterestConfig<BaseItem>, 'schema'>;
+type InterestState = {
+    tables: Record<string, SlotTableState>;
+    eventsSinceDecay: number;
+    totalEvents: number;
+};
+declare function emptyInterest<T extends BaseItem>(schema: Schema<T>): InterestState;
+declare function applyEvent<T extends BaseItem>(state: InterestState, item: T, magnitude: number, config: InterestConfig<T>): void;
+declare function scoreItem$1<T extends BaseItem>(state: InterestState, item: T, popularityNorm: number, config: InterestConfig<T>): number;
+declare function isCold$1(state: InterestState): boolean;
+declare function describe$1(state: InterestState, top?: number): Record<string, Array<[string, number]>>;
+
+type RNG = () => number;
+declare const defaultRng: RNG;
+declare function weightedSampleWithoutReplacement<T>(pool: T[], weight: (item: T) => number, count: number, rng?: RNG): T[];
+declare function seededRng(seed: number): RNG;
+
+interface RecommenderConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    popularity?: (item: T) => number;
+    popularityWeight?: number;
+    decayFactor?: number;
+    decayEvery?: number;
+    seenWindow?: number;
+    batchSize?: number;
+    rng?: RNG;
+}
+interface ResolvedConfig$1<T extends BaseItem> {
+    interest: InterestConfig<T>;
+    popularity: ((item: T) => number) | null;
+    seenWindow: number;
+    batchSize: number;
+    rng: RNG;
+}
+interface RecommendDiagnostics {
+    cold: boolean;
+    candidates: number;
+    excluded_seen: number;
+    excluded_owned: number;
+}
+interface RecommendResult<T extends BaseItem> {
+    items: T[];
+    scores: number[];
+    diagnostics: RecommendDiagnostics;
+}
+declare class Recommender<T extends BaseItem> {
+    readonly catalog: T[];
+    readonly byId: Map<string, T>;
+    readonly interest: InterestState;
+    readonly config: ResolvedConfig$1<T>;
+    readonly maxPopularity: number;
+    private ownedIds;
+    private seenOrder;
+    private seen;
+    constructor(catalog: T[], config: RecommenderConfig<T>);
+    setOwned(ids: Iterable<string>): void;
+    prime(items: T[], magnitudePerItem?: number): void;
+    engage(item: T, score: number): void;
+    recommend(count?: number): RecommendResult<T>;
+    seenCount(): number;
+    clearSeen(): void;
+    private markSeen;
+    reset(): void;
+}
+
+interface BucketState {
+    slots: Slot[];
+    pointer: number;
+}
+interface BucketConfig {
+    capacity: number;
+    decrementCap: number;
+}
+declare function emptyBucket(): BucketState;
+declare function admit(state: BucketState, value: string, score: number, config?: BucketConfig): void;
+declare function powerOf(state: BucketState, value: string | null): number;
+declare function contribution(state: BucketState, value: string | null, epsilon: number): number;
+declare function isEmpty(state: BucketState): boolean;
+
+interface DualInterestConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    weightedScoring?: boolean;
+}
+interface DualBucketState {
+    liked: Record<string, BucketState>;
+    disliked: Record<string, BucketState>;
+    totalEvents: number;
+}
+declare function emptyDualState<T extends BaseItem>(schema: Schema<T>): DualBucketState;
+declare function engagePositive<T extends BaseItem>(state: DualBucketState, item: T, magnitude: number, config: DualInterestConfig<T>): void;
+declare function engageNegative<T extends BaseItem>(state: DualBucketState, item: T, magnitude: number, config: DualInterestConfig<T>): void;
+interface ItemScore {
+    liked: number;
+    disliked: number;
+    net: number;
+    byFeature: Array<{
+        key: string;
+        value: string | null;
+        liked: number;
+        disliked: number;
+    }>;
+}
+declare function scoreItem<T extends BaseItem>(state: DualBucketState, item: T, config: DualInterestConfig<T>): ItemScore;
+declare function isCold(state: DualBucketState): boolean;
+declare function describe(state: DualBucketState, top?: number): {
+    liked: Record<string, [string, number][]>;
+    disliked: Record<string, [string, number][]>;
+};
+
+interface DualRecommenderConfig<T extends BaseItem> {
+    schema: Schema<T>;
+    sampleSize?: number;
+    shuffleThreshold?: number;
+    weightedScoring?: boolean;
+    rng?: RNG;
+}
+interface ResolvedConfig<T extends BaseItem> {
+    interest: DualInterestConfig<T>;
+    sampleSize: number;
+    shuffleThreshold: number;
+    rng: RNG;
+}
+interface DualRecommendDiagnostics<T extends BaseItem> {
+    cold: boolean;
+    candidatesPool: number;
+    sampleSize: number;
+    bestNet: number;
+    bestLiked: number;
+    bestDisliked: number;
+    freshPagesIssued: number;
+    breakdown: ItemScore['byFeature'] | null;
+    runnersUp: Array<{
+        item: T;
+        net: number;
+        liked: number;
+        disliked: number;
+    }>;
+}
+interface DualRecommendResult<T extends BaseItem> {
+    items: T[];
+    scores: number[];
+    diagnostics: DualRecommendDiagnostics<T>;
+}
+declare class DualBucketRecommender<T extends BaseItem> {
+    readonly catalog: T[];
+    readonly byId: Map<string, T>;
+    readonly interest: DualBucketState;
+    readonly config: ResolvedConfig<T>;
+    private ownedIds;
+    private seen;
+    private freshPagesIssued;
+    constructor(catalog: T[], config: DualRecommenderConfig<T>);
+    setOwned(ids: Iterable<string>): void;
+    setSampleSize(k: number): void;
+    prime(items: T[], magnitudePerItem?: number): void;
+    engage(item: T, score: number): void;
+    recommend(count?: number): DualRecommendResult<T>;
+    private pickOne;
+    private candidatePool;
+    seenCount(): number;
+    clearSeen(): void;
+    reset(): void;
+}
+
+declare function logDecadeBucket(value: number | null, multiplier?: number, prefix?: string): string | null;
+declare function yearBucket(year: number | null, bandSize?: number): string | null;
+
+export { type BaseItem, type BucketConfig, type BucketState, DEFAULT_CAPACITY, DEFAULT_DECREMENT_CAP, DEFAULT_EPSILON, DEFAULT_INTEREST_CONFIG, DEFAULT_SLOT_CONFIG, DualBucketRecommender, type DualBucketState, type DualInterestConfig, type ItemScore as DualItemScore, type DualRecommendDiagnostics, type DualRecommendResult, type DualRecommenderConfig, type FeatureConfig, type InterestConfig, type InterestState, type RNG, type RecommendDiagnostics, type RecommendResult, Recommender, type RecommenderConfig, SIGNALS, type Schema, type SignalName, type Slot, type SlotTableConfig, type SlotTableState, admit, applyEvent, contribution as bucketContribution, contribution$1 as contribution, decay, defaultRng, describe$1 as describe, describe as describeDual, emptyBucket, emptyDualState, emptyInterest, emptyState, engageNegative, engagePositive, isCold$1 as isCold, isCold as isColdDual, isEmpty$1 as isEmpty, isEmpty as isEmptyBucket, logDecadeBucket, observe, powerOf, scoreItem$1 as scoreItem, scoreItem as scoreItemDual, seededRng, weightedSampleWithoutReplacement, yearBucket };