Method constructor

src/extraction/store-writer.ts:81–127

(workerScriptPath: string, dbPath: string, fastInit: boolean)

  private belowWaiters: Array<{ limit: number; resolve: () => void }> = [];

  constructor(workerScriptPath: string, dbPath: string, fastInit: boolean) {
    this.worker = new Worker(workerScriptPath);
    this.started = workerStarted(this.worker);
    let readyResolve!: () => void;
    let readyReject!: (e: Error) => void;
    this.readyPromise = new Promise<void>((resolve, reject) => {
      readyResolve = resolve;
      readyReject = reject;
    });

    this.worker.on('message', (msg: { type: string; id?: number; message?: string }) => {
      if (msg.type === 'ready') {
        readyResolve();
      } else if (msg.type === 'ack') {
        this.settleOne();
      } else if (msg.type === 'drained' && msg.id !== undefined) {
        const waiter = this.drainWaiters.get(msg.id);
        this.drainWaiters.delete(msg.id);
        if (!waiter) return;
        if (this.firstError) waiter.reject(this.firstError);
        else waiter.resolve();
      } else if (msg.type === 'error') {
        if (!this.firstError) this.firstError = new Error(`store worker: ${msg.message}`);
        this.settleOne(); // the error reply is also the failed bundle's ack
      }
    });
    this.worker.on('error', (err) => {
      this.failAll(err instanceof Error ? err : new Error(String(err)));
      readyReject(this.firstError!);
    });
    this.worker.on('exit', (code) => {
      this.exited = true;
      if (code !== 0) {
        this.failAll(new Error(`store worker exited with code ${code}`));
        readyReject(this.firstError!);
      } else if (this.drainWaiters.size > 0 || this.belowWaiters.length > 0) {
        // A clean exit with waiters pending is a protocol violation (only
        // close() should end the worker) — settle the waiters instead of
        // hanging the index forever.
        this.failAll(new Error('store worker exited before drain completed'));
      }
    });

    this.worker.postMessage({ type: 'open', dbPath, fastInit });
    // The worker holds the event loop open only until close(); don't unref —
    // bundles must never be dropped because main ran out of work.
  }

  private failAll(err: Error): void {
    if (!this.firstError) this.firstError = err;