@obsidiane/meridiane 2.0.13 → 3.0.0

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

@@ -1,30 +1,18 @@
 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 ACCEPT = 'application/ld+json';
 
 const CONTENT_TYPE_BY_METHOD: Record<string, string> = {
-  POST: DEFAULT_MEDIA_TYPES.post,
-  PUT: DEFAULT_MEDIA_TYPES.put,
-  PATCH: DEFAULT_MEDIA_TYPES.patch,
+  POST: 'application/ld+json',
+  PUT: 'application/ld+json',
+  PATCH: 'application/merge-patch+json',
 };
 
 export const contentTypeInterceptor: HttpInterceptorFn = (req, next) => {
   let headers = req.headers;
 
   if (!headers.has('Accept')) {
-    headers = headers.set('Accept', DEFAULT_MEDIA_TYPES.accept);
+    headers = headers.set('Accept', ACCEPT);
   }
 
   const contentType = CONTENT_TYPE_BY_METHOD[req.method];

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

@@ -1,32 +1,36 @@
 import {HttpEvent, HttpHeaders, HttpInterceptorFn, HttpRequest} from '@angular/common/http';
+import {inject, InjectionToken} from '@angular/core';
 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$;
-  };
-}
+/** In-flight requests of one application instance (one per server-side render). */
+const IN_FLIGHT_REQUESTS = new InjectionToken<Map<string, Observable<HttpEvent<unknown>>>>('IN_FLIGHT_REQUESTS', {
+  providedIn: 'root',
+  factory: () => new Map(),
+});
+
+export const singleFlightInterceptor: HttpInterceptorFn = (request, next) => {
+  const method = request.method.toUpperCase();
+  if (!SAFE_METHODS.has(method) || request.reportProgress) {
+    return next(request);
+  }
+
+  const inFlight = inject(IN_FLIGHT_REQUESTS);
+  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 [

package/templates/angular-bridge/src/lib/ports/realtime.port.ts

@@ -1,71 +1,52 @@
+import {Signal} from '@angular/core';
 import {Observable} from 'rxjs';
-import {Iri} from './resource-repository.port';
-import {RealtimeConnectionStatus, RealtimeDiagnostics, WatchConnectionOptions} from '../bridge.types';
-
-export type RealtimeStatus = RealtimeConnectionStatus;
-
-export interface SseEvent {
-  type: string;
-  data: string;
-  lastEventId?: string;
+import {RealtimeDiagnostics, RealtimeStatus} from '../bridge.types';
+
+/**
+ * A Mercure 1.0 subscription, sent to the hub as `match=` (exact) or `match_urlpattern=` (WHATWG URL Pattern).
+ */
+export interface MercureSubscription {
+  /** Absolute topic, or absolute URL Pattern when `type` is `urlpattern` (e.g. `https://api.example.com/api/books/:id`). */
+  match: string;
+  type: 'exact' | 'urlpattern';
 }
 
-export interface SseOptions {
-  withCredentials?: boolean;
-}
+/**
+ * Connection carrying a subscription:
+ * - `shared`: connections shared by the application, split automatically when too long;
+ * - `dedicated`: a connection for this subscription only;
+ * - any other value: connections shared by the subscriptions using this name.
+ */
+export type RealtimeConnection = 'shared' | 'dedicated' | (string & {});
 
-export interface RealtimeEvent<T> {
-  iri: string;
-  /**
-   * Matched subscription topic (normalized).
-   *
-   * - When matching by `@id`, this is typically the same as `iri`.
-   * - When matching by a relation field (e.g. `conversation`), this is the parent topic IRI.
-   */
-  topic?: string;
-  data?: T;
+export interface RealtimeSubscribeOptions {
+  connection?: RealtimeConnection;
 }
 
-export type SubscribeFilter = {
-  /**
-   * Single relation path used to match events to subscription topics.
-   * Example: `conversation` or `embedded.author`.
-   */
-  field?: string;
-  /**
-   * Multiple relation paths used to match events to subscription topics.
-   */
-  fields?: string[];
-  /**
-   * When relation fields are provided, also include events whose `@id` matches the subscribed topics.
-   *
-   * Default:
-   * - `true` when no relation fields are provided (match by `@id`)
-   * - `false` when relation fields are provided (sub-resource mode)
-   */
-  includeSelf?: boolean;
-};
+/** A Mercure update received on the SSE connection. */
+export interface MercureUpdate {
+  /** Update ID assigned by the hub (SSE `id`). */
+  id?: string;
+  /** Parsed JSON payload. */
+  data: unknown;
+}
 
 export interface RealtimePort {
-  /**
-   * Subscribes to Mercure events for the given topics.
-   *
-   * Note: topics must be stable strings. Undefined values are ignored by the adapter.
-   */
-  subscribe$<T>(iris: Iri[], filter?: SubscribeFilter, options?: WatchConnectionOptions): Observable<RealtimeEvent<T>>;
+  /** State of the connections. */
+  readonly status: Signal<RealtimeStatus>;
 
   /**
-   * Subscribes to all JSON payloads received on the given Mercure topics.
+   * Registers a subscription for as long as the returned Observable is subscribed. Default connection: `shared`.
    *
-   * No payload-to-topic matching is applied.
+   * Mercure does not tell which subscription matched an update: the stream emits every update received on the
+   * connections carrying the subscription, and consumers keep the ones that concern them (e.g. by `@id`).
    */
-  subscribeAll$<T>(iris: Iri[], options?: WatchConnectionOptions): Observable<RealtimeEvent<T>>;
+  subscribe$(subscription: MercureSubscription, options?: RealtimeSubscribeOptions): Observable<MercureUpdate>;
 
-  unsubscribe(iris: Iri[]): void;
+  /** Renews the authorization and reopens every connection, e.g. after login or logout. */
+  reconnect(): void;
 
   status$(): Observable<RealtimeStatus>;
-}
 
-export interface RealtimeDiagnosticsPort extends RealtimePort {
   diagnostics$(): Observable<RealtimeDiagnostics>;
 }

package/templates/angular-bridge/src/lib/ports/resource-repository.port.ts

@@ -1,8 +1,8 @@
 import {HttpHeaders, HttpParams} from '@angular/common/http';
 import {Observable} from 'rxjs';
 
-export type Iri = string | undefined;
-export type IriRequired = string;
+/** IRI of an API Platform resource (e.g. `/api/books/1`), or an absolute URL. */
+export type Iri = string;
 
 type BaseHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
 export type HttpMethod = BaseHttpMethod | Lowercase<BaseHttpMethod>;
@@ -10,29 +10,40 @@ export type HttpMethod = BaseHttpMethod | Lowercase<BaseHttpMethod>;
 export type QueryParamValue = string | number | boolean | Array<string | number | boolean>;
 export type AnyQuery = Query | Record<string, QueryParamValue> | HttpParams;
 
+/** A resource read from the API, as described by API Platform's `HydraItemBaseSchema`. */
 export interface Item {
+  '@context'?: string | Record<string, unknown>;
+  '@id': Iri;
+  '@type': string;
+}
+
+/** Pagination of a collection (`view` of `HydraCollectionBaseSchema`). */
+export interface View {
   '@id'?: Iri;
-  '@context'?: string;
   '@type'?: string;
+  first?: Iri | null;
+  last?: Iri | null;
+  previous?: Iri | null;
+  next?: Iri | null;
 }
 
-export interface View extends Item {
-  first?: Iri;
-  last?: Iri;
-  next?: Iri;
-  previous?: Iri;
-}
-export interface IriTemplateMapping extends Item {
-  variable: string;
-  property?: string;
+export interface IriTemplateMapping {
+  '@type'?: string;
+  variable?: string;
+  property?: string | null;
   required?: boolean;
 }
-export interface IriTemplate extends Item {
-  template: string;
+
+/** Filters of a collection (`search` of `HydraCollectionBaseSchema`). */
+export interface IriTemplate {
+  '@type'?: string;
+  template?: string;
   variableRepresentation?: string;
-  mapping: IriTemplateMapping[];
+  mapping?: IriTemplateMapping[];
 }
-export interface Collection<T> extends Item {
+
+/** A collection, as described by API Platform's `HydraCollectionBaseSchema`. */
+export interface Collection<T> {
   member: T[];
   totalItems?: number;
   search?: IriTemplate;
@@ -53,15 +64,15 @@ export interface HttpCallOptions {
 export interface ResourceRepository<T> {
   getCollection$(query?: AnyQuery, options?: HttpCallOptions): Observable<Collection<T>>;
 
-  get$(iri: IriRequired, options?: HttpCallOptions): Observable<T>;
+  get$(iri: Iri, options?: HttpCallOptions): Observable<T>;
 
   post$(payload: Partial<T>, options?: HttpCallOptions): Observable<T>;
 
-  patch$(iri: IriRequired, changes: Partial<T>, options?: HttpCallOptions): Observable<T>;
+  patch$(iri: Iri, changes: Partial<T>, options?: HttpCallOptions): Observable<T>;
 
-  put$(iri: IriRequired, payload: Partial<T>, options?: HttpCallOptions): Observable<T>;
+  put$(iri: Iri, payload: Partial<T>, options?: HttpCallOptions): Observable<T>;
 
-  delete$(iri: IriRequired, options?: HttpCallOptions): Observable<void>;
+  delete$(iri: Iri, options?: HttpCallOptions): Observable<void>;
 
   request$<R = unknown, B = unknown>(request: HttpRequestConfig<B>): Observable<R>;
 }
@@ -74,5 +85,4 @@ export interface HttpRequestConfig<TBody = unknown> {
   headers?: HttpHeaders | Record<string, string>;
   responseType?: 'json' | 'text' | 'blob';
   withCredentials?: boolean;
-  options?: Record<string, unknown>;
 }

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

@@ -1,28 +1,24 @@
 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 {BridgeLogger} from './bridge.types';
+import {createAuthInterceptor} 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 {singleFlightInterceptor} 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,
+  BRIDGE_MERCURE,
 } from './tokens';
 
 export type {BridgeAuth, BridgeHttpOptions, BridgeMercureOptions, BridgeOptions} from './bridge-options';
 
-/** Registers the bridge HTTP client, interceptors, Mercure realtime adapter and configuration tokens. */
+/** Registers the bridge HTTP client, interceptors, Mercure realtime and configuration tokens. */
 export function provideBridge(options: BridgeOptions): EnvironmentProviders {
   const {
     baseUrl,
@@ -39,24 +35,19 @@ export function provideBridge(options: BridgeOptions): EnvironmentProviders {
     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 authInterceptor = createAuthInterceptor(auth);
 
+  // Configured defaults come before the bridge headers, which are only added when absent.
+  // Single-flight comes after the application interceptors, so it compares the final requests.
   const interceptors: HttpInterceptorFn[] = [
-    scopeToBridge(contentTypeInterceptor),
     scopeToBridge(bridgeDefaultsInterceptor),
-    ...createAuthInterceptors(auth, baseUrl),
-    ...(singleFlight ? [scopeToBridge(createSingleFlightInterceptor())] : []),
-    ...(debug ? [scopeToBridge(bridgeDebugInterceptor)] : []),
+    scopeToBridge(contentTypeInterceptor),
+    ...(authInterceptor ? [scopeToBridge(authInterceptor)] : []),
     ...extraInterceptors,
+    ...(singleFlight ? [scopeToBridge(singleFlightInterceptor)] : []),
+    ...(debug ? [scopeToBridge(bridgeDebugInterceptor)] : []),
   ];
 
   return makeEnvironmentProviders([
@@ -65,12 +56,8 @@ export function provideBridge(options: BridgeOptions): EnvironmentProviders {
       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_HTTP_WITH_CREDENTIALS, useValue: http?.withCredentials ?? false},
+    ...(mercure?.hubUrl ? [{provide: BRIDGE_MERCURE, useValue: mercure}] : []),
     {provide: BRIDGE_DEFAULTS, useValue: defaults ?? {}},
     {provide: BRIDGE_LOGGER, useValue: loggerProvider},
   ]);
@@ -85,14 +72,3 @@ function createBridgeLogger(debug: boolean): BridgeLogger {
     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;
-}

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

@@ -1,11 +1,12 @@
 import {InjectionToken} from '@angular/core';
-import {BridgeDefaults, BridgeLogger, MercureConnectionMode, MercureTopicMode} from './bridge.types';
+import {BridgeDefaults, BridgeLogger} from './bridge.types';
+import {BridgeMercureOptions} from './bridge-options';
 
 /** Base URL of the API (e.g. `http://localhost:8000`). */
 export const API_BASE_URL = new InjectionToken<string>('API_BASE_URL');
 
-/** Mercure hub URL (e.g. `http://localhost:8000/.well-known/mercure`). */
-export const MERCURE_HUB_URL = new InjectionToken<string>('MERCURE_HUB_URL');
+/** Mercure options; absent when realtime is disabled. */
+export const BRIDGE_MERCURE = new InjectionToken<BridgeMercureOptions>('BRIDGE_MERCURE');
 
 /**
  * Default credential policy for HTTP requests.
@@ -13,18 +14,6 @@ export const MERCURE_HUB_URL = new InjectionToken<string>('MERCURE_HUB_URL');
  */
 export const BRIDGE_HTTP_WITH_CREDENTIALS = new InjectionToken<boolean>('BRIDGE_HTTP_WITH_CREDENTIALS');
 
-/**
- * Default credential policy for Mercure EventSource.
- * When `true`, the bridge opens SSE connections with cookies enabled.
- */
-export const BRIDGE_MERCURE_WITH_CREDENTIALS = new InjectionToken<boolean>('BRIDGE_MERCURE_WITH_CREDENTIALS');
-
-export const MERCURE_TOPIC_MODE = new InjectionToken<MercureTopicMode>('MERCURE_TOPIC_MODE');
-
-export const MERCURE_CONNECTION_MODE = new InjectionToken<MercureConnectionMode>('MERCURE_CONNECTION_MODE');
-
-export const MERCURE_MAX_URL_LENGTH = new InjectionToken<number>('MERCURE_MAX_URL_LENGTH');
-
 export const BRIDGE_LOGGER = new InjectionToken<BridgeLogger>('BRIDGE_LOGGER');
 
 export const BRIDGE_DEFAULTS = new InjectionToken<BridgeDefaults>('BRIDGE_DEFAULTS');

package/templates/angular-bridge/src/lib/utils/request-url.ts

@@ -1,3 +1,5 @@
+import {isAbsoluteHttpUrl, trimTrailingSlash} from './url';
+
 type UrlKind = 'absolute' | 'protocol-relative' | 'relative';
 
 /** Returns whether a request belongs to the configured API origin and path. */
@@ -13,7 +15,7 @@ export function isRequestWithinBaseUrl(requestUrl: string, baseUrl: string): boo
 
     if (base.origin !== request.origin) return false;
 
-    const basePath = trimTrailingSlash(base.pathname);
+    const basePath = trimTrailingSlash(base.pathname) || '/';
     return basePath === '/' || request.pathname === basePath || request.pathname.startsWith(`${basePath}/`);
   } catch {
     return false;
@@ -21,11 +23,7 @@ export function isRequestWithinBaseUrl(requestUrl: string, baseUrl: string): boo
 }
 
 function classifyUrl(url: string): UrlKind {
-  if (/^https?:\/\//i.test(url)) return 'absolute';
+  if (isAbsoluteHttpUrl(url)) return 'absolute';
   if (url.startsWith('//')) return 'protocol-relative';
   return 'relative';
 }
-
-function trimTrailingSlash(pathname: string): string {
-  return pathname === '/' ? pathname : pathname.replace(/\/+$/, '') || '/';
-}

package/templates/angular-bridge/src/lib/utils/url.ts

@@ -1,15 +1,38 @@
-export function joinUrl(base: string, path: string): string {
-  const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base;
-  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
-  return `${normalizedBase}${normalizedPath}`;
+const ABSOLUTE_HTTP_URL = /^https?:\/\//i;
+
+export function isAbsoluteHttpUrl(url: string): boolean {
+  return ABSOLUTE_HTTP_URL.test(url);
+}
+
+export function trimTrailingSlash(path: string): string {
+  return path.replace(/\/+$/, '');
 }
 
+const URL_ORIGIN = /^(?:https?:)?\/\/[^/?#]*/i;
+
 /**
- * Resolves an API IRI (e.g. `/api/books/1`) to a full URL using the API base.
- * If `path` is already absolute (http/https), it is returned as-is.
+ * Resolves a path against the API base, with one rule for requests and Mercure topics:
+ * - an absolute (`http(s)://`) or protocol-relative (`//host`) URL is returned as-is;
+ * - a path starting with `/` is relative to the origin of the base, like the IRIs API Platform returns
+ *   (`/api/books/1` against `https://example.com/backend` → `https://example.com/api/books/1`);
+ * - any other path is relative to the base (`books/1` → `https://example.com/backend/books/1`).
+ *
+ * Plain string operations: URL Pattern syntax (`:id`, `{…}`, `*`) is kept unencoded.
  */
 export function resolveUrl(base: string, path: string): string {
-  if (/^https?:\/\//i.test(path)) return path;
-  if (path.startsWith('//')) return path;
-  return joinUrl(base, path);
+  if (isAbsoluteHttpUrl(path) || path.startsWith('//')) return path;
+  if (path.startsWith('/')) return `${URL_ORIGIN.exec(base)?.[0] ?? ''}${path}`;
+  return `${trimTrailingSlash(base)}/${path}`;
+}
+
+/**
+ * Resolves `url` against `base` (e.g. `/` against the document base → `https://app.example.com/`).
+ * Returns `url` unchanged when no absolute URL can be built (e.g. no document base on the server).
+ */
+export function toAbsoluteUrl(url: string, base: string | undefined): string {
+  try {
+    return new URL(url, base).toString();
+  } catch {
+    return url;
+  }
 }

package/templates/angular-bridge/src/public-api.ts

@@ -6,6 +6,5 @@ export * from './lib/facades/resource.facade';
 export * from './lib/facades/facade.interface';
 export * from './lib/ports/realtime.port';
 export * from './lib/ports/resource-repository.port';
-export * from './lib/utils/url';
 
 export * from './models';

package/templates/angular-bridge/tsconfig.lib.json

@@ -19,9 +19,6 @@
   "include": [
     "src/**/*.ts"
   ],
-  "exclude": [
-    "**/*.spec.ts"
-  ],
   "angularCompilerOptions": {
     "compilationMode": "partial",
     "strictTemplates": true

package/src/infrastructure/json.js

@@ -1,71 +0,0 @@
-import fs from 'node:fs/promises';
-
-function stripJsonComments(input) {
-  let out = '';
-  let i = 0;
-  let inString = false;
-  let stringQuote = '"';
-  while (i < input.length) {
-    const ch = input[i];
-
-    if (inString) {
-      out += ch;
-      if (ch === '\\') {
-        // skip escaped char
-        i += 2;
-        continue;
-      }
-      if (ch === stringQuote) inString = false;
-      i += 1;
-      continue;
-    }
-
-    if (ch === '"' || ch === "'") {
-      inString = true;
-      stringQuote = ch;
-      out += ch;
-      i += 1;
-      continue;
-    }
-
-    // line comment
-    if (ch === '/' && input[i + 1] === '/') {
-      i += 2;
-      while (i < input.length && input[i] !== '\n') i += 1;
-      continue;
-    }
-
-    // block comment
-    if (ch === '/' && input[i + 1] === '*') {
-      i += 2;
-      while (i < input.length && !(input[i] === '*' && input[i + 1] === '/')) i += 1;
-      i += 2;
-      continue;
-    }
-
-    out += ch;
-    i += 1;
-  }
-  return out;
-}
-
-export async function readJson(filePath) {
-  const raw = await fs.readFile(filePath, 'utf8');
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return JSON.parse(stripJsonComments(raw));
-  }
-}
-
-export async function writeJsonIfChanged(filePath, data) {
-  const next = JSON.stringify(data, null, 2) + '\n';
-  try {
-    const prev = await fs.readFile(filePath, 'utf8');
-    if (prev === next) return false;
-  } catch {
-    // ignore (file missing / unreadable)
-  }
-  await fs.writeFile(filePath, next, 'utf8');
-  return true;
-}