applesauce-core 0.0.0-next-20250526151506 → 0.0.0-next-20250606170247

package/README.md

@@ -1,13 +1,12 @@
 # applesauce-core
 
-AppleSauce is a collection of utilities for building reactive nostr applications. The core package provides an in-memory event database and reactive queries to help you build nostr UIs with less code.
+AppleSauce is a collection of utilities for building reactive nostr applications. The core package provides an in-memory event database and reactive models to help you build nostr UIs with less code.
 
 ## Key Components
 
 - **Helpers**: Core utility methods for parsing and extracting data from nostr events
 - **EventStore**: In-memory database for storing and subscribing to nostr events
-- **QueryStore**: Manages queries and ensures efficient subscription handling
-- **Queries**: Complex subscriptions for common nostr data patterns
+- **Models**: Complex subscriptions for common nostr data patterns
 
 ## Documentation
 
@@ -19,15 +18,13 @@ For detailed documentation and guides, visit:
 ## Example
 
 ```js
-import { EventStore, QueryStore } from "applesauce-core";
+import { EventStore } from "applesauce-core";
+import { ProfileModel, TimelineModel } from "applesauce-core/models";
 import { Relay } from "nostr-tools/relay";
 
 // Create a single EventStore instance for your app
 const eventStore = new EventStore();
 
-// Create a QueryStore to manage subscriptions efficiently
-const queryStore = new QueryStore(eventStore);
-
 // Use any nostr library for relay connections (nostr-tools, ndk, nostrify, etc...)
 const relay = await Relay.connect("wss://relay.example.com");
 
@@ -38,18 +35,15 @@ const sub = relay.subscribe([{ authors: ["3bf0c63fcb93463407af97a5e5ee64fa883d10
   },
 });
 
-// Subscribe to profile changes using ProfileQuery
-const profile = queryStore.createQuery(
-  ProfileQuery,
-  "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
-);
+// Subscribe to profile changes using ProfileModel
+const profile = eventStore.model(ProfileModel, "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d");
 
 profile.subscribe((parsed) => {
   if (parsed) console.log(parsed);
 });
 
 // Subscribe to a timeline of events
-const timeline = queryStore.createQuery(TimelineQuery, { kinds: [1] });
+const timeline = eventStore.model(TimelineModel, { kinds: [1] });
 
 timeline.subscribe((events) => {
   console.log(events);

package/dist/__tests__/exports.test.js

@@ -4,23 +4,22 @@ describe("exports", () => {
     it("should export the expected functions", () => {
         expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
       [
-        "Database",
+        "EventSet",
         "EventStore",
         "EventStoreSymbol",
         "Helpers",
-        "Queries",
-        "QueryStore",
+        "Models",
         "TimeoutError",
         "defined",
         "firstValueFrom",
         "getObservableValue",
         "lastValueFrom",
-        "listenLatestUpdates",
         "logger",
         "mapEventsToStore",
         "mapEventsToTimeline",
         "simpleTimeout",
         "watchEventUpdates",
+        "watchEventsUpdates",
         "withImmediateValueOrDefault",
       ]
     `);

package/dist/__tests__/fixtures.d.ts

@@ -1,7 +1,16 @@
 import type { NostrEvent } from "nostr-tools";
