@logg/signals 0.1.5 → 0.3.0

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() {
@@ -50,19 +47,23 @@ var EventQueue = class {
     this.getEventContext = getEventContext;
   }
   /**
-   * Initialize queue by loading persisted events
+   * Initialize queue by loading persisted events.
+   * Returns the number of events loaded from storage so callers can decide
+   * whether to force an immediate flush without racing against new events.
    */
   async init() {
     try {
       const stored = await this.storage.getItem(STORAGE_KEY);
       if (stored) {
         const parsed = JSON.parse(stored);
-        this.queue = Array.isArray(parsed) ? parsed : [];
+        const loaded = Array.isArray(parsed) ? parsed : [];
+        this.queue = loaded.concat(this.queue);
+        return loaded.length;
       }
     } catch (error) {
       console.warn("Failed to load persisted events:", error);
-      this.queue = [];
     }
+    return 0;
   }
   /**
    * Add event to queue
@@ -326,7 +327,8 @@ var Signals = class {
   constructor(config) {
     this.flushTimer = null;
     this.isDestroyed = false;
-    this.isFlushing = false;
+    this.flushingPromise = null;
+    this.errorListeners = /* @__PURE__ */ new Set();
     if (!config.apiKey) {
       throw new Error("Signals: apiKey is required");
     }
@@ -360,13 +362,13 @@ var Signals = class {
    * Initialize client
    */
   async init() {
-    await this.queue.init();
+    const persistedCount = await this.queue.init();
     this.log("Signals initialized", {
       sessionId: this.config.sessionId,
       queueSize: this.queue.size()
     });
     this.startFlushTimer();
-    if (!this.queue.isEmpty()) {
+    if (persistedCount > 0) {
       await this.flush();
     }
   }
@@ -384,18 +386,55 @@ var Signals = class {
     }
   }
   /**
-   * Manually flush events
+   * Send one batch of up to `batchSize` events. If a flush is already
+   * in-flight, callers join that one rather than starting a new request — this
+   * preserves at-most-one-in-flight delivery without silently no-op'ing.
+   *
+   * Failures do not throw. They emit a `send_failed` error event and leave
+   * events in the queue for the next flush.
    */
   async flush() {
-    if (this.isDestroyed || this.queue.isEmpty() || this.isFlushing) {
+    if (this.queue.isEmpty()) return;
+    if (this.flushingPromise) {
+      await this.flushingPromise.catch(() => {
+      });
       return;
     }
-    this.isFlushing = true;
-    const events = this.queue.getBatch(this.config.batchSize);
-    if (events.length === 0) {
-      this.isFlushing = false;
-      return;
+    this.flushingPromise = this.doFlushOnce();
+    try {
+      await this.flushingPromise;
+    } finally {
+      this.flushingPromise = null;
     }
+  }
+  /**
+   * Drain the entire queue. Loops `flush()` until the queue is empty or sends
+   * keep failing without making progress. Use at process shutdown or anywhere
+   * a backfill / migration script needs every queued event to land.
+   *
+   * Returns the number of events still queued (and thus unsent) after the
+   * drain attempt completes. Zero means full success.
+   */
+  async flushAll() {
+    let consecutiveStalls = 0;
+    while (!this.queue.isEmpty() && consecutiveStalls < 3) {
+      const before = this.queue.size();
+      await this.flush();
+      if (this.queue.size() === before) {
+        consecutiveStalls++;
+      } else {
+        consecutiveStalls = 0;
+      }
+    }
+    return this.queue.size();
+  }
+  /**
+   * Send a single batch. Internal — call via flush() so the in-flight gate
+   * is honored.
+   */
+  async doFlushOnce() {
+    const events = this.queue.getBatch(this.config.batchSize);
+    if (events.length === 0) return;
     this.log(`Flushing ${events.length} events`);
     const batch = {
       api_key: this.config.apiKey,
@@ -410,8 +449,14 @@ var Signals = class {
       this.log("Batch sent successfully");
     } catch (error) {
       this.log("Failed to send batch", error);
-    } finally {
-      this.isFlushing = false;
+      this.emitError({
+        type: "send_failed",
+        message: `Failed to send batch after ${this.config.maxRetries} retries`,
+        error: error instanceof Error ? error : new Error(String(error)),
+        batchId: batch.batch_id,
+        eventCount: events.length,
+        pendingCount: this.queue.size()
+      });
     }
   }
   /**
@@ -439,10 +484,56 @@ var Signals = class {
         initialDelay: this.config.retryDelay,
         onRetry: (attempt, error) => {
           this.log(`Retry attempt ${attempt}`, error);
+          this.emitError({
+            type: "send_retry",
+            message: `Retrying batch send (attempt ${attempt})`,
+            error,
+            batchId: batch.batch_id,
+            eventCount: batch.events.length,
+            attempt
+          });
         }
       }
     );
   }
+  /**
+   * Subscribe to error events from the SDK. Returns an unsubscribe function.
+   *
+   * @example
+   *   const off = signals.on('error', (e) => {
+   *     console.error('[signals]', e.type, e.message, e.error);
+   *   });
+   *   // ... later
+   *   off();
+   */
+  on(event, listener) {
+    if (event !== "error") {
+      throw new Error(`Signals.on: unknown event "${event}"`);
+    }
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  /** Remove a previously registered error listener. */
+  off(event, listener) {
+    if (event !== "error") return;
+    this.errorListeners.delete(listener);
+  }
+  emitError(payload) {
+    if (this.errorListeners.size === 0) {
+      console.warn(
+        `[Signals] ${payload.type}: ${payload.message}`,
+        payload.error ?? "",
+        payload.pendingCount !== void 0 ? `(${payload.pendingCount} events still queued)` : ""
+      );
+      return;
+    }
+    for (const listener of this.errorListeners) {
+      try {
+        listener(payload);
+      } catch {
+      }
+    }
+  }
   /**
    * Start periodic flush timer
    */
@@ -534,21 +625,38 @@ var Signals = class {
     this.log("Context reset");
   }
   /**
-   * Destroy client and cleanup
+   * Destroy the client and drain the queue.
+   *
+   * Awaits any in-flight flush, then keeps flushing batches until the queue
+   * is empty (or sends keep failing without progress). Only after that does
+   * the instance refuse new events. If anything remains undrainable, emits a
+   * `destroy_pending` error so callers can see the loss instead of having it
+   * silently swallowed at process exit.
    */
   async destroy() {
     if (this.isDestroyed) return;
     this.log("Destroying Signals instance");
-    this.isDestroyed = true;
     this.stopFlushTimer();
-    await this.flush();
+    if (this.flushingPromise) {
+      await this.flushingPromise.catch(() => {
+      });
+    }
+    const stranded = await this.flushAll();
+    this.isDestroyed = true;
+    if (stranded > 0) {
+      this.emitError({
+        type: "destroy_pending",
+        message: `Destroyed with ${stranded} unsent events \u2014 sends are failing`,
+        pendingCount: stranded
+      });
+    }
   }
   /**
    * Debug logging
    */
   log(message, data) {
     if (this.config.debug) {
-      console.log(`[LoggClient] ${message}`, data ?? "");
+      console.log(`[Signals] ${message}`, data ?? "");
     }
   }
 };

package/dist/reco.d.mts

@@ -0,0 +1,216 @@
+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(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 isEmpty(state: BucketState): boolean;
+
+interface DualInterestConfig<T extends BaseItem> {
+    schema: Schema<T>;
+}
+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;
+    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, 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,216 @@
+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(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 isEmpty(state: BucketState): boolean;
+
+interface DualInterestConfig<T extends BaseItem> {
+    schema: Schema<T>;
+}
+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;
+    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, 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 };