@zenbujs/core 0.0.1

package/dist/build-electron-B4Gd0Gi4.mjs

@@ -0,0 +1,516 @@
+import { a as findBuildConfig, o as loadBuildConfig, r as initSeedRepo } from "./mirror-sync-CodOnwkD.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import crypto from "node:crypto";
+import fsp from "node:fs/promises";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import https from "node:https";
+//#region src/cli/lib/toolchain.ts
+const execFileAsync = promisify(execFile);
+/**
+* Hardcoded bun + pnpm versions that the .app bundles for its first-launch
+* `pnpm install`. We download these from upstream releases on demand (cached
+* globally per-version), verify against pinned sha256, and stage them into
+* the build's `extraResources/toolchain/` directory.
+*
+* Bumping a version: update the entry, paste the upstream release tarball's
+* sha256, and the next `zen build:electron` will re-fetch into a new cache
+* directory automatically.
+*
+* Currently darwin-only — Linux/Windows support is a future-PR concern.
+*/
+const TOOLCHAIN = {
+	bun: {
+		version: "1.3.12",
+		releaseTag: "bun-v1.3.12",
+		targets: {
+			"darwin-aarch64": {
+				asset: "bun-darwin-aarch64.zip",
+				sha256: "6c4bb87dd013ed1a8d6a16e357a3d094959fd5530b4d7061f7f3680c3c7cea1c"
+			},
+			"darwin-x64": {
+				asset: "bun-darwin-x64.zip",
+				sha256: "0f58c53a3e7947f1e626d2f8d285f97c14b7cadcca9c09ebafc0ae9d35b58c3d"
+			}
+		}
+	},
+	pnpm: {
+		version: "10.33.0",
+		releaseTag: "v10.33.0",
+		targets: {
+			"darwin-arm64": {
+				asset: "pnpm-macos-arm64",
+				sha256: "ed8a1f140f4de457b01ebe0be3ae28e9a7e28863315dcd53d22ff1e5a32d63ae"
+			},
+			"darwin-x64": {
+				asset: "pnpm-macos-x64",
+				sha256: "c31e29554b0e3f4e03f4617195c949595e4dca36085922003de4896c3ca4057d"
+			}
+		}
+	}
+};
+TOOLCHAIN.pnpm.version;
+TOOLCHAIN.bun.version;
+function cacheRoot() {
+	return path.join(os.homedir(), ".zenbu", "cache", "toolchain");
+}
+function bunTarget() {
+	if (process.arch === "arm64") return "darwin-aarch64";
+	if (process.arch === "x64") return "darwin-x64";
+	throw new Error(`zenbu toolchain: unsupported architecture ${process.arch}`);
+}
+function pnpmTarget() {
+	if (process.arch === "arm64") return "darwin-arm64";
+	if (process.arch === "x64") return "darwin-x64";
+	throw new Error(`zenbu toolchain: unsupported architecture ${process.arch}`);
+}
+function download(url, dest) {
+	return new Promise((resolve, reject) => {
+		https.get(url, (res) => {
+			if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+				res.resume();
+				download(new URL(res.headers.location, url).href, dest).then(resolve, reject);
+				return;
+			}
+			if (res.statusCode !== 200) {
+				reject(/* @__PURE__ */ new Error(`GET ${url} -> ${res.statusCode}`));
+				res.resume();
+				return;
+			}
+			const out = fs.createWriteStream(dest);
+			res.pipe(out);
+			out.on("finish", () => out.close(() => resolve()));
+			out.on("error", reject);
+		}).on("error", reject);
+	});
+}
+async function sha256(filePath) {
+	const hash = crypto.createHash("sha256");
+	await new Promise((resolve, reject) => {
+		const stream = fs.createReadStream(filePath);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("end", () => resolve());
+		stream.on("error", reject);
+	});
+	return hash.digest("hex");
+}
+async function verify(filePath, expected) {
+	const actual = await sha256(filePath);
+	if (actual !== expected) throw new Error(`zenbu toolchain: sha256 mismatch for ${path.basename(filePath)} (expected ${expected}, got ${actual})`);
+}
+async function findExecutable(dir, name) {
+	const entries = await fsp.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			const nested = await findExecutable(full, name);
+			if (nested) return nested;
+		} else if (entry.isFile() && entry.name === name) return full;
+	}
+	return null;
+}
+async function ensureBunCached() {
+	const target = bunTarget();
+	const info = TOOLCHAIN.bun.targets[target];
+	const dir = path.join(cacheRoot(), `bun-${TOOLCHAIN.bun.version}-${target}`);
+	const cached = path.join(dir, "bun");
+	if (fs.existsSync(cached)) return cached;
+	await fsp.mkdir(dir, { recursive: true });
+	const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "zenbu-bun-"));
+	try {
+		const zipPath = path.join(tmp, info.asset);
+		const url = `https://github.com/oven-sh/bun/releases/download/${TOOLCHAIN.bun.releaseTag}/${info.asset}`;
+		console.log(`  → downloading bun ${TOOLCHAIN.bun.version} (${target})`);
+		await download(url, zipPath);
+		await verify(zipPath, info.sha256);
+		await execFileAsync("unzip", [
+			"-q",
+			zipPath,
+			"-d",
+			tmp
+		]);
+		const extracted = await findExecutable(tmp, "bun");
+		if (!extracted) throw new Error(`zenbu toolchain: could not find bun in ${info.asset}`);
+		await fsp.copyFile(extracted, cached);
+		await fsp.chmod(cached, 493);
+	} finally {
+		await fsp.rm(tmp, {
+			recursive: true,
+			force: true
+		});
+	}
+	return cached;
+}
+async function ensurePnpmCached() {
+	const target = pnpmTarget();
+	const info = TOOLCHAIN.pnpm.targets[target];
+	const dir = path.join(cacheRoot(), `pnpm-${TOOLCHAIN.pnpm.version}-${target}`);
+	const cached = path.join(dir, "pnpm");
+	if (fs.existsSync(cached)) return cached;
+	await fsp.mkdir(dir, { recursive: true });
+	const tmp = path.join(dir, ".download");
+	const url = `https://github.com/pnpm/pnpm/releases/download/${TOOLCHAIN.pnpm.releaseTag}/${info.asset}`;
+	console.log(`  → downloading pnpm ${TOOLCHAIN.pnpm.version} (${target})`);
+	await download(url, tmp);
+	await verify(tmp, info.sha256);
+	await fsp.chmod(tmp, 493);
+	await fsp.rename(tmp, cached);
+	return cached;
+}
+/**
+* Stage hardcoded bun + pnpm into `<stagingDir>/{bun, pnpm}` so the build
+* can wire them into electron-builder as extraResources. Returns absolute
+* paths to the staged binaries.
+*
+* The sibling `node` symlink (-> `bun`) is created so that any npm
+* lifecycle script that does `#!/usr/bin/env node` can resolve to bun
+* inside the launched .app.
+*/
+async function provisionToolchain(stagingDir) {
+	if (process.platform !== "darwin") throw new Error(`zenbu toolchain: only darwin is supported today (got ${process.platform})`);
+	await fsp.mkdir(stagingDir, { recursive: true });
+	const cachedBun = await ensureBunCached();
+	const cachedPnpm = await ensurePnpmCached();
+	const bunOut = path.join(stagingDir, "bun");
+	const pnpmOut = path.join(stagingDir, "pnpm");
+	const nodeOut = path.join(stagingDir, "node");
+	await fsp.copyFile(cachedBun, bunOut);
+	await fsp.chmod(bunOut, 493);
+	await fsp.copyFile(cachedPnpm, pnpmOut);
+	await fsp.chmod(pnpmOut, 493);
+	try {
+		await fsp.unlink(nodeOut);
+	} catch {}
+	await fsp.symlink("bun", nodeOut);
+	return {
+		bun: bunOut,
+		pnpm: pnpmOut,
+		node: nodeOut
+	};
+}
+//#endregion
+//#region src/cli/commands/build-electron.ts
+const ELECTRON_BUILDER_CONFIG_NAMES = [
+	"electron-builder.json",
+	"electron-builder.json5",
+	"electron-builder.yml",
+	"electron-builder.yaml",
+	"electron-builder.config.js",
+	"electron-builder.config.cjs",
+	"electron-builder.config.mjs"
+];
+function resolveProjectDir() {
+	const cwd = process.cwd();
+	if (fs.existsSync(path.join(cwd, "zenbu.plugin.json"))) return cwd;
+	console.error("zen build:electron: no zenbu.plugin.json found in current directory");
+	process.exit(1);
+}
+/**
+* Args use `--` to delimit zen flags from electron-builder pass-through
+* flags. e.g. `pnpm build:electron -- --publish always` forwards
+* `--publish always` to electron-builder. Without `--` everything is treated
+* as a zen flag (and unknown flags error out).
+*/
+function parseFlags(argv) {
+	const flags = {
+		noSource: false,
+		passthrough: []
+	};
+	let sawSeparator = false;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (sawSeparator) {
+			flags.passthrough.push(arg);
+			continue;
+		}
+		if (arg === "--") {
+			sawSeparator = true;
+			continue;
+		}
+		if (arg === "--config" || arg === "-c") flags.config = argv[++i];
+		else if (arg.startsWith("--config=")) flags.config = arg.slice(9);
+		else if (arg === "--no-source") flags.noSource = true;
+		else {
+			console.error(`zen build:electron: unknown flag "${arg}"`);
+			console.error(`valid: zen build:electron [--config <zenbu.build.ts>] [--no-source] [-- <electron-builder args>]`);
+			process.exit(1);
+		}
+	}
+	return flags;
+}
+function readJson(filePath) {
+	return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+function expandMirrorUrl(target) {
+	if (target.startsWith("http://") || target.startsWith("https://") || target.startsWith("git@")) return target;
+	if (/^[\w.-]+\/[\w.-]+$/.test(target)) return `https://github.com/${target}.git`;
+	return target;
+}
+function resolveCoreVersion() {
+	try {
+		const pkg = readJson(createRequire(import.meta.url).resolve("@zenbujs/core/package.json"));
+		if (pkg.version) return pkg.version;
+	} catch {}
+	try {
+		const here = fileURLToPath(import.meta.url);
+		let dir = path.dirname(here);
+		while (dir !== path.dirname(dir)) {
+			const candidate = path.join(dir, "package.json");
+			if (fs.existsSync(candidate)) {
+				const pkg = readJson(candidate);
+				if (pkg.name === "@zenbujs/core" && pkg.version) return pkg.version;
+				if (pkg.version) return pkg.version;
+			}
+			dir = path.dirname(dir);
+		}
+	} catch {}
+	return "0.0.0";
+}
+/**
+* Find the bundled `launcher.mjs` shipped inside `@zenbujs/core/dist/`. We
+* resolve it through Node's resolution from the user's project so that the
+* launcher matches the version of `@zenbujs/core` actually installed in the
+* app's `node_modules` (which is what runs in the bundled .app).
+*/
+function resolveLauncher(projectDir) {
+	const localRequire = createRequire(path.join(projectDir, "package.json"));
+	try {
+		const pkgPath = localRequire.resolve("@zenbujs/core/package.json");
+		const launcher = path.join(path.dirname(pkgPath), "dist", "launcher.mjs");
+		if (fs.existsSync(launcher)) return launcher;
+	} catch {}
+	const here = fileURLToPath(import.meta.url);
+	const candidate = path.resolve(path.dirname(here), "..", "launcher.mjs");
+	if (fs.existsSync(candidate)) return candidate;
+	throw new Error("zen build:electron: cannot locate `@zenbujs/core/dist/launcher.mjs`. Make sure @zenbujs/core is installed in this project.");
+}
+function resolveElectronBuilder(projectDir) {
+	const candidates = [path.join(projectDir, "node_modules", ".bin", "electron-builder"), path.join(projectDir, "node_modules", "electron-builder", "out", "cli", "cli.js")];
+	for (const candidate of candidates) if (fs.existsSync(candidate)) return candidate;
+	throw new Error("zen build:electron: electron-builder not found in node_modules. Add it to devDependencies and run `pnpm install`.");
+}
+function findElectronBuilderConfig(projectDir) {
+	for (const name of ELECTRON_BUILDER_CONFIG_NAMES) {
+		const candidate = path.join(projectDir, name);
+		if (fs.existsSync(candidate)) return {
+			path: candidate,
+			format: name.endsWith(".json") ? "json" : "other"
+		};
+	}
+	const pkgPath = path.join(projectDir, "package.json");
+	if (fs.existsSync(pkgPath)) try {
+		if (readJson(pkgPath).build) return {
+			path: pkgPath,
+			format: "json"
+		};
+	} catch {}
+	return null;
+}
+function readElectronBuilderConfig(projectDir) {
+	const found = findElectronBuilderConfig(projectDir);
+	if (!found) throw new Error([
+		"zen build:electron: no electron-builder config found.",
+		"",
+		"Create `electron-builder.json` in the project root, e.g.:",
+		"",
+		"  {",
+		"    \"appId\": \"dev.you.your-app\",",
+		"    \"productName\": \"Your App\",",
+		"    \"asar\": false,",
+		"    \"directories\": { \"output\": \"dist\" },",
+		"    \"mac\": { \"category\": \"public.app-category.developer-tools\", \"target\": [\"zip\"] }",
+		"  }",
+		""
+	].join("\n"));
+	if (found.format !== "json") throw new Error(`zen build:electron: only JSON electron-builder configs are supported right now (got ${path.basename(found.path)}). Convert to electron-builder.json or move the config under package.json#build.`);
+	if (path.basename(found.path) === "package.json") return { ...readJson(found.path).build ?? {} };
+	return readJson(found.path);
+}
+async function ensureSource(projectDir, config, noSource) {
+	const stagingDir = path.resolve(projectDir, config.out);
+	const shaPath = path.join(stagingDir, ".sha");
+	const currentSha = (() => {
+		try {
+			return execFileSync("git", ["rev-parse", "HEAD"], {
+				cwd: projectDir,
+				encoding: "utf8"
+			}).trim();
+		} catch {
+			return "uncommitted";
+		}
+	})();
+	if (fs.existsSync(shaPath)) {
+		const meta = readJson(shaPath);
+		if (meta.sourceSha === currentSha) return meta;
+		if (noSource) {
+			console.warn(`[build:electron] --no-source: using stale staging (built from ${meta.sourceSha.slice(0, 7)}, current HEAD ${currentSha.slice(0, 7)})`);
+			return meta;
+		}
+	}
+	if (noSource) {
+		console.error("zen build:electron: --no-source given but no staging found. Run `zen build:source` first.");
+		process.exit(1);
+	}
+	console.log(`  → running zen build:source (seed is missing or stale)`);
+	const { runBuildSource } = await import("./build-source-_q1n1zTV.mjs");
+	await runBuildSource([]);
+	return readJson(shaPath);
+}
+async function spawnAsync(cmd, args, cwd, env = process.env) {
+	await new Promise((resolve, reject) => {
+		const child = spawn(cmd, args, {
+			cwd,
+			stdio: "inherit",
+			env
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`${cmd} exited with code ${code}`));
+		});
+	});
+}
+/**
+* Compose the user's electron-builder config with the zenbu overlays. The
+* overlays are minimal and targeted:
+*
+*   - `directories.app`        owned by zen — points at our staged app dir
+*   - `files`                  owned by zen — the staged app dir is fully
+*                              under our control, so user-side `files`
+*                              entries would not resolve anyway
+*   - `extraResources`         additive — we APPEND the toolchain entry to
+*                              whatever the user already declared
+*   - `npmRebuild`             forced to false — the seed ships its own
+*                              lockfile and `pnpm install` runs at first
+*                              launch, no rebuild step needed at build time
+*
+* Everything else (`appId`, `productName`, `mac`, `win`, `linux`,
+* `publish`, `directories.output`, `directories.buildResources`, `asar`,
+* signing/notarize, target list) is preserved as-is from the user's config.
+*/
+function mergeElectronBuilderConfig(userConfig, overlay) {
+	const merged = { ...userConfig };
+	merged.directories = {
+		...userConfig.directories ?? {},
+		app: overlay.appDir,
+		output: overlay.output
+	};
+	merged.files = overlay.seedFiles;
+	merged.extraResources = [...Array.isArray(userConfig.extraResources) ? userConfig.extraResources : [], overlay.extraResource];
+	if (userConfig.npmRebuild !== false) merged.npmRebuild = false;
+	if (userConfig.asar === void 0) merged.asar = false;
+	return merged;
+}
+async function copyFile(src, dest) {
+	await fsp.mkdir(path.dirname(dest), { recursive: true });
+	await fsp.copyFile(src, dest);
+}
+async function runBuildElectron(argv) {
+	const projectDir = resolveProjectDir();
+	const flags = parseFlags(argv);
+	const config = await loadBuildConfig(flags.config ? path.resolve(projectDir, flags.config) : findBuildConfig(projectDir));
+	const meta = await ensureSource(projectDir, config, flags.noSource);
+	const seedDir = path.resolve(projectDir, config.out);
+	const projectPkg = readJson(path.join(projectDir, "package.json"));
+	const appName = projectPkg.name ?? path.basename(projectDir);
+	const appVersion = projectPkg.version ?? "0.0.1";
+	const bundleDir = await fsp.mkdtemp(path.join(os.tmpdir(), `zenbu-electron-${appName}-`));
+	const stagedSeed = path.join(bundleDir, "seed");
+	const toolchainDir = path.join(bundleDir, "toolchain");
+	const launcherOut = path.join(bundleDir, "launcher.mjs");
+	const bundlePkgOut = path.join(bundleDir, "package.json");
+	const appConfigOut = path.join(bundleDir, "app-config.json");
+	const mergedConfigPath = path.join(bundleDir, "electron-builder.merged.json");
+	const mirrorTarget = config.mirror?.target ?? null;
+	const mirrorBranch = config.mirror?.branch ?? "main";
+	const mirrorUrl = mirrorTarget ? expandMirrorUrl(mirrorTarget) : null;
+	console.log(`\n  zen build:electron`);
+	console.log(`    name:    ${appName}`);
+	console.log(`    version: ${appVersion}`);
+	console.log(`    source:  ${meta.sourceSha === "uncommitted" ? "uncommitted" : meta.sourceSha.slice(0, 7)}`);
+	console.log(`    mirror:  ${mirrorTarget ?? "(none — set config.mirror.target to enable updates)"}`);
+	console.log(`    bundle:  ${bundleDir}`);
+	console.log("  → staging launcher.mjs");
+	await copyFile(resolveLauncher(projectDir), launcherOut);
+	console.log("  → staging seed/");
+	await fsp.cp(seedDir, stagedSeed, {
+		recursive: true,
+		filter: (src) => path.basename(src) !== ".sha"
+	});
+	if (mirrorUrl) await initSeedRepo({
+		dir: stagedSeed,
+		mirrorUrl,
+		branch: mirrorBranch,
+		sourceSha: meta.sourceSha === "uncommitted" ? "0000000000000000000000000000000000000000" : meta.sourceSha
+	});
+	console.log("  → provisioning bundled toolchain (bun + pnpm)");
+	await provisionToolchain(toolchainDir);
+	console.log("  → writing bundle package.json + app-config.json");
+	const host = resolveCoreVersion();
+	const bundlePkg = {
+		name: appName,
+		version: appVersion,
+		main: "launcher.mjs",
+		type: "module",
+		zenbu: { host }
+	};
+	if (mirrorUrl) bundlePkg.repository = {
+		type: "git",
+		url: mirrorUrl
+	};
+	await fsp.writeFile(bundlePkgOut, JSON.stringify(bundlePkg, null, 2) + "\n");
+	const appConfig = {
+		name: appName,
+		mirrorUrl,
+		branch: mirrorBranch,
+		version: appVersion,
+		host
+	};
+	await fsp.writeFile(appConfigOut, JSON.stringify(appConfig, null, 2) + "\n");
+	const userConfig = readElectronBuilderConfig(projectDir);
+	const userOutput = userConfig.directories?.output ?? "dist";
+	const resolvedOutput = path.isAbsolute(userOutput) ? userOutput : path.resolve(projectDir, userOutput);
+	const merged = mergeElectronBuilderConfig(userConfig, {
+		appDir: bundleDir,
+		output: resolvedOutput,
+		seedFiles: [
+			"package.json",
+			"app-config.json",
+			"launcher.mjs",
+			"seed/**/*",
+			"!node_modules",
+			"!**/node_modules",
+			"!**/node_modules/**"
+		],
+		extraResource: {
+			from: toolchainDir,
+			to: "toolchain"
+		}
+	});
+	await fsp.writeFile(mergedConfigPath, JSON.stringify(merged, null, 2) + "\n");
+	console.log("  → injected into electron-builder config:");
+	console.log(`      directories.app    = ${bundleDir}`);
+	console.log(`      directories.output = ${resolvedOutput}`);
+	console.log(`      files              = [zenbu seed]`);
+	console.log(`      extraResources    += { from: <bundle>/toolchain, to: toolchain }`);
+	console.log(`      asar               = ${merged.asar !== void 0 ? merged.asar : "(unset)"}`);
+	console.log(`      npmRebuild         = false`);
+	console.log("  → invoking electron-builder");
+	const electronBuilder = resolveElectronBuilder(projectDir);
+	const cliArgs = [
+		"--config",
+		mergedConfigPath,
+		...flags.passthrough
+	];
+	const env = { ...process.env };
+	if (!env.GH_TOKEN && env.GITHUB_TOKEN) env.GH_TOKEN = env.GITHUB_TOKEN;
+	if (electronBuilder.endsWith(".js")) await spawnAsync(process.execPath, [electronBuilder, ...cliArgs], projectDir, env);
+	else await spawnAsync(electronBuilder, cliArgs, projectDir, env);
+	console.log(`\n  ✓ Built ${appName} ${appVersion} at ${path.relative(projectDir, resolvedOutput) || resolvedOutput}\n`);
+}
+//#endregion
+export { runBuildElectron };

