From 8cdfbe6b31e8c1fd7c55c8995e5ad3138953ca81 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 09:27:53 -0700
Subject: [PATCH 01/12] Fix duplicate lint script in package.json

---
 package.json | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/package.json b/package.json
index b15bb9f66..20d89b0a5 100644
--- a/package.json
+++ b/package.json
@@ -91,7 +91,8 @@
       "files": [
         ".eslintignore",
         ".eslintrc.cjs",
-        "src/**/*.ts"
+        "src/**/*.ts",
+        "vscode-extension/**/*.ts"
       ],
       "output": []
     },
@@ -232,15 +233,6 @@
       ],
       "files": [],
       "output": []
-    },
-    "lint": {
-      "files": [
-        "src/**/*.ts",
-        ".eslintignore",
-        ".eslintrc.cjs",
-        "vscode-extension/**/*.ts"
-      ],
-      "command": "eslint ."
     }
   },
   "devDependencies": {

From 9006808937ea73baa737d8a53f5c4368177f021d Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 09:29:01 -0700
Subject: [PATCH 02/12] Install braces so we can do brace expansion ourselves

---
 package-lock.json | 14 ++++++++++++++
 package.json      |  2 ++
 2 files changed, 16 insertions(+)

diff --git a/package-lock.json b/package-lock.json
index bcd7cdfd5..4ba2238a8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,6 +13,7 @@
       ],
       "dependencies": {
         "@actions/cache": "=2.0.2",
+        "braces": "^3.0.2",
         "chokidar": "^3.5.3",
         "fast-glob": "^3.2.11",
         "jsonc-parser": "^3.0.0"
@@ -21,6 +22,7 @@
         "wireit": "bin/wireit.js"
       },
       "devDependencies": {
+        "@types/braces": "^3.0.1",
         "@types/node": "^14.0.0",
         "@typescript-eslint/eslint-plugin": "^5.17.0",
         "@typescript-eslint/parser": "^5.17.0",
@@ -402,6 +404,12 @@
         "node": ">= 6"
       }
     },
+    "node_modules/@types/braces": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/@types/braces/-/braces-3.0.1.tgz",
+      "integrity": "sha512-+euflG6ygo4bn0JHtn4pYqcXwRtLvElQ7/nnjDu7iYG56H0+OhCd7d6Ug0IE3WcFpZozBKW2+80FUbv5QGk5AQ==",
+      "dev": true
+    },
     "node_modules/@types/json-schema": {
       "version": "7.0.11",
       "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz",
@@ -4526,6 +4534,12 @@
       "integrity": "sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==",
       "dev": true
     },
