@quenty/nevermore-cli 4.50.0 → 4.51.0

package/src/commands/batch-command/batch-bundle-command.ts

@@ -0,0 +1,140 @@
+import { CommandModule } from 'yargs';
+import { OutputHelper } from '@quenty/cli-output-helpers';
+import { BaseReporter } from '@quenty/cli-output-helpers/reporting';
+import { NevermoreGlobalArgs } from '../../args/global-args.js';
+import {
+  BatchScriptJobContext,
+  LocalJobContext,
+} from '../../utils/job-context/index.js';
+import {
+  discoverAllTestableBatchTargetsAsync,
+  discoverChangedTestableBatchTargetsAsync,
+  type BatchTarget,
+} from '../../utils/batch/changed-packages-utils.js';
+import { prepareTestAsync } from '../../utils/testing/runner/test-runner.js';
+import {
+  BUNDLE_FILE_SUFFIX,
+  writePrebuiltBatchBundleAsync,
+} from '../../utils/testing/runner/prebuilt-batch-bundle.js';
+
+interface BatchBundleArgs extends NevermoreGlobalArgs {
+  file: string;
+  base?: string;
+  all?: boolean;
+  limit?: number;
+  maxPlaceMb?: number;
+}
+
+export const batchBundleCommand: CommandModule<
+  NevermoreGlobalArgs,
+  BatchBundleArgs
+> = {
+  command: 'bundle <file>',
+  describe:
+    'Build the test places for changed packages into one bundle file, without an API key. ' +
+    'Run it with "batch test --bundle <file>".',
+  builder: (yargs) => {
+    return yargs
+      .positional('file', {
+        describe: `File to write, conventionally <name>${BUNDLE_FILE_SUFFIX}`,
+        type: 'string',
+        demandOption: true,
+      })
+      .option('all', {
+        describe: 'Bundle all packages with test targets, not just changed',
+        type: 'boolean',
+        default: false,
+      })
+      .option('base', {
+        describe: 'Git ref to diff against for change detection',
+        type: 'string',
+        default: 'origin/main',
+      })
+      .option('limit', {
+        describe: 'Max number of packages to bundle (for local debugging)',
+        type: 'number',
+      })
+      .option('max-place-mb', {
+        describe:
+          'Size budget in MB for one combined place. Larger batches are split into several places. (default: 90, under the Open Cloud upload limit)',
+        type: 'number',
+      }) as any;
+  },
+  handler: async (args) => {
+    try {
+      await _runAsync(args);
+    } catch (err) {
+      OutputHelper.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+async function _runAsync(args: BatchBundleArgs): Promise<void> {
+  let packages = args.all
+    ? await discoverAllTestableBatchTargetsAsync()
+    : await discoverChangedTestableBatchTargetsAsync(args.base!);
+  if (args.limit && args.limit > 0) {
+    packages = packages.slice(0, args.limit);
+  }
+
+  if (args.dryrun) {
+    OutputHelper.info(
+      `[DRYRUN] Would bundle ${packages.length} packages: ${packages
+        .map((p) => p.name)
+        .join(', ')}`
+    );
+    return;
+  }
+
+  await _writeBundleAsync(args, packages);
+}
+
+async function _writeBundleAsync(
+  args: BatchBundleArgs,
+  packages: BatchTarget[]
+): Promise<void> {
+  if (packages.length === 0) {
+    OutputHelper.warn('No testable packages found; writing an empty bundle.');
+    await writePrebuiltBatchBundleAsync(args.file, [], new Map());
+    return;
+  }
+
+  // No client: building never uploads, so there is no key to need.
+  const batchContext = new BatchScriptJobContext(
+    new LocalJobContext(new BaseReporter()),
+    packages,
+    {
+      maxChunkBytes:
+        args.maxPlaceMb !== undefined
+          ? args.maxPlaceMb * 1024 * 1024
+          : undefined,
+    }
+  );
+
+  try {
+    // Prepared one at a time so every package's deploy-metadata stamp lands in
+    // the shared place before it is packed, and the last package's stamp wins.
+    // A live aggregated run stamps only after the shared place has uploaded,
+    // so its specs never see a stamp at all.
+    const hasJestConfig = new Map<string, boolean>();
+    for (const pkg of packages) {
+      const prepared = await prepareTestAsync(batchContext, {
+        packagePath: pkg.path,
+        packageName: pkg.name,
+        target: pkg.target,
+      });
+      hasJestConfig.set(pkg.name, prepared.hasJestConfig);
+    }
+
+    const chunks = await batchContext.getBuiltChunksAsync();
+    await writePrebuiltBatchBundleAsync(args.file, chunks, hasJestConfig);
+    OutputHelper.info(
+      `Wrote ${packages.length} package${packages.length === 1 ? '' : 's'} in ${
+        chunks.length
+      } place${chunks.length === 1 ? '' : 's'} to ${args.file}.`
+    );
+  } finally {
+    await batchContext.disposeAsync();
+  }
+}

package/src/commands/batch-command/batch-test-command.ts

@@ -11,6 +11,8 @@ import { getApiKeyAsync } from '@quenty/nevermore-cli-helpers';
 import { runBatchAsync } from '../../utils/batch/batch-runner.js';
 import { renderBatchOutcome } from '../../utils/testing/parsers/batch-log-renderer.js';
 import { emitDiagnostic } from '../../utils/testing/parsers/batch-log-parser.js';
+import { type DeployTarget } from '@quenty/nevermore-deploy';
+import { type BuildContext } from '@quenty/nevermore-template-helpers';
 import { createBasePlaceResolver } from '../../utils/build/base-place-resolver-factory.js';
 import {
   type JobContext,
@@ -37,9 +39,13 @@ import {
   createTestCommentConfig,
 } from '../../utils/testing/reporting/index.js';
 import {
+  executePreparedTestAsync,
   runSingleTestAsync,
+  type SingleTestOptions,
   type SingleTestResult,
 } from '../../utils/testing/runner/test-runner.js';
+import { type CombinedPlaceChunk } from '../../utils/testing/runner/combined-project-generator.js';
+import { readPrebuiltBatchBundleAsync } from '../../utils/testing/runner/prebuilt-batch-bundle.js';
 import { isCI } from '../../utils/nevermore-cli-utils.js';
 
 interface BatchTestArgs extends NevermoreGlobalArgs {
@@ -56,6 +62,7 @@ interface BatchTestArgs extends NevermoreGlobalArgs {
   batchUniverseId?: number;
   maxPlaceMb?: number;
   timeout?: number;
+  bundle?: string;
 }
 
 export const batchTestCommand: CommandModule<
@@ -129,6 +136,14 @@ export const batchTestCommand: CommandModule<
             'Max script execution time in seconds for the whole batch. Sent to the Open Cloud API so Roblox cancels server-side on overrun. Max 300s (API limit). (default: 300)',
           type: 'number',
         })
+        .option('bundle', {
+          describe:
+            'Run the places in a *.nevermore.tests.tar written by "batch bundle" instead of finding ' +
+            'and building packages. The bundle never chooses where it is uploaded: ' +
+            'that is --batch-place-id/--batch-universe-id, or else the test place this ' +
+            'checkout gives one of its packages.',
+          type: 'string',
+        })
         // Accepted only to fail with a useful message. A batch runs one shared
         // script across packages, so there is nothing for arbitrary Luau to mean
         // here — but yargs strict mode would otherwise reject it with a bare
@@ -145,6 +160,18 @@ export const batchTestCommand: CommandModule<
                 '  cd <package> && nevermore test --cloud --script-text \'print("hi")\''
             );
           }
+          if (args.bundle !== undefined) {
+            if (args.all || args.limit !== undefined) {
+              throw new Error(
+                '--bundle runs every package in the bundle; drop --all and --limit.'
+              );
+            }
+            if (args.aggregated === false) {
+              throw new Error(
+                '--bundle runs an aggregated batch; drop --no-aggregated.'
+              );
+            }
+          }
           return true;
         })
     );
