Function main

scripts/leak-check.js:204–315

()

};

const main = async () => {
  const config = new Config();
  config.setPort(PORT);
  config.setToken(TOKEN);
  config.setConcurrent(10);

  const browserless = new Browserless({ config, metrics: new Metrics() });
  await browserless.start();
  const dataDir = await config.getDataDir();
  console.log(`Server up on :${PORT} — ${WAVES} waves, ~60 requests each\n`);

  const results = [];
  const requestFailures = [];

  for (let wave = 1; wave <= WAVES; wave++) {
    const startedAt = Date.now();
    const failures = await pool(scenarios(wave));
    requestFailures.push(...failures.map((f) => `wave ${wave}: ${f}`));
    // Let in-flight teardown (browser closes, dir deletes) finish
    await sleep(2000);

    const mem = await settleAndMeasure();
    const state = internals(browserless);
    const dataDirs = await countDataDirs(dataDir);
    results.push({ dataDirs, mem, state, wave });

    console.log(
      `wave ${wave}: heap=${mb(mem.heapUsed)} rss=${mb(mem.rss)} ` +
        `sessions=${state.sessions} timers=${state.timers} ` +
        `limiterQueue=${state.limiterQueue} fsCache=${state.fsCacheEntries} ` +
        `writeChains=${state.writeChains} ` +
        `cfgListeners=${state.configListeners} dataDirs=${dataDirs} ` +
        `(${((Date.now() - startedAt) / 1000).toFixed(1)}s, ${failures.length} req errors)`,
    );
  }

  await browserless.stop();
  await sleep(1000);
  const finalMem = await settleAndMeasure();

  // ---- Verdict ----------------------------------------------------------
  console.log('\n--- Analysis ---');
  const measured = results.slice(WARMUP_WAVES);
  const deltas = measured
    .slice(1)
    .map((r, i) => r.mem.heapUsed - measured[i].mem.heapUsed);
  const avgGrowth = deltas.length
    ? deltas.reduce((a, b) => a + b, 0) / deltas.length
    : 0;
  const monotonic = deltas.length > 1 && deltas.every((d) => d > 0);

  const problems = [];
  const warnings = [];
  const last = results[results.length - 1];

  // Only a large, unambiguous average growth is a hard failure. A small
  // monotonic creep across this few measured waves is too noise-sensitive to
  // block CI — GC timing and heap fragmentation alone can produce a short run