@palbase/web 7.3.9 → 7.4.1

package/dist/{analytics-facade-BER0EyYT.d.ts → analytics-facade-But6gu2r.d.ts}

@@ -612,9 +612,15 @@ declare class PalbeCalls {
      * @param media    - Which media tracks to publish (default: audio + video)
      * @returns        A `Call` in `connecting` state; transitions to `active` once the media room connects.
      *
-     * @throws BackendError('network', { code: 'call_service_unavailable' })  if the SFU is down (503)
-     * @throws BackendError('forbidden', { code: 'not_group_member' })       if the caller is not a member (403)
-     * @throws BackendError('conflict', { code: 'call_room_full' })          if the room is full (409)
+     * Every failure below arrives as kind `'server'` — this SDK's error kinds are
+     * `notConfigured | validation | unauthorized | rateLimited | server | network
+     * | decode`, and only a 401, a 429 or a 400 carrying a field-error array gets
+     * its own kind. So branch on `err.code`, never on the kind.
+     *
+     * @throws BackendError('server', { code: 'calling_unavailable' })  no SFU configured on this stack (503)
+     * @throws BackendError('server', { code: 'not_group_member' })     the caller is not a member of the group (403)
+     * @throws BackendError('server', { code: 'call_room_full' })       the call is at its participant limit (409)
+     * @throws BackendError('server', { code: 'call_provider_error' })  the media provider failed upstream (502)
      */
     start(groupId: string, { media }?: {
         media?: Array<'audio' | 'video'>;
@@ -623,7 +629,11 @@ declare class PalbeCalls {
      * Accept an incoming call in a messaging group.
      *
      * @param groupId  - Messaging group display-id
-     * @param callId   - Call identifier (from the push notification payload)
+     * @param callId   - Call identifier, carried by the `call_invite` the server
+     *   fans onto the group's conversation topic
+     *   (`pb.realtime.channel('messaging:conv:<rfcGroupId>').on('call_invite', …)`).
+     *   This SDK ships no web push: on the web the invite arrives over realtime or
+     *   over whatever signalling the app already runs.
      * @param media    - Which media tracks to publish (default: audio + video)
      */
     accept(groupId: string, callId: string, { media }?: {
@@ -1579,6 +1589,19 @@ interface RealtimeStatus {
     readonly lastEventAt: Date | null;
     onChange(callback: (status: RealtimeStatusSnapshot) => void): Unsubscribe;
 }
+/** Why the server refused a channel. */
+interface RealtimeChannelError {
+    /** The channel this is about. */
+    topic: string;
+    /** Exactly what the server said: `"unauthorized"` or `"unavailable"`. */
+    reason: string;
+    /**
+     * Whether asking again could succeed. `unavailable` (the project could not be
+     * reached to decide) is retryable and the socket retries it on reconnect;
+     * `unauthorized` is a settled answer and is not.
+     */
+    retryable: boolean;
+}
 /**
  * A subscription handle for one realtime channel (returned by
  * `pb.realtime.channel(name)` — the SAME instance per name). A channel is
@@ -1595,12 +1618,62 @@ declare class RealtimeChannel {
      * subscription and `cancel()` it to stop.
      */
     on(event: string, handler: RealtimeHandler): RealtimeSubscription;
+    /**
+     * Called when the server REFUSES this channel.
+     *
+     * A join is an authorization decision, and a decision the app never hears is
+     * the same as no decision at all: silence looks exactly like a slow network.
+     * This is where a refusal arrives, carrying the server's own distinction —
+     * `retryable: false` means "you may not" and asking again will not help;
+     * `retryable: true` means the project could not be asked, and the socket's
+     * next reconnect retries on its own.
+     *
+     *     pb.realtime.channel('room:42').onError((err) => {
+     *       if (!err.retryable) showJoinDenied()
+     *     })
+     */
+    onError(handler: (error: RealtimeChannelError) => void): RealtimeSubscription;
     /**
      * Broadcast `payload` to the channel's other subscribers (web addition —
      * iOS is receive-only). Joins the channel if it isn't already; queued
      * until the join is live on the socket.
      */
     send(event: string, payload?: RealtimePayload): void;
+    /**
+     * Watch one key of the channel's shared state.
+     *
+     * The handler is called with the CURRENT value straight away when there is
+     * one, and again on every change. That is the difference from `on()`: a
+     * subscriber to an event learns nothing until the next one, while state is
+     * already there when you ask.
+     */
+    onState(key: string, handler: (value: unknown) => void): RealtimeSubscription;
+    /** Read one key without subscribing. */
+    stateValue(key: string): unknown;
+    /** Write one key. `durable` outlives this connection; `ephemeral` is reaped
+     * when it closes, which is what presence is built on. */
+    setState(key: string, value: unknown, opts?: {
+        life?: 'ephemeral' | 'durable';
+    }): void;
+    /** Remove a key this connection wrote. */
+    clearState(key: string): void;
+    /**
+     * Announce this client on the channel. `meta` is whatever other participants
+     * should see — a name, an avatar, a cursor.
+     *
+     * It is ephemeral state keyed by this connection, so it disappears when the
+     * socket does. Nothing has to be un-announced on a crash.
+     */
+    presenceEnter(meta: RealtimePayload): void;
+    /** Replace the announced value — a cursor moving is this, at whatever rate
+     * the app likes: the server conflates writes it cannot deliver fast enough. */
+    presenceUpdate(meta: RealtimePayload): void;
+    /** Leave early. Closing the socket does this on its own. */
+    presenceLeave(): void;
+    /** Everyone else currently announced, this client excluded. */
+    presenceOthers(): unknown[];
+    /** Watch the announced set. Called on every change. */
+    onPresence(handler: (others: unknown[]) => void): RealtimeSubscription;
 }
 declare class PalbeRealtime {
     private readonly rt;
@@ -1608,7 +1681,13 @@ declare class PalbeRealtime {
     private readonly channels;
     private readonly statusStore;
     private readonly handlers;
+    private readonly errorHandlers;
     private readonly topicRefcount;
+    private readonly states;
+    private readonly connIds;
+    private readonly pendingPresence;
+    private readonly stateWatchers;
+    private readonly presenceWatchers;
     constructor(rt: PalbeRuntime);
     /**
      * Get the handle for an app-defined channel (e.g. "room:42"). The same
@@ -1624,16 +1703,52 @@ declare class PalbeRealtime {
     destroy(): void;
     /** The observable connection status. Safe to read anywhere (reports `idle` until a socket exists). */
     get status(): RealtimeStatus;
+    /**
+     * Hand the socket a fresher credential for the SAME user, without rejoining.
+     *
+     * Called when the app's token rotates. The alternative — letting the channels
+     * die at expiry and rejoining — reaps this connection's ephemeral entries
+     * (its presence, on every channel) and forces a full state resync. A token
+     * getting older is not a disconnection and must not cost one.
+     *
+     * A no-op before a socket exists: the first connect resolves a fresh token
+     * on its own.
+     */
+    refreshToken(token: string): void;
     /** Lazily build + start the shared socket on first subscription/send. */
     private ensureSocket;
     private route;
     /**
-     * A channel died for good (token-expiry rejoin exhausted N attempts). Drop its
-     * handlers + refcount so the app stops expecting events on it, and flip the
-     * status observable to `'error'` (the React `useChannel` hook reports this).
-     * A later `.on()` for the same topic re-joins from scratch (refcount 1).
+    /**
+     * The server refused a channel. Tell whoever asked, and — when the answer is
+     * final — stop pretending the app is subscribed to it.
+     *
+     * `unavailable` leaves everything in place: the project could not be reached
+     * to decide, the socket rejoins on its next reconnect, and dropping the app's
+     * handlers would make a momentary outage look like a permanent denial.
+     */
+    private handleChannelRefused;
+    /**
+     * A channel died for good — a token-expiry rejoin that exhausted its attempts.
+     * The app must stop expecting anything on it, and the status observable flips
+     * to `'error'` (the React `useChannel` hook reports that).
+     *
+     * It clears the SAME registries a final refusal clears, and used to clear only
+     * the event handlers. A state or presence watcher left behind here waits
+     * forever for a snapshot that cannot arrive, and fires twice if the app ever
+     * re-subscribes — the identical failure its sibling three functions up
+     * describes, on a channel that was given up on rather than refused.
      */
     private handleChannelError;
+    /** Drop every registration this topic holds. One place, because "which
+     *  registries" is a question two callers must never answer differently. */
+    private forgetTopic;
+    private retainTopic;
+    private releaseTopic;
+    private applySnapshot;
+    private applyDiff;
+    private applyJoinInfo;
+    private notifyState;
 }
 
 interface PalbeRuntime {
@@ -1758,10 +1873,16 @@ declare class PalbeAuth {
      * Self-service account erasure ("right to be forgotten"). Calls palauth
      * `DELETE /auth/user` (session-authed + fresh re-auth): password users pass
      * `{ password }`; passwordless/OAuth users rely on a freshly stepped-up
-     * session. On 202 the erasure workflow is durably queued AND every session is
-     * already revoked server-side — so we tear down local state (mirroring
-     * `signOut()`'s clear, minus the pointless `/logout`) and emit
-     * `signedOut{reason:'accountDeleted'}`.
+     * session. The handler answers **204 with no body** — the erasure has already
+     * finished and every session is already revoked server-side — so we tear down
+     * local state (mirroring `signOut()`'s clear, minus the pointless `/logout`)
+     * and emit `signedOut{reason:'accountDeleted'}`.
+     *
+     * Returns nothing, because there is nothing to return: the handler used to
+     * answer 202 with an `{erasure_id}` naming an asynchronous run, and that id
+     * was removed along with the run (`gdpr_handlers.go:221-229`). Reading it
+     * here threw a `TypeError` AFTER the account was already gone — a success
+     * reported as a failure.
      *
      * On 401 `reauth_required` / 503 `not_configured` (or `erasure_unavailable`)
      * the request throws BEFORE the teardown line, so the local session is left
@@ -1769,9 +1890,7 @@ declare class PalbeAuth {
      */
     deleteAccount(params?: {
         password?: string;
-    }): Promise<{
-        erasureId: string;
-    }>;
+    }): Promise<void>;
     getUser(): Promise<AuthUser>;
     /**
      * Which credentials this account actually has.
@@ -2014,4 +2133,4 @@ declare class PalbeAnalytics {
     private post;
 }
 
-export { type AuthUser as A, PalbeMessaging as B, Chat as C, type PalbeOAuthConfig as D, PalbeRealtime as E, type FlagsView as F, type PresenceState as G, RealtimeChannel as H, type RealtimeHandler as I, type RealtimeStatus as J, type RealtimeStatusSnapshot as K, type RealtimeSubscription as L, type MagicLinkResult as M, type NotifyScope as N, type OAuthExchangeResult as O, type PalbeConfig as P, type ResolvedMention as Q, type RealtimeConnectionState as R, type ResolvedReply as S, type SentReceipt as T, type SignInMethods as U, type UnreadView as V, type Unsubscribe as W, PalbePerf as X, type RealtimePayload as a, type ChatMember as b, type ChatMessage as c, type PalbeRuntime as d, buildRuntime as e, type AnalyticsProperties as f, type AuthChangeEvent as g, type AuthState as h, type AuthSuccess as i, Call as j, type CallChangeCallback as k, type CallParticipant as l, type CallState as m, type ChatBackend as n, type ChatDraft as o, type ChatKind as p, type ChatMessageKind as q, type ChatRole as r, type ChatState as s, type CommsPrefs as t, type MentionRange as u, type MessageDirection as v, PalbeAnalytics as w, PalbeAuth as x, PalbeCalls as y, PalbeFlags as z };
+export { type AuthUser as A, PalbeMessaging as B, Chat as C, type PalbeOAuthConfig as D, PalbeRealtime as E, type FlagsView as F, type PresenceState as G, RealtimeChannel as H, type RealtimeChannelError as I, type RealtimeHandler as J, type RealtimeStatus as K, type RealtimeStatusSnapshot as L, type MagicLinkResult as M, type NotifyScope as N, type OAuthExchangeResult as O, type PalbeConfig as P, type RealtimeSubscription as Q, type RealtimeConnectionState as R, type ResolvedMention as S, type ResolvedReply as T, type SentReceipt as U, type SignInMethods as V, type UnreadView as W, type Unsubscribe as X, PalbePerf as Y, type RealtimePayload as a, type ChatMember as b, type ChatMessage as c, type PalbeRuntime as d, buildRuntime as e, type AnalyticsProperties as f, type AuthChangeEvent as g, type AuthState as h, type AuthSuccess as i, Call as j, type CallChangeCallback as k, type CallParticipant as l, type CallState as m, type ChatBackend as n, type ChatDraft as o, type ChatKind as p, type ChatMessageKind as q, type ChatRole as r, type ChatState as s, type CommsPrefs as t, type MentionRange as u, type MessageDirection as v, PalbeAnalytics as w, PalbeAuth as x, PalbeCalls as y, PalbeFlags as z };

package/dist/{analytics-facade-CQXCQSoF.d.cts → analytics-facade-f8IVujJW.d.cts}

@@ -612,9 +612,15 @@ declare class PalbeCalls {
      * @param media    - Which media tracks to publish (default: audio + video)
      * @returns        A `Call` in `connecting` state; transitions to `active` once the media room connects.
      *
-     * @throws BackendError('network', { code: 'call_service_unavailable' })  if the SFU is down (503)
-     * @throws BackendError('forbidden', { code: 'not_group_member' })       if the caller is not a member (403)
-     * @throws BackendError('conflict', { code: 'call_room_full' })          if the room is full (409)
+     * Every failure below arrives as kind `'server'` — this SDK's error kinds are
+     * `notConfigured | validation | unauthorized | rateLimited | server | network
+     * | decode`, and only a 401, a 429 or a 400 carrying a field-error array gets
+     * its own kind. So branch on `err.code`, never on the kind.
+     *
+     * @throws BackendError('server', { code: 'calling_unavailable' })  no SFU configured on this stack (503)
+     * @throws BackendError('server', { code: 'not_group_member' })     the caller is not a member of the group (403)
+     * @throws BackendError('server', { code: 'call_room_full' })       the call is at its participant limit (409)
+     * @throws BackendError('server', { code: 'call_provider_error' })  the media provider failed upstream (502)
      */
     start(groupId: string, { media }?: {
         media?: Array<'audio' | 'video'>;
@@ -623,7 +629,11 @@ declare class PalbeCalls {
      * Accept an incoming call in a messaging group.
      *
      * @param groupId  - Messaging group display-id
-     * @param callId   - Call identifier (from the push notification payload)
+     * @param callId   - Call identifier, carried by the `call_invite` the server
+     *   fans onto the group's conversation topic
+     *   (`pb.realtime.channel('messaging:conv:<rfcGroupId>').on('call_invite', …)`).
+     *   This SDK ships no web push: on the web the invite arrives over realtime or
+     *   over whatever signalling the app already runs.
      * @param media    - Which media tracks to publish (default: audio + video)
      */
     accept(groupId: string, callId: string, { media }?: {
@@ -1579,6 +1589,19 @@ interface RealtimeStatus {
     readonly lastEventAt: Date | null;
     onChange(callback: (status: RealtimeStatusSnapshot) => void): Unsubscribe;
 }
+/** Why the server refused a channel. */
+interface RealtimeChannelError {
+    /** The channel this is about. */
+    topic: string;
+    /** Exactly what the server said: `"unauthorized"` or `"unavailable"`. */
+    reason: string;
+    /**
+     * Whether asking again could succeed. `unavailable` (the project could not be
+     * reached to decide) is retryable and the socket retries it on reconnect;
+     * `unauthorized` is a settled answer and is not.
+     */
+    retryable: boolean;
+}
 /**
  * A subscription handle for one realtime channel (returned by
  * `pb.realtime.channel(name)` — the SAME instance per name). A channel is
@@ -1595,12 +1618,62 @@ declare class RealtimeChannel {
      * subscription and `cancel()` it to stop.
      */
     on(event: string, handler: RealtimeHandler): RealtimeSubscription;
+    /**
+     * Called when the server REFUSES this channel.
+     *
+     * A join is an authorization decision, and a decision the app never hears is
+     * the same as no decision at all: silence looks exactly like a slow network.
+     * This is where a refusal arrives, carrying the server's own distinction —
+     * `retryable: false` means "you may not" and asking again will not help;
+     * `retryable: true` means the project could not be asked, and the socket's
+     * next reconnect retries on its own.
+     *
+     *     pb.realtime.channel('room:42').onError((err) => {
+     *       if (!err.retryable) showJoinDenied()
+     *     })
+     */
+    onError(handler: (error: RealtimeChannelError) => void): RealtimeSubscription;
     /**
      * Broadcast `payload` to the channel's other subscribers (web addition —
      * iOS is receive-only). Joins the channel if it isn't already; queued
      * until the join is live on the socket.
      */
     send(event: string, payload?: RealtimePayload): void;
+    /**
+     * Watch one key of the channel's shared state.
+     *
+     * The handler is called with the CURRENT value straight away when there is
+     * one, and again on every change. That is the difference from `on()`: a
+     * subscriber to an event learns nothing until the next one, while state is
+     * already there when you ask.
+     */
+    onState(key: string, handler: (value: unknown) => void): RealtimeSubscription;
+    /** Read one key without subscribing. */
+    stateValue(key: string): unknown;
+    /** Write one key. `durable` outlives this connection; `ephemeral` is reaped
+     * when it closes, which is what presence is built on. */
+    setState(key: string, value: unknown, opts?: {
+        life?: 'ephemeral' | 'durable';
+    }): void;
+    /** Remove a key this connection wrote. */
+    clearState(key: string): void;
+    /**
+     * Announce this client on the channel. `meta` is whatever other participants
+     * should see — a name, an avatar, a cursor.
+     *
+     * It is ephemeral state keyed by this connection, so it disappears when the
+     * socket does. Nothing has to be un-announced on a crash.
+     */
+    presenceEnter(meta: RealtimePayload): void;
+    /** Replace the announced value — a cursor moving is this, at whatever rate
+     * the app likes: the server conflates writes it cannot deliver fast enough. */
+    presenceUpdate(meta: RealtimePayload): void;
+    /** Leave early. Closing the socket does this on its own. */
+    presenceLeave(): void;
+    /** Everyone else currently announced, this client excluded. */
+    presenceOthers(): unknown[];
+    /** Watch the announced set. Called on every change. */
+    onPresence(handler: (others: unknown[]) => void): RealtimeSubscription;
 }
 declare class PalbeRealtime {
     private readonly rt;
@@ -1608,7 +1681,13 @@ declare class PalbeRealtime {
     private readonly channels;
     private readonly statusStore;
     private readonly handlers;
+    private readonly errorHandlers;
     private readonly topicRefcount;
+    private readonly states;
+    private readonly connIds;
+    private readonly pendingPresence;
+    private readonly stateWatchers;
+    private readonly presenceWatchers;
     constructor(rt: PalbeRuntime);
     /**
      * Get the handle for an app-defined channel (e.g. "room:42"). The same
@@ -1624,16 +1703,52 @@ declare class PalbeRealtime {
     destroy(): void;
     /** The observable connection status. Safe to read anywhere (reports `idle` until a socket exists). */
     get status(): RealtimeStatus;
+    /**
+     * Hand the socket a fresher credential for the SAME user, without rejoining.
+     *
+     * Called when the app's token rotates. The alternative — letting the channels
+     * die at expiry and rejoining — reaps this connection's ephemeral entries
+     * (its presence, on every channel) and forces a full state resync. A token
+     * getting older is not a disconnection and must not cost one.
+     *
+     * A no-op before a socket exists: the first connect resolves a fresh token
+     * on its own.
+     */
+    refreshToken(token: string): void;
     /** Lazily build + start the shared socket on first subscription/send. */
     private ensureSocket;
     private route;
     /**
-     * A channel died for good (token-expiry rejoin exhausted N attempts). Drop its
-     * handlers + refcount so the app stops expecting events on it, and flip the
-     * status observable to `'error'` (the React `useChannel` hook reports this).
-     * A later `.on()` for the same topic re-joins from scratch (refcount 1).
+    /**
+     * The server refused a channel. Tell whoever asked, and — when the answer is
+     * final — stop pretending the app is subscribed to it.
+     *
+     * `unavailable` leaves everything in place: the project could not be reached
+     * to decide, the socket rejoins on its next reconnect, and dropping the app's
+     * handlers would make a momentary outage look like a permanent denial.
+     */
+    private handleChannelRefused;
+    /**
+     * A channel died for good — a token-expiry rejoin that exhausted its attempts.
+     * The app must stop expecting anything on it, and the status observable flips
+     * to `'error'` (the React `useChannel` hook reports that).
+     *
+     * It clears the SAME registries a final refusal clears, and used to clear only
+     * the event handlers. A state or presence watcher left behind here waits
+     * forever for a snapshot that cannot arrive, and fires twice if the app ever
+     * re-subscribes — the identical failure its sibling three functions up
+     * describes, on a channel that was given up on rather than refused.
      */
     private handleChannelError;
+    /** Drop every registration this topic holds. One place, because "which
+     *  registries" is a question two callers must never answer differently. */
+    private forgetTopic;
+    private retainTopic;
+    private releaseTopic;
+    private applySnapshot;
+    private applyDiff;
+    private applyJoinInfo;
+    private notifyState;
 }
 
 interface PalbeRuntime {
@@ -1758,10 +1873,16 @@ declare class PalbeAuth {
      * Self-service account erasure ("right to be forgotten"). Calls palauth
      * `DELETE /auth/user` (session-authed + fresh re-auth): password users pass
      * `{ password }`; passwordless/OAuth users rely on a freshly stepped-up
-     * session. On 202 the erasure workflow is durably queued AND every session is
-     * already revoked server-side — so we tear down local state (mirroring
-     * `signOut()`'s clear, minus the pointless `/logout`) and emit
-     * `signedOut{reason:'accountDeleted'}`.
+     * session. The handler answers **204 with no body** — the erasure has already
+     * finished and every session is already revoked server-side — so we tear down
+     * local state (mirroring `signOut()`'s clear, minus the pointless `/logout`)
+     * and emit `signedOut{reason:'accountDeleted'}`.
+     *
+     * Returns nothing, because there is nothing to return: the handler used to
+     * answer 202 with an `{erasure_id}` naming an asynchronous run, and that id
+     * was removed along with the run (`gdpr_handlers.go:221-229`). Reading it
+     * here threw a `TypeError` AFTER the account was already gone — a success
+     * reported as a failure.
      *
      * On 401 `reauth_required` / 503 `not_configured` (or `erasure_unavailable`)
      * the request throws BEFORE the teardown line, so the local session is left
@@ -1769,9 +1890,7 @@ declare class PalbeAuth {
      */
     deleteAccount(params?: {
         password?: string;
-    }): Promise<{
-        erasureId: string;
-    }>;
+    }): Promise<void>;
     getUser(): Promise<AuthUser>;
     /**
      * Which credentials this account actually has.
@@ -2014,4 +2133,4 @@ declare class PalbeAnalytics {
     private post;
 }
 
-export { type AuthUser as A, PalbeMessaging as B, Chat as C, type PalbeOAuthConfig as D, PalbeRealtime as E, type FlagsView as F, type PresenceState as G, RealtimeChannel as H, type RealtimeHandler as I, type RealtimeStatus as J, type RealtimeStatusSnapshot as K, type RealtimeSubscription as L, type MagicLinkResult as M, type NotifyScope as N, type OAuthExchangeResult as O, type PalbeConfig as P, type ResolvedMention as Q, type RealtimeConnectionState as R, type ResolvedReply as S, type SentReceipt as T, type SignInMethods as U, type UnreadView as V, type Unsubscribe as W, PalbePerf as X, type RealtimePayload as a, type ChatMember as b, type ChatMessage as c, type PalbeRuntime as d, buildRuntime as e, type AnalyticsProperties as f, type AuthChangeEvent as g, type AuthState as h, type AuthSuccess as i, Call as j, type CallChangeCallback as k, type CallParticipant as l, type CallState as m, type ChatBackend as n, type ChatDraft as o, type ChatKind as p, type ChatMessageKind as q, type ChatRole as r, type ChatState as s, type CommsPrefs as t, type MentionRange as u, type MessageDirection as v, PalbeAnalytics as w, PalbeAuth as x, PalbeCalls as y, PalbeFlags as z };
+export { type AuthUser as A, PalbeMessaging as B, Chat as C, type PalbeOAuthConfig as D, PalbeRealtime as E, type FlagsView as F, type PresenceState as G, RealtimeChannel as H, type RealtimeChannelError as I, type RealtimeHandler as J, type RealtimeStatus as K, type RealtimeStatusSnapshot as L, type MagicLinkResult as M, type NotifyScope as N, type OAuthExchangeResult as O, type PalbeConfig as P, type RealtimeSubscription as Q, type RealtimeConnectionState as R, type ResolvedMention as S, type ResolvedReply as T, type SentReceipt as U, type SignInMethods as V, type UnreadView as W, type Unsubscribe as X, PalbePerf as Y, type RealtimePayload as a, type ChatMember as b, type ChatMessage as c, type PalbeRuntime as d, buildRuntime as e, type AnalyticsProperties as f, type AuthChangeEvent as g, type AuthState as h, type AuthSuccess as i, Call as j, type CallChangeCallback as k, type CallParticipant as l, type CallState as m, type ChatBackend as n, type ChatDraft as o, type ChatKind as p, type ChatMessageKind as q, type ChatRole as r, type ChatState as s, type CommsPrefs as t, type MentionRange as u, type MessageDirection as v, PalbeAnalytics as w, PalbeAuth as x, PalbeCalls as y, PalbeFlags as z };

package/dist/{chunk-EAOROUSW.js → chunk-4WMJTUDN.js}

@@ -144,6 +144,15 @@ function parseEnvironmentRef(apiKey) {
 var MAX_RETRIES = 3;
 var INITIAL_BACKOFF_MS = 200;
 var MAX_RETRY_DELAY_MS = 1e4;
+function withRetryHint(body, response) {
+  if (response.status !== 429) return body;
+  const data = body?.data;
+  const alreadyStated = typeof body?.retry_after === "number" || typeof data === "object" && data !== null && "retryAfter" in data;
+  if (alreadyStated) return body;
+  const seconds = Number.parseInt(response.headers.get("Retry-After") ?? "", 10);
+  if (Number.isNaN(seconds) || seconds <= 0) return body;
+  return { ...body, retry_after: seconds };
+}
 var HttpClient = class _HttpClient {
   apiKey;
   options;
@@ -319,7 +328,7 @@ var HttpClient = class _HttpClient {
           errorBody?.error ?? "unknown_error",
           errorBody?.error_description ?? response.statusText,
           response.status,
-          errorBody
+          withRetryHint(errorBody, response)
         ),
         status: response.status
       };
@@ -442,6 +451,15 @@ function isFieldErrorArray(value) {
     (v) => typeof v === "object" && v !== null && typeof v.field === "string" && typeof v.message === "string"
   );
 }
+function fieldErrorsOf(envelope) {
+  const scoped = pickField(pickField(envelope, "data"), "fields");
+  if (isFieldErrorArray(scoped)) return scoped;
+  const flat = pickField(envelope, "fields");
+  return isFieldErrorArray(flat) ? flat : void 0;
+}
+function retryAfterOf(envelope) {
+  return pickNumber(envelope, "retry_after") ?? pickNumber(pickField(envelope, "data"), "retryAfter");
+}
 function pickField(value, key) {
   if (typeof value === "object" && value !== null) {
     return value[key];
@@ -467,20 +485,15 @@ function fromPalbaseError(err) {
   if (err.code === "network_error") return new BackendError("network", base);
   if (err.status === 401) return new BackendError("unauthorized", base);
   if (err.status === 429)
-    return new BackendError("rateLimited", {
-      ...base,
-      retryAfter: pickNumber(err.details, "retry_after")
-    });
-  const nested = pickField(err.details, "details");
-  if (err.status === 400 && isFieldErrorArray(nested))
-    return new BackendError("validation", { ...base, fields: nested });
+    return new BackendError("rateLimited", { ...base, retryAfter: retryAfterOf(err.details) });
+  const fields = fieldErrorsOf(err.details);
+  if (err.status === 400 && fields) return new BackendError("validation", { ...base, fields });
   return new BackendError("server", base);
 }
 function fromEnvelope(status, body) {
   const code = pickString(body, "error") ?? "http_error";
   const message = pickString(body, "error_description") ?? `HTTP ${status}`;
   const requestId = pickString(body, "request_id");
-  const details = pickField(body, "details");
   const params = {
     code,
     message,
@@ -490,13 +503,9 @@ function fromEnvelope(status, body) {
   };
   if (status === 401) return new BackendError("unauthorized", params);
   if (status === 429)
-    return new BackendError("rateLimited", {
-      ...params,
-      // Real 429 wire body has TOP-LEVEL retry_after; nested details is a fallback.
-      retryAfter: pickNumber(body, "retry_after") ?? pickNumber(details, "retry_after")
-    });
-  if (status === 400 && isFieldErrorArray(details))
-    return new BackendError("validation", { ...params, fields: details });
+    return new BackendError("rateLimited", { ...params, retryAfter: retryAfterOf(body) });
+  const fields = fieldErrorsOf(body);
+  if (status === 400 && fields) return new BackendError("validation", { ...params, fields });
   return new BackendError("server", params);
 }
 function isBackendError(e) {
@@ -525,4 +534,4 @@ export {
   asPalbaseError,
   unwrap
 };
-//# sourceMappingURL=chunk-EAOROUSW.js.map
+//# sourceMappingURL=chunk-4WMJTUDN.js.map