applesauce-relay 0.0.0-next-20250916134023 → 0.0.0-next-20250919114711

package/dist/group.d.ts

@@ -1,12 +1,12 @@
 import { type NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-import { IEventStoreActions } from "applesauce-core";
+import { IAsyncEventStoreActions, IEventStoreActions } from "applesauce-core";
 import { FilterInput, IGroup, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 export declare class RelayGroup implements IGroup {
     relays: IRelay[];
     constructor(relays: IRelay[]);
     /** Takes an array of observables and only emits EOSE when all observables have emitted EOSE */
-    protected mergeEOSE(requests: Observable<SubscriptionResponse>[], eventStore?: IEventStoreActions): Observable<import("nostr-tools").Event | "EOSE">;
+    protected mergeEOSE(requests: Observable<SubscriptionResponse>[], eventStore?: IEventStoreActions | IAsyncEventStoreActions): Observable<import("nostr-tools").Event | "EOSE">;
     /**
      * Make a request to all relays
      * @note This does not deduplicate events

package/dist/pool.d.ts

@@ -1,5 +1,5 @@
 import { type NostrEvent } from "nostr-tools";
-import { BehaviorSubject, Observable } from "rxjs";
+import { BehaviorSubject, Observable, Subject } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay, RelayOptions } from "./relay.js";
 import { FilterInput, IPool, IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
@@ -9,6 +9,10 @@ export declare class RelayPool implements IPool {
     get groups(): Map<string, RelayGroup>;
     relays$: BehaviorSubject<Map<string, Relay>>;
     get relays(): Map<string, Relay>;
+    /** A signal when a relay is added */
+    add$: Subject<IRelay>;
+    /** A signal when a relay is removed */
+    remove$: Subject<IRelay>;
     /** An array of relays to never connect to */
     blacklist: Set<string>;
     constructor(options?: RelayOptions | undefined);

package/dist/pool.js

@@ -1,4 +1,4 @@
-import { BehaviorSubject } from "rxjs";
+import { BehaviorSubject, Subject } from "rxjs";
 import { normalizeURL } from "applesauce-core/helpers";
 import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";
@@ -12,10 +12,27 @@ export class RelayPool {
     get relays() {
         return this.relays$.value;
     }
+    /** A signal when a relay is added */
+    add$ = new Subject();
+    /** A signal when a relay is removed */
+    remove$ = new Subject();
     /** An array of relays to never connect to */
     blacklist = new Set();
     constructor(options) {
         this.options = options;
+        // Listen for relays being added and removed to emit connect / disconnect signals
+        // const listeners = new Map<IRelay, Subscription>();
+        // this.add$.subscribe((relay) =>
+        //   listeners.set(
+        //     relay,
+        //     relay.connected$.subscribe((conn) => (conn ? this.connect$.next(relay) : this.disconnect$.next(relay))),
+        //   ),
+        // );
+        // this.remove$.subscribe((relay) => {
+        //   const listener = listeners.get(relay);
+        //   if (listener) listener.unsubscribe();
+        //   listeners.delete(relay);
+        // });
     }
     filterBlacklist(urls) {
         return urls.filter((url) => !this.blacklist.has(url));
@@ -35,6 +52,7 @@ export class RelayPool {
         relay = new Relay(url, this.options);
         this.relays.set(url, relay);
         this.relays$.next(this.relays);
+        this.add$.next(relay);
         return relay;
     }
     /** Create a group of relays */
@@ -68,6 +86,7 @@ export class RelayPool {
             instance?.close();
         this.relays.delete(instance.url);
         this.relays$.next(this.relays);
+        this.remove$.next(instance);
     }
     /** Make a REQ to multiple relays that does not deduplicate events */
     req(relays, filters, id) {

package/dist/relay.d.ts

@@ -14,6 +14,8 @@ export type RelayOptions = {
     eoseTimeout?: number;
     /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout?: number;
+    /** How long to wait for a publish to complete (default 30s) */
+    publishTimeout?: number;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive?: number;
 };
@@ -70,6 +72,8 @@ export declare class Relay implements IRelay {
     eoseTimeout: number;
     /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout: number;
+    /** How long to wait for a publish to complete (default 30s) */
+    publishTimeout: number;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive: number;
     protected receivedAuthRequiredForReq: BehaviorSubject<boolean>;
@@ -101,6 +105,8 @@ export declare class Relay implements IRelay {
     protected customRetryOperator<T extends unknown = unknown>(times: undefined | boolean | number | RetryConfig, base?: RetryConfig): MonoTypeOperatorFunction<T>;
     /** Internal operator for creating the repeat() operator */
     protected customRepeatOperator<T extends unknown = unknown>(times: undefined | boolean | number | RepeatConfig | undefined): MonoTypeOperatorFunction<T>;
+    /** Internal operator for creating the timeout() operator */
+    protected customTimeoutOperator<T extends unknown = unknown>(timeout: undefined | boolean | number, defaultTimeout: number): MonoTypeOperatorFunction<T>;
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
     /** Makes a single request that retires on errors and completes on EOSE */

package/dist/relay.js

@@ -77,6 +77,8 @@ export class Relay {
     eoseTimeout = 10_000;
     /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout = 10_000;
+    /** How long to wait for a publish to complete (default 30s) */
+    publishTimeout = 30_000;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive = 30_000;
     // Subjects that track if an "auth-required" message has been received for REQ or EVENT
@@ -108,6 +110,8 @@ export class Relay {
             this.eoseTimeout = opts.eoseTimeout;
         if (opts?.eventTimeout !== undefined)
             this.eventTimeout = opts.eventTimeout;
+        if (opts?.publishTimeout !== undefined)
+            this.publishTimeout = opts.publishTimeout;
         if (opts?.keepAlive !== undefined)
             this.keepAlive = opts.keepAlive;
         // Create an observable that tracks boolean authentication state
@@ -378,6 +382,18 @@ export class Relay {
         else
             return repeat(times);
     }
+    /** Internal operator for creating the timeout() operator */
+    customTimeoutOperator(timeout, defaultTimeout) {
+        // Do nothing if disabled
+        if (timeout === false)
+            return identity;
+        // If true default to 30 seconds
+        else if (timeout === true)
+            return simpleTimeout(defaultTimeout);
+        // Otherwise use the timeout value or default to 30 seconds
+        else
+            return simpleTimeout(timeout ?? defaultTimeout);
+    }
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters, opts) {
         return this.req(filters, opts?.id).pipe(
@@ -410,6 +426,8 @@ export class Relay {
         }), 
         // Retry the publish until it succeeds or the number of retries is reached
         this.customRetryOperator(opts?.retries ?? opts?.reconnect ?? true, DEFAULT_RETRY_CONFIG), 
+        // Add timeout for publishing
+        this.customTimeoutOperator(opts?.timeout, this.publishTimeout), 
         // Single subscription
         share()));
     }

package/dist/types.d.ts

@@ -21,6 +21,8 @@ export type PublishOptions = {
      * @see https://rxjs.dev/api/index/function/retry
      */
     reconnect?: boolean | number | Parameters<typeof retry>[0];
+    /** Timeout for publish in milliseconds (default 30 seconds) */
+    timeout?: number | boolean;
 };
 /** Options for the request method on the pool and relay */
 export type RequestOptions = SubscriptionOptions;
@@ -58,6 +60,7 @@ export interface IRelay extends MultiplexWebSocket {
     challenge$: Observable<string | null>;
     authenticated$: Observable<boolean>;
     notices$: Observable<string[]>;
+    error$: Observable<Error | null>;
     readonly connected: boolean;
     readonly authenticated: boolean;
     readonly challenge: string | null;
@@ -91,7 +94,12 @@ export interface IGroup {
     /** Open a subscription with retries */
     subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }
-export interface IPool {
+/** Signals emitted by the pool */
+export interface IPoolSignals {
+    add$: Observable<IRelay>;
+    remove$: Observable<IRelay>;
+}
+export interface IPool extends IPoolSignals {
     /** Get or create a relay */
     relay(url: string): IRelay;
     /** Create a relay group */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250916134023",
+  "version": "0.0.0-next-20250919114711",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -52,14 +52,15 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "0.0.0-next-20250916134023",
+    "applesauce-core": "0.0.0-next-20250919114711",
     "nanoid": "^5.0.9",
     "nostr-tools": "~2.15",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "0.0.0-next-20250916134023",
+    "applesauce-signers": "0.0.0-next-20250919114711",
+    "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vitest": "^3.2.4",
     "vitest-websocket-mock": "^0.5.0"
@@ -69,6 +70,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__/auth.test.d.ts

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

package/dist/__tests__/auth.test.js

@@ -1,111 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { subscribeSpyTo } from "@hirez_io/observer-spy";
-import { WS } from "vitest-websocket-mock";
-import { Relay } from "../relay.js";
-let server;
-let relay;
-beforeEach(async () => {
-    server = new WS("wss://test", { jsonProtocol: true });
-    relay = new Relay("wss://test");
-    // Create a persistent subscription to keep the connection open
-    // @ts-expect-error
-    subscribeSpyTo(relay.socket);
-});
-afterEach(async () => {
-    server.close();
-    // Wait for server to close to prevent memory leaks
-    await WS.clean();
-});
-const mockEvent = {
-    kind: 1,
-    id: "00007641c9c3e65a71843933a44a18060c7c267a4f9169efa3735ece45c8f621",
-    pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
-    created_at: 1743712795,
-    tags: [["nonce", "13835058055282167643", "16"]],
-    content: "This is just stupid: https://codestr.fiatjaf.com/",
-    sig: "5a57b5a12bba4b7cf0121077b1421cf4df402c5c221376c076204fc4f7519e28ce6508f26ddc132c406ccfe6e62cc6db857b96c788565cdca9674fe9a0710ac2",
-};
-describe("event", () => {
-    it("should wait for auth before sending EVENT if auth-required received", async () => {
-        // Create first event subscription
-        const spy1 = subscribeSpyTo(relay.event(mockEvent));
-        // Verify EVENT was sent
-        const firstEventMessage = await server.nextMessage;
-        expect(firstEventMessage).toEqual(["EVENT", mockEvent]);
-        // Send auth-required response
-        server.send(["OK", mockEvent.id, false, "auth-required: need to authenticate"]);
-        // Create second event subscription - this should not send EVENT yet
-        const spy2 = subscribeSpyTo(relay.event(mockEvent));
-        // Should not have received any messages
-        expect(server.messages.length).toBe(1);
-        // Send AUTH challenge
-        server.send(["AUTH", "challenge-string"]);
-        // Send auth event
-        const authEvent = { ...mockEvent, id: "auth-id" };
-        subscribeSpyTo(relay.auth(authEvent));
-        // Verify AUTH was sent
-        const authMessage = await server.nextMessage;
-        expect(authMessage).toEqual(["AUTH", authEvent]);
-        // Send successful auth response
-        server.send(["OK", authEvent.id, true, ""]);
-        // Now the second EVENT should be sent
-        const secondEventMessage = await server.nextMessage;
-        expect(secondEventMessage).toEqual(["EVENT", mockEvent]);
-        // Send OK response for second event
-        server.send(["OK", mockEvent.id, true, ""]);
-        expect(spy1.getLastValue()).toEqual({
-            ok: false,
-            message: "auth-required: need to authenticate",
-            from: "wss://test",
-        });
-        expect(spy2.getLastValue()).toEqual({ ok: true, message: "", from: "wss://test" });
-    });
-});
-describe("req", () => {
-    it("should wait for auth before sending REQ if auth-required received", async () => {
-        // Create first REQ subscription
-        const filters = [{ kinds: [1], limit: 10 }];
-        subscribeSpyTo(relay.req(filters, "sub1"), { expectErrors: true });
-        // Verify REQ was sent
-        const firstReqMessage = await server.nextMessage;
-        expect(firstReqMessage).toEqual(["REQ", "sub1", ...filters]);
-        // Send auth-required response
-        server.send(["CLOSED", "sub1", "auth-required: need to authenticate"]);
-        // Consume the client CLOSE message for sub1
-        await server.nextMessage;
-        // Create second REQ subscription - this should not send REQ yet
-        subscribeSpyTo(relay.req(filters, "sub2"), { expectErrors: true });
-        // Should not have received any messages
-        expect(server.messages).not.toContain(["REQ", "sub2", ...filters]);
-        // Send AUTH challenge
-        server.send(["AUTH", "challenge-string"]);
-        // Send auth event
-        const authEvent = { ...mockEvent, id: "auth-id" };
-        subscribeSpyTo(relay.auth(authEvent));
-        // Verify AUTH was sent
-        const authMessage = await server.nextMessage;
-        expect(authMessage).toEqual(["AUTH", authEvent]);
-        // Send successful auth response
-        server.send(["OK", authEvent.id, true, ""]);
-        // Now the second REQ should be sent
-        const secondReqMessage = await server.nextMessage;
-        expect(secondReqMessage).toEqual(["REQ", "sub2", ...filters]);
-        // Send some events for the second subscription
-        server.send(["EVENT", "sub2", mockEvent]);
-        server.send(["EOSE", "sub2"]);
-    });
-});
-describe("auth", () => {
-    it("should set authenticated state after successful AUTH challenge response", async () => {
-        // Send AUTH challenge
-        server.send(["AUTH", "challenge-string"]);
-        // Send auth event response
-        const authEvent = { ...mockEvent, id: "auth-id" };
-        subscribeSpyTo(relay.auth(authEvent));
-        // Verify AUTH was sent
-        await expect(server).toReceiveMessage(["AUTH", authEvent]);
-        // Send successful auth response
-        server.send(["OK", authEvent.id, true, ""]);
-        expect(relay.authenticated).toBe(true);
-    });
-});

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

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

package/dist/__tests__/exports.test.js

@@ -1,19 +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(`
-      [
-        "Relay",
-        "RelayGroup",
-        "RelayPool",
-        "ReqCloseError",
-        "completeOnEose",
-        "markFromRelay",
-        "onlyEvents",
-        "storeEvents",
-        "toEventStore",
-      ]
-    `);
-    });
-});

package/dist/__tests__/fake-user.d.ts

@@ -1,10 +0,0 @@
-import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
-import type { NostrEvent } from "nostr-tools";
-export declare class FakeUser extends SimpleSigner {
-    pubkey: 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;
-    contacts(pubkeys?: string[]): import("nostr-tools").Event;
-    list(tags?: string[][], extra?: Partial<NostrEvent>): import("nostr-tools").Event;
-}

package/dist/__tests__/fake-user.js

@@ -1,31 +0,0 @@
-import { unixNow } from "applesauce-core/helpers";
-import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
-import { finalizeEvent, getPublicKey, kinds } from "nostr-tools";
-export class FakeUser extends SimpleSigner {
-    pubkey = getPublicKey(this.key);
-    event(data) {
-        return finalizeEvent({
-            kind: data?.kind ?? kinds.ShortTextNote,
-            content: data?.content || "",
-            created_at: data?.created_at ?? unixNow(),
-            tags: data?.tags || [],
-        }, this.key);
-    }
-    note(content = "Hello World", extra) {
-        return this.event({ kind: kinds.ShortTextNote, content, ...extra });
-    }
-    profile(profile = {}, extra) {
-        return this.event({ kind: kinds.Metadata, content: JSON.stringify({ ...profile }), ...extra });
-    }
-    contacts(pubkeys = []) {
-        return this.event({ kind: kinds.Contacts, tags: pubkeys.map((p) => ["p", p]) });
-    }
-    list(tags = [], extra) {
-        return this.event({
-            kind: kinds.Bookmarksets,
-            content: "",
-            tags: [["d", String(Math.round(Math.random() * 10000))], ...tags],
-            ...extra,
-        });
-    }
-}

package/dist/__tests__/faker.d.ts

@@ -1,19 +0,0 @@
-import * as Nostr from "nostr-typedef";
-export declare const faker: {
-    filter(filter?: Nostr.Filter): Nostr.Filter;
-    filters(): Nostr.Filter[];
-    event<const K extends number>(event?: Partial<Nostr.Event<K>>): Nostr.Event<K>;
-    AUTH(event?: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): Nostr.ToRelayMessage.AUTH;
-    CLOSE(subId: string): Nostr.ToRelayMessage.CLOSE;
-    COUNT(subId: string, filters?: Nostr.Filter[]): Nostr.ToRelayMessage.COUNT;
-    EVENT(event?: Partial<Nostr.Event>): Nostr.ToRelayMessage.EVENT;
-    REQ(subId: string, filters?: Nostr.Filter[]): Nostr.ToRelayMessage.REQ;
-    toClientMessage: {
-        AUTH(message?: string): Nostr.ToClientMessage.AUTH;
-        COUNT(subId: string, count?: number): Nostr.ToClientMessage.COUNT;
-        EOSE(subId: string): Nostr.ToClientMessage.EOSE;
-        EVENT(subId: string, event?: Partial<Nostr.Event>): Nostr.ToClientMessage.EVENT;
-        NOTICE(message?: string): Nostr.ToClientMessage.NOTICE;
-        OK(eventId: string, succeeded: boolean, message?: string): Nostr.ToClientMessage.OK;
-    };
-};

package/dist/__tests__/faker.js

@@ -1,56 +0,0 @@
-import { kinds } from "nostr-tools";
-export const faker = {
-    filter(filter) {
-        return filter ?? { kinds: [0] };
-    },
-    filters() {
-        return [faker.filter()];
-    },
-    event(event) {
-        return {
-            id: "*",
-            content: "*",
-            created_at: 0,
-            kind: 0,
-            pubkey: "*",
-            sig: "*",
-            tags: [],
-            ...event,
-        };
-    },
-    AUTH(event) {
-        return ["AUTH", { ...faker.event(event), kind: kinds.ClientAuth }];
-    },
-    CLOSE(subId) {
-        return ["CLOSE", subId];
-    },
-    COUNT(subId, filters) {
-        return ["COUNT", subId, ...(filters ?? faker.filters())];
-    },
-    EVENT(event) {
-        return ["EVENT", faker.event(event)];
-    },
-    REQ(subId, filters) {
-        return ["REQ", subId, ...(filters ?? faker.filters())];
-    },
-    toClientMessage: {
-        AUTH(message) {
-            return ["AUTH", message ?? "*"];
-        },
-        COUNT(subId, count) {
-            return ["COUNT", subId, { count: count ?? 0 }];
-        },
-        EOSE(subId) {
-            return ["EOSE", subId];
-        },
-        EVENT(subId, event) {
-            return ["EVENT", subId, faker.event(event)];
-        },
-        NOTICE(message) {
-            return ["NOTICE", message ?? "*"];
-        },
-        OK(eventId, succeeded, message) {
-            return ["OK", eventId, succeeded, message ?? "*"];
-        },
-    },
-};

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

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

package/dist/__tests__/group.test.js

@@ -1,106 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { subscribeSpyTo } from "@hirez_io/observer-spy";
-import { WS } from "vitest-websocket-mock";
-import { Relay } from "../relay.js";
-import { RelayGroup } from "../group.js";
-import { of } from "rxjs";
-let mockRelay1;
-let mockRelay2;
-let relay1;
-let relay2;
-let group;
-let mockEvent;
-beforeEach(async () => {
-    // Create mock relays
-    mockRelay1 = new WS("wss://relay1.test", { jsonProtocol: true });
-    mockRelay2 = new WS("wss://relay2.test", { jsonProtocol: true });
-    // Mock empty information document
-    vi.spyOn(Relay, "fetchInformationDocument").mockImplementation(() => of(null));
-    // Create relays
-    relay1 = new Relay("wss://relay1.test");
-    relay2 = new Relay("wss://relay2.test");
-    // Create group
-    group = new RelayGroup([relay1, relay2]);
-    mockEvent = {
-        kind: 1,
-        id: "test-id",
-        pubkey: "test-pubkey",
-        created_at: 1234567890,
-        tags: [],
-        content: "test content",
-        sig: "test-sig",
-    };
-});
-afterEach(async () => {
-    mockRelay1.close();
-    mockRelay2.close();
-    await WS.clean();
-});
-describe("req", () => {
-    it("should make requests to multiple relays", async () => {
-        group.req([{ kinds: [1] }], "test-sub").subscribe();
-        await expect(mockRelay1).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-        await expect(mockRelay2).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-    });
-    it("should emit events from all relays", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        await expect(mockRelay1).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-        await expect(mockRelay2).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-        mockRelay1.send(["EVENT", "test-sub", { ...mockEvent, id: "1" }]);
-        mockRelay2.send(["EVENT", "test-sub", { ...mockEvent, id: "2" }]);
-        expect(spy.getValues()).toEqual([expect.objectContaining({ id: "1" }), expect.objectContaining({ id: "2" })]);
-    });
-    it("should only emit EOSE once all relays have emitted EOSE", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        mockRelay1.send(["EOSE", "test-sub"]);
-        expect(spy.getValues()).not.toContain("EOSE");
-        mockRelay2.send(["EOSE", "test-sub"]);
-        expect(spy.getValues()).toContain("EOSE");
-    });
-    it("should ignore relays that have an error", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        mockRelay1.error();
-        mockRelay2.send(["EVENT", "test-sub", mockEvent]);
-        mockRelay2.send(["EOSE", "test-sub"]);
-        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
-    });
-    it("should emit EOSE if all relays error", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        mockRelay1.error();
-        mockRelay2.error();
-        expect(spy.getValues()).toEqual(["EOSE"]);
-    });
-});
-describe("event", () => {
-    it("should send EVENT to all relays in the group", async () => {
-        group.event(mockEvent).subscribe();
-        await expect(mockRelay1).toReceiveMessage(["EVENT", mockEvent]);
-        await expect(mockRelay2).toReceiveMessage(["EVENT", mockEvent]);
-    });
-    it("should emit OK messages from all relays", async () => {
-        const spy = subscribeSpyTo(group.event(mockEvent));
-        mockRelay1.send(["OK", mockEvent.id, true, ""]);
-        mockRelay2.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.getValues()).toEqual([
-            expect.objectContaining({ ok: true, from: "wss://relay1.test", message: "" }),
-            expect.objectContaining({ ok: true, from: "wss://relay2.test", message: "" }),
-        ]);
-    });
-    it("should complete when all relays have sent OK messages", async () => {
-        const spy = subscribeSpyTo(group.event(mockEvent));
-        mockRelay1.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.receivedComplete()).toBe(false);
-        mockRelay2.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.receivedComplete()).toBe(true);
-    });
-    it("should handle relay errors and still complete", async () => {
-        const spy = subscribeSpyTo(group.event(mockEvent));
-        mockRelay1.error();
-        mockRelay2.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.getValues()).toEqual([
-            expect.objectContaining({ ok: false, from: "wss://relay1.test", message: "Unknown error" }),
-            expect.objectContaining({ ok: true, from: "wss://relay2.test", message: "" }),
-        ]);
-        expect(spy.receivedComplete()).toBe(true);
-    });
-});

