@obsidiane/meridiane 2.0.13 → 3.0.1

package/templates/angular-bridge/src/lib/bridge/sse/mercure-hub.ts

@@ -0,0 +1,449 @@
+import {inject, Injectable, OnDestroy, PLATFORM_ID, signal} from '@angular/core';
+import {DOCUMENT, isPlatformBrowser} from '@angular/common';
+import {HttpClient} from '@angular/common/http';
+import {BehaviorSubject, EMPTY, firstValueFrom, Observable, Subject} from 'rxjs';
+import {distinctUntilChanged, filter, map} from 'rxjs/operators';
+import {API_BASE_URL, BRIDGE_HTTP_WITH_CREDENTIALS, BRIDGE_LOGGER, BRIDGE_MERCURE} from '../../tokens';
+import {RealtimeDiagnostics, RealtimeStatus} from '../../bridge.types';
+import {
+  MercureSubscription,
+  MercureUpdate,
+  RealtimePort,
+  RealtimeSubscribeOptions,
+} from '../../ports/realtime.port';
+import {resolveUrl, toAbsoluteUrl} from '../../utils/url';
+import {buildSubscribeUrl, subscriptionKey} from './mercure-url';
+
+const RETRY_MIN_DELAY_MS = 1_000;
+const RETRY_MAX_DELAY_MS = 30_000;
+/** Renewal margin before the authorization cookie expires. */
+const RENEW_BEFORE_EXPIRY_MS = 5_000;
+/** Maximum number of `match*` parameters the reference hub accepts in one subscription request. */
+const MAX_MATCHERS = 100;
+const DEFAULT_MAX_URL_LENGTH = 4_000;
+const SHARED_GROUP = 'shared';
+
+/** One `EventSource` and the subscriptions it carries. */
+type HubConnection = {
+  /** Subscriptions only share connections of the same group. */
+  group: string;
+  /** `shared`, `dedicated` or the connection name, as exposed in the diagnostics. */
+  label: string;
+  subscriptions: Map<string, MercureSubscription>;
+  source?: EventSource;
+  /** Subscribe URL of the open source (without `last_event_id`). */
+  url?: string;
+  status: RealtimeStatus;
+  lastEventId?: string;
+  failures: number;
+  retryTimer?: ReturnType<typeof setTimeout>;
+};
+
+type ActiveSubscription = {
+  subscription: MercureSubscription;
+  consumers: number;
+  connection: HubConnection;
+};
+
+type GroupedUpdate = {
+  group: string;
+  update: MercureUpdate;
+};
+
+/**
+ * Mercure connections of the whole application.
+ *
+ * Subscriptions are spread over as few connections as possible within their group (`shared` by default, a name,
+ * or one connection per `dedicated` subscription): a connection takes subscriptions until its subscribe URL would
+ * exceed `maxUrlLength` or 100 matchers. Mercure cannot change the subscriptions of an open stream, so a connection
+ * is reopened when its own subscriptions change, with `last_event_id` set to its last received update to request
+ * replay from the hub's retained history.
+ */
+@Injectable({providedIn: 'root'})
+export class MercureHub implements RealtimePort, OnDestroy {
+  private readonly options = inject(BRIDGE_MERCURE, {optional: true}) ?? undefined;
+  private readonly http = inject(HttpClient);
+  private readonly apiBaseUrl = inject(API_BASE_URL);
+  private readonly httpWithCredentials = inject(BRIDGE_HTTP_WITH_CREDENTIALS);
+  private readonly logger = inject(BRIDGE_LOGGER, {optional: true}) ?? undefined;
+  private readonly hubUrl = this.options
+    ? toAbsoluteUrl(this.options.hubUrl, toAbsoluteUrl(this.apiBaseUrl, inject(DOCUMENT).baseURI))
+    : undefined;
+  private readonly withCredentials = this.options?.withCredentials ?? true;
+  private readonly maxUrlLength = this.options?.maxUrlLength ?? DEFAULT_MAX_URL_LENGTH;
+  private readonly enabled = !!this.hubUrl && isPlatformBrowser(inject(PLATFORM_ID));
+
+  private readonly subscriptions = new Map<string, ActiveSubscription>();
+  private readonly connections: HubConnection[] = [];
+  private readonly updates = new Subject<GroupedUpdate>();
+  private readonly diagnostics = new BehaviorSubject<RealtimeDiagnostics>(this.snapshot());
+  private readonly statusSignal = signal<RealtimeStatus>('closed');
+
+  readonly status = this.statusSignal.asReadonly();
+
+  private authorization?: Promise<void>;
+  private authorizing = false;
+  private renewTimer?: ReturnType<typeof setTimeout>;
+  private destroyed = false;
+  private suspended = false;
+  private dedicatedSequence = 0;
+  private syncTimer?: ReturnType<typeof setTimeout>;
+
+  private readonly onPageHide = (event: PageTransitionEvent) => {
+    // Free the connections, and let the page enter the back/forward cache.
+    if (!event.persisted) return;
+    this.suspended = true;
+    clearTimeout(this.syncTimer);
+    for (const connection of this.connections) {
+      this.closeSource(connection);
+      connection.status = 'closed';
+    }
+    this.publishDiagnostics();
+  };
+  private readonly onPageShow = (event: PageTransitionEvent) => {
+    if (!event.persisted) return;
+    this.suspended = false;
+    this.scheduleSync();
+  };
+
+  constructor() {
+    if (this.enabled) {
+      window.addEventListener('pagehide', this.onPageHide);
+      window.addEventListener('pageshow', this.onPageShow);
+    }
+  }
+
+  subscribe$(subscription: MercureSubscription, options?: RealtimeSubscribeOptions): Observable<MercureUpdate> {
+    if (!this.enabled || this.destroyed) {
+      if (!this.hubUrl) this.logger?.debug?.('[Mercure] hubUrl not configured: realtime disabled');
+      return EMPTY;
+    }
+
+    return new Observable<MercureUpdate>((subscriber) => {
+      const {group, label} = this.groupOf(options?.connection);
+      const updates = this.updates
+        .pipe(
+          filter((grouped) => grouped.group === group),
+          map((grouped) => grouped.update)
+        )
+        .subscribe(subscriber);
+      const key = this.retain(group, label, subscription);
+      return () => {
+        updates.unsubscribe();
+        this.release(key);
+      };
+    });
+  }
+
+  reconnect(): void {
+    if (!this.enabled || this.destroyed) return;
+    void this.authorize('restart').then(() => {
+      if (this.destroyed || this.suspended) return;
+      for (const connection of this.connections) {
+        if (connection.subscriptions.size > 0) this.open(connection, this.subscribeUrl(connection.subscriptions));
+      }
+      this.publishDiagnostics();
+    });
+  }
+
+  status$(): Observable<RealtimeStatus> {
+    return this.diagnostics.pipe(map((diagnostics) => diagnostics.status), distinctUntilChanged());
+  }
+
+  diagnostics$(): Observable<RealtimeDiagnostics> {
+    return this.diagnostics.asObservable();
+  }
+
+  ngOnDestroy(): void {
+    this.destroyed = true;
+    clearTimeout(this.syncTimer);
+    clearTimeout(this.renewTimer);
+    for (const connection of this.connections) this.closeSource(connection);
+    this.connections.length = 0;
+    this.subscriptions.clear();
+    if (this.enabled) {
+      window.removeEventListener('pagehide', this.onPageHide);
+      window.removeEventListener('pageshow', this.onPageShow);
+    }
+    this.updates.complete();
+    this.diagnostics.complete();
+  }
+
+  private groupOf(connection: RealtimeSubscribeOptions['connection'] = SHARED_GROUP): {group: string; label: string} {
+    if (connection === 'dedicated') return {group: `dedicated:${++this.dedicatedSequence}`, label: connection};
+    if (connection === SHARED_GROUP) return {group: SHARED_GROUP, label: connection};
+    return {group: `named:${connection}`, label: connection};
+  }
+
+  /** Returns the key of the subscription, shared by its consumers within the group. */
+  private retain(group: string, label: string, subscription: MercureSubscription): string {
+    const key = `${group} ${subscriptionKey(subscription)}`;
+    const active = this.subscriptions.get(key);
+    if (active) {
+      active.consumers++;
+      this.publishDiagnostics();
+      return key;
+    }
+
+    const connection = this.connectionFor(group, label, key, subscription);
+    connection.subscriptions.set(key, subscription);
+    this.subscriptions.set(key, {subscription, consumers: 1, connection});
+    this.scheduleSync();
+    return key;
+  }
+
+  private release(key: string): void {
+    const active = this.subscriptions.get(key);
+    if (!active) return;
+
+    if (--active.consumers > 0) {
+      this.publishDiagnostics();
+      return;
+    }
+
+    this.subscriptions.delete(key);
+    active.connection.subscriptions.delete(key);
+    this.scheduleSync();
+  }
+
+  /** First connection of the group that stays within the limits with this subscription, or a new connection. */
+  private connectionFor(group: string, label: string, key: string, subscription: MercureSubscription): HubConnection {
+    const fitting = this.connections.find((connection) => {
+      if (connection.group !== group || connection.subscriptions.size >= MAX_MATCHERS) return false;
+      const subscriptions = new Map(connection.subscriptions).set(key, subscription);
+      return this.subscribeUrl(subscriptions).length <= this.maxUrlLength;
+    });
+    if (fitting) return fitting;
+
+    const connection: HubConnection = {group, label, subscriptions: new Map(), status: 'closed', failures: 0};
+    this.connections.push(connection);
+    return connection;
+  }
+
+  /** Coalesces the subscription changes of the current task (e.g. a route change) into one reconciliation. */
+  private scheduleSync(): void {
+    if (this.destroyed || this.suspended) return;
+    clearTimeout(this.syncTimer);
+    this.syncTimer = setTimeout(() => void this.sync());
+  }
+
+  private async sync(): Promise<void> {
+    await this.authorize();
+    if (this.destroyed || this.suspended) return;
+
+    for (const connection of [...this.connections]) {
+      if (connection.subscriptions.size === 0) {
+        this.remove(connection);
+        continue;
+      }
+      // A refused connection is reopened by its retry, with its subscriptions at that time.
+      if (connection.retryTimer) continue;
+
+      const url = this.subscribeUrl(connection.subscriptions);
+      if (connection.source && url === connection.url) continue;
+      this.open(connection, url);
+    }
+    this.publishDiagnostics();
+  }
+
+  private open(connection: HubConnection, url: string): void {
+    this.closeSource(connection);
+    if (url.length > this.maxUrlLength) {
+      this.logger?.warn?.('[Mercure] a single subscription exceeds maxUrlLength', {url});
+    }
+
+    const resumeUrl = this.subscribeUrl(connection.subscriptions, connection.lastEventId);
+    this.logger?.debug?.('[Mercure] connect', {url: resumeUrl});
+
+    const source = new EventSource(resumeUrl, {withCredentials: this.withCredentials});
+    connection.source = source;
+    connection.url = url;
+    connection.status = 'connecting';
+
+    source.onopen = () => {
+      if (connection.source !== source) return;
+      connection.failures = 0;
+      connection.status = 'connected';
+      this.publishDiagnostics();
+    };
+
+    source.onmessage = (event) => {
+      if (connection.source !== source) return;
+      if (event.lastEventId) {
+        connection.lastEventId = event.lastEventId;
+        this.publishDiagnostics();
+      }
+      const data = parseJson(event.data);
+      if (data === undefined) {
+        this.logger?.debug?.('[Mercure] non-JSON update ignored', {id: event.lastEventId});
+        return;
+      }
+      this.updates.next({group: connection.group, update: {id: event.lastEventId || undefined, data}});
+    };
+
+    source.onerror = () => {
+      if (connection.source !== source) return;
+      if (source.readyState !== EventSource.CLOSED) {
+        // Network interruption, or the hub ending the stream before the token expires:
+        // the browser reconnects by itself, with `Last-Event-ID` and the current cookie.
+        connection.status = 'connecting';
+        this.publishDiagnostics();
+        return;
+      }
+
+      // The hub refused the request (401 / 403 / 429 / 400...): EventSource gives up.
+      // Renew the authorization (e.g. expired token), then reopen with backoff.
+      connection.failures++;
+      this.closeSource(connection);
+      connection.status = 'connecting';
+      const delay = Math.min(RETRY_MIN_DELAY_MS * 2 ** (connection.failures - 1), RETRY_MAX_DELAY_MS);
+      this.logger?.warn?.('[Mercure] subscription refused by the hub, retrying', {delay, failures: connection.failures});
+      connection.retryTimer = setTimeout(() => void this.retry(connection), delay);
+      this.publishDiagnostics();
+    };
+  }
+
+  /**
+   * The hub ends each stream before its token expires, and the browser reconnects by itself with `Last-Event-ID`.
+   * When the authorization endpoint returns `expiresIn`, the cookie is renewed 5 seconds before it expires, so that
+   * reconnections keep carrying a valid token instead of being refused.
+   */
+  private scheduleRenewal(expiresIn: number | undefined): void {
+    clearTimeout(this.renewTimer);
+    if (expiresIn === undefined || this.destroyed) return;
+
+    this.renewTimer = setTimeout(() => {
+      if (this.connections.some((connection) => connection.subscriptions.size > 0)) {
+        void this.authorize('renew');
+      } else {
+        // Nothing open: the next connection asks for a new cookie.
+        this.authorization = undefined;
+      }
+    }, Math.max(expiresIn * 1_000 - RENEW_BEFORE_EXPIRY_MS, RETRY_MIN_DELAY_MS));
+  }
+
+  private async retry(connection: HubConnection): Promise<void> {
+    await this.authorize('renew');
+    connection.retryTimer = undefined;
+    if (this.destroyed || this.suspended || !this.connections.includes(connection)) return;
+
+    if (connection.subscriptions.size === 0) this.remove(connection);
+    else this.open(connection, this.subscribeUrl(connection.subscriptions));
+    this.publishDiagnostics();
+  }
+
+  /**
+   * Obtains the authorization cookie.
+   * - `once`: the first time only.
+   * - `renew` (refused connection): again, sharing the request in flight.
+   * - `restart` (e.g. after a login or logout): again, once the request in flight is over, so the cookie set last
+   *   belongs to the current identity.
+   *
+   * Resolves once the latest request is over: a request started meanwhile (e.g. by `reconnect()`) supersedes this one.
+   */
+  private async authorize(mode: 'once' | 'renew' | 'restart' = 'once'): Promise<void> {
+    let authorization = this.requestAuthorization(mode);
+    while (authorization) {
+      await authorization;
+      if (authorization === this.authorization) return;
+      authorization = this.authorization;
+    }
+  }
+
+  private requestAuthorization(mode: 'once' | 'renew' | 'restart'): Promise<void> | undefined {
+    const authorize = this.options?.authorize;
+    if (!authorize) return undefined;
+    if (this.authorization && (mode === 'once' || (mode === 'renew' && this.authorizing))) return this.authorization;
+
+    const request = () => typeof authorize === 'function'
+      ? authorize()
+      : firstValueFrom(
+        this.http.get(resolveUrl(this.apiBaseUrl, authorize), {withCredentials: this.httpWithCredentials}),
+        {defaultValue: undefined}
+      );
+    const authorization: Promise<void> = (this.authorizing ? this.authorization! : Promise.resolve())
+      .then(request)
+      .then(
+        (response) => {
+          if (this.authorization === authorization) this.scheduleRenewal(expiresInOf(response));
+        },
+        (error: unknown) => this.logger?.warn?.('[Mercure] authorization failed', error)
+      )
+      .finally(() => {
+        if (this.authorization === authorization) this.authorizing = false;
+      });
+    this.authorization = authorization;
+    this.authorizing = true;
+    return authorization;
+  }
+
+  private remove(connection: HubConnection): void {
+    this.closeSource(connection);
+    this.connections.splice(this.connections.indexOf(connection), 1);
+  }
+
+  private closeSource(connection: HubConnection): void {
+    clearTimeout(connection.retryTimer);
+    connection.retryTimer = undefined;
+    if (!connection.source) return;
+
+    connection.source.onopen = null;
+    connection.source.onmessage = null;
+    connection.source.onerror = null;
+    connection.source.close();
+    connection.source = undefined;
+    connection.url = undefined;
+    this.logger?.debug?.('[Mercure] closed');
+  }
+
+  private subscribeUrl(subscriptions: Map<string, MercureSubscription>, lastEventId?: string): string {
+    const sorted = [...subscriptions.entries()]
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([, subscription]) => subscription);
+    return buildSubscribeUrl(this.hubUrl!, sorted, lastEventId);
+  }
+
+  private publishDiagnostics(): void {
+    const diagnostics = this.snapshot();
+    this.statusSignal.set(diagnostics.status);
+    this.diagnostics.next(diagnostics);
+  }
+
+  private snapshot(): RealtimeDiagnostics {
+    return {
+      status: aggregateStatus(this.connections.map((connection) => connection.status)),
+      connections: this.connections.map((connection) => ({
+        connection: connection.label,
+        status: connection.status,
+        url: connection.url,
+        subscriptions: [...connection.subscriptions.entries()].map(([key, subscription]) => ({
+          match: subscription.match,
+          type: subscription.type,
+          consumers: this.subscriptions.get(key)?.consumers ?? 0,
+        })),
+        lastEventId: connection.lastEventId,
+        failures: connection.failures,
+      })),
+    };
+  }
+}
+
+function aggregateStatus(statuses: RealtimeStatus[]): RealtimeStatus {
+  if (statuses.every((status) => status === 'closed')) return 'closed';
+  if (statuses.every((status) => status === 'connected')) return 'connected';
+  return 'connecting';
+}
+
+/** `expiresIn` (seconds) of the authorization response, when the endpoint returns it. */
+function expiresInOf(response: unknown): number | undefined {
+  const expiresIn = (response as {expiresIn?: unknown} | null | undefined)?.expiresIn;
+  return typeof expiresIn === 'number' && expiresIn > 0 ? expiresIn : undefined;
+}
+
+function parseJson(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+}

