@fased/fased 0.1.48 → 0.1.49

package/dist/infra/exec-command-resolution.js

@@ -1,6 +1,6 @@
 import { expandHomePrefix } from "./home-dir.js";
 import { resolveDispatchWrapperExecutionPlan } from "./exec-wrapper-resolution.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/exec-command-resolution.ts
@@ -15,12 +15,12 @@ const DEFAULT_SAFE_BINS = [
 ];
 function isExecutableFile(filePath) {
 	try {
-		const stat = fs.statSync(filePath);
+		const stat = syncFs.statSync(filePath);
 		if (!stat.isFile()) {
 			return false;
 		}
 		if (process.platform !== "win32") {
-			fs.accessSync(filePath, fs.constants.X_OK);
+			syncFs.accessSync(filePath, syncFs.constants.X_OK);
 		}
 		return true;
 	} catch {
@@ -111,7 +111,7 @@ function normalizeMatchTarget(value) {
 }
 function tryRealpath(value) {
 	try {
-		return fs.realpathSync(value);
+		return syncFs.realpathSync(value);
 	} catch {
 		return null;
 	}

package/dist/infra/exec-safe-bin-trust.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/exec-safe-bin-trust.ts
@@ -61,7 +61,7 @@ function listWritableExplicitTrustedSafeBinDirs(entries) {
 	for (const dir of resolved) {
 		let stat;
 		try {
-			stat = fs.statSync(dir);
+			stat = syncFs.statSync(dir);
 		} catch {
 			continue;
 		}

package/dist/infra/fased-root.js

@@ -1,13 +1,13 @@
 import { fileURLToPath } from "node:url";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 
 //#region src/infra/fased-root.ts
 const CORE_PACKAGE_NAMES = new Set(["fased", "@fased/fased"]);
 async function readPackageName(dir) {
 	try {
-		const raw = await fs$1.readFile(path.join(dir, "package.json"), "utf-8");
+		const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8");
 		const parsed = JSON.parse(raw);
 		return typeof parsed.name === "string" ? parsed.name : null;
 	} catch {
@@ -16,7 +16,7 @@ async function readPackageName(dir) {
 }
 function readPackageNameSync(dir) {
 	try {
-		const raw = fs.readFileSync(path.join(dir, "package.json"), "utf-8");
+		const raw = syncFs.readFileSync(path.join(dir, "package.json"), "utf-8");
 		const parsed = JSON.parse(raw);
 		return typeof parsed.name === "string" ? parsed.name : null;
 	} catch {
@@ -56,7 +56,7 @@ function candidateDirsFromArgv1(argv1) {
 	const normalized = path.resolve(argv1);
 	const candidates = [path.dirname(normalized)];
 	try {
-		const resolved = fs.realpathSync(normalized);
+		const resolved = syncFs.realpathSync(normalized);
 		if (resolved !== normalized) {
 			candidates.push(path.dirname(resolved));
 		}

package/dist/infra/fs-safe.js

@@ -3,7 +3,7 @@ import { sameFileIdentity } from "./file-identity.js";
 import { assertNoPathAliasEscape } from "./path-alias-guards.js";
 import { constants } from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 
 //#region src/infra/fs-safe.ts
 var SafeOpenError = class extends Error {
@@ -25,7 +25,7 @@ async function openVerifiedLocalFile(filePath, options) {
 	let handle;
 	try {
 		const openFlags = options?.allowSymlinkTargetWithinRoot ? options.nonBlockingRead ? OPEN_READ_FOLLOW_NONBLOCK_FLAGS : OPEN_READ_FOLLOW_FLAGS : options?.nonBlockingRead ? OPEN_READ_NONBLOCK_FLAGS : OPEN_READ_FLAGS;
-		handle = await fs$1.open(filePath, openFlags);
+		handle = await fs.open(filePath, openFlags);
 	} catch (err) {
 		if (isNotFoundPathError(err)) {
 			throw new SafeOpenError("not-found", "file not found");
@@ -36,7 +36,7 @@ async function openVerifiedLocalFile(filePath, options) {
 		throw err;
 	}
 	try {
-		const [stat, pathStat] = await Promise.all([handle.stat(), options?.allowSymlinkTargetWithinRoot ? fs$1.stat(filePath) : fs$1.lstat(filePath)]);
+		const [stat, pathStat] = await Promise.all([handle.stat(), options?.allowSymlinkTargetWithinRoot ? fs.stat(filePath) : fs.lstat(filePath)]);
 		if (!options?.allowSymlinkTargetWithinRoot && pathStat.isSymbolicLink()) {
 			throw new SafeOpenError("symlink", "symlink not allowed");
 		}
@@ -49,8 +49,8 @@ async function openVerifiedLocalFile(filePath, options) {
 		if (!sameFileIdentity(stat, pathStat)) {
 			throw new SafeOpenError("path-mismatch", "path changed during read");
 		}
-		const realPath = await fs$1.realpath(filePath);
-		const realStat = await fs$1.stat(realPath);
+		const realPath = await fs.realpath(filePath);
+		const realStat = await fs.stat(realPath);
 		if (options?.rejectHardlinks && realStat.nlink > 1) {
 			throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
 		}
@@ -76,7 +76,7 @@ async function openVerifiedLocalFile(filePath, options) {
 async function openFileWithinRoot(params) {
 	let rootReal;
 	try {
-		rootReal = await fs$1.realpath(params.rootDir);
+		rootReal = await fs.realpath(params.rootDir);
 	} catch (err) {
 		if (isNotFoundPathError(err)) {
 			throw new SafeOpenError("not-found", "root dir not found");
@@ -154,7 +154,7 @@ async function readFileWithinRoot(params) {
 async function writeFileWithinRoot(params) {
 	let rootReal;
 	try {
-		rootReal = await fs$1.realpath(params.rootDir);
+		rootReal = await fs.realpath(params.rootDir);
 	} catch (err) {
 		if (isNotFoundPathError(err)) {
 			throw new SafeOpenError("not-found", "root dir not found");
@@ -176,7 +176,7 @@ async function writeFileWithinRoot(params) {
 		throw new SafeOpenError("invalid-path", "path alias escape blocked", { cause: err });
 	}
 	if (params.mkdir !== false) {
-		await fs$1.mkdir(path.dirname(resolved), { recursive: true });
+		await fs.mkdir(path.dirname(resolved), { recursive: true });
 	}
 	try {
 		await assertNoPathAliasEscape({
@@ -188,7 +188,7 @@ async function writeFileWithinRoot(params) {
 		throw new SafeOpenError("invalid-path", "path alias escape blocked", { cause: err });
 	}
 	try {
-		const pathStat = await fs$1.lstat(resolved);
+		const pathStat = await fs.lstat(resolved);
 		if (pathStat.isSymbolicLink()) {
 			throw new SafeOpenError("invalid-path", "symlink open blocked");
 		}
@@ -202,7 +202,7 @@ async function writeFileWithinRoot(params) {
 	}
 	let ioPath = resolved;
 	try {
-		const resolvedRealPath = await fs$1.realpath(resolved);
+		const resolvedRealPath = await fs.realpath(resolved);
 		if (!isPathInside(rootWithSep, resolvedRealPath)) {
 			throw new SafeOpenError("invalid-path", "path escapes root");
 		}
@@ -217,7 +217,7 @@ async function writeFileWithinRoot(params) {
 	}
 	let handle;
 	try {
-		handle = await fs$1.open(ioPath, OPEN_WRITE_FLAGS, 384);
+		handle = await fs.open(ioPath, OPEN_WRITE_FLAGS, 384);
 	} catch (err) {
 		if (isNotFoundPathError(err)) {
 			throw new SafeOpenError("not-found", "file not found");
@@ -228,7 +228,7 @@ async function writeFileWithinRoot(params) {
 		throw err;
 	}
 	try {
-		const [stat, lstat] = await Promise.all([handle.stat(), fs$1.lstat(ioPath)]);
+		const [stat, lstat] = await Promise.all([handle.stat(), fs.lstat(ioPath)]);
 		if (lstat.isSymbolicLink() || !stat.isFile()) {
 			throw new SafeOpenError("invalid-path", "path is not a regular file under root");
 		}
@@ -238,8 +238,8 @@ async function writeFileWithinRoot(params) {
 		if (!sameFileIdentity(stat, lstat)) {
 			throw new SafeOpenError("path-mismatch", "path changed during write");
 		}
-		const realPath = await fs$1.realpath(ioPath);
-		const realStat = await fs$1.stat(realPath);
+		const realPath = await fs.realpath(ioPath);
+		const realStat = await fs.stat(realPath);
 		if (!sameFileIdentity(stat, realStat)) {
 			throw new SafeOpenError("path-mismatch", "path mismatch");
 		}

package/dist/infra/gateway-lock.js

@@ -1,8 +1,8 @@
 import { resolveConfigPath, resolveGatewayLockDir, resolveStateDir } from "../config/paths.js";
 import { isPidAlive } from "../shared/pid-alive.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 import { createHash } from "node:crypto";
 import net from "node:net";
 
@@ -44,7 +44,7 @@ function isGatewayArgv(args) {
 }
 function readLinuxCmdline(pid) {
 	try {
-		const raw = fs.readFileSync(`/proc/${pid}/cmdline`, "utf8");
+		const raw = syncFs.readFileSync(`/proc/${pid}/cmdline`, "utf8");
 		return parseProcCmdline(raw);
 	} catch {
 		return null;
@@ -52,7 +52,7 @@ function readLinuxCmdline(pid) {
 }
 function readLinuxStartTime(pid) {
 	try {
-		const raw = fs.readFileSync(`/proc/${pid}/stat`, "utf8").trim();
+		const raw = syncFs.readFileSync(`/proc/${pid}/stat`, "utf8").trim();
 		const closeParen = raw.lastIndexOf(")");
 		if (closeParen < 0) {
 			return null;
@@ -122,7 +122,7 @@ async function resolveGatewayOwnerStatus(pid, payload, platform, port) {
 }
 async function readLockPayload(lockPath) {
 	try {
-		const raw = await fs$1.readFile(lockPath, "utf8");
+		const raw = await fs.readFile(lockPath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (typeof parsed.pid !== "number") {
 			return null;
@@ -167,12 +167,12 @@ async function acquireGatewayLock(opts = {}) {
 	const platform = opts.platform ?? process.platform;
 	const port = opts.port;
 	const { lockPath, configPath } = resolveGatewayLockPath(env);
-	await fs$1.mkdir(path.dirname(lockPath), { recursive: true });
+	await fs.mkdir(path.dirname(lockPath), { recursive: true });
 	const startedAt = Date.now();
 	let lastPayload = null;
 	while (Date.now() - startedAt < timeoutMs) {
 		try {
-			const handle = await fs$1.open(lockPath, "wx");
+			const handle = await fs.open(lockPath, "wx");
 			const startTime = platform === "linux" ? readLinuxStartTime(process.pid) : null;
 			const payload = {
 				pid: process.pid,
@@ -188,7 +188,7 @@ async function acquireGatewayLock(opts = {}) {
 				configPath,
 				release: async () => {
 					await handle.close().catch(() => undefined);
-					await fs$1.rm(lockPath, { force: true });
+					await fs.rm(lockPath, { force: true });
 				}
 			};
 		} catch (err) {
@@ -200,7 +200,7 @@ async function acquireGatewayLock(opts = {}) {
 			const ownerPid = lastPayload?.pid;
 			const ownerStatus = ownerPid ? await resolveGatewayOwnerStatus(ownerPid, lastPayload, platform, port) : "unknown";
 			if (ownerStatus === "dead" && ownerPid) {
-				await fs$1.rm(lockPath, { force: true });
+				await fs.rm(lockPath, { force: true });
 				continue;
 			}
 			if (ownerStatus !== "alive") {
@@ -211,14 +211,14 @@ async function acquireGatewayLock(opts = {}) {
 				}
 				if (!stale) {
 					try {
-						const st = await fs$1.stat(lockPath);
+						const st = await fs.stat(lockPath);
 						stale = Date.now() - st.mtimeMs > staleMs;
 					} catch {
 						stale = false;
 					}
 				}
 				if (stale) {
-					await fs$1.rm(lockPath, { force: true });
+					await fs.rm(lockPath, { force: true });
 					continue;
 				}
 			}

package/dist/infra/git-commit.js

@@ -1,6 +1,6 @@
 import { resolveGitHeadPath } from "./git-root.js";
 import { createRequire } from "node:module";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/git-commit.ts
@@ -48,7 +48,7 @@ function isMissingPathError(error) {
 function resolveGitRefsBase(headPath) {
 	const gitDir = path.dirname(headPath);
 	try {
-		const commonDirRaw = fs.readFileSync(path.join(gitDir, "commondir"), "utf-8").trim();
+		const commonDirRaw = syncFs.readFileSync(path.join(gitDir, "commondir"), "utf-8").trim();
 		if (!commonDirRaw) {
 			return gitDir;
 		}
@@ -79,7 +79,7 @@ function resolveRefPath(refsBase, ref) {
 }
 function readCommitFromPackedRefs(refsBase, ref) {
 	try {
-		const packedRefs = fs.readFileSync(path.join(refsBase, "packed-refs"), "utf-8");
+		const packedRefs = syncFs.readFileSync(path.join(refsBase, "packed-refs"), "utf-8");
 		for (const line of packedRefs.split("\n")) {
 			if (!line || line.startsWith("#") || line.startsWith("^")) {
 				continue;
@@ -124,7 +124,7 @@ const resolveCommitHash = (options = {}) => {
 			cachedCommit = null;
 			return cachedCommit;
 		}
-		const head = fs.readFileSync(headPath, "utf-8").trim();
+		const head = syncFs.readFileSync(headPath, "utf-8").trim();
 		if (!head) {
 			cachedCommit = null;
 			return cachedCommit;
@@ -138,7 +138,7 @@ const resolveCommitHash = (options = {}) => {
 				return cachedCommit;
 			}
 			try {
-				const refHash = fs.readFileSync(refPath, "utf-8").trim();
+				const refHash = syncFs.readFileSync(refPath, "utf-8").trim();
 				cachedCommit = formatCommit(refHash);
 				return cachedCommit;
 			} catch (error) {

package/dist/infra/git-root.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/git-root.ts
@@ -22,7 +22,7 @@ function walkUpFrom(startDir, opts, resolveAtDir) {
 function hasGitMarker(repoRoot) {
 	const gitPath = path.join(repoRoot, ".git");
 	try {
-		const stat = fs.statSync(gitPath);
+		const stat = syncFs.statSync(gitPath);
 		return stat.isDirectory() || stat.isFile();
 	} catch {
 		return false;
@@ -34,14 +34,14 @@ function findGitRoot(startDir, opts = {}) {
 function resolveGitDirFromMarker(repoRoot) {
 	const gitPath = path.join(repoRoot, ".git");
 	try {
-		const stat = fs.statSync(gitPath);
+		const stat = syncFs.statSync(gitPath);
 		if (stat.isDirectory()) {
 			return gitPath;
 		}
 		if (!stat.isFile()) {
 			return null;
 		}
-		const raw = fs.readFileSync(gitPath, "utf-8");
+		const raw = syncFs.readFileSync(gitPath, "utf-8");
 		const match = raw.match(/gitdir:\s*(.+)/i);
 		if (!match?.[1]) {
 			return null;

package/dist/infra/hosted-runtime-artifact.js

@@ -1,6 +1,6 @@
 import { createReadStream, createWriteStream } from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -141,7 +141,7 @@ async function downloadHostedRuntimeDescriptor(params) {
 			reason: `hosted runtime artifact unavailable (${artifactResponse.status})`
 		};
 	}
-	await fs$1.mkdir(params.destinationDir, { recursive: true });
+	await fs.mkdir(params.destinationDir, { recursive: true });
 	const archivePath = path.join(params.destinationDir, descriptor.assetName);
 	try {
 		await writeResponseBody(artifactResponse, archivePath);
@@ -153,7 +153,7 @@ async function downloadHostedRuntimeDescriptor(params) {
 	}
 	const actualChecksum = await sha256(archivePath);
 	if (actualChecksum !== expectedChecksum) {
-		await fs$1.rm(archivePath, { force: true });
+		await fs.rm(archivePath, { force: true });
 		return {
 			kind: "error",
 			reason: `hosted runtime checksum mismatch for ${descriptor.assetName}`

package/dist/infra/is-main.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/is-main.ts
@@ -8,7 +8,7 @@ function normalizePathCandidate(candidate, cwd) {
 	}
 	const resolved = path.resolve(cwd, candidate);
 	try {
-		return fs.realpathSync.native(resolved);
+		return syncFs.realpathSync.native(resolved);
 	} catch {
 		return resolved;
 	}

package/dist/infra/json-file.js

@@ -1,13 +1,13 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/json-file.ts
 function loadJsonFile(pathname) {
 	try {
-		if (!fs.existsSync(pathname)) {
+		if (!syncFs.existsSync(pathname)) {
 			return undefined;
 		}
-		const raw = fs.readFileSync(pathname, "utf8");
+		const raw = syncFs.readFileSync(pathname, "utf8");
 		return JSON.parse(raw);
 	} catch {
 		return undefined;
@@ -15,14 +15,14 @@ function loadJsonFile(pathname) {
 }
 function saveJsonFile(pathname, data) {
 	const dir = path.dirname(pathname);
-	if (!fs.existsSync(dir)) {
-		fs.mkdirSync(dir, {
+	if (!syncFs.existsSync(dir)) {
+		syncFs.mkdirSync(dir, {
 			recursive: true,
 			mode: 448
 		});
 	}
-	fs.writeFileSync(pathname, `${JSON.stringify(data, null, 2)}\n`, "utf8");
-	fs.chmodSync(pathname, 384);
+	syncFs.writeFileSync(pathname, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+	syncFs.chmodSync(pathname, 384);
 }
 
 //#endregion

package/dist/infra/outbound/delivery-queue.js

@@ -2,7 +2,7 @@ import { resolveStateDir } from "../../config/paths.js";
 import { formatErrorMessage } from "../errors.js";
 import { generateSecureUuid } from "../secure-random.js";
 import { formatOutboundTargetForLog, redactOutboundTargetInText } from "./format.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/outbound/delivery-queue.ts
@@ -26,11 +26,11 @@ function resolveFailedDir(stateDir) {
 /** Ensure the queue directory (and failed/ subdirectory) exist. */
 async function ensureQueueDir(stateDir) {
 	const queueDir = resolveQueueDir(stateDir);
-	await fs.promises.mkdir(queueDir, {
+	await syncFs.promises.mkdir(queueDir, {
 		recursive: true,
 		mode: 448
 	});
-	await fs.promises.mkdir(resolveFailedDir(stateDir), {
+	await syncFs.promises.mkdir(resolveFailedDir(stateDir), {
 		recursive: true,
 		mode: 448
 	});
@@ -57,18 +57,18 @@ async function enqueueDelivery(params, stateDir) {
 	const filePath = path.join(queueDir, `${id}.json`);
 	const tmp = `${filePath}.${process.pid}.tmp`;
 	const json = JSON.stringify(entry, null, 2);
-	await fs.promises.writeFile(tmp, json, {
+	await syncFs.promises.writeFile(tmp, json, {
 		encoding: "utf-8",
 		mode: 384
 	});
-	await fs.promises.rename(tmp, filePath);
+	await syncFs.promises.rename(tmp, filePath);
 	return id;
 }
 /** Remove a successfully delivered entry from the queue. */
 async function ackDelivery(id, stateDir) {
 	const filePath = path.join(resolveQueueDir(stateDir), `${id}.json`);
 	try {
-		await fs.promises.unlink(filePath);
+		await syncFs.promises.unlink(filePath);
 	} catch (err) {
 		const code = err && typeof err === "object" && "code" in err ? String(err.code) : null;
 		if (code !== "ENOENT") {
@@ -79,24 +79,24 @@ async function ackDelivery(id, stateDir) {
 /** Update a queue entry after a failed delivery attempt. */
 async function failDelivery(id, error, stateDir) {
 	const filePath = path.join(resolveQueueDir(stateDir), `${id}.json`);
-	const raw = await fs.promises.readFile(filePath, "utf-8");
+	const raw = await syncFs.promises.readFile(filePath, "utf-8");
 	const entry = JSON.parse(raw);
 	entry.retryCount += 1;
 	entry.lastAttemptAt = Date.now();
 	entry.lastError = error;
 	const tmp = `${filePath}.${process.pid}.tmp`;
-	await fs.promises.writeFile(tmp, JSON.stringify(entry, null, 2), {
+	await syncFs.promises.writeFile(tmp, JSON.stringify(entry, null, 2), {
 		encoding: "utf-8",
 		mode: 384
 	});
-	await fs.promises.rename(tmp, filePath);
+	await syncFs.promises.rename(tmp, filePath);
 }
 /** Load all pending delivery entries from the queue directory. */
 async function loadPendingDeliveries(stateDir) {
 	const queueDir = resolveQueueDir(stateDir);
 	let files;
 	try {
-		files = await fs.promises.readdir(queueDir);
+		files = await syncFs.promises.readdir(queueDir);
 	} catch (err) {
 		const code = err && typeof err === "object" && "code" in err ? String(err.code) : null;
 		if (code === "ENOENT") {
@@ -111,20 +111,20 @@ async function loadPendingDeliveries(stateDir) {
 		}
 		const filePath = path.join(queueDir, file);
 		try {
-			const stat = await fs.promises.stat(filePath);
+			const stat = await syncFs.promises.stat(filePath);
 			if (!stat.isFile()) {
 				continue;
 			}
-			const raw = await fs.promises.readFile(filePath, "utf-8");
+			const raw = await syncFs.promises.readFile(filePath, "utf-8");
 			const parsed = JSON.parse(raw);
 			const { entry, migrated } = normalizeLegacyQueuedDeliveryEntry(parsed);
 			if (migrated) {
 				const tmp = `${filePath}.${process.pid}.tmp`;
-				await fs.promises.writeFile(tmp, JSON.stringify(entry, null, 2), {
+				await syncFs.promises.writeFile(tmp, JSON.stringify(entry, null, 2), {
 					encoding: "utf-8",
 					mode: 384
 				});
-				await fs.promises.rename(tmp, filePath);
+				await syncFs.promises.rename(tmp, filePath);
 			}
 			entries.push(entry);
 		} catch {}
@@ -135,13 +135,13 @@ async function loadPendingDeliveries(stateDir) {
 async function moveToFailed(id, stateDir) {
 	const queueDir = resolveQueueDir(stateDir);
 	const failedDir = resolveFailedDir(stateDir);
-	await fs.promises.mkdir(failedDir, {
+	await syncFs.promises.mkdir(failedDir, {
 		recursive: true,
 		mode: 448
 	});
 	const src = path.join(queueDir, `${id}.json`);
 	const dest = path.join(failedDir, `${id}.json`);
-	await fs.promises.rename(src, dest);
+	await syncFs.promises.rename(src, dest);
 }
 /** Compute the backoff delay in ms for a given retry count. */
 function computeBackoffMs(retryCount) {

package/dist/infra/path-env.js

@@ -1,13 +1,13 @@
 import { isTruthyEnvValue } from "./env.js";
 import { resolveBrewPathDirs } from "./brew.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
 //#region src/infra/path-env.ts
 function isExecutable(filePath) {
 	try {
-		fs.accessSync(filePath, fs.constants.X_OK);
+		syncFs.accessSync(filePath, syncFs.constants.X_OK);
 		return true;
 	} catch {
 		return false;
@@ -15,7 +15,7 @@ function isExecutable(filePath) {
 }
 function isDirectory(dirPath) {
 	try {
-		return fs.statSync(dirPath).isDirectory();
+		return syncFs.statSync(dirPath).isDirectory();
 	} catch {
 		return false;
 	}

package/dist/infra/ports-lsof.js

@@ -1,11 +1,11 @@
-import fs from "node:fs";
-import fs$1 from "node:fs/promises";
+import syncFs from "node:fs";
+import fs from "node:fs/promises";
 
 //#region src/infra/ports-lsof.ts
 const LSOF_CANDIDATES = process.platform === "darwin" ? ["/usr/sbin/lsof", "/usr/bin/lsof"] : ["/usr/bin/lsof", "/usr/sbin/lsof"];
 async function canExecute(path) {
 	try {
-		await fs$1.access(path, fs.constants.X_OK);
+		await fs.access(path, syncFs.constants.X_OK);
 		return true;
 	} catch {
 		return false;
@@ -22,7 +22,7 @@ async function resolveLsofCommand() {
 function resolveLsofCommandSync() {
 	for (const candidate of LSOF_CANDIDATES) {
 		try {
-			fs.accessSync(candidate, fs.constants.X_OK);
+			syncFs.accessSync(candidate, syncFs.constants.X_OK);
 			return candidate;
 		} catch {}
 	}

package/dist/infra/provider-usage.auth.js

@@ -9,7 +9,7 @@ import { resolveAuthProfileOrder } from "../agents/auth-profiles/order.js";
 import "../agents/auth-profiles.js";
 import { getCustomProviderApiKey } from "../agents/model-auth.js";
 import { normalizeProviderId } from "../agents/model-selection.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
@@ -43,10 +43,10 @@ function resolveZaiApiKey() {
 	}
 	try {
 		const authPath = path.join(resolveRequiredHomeDir(process.env, os.homedir), ".pi", "agent", "auth.json");
-		if (!fs.existsSync(authPath)) {
+		if (!syncFs.existsSync(authPath)) {
 			return undefined;
 		}
-		const data = JSON.parse(fs.readFileSync(authPath, "utf-8"));
+		const data = JSON.parse(syncFs.readFileSync(authPath, "utf-8"));
 		return data["z-ai"]?.access || data.zai?.access;
 	} catch {
 		return undefined;

package/dist/infra/safe-open-sync.js

@@ -1,5 +1,5 @@
 import { sameFileIdentity as sameFileIdentity$1 } from "./file-identity.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/infra/safe-open-sync.ts
 function isExpectedPathError(error) {
@@ -10,7 +10,7 @@ function sameFileIdentity(left, right) {
 	return sameFileIdentity$1(left, right);
 }
 function openVerifiedFileSync(params) {
-	const ioFs = params.ioFs ?? fs;
+	const ioFs = params.ioFs ?? syncFs;
 	const openReadFlags = ioFs.constants.O_RDONLY | (typeof ioFs.constants.O_NOFOLLOW === "number" ? ioFs.constants.O_NOFOLLOW : 0);
 	let fd = null;
 	try {