applesauce-common 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

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

@@ -0,0 +1,14 @@
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+export declare const FAVORITE_RELAYS_KIND = 10012;
+export type FavoriteRelaysListEvent = KnownEvent<typeof FAVORITE_RELAYS_KIND>;
+export type SearchRelaysListEvent = KnownEvent<typeof kinds.SearchRelaysList>;
+export type BlockedRelaysListEvent = KnownEvent<typeof kinds.BlockedRelaysList>;
+export type DMRelaysListEvent = KnownEvent<typeof kinds.DirectMessageRelaysList>;
+/** Validates that an event is a valid favorite relays list (kind 10012) */
+export declare function isValidFavoriteRelaysList(event: NostrEvent): event is FavoriteRelaysListEvent;
+/** Validates that an event is a valid search relays list (kind 10007) */
+export declare function isValidSearchRelaysList(event: NostrEvent): event is SearchRelaysListEvent;
+/** Validates that an event is a valid blocked relays list (kind 10006) */
+export declare function isValidBlockedRelaysList(event: NostrEvent): event is BlockedRelaysListEvent;
+/** Validates that an event is a valid DM relays list (kind 10050) */
+export declare function isValidDirectMessageRelaysList(event: NostrEvent): event is DMRelaysListEvent;

package/dist/helpers/relay-list.js

@@ -0,0 +1,18 @@
+import { kinds } from "applesauce-core/helpers/event";
+export const FAVORITE_RELAYS_KIND = 10012;
+/** Validates that an event is a valid favorite relays list (kind 10012) */
+export function isValidFavoriteRelaysList(event) {
+    return event.kind === FAVORITE_RELAYS_KIND;
+}
+/** Validates that an event is a valid search relays list (kind 10007) */
+export function isValidSearchRelaysList(event) {
+    return event.kind === kinds.SearchRelaysList;
+}
+/** Validates that an event is a valid blocked relays list (kind 10006) */
+export function isValidBlockedRelaysList(event) {
+    return event.kind === kinds.BlockedRelaysList;
+}
+/** Validates that an event is a valid DM relays list (kind 10050) */
+export function isValidDirectMessageRelaysList(event) {
+    return event.kind === kinds.DirectMessageRelaysList;
+}

package/dist/helpers/reports.d.ts

