applesauce-core 5.2.0 → 6.0.0

package/dist/factories/profile.js

@@ -0,0 +1,80 @@
+import { isKind } from "nostr-tools/kinds";
+import { kinds } from "../helpers/event.js";
+import { setProfile, updateProfile } from "../operations/profile.js";
+import { blankEventTemplate, EventFactory, toEventTemplate } from "./event.js";
+/** A factory class for building kind 0 profile/metadata events */
+export class ProfileFactory extends EventFactory {
+    /**
+     * Creates a new profile factory
+     * @returns A new profile factory
+     */
+    static create() {
+        return new ProfileFactory((res) => res(blankEventTemplate(kinds.Metadata)));
+    }
+    /**
+     * Creates a new profile factory from an existing metadata event with validation
+     * @param event - The existing metadata event
+     * @returns A new profile factory
+     */
+    static modify(event) {
+        if (!isKind(event, kinds.Metadata))
+            throw new Error("Event is not a profile event");
+        return new ProfileFactory((res) => res(toEventTemplate(event)));
+    }
+    /** Sets the entire profile content, replacing any existing content */
+    override(content) {
+        return this.chain(setProfile(content));
+    }
+    /** Updates specific fields in the profile content, merging with existing content */
+    update(content) {
+        return this.chain(updateProfile(content));
+    }
+    /** Sets the display name */
+    name(name) {
+        return this.chain(updateProfile({ name }));
+    }
+    /** Sets the username */
+    username(username) {
+        return this.chain(updateProfile({ username }));
+    }
+    /** Sets the display name (alias for name) */
+    displayName(displayName) {
+        return this.chain(updateProfile({ display_name: displayName }));
+    }
+    /** Sets the about/bio text */
+    about(about) {
+        return this.chain(updateProfile({ about }));
+    }
+    /** Sets the profile picture URL */
+    picture(picture) {
+        return this.chain(updateProfile({ picture }));
+    }
+    /** Sets the banner image URL */
+    banner(banner) {
+        return this.chain(updateProfile({ banner }));
+    }
+    /** Sets the website URL */
+    website(website) {
+        return this.chain(updateProfile({ website }));
+    }
+    /** Sets the NIP-05 identifier */
+    nip05(nip05) {
+        return this.chain(updateProfile({ nip05 }));
+    }
+    /** Sets the Lightning Network address */
+    lnurlp(lnurlp) {
+        return this.chain(updateProfile({ lud06: lnurlp }));
+    }
+    /** Sets the Lightning Network address (LNURL) */
+    lightningAddress(address) {
+        return this.chain(updateProfile({ lud16: address }));
+    }
+    /** Sets the bot flag */
+    bot(bot) {
+        return this.chain(updateProfile({ bot }));
+    }
+    /** Sets the languages */
+    languages(languages) {
+        return this.chain(updateProfile({ languages }));
+    }
+}

package/dist/factories/types.d.ts

