applesauce-core 0.0.0-next-20250423145737 → 0.0.0-next-20250423181842

package/dist/helpers/__tests__/bookmarks.test.d.ts

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

package/dist/helpers/__tests__/bookmarks.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { kinds } from "nostr-tools";
+import { mergeBookmarks } from "../bookmarks.js";
+describe("mergeBookmarks", () => {
+    it("should merge bookmarks and handle duplicates", () => {
+        // Create test data with some duplicates
+        const eventPointer1 = {
+            id: "event1",
+            relays: ["wss://relay1.com/", "wss://relay2.com/"],
+            author: "author1",
+        };
+        const eventPointer2 = {
+            id: "event1", // Same ID as eventPointer1
+            relays: ["wss://relay2.com/", "wss://relay3.com/"],
+            author: "author1",
+        };
+        const eventPointer3 = {
+            id: "event2",
+            relays: ["wss://relay1.com/"],
+            author: "author2",
+        };
+        const addressPointer1 = {
+            kind: kinds.LongFormArticle,
+            pubkey: "pubkey1",
+            identifier: "article1",
+            relays: ["wss://relay1.com/", "wss://relay2.com/"],
+        };
+        const addressPointer2 = {
+            kind: kinds.LongFormArticle,
+            pubkey: "pubkey1",
+            identifier: "article1", // Same as addressPointer1
+            relays: ["wss://relay3.com/"],
+        };
+        const bookmark1 = {
+            notes: [eventPointer1],
+            articles: [addressPointer1],
+            hashtags: ["tag1", "tag2"],
+            urls: ["https://example1.com/"],
+        };
+        const bookmark2 = {
+            notes: [eventPointer2, eventPointer3],
+            articles: [addressPointer2],
+            hashtags: ["tag2", "tag3"],
+            urls: ["https://example1.com/", "https://example2.com/"],
+        };
+        const result = mergeBookmarks(bookmark1, bookmark2);
+        // Check that duplicates are properly merged
+        expect(result.notes).toHaveLength(2); // event1 should be merged, plus event2
+        expect(result.articles).toHaveLength(1); // article1 should be merged
+        expect(result.hashtags).toHaveLength(3); // unique tags
+        expect(result.urls).toHaveLength(2); // unique urls
+        // Check that relays are merged for duplicate event
+        const mergedEvent = result.notes.find((note) => note.id === "event1");
+        expect(mergedEvent?.relays).toHaveLength(3);
+        expect(mergedEvent?.relays).toContain("wss://relay1.com/");
+        expect(mergedEvent?.relays).toContain("wss://relay2.com/");
+        expect(mergedEvent?.relays).toContain("wss://relay3.com/");
+        // Check that relays are merged for duplicate article
+        const mergedArticle = result.articles[0];
+        expect(mergedArticle.relays).toHaveLength(3);
+        expect(mergedArticle.relays).toContain("wss://relay1.com/");
+        expect(mergedArticle.relays).toContain("wss://relay2.com/");
+        expect(mergedArticle.relays).toContain("wss://relay3.com/");
+        // Check that hashtags are unique
+        expect(result.hashtags).toContain("tag1");
+        expect(result.hashtags).toContain("tag2");
+        expect(result.hashtags).toContain("tag3");
+        // Check that urls are unique
+        expect(result.urls).toContain("https://example1.com/");
+        expect(result.urls).toContain("https://example2.com/");
+    });
+    it("should handle undefined bookmarks", () => {
+        const bookmark = {
+            notes: [{ id: "event1", relays: ["wss://relay1.com/"] }],
+            articles: [],
+            hashtags: ["tag1"],
+            urls: ["https://example.com/"],
+        };
+        const result = mergeBookmarks(bookmark, undefined);
+        expect(result).toEqual(bookmark);
+        expect(mergeBookmarks(undefined, undefined)).toEqual({
+            notes: [],
+            articles: [],
+            hashtags: [],
+            urls: [],
+        });
+    });
+});

package/dist/helpers/__tests__/contacts.test.d.ts

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