+    "@types/braces": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/@types/braces/-/braces-3.0.1.tgz",
+      "integrity": "sha512-+euflG6ygo4bn0JHtn4pYqcXwRtLvElQ7/nnjDu7iYG56H0+OhCd7d6Ug0IE3WcFpZozBKW2+80FUbv5QGk5AQ==",
+      "dev": true
+    },
     "@types/json-schema": {
       "version": "7.0.11",
       "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz",
diff --git a/package.json b/package.json
index 20d89b0a5..61f6ff2cb 100644
--- a/package.json
+++ b/package.json
@@ -236,6 +236,7 @@
     }
   },
   "devDependencies": {
+    "@types/braces": "^3.0.1",
     "@types/node": "^14.0.0",
     "@typescript-eslint/eslint-plugin": "^5.17.0",
     "@typescript-eslint/parser": "^5.17.0",
@@ -255,6 +256,7 @@
   },
   "dependencies": {
     "@actions/cache": "=2.0.2",
+    "braces": "^3.0.2",
     "chokidar": "^3.5.3",
     "fast-glob": "^3.2.11",
     "jsonc-parser": "^3.0.0"

From 8f917c4cbca8800c27536cb992652b5a656f98e0 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 09:15:58 -0700
Subject: [PATCH 03/12] Implement rerootToCwd

---
 src/util/glob.ts | 49 ++++++++++++++++++++++++++++++++++--------------
 tsconfig.json    |  1 +
 2 files changed, 36 insertions(+), 14 deletions(-)

diff --git a/src/util/glob.ts b/src/util/glob.ts
index 4e3d58da6..21a97da11 100644
--- a/src/util/glob.ts
+++ b/src/util/glob.ts
@@ -5,6 +5,7 @@
  */
 
 import fastGlob from 'fast-glob';
+import braces from 'braces';
 import * as pathlib from 'path';
 
 import type {Entry} from 'fast-glob';
@@ -44,6 +45,13 @@ export interface GlobOptions {
    * Note this works even if includeDirectories is false.
    */
   expandDirectories: boolean;
+
+  /**
+   * If true, interpret `/` as the `cwd`, but still allow `../` for referring
+   * outside of `cwd` (for example, `/foo` is interpreted as `<cwd>/foo`). If
+   * false, `/` refers to the root of the filesystem.
+   */
+  rerootToCwd: boolean;
 }
 
 interface GlobGroup {
@@ -85,17 +93,22 @@ export async function glob(
     return [];
   }
 
-  let expandedPatterns = patterns;
-  if (opts.expandDirectories) {
-    expandedPatterns = []; // New array so we don't mutate input patterns array.
-    for (const pattern of patterns) {
-      expandedPatterns.push(pattern);
-      // Also include a recursive-children version of every pattern, in case the
-      // pattern refers to a directory. This gives us behavior similar to the
-      // npm package.json "files" array, where matching a directory implicitly
-      // includes all transitive children.
-      if (!isRecursive(pattern)) {
-        expandedPatterns.push(pattern + '/**');
+  const expandedPatterns = []; // New array so we don't mutate input patterns array.
+  for (const pattern of patterns) {
+    // We need to expand `{foo,bar}` style brace patterns ourselves so that we
+    // can reliably interpret the syntax of the pattern. For example, for
+    // re-rooting we need to check for a leading `/`, but we can't do that
+    // directly on `{/foo,/bar}`.
+    for (const expanded of braces(pattern, {expand: true})) {
+      expandedPatterns.push(expanded);
+      if (opts.expandDirectories) {
+        // Also include a recursive-children version of every pattern, in case
+        // the pattern refers to a directory. This gives us behavior similar to
+        // the npm package.json "files" array, where matching a directory
+        // implicitly includes all transitive children.
+        if (!isRecursive(expanded)) {
+          expandedPatterns.push(expanded + '/**');
+        }
       }
     }
   }
@@ -131,8 +144,14 @@ export async function glob(
   // We want each group to include all subsequent negated patterns. The simplest
   // way to do that is to build the groups backwards.
   for (let i = expandedPatterns.length - 1; i >= 0; i--) {
-    const pattern = expandedPatterns[i];
+    let pattern = expandedPatterns[i];
     const isExclusive = pattern[0] === '!';
+    if (isExclusive) {
+      pattern = pattern.slice(1); // Remove the "!"
+    }
+    if (opts.rerootToCwd) {
+      pattern = pattern.replace(/^\/+/, '');
+    }
     if (isExclusive) {
       if (prevWasInclusive) {
         // A new group is needed because this exclusion comes before an
@@ -151,8 +170,7 @@ export async function glob(
         }
         groups.push(currentGroup);
       }
-      const inverted = pattern.slice(1); // Remove the "!"
-      currentGroup.exclude.push(inverted);
+      currentGroup.exclude.push(pattern);
     } else if (pattern.match(/^\s*$/)) {
       // fast-glob already throws on empty strings, but we also throw on
       // only-whitespace patterns.
@@ -189,6 +207,9 @@ export async function glob(
         // ENOTDIR errors when the path we appended to was not a directory. We
         // can't know in advance which patterns refer to directories.
         suppressErrors: true,
+        // We already do brace expansion ourselves. Doing it again would be
+        // inefficient and would also break brace escaping.
+        braceExpansion: false,
       });
       for (const match of matches) {
         combinedMap.set(match.path, match);
diff --git a/tsconfig.json b/tsconfig.json
index 2ad1a91f9..e5602d090 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,6 +3,7 @@
     "target": "es2020",
     "module": "es2022",
     "moduleResolution": "node",
+    "esModuleInterop": true,
     "useDefineForClassFields": true,
     "lib": ["es2020"],
     "rootDir": "src",

From 1dde704311df8eeae83bc5d390e272450f13c5db Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 09:16:16 -0700
Subject: [PATCH 04/12] Test rerootToCwd

---
 src/test/glob.test.ts | 53 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 51 insertions(+), 2 deletions(-)

diff --git a/src/test/glob.test.ts b/src/test/glob.test.ts
index 92df7307e..0dd2098c2 100644
--- a/src/test/glob.test.ts
+++ b/src/test/glob.test.ts
@@ -28,6 +28,7 @@ interface TestCase {
   followSymlinks?: boolean;
   includeDirectories?: boolean;
   expandDirectories?: boolean;
+  rerootToCwd?: boolean;
 }
 
 const test = suite<{
@@ -44,11 +45,12 @@ test.before.each(async (ctx) => {
       files,
       patterns,
       expected,
-      cwd = rig.temp,
+      cwd = '.',
       absolute = false,
       followSymlinks = true,
       includeDirectories = false,
       expandDirectories = false,
+      rerootToCwd = false,
     }: TestCase): Promise<void> => {
       for (const file of files) {
         if (typeof file === 'string') {
@@ -73,11 +75,12 @@ test.before.each(async (ctx) => {
       let actual, error;
       try {
         actual = await glob(patterns, {
-          cwd,
+          cwd: rig.resolve(cwd),
           absolute,
           followSymlinks,
           includeDirectories,
           expandDirectories,
+          rerootToCwd,
         });
       } catch (e) {
         error = e;
@@ -408,6 +411,7 @@ test('dirent tags files', async ({rig}) => {
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
+    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -424,6 +428,7 @@ test('dirent tags directories', async ({rig}) => {
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
+    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -440,6 +445,7 @@ test('dirent tags symlinks when followSymlinks=false', async ({rig}) => {
     followSymlinks: false,
     includeDirectories: true,
     expandDirectories: false,
+    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -459,6 +465,7 @@ test('dirent tags symlinks to files as files when followSymlinks=true', async ({
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
+    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -478,6 +485,7 @@ test('dirent tags symlinks to directories as directories when followSymlinks=tru
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
+    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -486,4 +494,45 @@ test('dirent tags symlinks to directories as directories when followSymlinks=tru
   assert.not(actual[0].dirent.isSymbolicLink());
 });
 
+test('re-roots to cwd', ({check}) =>
+  check({
+    files: ['foo'],
+    patterns: ['/foo'],
+    expected: ['foo'],
+    rerootToCwd: true,
+  }));
+
+test('re-roots to cwd with exclusion', ({check}) =>
+  check({
+    files: ['foo', 'bar', 'baz'],
+    patterns: ['/*', '!/bar'],
+    expected: ['foo', 'baz'],
+    rerootToCwd: true,
+  }));
+
+test('re-rooting allows ../', ({check}) =>
+  check({
+    cwd: 'subdir',
+    files: ['foo', 'subdir/'],
+    patterns: ['../foo'],
+    expected: ['../foo'],
+    rerootToCwd: true,
+  }));
+
+test('re-roots to cwd with braces', ({check}) =>
+  check({
+    files: ['foo', 'bar'],
+    patterns: ['{/foo,/bar}'],
+    expected: ['foo', 'bar'],
+    rerootToCwd: true,
+  }));
+
+test('braces can be escaped', ({check}) =>
+  check({
+    files: ['{foo,bar}'],
+    patterns: ['\\{foo,bar\\}'],
+    expected: ['{foo,bar}'],
+    rerootToCwd: true,
+  }));
+
 test.run();

From 3186c3016db27b4ada4c58808e4d71bcca76da89 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 09:18:13 -0700
Subject: [PATCH 05/12] Integrate rerootToCwd

---
 src/caching/local-cache.ts | 1 +
 src/executor.ts            | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/src/caching/local-cache.ts b/src/caching/local-cache.ts
index 3fe20c69a..aab26acbe 100644
--- a/src/caching/local-cache.ts
+++ b/src/caching/local-cache.ts
@@ -93,6 +93,7 @@ class LocalCacheHit implements CacheHit {
       followSymlinks: false,
       includeDirectories: true,
       expandDirectories: true,
+      rerootToCwd: true,
     });
     await copyEntries(entries, this.#source, this.#destination);
   }
diff --git a/src/executor.ts b/src/executor.ts
index 8f79395e2..8c3cc77a8 100644
--- a/src/executor.ts
+++ b/src/executor.ts
@@ -492,6 +492,7 @@ class ScriptExecution {
           followSymlinks: false,
           includeDirectories: true,
           expandDirectories: true,
+          rerootToCwd: true,
         }
       )
     );
@@ -530,6 +531,7 @@ class ScriptExecution {
         // We must expand directories here, because we need the complete
         // explicit list of files to hash.
         expandDirectories: true,
+        rerootToCwd: true,
       });
       // TODO(aomarks) Instead of reading and hashing every input file on every
       // build, use inode/mtime/ctime/size metadata (which is much faster to
@@ -662,6 +664,7 @@ class ScriptExecution {
       followSymlinks: false,
       includeDirectories: true,
       expandDirectories: true,
+      rerootToCwd: true,
     });
     if (absFiles.length === 0) {
       return;

From d6346df81096cf9c0b77d905e4f645d39b9f6b1f Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 09:33:59 -0700
Subject: [PATCH 06/12] Add rerootToCwd integration tests

---
 src/test/cache-common.ts   | 67 ++++++++++++++++++++++++++++++++++++++
 src/test/clean.test.ts     | 35 ++++++++++++++++++++
 src/test/freshness.test.ts | 44 +++++++++++++++++++++++++
 3 files changed, 146 insertions(+)

diff --git a/src/test/cache-common.ts b/src/test/cache-common.ts
index f16e786b6..46ef5c5ad 100644
--- a/src/test/cache-common.ts
+++ b/src/test/cache-common.ts
@@ -1007,4 +1007,71 @@ export const registerCommonCacheTests = (
       }
     })
   );
+
+  test(
+    'leading slash on output glob is package relative',
+    timeout(async ({rig}) => {
+      const cmdA = await rig.newCommand();
+      await rig.write({
+        'package.json': {
+          scripts: {
+            a: 'wireit',
+          },
+          wireit: {
+            a: {
+              command: cmdA.command,
+              files: ['input'],
+              output: ['/output'],
+            },
+          },
+        },
+        input: 'v0',
+      });
+
+      // Initial run with input v0.
+      {
+        const exec = rig.exec('npm run a');
+        const inv = await cmdA.nextInvocation();
+        await rig.write({output: 'v0'});
+        inv.exit(0);
+        const res = await exec.exit;
+        assert.equal(res.code, 0);
+        assert.equal(cmdA.numInvocations, 1);
+        assert.equal(await rig.read('output'), 'v0');
+      }
+
+      // Input changed to v1. Run again.
+      {
+        await rig.write({input: 'v1'});
+        const exec = rig.exec('npm run a');
+        const inv = await cmdA.nextInvocation();
+        await rig.write({output: 'v1'});
+        inv.exit(0);
+        const res = await exec.exit;
+        assert.equal(res.code, 0);
+        assert.equal(cmdA.numInvocations, 2);
+        assert.equal(await rig.read('output'), 'v1');
+      }
+
+      // Input changed back to v0. Output should be cached.
+      {
+        await rig.write({input: 'v0'});
+        const exec = rig.exec('npm run a');
+        const res = await exec.exit;
+        assert.equal(res.code, 0);
+        assert.equal(cmdA.numInvocations, 2);
+        assert.equal(await rig.read('output'), 'v0');
+      }
+
+      // Input changed back to v1. Output should be cached.
+      {
+        await rig.write({input: 'v1'});
+        const exec = rig.exec('npm run a');
+        const res = await exec.exit;
+        assert.equal(res.code, 0);
+        assert.equal(cmdA.numInvocations, 2);
+        assert.equal(await rig.read('output'), 'v1');
+      }
+    })
+  );
 };
diff --git a/src/test/clean.test.ts b/src/test/clean.test.ts
index d8c5b3886..3e90f0f2e 100644
--- a/src/test/clean.test.ts
+++ b/src/test/clean.test.ts
@@ -524,4 +524,39 @@ test(
   })
 );
 
+test(
+  'leading slash on output glob is package relative',
+  timeout(async ({rig}) => {
+    const cmdA = await rig.newCommand();
+    await rig.write({
+      'package.json': {
+        scripts: {
+          a: 'wireit',
+        },
+        wireit: {
+          a: {
+            command: cmdA.command,
+            output: ['/output'],
+          },
+        },
+      },
+      output: 'foo',
+    });
+
+    // Output should exist before we run the script.
+    assert.ok(await rig.exists('output'));
+
+    // Output should be deleted between running the script and executing the
+    // command.
+    const exec = rig.exec('npm run a');
+    const inv = await cmdA.nextInvocation();
+    assert.not(await rig.exists('output'));
+
+    inv.exit(0);
+    const res = await exec.exit;
+    assert.equal(res.code, 0);
+    assert.equal(cmdA.numInvocations, 1);
+  })
+);
+
 test.run();
diff --git a/src/test/freshness.test.ts b/src/test/freshness.test.ts
index 5163d6291..e37d10e21 100644
--- a/src/test/freshness.test.ts
+++ b/src/test/freshness.test.ts
@@ -1654,4 +1654,48 @@ test(
   })
 );
 
+test(
+  'leading slash on files glob is package relative',
+  timeout(async ({rig}) => {
+    const cmdA = await rig.newCommand();
+    await rig.write({
+      'package.json': {
+        scripts: {
+          a: 'wireit',
+        },
+        wireit: {
+          a: {
+            command: cmdA.command,
+            files: ['/input.txt'],
+          },
+        },
+      },
+      'input.txt': 'v0',
+    });
+
+    // Initially stale, so command is invoked.
+    {
+      const exec = rig.exec('npm run a');
+      const inv = await cmdA.nextInvocation();
+      inv.exit(0);
+      const res = await exec.exit;
+      assert.equal(res.code, 0);
+      assert.equal(cmdA.numInvocations, 1);
+    }
+
+    // Input file changed, so script is stale, and command is invoked.
+    {
+      await rig.write({
+        'input.txt': 'v1',
+      });
+      const exec = rig.exec('npm run a');
+      const inv = await cmdA.nextInvocation();
+      inv.exit(0);
+      const res = await exec.exit;
+      assert.equal(res.code, 0);
+      assert.equal(cmdA.numInvocations, 2);
+    }
+  })
+);
+
 test.run();

From 0344bdbe86dbffa55a21d55f0551eee7fa714030 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 09:40:59 -0700
Subject: [PATCH 07/12] README and CHANGELOG updates

---
 CHANGELOG.md | 10 ++++++++--
 README.md    |  9 ++++++++-
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 421c6108d..b8a254bea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,8 +10,14 @@ Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Changed
 
-- Starting to improve error messages by drawing squiggles underneith the
-  specific part of the package.json file that's in error.
+- [**Breaking**] A leading `/` on a `files` or `output` glob pattern is now
+  interpreted relative to the current package directory. Previously it was
+  interpreted relative to the root of the filesystem. In the case of `files`
+  (but not `output`), it is still possible to reference files outside of the
+  current package with a pattern like `../foo`.
+
+- Starting to improve error messages by drawing squiggles underneath the
+  specific part of the `package.json` file that's in error.
 
 ## [0.3.1] - 2022-04-30
 
diff --git a/README.md b/README.md
index 71f9ee784..9b1bac25c 100644
--- a/README.md
+++ b/README.md
@@ -526,10 +526,17 @@ The following glob syntaxes are supported in the `files` and `output` arrays:
 
 Also note these details:
 
+- Paths should always use `/` (forward-slash) delimiters, even on Windows.
+- Paths are interpreted relative to the current package even if there is a
+  leading `/` (e.g. `/foo` is the same as `foo`).
 - Whenever a directory is matched, all recursive children of that directory are
   included.
+- `files` are allowed to reach outside of the current package using e.g.
+  `../foo`. `output` files cannot reference files outside of the current
+  package.
 - Symlinks in input `files` are followed, so that they are identified by their content.
-- Symlinks in `output` files are cached as symlinks, so that restoring from cache doesn't create unnecessary copies.
+- Symlinks in `output` files are cached as symlinks, so that restoring from
+  cache doesn't create unnecessary copies.
 - The order of `!exclude` patterns is significant.
 - Hidden/dot files are matched by `*` and `**`.
 - Patterns are case-sensitive (if supported by the filesystem).

From b209d54ab7bf7555a01373b3cf38447a92660c33 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 11:50:22 -0700
Subject: [PATCH 08/12] Always enable rerootToCwd

---
 src/caching/local-cache.ts |  1 -
 src/executor.ts            |  3 ---
 src/test/glob.test.ts      | 13 -------------
 src/util/glob.ts           | 15 +++++----------
 4 files changed, 5 insertions(+), 27 deletions(-)

diff --git a/src/caching/local-cache.ts b/src/caching/local-cache.ts
index aab26acbe..3fe20c69a 100644
--- a/src/caching/local-cache.ts
+++ b/src/caching/local-cache.ts
@@ -93,7 +93,6 @@ class LocalCacheHit implements CacheHit {
       followSymlinks: false,
       includeDirectories: true,
       expandDirectories: true,
-      rerootToCwd: true,
     });
     await copyEntries(entries, this.#source, this.#destination);
   }
diff --git a/src/executor.ts b/src/executor.ts
index 8c3cc77a8..8f79395e2 100644
--- a/src/executor.ts
+++ b/src/executor.ts
@@ -492,7 +492,6 @@ class ScriptExecution {
           followSymlinks: false,
           includeDirectories: true,
           expandDirectories: true,
-          rerootToCwd: true,
         }
       )
     );
@@ -531,7 +530,6 @@ class ScriptExecution {
         // We must expand directories here, because we need the complete
         // explicit list of files to hash.
         expandDirectories: true,
-        rerootToCwd: true,
       });
       // TODO(aomarks) Instead of reading and hashing every input file on every
       // build, use inode/mtime/ctime/size metadata (which is much faster to
@@ -664,7 +662,6 @@ class ScriptExecution {
       followSymlinks: false,
       includeDirectories: true,
       expandDirectories: true,
-      rerootToCwd: true,
     });
     if (absFiles.length === 0) {
       return;
diff --git a/src/test/glob.test.ts b/src/test/glob.test.ts
index 0dd2098c2..18c304433 100644
--- a/src/test/glob.test.ts
+++ b/src/test/glob.test.ts
@@ -28,7 +28,6 @@ interface TestCase {
   followSymlinks?: boolean;
   includeDirectories?: boolean;
   expandDirectories?: boolean;
-  rerootToCwd?: boolean;
 }
 
 const test = suite<{
@@ -50,7 +49,6 @@ test.before.each(async (ctx) => {
       followSymlinks = true,
       includeDirectories = false,
       expandDirectories = false,
-      rerootToCwd = false,
     }: TestCase): Promise<void> => {
       for (const file of files) {
         if (typeof file === 'string') {
@@ -80,7 +78,6 @@ test.before.each(async (ctx) => {
           followSymlinks,
           includeDirectories,
           expandDirectories,
-          rerootToCwd,
         });
       } catch (e) {
         error = e;
@@ -411,7 +408,6 @@ test('dirent tags files', async ({rig}) => {
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
-    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -428,7 +424,6 @@ test('dirent tags directories', async ({rig}) => {
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
-    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -445,7 +440,6 @@ test('dirent tags symlinks when followSymlinks=false', async ({rig}) => {
     followSymlinks: false,
     includeDirectories: true,
     expandDirectories: false,
-    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -465,7 +459,6 @@ test('dirent tags symlinks to files as files when followSymlinks=true', async ({
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
-    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -485,7 +478,6 @@ test('dirent tags symlinks to directories as directories when followSymlinks=tru
     followSymlinks: true,
     includeDirectories: true,
     expandDirectories: false,
-    rerootToCwd: false,
   });
   assert.equal(actual.length, 1);
   assert.equal(actual[0].path, 'foo');
@@ -499,7 +491,6 @@ test('re-roots to cwd', ({check}) =>
     files: ['foo'],
     patterns: ['/foo'],
     expected: ['foo'],
-    rerootToCwd: true,
   }));
 
 test('re-roots to cwd with exclusion', ({check}) =>
@@ -507,7 +498,6 @@ test('re-roots to cwd with exclusion', ({check}) =>
     files: ['foo', 'bar', 'baz'],
     patterns: ['/*', '!/bar'],
     expected: ['foo', 'baz'],
-    rerootToCwd: true,
   }));
 
 test('re-rooting allows ../', ({check}) =>
@@ -516,7 +506,6 @@ test('re-rooting allows ../', ({check}) =>
     files: ['foo', 'subdir/'],
     patterns: ['../foo'],
     expected: ['../foo'],
-    rerootToCwd: true,
   }));
 
 test('re-roots to cwd with braces', ({check}) =>
@@ -524,7 +513,6 @@ test('re-roots to cwd with braces', ({check}) =>
     files: ['foo', 'bar'],
     patterns: ['{/foo,/bar}'],
     expected: ['foo', 'bar'],
-    rerootToCwd: true,
   }));
 
 test('braces can be escaped', ({check}) =>
@@ -532,7 +520,6 @@ test('braces can be escaped', ({check}) =>
     files: ['{foo,bar}'],
     patterns: ['\\{foo,bar\\}'],
     expected: ['{foo,bar}'],
-    rerootToCwd: true,
   }));
 
 test.run();
diff --git a/src/util/glob.ts b/src/util/glob.ts
index 21a97da11..4f8a7ba3f 100644
--- a/src/util/glob.ts
+++ b/src/util/glob.ts
@@ -45,13 +45,6 @@ export interface GlobOptions {
    * Note this works even if includeDirectories is false.
    */
   expandDirectories: boolean;
-
-  /**
-   * If true, interpret `/` as the `cwd`, but still allow `../` for referring
-   * outside of `cwd` (for example, `/foo` is interpreted as `<cwd>/foo`). If
-   * false, `/` refers to the root of the filesystem.
-   */
-  rerootToCwd: boolean;
 }
 
 interface GlobGroup {
@@ -64,6 +57,8 @@ interface GlobGroup {
  *
  * - Input patterns must be / separated.
  * - Matches are returned with the OS-specific separator.
+ * - Leading `/`s are interpreted as relative to the `cwd`, instead of the root
+ *   of the filesystem.
  * - Dot (aka hidden) files are always matched.
  * - Empty or blank patterns throw.
  * - The order of "!exclusion" patterns matter (i.e. files can be "re-included"
@@ -149,9 +144,9 @@ export async function glob(
     if (isExclusive) {
       pattern = pattern.slice(1); // Remove the "!"
     }
-    if (opts.rerootToCwd) {
-      pattern = pattern.replace(/^\/+/, '');
-    }
+    // Ignore leading `/`s so that e.g. "/foo" is interpreted relative to the
+    // cwd, instead of relative to the root of the filesystem.
+    pattern = pattern.replace(/^\/+/, '');
     if (isExclusive) {
       if (prevWasInclusive) {
         // A new group is needed because this exclusion comes before an

From c5454045d236387b4d2cbd7aea181765617c4301 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 11:51:32 -0700
Subject: [PATCH 09/12] Added comment about multiple slashes

---
 src/util/glob.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/util/glob.ts b/src/util/glob.ts
index 4f8a7ba3f..4a12a09f4 100644
--- a/src/util/glob.ts
+++ b/src/util/glob.ts
@@ -145,7 +145,8 @@ export async function glob(
       pattern = pattern.slice(1); // Remove the "!"
     }
     // Ignore leading `/`s so that e.g. "/foo" is interpreted relative to the
-    // cwd, instead of relative to the root of the filesystem.
+    // cwd, instead of relative to the root of the filesystem. We want to include
+    // >1 leading slashes, since those are technically valid paths too.
     pattern = pattern.replace(/^\/+/, '');
     if (isExclusive) {
       if (prevWasInclusive) {

From d397391f16f955f05c3d9c3de85b2e1c36eff617 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 12:15:04 -0700
Subject: [PATCH 10/12] Add more test cases

---
 src/test/glob.test.ts | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/test/glob.test.ts b/src/test/glob.test.ts
index 18c304433..393b7d798 100644
--- a/src/test/glob.test.ts
+++ b/src/test/glob.test.ts
@@ -508,6 +508,22 @@ test('re-rooting allows ../', ({check}) =>
     expected: ['../foo'],
   }));
 
+test('re-rooting handles /./foo', ({check}) =>
+  check({
+    files: ['foo'],
+    patterns: ['/./foo'],
+    // TODO(aomarks) Normalize this.
+    expected: ['./foo'],
+  }));
+
+test('re-rooting handles /../foo', ({check}) =>
+  check({
+    cwd: 'subdir',
+    files: ['foo', 'subdir/'],
+    patterns: ['/../foo'],
+    expected: ['../foo'],
+  }));
+
 test('re-roots to cwd with braces', ({check}) =>
   check({
     files: ['foo', 'bar'],

From 27f205b77a33784e968c10924aace3ae03686e07 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 14:43:15 -0700
Subject: [PATCH 11/12] Fix Windows test

---
 src/test/glob.test.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/glob.test.ts b/src/test/glob.test.ts
index 393b7d798..2994c7b32 100644
--- a/src/test/glob.test.ts
+++ b/src/test/glob.test.ts
@@ -512,8 +512,8 @@ test('re-rooting handles /./foo', ({check}) =>
   check({
     files: ['foo'],
     patterns: ['/./foo'],
-    // TODO(aomarks) Normalize this.
-    expected: ['./foo'],
+    // TODO(aomarks) This should be normalized to to "foo".
+    expected: [`.${pathlib.sep}foo`],
   }));
 
 test('re-rooting handles /../foo', ({check}) =>

From 07faf39b3ffd5186439682064f177305d30c40e2 Mon Sep 17 00:00:00 2001
From: Alexander Marks <aomarks@google.com>
Date: Wed, 4 May 2022 14:53:34 -0700
Subject: [PATCH 12/12] Temporarily disable failing test

---
 src/test/glob.test.ts | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/test/glob.test.ts b/src/test/glob.test.ts
index 2994c7b32..b5e3b0ea3 100644
--- a/src/test/glob.test.ts
+++ b/src/test/glob.test.ts
@@ -508,11 +508,12 @@ test('re-rooting allows ../', ({check}) =>
     expected: ['../foo'],
   }));
 
-test('re-rooting handles /./foo', ({check}) =>
+// TODO(aomarks) This should be normalized to "foo" consistently. It currently
+// differs on Windows between Node 14 and 16.
+test.skip('re-rooting handles /./foo', ({check}) =>
   check({
     files: ['foo'],
     patterns: ['/./foo'],
-    // TODO(aomarks) This should be normalized to to "foo".
     expected: [`.${pathlib.sep}foo`],
   }));