@@ -0,0 +1,56 @@
+import { EventTemplate, NostrEvent, UnsignedEvent } from "../helpers/event.js";
+import { AddressPointer } from "../helpers/pointers.js";
+/** Nostr event signer */
+export interface EventSigner {
+    getPublicKey: () => Promise<string> | string;
+    signEvent: (draft: EventTemplate | UnsignedEvent) => Promise<NostrEvent> | NostrEvent;
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    nip44?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+}
+/** A single operation that transforms a value (context-free) */
+export type Operation<I extends unknown = unknown, R extends unknown = unknown> = (value: I) => R | Promise<R>;
+/** A single operation that modifies an events public or hidden tags array */
+export type TagOperation = Operation<string[][], string[][]>;
+/** A single operation that modifies an event */
+export type EventOperation<I extends EventTemplate | UnsignedEvent | NostrEvent = EventTemplate, R extends EventTemplate | UnsignedEvent | NostrEvent = EventTemplate> = Operation<I, R>;
+/** NIP-30 emoji type */
+export type Emoji = {
+    /** The emoji shortcode (without the ::) */
+    shortcode: string;
+    /** The URL to the emoji image */
+    url: string;
+    /** The NIP-01 "a" tag address of the emoji pack this emoji belongs to */
+    address?: AddressPointer;
+};
+/** A context with optional methods for getting relay hints */
+export interface RelayHintContext {
+    getEventRelayHint?: (event: string) => string | undefined | Promise<string> | Promise<undefined>;
+    getPubkeyRelayHint?: (pubkey: string) => string | undefined | Promise<string> | Promise<undefined>;
+}
+export interface EventFactoryClient {
+    name: string;
+    address?: Omit<AddressPointer, "kind" | "relays">;
+}
+export interface EmojiContext {
+    /** An array of custom emojis that will be used for text notes */
+    emojis?: Emoji[];
+}
+/** Services that can be provided to event operations */
+export interface EventFactoryServices {
+    /** Event signer for signing and stamping events */
+    signer?: EventSigner;
+    /** Function to get relay hint for an event ID */
+    getEventRelayHint?: (eventId: string) => Promise<string | undefined>;
+    /** Function to get relay hint for a pubkey */
+    getPubkeyRelayHint?: (pubkey: string) => Promise<string | undefined>;
+    /** Custom emojis for NIP-30 emoji tags */
+    emojis?: Emoji[];
+    /** NIP-89 client pointer */
+    client?: EventFactoryClient;
+}

package/dist/helpers/event.d.ts

@@ -1,14 +1,23 @@
 import { kinds } from "nostr-tools";
+import { isKind } from "nostr-tools/kinds";
 import { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind } from "nostr-tools/kinds";
-import { NostrEvent, VerifiedEvent } from "nostr-tools/pure";
+import { EventTemplate, NostrEvent, UnsignedEvent, VerifiedEvent } from "nostr-tools/pure";
 import { IAsyncEventStore, IEventStore } from "../event-store/interface.js";
 export { EventTemplate, finalizeEvent, getEventHash, NostrEvent, serializeEvent, UnsignedEvent, VerifiedEvent, verifiedSymbol, verifyEvent, } from "nostr-tools/pure";
 export { binarySearch, bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, } from "nostr-tools/utils";
-export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds };
+export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds, isKind };
 /** An event with a known kind. this is used to know if events have been validated */
 export type KnownEvent<K extends number> = Omit<NostrEvent, "kind"> & {
     kind: K;
 };
+/** An event template with a known kind. used in event factories */
+export type KnownEventTemplate<K extends number> = Omit<EventTemplate, "kind"> & {
+    kind: K;
+};
+/** An unsigned event with a known kind. used in event factories */
+export type KnownUnsignedEvent<K extends number> = Omit<UnsignedEvent, "kind"> & {
+    kind: K;
+};
 /** A symbol on an event that marks which event store its part of */
 export declare const EventStoreSymbol: unique symbol;
 export declare const EventUIDSymbol: unique symbol;

package/dist/helpers/event.js

@@ -1,11 +1,12 @@
 import { kinds } from "nostr-tools";
+import { isKind } from "nostr-tools/kinds";
 import { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind } from "nostr-tools/kinds";
 import { verifiedSymbol, verifyEvent } from "nostr-tools/pure";
 import { getOrComputeCachedValue } from "./cache.js";
 // Re-export types from nostr-tools
 export { finalizeEvent, getEventHash, serializeEvent, verifiedSymbol, verifyEvent, } from "nostr-tools/pure";
 export { binarySearch, bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, } from "nostr-tools/utils";
-export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds };
+export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds, isKind };
 /** A symbol on an event that marks which event store its part of */
 export const EventStoreSymbol = Symbol.for("event-store");
 export const EventUIDSymbol = Symbol.for("event-uid");

package/dist/helpers/mailboxes.d.ts

