applesauce-core 0.0.0-next-20250916134023 → 0.0.0-next-20250919114711

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

@@ -17,7 +17,7 @@ declare const AsyncEventStore_base: {
         addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
         timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
         profile(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[] | undefined>;
+        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
         mutes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
         mailboxes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<{
             inboxes: string[];

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

@@ -214,7 +214,7 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
         // remove all old version of the replaceable event
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
-            if (existing) {
+            if (existing && existing.length > 0) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
                     await this.remove(old);
@@ -231,16 +231,16 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
     }
     /** Removes an event from the store and updates subscriptions */
     async remove(event) {
-        // Get the current instance from the database
-        const e = await this.database.getEvent(typeof event === "string" ? event : event.id);
-        if (!e)
-            return false;
+        let instance = this.memory?.getEvent(typeof event === "string" ? event : event.id);
         // Remove from memory if available
         if (this.memory)
-            this.memory.remove(typeof event === "string" ? event : event.id);
+            this.memory.remove(event);
+        // Remove the event from the database
         const removed = await this.database.remove(event);
-        if (removed && e)
-            this.remove$.next(e);
+        // If the event was removed, notify the subscriptions
+        if (removed && instance) {
+            this.remove$.next(instance);
+        }
         return removed;
     }
     /** Add an event to the store and notifies all subscribes it has updated */

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

@@ -66,9 +66,9 @@ export declare class EventMemory implements IEventMemory {
     /** Iterates over all events by id */
     iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
     /** Returns all events that match the filter */
-    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    protected getEventsForFilter(filter: Filter): Set<NostrEvent>;
     /** Returns all events that match the filters */
-    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
+    protected getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
     /** Resets the event set */
     reset(): void;
 }

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

@@ -90,7 +90,7 @@ export class EventMemory {
     remove(eventOrId) {
         let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
         if (!event)
-            throw new Error("Missing event");
+            return false;
         const id = event.id;
         // only remove events that are known
         if (!this.events.has(id))
@@ -327,7 +327,7 @@ export class EventMemory {
     /** Returns all events that match the filters */
     getEventsForFilters(filters) {
         if (filters.length === 0)
-            throw new Error("No Filters");
+            return new Set();
         let events = new Set();
         for (const filter of filters) {
             const filtered = this.getEventsForFilter(filter);

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

@@ -17,7 +17,7 @@ declare const EventStore_base: {
         addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
         timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
         profile(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[] | undefined>;
+        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
         mutes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
         mailboxes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<{
             inboxes: string[];

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

@@ -218,7 +218,7 @@ export class EventStore extends EventStoreModelMixin(class {
         // remove all old version of the replaceable event
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
             const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
-            if (existing) {
+            if (existing && existing.length > 0) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
                     this.remove(old);
@@ -235,16 +235,16 @@ export class EventStore extends EventStoreModelMixin(class {
     }
     /** Removes an event from the store and updates subscriptions */
     remove(event) {
-        // Get the current instance from the database
-        const e = this.database.getEvent(typeof event === "string" ? event : event.id);
-        if (!e)
-            return false;
+        let instance = this.memory?.getEvent(typeof event === "string" ? event : event.id);
         // Remove from memory if available
         if (this.memory)
             this.memory.remove(event);
+        // Remove the event from the database
         const removed = this.database.remove(event);
-        if (removed && e)
-            this.remove$.next(e);
+        // If the event was removed, notify the subscriptions
+        if (removed && instance) {
+            this.remove$.next(instance);
+        }
         return removed;
     }
     /** Add an event to the store and notifies all subscribes it has updated */

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

@@ -112,7 +112,7 @@ export interface IEventHelpfulSubscriptions {
     /** Subscribe to a users profile */
     profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
     /** Subscribe to a users contacts */
-    contacts(user: string | ProfilePointer): Observable<ProfilePointer[] | undefined>;
+    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
     /** Subscribe to a users mutes */
     mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
     /** Subscribe to a users NIP-65 mailboxes */

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

@@ -31,7 +31,7 @@ export declare function EventStoreModelMixin<T extends new (...args: any[]) => a
         /** 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[] | undefined>;
+        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 */

package/dist/helpers/index.d.ts

@@ -43,6 +43,7 @@ export * from "./pointers.js";
 export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./relay-selection.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";

package/dist/helpers/index.js

@@ -43,6 +43,7 @@ export * from "./pointers.js";
 export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./relay-selection.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";

package/dist/helpers/mailboxes.d.ts

@@ -1,11 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 export declare const MailboxesInboxesSymbol: unique symbol;
 export declare const MailboxesOutboxesSymbol: unique symbol;
-/**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export declare function getInboxes(event: NostrEvent): string[];
-/**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export declare function getOutboxes(event: NostrEvent): string[];

package/dist/helpers/mailboxes.js

@@ -1,41 +1,47 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
+import { isRTag } from "./tags.js";
 import { normalizeURL } from "./url.js";
 export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
 export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
-/**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export function getInboxes(event) {
     return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
         const inboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !inboxes.includes(url) &&
-                (mode === "read" || mode === undefined)) {
-                inboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [, url, mode] = tag;
+                if (url && isSafeRelayURL(url) && !inboxes.includes(url) && (mode === "read" || mode === undefined)) {
+                    inboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return inboxes;
     });
 }
-/**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export function getOutboxes(event) {
     return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
         const outboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !outboxes.includes(url) &&
-                (mode === "write" || mode === undefined)) {
-                outboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [name, url, mode] = tag;
+                if (name === "r" &&
+                    isSafeRelayURL(url) &&
+                    !outboxes.includes(url) &&
+                    (mode === "write" || mode === undefined)) {
+                    outboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return outboxes;

package/dist/helpers/pointers.js

@@ -5,6 +5,7 @@ import { isAddressableKind } from "nostr-tools/kinds";
 import { isSafeRelayURL, mergeRelaySets } from "./relays.js";
 import { isHexKey } from "./string.js";
 import { hexToBytes } from "@noble/hashes/utils";
+import { normalizeURL } from "./url.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] ? parseInt(parts[0]) : undefined;
@@ -117,7 +118,7 @@ export function getProfilePointerFromPTag(tag) {
         throw new Error("Invalid pubkey");
     const pointer = { pubkey: tag[1] };
     if (tag[2] && isSafeRelayURL(tag[2]))
-        pointer.relays = [tag[2]];
+        pointer.relays = [normalizeURL(tag[2])];
     return pointer;
 }
 /** Checks if a pointer is an AddressPointer */

package/dist/helpers/relay-selection.d.ts

@@ -0,0 +1,13 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+export type SelectOptimalRelaysOptions = {
+    /** Maximum number of connections (relays) to select */
+    maxConnections: number;
+    /** Cap the number of relays a user can have */
+    maxRelaysPerUser?: number;
+};
+/** Selects the optimal relays for a list of ProfilePointers */
+export declare function selectOptimalRelays(users: ProfilePointer[], { maxConnections, maxRelaysPerUser }: SelectOptimalRelaysOptions): ProfilePointer[];
+/** A map of pubkeys by relay */
+export type OutboxMap = Record<string, ProfilePointer[]>;
+/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+export declare function groupPubkeysByRelay(pointers: ProfilePointer[]): OutboxMap;

package/dist/helpers/relay-selection.js

@@ -0,0 +1,84 @@
+/** Selects the optimal relays for a list of ProfilePointers */
+export function selectOptimalRelays(users, { maxConnections, maxRelaysPerUser }) {
+    const usersWithRelays = users.filter((user) => user.relays && user.relays.length > 0);
+    // create map of popular relays
+    const popular = new Map();
+    for (const user of usersWithRelays) {
+        if (!user.relays)
+            continue;
+        for (const relay of user.relays)
+            popular.set(relay, (popular.get(relay) || 0) + 1);
+    }
+    // sort users relays by popularity
+    for (const user of usersWithRelays) {
+        if (!user.relays)
+            continue;
+        user.relays = Array.from(user.relays).sort((a, b) => popular.get(b) - popular.get(a));
+    }
+    // Create a pool of users to calculate relay coverage from
+    let selectionPool = Array.from(usersWithRelays);
+    // Create map of times a users relay has been selected
+    const selectionCount = new Map();
+    let selection = new Set();
+    while (selectionPool.length > 0 && selection.size < maxConnections) {
+        // Create map of number of pool users per relay
+        const relayUserCount = new Map();
+        for (const user of selectionPool) {
+            if (!user.relays)
+                continue;
+            for (const relay of user.relays) {
+                // Skip relays that are already selected
+                if (selection.has(relay))
+                    continue;
+                // Increment relay user count
+                relayUserCount.set(relay, (relayUserCount.get(relay) || 0) + 1);
+            }
+        }
+        // Sort relays by coverage
+        const byCoverage = Array.from(relayUserCount.entries()).sort((a, b) => b[1] - a[1]);
+        // No more relays to select, exit loop
+        if (byCoverage.length === 0)
+            break;
+        // Pick the most popular relay
+        const relay = byCoverage[0][0];
+        // Add relay to selection
+        selection.add(relay);
+        // Increment user relay count and remove users over the limit
+        selectionPool = selectionPool.filter((user) => {
+            // Ignore users that don't have the relay
+            if (!user.relays || !user.relays.includes(relay))
+                return true;
+            // Increment user relay count
+            let count = selectionCount.get(relay) || 0;
+            selectionCount.set(relay, count++);
+            // Remove user if they their relay has been selected more than minRelaysPerUser times
+            if (count >= 1)
+                return false;
+            return true;
+        });
+    }
+    // Take the original users and only include relays that where selected
+    return users.map((user) => ({
+        ...user,
+        relays: maxRelaysPerUser
+            ? user.relays
+                ?.filter((relay) => selection.has(relay))
+                .sort((a, b) => (popular.get(a) ?? 0) - (popular.get(b) ?? 0))
+                .slice(0, maxRelaysPerUser)
+            : user.relays?.filter((relay) => selection.has(relay)),
+    }));
+}
+/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+export function groupPubkeysByRelay(pointers) {
+    const outbox = {};
+    for (const pointer of pointers) {
+        if (!pointer.relays)
+            continue;
+        for (const relay of pointer.relays) {
+            if (!outbox[relay])
+                outbox[relay] = [];
+            outbox[relay].push(pointer);
+        }
+    }
+    return outbox;
+}

package/dist/helpers/url.js

@@ -78,13 +78,13 @@ export function ensureHttpURL(url) {
  */
 export function normalizeURL(url) {
     let p = new URL(url);
-    // remove any double slashes
+    // Remove any double slashes
     p.pathname = p.pathname.replace(/\/+/g, "/");
-    // drop the port if its not needed
+    // Remove the port if its not needed
     if ((p.port === "80" && (p.protocol === "ws:" || p.protocol === "http:")) ||
         (p.port === "443" && (p.protocol === "wss:" || p.protocol === "https:")))
         p.port = "";
-    // return a string if a string was passed in
+    // Return a string if a string was passed in
     // @ts-expect-error
     return typeof url === "string" ? p.toString() : p;
 }

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(user: string | ProfilePointer): Model<ProfilePointer[] | undefined>;
+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

@@ -10,7 +10,7 @@ export function ContactsModel(user) {
     // listen for event updates (hidden tags unlocked)
     watchEventUpdates(events), 
     // Get all contacts
-    map((e) => (e ? getContacts(e) : undefined)));
+    map((e) => (e ? getContacts(e) : [])));
 }
 /** A model that returns all public contacts for a user */
 export function PublicContactsModel(pubkey) {

package/dist/models/index.d.ts

@@ -17,3 +17,4 @@ export * from "./relays.js";
 export * from "./thread.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
+export * from "./outbox.js";

package/dist/models/index.js

@@ -17,3 +17,4 @@ export * from "./relays.js";
 export * from "./thread.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
+export * from "./outbox.js";

package/dist/models/outbox.d.ts

@@ -0,0 +1,13 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Model } from "../event-store/interface.js";
+import { SelectOptimalRelaysOptions } from "../helpers/relay-selection.js";
+import { ignoreBlacklistedRelays } from "../observable/relay-selection.js";
+export type OutboxModelOptions = SelectOptimalRelaysOptions & {
+    type?: "inbox" | "outbox";
+    blacklist?: Parameters<typeof ignoreBlacklistedRelays>[0];
+};
+/** A model that returns the users contacts with the relays to connect to */
+export declare function OutboxModel(user: string | ProfilePointer, opts: OutboxModelOptions): Model<ProfilePointer[]>;
+export declare namespace OutboxModel {
+    var getKey: (user: string | ProfilePointer, opts: OutboxModelOptions) => string;
+}

package/dist/models/outbox.js

@@ -0,0 +1,18 @@
+import hash_sum from "hash-sum";
+import { identity, map } from "rxjs";
+import { selectOptimalRelays } from "../helpers/relay-selection.js";
+import { ignoreBlacklistedRelays, includeMailboxes } from "../observable/relay-selection.js";
+/** A model that returns the users contacts with the relays to connect to */
+export function OutboxModel(user, opts) {
+    return (store) => store.contacts(user).pipe(
+    /** Ignore blacklisted relays */
+    opts?.blacklist ? ignoreBlacklistedRelays(opts.blacklist) : identity, 
+    /** Include mailboxes */
+    includeMailboxes(store, opts.type), 
+    /** Select the optimal relays */
+    map((users) => selectOptimalRelays(users, opts)));
+}
+OutboxModel.getKey = (user, opts) => {
+    const p = typeof user === "string" ? user : user.pubkey;
+    return hash_sum([p, opts.type, opts.maxConnections, opts.maxRelaysPerUser]);
+};

package/dist/observable/index.d.ts

@@ -1,4 +1,5 @@
-import { firstValueFrom, lastValueFrom } from "rxjs";
+export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
+export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
 export * from "./map-events-to-timeline.js";
@@ -6,4 +7,4 @@ export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
 export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
-export { firstValueFrom, lastValueFrom };
+export * from "./relay-selection.js";

package/dist/observable/index.js

@@ -1,4 +1,6 @@
-import { firstValueFrom, lastValueFrom } from "rxjs";
+// Re-export some useful rxjs functions
+export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
+export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
 export * from "./map-events-to-timeline.js";
@@ -6,5 +8,4 @@ export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
 export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
-// Re-export some useful rxjs functions
-export { firstValueFrom, lastValueFrom };
+export * from "./relay-selection.js";

package/dist/observable/map-events-to-store.d.ts

@@ -1,7 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 import { MonoTypeOperatorFunction } from "rxjs";
-import { IEventStoreActions } from "../event-store/interface.js";
+import { IAsyncEventStoreActions, IEventStoreActions } from "../event-store/interface.js";
 /** Saves all events to an event store and filters out invalid events */
-export declare function mapEventsToStore(store: IEventStoreActions, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;
+export declare function mapEventsToStore(store: IEventStoreActions | IAsyncEventStoreActions, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;
 /** Alias for {@link mapEventsToStore} */
-export declare const filterDuplicateEvents: (store: IEventStoreActions) => MonoTypeOperatorFunction<import("nostr-tools").Event>;
+export declare const filterDuplicateEvents: (store: IEventStoreActions | IAsyncEventStoreActions) => MonoTypeOperatorFunction<import("nostr-tools").Event>;

package/dist/observable/map-events-to-store.js

@@ -1,10 +1,19 @@
-import { distinct, filter, identity, map } from "rxjs";
+import { catchError, distinct, filter, from, identity, mergeMap, of } from "rxjs";
 /** Saves all events to an event store and filters out invalid events */
 export function mapEventsToStore(store, removeDuplicates = true) {
     return (source) => source.pipe(
     // Map all events to the store
-    // NOTE: map is used here because we want to return the single instance of the event so that distinct() can be used later
-    map((event) => store.add(event)), 
+    // NOTE: mergeMap is used here because we want to return the single instance of the event so that distinct() can be used later
+    mergeMap((event) => {
+        const r = store.add(event);
+        // Unwrap the promise from the async store
+        if (r instanceof Promise)
+            return from(r);
+        else
+            return of(r);
+    }), 
+    // Ignore errors when inserting events into the store
+    catchError(() => of(null)), 
     // Ignore invalid events
     filter((e) => e !== null), 
     // Remove duplicates if requested

package/dist/observable/relay-selection.d.ts

@@ -0,0 +1,7 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction } from "rxjs";
+import { IEventSubscriptions } from "../event-store/interface.js";
+/** RxJS operator that fetches outboxes for profile pointers from the event store */
+export declare function includeMailboxes(store: IEventSubscriptions, type?: "inbox" | "outbox"): OperatorFunction<ProfilePointer[], ProfilePointer[]>;
+/** Removes blacklisted relays from the user's relays */
+export declare function ignoreBlacklistedRelays(blacklist: string[] | Observable<string[]>): MonoTypeOperatorFunction<ProfilePointer[]>;

package/dist/observable/relay-selection.js

@@ -0,0 +1,38 @@
+import { combineLatest, combineLatestWith, isObservable, map, of, pipe, switchMap, } from "rxjs";
+import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+import { addRelayHintsToPointer } from "../helpers/pointers.js";
+/** RxJS operator that fetches outboxes for profile pointers from the event store */
+export function includeMailboxes(store, type = "outbox") {
+    // Get the outboxes for all contacts
+    return switchMap((contacts) => combineLatest(contacts.map((user) => 
+    // Subscribe to the outboxes for the user
+    store
+        .replaceable({
+        kind: 10002,
+        pubkey: user.pubkey,
+    })
+        .pipe(
+    // Add the relays to the user
+    map((event) => {
+        if (!event)
+            return user;
+        // Get the relays from the event
+        const relays = type === "outbox" ? getOutboxes(event) : getInboxes(event);
+        if (!relays)
+            return user;
+        // Add the relays to the user
+        return addRelayHintsToPointer(user, relays);
+    })))));
+}
+/** Removes blacklisted relays from the user's relays */
+export function ignoreBlacklistedRelays(blacklist) {
+    return pipe(
+    // Combine with the observable so it re-emits when the blacklist changes
+    combineLatestWith(isObservable(blacklist) ? blacklist : of(blacklist)), 
+    // Filter the relays for the user
+    map(([users, blacklist]) => users.map((user) => {
+        if (!user.relays)
+            return user;
+        return { ...user, relays: user.relays.filter((relay) => !blacklist.includes(relay)) };
+    })));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250916134023",
+  "version": "0.0.0-next-20250919114711",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -71,6 +71,7 @@
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
+    "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },
@@ -79,6 +80,7 @@
     "url": "lightning:nostrudel@geyser.fund"
   },
   "scripts": {
+    "prebuild": "rimraf dist",
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
     "test": "vitest run --passWithNoTests",

package/dist/__tests__/exports.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/exports.test.js

@@ -1,27 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as exports from "../index.js";
-describe("exports", () => {
-    it("should export the expected functions", () => {
-        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
-      [
-        "EventSet",
-        "EventStore",
-        "EventStoreSymbol",
-        "Helpers",
-        "Models",
-        "TimeoutError",
-        "defined",
-        "firstValueFrom",
-        "getObservableValue",
-        "lastValueFrom",
-        "logger",
-        "mapEventsToStore",
-        "mapEventsToTimeline",
-        "simpleTimeout",
-        "watchEventUpdates",
-        "watchEventsUpdates",
-        "withImmediateValueOrDefault",
-      ]
-    `);
-    });
-});

package/dist/__tests__/fixtures.d.ts

@@ -1,17 +0,0 @@
-import type { NostrEvent } from "nostr-tools";
-import { EncryptedContentSigner } from "../helpers/encrypted-content.js";
-export declare class FakeUser implements EncryptedContentSigner {
-    key: Uint8Array<ArrayBufferLike>;
-    pubkey: string;
-    nip04: {
-        encrypt: (pubkey: string, plaintext: string) => string;
-        decrypt: (pubkey: string, ciphertext: string) => string;
-    };
-    nip44: {
-        encrypt: (pubkey: string, plaintext: string) => string;
-        decrypt: (pubkey: string, ciphertext: string) => string;
-    };
-    event(data?: Partial<NostrEvent>): NostrEvent;
-    note(content?: string, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
-    profile(profile: any, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
-}