test: cover the memory changes

- With one thread, chunks are processed one at a time, in order.
- Workers get both the old and young generation limits.
- jsx-ast and legacy-html leave their input unchanged on the main thread.
- resolveBundler sets the bundler's thread and allocator variables from
  `threads`, keeps any already set, and leaves a custom bundler alone.

Each fails against `main`.

Assisted-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: ovflowd

packages/core/src/threading/__tests__/index.test.mjs

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 
 import { LogLevel } from '../../logger/constants.mjs';
 import logger from '../../logger/index.mjs';
+import { WORKER_GEN_SIZE, WORKER_HEAP_SIZE } from '../constants.mjs';
 import createWorkerPool from '../index.mjs';
 
 const reporterSpecifier = fileURLToPath(
@@ -114,4 +115,17 @@ describe('createWorkerPool', () => {
       await pool.destroy();
     }
   });
+
+  it("should limit each worker's old and young generation", async () => {
+    const pool = createWorkerPool(1);
+
+    try {
+      deepStrictEqual(pool.options.resourceLimits, {
+        maxOldGenerationSizeMb: WORKER_HEAP_SIZE,
+        maxYoungGenerationSizeMb: WORKER_GEN_SIZE,
+      });
+    } finally {
+      await pool.destroy();
+    }
+  });
 });

packages/core/src/threading/__tests__/parallel.test.mjs

@@ -177,4 +177,32 @@ describe('createParallelWorker', () => {
 
     await pool.destroy();
   });
+
+  it('should process one chunk at a time, in order, with a single thread', async () => {
+    let running = 0;
+    let mostRunning = 0;
+
+    const generator = {
+      name: 'sequential',
+      async processChunk(items, indices) {
+        mostRunning = Math.max(mostRunning, ++running);
+
+        await new Promise(resolve => setImmediate(resolve));
+
+        running--;
+
+        return indices.map(index => items[index]);
+      },
+    };
+
+    const worker = createParallelWorker('sequential', generator, null, {
+      threads: 1,
+      chunkSize: 2,
+    });
+
+    const chunks = await collectChunks(worker.stream([1, 2, 3, 4, 5], {}));
+
+    strictEqual(mostRunning, 1);
+    deepStrictEqual(chunks, [[1, 2], [3, 4], [5]]);
+  });
 });

packages/node-legacy/src/legacy-html/__tests__/generate.test.mjs

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { loadGenerator } from '@doc-kit/core/generators/loader.mjs';
+import { setConfig } from '@doc-kit/core/utils/configuration/index.mjs';
+import { loadMarkdownPlugins } from '@doc-kit/core/utils/markdown/plugins.mjs';
+
+import { processChunk } from '../generate.mjs';
+
+await loadMarkdownPlugins(
+  await loadGenerator(import.meta.resolve('../index.mjs'))
+);
+
+const createEntry = (api, name) => {
+  const heading = {
+    type: 'heading',
+    depth: 1,
+    children: [{ type: 'text', value: name }],
+    data: { name, text: name, slug: api, type: 'module' },
+  };
+
+  return {
+    api,
+    path: `/${api}`,
+    heading,
+    stability: null,
+    content: {
+      type: 'root',
+      children: [
+        heading,
+        {
+          type: 'paragraph',
+          children: [{ type: 'text', value: `${name} body` }],
+        },
+      ],
+    },
+  };
+};
+
+describe('legacy-html processChunk', () => {
+  it('does not change its input on the main thread', async () => {
+    await setConfig({ target: ['legacy-html'] });
+
+    const fs = createEntry('fs', 'File system');
+    const before = structuredClone(fs);
+
+    const [page] = await processChunk(
+      [{ head: fs, nodes: [fs], headNodes: [fs] }],
+      [0],
+      '<a class="nav-fs" href="fs.html">File system</a>'
+    );
+
+    assert.match(page.content, /File system body/);
+    assert.deepEqual(fs, before);
+  });
+});

packages/react/src/html/bundlers/__tests__/index.test.mjs

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import { afterEach, describe, it, mock } from 'node:test';
+
+import { setConfig } from '@doc-kit/core/utils/configuration/index.mjs';
+
+mock.module('../vite.mjs', {
+  namedExports: { createViteBundler: () => 'vite' },
+});
+
+const { resolveBundler } = await import('../index.mjs');
+
+const VARIABLES = [
+  'ROLLDOWN_WORKER_THREADS',
+  'RAYON_NUM_THREADS',
+  'MIMALLOC_PURGE_DELAY',
+  'MIMALLOC_ALLOW_THP',
+];
+
+const original = Object.fromEntries(
+  VARIABLES.map(name => [name, process.env[name]])
+);
+
+afterEach(() => {
+  for (const name of VARIABLES) {
+    if (original[name] === undefined) {
+      delete process.env[name];
+    } else {
+      process.env[name] = original[name];
+    }
+  }
+});
+
+describe('resolveBundler', () => {
+  it("sizes the bundler's thread pools and allocator before loading it", async () => {
+    await setConfig({ target: ['html'], threads: 3 });
+
+    for (const name of VARIABLES) {
+      delete process.env[name];
+    }
+
+    assert.equal(await resolveBundler(), 'vite');
+    assert.equal(process.env.ROLLDOWN_WORKER_THREADS, '3');
+    assert.equal(process.env.RAYON_NUM_THREADS, '3');
+    assert.equal(process.env.MIMALLOC_PURGE_DELAY, '0');
+    assert.equal(process.env.MIMALLOC_ALLOW_THP, '0');
+  });
+
+  it('keeps what the environment already sets', async () => {
+    await setConfig({ target: ['html'], threads: 3 });
+
+    process.env.ROLLDOWN_WORKER_THREADS = '8';
+    process.env.MIMALLOC_PURGE_DELAY = '250';
+
+    await resolveBundler();
+
+    assert.equal(process.env.ROLLDOWN_WORKER_THREADS, '8');
+    assert.equal(process.env.MIMALLOC_PURGE_DELAY, '250');
+  });
+
+  it('leaves the environment alone for a custom bundler', async () => {
+    for (const name of VARIABLES) {
+      delete process.env[name];
+    }
+
+    const bundler = {};
+
+    assert.equal(await resolveBundler(bundler), bundler);
+
+    for (const name of VARIABLES) {
+      assert.equal(process.env[name], undefined);
+    }
+  });
+});

packages/react/src/jsx-ast/__tests__/generate.test.mjs

@@ -108,4 +108,15 @@ describe('jsx-ast generate', () => {
       ['index', 'fs']
     );
   });
+
+  it('does not change its input on the main thread', async () => {
+    await setConfig({ target: ['jsx-ast'] });
+
+    const fs = createEntry('fs', 'File system');
+    const before = structuredClone(fs);
+
+    await processChunk([{ head: fs, entries: [fs] }], [0]);
+
+    assert.deepEqual(fs, before);
+  });
 });