@howaboua/pi-pet 0.1.1

package/authoring/references/import-existing-pet.md

@@ -0,0 +1,47 @@
+# Import an existing pet
+
+Use this route when the user already has a pet package from Codex, ChatGPT, or another Hatch Pet run. Import the package as data; do not rehatch compatible artwork.
+
+## Find and classify the source
+
+1. Prefer a path supplied by the user. Codex custom pets normally live at `${CODEX_HOME:-$HOME/.codex}/pets/<pet-id>/`. A source on another user-authorized host may be copied through that host's ordinary file transport.
+2. Inspect the source before copying it. A directly compatible package contains `pet.json` and the relative PNG/WebP named by `spritesheetPath`.
+3. Direct import requires `spriteVersionNumber: 2` and a `1536×2288` atlas. An 8×9 or `1536×1872` v1 atlas needs completion through `../hatch/HATCH-GUIDE.md`; an ordinary generated character image is a hatch reference, not a pet package.
+
+## Recover Codex built-in assets
+
+Codex also caches its built-in pets without custom manifests:
+
+- TUI assets normally appear under `${CODEX_HOME:-$HOME/.codex}/cache/tui-pets/v1/assets/` as `<pet>-spritesheet-*.webp`. These are legacy `1536×1872` atlases and need the two look-direction rows completed through the hatch guide before Pi Pet can load them.
+- Desktop assets live inside the installed or cached Codex application's `content/webview/assets/` directory as `<pet>-spritesheet-<version>-<hash>.webp`. Linux native builds commonly expose them under `~/.cache/codex-desktop-linux-native-build/codex-app/content/webview/assets/` or a `~/.cache/codex-update-manager/workspaces/<version>/codex-app/content/webview/assets/` workspace. Other roots vary by platform and install method; search the user's Codex application and cache directories for `*-spritesheet-*.webp`. Current desktop atlases may already be v2 `1536×2288` assets.
+
+For a v2 desktop asset, copy the selected atlas into staging as `spritesheet.webp` and create the minimal `pet.json` from `pet-format.md`, using the filename's pet name as a starting point for the id and display name. Validate dimensions and inspect the rebuilt animations rather than trusting the filename version. Record the Codex application asset and original filename in `PET.md`; redistribution terms remain uncertain, but that uncertainty does not block importing it into the user's local pet library.
+
+## Stage the package
+
+Resolve the package root from this guide's installed path and the durable destination as `<pi-agent-directory>/pi-pet/pets/<pet-id>`. The destination directory name and `pet.json` id must match.
+
+1. Create a fresh staging root under `<pi-agent-directory>/pi-pet/runs/<pet-id>/` with the package in a child directory named exactly `<pet-id>`; validation requires that basename to match the manifest id.
+2. Copy `pet.json`, its referenced spritesheet, and any supplied `PET.md` or `validation.json` with ordinary filesystem commands. If a supplied `pet.pi.json` references extra local PNG/WebP assets, copy those too; leave unrelated files behind.
+3. If `PET.md` is absent, create a short one recording the display name, description, `source_format: codex-v2`, known provenance, included standard actions, and any redistribution uncertainty. Do not invent ownership or licensing.
+4. From the installed Pi Pet package root, validate the staged directory:
+
+```bash
+npm run pet:validate -- <absolute-staged-pet-directory>
+```
+
+Fix or reroute any contract failure; never edit dimensions or version metadata merely to silence validation.
+
+## Place and load it
+
+- If the durable destination is absent, move the validated `<pet-id>` staging directory into place and remove its empty staging root.
+- If an existing durable or bundled pet has the same id and the manifest plus assets are byte-identical, keep the existing copy and do not duplicate it.
+- If the same id contains different data, show the conflict and ask before replacement unless the user already requested replacement. Validate the replacement before removing the old directory; leave no backup after an explicit replacement.
+
+Then rebuild from the installed package root:
+
+```bash
+npm run pet:rebuild -- <pet-id>
+```
+
+The rebuild validates again, generates the durable miniapp, and selects the imported pet globally. A repository-level selection still wins. Tell the user to run `/reload`; slash commands are user actions. After reload, inspect the pet at actual scale and exercise one known action with `pet_show`.