@@ -1,7 +1,11 @@
-import { NostrEvent } from "./event.js";
+import { kinds, KnownEvent, NostrEvent } from "./event.js";
+/** Type for NIP-65 relay list events */
+export type MailboxesEvent = KnownEvent<kinds.RelayList>;
 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 */
 export declare function getInboxes(event: NostrEvent): string[];
 /** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export declare function getOutboxes(event: NostrEvent): string[];
+/** Checks if an event is a valid mailboxes event */
+export declare function isMailboxesEvent(event: any): event is MailboxesEvent;

package/dist/helpers/mailboxes.js

@@ -1,3 +1,4 @@
+import { isKind, kinds } from "./event.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
 import { isRTag } from "./tags.js";
@@ -47,3 +48,7 @@ export function getOutboxes(event) {
         return outboxes;
     });
 }
+/** Checks if an event is a valid mailboxes event */
+export function isMailboxesEvent(event) {
+    return isKind(event, kinds.RelayList);
+}

package/dist/helpers/pipeline.d.ts

@@ -1,4 +1,4 @@
-import { EventOperation, Operation, TagOperation } from "../event-factory/types.js";
+import type { EventOperation, Operation, TagOperation } from "../factories/types.js";
 /** An array of Symbols to preserve when building events with {@link eventPipe} */
 export declare const PRESERVE_EVENT_SYMBOLS: Set<symbol>;
 export declare function identity<T>(x: T): T;
@@ -8,6 +8,19 @@ export declare function eventPipe(...operations: (EventOperation | undefined)[])
 export declare function tagPipe(...operations: (TagOperation | undefined)[]): TagOperation;
 /** A pipeline operation that does nothing */
 export declare function skip<T>(): (value: T) => T;
+/**
+ * Pipe a value through a series of async operations
+ * @example
+ * ```ts
+ * const result = await pipe(
+ *   draft,
+ *   setContent("hello"),
+ *   addTag("p", pubkey),
+ *   sign(signer)
+ * );
+ * ```
+ */
+export declare function pipe<T>(value: T, ...operations: Array<(v: any) => any | Promise<any>>): Promise<any>;
 /**
  * @param fns - An array of operations to pipe together
  * @param preserve - If set an array of symbols to keep, all other symbols will be removed

package/dist/helpers/pipeline.js

@@ -18,6 +18,21 @@ export function tagPipe(...operations) {
 export function skip() {
     return (value) => value;
 }
+/**
+ * Pipe a value through a series of async operations
+ * @example
+ * ```ts
+ * const result = await pipe(
+ *   draft,
+ *   setContent("hello"),
+ *   addTag("p", pubkey),
+ *   sign(signer)
+ * );
+ * ```
+ */
+export async function pipe(value, ...operations) {
+    return operations.reduce(async (prev, op) => op(await prev), Promise.resolve(value));
+}
 /**
  * @param fns - An array of operations to pipe together
  * @param preserve - If set an array of symbols to keep, all other symbols will be removed
@@ -26,9 +41,9 @@ export function skip() {
 export function pipeFromAsyncArray(fns, preserve) {
     if (fns.length === 0)
         return identity;
-    return async function piped(input, context) {
+    return async function piped(input) {
         return fns.reduce(async (prev, fn) => {
-            const result = await fn(await prev, context);
+            const result = await fn(await prev);
             // Copy the symbols and fields if result is an object
             if (preserve && typeof result === "object" && result !== null && typeof prev === "object" && prev !== null) {
                 const keys = Reflect.ownKeys(result).filter((key) => typeof key === "symbol");

package/dist/helpers/profile.d.ts

@@ -19,10 +19,10 @@ export type ProfileContent = {
     banner?: string;
     /** A web URL related in any way to the event author */
     website?: string;
+    /** A LNURL-based Lightning address in the format `lnurlp://…` */
+    lud06?: string;
     /** Lightning address in the format `user@domain.com` (LUD-16 format) */
     lud16?: string;
-    /** Lightning address in the format `user@domain.com` (LUD-06 format) */
-    lud06?: string;
     /** DNS-based verification identifier in the format `_@domain.com` or `user@domain.com` */
     nip05?: string;
     /** Boolean to clarify that the content is entirely or partially the result of automation, such as with chatbots or newsfeeds */

