@hydranium/protocol 1.0.0-next.31 → 1.0.0-next.313

package/src/testing/catalogue-audit.ts

@@ -0,0 +1,111 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, 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 { collectMessages } from '../messages/primitives';
+
+/**
+ * Audit a translation catalogue against the codes that actually exist.
+ *
+ * **The one failure mode a catalogue has, and the only one nothing else
+ * catches.** A key naming no declared code falls back to the English — which is
+ * byte-identical to a deliberate omission, so a typo is invisible at runtime and
+ * indistinguishable from the partial-catalogue behaviour every adopter relies
+ * on. Nothing on the render path can tell them apart, `theia nls-extract`
+ * reports what the SOURCE declares rather than whether a catalogue matches it,
+ * and the framework's own gates see only the framework's own files.
+ *
+ * Shipped as test support rather than as a runtime check on purpose: an
+ * orphaned key is an authoring mistake, and failing a server boot over one would
+ * take a running product down for a cosmetic defect.
+ */
+
+/**
+ * Flatten a nested catalogue into the `/`-joined keys a message code is spelled
+ * with, dropping `_`-prefixed keys as notes to a human reader.
+ *
+ * Nesting is a HOST convention, not the framework's: Theia flattens a nested
+ * catalogue by joining keys with `/`, which is the separator a code already
+ * uses, so an adopter on that host writes the file nested and one handed
+ * straight to a `DefaultMessageRenderer` writes it flat. Both end up here.
+ *
+ * `_`-prefixed keys are dropped by PREFIX rather than by matching one literal
+ * name, so a second note added to a file cannot silently become a catalogue
+ * entry. A code is three `/`-separated segments, so no real entry can begin
+ * with `_`.
+ */
+export function flattenCatalogue(catalogue: Record<string, unknown>, prefix = ''): Record<string, string> {
+   const flat: Record<string, string> = {};
+   for (const [key, value] of Object.entries(catalogue)) {
+      if (key.startsWith('_')) {
+         continue;
+      }
+      const joined = prefix ? `${prefix}/${key}` : key;
+      if (typeof value === 'string') {
+         flat[joined] = value;
+      } else if (typeof value === 'object' && value !== null) {
+         Object.assign(flat, flattenCatalogue(value as Record<string, unknown>, joined));
+      }
+   }
+   return flat;
+}
+
+/** Options for {@link findUndeclaredCodes}. */
+export interface CatalogueAuditOptions {
+   /**
+    * Key prefixes to skip, for entries whose codes are NOT declared through a
+    * `defineMessage` barrel.
+    *
+    * The real case is a host's own mechanism: Theia's `nls.localize` takes its
+    * key as an inline literal at the call site, so those keys exist only in
+    * source text and no barrel can enumerate them. Keep this as narrow as the
+    * host layer actually is — exempting a namespace is exempting every typo in
+    * it, which is what this function exists to find.
+    */
+   readonly exemptPrefixes?: readonly string[];
+}
+
+/**
+ * Every catalogue key that names no code any of `barrels` declares.
+ *
+ * Barrels are taken as opaque objects and read with {@link collectMessages},
+ * which is what lets a caller pass a `import * as messages` namespace directly:
+ * a barrel's value type is a union of its declarations AND its functions, and
+ * filtering that union will not narrow to a `MessageDefinition`.
+ *
+ * Returns the offending keys rather than a boolean, so a failing assertion names
+ * WHICH key is wrong — a count says only that something is.
+ */
+export function findUndeclaredCodes(
+   catalogueKeys: readonly string[],
+   barrels: readonly object[],
+   options: CatalogueAuditOptions = {}
+): string[] {
+   const declared = new Set(barrels.flatMap(barrel => collectMessages(barrel).map(message => message.code)));
+   const exempt = options.exemptPrefixes ?? [];
+   return catalogueKeys.filter(key => !exempt.some(prefix => key.startsWith(prefix)) && !declared.has(key));
+}
+
+/**
+ * Keys present in more than one catalogue — the shape a split catalogue rots
+ * into.
+ *
+ * Exactly one side renders a given message, so two catalogues holding one code
+ * are two authorities over one sentence and they diverge on the first reword.
+ * Nothing at runtime notices: both sides render, and whichever ran last wins on
+ * its own surface.
+ *
+ * Takes the key sets rather than a boolean answer for the same reason as
+ * {@link findUndeclaredCodes}, and reports NOTHING when a set is empty — an
+ * empty catalogue shares no key with anything, so a caller must assert
+ * non-emptiness separately or a failed read passes this vacuously.
+ */
+export function findSharedCodes(first: readonly string[], second: readonly string[]): string[] {
+   const other = new Set(second);
+   return first.filter(key => other.has(key));
+}

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();
+      }
+   };
+}