package/templates/angular-bridge/src/lib/bridge/sse/mercure-url.ts

@@ -0,0 +1,28 @@
+import type {MercureSubscription} from '../../ports/realtime.port';
+
+const MATCH_PARAMETER: Record<MercureSubscription['type'], string> = {
+  exact: 'match',
+  urlpattern: 'match_urlpattern',
+};
+
+/**
+ * Builds a Mercure 1.0 subscribe URL: one `match` / `match_urlpattern` parameter per subscription,
+ * plus `last_event_id` to resume from the last received update (browsers cannot set the
+ * `Last-Event-ID` header on the first request).
+ */
+export function buildSubscribeUrl(
+  hubUrl: string,
+  subscriptions: Iterable<MercureSubscription>,
+  lastEventId?: string
+): string {
+  const url = new URL(hubUrl);
+  for (const subscription of subscriptions) {
+    url.searchParams.append(MATCH_PARAMETER[subscription.type], subscription.match);
+  }
+  if (lastEventId) url.searchParams.set('last_event_id', lastEventId);
+  return url.toString();
+}
+
+export function subscriptionKey(subscription: MercureSubscription): string {
+  return `${subscription.type} ${subscription.match}`;
+}

package/templates/angular-bridge/src/lib/bridge/sse/resource-topic.ts