package/dist/helpers/__tests__/contacts.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { mergeContacts } from "../contacts.js";
+describe("mergeContacts", () => {
+    it("should merge contacts and remove duplicates", () => {
+        // Create some test profile pointers
+        const pointer1 = { pubkey: "pubkey1", relays: ["relay1"] };
+        const pointer2 = { pubkey: "pubkey2" }; // No relays
+        const pointer3 = { pubkey: "pubkey3", relays: ["relay3"] };
+        const pointer4 = { pubkey: "pubkey1" }; // Duplicate pubkey without relays
+        // Test merging arrays of pointers
+        const result1 = mergeContacts([pointer1, pointer2], [pointer3, pointer4]);
+        // Should have 3 unique pubkeys
+        expect(result1.length).toBe(3);
+        // Check that the duplicate was handled correctly (last one should win)
+        const pubkey1Entry = result1.find((p) => p.pubkey === "pubkey1");
+        expect(pubkey1Entry).toBeDefined();
+        expect(pubkey1Entry?.relays).toBeUndefined();
+        // Test with undefined values
+        const result2 = mergeContacts([pointer1], undefined, [pointer2, undefined]);
+        expect(result2.length).toBe(2);
+        // Test with single pointers
+        const result3 = mergeContacts(pointer1, pointer2, pointer1);
+        expect(result3.length).toBe(2);
+        // Test with empty arrays
+        const result4 = mergeContacts([], [pointer1], []);
+        expect(result4.length).toBe(1);
+        // Test with pointers that have and don't have relays
+        const pointer5 = { pubkey: "pubkey5", relays: ["relay5"] };
+        const pointer6 = { pubkey: "pubkey5" }; // Same pubkey without relays
+        const result5 = mergeContacts([pointer5], [pointer6]);
+        expect(result5.length).toBe(1);
+        expect(result5[0].relays).toBeUndefined();
+    });
+});

package/dist/helpers/bookmarks.d.ts

@@ -8,8 +8,13 @@ export type Bookmarks = {
     hashtags: string[];
     urls: string[];
 };
+/** Parses an array of tags into a {@link Bookmarks} object */
 export declare function parseBookmarkTags(tags: string[][]): Bookmarks;
-/** Returns the public bookmarks of the event */
+/** Merges any number of {@link Bookmarks} objects */
+export declare function mergeBookmarks(...bookmarks: (Bookmarks | undefined)[]): Bookmarks;
+/** Returns all the bookmarks of the event */
 export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
+/** Returns the public bookmarks of the event */
+export declare function getPublicBookmarks(bookmark: NostrEvent): Bookmarks;
 /** Returns the bookmarks of the event if its unlocked */
 export declare function getHiddenBookmarks(bookmark: NostrEvent): Bookmarks | undefined;

package/dist/helpers/bookmarks.js

@@ -1,9 +1,11 @@
 import { kinds } from "nostr-tools";
-import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags } from "./index.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./index.js";
+import { mergeAddressPointers, mergeEventPointers } from "./nip-19.js";
+import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag } from "./pointers.js";
 export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
 export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
+/** Parses an array of tags into a {@link Bookmarks} object */
 export function parseBookmarkTags(tags) {
     const notes = tags.filter((t) => t[0] === "e" && t[1]).map(getEventPointerFromETag);
     const articles = tags
@@ -14,14 +16,57 @@ export function parseBookmarkTags(tags) {
     const urls = tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
     return { notes, articles, hashtags, urls };
 }
-/** Returns the public bookmarks of the event */
+/** Merges any number of {@link Bookmarks} objects */
+export function mergeBookmarks(...bookmarks) {
+    const notes = new Map();
+    const articles = new Map();
+    const hashtags = new Set();
+    const urls = new Set();
+    for (const bookmark of bookmarks) {
+        if (!bookmark)
+            continue;
+        for (const note of bookmark.notes) {
+            const existing = notes.get(note.id);
+            if (existing)
+                notes.set(note.id, mergeEventPointers(existing, note));
+            else
+                notes.set(note.id, note);
+        }
+        for (const article of bookmark.articles) {
+            const coord = getCoordinateFromAddressPointer(article);
+            const existing = articles.get(coord);
+            if (existing)
+                articles.set(coord, mergeAddressPointers(existing, article));
+            else
+                articles.set(coord, article);
+        }
+        for (const hashtag of bookmark.hashtags)
+            hashtags.add(hashtag);
+        for (const url of bookmark.urls)
+            urls.add(url);
+    }
+    return {
+        notes: Array.from(notes.values()),
+        articles: Array.from(articles.values()),
+        hashtags: Array.from(hashtags),
+        urls: Array.from(urls),
+    };
+}
+/** Returns all the bookmarks of the event */
 export function getBookmarks(bookmark) {
+    const hidden = getHiddenBookmarks(bookmark);
+    if (hidden)
+        return mergeBookmarks(hidden, getPublicBookmarks(bookmark));
+    else
+        return getPublicBookmarks(bookmark);
+}
+/** Returns the public bookmarks of the event */
+export function getPublicBookmarks(bookmark) {
     return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
 }
 /** Returns the bookmarks of the event if its unlocked */
 export function getHiddenBookmarks(bookmark) {
-    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => {
-        const tags = getHiddenTags(bookmark);
-        return tags && parseBookmarkTags(tags);
-    });
+    if (isHiddenTagsLocked(bookmark))
+        return undefined;
+    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => parseBookmarkTags(getHiddenTags(bookmark)));
 }

