applesauce-core 6.0.3 → 6.2.0

package/dist/casts/cast.d.ts

@@ -1,8 +1,6 @@
-import { Observable } from "rxjs";
 import { EventModels, IEventStoreStreams, IEventSubscriptions } from "../event-store/index.js";
 import { NostrEvent } from "../helpers/event.js";
-import { ChainableObservable } from "../observable/chainable.js";
-import { User } from "./user.js";
+import { EventCast } from "./event.js";
 /** The type of event store that is passed to cast references */
 export type CastRefEventStore = IEventSubscriptions & EventModels & IEventStoreStreams;
 /** A symbol used to store all the cast instances for a given event */
@@ -13,19 +11,3 @@ export declare const CASTS_SYMBOL: unique symbol;
 export type CastConstructor<C extends EventCast<NostrEvent>> = new (event: NostrEvent, store: CastRefEventStore) => C;
 /** Cast a Nostr event to a specific class */
 export declare function castEvent<C extends EventCast<NostrEvent>>(event: NostrEvent, cls: CastConstructor<C>, store?: CastRefEventStore): C;
-/** The base class for all casts */
-export declare class EventCast<T extends NostrEvent = NostrEvent> {
-    #private;
-    readonly event: T;
-    readonly store: CastRefEventStore;
-    get id(): string;
-    get uid(): string;
-    get createdAt(): Date;
-    /** Get the {@link User} that authored this event */
-    get author(): User;
-    /** Return the set of relays this event was seen on */
-    get seen(): Set<string> | undefined;
-    constructor(event: T, store: CastRefEventStore);
-    /** Internal method for creating a reference */
-    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
-}

package/dist/casts/cast.js

@@ -1,7 +1,4 @@
-import { getEventUID, getParentEventStore } from "../helpers/event.js";
-import { getSeenRelays } from "../helpers/relays.js";
-import { chainable } from "../observable/chainable.js";
-import { castUser } from "./user.js";
+import { getParentEventStore } from "../helpers/event.js";
 /** A symbol used to store all the cast instances for a given event */
 export const CAST_REF_SYMBOL = Symbol.for("cast-ref");
 /** A symbol used to store all the casts for an event */
@@ -26,42 +23,3 @@ export function castEvent(event, cls, store) {
         casts.set(cls, cast);
     return cast;
 }
