fix(vite): serve declared directory members that link out of their tree (#363)

When bazel-bin is mirrored with one link per file, Vite resolves a member
of a declared directory output to its link target, outside the tree, and
the plugin rejected it as "resolved outside declared directory". Map the
target back to the in-tree member whose realpath it is and serve that path;
anything else still throws.

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

Author: mikn

changelog.d/vite-linked-tree-members.md

@@ -0,0 +1,8 @@
+### Fixed
+
+- **The dev server serves a declared directory output whose files are
+  symlinks to paths outside it.** When bazel-bin is mirrored with one link per
+  file, Vite resolves a directory member to its link target, and the plugin
+  rejected it as "resolved outside declared directory". In serve mode the
+  plugin now maps the target back to the member that links to it and serves
+  it at the member's path.

vite/src/plugin.ts

@@ -291,9 +291,13 @@ export function bazelPlugin(options: BazelPluginOptions = {}): Plugin {
             return result?.filePath ?? null;
           }
           if (directory !== undefined && resolver.declaredDirectory(resolved.id) !== directory) {
-            throw new Error(
-              `Bazel module ${file} resolved outside declared directory: ${resolved.id}`,
-            );
+            const member = linkedMember(file, resolved.id);
+            if (member === undefined || resolver.declaredDirectory(member) !== directory) {
+              throw new Error(
+                `Bazel module ${file} resolved outside declared directory: ${resolved.id}`,
+              );
+            }
+            return { ...resolved, id: member + suffix };
           }
           if (
             result !== null &&
@@ -493,6 +497,19 @@ function splitSuffix(request: string): [string, string] {
   return cut < 0 ? [request, ''] : [request.slice(0, cut + 1), request.slice(cut + 1)];
 }
 
+/** A tree member that links out of its tree, as in a bazel-bin mirrored file by file, resolves to its link target. */
+function linkedMember(request: string, resolvedId: string): string | undefined {
+  const target = path.normalize(resolvedId);
+  const name = path.basename(target);
+  return [request, path.join(path.dirname(request), name), path.join(request, name)].find((candidate) => {
+    try {
+      return fs.realpathSync(candidate) === target;
+    } catch {
+      return false;
+    }
+  });
+}
+
 function canonicalPath(file: string): string {
   for (let ancestor = file; ; ancestor = path.dirname(ancestor)) {
     try {

vite/tests/resolution_parity_test.mjs

@@ -866,6 +866,22 @@ test('a declared generated tree cannot be replaced by checkout files', async ()
     'a native resolution miss must retain the declared producer path');
 });
 
+test('a declared tree whose members link out of it still resolves to the member', async () => {
+  const tree = path.join(bazelBin, 'app/linked');
+  const target = path.join(root, 'linked-runfiles/runtime.js');
+  write(target, 'export const runtime = "linked member";\n');
+  fs.mkdirSync(tree, { recursive: true });
+  fs.symlinkSync(target, path.join(tree, 'runtime.js'));
+  const plugin = bazelPlugin({
+    workspaceRoot, bazelBin, mode: 'serve',
+    declaredFiles: { 'app/linked': { path: tree, context: 'source', directory: true } },
+  });
+  plugin.configResolved({ root: workspaceRoot, logger: { info() {} } });
+  const context = { resolve: async () => ({ id: fs.realpathSync(target) }) };
+  assert.deepEqual(await plugin.resolveId.handler.call(context, './linked/runtime', importers.serve, {}),
+    { id: path.join(tree, 'runtime.js') });
+});
+
 let failed = 0;
 for (const [name, fn] of tests) {
   try {