applesauce-core 6.1.0 → 6.2.0

package/dist/casts/pubkey.d.ts

@@ -4,11 +4,15 @@ import type { ProfilePointer } from "../helpers/pointers.js";
 import { ChainableObservable } from "../observable/chainable.js";
 import { CastRefEventStore } from "./cast.js";
 export type PubkeyCastConstructor<C extends PubkeyCast> = (new (pointer: ProfilePointer, store: CastRefEventStore) => C) & {
-    cache: Map<string, C>;
+    cache?: Map<string, WeakRef<C>>;
+    cacheRegistry?: FinalizationRegistry<string>;
 };
 /**
  * Cast a pubkey to a specific class instance.
  * Works like {@link castUser} - returns a cached singleton per pubkey+relay-hints combination.
+ *
+ * @note Instances are held weakly so unused casts can be garbage collected instead of
+ * accumulating one instance per pubkey for the lifetime of the process.
  */
 export declare function castPubkey<C extends PubkeyCast>(pubkey: string | NostrEvent | ProfilePointer, cls: PubkeyCastConstructor<C>, store: CastRefEventStore): C;
 /** Base class for pubkey-based casts (analogous to {@link EventCast} for events) */
@@ -16,8 +20,10 @@ export declare class PubkeyCast {
     #private;
     readonly pointer: ProfilePointer;
     readonly store: CastRefEventStore;
-    /** A global cache of pubkey -> instance, populated by {@link castPubkey} */
-    static cache: Map<string, PubkeyCast>;
+    /** A global cache of pubkey -> weak instance reference, populated by {@link castPubkey} */
+    static cache: Map<string, WeakRef<PubkeyCast>>;
+    /** Cleans up dead {@link cache} entries when their instances are garbage collected */
+    static cacheRegistry?: FinalizationRegistry<string>;
     constructor(pointer: ProfilePointer, store: CastRefEventStore);
     /** The hex pubkey represented by this cast */
     get pubkey(): string;

package/dist/casts/pubkey.js

@@ -4,6 +4,9 @@ import { chainable } from "../observable/chainable.js";
 /**
  * Cast a pubkey to a specific class instance.
  * Works like {@link castUser} - returns a cached singleton per pubkey+relay-hints combination.
+ *
+ * @note Instances are held weakly so unused casts can be garbage collected instead of
+ * accumulating one instance per pubkey for the lifetime of the process.
  */
 export function castPubkey(pubkey, cls, store) {
     if (isEvent(pubkey))
@@ -14,19 +17,30 @@ export function castPubkey(pubkey, cls, store) {
     const cacheKey = pointer.relays?.length ? `${pointer.pubkey}:${JSON.stringify(pointer.relays)}` : pointer.pubkey;
     if (!cls.cache)
         cls.cache = new Map();
-    const existing = cls.cache.get(cacheKey);
+    // Clean up dead cache entries when their instances are garbage collected
+    if (!cls.cacheRegistry)
+        cls.cacheRegistry = new FinalizationRegistry((key) => {
+            // Only drop the entry if it still points at a collected instance; a re-created
+            // instance under the same key has a live ref and must be kept.
+            if (cls.cache.get(key)?.deref() === undefined)
+                cls.cache.delete(key);
+        });
+    const existing = cls.cache.get(cacheKey)?.deref();
     if (existing)
         return existing;
     const instance = new cls(pointer, store);
-    cls.cache.set(cacheKey, instance);
+    cls.cache.set(cacheKey, new WeakRef(instance));
+    cls.cacheRegistry.register(instance, cacheKey);
     return instance;
 }
 /** Base class for pubkey-based casts (analogous to {@link EventCast} for events) */
 export class PubkeyCast {
     pointer;
     store;
-    /** A global cache of pubkey -> instance, populated by {@link castPubkey} */
+    /** A global cache of pubkey -> weak instance reference, populated by {@link castPubkey} */
     static cache = new Map();
+    /** Cleans up dead {@link cache} entries when their instances are garbage collected */
+    static cacheRegistry;
     constructor(pointer, store) {
         this.pointer = pointer;
         this.store = store;

package/dist/casts/user.d.ts

@@ -11,8 +11,8 @@ export declare function castUser(event: NostrEvent, store: CastRefEventStore): U
 export declare function castUser(user: string | ProfilePointer, store: CastRefEventStore): User;
 /** A class representing a Nostr user */
 export declare class User extends PubkeyCast {
-    /** A global cache of pubkey -> {@link User} */
-    static cache: Map<string, User>;
+    /** A global cache of pubkey -> weak {@link User} reference */
+    static cache: Map<string, WeakRef<User>>;
     /** Returns the NIP-19 npub for this user */
     get npub(): `npub1${string}`;
     /** Returns the NIP-19 nprofile for this user */

package/dist/casts/user.js

@@ -8,7 +8,7 @@ export function castUser(user, store) {
 }
 /** A class representing a Nostr user */
 export class User extends PubkeyCast {
-    /** A global cache of pubkey -> {@link User} */
+    /** A global cache of pubkey -> weak {@link User} reference */
     static cache = new Map();
     /** Returns the NIP-19 npub for this user */
     get npub() {

package/dist/event-store/async-event-store.d.ts

@@ -52,6 +52,8 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
      * A method that will be called when an event isn't found in the store
      */
     eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /** Internal subscriptions (delete + expiration managers) torn down on dispose */
+    private internalSubscriptions;
     constructor(options: AsyncEventStoreOptions);
     /** A method to add all events to memory to ensure there is only ever a single instance of an event */
     private mapToMemory;
@@ -98,4 +100,12 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     unclaimed(): Generator<NostrEvent>;
     /** Removes any event that is not being used by a subscription */
     prune(limit?: number): number;
+    /**
+     * Tears down the store: disposes the attached event loader, completes the event streams, releases
+     * model keep-warm timers, unsubscribes internal manager listeners, and cancels any pending expiration timer.
+     * @note This is a terminal operation; the store should be discarded after calling it.
+     */
+    dispose(): void;
+    /** Allows the store to be used with the `using` keyword */
+    [Symbol.dispose](): void;
 }

package/dist/event-store/async-event-store.js

@@ -1,5 +1,5 @@
 import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
-import { Subject } from "rxjs";
+import { Subject, Subscription } from "rxjs";
 import { EventStoreSymbol, getReplaceableIdentifier, isReplaceable, kinds } from "../helpers/event.js";
 import { getExpirationTimestamp } from "../helpers/expiration.js";
 import { eventMatchesPointer, isAddressPointer, isEventPointer, } from "../helpers/pointers.js";
@@ -47,6 +47,8 @@ export class AsyncEventStore extends EventModels {
      * A method that will be called when an event isn't found in the store
      */
     eventLoader;
+    /** Internal subscriptions (delete + expiration managers) torn down on dispose */
+    internalSubscriptions = new Subscription();
     constructor(options) {
         super();
         this.database = options.database;
@@ -63,19 +65,19 @@ export class AsyncEventStore extends EventModels {
         // Use provided delete manager or create a default one
         this.deletes = options.deleteManager ?? new AsyncDeleteManager();
         // Listen to delete notifications and remove matching events
-        this.deletes.deleted$.subscribe((notification) => {
+        this.internalSubscriptions.add(this.deletes.deleted$.subscribe((notification) => {
             this.handleDeleteNotification(notification).catch((error) => {
                 console.error("[applesauce-core] Error handling delete notification:", error);
             });
-        });
+        }));
         // Create expiration manager
         this.expiration = options.expirationManager ?? new ExpirationManager();
         // Listen to expired events and remove them from the store
-        this.expiration.expired$.subscribe((id) => {
+        this.internalSubscriptions.add(this.expiration.expired$.subscribe((id) => {
             this.handleExpiredNotification(id).catch((error) => {
                 console.error("[applesauce-core] Error handling expired notification:", error);
             });
-        });
+        }));
     }
     mapToMemory(event) {
         if (event === undefined)
@@ -339,4 +341,30 @@ export class AsyncEventStore extends EventModels {
     prune(limit) {
         return this.memory.prune(limit) ?? 0;
     }
+    /**
+     * Tears down the store: disposes the attached event loader, completes the event streams, releases
+     * model keep-warm timers, unsubscribes internal manager listeners, and cancels any pending expiration timer.
+     * @note This is a terminal operation; the store should be discarded after calling it.
+     */
+    dispose() {
+        // Tear down the attached event loader if it supports disposal
+        const loader = this.eventLoader;
+        if (loader && typeof loader[Symbol.dispose] === "function")
+            loader[Symbol.dispose]();
+        this.eventLoader = undefined;
+        // Complete all models and release their keep-warm timers
+        super.dispose();
+        // Tear down internal manager subscriptions
+        this.internalSubscriptions.unsubscribe();
+        // Cancel any pending expiration timer
+        this.expiration.dispose?.();
+        // Complete the event streams
+        this.insert$.complete();
+        this.update$.complete();
+        this.remove$.complete();
+    }
+    /** Allows the store to be used with the `using` keyword */
+    [Symbol.dispose]() {
+        this.dispose();
+    }
 }

package/dist/event-store/event-memory.js

@@ -97,16 +97,36 @@ export class EventMemory {
         // only remove events that are known
         if (!this.events.has(id))
             return false;
-        this.getAuthorsIndex(event.pubkey).delete(event);
-        this.getKindIndex(event.kind).delete(event);
-        // Remove from composite kind+author index
+        // Remove from author index, dropping the index entry when it becomes empty so
+        // the map does not accumulate empty Sets keyed by every pubkey ever seen
+        const authorIndex = this.authors.get(event.pubkey);
+        if (authorIndex) {
+            authorIndex.delete(event);
+            if (authorIndex.size === 0)
+                this.authors.delete(event.pubkey);
+        }
+        // Remove from kind index, dropping the index entry when it becomes empty
+        const kindIndex = this.kinds.get(event.kind);
+        if (kindIndex) {
+            kindIndex.delete(event);
+            if (kindIndex.size === 0)
+                this.kinds.delete(event.kind);
+        }
+        // Remove from composite kind+author index, dropping the entry when empty
         const kindAuthorKey = `${event.kind}:${event.pubkey}`;
-        if (this.kindAuthor.has(kindAuthorKey)) {
-            this.kindAuthor.get(kindAuthorKey).delete(event);
+        const kindAuthorIndex = this.kindAuthor.get(kindAuthorKey);
+        if (kindAuthorIndex) {
+            kindAuthorIndex.delete(event);
+            if (kindAuthorIndex.size === 0)
+                this.kindAuthor.delete(kindAuthorKey);
         }
         for (const tag of getIndexableTags(event)) {
             if (this.tags.has(tag)) {
-                this.getTagIndex(tag).delete(event);
+                const tagIndex = this.getTagIndex(tag);
+                tagIndex.delete(event);
+                // Drop the tag index when empty so it does not retain the key forever
+                if (tagIndex.size === 0)
+                    this.tags.delete(tag);
             }
         }
         // remove from created_at index using binary search
@@ -117,8 +137,12 @@ export class EventMemory {
             const identifier = event.tags.find((t) => t[0] === "d")?.[1];
             const address = createReplaceableAddress(event.kind, event.pubkey, identifier);
             const array = this.replaceable.get(address);
-            if (array)
+            if (array) {
                 this.removeFromSortedArray(array, event);
+                // Drop the empty array so the map does not retain an address key forever
+                if (array.length === 0)
+                    this.replaceable.delete(address);
+            }
         }
         // remove any claims this event has
         this.claims.delete(event);

package/dist/event-store/event-models.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from "rxjs";
+import { Observable, ReplaySubject } from "rxjs";
 import { NostrEvent } from "../helpers/event.js";
 import { Filter } from "../helpers/filter.js";
 import { AddressPointer, AddressPointerWithoutD, EventPointer, ProfilePointer } from "../helpers/pointers.js";
@@ -30,6 +30,11 @@ export declare class EventModels<TStore extends IEventStore | IAsyncEventStore =
     models: Map<ModelConstructor<any, any[], TStore>, Map<string, Observable<any>>>;
     /** How long a model should be kept "warm" while nothing is subscribed to it */
     modelKeepWarm: number;
+    /**
+     * Emits when {@link EventModels.dispose} is called to tear down all models.
+     * A {@link ReplaySubject} so reset notifiers subscribed after disposal fire immediately.
+     */
+    protected destroy$: ReplaySubject<void>;
     /** Get or create a model on the event store */
     model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args, TStore>, ...args: Args): Observable<T>;
     /**
@@ -56,4 +61,9 @@ export declare class EventModels<TStore extends IEventStore | IAsyncEventStore =
         inboxes: string[];
         outboxes: string[];
     } | undefined>;
+    /**
+     * Tears down all models, completing active subscriptions and releasing their keep-warm timers immediately.
+     * @note This is a terminal operation; the instance should be discarded after calling it.
+     */
+    dispose(): void;
 }

package/dist/event-store/event-models.js

@@ -1,5 +1,5 @@
 import hash_sum from "hash-sum";
-import { finalize, ReplaySubject, share, timer } from "rxjs";
+import { finalize, merge, ReplaySubject, share, takeUntil, timer } from "rxjs";
 import { isEventPointer, } from "../helpers/pointers.js";
 import { EventModel, FiltersModel, ReplaceableModel, TimelineModel } from "../models/base.js";
 import { ContactsModel } from "../models/contacts.js";
@@ -32,6 +32,11 @@ export class EventModels {
     models = new Map();
     /** How long a model should be kept "warm" while nothing is subscribed to it */
     modelKeepWarm = 60_000;
+    /**
+     * Emits when {@link EventModels.dispose} is called to tear down all models.
+     * A {@link ReplaySubject} so reset notifiers subscribed after disposal fire immediately.
+     */
+    destroy$ = new ReplaySubject(1);
     /** Get or create a model on the event store */
     model(constructor, ...args) {
         let models = this.models.get(constructor);
@@ -54,9 +59,12 @@ export class EventModels {
             // only subscribe to models once for all subscriptions
             share({
                 connector: () => new ReplaySubject(1),
-                resetOnComplete: () => timer(this.modelKeepWarm),
-                resetOnRefCountZero: () => timer(this.modelKeepWarm),
-            }));
+                // Reset after the keep-warm window OR immediately when the store is disposed
+                resetOnComplete: () => merge(timer(this.modelKeepWarm), this.destroy$),
+                resetOnRefCountZero: () => merge(timer(this.modelKeepWarm), this.destroy$),
+            }), 
+            // Complete any active subscriptions when the store is disposed
+            takeUntil(this.destroy$));
             // Add the model to the cache
             models.set(key, model);
         }
@@ -118,4 +126,12 @@ export class EventModels {
             user = { pubkey: user };
         return this.model(MailboxesModel, user);
     }
+    /**
+     * Tears down all models, completing active subscriptions and releasing their keep-warm timers immediately.
+     * @note This is a terminal operation; the instance should be discarded after calling it.
+     */
+    dispose() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
 }

package/dist/event-store/event-store.d.ts

@@ -50,6 +50,8 @@ export declare class EventStore extends EventModels implements IEventStore {
     remove$: Subject<NostrEvent>;
     /** A method that will be called when an event isn't found in the store */
     eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /** Internal subscriptions (delete + expiration managers) torn down on dispose */
+    private internalSubscriptions;
     constructor(options?: EventStoreOptions);
     /** A method to add all events to memory to ensure there is only ever a single instance of an event */
     private mapToMemory;
@@ -98,4 +100,12 @@ export declare class EventStore extends EventModels implements IEventStore {
     unclaimed(): Generator<NostrEvent>;
     /** Removes any event that is not being used by a subscription */
     prune(limit?: number): number;
+    /**
+     * Tears down the store: disposes the attached event loader, completes the event streams, releases
+     * model keep-warm timers, and unsubscribes internal manager listeners.
+     * @note This is a terminal operation; the store should be discarded after calling it.
+     */
+    dispose(): void;
+    /** Allows the store to be used with the `using` keyword */
+    [Symbol.dispose](): void;
 }

package/dist/event-store/event-store.js

@@ -1,5 +1,5 @@
 import { verifyEvent as coreVerifyEvent, verifiedSymbol } from "nostr-tools/pure";
-import { Subject } from "rxjs";
+import { Subject, Subscription } from "rxjs";
 import { EncryptedContentSymbol } from "../helpers/encrypted-content.js";
 import { EventStoreSymbol, FromCacheSymbol, getReplaceableIdentifier, isRegularKind, isReplaceable, kinds, } from "../helpers/event.js";
 import { getExpirationTimestamp } from "../helpers/expiration.js";
@@ -45,6 +45,8 @@ export class EventStore extends EventModels {
     remove$ = new Subject();
     /** A method that will be called when an event isn't found in the store */
     eventLoader;
+    /** Internal subscriptions (delete + expiration managers) torn down on dispose */
+    internalSubscriptions = new Subscription();
     constructor(options) {
         super();
         if (options?.database) {
@@ -67,11 +69,11 @@ export class EventStore extends EventModels {
         // Use provided delete manager or create a default one
         this.deletes = options?.deleteManager ?? new DeleteManager();
         // Listen to delete notifications and remove matching events
-        this.deletes.deleted$.subscribe(this.handleDeleteNotification.bind(this));
+        this.internalSubscriptions.add(this.deletes.deleted$.subscribe(this.handleDeleteNotification.bind(this)));
         // Create expiration manager
         this.expiration = options?.expirationManager ?? new ExpirationManager();
         // Listen to expired events and remove them from the store
-        this.expiration.expired$.subscribe(this.handleExpiredNotification.bind(this));
+        this.internalSubscriptions.add(this.expiration.expired$.subscribe(this.handleExpiredNotification.bind(this)));
     }
     mapToMemory(event) {
         if (event === undefined)
@@ -364,4 +366,30 @@ export class EventStore extends EventModels {
     prune(limit) {
         return this.memory.prune(limit) ?? 0;
     }
+    /**
+     * Tears down the store: disposes the attached event loader, completes the event streams, releases
+     * model keep-warm timers, and unsubscribes internal manager listeners.
+     * @note This is a terminal operation; the store should be discarded after calling it.
+     */
+    dispose() {
+        // Tear down the attached event loader if it supports disposal
+        const loader = this.eventLoader;
+        if (loader && typeof loader[Symbol.dispose] === "function")
+            loader[Symbol.dispose]();
+        this.eventLoader = undefined;
+        // Complete all models and release their keep-warm timers
+        super.dispose();
+        // Tear down internal manager subscriptions
+        this.internalSubscriptions.unsubscribe();
+        // Cancel any pending expiration timer
+        this.expiration.dispose?.();
+        // Complete the event streams
+        this.insert$.complete();
+        this.update$.complete();
+        this.remove$.complete();
+    }
+    /** Allows the store to be used with the `using` keyword */
+    [Symbol.dispose]() {
+        this.dispose();
+    }
 }

package/dist/event-store/expiration-manager.d.ts

@@ -30,6 +30,13 @@ export declare class ExpirationManager implements IExpirationManager {
      * @returns true if the event has expired, false otherwise
      */
     check(event: NostrEvent): boolean;
+    /**
+     * Tears down the manager: cancels any pending timer and completes the expired$ stream
+     * @note This is a terminal operation; the manager should be discarded after calling it.
+     */
+    dispose(): void;
+    /** Allows the manager to be used with the `using` keyword */
+    [Symbol.dispose](): void;
     /**
      * Remove expired events from the store and emit them
      */

package/dist/event-store/expiration-manager.js

@@ -62,6 +62,22 @@ export class ExpirationManager {
             return false;
         return expiration <= unixNow();
     }
+    /**
+     * Tears down the manager: cancels any pending timer and completes the expired$ stream
+     * @note This is a terminal operation; the manager should be discarded after calling it.
+     */
+    dispose() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.nextCheck = null;
+        this.expirations.clear();
+        this.expiredSubject.complete();
+    }
+    /** Allows the manager to be used with the `using` keyword */
+    [Symbol.dispose]() {
+        this.dispose();
+    }
     /**
      * Remove expired events from the store and emit them
      */

package/dist/event-store/interface.d.ts

@@ -172,6 +172,8 @@ export interface IExpirationManager {
     forget(eventId: string): void;
     /** Check if an event is expired */
     check(event: NostrEvent): boolean;
+    /** Tears down the manager and cancels any pending timers */
+    dispose?(): void;
 }
 /** The base interface for a database of events */
 export interface IEventDatabase extends IEventStoreRead {

package/dist/models/base.js

@@ -106,6 +106,7 @@ export function TimelineModel(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
     return (store) => {
         const seen = new Map();
+        const getTimelineUID = (event) => (includeOldVersion ? event.id : getEventUID(event));
         // get current events
         return defer(() => {
             const r = store.getTimeline(filters);
@@ -125,27 +126,37 @@ export function TimelineModel(filters, includeOldVersion) {
         // build a timeline
         scan((timeline, event) => {
             // filter out removed events from timeline
-            if (typeof event === "string")
+            if (typeof event === "string") {
+                // Forget the removed event so the seen map does not grow unbounded on long-lived
+                // feeds. Only forget when the seen entry is the event being removed (not a newer
+                // replaceable version that happens to share a UID).
+                const removed = timeline.find((e) => e.id === event);
+                if (removed) {
+                    const uid = getTimelineUID(removed);
+                    if (seen.get(uid)?.id === event)
+                        seen.delete(uid);
+                }
                 return timeline.filter((e) => e.id !== event);
+            }
             // initial timeline array
             if (Array.isArray(event)) {
-                if (!includeOldVersion) {
-                    for (const e of event)
-                        if (isReplaceable(e.kind))
-                            seen.set(getEventUID(e), e);
-                }
+                seen.clear();
+                for (const e of event)
+                    seen.set(getTimelineUID(e), e);
                 // Always return a new array instance to ensure UI libraries detect changes
                 return [...event];
             }
             // create a new timeline and insert the event into it
             let newTimeline = [...timeline];
+            const uid = getTimelineUID(event);
+            const existing = seen.get(uid);
+            // Ignore duplicate regular events and older replaceable versions.
+            if (existing &&
+                (!isReplaceable(event.kind) || (!includeOldVersion && event.created_at < existing.created_at))) {
+                return [...timeline];
+            }
             // remove old replaceable events if enabled
             if (!includeOldVersion && isReplaceable(event.kind)) {
-                const uid = getEventUID(event);
-                const existing = seen.get(uid);
-                // if this is an older replaceable event, return a new array instance
-                if (existing && event.created_at < existing.created_at)
-                    return [...timeline];
                 // update latest version
                 seen.set(uid, event);
                 // remove old event from timeline
@@ -155,6 +166,9 @@ export function TimelineModel(filters, includeOldVersion) {
                         newTimeline.splice(index, 1);
                 }
             }
+            else {
+                seen.set(uid, event);
+            }
             // add event into timeline
             insertEventIntoDescendingList(newTimeline, event);
             return newTimeline;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",