@@ -0,0 +1,55 @@
+// Which of a patch's or pull request's files the contributor has changed
+// since (#669), for the "also edited" mark under "Changed files".
+//
+// A pull request is its branch's base, so that is a question the unsubmitted
+// list already answers. A patch is an uncommitted layer: every file it wrote
+// is in that list whoever touched it last, so each one's content is
+// fingerprinted when the patch is applied and compared with the disk later.
+// Pure: main reads the files and hands over their fingerprints.
+'use strict';
+
+const crypto = require('crypto');
+const { normalizeEolBuffer } = require('./git-update.cjs');
+
+/**
+ * A file's content, as a SHA-256 hex digest, or null for a file that is not
+ * there. Line endings are normalised first, byte by byte, so a CRLF checkout
+ * is not an edit and a file in another encoding is hashed as it is.
+ *
+ * @param {?Buffer} buf
+ * @return {?string}
+ */
+function fingerprint(buf) {
+	if (!buf) return null;
+	return crypto.createHash('sha256').update(normalizeEolBuffer(buf)).digest('hex');
+}
+
+/**
+ * The change's files the contributor has changed since it arrived, in the
+ * change's order.
+ *
+ * For a patch, `fingerprints` (what it wrote, recorded at apply) against
+ * `now` (the same paths' fingerprints read now). For a pull request, its
+ * files that are among the `unsubmitted` changes; a kept patch recorded
+ * before fingerprints were is passed in the same way, as `prFiles`, by the
+ * caller. With neither, nothing is marked.
+ *
+ * @param {Object}   root0
+ * @param {?Object}  [root0.fingerprints] Path → fingerprint or null, from the patch's record.
+ * @param {Object}   [root0.now]          Path → fingerprint or null, read now.
+ * @param {string[]} [root0.prFiles]      The pull request's files.
+ * @param {string[]} [root0.unsubmitted]  Every path changed from the branch's base.
+ * @return {string[]}
+ */
+function editedSinceChange({ fingerprints = null, now = {}, prFiles = null, unsubmitted = [] } = {}) {
+	if (fingerprints) {
+		return Object.keys(fingerprints).filter((file) => (now[file] ?? null) !== fingerprints[file]);
+	}
+	if (Array.isArray(prFiles)) {
+		const changed = new Set(unsubmitted);
+		return prFiles.filter((file) => changed.has(file));
+	}
+	return [];
+}
+
+module.exports = { fingerprint, editedSinceChange };
@@ -268,11 +268,65 @@ async function isLaunchableEditorPath(editorPath, { platform, statPath } = {}) {
 // bundle is a directory rather than something executable. Everywhere else the
 // executable takes the folder as its argument, which is what every editor in the
 // table above supports.
-function resolveLaunch(editorPath, sitePath, { platform } = {}) {
+//
+// A `file`, absolute and already checked by `resolveSiteFile`, goes after the
+// folder: the editor opens the site and shows the file in it, rather than a
+// window of its own with no project around it (#669).
+function resolveLaunch(editorPath, sitePath, { platform, file = null } = {}) {
+	const targets = file ? [sitePath, file] : [sitePath];
 	if (platform === 'darwin') {
-		return { command: '/usr/bin/open', args: ['-a', editorPath, sitePath] };
+		return { command: '/usr/bin/open', args: ['-a', editorPath, ...targets] };
+	}
+	return { command: editorPath, args: targets };
+}
+
+// The absolute path of a file of the site, or null for anything that is not
+// one. The window names the file, and the window is where injected content
+// ends up, so "open this file of the site" is bounded by the site the way
+// "open this site" is bounded by the registry: an absolute path, a path that
+// climbs out, and a path on another drive all resolve to nothing.
+function resolveSiteFile(sitePath, relPath, { platform } = {}) {
+	if (typeof relPath !== 'string' || relPath === '') return null;
+	const p = pathApi(platform);
+	if (p.isAbsolute(relPath)) return null;
+	const target = p.resolve(sitePath, relPath);
+	const inside = p.relative(sitePath, target);
+	if (inside === '' || inside === '..' || inside.startsWith(`..${p.sep}`) || p.isAbsolute(inside)) return null;
+	return target;
+}
+
+// The file to open: `resolveSiteFile`, and then the same question asked of
+// where the file really is. A symbolic link is judged by where it
+// leads, so a link a patch added inside the site that names a file outside it
+// is not a file of the site; Git writes links in a checkout added from disk on
+// macOS or Linux, unlike the ones the app clones. Both sides are resolved, so
+// a site whose own folder is behind a link (macOS's /var) still holds its
+// files. A path with nothing there does not resolve, which is how a file the
+// patch deleted is refused.
+//
+// `{ file, error }`: `file` is the path to open, or null. `error` is the code
+// realpath failed with when the failure was not "nothing there" (a folder that
+// cannot be read, a loop of links), so the caller can say that rather than
+// report a file the patch only changed as one it may have deleted.
+//
+// `realPath` is injected and awaited like `statPath`: fs.promises.realpath in
+// main, a map in the tests.
+const NOT_THERE = new Set(['ENOENT', 'ENOTDIR']);
+async function existingSiteFile(sitePath, relPath, { platform, realPath } = {}) {
+	const target = resolveSiteFile(sitePath, relPath, { platform });
+	if (!target || typeof realPath !== 'function') return { file: null, error: null };
+	let realSite;
+	let realTarget;
+	try {
+		[realSite, realTarget] = await Promise.all([realPath(sitePath), realPath(target)]);
+	} catch (e) {
+		const code = typeof e?.code === 'string' ? e.code : 'UNKNOWN';
+		return { file: null, error: NOT_THERE.has(code) ? null : code };
 	}
-	return { command: editorPath, args: [sitePath] };
+	const p = pathApi(platform);
+	const inside = p.relative(realSite, realTarget);
+	if (inside === '' || inside === '..' || inside.startsWith(`..${p.sep}`) || p.isAbsolute(inside)) return { file: null, error: null };
+	return { file: target, error: null };
 }
 
 // Every `reason` this module can answer `editor:open` with, refusals and
@@ -283,6 +337,8 @@ const REFUSAL_REASONS = {
 	UNREGISTERED_SITE: 'unregistered-site',
 	UNLAUNCHABLE_EDITOR: 'unlaunchable-editor',
 	UNKNOWN_EDITOR: 'unknown-editor',
+	MISSING_FILE: 'missing-file',
+	UNREADABLE_FILE: 'unreadable-file',
 	SPAWN_FAILED: 'spawn-failed'
 };
 
@@ -313,7 +369,9 @@ async function openSiteInEditor(sitePath, editorPath, {
 	platform,
 	statPath,
 	spawn,
-	onRefused
+	onRefused,
+	realPath,
+	file = null
 } = {}) {
 	if (!isActionableSite(sitePath, { sites, pending })) {
 		if (typeof onRefused === 'function') {
@@ -329,7 +387,29 @@ async function openSiteInEditor(sitePath, editorPath, {
 		return { ok: false, reason: REFUSAL_REASONS.UNLAUNCHABLE_EDITOR };
 	}
 
-	const { command, args } = resolveLaunch(editorPath, sitePath, { platform });
+	// A third gate when a file of the site is named (#669): inside the site,
+	// and there. A patch that deleted a file still lists it, and an editor
+	// handed a path that is not there opens an empty buffer under that name,
+	// which reads as the file having been emptied.
+	let filePath = null;
+	if (file !== null) {
+		const found = await existingSiteFile(sitePath, file, { platform, realPath });
+		filePath = found.file;
+		if (found.error) {
+			if (typeof onRefused === 'function') {
+				onRefused(REFUSAL_REASONS.UNREADABLE_FILE, `${describeRefused(file)} (${found.error})`);
+			}
+			return { ok: false, reason: REFUSAL_REASONS.UNREADABLE_FILE, error: found.error };
+		}
+		if (!filePath) {
+			if (typeof onRefused === 'function') {
+				onRefused(REFUSAL_REASONS.MISSING_FILE, describeRefused(file));
+			}
+			return { ok: false, reason: REFUSAL_REASONS.MISSING_FILE };
+		}
+	}
+
+	const { command, args } = resolveLaunch(editorPath, sitePath, { platform, file: filePath });
 
 	let child;
 	try {
@@ -411,5 +491,7 @@ module.exports = {
 	knownEditorName,
 	isLaunchableEditorPath,
 	resolveLaunch,
+	resolveSiteFile,
+	existingSiteFile,
 	openSiteInEditor
 };
@@ -239,6 +239,32 @@ async function unstagePaths(dir, paths, { platform = process.platform, run = run
 	return paths.length;
 }
 
+/**
+ * Puts `paths` in the worktree back as `source` has them (#669): one file's
+ * edits undone, or a file the contributor deleted brought back. The worktree
+ * only, so the index stays as the app always leaves it. Every path has to
+ * exist in `source`; one that does not is an error from Git, and a file the
+ * contributor added is removed by the caller instead. Fed on stdin like
+ * `stagePaths`, NUL-separated and literal.
+ *
+ * @param {string}   dir
+ * @param {string}   source             The commit to take the content from.
+ * @param {string[]} paths
+ * @param {Object}   [options]
+ * @param {string}   [options.platform]
+ * @param {Function} [options.run]
+ * @return {Promise<number>} How many paths were handed to Git.
+ */
+async function restoreWorktreePaths(dir, source, paths, { platform = process.platform, run = runGit } = {}) {
+	if (!paths.length) return 0;
+	const win = await windowsArgs(dir, { platform, run });
+	await run([...win, '--literal-pathspecs', 'restore', `--source=${source}`, '--worktree', '--pathspec-from-file=-', '--pathspec-file-nul'], {
+		cwd: dir,
+		input: Buffer.from(`${paths.join('\0')}\0`, 'utf8')
+	});
+	return paths.length;
+}
+
 /**
  * Removes every untracked file and directory that is not ignored. Without
  * `-x`, what `.gitignore` and `.git/info/exclude` name stays (`node_modules`,
@@ -292,6 +318,7 @@ async function applyPatch(dir, patchText, { check = false, reverse = false, plat
 module.exports = {
 	stagePaths,
 	unstagePaths,
+	restoreWorktreePaths,
 	writeTree,
 	commitTree,
 	updateBranch,