applesauce-core 0.0.0-next-20251209200210 → 0.0.0-next-20251220152312

package/dist/event-factory/methods.js

@@ -1,4 +1,5 @@
 import { EncryptedContentSymbol } from "../helpers/encrypted-content.js";
+import { isEvent } from "../helpers/event.js";
 import { eventPipe } from "../helpers/pipeline.js";
 import { unixNow } from "../helpers/time.js";
 import { setClient } from "../operations/client.js";
@@ -36,5 +37,8 @@ export async function createEvent(context, blueprint, ...args) {
 }
 /** Modifies an event using a context and a set of operations */
 export async function modifyEvent(event, context, ...operations) {
+    // NOTE: Unwrapping evnet object in order to handle cast events from applesauce-common
+    if ("event" in event && isEvent(event.event))
+        event = event.event;
     return await wrapCommon(stripSignature(), stripStamp(), updateCreatedAt(), ...operations)(event, context);
 }

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

@@ -4,7 +4,7 @@ import { Filter } from "../helpers/filter.js";
 import { AddressPointer, AddressPointerWithoutD, EventPointer } from "../helpers/pointers.js";
 import { EventMemory } from "./event-memory.js";
 import { EventModels } from "./event-models.js";
-import { IAsyncEventDatabase, IAsyncEventStore, IAsyncDeleteManager, IExpirationManager } from "./interface.js";
+import { IAsyncDeleteManager, IAsyncEventDatabase, IAsyncEventStore, IExpirationManager } from "./interface.js";
 export type AsyncEventStoreOptions = {
     /** Keep deleted events in the store */
     keepDeleted?: boolean;
@@ -44,7 +44,7 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     set verifyEvent(method: undefined | ((event: NostrEvent) => boolean));
     /** A stream of new events added to the store */
     insert$: Subject<import("nostr-tools/core").Event>;
-    /** A stream of events that have been updated */
+    /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
     update$: Subject<import("nostr-tools/core").Event>;
     /** A stream of events that have been removed */
     remove$: Subject<import("nostr-tools/core").Event>;
@@ -59,8 +59,6 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     private handleDeleteNotification;
     /** Handle an expired event by id */
     private handleExpiredNotification;
-    /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
     /**
      * Adds an event to the store and update subscriptions
      * @returns The existing event or the event that was added, if it was ignored returns null
@@ -73,9 +71,9 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): Promise<void>;
     /** Check if the store has an event by id */
-    hasEvent(id: string): Promise<boolean>;
+    hasEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<boolean>;
     /** Get an event by id from the store */
-    getEvent(id: string): Promise<NostrEvent | undefined>;
+    getEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<NostrEvent | undefined>;
     /** Check if the store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, d?: string): Promise<boolean>;
     /** Gets the latest version of a replaceable event */

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

@@ -1,13 +1,14 @@
+import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
 import { Subject } from "rxjs";
-import { EventStoreSymbol, FromCacheSymbol, getReplaceableIdentifier, isReplaceable, kinds, } from "../helpers/event.js";
+import { EventStoreSymbol, getReplaceableIdentifier, isReplaceable, kinds } from "../helpers/event.js";
 import { getExpirationTimestamp } from "../helpers/expiration.js";
-import { eventMatchesPointer, isEventPointer, isAddressPointer, } from "../helpers/pointers.js";
-import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { eventMatchesPointer, isAddressPointer, isEventPointer, } from "../helpers/pointers.js";
+import { addSeenRelay } from "../helpers/relays.js";
 import { unixNow } from "../helpers/time.js";
+import { AsyncDeleteManager } from "./async-delete-manager.js";
 import { EventMemory } from "./event-memory.js";
 import { EventModels } from "./event-models.js";
-import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
-import { AsyncDeleteManager } from "./async-delete-manager.js";
+import { EventStore } from "./event-store.js";
 import { ExpirationManager } from "./expiration-manager.js";
 /** An async wrapper around an async event database that handles replaceable events, deletes, and models */
 export class AsyncEventStore extends EventModels {
@@ -38,7 +39,7 @@ export class AsyncEventStore extends EventModels {
     }
     /** A stream of new events added to the store */
     insert$ = new Subject();
-    /** A stream of events that have been updated */
+    /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
     update$ = new Subject();
     /** A stream of events that have been removed */
     remove$ = new Subject();
@@ -75,14 +76,6 @@ export class AsyncEventStore extends EventModels {
                 console.error("[applesauce-core] Error handling expired notification:", error);
             });
         });
-        // when events are added to the database, add the symbol
-        this.insert$.subscribe((event) => {
-            Reflect.set(event, EventStoreSymbol, this);
-        });
-        // when events are removed from the database, remove the symbol
-        this.remove$.subscribe((event) => {
-            Reflect.deleteProperty(event, EventStoreSymbol);
-        });
     }
     mapToMemory(event) {
         if (event === undefined)
@@ -122,18 +115,6 @@ export class AsyncEventStore extends EventModels {
             return;
         await this.remove(id);
     }
-    /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source, dest) {
-        const relays = getSeenRelays(source);
-        if (relays) {
-            for (const relay of relays)
-                addSeenRelay(dest, relay);
-        }
-        // copy the from cache symbol only if its true
-        const fromCache = Reflect.get(source, FromCacheSymbol);
-        if (fromCache && !Reflect.get(dest, FromCacheSymbol))
-            Reflect.set(dest, FromCacheSymbol, fromCache);
-    }
     /**
      * Adds an event to the store and update subscriptions
      * @returns The existing event or the event that was added, if it was ignored returns null
@@ -151,6 +132,9 @@ export class AsyncEventStore extends EventModels {
         const expiration = getExpirationTimestamp(event);
         if (this.keepExpired === false && expiration && expiration <= unixNow())
             return null;
+        // Attach relay this event was from
+        if (fromRelay)
+            addSeenRelay(event, fromRelay);
         // Get the replaceable identifier
         const identifier = isReplaceable(event.kind) ? getReplaceableIdentifier(event) : undefined;
         // Don't insert the event if there is already a newer version
@@ -158,7 +142,8 @@ export class AsyncEventStore extends EventModels {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             // If there is already a newer version, copy cached symbols and return existing event
             if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
-                AsyncEventStore.mergeDuplicateEvent(event, existing[0]);
+                if (EventStore.copySymbolsToDuplicateEvent(event, existing[0]))
+                    await this.update(existing[0]);
                 return existing[0];
             }
         }
@@ -166,27 +151,28 @@ export class AsyncEventStore extends EventModels {
         if (this.verifyEvent && this.verifyEvent(event) === false)
             return null;
         // Always add event to memory
-        const existing = this.memory?.add(event);
+        const existing = this.memory.add(event);
         // If the memory returned a different instance, this is a duplicate event
         if (existing && existing !== event) {
             // Copy cached symbols and return existing event
-            AsyncEventStore.mergeDuplicateEvent(event, existing);
-            // attach relay this event was from
-            if (fromRelay)
-                addSeenRelay(existing, fromRelay);
+            if (EventStore.copySymbolsToDuplicateEvent(event, existing))
+                await this.update(existing);
             return existing;
         }
         // Insert event into database
         const inserted = this.mapToMemory(await this.database.add(event));
-        // Copy cached data if its a duplicate event
-        if (event !== inserted)
-            AsyncEventStore.mergeDuplicateEvent(event, inserted);
-        // attach relay this event was from
-        if (fromRelay)
-            addSeenRelay(inserted, fromRelay);
-        // Emit insert$ signal
-        if (inserted === event)
+        // If the event is the same as the inserted event, its a new event
+        if (inserted === event) {
+            // Set the event store on the event
+            Reflect.set(inserted, EventStoreSymbol, this);
+            // Emit insert$ signal
             this.insert$.next(inserted);
+        }
+        else {
+            // Copy cached data if its a duplicate event
+            if (EventStore.copySymbolsToDuplicateEvent(event, inserted))
+                await this.update(inserted);
+        }
         // remove all old version of the replaceable event
         if (this.keepOldVersions === false && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
@@ -208,18 +194,20 @@ export class AsyncEventStore extends EventModels {
     /** Removes an event from the store and updates subscriptions */
     async remove(event) {
         const eventId = typeof event === "string" ? event : event.id;
-        let instance = this.memory?.getEvent(eventId);
+        let instance = this.memory.getEvent(eventId);
         // Remove from expiration manager
         this.expiration.forget(eventId);
+        // Remove the event store from the event
+        if (instance)
+            Reflect.deleteProperty(instance, EventStoreSymbol);
         // Remove from memory if available
         if (this.memory)
             this.memory.remove(event);
         // Remove the event from the database
         const removed = await this.database.remove(event);
         // If the event was removed, notify the subscriptions
-        if (removed && instance) {
+        if (removed && instance)
             this.remove$.next(instance);
-        }
         return removed;
     }
     /** Remove multiple events that match the given filters */
