@zenbujs/core 0.0.9 → 0.0.12

package/dist/services/default.mjs

@@ -1,23 +1,19 @@
 //#region src/services/default.ts
 /**
-* Loads and registers all built-in services. Kept separate from
-* `./index.ts` (which statically re-exports the service classes for
-* `Service.withDeps(...)` consumers) so that `setup-gate` can import it
-* without eagerly loading every service module before `setupGate()` has
-* had a chance to bootstrap env vars and `process.chdir(projectRoot)`.
+* parallelize? i forgor is it serial no matter what?
 */
 async function defaultServices() {
-	await import("../server-CZLMF8Dj.mjs").then((n) => n.n);
-	await import("../reloader-B22UiNA2.mjs").then((n) => n.n);
-	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.n);
-	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.c);
-	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.o);
-	await import("../base-window-BxBZ2md_.mjs").then((n) => n.r);
-	await import("../rpc-C4_NQmpT.mjs").then((n) => n.n);
-	await import("../renderer-host-DD16MXhI.mjs").then((n) => n.i);
-	await import("../window-YFKvAM0l.mjs").then((n) => n.n);
-	await import("../advice-config-DXSIo0sg.mjs").then((n) => n.t);
-	await import("../updater-BtB_Ki1r.mjs").then((n) => n.n);
+	await import("../server-BJ2ZC2z2.mjs").then((n) => n.n);
+	await import("../reloader-CFzxYa67.mjs").then((n) => n.n);
+	await import("../renderer-host-Cw38dSDe.mjs").then((n) => n.n);
+	await import("../renderer-host-Cw38dSDe.mjs").then((n) => n.c);
+	await import("../renderer-host-Cw38dSDe.mjs").then((n) => n.o);
+	await import("../base-window-4P-fVvC_.mjs").then((n) => n.r);
+	await import("../rpc-Dg9zwZ33.mjs").then((n) => n.n);
+	await import("../renderer-host-Cw38dSDe.mjs").then((n) => n.i);
+	await import("../window-DgB70qeZ.mjs").then((n) => n.n);
+	await import("../runtime-DYUONc3S.mjs").then((n) => n.h);
+	await import("../updater-Bs1Jtem6.mjs").then((n) => n.n);
 }
 //#endregion
 export { defaultServices };

package/dist/services/index.d.mts

@@ -1,2 +1,2 @@
-import { a as MAIN_WINDOW_ID, c as DbService, d as ServerService, i as BaseWindowService, l as HttpService, n as WindowService, o as RendererHostService, r as RpcService, s as ViewRegistryService, t as UpdaterService, u as ReloaderService } from "../index-CVF768Xs.mjs";
+import { a as MAIN_WINDOW_ID, c as DbService, d as ServerService, i as BaseWindowService, l as HttpService, n as WindowService, o as RendererHostService, r as RpcService, s as ViewRegistryService, t as UpdaterService, u as ReloaderService } from "../index-C0mXKol5.mjs";
 export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, UpdaterService, ViewRegistryService, WindowService };

package/dist/services/index.mjs

@@ -1,8 +1,8 @@
-import { t as ServerService } from "../server-CZLMF8Dj.mjs";
-import { t as ReloaderService } from "../reloader-B22UiNA2.mjs";
-import { a as DbService, r as ViewRegistryService, s as HttpService, t as RendererHostService } from "../renderer-host-DD16MXhI.mjs";
-import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-BxBZ2md_.mjs";
-import { t as RpcService } from "../rpc-C4_NQmpT.mjs";
-import { t as WindowService } from "../window-YFKvAM0l.mjs";
-import { t as UpdaterService } from "../updater-BtB_Ki1r.mjs";
+import { t as ServerService } from "../server-BJ2ZC2z2.mjs";
+import { t as ReloaderService } from "../reloader-CFzxYa67.mjs";
+import { a as DbService, r as ViewRegistryService, s as HttpService, t as RendererHostService } from "../renderer-host-Cw38dSDe.mjs";
+import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-4P-fVvC_.mjs";
+import { t as RpcService } from "../rpc-Dg9zwZ33.mjs";
+import { t as WindowService } from "../window-DgB70qeZ.mjs";
+import { t as UpdaterService } from "../updater-Bs1Jtem6.mjs";
 export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, UpdaterService, ViewRegistryService, WindowService };

