applesauce-core 0.0.0-next-20250918142212 → 0.0.0-next-20250919114711

package/dist/helpers/mailboxes.d.ts

@@ -1,11 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 export declare const MailboxesInboxesSymbol: unique symbol;
 export declare const MailboxesOutboxesSymbol: unique symbol;
-/**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export declare function getInboxes(event: NostrEvent): string[];
-/**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export declare function getOutboxes(event: NostrEvent): string[];

package/dist/helpers/mailboxes.js

@@ -1,41 +1,47 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
+import { isRTag } from "./tags.js";
 import { normalizeURL } from "./url.js";
 export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
 export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
-/**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export function getInboxes(event) {
     return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
         const inboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !inboxes.includes(url) &&
-                (mode === "read" || mode === undefined)) {
-                inboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [, url, mode] = tag;
+                if (url && isSafeRelayURL(url) && !inboxes.includes(url) && (mode === "read" || mode === undefined)) {
+                    inboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return inboxes;
     });
 }
-/**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export function getOutboxes(event) {
     return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
         const outboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !outboxes.includes(url) &&
-                (mode === "write" || mode === undefined)) {
-                outboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [name, url, mode] = tag;
+                if (name === "r" &&
+                    isSafeRelayURL(url) &&
+                    !outboxes.includes(url) &&
+                    (mode === "write" || mode === undefined)) {
+                    outboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return outboxes;

package/dist/helpers/pointers.js

@@ -5,6 +5,7 @@ import { isAddressableKind } from "nostr-tools/kinds";
 import { isSafeRelayURL, mergeRelaySets } from "./relays.js";
 import { isHexKey } from "./string.js";
 import { hexToBytes } from "@noble/hashes/utils";
+import { normalizeURL } from "./url.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] ? parseInt(parts[0]) : undefined;
@@ -117,7 +118,7 @@ export function getProfilePointerFromPTag(tag) {
         throw new Error("Invalid pubkey");
     const pointer = { pubkey: tag[1] };
     if (tag[2] && isSafeRelayURL(tag[2]))
-        pointer.relays = [tag[2]];
+        pointer.relays = [normalizeURL(tag[2])];
     return pointer;
 }
 /** Checks if a pointer is an AddressPointer */

package/dist/helpers/relay-selection.d.ts

@@ -2,18 +2,12 @@ import { ProfilePointer } from "nostr-tools/nip19";
 export type SelectOptimalRelaysOptions = {
     /** Maximum number of connections (relays) to select */
     maxConnections: number;
-    /** Maximum coverage percentage a single relay can have (0-100 default 50) */
-    maxRelayCoverage?: number;
-    /** Maximum number of relays per user (default 8) */
+    /** Cap the number of relays a user can have */
     maxRelaysPerUser?: number;
-    /** Minimum number of relays per user (default 2) */
-    minRelaysPerUser?: number;
 };
 /** Selects the optimal relays for a list of ProfilePointers */
-export declare function selectOptimalRelays(users: ProfilePointer[], { maxConnections, maxRelayCoverage, maxRelaysPerUser, minRelaysPerUser }: SelectOptimalRelaysOptions): ProfilePointer[];
-/** Sorts each ProfilePointer's relays by popularity */
-export declare function sortRelaysByPopularity(users: ProfilePointer[]): ProfilePointer[];
+export declare function selectOptimalRelays(users: ProfilePointer[], { maxConnections, maxRelaysPerUser }: SelectOptimalRelaysOptions): ProfilePointer[];
 /** A map of pubkeys by relay */
-export type OutboxMap = Record<string, string[]>;
+export type OutboxMap = Record<string, ProfilePointer[]>;
 /** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
 export declare function groupPubkeysByRelay(pointers: ProfilePointer[]): OutboxMap;

package/dist/helpers/relay-selection.js

@@ -1,111 +1,72 @@
-import { logger } from "../logger.js";
-const log = logger.extend("relay-selection");
 /** Selects the optimal relays for a list of ProfilePointers */