@@ -252,29 +240,40 @@ export class AsyncEventStore extends EventModels {
     }
     /** Check if the store has an event by id */
     async hasEvent(id) {
-        // Check if the event exists in memory first, then in the database
-        return (this.memory?.hasEvent(id) ?? false) || (await this.database.hasEvent(id));
+        if (typeof id === "string")
+            return this.memory.hasEvent(id) || this.database.hasEvent(id);
+        // If its a pointer, use the advanced has event method to resolve
+        else if (isEventPointer(id))
+            return this.memory.hasEvent(id.id) || this.database.hasEvent(id.id);
+        else
+            return this.hasReplaceable(id.kind, id.pubkey, id.identifier);
     }
     /** Get an event by id from the store */
     async getEvent(id) {
         // Get the event from memory first, then from the database
-        return this.memory?.getEvent(id) ?? this.mapToMemory(await this.database.getEvent(id));
+        if (typeof id === "string")
+            return this.memory.getEvent(id) ?? this.mapToMemory(await this.database.getEvent(id));
+        // If its a pointer, use the advanced get event method to resolve
+        else if (isEventPointer(id))
+            return this.memory.getEvent(id.id) ?? this.mapToMemory(await this.database.getEvent(id.id));
+        else
+            return this.getReplaceable(id.kind, id.pubkey, id.identifier);
     }
     /** Check if the store has a replaceable event */
     async hasReplaceable(kind, pubkey, d) {
         // Check if the event exists in memory first, then in the database
-        return ((this.memory?.hasReplaceable(kind, pubkey, d) ?? false) || (await this.database.hasReplaceable(kind, pubkey, d)));
+        return this.memory.hasReplaceable(kind, pubkey, d) || this.database.hasReplaceable(kind, pubkey, d);
     }
     /** Gets the latest version of a replaceable event */
     async getReplaceable(kind, pubkey, identifier) {
         // Get the event from memory first, then from the database
-        return (this.memory?.getReplaceable(kind, pubkey, identifier) ??
+        return (this.memory.getReplaceable(kind, pubkey, identifier) ??
             this.mapToMemory(await this.database.getReplaceable(kind, pubkey, identifier)));
     }
     /** Returns all versions of a replaceable event */
     async getReplaceableHistory(kind, pubkey, identifier) {
         // Get the events from memory first, then from the database
-        return (this.memory?.getReplaceableHistory(kind, pubkey, identifier) ??
+        return (this.memory.getReplaceableHistory(kind, pubkey, identifier) ??
             (await this.database.getReplaceableHistory(kind, pubkey, identifier))?.map((e) => this.mapToMemory(e) ?? e));
     }
     /** Get all events matching a filter */
@@ -297,30 +296,30 @@ export class AsyncEventStore extends EventModels {
     }
     /** Passthrough method for the database.touch */
     touch(event) {
-        return this.memory?.touch(event);
+        return this.memory.touch(event);
     }
     /** Increments the claim count on the event and touches it */
     claim(event) {
-        return this.memory?.claim(event);
+        return this.memory.claim(event);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
-        return this.memory?.isClaimed(event) ?? false;
+        return this.memory.isClaimed(event) ?? false;
     }
     /** Decrements the claim count on an event */
     removeClaim(event) {
-        return this.memory?.removeClaim(event);
+        return this.memory.removeClaim(event);
     }
     /** Removes all claims on an event */
     clearClaim(event) {
-        return this.memory?.clearClaim(event);
+        return this.memory.clearClaim(event);
     }
     /** Pass through method for the database.unclaimed */
     unclaimed() {
-        return this.memory?.unclaimed() || (function* () { })();
+        return this.memory.unclaimed() || (function* () { })();
     }
     /** Removes any event that is not being used by a subscription */
     prune(limit) {
-        return this.memory?.prune(limit) ?? 0;
+        return this.memory.prune(limit) ?? 0;
     }
 }

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

@@ -2,24 +2,7 @@ import { Observable } from "rxjs";
 import { NostrEvent } from "../helpers/event.js";
 import { Filter } from "../helpers/filter.js";
 import { AddressPointer, AddressPointerWithoutD, EventPointer, ProfilePointer } from "../helpers/pointers.js";
-import { ProfileContent } from "../helpers/profile.js";
-import { IAsyncEventStore, IEventStore, ModelConstructor } from "./interface.js";
-/**
- * Core helpful subscriptions interface.
- * Contains only methods that use models from the core package.
- * Other packages (like applesauce-common) can extend this interface via module augmentation.
- */
-export interface IEventStoreModels {
-    /** Subscribe to a users profile */
-    profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
-    /** Subscribe to a users contacts */
-    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
-    /** Subscribe to a users mailboxes */
-    mailboxes(user: string | ProfilePointer): Observable<{
-        inboxes: string[];
-        outboxes: string[];
-    } | undefined>;
-}
+import { IAsyncEventStore, IEventStore, IEventSubscriptions, ModelConstructor } from "./interface.js";
 /**
  * Base class that provides model functionality for both sync and async event stores.
  * This class can be extended by other packages to add additional helpful subscription methods.
@@ -42,7 +25,7 @@ export interface IEventStoreModels {
  * }
  * ```
  */
-export declare class EventModels<TStore extends IEventStore | IAsyncEventStore = IEventStore | IAsyncEventStore> implements IEventStoreModels {
+export declare class EventModels<TStore extends IEventStore | IAsyncEventStore = IEventStore | IAsyncEventStore> implements IEventSubscriptions {
     /** A directory of all active models */
     models: Map<ModelConstructor<any, any[], TStore>, Map<string, Observable<any>>>;
     /** How long a model should be kept "warm" while nothing is subscribed to it */
@@ -55,8 +38,8 @@ export declare class EventModels<TStore extends IEventStore | IAsyncEventStore =
      * @param [onlyNew=false] Only subscribe to new events
      */
     filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
-    /** Creates a {@link EventModel} */
-    event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
+    /** Subscribe to an event by pointer */
+    event(pointer: string | EventPointer | AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     /** Subscribe to a replaceable event by pointer */
     replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
@@ -65,7 +48,7 @@ export declare class EventModels<TStore extends IEventStore | IAsyncEventStore =
     /** Creates a {@link TimelineModel} */
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
     /** Subscribe to a users profile */
-    profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
+    profile(user: string | ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
     /** Subscribe to a users contacts */
     contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
     /** Subscribe to a users mailboxes */

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

@@ -1,5 +1,6 @@
 import hash_sum from "hash-sum";
-import { ReplaySubject, finalize, share, timer } from "rxjs";
+import { finalize, ReplaySubject, share, timer } from "rxjs";
+import { isEventPointer, } from "../helpers/pointers.js";
 import { EventModel, FiltersModel, ReplaceableModel, TimelineModel } from "../models/base.js";
 import { ContactsModel } from "../models/contacts.js";
 import { MailboxesModel } from "../models/mailboxes.js";
@@ -67,14 +68,16 @@ export class EventModels {
      * @param [onlyNew=false] Only subscribe to new events
      */
     filters(filters, onlyNew = false) {
+        if (!Array.isArray(filters))
+            filters = [filters];
         return this.model(FiltersModel, filters, onlyNew);
     }
-    // Helper methods for creating models
-    /** Creates a {@link EventModel} */
+    /** Subscribe to an event by pointer */
     event(pointer) {
-        if (typeof pointer === "string")
-            pointer = { id: pointer };
-        return this.model(EventModel, pointer);
+        if (typeof pointer === "string" || isEventPointer(pointer))
+            return this.model(EventModel, pointer);
+        else
+            return this.replaceable(pointer);
     }
     replaceable(...args) {
         let pointer;
@@ -92,7 +95,7 @@ export class EventModels {
     }
     /** Subscribe to an addressable event by pointer */
     addressable(pointer) {
-        return this.model(ReplaceableModel, pointer);
+        return this.replaceable(pointer);
     }
     /** Creates a {@link TimelineModel} */
     timeline(filters, includeOldVersion = false) {

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

@@ -44,7 +44,7 @@ export declare class EventStore extends EventModels implements IEventStore {
     set verifyEvent(method: undefined | ((event: NostrEvent) => boolean));
     /** A stream of new events added to the store */
     insert$: Subject<import("nostr-tools/core").Event>;
-    /** A stream of events that have been updated */
+    /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
     update$: Subject<import("nostr-tools/core").Event>;
     /** A stream of events that have been removed */
     remove$: Subject<import("nostr-tools/core").Event>;
@@ -58,7 +58,7 @@ export declare class EventStore extends EventModels implements IEventStore {
     /** Handle an expired event by id */
     private handleExpiredNotification;
     /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
+    static copySymbolsToDuplicateEvent(source: NostrEvent, dest: NostrEvent): boolean;
     /**
      * Adds an event to the store and update subscriptions
      * @returns The existing event or the event that was added, if it was ignored returns null
@@ -71,9 +71,9 @@ export declare class EventStore extends EventModels implements IEventStore {
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): boolean;
     /** Check if the store has an event by id */
-    hasEvent(id: string): boolean;
+    hasEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): boolean;
     /** Get an event by id from the store */
-    getEvent(id: string): NostrEvent | undefined;
+    getEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): NostrEvent | undefined;
     /** Check if the store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
     /** Gets the latest version of a replaceable event */

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

@@ -1,6 +1,7 @@
-import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
+import { verifyEvent as coreVerifyEvent, verifiedSymbol } from "nostr-tools/pure";
 import { Subject } from "rxjs";
-import { EventStoreSymbol, FromCacheSymbol, getReplaceableIdentifier, isReplaceable, kinds, } from "../helpers/event.js";
+import { EncryptedContentSymbol } from "../helpers/encrypted-content.js";
+import { EventStoreSymbol, FromCacheSymbol, getReplaceableIdentifier, isRegularKind, isReplaceable, kinds, } from "../helpers/event.js";
 import { getExpirationTimestamp } from "../helpers/expiration.js";
 import { eventMatchesPointer, isAddressPointer, isEventPointer, } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
@@ -38,7 +39,7 @@ export class EventStore extends EventModels {
     }
     /** A stream of new events added to the store */
     insert$ = new Subject();
-    /** A stream of events that have been updated */
+    /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
     update$ = new Subject();
     /** A stream of events that have been removed */
     remove$ = new Subject();
@@ -71,14 +72,6 @@ export class EventStore extends EventModels {
         this.expiration = options?.expirationManager ?? new ExpirationManager();
         // Listen to expired events and remove them from the store
         this.expiration.expired$.subscribe(this.handleExpiredNotification.bind(this));
-        // when events are added to the database, add the symbol
-        this.insert$.subscribe((event) => {
-            Reflect.set(event, EventStoreSymbol, this);
-        });
-        // when events are removed from the database, remove the symbol
-        this.remove$.subscribe((event) => {
-            Reflect.deleteProperty(event, EventStoreSymbol);
-        });
     }
     mapToMemory(event) {
         if (event === undefined)
@@ -120,16 +113,31 @@ export class EventStore extends EventModels {
         this.remove(id);
     }
     /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source, dest) {
+    static copySymbolsToDuplicateEvent(source, dest) {
+        if (source.kind !== dest.kind)
+            throw new Error("Source and destination events must have the same kind");
+        if (isRegularKind(source.kind) && source.id !== dest.id)
+            throw new Error("Source and destination events must have the same ID");
+        if (isReplaceable(source.kind) &&
+            source.pubkey !== dest.pubkey &&
+            getReplaceableIdentifier(source) !== getReplaceableIdentifier(dest))
+            throw new Error("Source and destination events must have the same pubkey and replaceable identifier");
+        let changed = false;
+        // Merge seen relays
         const relays = getSeenRelays(source);
         if (relays) {
             for (const relay of relays)
                 addSeenRelay(dest, relay);
+            changed = true;
         }
-        // copy the from cache symbol only if its true
-        const fromCache = Reflect.get(source, FromCacheSymbol);
-        if (fromCache && !Reflect.get(dest, FromCacheSymbol))
-            Reflect.set(dest, FromCacheSymbol, fromCache);
+        const symbols = [FromCacheSymbol, verifiedSymbol, EncryptedContentSymbol];
+        for (const symbol of symbols) {
+            if (symbol in source && !(symbol in dest)) {
+                Reflect.set(dest, symbol, Reflect.get(source, symbol));
+                changed = true;
+            }
+        }
+        return changed;
     }
     /**
      * Adds an event to the store and update subscriptions
@@ -148,6 +156,9 @@ export class EventStore extends EventModels {
         const expiration = getExpirationTimestamp(event);
         if (this.keepExpired === false && expiration && expiration <= unixNow())
             return null;
+        // Attach relay this event was from
+        if (fromRelay)
+            addSeenRelay(event, fromRelay);
         // Get the replaceable identifier
         const identifier = isReplaceable(event.kind) ? getReplaceableIdentifier(event) : undefined;
         // Don't insert the event if there is already a newer version
@@ -155,7 +166,8 @@ export class EventStore extends EventModels {
             const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             // If there is already a newer version, copy cached symbols and return existing event
             if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
-                EventStore.mergeDuplicateEvent(event, existing[0]);
+                if (EventStore.copySymbolsToDuplicateEvent(event, existing[0]))
+                    this.update(existing[0]);
                 return existing[0];
             }
         }
@@ -163,27 +175,28 @@ export class EventStore extends EventModels {
         if (this.verifyEvent && this.verifyEvent(event) === false)
             return null;
         // Always add event to memory
-        const existing = this.memory?.add(event);
+        const existing = this.memory.add(event);
         // If the memory returned a different instance, this is a duplicate event
         if (existing && existing !== event) {
             // Copy cached symbols and return existing event
-            EventStore.mergeDuplicateEvent(event, existing);
-            // attach relay this event was from
-            if (fromRelay)
-                addSeenRelay(existing, fromRelay);
+            if (EventStore.copySymbolsToDuplicateEvent(event, existing))
+                this.update(existing);
             return existing;
         }
         // Insert event into database
         const inserted = this.mapToMemory(this.database.add(event));
-        // Copy cached data if its a duplicate event
-        if (event !== inserted)
-            EventStore.mergeDuplicateEvent(event, inserted);
-        // attach relay this event was from
-        if (fromRelay)
-            addSeenRelay(inserted, fromRelay);
-        // Emit insert$ signal
-        if (inserted === event)
+        // If the event is the same as the inserted event, its a new event
+        if (inserted === event) {
+            // Set the event store on the event
+            Reflect.set(inserted, EventStoreSymbol, this);
+            // Emit insert$ signal
             this.insert$.next(inserted);
+        }
+        else {
+            // Copy cached data if its a duplicate event
+            if (EventStore.copySymbolsToDuplicateEvent(event, inserted))
+                this.update(inserted);
+        }
         // remove all old version of the replaceable event
         if (this.keepOldVersions === false && isReplaceable(event.kind)) {
             const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
@@ -205,18 +218,20 @@ export class EventStore extends EventModels {
     /** Removes an event from the store and updates subscriptions */
     remove(event) {
         const eventId = typeof event === "string" ? event : event.id;
-        let instance = this.memory?.getEvent(eventId);
+        let instance = this.memory.getEvent(eventId);
         // Remove from expiration manager
         this.expiration.forget(eventId);
+        // Remove the event store from the event
+        if (instance)
+            Reflect.deleteProperty(instance, EventStoreSymbol);
         // Remove from memory if it's not the same as the database
         if (this.memory !== this.database)
             this.memory.remove(event);
         // Remove the event from the database
         const removed = this.database.remove(event);
         // If the event was removed, notify the subscriptions
-        if (removed && instance) {
+        if (removed && instance)
             this.remove$.next(instance);
-        }
         return removed;
     }
     /** Remove multiple events that match the given filters */
@@ -250,29 +265,40 @@ export class EventStore extends EventModels {
     }
     /** Check if the store has an event by id */
     hasEvent(id) {
-        // Check if the event exists in memory first, then in the database
-        return this.memory?.hasEvent(id) || this.database.hasEvent(id);
+        if (typeof id === "string")
+            return this.memory.hasEvent(id) || this.database.hasEvent(id);
+        // If its a pointer, use the advanced has event method to resolve
+        else if (isEventPointer(id))
+            return this.memory.hasEvent(id.id) || this.database.hasEvent(id.id);
+        else
+            return this.hasReplaceable(id.kind, id.pubkey, id.identifier);
     }
     /** Get an event by id from the store */
     getEvent(id) {
         // Get the event from memory first, then from the database
-        return this.memory?.getEvent(id) ?? this.mapToMemory(this.database.getEvent(id));
+        if (typeof id === "string")
+            return this.memory.getEvent(id) ?? this.mapToMemory(this.database.getEvent(id));
+        // If its a pointer, use the advanced get event method to resolve
+        else if (isEventPointer(id))
+            return this.memory.getEvent(id.id) ?? this.mapToMemory(this.database.getEvent(id.id));
+        else
+            return this.getReplaceable(id.kind, id.pubkey, id.identifier);
     }
     /** Check if the store has a replaceable event */
     hasReplaceable(kind, pubkey, d) {
         // Check if the event exists in memory first, then in the database
-        return this.memory?.hasReplaceable(kind, pubkey, d) || this.database.hasReplaceable(kind, pubkey, d);
+        return this.memory.hasReplaceable(kind, pubkey, d) || this.database.hasReplaceable(kind, pubkey, d);
     }
     /** Gets the latest version of a replaceable event */
     getReplaceable(kind, pubkey, identifier) {
         // Get the event from memory first, then from the database
-        return (this.memory?.getReplaceable(kind, pubkey, identifier) ??
+        return (this.memory.getReplaceable(kind, pubkey, identifier) ??
             this.mapToMemory(this.database.getReplaceable(kind, pubkey, identifier)));
     }
     /** Returns all versions of a replaceable event */
     getReplaceableHistory(kind, pubkey, identifier) {
         // Get the events from memory first, then from the database
-        return (this.memory?.getReplaceableHistory(kind, pubkey, identifier) ??
+        return (this.memory.getReplaceableHistory(kind, pubkey, identifier) ??
             this.database.getReplaceableHistory(kind, pubkey, identifier)?.map((e) => this.mapToMemory(e) ?? e));
     }
     /** Get all events matching a filter */
@@ -295,30 +321,30 @@ export class EventStore extends EventModels {
     }
     /** Passthrough method for the database.touch */
     touch(event) {
-        return this.memory?.touch(event);
+        return this.memory.touch(event);
     }
     /** Increments the claim count on the event and touches it */
     claim(event) {
-        return this.memory?.claim(event);
+        return this.memory.claim(event);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
-        return this.memory?.isClaimed(event) ?? false;
+        return this.memory.isClaimed(event) ?? false;
     }
     /** Decrements the claim count on an event */
     removeClaim(event) {
-        return this.memory?.removeClaim(event);
+        return this.memory.removeClaim(event);
     }
     /** Removes all claims on an event */
     clearClaim(event) {
-        return this.memory?.clearClaim(event);
+        return this.memory.clearClaim(event);
     }
     /** Pass through method for the database.unclaimed */
     unclaimed() {
-        return this.memory?.unclaimed() || (function* () { })();
+        return this.memory.unclaimed() || (function* () { })();
     }
     /** Removes any event that is not being used by a subscription */
     prune(limit) {
-        return this.memory?.prune(limit) ?? 0;
+        return this.memory.prune(limit) ?? 0;
     }
 }

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

@@ -1,8 +1,8 @@
 import { Observable } from "rxjs";
 import { NostrEvent } from "../helpers/event.js";
 import { Filter } from "../helpers/filter.js";
-import { AddressPointer, AddressPointerWithoutD, EventPointer } from "../helpers/pointers.js";
-import { IEventStoreModels } from "./event-models.js";
+import { AddressPointer, AddressPointerWithoutD, EventPointer, ProfilePointer } from "../helpers/pointers.js";
+import { ProfileContent } from "../helpers/profile.js";
 /** The read interface for an event store */
 export interface IEventStoreRead {
     /** Check if the event store has an event with id */
@@ -37,6 +37,20 @@ export interface IAsyncEventStoreRead {
     /** Get a timeline of events that match the filters */
     getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
 }
+/** An extended read interface for an event store that supports pointers */
+export interface IEventStoreReadAdvanced extends Omit<IEventStoreRead, "hasEvent" | "getEvent"> {
+    /** Check if the event store has an event with id */
+    hasEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): boolean;
+    /** Get an event by id */
+    getEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): NostrEvent | undefined;
+}
+/** An extended async read interface for an event store that supports pointers */
+export interface IAsyncEventStoreReadAdvanced extends Omit<IAsyncEventStoreRead, "hasEvent" | "getEvent"> {
+    /** Check if the event store has an event with id */
+    hasEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<boolean>;
+    /** Get an event by id */
+    getEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<NostrEvent | undefined>;
+}
 /** The stream interface for an event store */
 export interface IEventStoreStreams {
     /** A stream of new events added to the store */
@@ -81,8 +95,8 @@ export interface IEventClaims {
 }
 /** An event store that can be subscribed to */
 export interface IEventSubscriptions {
-    /** Subscribe to an event by id */
-    event(id: string | EventPointer): Observable<NostrEvent | undefined>;
+    /** Subscribe to an event by id or pointer */
+    event(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     /** Subscribe to a replaceable event by pointer */
     replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     /** Subscribe to a replaceable event with legacy arguments */
@@ -93,6 +107,15 @@ export interface IEventSubscriptions {
     filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
     /** Subscribe to a sorted timeline of events that match the filters */
     timeline(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent[]>;
+    /** Subscribe to a users profile */
+    profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
+    /** Subscribe to a users contacts */
+    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+    /** Subscribe to a users mailboxes */
+    mailboxes(user: string | ProfilePointer): Observable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
 }
 /** Methods for creating common models */
 export interface IEventModelMixin<TStore extends IEventStore | IAsyncEventStore> {
@@ -185,8 +208,8 @@ export interface IMissingEventLoader {
     eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
 }
 /** Generic async event store interface */
-export interface IAsyncEventStore extends IAsyncEventStoreRead, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventClaims, IMissingEventLoader, IEventStoreModels {
+export interface IAsyncEventStore extends IAsyncEventStoreReadAdvanced, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventClaims, IMissingEventLoader {
 }
 /** Generic sync event store interface */
-export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventSubscriptions, IEventStoreActions, IEventModelMixin<IEventStore>, IEventClaims, IMissingEventLoader, IEventStoreModels {
+export interface IEventStore extends IEventStoreReadAdvanced, IEventStoreStreams, IEventSubscriptions, IEventStoreActions, IEventModelMixin<IEventStore>, IEventClaims, IMissingEventLoader {
 }

package/dist/helpers/contacts.d.ts

@@ -18,6 +18,7 @@ export declare function getPublicContacts(event: NostrEvent): ProfilePointer[];
 /** Checks if the hidden contacts are unlocked */
 export declare function isHiddenContactsUnlocked<T extends NostrEvent>(event: T): event is T & UnlockedContacts;
 /** Returns only the hidden contacts from a contacts list event */
+export declare function getHiddenContacts(event: UnlockedContacts): ProfilePointer[];
 export declare function getHiddenContacts(event: NostrEvent): ProfilePointer[] | undefined;
 /** Unlocks the hidden contacts */
 export declare function unlockHiddenContacts(event: NostrEvent, signer: HiddenContentSigner): Promise<ProfilePointer[]>;

package/dist/helpers/contacts.js

@@ -54,11 +54,11 @@ export function getPublicContacts(event) {
 }
 /** Checks if the hidden contacts are unlocked */
 export function isHiddenContactsUnlocked(event) {
-    return isHiddenTagsUnlocked(event) && Reflect.has(event, HiddenContactsSymbol);
+    // No need for try catch or proactivly parsing here since it only depends on hidden tags
+    return isHiddenTagsUnlocked(event);
 }
-/** Returns only the hidden contacts from a contacts list event */
 export function getHiddenContacts(event) {
-    if (isHiddenContactsUnlocked(event))
+    if (HiddenContactsSymbol in event)
         return event[HiddenContactsSymbol];
     // Get hidden tags
     const tags = getHiddenTags(event);

package/dist/helpers/encrypted-content.d.ts

@@ -45,7 +45,9 @@ export declare function hasEncryptedContent<T extends {
 export declare function getEncryptedContent<T extends UnlockedEncryptedContent>(event: T): string;
 export declare function getEncryptedContent<T extends object>(event: T): string | undefined;
 /** Checks if the encrypted content is unlocked and casts it to the {@link UnlockedEncryptedContent} type */
-export declare function isEncryptedContentUnlocked<T extends object>(event: T): event is T & UnlockedEncryptedContent;
+export declare function isEncryptedContentUnlocked<T extends {
+    kind: number;
+}>(event: T): event is T & UnlockedEncryptedContent;
 /**
  * Unlocks the encrypted content in an event and caches it
  * @param event The event with content to decrypt

package/dist/helpers/event-cache.js

@@ -1,6 +1,6 @@
 import { bufferTime, filter } from "rxjs";
 import { logger } from "../logger.js";
-import { isFromCache } from "./index.js";
+import { isFromCache } from "./event.js";
 const log = logger.extend("event-cache");
 /**
  * Setups a process to write batches of new events from an event store to a cache

package/dist/helpers/event.d.ts

@@ -1,7 +1,7 @@
 import { kinds } from "nostr-tools";
 import { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind } from "nostr-tools/kinds";
 import { NostrEvent, VerifiedEvent } from "nostr-tools/pure";
-import { IEventStore } from "../event-store/interface.js";
+import { IAsyncEventStore, IEventStore } from "../event-store/interface.js";
 export { EventTemplate, finalizeEvent, getEventHash, NostrEvent, serializeEvent, UnsignedEvent, VerifiedEvent, verifiedSymbol, verifyEvent, } from "nostr-tools/pure";
 export { binarySearch, bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, } from "nostr-tools/utils";
 export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds };
@@ -51,7 +51,7 @@ export declare function markFromCache(event: NostrEvent): void;
 /** Returns if an event was from a cache */
 export declare function isFromCache(event: NostrEvent): boolean;
 /** Returns the EventStore of an event if its been added to one */
-export declare function getParentEventStore<T extends object>(event: T): IEventStore | undefined;
+export declare function getParentEventStore<T extends object>(event: T): IEventStore | IAsyncEventStore | undefined;
 /** Notifies the events parent store that an event has been updated */
 export declare function notifyEventUpdate(event: any): void;
 /** Returns the replaceable identifier for a replaceable event */

package/dist/helpers/hidden-content.js

@@ -28,8 +28,8 @@ export function isHiddenContentUnlocked(event) {
 export function getHiddenContent(event) {
     if (!canHaveHiddenContent(event.kind))
         return undefined;
-    if (isHiddenContentUnlocked(event))
-        return event[EncryptedContentSymbol];
+    if (HiddenContentSymbol in event)
+        return Reflect.get(event, HiddenContentSymbol);
     return getEncryptedContent(event);
 }
 /**
@@ -42,8 +42,8 @@ export async function unlockHiddenContent(event, signer, override) {
     if (!canHaveHiddenContent(event.kind))
         throw new Error("Event kind does not support hidden content");
     // If the encrypted content is already unlocked, return the cached value
-    if (isEncryptedContentUnlocked(event))
-        return event[EncryptedContentSymbol];
+    if (HiddenContentSymbol in event)
+        return Reflect.get(event, HiddenContentSymbol);
     // Get the encryption method from the signer
     const encryption = getEncryptedContentEncryptionMethods(event.kind, signer, override);
     // Decrypt the content using the events pubkey

package/dist/helpers/hidden-tags.d.ts

@@ -23,7 +23,10 @@ export declare function getHiddenTagsEncryptionMethods(kind: number, signer: Hid
 export declare function isHiddenTagsUnlocked<T extends {
     kind: number;
 }>(event: T): event is T & UnlockedHiddenTags;
-/** Returns the hidden tags for an event if they are unlocked */
+/**
+ * Returns the hidden tags for an event if they are unlocked
+ * @throws {Error} If the hidden content is not an array of tags
+ */
 export declare function getHiddenTags<T extends {
     kind: number;
 } & UnlockedHiddenTags>(event: T): string[][];
@@ -35,7 +38,8 @@ export declare function getHiddenTags<T extends {
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
  * @param override The encryption method to use instead of the default
- * @throws
+ * @throws {Error} If the event kind does not support hidden tags
+ * @throws {Error} If the hidden content is not an array of tags
  */
 export declare function unlockHiddenTags<T extends {
     kind: number;

package/dist/helpers/hidden-tags.js

@@ -42,13 +42,18 @@ export function getHiddenTagsEncryptionMethods(kind, signer) {
 export function isHiddenTagsUnlocked(event) {
     if (!canHaveHiddenTags(event.kind))
         return false;
-    return isHiddenContentUnlocked(event) && Reflect.has(event, `HiddenTagsSymbol`);
+    // Wrap in try catch to avoid throwing validation errors
+    try {
+        return HiddenTagsSymbol in event || (isHiddenContentUnlocked(event) && getHiddenTags(event) !== undefined);
+    }
+    catch { }
+    return false;
 }
 export function getHiddenTags(event) {
     if (!canHaveHiddenTags(event.kind))
         return undefined;
     // If the hidden tags are already unlocked, return the cached value
-    if (isHiddenTagsUnlocked(event))
+    if (HiddenTagsSymbol in event)
         return event[HiddenTagsSymbol];
     // unlock hidden content is needed
     const content = getHiddenContent(event);
@@ -71,7 +76,8 @@ export function getHiddenTags(event) {
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
  * @param override The encryption method to use instead of the default
- * @throws
+ * @throws {Error} If the event kind does not support hidden tags
+ * @throws {Error} If the hidden content is not an array of tags
  */
 export async function unlockHiddenTags(event, signer, override) {
     if (!canHaveHiddenTags(event.kind))

package/dist/helpers/pointers.d.ts

@@ -29,9 +29,9 @@ export declare function getAddressPointerFromATag(tag: string[]): AddressPointer
 /** Gets a ProfilePointer from a common "p" tag */
 export declare function getProfilePointerFromPTag(tag: string[]): ProfilePointer | null;
 /** Checks if a pointer is an AddressPointer */
-export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
+export declare function isAddressPointer(pointer: any): pointer is AddressPointer;
 /** Checks if a pointer is an EventPointer */
-export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
+export declare function isEventPointer(pointer: any): pointer is EventPointer;
 /** Returns the stringified address pointer */
 export declare function getReplaceableAddressFromPointer(pointer: AddressPointer): string;
 /** Returns an AddressPointer for a replaceable event */

package/dist/helpers/pointers.js

@@ -40,13 +40,15 @@ export function parseReplaceableAddress(address, requireIdentifier = false) {
     const parts = address.split(":");
     const kind = parts[0] ? parseInt(parts[0]) : undefined;
     const pubkey = parts[1];
-    const identifier = parts[2] ?? "";
     // Check valid kind
     if (kind === undefined)
         return null;
     // Check valid pubkey
     if (pubkey === undefined || pubkey === "" || !isHexKey(pubkey))
         return null;
+    // Reconstruct identifier by joining all remaining parts after pubkey
+    // This handles cases where the identifier contains colons (e.g., URLs)
+    const identifier = parts.slice(2).join(":");
     // Return null if identifier is required and missing
     if (requireIdentifier && identifier === "")
         return null;
@@ -149,11 +151,18 @@ export function getProfilePointerFromPTag(tag) {
 }
 /** Checks if a pointer is an AddressPointer */
 export function isAddressPointer(pointer) {
-    return typeof pointer !== "string" && "identifier" in pointer && "pubkey" in pointer && "kind" in pointer;
+    return (typeof pointer === "object" &&
+        pointer !== null &&
+        "identifier" in pointer &&
+        "pubkey" in pointer &&
+        "kind" in pointer &&
+        typeof pointer.identifier === "string" &&
+        typeof pointer.pubkey === "string" &&
+        typeof pointer.kind === "number");
 }
 /** Checks if a pointer is an EventPointer */
 export function isEventPointer(pointer) {
-    return typeof pointer !== "string" && "id" in pointer;
+    return typeof pointer === "object" && pointer !== null && "id" in pointer && typeof pointer.id === "string";
 }
 /** Returns the stringified address pointer */
 export function getReplaceableAddressFromPointer(pointer) {

package/dist/helpers/profile.d.ts

@@ -1,5 +1,4 @@
-import { NostrEvent, kinds } from "./event.js";
-import { KnownEvent } from "./index.js";
+import { KnownEvent, NostrEvent, kinds } from "./event.js";
 export declare const ProfileContentSymbol: unique symbol;
 export type ProfileContent = {
     name?: string;

package/dist/helpers/profile.js

@@ -1,6 +1,6 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { kinds } from "./event.js";
-import { safeParse } from "./index.js";
+import { safeParse } from "./json.js";
 import { npubEncode } from "./pointers.js";
 export const ProfileContentSymbol = Symbol.for("profile-content");
 export function getProfileContent(event) {

package/dist/helpers/relays.d.ts

@@ -9,6 +9,8 @@ declare module "nostr-tools" {
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
 /** Returns the set of relays this event was seen on */
 export declare function getSeenRelays(event: NostrEvent): Set<string> | undefined;
+/** Checks if an event was received from a specific relay */
+export declare function isFromRelay(event: NostrEvent, relay: string): boolean;
 /** A fast check to make sure relay hints are safe to connect to */
 export declare function isSafeRelayURL(relay: string): boolean;
 /** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */

package/dist/helpers/relays.js

@@ -17,6 +17,10 @@ export function addSeenRelay(event, relay) {
 export function getSeenRelays(event) {
     return Reflect.get(event, SeenRelaysSymbol);
 }
+/** Checks if an event was received from a specific relay */
+export function isFromRelay(event, relay) {
+    return getSeenRelays(event)?.has(relay) === true;
+}
 const WEBSOCKET_URL_CHECK = /^wss?:\/\/([-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}|localhost)\b([-a-zA-Z0-9()@:%_\+.~#?&\/\/=]*)$/;
 /** A fast check to make sure relay hints are safe to connect to */
 export function isSafeRelayURL(relay) {

package/dist/helpers/tags.d.ts

@@ -12,8 +12,10 @@ export declare function isRTag(tag: string[]): tag is ["r", string, ...string[]]
 export declare function isDTag(tag: string[]): tag is ["d", string, ...string[]];
 /** Checks if tag is an "a" tag and has at least one value */
 export declare function isATag(tag: string[]): tag is ["a", string, ...string[]];
-/** Checks if tag is an "a" tag and has at least one value */
+/** Checks if tag is an "t" tag and has at least one value */
 export declare function isTTag(tag: string[]): tag is ["t", string, ...string[]];
+/** Checks if tag is an "q" tag and has at least one value */
+export declare function isQTag(tag: string[]): tag is ["q", string, ...string[]];
 /** Filter and transform tags */
 export declare const processTags: TagPipe;
 /** A pipeline that filters and maps each tag */

package/dist/helpers/tags.js

@@ -22,10 +22,14 @@ export function isDTag(tag) {
 export function isATag(tag) {
     return isNameValueTag(tag, "a");
 }
-/** Checks if tag is an "a" tag and has at least one value */
+/** Checks if tag is an "t" tag and has at least one value */
 export function isTTag(tag) {
     return isNameValueTag(tag, "t");
 }
+/** Checks if tag is an "q" tag and has at least one value */
+export function isQTag(tag) {
+    return isNameValueTag(tag, "q");
+}
 /** Filter and transform tags */
 export const processTags = (tags, ...fns) => {
     return fns.reduce((step, fn) => {

package/dist/models/base.js

@@ -1,9 +1,8 @@
-import { defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, ignoreElements, map, merge, mergeMap, mergeWith, of, repeat, scan, switchMap, take, takeUntil, tap, } from "rxjs";
+import { defer, distinctUntilChanged, EMPTY, filter, finalize, from, identity, map, merge, mergeMap, mergeWith, of, scan, startWith, switchMap, take, tap, } from "rxjs";
 import { getEventUID, getReplaceableIdentifier, insertEventIntoDescendingList, isReplaceable, } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { claimEvents } from "../observable/claim-events.js";
 import { claimLatest } from "../observable/claim-latest.js";
-import { defined } from "../observable/defined.js";
 /** Gets a single event from both types of event stores and returns an observable that completes */
 function getEventFromStores(store, pointer) {
     const r = store.getEvent(pointer.id);
@@ -35,10 +34,13 @@ function loadEventUsingFallback(store, pointer) {
     return switchMap((event) => {
         if (event)
             return of(event);
-        // If event was not found, attempt to load
+        // If no loader pass value through, should never happen
         if (!store.eventLoader)
-            return EMPTY;
-        return from(store.eventLoader(pointer)).pipe(filter((e) => !!e));
+            return of(event);
+        // If event was not found, attempt to load
+        return from(store.eventLoader(pointer)).pipe(
+        // Start with `undefined` since its not loaded yet
+        startWith(undefined));
     });
 }
 /** A model that returns a single event or undefined when its removed */
@@ -46,22 +48,22 @@ export function EventModel(pointer) {
     if (typeof pointer === "string")
         pointer = { id: pointer };
     return (store) => merge(
-    // get current event and ignore if there is none
+    // get current event
     defer(() => getEventFromStores(store, pointer)).pipe(
     // If the event isn't found, attempt to load using the fallback loader
-    loadEventUsingFallback(store, pointer), 
-    // Only emit found events
-    defined()), 
+    store.eventLoader ? loadEventUsingFallback(store, pointer) : identity), 
     // Listen for new events
     store.insert$.pipe(filter((e) => e.id === pointer.id)), 
     // emit undefined when deleted
-    store.remove$.pipe(filter((e) => e.id === pointer.id), take(1), ignoreElements(), 
+    store.remove$.pipe(filter((e) => e.id === pointer.id), 
+    // Complete when the event is removed
+    take(1), 
     // Emit undefined when deleted
-    endWith(undefined))).pipe(
+    map(() => undefined))).pipe(
+    // ignore duplicate events (true === same)
+    distinctUntilChanged((a, b) => a?.id === b?.id), 
     // claim all events
-    claimLatest(store), 
-    // ignore duplicate events
-    distinctUntilChanged((a, b) => a?.id === b?.id));
+    claimLatest(store));
 }
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
 export function ReplaceableModel(pointer) {
@@ -71,26 +73,30 @@ export function ReplaceableModel(pointer) {
         // lazily get current event
         defer(() => getReplaceableFromStores(store, pointer)).pipe(
         // If the event isn't found, attempt to load using the fallback loader
-        loadEventUsingFallback(store, pointer), 
-        // Only emit found events
-        defined()), 
+        store.eventLoader ? loadEventUsingFallback(store, pointer) : identity), 
         // Subscribe to new events that match the pointer
         store.insert$.pipe(filter((e) => e.pubkey == pointer.pubkey &&
             e.kind === pointer.kind &&
             (pointer.identifier !== undefined ? getReplaceableIdentifier(e) === pointer.identifier : true)))).pipe(
-        // only update if event is newer
+        // Hacky way to extract the current event so it can be used in the remove$ stream
+        tap((event) => (current = event)), 
+        // Subscribe to the event being removed
+        mergeWith(store.remove$.pipe(filter((e) => {
+            return e.id === current?.id;
+        }), 
+        // Emit undefined when the event is removed
+        map(() => {
+            return undefined;
+        }))), 
+        // only update if event is newer (true === same)
         distinctUntilChanged((prev, event) => {
-            // are the events the same? i.e. is the prev event older
-            return prev.created_at >= event.created_at;
+            // If the event has changed from undefined to defined or vice versa
+            if (prev === undefined || event === undefined) {
+                return prev === event;
+            }
+            // Return if event is newer than the previous event
+            return event.created_at < prev.created_at;
         }), 
-        // Hacky way to extract the current event so takeUntil can access it
-        tap((event) => (current = event)), 
-        // complete when event is removed
-        takeUntil(store.remove$.pipe(filter((e) => e.id === current?.id))), 
-        // emit undefined when removed
-        endWith(undefined), 
-        // keep the observable hot
-        repeat(), 
         // claim latest event
         claimLatest(store));
     };
@@ -128,7 +134,8 @@ export function TimelineModel(filters, includeOldVersion) {
                         if (isReplaceable(e.kind))
                             seen.set(getEventUID(e), e);
                 }
-                return event;
+                // 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];
@@ -136,14 +143,17 @@ export function TimelineModel(filters, includeOldVersion) {
             if (!includeOldVersion && isReplaceable(event.kind)) {
                 const uid = getEventUID(event);
                 const existing = seen.get(uid);
-                // if this is an older replaceable event, exit
+                // if this is an older replaceable event, return a new array instance
                 if (existing && event.created_at < existing.created_at)
-                    return timeline;
+                    return [...timeline];
                 // update latest version
                 seen.set(uid, event);
                 // remove old event from timeline
-                if (existing)
-                    newTimeline.slice(newTimeline.indexOf(existing), 1);
+                if (existing) {
+                    const index = newTimeline.indexOf(existing);
+                    if (index !== -1)
+                        newTimeline.splice(index, 1);
+                }
             }
             // add event into timeline
             insertEventIntoDescendingList(newTimeline, event);

package/dist/observable/watch-event-updates.d.ts

@@ -5,3 +5,5 @@ import { IEventStoreStreams } from "../event-store/interface.js";
 export declare function watchEventUpdates(eventStore: IEventStoreStreams): MonoTypeOperatorFunction<NostrEvent | undefined>;
 /** Watches for any updates to the latest array of events and remits the array of events when updated */
 export declare function watchEventsUpdates(eventStore: IEventStoreStreams): MonoTypeOperatorFunction<NostrEvent[]>;
+/** Alias for watchEventsUpdates */
+export declare const watchTimelineUpdates: typeof watchEventsUpdates;

package/dist/observable/watch-event-updates.js

@@ -23,3 +23,5 @@ export function watchEventsUpdates(eventStore) {
         map(() => latest)));
     };
 }
+/** Alias for watchEventsUpdates */
+export const watchTimelineUpdates = watchEventsUpdates;

package/dist/operations/tag/common.d.ts

@@ -5,7 +5,7 @@ import { AddressPointer, EventPointer, ProfilePointer } from "../../helpers/poin
 export declare function addProfilePointerTag(pubkey: string | ProfilePointer, replace?: boolean): TagOperation;
 /** Removes all "p" tags matching a pubkey */
 export declare function removeProfilePointerTag(pubkey: string | ProfilePointer): TagOperation;
-/** Adds a a single "e" tag for an EventPointer */
+/** Adds a single "e" tag for an EventPointer */
 export declare function addEventPointerTag(id: string | EventPointer | NostrEvent, replace?: boolean): TagOperation;
 /** Removes all "e" tags matching EventPointer or id */
 export declare function removeEventPointerTag(id: string | EventPointer): TagOperation;

package/dist/operations/tag/common.js

@@ -24,7 +24,7 @@ export function removeProfilePointerTag(pubkey) {
     pubkey = typeof pubkey !== "string" ? pubkey.pubkey : pubkey;
     return (tags) => tags.filter((t) => !(t[0] === "p" && t[1] === pubkey));
 }
-/** Adds a a single "e" tag for an EventPointer */
+/** Adds a single "e" tag for an EventPointer */
 export function addEventPointerTag(id, replace = true) {
     return async (tags, { getEventRelayHint }) => {
         const pointer = typeof id === "string" ? { id } : isEvent(id) ? getEventPointerForEvent(id) : id;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20251209200210",
+  "version": "0.0.0-next-20251220152312",
   "description": "",
   "type": "module",
   "main": "dist/index.js",