@hydranium/protocol 1.0.0-next.30 → 1.0.0-next.300

package/src/testing/data-doubles.ts

@@ -33,9 +33,19 @@
 
 import { Emitter, type MessageConnection } from 'vscode-jsonrpc';
 import type { DataPort } from '../client/data-port';
+import { DATA_CLIENT_PROTOCOL_METHODS } from '../data/data-protocol-methods';
 import type { DataClientProtocol } from '../data/data-server-protocol';
-import type { ProjectsChangedEvent, TransferDocumentSavedEvent, TransferDocumentUpdatedEvent } from '../data/events';
+import type {
+   ProjectsChangedEvent,
+   TransferDocumentDeletedEvent,
+   TransferDocumentDirtyChangedEvent,
+   TransferDocumentSavedEvent,
+   TransferDocumentsBuiltEvent,
+   TransferDocumentUpdatedEvent
+} from '../data/events';
+import type { Logger } from '../logger';
 import type { ResolvedMessage } from '../messages/primitives';
+import type { RpcProxyLifecycle } from '../rpc/create-rpc-proxy';
 import type { Project } from '../project';
 import type { TransferDiagnostic } from '../transfer-diagnostic';
 import type { TransferElement } from '../transfer-element';
@@ -50,15 +60,14 @@ export interface FakeDataPortOptions {
     *
     * Throwing (or rejecting) here is the transport-construction failure path,
     * which the consumer surfaces through {@link FakeDataPort.reported}.
+    *
+    * The double disposes none of these connections and goes on connecting
+    * after its dispose, where a real port releases its connection and refuses:
+    * the test owns them.
     */
    connect(): MessageConnection | Promise<MessageConnection>;
-   /**
-    * Stable client identity. Defaults to `'fake-data-port'`, which avoids the
-    * three sentinels the framework reserves (`'language-client'`, `'unknown'`,
-    * `'revert-on-close'`); override it when a test needs two distinguishable
-    * clients on one server.
-    */
-   clientId?: string;
+   /** The port's {@link DataPort.logger}. */
+   logger?: Logger;
 }
 
 /** A {@link DataPort} that records what passed through it. */