package/dist/setup-gate.d.mts

@@ -1,2 +1,2 @@
-import { t as setupGate } from "./setup-gate-BQq0QgZH.mjs";
+import { t as setupGate } from "./setup-gate-DkysEZQO.mjs";
 export { setupGate };

package/dist/setup-gate.mjs

@@ -1,4 +1,5 @@
 import { bootstrapEnv } from "./env-bootstrap.mjs";
+import { n as pickZenbuBgEntry, t as parseZenbuBgEntries } from "./zenbu-bg-parse-CIyPkJOY.mjs";
 import { createRequire, register } from "node:module";
 import fs from "node:fs";
 import os from "node:os";
@@ -87,16 +88,23 @@ async function closeRegisteredWatchers() {
 	await (await import("@zenbujs/hmr/pause")).closeAllWatchers?.();
 }
 /**
-* Extract the splash's intended background color from a
-* `<meta name="zenbu-bg" content="#xxx">` tag. Used as the BaseWindow's
-* `backgroundColor` so the OS doesn't paint a single white frame before
-* the WebContentsView's pixels reach the screen. Convention only —
-* defaults to `#F4F4F4` when unset.
+* Extract the splash's intended background color from `<meta name="zenbu-bg">`
+* tag(s). Used as the BaseWindow's `backgroundColor` so the OS doesn't
+* paint a single mismatched frame before the WebContentsView's pixels
+* reach the screen.
+*
+* Supports the `media` attribute (mirrors the W3C `theme-color` pattern),
+* so the splash can declare separate colors per system theme:
+*
+*   <meta name="zenbu-bg" content="#fafafa" media="(prefers-color-scheme: light)">
+*   <meta name="zenbu-bg" content="#09090b" media="(prefers-color-scheme: dark)">
+*
+* Defaults to `#F4F4F4` when no tag matches.
 */
