applesauce-actions 0.0.0-next-20250808173123 → 0.0.0-next-20250828144630

package/dist/__tests__/action-hub.test.d.ts

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

package/dist/__tests__/action-hub.test.js

@@ -0,0 +1,67 @@
+import { from, Subject } from "rxjs";
+import { describe, expect, it, vi } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { EventFactory } from "applesauce-factory";
+import { EventStore } from "applesauce-core";
+import { FakeUser } from "./fake-user.js";
+import { ActionHub } from "../action-hub.js";
+import { CreateProfile } from "../actions/profile.js";
+const user = new FakeUser();
+const events = new EventStore();
+const factory = new EventFactory({ signer: user });
+describe("runAction", () => {
+    it("should handle action that return observables", async () => {
+        const e = [user.note(), user.profile({ name: "testing" })];
+        const action = () => from(e);
+        const spy = subscribeSpyTo(ActionHub.runAction({ events, factory, self: await user.getPublicKey() }, action));
+        await spy.onComplete();
+        expect(spy.getValues()).toEqual(e);
+    });
+    it("should handle action that return AsyncIterable", async () => {
+        const e = [user.note(), user.profile({ name: "testing" })];
+        async function* action() {
+            for (const event of e)
+                yield event;
+        }
+        const spy = subscribeSpyTo(ActionHub.runAction({ events, factory, self: await user.getPublicKey() }, action));
+        await spy.onComplete();
+        expect(spy.getValues()).toEqual(e);
+    });
+    it("should handle action that return Iterable", async () => {
+        const e = [user.note(), user.profile({ name: "testing" })];
+        function* action() {
+            for (const event of e)
+                yield event;
+        }
+        const spy = subscribeSpyTo(ActionHub.runAction({ events, factory, self: await user.getPublicKey() }, action));
+        await spy.onComplete();
+        expect(spy.getValues()).toEqual(e);
+    });
+});
+describe("run", () => {
+    it("should throw if publish is not set", async () => {
+        const hub = new ActionHub(events, factory);
+        await expect(async () => hub.run(CreateProfile, { name: "fiatjaf" })).rejects.toThrow();
+    });
+    it("should call publish with all events", async () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const hub = new ActionHub(events, factory, publish);
+        await hub.run(CreateProfile, { name: "fiatjaf" });
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ content: JSON.stringify({ name: "fiatjaf" }) }));
+    });
+});
+describe("exec", () => {
+    it("should support forEach to stream to publish", async () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const hub = new ActionHub(events, factory);
+        await hub.exec(CreateProfile, { name: "fiatjaf" }).forEach(publish);
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ content: JSON.stringify({ name: "fiatjaf" }) }));
+    });
+    it("should support streaming to a publish subject", async () => {
+        const publish = new Subject();
+        const spy = subscribeSpyTo(publish);
+        const hub = new ActionHub(events, factory);
+        await hub.exec(CreateProfile, { name: "fiatjaf" }).forEach((v) => publish.next(v));
+        expect(spy.getValues()).toEqual([expect.objectContaining({ content: JSON.stringify({ name: "fiatjaf" }) })]);
+    });
+});

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

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

package/dist/__tests__/exports.test.js

@@ -0,0 +1,12 @@
+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(`
+      [
+        "ActionHub",
+        "Actions",
+      ]
+    `);
+    });
+});

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,32 @@
+import { unixNow } from "applesauce-core/helpers";
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
+import { nanoid } from "nanoid";
+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", nanoid()], ...tags],
+            ...extra,
+        });
+    }
+}

package/dist/actions/__tests__/blossom.test.d.ts

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

package/dist/actions/__tests__/blossom.test.js