package/dist/helpers/contacts.d.ts

@@ -1,3 +1,14 @@
 import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
 export declare const ContactsRelaysSymbol: unique symbol;
+export declare const PublicContactsSymbol: unique symbol;
+export declare const HiddenContactsSymbol: unique symbol;
 export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "all" | "inbox" | "outbox"> | null;
+/** Merges any number of contact lists into a single list */
+export declare function mergeContacts(...pointers: (ProfilePointer | undefined | (ProfilePointer | undefined)[])[]): ProfilePointer[];
+/** Returns all public and hidden contacts from a contacts list event */
+export declare function getContacts(event: NostrEvent): ProfilePointer[];
+/** Returns only the public contacts from a contacts list event */
+export declare function getPublicContacts(event: NostrEvent): ProfilePointer[];
+/** Returns only the hidden contacts from a contacts list event */
+export declare function getHiddenContacts(event: NostrEvent): ProfilePointer[] | undefined;

package/dist/helpers/contacts.js

@@ -1,6 +1,11 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
+import { isPTag, processTags } from "./tags.js";
+import { getProfilePointerFromPTag } from "./pointers.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
 export const ContactsRelaysSymbol = Symbol.for("contacts-relays");
+export const PublicContactsSymbol = Symbol.for("public-contacts");
+export const HiddenContactsSymbol = Symbol.for("hidden-contacts");
 export function getRelaysFromContactsEvent(event) {
     return getOrComputeCachedValue(event, ContactsRelaysSymbol, () => {
         try {
@@ -23,3 +28,32 @@ export function getRelaysFromContactsEvent(event) {
         }
     });
 }
+/** Merges any number of contact lists into a single list */
+export function mergeContacts(...pointers) {
+    const merged = new Map();
+    for (const arr of pointers) {
+        if (Array.isArray(arr)) {
+            for (const pointer of arr)
+                if (pointer)
+                    merged.set(pointer.pubkey, pointer);
+        }
+        else if (arr) {
+            merged.set(arr.pubkey, arr);
+        }
+    }
+    return Array.from(merged.values());
+}
+/** Returns all public and hidden contacts from a contacts list event */
+export function getContacts(event) {
+    return mergeContacts(getPublicContacts(event), getHiddenContacts(event));
+}
+/** Returns only the public contacts from a contacts list event */
+export function getPublicContacts(event) {
+    return getOrComputeCachedValue(event, PublicContactsSymbol, () => processTags(event.tags, (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+}
+/** Returns only the hidden contacts from a contacts list event */
+export function getHiddenContacts(event) {
+    if (isHiddenTagsLocked(event))
+        return undefined;
+    return getOrComputeCachedValue(event, HiddenContactsSymbol, () => processTags(getHiddenTags(event), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+}

package/dist/helpers/mutes.d.ts

@@ -7,9 +7,13 @@ export type Mutes = {
     hashtags: Set<string>;
     words: Set<string>;
 };
+/** Merges any number of mute sets */
+export declare function mergeMutes(...mutes: Mutes[]): Mutes;
 /** Parses mute tags */
 export declare function parseMutedTags(tags: string[][]): Mutes;
 /** Returns muted things */
 export declare function getMutedThings(mute: NostrEvent): Mutes;
+/** Returns only the public muted things from a mute event */
+export declare function getPublicMutedThings(mute: NostrEvent): Mutes;
 /** Returns the hidden muted content if the event is unlocked */
 export declare function getHiddenMutedThings(mute: NostrEvent): Mutes | undefined;

package/dist/helpers/mutes.js

@@ -1,8 +1,23 @@
 import { isETag, isPTag, isTTag } from "./tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags } from "./hidden-tags.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
+/** Merges any number of mute sets */
+export function mergeMutes(...mutes) {
+    const mute = { pubkeys: new Set(), threads: new Set(), hashtags: new Set(), words: new Set() };
+    for (const m of mutes) {
+        for (const pubkey of m.pubkeys)
+            mute.pubkeys.add(pubkey);
+        for (const thread of m.threads)
+            mute.threads.add(thread);
+        for (const hashtag of m.hashtags)
+            mute.hashtags.add(hashtag);
+        for (const word of m.words)
+            mute.words.add(word);
+    }
+    return mute;
+}
 /** Parses mute tags */
 export function parseMutedTags(tags) {
     const pubkeys = new Set(tags.filter(isPTag).map((t) => t[1]));
@@ -13,12 +28,19 @@ export function parseMutedTags(tags) {
 }
 /** Returns muted things */
 export function getMutedThings(mute) {
+    const hidden = getHiddenMutedThings(mute);
+    const mutes = getPublicMutedThings(mute);
+    if (hidden)
+        return mergeMutes(hidden, mutes);
+    return mutes;
+}
+/** Returns only the public muted things from a mute event */
+export function getPublicMutedThings(mute) {
     return getOrComputeCachedValue(mute, MutePublicSymbol, () => parseMutedTags(mute.tags));
 }
 /** Returns the hidden muted content if the event is unlocked */
 export function getHiddenMutedThings(mute) {
-    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => {
-        const tags = getHiddenTags(mute);
-        return tags && parseMutedTags(tags);
-    });
+    if (isHiddenTagsLocked(mute))
+        return undefined;
+    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => parseMutedTags(getHiddenTags(mute)));
 }

package/dist/helpers/nip-19.d.ts

@@ -1,4 +1,18 @@
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 /** Gets the hex pubkey from any nip-19 encoded string */
 export declare function normalizeToPubkey(str: string): string;
 /** Converts hex to nsec strings into Uint8 secret keys */
 export declare function normalizeToSecretKey(str: string): Uint8Array;
+/**
+ * Merges two event points and keeps all relays
+ * @throws if the ids are different
+ */
+export declare function mergeEventPointers(a: EventPointer, b: EventPointer): EventPointer;
+/** Merges two address pointers and keeps all relays
+ * @throws if the kinds, pubkeys, or identifiers are different
+ */
+export declare function mergeAddressPointers(a: AddressPointer, b: AddressPointer): AddressPointer;
+/** Merges two profile pointers and keeps all relays
+ * @throws if the pubkeys are different
+ */
+export declare function mergeProfilePointers(a: ProfilePointer, b: ProfilePointer): ProfilePointer;

package/dist/helpers/nip-19.js

@@ -2,6 +2,7 @@ import { nip19 } from "nostr-tools";
 import { hexToBytes } from "@noble/hashes/utils";
 import { isHexKey } from "./string.js";
 import { getPubkeyFromDecodeResult } from "./pointers.js";
+import { mergeRelaySets } from "./relays.js";
 /** Gets the hex pubkey from any nip-19 encoded string */
 export function normalizeToPubkey(str) {
     if (isHexKey(str))
@@ -25,3 +26,31 @@ export function normalizeToSecretKey(str) {
         return decode.data;
     }
 }
+/**
+ * Merges two event points and keeps all relays
+ * @throws if the ids are different
+ */
+export function mergeEventPointers(a, b) {
+    if (a.id !== b.id)
+        throw new Error("Cant merge event pointers with different ids");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { id: a.id, kind: a.kind ?? b.kind, author: a.author ?? b.author, relays };
+}
+/** Merges two address pointers and keeps all relays
+ * @throws if the kinds, pubkeys, or identifiers are different
+ */
+export function mergeAddressPointers(a, b) {
+    if (a.kind !== b.kind || a.pubkey !== b.pubkey || a.identifier !== b.identifier)
+        throw new Error("Cant merge address pointers with different kinds, pubkeys, or identifiers");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { ...a, relays };
+}
+/** Merges two profile pointers and keeps all relays
+ * @throws if the pubkeys are different
+ */
+export function mergeProfilePointers(a, b) {
+    if (a.pubkey !== b.pubkey)
+        throw new Error("Cant merge profile pointers with different pubkeys");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { ...a, relays };
+}

package/dist/observable/defined.d.ts

@@ -0,0 +1,3 @@
+import { OperatorFunction } from "rxjs";
+/** Filters out undefined and null values */
+export declare function defined<T>(): OperatorFunction<T | undefined, NonNullable<T>>;

package/dist/observable/defined.js

@@ -0,0 +1,5 @@
+import { filter } from "rxjs";
+/** Filters out undefined and null values */
+export function defined() {
+    return (source) => source.pipe(filter((v) => v !== undefined && v !== null));
+}

package/dist/observable/get-observable-value.d.ts

@@ -1,3 +1,6 @@
 import { Observable } from "rxjs";
-/** Subscribes and returns the observables current or next value */
+/**
+ * Subscribes and returns the observables current or next value
+ * @deprecated use `firstValueFrom` instead
+ */
 export declare function getObservableValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/get-observable-value.js

@@ -1,5 +1,8 @@
 import { BehaviorSubject, firstValueFrom } from "rxjs";
-/** Subscribes and returns the observables current or next value */
+/**
+ * Subscribes and returns the observables current or next value
+ * @deprecated use `firstValueFrom` instead
+ */
 export function getObservableValue(observable) {
     if (observable instanceof BehaviorSubject)
         return observable.value;

package/dist/observable/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./share-latest-value.js";
+export * from "./listen-latest-updates.js";
 export * from "./simple-timeout.js";
+export * from "./with-immediate-value.js";

package/dist/observable/index.js

@@ -1,3 +1,5 @@
+export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./share-latest-value.js";
+export * from "./listen-latest-updates.js";
 export * from "./simple-timeout.js";
+export * from "./with-immediate-value.js";

package/dist/observable/listen-latest-updates.d.ts

@@ -0,0 +1,5 @@
+import { NostrEvent } from "nostr-tools";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IStreamEventStore } from "../event-store/interface.js";
+/** Lists for any updates to the latest event and remits it */
+export declare function listenLatestUpdates(eventStore: IStreamEventStore): MonoTypeOperatorFunction<NostrEvent | undefined>;

package/dist/observable/listen-latest-updates.js

@@ -0,0 +1,12 @@
+import { filter, merge, tap } from "rxjs";
+/** Lists for any updates to the latest event and remits it */
+export function listenLatestUpdates(eventStore) {
+    return (source) => {
+        let latest;
+        return merge(
+        // Get the latest event
+        source.pipe(tap((value) => (latest = value))), 
+        // listen for updates
+        eventStore.updates.pipe(filter((e) => e.id === latest?.id)));
+    };
+}

package/dist/queries/blossom.js

@@ -1,10 +1,5 @@
 import { map } from "rxjs/operators";
 import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
 export function UserBlossomServersQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey)
-            .pipe(map((event) => event && getBlossomServersFromList(event))),
-    };
+    return (store) => store.replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey).pipe(map((event) => event && getBlossomServersFromList(event)));
 }

package/dist/queries/bookmarks.d.ts

@@ -1,8 +1,8 @@
 import { Bookmarks } from "../helpers/bookmarks.js";
 import { Query } from "../query-store/index.js";
+/** A query that returns all the bookmarks of a user */
 export declare function UserBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
-export declare function UserHiddenBookmarkQuery(pubkey: string): Query<(Bookmarks & {
-    locked: false;
-}) | {
-    locked: true;
-} | undefined>;
+/** A query that returns all the public bookmarks of a user */
+export declare function UserPublicBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
+/** A query that returns all the hidden bookmarks of a user */
+export declare function UserHiddenBookmarkQuery(pubkey: string): Query<Bookmarks | null | undefined>;

package/dist/queries/bookmarks.js

@@ -1,23 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { isHiddenTagsLocked } from "../helpers/index.js";
-import { getBookmarks, getHiddenBookmarks } from "../helpers/bookmarks.js";
+import { getBookmarks, getHiddenBookmarks, getPublicBookmarks } from "../helpers/bookmarks.js";
+import { listenLatestUpdates } from "../observable/index.js";
+/** A query that returns all the bookmarks of a user */
 export function UserBookmarkQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getBookmarks(event))),
-    };
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all bookmarks
+    map((event) => event && getBookmarks(event)));
 }
+/** A query that returns all the public bookmarks of a user */
+export function UserPublicBookmarkQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicBookmarks(event)));
+}
+/** A query that returns all the hidden bookmarks of a user */
 export function UserHiddenBookmarkQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const bookmarks = getHiddenBookmarks(event);
-            if (isHiddenTagsLocked(event) || !bookmarks)
-                return { locked: true };
-            return { locked: false, ...bookmarks };
-        })),
-    };
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden bookmarks
+    map((event) => event && (getHiddenBookmarks(event) ?? null)));
 }