@@ -14,6 +14,7 @@ export type ReportedUser = {
     event: NostrEvent;
     pubkey: string;
     reason?: ReportReason;
+    comment?: string;
 };
 export type ReportedEvent = {
     type: "event";
@@ -25,4 +26,6 @@ export type ReportedEvent = {
     blobs?: string[];
 };
 /** Reads a report event as either a user or event report */
-export declare function getReported(report: NostrEvent): ReportedEvent | ReportedUser;
+export declare function getReported(report: NostrEvent): ReportedEvent | ReportedUser | null;
+/** Gets the server tags from a report event (for blob reports) */
+export declare function getReportServers(report: NostrEvent): string[];

package/dist/helpers/reports.js

@@ -1,5 +1,5 @@
 import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
-import { isETag, isPTag } from "applesauce-core/helpers/tags";
+import { isETag, isNameValueTag, isPTag } from "applesauce-core/helpers/tags";
 export const ParsedReportSymbol = Symbol("parsed-report");
 export var ReportReason;
 (function (ReportReason) {
@@ -14,25 +14,29 @@ export var ReportReason;
 /** Reads a report event as either a user or event report */
 export function getReported(report) {
     return getOrComputeCachedValue(report, ParsedReportSymbol, () => {
-        const p = report.tags.find(isPTag);
-        if (!p)
-            throw new Error("Report missing p tag");
+        const pTag = report.tags.find(isPTag);
+        if (!pTag)
+            return null;
         const comment = report.content ? report.content.trim() : undefined;
-        const e = report.tags.find(isETag);
+        const eTag = report.tags.find(isETag);
         // Event report
-        if (e) {
+        if (eTag) {
             const blobs = report.tags.filter((t) => t[0] === "x" && t[1]).map((t) => t[1]);
             return {
                 type: "event",
                 event: report,
                 comment,
-                id: e[1],
-                pubkey: p[1],
-                reason: e[2],
+                id: eTag[1],
+                pubkey: pTag[1],
+                reason: eTag[2],
                 blobs,
             };
         }
         // User report
-        return { type: "user", event: report, comment, pubkey: p[1], reason: p[2] };
+        return { type: "user", event: report, comment, pubkey: pTag[1], reason: pTag[2] };
     });
 }
+/** Gets the server tags from a report event (for blob reports) */
+export function getReportServers(report) {
+    return report.tags.filter((t) => isNameValueTag(t, "server") && t[1]).map((t) => t[1]);
+}

package/dist/helpers/stream-chat.d.ts

@@ -1,4 +1,7 @@
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { AddressPointer } from "applesauce-core/helpers/pointers";
+export type StreamChatMessageEvent = KnownEvent<kinds.LiveChatMessage>;
+export declare function isValidStreamChatMessage(event: NostrEvent): event is StreamChatMessageEvent;
 /** Returns the pointer to the stream chat message stream */
+export declare function getStreamChatMessageStream(message: StreamChatMessageEvent): AddressPointer;
 export declare function getStreamChatMessageStream(message: NostrEvent): AddressPointer | undefined;

package/dist/helpers/stream-chat.js

@@ -1,6 +1,9 @@
+import { kinds } from "applesauce-core/helpers/event";
 import { getAddressPointerFromATag } from "applesauce-core/helpers/pointers";
 import { isATag } from "applesauce-core/helpers/tags";
-/** Returns the pointer to the stream chat message stream */
+export function isValidStreamChatMessage(event) {
+    return event.kind === kinds.LiveChatMessage && getStreamChatMessageStream(event) !== undefined;
+}
 export function getStreamChatMessageStream(message) {
     const tag = message.tags.find(isATag);
     if (!tag)

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";
 export * as Blueprints from "./blueprints/index.js";
 export * as Observable from "./observable/index.js";
+export * as Casts from "./casts/index.js";
 import "./register.js";

package/dist/index.js

@@ -3,5 +3,6 @@ export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";
 export * as Blueprints from "./blueprints/index.js";
 export * as Observable from "./observable/index.js";
+export * as Casts from "./casts/index.js";
 // Register the common models and blueprints with the event store and event factory
 import "./register.js";

package/dist/models/__register__.d.ts

@@ -0,0 +1,5 @@
+import "./blossom.js";
+import "./mutes.js";
+import "./reactions.js";
+import "./comments.js";
+import "./thread.js";

package/dist/models/__register__.js

@@ -0,0 +1,6 @@
+// Import models that should register with the event store
+import "./blossom.js";
+import "./mutes.js";
+import "./reactions.js";
+import "./comments.js";
+import "./thread.js";

package/dist/models/blossom.d.ts

@@ -2,10 +2,10 @@ import { Model } from "applesauce-core/event-store";
 import { ProfilePointer } from "applesauce-core/helpers/pointers";
 import { type Observable } from "rxjs";
 /** A model that returns a users blossom servers */
-export declare function UserBlossomServersModel(user: string | ProfilePointer): Model<URL[]>;
+export declare function UserBlossomServersModel(user: string | ProfilePointer): Model<URL[] | undefined>;
 declare module "applesauce-core/event-store" {
     interface EventModels {
         /** Subscribe to a users blossom servers */
-        blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+        blossomServers(user: string | ProfilePointer): Observable<URL[] | undefined>;
     }
 }

package/dist/models/blossom.js

@@ -8,7 +8,7 @@ export function UserBlossomServersModel(user) {
         user = { pubkey: user };
     return (store) => store
         .replaceable({ kind: BLOSSOM_SERVER_LIST_KIND, pubkey: user.pubkey, relays: user.relays })
-        .pipe(map((event) => (event ? getBlossomServersFromList(event) : [])));
+        .pipe(map((event) => event && getBlossomServersFromList(event)));
 }
 // Register this model with EventModels
 EventModels.prototype.blossomServers = function (user) {

package/dist/models/bookmarks.d.ts

@@ -1,8 +1,6 @@
 import { Model } from "applesauce-core/event-store";
-import { Bookmarks } from "../helpers/bookmark.js";
+import { BookmarkPointer } from "../helpers/bookmark.js";
 /** A model that returns all the bookmarks of a user */
-export declare function UserBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
-/** A model that returns all the public bookmarks of a user */
-export declare function UserPublicBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
+export declare function UserBookmarkModel(pubkey: string): Model<BookmarkPointer[] | undefined>;
 /** A model that returns all the hidden bookmarks of a user */
-export declare function UserHiddenBookmarkModel(pubkey: string): Model<Bookmarks | null | undefined>;
+export declare function UserHiddenBookmarkModel(pubkey: string): Model<BookmarkPointer[] | null | undefined>;

package/dist/models/bookmarks.js

@@ -1,18 +1,10 @@
 import { kinds } from "applesauce-core/helpers/event";
 import { watchEventUpdates } from "applesauce-core/observable";
 import { map } from "rxjs/operators";
-import { getBookmarks, getHiddenBookmarks, getPublicBookmarks } from "../helpers/bookmark.js";
+import { getBookmarks, getHiddenBookmarks } from "../helpers/bookmark.js";
 /** A model that returns all the bookmarks of a user */
 export function UserBookmarkModel(pubkey) {
-    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
-    // listen for event updates (hidden tags unlocked)
-    watchEventUpdates(events), 
-    // Get all bookmarks
-    map((event) => event && getBookmarks(event)));
-}
-/** A model that returns all the public bookmarks of a user */
-export function UserPublicBookmarkModel(pubkey) {
-    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicBookmarks(event)));
+    return (events) => events.replaceable(kinds.BookmarkList, pubkey).pipe(map((event) => event && getBookmarks(event)));
 }
 /** A model that returns all the hidden bookmarks of a user */
 export function UserHiddenBookmarkModel(pubkey) {

package/dist/models/channels.js

@@ -31,15 +31,9 @@ export function ChannelMetadataModel(channel) {
         ];
         let latest = channel;
         return events.filters(filters).pipe(map((event) => {
-            try {
-                if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
-                    latest = event;
-                }
-                return getChannelMetadataContent(latest);
-            }
-            catch (error) {
-                return undefined;
-            }
+            if (event.pubkey === latest.pubkey && event.created_at > latest.created_at)
+                latest = event;
+            return getChannelMetadataContent(latest) ?? undefined;
         }));
     };
 }

package/dist/models/comments.d.ts

@@ -1,11 +1,12 @@
 import { Model } from "applesauce-core/event-store";
 import { NostrEvent } from "applesauce-core/helpers/event";
 import { type Observable } from "rxjs";
+import { CommentPointer } from "../helpers/comment.js";
 /** A model that returns all NIP-22 comment replies for the event */
-export declare function CommentsModel(parent: NostrEvent): Model<NostrEvent[]>;
+export declare function CommentsModel(parent: NostrEvent | CommentPointer): Model<NostrEvent[]>;
 declare module "applesauce-core/event-store" {
     interface EventModels {
         /** Subscribe to an event's comments */
-        comments(event: NostrEvent): Observable<NostrEvent[]>;
+        comments(event: NostrEvent | CommentPointer): Observable<NostrEvent[]>;
     }
 }

package/dist/models/comments.js

@@ -1,9 +1,27 @@
 import { EventModels } from "applesauce-core/event-store";
+import { createReplaceableAddress, isEvent } from "applesauce-core/helpers/event";
 import { buildCommonEventRelationFilters } from "applesauce-core/helpers/model";
+import { of } from "rxjs";
 import { COMMENT_KIND } from "../helpers/comment.js";
 /** A model that returns all NIP-22 comment replies for the event */
 export function CommentsModel(parent) {
-    return (events) => events.timeline(buildCommonEventRelationFilters({ kinds: [COMMENT_KIND] }, parent));
+    return (events) => {
+        if (isEvent(parent))
+            return events.timeline(buildCommonEventRelationFilters({ kinds: [COMMENT_KIND] }, parent));
+        else {
+            switch (parent.type) {
+                case "event":
+                    return events.timeline({ kinds: [COMMENT_KIND], "#e": [parent.id] });
+                case "address":
+                    return events.timeline({
+                        kinds: [COMMENT_KIND],
+                        "#a": [createReplaceableAddress(parent.kind, parent.pubkey, parent.identifier)],
+                    });
+                default:
+                    return of([]);
+            }
+        }
+    };
 }
 // Register this model with EventModels
 EventModels.prototype.comments = function (event) {

package/dist/models/index.d.ts

@@ -12,6 +12,8 @@ export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
 export * from "./gift-wrap.js";
-export * from "./relays.js";
+export * from "./relay-lists.js";
 export * from "./stream.js";
+export * from "./shares.js";
+export * from "applesauce-core/models";
 import "../register.js";

package/dist/models/index.js

@@ -12,7 +12,10 @@ export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
 export * from "./gift-wrap.js";
-export * from "./relays.js";
+export * from "./relay-lists.js";
 export * from "./stream.js";
+export * from "./shares.js";
+// Export all models from core
+export * from "applesauce-core/models";
 // Register the common models with the event store
 import "../register.js";

package/dist/models/mutes.d.ts

@@ -1,16 +1,16 @@
 import { Model } from "applesauce-core/event-store";
 import { ProfilePointer } from "applesauce-core/helpers/pointers";
 import { type Observable } from "rxjs";
-import { Mutes } from "../helpers/mute.js";
+import { MutedThings } from "../helpers/mute.js";
 /** A model that returns all a users muted things */
-export declare function MuteModel(user: string | ProfilePointer): Model<Mutes | undefined>;
+export declare function MuteModel(user: string | ProfilePointer): Model<MutedThings | undefined>;
 /** A model that returns all a users public muted things */
-export declare function PublicMuteModel(pubkey: string): Model<Mutes | undefined>;
+export declare function PublicMuteModel(pubkey: string): Model<MutedThings | undefined>;
 /** A model that returns all a users hidden muted things */
-export declare function HiddenMuteModel(pubkey: string): Model<Mutes | null | undefined>;
+export declare function HiddenMuteModel(pubkey: string): Model<MutedThings | null | undefined>;
 declare module "applesauce-core/event-store" {
     interface EventModels {
         /** Subscribe to a users mutes */
-        mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
+        mutes(user: string | ProfilePointer): Observable<MutedThings | undefined>;
     }
 }

package/dist/models/{relays.js → relay-lists.js}

@@ -1,7 +1,8 @@
 import { kinds } from "applesauce-core/helpers/event";
 import { watchEventUpdates } from "applesauce-core/observable";
 import { identity, map } from "rxjs";
-import { FAVORITE_RELAYS_KIND, getAddressPointersFromList, getRelaysFromList } from "../helpers/lists.js";
+import { getAddressPointersFromList, getRelaysFromList } from "../helpers/lists.js";
+import { FAVORITE_RELAYS_KIND } from "../helpers/relay-list.js";
 /**
  * A model that returns all favorite relays for a pubkey
  * @param pubkey - The pubkey to get the favorite relays for

package/dist/models/shares.d.ts

@@ -0,0 +1,3 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+export declare function SharesModel(event: NostrEvent): Model<NostrEvent[]>;

package/dist/models/shares.js

@@ -0,0 +1,5 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { buildCommonEventRelationFilters } from "applesauce-core/helpers/model";
+export function SharesModel(event) {
+    return (events) => events.timeline(buildCommonEventRelationFilters({ kinds: [kinds.Repost, kinds.GenericRepost] }, event));
+}

package/dist/models/thread.js

@@ -1,12 +1,10 @@
-import { createReplaceableAddress, getEventUID, isEvent, kinds } from "applesauce-core/helpers/event";
-import { getTagValue } from "applesauce-core/helpers/event";
-import { getReplaceableAddressFromPointer, isAddressPointer, isEventPointer, } from "applesauce-core/helpers/pointers";
-import { isAddressableKind } from "applesauce-core/helpers/event";
-import { map } from "rxjs/operators";
-import { COMMENT_KIND } from "../helpers/comment.js";
-import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
-// Import EventModels as a value (class) to modify its prototype
 import { EventModels } from "applesauce-core/event-store";
+import { buildCommonEventRelationFilters } from "applesauce-core/helpers";
+import { getEventUID, kinds } from "applesauce-core/helpers/event";
+import { eventMatchesPointer, getReplaceableAddressFromPointer, isAddressPointer, } from "applesauce-core/helpers/pointers";
+import { map } from "rxjs/operators";
+import { COMMENT_KIND, getCommentReplyPointer } from "../helpers/comment.js";
+import { getNip10References } from "../helpers/threading.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
 };
@@ -69,22 +67,30 @@ export function ThreadModel(root, opts) {
 /** A model that gets all legacy and NIP-10, and NIP-22 replies for an event */
 export function RepliesModel(event, overrideKinds) {
     return (events) => {
-        const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
-        const filter = { kinds };
-        if (isEvent(parent) || isEventPointer(event))
-            filter["#e"] = [event.id];
-        const address = isAddressableKind(event.kind)
-            ? createReplaceableAddress(event.kind, event.pubkey, getTagValue(event, "d"))
-            : undefined;
-        if (address) {
-            filter["#a"] = [address];
-        }
-        return events.timeline(filter).pipe(map((events) => {
-            return events.filter((e) => {
-                const refs = interpretThreadTags(e.tags);
-                return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
-            });
-        }));
+        const filter = { kinds: overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND] };
+        return events.timeline(buildCommonEventRelationFilters(filter, event)).pipe(map((events) => 
+        // Filter for direct replies
+        events.filter((reply) => {
+            if (reply.kind === kinds.ShortTextNote) {
+                // Check if a NIP-10 reply is a direct reply to this event
+                const refs = getNip10References(reply);
+                const pointer = refs.reply?.a || refs.reply?.e;
+                if (!pointer)
+                    return false;
+                return eventMatchesPointer(event, pointer);
+            }
+            else if (reply.kind === COMMENT_KIND) {
+                // Check if a NIP-22 reply is a direct reply to this event
+                const pointer = getCommentReplyPointer(reply);
+                if (!pointer)
+                    return false;
+                if (pointer.type === "address")
+                    return eventMatchesPointer(event, pointer);
+                else if (pointer.type === "event")
+                    return pointer.id === event.id;
+            }
+            return false;
+        })));
     };
 }
 // Register this model with EventModels

package/dist/observable/cast-stream.d.ts

@@ -0,0 +1,8 @@
+import type { NostrEvent } from "applesauce-core/helpers/event";
+import { OperatorFunction } from "rxjs";
+import type { CastConstructor, CastRefEventStore } from "../casts/cast.js";
+import { EventCast } from "../casts/cast.js";
+/** Casts an event to a specific type */
+export declare function castEventStream<C extends EventCast>(cls: CastConstructor<C>, store?: CastRefEventStore): OperatorFunction<NostrEvent | undefined, C | undefined>;
+/** Casts and array of events to an array of casted events and filters out undefined values */
+export declare function castTimelineStream<C extends EventCast>(cls: CastConstructor<C>, store?: CastRefEventStore): OperatorFunction<NostrEvent[], C[]>;

package/dist/observable/cast-stream.js

@@ -0,0 +1,29 @@
+import { defined } from "applesauce-core/observable/defined";
+import { map } from "rxjs";
+import { castEvent } from "../casts/cast.js";
+/** Casts an event to a specific type */
+export function castEventStream(cls, store) {
+    return (source) => source.pipe(map((event) => {
+        if (!event)
+            return undefined;
+        try {
+            return castEvent(event, cls, store);
+        }
+        catch { }
+        return undefined;
+    }));
+}
+/** Casts and array of events to an array of casted events and filters out undefined values */
+export function castTimelineStream(cls, store) {
+    return (source) => source.pipe(map((events) => {
+        const castedEvents = [];
+        for (const event of events) {
+            try {
+                const casted = castEvent(event, cls, store);
+                castedEvents.push(casted);
+            }
+            catch { }
+        }
+        return castedEvents;
+    }), defined());
+}

package/dist/observable/chainable.d.ts

@@ -0,0 +1,50 @@
+import { Observable } from "rxjs";
+/**
+ * Wraps an Observable in a Proxy that enables property chaining.
+ * When accessing a property ending with `$`, it uses switchMap to chain
+ * to that property's observable value.
+ * When accessing a non-observable property, it returns an Observable of that property's value.
+ *
+ * @example
+ * ```ts
+ * const author$ = chainable(note.author$);
+ * const outboxes$ = author$.outboxes$; // Observable<string[] | undefined>
+ * const displayName$ = author$.displayName; // Observable<string | undefined>
+ * ```
+ */
+export declare function chainable<T>(observable: Observable<T>): ChainableObservable<T>;
+/**
+ * Helper type to extract nullable parts (undefined/null) from a type
+ */
+type NullableParts<T> = Extract<T, undefined | null>;
+/**
+ * Helper type to get the property type, preserving nullable parts from the parent type
+ */
+type PropChain<T, K extends keyof NonNullable<T>> = NonNullable<T>[K] | NullableParts<T>;
+/**
+ * A chainable Observable type that allows property chaining.
+ * This type maps all properties to chainable observables:
+ * - Properties ending with $: extracts inner type from Observable<U> → ChainableObservable<U>
+ * - Other properties: uses property type directly → ChainableObservable<PropertyType>
+ *
+ * Note: TypeScript has limitations inferring through Proxy types. For better
+ * type inference, you may need to explicitly type the result:
+ *
+ * @example
+ * ```ts
+ * const inboxes$: Observable<string[] | undefined> = note?.author$.inboxes$;
+ * const displayName$: Observable<string | undefined> = note?.author$.displayName;
+ * const inboxes = useObservableMemo(() => inboxes$, [note]);
+ * ```
+ */
+export type ChainableObservable<T> = Observable<T> & Omit<{
+    [K in keyof NonNullable<T> as K extends string ? K : never]: K extends `${infer _}$` ? NonNullable<T>[K] extends Observable<infer U> ? ChainableObservable<U | NullableParts<T>> : never : ChainableObservable<PropChain<T, K>>;
+}, "$first" | "$last"> & {
+    /** Returns a promise that resolves with the first value or rejects with a timeout error */
+    $first(first?: number): Promise<NonNullable<T>>;
+    $first<V>(first?: number, fallback?: V): Promise<NonNullable<T> | V>;
+    /** Returns a promise that resolves with the last value or rejects with a timeout error */
+    $last(max?: number): Promise<NonNullable<T>>;
+    $last<V>(max?: number, fallback?: V): Promise<NonNullable<T> | V>;
+};
+export {};

package/dist/observable/chainable.js

@@ -0,0 +1,79 @@
+import { filter, firstValueFrom, isObservable, lastValueFrom, map, of, switchMap, timeout } from "rxjs";
+/**
+ * A symbol used to mark an Observable as chainable
+ */
+const CHAINABLE_CACHE_SYMBOL = Symbol.for("chainable-cache");
+/**
+ * Wraps an Observable in a Proxy that enables property chaining.
+ * When accessing a property ending with `$`, it uses switchMap to chain
+ * to that property's observable value.
+ * When accessing a non-observable property, it returns an Observable of that property's value.
+ *
+ * @example
+ * ```ts
+ * const author$ = chainable(note.author$);
+ * const outboxes$ = author$.outboxes$; // Observable<string[] | undefined>
+ * const displayName$ = author$.displayName; // Observable<string | undefined>
+ * ```
+ */
+export function chainable(observable) {
+    // Create a Proxy that intercepts property access
+    const proxy = new Proxy(observable, {
+        get(target$, prop) {
+            const cache = observable[CHAINABLE_CACHE_SYMBOL] ||
+                (observable[CHAINABLE_CACHE_SYMBOL] = {});
+            // Forward all Observable methods and properties
+            if (prop in target$ || typeof prop === "symbol") {
+                const value = target$[prop];
+                // If it's a function, bind it to the target
+                if (typeof value === "function")
+                    return value.bind(target$);
+                return value;
+            }
+            if (typeof prop === "string") {
+                // Return cached observable if it exists
+                const cached = cache[prop];
+                if (cached)
+                    return cached;
+                // Otherwise, create a new observable
+                let prop$;
+                // Extra observalbe helpers to make it easier to work with observables
+                if (prop === "$first") {
+                    return (...args) => firstValueFrom(target$.pipe(filter((v) => v !== undefined && v !== null), args.length === 2
+                        ? timeout({ first: args[0], with: () => of(args[1]) })
+                        : timeout({ first: args[0] ?? 10_000 })));
+                }
+                else if (prop === "$last") {
+                    return (...args) => lastValueFrom(target$.pipe(filter((v) => v !== undefined && v !== null), args.length === 2
+                        ? timeout({ first: args[0], with: () => of(args[1]) })
+                        : timeout({ first: args[0] ?? 10_000 })));
+                }
+                // Handle property access for properties ending with $
+                else if (prop.endsWith("$")) {
+                    // Use switchMap to chain to the nested observable
+                    prop$ = target$.pipe(switchMap((target) => {
+                        const value = target === undefined || target === null ? target : target[prop];
+                        // If value is an observable, return it
+                        if (isObservable(value))
+                            return value;
+                        // Otherwise wrap it in an observable
+                        else
+                            return of(value);
+                    }));
+                }
+                // For non-$ properties, return an Observable of the property value
+                else {
+                    prop$ = target$.pipe(
+                    // Access the property on the value if target is not undefined or null
+                    map((target) => (target === undefined || target === null ? target : target[prop])));
+                }
+                // Make the chained observable chainable too
+                const observable = chainable(prop$);
+                cache[prop] = observable;
+                return observable;
+            }
+            throw new Error(`Unable to access property "${prop}" on chainable observable`);
+        },
+    });
+    return proxy;
+}

package/dist/observable/index.d.ts

@@ -1 +1,3 @@
 export * from "./filter-timeline-by-mutes.js";
+export * from "./cast-stream.js";
+export * from "./chainable.js";

package/dist/observable/index.js

@@ -1 +1,3 @@
 export * from "./filter-timeline-by-mutes.js";
+export * from "./cast-stream.js";
+export * from "./chainable.js";

package/dist/operations/comment.d.ts

@@ -1,4 +1,5 @@
 import { EventOperation } from "applesauce-core/event-factory";
 import { NostrEvent } from "applesauce-core/helpers/event";
-/** Sets the necessary tags for a NIP-22 comment event to point to a parent event */
-export declare function setParent(parent: NostrEvent): EventOperation;
+import { CommentPointer } from "../helpers/comment.js";
+/** Sets the necessary tags for a NIP-22 comment event to point to a parent event or pointer */
+export declare function setParent(parent: NostrEvent | CommentPointer): EventOperation;