@@ -0,0 +1,93 @@
+import { EventStore } from "applesauce-core";
+import { BLOSSOM_SERVER_LIST_KIND } from "applesauce-core/helpers/blossom";
+import { EventFactory } from "applesauce-factory";
+import { firstValueFrom, lastValueFrom } from "rxjs";
+import { toArray } from "rxjs/operators";
+import { beforeEach, describe, expect, it } from "vitest";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { AddBlossomServer, NewBlossomServers, RemoveBlossomServer, SetDefaultBlossomServer } from "../blossom.js";
+const user = new FakeUser();
+let events;
+let factory;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    hub = new ActionHub(events, factory);
+});
+describe("NewBlossomServers", () => {
+    it("should publish a kind 10063 blossom server list", async () => {
+        const result = await lastValueFrom(hub.exec(NewBlossomServers, ["https://cdn.example.com/"]).pipe(toArray()));
+        expect(result[0]).toMatchObject({ kind: BLOSSOM_SERVER_LIST_KIND, tags: [["server", "https://cdn.example.com/"]] });
+    });
+    it("should throw if a blossom servers event already exists", async () => {
+        // Create the initial event
+        await hub.exec(NewBlossomServers, ["https://cdn.example.com/"]).forEach((e) => events.add(e));
+        // Attempt to create another one
+        await expect(lastValueFrom(hub.exec(NewBlossomServers, ["https://other.example.com/"]).pipe(toArray()))).rejects.toThrow("Blossom servers event already exists");
+    });
+});
+describe("AddBlossomServer", () => {
+    beforeEach(async () => {
+        // Create an initial empty server list
+        await hub.exec(NewBlossomServers, ["https://cdn.example.com/"]).forEach((e) => events.add(e));
+    });
+    it("should add a single server to the list", async () => {
+        const result = await firstValueFrom(hub.exec(AddBlossomServer, "https://other.example.com/"));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([["server", expect.stringContaining("other.example.com")]]),
+        });
+    });
+    it("should add multiple servers to the list", async () => {
+        const result = await firstValueFrom(hub.exec(AddBlossomServer, ["https://other.example.com/", "https://other2.example.com/"]));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([
+                ["server", expect.stringContaining("other.example.com")],
+                ["server", expect.stringContaining("other2.example.com")],
+            ]),
+        });
+    });
+});
+describe("RemoveBlossomServer", () => {
+    beforeEach(async () => {
+        // Create an initial server list with two servers
+        await hub
+            .exec(NewBlossomServers, ["https://cdn.example.com/", "https://other.example.com/"])
+            .forEach((e) => events.add(e));
+    });
+    it("should remove a server from the list", async () => {
+        const result = await firstValueFrom(hub.exec(RemoveBlossomServer, "https://cdn.example.com/"));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([["server", expect.stringContaining("other.example.com")]]),
+        });
+    });
+    it("should remove multiple servers from the list", async () => {
+        const result = await firstValueFrom(hub.exec(RemoveBlossomServer, ["https://cdn.example.com/", "https://other.example.com/"]));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: [],
+        });
+    });
+});
+describe("SetDefaultBlossomServer", () => {
+    beforeEach(async () => {
+        // Create an initial server list with two servers
+        await hub
+            .exec(NewBlossomServers, ["https://cdn.example.com/", "https://other.example.com/"])
+            .forEach((e) => events.add(e));
+    });
+    it("should move the specified server to the top of the list", async () => {
+        const result = await firstValueFrom(hub.exec(SetDefaultBlossomServer, "https://other.example.com/"));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([
+                ["server", expect.stringContaining("other.example.com")],
+                ["server", expect.stringContaining("cdn.example.com")],
+            ]),
+        });
+    });
+});

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

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

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

@@ -0,0 +1,24 @@
+import { beforeEach, describe, expect, it, vitest } from "vitest";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { kinds } from "nostr-tools";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { CreateBookmarkList } from "../bookmarks.js";
+const user = new FakeUser();
+let events;
+let factory;
+let publish;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    publish = vitest.fn().mockResolvedValue(undefined);
+    hub = new ActionHub(events, factory, publish);
+});
+describe("CreateBookmarkList", () => {
+    it("should publish a kind 10003 bookmark list", async () => {
+        await hub.run(CreateBookmarkList);
+        expect(publish).toBeCalledWith(expect.objectContaining({ kind: kinds.BookmarkList }));
+    });
+});

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

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

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

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach, vitest } from "vitest";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { EventFactory } from "applesauce-factory";
+import { EventStore } from "applesauce-core";
+import { ActionHub } from "../../action-hub.js";
+import { FollowUser, NewContacts, UnfollowUser } from "../contacts.js";
+const user = new FakeUser();
+let events;
+let factory;
+let publish;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    publish = vitest.fn().mockResolvedValue(undefined);
+    hub = new ActionHub(events, factory, publish);
+});
+describe("FollowUser", () => {
+    it("should throw an error if contacts does not exist", async () => {
+        // don't add any events to the store
+        await expect(hub.run(FollowUser, user.pubkey)).rejects.toThrow();
+        expect(publish).not.toHaveBeenCalled();
+    });
+    it('should publish an event with a new "p" tag', async () => {
+        events.add(user.contacts());
+        await hub.run(FollowUser, user.pubkey);
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ tags: expect.arrayContaining([["p", user.pubkey]]) }));
+    });
+});
+describe("UnfollowUser", () => {
+    it("should throw an error if contacts does not exist", async () => {
+        // don't add any events to the store
+        await expect(hub.run(UnfollowUser, user.pubkey)).rejects.toThrow();
+        expect(publish).not.toHaveBeenCalled();
+    });
+    it('should publish an event with a new "p" tag', async () => {
+        events.add(user.contacts([user.pubkey]));
+        await hub.run(UnfollowUser, user.pubkey);
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ kind: 3, tags: [] }));
+    });
+});
+describe("NewContacts", () => {
+    it("should throw if contact list already exists", async () => {
+        events.add(user.contacts([user.pubkey]));
+        await expect(hub.run(NewContacts, [])).rejects.toThrow();
+        expect(publish).not.toBeCalled();
+    });
+    it("should publish a new contact event with pubkeys", async () => {
+        await hub.run(NewContacts, [user.pubkey]);
+        expect(publish).toHaveBeenCalled();
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ kind: 3, tags: expect.arrayContaining([["p", user.pubkey]]) }));
+    });
+});

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

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