@@ -0,0 +1,83 @@
+import type {Item} from '../../ports/resource-repository.port';
+import type {MercureSubscription} from '../../ports/realtime.port';
+import {resolveUrl} from '../../utils/url';
+
+/**
+ * Payload API Platform publishes on deletion: `{"@id"}`, plus `@type` with `mercure.include_type`.
+ * Never a `@context`, unlike a serialized resource: a generated model therefore never matches this type.
+ */
+export interface ResourceDeletion {
+  '@id': string;
+  '@type'?: string | string[];
+  '@context'?: never;
+}
+
+interface UrlPatternLike {
+  test(input: string): boolean;
+}
+
+type UrlPatternConstructor = new (input: string) => UrlPatternLike;
+
+/**
+ * Recognizes the deletion payload API Platform builds by hand. Creations and updates are serialized
+ * resources, which always carry `@context` in JSON-LD.
+ */
+export function isResourceDeletion(payload: object): payload is ResourceDeletion {
+  return typeof (payload as ResourceDeletion)['@id'] === 'string'
+    && Object.keys(payload).every((key) => key === '@id' || key === '@type');
+}
+
+/**
+ * A resource URL Pattern or an exact item IRI, as published by API Platform.
+ * The same selector is sent to the hub and used to route updates by `@id`.
+ */
+export class ResourceTopic implements MercureSubscription {
+  readonly match: string;
+  readonly type: MercureSubscription['type'];
+  private readonly apiBaseUrl: string;
+  private pattern?: UrlPatternLike;
+
+  constructor(
+    match: string,
+    apiBaseUrl: string,
+    type: MercureSubscription['type'] = 'urlpattern',
+  ) {
+    this.match = match;
+    this.apiBaseUrl = apiBaseUrl;
+    this.type = type;
+  }
+
+  forIri(iri: string): ResourceTopic {
+    if (!iri.trim()) throw new Error('ResourceFacade.watch$(): missing resource IRI');
+    return new ResourceTopic(resolveUrl(this.apiBaseUrl, iri), this.apiBaseUrl, 'exact');
+  }
+
+  /** Returns the original payload, or `undefined` when it belongs to another resource. */
+  toResource<T extends Item>(payload: unknown): T | ResourceDeletion | undefined {
+    if (!isRecord(payload)) return undefined;
+
+    const iri = payload['@id'];
+    if (typeof iri !== 'string' || !this.matches(iri)) return undefined;
+
+    return payload as T | ResourceDeletion;
+  }
+
+  private matches(iri: string): boolean {
+    const url = resolveUrl(this.apiBaseUrl, iri);
+    if (this.type === 'exact') return url === this.match;
+    this.pattern ??= compileUrlPattern(this.match);
+    return this.pattern.test(url);
+  }
+}
+
+function compileUrlPattern(pattern: string): UrlPatternLike {
+  const URLPatternImpl = (globalThis as {URLPattern?: UrlPatternConstructor}).URLPattern;
+  if (!URLPatternImpl) {
+    throw new Error('URLPattern is not available in this environment: load a polyfill such as `urlpattern-polyfill`.');
+  }
+  return new URLPatternImpl(pattern);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}

