applesauce-core 0.0.0-next-20241210193522 → 0.0.0-next-20241212192616

package/README.md

@@ -1,6 +1,6 @@
 # applesauce-core
 
-AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/modules/Queries)
+AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/typedoc/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/typedoc/modules/Queries)
 
 # Example
 

package/dist/helpers/comment.js

@@ -1,6 +1,7 @@
 import { getExternalPointerFromTag } from "./external-id.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+import { safeRelayUrl } from "./relays.js";
 export const COMMENT_KIND = 1111;
 export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
 export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
@@ -14,13 +15,13 @@ export function getCommentEventPointer(tags, root = false) {
     if (tag) {
         if (!kind)
             throw new Error("Missing kind tag");
-        const eventPointer = getEventPointerFromTag(tag);
-        return {
-            id: eventPointer.id,
+        const pointer = {
+            id: tag[1],
             kind: parseInt(kind),
-            pubkey: eventPointer.author,
-            relay: eventPointer.relays?.[0],
+            pubkey: tag[3] || undefined,
+            relay: tag[2] && (safeRelayUrl(tag[2]) ?? undefined),
         };
+        return pointer;
     }
     return null;
 }
@@ -37,7 +38,7 @@ export function getCommentAddressPointer(tags, root = false) {
             throw new Error("Missing kind tag");
         const pointer = {
             id,
-            ...getAddressPointerFromTag(tag),
+            ...getAddressPointerFromATag(tag),
             kind: parseInt(kind),
         };
         return pointer;

package/dist/helpers/delete.d.ts

@@ -1,5 +1,3 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
+import { NostrEvent } from "nostr-tools";
 export declare function getDeleteIds(deleteEvent: NostrEvent): string[];
 export declare function getDeleteCoordinates(deleteEvent: NostrEvent): string[];
-/** Creates a NIP-09 delete event for an array of events */
-export declare function createDeleteEvent(events: NostrEvent[], message?: string): EventTemplate;

package/dist/helpers/delete.js

@@ -1,38 +1,7 @@
-import { kinds } from "nostr-tools";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 import { isATag, isETag } from "./tags.js";
-import { unixNow } from "./time.js";
-import { getATagFromAddressPointer, getETagFromEventPointer } from "./pointers.js";
-import { getTagValue } from "./index.js";
 export function getDeleteIds(deleteEvent) {
     return deleteEvent.tags.filter(isETag).map((t) => t[1]);
 }
 export function getDeleteCoordinates(deleteEvent) {
     return deleteEvent.tags.filter(isATag).map((t) => t[1]);
 }
-/** Creates a NIP-09 delete event for an array of events */
-export function createDeleteEvent(events, message) {
-    const eventPointers = [];
-    const addressPointers = [];
-    const eventKinds = new Set();
-    for (const event of events) {
-        eventKinds.add(event.kind);
-        eventPointers.push({ id: event.id });
-        if (isParameterizedReplaceableKind(event.kind)) {
-            const identifier = getTagValue(event, "d");
-            if (!identifier)
-                throw new Error("Event missing identifier");
-            addressPointers.push({ pubkey: event.pubkey, kind: event.kind, identifier });
-        }
-    }
-    return {
-        kind: kinds.EventDeletion,
-        content: message ?? "",
-        tags: [
-            ...eventPointers.map(getETagFromEventPointer),
-            ...addressPointers.map(getATagFromAddressPointer),
-            ...Array.from(eventKinds).map((k) => ["k", String(k)]),
-        ],
-        created_at: unixNow(),
-    };
-}

package/dist/helpers/hidden-tags.test.js

@@ -1,3 +1,4 @@
+import { describe, beforeEach, it, expect } from "vitest";
 import { getHiddenTags, unixNow, unlockHiddenTags } from "applesauce-core/helpers";
 import { finalizeEvent, generateSecretKey, getPublicKey, kinds, nip04 } from "nostr-tools";
 const key = generateSecretKey();

package/dist/helpers/mailboxes.test.js

@@ -1,3 +1,4 @@
+import { describe, test, expect } from "vitest";
 import { getInboxes, getOutboxes } from "./mailboxes.js";
 const emptyEvent = {
     kind: 10002,
@@ -14,33 +15,33 @@ describe("Mailboxes", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
         test("should remove bad urls", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "bad://inbox.com"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "something that is not a url"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com,wss://inbox.org"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
         });
         test("without marker", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com/"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
         test("with marker", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com/", "read"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
     });
     describe("getOutboxes", () => {
@@ -48,33 +49,33 @@ describe("Mailboxes", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
         test("should remove bad urls", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "bad://inbox.com"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "something that is not a url"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com,wss://inbox.org"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
         });
         test("without marker", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com/"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
         test("with marker", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com/", "write"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
     });
 });

package/dist/helpers/pointers.d.ts

@@ -15,21 +15,41 @@ export declare function parseCoordinate(a: string, requireD: false, silent: true
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
 /** Encodes the result of nip19.decode */
 export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
-/** @throws */
-export declare function getEventPointerFromTag(tag: string[]): EventPointer;
-/** @throws */
-export declare function getAddressPointerFromTag(tag: string[]): AddressPointer;
-/** @throws */
-export declare function getProfilePointerFromTag(tag: string[]): ProfilePointer;
+/**
+ * Gets an EventPointer form a common "e" tag
+ * @throws
+ */
+export declare function getEventPointerFromETag(tag: string[]): EventPointer;
+/**
+ * Gets an EventPointer form a "q" tag
+ * @throws
+ */
+export declare function getEventPointerFromQTag(tag: string[]): EventPointer;
+/**
+ * Get an AddressPointer from an "a" tag
+ * @throws
+ */
+export declare function getAddressPointerFromATag(tag: string[]): AddressPointer;
+/**
+ * Gets a ProfilePointer from a "p" tag
+ * @throws
+ */
+export declare function getProfilePointerFromPTag(tag: string[]): ProfilePointer;
 /** Parses "e", "a", "p", and "q" tags into a pointer */
 export declare function getPointerFromTag(tag: string[]): DecodeResult | null;
 export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
 export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
 /** Returns the coordinate string for an AddressPointer */
 export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
-/** Returns a tag for an address pointer */
-export declare function getATagFromAddressPointer(pointer: AddressPointer): ["a", ...string[]];
-/** Returns a tag for an event pointer */
-export declare function getETagFromEventPointer(pointer: EventPointer): ["e", ...string[]];
+/**
+ * Returns an AddressPointer for a replaceable event
+ * @throws
+ */
+export declare function getAddressPointerForEvent(event: NostrEvent, relays?: string[]): AddressPointer;
+/**
+ * Returns an EventPointer for an event
+ * @throws
+ */
+export declare function getEventPointerForEvent(event: NostrEvent, relays?: string[]): EventPointer;
 /** Returns a pointer for a given event */
 export declare function getPointerForEvent(event: NostrEvent, relays?: string[]): DecodeResult;

package/dist/helpers/pointers.js

@@ -2,6 +2,7 @@ import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsec
 import { getPublicKey, kinds } from "nostr-tools";
 import { safeRelayUrls } from "./relays.js";
 import { getTagValue } from "./index.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] && parseInt(parts[0]);
@@ -65,21 +66,37 @@ export function encodeDecodeResult(result) {
     }
     return "";
 }
-/** @throws */
-export function getEventPointerFromTag(tag) {
+/**
+ * Gets an EventPointer form a common "e" tag
+ * @throws
+ */
+export function getEventPointerFromETag(tag) {
     if (!tag[1])
         throw new Error("Missing event id in tag");
     let pointer = { id: tag[1] };
     if (tag[2])
         pointer.relays = safeRelayUrls([tag[2]]);
-    // get author from NIP-18 quote tags and nip-22 comments
-    if ((tag[0] === "q" || tag[0] === "e" || tag[0] === "E") && tag[3] && tag[3].length === 64) {
+    return pointer;
+}
+/**
+ * Gets an EventPointer form a "q" tag
+ * @throws
+ */
+export function getEventPointerFromQTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    if (tag[3] && tag[3].length === 64)
         pointer.author = tag[3];
-    }
     return pointer;
 }
-/** @throws */
-export function getAddressPointerFromTag(tag) {
+/**
+ * Get an AddressPointer from an "a" tag
+ * @throws
+ */
+export function getAddressPointerFromATag(tag) {
     if (!tag[1])
         throw new Error("Missing coordinate in tag");
     const pointer = parseCoordinate(tag[1], true, false);
@@ -87,8 +104,11 @@ export function getAddressPointerFromTag(tag) {
         pointer.relays = safeRelayUrls([tag[2]]);
     return pointer;
 }
-/** @throws */
-export function getProfilePointerFromTag(tag) {
+/**
+ * Gets a ProfilePointer from a "p" tag
+ * @throws
+ */
+export function getProfilePointerFromPTag(tag) {
     if (!tag[1])
         throw new Error("Missing pubkey in tag");
     const pointer = { pubkey: tag[1] };
@@ -101,17 +121,17 @@ export function getPointerFromTag(tag) {
     try {
         switch (tag[0]) {
             case "e":
-                return { type: "nevent", data: getEventPointerFromTag(tag) };
+                return { type: "nevent", data: getEventPointerFromETag(tag) };
             case "a":
                 return {
                     type: "naddr",
-                    data: getAddressPointerFromTag(tag),
+                    data: getAddressPointerFromATag(tag),
                 };
             case "p":
-                return { type: "nprofile", data: getProfilePointerFromTag(tag) };
+                return { type: "nprofile", data: getProfilePointerFromPTag(tag) };
             // NIP-18 quote tags
             case "q":
-                return { type: "nevent", data: getEventPointerFromTag(tag) };
+                return { type: "nevent", data: getEventPointerFromETag(tag) };
         }
     }
     catch (error) { }
@@ -130,15 +150,34 @@ export function isEventPointer(pointer) {
 export function getCoordinateFromAddressPointer(pointer) {
     return `${pointer.kind}:${pointer.pubkey}:${pointer.identifier}`;
 }
-/** Returns a tag for an address pointer */
-export function getATagFromAddressPointer(pointer) {
-    const relay = pointer.relays?.[0];
-    const coordinate = getCoordinateFromAddressPointer(pointer);
-    return relay ? ["a", coordinate, relay] : ["a", coordinate];
+/**
+ * Returns an AddressPointer for a replaceable event
+ * @throws
+ */
+export function getAddressPointerForEvent(event, relays) {
+    if (!isParameterizedReplaceableKind(event.kind))
+        throw new Error("Cant get AddressPointer for non-replaceable event");
+    const d = getTagValue(event, "d");
+    if (!d)
+        throw new Error("Event missing identifier");
+    return {
+        identifier: d,
+        kind: event.kind,
+        pubkey: event.pubkey,
+        relays,
+    };
 }
-/** Returns a tag for an event pointer */
-export function getETagFromEventPointer(pointer) {
-    return pointer.relays?.length ? ["e", pointer.id, pointer.relays[0]] : ["e", pointer.id];
+/**
+ * Returns an EventPointer for an event
+ * @throws
+ */
+export function getEventPointerForEvent(event, relays) {
+    return {
+        id: event.id,
+        kind: event.kind,
+        author: event.pubkey,
+        relays,
+    };
 }
 /** Returns a pointer for a given event */
 export function getPointerForEvent(event, relays) {

package/dist/helpers/threading.d.ts

@@ -23,13 +23,13 @@ export type ThreadReferences = {
     };
 };
 export declare const Nip10ThreadRefsSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [Nip10ThreadRefsSymbol]?: ThreadReferences;
-    }
-}
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export declare function getEventPointerFromThreadTag(tag: string[]): EventPointer;
 /** Parses NIP-10 tags and handles legacy behavior */
-export declare function interpretThreadTags(event: NostrEvent | EventTemplate): {
+export declare function interpretThreadTags(tags: string[][]): {
     root?: {
         e: string[];
         a: undefined;

package/dist/helpers/threading.js

@@ -1,10 +1,31 @@
-import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getAddressPointerFromATag } from "./pointers.js";
 import { getOrComputeCachedValue } from "./cache.js";
+import { safeRelayUrls } from "./relays.js";
 export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export function getEventPointerFromThreadTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    // get author from NIP-18 quote tags, nip-22 comments tags, or nip-10 thread tags
+    if (tag[0] === "e" &&
+        (tag[3] === "root" || tag[3] === "reply" || tag[3] === "mention") &&
+        tag[4] &&
+        tag[4].length === 64) {
+        // NIP-10 "e" tag
+        pointer.author = tag[4];
+    }
+    return pointer;
+}
 /** Parses NIP-10 tags and handles legacy behavior */
-export function interpretThreadTags(event) {
-    const eTags = event.tags.filter((t) => t[0] === "e" && t[1]);
-    const aTags = event.tags.filter((t) => t[0] === "a" && t[1]);
+export function interpretThreadTags(tags) {
+    const eTags = tags.filter((t) => t[0] === "e" && t[1]);
+    const aTags = tags.filter((t) => t[0] === "a" && t[1]);
     // find the root and reply tags.
     let rootETag = eTags.find((t) => t[3] === "root");
     let replyETag = eTags.find((t) => t[3] === "reply");
@@ -44,13 +65,13 @@ export function interpretThreadTags(event) {
 /** Returns the parsed NIP-10 tags for an event */
 export function getNip10References(event) {
     return getOrComputeCachedValue(event, Nip10ThreadRefsSymbol, () => {
-        const tags = interpretThreadTags(event);
+        const tags = interpretThreadTags(event.tags);
         let root;
         if (tags.root) {
             try {
                 root = {
-                    e: tags.root.e && getEventPointerFromTag(tags.root.e),
-                    a: tags.root.a && getAddressPointerFromTag(tags.root.a),
+                    e: tags.root.e && getEventPointerFromThreadTag(tags.root.e),
+                    a: tags.root.a && getAddressPointerFromATag(tags.root.a),
                 };
             }
             catch (error) { }
@@ -59,8 +80,8 @@ export function getNip10References(event) {
         if (tags.reply) {
             try {
                 reply = {
-                    e: tags.reply.e && getEventPointerFromTag(tags.reply.e),
-                    a: tags.reply.a && getAddressPointerFromTag(tags.reply.a),
+                    e: tags.reply.e && getEventPointerFromThreadTag(tags.reply.e),
+                    a: tags.reply.a && getAddressPointerFromATag(tags.reply.a),
                 };
             }
             catch (error) { }

package/dist/helpers/threading.test.d.ts

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

package/dist/helpers/threading.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { interpretThreadTags } from "./threading.js";
+describe("threading helpers", () => {
+    describe("interpretThreadTags", () => {
+        it("should handle legacy tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id"],
+                ["e", "reply-id"],
+            ])).toEqual({ root: { a: undefined, e: ["e", "root-id"] }, reply: { a: undefined, e: ["e", "reply-id"] } });
+        });
+        it("should handle nip-10 tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id", "relay", "root"],
+                ["e", "reply-id", "relay", "reply"],
+            ])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+        it("should ignore mention nip-10 tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id", "relay", "root"],
+                ["e", "mention-id", "relay", "mention"],
+                ["e", "reply-id", "relay", "reply"],
+            ])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+        it("should handle single nip-10 tags", () => {
+            expect(interpretThreadTags([["e", "root-id", "relay", "root"]])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+            });
+            expect(interpretThreadTags([["e", "reply-id", "relay", "reply"]])).toEqual({
+                root: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+    });
+});

package/dist/helpers/zap.js

@@ -2,7 +2,7 @@ import { kinds, nip57 } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getTagValue } from "./event.js";
 import { isATag, isETag } from "./tags.js";
-import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { parseBolt11 } from "./bolt11.js";
 export const ZapRequestSymbol = Symbol.for("zap-request");
 export const ZapFromSymbol = Symbol.for("zap-from");
@@ -34,14 +34,14 @@ export function getZapPayment(zap) {
 export function getZapAddressPointer(zap) {
     return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
         const a = zap.tags.find(isATag);
-        return a ? getAddressPointerFromTag(a) : null;
+        return a ? getAddressPointerFromATag(a) : null;
     });
 }
 /** Gets the EventPointer that was zapped */
 export function getZapEventPointer(zap) {
     return getOrComputeCachedValue(zap, ZapEventPointerSymbol, () => {
         const e = zap.tags.find(isETag);
-        return e ? getEventPointerFromTag(e) : null;
+        return e ? getEventPointerFromETag(e) : null;
     });
 }
 /** Gets the preimage for the bolt11 invoice */

package/dist/queries/thread.d.ts

@@ -21,5 +21,5 @@ export type ThreadQueryOptions = {
     kinds?: number[];
 };
 export declare function ThreadQuery(root: string | AddressPointer | EventPointer, opts?: ThreadQueryOptions): Query<Thread>;
-/** A query that gets all legacy and NIP-10 replies for an event */
+/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
 export declare function RepliesQuery(event: NostrEvent, overrideKinds?: number[]): Query<NostrEvent[]>;

package/dist/queries/thread.js

@@ -4,6 +4,7 @@ import { map } from "rxjs/operators";
 import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
 import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer } from "../helpers/pointers.js";
 import { getEventUID, getReplaceableUID, getTagValue, isEvent } from "../helpers/event.js";
+import { COMMENT_KIND } from "../helpers/comment.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
 };
@@ -65,12 +66,12 @@ export function ThreadQuery(root, opts) {
         })),
     };
 }
-/** A query that gets all legacy and NIP-10 replies for an event */
+/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
 export function RepliesQuery(event, overrideKinds) {
     return {
         key: getEventUID(event),
         run: (events) => {
-            const kinds = overrideKinds || event.kind === 1 ? [1, 1111] : [1111];
+            const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
             const filter = { kinds };
             if (isEvent(parent) || isEventPointer(event))
                 filter["#e"] = [event.id];
@@ -82,7 +83,7 @@ export function RepliesQuery(event, overrideKinds) {
             }
             return events.timeline(filter).pipe(map((events) => {
                 return events.filter((e) => {
-                    const refs = interpretThreadTags(e);
+                    const refs = interpretThreadTags(e.tags);
                     return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
                 });
             }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20241210193522",
+  "version": "0.0.0-next-20241212192616",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -62,21 +62,10 @@
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
-    "@types/jest": "^29.5.13",
-    "jest": "^29.7.0",
-    "jest-extended": "^4.0.2",
-    "typescript": "^5.6.3"
-  },
-  "jest": {
-    "roots": [
-      "dist"
-    ],
-    "setupFilesAfterEnv": [
-      "jest-extended/all"
-    ]
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
   },
   "funding": {
     "type": "lightning",
@@ -85,7 +74,7 @@
   "scripts": {
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "watch:test": "(trap 'kill 0' SIGINT; pnpm run build -w > /dev/null & pnpm run test --watch)"
+    "test": "vitest run --passWithNoTests",
+    "watch:test": "vitest"
   }
 }