package/authoring/references/pet-format.md

@@ -0,0 +1,88 @@
+# Pi Pet package format
+
+## Base package
+
+Every package currently starts from a Codex-compatible v2 atlas:
+
+```text
+pets/<id>/
+├── PET.md
+├── pet.json
+├── spritesheet.webp
+├── pet.pi.json          # optional extension layer
+└── validation.json      # optional retained authoring evidence
+```
+
+`pet.json`:
+
+```json
+{
+  "id": "pet-id",
+  "displayName": "Pet Name",
+  "description": "One short sentence.",
+  "spriteVersionNumber": 2,
+  "spritesheetPath": "spritesheet.webp"
+}
+```
+
+The base atlas is PNG or WebP, exactly `1536x2288`: 8 columns by 11 rows, with `192x208` cells. Rows 0–8 are the standard actions; rows 9–10 are sixteen clockwise pointer-look frames. Transparent unused cells and clean transparent RGB remain part of the visual contract.
+
+## Pi extension layer
+
+`pet.pi.json` adds or replaces data-driven actions without changing the Codex manifest:
+
+```json
+{
+  "schemaVersion": 1,
+  "defaultAction": "idle",
+  "aliases": {
+    "party": "celebrate"
+  },
+  "actions": {
+    "celebrate": {
+      "asset": "celebrate.webp",
+      "frames": [
+        { "x": 0, "y": 0, "width": 192, "height": 208, "durationMs": 120 },
+        { "x": 192, "y": 0, "width": 192, "height": 208, "durationMs": 260 }
+      ],
+      "loop": false,
+      "next": "idle"
+    }
+  }
+}
+```
+
+Rules:
+
+- `schemaVersion` is exactly `1`.
+- Unknown fields fail validation.
+- Action names are 1–64 lowercase characters: letters, numbers, `.`, `_`, `-`.
+- `asset` is a relative PNG/WebP path inside the package.
+- Each action has 1–64 frames.
+- Coordinates are non-negative integers and every frame stays within the decoded image.
+- Width and height are 1–4096; a decoded asset may contain at most 16 million pixels.
+- `durationMs` is an integer from 16–60,000.
+- `loop` is a boolean.
+- Optional `next` names an action that exists after the overlay is merged.
+- Optional aliases map alternate names directly to real actions. Aliases are accepted by `pet_show` but are not separate animations or shown as picker actions.
+- Assets are regular files up to 16 MiB. Escaping symlinks are rejected.
+
+## Standard rows
+
+| Row | Action | Frames | Durations (ms) |
+|---:|---|---:|---|
+| 0 | idle | 6 | 280, 110, 110, 140, 140, 320 |
+| 1 | running-right | 8 | 120 × 7, 220 |
+| 2 | running-left | 8 | 120 × 7, 220 |
+| 3 | waving | 4 | 140 × 3, 280 |
+| 4 | jumping | 5 | 140 × 4, 280 |
+| 5 | failed | 8 | 140 × 7, 240 |
+| 6 | waiting | 6 | 150 × 5, 260 |
+| 7 | running | 6 | 120 × 5, 220 |
+| 8 | review | 6 | 150 × 5, 280 |
+
+`running` means active processing, not locomotion. `waiting` means Pi needs user input. `review` means output is ready to inspect.
+
+## PET.md
+
+Use frontmatter for stable identity metadata and prose for personality, action semantics, and provenance. `PET.md` guides humans and agents; it is not parsed by the renderer and cannot override `pet.json` or `pet.pi.json`.

package/changelog.ts

