@fased/fased 0.1.42 → 0.1.43

package/dist/infra/state-migrations.fs.js

@@ -1,27 +1,27 @@
-import syncFs from "node:fs";
+import fs from "node:fs";
 import JSON5 from "json5";
 
 //#region src/infra/state-migrations.fs.ts
 function safeReadDir(dir) {
 	try {
-		return syncFs.readdirSync(dir, { withFileTypes: true });
+		return fs.readdirSync(dir, { withFileTypes: true });
 	} catch {
 		return [];
 	}
 }
 function existsDir(dir) {
 	try {
-		return syncFs.existsSync(dir) && syncFs.statSync(dir).isDirectory();
+		return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
 	} catch {
 		return false;
 	}
 }
 function ensureDir(dir) {
-	syncFs.mkdirSync(dir, { recursive: true });
+	fs.mkdirSync(dir, { recursive: true });
 }
 function fileExists(p) {
 	try {
-		return syncFs.existsSync(p) && syncFs.statSync(p).isFile();
+		return fs.existsSync(p) && fs.statSync(p).isFile();
 	} catch {
 		return false;
 	}
@@ -37,7 +37,7 @@ function isLegacyWhatsAppAuthFile(name) {
 }
 function readSessionStoreJson5(storePath) {
 	try {
-		const raw = syncFs.readFileSync(storePath, "utf-8");
+		const raw = fs.readFileSync(storePath, "utf-8");
 		const parsed = JSON5.parse(raw);
 		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
 			return {

package/dist/infra/state-migrations.js

@@ -8,7 +8,7 @@ import { canonicalizeMainSessionAlias } from "../config/sessions/main-session.js
 import { saveSessionStore } from "../config/sessions/store.js";
 import "../config/sessions.js";
 import { ensureDir, existsDir, fileExists, isLegacyWhatsAppAuthFile, readSessionStoreJson5, safeReadDir } from "./state-migrations.fs.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
@@ -241,7 +241,7 @@ function removeDirIfEmpty(dir) {
 		return;
 	}
 	try {
-		syncFs.rmdirSync(dir);
+		fs.rmdirSync(dir);
 	} catch {}
 }
 function resetAutoMigrateLegacyStateForTest() {
@@ -255,7 +255,7 @@ function resetAutoMigrateLegacyStateDirForTest() {
 }
 function resolveSymlinkTarget(linkPath) {
 	try {
-		const target = syncFs.readlinkSync(linkPath);
+		const target = fs.readlinkSync(linkPath);
 		return path.resolve(path.dirname(linkPath), target);
 	} catch {
 		return null;
@@ -266,7 +266,7 @@ function formatStateDirMigration(legacyDir, targetDir) {
 }
 function isDirPath(filePath) {
 	try {
-		return syncFs.statSync(filePath).isDirectory();
+		return fs.statSync(filePath).isDirectory();
 	} catch {
 		return false;
 	}
@@ -274,7 +274,7 @@ function isDirPath(filePath) {
 function isLegacyTreeSymlinkMirror(currentDir, realTargetDir) {
 	let entries;
 	try {
-		entries = syncFs.readdirSync(currentDir, { withFileTypes: true });
+		entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	} catch {
 		return false;
 	}
@@ -285,7 +285,7 @@ function isLegacyTreeSymlinkMirror(currentDir, realTargetDir) {
 		const entryPath = path.join(currentDir, entry.name);
 		let stat;
 		try {
-			stat = syncFs.lstatSync(entryPath);
+			stat = fs.lstatSync(entryPath);
 		} catch {
 			return false;
 		}
@@ -296,7 +296,7 @@ function isLegacyTreeSymlinkMirror(currentDir, realTargetDir) {
 			}
 			let resolvedRealTarget;
 			try {
-				resolvedRealTarget = syncFs.realpathSync(resolvedTarget);
+				resolvedRealTarget = fs.realpathSync(resolvedTarget);
 			} catch {
 				return false;
 			}
@@ -318,7 +318,7 @@ function isLegacyTreeSymlinkMirror(currentDir, realTargetDir) {
 function isLegacyDirSymlinkMirror(legacyDir, targetDir) {
 	let realTargetDir;
 	try {
-		realTargetDir = syncFs.realpathSync(targetDir);
+		realTargetDir = fs.realpathSync(targetDir);
 	} catch {
 		return false;
 	}
@@ -348,7 +348,7 @@ async function autoMigrateLegacyStateDir(params) {
 	const legacyDirs = resolveLegacyStateDirs(homedir);
 	let legacyDir = legacyDirs.find((dir) => {
 		try {
-			return syncFs.existsSync(dir);
+			return fs.existsSync(dir);
 		} catch {
 			return false;
 		}
@@ -357,7 +357,7 @@ async function autoMigrateLegacyStateDir(params) {
 	const changes = [];
 	let legacyStat = null;
 	try {
-		legacyStat = legacyDir ? syncFs.lstatSync(legacyDir) : null;
+		legacyStat = legacyDir ? fs.lstatSync(legacyDir) : null;
 	} catch {
 		legacyStat = null;
 	}
@@ -401,7 +401,7 @@ async function autoMigrateLegacyStateDir(params) {
 		if (legacyDirs.some((dir) => path.resolve(dir) === path.resolve(legacyTarget))) {
 			legacyDir = legacyTarget;
 			try {
-				legacyStat = syncFs.lstatSync(legacyDir);
+				legacyStat = fs.lstatSync(legacyDir);
 			} catch {
 				legacyStat = null;
 			}
@@ -464,7 +464,7 @@ async function autoMigrateLegacyStateDir(params) {
 		if (!legacyDir) {
 			throw new Error("Legacy state dir not found");
 		}
-		syncFs.renameSync(legacyDir, targetDir);
+		fs.renameSync(legacyDir, targetDir);
 	} catch (err) {
 		warnings.push(`Failed to move legacy state dir (${legacyDir ?? "unknown"} → ${targetDir}): ${String(err)}`);
 		return {
@@ -478,7 +478,7 @@ async function autoMigrateLegacyStateDir(params) {
 		if (!legacyDir) {
 			throw new Error("Legacy state dir not found");
 		}
-		syncFs.symlinkSync(targetDir, legacyDir, "dir");
+		fs.symlinkSync(targetDir, legacyDir, "dir");
 		changes.push(formatStateDirMigration(legacyDir, targetDir));
 	} catch (err) {
 		try {
@@ -486,7 +486,7 @@ async function autoMigrateLegacyStateDir(params) {
 				if (!legacyDir) {
 					throw new Error("Legacy state dir not found", { cause: err });
 				}
-				syncFs.symlinkSync(targetDir, legacyDir, "junction");
+				fs.symlinkSync(targetDir, legacyDir, "junction");
 				changes.push(formatStateDirMigration(legacyDir, targetDir));
 			} else {
 				throw err;
@@ -496,7 +496,7 @@ async function autoMigrateLegacyStateDir(params) {
 				if (!legacyDir) {
 					throw new Error("Legacy state dir not found", { cause: fallbackErr });
 				}
-				syncFs.renameSync(targetDir, legacyDir);
+				fs.renameSync(targetDir, legacyDir);
 				warnings.push(`State dir migration rolled back (failed to link legacy path): ${String(fallbackErr)}`);
 				return {
 					migrated: false,
@@ -682,7 +682,7 @@ async function migrateLegacySessions(detected, now) {
 			continue;
 		}
 		try {
-			syncFs.renameSync(from, to);
+			fs.renameSync(from, to);
 			changes.push(`Moved ${entry.name} → agents/${detected.targetAgentId}/sessions`);
 		} catch (err) {
 			warnings.push(`Failed moving ${from}: ${String(err)}`);
@@ -691,7 +691,7 @@ async function migrateLegacySessions(detected, now) {
 	if (legacyParsed.ok) {
 		try {
 			if (fileExists(detected.sessions.legacyStorePath)) {
-				syncFs.rmSync(detected.sessions.legacyStorePath, { force: true });
+				fs.rmSync(detected.sessions.legacyStorePath, { force: true });
 			}
 		} catch {}
 	}
@@ -700,7 +700,7 @@ async function migrateLegacySessions(detected, now) {
 	if (legacyLeft.length > 0) {
 		const backupDir = `${detected.sessions.legacyDir}.legacy-${now()}`;
 		try {
-			syncFs.renameSync(detected.sessions.legacyDir, backupDir);
+			fs.renameSync(detected.sessions.legacyDir, backupDir);
 			warnings.push(`Left legacy sessions at ${backupDir}`);
 		} catch {}
 	}
@@ -723,11 +723,11 @@ async function migrateLegacyAgentDir(detected, now) {
 	for (const entry of entries) {
 		const from = path.join(detected.agentDir.legacyDir, entry.name);
 		const to = path.join(detected.agentDir.targetDir, entry.name);
-		if (syncFs.existsSync(to)) {
+		if (fs.existsSync(to)) {
 			continue;
 		}
 		try {
-			syncFs.renameSync(from, to);
+			fs.renameSync(from, to);
 			changes.push(`Moved agent file ${entry.name} → agents/${detected.targetAgentId}/agent`);
 		} catch (err) {
 			warnings.push(`Failed moving ${from}: ${String(err)}`);
@@ -737,7 +737,7 @@ async function migrateLegacyAgentDir(detected, now) {
 	if (!emptyDirOrMissing(detected.agentDir.legacyDir)) {
 		const backupDir = path.join(detected.stateDir, "agents", detected.targetAgentId, `agent.legacy-${now()}`);
 		try {
-			syncFs.renameSync(detected.agentDir.legacyDir, backupDir);
+			fs.renameSync(detected.agentDir.legacyDir, backupDir);
 			warnings.push(`Left legacy agent dir at ${backupDir}`);
 		} catch (err) {
 			warnings.push(`Failed relocating legacy agent dir: ${String(err)}`);
@@ -775,7 +775,7 @@ async function migrateLegacyWhatsAppAuth(detected) {
 			continue;
 		}
 		try {
-			syncFs.renameSync(from, to);
+			fs.renameSync(from, to);
 			changes.push(`Moved WhatsApp auth ${entry.name} → whatsapp/default`);
 		} catch (err) {
 			warnings.push(`Failed moving ${from}: ${String(err)}`);
@@ -799,7 +799,7 @@ async function migrateLegacyTelegramPairingAllowFrom(detected) {
 	const targetPath = detected.pairingAllowFrom.targetTelegramPath;
 	try {
 		ensureDir(path.dirname(targetPath));
-		syncFs.copyFileSync(legacyPath, targetPath);
+		fs.copyFileSync(legacyPath, targetPath);
 		changes.push(`Copied Telegram pairing allowFrom → ${targetPath}`);
 	} catch (err) {
 		warnings.push(`Failed migrating Telegram pairing allowFrom (${legacyPath}): ${String(err)}`);

package/dist/infra/tmp-fased-dir.js

@@ -1,18 +1,18 @@
-import syncFs from "node:fs";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
 //#region src/infra/tmp-fased-dir.ts
 const POSIX_FASED_TMP_DIR = "/tmp/fased";
-const TMP_DIR_ACCESS_MODE = syncFs.constants.W_OK | syncFs.constants.X_OK;
+const TMP_DIR_ACCESS_MODE = fs.constants.W_OK | fs.constants.X_OK;
 function isNodeErrorWithCode(err, code) {
 	return typeof err === "object" && err !== null && "code" in err && err.code === code;
 }
 function resolvePreferredFasedAgentTmpDir(options = {}) {
-	const accessSync = options.accessSync ?? syncFs.accessSync;
-	const chmodSync = options.chmodSync ?? syncFs.chmodSync;
-	const lstatSync = options.lstatSync ?? syncFs.lstatSync;
-	const mkdirSync = options.mkdirSync ?? syncFs.mkdirSync;
+	const accessSync = options.accessSync ?? fs.accessSync;
+	const chmodSync = options.chmodSync ?? fs.chmodSync;
+	const lstatSync = options.lstatSync ?? fs.lstatSync;
+	const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
 	const warn = options.warn ?? ((message) => console.warn(message));
 	const getuid = options.getuid ?? (() => {
 		try {

package/dist/infra/update-global.js

@@ -53,6 +53,7 @@ function resolveHostedNpmInstallTarget(pkgRoot) {
 	return {
 		manager: "npm",
 		globalRoot,
+		cacheRoot: path.dirname(prefix),
 		env: {
 			npm_config_prefix: prefix,
 			npm_config_cache: cache

package/dist/infra/update-runner.js

@@ -487,6 +487,7 @@ async function runHostedArtifactUpdate(params) {
 			kind: "updated",
 			steps,
 			afterVersion,
+			reason: "package artifact swap",
 			transaction: {
 				kind: "package-root-swap",
 				packageRoot: params.pkgRoot,
@@ -508,6 +509,96 @@ async function pathExists(pathname) {
 		return false;
 	}
 }
+async function seedHostedDependencyLayerFromCurrent(params) {
+	const currentMetadata = await readHostedRuntimeMetadata(params.pkgRoot);
+	if (currentMetadata?.dependencyHash !== params.dependencyHash) {
+		return false;
+	}
+	const currentModules = path.join(params.pkgRoot, "node_modules");
+	const dependencyModules = path.join(params.dependencyRoot, "node_modules");
+	let currentStat;
+	try {
+		currentStat = await fs.lstat(currentModules);
+	} catch {
+		return false;
+	}
+	if (currentStat.isSymbolicLink()) {
+		try {
+			const currentModulesReal = await fs.realpath(currentModules);
+			if (currentModulesReal === await fs.realpath(dependencyModules).catch(() => "")) {
+				return true;
+			}
+			const legacyDependencyRoot = path.dirname(currentModulesReal);
+			const legacyDependencyParent = path.dirname(legacyDependencyRoot);
+			const recognizedLegacyLayer = path.basename(currentModulesReal) === "node_modules" && path.basename(legacyDependencyRoot) === params.dependencyHash && path.basename(legacyDependencyParent) === ".fased-dependencies";
+			if (!recognizedLegacyLayer) {
+				return false;
+			}
+			const nextLink = path.join(params.pkgRoot, `.node_modules-link-${process.pid}-${Date.now()}`);
+			const previousLink = path.join(params.pkgRoot, `.node_modules-previous-${process.pid}-${Date.now()}`);
+			let layerMoved = false;
+			let linkReplaced = false;
+			await fs.mkdir(path.dirname(params.dependencyRoot), { recursive: true });
+			try {
+				await fs.symlink(dependencyModules, nextLink, "dir");
+				await fs.rename(legacyDependencyRoot, params.dependencyRoot);
+				layerMoved = true;
+				await fs.rename(currentModules, previousLink);
+				await fs.rename(nextLink, currentModules);
+				linkReplaced = true;
+				await safeRemove(previousLink);
+				return true;
+			} catch (error) {
+				if (linkReplaced) {
+					await safeRemove(currentModules);
+				}
+				if (await pathExists(previousLink)) {
+					await fs.rename(previousLink, currentModules).catch(() => undefined);
+				}
+				if (layerMoved) {
+					await fs.rename(params.dependencyRoot, legacyDependencyRoot).catch(() => undefined);
+				}
+				await safeRemove(nextLink);
+				throw error;
+			}
+		} catch {
+			return false;
+		}
+	}
+	if (!currentStat.isDirectory()) {
+		return false;
+	}
+	const dependencyParent = path.dirname(params.dependencyRoot);
+	const stagingRoot = `${params.dependencyRoot}.staging-${process.pid}-${Date.now()}`;
+	const linkPath = path.join(params.pkgRoot, `.node_modules-link-${process.pid}-${Date.now()}`);
+	let modulesMoved = false;
+	let layerActivated = false;
+	await fs.mkdir(dependencyParent, { recursive: true });
+	if (await pathExists(params.dependencyRoot)) {
+		await safeRemove(params.dependencyRoot);
+	}
+	try {
+		await fs.symlink(dependencyModules, linkPath, "dir");
+		await fs.mkdir(stagingRoot, { recursive: true });
+		await fs.rename(currentModules, path.join(stagingRoot, "node_modules"));
+		modulesMoved = true;
+		await fs.rename(stagingRoot, params.dependencyRoot);
+		layerActivated = true;
+		await fs.rename(linkPath, currentModules);
+		return true;
+	} catch (error) {
+		await safeRemove(linkPath);
+		if (!await pathExists(currentModules)) {
+			const rollbackSource = path.join(layerActivated ? params.dependencyRoot : stagingRoot, "node_modules");
+			if (modulesMoved && await pathExists(rollbackSource)) {
+				await fs.rename(rollbackSource, currentModules).catch(() => undefined);
+			}
+		}
+		throw error;
+	} finally {
+		await safeRemove(stagingRoot);
+	}
+}
 async function runHostedLayeredArtifactUpdate(params) {
 	const packageParent = path.dirname(params.pkgRoot);
 	const tempRoot = await fs.mkdtemp(path.join(packageParent, ".fased-layered-update-"));
@@ -601,9 +692,19 @@ async function runHostedLayeredArtifactUpdate(params) {
 				reason: "hosted app dependency metadata missing"
 			};
 		}
-		const dependencyParent = path.join(packageParent, ".fased-dependencies");
+		const dependencyParent = path.join(params.dependencyCacheRoot, "hosted-dependencies");
 		const dependencyRoot = path.join(dependencyParent, metadata.dependencyHash);
 		const dependencyModules = path.join(dependencyRoot, "node_modules");
+		if (!await pathExists(dependencyModules)) {
+			const currentMetadata = await readHostedRuntimeMetadata(params.pkgRoot);
+			if (currentMetadata?.dependencyHash === metadata.dependencyHash) {
+				await record("hosted dependency seed", `reuse current dependency layer ${metadata.dependencyHash.slice(0, 12)}`, async () => await seedHostedDependencyLayerFromCurrent({
+					pkgRoot: params.pkgRoot,
+					dependencyRoot,
+					dependencyHash: metadata.dependencyHash
+				}));
+			}
+		}
 		if (!await pathExists(dependencyModules)) {
 			const dependencyDescriptor = resolveHostedRuntimeDependencyArtifact({
 				version: params.expectedVersion,
@@ -664,33 +765,7 @@ async function runHostedLayeredArtifactUpdate(params) {
 				afterVersion: await readPackageVersion(params.pkgRoot)
 			};
 		}
-		const smokeHome = path.join(tempRoot, "smoke-home");
-		const smokeStateDir = path.join(smokeHome, ".fased");
-		await fs.mkdir(smokeStateDir, { recursive: true });
-		const smokeArgv = [
-			process.execPath,
-			path.join(artifactRoot, "fased.mjs"),
-			"plugins",
-			"doctor"
-		];
-		const smokeResult = await record("hosted layered verify", smokeArgv.join(" "), async () => await params.runCommand(smokeArgv, {
-			cwd: artifactRoot,
-			timeoutMs: params.timeoutMs,
-			env: {
-				...process.env,
-				HOME: smokeHome,
-				FASED_STATE_DIR: smokeStateDir,
-				FASED_CONFIG_PATH: path.join(smokeStateDir, "fased.json")
-			}
-		}));
-		if (smokeResult.code !== 0) {
-			return {
-				kind: "error",
-				steps,
-				reason: "layered hosted runtime verification failed",
-				afterVersion: await readPackageVersion(params.pkgRoot)
-			};
-		}
+		await record("hosted layered verify", `verify checksummed v${params.expectedVersion} runtime shape`, async () => undefined);
 		await record("hosted app swap", `replace ${params.pkgRoot}`, async () => {
 			const swapped = await swapPackageRoot({
 				pkgRoot: params.pkgRoot,
@@ -706,6 +781,7 @@ async function runHostedLayeredArtifactUpdate(params) {
 			kind: "updated",
 			steps,
 			afterVersion: await readPackageVersion(params.pkgRoot),
+			reason: "verified layered hosted runtime",
 			transaction: {
 				kind: "package-root-swap",
 				packageRoot: params.pkgRoot,
@@ -828,49 +904,18 @@ async function runHostedReleaseArtifactUpdate(params) {
 		const artifactRoot = path.join(extractDir, "package");
 		const artifactVersion = await readPackageVersion(artifactRoot);
 		const runtimeShapeReady = compareSemverStrings(artifactVersion, params.expectedVersion) === 0 && await pathExists(path.join(artifactRoot, "fased.mjs")) && await pathExists(path.join(artifactRoot, "node_modules"));
-		const smokeHome = path.join(tempRoot, "smoke-home");
-		const smokeStateDir = path.join(smokeHome, ".fased");
-		const smokeArgv = [
-			process.execPath,
-			path.join(artifactRoot, "fased.mjs"),
-			"plugins",
-			"doctor"
-		];
-		const verifyCommand = smokeArgv.join(" ");
+		const verifyCommand = `verify checksummed v${params.expectedVersion} runtime shape`;
 		const verifyInfo = startProgress("hosted artifact verify", verifyCommand, artifactRoot);
 		const verifyStarted = Date.now();
-		let smokeResult = null;
-		let smokeError = null;
-		if (runtimeShapeReady) {
-			try {
-				await fs.mkdir(smokeHome, { recursive: true });
-				smokeResult = await params.runCommand(smokeArgv, {
-					cwd: artifactRoot,
-					timeoutMs: params.timeoutMs,
-					env: {
-						...process.env,
-						HOME: smokeHome,
-						FASED_STATE_DIR: smokeStateDir,
-						FASED_CONFIG_PATH: path.join(smokeStateDir, "fased.json")
-					}
-				});
-			} catch (error) {
-				smokeError = String(error);
-			}
-		}
-		const runtimeReady = runtimeShapeReady && smokeResult?.code === 0;
-		const verifyFailure = !runtimeShapeReady ? `expected complete v${params.expectedVersion}, found ${artifactVersion ?? "unknown"}` : trimLogTail([
-			smokeResult?.stderr,
-			smokeResult?.stdout,
-			smokeError
-		].filter((value) => Boolean(value?.trim())).join("\n"), MAX_LOG_CHARS) || "hosted runtime CLI and plugin check failed";
+		const runtimeReady = runtimeShapeReady;
+		const verifyFailure = !runtimeShapeReady ? `expected complete v${params.expectedVersion}, found ${artifactVersion ?? "unknown"}` : "hosted runtime shape verification failed";
 		completeProgress(verifyInfo, {
 			name: "hosted artifact verify",
 			command: verifyCommand,
 			cwd: artifactRoot,
 			durationMs: Date.now() - verifyStarted,
 			exitCode: runtimeReady ? 0 : 1,
-			...runtimeReady ? { stdoutTail: `v${params.expectedVersion} CLI and bundled plugins passed` } : { stderrTail: verifyFailure }
+			...runtimeReady ? { stdoutTail: `checksummed v${params.expectedVersion} runtime shape passed` } : { stderrTail: verifyFailure }
 		});
 		if (!runtimeReady) {
 			return {
@@ -917,6 +962,7 @@ async function runHostedReleaseArtifactUpdate(params) {
 			kind: "updated",
 			steps,
 			afterVersion: await readPackageVersion(params.pkgRoot),
+			reason: "verified self-contained hosted runtime",
 			transaction: {
 				kind: "package-root-swap",
 				packageRoot: params.pkgRoot,
@@ -1624,6 +1670,7 @@ async function runGatewayUpdate(opts = {}) {
 					fetchImpl: releaseFetch,
 					baseUrl: opts.hostedReleaseBaseUrl ?? process.env.FASED_HOSTED_ARTIFACT_BASE_URL,
 					pkgRoot,
+					dependencyCacheRoot: hostedTarget.cacheRoot,
 					expectedVersion,
 					runCommand,
 					timeoutMs,
@@ -1636,7 +1683,7 @@ async function runGatewayUpdate(opts = {}) {
 						mode: globalManager,
 						strategy: {
 							kind: "hosted-artifact",
-							reason: "verified self-contained hosted runtime"
+							reason: releaseResult.reason
 						},
 						root: pkgRoot,
 						before: { version: beforeVersion },

package/dist/infra/widearea-dns.js

@@ -1,5 +1,5 @@
 import { CONFIG_DIR, ensureDir } from "../utils.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
@@ -126,7 +126,7 @@ async function writeWideAreaGatewayZone(opts) {
 	await ensureDir(path.dirname(zonePath));
 	const existing = (() => {
 		try {
-			return syncFs.readFileSync(zonePath, "utf-8");
+			return fs.readFileSync(zonePath, "utf-8");
 		} catch {
 			return null;
 		}
@@ -149,7 +149,7 @@ async function writeWideAreaGatewayZone(opts) {
 		...opts,
 		serial
 	});
-	syncFs.writeFileSync(zonePath, next, "utf-8");
+	fs.writeFileSync(zonePath, next, "utf-8");
 	return {
 		zonePath,
 		changed: true

package/dist/infra/wsl.js

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import fs from "node:fs/promises";
+import fs$1 from "node:fs/promises";
 
 //#region src/infra/wsl.ts
 let wslCached = null;
@@ -50,7 +50,7 @@ async function isWSL() {
 		return wslCached;
 	}
 	try {
-		const release = await fs.readFile("/proc/sys/kernel/osrelease", "utf8");
+		const release = await fs$1.readFile("/proc/sys/kernel/osrelease", "utf8");
 		wslCached = release.toLowerCase().includes("microsoft") || release.toLowerCase().includes("wsl");
 	} catch {
 		wslCached = false;