-function readSplashBgColor(splashPath) {
+function readSplashBgColor(splashPath, dark) {
 	try {
-		const match = fs.readFileSync(splashPath, "utf8").match(/<meta\s+name=["']zenbu-bg["']\s+content=["']([^"']+)["']/i);
-		if (match?.[1]) return match[1];
+		const picked = pickZenbuBgEntry(parseZenbuBgEntries(fs.readFileSync(splashPath, "utf8")), dark);
+		if (picked) return picked;
 	} catch {}
 	return "#F4F4F4";
 }
@@ -125,7 +133,7 @@ async function spawnSplashWindow(splashPath) {
 	}
 	const slot = globalThis;
 	const electron = await import("electron");
-	const backgroundColor = readSplashBgColor(splashPath);
+	const backgroundColor = readSplashBgColor(splashPath, electron.nativeTheme.shouldUseDarkColors);
 	const existing = slot.__zenbu_boot_windows__?.find((b) => b.windowId === "main");
 	let win;
 	if (existing) {
@@ -186,10 +194,10 @@ async function spawnSplashWindow(splashPath) {
 */
 async function loadConfigPhase(tsconfig, projectRoot) {
 	register$1({ tsconfig });
-	const { loadConfig } = await import("./load-config-C4Oe2qZO.mjs").then((n) => n.n);
+	const { loadConfig } = await import("./load-config-C2XloBaQ.mjs").then((n) => n.a);
 	const { resolved, pluginSourceFiles } = await loadConfig(projectRoot);
 	try {
-		const { linkProject } = await import("./link-glX89NV5.mjs").then((n) => n.n);
+		const { linkProject } = await import("./link-Bt3LB_NW.mjs").then((n) => n.n);
 		await linkProject(projectRoot, { quiet: true });
 	} catch (err) {
 		console.warn(`[setup-gate] zen link failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
@@ -225,7 +233,7 @@ async function loadConfigPhase(tsconfig, projectRoot) {
 async function registerLoadersPhase(projectRoot, loaderData) {
 	registerLoader(import.meta.resolve("@zenbujs/core/loaders/zenbu"), { data: loaderData });
 	process.env.ZENBU_ADVICE_ROOT = projectRoot;
-	await import("./node-BhfLKYCi.mjs");
+	await import("./node-BuHlEsE4.mjs");
 	const dynohot = await import(pathToFileURL(createRequire(import.meta.url).resolve("@zenbujs/hmr/register")).href);
 	if (typeof dynohot.register === "function") dynohot.register({ ignore: /[/\\](?:node_modules|dist)[/\\]/ });
 }

package/dist/{transport-F2hv_OEm.mjs → transport-Bqlv9pmJ.mjs}

@@ -1,4 +1,4 @@
-import { t as traceKyju } from "./trace-BaVg0rnY.mjs";
+import { t as traceKyju } from "./trace-BVcQSD59.mjs";
 import * as Effect from "effect/Effect";
 import * as Ref from "effect/Ref";
 import * as Context from "effect/Context";

package/dist/updater-Bs1Jtem6.mjs

@@ -0,0 +1,480 @@
+import { n as __exportAll } from "./chunk-DsiFFCwN.mjs";
+import { f as runtime, n as Service } from "./runtime-DYUONc3S.mjs";
+import { t as createLogger } from "./log-BkRqDwwB.mjs";
+import { n as tryReadHostVersion } from "./host-version-Cog_odmD.mjs";
+import fs, { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import fsp from "node:fs/promises";
+import { app } from "electron";
+import * as git from "isomorphic-git";
+import http from "isomorphic-git/http/node";
+//#region src/shared/pm-install.ts
+/**
+* Bundled-toolchain `<pm> install` helpers.
+*
+* Imported by both:
+*   - `packages/core/src/launcher.ts` (tsdown inlines this into
+*     `dist/launcher.mjs`; the launcher cannot `import "@zenbujs/core"`)
+*   - `packages/core/src/services/updater.ts` (resolved through normal
+*     `@zenbujs/core/...` resolution at runtime)
+*
+* Both call sites operate on the apps-dir (`~/.zenbu/apps/<name>/`) and
+* the .app's `Resources/` (where `provisionToolchain` staged
+* `bun`, `pnpm`, etc.). The launcher kicks off the FIRST install at
+* launch; the updater service runs the SAME logic when an `update()`
+* lockfile-diff says deps drifted.
+*/
+function lockfileFor(type) {
+	switch (type) {
+		case "pnpm": return "pnpm-lock.yaml";
+		case "npm": return "package-lock.json";
+		case "yarn": return "yarn.lock";
+		case "bun": return "bun.lock";
+	}
+}
+function isYarnBerry(version) {
+	const major = parseInt(version.split(".")[0] ?? "", 10);
+	return Number.isFinite(major) && major >= 2;
+}
+function bundledToolPath(name, resourcesPath) {
+	const candidates = [path.join(resourcesPath, "toolchain", "bin", name), path.join(resourcesPath, "toolchain", name)];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	return null;
+}
+/**
+* Resolve the entrypoint we'll exec for a given PM, mirroring the layout
+* `provisionToolchain` writes into the bundle's `Resources/toolchain/`.
+*/
+function bundledPmEntry(pm, resourcesPath) {
+	switch (pm.type) {
+		case "pnpm": {
+			const p = path.join(resourcesPath, "toolchain", "pnpm", "bin", "pnpm.cjs");
+			if (!existsSync(p)) throw new Error(`bundled pnpm entry not found at ${p}. The .app's toolchain is incomplete.`);
+			return {
+				kind: "js",
+				path: p
+			};
+		}
+		case "npm": {
+			const p = path.join(resourcesPath, "toolchain", "npm", "bin", "npm-cli.js");
+			if (!existsSync(p)) throw new Error(`bundled npm entry not found at ${p}. The .app's toolchain is incomplete.`);
+			return {
+				kind: "js",
+				path: p
+			};
+		}
+		case "yarn": {
+			if (isYarnBerry(pm.version)) {
+				const p = path.join(resourcesPath, "toolchain", "yarn.cjs");
+				if (!existsSync(p)) throw new Error(`bundled yarn (berry) entry not found at ${p}. The .app's toolchain is incomplete.`);
+				return {
+					kind: "js",
+					path: p
+				};
+			}
+			const p = path.join(resourcesPath, "toolchain", "yarn", "bin", "yarn.js");
+			if (!existsSync(p)) throw new Error(`bundled yarn (classic) entry not found at ${p}. The .app's toolchain is incomplete.`);
+			return {
+				kind: "js",
+				path: p
+			};
+		}
+		case "bun": return { kind: "bun" };
+	}
+}
+function electronTargetVersion(appsDir) {
+	if (process.versions.electron) return process.versions.electron;
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(appsDir, "package.json"), "utf8"));
+		return (pkg.devDependencies?.electron ?? pkg.dependencies?.electron ?? "").replace(/^[^\d]*/, "") || "42.0.0";
+	} catch {
+		return "42.0.0";
+	}
+}
+function buildInstallEnv(appsDir) {
+	const target = electronTargetVersion(appsDir);
+	return {
+		...process.env,
+		CI: "true",
+		HOME: path.join(appsDir, ".zenbu", ".node-gyp"),
+		npm_config_runtime: "electron",
+		npm_config_target: target,
+		npm_config_disturl: "https://electronjs.org/headers",
+		npm_config_arch: process.arch
+	};
+}
+/**
+* Best-effort progress regex per package manager. We pass each stdout line
+* through these and return a `progress` payload when one matches; otherwise
+* `null`. Failing to match is fine — the UI just won't show fine-grained
+* progress for that PM.
+*/
+const PNPM_RESOLVED_RE = /Progress:\s+resolved\s+(\d+),\s+reused\s+(\d+),\s+downloaded\s+(\d+)/i;
+const PNPM_PROGRESS_RE = /(\d+)\s*\/\s*(\d+)/;
+function parseInstallProgress(pm, line) {
+	if (pm === "pnpm") {
+		const m = line.match(PNPM_RESOLVED_RE);
+		if (m) {
+			const resolved = parseInt(m[1], 10);
+			const reused = parseInt(m[2], 10);
+			const downloaded = parseInt(m[3], 10);
+			return {
+				phase: "resolve",
+				loaded: reused + downloaded,
+				total: resolved,
+				ratio: resolved > 0 ? (reused + downloaded) / resolved : void 0
+			};
+		}
+	}
+	const m = line.match(PNPM_PROGRESS_RE);
+	if (m) {
+		const loaded = parseInt(m[1], 10);
+		const total = parseInt(m[2], 10);
+		if (total > 0) return {
+			loaded,
+			total,
+			ratio: loaded / total
+		};
+	}
+	return null;
+}
+function spawnInstall(args) {
+	const { bin, cliArgs, cwd, env, label, pmType, reporter, signal } = args;
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(/* @__PURE__ */ new Error(`${label} aborted before start`));
+			return;
+		}
+		const usePiped = reporter != null;
+		const child = spawn(bin, cliArgs, {
+			cwd,
+			stdio: usePiped ? [
+				"inherit",
+				"pipe",
+				"pipe"
+			] : "inherit",
+			env
+		});
+		const onAbort = () => {
+			try {
+				child.kill("SIGTERM");
+			} catch {}
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (usePiped) {
+			const wireStream = (stream, which) => {
+				if (!stream) return;
+				let buf = "";
+				stream.setEncoding("utf8");
+				stream.on("data", (chunk) => {
+					buf += chunk;
+					let nl;
+					while ((nl = buf.indexOf("\n")) >= 0) {
+						const rawLine = buf.slice(0, nl);
+						buf = buf.slice(nl + 1);
+						reporter?.rawLine?.(which, rawLine);
+						const line = rawLine.replace(/\r/g, "").trimEnd();
+						if (!line) continue;
+						reporter?.message?.(line);
+						const progress = parseInstallProgress(pmType, line);
+						if (progress) reporter?.progress?.(progress);
+					}
+				});
+				stream.on("end", () => {
+					if (buf.length > 0) {
+						reporter?.rawLine?.(which, buf);
+						const line = buf.replace(/\r/g, "").trimEnd();
+						if (line) reporter?.message?.(line);
+					}
+				});
+			};
+			wireStream(child.stdout, "stdout");
+			wireStream(child.stderr, "stderr");
+		}
+		child.on("error", (err) => {
+			signal?.removeEventListener("abort", onAbort);
+			reject(err);
+		});
+		child.on("close", (code, sig) => {
+			signal?.removeEventListener("abort", onAbort);
+			if (code === 0) resolve();
+			else if (signal?.aborted) reject(/* @__PURE__ */ new Error(`${label} aborted (${sig ?? code})`));
+			else reject(/* @__PURE__ */ new Error(`${label} exited with code ${code}`));
+		});
+	});
+}
+async function runInstall(opts) {
+	const { appsDir, resourcesPath, pm, reporter = null, signal } = opts;
+	const env = buildInstallEnv(appsDir);
+	const entry = bundledPmEntry(pm, resourcesPath);
+	switch (pm.type) {
+		case "pnpm": {
+			if (entry.kind !== "js") throw new Error("internal: pnpm entry shape");
+			const bun = bundledToolPath("bun", resourcesPath);
+			if (!bun) throw new Error(`bundled bun not found in ${resourcesPath}/toolchain (required to host the pnpm.cjs entry)`);
+			await spawnInstall({
+				bin: bun,
+				cliArgs: [
+					entry.path,
+					"install",
+					"--reporter=append-only"
+				],
+				cwd: appsDir,
+				env,
+				label: "pnpm install",
+				pmType: pm.type,
+				reporter,
+				signal
+			});
+			return;
+		}
+		case "npm": {
+			if (entry.kind !== "js") throw new Error("internal: npm entry shape");
+			const bun = bundledToolPath("bun", resourcesPath);
+			if (!bun) throw new Error(`bundled bun not found in ${resourcesPath}/toolchain (required to host the npm-cli.js entry)`);
+			await spawnInstall({
+				bin: bun,
+				cliArgs: [
+					entry.path,
+					"install",
+					"--no-audit",
+					"--no-fund",
+					"--no-progress"
+				],
+				cwd: appsDir,
+				env,
+				label: "npm install",
+				pmType: pm.type,
+				reporter,
+				signal
+			});
+			return;
+		}
+		case "yarn": {
+			if (entry.kind !== "js") throw new Error("internal: yarn entry shape");
+			const bun = bundledToolPath("bun", resourcesPath);
+			if (!bun) throw new Error(`bundled bun not found in ${resourcesPath}/toolchain (required to host the yarn.js entry)`);
+			if (isYarnBerry(pm.version)) await spawnInstall({
+				bin: bun,
+				cliArgs: [entry.path, "install"],
+				cwd: appsDir,
+				env: {
+					...env,
+					YARN_ENABLE_IMMUTABLE_INSTALLS: "false"
+				},
+				label: `yarn install (${pm.version})`,
+				pmType: pm.type,
+				reporter,
+				signal
+			});
+			else {
+				const rcPath = path.join(appsDir, ".zenbu", "yarn-classic-bun.yarnrc");
+				await fsp.mkdir(path.dirname(rcPath), { recursive: true });
+				await fsp.writeFile(rcPath, "strict-ssl false\n");
+				await spawnInstall({
+					bin: bun,
+					cliArgs: [
+						entry.path,
+						"install",
+						"--non-interactive",
+						"--no-progress",
+						"--network-timeout",
+						"600000",
+						"--use-yarnrc",
+						rcPath,
+						"--registry",
+						"https://registry.npmjs.org/"
+					],
+					cwd: appsDir,
+					env,
+					label: `yarn install (${pm.version})`,
+					pmType: pm.type,
+					reporter,
+					signal
+				});
+			}
+			return;
+		}
+		case "bun": {
+			const bun = bundledToolPath("bun", resourcesPath);
+			if (!bun) throw new Error(`bundled bun not found in ${resourcesPath}/toolchain. The .app is missing required toolchain binaries.`);
+			await spawnInstall({
+				bin: bun,
+				cliArgs: ["install", "--no-progress"],
+				cwd: appsDir,
+				env,
+				label: "bun install",
+				pmType: pm.type,
+				reporter,
+				signal
+			});
+			return;
+		}
+	}
+}
+async function fileHash(hash, filePath) {
+	hash.update(filePath);
+	hash.update("\0");
+	try {
+		hash.update(await fsp.readFile(filePath));
+	} catch {}
+	hash.update("\0");
+}
+async function depsSignature(appsDir, pm) {
+	const hash = crypto.createHash("sha256");
+	await fileHash(hash, path.join(appsDir, "package.json"));
+	await fileHash(hash, path.join(appsDir, lockfileFor(pm.type)));
+	hash.update(`${pm.type}@${pm.version}`);
+	hash.update("\0");
+	hash.update(process.versions.electron ?? "no-electron");
+	hash.update("\0");
+	hash.update(process.platform);
+	hash.update("\0");
+	hash.update(process.arch);
+	return hash.digest("hex");
+}
+/**
+* Read `<appsDir>/.zenbu/deps-sig` (the signature recorded after the
+* last successful install). Returns `null` when missing.
+*/
+async function readDepsSig(appsDir) {
+	const sigPath = path.join(appsDir, ".zenbu", "deps-sig");
+	try {
+		return await fsp.readFile(sigPath, "utf8");
+	} catch {
+		return null;
+	}
+}
+async function writeDepsSig(appsDir, sig) {
+	const sigPath = path.join(appsDir, ".zenbu", "deps-sig");
+	await fsp.mkdir(path.dirname(sigPath), { recursive: true });
+	await fsp.writeFile(sigPath, sig);
+}
+//#endregion
+//#region src/services/updater.ts
+/**
+* Atomic, thin wrappers over `isomorphic-git` plus a single `install()`
+* primitive over `runInstall`. Each public method is one underlying
+* call; callers compose update flows themselves.
+*
+* `getAppContext()` is a read-only convenience that surfaces the
+* running .app's `app-config.json` + `host.json` so callers don't have
+* to re-parse them. It returns `null` in dev or when the bundle is
+* missing those files.
+*/
+var updater_exports = /* @__PURE__ */ __exportAll({ UpdaterService: () => UpdaterService });
+const log = createLogger("updater");
+const LEGACY_PACKAGE_MANAGER = {
+	type: "pnpm",
+	version: "10.33.0"
+};
+function isBundleMode() {
+	return process.env.ZENBU_LAUNCHED_FROM_BUNDLE === "1";
+}
+function readAppConfig(appPath) {
+	const configPath = path.join(appPath, "app-config.json");
+	try {
+		return JSON.parse(fs.readFileSync(configPath, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function appsDirFor(name) {
+	if (process.env.ZENBU_APPS_DIR) return path.resolve(process.env.ZENBU_APPS_DIR);
+	return path.join(os.homedir(), ".zenbu", "apps", name);
+}
+var UpdaterService = class extends Service.create({ key: "updater" }) {
+	evaluate() {
+		log.verbose(`updater service ready (mode=${isBundleMode() ? "bundle" : "dev"})`);
+	}
+	/**
+	* Snapshot of the running .app's mirror + toolchain. Returns `null`
+	* in dev (no bundle) or when `app-config.json` / `host.json` are
+	* missing. No side effects.
+	*/
+	async getAppContext() {
+		if (!isBundleMode()) return null;
+		const appPath = app.getAppPath();
+		const cfg = readAppConfig(appPath);
+		if (!cfg || !cfg.mirrorUrl) return null;
+		const host = tryReadHostVersion(appPath);
+		if (!host) return null;
+		return {
+			appsDir: appsDirFor(cfg.name),
+			resourcesPath: path.dirname(appPath),
+			mirror: {
+				url: cfg.mirrorUrl,
+				branch: cfg.branch ?? "main"
+			},
+			packageManager: cfg.packageManager ?? LEGACY_PACKAGE_MANAGER,
+			hostVersion: host.version,
+			appName: cfg.name
+		};
+	}
+	async fetch(opts) {
+		return git.fetch({
+			fs,
+			http,
+			...opts
+		});
+	}
+	async clone(opts) {
+		await git.clone({
+			fs,
+			http,
+			...opts
+		});
+	}
+	async checkout(opts) {
+		await git.checkout({
+			fs,
+			...opts
+		});
+	}
+	async resolveRef(opts) {
+		return git.resolveRef({
+			fs,
+			...opts
+		});
+	}
+	async statusMatrix(opts) {
+		return git.statusMatrix({
+			fs,
+			...opts
+		});
+	}
+	async log(opts) {
+		return git.log({
+			fs,
+			...opts
+		});
+	}
+	/**
+	* Run `<pm> install` in `dir` using the bundled toolchain at
+	* `resourcesPath`. Always runs; no signature gating. Compose with
+	* `getDepsSignature` / `readDepsSignature` / `writeDepsSignature`
+	* if you want a skip-when-clean gate.
+	*/
+	async install(opts) {
+		await runInstall({
+			appsDir: opts.dir,
+			resourcesPath: opts.resourcesPath,
+			pm: opts.pm
+		});
+	}
+	async getDepsSignature(opts) {
+		return depsSignature(opts.dir, opts.pm);
+	}
+	async readDepsSignature(opts) {
+		return readDepsSig(opts.dir);
+	}
+	async writeDepsSignature(opts) {
+		await writeDepsSig(opts.dir, opts.sig);
+	}
+};
+runtime.register(UpdaterService, import.meta);
+//#endregion
+export { updater_exports as n, UpdaterService as t };

package/dist/{vite-plugins-tt6KAtyE.mjs → vite-plugins-Df-cfldF.mjs}

@@ -1,6 +1,5 @@
-import { getPlugins } from "./runtime.mjs";
-import { n as require_lib, t as zenbuAdviceTransform$1 } from "./transform-BzrwkEdf.mjs";
-import { a as getAllTypes, i as getAllContentScriptPaths, n as getAdvice, o as getContentScripts } from "./advice-config-DXSIo0sg.mjs";
+import { b as getContentScripts, g as getAdvice, v as getAllContentScriptPaths, y as getAllTypes } from "./runtime-DYUONc3S.mjs";
+import { n as require_lib, t as zenbuAdviceTransform$1 } from "./transform-czrcGnVV.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 //#region ../advice/src/vite.ts
@@ -99,47 +98,6 @@ function zenbuFrameworkResolve() {
 				] },
 				server: { fs: { allow: [CORE_PACKAGE_ROOT] } }
 			};
-		},
-		/**
-		* Vite's built-in tsconfig watcher (`reloadOnTsconfigChange` in
-		* `plugins/esbuild.ts`) only triggers a cache-clear + full reload when
-		* the changed path ends in exactly `/tsconfig.json` — non-canonical
-		* names like `tsconfig.local.json` are silently ignored even though the
-		* underlying chokidar watcher does fire on them. We use that pattern
-		* (a committed `tsconfig.json` that extends a generated, gitignored
-		* `tsconfig.local.json`) so plugin sources can `#registry/*`-import
-		* the host's typed registry without a host-specific path leaking into
-		* a committed file.
-		*
-		* Without this hook, every `zen link` run would silently leave esbuild
-		* with a stale "extends target missing" cache and plugin sources would
-		* fail to load until the dev process is killed by hand. This watches
-		* the plugin directories declared in the host's `config.json` and
-		* proactively calls `server.restart()` on add/change/unlink of any
-		* `tsconfig.local.json`.
-		*/
-		configureServer(server) {
-			const tsconfigPaths = getPlugins().map((p) => path.join(p.dir, "tsconfig.local.json"));
-			if (tsconfigPaths.length === 0) return;
-			server.watcher.add(tsconfigPaths);
-			let restarting = false;
-			const handle = (file) => {
-				if (!file.endsWith("tsconfig.local.json")) return;
-				if (restarting) return;
-				restarting = true;
-				server.config.logger.info(`[zenbu] ${file} changed — restarting Vite to refresh tsconfig (vite's built-in watcher only fires on /tsconfig.json)`, {
-					timestamp: true,
-					clear: false
-				});
-				server.restart().catch((err) => {
-					server.config.logger.error(`[zenbu] vite restart failed: ${err instanceof Error ? err.message : String(err)}`);
-				}).finally(() => {
-					restarting = false;
-				});
-			};
-			server.watcher.on("add", handle);
-			server.watcher.on("change", handle);
-			server.watcher.on("unlink", handle);
 		}
 	};
 }
@@ -294,11 +252,6 @@ function zenbuAdviceTransform() {
 	};
 }
 /**
-* Returns the framework Vite plugins in the canonical order. Auto-injected
-* by `ReloaderService` for every renderer; exported for advanced users who
-* want to compose them into a custom Vite stack.
-*
-* Order matters:
 *   1. `zenbuFrameworkResolve` — `enforce: "pre"`, runs first so it gets
 *      `react` / `@zenbujs/core/*` *before* Vite's default resolver walks
 *      up and finds plugin-local copies.