-export declare class FakeUser {
+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;

package/dist/__tests__/fixtures.js

@@ -1,8 +1,16 @@
-import { finalizeEvent, generateSecretKey, getPublicKey, kinds } from "nostr-tools";
+import { finalizeEvent, generateSecretKey, getPublicKey, kinds, nip04, nip44 } from "nostr-tools";
 import { unixNow } from "../helpers/time.js";
 export class FakeUser {
     key = generateSecretKey();
     pubkey = getPublicKey(this.key);
+    nip04 = {
+        encrypt: (pubkey, plaintext) => nip04.encrypt(this.key, pubkey, plaintext),
+        decrypt: (pubkey, ciphertext) => nip04.decrypt(this.key, pubkey, ciphertext),
+    };
+    nip44 = {
+        encrypt: (pubkey, plaintext) => nip44.encrypt(plaintext, nip44.getConversationKey(this.key, pubkey)),
+        decrypt: (pubkey, ciphertext) => nip44.decrypt(ciphertext, nip44.getConversationKey(this.key, pubkey)),
+    };
     event(data) {
         return finalizeEvent({
             kind: data?.kind ?? kinds.ShortTextNote,

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

@@ -1,10 +1,12 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { kinds } from "nostr-tools";
 import { subscribeSpyTo } from "@hirez_io/observer-spy";
-import { EventStore } from "../event-store.js";
-import { addSeenRelay, getSeenRelays } from "../../helpers/relays.js";
-import { getEventUID } from "../../helpers/event.js";
+import { kinds } from "nostr-tools";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { FakeUser } from "../../__tests__/fixtures.js";
+import { getEventUID } from "../../helpers/event.js";
+import { addSeenRelay, getSeenRelays } from "../../helpers/relays.js";
+import { EventModel } from "../../models/common.js";
+import { ProfileModel } from "../../models/profile.js";
+import { EventStore } from "../event-store.js";
 let eventStore;
 beforeEach(() => {
     eventStore = new EventStore();
@@ -107,14 +109,14 @@ describe("add", () => {
 });
 describe("inserts", () => {
     it("should emit newer replaceable events", () => {
-        const spy = subscribeSpyTo(eventStore.inserts);
+        const spy = subscribeSpyTo(eventStore.insert$);
         eventStore.add(profile);
         const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 100 });
         eventStore.add(newer);
         expect(spy.getValues()).toEqual([profile, newer]);
     });
     it("should not emit when older replaceable event is added", () => {
-        const spy = subscribeSpyTo(eventStore.inserts);
+        const spy = subscribeSpyTo(eventStore.insert$);
         eventStore.add(profile);
         eventStore.add(user.profile({ name: "new name" }, { created_at: profile.created_at - 1000 }));
         expect(spy.getValues()).toEqual([profile]);
@@ -122,7 +124,7 @@ describe("inserts", () => {
 });
 describe("removes", () => {
     it("should emit older replaceable events when the newest replaceable event is added", () => {
-        const spy = subscribeSpyTo(eventStore.removes);
+        const spy = subscribeSpyTo(eventStore.remove$);
         eventStore.add(profile);
         const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
         eventStore.add(newer);
@@ -159,6 +161,34 @@ describe("removed", () => {
         expect(spy.receivedComplete()).toBe(true);
     });
 });
+describe("model", () => {
+    it("should emit synchronous value if it exists", () => {
+        let value = undefined;
+        eventStore.add(profile);
+        eventStore.model(ProfileModel, user.pubkey).subscribe((v) => (value = v));
+        expect(value).not.toBe(undefined);
+    });
+    it("should not emit undefined if value exists", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.model(EventModel, profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit synchronous undefined if value does not exists", () => {
+        let value = 0;
+        eventStore.model(ProfileModel, user.pubkey).subscribe((v) => {
+            value = v;
+        });
+        expect(value).not.toBe(0);
+        expect(value).toBe(undefined);
+    });
+    it("should share latest value", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.model(EventModel, profile.id));
+        const spy2 = subscribeSpyTo(eventStore.model(EventModel, profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+        expect(spy2.getValues()).toEqual([profile]);
+    });
+});
 describe("event", () => {
     it("should emit existing event", () => {
         eventStore.add(profile);
@@ -167,9 +197,9 @@ describe("event", () => {
     });
     it("should emit then event when its added", () => {
         const spy = subscribeSpyTo(eventStore.event(profile.id));
-        expect(spy.getValues()).toEqual([]);
+        expect(spy.getValues()).toEqual([undefined]);
         eventStore.add(profile);
-        expect(spy.getValues()).toEqual([profile]);
+        expect(spy.getValues()).toEqual([undefined, profile]);
     });
     it("should emit undefined when event is removed", () => {
         eventStore.add(profile);
@@ -191,9 +221,9 @@ describe("event", () => {
         eventStore.remove(profile);
         expect(spy.receivedComplete()).toBe(false);
     });
-    it("should not emit any values if there are no events", () => {
+    it("should emit undefined if event is not found", () => {
         const spy = subscribeSpyTo(eventStore.event(profile.id));
-        expect(spy.receivedNext()).toBe(false);
+        expect(spy.getValues()).toEqual([undefined]);
     });
 });
 describe("events", () => {
@@ -222,10 +252,6 @@ describe("events", () => {
     });
 });
 describe("replaceable", () => {
-    it("should not emit till there is an event", () => {
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        expect(spy.receivedNext()).toBe(false);
-    });
     it("should emit existing events", () => {
         eventStore.add(profile);
         const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
@@ -269,8 +295,8 @@ describe("replaceable", () => {
         expect(spy.getValues()).toEqual([profile]);
     });
     it("should emit newer events", () => {
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
         eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
         const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 500 });
         eventStore.add(newProfile);
         expect(spy.getValues()).toEqual([profile, newProfile]);

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

@@ -0,0 +1,82 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Subject } from "rxjs";
+import { LRU } from "../helpers/lru.js";
+import { IEventSet } from "./interface.js";
+/**
+ * A set of nostr events that can be queried and subscribed to
+ * NOTE: does not handle replaceable events or any deletion logic
+ */
+export declare class EventSet implements IEventSet {
+    protected log: import("debug").Debugger;
+    /** Indexes */
+    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
+    protected authors: Map<string, Set<import("nostr-tools").Event>>;
+    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected created_at: NostrEvent[];
+    /** LRU cache of last events touched */
+    events: LRU<import("nostr-tools").Event>;
+    /** A sorted array of replaceable events by uid */
+    protected replaceable: Map<string, import("nostr-tools").Event[]>;
+    /** A stream of events inserted into the database */
+    insert$: Subject<import("nostr-tools").Event>;
+    /** A stream of events that have been updated */
+    update$: Subject<import("nostr-tools").Event>;
+    /** A stream of events removed from the database */
+    remove$: Subject<import("nostr-tools").Event>;
+    /** A method thats called before a new event is inserted */
+    onBeforeInsert?: (event: NostrEvent) => boolean;
+    /** The number of events in the event set */
+    get size(): number;
+    /** Moves an event to the top of the LRU cache */
+    touch(event: NostrEvent): void;
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id: string): boolean;
+    /** Gets a single event based on id */
+    getEvent(id: string): NostrEvent | undefined;
+    /** Checks if the event set has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
+    /** Gets the latest replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
+    /** Gets the history of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
+    /** Gets all events that match the filters */
+    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    /** Gets a timeline of events that match the filters */
+    getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    /** Inserts an event into the database and notifies all subscriptions */
+    add(event: NostrEvent): NostrEvent | null;
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    update(event: NostrEvent): boolean;
+    /** Removes an event from the database and notifies all subscriptions */
+    remove(eventOrId: string | NostrEvent): boolean;
+    /** A weak map of events that are claimed by other things */
+    protected claims: WeakMap<import("nostr-tools").Event, any>;
+    /** Sets the claim on the event and touches it */
+    claim(event: NostrEvent, claim: any): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): boolean;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): void;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): void;
+    /** Index helper methods */
+    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
+    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /** Iterates over all events by author */
+    iterateAuthors(authors: Iterable<string>): Generator<NostrEvent>;
+    /** Iterates over all events by indexable tag and value */
+    iterateTag(tag: string, values: Iterable<string>): Generator<NostrEvent>;
+    /** Iterates over all events by kind */
+    iterateKinds(kinds: Iterable<number>): Generator<NostrEvent>;
+    /** Iterates over all events by time */
+    iterateTime(since: number | undefined, until: number | undefined): Generator<NostrEvent>;
+    /** Iterates over all events by id */
+    iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    /** Returns all events that match the filters */
+    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
+    /** Remove the oldest events that are not claimed */
+    prune(limit?: number): number;
+}

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

@@ -0,0 +1,347 @@
+import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import { Subject } from "rxjs";
+import { createReplaceableAddress, getEventUID, getIndexableTags, isReplaceable } from "../helpers/event.js";
+import { LRU } from "../helpers/lru.js";
+import { logger } from "../logger.js";
+import { INDEXABLE_TAGS } from "./common.js";
+/**
+ * A set of nostr events that can be queried and subscribed to
+ * NOTE: does not handle replaceable events or any deletion logic
+ */
+export class EventSet {
+    log = logger.extend("EventSet");
+    /** Indexes */
+    kinds = new Map();
+    authors = new Map();
+    tags = new LRU();
+    created_at = [];
+    /** LRU cache of last events touched */
+    events = new LRU();
+    /** A sorted array of replaceable events by uid */
+    replaceable = new Map();
+    /** A stream of events inserted into the database */
+    insert$ = new Subject();
+    /** A stream of events that have been updated */
+    update$ = new Subject();
+    /** A stream of events removed from the database */
+    remove$ = new Subject();
+    /** A method thats called before a new event is inserted */
+    onBeforeInsert;
+    /** The number of events in the event set */
+    get size() {
+        return this.events.size;
+    }
+    /** Moves an event to the top of the LRU cache */
+    touch(event) {
+        this.events.set(event.id, event);
+    }
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id) {
+        return this.events.has(id);
+    }
+    /** Gets a single event based on id */
+    getEvent(id) {
+        return this.events.get(id);
+    }
+    /** Checks if the event set has a replaceable event */
+    hasReplaceable(kind, pubkey, identifier) {
+        const events = this.replaceable.get(createReplaceableAddress(kind, pubkey, identifier));
+        return !!events && events.length > 0;
+    }
+    /** Gets the latest replaceable event */
+    getReplaceable(kind, pubkey, identifier) {
+        const address = createReplaceableAddress(kind, pubkey, identifier);
+        const events = this.replaceable.get(address);
+        return events?.[0];
+    }
+    /** Gets the history of a replaceable event */
+    getReplaceableHistory(kind, pubkey, identifier) {
+        const address = createReplaceableAddress(kind, pubkey, identifier);
+        return this.replaceable.get(address);
+    }
+    /** Gets all events that match the filters */
+    getByFilters(filters) {
+        return this.getEventsForFilters(Array.isArray(filters) ? filters : [filters]);
+    }
+    /** Gets a timeline of events that match the filters */
+    getTimeline(filters) {
+        const timeline = [];
+        const events = this.getEventsForFilters(Array.isArray(filters) ? filters : [filters]);
+        for (const event of events)
+            insertEventIntoDescendingList(timeline, event);
+        return timeline;
+    }
+    /** Inserts an event into the database and notifies all subscriptions */
+    add(event) {
+        const id = event.id;
+        const current = this.events.get(id);
+        if (current)
+            return current;
+        // Ignore events if before insert returns false
+        if (this.onBeforeInsert?.(event) === false)
+            return null;
+        this.events.set(id, event);
+        this.getKindIndex(event.kind).add(event);
+        this.getAuthorsIndex(event.pubkey).add(event);
+        // Add the event to the tag indexes if they exist
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag))
+                this.getTagIndex(tag).add(event);
+        }
+        // Insert into time index
+        insertEventIntoDescendingList(this.created_at, event);
+        // Insert into replaceable index
+        if (isReplaceable(event.kind)) {
+            const uid = getEventUID(event);
+            let array = this.replaceable.get(uid);
+            if (!this.replaceable.has(uid)) {
+                // add an empty array if there is no array
+                array = [];
+                this.replaceable.set(uid, array);
+            }
+            // insert the event into the sorted array
+            insertEventIntoDescendingList(array, event);
+        }
+        // Notify subscribers that the event was inserted
+        this.insert$.next(event);
+        return event;
+    }
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    update(event) {
+        const inserted = this.add(event);
+        if (inserted)
+            this.update$.next(inserted);
+        return inserted !== null;
+    }
+    /** Removes an event from the database and notifies all subscriptions */
+    remove(eventOrId) {
+        let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
+        if (!event)
+            throw new Error("Missing event");
+        const id = event.id;
+        // only remove events that are known
+        if (!this.events.has(id))
+            return false;
+        this.getAuthorsIndex(event.pubkey).delete(event);
+        this.getKindIndex(event.kind).delete(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).delete(event);
+            }
+        }
+        // remove from created_at index
+        const i = this.created_at.indexOf(event);
+        this.created_at.splice(i, 1);
+        this.events.delete(id);
+        // remove from replaceable index
+        if (isReplaceable(event.kind)) {
+            const uid = getEventUID(event);
+            const array = this.replaceable.get(uid);
+            if (array && array.includes(event)) {
+                const idx = array.indexOf(event);
+                array.splice(idx, 1);
+            }
+        }
+        // remove any claims this event has
+        this.claims.delete(event);
+        // notify subscribers this event was removed
+        this.remove$.next(event);
+        return true;
+    }
+    /** A weak map of events that are claimed by other things */
+    claims = new WeakMap();
+    /** Sets the claim on the event and touches it */
+    claim(event, claim) {
+        if (!this.claims.has(event)) {
+            this.claims.set(event, claim);
+        }
+        // always touch event
+        this.touch(event);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.claims.has(event);
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        const current = this.claims.get(event);
+        if (current === claim)
+            this.claims.delete(event);
+    }
+    /** Removes all claims on an event */
+    clearClaim(event) {
+        this.claims.delete(event);
+    }
+    /** Index helper methods */
+    getKindIndex(kind) {
+        if (!this.kinds.has(kind))
+            this.kinds.set(kind, new Set());
+        return this.kinds.get(kind);
+    }
+    getAuthorsIndex(author) {
+        if (!this.authors.has(author))
+            this.authors.set(author, new Set());
+        return this.authors.get(author);
+    }
+    getTagIndex(tagAndValue) {
+        if (!this.tags.has(tagAndValue)) {
+            // build new tag index from existing events
+            const events = new Set();
+            const ts = Date.now();
+            for (const event of this.events.values()) {
+                if (getIndexableTags(event).has(tagAndValue)) {
+                    events.add(event);
+                }
+            }
+            const took = Date.now() - ts;
+            if (took > 100)
+                this.log(`Built index ${tagAndValue} took ${took}ms`);
+            this.tags.set(tagAndValue, events);
+        }
+        return this.tags.get(tagAndValue);
+    }
+    /** Iterates over all events by author */
+    *iterateAuthors(authors) {
+        for (const author of authors) {
+            const events = this.authors.get(author);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    /** Iterates over all events by indexable tag and value */
+    *iterateTag(tag, values) {
+        for (const value of values) {
+            const events = this.getTagIndex(tag + ":" + value);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    /** Iterates over all events by kind */
+    *iterateKinds(kinds) {
+        for (const kind of kinds) {
+            const events = this.kinds.get(kind);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    /** Iterates over all events by time */
+    *iterateTime(since, until) {
+        let untilIndex = 0;
+        let sinceIndex = this.created_at.length - 1;
+        let start = until
+            ? binarySearch(this.created_at, (mid) => {
+                return mid.created_at - until;
+            })
+            : undefined;
+        if (start)
+            untilIndex = start[0];
+        const end = since
+            ? binarySearch(this.created_at, (mid) => {
+                return mid.created_at - since;
+            })
+            : undefined;
+        if (end)
+            sinceIndex = end[0];
+        for (let i = untilIndex; i < sinceIndex; i++) {
+            yield this.created_at[i];
+        }
+    }
+    /** Iterates over all events by id */
+    *iterateIds(ids) {
+        for (const id of ids) {
+            if (this.events.has(id))
+                yield this.events.get(id);
+        }
+    }
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter) {
+        // search is not supported, return an empty set
+        if (filter.search)
+            return new Set();
+        let first = true;
+        let events = new Set();
+        const and = (iterable) => {
+            const set = iterable instanceof Set ? iterable : new Set(iterable);
+            if (first) {
+                events = set;
+                first = false;
+            }
+            else {
+                for (const event of events) {
+                    if (!set.has(event))
+                        events.delete(event);
+                }
+            }
+            return events;
+        };
+        if (filter.ids)
+            and(this.iterateIds(filter.ids));
+        let time = null;
+        // query for time first if since is set
+        if (filter.since !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        for (const t of INDEXABLE_TAGS) {
+            const key = `#${t}`;
+            const values = filter[key];
+            if (values?.length)
+                and(this.iterateTag(t, values));
+        }
+        if (filter.authors)
+            and(this.iterateAuthors(filter.authors));
+        if (filter.kinds)
+            and(this.iterateKinds(filter.kinds));
+        // query for time last if only until is set
+        if (filter.since === undefined && filter.until !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        // if the filter queried on time and has a limit. truncate the events now
+        if (filter.limit && time) {
+            const limited = new Set();
+            for (const event of time) {
+                if (limited.size >= filter.limit)
+                    break;
+                if (events.has(event))
+                    limited.add(event);
+            }
+            return limited;
+        }
+        return events;
+    }
+    /** Returns all events that match the filters */
+    getEventsForFilters(filters) {
+        if (filters.length === 0)
+            throw new Error("No Filters");
+        let events = new Set();
+        for (const filter of filters) {
+            const filtered = this.getEventsForFilter(filter);
+            for (const event of filtered)
+                events.add(event);
+        }
+        return events;
+    }
+    /** Remove the oldest events that are not claimed */
+    prune(limit = 1000) {
+        let removed = 0;
+        let cursor = this.events.first;
+        while (cursor) {
+            const event = cursor.value;
+            if (!this.isClaimed(event)) {
+                this.remove(event);
+                removed++;
+                if (removed >= limit)
+                    break;
+            }
+            cursor = cursor.next;
+        }
+        return removed;
+    }
+}