-/** The base class for all casts */
-export class EventCast {
-    event;
-    store;
-    get id() {
-        return this.event.id;
-    }
-    get uid() {
-        return getEventUID(this.event);
-    }
-    get createdAt() {
-        return new Date(this.event.created_at * 1000);
-    }
-    /** Get the {@link User} that authored this event */
-    get author() {
-        return castUser(this.event, this.store);
-    }
-    /** Return the set of relays this event was seen on */
-    get seen() {
-        return getSeenRelays(this.event);
-    }
-    // Enfore kind check in constructor. this will force child classes to verify the event before calling super()
-    constructor(event, store) {
-        this.event = event;
-        this.store = store;
-    }
-    /** A cache of observable references */
-    #refs = {};
-    /** Internal method for creating a reference */
-    $$ref(key, builder) {
-        // Return cached observable
-        if (this.#refs[key])
-            return this.#refs[key];
-        // Build a new observable and cache it
-        const observable = chainable(builder(this.store));
-        this.#refs[key] = observable;
-        return observable;
-    }
-}

package/dist/casts/event.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from "rxjs";
+import { NostrEvent } from "../helpers/event.js";
+import { AddressPointer, EventPointer } from "../helpers/pointers.js";
+import { ChainableObservable } from "../observable/chainable.js";
+import { CastRefEventStore } from "./cast.js";
+import { User } from "./user.js";
+/** The base class for all casts */
+export declare class EventCast<T extends NostrEvent = NostrEvent> {
+    #private;
+    readonly event: T;
+    readonly store: CastRefEventStore;
+    /** Alias for event.id */
+    get id(): string;
+    /** Alias for event.kind */
+    get kind(): number;
+    /** Returns the unique identifier for this event */
+    get uid(): string;
+    /** Returns the created_at timestamp as a Date object */
+    get createdAt(): Date;
+    /** Get the {@link User} that authored this event */
+    get author(): User;
+    /** Return the set of relays this event was seen on */
+    get seen(): Set<string> | undefined;
+    /** Returns the NIP-01 address string for this event if its replaceable or addressable, otherwise returns null */
+    get coordinate(): string | null;
+    /** Alias for {@link coordinate} */
+    get replaceableAddress(): string | null;
+    /** Returns a single {@link EventPointer} or {@link AddressPointer} for this event */
+    get pointer(): EventPointer | AddressPointer;
+    constructor(event: T, store: CastRefEventStore);
+    /** Internal method for creating a reference */
+    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
+}

package/dist/casts/event.js

@@ -0,0 +1,65 @@
+import { getEventUID, isAddressableKind, isReplaceableKind } from "../helpers/event.js";
+import { getAddressPointerForEvent, getEventPointerForEvent, getReplaceableAddressForEvent, } from "../helpers/pointers.js";
+import { getSeenRelays } from "../helpers/relays.js";
+import { chainable } from "../observable/chainable.js";
+import { castUser } from "./user.js";
+/** The base class for all casts */
+export class EventCast {
+    event;
+    store;
+    /** Alias for event.id */
+    get id() {
+        return this.event.id;
+    }
+    /** Alias for event.kind */
+    get kind() {
+        return this.event.kind;
+    }
+    /** Returns the unique identifier for this event */
+    get uid() {
+        return getEventUID(this.event);
+    }
+    /** Returns the created_at timestamp as a Date object */
+    get createdAt() {
+        return new Date(this.event.created_at * 1000);
+    }
+    /** Get the {@link User} that authored this event */
+    get author() {
+        return castUser(this.event, this.store);
+    }
+    /** Return the set of relays this event was seen on */
+    get seen() {
+        return getSeenRelays(this.event);
+    }
+    /** Returns the NIP-01 address string for this event if its replaceable or addressable, otherwise returns null */
+    get coordinate() {
+        return getReplaceableAddressForEvent(this.event);
+    }
+    /** Alias for {@link coordinate} */
+    get replaceableAddress() {
+        return this.coordinate;
+    }
+    /** Returns a single {@link EventPointer} or {@link AddressPointer} for this event */
+    get pointer() {
+        if (isReplaceableKind(this.kind) || isAddressableKind(this.kind))
+            return getAddressPointerForEvent(this.event) || getEventPointerForEvent(this.event);
+        return getEventPointerForEvent(this.event);
+    }
+    // Enfore kind check in constructor. this will force child classes to verify the event before calling super()
+    constructor(event, store) {
+        this.event = event;
+        this.store = store;
+    }
+    /** A cache of observable references */
+    #refs = {};
+    /** Internal method for creating a reference */
+    $$ref(key, builder) {
+        // Return cached observable
+        if (this.#refs[key])
+            return this.#refs[key];
+        // Build a new observable and cache it
+        const observable = chainable(builder(this.store));
+        this.#refs[key] = observable;
+        return observable;
+    }
+}

package/dist/casts/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./cast.js";
+export * from "./event.js";
 export * from "./pubkey.js";
 export * from "./user.js";

package/dist/casts/index.js

@@ -1,3 +1,4 @@
 export * from "./cast.js";
+export * from "./event.js";
 export * from "./pubkey.js";
 export * from "./user.js";

package/dist/casts/pubkey.d.ts

@@ -1,15 +1,18 @@
-/** A constructor type for {@link PubkeyCast} subclasses */
 import { Observable } from "rxjs";
 import { NostrEvent } from "../helpers/event.js";
 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) */
@@ -17,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

@@ -1,10 +1,12 @@
-/** A constructor type for {@link PubkeyCast} subclasses */
 import { isEvent } from "../helpers/event.js";
 import { isHexKey } from "../helpers/string.js";
 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))
@@ -15,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

@@ -1,19 +1,31 @@
+import { Observable } from "rxjs";
 import { NostrEvent } from "../helpers/event.js";
+import { Filter } from "../helpers/filter.js";
 import { ProfilePointer } from "../helpers/pointers.js";
 import { ChainableObservable } from "../observable/chainable.js";
-import type { CastRefEventStore } from "./cast.js";
+import type { CastConstructor, CastRefEventStore } from "./cast.js";
 import { PubkeyCast } from "./pubkey.js";