@@ -101,9 +110,9 @@ export function makeFakeDataPort(options: FakeDataPortOptions): FakeDataPort {
    const reported: { error: unknown; message: ResolvedMessage }[] = [];
    const disposeEmitter = new Emitter<void>();
    return {
-      clientId: options.clientId ?? 'fake-data-port',
       connections,
       reported,
+      logger: options.logger,
       onDispose: disposeEmitter.event,
       async connect(): Promise<MessageConnection> {
          const connection = await options.connect();
@@ -122,26 +131,78 @@ export function makeFakeDataPort(options: FakeDataPortOptions): FakeDataPort {
    };
 }
 
+type UpperLetter =
+   | 'A'
+   | 'B'
+   | 'C'
+   | 'D'
+   | 'E'
+   | 'F'
+   | 'G'
+   | 'H'
+   | 'I'
+   | 'J'
+   | 'K'
+   | 'L'
+   | 'M'
+   | 'N'
+   | 'O'
+   | 'P'
+   | 'Q'
+   | 'R'
+   | 'S'
+   | 'T'
+   | 'U'
+   | 'V'
+   | 'W'
+   | 'X'
+   | 'Y'
+   | 'Z';
+
+/**
+ * A notification name `TClient` adds to {@link DataClientProtocol}. Limited to
+ * `on` plus a letter A–Z, the names the proxy sends as notifications; any other
+ * name would be bound as a request. The {@link RpcProxyLifecycle} names are
+ * excluded too: the proxy returns its own events for them and sends nothing.
+ */
+export type AdditionalClientMethod<TClient> = Exclude<keyof TClient, keyof DataClientProtocol<TransferElement> | keyof RpcProxyLifecycle> &
+   `on${UpperLetter}${string}`;
+
 /** A {@link DataClientProtocol} plus the arrays it records into. */
 export interface CapturingDataClient<
    TTransfer extends TransferElement,
    TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
-   TProject extends Project = Project
+   TProject extends Project = Project,
+   TClient extends DataClientProtocol<TTransfer, TDiagnostic, TProject> = DataClientProtocol<TTransfer, TDiagnostic, TProject>
 > {
    /** The client to hand to a `DataSession` or bind as an RPC `localTarget`. */
-   readonly client: DataClientProtocol<TTransfer, TDiagnostic, TProject>;
+   readonly client: TClient;
    /** Every `onDocumentUpdated` event, in arrival order. */
    readonly updates: TransferDocumentUpdatedEvent<TTransfer, TDiagnostic>[];
    /** Every `onDocumentSaved` event, in arrival order. */
    readonly saves: TransferDocumentSavedEvent<TTransfer, TDiagnostic>[];
+   /** Every `onDocumentDirtyChanged` event, in arrival order. */
+   readonly dirtyChanges: TransferDocumentDirtyChangedEvent[];
+   /** Every `onDocumentDeleted` event, in arrival order. */
+   readonly deletions: TransferDocumentDeletedEvent[];
+   /** Every `onDocumentsBuilt` event, in arrival order. */
+   readonly builds: TransferDocumentsBuiltEvent[];
    /** Every `onProjectsChanged` event, in arrival order. */
    readonly projectsChanges: ProjectsChangedEvent<TProject>[];
+   /**
+    * Every event of each additional client method, keyed by method, in arrival
+    * order. A method of `TClient` left out of `additionalClientMethods` has no
+    * entry.
+    */
+   readonly additionalNotifications: {
+      readonly [K in AdditionalClientMethod<TClient>]: TClient[K] extends (event: infer TEvent) => void ? TEvent[] : never;
+   };
 }
 
 /**
  * A {@link DataClientProtocol} that records every notification it receives.
  *
- * Recording ALL THREE channels even when a suite reads one is deliberate: an
+ * Recording EVERY channel even when a suite reads one is deliberate: an
  * event delivered on the wrong channel is a real defect of the data head, and a
  * double that drops the other two turns it into silence on the one being
  * watched.
@@ -150,31 +211,92 @@ export interface CapturingDataClient<
  * the corresponding array stays empty — that is what makes an override usable
  * as a barrier (rejecting, counting differently, throwing) rather than only as
  * a spy.
+ *
+ * `additionalClientMethods` names the notifications `TClient` adds to
+ * {@link DataClientProtocol}. Each is recorded and overridable the same way;
+ * one left out is not on the client at all, and overriding it throws, since
+ * nothing would call the override.
  */
 export function makeCapturingDataClient<
    TTransfer extends TransferElement,
    TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
-   TProject extends Project = Project
->(overrides: Partial<DataClientProtocol<TTransfer, TDiagnostic, TProject>> = {}): CapturingDataClient<TTransfer, TDiagnostic, TProject> {
+   TProject extends Project = Project,
+   TClient extends DataClientProtocol<TTransfer, TDiagnostic, TProject> = DataClientProtocol<TTransfer, TDiagnostic, TProject>
+>(
+   overrides: Partial<TClient> = {},
+   additionalClientMethods: readonly AdditionalClientMethod<TClient>[] = []
+): CapturingDataClient<TTransfer, TDiagnostic, TProject, TClient> {
+   const bound = new Set<string>([...DATA_CLIENT_PROTOCOL_METHODS, ...additionalClientMethods]);
+   for (const name of Object.keys(overrides)) {
+      if (!bound.has(name)) {
+         throw new Error(
+            `Override '${name}' is neither a DataClientProtocol method nor listed in additionalClientMethods, so nothing would call it.`
+         );
+      }
+   }
+   const frameworkOverrides: Partial<DataClientProtocol<TTransfer, TDiagnostic, TProject>> = overrides;
    const updates: TransferDocumentUpdatedEvent<TTransfer, TDiagnostic>[] = [];
    const saves: TransferDocumentSavedEvent<TTransfer, TDiagnostic>[] = [];
+   const dirtyChanges: TransferDocumentDirtyChangedEvent[] = [];
+   const deletions: TransferDocumentDeletedEvent[] = [];
+   const builds: TransferDocumentsBuiltEvent[] = [];
    const projectsChanges: ProjectsChangedEvent<TProject>[] = [];
-   const client: DataClientProtocol<TTransfer, TDiagnostic, TProject> = {
+   const frameworkClient: DataClientProtocol<TTransfer, TDiagnostic, TProject> = {
       onDocumentUpdated:
-         overrides.onDocumentUpdated ??
+         frameworkOverrides.onDocumentUpdated ??
          (event => {
             updates.push(event);
          }),
       onDocumentSaved:
-         overrides.onDocumentSaved ??
+         frameworkOverrides.onDocumentSaved ??
          (event => {
             saves.push(event);
          }),
+      onDocumentDirtyChanged:
+         frameworkOverrides.onDocumentDirtyChanged ??
+         (event => {
+            dirtyChanges.push(event);
+         }),
+      onDocumentDeleted:
+         frameworkOverrides.onDocumentDeleted ??
+         (event => {
+            deletions.push(event);
+         }),
+      onDocumentsBuilt:
+         frameworkOverrides.onDocumentsBuilt ??
+         (event => {
+            builds.push(event);
+         }),
       onProjectsChanged:
-         overrides.onProjectsChanged ??
+         frameworkOverrides.onProjectsChanged ??
          (event => {
             projectsChanges.push(event);
          })
    };
-   return { client, updates, saves, projectsChanges };
+   const additionalNotifications: Record<string, unknown[]> = {};
+   const additionalHandlers: Record<string, unknown> = {};
+   for (const method of additionalClientMethods) {
+      const events: unknown[] = [];
+      additionalNotifications[method] = events;
+      additionalHandlers[method] =
+         overrides[method] ??
+         ((event: unknown) => {
+            events.push(event);
+         });
+   }
+   return {
+      client: { ...frameworkClient, ...additionalHandlers } as unknown as TClient,
+      updates,
+      saves,
+      dirtyChanges,
+      deletions,
+      builds,
+      projectsChanges,
+      additionalNotifications: additionalNotifications as CapturingDataClient<
+         TTransfer,
+         TDiagnostic,
+         TProject,
+         TClient
+      >['additionalNotifications']
+   };
 }

package/src/testing/fake-clock.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type Clock, type Stopwatch, type Timed } from '../clock';
+import { type Clock, type Stopwatch, SystemClock } from '../clock';
 import { Disposable } from '../util';
 
 /** A {@link Clock} whose time only moves when the test calls {@link FakeClock.advance}. */
@@ -17,9 +17,19 @@ export interface FakeClock extends Clock {
     * whose deadline falls within the window — in chronological order, each at
     * its own deadline (so `now()` inside a callback reads the fire instant, not
     * the advance target). Timers scheduled by a callback fire too if they fall
-    * within the same window.
+    * within the same window. A {@link Clock.raceTimer} over a promise that
+    * settles through a chain still pending loses to the timer, so let that
+    * chain settle before advancing.
     */
    advance(ms: number): void;
+   /**
+    * Move `now()` by `ms`, backwards when negative, leaving stopwatches and
+    * timers where they are: the wall-clock step a time sync or a manual change makes,
+    * which a duration taken from two `now()` readings gets wrong.
+    */
+   jumpWallClock(ms: number): void;
+   /** How many {@link Clock.setTimer} timers have neither fired nor been disposed. */
+   pendingTimers(): number;
 }
 
 interface FakeTimer {
@@ -35,72 +45,90 @@ interface FakeTimer {
  * (`Date.now` for `now()`, `performance.now()` for the stopwatch); the fake
  * collapses them onto ONE virtual time axis, so a single
  * {@link FakeClock.advance} drives `now()`, every live stopwatch's elapsed, and
- * any due timer together.
+ * any due timer together; only {@link FakeClock.jumpWallClock} pulls `now()`
+ * off that axis.
  *
  * Server-free and DI-free — lives in `@hydranium/protocol/testing` so every
  * head can bind it without pulling in a server package.
+ *
+ * The clock is a `SystemClock` with its time replaced, so its methods live on
+ * its prototype and a spread of it carries none of them. Replace one by
+ * assigning it onto the clock, or layer over the clock with `Object.create`.
  */
 export function makeFakeClock(options: { now?: number } = {}): FakeClock {
-   let current = options.now ?? 0;
-   const timers: FakeTimer[] = [];
+   return new VirtualClock(options.now ?? 0);
+}
+
+/**
+ * A `SystemClock` whose time, stopwatches and timers read one virtual axis, so
+ * the `measure` and `raceTimer` it inherits run on that axis too.
+ */
+class VirtualClock extends SystemClock implements FakeClock {
+   protected readonly timers: FakeTimer[] = [];
+   /** What {@link jumpWallClock} has added to `now()`. */
+   protected wallClockOffset = 0;
 
-   const makeStopwatch = (): Stopwatch => {
-      const start = current;
-      let lastLap = current;
+   constructor(protected current: number) {
+      super();
+   }
+
+   override now(): number {
+      return this.current + this.wallClockOffset;
+   }
+
+   jumpWallClock(ms: number): void {
+      this.wallClockOffset += ms;
+   }
+
+   override setTimer(callback: () => void, ms: number): Disposable {
+      const timer: FakeTimer = { at: this.current + ms, callback, disposed: false, fired: false };
+      this.timers.push(timer);
+      return Disposable.create(() => {
+         timer.disposed = true;
+      });
+   }
+
+   override stopwatch(): Stopwatch {
+      const read = (): number => this.current;
+      const start = read();
+      let lastLap = start;
       let stopped: number | undefined;
       return {
          get elapsedMs(): number {
-            return (stopped ?? current) - start;
+            return (stopped ?? read()) - start;
          },
          lap(): number {
-            const at = stopped ?? current;
+            const at = stopped ?? read();
             const split = at - lastLap;
             lastLap = at;
             return split;
          },
          stop(): number {
-            if (stopped === undefined) {
-               stopped = current;
-            }
+            stopped ??= read();
             return stopped - start;
          }
       };
-   };
+   }
 
-   return {
-      now: () => current,
-      setTimer(callback: () => void, ms: number): Disposable {
-         const timer: FakeTimer = { at: current + ms, callback, disposed: false, fired: false };
-         timers.push(timer);
-         return Disposable.create(() => {
-            timer.disposed = true;
-         });
-      },
-      stopwatch: makeStopwatch,
-      measure: (<T>(callback: () => T | Promise<T>): Timed<T> | Promise<Timed<T>> => {
-         const stopwatch = makeStopwatch();
-         const result = callback();
-         if (result instanceof Promise) {
-            return (result as Promise<T>).then(value => ({ result: value, elapsedMs: stopwatch.elapsedMs }));
-         }
-         return { result: result as T, elapsedMs: stopwatch.elapsedMs };
-      }) as Clock['measure'],
-      advance(ms: number): void {
-         const target = current + ms;
-         // Fire due timers one at a time, re-scanning after each so a callback
-         // that schedules a nearer timer still fires within this window.
-         for (;;) {
-            const next = timers
-               .filter(timer => !timer.disposed && !timer.fired && timer.at <= target)
-               .sort((left, right) => left.at - right.at)[0];
-            if (!next) {
-               break;
-            }
-            current = next.at;
-            next.fired = true;
-            next.callback();
+   pendingTimers(): number {
+      return this.timers.filter(timer => !timer.disposed && !timer.fired).length;
+   }
+
+   advance(ms: number): void {
+      const target = this.current + ms;
+      // Fire due timers one at a time, re-scanning after each so a callback
+      // that schedules a nearer timer still fires within this window.
+      for (;;) {
+         const next = this.timers
+            .filter(timer => !timer.disposed && !timer.fired && timer.at <= target)
+            .sort((left, right) => left.at - right.at)[0];
+         if (!next) {
+            break;
          }
-         current = target;
+         this.current = next.at;
+         next.fired = true;
+         next.callback();
       }
-   };
+      this.current = target;
+   }
 }

package/src/testing/index.ts

@@ -10,16 +10,19 @@
 // Subpath barrel for `@hydranium/protocol/testing` — the BROWSER-NEUTRAL shared
 // primitives: `makeFakeClock` (deterministic `Clock` double on one virtual time
 // axis), `waitFor` / `tick`, the client-side data-head doubles
-// (`makeFakeDataPort` / `makeCapturingDataClient`), and the `Harness` marker
+// (`makeFakeDataPort` / `makeCapturingDataClient`), the translation-catalogue
+// audit (`flattenCatalogue` / `findUndeclaredCodes` / `findSharedCodes`), and
+// the `Harness` marker
 // interface every framework harness extends. Kept out of the main barrel so production bundles don't pull
 // the test scaffolding in by default; adopters opt in by importing from
 // `@hydranium/protocol/testing`.
 //
-// Neutrality is gated (`scripts/check-neutral-bundles.mjs`), which is why the
+// Neutrality is gated (`scripts/check-neutral-bundles.mts`), which is why the
 // duplex transports are NOT here: a `PassThrough` pair is in their exported
 // type, so they cannot be made portable and live at `./testing/node` instead.
 // The same rule the package surface uses — the portable name is the short one.
 
+export * from './catalogue-audit';
 export * from './data-doubles';
 export * from './fake-clock';
 export * from './harness';

package/src/testing/node/duplex-connection.ts

@@ -32,8 +32,9 @@ export function makeDuplexConnectionPair(): DuplexConnectionPair {
    const pair = makeDuplexStreamPair();
    const { clientToServer, serverToClient } = pair;
 
-   const left = createMessageConnection(new StreamMessageReader(serverToClient), new StreamMessageWriter(clientToServer));
-   const right = createMessageConnection(new StreamMessageReader(clientToServer), new StreamMessageWriter(serverToClient));
+   // `console`, so a protocol fault on either end shows in the test's output.
+   const left = createMessageConnection(new StreamMessageReader(serverToClient), new StreamMessageWriter(clientToServer), console);
+   const right = createMessageConnection(new StreamMessageReader(clientToServer), new StreamMessageWriter(serverToClient), console);
 
    left.listen();
    right.listen();

package/src/testing/node/index.ts

@@ -8,8 +8,7 @@
  ********************************************************************************/
 
 // Subpath barrel for `@hydranium/protocol/testing/node` — the test transports
-// that need a Node runtime: a crossed `PassThrough` pair and the in-process
-// `MessageConnection` bridge over it.
+// that need a Node runtime.
 //
 // Separate from `./testing` because a `PassThrough` is in `DuplexStreamPair`'s
 // exported type and `StreamMessageReader` comes from `vscode-jsonrpc/node`, so
@@ -20,3 +19,4 @@
 
 export * from './duplex-connection';
 export * from './duplex-stream';
+export * from './message-port-pair';

package/src/testing/node/message-port-pair.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { MessageChannel } from 'node:worker_threads';
+import type { TransferredMessagePort } from '../../client/post-message-transport';
+
+/**
+ * The two ends of a `worker_threads` `MessageChannel`, typed as the transferred
+ * browser ports `createMessagePortTransport` takes. Node's port clones and keeps
+ * order as a browser's does, which is what lets a headless test stand in for a
+ * worker.
+ *
+ * `dispose` closes both ports. Node reports that as a close and a browser port
+ * reports nothing, so a test that asserts on a close does so before teardown.
+ */
+export interface MessagePortPair {
+   readonly port1: TransferredMessagePort;
+   readonly port2: TransferredMessagePort;
+   dispose(): void;
+}
+
+export function makeMessagePortPair(): MessagePortPair {
+   const channel = new MessageChannel();
+   return {
+      // Node's port satisfies the structural type at runtime; the cast records
+      // one platform's port standing in for the other's.
+      port1: channel.port1 as unknown as TransferredMessagePort,
+      port2: channel.port2 as unknown as TransferredMessagePort,
+      dispose(): void {
+         channel.port1.close();
+         channel.port2.close();
+      }
+   };
+}

package/src/testing/wait-for.ts

@@ -33,13 +33,19 @@ export interface WaitForOptions {
    readonly timeoutMs?: number;
    /** Poll the predicate every this-many milliseconds. Default 5. */
    readonly intervalMs?: number;
-   /** Error message on timeout. Default a generic phrasing. */
-   readonly message?: string;
+   /**
+    * Error message on timeout, and when the predicate throws. A function is
+    * called only then, so it can report the state the wait ended on; when it
+    * throws, the default text is used, with its throw as the error's `cause`
+    * unless the predicate threw. Default a generic phrasing.
+    */
+   readonly message?: string | (() => string);
 }
 
 /**
  * Resolve once `predicate()` returns true, polling at `intervalMs`; reject with
- * `message` once `timeoutMs` elapses. The **non-racy** alternative to a fixed
+ * `message` once `timeoutMs` elapses, or at once when the predicate throws, with
+ * the throw as the error's `cause`. The **non-racy** alternative to a fixed
  * sleep for awaiting an asynchronous side effect that lands on an observable
  * value.
  *
@@ -56,20 +62,62 @@ export interface WaitForOptions {
 export function waitFor(predicate: () => boolean, options: WaitForOptions = {}): Promise<void> {
    const timeoutMs = options.timeoutMs ?? 2000;
    const intervalMs = options.intervalMs ?? 5;
-   const message = options.message ?? `Timed out after ${timeoutMs}ms waiting for a condition`;
-   if (predicate()) {
-      return Promise.resolve();
-   }
+   const defaultMessage = `Timed out after ${timeoutMs}ms waiting for a condition`;
    return new Promise<void>((resolve, reject) => {
-      const deadline = setTimeout(() => {
+      // A throw from the predicate or the message function would leave the
+      // promise unsettled from the poll's or the deadline's timer, or escape
+      // `waitFor` itself on the first check; it rejects instead, with the
+      // predicate's throw, else the message function's, as cause. True once
+      // the promise is settled.
+      const settle = (timedOut: boolean): boolean => {
+         let met = false;
+         let threw = false;
+         let cause: unknown;
+         try {
+            met = predicate();
+         } catch (error: unknown) {
+            threw = true;
+            cause = error;
+         }
+         if (met) {
+            resolve();
+            return true;
+         }
+         if (!timedOut && !threw) {
+            return false;
+         }
+         let message = defaultMessage;
+         try {
+            if (typeof options.message === 'function') {
+               message = options.message();
+            } else if (options.message !== undefined) {
+               message = options.message;
+            }
+         } catch (error: unknown) {
+            if (!threw) {
+               threw = true;
+               cause = error;
+            }
+         }
+         reject(new Error(message, threw ? { cause } : undefined));
+         return true;
+      };
+      if (settle(false)) {
+         return;
+      }
+      const stop = (): void => {
          clearInterval(poll);
-         reject(new Error(message));
+         clearTimeout(deadline);
+      };
+      // A stalled loop can run the deadline after the condition came true but
+      // before the next poll saw it, so the deadline checks once more.
+      const deadline = setTimeout(() => {
+         settle(true);
+         stop();
       }, timeoutMs);
       const poll = setInterval(() => {
-         if (predicate()) {
-            clearInterval(poll);
-            clearTimeout(deadline);
-            resolve();
+         if (settle(false)) {
+            stop();
          }
       }, intervalMs);
    });

package/src/tracer.ts

@@ -12,6 +12,7 @@ import { Format, Logger, type LogThreshold } from './logger';
 import { NoopLogger } from './noop-logger';
 import { DefaultProfileSession, type ProfileSession } from './profile-session';
 import { Disposable } from './util';
+import { describeErrorWithStack } from './messages/primitives';
 
 /** Module-global so nested timers don't reuse ids. */
 let nextTimerId = 0;
@@ -181,15 +182,10 @@ export class DefaultTracer implements Tracer {
          const suffix = this.timingSuffix(status, elapsed, options);
          this.logger[logLevel](`${label} [#${id} ${status}, ${Format.elapsed(elapsed)}${currentExtras()}${suffix}]`);
          if (status === 'failed') {
-            // The timing line above sits at `logLevel`, which may be below the
-            // active threshold — and on its own it never carries *why* the op
-            // failed. Surface the error at warn so the failure is never silent,
-            // with the stack at debug. Cancellations are normal control flow.
-            const detail = error instanceof Error ? error.message : String(error);
-            this.logger.warn(`${label} [#${id}] failed: ${detail}`);
-            if (error instanceof Error && error.stack) {
-               this.logger.debug(error.stack);
-            }
+            // Reporting the failure is the caller's, who receives it: a line at
+            // warn here would exist only while `logLevel` is enabled.
+            const detail = describeErrorWithStack(error);
+            this.logger.debug(`${label} [#${id}] failed: ${detail}`);
          }
       };
       let result: T;