@travetto/compiler 4.0.0-rc.0 → 4.0.0-rc.1

package/src/watch.ts

@@ -1,24 +1,19 @@
-import { readFileSync } from 'node:fs';
-
-import {
-  ManifestModuleUtil, ManifestUtil, ManifestModuleFolderType, ManifestModuleFileType, path, ManifestModule,
-} from '@travetto/manifest';
+import { ManifestContext, ManifestModuleUtil, ManifestUtil, RuntimeIndex, path } from '@travetto/manifest';
 
 import type { CompileStateEntry } from './types';
 import { CompilerState } from './state';
 import { CompilerUtil } from './util';
 
-import { WatchEvent, fileWatchEvents } from './internal/watch-core';
+import { AsyncQueue } from '../support/queue';
 
-type DirtyFile = { modFolder: string, mod: string, remove?: boolean, moduleFile: string, folderKey: ManifestModuleFolderType, type: ManifestModuleFileType };
+type WatchAction = 'create' | 'update' | 'delete';
+type WatchEvent = { action: WatchAction, file: string };
+type CompilerWatchEvent = WatchEvent & { entry: CompileStateEntry };
 
 /**
  * Watch support, based on compiler state and manifest details
  */
 export class CompilerWatcher {
-
-  #sourceHashes = new Map<string, number>();
-  #dirtyFiles: DirtyFile[] = [];
   #state: CompilerState;
   #signal: AbortSignal;
 
@@ -27,54 +22,75 @@ export class CompilerWatcher {
     this.#signal = signal;
   }
 
-  async #rebuildManifestsIfNeeded(): Promise<void> {
-    if (!this.#dirtyFiles.length) {
+  /** Watch files */
+  async * #watchFolder(rootPath: string): AsyncIterable<WatchEvent> {
+    const q = new AsyncQueue<WatchEvent>(this.#signal);
+    const lib = await import('@parcel/watcher');
+
+    const cleanup = await lib.subscribe(rootPath, (err, events) => {
+      if (err) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        q.throw(err instanceof Error ? err : new Error((err as Error).message));
+        return;
+      }
+      for (const ev of events) {
+        q.add({ action: ev.type, file: path.toPosix(ev.path) });
+      }
+    }, {
+      // TODO: Read .gitignore?
+      ignore: [
+        'node_modules', '**/node_modules', '.git', '**/.git',
+        `${this.#state.manifest.build.outputFolder}/node_modules/**`,
+        `${this.#state.manifest.build.compilerFolder}/node_modules/**`,
+        `${this.#state.manifest.build.toolFolder}/**`
+      ]
+    });
+
+    if (this.#signal.aborted) { // If already aborted, can happen async
+      cleanup.unsubscribe();
+      return;
+    }
+
+    this.#signal.addEventListener('abort', () => cleanup.unsubscribe());
+
+    yield* q;
+  }
+
+  async #rebuildManifestsIfNeeded(event: CompilerWatchEvent, moduleFile: string): Promise<void> {
+    if (!event.entry.outputFile || event.action === 'update') {
       return;
     }
-    const mods = [...new Set(this.#dirtyFiles.map(x => x.modFolder))];
-    const contexts = await Promise.all(mods.map(folder =>
-      ManifestUtil.getModuleContext(this.#state.manifest, folder)
-    ));
 
-    const files = this.#dirtyFiles.slice(0);
-    this.#dirtyFiles = [];
+    const toUpdate: ManifestContext[] = RuntimeIndex.getDependentModules(event.entry.module.name, 'parents')
+      .map(el => ManifestUtil.getModuleContext(this.#state.manifest, el.sourceFolder));
+
+    toUpdate.push(this.#state.manifest);
+
+    const mod = event.entry.module;
+    const folderKey = ManifestModuleUtil.getFolderKey(moduleFile);
+    const fileType = ManifestModuleUtil.getFileType(moduleFile);
 
-    for (const ctx of [...contexts, this.#state.manifest]) {
+    for (const ctx of toUpdate) {
       const newManifest = await ManifestUtil.buildManifest(ctx);
-      for (const file of files) {
-        if (file.mod in newManifest.modules) {
-          const modFiles = newManifest.modules[file.mod].files[file.folderKey] ??= [];
-          const idx = modFiles.findIndex(x => x[0] === file.moduleFile);
-
-          if (!file.remove && idx < 0) {
-            modFiles.push([file.moduleFile, file.type, Date.now()]);
-          } else if (idx >= 0) {
-            if (file.remove) {
-              modFiles.splice(idx, 1);
-            } else {
-              modFiles[idx] = [file.moduleFile, file.type, Date.now()];
-            }
+      if (mod.name in newManifest.modules) {
+        const modFiles = newManifest.modules[mod.name].files[folderKey] ??= [];
+        const idx = modFiles.findIndex(x => x[0] === moduleFile);
+
+        if (event.action === 'create' && idx < 0) {
+          modFiles.push([moduleFile, fileType, Date.now()]);
+        } else if (idx >= 0) {
+          if (event.action === 'delete') {
+            modFiles.splice(idx, 1);
+          } else {
+            modFiles[idx] = [moduleFile, fileType, Date.now()];
           }
         }
       }
       await ManifestUtil.writeManifest(newManifest);
     }
-    // Reindex
-    this.#state.manifestIndex.init(this.#state.manifestIndex.manifestFile);
-  }
-
-  #getModuleMap(): Record<string, ManifestModule> {
-    return Object.fromEntries(
-      Object.values(this.#state.manifest.modules).map(x => [path.resolve(this.#state.manifest.workspace.path, x.sourceFolder), x])
-    );
-  }
 
-  #addDirtyFile(mod: ManifestModule, folder: string, moduleFile: string, remove = false): void {
-    this.#dirtyFiles.push({
-      mod: mod.name, modFolder: folder, remove, moduleFile,
-      folderKey: ManifestModuleUtil.getFolderKey(moduleFile),
-      type: ManifestModuleUtil.getFileType(moduleFile),
-    });
+    // Reindex at workspace root
+    this.#state.manifestIndex.init(ManifestUtil.getManifestLocation(this.#state.manifest));
   }
 
   /**
@@ -83,69 +99,56 @@ export class CompilerWatcher {
    * @param handler
    * @returns
    */
-  async * watchChanges(): AsyncIterable<WatchEvent<{ entry: CompileStateEntry }>> {
+  async * watchChanges(): AsyncIterable<CompilerWatchEvent> {
     if (this.#signal.aborted) {
-      yield* [];
       return;
     }
 
-    const mods = this.#getModuleMap();
-
-    const modules = [...this.#state.manifestIndex.getModuleList('all')].map(x => this.#state.manifestIndex.getModule(x)!);
-
-    const stream = fileWatchEvents(this.#state.manifest, modules, this.#signal);
-    for await (const ev of stream) {
-
-      if (ev.action === 'reset') {
-        yield ev;
-        return;
+    const manifest = this.#state.manifest;
+    const ROOT_LOCK = path.resolve(manifest.workspace.path, 'package-lock.json');
+    const ROOT_PKG = path.resolve(manifest.workspace.path, 'package.json');
+    const OUTPUT_PATH = path.resolve(manifest.workspace.path, manifest.build.outputFolder);
+    const COMPILER_PATH = path.resolve(manifest.workspace.path, manifest.build.compilerFolder);
+
+    for await (const ev of this.#watchFolder(this.#state.manifest.workspace.path)) {
+      const { action, file: sourceFile } = ev;
+
+      if (
+        sourceFile === ROOT_LOCK ||
+        sourceFile === ROOT_PKG ||
+        (action === 'delete' && (sourceFile === OUTPUT_PATH || sourceFile === COMPILER_PATH))
+      ) {
+        throw new Error('RESET');
       }
 
-      const { action, file: sourceFile, folder } = ev;
-      const mod = mods[folder];
-      const moduleFile = mod.sourceFolder ?
-        (sourceFile.includes(mod.sourceFolder) ? sourceFile.split(`${mod.sourceFolder}/`)[1] : sourceFile) :
-        sourceFile.replace(`${this.#state.manifest.workspace.path}/`, '');
+      const fileType = ManifestModuleUtil.getFileType(sourceFile);
+      if (!CompilerUtil.validFile(fileType)) {
+        continue;
+      }
 
       let entry = this.#state.getBySource(sourceFile);
 
-      switch (action) {
-        case 'create': {
-          const fileType = ManifestModuleUtil.getFileType(moduleFile);
-          this.#addDirtyFile(mod, folder, moduleFile);
-          if (CompilerUtil.validFile(fileType)) {
-            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
-            entry = this.#state.registerInput(mod, moduleFile);
-            this.#sourceHashes.set(sourceFile, hash);
-          }
-          break;
-        }
-        case 'update': {
-          if (entry) {
-            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
-            if (this.#sourceHashes.get(sourceFile) !== hash) {
-              this.#state.resetInputSource(entry.input);
-              this.#sourceHashes.set(sourceFile, hash);
-            } else {
-              entry = undefined;
-            }
-          }
-          break;
-        }
-        case 'delete': {
-          if (entry) {
-            this.#state.removeInput(entry.input);
-            if (entry.output) {
-              this.#addDirtyFile(mod, folder, moduleFile, true);
-            }
-          }
-        }
+      const mod = entry?.module ?? this.#state.manifestIndex.findModuleForArbitraryFile(sourceFile);
+      if (!mod) { // Unknown module
+        continue;
       }
 
-      if (entry) {
-        await this.#rebuildManifestsIfNeeded();
-        yield { action, file: entry.source, folder, entry };
+      const modRoot = mod.sourceFolder || this.#state.manifest.workspace.path;
+      const moduleFile = sourceFile.includes(modRoot) ? sourceFile.split(`${modRoot}/`)[1] : sourceFile;
+
+      if (action === 'create') {
+        entry = this.#state.registerInput(mod, moduleFile);
+      } else if (!entry) {
+        continue;
+      } else if (action === 'update' && !this.#state.checkIfSourceChanged(entry.inputFile)) {
+        continue;
+      } else if (action === 'delete') {
+        this.#state.removeInput(entry.inputFile);
       }
+
+      const result: CompilerWatchEvent = { action, file: entry.sourceFile, entry };
+      await this.#rebuildManifestsIfNeeded(result, moduleFile);
+      yield result;
     }
   }
 }

package/support/entry.trvc.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerEventType, CompilerOp, CompilerServerInfo } from './types';
+import type { CompilerLogLevel, CompilerMode, CompilerServerInfo } from './types';
 import { LogUtil } from './log';
 import { CommonUtil } from './util';
 import { CompilerSetup } from './setup';
@@ -13,9 +13,35 @@ import { CompilerClient } from './server/client';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export const main = (ctx: ManifestContext) => {
-  const client = new CompilerClient(ctx, LogUtil.scoped('client.main'));
+  const log = LogUtil.logger('client.main');
+  const client = new CompilerClient(ctx, log);
   const buildFolders = [ctx.build.outputFolder, ctx.build.compilerFolder];
 
+  /** Main entry point for compilation */
+  const compile = async (op: CompilerMode, logLevel: CompilerLogLevel, setupOnly = false): Promise<void> => {
+    LogUtil.initLogs(ctx, logLevel ?? 'info');
+
+    const server = await new CompilerServer(ctx, op).listen();
+
+    // Wait for build to be ready
+    if (server) {
+      log('debug', 'Start Server');
+      await server.processEvents(async function* (signal) {
+        const changed = await CompilerSetup.setup(ctx);
+        if (!setupOnly) {
+          yield* CompilerRunner.runProcess(ctx, changed, op, signal);
+        }
+      });
+      log('debug', 'End Server');
+    } else {
+      log('info', 'Server already running, waiting for initial compile to complete');
+      const ctrl = new AbortController();
+      LogUtil.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
+      await client.waitForState(['compile-end', 'watch-start'], 'Successfully built');
+      ctrl.abort();
+    }
+  };
+
   const ops = {
     /** Stop the server */
     async stop(): Promise<void> {
@@ -26,6 +52,9 @@ export const main = (ctx: ManifestContext) => {
       }
     },
 
+    /** Restart the server */
+    async restart(): Promise<void> { await client.stop().then(() => ops.watch()); },
+
     /** Get server info */
     info: (): Promise<CompilerServerInfo | undefined> => client.info(),
 
@@ -40,37 +69,33 @@ export const main = (ctx: ManifestContext) => {
     },
 
     /** Stream events */
-    events: async (type: CompilerEventType, handler: (ev: unknown) => unknown): Promise<void> => {
+    events: async (type: string, handler: (ev: unknown) => unknown): Promise<void> => {
       LogUtil.initLogs(ctx, 'error');
-      for await (const ev of client.fetchEvents(type)) { await handler(ev); }
+      if (type === 'change' || type === 'log' || type === 'progress' || type === 'state') {
+        for await (const ev of client.fetchEvents(type)) { await handler(ev); }
+      } else {
+        throw new Error(`Unknown event type: ${type}`);
+      }
     },
 
-    /** Main entry point for compilation */
-    async compile(op: CompilerOp, setupOnly = false): Promise<(mod: string) => Promise<unknown>> {
-      LogUtil.initLogs(ctx, op === 'run' ? 'error' : 'info');
+    /** Build the project */
+    async build(): Promise<void> { await compile('build', 'info'); },
 
-      const server = await new CompilerServer(ctx, op).listen();
+    /** Build and watch the project */
+    async watch(): Promise<void> { await compile('watch', 'info'); },
 
-      // Wait for build to be ready
-      if (server) {
-        await server.processEvents(async function* (signal) {
-          const changed = await CompilerSetup.setup(ctx);
-          if (!setupOnly) {
-            yield* CompilerRunner.runProcess(ctx, changed, op, signal);
-          }
-        });
-      } else {
-        const ctrl = new AbortController();
-        LogUtil.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
-        await client.waitForState(['compile-end', 'watch-start'], 'Successfully built');
-        ctrl.abort();
+    /** Build and return a loader */
+    async getLoader(): Promise<(mod: string) => Promise<unknown>> {
+      // Short circuit if we can
+      if (!(await client.isWatching())) {
+        await compile('build', 'error');
       }
       return CommonUtil.moduleLoader(ctx);
     },
 
     /** Manifest entry point */
     async manifest(output?: string, prod?: boolean): Promise<void> {
-      await ops.compile('run', true);
+      await compile('build', 'error', true);
       await CompilerSetup.exportManifest(ctx, output, prod); return;
     }
   };

package/support/log.ts

@@ -18,6 +18,18 @@ export class LogUtil {
 
   static logProgress?: ProgressWriter;
 
+  static linePartial = false;
+
+  static #rewriteLine(text: string): Promise<void> | void {
+    // Move to 1st position, and clear after text
+    const done = process.stdout.write(`\x1b[1G${text}\x1b[0K`);
+    this.linePartial = !!text;
+    if (!done) {
+      return new Promise<void>(r => process.stdout.once('drain', r));
+    }
+  }
+
+
   /**
    * Set level for operation
    */
@@ -28,20 +40,13 @@ export class LogUtil {
       this.logLevel = build || defaultLevel;
     }
     this.root = ctx.workspace.path;
-
-    if (this.isLevelActive('info') && process.stdout.isTTY) {
-      this.logProgress = this.#logProgressEvent;
-    }
+    this.logProgress = (this.isLevelActive('info') && process.stdout.isTTY) ? this.#logProgressEvent : undefined;
   }
 
   static #logProgressEvent(ev: CompilerProgressEvent): Promise<void> | void {
     const pct = Math.trunc(ev.idx * 100 / ev.total);
     const text = ev.complete ? '' : `Compiling [${'#'.repeat(Math.trunc(pct / 10)).padEnd(10, ' ')}] [${ev.idx}/${ev.total}] ${ev.message}`;
-    // Move to 1st position, and clear after text
-    const done = process.stdout.write(`\x1b[1G${text}\x1b[0K`);
-    if (!done) {
-      return new Promise<void>(r => process.stdout.once('drain', r));
-    }
+    return this.#rewriteLine(text);
   }
 
   /**
@@ -52,18 +57,18 @@ export class LogUtil {
   }
 
   /**
-   * Log message with filtering by level
+   * Log event with filtering by level
    */
-  static log(event: CompilerLogEvent): void;
-  static log(scope: string, ...args: Parameters<CompilerLogger>): void;
-  static log(scopeOrEvent: string | CompilerLogEvent, level?: CompilerLogLevel, message?: string, ...args: unknown[]): void {
-    const ev = typeof scopeOrEvent === 'string' ? { scope: scopeOrEvent, level: level!, message, args } : scopeOrEvent;
+  static logEvent(ev: CompilerLogEvent): void {
     if (this.isLevelActive(ev.level)) {
       const params = [ev.message, ...ev.args ?? []].map(x => typeof x === 'string' ? x.replaceAll(this.root, '.') : x);
       if (ev.scope) {
         params.unshift(`[${ev.scope.padEnd(SCOPE_MAX, ' ')}]`);
       }
       params.unshift(new Date().toISOString(), `${ev.level.padEnd(5)}`);
+      if (this.linePartial) {
+        this.#rewriteLine(''); // Clear out progress line
+      }
       // eslint-disable-next-line no-console
       console[ev.level]!(...params);
     }
@@ -73,7 +78,7 @@ export class LogUtil {
    * With logger
    */
   static withLogger<T>(scope: string, op: WithLogger<T>, basic = true): Promise<T> {
-    const log = this.scoped(scope);
+    const log = this.logger(scope);
     basic && log('debug', 'Started');
     return op(log).finally(() => basic && log('debug', 'Completed'));
   }
@@ -81,15 +86,8 @@ export class LogUtil {
   /**
    * With scope
    */
-  static scoped(scope: string): CompilerLogger {
-    return this.log.bind(this, scope);
-  }
-
-  /**
-   * Stream Compiler log events to console
-   */
-  static async consumeLogEvents(src: AsyncIterable<CompilerLogEvent>): Promise<void> {
-    for await (const ev of src) { this.log(ev); }
+  static logger(scope: string): CompilerLogger {
+    return (level, message, ...args) => this.logEvent({ scope, message, level, args, time: Date.now() });
   }
 
   /**

package/support/queue.ts

@@ -28,6 +28,12 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
     return { value: (this.#queue.length ? this.#queue.shift() : undefined)!, done: this.#done };
   }
 
+  async throw(e?: Error): Promise<IteratorResult<X>> {
+    this.#done = true;
+    this.#ready.reject(e);
+    return { value: undefined, done: this.#done };
+  }
+
   add(item: X): void {
     this.#queue.push(item);
     this.#ready.resolve();

package/support/server/client.ts

@@ -6,10 +6,7 @@ import { ManifestContext } from '@travetto/manifest';
 
 import type { CompilerEvent, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types';
 import type { CompilerLogger } from '../log';
-
-declare global {
-  interface RequestInit { timeout?: number }
-}
+import { ProcessHandle } from './process-handle';
 
 type FetchEventsConfig<T> = {
   signal?: AbortSignal;
@@ -23,11 +20,13 @@ type FetchEventsConfig<T> = {
 export class CompilerClient {
 
   #url: string;
-  #log?: CompilerLogger;
+  #log: CompilerLogger;
+  #handle: Record<'compiler' | 'server', ProcessHandle>;
 
-  constructor(ctx: ManifestContext, log?: CompilerLogger) {
+  constructor(ctx: ManifestContext, log: CompilerLogger) {
     this.#url = ctx.build.compilerUrl.replace('localhost', '127.0.0.1');
     this.#log = log;
+    this.#handle = { compiler: new ProcessHandle(ctx, 'compiler'), server: new ProcessHandle(ctx, 'server') };
   }
 
   toString(): string {
@@ -38,20 +37,49 @@ export class CompilerClient {
     return this.#url;
   }
 
+  async #fetch(rel: string, opts?: RequestInit & { timeout?: number }): Promise<Response> {
+    const ctrl = new AbortController();
+    opts?.signal?.addEventListener('abort', () => ctrl.abort());
+    const timeoutId = setTimeout(() => {
+      this.#log('error', `Timeout on request to ${this.#url}${rel}`);
+      ctrl.abort('TIMEOUT');
+    }, 100).unref();
+    try {
+      return await fetch(`${this.#url}${rel}`, { ...opts, signal: ctrl.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
   /** Get server information, if server is running */
   info(): Promise<CompilerServerInfo | undefined> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return fetch(`${this.#url}/info`).then(v => v.json(), () => undefined) as Promise<CompilerServerInfo>;
+    return this.#fetch('/info').then(v => v.json(), () => undefined)
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      .then(v => v as CompilerServerInfo);
+  }
+
+  async isWatching(): Promise<boolean> {
+    return (await this.info())?.state === 'watch-start';
   }
 
   /** Clean the server */
   clean(): Promise<boolean> {
-    return fetch(`${this.#url}/clean`).then(v => v.ok, () => false);
+    return this.#fetch('/clean').then(v => v.ok, () => false);
   }
 
-  /** Stop server */
-  stop(): Promise<boolean> {
-    return fetch(`${this.#url}/stop`).then(v => v.ok, () => false);
+  /** Stop server and wait for shutdown */
+  async stop(): Promise<boolean> {
+    const info = await this.info();
+    if (!info) {
+      this.#log('debug', 'Stopping server, info not found, manual killing');
+      return Promise.all([this.#handle.server.kill(), this.#handle.compiler.kill()])
+        .then(v => v.some(x => x));
+    }
+
+    await this.#fetch('/stop').catch(() => { }); // Trigger
+    this.#log('debug', 'Waiting for compiler to exit');
+    await this.#handle.compiler.ensureKilled();
+    return true;
   }
 
   /** Fetch compiler events */
@@ -64,7 +92,7 @@ export class CompilerClient {
       return;
     }
 
-    this.#log?.('debug', `Starting watch for events of type "${type}"`);
+    this.#log('debug', `Starting watch for events of type "${type}"`);
 
     let signal = cfg.signal;
 
@@ -75,17 +103,15 @@ export class CompilerClient {
       signal = ctrl.signal;
     }
 
-
     const { iteration } = info;
 
     for (; ;) {
       const ctrl = new AbortController();
+      const quit = (): void => ctrl.abort();
       try {
-        signal.addEventListener('abort', () => ctrl.abort());
-        const stream = await fetch(`${this.#url}/event/${type}`, {
-          signal: ctrl.signal,
-          timeout: 1000 * 60 * 60
-        });
+        signal.addEventListener('abort', quit);
+        const stream = await this.#fetch(`/event/${type}`, { signal: ctrl.signal, keepalive: true });
+
         for await (const line of rl.createInterface(Readable.fromWeb(stream.body!))) {
           if (line.trim().charAt(0) === '{') {
             const val = JSON.parse(line);
@@ -96,17 +122,25 @@ export class CompilerClient {
             yield val;
           }
         }
-      } catch (err) { }
+      } catch (err) {
+        if (!ctrl.signal.aborted) { throw err; }
+      }
+      signal.removeEventListener('abort', quit);
 
       await timers.setTimeout(1);
 
       info = await this.info();
 
+      if (ctrl.signal.reason === 'TIMEOUT') {
+        this.#log('debug', 'Failed due to timeout');
+        return;
+      }
+
       if (ctrl.signal.aborted || !info || (cfg.enforceIteration && info.iteration !== iteration)) { // If health check fails, or aborted
-        this.#log?.('debug', `Stopping watch for events of type "${type}"`);
+        this.#log('debug', `Stopping watch for events of type "${type}"`);
         return;
       } else {
-        this.#log?.('debug', `Restarting watch for events of type "${type}"`);
+        this.#log('debug', `Restarting watch for events of type "${type}"`);
       }
     }
   }
@@ -114,18 +148,12 @@ export class CompilerClient {
   /** Wait for one of N states to be achieved */
   async waitForState(states: CompilerStateType[], message?: string, signal?: AbortSignal): Promise<void> {
     const set = new Set(states);
-    const existing = await this.info();
-    this.#log?.('debug', `Existing: ${JSON.stringify(existing)}`);
-    if (existing && set.has(existing.state)) {
-      this.#log?.('debug', `Waited for state, ${existing.state} in server info`);
-      return;
-    }
     // Loop until
-    this.#log?.('debug', `Waiting for states, ${states.join(', ')}`);
+    this.#log('debug', `Waiting for states, ${states.join(', ')}`);
     for await (const _ of this.fetchEvents('state', { signal, until: s => set.has(s.state) })) { }
-    this.#log?.('debug', `Found state, one of ${states.join(', ')} `);
+    this.#log('debug', `Found state, one of ${states.join(', ')} `);
     if (message) {
-      this.#log?.('info', message);
+      this.#log('info', message);
     }
   }
 }