Class FakeWorker

__tests__/parse-pool.test.ts:30–61

* Fake worker speaking the same {load-grammars → grammars-loaded} / * {parse → parse-result} protocol as the real parse-worker. `behavior` decides * per parse whether to return a result, crash (exit≠0), hang (never reply — * exercises the timeout), or wait on a promise (hold a parse in-flight to

 * wired its listeners first.
 */
class FakeWorker implements ParsePoolWorker {
  private msgCb?: (m: unknown) => void;
  private exitCb?: (code: number) => void;
  alive = true;
  constructor(private behavior: (m: ParseMsg) => Action, private onTerminate?: () => void) {}
  on(event: string, cb: (...args: any[]) => void): void {
    if (event === 'message') this.msgCb = cb;
    else if (event === 'exit') this.exitCb = cb;
    // 'error' unused by the fakes
  }
  private reply(id: number, result: ExtractionResult): void {
    if (this.alive) this.msgCb?.({ type: 'parse-result', id, result });
  }
  postMessage(msg: unknown): void {
    const m = msg as { type: string } & Partial<ParseMsg>;
    if (m.type === 'load-grammars') {
      setTimeout(() => { if (this.alive) this.msgCb?.({ type: 'grammars-loaded' }); }, 0);
      return;
    }
    if (m.type !== 'parse') return;
    const action = this.behavior(m as ParseMsg);
    if ('crash' in action) {
      this.alive = false;
      setTimeout(() => this.exitCb?.(1), 0); // simulate a WASM-OOM exit(1)
      return;
    }
    if ('hang' in action) return; // never reply → timeout path
    if ('wait' in action) { void action.wait.then((r) => this.reply(m.id!, r)); return; }
    setTimeout(() => this.reply(m.id!, action.result), 0);
  }
  terminate(): Promise<number> { this.alive = false; this.onTerminate?.(); return Promise.resolve(0); }
}

const task = (filePath: string, content = 'code'): ParseTask => ({ filePath, content, language: 'typescript' as Language });
const result = (tag = 0): ExtractionResult => ({ nodes: [], edges: [], unresolvedReferences: [], errors: [], durationMs: tag });