@meteorjs/rspack 3.0.0-rc.0 → 3.0.0-rc.2

package/lib/clean.js

@@ -0,0 +1,47 @@
+const path = require('path');
+const fs = require('fs');
+
+function isOutside(relative) {
+  return relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
+}
+
+// output.path can be an app's public/ or private/ source directory. Only the
+// configured generated contexts belong to this compiler's cleanup.
+function keepOutsideContexts(outputPath, contexts) {
+  const outputRoot = path.resolve(outputPath);
+  const owned = contexts
+    .filter(context => typeof context === 'string' && context.length > 0)
+    .map(context => path.relative(outputRoot, path.resolve(outputRoot, context)))
+    .filter(context => context && !isOutside(context));
+
+  return filename => {
+    if (typeof filename !== 'string' || filename.includes('\0')) return true;
+    const relative = path.relative(outputRoot, path.resolve(outputRoot, filename));
+    if (isOutside(relative)) return true;
+
+    const canClean = owned.some(context =>
+      relative === context || relative.startsWith(`${context}${path.sep}`) ||
+      // Rspack calls keep on directories before walking their children. Let
+      // it traverse the output root and parents of nested owned contexts.
+      relative === '' || context.startsWith(`${relative}${path.sep}`)
+    );
+    if (!canClean) return true;
+
+    // Rspack follows directory symlinks while cleaning. Check every component,
+    // including the output root, even when it calls keep directly on a file.
+    let current = outputRoot;
+    const segments = relative ? relative.split(path.sep) : [];
+    try {
+      for (const segment of ['', ...segments]) {
+        current = path.join(current, segment);
+        if (fs.lstatSync(current).isSymbolicLink()) return true;
+      }
+    } catch {
+      // If ownership cannot be checked, preserve the path.
+      return true;
+    }
+    return false;
+  };
+}
+
+module.exports = { keepOutsideContexts };

package/lib/clean.test.js

