@@ -26,13 +26,20 @@ export interface BuildMeasurement {
 
 export interface BuilderPaths {
   buildPkg: string;
+  corePkg: string;
   architectPkg: string;
   architectCli: string;
 }
 
+export interface BuilderEnv extends BuilderPaths {
+  /** NODE_PATH value to pass to a spawned child so its bare `require()`s resolve into dist/. */
+  nodePath: string;
+}
+
 /** Verifies `@angular/build` and `@angular-devkit/architect` are built before attempting a build. */
 export function checkBuilderIsBuilt(repoRoot: string, logger: Console): BuilderPaths | undefined {
   const buildPkg = path.join(repoRoot, 'dist', '@angular', 'build');
+  const corePkg = path.join(repoRoot, 'dist', '@angular-devkit', 'core');
   const architectPkg = path.join(repoRoot, 'dist', '@angular-devkit', 'architect');
   const architectCli = path.join(architectPkg, 'bin', 'cli.js');
 
@@ -45,19 +52,89 @@ export function checkBuilderIsBuilt(repoRoot: string, logger: Console): BuilderP
     return undefined;
   }
 
-  return { buildPkg, architectPkg, architectCli };
+  return { buildPkg, corePkg, architectPkg, architectCli };
+}
+
+/** Creates/repairs `shimDir/<name>` as a symlink to `target`, skipping if already correct. */
+function linkIntoShim(shimDir: string, name: string, target: string): void {
+  const linkPath = path.join(shimDir, name);
+  fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+
+  try {
+    if (fs.readlinkSync(linkPath) === target) {
+      return;
+    }
+    fs.rmSync(linkPath, { force: true });
+  } catch {
+    // ENOENT (link doesn't exist yet) -- fall through to create it.
+  }
+
+  fs.symlinkSync(target, linkPath, 'junction');
+}
+
+/**
+ * Prepares the environment a standalone, spawned `architectCli` process needs to resolve its own
+ * dependencies. `dist/` has no `node_modules` of its own, and a `pnpm install` (`hoist: false`)
+ * only links `@angular-devkit/core`/`architect`/`@angular/build`'s dependencies into each
+ * package's own SOURCE directory under `packages/`, not into anything reachable from `dist/`. So
+ * a bare `require('@angular-devkit/core')` from the built CLI script has nowhere to resolve to.
+ *
+ * Fixes this with a small symlink directory mapping each built package's bare specifier to its
+ * `dist/` output, combined with each package's own `node_modules` (where its actual npm deps --
+ * ajv-formats, esbuild, sass, etc. -- are already pnpm-linked) into a `NODE_PATH` value: Node
+ * treats each `NODE_PATH` entry as an extra global resolution root, so this covers arbitrarily
+ * nested bare requires without having to enumerate individual third-party packages.
+ */
+export function prepareBuilderEnv(
+  repoRoot: string,
+  builder: BuilderPaths,
+  shimDir: string,
+  logger: Console,
+): BuilderEnv | undefined {
+  const ownNodeModulesDirs = [
+    path.join(repoRoot, 'packages', 'angular_devkit', 'core', 'node_modules'),
+    path.join(repoRoot, 'packages', 'angular_devkit', 'architect', 'node_modules'),
+    path.join(repoRoot, 'packages', 'angular', 'build', 'node_modules'),
+  ];
+
+  const missing = ownNodeModulesDirs.filter((dir) => !fs.existsSync(dir));
+  if (missing.length > 0) {
+    logger.error(
+      'Error: expected node_modules missing for:\n  ' +
+        missing.join('\n  ') +
+        '\nRun "pnpm install" at the repo root first.',
+    );
+
+    return undefined;
+  }
+
+  fs.mkdirSync(shimDir, { recursive: true });
+  linkIntoShim(shimDir, '@angular/build', builder.buildPkg);
+  linkIntoShim(shimDir, '@angular-devkit/core', builder.corePkg);
+  linkIntoShim(shimDir, '@angular-devkit/architect', builder.architectPkg);
+
+  const nodePath = [shimDir, ...ownNodeModulesDirs].join(path.delimiter);
+
+  return { ...builder, nodePath };
 }
 
 /** Spawns one cold `lib:build` run against `projectDir` and times it. */
 export function buildOnce(
   projectDir: string,
   architectCli: string,
+  nodePath: string,
 ): { durationMs: number; status: 'ok' | 'fail' } {
+  const existingNodePath = process.env['NODE_PATH'];
+  const mergedNodePath = existingNodePath
+    ? `${nodePath}${path.delimiter}${existingNodePath}`
+    : nodePath;
+
   const start = performance.now();
   const result = spawnSync(process.execPath, [architectCli, 'lib:build'], {
     cwd: projectDir,
     stdio: 'pipe',
     maxBuffer: Infinity,
+    env: { ...process.env, NODE_PATH: mergedNodePath },
   });
   const durationMs = performance.now() - start;
   const status = result.status === 0 ? 'ok' : 'fail';
 
@@ -20,7 +20,13 @@ import {
   type StyleFlavor,
   generateFixture,
 } from './fixtures.mts';
-import { type BuildMeasurement, buildOnce, checkBuilderIsBuilt, median } from './harness.mts';
+import {
+  type BuildMeasurement,
+  buildOnce,
+  checkBuilderIsBuilt,
+  median,
+  prepareBuilderEnv,
+} from './harness.mts';
 import { formatCsvReport, formatJsonReport } from './reporters.mts';
 
 export interface LibraryBuilderBenchmarkOptions {
@@ -35,6 +41,7 @@ export interface LibraryBuilderBenchmarkOptions {
 
 const repoRoot = fileURLToPath(new URL('../../../', import.meta.url));
 const scratchRoot = path.join(repoRoot, 'dist', '.library-benchmark-fixtures');
+const nodeModulesShimDir = path.join(repoRoot, 'dist', '.library-benchmark-node-modules-shim');
 
 /**
  * Default entry-point counts for the `flat` layout, chosen to resolve a U-shaped scaling curve.
@@ -66,6 +73,11 @@ export async function runLibraryBuilderBenchmarks(
     return { measurements: [], exitCode: 1 };
   }
 
+  const builderEnv = prepareBuilderEnv(repoRoot, builder, nodeModulesShimDir, console);
+  if (!builderEnv) {
+    return { measurements: [], exitCode: 1 };
+  }
+
   const layout = options.layout ?? 'flat';
   const iterations = options.iterations ?? 3;
   const sizes =
@@ -104,7 +116,11 @@ export async function runLibraryBuilderBenchmarks(
 
         const durations: number[] = [];
         for (let i = 1; i <= iterations; i++) {
-          const { durationMs, status } = buildOnce(projectDir, builder.architectCli);
+          const { durationMs, status } = buildOnce(
+            projectDir,
+            builder.architectCli,
+            builderEnv.nodePath,
+          );
           if (!options.json) {
             // eslint-disable-next-line no-console
             console.log(