@@ -11,11 +11,10 @@ import { constants, copyFile, mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { emitFilesToDisk } from '../../../tools/esbuild/utils';
 import { toPosixPath } from '../../../utils/path';
-import type { NormalizedEntryPoint, NormalizedLibraryOptions } from '../options';
+import type { NormalizedLibraryOptions } from '../options';
 import { collectAssetsToEmit } from './assets';
 import { type BundleEntryPointInput, type BundleResult, bundleEntryPoints } from './bundler';
 import { type SingleProgramCache, compileLibrary } from './compilation';
-import { type EntryPointLookup, createEntryDirectoryLookup } from './entry-points';
 import { generatePackageManifests } from './package-manifests';
 import type { createComponentStylesheetBundlerForLibrary } from './stylesheet-bundler';
 import type { OutputFile } from './utils';
@@ -31,7 +30,6 @@ export interface SingleBuildState {
   hasCompilationError?: boolean;
   hasEmittedManifests?: boolean;
   hasEmittedAssets?: boolean;
-  entryDirectoryLookup?: EntryPointLookup;
   directoryExists: Set<string>;
 }
 
@@ -131,29 +129,16 @@ export async function buildAction(actionContext: BuildActionContext): Promise<vo
       pendingChangedDtsFiles.add(file);
     }
 