@@ -160,12 +187,38 @@ export const batchTestCommand: CommandModule<
 };
 
 async function _runAsync(args: BatchTestArgs): Promise<void> {
-  let packages = args.all
-    ? await discoverAllTestableBatchTargetsAsync()
-    : await discoverChangedTestableBatchTargetsAsync(args.base!);
+  const prebuilt =
+    args.bundle !== undefined
+      ? await _loadPrebuiltRunAsync(args, args.bundle)
+      : undefined;
+  let exitCode: number | undefined;
+  try {
+    exitCode = await _runPackagesAsync(args, prebuilt);
+  } finally {
+    await prebuilt?.buildContext.cleanupAsync();
+  }
+
+  // Node.js fetch (undici) keeps TCP connections alive in a global pool,
+  // which prevents the event loop from draining. Explicit exit required.
+  if (exitCode !== undefined) {
+    process.exit(exitCode);
+  }
+}
 
-  if (args.limit && args.limit > 0) {
-    packages = packages.slice(0, args.limit);
+async function _runPackagesAsync(
+  args: BatchTestArgs,
+  prebuilt: PrebuiltRun | undefined
+): Promise<number | undefined> {
+  let packages: BatchTarget[];
+  if (prebuilt) {
+    packages = prebuilt.packages;
+  } else {
+    packages = args.all
+      ? await discoverAllTestableBatchTargetsAsync()
+      : await discoverChangedTestableBatchTargetsAsync(args.base!);
+    if (args.limit && args.limit > 0) {
+      packages = packages.slice(0, args.limit);
+    }
   }
 
   if (packages.length === 0) {
@@ -173,7 +226,7 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
       'No testable packages found. Packages need a deploy.nevermore.json with a "test" target.\n' +
         'Run "nevermore deploy init" inside a package to set one up.'
     );
-    return;
+    return undefined;
   }
 
   if (args.dryrun) {
@@ -181,7 +234,7 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
     OutputHelper.info(
       `[DRYRUN] Would test ${packages.length} packages: ${names}`
     );
-    return;
+    return undefined;
   }
 
   const cloud = args.cloud ?? false;
@@ -273,8 +326,8 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
 
   const batchContext = aggregated
     ? new BatchScriptJobContext(innerContext, packages, {
-        batchPlaceId: args.batchPlaceId,
-        batchUniverseId: args.batchUniverseId,
+        batchPlaceId: prebuilt?.target.placeId ?? args.batchPlaceId,
+        batchUniverseId: prebuilt?.target.universeId ?? args.batchUniverseId,
         batchTimeoutMs: timeoutMs,
         // Only an upload is size-limited, so a local run stays one place
         // unless asked to split.
@@ -285,6 +338,10 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
             ? undefined
             : Infinity,
         reporter,
+        prebuilt: prebuilt && {
+          chunks: prebuilt.chunks,
+          buildContext: prebuilt.buildContext,
+        },
       })
     : undefined;
   const context: JobContext = batchContext ?? innerContext;
@@ -326,7 +383,8 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
           pkg,
           context,
           timeoutMs,
-          aggregated
+          aggregated,
+          prebuilt?.hasJestConfig.get(pkg.name)
         );
 
         return {
@@ -360,19 +418,17 @@ async function _runAsync(args: BatchTestArgs): Promise<void> {
   }
 
   await reporter.stopAsync();
-
-  // Node.js fetch (undici) keeps TCP connections alive in a global pool,
-  // which prevents the event loop from draining. Explicit exit required.
-  process.exit(exitCode);
+  return exitCode;
 }
 
 async function _runWithRetryAsync(
   pkg: BatchTarget,
   context: JobContext,
   timeoutMs: number,
-  aggregated: boolean
+  aggregated: boolean,
+  prebuiltHasJestConfig: boolean | undefined
 ): Promise<SingleTestResult> {
-  const opts = {
+  const opts: SingleTestOptions = {
     packagePath: pkg.path,
     packageName: pkg.name,
     timeoutMs,
@@ -382,11 +438,95 @@ async function _runWithRetryAsync(
     suppressCountsProvenance: aggregated,
   };
 
+  if (prebuiltHasJestConfig !== undefined) {
+    return _retryOnTransientAsync(pkg.name, async () =>
+      executePreparedTestAsync(
+        context,
+        {
+          builtPlace: await context.buildPlaceAsync(opts),
+          scriptContent: '',
+          hasJestConfig: prebuiltHasJestConfig,
+        },
+        opts
+      )
+    );
+  }
+
   return _retryOnTransientAsync(pkg.name, () =>
     runSingleTestAsync(context, opts)
   );
 }
 
+interface PrebuiltRun {
+  target: DeployTarget;
+  packages: BatchTarget[];
+  chunks: CombinedPlaceChunk[];
+  hasJestConfig: Map<string, boolean>;
+  buildContext: BuildContext;
+}
+
+async function _loadPrebuiltRunAsync(
+  args: BatchTestArgs,
+  bundleFile: string
+): Promise<PrebuiltRun> {
+  const bundle = await readPrebuiltBatchBundleAsync(bundleFile);
+  let target: DeployTarget;
+  try {
+    target = await _resolvePrebuiltTargetAsync(
+      args,
+      new Set(bundle.packages.map((p) => p.name))
+    );
+  } catch (err) {
+    await bundle.buildContext.cleanupAsync();
+    throw err;
+  }
+
+  OutputHelper.info(
+    `Running ${bundle.packages.length} prebuilt package${
+      bundle.packages.length === 1 ? '' : 's'
+    } in ${bundle.chunks.length} place${
+      bundle.chunks.length === 1 ? '' : 's'
+    } on place ${target.placeId}.`
+  );
+
+  return {
+    target,
+    packages: bundle.packages.map((p) => ({
+      name: p.name,
+      packageName: p.name,
+      path: process.cwd(),
+      target,
+    })),
+    chunks: bundle.chunks,
+    hasJestConfig: new Map(
+      bundle.packages.map((p) => [p.name, p.hasJestConfig])
+    ),
+    buildContext: bundle.buildContext,
+  };
+}
+
+/**
+ * Where a bundle uploads to, picked the way a normal batch run picks it: the
+ * test place of one of its packages, read from this checkout rather than from
+ * the bundle.
+ */
+async function _resolvePrebuiltTargetAsync(
+  args: BatchTestArgs,
+  bundledNames: Set<string>
+): Promise<DeployTarget> {
+  const known = await discoverAllTestableBatchTargetsAsync();
+  const base = known.find((t) => bundledNames.has(t.name)) ?? known[0];
+  const universeId = args.batchUniverseId ?? base?.target.universeId;
+  const placeId = args.batchPlaceId ?? base?.target.placeId;
+  if (!universeId || !placeId) {
+    throw new Error(
+      'No test place to upload the bundle to: this checkout has no testable ' +
+        'package. Pass --batch-place-id and --batch-universe-id.'
+    );
+  }
+  return { universeId, placeId, project: '' };
+}
+
 /**
  * Run something once more if it failed for a reason that tends not to repeat.
  *

package/src/commands/batch-command/index.ts

@@ -1,5 +1,6 @@
 import { Argv, CommandModule } from 'yargs';
 import { NevermoreGlobalArgs } from '../../args/global-args.js';
+import { batchBundleCommand } from './batch-bundle-command.js';
 import { batchDeployCommand } from './batch-deploy-command.js';
 import { batchTestCommand } from './batch-test-command.js';
 
@@ -8,6 +9,7 @@ export class BatchCommand<T> implements CommandModule<T, NevermoreGlobalArgs> {
   public describe = 'Run operations across multiple packages';
 
   public builder = (args: Argv<T>) => {
+    args.command(batchBundleCommand as any);
     args.command(batchDeployCommand as any);
     args.command(batchTestCommand as any);
     return args as Argv<NevermoreGlobalArgs>;

package/src/commands/tools-command/ci-post-test-results.ts

@@ -2,6 +2,7 @@ import { CommandModule } from 'yargs';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import {
   type Diagnostic,
+  dedupeDiagnostics,
   emitAnnotations,
   writeAnnotationSummaryAsync,
 } from '@quenty/cli-output-helpers/reporting';
@@ -16,6 +17,7 @@ import {
 } from '../../utils/testing/reporting/index.js';
 import { parseJestLuaOutput } from '../../utils/testing/parsers/index.js';
 import { tryLoadSourcemapResolver } from '../../utils/sourcemap/index.js';
+import { tryLoadAnnotationWorkspaceAsync } from '../../utils/testing/parsers/annotation-workspace.js';
 
 type ErrorReporter = Reporter & {
   setError(error: string): void;
@@ -25,6 +27,7 @@ type ErrorReporter = Reporter & {
 interface CiPostTestResultsArgs extends NevermoreGlobalArgs {
   input: string;
   runOutcome?: string;
+  sourcemap?: string;
 }
 
 /** Create the standard set of GitHub reporters for posting results. */
@@ -59,6 +62,12 @@ export const ciPostTestResultsCommand: CommandModule<
           'When the results file is missing and run-outcome is "success", ' +
           'posts a neutral "no tests" comment instead of an error.',
         type: 'string',
+      })
+      .option('sourcemap', {
+        describe:
+          'Sourcemap that test failure annotations resolve files against ' +
+          '(default: sourcemap.json in the current directory)',
+        type: 'string',
       });
   },
   handler: async (args) => {
@@ -98,15 +107,21 @@ export const ciPostTestResultsCommand: CommandModule<
       }
 
       // Emit test failure annotations