@@ -0,0 +1,125 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { keepOutsideContexts } = require('./clean');
+
+describe('Rspack output cleanup ownership', () => {
+  let root;
+  let outputPath;
+
+  function writeFile(filename, content = 'generated') {
+    fs.mkdirSync(path.dirname(filename), { recursive: true });
+    fs.writeFileSync(filename, content);
+  }
+
+  function linkDirectory(target, link) {
+    fs.mkdirSync(path.dirname(link), { recursive: true });
+    fs.symlinkSync(target, link, process.platform === 'win32' ? 'junction' : 'dir');
+  }
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'meteor-clean-'));
+    outputPath = path.join(root, 'build', 'build-agent', 'app', 'private');
+    fs.mkdirSync(outputPath, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  test.each([
+    ['build-assets', 'build-chunks'],
+    ['build-assets-test', 'build-chunks-test'],
+    ['build-assets-local-secondary-app-test', 'build-chunks-local-secondary-app-test'],
+    ['generated/assets', 'generated/chunks'],
+  ])('cleans only %s and %s, with absolute or relative callbacks', (assets, chunks) => {
+    writeFile(path.join(outputPath, assets, 'stale.svg'));
+    writeFile(path.join(outputPath, chunks, 'stale.js'));
+    const keep = keepOutsideContexts(outputPath, [assets, chunks]);
+    const cases = [
+      ['', false],
+      [assets, false],
+      [`${assets}/stale.svg`, false],
+      [`${chunks}/stale.js`, false],
+      ['ordinary.txt', true],
+      ['build', true],
+      ['build-notes/guide.txt', true],
+      ['docs/build/guide.txt', true],
+      [`${assets}-another-mode/keep.svg`, true],
+      ['build-assets-local-unrelated/keep.svg', true],
+      ['unrelated/build-chunks/stale.js', true],
+      ['../private-neighbor/build-assets/keep.txt', true],
+    ];
+    for (const [file, expected] of cases) {
+      for (const input of [file, path.resolve(outputPath, file)]) {
+        expect({ input, keep: keep(input) }).toEqual({ input, keep: expected });
+      }
+    }
+  });
+
+  test('traverses a shared parent without cleaning a sibling context', () => {
+    writeFile(path.join(outputPath, 'build-chunks/web.browser/stale.js'));
+    const keep = keepOutsideContexts(outputPath, [
+      'build-chunks/web.browser/assets', 'build-chunks/web.browser',
+    ]);
+    expect(keep(outputPath)).toBe(false);
+    expect(keep(path.join(outputPath, 'build-chunks'))).toBe(false);
+    expect(keep('build-chunks/web.browser/stale.js')).toBe(false);
+    expect(keep('build-chunks/web.browser.legacy/keep.js')).toBe(true);
+    expect(keep('build-chunks/web.cordova/keep.js')).toBe(true);
+  });
+
+  test('keeps files when no safe child context is configured', () => {
+    const keep = keepOutsideContexts(outputPath, ['', '.', '..', '../public', null]);
+    for (const input of [outputPath, 'ordinary.txt', '../public/keep.txt', null, 'bad\0path']) {
+      expect({ input, keep: keep(input) }).toEqual({ input, keep: true });
+    }
+  });
+
+  test.each([
+    ['context root', 'build-assets', 'build-assets', false, 'keep.txt'],
+    ['nested link', 'build-assets/linked', 'build-assets', true, 'keep.txt'],
+    ['custom context parent', 'generated', 'generated/assets', false, 'assets/keep.txt'],
+  ])('keeps a symlink at the %s and paths below it', (_name, linkPath, context, targetInsideOutput, child) => {
+    const target = path.join(targetInsideOutput ? outputPath : root, 'source-assets');
+    writeFile(path.join(target, child), 'source asset');
+    linkDirectory(target, path.join(outputPath, linkPath));
+    writeFile(path.join(outputPath, 'build-chunks/stale.js'));
+    const keep = keepOutsideContexts(outputPath, [context, 'build-chunks']);
+
+    for (const file of [linkPath, `${linkPath}/${child}`]) {
+      expect(keep(file)).toBe(true);
+      expect(keep(path.join(outputPath, file))).toBe(true);
+    }
+    expect(keep('build-chunks/stale.js')).toBe(false);
+  });
+
+  test('keeps a symlinked output root and its generated descendants', () => {
+    const target = path.join(root, 'shared-public');
+    writeFile(path.join(target, 'build-assets/keep.txt'), 'shared asset');
+    fs.rmdirSync(outputPath);
+    linkDirectory(target, outputPath);
+    const keep = keepOutsideContexts(outputPath, ['build-assets']);
+
+    expect(keep(outputPath)).toBe(true);
+    expect(keep('build-assets/keep.txt')).toBe(true);
+  });
+
+  test('preserves an uninspectable path without disabling cleanup elsewhere', () => {
+    const denied = path.join(outputPath, 'build-assets');
+    writeFile(path.join(denied, 'keep.txt'));
+    writeFile(path.join(outputPath, 'build-chunks/stale.js'));
+    const lstat = fs.lstatSync;
+    const spy = jest.spyOn(fs, 'lstatSync').mockImplementation((filename, ...args) => {
+      if (filename === denied) throw Object.assign(new Error('permission denied'), { code: 'EACCES' });
+      return lstat(filename, ...args);
+    });
+    try {
+      const keep = keepOutsideContexts(outputPath, ['build-assets', 'build-chunks']);
+      expect(keep('build-assets/keep.txt')).toBe(true);
+      expect(keep('build-chunks/stale.js')).toBe(false);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});

package/lib/compilationOutput.js

@@ -0,0 +1,33 @@
+// Type checkers and other plugins/watchers can invalidate a compilation without
+// changing its output. This can affect any Rspack project, regardless of language.
+// Rspack already compares asset contents before writing them, so track emitted
+// flags and asset names without copying and hashing entire bundles in JS.
+function createOutputTracker() {
+  let version = 0;
+  let previousNames;
+
+  return stats => {
+    const { assets } = stats.toJson({
+      all: false,
+      assets: true,
+      cachedAssets: true,
+      relatedAssets: true,
+    });
+    const pending = [...assets];
+    const names = [];
+    let emitted = false;
+    for (let i = 0; i < pending.length; i++) {
+      const asset = pending[i];
+      names.push(asset.name);
+      emitted ||= asset.emitted;
+      // Source maps are nested under their parent asset in Rspack stats.
+      if (asset.related) pending.push(...asset.related);
+    }
+    const currentNames = JSON.stringify(names.sort());
+    if (emitted || currentNames !== previousNames) version++;
+    previousNames = currentNames;
+    return version;
+  };
+}
+
+module.exports = { createOutputTracker };

package/lib/compilationOutput.test.js

@@ -0,0 +1,62 @@
+const { createOutputTracker } = require('./compilationOutput.js');
+
+const stats = (assets, { hash = 'compilation-hash', hasErrors = false } = {}) => ({
+  hash,
+  hasErrors: () => hasErrors,
+  toJson: () => ({ assets }),
+});
+const asset = (name, emitted = false, related = []) => ({
+  name, emitted, related,
+});
+
+describe('server output tracking', () => {
+  test('ignores compilation-only changes and asset ordering', () => {
+    const track = createOutputTracker();
+    const first = track(stats([
+      asset('server.js', true),
+      asset('chunk.js', true),
+    ]));
+
+    expect(track(stats([
+      asset('chunk.js'),
+      asset('server.js'),
+    ], { hash: 'different-compilation-hash' }))).toBe(first);
+
+    expect(track(stats([
+      asset('server.js'),
+      asset('chunk.js', true),
+    ]))).not.toBe(first);
+  });
+
+  test('detects source-map-only changes and asset removals', () => {
+    const track = createOutputTracker();
+    const first = track(stats([
+      asset('server.js', false, [asset('server.js.map')]),
+      asset('chunk.js'),
+    ]));
+    const updatedMap = track(stats([
+      asset('server.js', false, [asset('server.js.map', true)]),
+      asset('chunk.js'),
+    ]));
+    expect(updatedMap).not.toBe(first);
+
+    const removedChunk = track(stats([
+      asset('server.js', false, [asset('server.js.map')]),
+    ]));
+    expect(removedChunk).not.toBe(updatedMap);
+    expect(track(stats([
+      asset('server.js', false, [asset('server.js.map')]),
+    ]))).toBe(removedChunk);
+  });
+
+  test('keeps output changes visible when a failed build recovers without writing again', () => {
+    const track = createOutputTracker();
+    const lastSuccessful = track(stats([asset('server.js', true)]));
+    const failed = track(stats([asset('server.js', true)], { hasErrors: true }));
+    // Meteor ignores failed compilations; recovery must still differ from the
+    // last successful version even when Rspack has already written the output.
+    const recovered = track(stats([asset('server.js')]));
+    expect(recovered).toBe(failed);
+    expect(recovered).not.toBe(lastSuccessful);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "3.0.0-rc.0",
+  "version": "3.0.0-rc.2",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",

package/rspack.config.js

@@ -30,6 +30,8 @@ const { loadUserAndOverrideConfig } = require('./lib/meteorRspackConfigHelpers.j
 const { prepareMeteorRspackConfig } = require("./lib/meteorRspackConfigFactory");
 const { extractLocalDependencies } = require('./lib/localDependenciesHelpers.js');
 const { createTestClientNodePolyfillConfig } = require("./lib/testClientNodePolyfills.js");
+const { createOutputTracker } = require('./lib/compilationOutput.js');
+const { keepOutsideContexts } = require('./lib/clean.js');
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -206,16 +208,6 @@ function createRemoteDevServerConfig() {
   return {};
 }
 
-// Keep files outside of build folders
-function keepOutsideBuild() {
-  return (p) => {
-    const normalized = '/' + path.normalize(p).replaceAll(path.sep, '/').replace(/^\/+/, '');
-    const isInBuildRoot = /\/build(\/|$)/.test(normalized);
-    const isInBuildStar = /\/build-[^/]+(\/|$)/.test(normalized);
-    return !(isInBuildRoot || isInBuildStar);
-  };
-}
-
 /**
  * @param {{ isClient: boolean; isServer: boolean; isDevelopment?: boolean; isProduction?: boolean; isTest?: boolean }} Meteor
  * @param {{ mode?: string; clientEntry?: string; serverEntry?: string; clientOutputFolder?: string; serverOutputFolder?: string; chunksContext?: string; assetsContext?: string; serverAssetsContext?: string }} argv
@@ -643,7 +635,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       cssChunkFilename: `${clientChunkPrefix}[id]${
         isProd ? ".[contenthash]" : ""
       }.css`,
-      ...(isProd && { clean: clientOutputContext ? true : { keep: keepOutsideBuild() } }),
+      ...(isProd && { clean: clientOutputContext ? true : {
+        keep: keepOutsideContexts(clientOutputDir, [assetsContext, chunksContext]),
+      } }),
     },
     optimization: {
       usedExports: true,
@@ -766,7 +760,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       library: { type: "commonjs2" },
       chunkFilename: `${chunksContext}/[id]${isProd ? ".[chunkhash]" : ""}.js`,
       assetModuleFilename,
-      ...(isProd && { clean: { keep: keepOutsideBuild() } }),
+      ...(isProd && { clean: {
+        keep: keepOutsideContexts(serverOutputDir, [assetsContext, chunksContext]),
+      } }),
     },
     optimization: {
       usedExports: true,
@@ -961,6 +957,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   }
 
   // Add MeteorRspackOutputPlugin as the last plugin to output compilation info
+  const trackServerOutput = createOutputTracker();
   const meteorRspackOutputPlugin = new MeteorRspackOutputPlugin({
     getData: (stats, { isRebuild, compilationCount, compiler }) => {
       const generatedAppPaths = [
@@ -988,7 +985,13 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         hasErrors: stats.hasErrors(),
         hasWarnings: stats.hasWarnings(),
         hasAppSourceChanges,
-        hash: stats.hash,
+        // Use output changes to decide development server restarts. Production,
+        // test, native, and client compilations keep Rspack's original hash.
+        // Include failed emissions in the version so recovery still restarts
+        // if the output changed before the errors were cleared.
+        hash: isServer && isDevEnvironment
+          ? trackServerOutput(stats)
+          : stats.hash,
         timestamp: Date.now(),
         statsOverrided,
         compilationCount,