@@ -0,0 +1,327 @@
+// Generated extension packages copy this file during changelog:extensions.
+
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	DynamicBorder,
+	type ExtensionAPI,
+	getAgentDir,
+	getMarkdownTheme,
+} from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+
+const ENTRY_TYPE = "@howaboua/pi-stuff/changelog";
+const REGISTRATION_CHANNEL = "@howaboua/pi-stuff/changelog/register/v1";
+const STATE_FILENAME = "howaboua-pi-stuff-changelog.json";
+const SUPPRESS_KEY = "suppress";
+const LOCK_STALE_MS = 30_000;
+const LOCK_TIMEOUT_MS = 2_000;
+
+interface PackageMetadata {
+	name: string;
+	version: string;
+}
+
+interface PackageRegistration extends PackageMetadata {
+	changelogPath: string;
+}
+
+interface RegistrationEvent {
+	accept: () => void;
+	registration: PackageRegistration;
+}
+
+interface ChangelogEntry {
+	content: string;
+	version: string;
+}
+
+interface ChangelogEntryData {
+	markdown: string;
+}
+
+type ChangelogState = Record<string, boolean | string>;
+
+function packageRegistration(): PackageRegistration {
+	const packageDirectory = fileURLToPath(new URL(".", import.meta.url));
+	const metadata = JSON.parse(
+		readFileSync(join(packageDirectory, "package.json"), "utf8"),
+	) as Partial<PackageMetadata>;
+	if (typeof metadata.name !== "string" || typeof metadata.version !== "string")
+		throw new Error(`Invalid package metadata in ${packageDirectory}`);
+	return {
+		name: metadata.name,
+		version: metadata.version,
+		changelogPath: join(packageDirectory, "CHANGELOG.md"),
+	};
+}
+
+function isRegistrationEvent(value: unknown): value is RegistrationEvent {
+	if (!value || typeof value !== "object") return false;
+	const event = value as Partial<RegistrationEvent>;
+	return (
+		typeof event.accept === "function" &&
+		typeof event.registration?.name === "string" &&
+		typeof event.registration.version === "string" &&
+		typeof event.registration.changelogPath === "string"
+	);
+}
+
+function parseChangelog(markdown: string): ChangelogEntry[] {
+	const entries: ChangelogEntry[] = [];
+	let currentLines: string[] = [];
+	let currentVersion: string | undefined;
+
+	for (const line of markdown.split("\n")) {
+		const version = line.match(/^##\s+\[?(\d+\.\d+\.\d+)\]?(?:\s.*)?$/)?.[1];
+		if (version) {
+			if (currentVersion)
+				entries.push({
+					content: currentLines.join("\n").trim(),
+					version: currentVersion,
+				});
+			currentVersion = version;
+			currentLines = [line];
+		} else if (currentVersion) {
+			currentLines.push(line);
+		}
+	}
+
+	if (currentVersion)
+		entries.push({
+			content: currentLines.join("\n").trim(),
+			version: currentVersion,
+		});
+	return entries;
+}
+
+function compareVersions(left: string, right: string): number {
+	const leftParts = left.split(".").map(Number);
+	const rightParts = right.split(".").map(Number);
+	for (let index = 0; index < 3; index++) {
+		const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+
+function isStableVersion(version: string): boolean {
+	return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+function statePath(): string {
+	return join(getAgentDir(), STATE_FILENAME);
+}
+
+async function readState(path: string): Promise<ChangelogState> {
+	let text: string;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+		throw error;
+	}
+	const parsed = JSON.parse(text) as unknown;
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+		throw new Error(`${path} must contain a JSON object`);
+	for (const [name, value] of Object.entries(parsed)) {
+		if (name === SUPPRESS_KEY) {
+			if (typeof value !== "boolean")
+				throw new Error(`${path} ${SUPPRESS_KEY} must be a boolean`);
+		} else if (typeof value !== "string") {
+			throw new Error(`${path} version for ${name} must be a string`);
+		}
+	}
+	return parsed as ChangelogState;
+}
+
+async function acquireLock(path: string): Promise<() => Promise<void>> {
+	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	while (true) {
+		try {
+			await mkdir(path);
+			return () => rm(path, { force: true, recursive: true });
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			const info = await stat(path).catch(() => undefined);
+			if (info && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+				await rm(path, { force: true, recursive: true });
+				continue;
+			}
+			if (Date.now() >= deadline)
+				throw new Error(`Timed out waiting for ${path}`);
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+	}
+}
+
+async function writeState(path: string, state: ChangelogState): Promise<void> {
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		const ordered = Object.fromEntries(
+			Object.entries(state).sort(([left], [right]) =>
+				left.localeCompare(right),
+			),
+		);
+		await writeFile(temporaryPath, `${JSON.stringify(ordered, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		await rename(temporaryPath, path);
+	} catch (error) {
+		await rm(temporaryPath, { force: true });
+		throw error;
+	}
+}
+
+function packageMarkdown(
+	registration: PackageRegistration,
+	entries: ChangelogEntry[],
+): string {
+	return [
+		`## ${registration.name}`,
+		...entries.map((entry) => entry.content.replace(/^##\s+/, "### ")),
+	].join("\n\n");
+}
+
+async function claimUpdates(
+	registrations: Iterable<PackageRegistration>,
+): Promise<{ errors: string[]; markdown?: string }> {
+	const stableRegistrations = [...registrations]
+		.filter((registration) => isStableVersion(registration.version))
+		.sort((left, right) => left.name.localeCompare(right.name));
+	if (stableRegistrations.length === 0) return { errors: [] };
+	const path = statePath();
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const release = await acquireLock(`${path}.lock`);
+	try {
+		const state = await readState(path);
+		const errors: string[] = [];
+		const sections: string[] = [];
+		let changed = false;
+		if (state[SUPPRESS_KEY] === true) {
+			for (const registration of stableRegistrations) {
+				const seenVersion = state[registration.name];
+				if (
+					typeof seenVersion !== "string" ||
+					compareVersions(registration.version, seenVersion) > 0
+				) {
+					state[registration.name] = registration.version;
+					changed = true;
+				}
+			}
+			if (changed) await writeState(path, state);
+			return { errors };
+		}
+		for (const registration of stableRegistrations) {
+			const seenVersion = state[registration.name];
+			if (
+				typeof seenVersion === "string" &&
+				compareVersions(registration.version, seenVersion) <= 0
+			)
+				continue;
+			try {
+				const entries = parseChangelog(
+					await readFile(registration.changelogPath, "utf8"),
+				).filter(
+					(entry) =>
+						compareVersions(entry.version, registration.version) <= 0 &&
+						(typeof seenVersion === "string"
+							? compareVersions(entry.version, seenVersion) > 0
+							: entry.version === registration.version),
+				);
+				if (entries.length === 0) {
+					errors.push(
+						`No ${registration.version} changelog entry found for ${registration.name}`,
+					);
+					continue;
+				}
+				sections.push(packageMarkdown(registration, entries));
+				state[registration.name] = registration.version;
+				changed = true;
+			} catch (error) {
+				errors.push(
+					`Could not read the ${registration.name} changelog: ${error instanceof Error ? error.message : String(error)}`,
+				);
+			}
+		}
+		if (changed) await writeState(path, state);
+		return {
+			errors,
+			...(sections.length > 0 ? { markdown: sections.join("\n\n") } : {}),
+		};
+	} finally {
+		await release();
+	}
+}
+
+function registerCoordinator(
+	pi: ExtensionAPI,
+	registration: PackageRegistration,
+): void {
+	let accepted = false;
+	pi.events.emit(REGISTRATION_CHANNEL, {
+		registration,
+		accept: () => {
+			accepted = true;
+		},
+	} satisfies RegistrationEvent);
+	if (accepted) return;
+
+	const registrations = new Map([[registration.name, registration]]);
+	pi.events.on(REGISTRATION_CHANNEL, (value) => {
+		if (!isRegistrationEvent(value)) return;
+		registrations.set(value.registration.name, value.registration);
+		value.accept();
+	});
+	pi.registerEntryRenderer<ChangelogEntryData>(
+		ENTRY_TYPE,
+		(entry, _options, theme) => {
+			if (!entry.data) return undefined;
+			const container = new Container();
+			container.addChild(new DynamicBorder());
+			container.addChild(
+				new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(
+				new Markdown(entry.data.markdown.trim(), 1, 0, getMarkdownTheme()),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(new DynamicBorder());
+			return container;
+		},
+	);
+	pi.on("session_start", async (event, ctx) => {
+		if (event.reason === "reload" || ctx.mode !== "tui") return;
+		if (
+			ctx.sessionManager
+				.getEntries()
+				.some((entry) =>
+					["branch_summary", "compaction", "message"].includes(entry.type),
+				)
+		)
+			return;
+		try {
+			const update = await claimUpdates(registrations.values());
+			if (update.markdown)
+				pi.appendEntry<ChangelogEntryData>(ENTRY_TYPE, {
+					markdown: update.markdown,
+				});
+			for (const error of update.errors) ctx.ui.notify(error, "warning");
+		} catch (error) {
+			ctx.ui.notify(
+				`Could not update Howaboua changelog state: ${error instanceof Error ? error.message : String(error)}`,
+				"warning",
+			);
+		}
+	});
+}
+
+export default function howabouaPackageChangelog(pi: ExtensionAPI): void {
+	registerCoordinator(pi, packageRegistration());
+}

package/deploy/pi-pet-hyprland.conf

@@ -0,0 +1,10 @@
+# Keep the transparent pet borderless, fully opaque where painted, and above workspaces.
+windowrule = tag -default-opacity, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = opacity 1 1, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = float on, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = pin on, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = border_size 0, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = no_shadow on, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = no_blur on, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = no_initial_focus on, match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$
+windowrule = move (monitor_w-window_w-40) (monitor_h-window_h-40), match:class ^electron$, match:title ^(Pi Pet|Clawa · Pi Pet)$

package/desktop/build.mjs

@@ -0,0 +1,194 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream, constants as fsConstants } from "node:fs";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { get } from "node:https";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+const desktop = dirname(fileURLToPath(import.meta.url));
+const source = join(desktop, "..", "src", "desktop");
+const output = join(desktop, "dist", "app");
+const esmFiles = ["attention", "bridge", "config", "cursor-provider", "main"];
+const cjsFiles = ["bridge", "preload"];
+const require = createRequire(join(desktop, "package.json"));
+const MAX_ARCHIVE_BYTES = 1024 * 1024 * 1024;
+const LEADING_V_PATTERN = /^v/;
+
+function electronExecutable(platform = process.platform) {
+  if (platform === "win32") return "electron.exe";
+  if (platform === "darwin") return join("Electron.app", "Contents", "MacOS", "Electron");
+  return "electron";
+}
+
+async function ensureElectronRuntime() {
+  const electronRoot = dirname(require.resolve("electron/package.json"));
+  const manifest = JSON.parse(await readFile(join(electronRoot, "package.json"), "utf8"));
+  const dist = join(electronRoot, "dist");
+  const executable = electronExecutable();
+  try {
+    const installedVersion = (await readFile(join(dist, "version"), "utf8")).trim().replace(LEADING_V_PATTERN, "");
+    await access(join(dist, executable), process.platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK);
+    if (installedVersion === manifest.version) return;
+  } catch {
+    // Repair a missing or partial runtime below.
+  }
+  const artifactArch = process.arch === "arm" ? "armv7l" : process.arch;
+  const artifact = `electron-v${manifest.version}-${process.platform}-${artifactArch}.zip`;
+  const expectedChecksum = require(join(electronRoot, "checksums.json"))[artifact];
+  if (typeof expectedChecksum !== "string")
+    throw new Error(`Electron has no runtime for ${process.platform}-${process.arch}.`);
+  const cache = process.env["electron_config_cache"] || electronCacheDirectory();
+  await mkdir(cache, { recursive: true });
+  const archive = join(cache, artifact);
+  if ((await fileChecksum(archive)) !== expectedChecksum) {
+    await rm(archive, { force: true });
+    await downloadArchive(artifact, archive, expectedChecksum, manifest.version);
+  }
+  await rm(dist, { recursive: true, force: true });
+  await mkdir(dist, { recursive: true });
+  await extractArchive(archive, dist);
+  await writeFile(join(electronRoot, "path.txt"), executable);
+  await access(join(dist, executable), process.platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK);
+}
+
+function extractArchive(archive, destination) {
+  const command = process.platform === "win32" ? "powershell.exe" : "unzip";
+  const args =
+    process.platform === "win32"
+      ? [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force",
+          archive,
+          destination,
+        ]
+      : ["-q", archive, "-d", destination];
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, { stdio: "ignore", windowsHide: true });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0) resolvePromise();
+      else reject(new Error(`Electron archive extraction exited ${code ?? "without status"}.`));
+    });
+  });
+}
+
+function electronCacheDirectory() {
+  if (process.platform === "win32") {
+    return join(process.env["LOCALAPPDATA"] || join(homedir(), "AppData", "Local"), "electron", "Cache");
+  }
+  if (process.platform === "darwin") return join(homedir(), "Library", "Caches", "electron");
+  return join(process.env["XDG_CACHE_HOME"] || join(homedir(), ".cache"), "electron");
+}
+
+async function fileChecksum(path) {
+  try {
+    const checksum = createHash("sha256");
+    for await (const chunk of createReadStream(path)) checksum.update(chunk);
+    return checksum.digest("hex");
+  } catch {
+    return undefined;
+  }
+}
+
+function downloadResponse(url, path, expectedChecksum, redirects = 0) {
+  return new Promise((resolvePromise, reject) => {
+    const request = get(url, { headers: { "user-agent": "pi-pet-desktop-build" } }, (response) => {
+      const location = response.headers.location;
+      if (location && response.statusCode >= 300 && response.statusCode < 400) {
+        response.resume();
+        if (redirects >= 5) reject(new Error("Electron download redirected too many times."));
+        else resolvePromise(downloadResponse(new URL(location, url), path, expectedChecksum, redirects + 1));
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`Electron download failed: HTTP ${response.statusCode ?? "unknown"}.`));
+        return;
+      }
+      const checksum = createHash("sha256");
+      let received = 0;
+      const meter = new Transform({
+        transform(chunk, _encoding, callback) {
+          received += chunk.length;
+          if (received > MAX_ARCHIVE_BYTES) callback(new Error("Electron archive is unexpectedly large."));
+          else {
+            checksum.update(chunk);
+            callback(null, chunk);
+          }
+        },
+      });
+      pipeline(response, meter, createWriteStream(path, { mode: 0o600 }))
+        .then(() => {
+          if (checksum.digest("hex") !== expectedChecksum) throw new Error("Electron archive checksum does not match.");
+          resolvePromise();
+        })
+        .catch(reject);
+    });
+    request.once("error", reject);
+  });
+}
+
+async function downloadArchive(artifact, path, expectedChecksum, version) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  await rm(temporary, { force: true });
+  try {
+    await downloadResponse(
+      new URL(`https://github.com/electron/electron/releases/download/v${version}/${artifact}`),
+      temporary,
+      expectedChecksum,
+    );
+    await rename(temporary, path);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
+  }
+}
+
+function transpile(code, file, module) {
+  const result = ts.transpileModule(code, {
+    fileName: file,
+    compilerOptions: {
+      target: ts.ScriptTarget.ES2024,
+      module,
+      rewriteRelativeImportExtensions: true,
+      verbatimModuleSyntax: true,
+    },
+    reportDiagnostics: true,
+  });
+  const errors = (result.diagnostics || []).filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+  if (errors.length > 0) {
+    throw new Error(
+      errors.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")).join("\n"),
+    );
+  }
+  return result.outputText;
+}
+
+await ensureElectronRuntime();
+await rm(join(desktop, "dist"), { recursive: true, force: true });
+await mkdir(output, { recursive: true });
+
+for (const name of esmFiles) {
+  const path = join(source, `${name}.ts`);
+  await writeFile(join(output, `${name}.js`), transpile(await readFile(path, "utf8"), path, ts.ModuleKind.ESNext));
+}
+for (const name of cjsFiles) {
+  const path = join(source, `${name}.ts`);
+  const compiled = transpile(await readFile(path, "utf8"), path, ts.ModuleKind.CommonJS).replaceAll(
+    /require\("(\.\/.+)\.js"\)/g,
+    'require("$1.cjs")',
+  );
+  await writeFile(join(output, `${name}.cjs`), compiled);
+}
+await writeFile(
+  join(output, "package.json"),
+  `${JSON.stringify({ name: "pi-pet-remote-desktop", private: true, type: "module", main: "main.js" }, null, 2)}\n`,
+);