@obsidiane/meridiane 2.0.10 → 2.0.11

package/templates/{_lib_template → angular-bridge}/src/lib/facades/bridge.facade.ts

@@ -3,12 +3,13 @@ import {HttpClient} from '@angular/common/http';
 import {Observable} from 'rxjs';
 import {filter, map, share} from 'rxjs/operators';
 import {toHttpParams} from '../bridge/rest/query-builder';
-import {buildHttpRequestOptions} from '../bridge/rest/http-request.options';
+import {buildHttpRequestOptions, resolveHttpCallOptions} from '../bridge/rest/http-request.options';
 import {MercureRealtimeAdapter} from '../bridge/sse/mercure.adapter';
 import {API_BASE_URL, BRIDGE_HTTP_WITH_CREDENTIALS} from '../tokens';
 import {AnyQuery, Collection, HttpCallOptions, HttpRequestConfig, Iri, IriRequired, Item} from '../ports/resource-repository.port';
-import {SubscribeFilter} from '../ports/realtime.port';
+import {RealtimeDiagnosticsPort, SubscribeFilter} from '../ports/realtime.port';
 import {resolveUrl} from '../utils/url';
+import {toIriList} from '../utils/iri';
 import {RealtimeDiagnostics, WatchConnectionOptions} from '../bridge.types';
 
 export type TypedEvent<TType extends string = string, TPayload = unknown> = {
@@ -35,78 +36,75 @@ export type WatchSubscriptionOptions = WatchConnectionOptions;
 export class BridgeFacade {
   constructor(
     private readonly http: HttpClient,
-    private readonly realtime: MercureRealtimeAdapter,
+    @Inject(MercureRealtimeAdapter) private readonly realtime: RealtimeDiagnosticsPort,
     @Inject(API_BASE_URL) private readonly apiBase: string,
     @Inject(BRIDGE_HTTP_WITH_CREDENTIALS) private readonly httpWithCredentialsDefault: boolean,
   ) {
   }
 
-  // ──────────────── HTTP ────────────────
-
-  get$<R = unknown>(url: IriRequired, opts?: HttpCallOptions): Observable<R> {
-    return this.http.get<R>(this.resolveUrl(url), {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.httpWithCredentialsDefault,
-    });
+  get$<R = unknown>(url: IriRequired, options?: HttpCallOptions): Observable<R> {
+    return this.http.get<R>(
+      this.resolveUrl(url),
+      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
+    );
   }
 
   getCollection$<T extends Item = Item>(
     url: IriRequired,
     query?: AnyQuery,
-    opts?: HttpCallOptions
+    options?: HttpCallOptions
   ): Observable<Collection<T>> {
-    const params = toHttpParams(query);
     return this.http.get<Collection<T>>(this.resolveUrl(url), {
-      params,
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.httpWithCredentialsDefault,
+      ...resolveHttpCallOptions(options, this.httpWithCredentialsDefault),
+      params: toHttpParams(query),
     });
   }
 
-  post$<R = unknown, B = unknown>(url: IriRequired, payload: B, opts?: HttpCallOptions): Observable<R> {
-    return this.http.post<R>(this.resolveUrl(url), payload, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.httpWithCredentialsDefault,
-    });
+  post$<R = unknown, B = unknown>(url: IriRequired, payload: B, options?: HttpCallOptions): Observable<R> {
+    return this.http.post<R>(
+      this.resolveUrl(url),
+      payload,
+      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
+    );
   }
 
-  patch$<R = unknown, B = unknown>(url: IriRequired, changes: B, opts?: HttpCallOptions): Observable<R> {
-    return this.http.patch<R>(this.resolveUrl(url), changes, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.httpWithCredentialsDefault,
-    });
+  patch$<R = unknown, B = unknown>(url: IriRequired, changes: B, options?: HttpCallOptions): Observable<R> {
+    return this.http.patch<R>(
+      this.resolveUrl(url),
+      changes,
+      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
+    );
   }
 
-  put$<R = unknown, B = unknown>(url: IriRequired, payload: B, opts?: HttpCallOptions): Observable<R> {
-    return this.http.put<R>(this.resolveUrl(url), payload, {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.httpWithCredentialsDefault,
-    });
+  put$<R = unknown, B = unknown>(url: IriRequired, payload: B, options?: HttpCallOptions): Observable<R> {
+    return this.http.put<R>(
+      this.resolveUrl(url),
+      payload,
+      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
+    );
   }
 
-  delete$(url: IriRequired, opts?: HttpCallOptions): Observable<void> {
-    return this.http.delete<void>(this.resolveUrl(url), {
-      headers: opts?.headers,
-      withCredentials: opts?.withCredentials ?? this.httpWithCredentialsDefault,
-    });
+  delete$(url: IriRequired, options?: HttpCallOptions): Observable<void> {
+    return this.http.delete<void>(
+      this.resolveUrl(url),
+      resolveHttpCallOptions(options, this.httpWithCredentialsDefault)
+    );
   }
 
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R> {
-    const {method, url} = req;
+  request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R> {
+    const {method, url} = request;
     const targetUrl = this.resolveUrl(url);
 
-    const mergedOptions = buildHttpRequestOptions(req, {withCredentialsDefault: this.httpWithCredentialsDefault});
+    const mergedOptions = buildHttpRequestOptions(request, {withCredentialsDefault: this.httpWithCredentialsDefault});
     return this.http.request<R>(method, targetUrl, mergedOptions as {observe: 'body'});
   }
 
-  // ──────────────── SSE / Mercure ────────────────
-
   watch$<T = Item>(
     iri: Iri | Iri[],
     subscribeFilter?: SubscribeFilter,
     options?: WatchSubscriptionOptions
   ): Observable<T> {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
+    const iris = toIriList(iri);
     return this.realtime
       .subscribe$<T>(iris, subscribeFilter, options)
       .pipe(
@@ -131,12 +129,14 @@ export class BridgeFacade {
   watchTypes$<R extends Record<string, any>>(
     iri: Iri | Iri[],
     resourceTypes: (keyof R & string)[],
-    cfg?: WatchTypesConfig,
+    config?: WatchTypesConfig,
     options?: WatchSubscriptionOptions
   ): Observable<WatchTypesResult<R>> {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    const discriminator = cfg?.discriminator ?? '@type';
-    const allowedTypes = new Set(resourceTypes.filter((v): v is string => typeof v === 'string' && v.length > 0));
+    const iris = toIriList(iri);
+    const discriminator = config?.discriminator ?? '@type';
+    const allowedTypes = new Set(
+      resourceTypes.filter((type): type is string => typeof type === 'string' && type.length > 0)
+    );
 
     return this.realtime
       .subscribeAll$<unknown>(iris, options)
@@ -151,14 +151,13 @@ export class BridgeFacade {
           const key = resolvedType as keyof R & string;
           return {resourceType: key, payload: raw as R[keyof R]} as WatchTypesResult<R>;
         }),
-        filter((evt): evt is WatchTypesResult<R> => !!evt),
+        filter((event): event is WatchTypesResult<R> => !!event),
         share()
       );
   }
 
   unwatch(iri: Iri | Iri[]): void {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    this.realtime.unsubscribe(iris);
+    this.realtime.unsubscribe(toIriList(iri));
   }
 
   realtimeDiagnostics$(): Observable<RealtimeDiagnostics> {
@@ -171,9 +170,9 @@ export class BridgeFacade {
   }
 }
 
-function readDiscriminator(raw: unknown, discriminator: string): string | undefined {
-  if (!raw || typeof raw !== 'object') return undefined;
-  const value = (raw as any)?.[discriminator];
+function readDiscriminator(payload: unknown, discriminator: string): string | undefined {
+  if (!payload || typeof payload !== 'object') return undefined;
+  const value = (payload as Record<string, unknown>)[discriminator];
   if (typeof value === 'string') return value;
   if (Array.isArray(value)) {
     const first = value.find((v) => typeof v === 'string');

package/templates/{_lib_template → angular-bridge}/src/lib/facades/facade.factory.ts

@@ -13,7 +13,6 @@ export type FacadeConfig<T> = {
   realtime?: RealtimePort;
 };
 
-
 @Injectable({providedIn: 'root'})
 export class FacadeFactory {
   private readonly env = inject(EnvironmentInjector);

package/templates/angular-bridge/src/lib/facades/facade.interface.ts

@@ -0,0 +1,13 @@
+import {
+  Iri,
+  Item,
+  ResourceRepository,
+} from '../ports/resource-repository.port';
+import {Observable} from 'rxjs';
+import {WatchConnectionOptions} from '../bridge.types';
+
+export interface Facade<T extends Item> extends ResourceRepository<T> {
+  watch$(iri: Iri | Iri[], options?: WatchConnectionOptions): Observable<T>;
+
+  unwatch(iri: Iri | Iri[]): void;
+}

package/templates/{_lib_template → angular-bridge}/src/lib/facades/resource.facade.ts

@@ -7,54 +7,51 @@ import {
   IriRequired,
   Collection,
   Item,
-  HttpRequestConfig
+  HttpRequestConfig,
 } from '../ports/resource-repository.port';
 import {RealtimePort, RealtimeStatus} from '../ports/realtime.port';
 import {toSignal} from '@angular/core/rxjs-interop';
 import {filter, map, Observable, share} from 'rxjs';
 import {Facade} from './facade.interface';
 import {WatchConnectionOptions} from '../bridge.types';
+import {toIriList} from '../utils/iri';
 
 export class ResourceFacade<T extends Item> implements Facade<T> {
-
   readonly connectionStatus: Signal<RealtimeStatus>;
 
   constructor(
     protected readonly repo: ResourceRepository<T>,
     protected readonly realtime: RealtimePort
   ) {
-    this.connectionStatus = toSignal(
-      this.realtime.status$(),
-      {initialValue: 'closed'}
-    );
+    this.connectionStatus = toSignal(this.realtime.status$(), {initialValue: 'closed'});
   }
 
-  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>> {
-    return this.repo.getCollection$(query, opts);
+  getCollection$(query?: AnyQuery, options?: HttpCallOptions): Observable<Collection<T>> {
+    return this.repo.getCollection$(query, options);
   }
 
-  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.get$(iri, opts);
+  get$(iri: IriRequired, options?: HttpCallOptions): Observable<T> {
+    return this.repo.get$(iri, options);
   }
 
-  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.patch$(iri, changes, opts);
+  patch$(iri: IriRequired, changes: Partial<T>, options?: HttpCallOptions): Observable<T> {
+    return this.repo.patch$(iri, changes, options);
   }
 
-  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.post$(payload, opts);
+  post$(payload: Partial<T>, options?: HttpCallOptions): Observable<T> {
+    return this.repo.post$(payload, options);
   }
 
-  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T> {
-    return this.repo.put$(iri, payload, opts);
+  put$(iri: IriRequired, payload: Partial<T>, options?: HttpCallOptions): Observable<T> {
+    return this.repo.put$(iri, payload, options);
   }
 
-  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void> {
-    return this.repo.delete$(iri, opts);
+  delete$(iri: IriRequired, options?: HttpCallOptions): Observable<void> {
+    return this.repo.delete$(iri, options);
   }
 
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R> {
-    return this.repo.request$<R, B>(req);
+  request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R> {
+    return this.repo.request$<R, B>(request);
   }
 
   /**
@@ -62,14 +59,10 @@ export class ResourceFacade<T extends Item> implements Facade<T> {
    * Undefined/empty values are ignored.
    */
   watch$(iri: Iri | Iri[], options?: WatchConnectionOptions): Observable<T> {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    return this.subscribeAndSync(iris, options);
+    return this.subscribeAndSync(toIriList(iri), options);
   }
-
-
   unwatch(iri: Iri | Iri[]): void {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
-    this.realtime.unsubscribe(iris);
+    this.realtime.unsubscribe(toIriList(iri));
   }
 
   /**
@@ -81,12 +74,12 @@ export class ResourceFacade<T extends Item> implements Facade<T> {
     field: string,
     options?: WatchConnectionOptions
   ): Observable<R> {
-    const iris = (Array.isArray(iri) ? iri : [iri]).filter((v): v is string => typeof v === 'string' && v.length > 0);
+    const iris = toIriList(iri);
     return this.realtime
-      .subscribe$<R>(iris, {field: field}, options)
+      .subscribe$<R>(iris, {field}, options)
       .pipe(
-        map(e => e.data),
-        filter((d): d is R => d !== undefined),
+        map((event) => event.data),
+        filter((data): data is R => data !== undefined),
         share()
       );
   }
@@ -95,7 +88,7 @@ export class ResourceFacade<T extends Item> implements Facade<T> {
     return this.realtime
       .subscribe$<T>(iris, undefined, options)
       .pipe(
-        map(event => event.data),
+        map((event) => event.data),
         filter((data): data is T => data !== undefined),
         share()
       );

package/templates/angular-bridge/src/lib/interceptors/bearer-auth.interceptor.ts

@@ -0,0 +1,33 @@
+import {HttpInterceptorFn} from '@angular/common/http';
+import {from, switchMap} from 'rxjs';
+import {BridgeAuth} from '../bridge-options';
+import {isRequestWithinBaseUrl} from '../utils/request-url';
+
+type TokenProvider = () => string | undefined | Promise<string | undefined>;
+
+export function createAuthInterceptors(auth: BridgeAuth | undefined, baseUrl: string): HttpInterceptorFn[] {
+  if (!auth) return [];
+  if (typeof auth === 'function') return [auth];
+
+  const bearer = typeof auth === 'string' ? {type: 'bearer' as const, token: auth} : auth;
+  if (bearer.type !== 'bearer') return [];
+
+  const getToken: TokenProvider = 'token' in bearer ? () => bearer.token : bearer.getToken;
+  return [createBearerAuthInterceptor(baseUrl, getToken)];
+}
+
+function createBearerAuthInterceptor(baseUrl: string, getToken: TokenProvider): HttpInterceptorFn {
+  return (request, next) => {
+    if (!isRequestWithinBaseUrl(request.url, baseUrl) || request.headers.has('Authorization')) {
+      return next(request);
+    }
+
+    return from(Promise.resolve(getToken())).pipe(
+      switchMap((token) => {
+        if (!token) return next(request);
+        const headers = request.headers.set('Authorization', `Bearer ${token}`);
+        return next(request.clone({headers}));
+      })
+    );
+  };
+}

package/templates/angular-bridge/src/lib/interceptors/bridge-defaults.interceptor.ts

@@ -0,0 +1,65 @@
+import {HttpInterceptorFn, HttpRequest} from '@angular/common/http';
+import {inject} from '@angular/core';
+import {retry, timeout, timer} from 'rxjs';
+import {BridgeDefaults} from '../bridge.types';
+import {BRIDGE_DEFAULTS, BRIDGE_LOGGER} from '../tokens';
+
+const DEFAULT_RETRY_METHODS = ['GET', 'HEAD', 'OPTIONS'];
+
+type RetryPolicy = {
+  count: number;
+  delayMs: number;
+  methods: Set<string>;
+};
+
+/**
+ * Applies default headers, timeout and retry policy configured via `provideBridge({defaults: ...})`.
+ */
+export const bridgeDefaultsInterceptor: HttpInterceptorFn = (req, next) => {
+  const defaults = inject(BRIDGE_DEFAULTS, {optional: true}) ?? {};
+  const logger = inject(BRIDGE_LOGGER, {optional: true});
+  const request = applyDefaultHeaders(req, defaults.headers);
+
+  let response$ = next(request);
+  if (typeof defaults.timeoutMs === 'number' && defaults.timeoutMs > 0) {
+    response$ = response$.pipe(timeout({first: defaults.timeoutMs}));
+  }
+
+  const retryPolicy = resolveRetryPolicy(defaults.retries);
+  if (!retryPolicy || !retryPolicy.methods.has(req.method.toUpperCase())) {
+    return response$;
+  }
+
+  return response$.pipe(
+    retry({
+      count: retryPolicy.count,
+      delay: (_error, retryIndex) => {
+        logger?.debug?.('[Bridge] retry', {url: req.urlWithParams, method: req.method, retryIndex});
+        return timer(retryPolicy.delayMs);
+      },
+    })
+  );
+};
+
+function applyDefaultHeaders(request: HttpRequest<unknown>, defaults?: Record<string, string>): HttpRequest<unknown> {
+  if (!defaults) return request;
+
+  let headers = request.headers;
+  for (const [name, value] of Object.entries(defaults)) {
+    if (!headers.has(name)) headers = headers.set(name, value);
+  }
+
+  return headers === request.headers ? request : request.clone({headers});
+}
+
+function resolveRetryPolicy(retries: BridgeDefaults['retries']): RetryPolicy | undefined {
+  const count = typeof retries === 'number' ? retries : retries?.count;
+  if (!count || count <= 0) return undefined;
+
+  const methods = typeof retries === 'object' && retries.methods ? retries.methods : DEFAULT_RETRY_METHODS;
+  return {
+    count,
+    delayMs: typeof retries === 'object' ? (retries.delayMs ?? 250) : 250,
+    methods: new Set(methods.map((method) => method.toUpperCase())),
+  };
+}

package/templates/angular-bridge/src/lib/interceptors/content-type.interceptor.ts

@@ -0,0 +1,37 @@
+import {HttpInterceptorFn} from '@angular/common/http';
+
+export interface ApiMediaTypes {
+  accept: string;
+  post: string;
+  put: string;
+  patch: string;
+}
+
+export const DEFAULT_MEDIA_TYPES: ApiMediaTypes = {
+  accept: 'application/ld+json',
+  post: 'application/ld+json',
+  put: 'application/ld+json',
+  patch: 'application/merge-patch+json',
+};
+
+const CONTENT_TYPE_BY_METHOD: Record<string, string> = {
+  POST: DEFAULT_MEDIA_TYPES.post,
+  PUT: DEFAULT_MEDIA_TYPES.put,
+  PATCH: DEFAULT_MEDIA_TYPES.patch,
+};
+
+export const contentTypeInterceptor: HttpInterceptorFn = (req, next) => {
+  let headers = req.headers;
+
+  if (!headers.has('Accept')) {
+    headers = headers.set('Accept', DEFAULT_MEDIA_TYPES.accept);
+  }
+
+  const contentType = CONTENT_TYPE_BY_METHOD[req.method];
+  const isFormData = typeof FormData !== 'undefined' && req.body instanceof FormData;
+  if (contentType && !isFormData && !headers.has('Content-Type')) {
+    headers = headers.set('Content-Type', contentType);
+  }
+
+  return next(headers === req.headers ? req : req.clone({headers}));
+};

package/templates/angular-bridge/src/lib/interceptors/scoped.interceptor.ts

@@ -0,0 +1,9 @@
+import {HttpInterceptorFn} from '@angular/common/http';
+import {isRequestWithinBaseUrl} from '../utils/request-url';
+
+/** Limits a bridge interceptor to requests targeting the configured API. */
+export function scopeInterceptor(baseUrl: string, interceptor: HttpInterceptorFn): HttpInterceptorFn {
+  return (request, next) => isRequestWithinBaseUrl(request.url, baseUrl)
+    ? interceptor(request, next)
+    : next(request);
+}

package/templates/angular-bridge/src/lib/interceptors/singleflight.interceptor.ts

@@ -0,0 +1,46 @@
+import {HttpEvent, HttpHeaders, HttpInterceptorFn, HttpRequest} from '@angular/common/http';
+import {finalize, Observable, shareReplay} from 'rxjs';
+
+const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+
+export function createSingleFlightInterceptor(): HttpInterceptorFn {
+  const inFlight = new Map<string, Observable<HttpEvent<unknown>>>();
+
+  return (request, next) => {
+    const method = request.method.toUpperCase();
+    if (!SAFE_METHODS.has(method) || request.reportProgress) {
+      return next(request);
+    }
+
+    const key = computeKey(request);
+    const existing = inFlight.get(key);
+    if (existing) {
+      return existing;
+    }
+
+    const shared$ = next(request).pipe(
+      finalize(() => inFlight.delete(key)),
+      shareReplay({bufferSize: 1, refCount: true})
+    );
+
+    inFlight.set(key, shared$);
+    return shared$;
+  };
+}
+
+function computeKey(request: HttpRequest<unknown>): string {
+  return [
+    request.method.toUpperCase(),
+    request.urlWithParams,
+    `rt=${request.responseType}`,
+    `wc=${request.withCredentials ? '1' : '0'}`,
+    `h=${serializeHeaders(request.headers)}`,
+  ].join('::');
+}
+
+function serializeHeaders(headers: HttpHeaders): string {
+  return headers.keys()
+    .sort((left, right) => left.localeCompare(right))
+    .map((name) => `${name.toLowerCase()}=${JSON.stringify(headers.getAll(name) ?? [])}`)
+    .join('&');
+}

package/templates/{_lib_template → angular-bridge}/src/lib/ports/realtime.port.ts

@@ -1,8 +1,8 @@
 import {Observable} from 'rxjs';
 import {Iri} from './resource-repository.port';
-import {WatchConnectionOptions} from '../bridge.types';
+import {RealtimeConnectionStatus, RealtimeDiagnostics, WatchConnectionOptions} from '../bridge.types';
 
-export type RealtimeStatus = 'connecting' | 'connected' | 'closed';
+export type RealtimeStatus = RealtimeConnectionStatus;
 
 export interface SseEvent {
   type: string;
@@ -65,3 +65,7 @@ export interface RealtimePort {
 
   status$(): Observable<RealtimeStatus>;
 }
+
+export interface RealtimeDiagnosticsPort extends RealtimePort {
+  diagnostics$(): Observable<RealtimeDiagnostics>;
+}

package/templates/{_lib_template → angular-bridge}/src/lib/ports/resource-repository.port.ts

@@ -51,19 +51,19 @@ export interface HttpCallOptions {
 }
 
 export interface ResourceRepository<T> {
-  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>>;
+  getCollection$(query?: AnyQuery, options?: HttpCallOptions): Observable<Collection<T>>;
 
-  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T>;
+  get$(iri: IriRequired, options?: HttpCallOptions): Observable<T>;
 
-  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
+  post$(payload: Partial<T>, options?: HttpCallOptions): Observable<T>;
 
-  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T>;
+  patch$(iri: IriRequired, changes: Partial<T>, options?: HttpCallOptions): Observable<T>;
 
-  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
+  put$(iri: IriRequired, payload: Partial<T>, options?: HttpCallOptions): Observable<T>;
 
-  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void>;
+  delete$(iri: IriRequired, options?: HttpCallOptions): Observable<void>;
 
-  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R>;
+  request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R>;
 }
 
 export interface HttpRequestConfig<TBody = unknown> {

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

@@ -0,0 +1,98 @@
+import {EnvironmentProviders, makeEnvironmentProviders} from '@angular/core';
+import {HttpInterceptorFn, provideHttpClient, withFetch, withInterceptors} from '@angular/common/http';
+import {BridgeOptions} from './bridge-options';
+import {BridgeLogger, MercureConnectionMode, MercureTopicMode} from './bridge.types';
+import {createAuthInterceptors} from './interceptors/bearer-auth.interceptor';
+import {bridgeDebugInterceptor} from './interceptors/bridge-debug.interceptor';
+import {bridgeDefaultsInterceptor} from './interceptors/bridge-defaults.interceptor';
+import {contentTypeInterceptor} from './interceptors/content-type.interceptor';
+import {scopeInterceptor} from './interceptors/scoped.interceptor';
+import {createSingleFlightInterceptor} from './interceptors/singleflight.interceptor';
+import {
+  API_BASE_URL,
+  BRIDGE_DEFAULTS,
+  BRIDGE_HTTP_WITH_CREDENTIALS,
+  BRIDGE_LOGGER,
+  BRIDGE_MERCURE_WITH_CREDENTIALS,
+  MERCURE_CONNECTION_MODE,
+  MERCURE_HUB_URL,
+  MERCURE_MAX_URL_LENGTH,
+  MERCURE_TOPIC_MODE,
+} from './tokens';
+
+export type {BridgeAuth, BridgeHttpOptions, BridgeMercureOptions, BridgeOptions} from './bridge-options';
+
+/** Registers the bridge HTTP client, interceptors, Mercure realtime adapter and configuration tokens. */
+export function provideBridge(options: BridgeOptions): EnvironmentProviders {
+  const {
+    baseUrl,
+    auth,
+    http,
+    mercure,
+    defaults,
+    singleFlight = true,
+    debug = false,
+    extraInterceptors = [],
+  } = options;
+
+  if (!baseUrl) {
+    throw new Error("provideBridge(): missing 'baseUrl'");
+  }
+
+  const resolvedMercureInit: RequestInit = mercure?.init ?? {credentials: 'include' as RequestCredentials};
+  const resolvedMercureHubUrl = mercure?.hubUrl;
+  const resolvedMercureTopicMode: MercureTopicMode = mercure?.topicMode ?? 'url';
+  const resolvedMercureConnectionMode: MercureConnectionMode = mercure?.connectionMode ?? 'auto';
+  const resolvedMercureMaxUrlLength = normalizeMercureMaxUrlLength(mercure?.maxUrlLength, 1900);
+  const mercureWithCredentials = resolveWithCredentials(resolvedMercureInit);
+  const httpWithCredentials = http?.withCredentials ?? mercureWithCredentials;
+
+  const loggerProvider: BridgeLogger = createBridgeLogger(debug);
+  const scopeToBridge = (interceptor: HttpInterceptorFn) => scopeInterceptor(baseUrl, interceptor);
+
+  const interceptors: HttpInterceptorFn[] = [
+    scopeToBridge(contentTypeInterceptor),
+    scopeToBridge(bridgeDefaultsInterceptor),
+    ...createAuthInterceptors(auth, baseUrl),
+    ...(singleFlight ? [scopeToBridge(createSingleFlightInterceptor())] : []),
+    ...(debug ? [scopeToBridge(bridgeDebugInterceptor)] : []),
+    ...extraInterceptors,
+  ];
+
+  return makeEnvironmentProviders([
+    provideHttpClient(
+      withFetch(),
+      withInterceptors(interceptors)
+    ),
+    {provide: API_BASE_URL, useValue: baseUrl},
+    {provide: BRIDGE_HTTP_WITH_CREDENTIALS, useValue: httpWithCredentials},
+    {provide: BRIDGE_MERCURE_WITH_CREDENTIALS, useValue: mercureWithCredentials},
+    ...(resolvedMercureHubUrl ? [{provide: MERCURE_HUB_URL, useValue: resolvedMercureHubUrl}] : []),
+    {provide: MERCURE_TOPIC_MODE, useValue: resolvedMercureTopicMode},
+    {provide: MERCURE_CONNECTION_MODE, useValue: resolvedMercureConnectionMode},
+    {provide: MERCURE_MAX_URL_LENGTH, useValue: resolvedMercureMaxUrlLength},
+    {provide: BRIDGE_DEFAULTS, useValue: defaults ?? {}},
+    {provide: BRIDGE_LOGGER, useValue: loggerProvider},
+  ]);
+}
+
+function createBridgeLogger(debug: boolean): BridgeLogger {
+  const noop = () => undefined;
+  return {
+    debug: debug ? console.debug.bind(console) : noop,
+    info: debug ? console.info.bind(console) : noop,
+    warn: debug ? console.warn.bind(console) : noop,
+    error: console.error.bind(console),
+  };
+}
+
+function resolveWithCredentials(init: RequestInit | undefined): boolean {
+  if (!init) return false;
+  const anyInit = init as RequestInit & {withCredentials?: boolean};
+  return anyInit.withCredentials === true || init.credentials === 'include';
+}
+
+function normalizeMercureMaxUrlLength(input: unknown, fallback: number): number {
+  const value = typeof input === 'number' ? Math.floor(input) : fallback;
+  return Number.isFinite(value) && value >= 256 ? value : fallback;
+}