-      const sourcemapResolver = tryLoadSourcemapResolver(process.cwd());
-      const allDiagnostics: Diagnostic[] = [];
+      const sourcemapResolver = tryLoadSourcemapResolver(
+        process.cwd(),
+        args.sourcemap
+      );
+      const workspace = await tryLoadAnnotationWorkspaceAsync(process.cwd());
+      const parsedDiagnostics: Diagnostic[] = [];
       for (const failure of state.getFailures()) {
         const diagnostics = parseJestLuaOutput(failure.logs, {
           packageName: failure.packageName,
           sourcemapResolver,
+          workspace,
         });
-        allDiagnostics.push(...diagnostics);
+        parsedDiagnostics.push(...diagnostics);
       }
+      const allDiagnostics = dedupeDiagnostics(parsedDiagnostics);
 
       if (allDiagnostics.length > 0) {
         OutputHelper.info(

package/src/utils/batch/changed-packages-utils.ts

@@ -10,6 +10,11 @@ import {
   toManifestPlaceInfo,
 } from '@quenty/nevermore-deploy';
 
+export interface WorkspacePackageInfo {
+  name: string;
+  path: string;
+}
+
 export interface TargetPackage {
   name: string;
   path: string;
@@ -50,16 +55,19 @@ export interface BatchTarget {
 export async function discoverAllTargetPackagesAsync(
   targetName: string
 ): Promise<TargetPackage[]> {
-  const { stdout } = await execa('pnpm', [
-    'ls',
-    '--json',
-    '-r',
-    '--depth',
-    '-1',
-  ]);
+  return filterByTargetAsync(await listWorkspacePackagesAsync(), targetName);
+}
 
-  const packages = JSON.parse(stdout) as Array<{ name: string; path: string }>;
-  return _filterByTargetAsync(packages, targetName);
+/** Every package in the pnpm workspace, with absolute paths. */
+export async function listWorkspacePackagesAsync(
+  cwd?: string
+): Promise<WorkspacePackageInfo[]> {
+  const { stdout } = await execa(
+    'pnpm',
+    ['ls', '--json', '-r', '--depth', '-1'],
+    { cwd }
+  );
+  return JSON.parse(stdout) as WorkspacePackageInfo[];
 }
 
 /**
@@ -92,7 +100,7 @@ export async function discoverChangedTargetPackagesAsync(
     return [];
   }
 
-  return _filterByTargetAsync(packages, targetName);
+  return filterByTargetAsync(packages, targetName);
 }
 
 /**
@@ -181,8 +189,9 @@ function _requireScriptTemplate(targets: BatchTarget[]): BatchTarget[] {
   return withTemplate;
 }
 
-async function _filterByTargetAsync(
-  packages: Array<{ name: string; path: string }>,
+/** Keep the packages whose deploy config has `targetName`, with its places. */
+export async function filterByTargetAsync(
+  packages: WorkspacePackageInfo[],
   targetName: string
 ): Promise<TargetPackage[]> {
   const results: TargetPackage[] = [];

package/src/utils/job-context/batch-script-job-context.ts

@@ -42,6 +42,8 @@ class BatchDeployment implements Deployment {
   ) {}
 }
 
+type BatchBuild = Pick<CombinedProjectResult, 'chunks' | 'primaryTarget'>;
+
 /** One combined place's upload and execution, each started at most once. */
 interface ChunkRun {
   chunk: CombinedPlaceChunk;
@@ -98,7 +100,7 @@ export class BatchScriptJobContext implements JobContext {
   private _reporter?: Reporter;
 
   // Lazy-promise state
-  private _combinedBuildPromise?: Promise<CombinedProjectResult>;
+  private _combinedBuildPromise?: Promise<BatchBuild>;
   private _chunkRuns?: ChunkRun[];
   private _executionPromise?: Promise<BatchExecutionOutcome>;
 
@@ -119,6 +121,12 @@ export class BatchScriptJobContext implements JobContext {
        */
       maxChunkBytes?: number;
       reporter?: Reporter;
+      /**
+       * Places already built by `batch bundle`, run instead of building. They
+       * upload to `batchPlaceId` in `batchUniverseId`, which are then required.
+       * The context owns `buildContext` and cleans it up like its own build.
+       */
+      prebuilt?: { chunks: CombinedPlaceChunk[]; buildContext: BuildContext };
     }
   ) {
     this._inner = inner;
@@ -130,6 +138,25 @@ export class BatchScriptJobContext implements JobContext {
     this._maxChunkBytes = options?.maxChunkBytes;
     this._reporter = options?.reporter;
 
+    if (options?.prebuilt) {
+      if (!this._batchPlaceId || !this._batchUniverseId) {
+        throw new Error(
+          'Prebuilt places need batchPlaceId and batchUniverseId to upload to'
+        );
+      }
+      const { chunks, buildContext } = options.prebuilt;
+      this._combinedBuildContext = buildContext;
+      this._chunkRuns = chunks.map((chunk) => ({ chunk }));
+      this._combinedBuildPromise = Promise.resolve({
+        chunks,
+        primaryTarget: {
+          placeId: this._batchPlaceId,
+          universeId: this._batchUniverseId,
+          project: '',
+        },
+      });
+    }
+
     const withBasePlace = batchTargets.filter((t) => t.target.basePlace);
     if (withBasePlace.length > 0) {
       OutputHelper.warn(
@@ -203,6 +230,10 @@ export class BatchScriptJobContext implements JobContext {
     return this._getBatchExecutionAsync();
   }
 
+  async getBuiltChunksAsync(): Promise<CombinedPlaceChunk[]> {
+    return (await this._getChunkRunsAsync()).map((run) => run.chunk);
+  }
+
   async getLogsAsync(deployment: Deployment): Promise<JobLogs> {
     const batchDeployment = deployment as BatchDeployment;
     const { results, stats } = await this._getBatchExecutionAsync();
@@ -249,14 +280,14 @@ export class BatchScriptJobContext implements JobContext {
 
   // ---- Lazy-promise internals ----
 
-  private _getCombinedBuildAsync(): Promise<CombinedProjectResult> {
+  private _getCombinedBuildAsync(): Promise<BatchBuild> {
     if (!this._combinedBuildPromise) {
       this._combinedBuildPromise = this._doCombinedBuildAsync();
     }
     return this._combinedBuildPromise;
   }
 
-  private async _doCombinedBuildAsync(): Promise<CombinedProjectResult> {
+  private async _doCombinedBuildAsync(): Promise<BatchBuild> {
     OutputHelper.verbose('Building combined batch place...');
 
     // Set all packages to "waiting" — they're queued for building

package/src/utils/sourcemap/sourcemap-loader.ts

@@ -4,17 +4,16 @@ import type { SourcemapNode } from './sourcemap-types.js';
 import { SourcemapResolver } from './sourcemap-resolver.js';
 
 /**
- * Try to load a `SourcemapResolver` from `sourcemap.json` in the given
- * directory.
+ * Try to load a `SourcemapResolver` for `repoRoot`, from its `sourcemap.json`
+ * unless another file is given.
  *
  * Returns `undefined` if the file doesn't exist or can't be parsed — callers
  * should fall back to heuristic resolution.
  */
 export function tryLoadSourcemapResolver(
-  repoRoot: string
+  repoRoot: string,
+  sourcemapPath = path.join(repoRoot, 'sourcemap.json')
 ): SourcemapResolver | undefined {
-  const sourcemapPath = path.join(repoRoot, 'sourcemap.json');
-
   let content: string;
   try {
     content = fs.readFileSync(sourcemapPath, 'utf-8');
@@ -22,12 +21,11 @@ export function tryLoadSourcemapResolver(
     return undefined;
   }
 
-  let root: SourcemapNode;
+  // A fork's build supplies this file, so a malformed tree is not fatal.
   try {
-    root = JSON.parse(content) as SourcemapNode;
+    const root = JSON.parse(content) as SourcemapNode;
+    return SourcemapResolver.fromSourcemap(root, repoRoot);
   } catch {
     return undefined;
   }
-
-  return SourcemapResolver.fromSourcemap(root, repoRoot);
 }