@hitch42/applet 0.1.1-beta.1 → 0.1.1-beta.10

package/dist/build-Bh_S5BUv.js

@@ -0,0 +1,2 @@
+import { i as runBuild } from "./build-CEfFoIZZ.js";
+export { runBuild };

package/dist/{build-Rk3xDZV7.js → build-CEfFoIZZ.js}

@@ -1,7 +1,8 @@
-import { r as prepareAppletProject } from "./project-CxN-Dtc7.js";
+import { i as prepareAppletProjects, r as prepareAppletProject } from "./project-BRZGd6xq.js";
 import { rm } from "node:fs/promises";
 import { resolve } from "node:path";
 import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
 //#region src/build.ts
 function isMissingFile(error) {
 	return error instanceof Error && "code" in error && error.code === "ENOENT";
@@ -11,7 +12,8 @@ async function runPnpm(args, cwd) {
 		let finished = false;
 		const child = spawn("pnpm", args, {
 			cwd,
-			stdio: "inherit"
+			stdio: "inherit",
+			shell: process.platform === "win32"
 		});
 		child.once("error", (error) => {
 			finished = true;
@@ -28,14 +30,19 @@ async function runPnpm(args, cwd) {
 		});
 	});
 }
-async function buildApplet(changesetId, outDir = ".hitch/dist") {
-	const appletRoot = process.cwd();
-	const { workspaceRoot } = await prepareAppletProject(appletRoot);
+async function buildApplet(appletRoot, outDir = ".hitch/dist") {
+	await runPnpm(["install"], await prepareAppletProject(appletRoot));
+	await buildPreparedApplet(appletRoot, outDir);
+}
+async function prepareWorkspaceBuild(workspaceRoot, appletRoots) {
+	await prepareAppletProjects(workspaceRoot, appletRoots);
+	await runPnpm(["install"], workspaceRoot);
+}
+async function buildPreparedApplet(appletRoot, outDir = ".hitch/dist", logPrefix = "") {
 	await rm(resolve(appletRoot, ".hitch"), {
 		force: true,
 		recursive: true
 	});
-	await runPnpm(["install"], workspaceRoot);
 	await new Promise((resolveBuild, rejectBuild) => {
 		let finished = false;
 		const child = spawn("pnpm", [
@@ -46,12 +53,21 @@ async function buildApplet(changesetId, outDir = ".hitch/dist") {
 			outDir
 		], {
 			cwd: appletRoot,
-			stdio: "inherit",
-			env: {
-				...process.env,
-				...changesetId === void 0 ? {} : { HITCH_CHANGESET_ID: changesetId }
-			}
+			stdio: logPrefix === "" ? "inherit" : [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			shell: process.platform === "win32"
 		});
+		if (child.stdout) createInterface({
+			input: child.stdout,
+			crlfDelay: Infinity
+		}).on("line", (line) => console.log(`${logPrefix}${line}`));
+		if (child.stderr) createInterface({
+			input: child.stderr,
+			crlfDelay: Infinity
+		}).on("line", (line) => console.error(`${logPrefix}${line}`));
 		child.once("error", (error) => {
 			finished = true;
 			rejectBuild(isMissingFile(error) ? /* @__PURE__ */ new Error("pnpm was not found. Install pnpm, then run applet build again.") : error);
@@ -67,8 +83,8 @@ async function buildApplet(changesetId, outDir = ".hitch/dist") {
 		});
 	});
 }
-async function runBuild(options = {}) {
-	await buildApplet(options.changesetId);
+async function runBuild() {
+	await buildApplet(process.cwd());
 }
 //#endregion
-export { runBuild as n, buildApplet as t };
+export { runBuild as i, buildPreparedApplet as n, prepareWorkspaceBuild as r, buildApplet as t };

package/dist/ci-BKw14X2h.js

@@ -0,0 +1,69 @@
+import { f as resolveInstanceUrl } from "./workspace-D0dnnlxL.js";
+//#region src/ci.ts
+function githubActionsContext() {
+	const env = process.env;
+	if (env.GITHUB_ACTIONS !== "true" || env.HITCH_API_KEY) return void 0;
+	const requestUrl = env.ACTIONS_ID_TOKEN_REQUEST_URL;
+	const requestToken = env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+	if (!requestUrl || !requestToken) throw new Error("GitHub Actions did not provide an OIDC token. Grant the job the id-token: write permission, or set HITCH_API_KEY.");
+	return {
+		requestUrl,
+		requestToken
+	};
+}
+async function hitchResponseError(response, summary) {
+	let details = "";
+	try {
+		const body = await response.json();
+		if (body !== null && typeof body === "object") details = ["code" in body && typeof body.code === "string" ? body.code : void 0, "message" in body && typeof body.message === "string" ? body.message : void 0].filter((value) => value !== void 0).join(": ");
+	} catch {
+		details = "";
+	}
+	return /* @__PURE__ */ new Error(`${summary} (${response.status})${details ? `: ${details}` : ""}.`);
+}
+async function githubActionsToken(context, instanceUrl, fetcher) {
+	const url = new URL(context.requestUrl);
+	url.searchParams.set("audience", new URL(instanceUrl).origin);
+	const response = await fetcher(url, { headers: { Authorization: `bearer ${context.requestToken}` } });
+	if (!response.ok) throw new Error(`GitHub did not issue an OIDC token (${response.status}).`);
+	const body = await response.json();
+	if (body === null || typeof body !== "object" || !("value" in body)) throw new Error("GitHub returned an OIDC token response without a value.");
+	if (typeof body.value !== "string") throw new Error("GitHub returned an OIDC token response without a value.");
+	return body.value;
+}
+async function fetchWithGitHubActions(context, request) {
+	const instanceUrl = await resolveInstanceUrl();
+	return request(instanceUrl, await githubActionsToken(context, instanceUrl, globalThis.fetch));
+}
+async function loadGitHubActionsBuildInputs(context, requiresChangeset) {
+	const fetcher = globalThis.fetch;
+	const query = requiresChangeset === void 0 ? "" : `?changeset_id=${encodeURIComponent(requiresChangeset)}`;
+	const response = await fetchWithGitHubActions(context, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/ci/v1/build-inputs${query}`, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${accessToken}` }
+	}));
+	if (!response.ok) throw await hitchResponseError(response, "Failed to load the CI build inputs");
+	const body = await response.json();
+	if (body === null || typeof body !== "object" || !("openapi" in body) || !("theme" in body) || typeof body.theme !== "string") throw new Error("The CI build inputs must contain an openapi document and a theme string.");
+	return {
+		openapi: body.openapi,
+		theme: body.theme
+	};
+}
+async function loadGitHubActionsSources(context) {
+	const fetcher = globalThis.fetch;
+	const response = await fetchWithGitHubActions(context, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/ci/v1/applets`, { headers: { Authorization: `Bearer ${accessToken}` } }));
+	if (!response.ok) throw await hitchResponseError(response, "Failed to load the CI applets");
+	const body = await response.json();
+	if (body === null || typeof body !== "object" || !("data" in body) || !Array.isArray(body.data)) throw new Error("The CI applets response must contain a data array.");
+	return body.data.map((source) => {
+		if (source === null || typeof source !== "object" || !("code" in source) || typeof source.code !== "string" || !("source_directory" in source) || typeof source.source_directory !== "string" || !("source_hash" in source) || source.source_hash !== null && typeof source.source_hash !== "string") throw new Error("Each CI applet must contain code, source_directory, and source_hash fields.");
+		return {
+			code: source.code,
+			sourceDirectory: source.source_directory,
+			sourceHash: source.source_hash
+		};
+	});
+}
+//#endregion
+export { loadGitHubActionsSources as a, loadGitHubActionsBuildInputs as i, githubActionsContext as n, hitchResponseError as r, fetchWithGitHubActions as t };

package/dist/client.d.ts

@@ -1,7 +1,7 @@
-import { f as RegisteredContract, m as RegisteredRouter, p as RegisteredManifest } from "./manifest-BQCAxATS.js";
-import { t as NarrowContract } from "./contract-DMrpbaLJ.js";
+import { f as RegisteredContract, m as RegisteredRouter, p as RegisteredManifest } from "./manifest-C6_F4bL8.js";
+import { t as NarrowContract } from "./contract-CsUpTBe0.js";
 import { t as WithBatchRecorder } from "./batch-Qa4B4-Yp.js";
-import { o as WithFilesUpload } from "./upload-YbRKEqR6.js";
+import { o as WithFilesUpload } from "./upload-DKZzz5kW.js";
 import { RouterClient } from "@orpc/server";
 import { ContractRouterClient } from "@orpc/contract";
 import { NestedClient } from "@orpc/client";

package/dist/{contract-DMrpbaLJ.d.ts → contract-CsUpTBe0.d.ts}

@@ -1,4 +1,4 @@
-import { n as AppletManifest } from "./manifest-BQCAxATS.js";
+import { n as AppletManifest } from "./manifest-C6_F4bL8.js";
 import { AnyContractRouter } from "@orpc/contract";
 //#region src/hitch/contract.d.ts
 type ManifestObjectFor<Manifest, Code> = Manifest extends {

package/dist/{deploy-D3BGDqgC.js → deploy-wGYjwXrx.js}

@@ -1,9 +1,12 @@
-import { t as fetchWithOrgAuth } from "./auth-DaVK0k5R.js";
-import { t as buildApplet } from "./build-Rk3xDZV7.js";
+import { i as readWorkspaceConfig, n as fetchWithOrgAuth } from "./workspace-D0dnnlxL.js";
+import { a as loadGitHubActionsSources, n as githubActionsContext, r as hitchResponseError, t as fetchWithGitHubActions } from "./ci-BKw14X2h.js";
+import { n as buildPreparedApplet, r as prepareWorkspaceBuild, t as buildApplet } from "./build-CEfFoIZZ.js";
 import { createRequire } from "node:module";
-import { readFile, readdir } from "node:fs/promises";
-import { relative, resolve, sep } from "node:path";
-import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { lstat, readFile, readdir, readlink } from "node:fs/promises";
+import { dirname, relative, resolve, sep } from "node:path";
+import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { createGzip } from "node:zlib";
 //#region \0rolldown/runtime.js
@@ -2305,12 +2308,119 @@ var require_pack = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	}
 }));
 //#endregion
-//#region src/deploy.ts
+//#region src/source-hash.ts
 var import_tar_stream = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.extract = require_extract();
 	exports.pack = require_pack();
 })))(), 1);
+const execFileAsync$1 = promisify(execFile);
+function gitEnvironment() {
+	return Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+}
+var SourceHashUnavailableError = class extends Error {
+	constructor() {
+		super("Git is unavailable or the applet is outside a git repository.");
+	}
+};
+function isMissingPath(error) {
+	return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+async function hashFiles(topLevel, paths, env) {
+	if (paths.length === 0) return [];
+	return new Promise((resolveHashes, reject) => {
+		const child = spawn("git", ["hash-object", "--stdin-paths"], {
+			cwd: topLevel,
+			env
+		});
+		const stdout = [];
+		const stderr = [];
+		child.stdout.on("data", (chunk) => stdout.push(chunk));
+		child.stderr.on("data", (chunk) => stderr.push(chunk));
+		child.stdin.on("error", reject);
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (code !== 0) {
+				reject(/* @__PURE__ */ new Error(`git hash-object failed (${code}): ${Buffer.concat(stderr).toString("utf8").trim()}`));
+				return;
+			}
+			const hashes = Buffer.concat(stdout).toString("utf8").trimEnd().split("\n");
+			if (hashes.length !== paths.length || hashes.some((hash) => !/^[0-9a-f]{40,64}$/.test(hash))) {
+				reject(/* @__PURE__ */ new Error("git hash-object returned an unexpected number of hashes."));
+				return;
+			}
+			resolveHashes(hashes);
+		});
+		child.stdin.end(paths.map((path) => `"${path.split("").map((character) => character < " " || character === "" || character === "\"" || character === "\\" ? `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}` : character).join("")}"\n`).join(""));
+	});
+}
+async function sourceHashes(appletRoots) {
+	if (appletRoots.length === 0) return /* @__PURE__ */ new Map();
+	const env = gitEnvironment();
+	const workspaceRoot = dirname(dirname(appletRoots[0]));
+	let topLevel;
+	try {
+		const { stdout } = await execFileAsync$1("git", ["rev-parse", "--show-toplevel"], {
+			cwd: workspaceRoot,
+			env
+		});
+		topLevel = stdout.trim();
+	} catch (error) {
+		if (isMissingPath(error) || error instanceof Error && error.message.includes("not a git repository")) throw new SourceHashUnavailableError();
+		throw error;
+	}
+	const { stdout } = await execFileAsync$1("git", [
+		"ls-files",
+		"-z",
+		"--cached",
+		"--others",
+		"--exclude-standard"
+	], {
+		cwd: topLevel,
+		env,
+		maxBuffer: 67108864
+	});
+	const paths = [...new Set(stdout.split("\0").filter(Boolean))];
+	const present = (await Promise.all(paths.map(async (path) => {
+		const absolutePath = resolve(topLevel, path);
+		try {
+			const stat = await lstat(absolutePath);
+			if (stat.isFile()) return {
+				path,
+				kind: "file"
+			};
+			if (stat.isSymbolicLink()) return {
+				path,
+				kind: "link",
+				contentId: await readlink(absolutePath)
+			};
+			return;
+		} catch (error) {
+			if (isMissingPath(error)) return void 0;
+			throw error;
+		}
+	}))).filter((entry) => entry !== void 0);
+	const regularPaths = present.filter((entry) => entry.kind === "file").map((entry) => entry.path);
+	const hashes = await hashFiles(topLevel, regularPaths, env);
+	const contentIds = /* @__PURE__ */ new Map();
+	present.filter((entry) => entry.kind === "link").forEach((entry) => contentIds.set(entry.path, entry.contentId));
+	regularPaths.forEach((path, index) => contentIds.set(path, hashes[index]));
+	const appletsDirectory = relative(topLevel, resolve(workspaceRoot, "applets")).split(sep).join("/");
+	return new Map(appletRoots.map((appletRoot) => {
+		const appletDirectory = relative(topLevel, appletRoot).split(sep).join("/");
+		const digest = createHash("sha256");
+		[...contentIds.entries()].filter(([path]) => path !== appletsDirectory && !path.startsWith(`${appletsDirectory}/`) || path.startsWith(`${appletDirectory}/`)).sort(([left], [right]) => Buffer.compare(Buffer.from(left), Buffer.from(right))).forEach(([path, contentId]) => digest.update(`${path}\0${contentId}\n`));
+		return [appletRoot, digest.digest("hex")];
+	}));
+}
+//#endregion
+//#region src/deploy.ts
 const execFileAsync = promisify(execFile);