package/dist/build-source-_q1n1zTV.mjs

@@ -0,0 +1,162 @@
+import { a as findBuildConfig, o as loadBuildConfig, t as hashDir } from "./mirror-sync-CodOnwkD.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+//#region src/cli/commands/build-source.ts
+function resolveProjectDir() {
+	const cwd = process.cwd();
+	if (fs.existsSync(path.join(cwd, "zenbu.plugin.json"))) return cwd;
+	console.error("zen build:source: no zenbu.plugin.json found in current directory");
+	process.exit(1);
+}
+function resolveSourceHead(projectDir) {
+	try {
+		return execFileSync("git", ["rev-parse", "HEAD"], {
+			cwd: projectDir,
+			encoding: "utf8"
+		}).trim();
+	} catch {
+		return "uncommitted";
+	}
+}
+function parseFlags(argv) {
+	const flags = {};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--config" || arg === "-c") flags.config = argv[++i];
+		else if (arg.startsWith("--config=")) flags.config = arg.slice(9);
+		else if (arg === "--out" || arg === "-o") flags.out = argv[++i];
+		else if (arg.startsWith("--out=")) flags.out = arg.slice(6);
+	}
+	return flags;
+}
+async function collectFiles(sourceDir, config) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const pattern of config.include) {
+		const iter = fsp.glob(pattern, {
+			cwd: sourceDir,
+			exclude: config.ignore
+		});
+		for await (const entry of iter) {
+			const rel = entry.split(path.sep).join("/");
+			const abs = path.resolve(sourceDir, rel);
+			let stat;
+			try {
+				stat = await fsp.stat(abs);
+			} catch {
+				continue;
+			}
+			if (!stat.isFile()) continue;
+			seen.add(rel);
+		}
+	}
+	return [...seen].sort();
+}
+async function applyTransforms(input, transforms) {
+	let code = input.code;
+	let drop = false;
+	for (const transform of transforms) {
+		const result = await transform({
+			path: input.path,
+			code
+		});
+		if (!result) continue;
+		if (result.drop) {
+			drop = true;
+			break;
+		}
+		if (typeof result.code === "string") code = result.code;
+	}
+	return {
+		code,
+		drop
+	};
+}
+async function runBuildSource(argv) {
+	const projectDir = resolveProjectDir();
+	const flags = parseFlags(argv);
+	const configPath = flags.config ? path.resolve(projectDir, flags.config) : findBuildConfig(projectDir);
+	const config = await loadBuildConfig(configPath);
+	if (flags.out) config.out = flags.out;
+	const sourceDir = path.resolve(projectDir, config.source);
+	const outDir = path.resolve(projectDir, config.out);
+	console.log(`\n  zen build:source`);
+	console.log(`    config:  ${path.relative(projectDir, configPath) || configPath}`);
+	console.log(`    source:  ${path.relative(projectDir, sourceDir) || "."}`);
+	console.log(`    out:     ${path.relative(projectDir, outDir) || "."}`);
+	await fsp.rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	await fsp.mkdir(outDir, { recursive: true });
+	const files = await collectFiles(sourceDir, config);
+	if (files.length === 0) {
+		console.error("zen build:source: no files matched the include/ignore globs");
+		process.exit(1);
+	}
+	let written = 0;
+	let dropped = 0;
+	for (const rel of files) {
+		const src = path.join(sourceDir, rel);
+		const dst = path.join(outDir, rel);
+		const isText = isLikelyText(src);
+		if (config.transforms.length === 0 || !isText) {
+			await fsp.mkdir(path.dirname(dst), { recursive: true });
+			await fsp.copyFile(src, dst);
+			written += 1;
+			continue;
+		}
+		const { code: nextCode, drop } = await applyTransforms({
+			path: rel,
+			code: await fsp.readFile(src, "utf8")
+		}, config.transforms);
+		if (drop) {
+			dropped += 1;
+			continue;
+		}
+		await fsp.mkdir(path.dirname(dst), { recursive: true });
+		await fsp.writeFile(dst, nextCode);
+		written += 1;
+	}
+	const sourceSha = resolveSourceHead(projectDir);
+	const meta = {
+		sourceSha,
+		contentHash: await hashDir(outDir),
+		builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+		files: written,
+		dropped
+	};
+	await fsp.writeFile(path.join(outDir, ".sha"), JSON.stringify(meta, null, 2) + "\n");
+	console.log(`\n  ✓ ${written} file(s) written, ${dropped} dropped by transforms`);
+	console.log(`    source HEAD: ${sourceSha === "uncommitted" ? sourceSha : sourceSha.slice(0, 7)}\n`);
+}
+const TEXT_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts",
+	".json",
+	".md",
+	".html",
+	".css",
+	".scss",
+	".sass",
+	".less",
+	".yml",
+	".yaml",
+	".toml",
+	".sh",
+	".env",
+	".txt"
+]);
+function isLikelyText(filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	return TEXT_EXTENSIONS.has(ext);
+}
+//#endregion
+export { runBuildSource };

package/dist/chunk-Dm34NbLt.mjs

@@ -0,0 +1,6 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __require as n, __commonJSMin as t };

package/dist/cli/bin.d.mts

@@ -0,0 +1 @@
+export { };