applesauce-core 5.2.0 → 6.0.2

package/dist/operations/event.d.ts

@@ -1,5 +1,5 @@
-import { EventOperation } from "../event-factory/types.js";
-import { EventTemplate, NostrEvent, UnsignedEvent } from "../helpers/event.js";
+import type { EventOperation } from "../factories/types.js";
+import { EventTemplate, KnownEvent, KnownEventTemplate, KnownUnsignedEvent, NostrEvent, UnsignedEvent } from "../helpers/event.js";
 /** An operation that removes the signature from the event template */
 export declare function stripSignature<Input extends NostrEvent | UnsignedEvent | EventTemplate>(): EventOperation<Input, Omit<Input, "sig">>;
 /** An operation that removes the id and pubkey from the event template */
@@ -29,11 +29,13 @@ export type MetaTagOptions = {
 export declare function setMetaTags(options?: MetaTagOptions): EventOperation;
 /**
  * An operation that adds the signers pubkey to the event
+ * @param signer - Optional EventSigner (throws if not provided)
  * @throws {Error} if no signer is provided
  */
-export declare function stamp(): EventOperation<EventTemplate, UnsignedEvent>;
+export declare function stamp<K extends number = number>(signer?: import("../factories/types.js").EventSigner): EventOperation<KnownEventTemplate<K>, KnownUnsignedEvent<K>>;
 /**
  * An operation that signs the event
+ * @param signer - Optional EventSigner (throws if not provided)
  * @throws {Error} if no signer is provided
  */
-export declare function sign(): EventOperation<EventTemplate | UnsignedEvent, NostrEvent>;
+export declare function sign<K extends number = number, T extends KnownEventTemplate<K> = KnownEventTemplate<K>>(signer?: import("../factories/types.js").EventSigner): EventOperation<T, KnownEvent<K>>;

package/dist/operations/event.js

@@ -1,12 +1,12 @@
 import { nanoid } from "nanoid";
-import { getTagValue } from "../helpers/event.js";
-import { isAddressableKind } from "../helpers/event.js";
+import { isKind } from "nostr-tools/kinds";
+import { EncryptedContentSymbol } from "../helpers/encrypted-content.js";
+import { getTagValue, isAddressableKind, } from "../helpers/event.js";
 import { eventPipe, skip } from "../helpers/pipeline.js";
 import { ensureSingletonTag } from "../helpers/tags.js";
 import { unixNow } from "../helpers/time.js";
 import { removeSingletonTag, setSingletonTag } from "./tag/common.js";
 import { includeSingletonTag, modifyPublicTags } from "./tags.js";
-import { EncryptedContentSymbol } from "../helpers/encrypted-content.js";
 /** An operation that removes the signature from the event template */
 export function stripSignature() {
     return (draft) => {
@@ -72,16 +72,17 @@ export function setMetaTags(options) {
 }
 /**
  * An operation that adds the signers pubkey to the event
+ * @param signer - Optional EventSigner (throws if not provided)
  * @throws {Error} if no signer is provided
  */
-export function stamp() {
-    return async (draft, ctx) => {
-        if (!ctx.signer)
+export function stamp(signer) {
+    return async (draft) => {
+        if (!signer)
             throw new Error("Missing signer");
         // Remove old fields from signed nostr event
         Reflect.deleteProperty(draft, "id");
         Reflect.deleteProperty(draft, "sig");
-        const pubkey = await ctx.signer.getPublicKey();
+        const pubkey = await signer.getPublicKey();
         const newDraft = { ...draft, pubkey };
         // copy the plaintext hidden content if its on the draft
         if (Reflect.has(draft, EncryptedContentSymbol))
@@ -91,14 +92,21 @@ export function stamp() {
 }
 /**
  * An operation that signs the event
+ * @param signer - Optional EventSigner (throws if not provided)
  * @throws {Error} if no signer is provided
  */
-export function sign() {
-    return async (draft, ctx) => {
-        if (!ctx.signer)
+export function sign(signer) {
+    return async (draft) => {
+        if (!signer)
             throw new Error("Missing signer");
-        draft = await stamp()(draft, ctx);
-        const signed = await ctx.signer.signEvent(draft);
+        const unsigned = await stamp(signer)(draft);
+        const signed = await signer.signEvent(unsigned);
+        // Verify the pubkey has not changed
+        if (Reflect.has(draft, "pubkey") && Reflect.get(draft, "pubkey") !== signed.pubkey)
+            throw new Error("Signer modified pubkey");
+        // If its the same kind, return the signed event
+        if (!isKind(signed, draft.kind))
+            throw new Error("Signer modified event kind");
         // copy the plaintext hidden content if its on the draft
         if (Reflect.has(draft, EncryptedContentSymbol))
             Reflect.set(signed, EncryptedContentSymbol, Reflect.get(draft, EncryptedContentSymbol));

package/dist/operations/hidden-content.d.ts

@@ -1,4 +1,9 @@
-import { EventOperation } from "../event-factory/types.js";
+import type { EventOperation } from "../factories/types.js";
 import { EncryptionMethod } from "../helpers/encrypted-content.js";
-/** Sets the hidden content on an event */
-export declare function setHiddenContent(content: string, override?: EncryptionMethod): EventOperation;
+/**
+ * Sets the hidden content on an event
+ * @param content - Plaintext content to encrypt
+ * @param signer - EventSigner for encryption
+ * @param override - Optional encryption method override
+ */
+export declare function setHiddenContent(content: string, signer?: import("../factories/types.js").EventSigner, override?: EncryptionMethod): EventOperation;

package/dist/operations/hidden-content.js

@@ -1,10 +1,15 @@
 import { setEncryptedContent } from "./encrypted-content.js";
-/** Sets the hidden content on an event */
-export function setHiddenContent(content, override) {
-    return async (draft, ctx) => {
-        if (!ctx.signer)
+/**
+ * Sets the hidden content on an event
+ * @param content - Plaintext content to encrypt
+ * @param signer - EventSigner for encryption
+ * @param override - Optional encryption method override
+ */
+export function setHiddenContent(content, signer, override) {
+    return async (draft) => {
+        if (!signer)
             throw new Error("Signer required for encrypted content");
-        const pubkey = await ctx.signer.getPublicKey();
-        return setEncryptedContent(pubkey, content, override)(draft, ctx);
+        const pubkey = await signer.getPublicKey();
+        return setEncryptedContent(pubkey, content, signer, override)(draft);
     };
 }

package/dist/operations/mailboxes.d.ts

@@ -1,4 +1,4 @@
-import { EventOperation } from "../event-factory/types.js";
+import type { EventOperation } from "../factories/types.js";
 /** Add an outbox relay in NIP-65 mailboxes */
 export declare function addOutboxRelay(url: string | URL): EventOperation;
 /** Remove an outbox relay in NIP-65 mailboxes */
@@ -11,3 +11,7 @@ export declare function removeInboxRelay(url: string | URL): EventOperation;
 export declare function addMailboxRelay(url: string | URL): EventOperation;
 /** Completely removes a mailbox relay from NIP-65 */
 export declare function removeMailboxRelay(url: string | URL): EventOperation;
+/** Sets all inbox relays, replacing existing ones while preserving outbox dimension */
+export declare function setInboxRelays(urls: (string | URL)[]): EventOperation;
+/** Sets all outbox relays, replacing existing ones while preserving inbox dimension */
+export declare function setOutboxRelays(urls: (string | URL)[]): EventOperation;

package/dist/operations/mailboxes.js

@@ -78,3 +78,79 @@ export function addMailboxRelay(url) {
 export function removeMailboxRelay(url) {
     return modifyPublicTags(removeRelayTag(url, "r"));
 }
+/** Sets all inbox relays, replacing existing ones while preserving outbox dimension */
+export function setInboxRelays(urls) {
+    const normalizedUrls = urls.map((url) => normalizeURL(url).toString());
+    return modifyPublicTags((tags) => {
+        // Step 1: Remove all "read" markers from existing relays
+        const withoutInboxes = tags
+            .map((tag) => {
+            if (!isRTag(tag))
+                return tag;
+            // Remove inbox-only relays (read marker)
+            if (tag[2] === "read")
+                return null;
+            // Convert both (no marker) to outbox-only (write marker)
+            if (tag[2] === undefined)
+                return ["r", tag[1], "write"];
+            // Keep outbox-only relays (write marker) as is
+            return tag;
+        })
+            .filter((t) => t !== null);
+        // Step 2: Add "read" markers to the specified URLs
+        const result = [...withoutInboxes];
+        for (const url of normalizedUrls) {
+            const existingIndex = result.findIndex((t) => isRTag(t) && isSameURL(t[1], url));
+            if (existingIndex >= 0) {
+                const existing = result[existingIndex];
+                // Convert outbox-only (write) to both (no marker)
+                if (existing[2] === "write") {
+                    result[existingIndex] = ["r", url];
+                }
+            }
+            else {
+                // Add as inbox-only (read marker)
+                result.push(["r", url, "read"]);
+            }
+        }
+        return result;
+    });
+}
+/** Sets all outbox relays, replacing existing ones while preserving inbox dimension */
+export function setOutboxRelays(urls) {
+    const normalizedUrls = urls.map((url) => normalizeURL(url).toString());
+    return modifyPublicTags((tags) => {
+        // Step 1: Remove all "write" markers from existing relays
+        const withoutOutboxes = tags
+            .map((tag) => {
+            if (!isRTag(tag))
+                return tag;
+            // Remove outbox-only relays (write marker)
+            if (tag[2] === "write")
+                return null;
+            // Convert both (no marker) to inbox-only (read marker)
+            if (tag[2] === undefined)
+                return ["r", tag[1], "read"];
+            // Keep inbox-only relays (read marker) as is
+            return tag;
+        })
+            .filter((t) => t !== null);
+        // Step 2: Add "write" markers to the specified URLs
+        const result = [...withoutOutboxes];
+        for (const url of normalizedUrls) {
+            const existingIndex = result.findIndex((t) => isRTag(t) && isSameURL(t[1], url));
+            if (existingIndex >= 0) {
+                const existing = result[existingIndex];
+                // Convert inbox-only (read) to both (no marker)
+                if (existing[2] === "read") {
+                    result[existingIndex] = ["r", url];
+                }
+            }
+            else {
+                // Add as outbox-only (write marker)
+                result.push(["r", url, "write"]);
+            }
+        }
+        return result;
+    });
+}

package/dist/operations/profile.d.ts

@@ -1,4 +1,4 @@
-import { EventOperation } from "../event-factory/types.js";
+import type { EventOperation } from "../factories/types.js";
 import { ProfileContent } from "../helpers/index.js";
 /** Sets the content of a kind 0 metadata event */
 export declare function setProfile(content: ProfileContent): EventOperation;

package/dist/operations/tag/common.d.ts

@@ -1,16 +1,31 @@
 import { NostrEvent } from "nostr-tools";
-import { TagOperation } from "../../event-factory/types.js";
+import type { TagOperation } from "../../factories/types.js";
 import { AddressPointer, EventPointer, ProfilePointer } from "../../helpers/pointers.js";
-/** Adds a single "p" tag for a ProfilePointer */
-export declare function addProfilePointerTag(pubkey: string | ProfilePointer, replace?: boolean): TagOperation;
+/**
+ * Adds a single "p" tag for a ProfilePointer
+ * @param pubkey - Pubkey string or ProfilePointer object
+ * @param relayHint - Optional relay hint (string) or function to get relay hint
+ * @param replace - If true, removes existing "p" tags for this pubkey
+ */
+export declare function addProfilePointerTag(pubkey: string | ProfilePointer, relayHint?: string | ((pubkey: string) => Promise<string | undefined>), replace?: boolean): TagOperation;
 /** Removes all "p" tags matching a pubkey */
 export declare function removeProfilePointerTag(pubkey: string | ProfilePointer): TagOperation;
-/** Adds a single "e" tag for an EventPointer */
-export declare function addEventPointerTag(id: string | EventPointer | NostrEvent, replace?: boolean): TagOperation;
+/**
+ * Adds a single "e" tag for an EventPointer
+ * @param id - Event ID string, EventPointer object, or NostrEvent
+ * @param relayHint - Optional relay hint (string) or function to get relay hint
+ * @param replace - If true, removes existing "e" tags for this event ID
+ */
+export declare function addEventPointerTag(id: string | EventPointer | NostrEvent, relayHint?: string | ((eventId: string) => Promise<string | undefined>), replace?: boolean): TagOperation;
 /** Removes all "e" tags matching EventPointer or id */
 export declare function removeEventPointerTag(id: string | EventPointer): TagOperation;
-/** Adds a single "a" tag based on an AddressPointer */
-export declare function addAddressPointerTag(address: string | AddressPointer | NostrEvent, replace?: boolean): TagOperation;
+/**
+ * Adds a single "a" tag based on an AddressPointer
+ * @param address - Address string, AddressPointer object, or NostrEvent
+ * @param relayHint - Optional relay hint (string) or function to get relay hint
+ * @param replace - If true, removes existing "a" tags for this address
+ */
+export declare function addAddressPointerTag(address: string | AddressPointer | NostrEvent, relayHint?: string | ((pubkey: string) => Promise<string | undefined>), replace?: boolean): TagOperation;
 /** Removes all "a" tags for address pointer */
 export declare function removeAddressPointerTag(address: string | AddressPointer | NostrEvent): TagOperation;
 /** Adds a name / value tag */

package/dist/operations/tag/common.js

@@ -2,13 +2,18 @@ import { createATagFromAddressPointer, createETagFromEventPointer, createPTagFro
 import { getAddressPointerForEvent, getEventPointerForEvent, getReplaceableAddressFromPointer, parseReplaceableAddress, } from "../../helpers/pointers.js";
 import { ensureNamedValueTag, ensureSingletonTag } from "../../helpers/tags.js";
 import { getReplaceableAddress, isEvent, skip } from "../../helpers/index.js";
-/** Adds a single "p" tag for a ProfilePointer */
-export function addProfilePointerTag(pubkey, replace = true) {
-    return async (tags, { getPubkeyRelayHint }) => {
+/**
+ * Adds a single "p" tag for a ProfilePointer
+ * @param pubkey - Pubkey string or ProfilePointer object
+ * @param relayHint - Optional relay hint (string) or function to get relay hint
+ * @param replace - If true, removes existing "p" tags for this pubkey
+ */
+export function addProfilePointerTag(pubkey, relayHint, replace = true) {
+    return async (tags) => {
         const pointer = typeof pubkey === "string" ? { pubkey: pubkey } : { ...pubkey };
-        // add relay hint
-        if (getPubkeyRelayHint && pointer.relays?.[0] === undefined) {
-            const hint = await getPubkeyRelayHint(pointer.pubkey);
+        // add relay hint (hybrid: string or function)
+        if (!pointer.relays?.[0] && relayHint) {
+            const hint = typeof relayHint === "string" ? relayHint : await relayHint(pointer.pubkey);
             if (hint)
                 pointer.relays = [hint];
         }
@@ -24,13 +29,18 @@ export function removeProfilePointerTag(pubkey) {
     pubkey = typeof pubkey !== "string" ? pubkey.pubkey : pubkey;
     return (tags) => tags.filter((t) => !(t[0] === "p" && t[1] === pubkey));
 }
-/** Adds a single "e" tag for an EventPointer */
-export function addEventPointerTag(id, replace = true) {
-    return async (tags, { getEventRelayHint }) => {
+/**
+ * Adds a single "e" tag for an EventPointer
+ * @param id - Event ID string, EventPointer object, or NostrEvent
+ * @param relayHint - Optional relay hint (string) or function to get relay hint
+ * @param replace - If true, removes existing "e" tags for this event ID
+ */
+export function addEventPointerTag(id, relayHint, replace = true) {
+    return async (tags) => {
         const pointer = typeof id === "string" ? { id } : isEvent(id) ? getEventPointerForEvent(id) : id;
-        // add relay hint
-        if (getEventRelayHint && pointer.relays?.[0] === undefined) {
-            const hint = await getEventRelayHint(pointer.id);
+        // add relay hint (hybrid: string or function)
+        if (!pointer.relays?.[0] && relayHint) {
+            const hint = typeof relayHint === "string" ? relayHint : await relayHint(pointer.id);
             if (hint)
                 pointer.relays = [hint];
         }
@@ -46,8 +56,13 @@ export function removeEventPointerTag(id) {
     id = typeof id === "string" ? id : id.id;
     return (tags) => tags.filter((t) => !(t[0] === "e" && t[1] === id));
 }
-/** Adds a single "a" tag based on an AddressPointer */
-export function addAddressPointerTag(address, replace = true) {
+/**
+ * Adds a single "a" tag based on an AddressPointer
+ * @param address - Address string, AddressPointer object, or NostrEvent
+ * @param relayHint - Optional relay hint (string) or function to get relay hint
+ * @param replace - If true, removes existing "a" tags for this address
+ */
+export function addAddressPointerTag(address, relayHint, replace = true) {
     // convert the string into an address pointer object
     const pointer = typeof address === "string"
         ? parseReplaceableAddress(address)
@@ -56,11 +71,11 @@ export function addAddressPointerTag(address, replace = true) {
             : address;
     if (!pointer)
         throw new Error("Unable to resolve address pointer");
-    return async (tags, { getPubkeyRelayHint }) => {
+    return async (tags) => {
         const replaceableAddress = typeof address === "string" ? address : getReplaceableAddressFromPointer(pointer);
-        // add relay hint if there isn't one
-        if (getPubkeyRelayHint && pointer.relays?.[0] === undefined) {
-            const hint = await getPubkeyRelayHint(pointer.pubkey);
+        // add relay hint if there isn't one (hybrid: string or function)
+        if (!pointer.relays?.[0] && relayHint) {
+            const hint = typeof relayHint === "string" ? relayHint : await relayHint(pointer.pubkey);
             if (hint)
                 pointer.relays = [hint];
         }

package/dist/operations/tag/relay.d.ts

@@ -1,4 +1,4 @@
-import { TagOperation } from "../../event-factory/types.js";
+import type { TagOperation } from "../../factories/types.js";
 /** Adds a relay tag */
 export declare function addRelayTag(url: string | URL, tagName?: string, replace?: boolean): TagOperation;
 /** Removes all relay tags matching the relay */

package/dist/operations/tags.d.ts

@@ -1,4 +1,4 @@
-import { EventOperation, TagOperation } from "../event-factory/types.js";
+import type { EventOperation, TagOperation } from "../factories/types.js";
 import { EventTemplate, NostrEvent, UnsignedEvent } from "../helpers/event.js";
 /** Includes only a single instance of tag in an events public tags */
 export declare function includeSingletonTag(tag: [string, ...string[]], replace?: boolean): EventOperation;
@@ -8,13 +8,19 @@ export declare function includeNameValueTag(tag: [string, string, ...string[]],
 export declare function modifyPublicTags<E extends EventTemplate | UnsignedEvent | NostrEvent>(...operations: (TagOperation | undefined)[]): EventOperation<E, E>;
 /**
  * Creates an event operation that modifies the hidden tags on an event with {@link TagOperation}s
+ * @param signer - EventSigner for encrypting/decrypting hidden tags
+ * @param operations - Tag operations to apply to hidden tags
  * @throws {Error} if no signer is provided
  * @throws {Error} if the event kind does not support hidden tags
  */
-export declare function modifyHiddenTags<E extends EventTemplate | UnsignedEvent | NostrEvent>(...operations: (TagOperation | undefined)[]): EventOperation<E, E>;
+export declare function modifyHiddenTags<E extends EventTemplate | UnsignedEvent | NostrEvent>(signer: import("../factories/types.js").EventSigner | undefined, ...operations: (TagOperation | undefined)[]): EventOperation<E, E>;
 export type ModifyTagsOptions = TagOperation | TagOperation[] | {
     public?: TagOperation | TagOperation[];
     hidden?: TagOperation | TagOperation[];
 };
-/** A flexible method for creating an event operation that modifies the tags */
-export declare function modifyTags(tagOperations?: ModifyTagsOptions): EventOperation;
+/**
+ * A flexible method for creating an event operation that modifies the tags
+ * @param tagOperations - Tag operations for public and/or hidden tags
+ * @param signer - Optional signer (required if modifying hidden tags)
+ */
+export declare function modifyTags(tagOperations?: ModifyTagsOptions, signer?: import("../factories/types.js").EventSigner): EventOperation;

package/dist/operations/tags.js

@@ -12,21 +12,23 @@ export function includeNameValueTag(tag, replace = true) {
 }
 /** An event operation that modifies the public tags with {@link TagOperation}s */
 export function modifyPublicTags(...operations) {
-    return async (draft, ctx) => {
-        return { ...draft, tags: await tagPipe(...operations)(Array.from(draft.tags), ctx) };
+    return async (draft) => {
+        return { ...draft, tags: await tagPipe(...operations)(Array.from(draft.tags)) };
     };
 }
 /**
  * Creates an event operation that modifies the hidden tags on an event with {@link TagOperation}s
+ * @param signer - EventSigner for encrypting/decrypting hidden tags
+ * @param operations - Tag operations to apply to hidden tags
  * @throws {Error} if no signer is provided
  * @throws {Error} if the event kind does not support hidden tags
  */
-export function modifyHiddenTags(...operations) {
+export function modifyHiddenTags(signer, ...operations) {
     operations = operations.filter((o) => !!o);
     if (operations.length === 0)
         return skip();
-    return async (draft, ctx) => {
-        if (!ctx.signer)
+    return async (draft) => {
+        if (!signer)
             throw new Error("Missing signer for hidden tags");
         if (!canHaveHiddenTags(draft.kind))
             throw new Error("Event kind does not support hidden tags");
@@ -41,8 +43,8 @@ export function modifyHiddenTags(...operations) {
             if (hidden === undefined) {
                 if (hasHiddenTags(draft)) {
                     // draft is an existing event, attempt to unlock tags
-                    pubkey = await ctx.signer.getPublicKey();
-                    hidden = await unlockHiddenTags({ ...draft, pubkey }, ctx.signer);
+                    pubkey = await signer.getPublicKey();
+                    hidden = await unlockHiddenTags({ ...draft, pubkey }, signer);
                 }
                 // create a new array of hidden tags
                 else
@@ -56,19 +58,23 @@ export function modifyHiddenTags(...operations) {
         if (hidden === undefined)
             throw new Error("Failed to find hidden tags");
         // Create the new hidden tags
-        const tags = await tagPipe(...operations)(hidden, ctx);
+        const tags = await tagPipe(...operations)(hidden);
         // Encrypt new hidden tags
-        const methods = getHiddenTagsEncryptionMethods(draft.kind, ctx.signer);
+        const methods = getHiddenTagsEncryptionMethods(draft.kind, signer);
         if (!pubkey)
-            pubkey = await ctx.signer.getPublicKey();
+            pubkey = await signer.getPublicKey();
         const plaintext = JSON.stringify(tags);
         const content = await methods.encrypt(pubkey, plaintext);
         // add the plaintext content on the draft so it can be carried forward
         return { ...draft, content, [EncryptedContentSymbol]: plaintext };
     };
 }
-/** A flexible method for creating an event operation that modifies the tags */
-export function modifyTags(tagOperations) {
+/**
+ * A flexible method for creating an event operation that modifies the tags
+ * @param tagOperations - Tag operations for public and/or hidden tags
+ * @param signer - Optional signer (required if modifying hidden tags)
+ */
+export function modifyTags(tagOperations, signer) {
     let publicOperations = [];
     let hiddenOperations = [];
     // normalize tag operation arg
@@ -89,5 +95,5 @@ export function modifyTags(tagOperations) {
             hiddenOperations = tagOperations.hidden;
     }
     // return a new event operation that modifies the tags
-    return eventPipe(publicOperations.length > 0 ? modifyPublicTags(...publicOperations) : undefined, hiddenOperations.length > 0 ? modifyHiddenTags(...hiddenOperations) : undefined);
+    return eventPipe(publicOperations.length > 0 ? modifyPublicTags(...publicOperations) : undefined, hiddenOperations.length > 0 ? modifyHiddenTags(signer, ...hiddenOperations) : undefined);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "5.2.0",
+  "version": "6.0.2",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -60,10 +60,15 @@
       "require": "./dist/event-store/index.js",
       "types": "./dist/event-store/index.d.ts"
     },
-    "./event-factory": {
-      "import": "./dist/event-factory/index.js",
-      "require": "./dist/event-factory/index.js",
-      "types": "./dist/event-factory/index.d.ts"
+    "./factories": {
+      "import": "./dist/factories/index.js",
+      "require": "./dist/factories/index.js",
+      "types": "./dist/factories/index.d.ts"
+    },
+    "./factories/*": {
+      "import": "./dist/factories/*.js",
+      "require": "./dist/factories/*.js",
+      "types": "./dist/factories/*.d.ts"
     },
     "./operations": {
       "import": "./dist/operations/index.js",
@@ -74,6 +79,16 @@
       "import": "./dist/operations/*.js",
       "require": "./dist/operations/*.js",
       "types": "./dist/operations/*.d.ts"
+    },
+    "./casts": {
+      "import": "./dist/casts/index.js",
+      "require": "./dist/casts/index.js",
+      "types": "./dist/casts/index.d.ts"
+    },
+    "./casts/*": {
+      "import": "./dist/casts/*.js",
+      "require": "./dist/casts/*.js",
+      "types": "./dist/casts/*.d.ts"
     }
   },
   "dependencies": {

package/dist/event-factory/event-factory.d.ts

@@ -1,57 +0,0 @@
-import { EventTemplate, NostrEvent, UnsignedEvent } from "../helpers/event.js";
-import { ModifyTagsOptions } from "../operations/tags.js";
-import { EventFactoryTemplate } from "./methods.js";
-import { EventBlueprint, EventFactoryContext, EventOperation, IEventFactory } from "./types.js";
-/**
- * Base class that provides event creation functionality.
- * This class can be extended by other packages to add additional helpful event creation methods.
- *
- * @example
- * ```ts
- * // In another package (e.g., applesauce-common)
- * import { EventFactory } from "applesauce-core/event-factory";
- * import { NoteBlueprint, ReactionBlueprint } from "applesauce-common/blueprints";
- *
- * // Add methods to the prototype
- * EventFactory.prototype.note = function(content, options) {
- *   return this.create(NoteBlueprint, content, options);
- * };
- *
- * EventFactory.prototype.reaction = function(event, emoji) {
- *   return this.create(ReactionBlueprint, event, emoji);
- * };
- *
- * // Extend the type via module augmentation
- * declare module "applesauce-core/event-factory" {
- *   interface EventFactory {
- *     note(content: string, options?: NoteBlueprintOptions): Promise<EventTemplate>;
- *     reaction(event: NostrEvent, emoji?: string): Promise<EventTemplate>;
- *   }
- * }
- * ```
- */
-export declare class EventFactory implements IEventFactory {
-    context: EventFactoryContext;
-    constructor(context?: EventFactoryContext);
-    /** Build an event template with operations */
-    build(template: EventFactoryTemplate, ...operations: (EventOperation | undefined)[]): Promise<EventTemplate>;
-    /** Create an event from a blueprint */
-    create<T extends EventTemplate | UnsignedEvent | NostrEvent>(blueprint: EventBlueprint<T>): Promise<T>;
-    create<T extends EventTemplate | UnsignedEvent | NostrEvent, Args extends Array<any>>(blueprint: (...args: Args) => EventBlueprint<T>, ...args: Args): Promise<T>;
-    /** Modify an existing event with operations and updated the created_at */
-    modify(draft: EventTemplate | UnsignedEvent | NostrEvent, ...operations: (EventOperation | undefined)[]): Promise<EventTemplate>;
-    /** Modify a lists public and hidden tags and updated the created_at */
-    modifyTags(event: EventTemplate | UnsignedEvent | NostrEvent, tagOperations?: ModifyTagsOptions, eventOperations?: EventOperation | (EventOperation | undefined)[]): Promise<EventTemplate>;
-    /** Attaches the signers pubkey to an event template */
-    stamp(draft: EventTemplate | UnsignedEvent): Promise<UnsignedEvent>;
-    /** Signs a event template with the signer */
-    sign(draft: EventTemplate | UnsignedEvent): Promise<NostrEvent>;
-    /** Sets the signer in the context */
-    setSigner(signer: EventFactoryContext["signer"]): void;
-    /** clears the signer in the context */
-    clearSigner(): void;
-    /** sets the client in the context */
-    setClient(client: EventFactoryContext["client"]): void;
-    /** clears the client in the context */
-    clearClient(): void;
-}