+var WorkspaceDeployError = class extends Error {
+	constructor(failedApplets) {
+		super(`Failed to deploy: ${failedApplets.join(", ")}. See the applet logs above.`);
+		this.name = "WorkspaceDeployError";
+	}
+};
 function isErrno(error, code) {
 	return error instanceof Error && "code" in error && error.code === code;
 }
@@ -2355,14 +2465,14 @@ async function createBundle(distDir) {
 	body.set(bundle);
 	return body;
 }
-async function readGitInfo() {
-	const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+async function readGitInfo(appletRoot) {
+	const env = gitEnvironment();
 	try {
 		const [{ stdout: status }, { stdout: sha }] = await Promise.all([execFileAsync("git", ["status", "--porcelain"], {
-			cwd: process.cwd(),
+			cwd: appletRoot,
 			env
 		}), execFileAsync("git", ["rev-parse", "HEAD"], {
-			cwd: process.cwd(),
+			cwd: appletRoot,
 			env
 		})]);
 		return {
@@ -2373,44 +2483,148 @@ async function readGitInfo() {
 		return { gitDirty: false };
 	}
 }
-async function deployError(response) {
-	let details = "";
-	try {
-		const body = await response.json();
-		if (body !== null && typeof body === "object") details = ["code" in body && typeof body.code === "string" ? body.code : void 0, "message" in body && typeof body.message === "string" ? body.message : void 0].filter((value) => value !== void 0).join(": ");
-	} catch {
-		details = "";
-	}
-	return /* @__PURE__ */ new Error(`Deploy failed (${response.status})${details ? `: ${details}` : ""}.`);
+async function repositoryDirectory(appletRoot) {
+	const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+		cwd: appletRoot,
+		env: gitEnvironment()
+	});
+	const directory = relative(stdout.trim(), appletRoot).split(sep).join("/") || ".";
+	if (directory === ".." || directory.startsWith("../")) throw new Error(`${appletRoot} is outside its git repository ${stdout.trim()}.`);
+	return directory;
 }
-async function runDeploy(options) {
-	if (options.dist === void 0) await buildApplet(options.changesetId);
-	const distDir = resolve(options.dist ?? ".hitch/dist");
-	const manifest = await readManifest(distDir);
-	const [bundle, git] = await Promise.all([createBundle(distDir), readGitInfo()]);
-	const fetcher = options.fetch ?? globalThis.fetch;
-	const response = await fetchWithOrgAuth(manifest.org, options, (instanceUrl, accessToken) => {
-		const body = new FormData();
-		body.set("manifest", manifest.raw);
-		body.set("bundle", new File([bundle], "bundle.tar.gz", { type: "application/gzip" }));
+function releaseForm(manifest, bundle) {
+	const body = new FormData();
+	body.set("manifest", manifest.raw);
+	body.set("bundle", new File([bundle], "bundle.tar.gz", { type: "application/gzip" }));
+	return body;
+}
+async function deployWithOrgAuth(appletRoot, distDir, manifest, sourceHash) {
+	const fetcher = globalThis.fetch;
+	const [bundle, git] = await Promise.all([createBundle(distDir), readGitInfo(appletRoot)]);
+	return fetchWithOrgAuth(manifest.org, (instanceUrl, accessToken) => {
+		const body = releaseForm(manifest, bundle);
 		body.set("gitDirty", String(git.gitDirty));
 		if (git.gitSha !== void 0) body.set("gitSha", git.gitSha);
-		if (options.changesetId !== void 0) body.set("changeset_id", options.changesetId);
+		if (sourceHash !== void 0) body.set("sourceHash", sourceHash);
 		return fetcher(`${instanceUrl}/api/v1/applets/${manifest.code}/releases`, {
 			method: "POST",
 			headers: { Authorization: `Bearer ${accessToken}` },
 			body
 		});
 	});
-	if (!response.ok) throw await deployError(response);
+}
+async function deployWithGitHubActions(context, appletRoot, distDir, manifest, sourceHash) {
+	const fetcher = globalThis.fetch;
+	const [bundle, sourceDirectory] = await Promise.all([createBundle(distDir), repositoryDirectory(appletRoot)]);
+	return fetchWithGitHubActions(context, (instanceUrl, accessToken) => {
+		const body = releaseForm(manifest, bundle);
+		body.set("source_directory", sourceDirectory);
+		if (sourceHash !== void 0) body.set("source_hash", sourceHash);
+		return fetcher(`${instanceUrl}/api/ci/v1/applets/${manifest.code}/releases`, {
+			method: "POST",
+			headers: { Authorization: `Bearer ${accessToken}` },
+			body
+		});
+	});
+}
+async function deployApplet(appletRoot, options, logPrefix = "", sourceHash) {
+	const github = githubActionsContext();
+	sourceHash ??= (await computeSourceHash([appletRoot], github !== void 0)).get(appletRoot);
+	if (options.dist === void 0) await buildApplet(appletRoot);
+	const distDir = resolve(appletRoot, options.dist ?? ".hitch/dist");
+	const manifest = await readManifest(distDir);
+	const response = github === void 0 ? await deployWithOrgAuth(appletRoot, distDir, manifest, sourceHash) : await deployWithGitHubActions(github, appletRoot, distDir, manifest, sourceHash);
+	if (!response.ok) throw await hitchResponseError(response, "Deploy failed");
 	const result = await response.json();
-	console.log(`Deployed release ${result.data.id} (${result.promoted ? "promoted" : "not promoted"}).`);
+	console.log(`${logPrefix}Deployed release ${result.data.id} (${result.promoted ? "promoted" : "not promoted"}).`);
+	if (result.changeset_id !== void 0) console.log(`${logPrefix}The release goes live when changeset ${result.changeset_id} applies.`);
 	if (result.warnings?.length) {
-		for (const warning of result.warnings) console.warn(`Warning: ${warning.message}`);
-		console.warn(`Changeset ${result.changeset_id} cannot apply until the applet and the schema agree.`);
+		for (const warning of result.warnings) console.warn(`${logPrefix}Warning: ${warning.message}`);
+		console.warn(`${logPrefix}Changeset ${result.changeset_id} cannot apply until the applet and the schema agree.`);
 	}
-	if (result.unset_variables?.length) console.warn(`Warning: declared variables not set: ${result.unset_variables.join(", ")}. Set them with applet variables set.`);
+	if (result.unset_variables?.length) console.warn(`${logPrefix}Warning: declared variables not set: ${result.unset_variables.join(", ")}. Set them with applet variables set.`);
 	return result;
 }
+async function workspaceAppletRoots(workspaceRoot) {
+	const appletsDir = resolve(workspaceRoot, "applets");
+	const roots = (await readdir(appletsDir, { withFileTypes: true }).catch((error) => {
+		if (isErrno(error, "ENOENT")) return [];
+		throw error;
+	})).filter((entry) => entry.isDirectory()).map((entry) => resolve(appletsDir, entry.name)).filter((root) => existsSync(resolve(root, "applet.manifest.ts"))).sort();
+	if (roots.length === 0) throw new Error(`No applets were found under ${appletsDir}.`);
+	return roots;
+}
+async function computeSourceHash(appletRoots, required) {
+	try {
+		return await sourceHashes(appletRoots);
+	} catch (error) {
+		if (!required && error instanceof SourceHashUnavailableError) return /* @__PURE__ */ new Map();
+		throw error;
+	}
+}
+async function ciDeployDecisions(github, appletRoots, hashes) {
+	const [sources, directories] = await Promise.all([loadGitHubActionsSources(github), Promise.all(appletRoots.map((appletRoot) => repositoryDirectory(appletRoot)))]);
+	const hashByDirectory = new Map(sources.map((source) => [source.sourceDirectory, source.sourceHash]));
+	return new Map(appletRoots.map((appletRoot, index) => {
+		const sourceHash = hashByDirectory.get(directories[index]);
+		if (sourceHash === null || sourceHash === void 0) return [appletRoot, {
+			deploy: true,
+			reason: "no release with a source hash to compare"
+		}];
+		if (sourceHash !== hashes.get(appletRoot)) return [appletRoot, {
+			deploy: true,
+			reason: "files changed since the current release"
+		}];
+		return [appletRoot, {
+			deploy: false,
+			reason: "no changes since the current release"
+		}];
+	}));
+}
+async function runDeploy(options) {
+	const root = process.cwd();
+	const github = githubActionsContext();
+	if (existsSync(resolve(root, "applet.manifest.ts"))) {
+		await deployApplet(root, options);
+		return;
+	}
+	if (readWorkspaceConfig(root) === void 0) throw new Error("Run applet deploy in an applet folder or in the workspace root.");
+	const appletRoots = await workspaceAppletRoots(root);
+	const hashes = await computeSourceHash(appletRoots, github !== void 0);
+	const decisions = github === void 0 ? void 0 : await ciDeployDecisions(github, appletRoots, hashes);
+	const selectedRoots = appletRoots.filter((appletRoot) => {
+		const name = relative(root, appletRoot);
+		const decision = decisions?.get(appletRoot);
+		if (decision === void 0) console.log(`Deploying ${name}...`);
+		else if (decision.deploy) console.log(`Deploying ${name}: ${decision.reason}.`);
+		else {
+			console.log(`Skipping ${name}: ${decision.reason}.`);
+			return false;
+		}
+		return true;
+	});
+	if (selectedRoots.length === 0) return;
+	if (options.dist === void 0) await prepareWorkspaceBuild(root, appletRoots);
+	const interactive = github === void 0 && process.stdin.isTTY === true;
+	const deploy = async (appletRoot) => {
+		const logPrefix = `[${relative(root, appletRoot)}] `;
+		if (options.dist === void 0) await buildPreparedApplet(appletRoot, ".hitch/dist", interactive ? "" : logPrefix);
+		await deployApplet(appletRoot, {
+			...options,
+			dist: options.dist ?? ".hitch/dist"
+		}, logPrefix, hashes.get(appletRoot));
+	};
+	if (interactive) {
+		for (const appletRoot of selectedRoots) await deploy(appletRoot);
+		return;
+	}
+	const failedApplets = (await Promise.allSettled(selectedRoots.map(deploy))).flatMap((result, index) => {
+		if (result.status === "fulfilled") return [];
+		const name = relative(root, selectedRoots[index]);
+		console.error(`[${name}] ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+		return [name];
+	});
+	if (failedApplets.length > 0) throw new WorkspaceDeployError(failedApplets);
+}
 //#endregion
 export { runDeploy };

package/dist/email-DBTVhNB_.js

@@ -0,0 +1,62 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/email.ts
+const emailTagKeySchema = z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/);
+const emailTagsSchema = z.record(emailTagKeySchema, z.string().min(1).max(200)).refine((tags) => Object.keys(tags).length <= 10);
+const createEmailPixelInputSchema = z.object({ tags: emailTagsSchema.optional() }).strict();
+const createEmailPixelOutputSchema = z.object({
+	id: z.uuid(),
+	url: z.url()
+});
+const getEmailTrackerInputSchema = z.object({ id: z.uuid() });
+const markEmailTrackerSentInputSchema = z.object({
+	id: z.uuid(),
+	sentAt: z.iso.datetime({ offset: true }).optional()
+}).strict();
+const markEmailTrackerSentBodySchema = z.object({ sentAt: z.iso.datetime({ offset: true }).optional() }).strict();
+const emailTrackerSchema = z.object({
+	id: z.uuid(),
+	url: z.url(),
+	tags: emailTagsSchema,
+	createdAt: z.iso.datetime(),
+	sentAt: z.iso.datetime().nullable(),
+	firstHitAt: z.iso.datetime().nullable(),
+	lastHitAt: z.iso.datetime().nullable()
+});
+const listEmailTrackersInputSchema = z.object({
+	filter: emailTagsSchema.optional(),
+	sentAt: z.object({
+		$gte: z.iso.datetime({ offset: true }).optional(),
+		$lt: z.iso.datetime({ offset: true }).optional()
+	}).strict().optional(),
+	cursor: z.uuid().optional(),
+	limit: z.number().int().min(1).max(200).optional()
+}).strict();
+const listEmailTrackersOutputSchema = z.object({
+	trackers: z.array(emailTrackerSchema),
+	nextCursor: z.uuid().nullable()
+});
+function emailContract(appletCode) {
+	const path = `/v1/applets/${encodeURIComponent(appletCode)}/email/tracking`;
+	return { tracking: {
+		createPixel: oc.route({
+			method: "POST",
+			path: `${path}/pixels`,
+			successStatus: 201
+		}).input(createEmailPixelInputSchema.optional()).output(createEmailPixelOutputSchema),
+		markSent: oc.route({
+			method: "POST",
+			path: `${path}/{id}/sent`
+		}).input(markEmailTrackerSentInputSchema).output(emailTrackerSchema),
+		get: oc.route({
+			method: "GET",
+			path: `${path}/{id}`
+		}).input(getEmailTrackerInputSchema).output(emailTrackerSchema),
+		list: oc.route({
+			method: "POST",
+			path: `${path}/list`
+		}).input(listEmailTrackersInputSchema.optional()).output(listEmailTrackersOutputSchema)
+	} };
+}
+//#endregion
+export { emailTagsSchema as a, listEmailTrackersInputSchema as c, markEmailTrackerSentInputSchema as d, emailTagKeySchema as i, listEmailTrackersOutputSchema as l, createEmailPixelOutputSchema as n, emailTrackerSchema as o, emailContract as r, getEmailTrackerInputSchema as s, createEmailPixelInputSchema as t, markEmailTrackerSentBodySchema as u };