@moritzwilksch/diffle 0.1.8 → 0.1.9

package/dist/server/main.js

@@ -11,6 +11,7 @@ import { copyFile, lstat, mkdir, mkdtemp, open, readFile, readlink, realpath, re
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { homedir, hostname, tmpdir } from "node:os";
 import { createServer } from "node:http";
+import { getAssetKeys, getRawAsset, isSea } from "node:sea";
 import { Http2ServerRequest, constants as constants$1 } from "http2";
 import { Readable } from "stream";
 import crypto from "crypto";
@@ -3951,7 +3952,7 @@ function generateCompletion(program, { shell, executable = program.name() }) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.1.8";
+var version$1 = "0.1.9";
 //#endregion
 //#region src/server/comments/anchor.ts
 function splitLines(contents) {
@@ -4198,6 +4199,7 @@ var GitRepo = class GitRepo {
 			new: next
 		};
 	}
+	/** A commit's hash, abbreviation and full message; null when `rev` names no commit. */
 	async commitInfo(rev) {
 		let sha;
 		try {
@@ -4221,6 +4223,66 @@ var GitRepo = class GitRepo {
 			message: output.slice(separator + 1).trimEnd()
 		};
 	}
+	/**
+	* `sha`'s first parent, and the commit toward HEAD whose first parent it is. The
+	* child is null at HEAD, on an unborn branch, or when `sha` is off HEAD's
+	* first-parent line, e.g. on a merged side branch.
+	*/
+	async commitNeighbours(sha) {
+		const [parent, list] = await Promise.all([this.resolve(`${sha}^`).catch((e) => {
+			if (e instanceof GitError && e.code === 1) return null;
+			throw e;
+		}), this.text([
+			"rev-list",
+			"--first-parent",
+			"--ancestry-path",
+			"--parents",
+			`${sha}..HEAD`,
+			"--"
+		]).catch(() => "")]);
+		const [child, firstParent] = list.trim().split("\n").pop()?.split(" ") ?? [];
+		return {
+			parent,
+			child: child && firstParent === sha ? child : null
+		};
+	}
+	/** The commits a revision range such as `a..b` or `c^!` selects, oldest first: the newest `limit`, and the total. */
+	async rangeCommits(range, limit) {
+		const [count, log] = await Promise.all([this.text([
+			"rev-list",
+			"--count",
+			"--end-of-options",
+			range,
+			"--"
+		]), this.text([
+			"log",
+			"-z",
+			"--no-show-signature",
+			"--reverse",
+			`--max-count=${limit}`,
+			"--format=%H%x00%h%x00%an%x00%ae%x00%at%x00%B",
+			"--end-of-options",
+			range,
+			"--"
+		])]);
+		const fields = log.split("\0");
+		const list = [];
+		for (let i = 0; i + 5 < fields.length; i += 6) {
+			const [sha = "", short = "", author = "", email = "", time = "", message = ""] = fields.slice(i, i + 6);
+			list.push({
+				sha,
+				short,
+				message: message.trimEnd(),
+				author,
+				email,
+				date: Number(time) * 1e3
+			});
+		}
+		return {
+			list,
+			total: Number(count.trim())
+		};
+	}
 	/** The empty tree under the repository's hash algorithm: the old side of an unborn branch. */
 	async emptyTree() {
 		return (await this.text([
@@ -12099,14 +12161,26 @@ const ModeRequestSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("revspec"),
 		args: string().array()
+	}),
+	object({
+		kind: literal("focus"),
+		commit: string().nullable()
 	})
 ]);
-/** A comparison; both endpoints accept a Git revision or "worktree". */
-const ModeSpecSchema = object({
+/**
+* How the old side is derived: `old` itself, merge-base(old, new) with worktree
+* taken as HEAD, or new's first parent (the empty tree for a root commit).
+*/
+const ComparisonBaseSchema = _enum([
+	"direct",
+	"merge-base",
+	"parent"
+]);
+/** A comparison; both endpoints accept a Git revision or "worktree". Under `parent`, both name the one commit. */
+const ComparisonSchema = object({
 	old: string(),
 	new: string(),
-	/** Compare merge-base(old, new) to new; worktree uses HEAD for the merge base. */
-	mergeBase: boolean(),
+	base: ComparisonBaseSchema,
 	live: _enum([
 		"worktree",
 		"refs",
@@ -12115,10 +12189,18 @@ const ModeSpecSchema = object({
 	/** Fixed when the comparison is entered; discovery never changes comment storage. */
 	commentKey: string()
 });
-/** Display comparison endpoints with branch names instead of internal ref namespaces. */
+const ModeSpecSchema = ComparisonSchema.extend({ 
+/** Set while one commit of a range is focused: the range, whose commits the snapshot keeps listing. */
+within: ComparisonSchema.optional() });
+/**
+* Display comparison endpoints with branch names instead of internal ref namespaces; a single commit as
+* `<sha>^!`, or as `<range> @ <sha>` when focused within a range.
+*/
 function comparisonLabel(mode) {
+	if (mode.within) return `${comparisonLabel(mode.within)} @ ${mode.new.slice(0, 7)}`;
+	if (mode.base === "parent") return `${mode.new.slice(0, 7)}^!`;
 	const name = (rev) => rev.replace(/^refs\/diffle\/[^/]+\/\d+\/(?:base|head)\//, "").replace(/^refs\/(?:heads|remotes)\//, "");
-	return `${name(mode.old)}${mode.mergeBase ? "..." : ".."}${name(mode.new)}`;
+	return `${name(mode.old)}${mode.base === "merge-base" ? "..." : ".."}${name(mode.new)}`;
 }
 const GithubPullRequestSchema = object({
 	repository: string(),
@@ -12168,6 +12250,32 @@ const ChangedFileSchema = object({
 	/** A gitlink (mode 160000): `blob` is the recorded commit, the patch shows the commit-id change, and there is no file to open. */
 	submodule: literal(true).optional()
 });
+const CommitInfoSchema = object({
+	sha: string(),
+	short: string(),
+	message: string()
+});
+/** A single reviewed commit and its neighbours along HEAD's first-parent history, for stepping through it. */
+const ReviewedCommitSchema = CommitInfoSchema.extend({
+	/** First parent; null for a root commit. */
+	parent: string().nullable(),
+	/** The commit whose first parent this is, toward HEAD; null at HEAD or off HEAD's first-parent line. */
+	child: string().nullable()
+});
+/**
+* The commits a comparison spans: old..new, with the worktree taken as HEAD, or the one commit under `parent`.
+* A focused commit lists its range's.
+*/
+const RangeCommitsSchema = object({
+	/** Oldest first; the newest MAX_RANGE_COMMITS when there are more. */
+	list: CommitInfoSchema.extend({
+		author: string(),
+		email: string(),
+		/** Author date, epoch milliseconds. */
+		date: number()
+	}).array(),
+	total: number()
+});
 object({
 	root: string(),
 	mode: ModeSpecSchema,
@@ -12182,7 +12290,10 @@ object({
 	context: number(),
 	changed: ChangedFileSchema.array(),
 	/** All paths on the new side: the new commit's tree, or index ∪ untracked for the worktree. Sorted. */
-	tree: string().array()
+	tree: string().array(),
+	/** The reviewed commit when the comparison is a single commit against its parent; otherwise null. */
+	commit: ReviewedCommitSchema.nullable(),
+	commits: RangeCommitsSchema
 });
 /** Body of `POST /api/patch`: the changed files whose patches to return, concatenated. Unknown paths are skipped. */
 const PatchRequestSchema = object({ paths: string().array().max(200) });
@@ -12279,11 +12390,6 @@ const ViewedEntrySchema = object({
 	blob: string(),
 	viewed: boolean()
 });
-const CommitInfoSchema = object({
-	sha: string(),
-	short: string(),
-	message: string()
-});
 object({
 	old: CommitInfoSchema.nullable(),
 	new: CommitInfoSchema.nullable()
@@ -14044,6 +14150,7 @@ const WORKTREE = "worktree";
 *   "a..b"   → a vs b
 *   "a...b"  → merge-base(a, b) vs b
 *   "a" "b"  → a vs b
+*   "a^!"    → a vs its first parent: the one commit, as git show shows it
 * Empty sides default to HEAD. Either side accepts "worktree" for the uncommitted
 * tree; a merge base against it is taken against HEAD, the commit it sits on.
 */
@@ -14052,34 +14159,45 @@ function parseRevspec(args) {
 	if (args.length === 2) {
 		const [a, b] = args;
 		if (a.includes("..") || b.includes("..")) throw new RevspecError("cannot combine \"..\" with two revisions");
+		if (a.endsWith("^!") || b.endsWith("^!")) throw new RevspecError("cannot combine \"^!\" with two revisions");
 		return {
 			old: a,
 			new: b,
-			mergeBase: false
+			base: "direct"
 		};
 	}
 	const arg = args[0];
+	if (arg.endsWith("^!")) {
+		const commit = arg.slice(0, -2) || "HEAD";
+		if (commit.includes("..")) throw new RevspecError("cannot combine \"^!\" with \"..\"");
+		if (commit === WORKTREE) throw new RevspecError("the worktree is not a commit");
+		return {
+			old: commit,
+			new: commit,
+			base: "parent"
+		};
+	}
 	const three = arg.indexOf("...");
 	if (three !== -1) return {
 		old: arg.slice(0, three) || "HEAD",
 		new: arg.slice(three + 3) || "HEAD",
-		mergeBase: true
+		base: "merge-base"
 	};
 	const two = arg.indexOf("..");
 	if (two !== -1) return {
 		old: arg.slice(0, two) || "HEAD",
 		new: arg.slice(two + 2) || "HEAD",
-		mergeBase: false
+		base: "direct"
 	};
 	if (arg === WORKTREE) return {
 		old: "HEAD",
 		new: WORKTREE,
-		mergeBase: false
+		base: "direct"
 	};
 	return {
 		old: arg,
 		new: "HEAD",
-		mergeBase: true
+		base: "merge-base"
 	};
 }
 var RevspecError = class extends Error {};
@@ -17705,7 +17823,8 @@ var Server = class {
 		app.use("/api/*", compress());
 		app.route("/", createApi(this.deps));
 		app.all("/api/*", (c) => c.json({ error: "API endpoint not found. Restart diffle to load the latest server." }, 404));
-		if (!this.opts.dev) {
+		if (!this.opts.dev && isSea()) app.get("*", serveEmbedded);
+		else if (!this.opts.dev) {
 			const clientDir = resolveClientDir();
 			app.use("*", serveStatic({ root: clientDir }));
 			app.get("*", serveStatic({
@@ -17792,7 +17911,14 @@ function resolveClientDir() {
 	return join(projectRoot(), "dist", "client");
 }
 function hasClientBuild() {
-	return existsSync(join(resolveClientDir(), "index.html"));
+	return isSea() || existsSync(join(resolveClientDir(), "index.html"));
+}
+const embedded = isSea() ? new Set(getAssetKeys()) : /* @__PURE__ */ new Set();
+function serveEmbedded(c) {
+	const path = c.req.path.slice(1);
+	const key = embedded.has(path) ? path : "index.html";
+	const type = getMimeType(key) ?? "application/octet-stream";
+	return c.body(new Uint8Array(getRawAsset(key)), 200, { "content-type": type });
 }
 //#endregion
 //#region src/server/github/pulls.ts
@@ -18307,17 +18433,19 @@ function describe(skipped) {
 *   A--B--C  main
 *       \--D--E  HEAD
 *
-*   old       new       mergeBase   oldSha      newSha     live
-*   main      HEAD      false       C           E          refs
-*   main      HEAD      true        B           E          refs
-*   HEAD      worktree  false       E           worktree   worktree
-*   worktree  HEAD      false       worktree    E          worktree
-*   main      worktree  true        B           worktree   worktree
-*   <C hash>  <E hash>  false       C           E          none
+*   old       new       base        oldSha      newSha     live
+*   main      HEAD      direct      C           E          refs
+*   main      HEAD      merge-base  B           E          refs
+*   HEAD      worktree  direct      E           worktree   worktree
+*   worktree  HEAD      direct      worktree    E          worktree
+*   main      worktree  merge-base  B           worktree   worktree
+*   <C hash>  <E hash>  direct      C           E          none
+*   <E hash>  <E hash>  parent      D           E          none
 *
-* mergeBase replaces only the old endpoint with the common ancestor, using
-* HEAD for any worktree input. live is "worktree" if either input is worktree,
-* "none" if both inputs are pinned hashes, and "refs" otherwise.
+* merge-base replaces only the old endpoint with the common ancestor, using
+* HEAD for any worktree input; parent replaces it with new's first parent, or
+* the empty tree for a root commit. live is "worktree" if either input is
+* worktree, "none" if both inputs are pinned hashes, and "refs" otherwise.
 *
 * In an unborn repository, HEAD compared directly with worktree resolves to
 * the empty tree. Invalid revisions or missing merge bases throw RevspecError.
@@ -18329,14 +18457,14 @@ async function resolveComparison(repo, comparison) {
 		try {
 			return await repo.resolve(rev);
 		} catch (e) {
-			if (!comparison.mergeBase && rev === "HEAD" && endpoints.includes("worktree") && e instanceof GitError && e.code === 1) return repo.emptyTree();
+			if (comparison.base === "direct" && rev === "HEAD" && endpoints.includes("worktree") && e instanceof GitError && e.code === 1) return repo.emptyTree();
 			if (e instanceof GitError) throw new RevspecError(`unknown revision: ${rev}`);
 			throw e;
 		}
 	};
 	const [old, next] = await Promise.all([resolve(comparison.old), resolve(comparison.new)]);
 	let oldSha = old;
-	if (comparison.mergeBase) {
+	if (comparison.base === "merge-base") {
 		const [a, b] = await Promise.all([old === "worktree" ? resolve("HEAD") : old, next === "worktree" ? resolve("HEAD") : next]);
 		try {
 			oldSha = await repo.mergeBase(a, b);
@@ -18345,6 +18473,13 @@ async function resolveComparison(repo, comparison) {
 			throw e;
 		}
 	}
+	if (comparison.base === "parent") {
+		if (next === "worktree") throw new RevspecError("the worktree is not a commit");
+		oldSha = await repo.resolve(`${next}^`).catch((e) => {
+			if (e instanceof GitError && e.code === 1) return repo.emptyTree();
+			throw e;
+		});
+	}
 	const pinned = (rev, sha) => rev.length >= 7 && sha.startsWith(rev.toLowerCase());
 	return {
 		oldSha,
@@ -18358,8 +18493,18 @@ async function resolveReview(req, repo, github) {
 	const parsed = req.kind === "working" ? {
 		old: "HEAD",
 		new: "worktree",
-		mergeBase: false
+		base: "direct"
 	} : parseRevspec(req.args);
+	if (parsed.base === "parent") {
+		const { newSha: sha } = await resolveComparison(repo, parsed);
+		return { mode: {
+			old: sha,
+			new: sha,
+			base: "parent",
+			live: "none",
+			commentKey: `commit:${sha}`
+		} };
+	}
 	const { oldSha, newSha, live } = await resolveComparison(repo, parsed);
 	return { mode: {
 		...parsed,
@@ -18369,19 +18514,21 @@ async function resolveReview(req, repo, github) {
 }
 /**
 * Branch identities keep review state stable across pushes and local branch aliases.
+* Keys read like the comparison, with ... for a merge base and .. otherwise.
 * For origin = github.com/o/r and HEAD on feat tracking origin/feat:
-*   origin/main...HEAD → branches:["o/r:main","o/r:feat",true]
-*   origin/main..HEAD  → branches:["o/r:main","o/r:feat",false]
+*   origin/main...HEAD → range:o/r:main...o/r:feat
+*   origin/main..HEAD  → range:o/r:main..o/r:feat
 * The matching explicit PR uses the first key too. If feat tracks a fork,
 * its identity becomes e.g. "contributor/r:feat", keeping forks distinct.
 *
 * Without a GitHub upstream, branches use full refs:
-*   main...feat → branches:["refs/heads/main","refs/heads/feat",true]
+*   main...feat → range:refs/heads/main...refs/heads/feat
 * Non-branch endpoints use their resolved hash or literal "worktree":
-*   main..worktree → branches:["refs/heads/main","worktree",false]
-* If neither endpoint is a branch, the key is revspec:<oldSha>..<newSha>.
+*   main..worktree → range:refs/heads/main..worktree
+*   <C>..<E>       → range:<C hash>..<E hash>
 * Hash placeholders denote full resolved hashes, with oldSha already adjusted
-* for mergeBase. The working command bypasses this helper and uses "working".
+* for the merge base. The working command bypasses this helper and uses
+* "working"; a single commit uses "commit:<hash>".
 */
 async function commentKey(repo, comparison, oldSha, newSha) {
 	const remotes = await repo.remotes();
@@ -18395,14 +18542,10 @@ async function commentKey(repo, comparison, oldSha, newSha) {
 		return repo.branchRef(rev);
 	};
 	const [old, next] = await Promise.all([identity(comparison.old), identity(comparison.new)]);
-	return old || next ? branchKey(old ?? oldSha, next ?? newSha, comparison.mergeBase) : `revspec:${oldSha}..${newSha}`;
+	return rangeKey(old ?? oldSha, next ?? newSha, comparison.base === "merge-base");
 }
-function branchKey(old, next, mergeBase) {
-	return `branches:${JSON.stringify([
-		old,
-		next,
-		mergeBase
-	])}`;
+function rangeKey(old, next, mergeBase) {
+	return `range:${old}${mergeBase ? "..." : ".."}${next}`;
 }
 /**
 * A GitHub pull request, as GitHub shows it: merge-base(base tip, head) vs head.
@@ -18421,16 +18564,16 @@ async function resolvePr(req, repo, github) {
 	await resolveComparison(repo, {
 		old: base,
 		new: head,
-		mergeBase: true
+		base: "merge-base"
 	});
 	return {
 		prUrl: pr.url,
 		mode: {
 			old: base,
 			new: head,
-			mergeBase: true,
+			base: "merge-base",
 			live: "none",
-			commentKey: branchKey(`${pr.repository.toLowerCase()}:${pr.baseRefName}`, `${pr.headRepository?.toLowerCase() ?? `deleted:${pr.url}`}:${pr.headRefName}`, true)
+			commentKey: rangeKey(`${pr.repository.toLowerCase()}:${pr.baseRefName}`, `${pr.headRepository?.toLowerCase() ?? `deleted:${pr.url}`}:${pr.headRefName}`, true)
 		}
 	};
 }
@@ -18579,7 +18722,12 @@ var Snapshotter = class {
 	}
 	async compute(version) {
 		const [{ oldSha, newSha }, headSha] = await Promise.all([resolveComparison(this.repo, this.mode), this.repo.resolve("HEAD").catch(() => "")]);
-		const [tracked, changed] = await Promise.all([newSha === "worktree" ? Promise.all([this.repo.lsFiles(), this.repo.untracked()]).then((lists) => lists.flat().filter((p) => !p.endsWith("/"))) : this.repo.lsTree(newSha), this.repo.numstat(oldSha, newSha)]);
+		const [tracked, changed, commit, commits] = await Promise.all([
+			newSha === "worktree" ? Promise.all([this.repo.lsFiles(), this.repo.untracked()]).then((lists) => lists.flat().filter((p) => !p.endsWith("/"))) : this.repo.lsTree(newSha),
+			this.repo.numstat(oldSha, newSha),
+			this.mode.base === "parent" ? this.reviewedCommit(newSha) : null,
+			this.rangeCommits(oldSha, newSha, headSha)
+		]);
 		await this.fillGenerated(changed, newSha);
 		const tree = new Set(tracked);
 		for (const f of changed) {
@@ -18596,11 +18744,36 @@ var Snapshotter = class {
 			headSha,
 			context: this.context,
 			changed,
-			tree: [...tree].sort()
+			tree: [...tree].sort(),
+			commit,
+			commits
 		};
 		for (const f of changed.slice(0, PREWARM)) this.patchFor(snap, f).catch(() => {});
 		return snap;
 	}
+	async reviewedCommit(sha) {
+		const [info, neighbours] = await Promise.all([this.repo.commitInfo(sha), this.repo.commitNeighbours(sha)]);
+		return info && {
+			...info,
+			...neighbours
+		};
+	}
+	async rangeCommits(oldSha, newSha, headSha) {
+		if (this.mode.within) {
+			const range = await resolveComparison(this.repo, this.mode.within);
+			return this.spanned(range.oldSha, range.newSha, headSha);
+		}
+		if (this.mode.base === "parent") return this.repo.rangeCommits(`${newSha}^!`, 250);
+		return this.spanned(oldSha, newSha, headSha);
+	}
+	spanned(oldSha, newSha, headSha) {
+		const [from, to] = [oldSha, newSha].map((sha) => sha === "worktree" ? headSha : sha);
+		if (!from || !to || from === to) return Promise.resolve({
+			list: [],
+			total: 0
+		});
+		return this.repo.rangeCommits(`${from}..${to}`, 250);
+	}
 	/**
 	* Sets `generated` on each non-binary changed file. A `linguist-generated`
 	* gitattribute on the new side decides outright, as on GitHub; otherwise a
@@ -18771,7 +18944,7 @@ var Session = class {
 	}
 	/** Switch modes at runtime. Broadcasts a snapshot bump on success. */
 	async switchMode(req) {
-		const snap = await this.run(async () => this.activate(await resolveReview(req, this.repo, this.opts.github)));
+		const snap = await this.run(async () => this.activate(req.kind === "focus" ? await this.focus(req.commit) : await resolveReview(req, this.repo, this.opts.github)));
 		this.hub.broadcast({
 			type: "snapshot",
 			version: snap.version
@@ -18779,6 +18952,33 @@ var Session = class {
 		return snap;
 	}
 	/**
+	* Focuses `commit`, by hash or short hash, of the active range's listed commits, or with null returns to
+	* the range. A focused commit keeps its own comments, as when entered alone, and the range's PR identity.
+	*/
+	async focus(commit) {
+		const a = this.require();
+		const { within, ...self } = a.mode;
+		if (!within && self.base === "parent") throw new RevspecError("a single commit has no commits to focus");
+		const range = within ?? self;
+		if (commit === null) return {
+			mode: range,
+			prUrl: a.prUrl
+		};
+		const sha = (await a.snapshotter.current()).commits.list.find((c) => c.sha === commit || c.short === commit)?.sha;
+		if (!sha) throw new RevspecError(`not a listed commit of ${comparisonLabel(range)}: ${commit}`);
+		return {
+			prUrl: a.prUrl,
+			mode: {
+				old: sha,
+				new: sha,
+				base: "parent",
+				live: range.live === "none" ? "none" : "refs",
+				commentKey: `commit:${sha}`,
+				within: range
+			}
+		};
+	}
+	/**
 	* Runs `fn` after every earlier mutation settled. The only way to touch
 	* `active`, `version` or `opts.context`.
 	*/
@@ -22895,6 +23095,7 @@ Shorthands (in place of <revs>):
   working                  same as HEAD..worktree: uncommitted changes, staged and untracked included
   pr [number|url]          a GitHub pull request: its base...head, fetched if needed
                            (without an argument: the pull request for this branch)
+  show [rev]               same as <rev>^!: one commit against its first parent, pinned (default: HEAD)
 
 Revisions follow git diff, except that a lone one compares from the merge base:
   diffle main              same as main...HEAD: what this branch added since it left main
@@ -22902,6 +23103,7 @@ Revisions follow git diff, except that a lone one compares from the merge base:
   diffle main..feat        main vs feat
   diffle main...feat       what feat added since it left main
   diffle main..worktree    main vs the uncommitted tree ("worktree" works on either side)
+  diffle a1b2c3d^!         the commit a1b2c3d alone, like git show
 
 Without revisions, diffle compares HEAD..worktree.
 
@@ -22914,6 +23116,10 @@ Ctrl+C always stops it.`).action(async (revs, _o, cmd) => {
 	}, cmd.optsWithGlobals());
 });
 program.command("working", { hidden: true }).summary("same as HEAD..worktree").description("Same as `diffle HEAD..worktree`: uncommitted changes, staged and untracked files included.").action(async (_o, cmd) => run({ kind: "working" }, cmd.optsWithGlobals()));
+program.command("show", { hidden: true }).argument("[rev]", "the commit to review", "HEAD").summary("one commit").description("Same as `diffle <rev>^!`: one commit against its first parent, as git show shows it.").action(async (rev, _o, cmd) => run({
+	kind: "revspec",
+	args: [`${rev}^!`]
+}, cmd.optsWithGlobals()));
 program.command("pr", { hidden: true }).argument("[pr]", "pull request number or url; default: the pull request for this branch").summary("a GitHub pull request").description("A GitHub pull request, as GitHub shows it: merge-base(base, head) vs head.").action(async (pr, _o, cmd) => run({
 	kind: "pr",
 	pr

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moritzwilksch/diffle",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Local git diff reviewer in the browser with line comments exported as agent prompts",
   "keywords": [
     "agent",
@@ -9,7 +9,7 @@
     "diff",
     "git"
   ],
-  "homepage": "https://github.com/moritzwilksch/diffle#readme",
+  "homepage": "https://diffle.app",
   "bugs": {
     "url": "https://github.com/moritzwilksch/diffle/issues"
   },
@@ -25,6 +25,7 @@
   "files": [
     "bin",
     "dist",
+    "!dist/sea",
     "THIRD_PARTY_NOTICES.md"
   ],
   "type": "module",
@@ -37,6 +38,7 @@
     "build": "npm run build:client && npm run build:server",
     "build:client": "vite build",
     "build:server": "tsdown",
+    "build:sea": "npm run build && node scripts/build-sea.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit && tsc -p tsconfig.e2e.json --noEmit",
     "lint": "oxlint",
     "format": "oxfmt",
@@ -45,7 +47,7 @@
     "test:e2e": "playwright test",
     "test:e2e:install": "playwright install chromium",
     "test:e2e:install-deps": "playwright install-deps chromium",
-    "screenshot": "tsx",
+    "screenshot": "tsx scripts/screenshot.ts",
     "test:e2e:docker": "node scripts/e2e-docker.mjs",
     "test:e2e:docker:update": "node scripts/e2e-docker.mjs --update-snapshots",
     "test:e2e:report": "playwright show-report playwright-report",