package/dist/__tests__/matchers.d.ts

@@ -1,60 +0,0 @@
-import Nostr from "nostr-typedef";
-declare module "vitest" {
-    interface Assertion<T = any> extends CustomMatchers {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
-    }
-}
-interface CustomMatchers {
-    beToRelayAUTH(): void;
-    beToRelayAUTH(event: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): void;
-    beToRelayCLOSE(): void;
-    beToRelayCLOSE(subId: string): void;
-    beToRelayCOUNT(): void;
-    beToRelayCOUNT(subId: string): void;
-    beToRelayCOUNT(expected: [subId: string, ...filters: Nostr.Filter[]]): void;
-    beToRelayEVENT(): void;
-    beToRelayEVENT(event: Partial<Nostr.Event>): void;
-    beToRelayREQ(): void;
-    beToRelayREQ(subId: string): void;
-    beToRelayREQ(expected: [subId: string, ...filters: Nostr.Filter[]]): void;
-    beToClientAUTH(): void;
-    beToClientAUTH(challengeMessage: string): void;
-    beToClientCOUNT(): void;
-    beToClientCOUNT(subId: string): void;
-    beToClientCOUNT(expected: [subId: string, count: number]): void;
-    beToClientEOSE(): void;
-    beToClientEOSE(subId: string): void;
-    beToClientEVENT(): void;
-    beToClientEVENT(subId: string): void;
-    beToClientEVENT(expected: [subId: string, event: Partial<Nostr.Event>]): void;
-    beToClientNOTICE(): void;
-    beToClientNOTICE(message: string): void;
-    beToClientOK(expected: [eventId: string, succeeded: boolean, message?: string]): void;
-    toReceiveAUTH(): Promise<void>;
-    toReceiveAUTH(event: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): Promise<void>;
-    toReceiveCLOSE(): Promise<void>;
-    toReceiveCLOSE(subId: string): Promise<void>;
-    toReceiveCOUNT(): Promise<void>;
-    toReceiveCOUNT(subId: string): Promise<void>;
-    toReceiveCOUNT(expected: [subId: string, ...filters: Nostr.Filter[]]): Promise<void>;
-    toReceiveEVENT(): Promise<void>;
-    toReceiveEVENT(event: Partial<Nostr.Event>): Promise<void>;
-    toReceiveREQ(): Promise<void>;
-    toReceiveREQ(subId: string): Promise<void>;
-    toReceiveREQ(expected: [subId: string, ...filters: Nostr.Filter[]]): Promise<void>;
-    toSeeAUTH(): Promise<void>;
-    toSeeAUTH(challengeMessage: string): Promise<void>;
-    toSeeCOUNT(): Promise<void>;
-    toSeeCOUNT(subId: string): Promise<void>;
-    toSeeCOUNT(expected: [subId: string, count: number]): Promise<void>;
-    toSeeEOSE(): Promise<void>;
-    toSeeEOSE(subId: string): Promise<void>;
-    toSeeEVENT(): Promise<void>;
-    toSeeEVENT(subId: string): Promise<void>;
-    toSeeEVENT(expected: [subId: string, event: Partial<Nostr.Event>]): Promise<void>;
-    toSeeNOTICE(): Promise<void>;
-    toSeeNOTICE(message: string): Promise<void>;
-    toSeeOK(expected: [eventId: string, succeeded: boolean, message?: string]): Promise<void>;
-}
-export {};