+import { EventCast } from "./event.js";
 /** Cast a Nostr event or pointer into a {@link User} */
 export declare function castUser(event: NostrEvent, store: CastRefEventStore): User;
 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 */
     get nprofile(): `nprofile1${string}`;
     /** Subscribe to a replaceable event for this user */
     replaceable(kind: number, identifier?: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
     /** Subscribe to an addressable event for this user */
     addressable(kind: number, identifier: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    /**
+     * Creates an observable of a timeline of events created by this user
+     * @param input - The filter(s) for the timeline or kind(s)
+     * @returns A timeline observable of events by the user rom the event store
+     */
+    timeline$(input: Omit<Filter, "authors"> | Omit<Filter, "authors">[] | number | number[]): Observable<NostrEvent[]>;
+    timeline$<T extends EventCast>(input: Omit<Filter, "authors"> | Omit<Filter, "authors">[] | number | number[], cast?: CastConstructor<T>): Observable<T[]>;
 }

package/dist/casts/user.js

@@ -1,16 +1,20 @@
+import hash_sum from "hash-sum";
 import { nprofileEncode, npubEncode } from "../helpers/pointers.js";
 import { chainable } from "../observable/chainable.js";
 import { castPubkey, PubkeyCast } from "./pubkey.js";
+import { castTimelineStream } from "../observable/cast-stream.js";
 export function castUser(user, store) {
     return castPubkey(user, 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() {
         return npubEncode(this.pubkey);
     }
+    /** Returns the NIP-19 nprofile for this user */
     get nprofile() {
         return nprofileEncode(this.pointer);
     }
@@ -22,4 +26,24 @@ export class User extends PubkeyCast {
     addressable(kind, identifier, relays) {
         return chainable(this.store.addressable({ kind, pubkey: this.pointer.pubkey, identifier, relays }));
     }
+    timeline$(input, cast) {
+        let filters = [];
+        if (typeof input === "number") {
+            filters.push({ kinds: [input] });
+        }
+        else if (Array.isArray(input)) {
+            filters.push(...input.map((f) => (typeof f === "number" ? { kinds: [f] } : f)));
+        }
+        else if (input instanceof Object) {
+            filters.push(input);
+        }
+        // Use hash_sum to create a unique key for the timeline observable
+        const key = "timeline$|" + hash_sum(filters);
+        const base$ = this.$$ref(key, (store) => store.timeline(filters.map((f) => ({ ...f, authors: [this.pubkey] }))));
+        // Cast the timeline stream into a cast if provided
+        if (cast)
+            return base$.pipe(castTimelineStream(cast));
+        else
+            return base$;
+    }
 }

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/helpers/pointers.d.ts

@@ -39,6 +39,8 @@ export declare function isProfilePointer(pointer: any): pointer is ProfilePointe
 export declare function isEventPointer(pointer: any): pointer is EventPointer;
 /** Returns the stringified NIP-19 encoded naddr address pointer for an AddressPointer. */
 export declare function getReplaceableAddressFromPointer(pointer: AddressPointer): string;
+/** Returns the replaceable coordinate for a replaceable event ( used for "a" tags to reference replaceable events ). */
+export declare function getReplaceableAddressForEvent(event: NostrEvent): string | null;
 /** Returns an AddressPointer for a replaceable event. Returns null if the event is not addressable or replaceable. */
 export declare function getAddressPointerForEvent(event: NostrEvent, relays?: string[]): AddressPointer | null;
 /** Returns an EventPointer for an event */

package/dist/helpers/pointers.js

@@ -204,6 +204,13 @@ export function isEventPointer(pointer) {
 export function getReplaceableAddressFromPointer(pointer) {
     return pointer.kind + ":" + pointer.pubkey + ":" + pointer.identifier;
 }
+/** Returns the replaceable coordinate for a replaceable event ( used for "a" tags to reference replaceable events ). */
+export function getReplaceableAddressForEvent(event) {
+    if (!isReplaceableKind(event.kind) && !isAddressableKind(event.kind))
+        return null;
+    const d = getReplaceableIdentifier(event);
+    return event.kind + ":" + event.pubkey + ":" + d;
+}
 /** Returns an AddressPointer for a replaceable event. Returns null if the event is not addressable or replaceable. */
 export function getAddressPointerForEvent(event, relays) {
     if (!isAddressableKind(event.kind) && !isReplaceableKind(event.kind))

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/dist/observable/cast-stream.d.ts

@@ -0,0 +1,8 @@
+import { OperatorFunction } from "rxjs";
+import type { CastConstructor, CastRefEventStore } from "../casts/cast.js";
+import { EventCast } from "../casts/index.js";
+import { NostrEvent } from "../helpers/event.js";
+/** Casts an event to a specific type */
+export declare function castEventStream<C extends EventCast>(cls: CastConstructor<C>, store?: CastRefEventStore): OperatorFunction<NostrEvent | undefined, C | undefined>;
+/** Casts and array of events to an array of casted events and filters out undefined values */
+export declare function castTimelineStream<C extends EventCast>(cls: CastConstructor<C>, store?: CastRefEventStore): OperatorFunction<NostrEvent[], C[]>;

package/dist/observable/cast-stream.js

@@ -0,0 +1,29 @@
+import { map } from "rxjs";
+import { castEvent } from "../casts/index.js";
+import { defined } from "./defined.js";
+/** Casts an event to a specific type */
+export function castEventStream(cls, store) {
+    return (source) => source.pipe(map((event) => {
+        if (!event)
+            return undefined;
+        try {
+            return castEvent(event, cls, store);
+        }
+        catch { }
+        return undefined;
+    }));
+}
+/** Casts and array of events to an array of casted events and filters out undefined values */
+export function castTimelineStream(cls, store) {
+    return (source) => source.pipe(map((events) => {
+        const castedEvents = [];
+        for (const event of events) {
+            try {
+                const casted = castEvent(event, cls, store);
+                castedEvents.push(casted);
+            }
+            catch { }
+        }
+        return castedEvents;
+    }), defined());
+}

package/package.json

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