package/dist/helpers/regexp.d.ts

@@ -6,6 +6,7 @@ export declare const Expressions: {
     readonly emoji: RegExp;
     readonly hashtag: RegExp;
     readonly lightning: RegExp;
+    readonly blossom: RegExp;
 };
 /** A list of Regular Expressions that match tokens surrounded by whitespace to avoid matching in URLs */
 export declare const Tokens: {
@@ -16,4 +17,5 @@ export declare const Tokens: {
     readonly emoji: RegExp;
     readonly hashtag: RegExp;
     readonly lightning: RegExp;
+    readonly blossom: RegExp;
 };

package/dist/helpers/regexp.js

@@ -1,9 +1,9 @@
 export const Expressions = {
     get url() {
-        return /(?:https?|wss?|ircs?|s?ftp):\/\/([a-zA-Z0-9\.\-]+\.[a-zA-Z]+(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
+        return /(?:https?|wss?|ircs?|s?ftp):\/\/((?:(?:\d{1,3}\.){3}\d{1,3}|localhost|[a-zA-Z0-9\.\-]+\.[a-zA-Z]+)(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
     },
     get link() {
-        return /https?:\/\/([a-zA-Z0-9\.\-]+\.[a-zA-Z]+(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
+        return /https?:\/\/((?:(?:\d{1,3}\.){3}\d{1,3}|localhost|[a-zA-Z0-9\.\-]+\.[a-zA-Z]+)(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
     },
     get cashu() {
         return /(?:cashu:\/{0,2})?(cashu(?:A|B)[A-Za-z0-9_-]{100,}={0,3})/gi;
@@ -21,6 +21,9 @@ export const Expressions = {
     get lightning() {
         return /(?:lightning:)?(LNBC[A-Za-z0-9]+)/gim;
     },
+    get blossom() {
+        return /blossom:([0-9a-f]{64})\.([a-zA-Z0-9]+)(\?[^\s]*)?/g;
+    },
 };
 /** A list of Regular Expressions that match tokens surrounded by whitespace to avoid matching in URLs */
 export const Tokens = {
@@ -45,4 +48,7 @@ export const Tokens = {
     get lightning() {
         return new RegExp(`(?<=^|\\s)${Expressions.lightning.source}`, "gim");
     },
+    get blossom() {
+        return new RegExp(`(?<=^|\\s)${Expressions.blossom.source}`, "g");
+    },
 };

package/dist/helpers/relays.d.ts

@@ -1,5 +1,7 @@
 import { NostrEvent } from "./event.js";
 export declare const SeenRelaysSymbol: unique symbol;
+/** Normalizes a relay URL by using {@link normalizeURL} and {@link ensureWebSocketURL} */
+export declare function normalizeRelayUrl(input: string): string;
 /** Marks an event as being seen on a relay */
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
 /** Returns the set of relays this event was seen on */
@@ -9,6 +11,6 @@ export declare function isFromRelay(event: NostrEvent, relay: string): boolean;
 /** A fast check to make sure relay hints are safe to connect to */
 export declare function isSafeRelayURL(relay: string): boolean;
 /** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */
-export declare function mergeRelaySets(...sources: (Iterable<string> | string | undefined)[]): string[];
+export declare function mergeRelaySets(...sources: (Iterable<string> | string | undefined | null)[]): string[];
 /** Alias for {@link mergeRelaySets} */
 export declare const relaySet: typeof mergeRelaySets;

package/dist/helpers/relays.js

@@ -1,5 +1,9 @@
-import { normalizeURL } from "./url.js";
+import { ensureWebSocketURL, normalizeURL } from "./url.js";
 export const SeenRelaysSymbol = Symbol.for("seen-relays");
+/** Normalizes a relay URL by using {@link normalizeURL} and {@link ensureWebSocketURL} */
+export function normalizeRelayUrl(input) {
+    return normalizeURL(ensureWebSocketURL(input));
+}
 /** Marks an event as being seen on a relay */
 export function addSeenRelay(event, relay) {
     let seen = Reflect.get(event, SeenRelaysSymbol);
@@ -34,23 +38,17 @@ export function mergeRelaySets(...sources) {
         if (!src)
             continue;
         if (typeof src === "string") {
-            // Source is a string
             try {
-                const safe = normalizeURL(src).toString();
-                if (safe)
-                    set.add(safe);
+                set.add(normalizeRelayUrl(src));
             }
             catch (error) {
                 // failed to parse URL, ignore
             }
         }
-        else {
-            // Source is iterable
+        else if (Reflect.has(src, Symbol.iterator)) {
             for (const url of src) {
                 try {
-                    const safe = normalizeURL(url).toString();
-                    if (safe)
-                        set.add(safe);
+                    set.add(normalizeRelayUrl(url));
                 }
                 catch (error) {
                     // failed to parse URL, ignore

package/dist/helpers/url.d.ts

@@ -20,8 +20,5 @@ export declare function ensureProtocol(url: string, protocol?: string): string;
 export declare function ensureWebSocketURL<T extends string | URL>(url: T): T;
 /** Converts a domain or WS URL to a HTTP URL */
 export declare function ensureHttpURL<T extends string | URL>(url: T): T;
-/**
- * Normalizes a string into a relay URL
- * Does not remove the trailing slash
- */
+/** Normalizes a string into a cleaner URL by dropping port if its not needed */
 export declare function normalizeURL<T extends string | URL>(url: T): T;

package/dist/helpers/url.js

@@ -80,10 +80,7 @@ export function ensureHttpURL(url) {
     // @ts-expect-error
     return typeof url === "string" ? p.toString() : p;
 }
-/**
- * Normalizes a string into a relay URL
- * Does not remove the trailing slash
- */
+/** Normalizes a string into a cleaner URL by dropping port if its not needed */
 export function normalizeURL(url) {
     let p = new URL(url);
     // Remove any double slashes

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-export * from "./event-factory/index.js";
+export * from "./factories/index.js";
+export * from "./casts/index.js";
 export * from "./event-store/index.js";
 export * from "./logger.js";
 export * from "./observable/index.js";
 export * as Helpers from "./helpers/index.js";
 export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";
+export * as Factories from "./factories/index.js";

package/dist/index.js

@@ -1,7 +1,10 @@
-export * from "./event-factory/index.js";
+// Export from factories
+export * from "./factories/index.js";
+export * from "./casts/index.js";
 export * from "./event-store/index.js";
 export * from "./logger.js";
 export * from "./observable/index.js";
 export * as Helpers from "./helpers/index.js";
 export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";
+export * as Factories from "./factories/index.js";

package/dist/observable/catch-error-inline.d.ts

@@ -0,0 +1,3 @@
+import { OperatorFunction } from "rxjs";
+/** Catches any errors and includes them in the observable stream */
+export declare function catchErrorInline<T extends unknown>(): OperatorFunction<T, T | Error>;

package/dist/observable/catch-error-inline.js

@@ -0,0 +1,5 @@
+import { catchError, of } from "rxjs";
+/** Catches any errors and includes them in the observable stream */
+export function catchErrorInline() {
+    return catchError((err) => (err instanceof Error ? of(err) : of(new Error(err.message))));
+}

package/dist/observable/chainable.d.ts

@@ -0,0 +1,36 @@
+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.
+ */
+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:
+ */
+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,72 @@
+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.
+ */
+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/combine-latest-by-index.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from "rxjs";
+/**
+ * Dynamic counterpart to `switchMap(() => combineLatest(...))` for arrays,
+ * with stable branches by index.
+ *
+ * Each array index gets its own long-lived branch (`of(value).pipe(...)`
+ * equivalent), and branches are only created/removed when indices are
+ * added/removed.
+ */
+export declare function combineLatestByIndex<T, R>(project: (source$: Observable<T>, index: number) => Observable<R>): (source$: Observable<readonly T[]>) => Observable<R[]>;