applesauce-core 0.0.0-next-20250725170333 → 0.0.0-next-20250726160247

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

@@ -1,8 +1,9 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
 import { EventSet } from "./event-set.js";
 import { IEventStore, ModelConstructor } from "./interface.js";
-import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 /** An extended {@link EventSet} that handles replaceable events, delets, and models */
 export declare class EventStore implements IEventStore {
     database: EventSet;
@@ -19,6 +20,21 @@ export declare class EventStore implements IEventStore {
     update$: Observable<NostrEvent>;
     /** A stream of events that have been removed */
     remove$: Observable<NostrEvent>;
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent>;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent>;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent>;
     constructor();
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
@@ -76,36 +92,39 @@ export declare class EventStore implements IEventStore {
     /** Creates an observable that emits when event is updated */
     updated(event: string | NostrEvent): Observable<NostrEvent>;
     /** Creates a {@link EventModel} */
-    event(id: string): Observable<NostrEvent | undefined>;
+    event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
     /** Creates a {@link ReplaceableModel} */
+    replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+    /** Subscribe to an addressable event by pointer */
+    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     /** Creates a {@link TimelineModel} */
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
-    /** Creates a {@link EventsModel} */
-    events(ids: string[]): Observable<Record<string, NostrEvent>>;
-    /** Creates a {@link ReplaceableSetModel} */
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Record<string, NostrEvent>>;
-    /** Creates a {@link ProfileModel} */
-    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-    /** Creates a {@link ContactsModel} */
-    contacts(pubkey: string): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
-    /** Creates a {@link MuteModel} */
-    mutes(pubkey: string): Observable<import("../helpers/mutes.js").Mutes | undefined>;
-    /** Creates a {@link ReactionsModel} */
-    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** Creates a {@link MailboxesModel} */
-    mailboxes(pubkey: string): Observable<{
+    /** Subscribe to a users profile */
+    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 mutes */
+    mutes(user: string | ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
+    /** Subscribe to a users NIP-65 mailboxes */
+    mailboxes(user: string | ProfilePointer): Observable<{
         inboxes: string[];
         outboxes: string[];
     } | undefined>;
-    /** Creates a {@link UserBlossomServersModel} */
-    blossomServers(pubkey: string): Observable<URL[]>;
-    /** Creates a {@link ThreadModel} */
+    /** Subscribe to a users blossom servers */
+    blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+    /** Subscribe to an event's reactions */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** Subscribe to a thread */
     thread(root: string | EventPointer | AddressPointer): Observable<import("../models/thread.js").Thread>;
-    /** Creates a {@link CommentsModel} */
+    /** Subscribe to a event's comments */
     comments(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** @deprecated use multiple {@link EventModel} instead */
+    events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+    /** @deprecated use multiple {@link ReplaceableModel} instead */
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Record<string, NostrEvent | undefined>>;
 }

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

@@ -7,15 +7,15 @@ import { EventStoreSymbol, FromCacheSymbol, getReplaceableAddress, isReplaceable
 import { matchFilters } from "../helpers/filter.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { UserBlossomServersModel } from "../models/blossom.js";
 import { EventModel, EventsModel, ReplaceableModel, ReplaceableSetModel, TimelineModel } from "../models/common.js";
-import { EventSet } from "./event-set.js";
-import { ProfileModel } from "../models/profile.js";
 import { ContactsModel } from "../models/contacts.js";
+import { CommentsModel, ThreadModel } from "../models/index.js";
+import { MailboxesModel } from "../models/mailboxes.js";
 import { MuteModel } from "../models/mutes.js";
+import { ProfileModel } from "../models/profile.js";
 import { ReactionsModel } from "../models/reactions.js";
-import { MailboxesModel } from "../models/mailboxes.js";
-import { UserBlossomServersModel } from "../models/blossom.js";
-import { CommentsModel, ThreadModel } from "../models/index.js";
+import { EventSet } from "./event-set.js";
 /** An extended {@link EventSet} that handles replaceable events, delets, and models */
 export class EventStore {
     database;
@@ -32,6 +32,21 @@ export class EventStore {
     update$;
     /** A stream of events that have been removed */
     remove$;
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader;
     constructor() {
         this.database = new EventSet();
         // verify events before they are added to the database
@@ -285,55 +300,79 @@ export class EventStore {
     }
     // Helper methods for creating models
     /** Creates a {@link EventModel} */
-    event(id) {
-        return this.model(EventModel, id);
+    event(pointer) {
+        if (typeof pointer === "string")
+            pointer = { id: pointer };
+        return this.model(EventModel, pointer);
+    }
+    replaceable(...args) {
+        let pointer;
+        // Parse arguments
+        if (args.length === 1) {
+            pointer = args[0];
+        }
+        else if (args.length === 3 || args.length === 2) {
+            let [kind, pubkey, identifier] = args;
+            pointer = { kind, pubkey, identifier };
+        }
+        if (!pointer)
+            throw new Error("Invalid arguments, expected address pointer or kind, pubkey, identifier");
+        return this.model(ReplaceableModel, pointer);
     }
-    /** Creates a {@link ReplaceableModel} */
-    replaceable(kind, pubkey, identifier) {
-        return this.model(ReplaceableModel, kind, pubkey, identifier);
+    /** Subscribe to an addressable event by pointer */
+    addressable(pointer) {
+        return this.model(ReplaceableModel, pointer);
     }
     /** Creates a {@link TimelineModel} */
     timeline(filters, includeOldVersion = false) {
         return this.model(TimelineModel, filters, includeOldVersion);
     }
-    /** Creates a {@link EventsModel} */
-    events(ids) {
-        return this.model(EventsModel, ids);
-    }
-    /** Creates a {@link ReplaceableSetModel} */
-    replaceableSet(pointers) {
-        return this.model(ReplaceableSetModel, pointers);
-    }
-    /** Creates a {@link ProfileModel} */
-    profile(pubkey) {
-        return this.model(ProfileModel, pubkey);
-    }
-    /** Creates a {@link ContactsModel} */
-    contacts(pubkey) {
-        return this.model(ContactsModel, pubkey);
-    }
-    /** Creates a {@link MuteModel} */
-    mutes(pubkey) {
-        return this.model(MuteModel, pubkey);
-    }
-    /** Creates a {@link ReactionsModel} */
+    /** Subscribe to a users profile */
+    profile(user) {
+        return this.model(ProfileModel, user);
+    }
+    /** Subscribe to a users contacts */
+    contacts(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(ContactsModel, user);
+    }
+    /** Subscribe to a users mutes */
+    mutes(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(MuteModel, user);
+    }
+    /** Subscribe to a users NIP-65 mailboxes */
+    mailboxes(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(MailboxesModel, user);
+    }
+    /** Subscribe to a users blossom servers */
+    blossomServers(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(UserBlossomServersModel, user);
+    }
+    /** Subscribe to an event's reactions */
     reactions(event) {
         return this.model(ReactionsModel, event);
     }
-    /** Creates a {@link MailboxesModel} */
-    mailboxes(pubkey) {
-        return this.model(MailboxesModel, pubkey);
-    }
-    /** Creates a {@link UserBlossomServersModel} */
-    blossomServers(pubkey) {
-        return this.model(UserBlossomServersModel, pubkey);
-    }
-    /** Creates a {@link ThreadModel} */
+    /** Subscribe to a thread */
     thread(root) {
         return this.model(ThreadModel, root);
     }
-    /** Creates a {@link CommentsModel} */
+    /** Subscribe to a event's comments */
     comments(event) {
         return this.model(CommentsModel, event);
     }
+    /** @deprecated use multiple {@link EventModel} instead */
+    events(ids) {
+        return this.model(EventsModel, ids);
+    }
+    /** @deprecated use multiple {@link ReplaceableModel} instead */
+    replaceableSet(pointers) {
+        return this.model(ReplaceableSetModel, pointers);
+    }
 }

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

@@ -65,25 +65,13 @@ export interface IEventStoreSubscriptions {
 }
 /** Methods for creating common models */
 export interface IEventStoreModels {
+    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
     event(id: string): Observable<NostrEvent | undefined>;
-    events(ids: string[]): Observable<Record<string, NostrEvent>>;
-    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Record<string, NostrEvent>>;
+    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
-    profile(pubkey: string): Observable<ProfileContent | undefined>;
-    contacts(pubkey: string): Observable<ProfilePointer[]>;
-    mutes(pubkey: string): Observable<Mutes | undefined>;
-    reactions(event: NostrEvent): Observable<NostrEvent[]>;
-    mailboxes(pubkey: string): Observable<{
-        inboxes: string[];
-        outboxes: string[];
-    } | undefined>;
-    blossomServers(pubkey: string): Observable<URL[]>;
-    thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
+    events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+    replaceableSet(pointers: (AddressPointer | AddressPointerWithoutD)[]): Observable<Record<string, NostrEvent | undefined>>;
 }
 /** A computed view of an event set or event store */
 export type Model<T extends unknown> = (events: IEventStore) => Observable<T>;
@@ -99,5 +87,19 @@ export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEvent
     filters(filters: Filter | Filter[]): Observable<NostrEvent>;
     updated(id: string | NostrEvent): Observable<NostrEvent>;
     removed(id: string): Observable<never>;
-    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
+    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent>;
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent>;
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent>;
+    profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
+    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+    mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
+    mailboxes(user: string | ProfilePointer): Observable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+    reactions(event: NostrEvent): Observable<NostrEvent[]>;
+    thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
 }

package/dist/models/blossom.d.ts

@@ -1,3 +1,4 @@
+import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
 /** A model that returns a users blossom servers */
-export declare function UserBlossomServersModel(pubkey: string): Model<URL[]>;
+export declare function UserBlossomServersModel(user: string | ProfilePointer): Model<URL[]>;

package/dist/models/blossom.js

@@ -1,8 +1,10 @@
 import { map } from "rxjs/operators";
 import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
 /** A model that returns a users blossom servers */
-export function UserBlossomServersModel(pubkey) {
+export function UserBlossomServersModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
     return (store) => store
-        .replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey)
+        .replaceable({ kind: BLOSSOM_SERVER_LIST_KIND, pubkey: user.pubkey, relays: user.relays })
         .pipe(map((event) => (event ? getBlossomServersFromList(event) : [])));
 }

package/dist/models/common.d.ts

@@ -1,16 +1,20 @@
 import { Filter, NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
+import { AddressPointerWithoutD } from "../helpers/index.js";
 /** A model that returns a single event or undefined when its removed */
-export declare function EventModel(id: string): Model<NostrEvent | undefined>;
+export declare function EventModel(pointer: string | EventPointer): Model<NostrEvent | undefined>;
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
-export declare function ReplaceableModel(kind: number, pubkey: string, d?: string): Model<NostrEvent | undefined>;
+export declare function ReplaceableModel(pointer: AddressPointer | AddressPointerWithoutD): Model<NostrEvent | undefined>;
 /** A model that returns an array of sorted events matching the filters */
 export declare function TimelineModel(filters: Filter | Filter[], includeOldVersion?: boolean): Model<NostrEvent[]>;
-/** A model that returns a multiple events in a map */
-export declare function EventsModel(ids: string[]): Model<Record<string, NostrEvent>>;
-/** A model that returns a directory of events by their UID */
-export declare function ReplaceableSetModel(pointers: {
-    kind: number;
-    pubkey: string;
-    identifier?: string;
-}[]): Model<Record<string, NostrEvent>>;
+/**
+ * A model that returns a multiple events in a map
+ * @deprecated use multiple {@link EventModel} instead
+ */
+export declare function EventsModel(ids: string[]): Model<Record<string, NostrEvent | undefined>>;
+/**
+ * A model that returns a directory of events by their UID
+ * @deprecated use multiple {@link ReplaceableModel} instead
+ */
+export declare function ReplaceableSetModel(pointers: (AddressPointer | AddressPointerWithoutD)[]): Model<Record<string, NostrEvent | undefined>>;

package/dist/models/common.js

@@ -1,40 +1,52 @@
-import { defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeWith, of, repeat, scan, takeUntil, tap, } from "rxjs";
+import { combineLatest, defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, map, merge, mergeWith, of, repeat, scan, takeUntil, tap, } from "rxjs";
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { createReplaceableAddress, getEventUID, getReplaceableIdentifier, isReplaceable, matchFilters, } from "../helpers/index.js";
 import { claimEvents } from "../observable/claim-events.js";
 import { claimLatest } from "../observable/claim-latest.js";
-import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
 /** A model that returns a single event or undefined when its removed */
-export function EventModel(id) {
+export function EventModel(pointer) {
+    if (typeof pointer === "string")
+        pointer = { id: pointer };
     return (events) => merge(
     // get current event and ignore if there is none
     defer(() => {
-        let event = events.getEvent(id);
-        return event ? of(event) : EMPTY;
+        let event = events.getEvent(pointer.id);
+        if (event)
+            return of(event);
+        // If there is a loader, use it to get the event
+        return events.eventLoader?.(pointer) ?? EMPTY;
     }), 
-    // subscribe to updates
-    events.insert$.pipe(filter((e) => e.id === id)), 
-    // subscribe to updates
-    events.updated(id), 
+    // Listen for new events
+    events.insert$.pipe(filter((e) => e.id === pointer.id)), 
     // emit undefined when deleted
-    events.removed(id).pipe(endWith(undefined))).pipe(
+    events.removed(pointer.id).pipe(endWith(undefined))).pipe(
     // claim all events
     claimLatest(events), 
+    // ignore duplicate events
+    distinctUntilChanged((a, b) => a?.id === b?.id), 
     // always emit undefined so the observable is synchronous
     withImmediateValueOrDefault(undefined));
 }
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
-export function ReplaceableModel(kind, pubkey, d) {
+export function ReplaceableModel(pointer) {
     return (events) => {
         let current = undefined;
         return merge(
         // lazily get current event
         defer(() => {
-            let event = events.getReplaceable(kind, pubkey, d);
-            return event ? of(event) : EMPTY;
+            let event = events.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
+            if (event)
+                return of(event);
+            else if (pointer.identifier !== undefined)
+                return events.addressableLoader?.(pointer) ?? EMPTY;
+            else
+                return events.replaceableLoader?.(pointer) ?? EMPTY;
         }), 
         // subscribe to new events
-        events.insert$.pipe(filter((e) => e.pubkey == pubkey && e.kind === kind && (d !== undefined ? getReplaceableIdentifier(e) === d : true)))).pipe(
+        events.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
         distinctUntilChanged((prev, event) => {
             // are the events the same? i.e. is the prev event older
@@ -108,69 +120,20 @@ export function TimelineModel(filters, includeOldVersion) {
         finalize(() => seen.clear()));
     };
 }
-/** A model that returns a multiple events in a map */
+/**
+ * A model that returns a multiple events in a map
+ * @deprecated use multiple {@link EventModel} instead
+ */
 export function EventsModel(ids) {
-    return (events) => merge(
-    // lazily get existing events
-    defer(() => from(ids.map((id) => events.getEvent(id)))), 
-    // subscribe to new events
-    events.insert$.pipe(filter((e) => ids.includes(e.id))), 
-    // subscribe to updates
-    events.update$.pipe(filter((e) => ids.includes(e.id)))).pipe(
-    // ignore empty messages
-    filter((e) => !!e), 
-    // claim all events until cleanup
-    claimEvents(events), 
-    // watch for removed events
-    mergeWith(events.remove$.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
-    // merge all events into a directory
-    scan((dir, event) => {
-        if (typeof event === "string") {
-            // delete event by id
-            const clone = { ...dir };
-            delete clone[event];
-            return clone;
-        }
-        else {
-            // add even to directory
-            return { ...dir, [event.id]: event };
-        }
-    }, {}));
+    return (events) => combineLatest(Object.fromEntries(ids.map((id) => [id, events.model(EventModel, { id })])));
 }
-/** A model that returns a directory of events by their UID */
+/**
+ * A model that returns a directory of events by their UID
+ * @deprecated use multiple {@link ReplaceableModel} instead
+ */
 export function ReplaceableSetModel(pointers) {
-    return (events) => {
-        const uids = new Set(pointers.map((p) => createReplaceableAddress(p.kind, p.pubkey, p.identifier)));
-        return merge(
-        // start with existing events
-        defer(() => from(pointers.map((p) => events.getReplaceable(p.kind, p.pubkey, p.identifier)))), 
-        // subscribe to new events
-        events.insert$.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
-        // filter out undefined
-        filter((e) => !!e), 
-        // claim all events
-        claimEvents(events), 
-        // convert events to add commands
-        map((e) => ["add", e]), 
-        // watch for removed events
-        mergeWith(events.remove$.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))), map((e) => ["remove", e]))), 
-        // reduce events into directory
-        scan((dir, [action, event]) => {
-            const uid = getEventUID(event);
-            if (action === "add") {
-                // add event to dir if its newer
-                if (!dir[uid] || dir[uid].created_at < event.created_at)
-                    return { ...dir, [uid]: event };
-            }
-            else if (action === "remove" && dir[uid] === event) {
-                // remove event from dir
-                let newDir = { ...dir };
-                delete newDir[uid];
-                return newDir;
-            }
-            return dir;
-        }, {}), 
-        // ignore changes that do not modify the directory
-        distinctUntilChanged());
-    };
+    return (events) => combineLatest(Object.fromEntries(pointers.map((pointer) => [
+        createReplaceableAddress(pointer.kind, pointer.pubkey, pointer.identifier),
+        events.model(ReplaceableModel, pointer),
+    ])));
 }

package/dist/models/contacts.d.ts

@@ -1,7 +1,7 @@
 import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
 /** A model that returns all contacts for a user */
-export declare function ContactsModel(pubkey: string): Model<ProfilePointer[]>;
+export declare function ContactsModel(user: string | ProfilePointer): Model<ProfilePointer[]>;
 /** A model that returns all public contacts for a user */
 export declare function PublicContactsModel(pubkey: string): Model<ProfilePointer[] | undefined>;
 /** A model that returns all hidden contacts for a user */

package/dist/models/contacts.js

@@ -3,8 +3,10 @@ import { map } from "rxjs/operators";
 import { getContacts, getHiddenContacts, getPublicContacts } from "../helpers/contacts.js";
 import { watchEventUpdates } from "../observable/index.js";
 /** A model that returns all contacts for a user */
-export function ContactsModel(pubkey) {
-    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+export function ContactsModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.Contacts, pubkey: user.pubkey, relays: user.relays }).pipe(
     // listen for event updates (hidden tags unlocked)
     watchEventUpdates(events), 
     // Get all contacts

package/dist/models/mailboxes.d.ts

@@ -1,6 +1,7 @@
+import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
 /** A model that gets and parses the inbox and outbox relays for a pubkey */
-export declare function MailboxesModel(pubkey: string): Model<{
+export declare function MailboxesModel(user: string | ProfilePointer): Model<{
     inboxes: string[];
     outboxes: string[];
 } | undefined>;

package/dist/models/mailboxes.js

@@ -2,8 +2,10 @@ import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 /** A model that gets and parses the inbox and outbox relays for a pubkey */
-export function MailboxesModel(pubkey) {
-    return (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
+export function MailboxesModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.RelayList, pubkey: user.pubkey, relays: user.relays }).pipe(map((event) => event && {
         inboxes: getInboxes(event),
         outboxes: getOutboxes(event),
     }));

package/dist/models/mutes.d.ts

@@ -1,7 +1,8 @@
-import { Mutes } from "../helpers/mutes.js";
+import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
+import { Mutes } from "../helpers/mutes.js";
 /** A model that returns all a users muted things */
-export declare function MuteModel(pubkey: string): Model<Mutes | undefined>;
+export declare function MuteModel(user: string | ProfilePointer): Model<Mutes | undefined>;
 /** A model that returns all a users public muted things */
 export declare function PublicMuteModel(pubkey: string): Model<Mutes | undefined>;
 /** A model that returns all a users hidden muted things */

package/dist/models/mutes.js

@@ -3,8 +3,10 @@ import { map } from "rxjs/operators";
 import { getHiddenMutedThings, getMutedThings, getPublicMutedThings } from "../helpers/mutes.js";
 import { watchEventUpdates } from "../observable/watch-event-updates.js";
 /** A model that returns all a users muted things */
-export function MuteModel(pubkey) {
-    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+export function MuteModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.Mutelist, pubkey: user.pubkey, relays: user.relays }).pipe(
     // listen for event updates (hidden tags unlocked)
     watchEventUpdates(events), 
     // Get all muted things

package/dist/models/profile.d.ts

@@ -1,4 +1,5 @@
 import { Model } from "../event-store/interface.js";
 import { ProfileContent } from "../helpers/profile.js";
+import { ProfilePointer } from "nostr-tools/nip19";
 /** A model that gets and parses the kind 0 metadata for a pubkey */
-export declare function ProfileModel(pubkey: string): Model<ProfileContent | undefined>;
+export declare function ProfileModel(user: string | ProfilePointer): Model<ProfileContent | undefined>;

package/dist/models/profile.js

@@ -3,8 +3,10 @@ import { filter, map } from "rxjs/operators";
 import { getProfileContent, isValidProfile } from "../helpers/profile.js";
 import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
 /** A model that gets and parses the kind 0 metadata for a pubkey */
-export function ProfileModel(pubkey) {
-    return (events) => events.replaceable(kinds.Metadata, pubkey).pipe(
+export function ProfileModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.Metadata, pubkey: user.pubkey, relays: user.relays }).pipe(
     // Filter out invalid profile events
     filter(isValidProfile), 
     // Parse the profile event into a ProfileContent

package/package.json

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