-export function selectOptimalRelays(users, { maxConnections, maxRelayCoverage = 50, maxRelaysPerUser, minRelaysPerUser }) {
-    if (!users.length)
-        return [];
-    // Initialize result array and tracking structures
-    const result = [];
-    const selectedRelays = new Set();
-    const relayUserCounts = new Map();
-    const totalUsers = users.length;
-    const maxUsersPerRelay = Math.ceil((totalUsers * maxRelayCoverage) / 100);
-    // Process each user to select optimal relays
-    for (const user of users) {
-        const userRelays = [];
-        const availableRelays = user.relays || [];
-        // If user has no relays, add them with empty relays
-        if (availableRelays.length === 0) {
-            result.push({ ...user, relays: [] });
+export function selectOptimalRelays(users, { maxConnections, maxRelaysPerUser }) {
+    const usersWithRelays = users.filter((user) => user.relays && user.relays.length > 0);
+    // create map of popular relays
+    const popular = new Map();
+    for (const user of usersWithRelays) {
+        if (!user.relays)
             continue;
-        }
-        // Try to select relays for this user, respecting priority order
-        let attempts = 0;
-        const maxAttempts = availableRelays.length * 2; // Prevent infinite loops
-        while (userRelays.length < (maxRelaysPerUser || availableRelays.length) &&
-            selectedRelays.size < maxConnections &&
-            attempts < maxAttempts) {
-            attempts++;
-            let foundRelay = false;
-            // Try each relay in priority order (first = highest priority)
-            for (const relay of availableRelays) {
-                // Skip if we already selected this relay for this user
-                if (userRelays.includes(relay))
-                    continue;
-                // Check if this relay would exceed coverage limit
-                const currentRelayUsers = relayUserCounts.get(relay) || 0;
-                if (currentRelayUsers >= maxUsersPerRelay)
-                    continue;
-                // Select this relay
-                userRelays.push(relay);
-                selectedRelays.add(relay);
-                relayUserCounts.set(relay, currentRelayUsers + 1);
-                foundRelay = true;
-                // Stop if we've reached maxRelaysPerUser for this user
-                if (maxRelaysPerUser && userRelays.length >= maxRelaysPerUser)
-                    break;
-                // Stop if we've reached maxConnections globally
-                if (selectedRelays.size >= maxConnections)
-                    break;
-            }
-            // If we couldn't find any more suitable relays, break
-            if (!foundRelay)
-                break;
-        }
-        // Ensure minimum relays per user if specified
-        if (minRelaysPerUser && userRelays.length < minRelaysPerUser) {
-            // Try to add more relays even if they exceed coverage limits
-            let minAttempts = 0;
-            const maxMinAttempts = availableRelays.length;
-            while (userRelays.length < minRelaysPerUser && minAttempts < maxMinAttempts) {
-                minAttempts++;
-                for (const relay of availableRelays) {
-                    if (userRelays.includes(relay))
-                        continue;
-                    if (selectedRelays.size >= maxConnections)
-                        break;
-                    userRelays.push(relay);
-                    selectedRelays.add(relay);
-                    relayUserCounts.set(relay, (relayUserCounts.get(relay) || 0) + 1);
-                    if (userRelays.length >= minRelaysPerUser)
-                        break;
-                }
-                if (selectedRelays.size >= maxConnections)
-                    break;
-            }
-        }
-        // Add user with selected relays (maintaining original relay order)
-        const finalRelays = availableRelays.filter((relay) => userRelays.includes(relay));
-        result.push({ ...user, relays: finalRelays });
+        for (const relay of user.relays)
+            popular.set(relay, (popular.get(relay) || 0) + 1);
     }
-    log(`Selected ${selectedRelays.size} relays for ${result.length} users`);
-    log(`Relay distribution:`, Array.from(relayUserCounts.entries()));
-    return result;
-}
-/** Sorts each ProfilePointer's relays by popularity */
-export function sortRelaysByPopularity(users) {
-    const relayUsageCount = new Map();
-    // Count the times the relays are used
-    for (const user of users) {
+    // sort users relays by popularity
+    for (const user of usersWithRelays) {
         if (!user.relays)
             continue;
-        for (const relay of user.relays) {
-            relayUsageCount.set(relay, (relayUsageCount.get(relay) || 0) + 1);
+        user.relays = Array.from(user.relays).sort((a, b) => popular.get(b) - popular.get(a));
+    }
+    // Create a pool of users to calculate relay coverage from
+    let selectionPool = Array.from(usersWithRelays);
+    // Create map of times a users relay has been selected
+    const selectionCount = new Map();
+    let selection = new Set();
+    while (selectionPool.length > 0 && selection.size < maxConnections) {
+        // Create map of number of pool users per relay
+        const relayUserCount = new Map();
+        for (const user of selectionPool) {
+            if (!user.relays)
+                continue;
+            for (const relay of user.relays) {
+                // Skip relays that are already selected
+                if (selection.has(relay))
+                    continue;
+                // Increment relay user count
+                relayUserCount.set(relay, (relayUserCount.get(relay) || 0) + 1);
+            }
         }
+        // Sort relays by coverage
+        const byCoverage = Array.from(relayUserCount.entries()).sort((a, b) => b[1] - a[1]);
+        // No more relays to select, exit loop
+        if (byCoverage.length === 0)
+            break;
+        // Pick the most popular relay
+        const relay = byCoverage[0][0];
+        // Add relay to selection
+        selection.add(relay);
+        // Increment user relay count and remove users over the limit
+        selectionPool = selectionPool.filter((user) => {
+            // Ignore users that don't have the relay
+            if (!user.relays || !user.relays.includes(relay))
+                return true;
+            // Increment user relay count
+            let count = selectionCount.get(relay) || 0;
+            selectionCount.set(relay, count++);
+            // Remove user if they their relay has been selected more than minRelaysPerUser times
+            if (count >= 1)
+                return false;
+            return true;
+        });
     }
-    return users.map((user) => {
-        if (!user.relays)
-            return user;
-        // Sort the user's relays by popularity
-        return {
-            ...user,
-            relays: user.relays.sort((a, b) => {
-                const countA = relayUsageCount.get(a) || 0;
-                const countB = relayUsageCount.get(b) || 0;
-                return countB - countA;
-            }),
-        };
-    });
+    // Take the original users and only include relays that where selected
+    return users.map((user) => ({
+        ...user,
+        relays: maxRelaysPerUser
+            ? user.relays
+                ?.filter((relay) => selection.has(relay))
+                .sort((a, b) => (popular.get(a) ?? 0) - (popular.get(b) ?? 0))
+                .slice(0, maxRelaysPerUser)
+            : user.relays?.filter((relay) => selection.has(relay)),
+    }));
 }
 /** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
 export function groupPubkeysByRelay(pointers) {
@@ -116,9 +77,7 @@ export function groupPubkeysByRelay(pointers) {
         for (const relay of pointer.relays) {
             if (!outbox[relay])
                 outbox[relay] = [];
-            if (!outbox[relay].includes(pointer.pubkey)) {
-                outbox[relay].push(pointer.pubkey);
-            }
+            outbox[relay].push(pointer);
         }
     }
     return outbox;

package/dist/helpers/url.js

@@ -78,13 +78,13 @@ export function ensureHttpURL(url) {
  */
 export function normalizeURL(url) {
     let p = new URL(url);
-    // remove any double slashes
+    // Remove any double slashes
     p.pathname = p.pathname.replace(/\/+/g, "/");
-    // drop the port if its not needed
+    // Remove the port if its not needed
     if ((p.port === "80" && (p.protocol === "ws:" || p.protocol === "http:")) ||
         (p.port === "443" && (p.protocol === "wss:" || p.protocol === "https:")))
         p.port = "";
-    // return a string if a string was passed in
+    // Return a string if a string was passed in
     // @ts-expect-error
     return typeof url === "string" ? p.toString() : p;
 }

package/dist/models/outbox.d.ts

@@ -1,7 +1,7 @@
 import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
-import { ignoreBlacklistedRelays } from "../observable/relay-selection.js";
 import { SelectOptimalRelaysOptions } from "../helpers/relay-selection.js";
+import { ignoreBlacklistedRelays } from "../observable/relay-selection.js";
 export type OutboxModelOptions = SelectOptimalRelaysOptions & {
     type?: "inbox" | "outbox";
     blacklist?: Parameters<typeof ignoreBlacklistedRelays>[0];

package/dist/models/outbox.js

@@ -1,7 +1,7 @@
-import { ignoreBlacklistedRelays, includeLegacyAppRelays, includeMailboxes } from "../observable/relay-selection.js";
-import { selectOptimalRelays, sortRelaysByPopularity } from "../helpers/relay-selection.js";
-import { identity, map } from "rxjs";
 import hash_sum from "hash-sum";
+import { identity, map } from "rxjs";
+import { selectOptimalRelays } from "../helpers/relay-selection.js";
+import { ignoreBlacklistedRelays, includeMailboxes } from "../observable/relay-selection.js";
 /** A model that returns the users contacts with the relays to connect to */
 export function OutboxModel(user, opts) {
     return (store) => store.contacts(user).pipe(
@@ -9,21 +9,10 @@ export function OutboxModel(user, opts) {
     opts?.blacklist ? ignoreBlacklistedRelays(opts.blacklist) : identity, 
     /** Include mailboxes */
     includeMailboxes(store, opts.type), 
-    /** Include legacy app relays */
-    includeLegacyAppRelays(store, opts.type), 
-    /** Sort the relays by popularity */
-    map(sortRelaysByPopularity), 
     /** Select the optimal relays */
     map((users) => selectOptimalRelays(users, opts)));
 }
 OutboxModel.getKey = (user, opts) => {
     const p = typeof user === "string" ? user : user.pubkey;
-    return hash_sum([
-        p,
-        opts.type,
-        opts.maxConnections,
-        opts.maxRelayCoverage,
-        opts.maxRelaysPerUser,
-        opts.minRelaysPerUser,
-    ]);
+    return hash_sum([p, opts.type, opts.maxConnections, opts.maxRelaysPerUser]);
 };

package/dist/observable/relay-selection.d.ts

@@ -3,7 +3,5 @@ import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction }
 import { IEventSubscriptions } from "../event-store/interface.js";
 /** RxJS operator that fetches outboxes for profile pointers from the event store */
 export declare function includeMailboxes(store: IEventSubscriptions, type?: "inbox" | "outbox"): OperatorFunction<ProfilePointer[], ProfilePointer[]>;
-/** An operator that reads and adds the legacy relays from the kind 3 event */
-export declare function includeLegacyAppRelays(store: IEventSubscriptions, type?: "inbox" | "outbox"): OperatorFunction<ProfilePointer[], ProfilePointer[]>;
 /** Removes blacklisted relays from the user's relays */
 export declare function ignoreBlacklistedRelays(blacklist: string[] | Observable<string[]>): MonoTypeOperatorFunction<ProfilePointer[]>;

package/dist/observable/relay-selection.js

@@ -1,76 +1,34 @@
-import { combineLatest, combineLatestWith, defaultIfEmpty, EMPTY, map, of, pipe, switchMap, timeout, } from "rxjs";
-import { getRelaysFromContactsEvent } from "../helpers/contacts.js";
+import { combineLatest, combineLatestWith, isObservable, map, of, pipe, switchMap, } from "rxjs";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 import { addRelayHintsToPointer } from "../helpers/pointers.js";
-import { defined } from "./defined.js";
-import { logger } from "../logger.js";
-const log = logger.extend("relay-selection");
 /** RxJS operator that fetches outboxes for profile pointers from the event store */
 export function includeMailboxes(store, type = "outbox") {
     // Get the outboxes for all contacts
-    return switchMap((contacts) => combineLatest(contacts.map((contact) => 
-    // Get the outboxes for the contact
+    return switchMap((contacts) => combineLatest(contacts.map((user) => 
+    // Subscribe to the outboxes for the user
     store
         .replaceable({
         kind: 10002,
-        pubkey: contact.pubkey,
-        relays: contact.relays,
+        pubkey: user.pubkey,
     })
         .pipe(
-    // Wait for the event to be defined
-    defined(), 
-    // Merge the outboxes into the pointer
+    // Add the relays to the user
     map((event) => {
+        if (!event)
+            return user;
+        // Get the relays from the event
         const relays = type === "outbox" ? getOutboxes(event) : getInboxes(event);
         if (!relays)
-            return contact;
-        return addRelayHintsToPointer(contact, relays);
-    }), 
-    // Timeout the request if it takes too long
-    timeout({ first: 5_000, with: () => EMPTY }), 
-    // If no event is found, return the contact
-    defaultIfEmpty(contact)))));
-}
-/** An operator that reads and adds the legacy relays from the kind 3 event */
-export function includeLegacyAppRelays(store, type = "outbox") {
-    return switchMap((users) => {
-        // Get the relays for all contacts
-        return combineLatest(users.map((contact) => {
-            // If the contact already has relays don't add any
-            if (contact.relays && contact.relays.length > 0)
-                return of(contact);
-            // Get the relays for the contact
-            return store
-                .replaceable({
-                kind: 1003,
-                pubkey: contact.pubkey,
-                relays: contact.relays,
-            })
-                .pipe(defined(), 
-            // Merge the relays into the pointer
-            map((event) => {
-                let relays = getRelaysFromContactsEvent(event);
-                if (!relays)
-                    return contact;
-                // Get the write relays
-                const urls = Array.from(relays.entries())
-                    .filter(([_, t]) => t === type || t === "all")
-                    .map(([relay]) => relay);
-                log(`Found ${urls.length} legacy ${type} relays for ${contact.pubkey}`);
-                return addRelayHintsToPointer(contact, urls);
-            }), 
-            // Timeout the request if it takes too long
-            timeout({ first: 5_000, with: () => EMPTY }), 
-            // If no event is found, return the contact
-            defaultIfEmpty(contact));
-        }));
-    });
+            return user;
+        // Add the relays to the user
+        return addRelayHintsToPointer(user, relays);
+    })))));
 }
 /** Removes blacklisted relays from the user's relays */
 export function ignoreBlacklistedRelays(blacklist) {
     return pipe(
     // Combine with the observable so it re-emits when the blacklist changes
-    combineLatestWith(Array.isArray(blacklist) ? of(blacklist) : blacklist), 
+    combineLatestWith(isObservable(blacklist) ? blacklist : of(blacklist)), 
     // Filter the relays for the user
     map(([users, blacklist]) => users.map((user) => {
         if (!user.relays)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250918142212",
+  "version": "0.0.0-next-20250919114711",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -71,6 +71,7 @@
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
+    "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },
@@ -79,6 +80,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__/exports.test.d.ts

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

package/dist/__tests__/exports.test.js

@@ -1,27 +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(`
-      [
-        "EventSet",
-        "EventStore",
-        "EventStoreSymbol",
-        "Helpers",
-        "Models",
-        "TimeoutError",
-        "defined",
-        "firstValueFrom",
-        "getObservableValue",
-        "lastValueFrom",
-        "logger",
-        "mapEventsToStore",
-        "mapEventsToTimeline",
-        "simpleTimeout",
-        "watchEventUpdates",
-        "watchEventsUpdates",
-        "withImmediateValueOrDefault",
-      ]
-    `);
-    });
-});

package/dist/__tests__/fixtures.d.ts

@@ -1,17 +0,0 @@
-import type { NostrEvent } from "nostr-tools";
-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,28 +0,0 @@
-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,
-            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 });
-    }
-}

package/dist/event-store/__tests__/event-store.test.d.ts

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