package/templates/angular-bridge/src/lib/bridge-options.ts

@@ -1,5 +1,5 @@
 import {HttpInterceptorFn} from '@angular/common/http';
-import {BridgeDefaults, MercureConnectionMode, MercureTopicMode} from './bridge.types';
+import {BridgeDefaults} from './bridge.types';
 
 export type BridgeAuth =
   | string
@@ -8,29 +8,33 @@ export type BridgeAuth =
   | HttpInterceptorFn;
 
 export interface BridgeMercureOptions {
-  hubUrl?: string;
-  init?: RequestInit;
-  topicMode?: MercureTopicMode;
+  /** Mercure hub URL (e.g. `https://api.example.com/.well-known/mercure`), resolved against `baseUrl` when relative. */
+  hubUrl: string;
   /**
-   * Connection strategy for SSE subscriptions.
-   * - `single`: one SSE connection per watch subscription
-   * - `auto` (default): shared connections with automatic URL-length sharding
+   * Sends cookies with the subscription request. Default: `true`.
+   *
+   * Browsers authenticate to a Mercure 1.0 hub with the HttpOnly `__Secure-mercure_access_token`
+   * cookie set by the backend (`EventSource` cannot send an `Authorization` header).
+   */
+  withCredentials?: boolean;
+  /**
+   * Obtains the Mercure authorization cookie: an API endpoint called with `GET` (e.g. `/api/mercure/authorization`),
+   * or a function. Called before the first connection and after each connection refused by the hub
+   * (e.g. expired token), before reconnecting.
+   *
+   * When the endpoint returns (or the function resolves) `{expiresIn: <seconds>}`, the cookie is renewed 5 seconds
+   * before it expires: when the hub ends a connection, the browser reconnects with a valid one.
    */
-  connectionMode?: MercureConnectionMode;
+  authorize?: string | (() => Promise<unknown>);
   /**
-   * Maximum Mercure URL length before auto-sharding topics into multiple connections.
-   * Used only when `connectionMode: 'auto'`. Default: `1900`.
+   * Maximum length of a subscribe URL (without `last_event_id`). Beyond it, or beyond 100 subscriptions,
+   * the bridge opens another connection. Default: `4000`.
    */
   maxUrlLength?: number;
 }
 
 export interface BridgeHttpOptions {
-  /**
-   * Enables cookies / credentials on HTTP requests by default.
-   *
-   * When omitted, the bridge preserves the historical behavior and derives the
-   * HTTP value from `mercure.init.credentials`.
-   */
+  /** Enables cookies / credentials on HTTP requests by default. Default: `false`. */
   withCredentials?: boolean;
 }
 
@@ -41,7 +45,7 @@ export interface BridgeOptions {
   auth?: BridgeAuth;
   /** Default HTTP transport options. */
   http?: BridgeHttpOptions;
-  /** Use `topicMode` to control the `topic=` values sent to the hub. */
+  /** Enables Mercure realtime. */
   mercure?: BridgeMercureOptions;
   /** Default HTTP behaviour (headers, timeout, retries). */
   defaults?: BridgeDefaults;