package/dist/actions/__tests__/exports.test.js

@@ -0,0 +1,66 @@
+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(`
+      [
+        "AddBlockedRelay",
+        "AddBlossomServer",
+        "AddDMRelay",
+        "AddFavoriteRelay",
+        "AddFavoriteRelaySet",
+        "AddInboxRelay",
+        "AddOutboxRelay",
+        "AddRelayToRelaySet",
+        "AddSearchRelay",
+        "AddUserToFollowSet",
+        "BookmarkEvent",
+        "CreateBookmarkList",
+        "CreateBookmarkSet",
+        "CreateFollowSet",
+        "CreateMailboxes",
+        "CreatePinList",
+        "CreateProfile",
+        "CreateRelaySet",
+        "FollowUser",
+        "MuteHashtag",
+        "MuteThread",
+        "MuteUser",
+        "MuteWord",
+        "NewBlockedRelays",
+        "NewBlossomServers",
+        "NewContacts",
+        "NewDMRelays",
+        "NewFavoriteRelays",
+        "NewSearchRelays",
+        "PinNote",
+        "RemoveBlockedRelay",
+        "RemoveBlossomServer",
+        "RemoveDMRelay",
+        "RemoveFavoriteRelay",
+        "RemoveFavoriteRelaySet",
+        "RemoveInboxRelay",
+        "RemoveOutboxRelay",
+        "RemoveRelayFromRelaySet",
+        "RemoveSearchRelay",
+        "RemoveUserFromFollowSet",
+        "ReplyToLegacyMessage",
+        "ReplyToWrappedMessage",
+        "SendLegacyMessage",
+        "SendWrappedMessage",
+        "SetDefaultBlossomServer",
+        "SetListMetadata",
+        "UnbookmarkEvent",
+        "UnfollowUser",
+        "UnmuteHashtag",
+        "UnmuteThread",
+        "UnmuteUser",
+        "UnmuteWord",
+        "UnpinNote",
+        "UpdateFollowSetInformation",
+        "UpdateProfile",
+        "UpdateRelaySetInformation",
+      ]
+    `);
+    });
+});

package/dist/actions/__tests__/follow-sets.test.d.ts

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

package/dist/actions/__tests__/follow-sets.test.js

@@ -0,0 +1,80 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { kinds } from "nostr-tools";
+import { unlockHiddenTags } from "applesauce-core/helpers";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { AddUserToFollowSet, RemoveUserFromFollowSet } from "../follow-sets.js";
+const user = new FakeUser();
+const testPubkey = "test-pubkey";
+const testIdentifier = "test-list";
+let events;
+let factory;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    hub = new ActionHub(events, factory);
+    // Add a follow set event to work with
+    const followSet = user.event({
+        kind: kinds.Followsets,
+        tags: [["d", testIdentifier]],
+        content: "",
+        created_at: Math.floor(Date.now() / 1000),
+    });
+    events.add(followSet);
+});
+describe("AddUserToList", () => {
+    it("should add a pubkey to public tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(AddUserToFollowSet, testPubkey, testIdentifier), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(emittedEvent).toMatchObject({
+            kind: kinds.Followsets,
+            tags: expect.arrayContaining([
+                ["d", testIdentifier],
+                ["p", testPubkey],
+            ]),
+        });
+    });
+    it("should add a pubkey to hidden tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(AddUserToFollowSet, testPubkey, testIdentifier, true), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(await unlockHiddenTags(emittedEvent, user)).toEqual(expect.arrayContaining([["p", testPubkey]]));
+    });
+});
+describe("RemoveUserFromList", () => {
+    beforeEach(async () => {
+        // Add a follow set with existing tags to remove
+        const followSetWithTags = user.event({
+            kind: kinds.Followsets,
+            tags: [
+                ["d", testIdentifier],
+                ["p", testPubkey],
+            ],
+            content: await user.nip04.encrypt(user.pubkey, JSON.stringify(["p", testPubkey])),
+            created_at: Math.floor(Date.now() / 1000),
+        });
+        events.add(followSetWithTags);
+    });
+    it("should remove a pubkey from public tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(RemoveUserFromFollowSet, testPubkey, testIdentifier), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(emittedEvent).toMatchObject({
+            kind: kinds.Followsets,
+            tags: expect.not.arrayContaining([["p", testPubkey]]),
+        });
+    });
+    it("should remove a pubkey from hidden tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(RemoveUserFromFollowSet, testPubkey, testIdentifier, true), {
+            expectErrors: false,
+        });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(await unlockHiddenTags(emittedEvent, user)).toEqual(expect.not.arrayContaining([["hidden", "p", testPubkey]]));
+    });
+});