-    const findEntryPoint = (buildState.entryDirectoryLookup ??= createEntryDirectoryLookup(
-      options.entryPoints.values(),
-    ));
     const itemsToBundle: BundleEntryPointInput[] = [];
 
     for (const entryPoint of options.entryPoints.values()) {
       const previousBundleResult = buildState.previousBundleResults.get(entryPoint.name);
       const hasEsmChanges =
         !previousBundleResult ||
-        hasEntryPointChanges(
-          entryPoint,
-          previousBundleResult.esmModuleIds,
-          findEntryPoint,
-          pendingChangedEsmFiles,
-        );
+        hasEntryPointChanges(previousBundleResult.esmModuleIds, pendingChangedEsmFiles);
       const hasDtsChanges =
         !previousBundleResult ||
-        hasEntryPointChanges(
-          entryPoint,
-          previousBundleResult.dtsModuleIds,
-          findEntryPoint,
-          pendingChangedDtsFiles,
-        );
+        hasEntryPointChanges(previousBundleResult.dtsModuleIds, pendingChangedDtsFiles);
 
       if (hasEsmChanges || hasDtsChanges) {
         context.logger.info(`Compiling ${entryPoint.displayName}...`);
@@ -170,7 +155,7 @@ export async function buildAction(actionContext: BuildActionContext): Promise<vo
     let warnings: string[];
     try {
       [bundleOutput, warnings] = await Promise.all([
-        bundleEntryPoints(itemsToBundle, esmFiles, dtsFiles, options, findEntryPoint),
+        bundleEntryPoints(itemsToBundle, esmFiles, dtsFiles, options),
         diagnosePromise,
       ]);
     } catch (error) {
@@ -240,17 +225,15 @@ export function hasModifiedWatchedFile(
 }
 
 function hasEntryPointChanges(
-  entryPoint: NormalizedEntryPoint,
   moduleIds: ReadonlySet<string>,
-  findEntryPoint: EntryPointLookup,
   changedFiles: ReadonlySet<string>,
 ): boolean {
   if (changedFiles.size === 0) {
     return false;
   }
 
   for (const file of changedFiles) {
-    if (moduleIds.has(file) || findEntryPoint(file) === entryPoint) {
+    if (moduleIds.has(file)) {
       return true;
     }
   }
 
@@ -18,7 +18,6 @@ import {
 import { dts } from 'rolldown-plugin-dts';
 import { toPosixPath } from '../../../utils/path';
 import type { NormalizedEntryPoint, NormalizedLibraryOptions } from '../options';
-import { type EntryPointLookup, createEntryDirectoryLookup } from './entry-points';
 import {
   FESM_OUTPUT_DIR,
   type MemoryOutputFile,
@@ -87,15 +86,13 @@ interface MultiBundleOutput {
  * @param esmFiles Map of virtual ESM output file paths to their content.
  * @param dtsFiles Map of virtual TypeScript declaration file paths to their content.
  * @param options The normalized library builder options.
- * @param findEntryPoint Optional lookup function to find an entry point by file path.
  * @returns A promise resolving to the bundled output files and bundle cache results.
  */
 export async function bundleEntryPoints(
   items: readonly BundleEntryPointInput[],
   esmFiles: ReadonlyMap<string, string>,
   dtsFiles: ReadonlyMap<string, string>,
   options: NormalizedLibraryOptions,
-  findEntryPoint: EntryPointLookup = createEntryDirectoryLookup(options.entryPoints.values()),
 ): Promise<BundleEntryPointsOutput> {
   const bundleResults = new Map<string, BundleResult>();
   if (items.length === 0) {
@@ -115,8 +112,8 @@ export async function bundleEntryPoints(
   }
 
   const [esmOutput, dtsOutput] = await Promise.all([
-    bundleAllEsm(esmEntryPoints, esmFiles, options, findEntryPoint),
-    bundleAllDts(dtsEntryPoints, dtsFiles, options, findEntryPoint),
+    bundleAllEsm(esmEntryPoints, esmFiles, options),
+    bundleAllDts(dtsEntryPoints, dtsFiles, options),
   ]);
 
   for (const { entryPoint, previousBundleResult } of items) {
@@ -139,8 +136,6 @@ export async function bundleEntryPoints(
   };
 }
 
-export { type EntryPointLookup, createEntryDirectoryLookup };
-
 /**
  * Generates the Rolldown input mapping object from the specified entry points.
  *
@@ -170,14 +165,12 @@ function resolveEntryInputMap(
  * @param files Map of virtual file paths to their content.
  * @param extensions Candidate extensions to probe when resolving extensionless module specifiers.
  * @param includeMap Whether source map files should also be loaded from the memory map.
- * @param findEntryPoint Lookup function to identify the entry point owning a file path.
  * @returns A Rolldown plugin instance.
  */
 function createMemoryFileLoaderPlugin(
   files: ReadonlyMap<string, string>,
   extensions: readonly string[],
   includeMap: boolean,
-  findEntryPoint: EntryPointLookup,
 ): Plugin {
   return {
     name: 'memory-file-loader',
@@ -217,15 +210,6 @@ function createMemoryFileLoaderPlugin(
           }
         }
 
-        const importerEp = findEntryPoint(importerPosix);
-        const targetEp = findEntryPoint(resolvedCandidate ?? resolved);
-        if (importerEp && targetEp && importerEp.name !== targetEp.name) {
-          throw new Error(
-            `Entry point '${importerEp.name}' cannot import '${id}' from sibling entry point directly. ` +
-              `Import using the entry point package name instead.`,
-          );
-        }
-
         if (resolvedCandidate) {
           return { id: resolvedCandidate, external: false };
         }
@@ -247,27 +231,6 @@ function createMemoryFileLoaderPlugin(
   };
 }
 
-/**
- * Resolves the bundle prefix name for a shared chunk based on the entry point owning its modules.
- *
- * @param findEntryPoint Lookup function to identify entry points of module IDs.
- * @param moduleIds List of module IDs contained within the chunk.
- * @returns The bundle name if a containing entry point was found, otherwise undefined.
- */
-function resolveChunkBundleName(
-  findEntryPoint: EntryPointLookup,
-  moduleIds: readonly string[],
-): string | undefined {
-  for (const modId of moduleIds) {
-    const ep = findEntryPoint(modId);
-    if (ep) {
-      return ep.bundleName;
-    }
-  }
-
-  return undefined;
-}
-
 /**
  * Processes Rolldown output assets and chunks, extracting emitted files and computing
  * the transitive set of module IDs belonging to each entry point bundle.
@@ -352,7 +315,6 @@ async function executeMultiBundle(
   preserveSymlinks: boolean,
   extension: 'mjs' | 'd.ts',
   sourcemap: boolean,
-  findEntryPoint: EntryPointLookup,
 ): Promise<MultiBundleOutput> {
   const isDts = extension === 'd.ts';
   const dir = isDts ? TYPES_OUTPUT_DIR : FESM_OUTPUT_DIR;
@@ -373,12 +335,7 @@ async function executeMultiBundle(
       format: 'es',
       dir,
       entryFileNames: `[name].${extension}`,
-      chunkFileNames: (chunk) => {
-        const bundleName = resolveChunkBundleName(findEntryPoint, chunk.moduleIds);
-        const prefix = bundleName ? `${bundleName}-` : '';
-
-        return `${prefix}[name]-[hash].${extension}`;
-      },
+      chunkFileNames: `[name]-[hash].${extension}`,
       sourcemap,
       hoistTransitiveImports: false,
       comments: { jsdoc: isDts, legal: true, annotation: true },
@@ -396,26 +353,23 @@ async function executeMultiBundle(
  * @param entryPoints The entry points to bundle.
  * @param esmFiles Map of virtual ESM output file paths to contents.
  * @param options The normalized library options.
- * @param findEntryPoint Lookup function to resolve entry point ownership.
  * @returns A promise resolving to the multi-bundle output.
  */
 async function bundleAllEsm(
   entryPoints: readonly NormalizedEntryPoint[],
   esmFiles: ReadonlyMap<string, string>,
   options: NormalizedLibraryOptions,
-  findEntryPoint: EntryPointLookup,
 ): Promise<MultiBundleOutput> {
   if (entryPoints.length === 0) {
     return { filesToEmit: [], moduleIdsByBundle: new Map() };
   }
 
   return executeMultiBundle(
     resolveEntryInputMap(entryPoints, false),
-    [createMemoryFileLoaderPlugin(esmFiles, ESM_EXTENSIONS, true, findEntryPoint)],
+    [createMemoryFileLoaderPlugin(esmFiles, ESM_EXTENSIONS, true)],
     options.preserveSymlinks,
     'mjs',
     true,
-    findEntryPoint,
   );
 }
 
@@ -425,14 +379,12 @@ async function bundleAllEsm(
  * @param entryPoints The entry points to bundle.
  * @param dtsFiles Map of virtual declaration output file paths to contents.
  * @param options The normalized library options.
- * @param findEntryPoint Lookup function to resolve entry point ownership.
  * @returns A promise resolving to the multi-bundle output.
  */
 async function bundleAllDts(
   entryPoints: readonly NormalizedEntryPoint[],
   dtsFiles: ReadonlyMap<string, string>,
   options: NormalizedLibraryOptions,
-  findEntryPoint: EntryPointLookup,
 ): Promise<MultiBundleOutput> {
   if (entryPoints.length === 0) {
     return { filesToEmit: [], moduleIdsByBundle: new Map() };
@@ -459,13 +411,9 @@ async function bundleAllDts(
 
   return executeMultiBundle(
     resolveEntryInputMap(entryPoints, true),
-    [
-      createMemoryFileLoaderPlugin(dtsFiles, DTS_EXTENSIONS, dtsSourcemap, findEntryPoint),
-      ...dtsPlugins,
-    ],
+    [createMemoryFileLoaderPlugin(dtsFiles, DTS_EXTENSIONS, dtsSourcemap), ...dtsPlugins],
     options.preserveSymlinks,
     'd.ts',
     dtsSourcemap,
-    findEntryPoint,
   );
 }
@@ -6,9 +6,6 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import path from 'node:path';
-import { toPosixPath } from '../../../utils/path';
-
 export interface NormalizedEntryPoint {
   /** The subpath in package.json exports (e.g. '.' or './testing'). */
   subpath: string;
@@ -29,69 +26,6 @@ export interface NormalizedEntryPoint {
   isPrimary: boolean;
 }
 
-/**
- * Function that resolves a file path to its containing normalized library entry point, if any.
- */
-export type EntryPointLookup = (filePath: string) => NormalizedEntryPoint | undefined;
-
-/**
- * Creates an optimized, memoized lookup function that maps arbitrary file paths
- * to their closest containing library entry point.
- *
- * Entry point root directories are sorted in descending order of path length so that
- * more specific, nested sub-entry points take precedence over shallower or primary
- * entry points. Lookups are cached to avoid repeated path scanning.
- *
- * @example
- * Given two entry points:
- * - Primary entry point `.` at `/project/src/public-api.ts` (dir: `/project/src`)
- * - Secondary entry point `./testing` at `/project/src/testing/public-api.ts` (dir: `/project/src/testing`)
- *
- * ```ts
- * const findEntryPoint = createEntryDirectoryLookup(entryPoints);
- *
- * // Resolves to the 'testing' sub-entry point because /project/src/testing is the longest matching prefix:
- * findEntryPoint('/project/src/testing/test-bed.ts'); // -> NormalizedEntryPoint ('./testing')
- *
- * // Resolves to the primary entry point:
- * findEntryPoint('/project/src/button.ts'); // -> NormalizedEntryPoint ('.')
- *
- * // Returns undefined for files located outside any entry point directory:
- * findEntryPoint('/project/shared/utils.ts'); // -> undefined
- * ```
- *
- * @param entryPoints Iterable of normalized entry points.
- * @returns An {@link EntryPointLookup} function that returns the owning {@link NormalizedEntryPoint},
- * or `undefined` if the file does not belong to any entry point directory.
- */
-export function createEntryDirectoryLookup(
-  entryPoints: Iterable<NormalizedEntryPoint>,
-): EntryPointLookup {
-  const dirs = Array.from(entryPoints, (ep) => {
-    const dir = toPosixPath(path.dirname(ep.entryFilePath));
-
-    return {
-      ep,
-      dir,
-      dirSlash: dir.endsWith('/') ? dir : `${dir}/`,
-    };
-  }).sort((a, b) => b.dir.length - a.dir.length);
-
-  const cache = new Map<string, NormalizedEntryPoint | undefined>();
-
-  return (filePath: string): NormalizedEntryPoint | undefined => {
-    const posix = toPosixPath(filePath);
-    const cached = cache.get(posix);
-    if (cached !== undefined || cache.has(posix)) {
-      return cached;
-    }
-    const found = dirs.find(({ dir, dirSlash }) => posix === dir || posix.startsWith(dirSlash))?.ep;
-    cache.set(posix, found);
-
-    return found;
-  };
-}
-
 /**
  * Computes the base bundle file name for an entry point.
  *