package/dist/actions/__tests__/mute.test.d.ts

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

package/dist/actions/__tests__/mute.test.js

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { kinds } from "nostr-tools";
+import { getMutedThings, getHiddenMutedThings } from "applesauce-core/helpers";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { MuteThread, UnmuteThread } from "../mute.js";
+const user = new FakeUser();
+const testEventId = "test-event-id";
+let events;
+let factory;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    hub = new ActionHub(events, factory);
+    // Add a mute list event to work with
+    const muteList = user.event({
+        kind: kinds.Mutelist,
+        tags: [],
+        content: "",
+        created_at: Math.floor(Date.now() / 1000),
+    });
+    events.add(muteList);
+});
+describe("MuteThread", () => {
+    it("should add an event to public tags in mute list", async () => {
+        const spy = subscribeSpyTo(hub.exec(MuteThread, testEventId), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const mutedThings = getMutedThings(emittedEvent);
+        expect(mutedThings.threads).toContain(testEventId);
+    });
+    it("should add an event to hidden tags in mute list", async () => {
+        const spy = subscribeSpyTo(hub.exec(MuteThread, testEventId, true), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const hiddenMutedThings = await getHiddenMutedThings(emittedEvent);
+        expect(hiddenMutedThings?.threads).toContain(testEventId);
+    });
+});
+describe("UnmuteThread", () => {
+    it("should remove an event from public tags in mute list", async () => {
+        // First add the thread to mute list
+        const addSpy = subscribeSpyTo(hub.exec(MuteThread, testEventId), { expectErrors: false });
+        await addSpy.onComplete();
+        // Then unmute it
+        const spy = subscribeSpyTo(hub.exec(UnmuteThread, testEventId), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const mutedThings = getMutedThings(emittedEvent);
+        expect(mutedThings.threads).not.toContain(testEventId);
+    });
+    it("should remove an event from hidden tags in mute list", async () => {
+        // First add the thread to hidden mute list
+        const addSpy = subscribeSpyTo(hub.exec(MuteThread, testEventId, true), { expectErrors: false });
+        await addSpy.onComplete();
+        // Then unmute it
+        const spy = subscribeSpyTo(hub.exec(UnmuteThread, testEventId, true), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const hiddenMutedThings = await getHiddenMutedThings(emittedEvent);
+        expect(hiddenMutedThings?.threads).not.toContain(testEventId);
+    });
+});

package/dist/helpers/observable.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from "rxjs";
+/** Subscribes to an observable, send all the values to a method and unsubscribes when complete */
+export declare function play<T extends unknown = unknown>(stream: Observable<T>, method: (value: T) => void): Promise<void>;

package/dist/helpers/observable.js

@@ -0,0 +1,20 @@
+/** Subscribes to an observable, send all the values to a method and unsubscribes when complete */
+export function play(stream, method) {
+    return new Promise((resolve, reject) => {
+        const sub = stream.subscribe({
+            next: (v) => {
+                try {
+                    method(v);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            },
+            error: (error) => reject(error),
+            complete: () => {
+                sub.unsubscribe();
+                resolve();
+            },
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-actions",
-  "version": "0.0.0-next-20250808173123",
+  "version": "0.0.0-next-20250828144630",
   "description": "A package for performing common nostr actions",
   "type": "module",
   "main": "dist/index.js",
@@ -32,15 +32,15 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "0.0.0-next-20250808173123",
-    "applesauce-factory": "0.0.0-next-20250808173123",
-    "nostr-tools": "^2.13",
+    "applesauce-core": "0.0.0-next-20250828144630",
+    "applesauce-factory": "0.0.0-next-20250828144630",
+    "nostr-tools": "~2.15",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
-    "applesauce-signers": "0.0.0-next-20250808173123",
+    "applesauce-signers": "0.0.0-next-20250828144630",
     "nanoid": "^5.1.5",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3"