@fased/fased 0.1.64 → 0.1.66

package/dist/wallet/wallet-observability.js

@@ -1,5 +1,5 @@
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 
 //#region src/wallet/wallet-observability.ts
 const OBSERVABILITY_FILENAME = "observability.v1.json";
@@ -37,11 +37,11 @@ function sanitizeBucket(input) {
 }
 function readSnapshot(env) {
 	const file = observabilityPath(env);
-	if (!syncFs.existsSync(file)) {
+	if (!fs.existsSync(file)) {
 		return makeDefaultSnapshot();
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(file, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
 		if (parsed?.version !== 1) {
 			return makeDefaultSnapshot();
 		}
@@ -60,12 +60,12 @@ function readSnapshot(env) {
 }
 function writeSnapshot(env, snapshot) {
 	const file = observabilityPath(env);
-	syncFs.writeFileSync(file, `${JSON.stringify(snapshot, null, 2)}\n`, {
+	fs.writeFileSync(file, `${JSON.stringify(snapshot, null, 2)}\n`, {
 		mode: 384,
 		encoding: "utf8"
 	});
 	try {
-		syncFs.chmodSync(file, 384);
+		fs.chmodSync(file, 384);
 	} catch {}
 }
 function incrementWalletObservabilityCounter(params) {

package/dist/wallet/wallet-policy.js

@@ -3,7 +3,7 @@ import { readWalletProviderRegistry, resolveWalletUserRole } from "./wallet-prov
 import { assertValidSolanaAddress } from "./solana-address.js";
 import { tryResolveSatRuntimeIds } from "../config/sat-runtime-ids.js";
 import { serializeWalletState, writeWalletStateFileAtomically } from "./wallet-atomic-state.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 
 //#region src/wallet/wallet-policy.ts
@@ -11,6 +11,7 @@ const SOLANA_SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
 const SOLANA_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const SOLANA_TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 const SOLANA_ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const SOLANA_ADDRESS_LOOKUP_TABLE_PROGRAM_ID = "AddressLookupTab1e1111111111111111111111111";
 const DEFAULT_POLICY_CAPS = { solana: {
 	maxPerTx: "1000000000",
 	maxDaily: "5000000000"
@@ -69,11 +70,11 @@ function isNonNegativeIntegerString(value) {
 }
 function loadLedger(paths) {
 	const fallback = defaultWalletUsageLedger();
-	if (!syncFs.existsSync(paths.dailyUsagePath)) {
+	if (!fs.existsSync(paths.dailyUsagePath)) {
 		return fallback;
 	}
 	try {
-		const raw = syncFs.readFileSync(paths.dailyUsagePath, "utf8");
+		const raw = fs.readFileSync(paths.dailyUsagePath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (parsed && parsed.version === 2 && typeof parsed.date === "string") {
 			if (!parsed.wallets || typeof parsed.wallets !== "object" || Array.isArray(parsed.wallets)) {
@@ -153,7 +154,8 @@ function miningPolicyProgramAllowlist(env) {
 		SOLANA_SYSTEM_PROGRAM_ID,
 		SOLANA_TOKEN_PROGRAM_ID,
 		SOLANA_TOKEN_2022_PROGRAM_ID,
-		SOLANA_ASSOCIATED_TOKEN_PROGRAM_ID
+		SOLANA_ASSOCIATED_TOKEN_PROGRAM_ID,
+		String(env.FASED_SAT_ENABLE_ALT_V0 ?? "").trim() === "1" ? SOLANA_ADDRESS_LOOKUP_TABLE_PROGRAM_ID : ""
 	]);
 }
 function isWalletHandle(value) {
@@ -370,11 +372,11 @@ function readWalletPolicyState(env = process.env) {
 		updatedAt: nowIso(),
 		wallets: {}
 	};
-	if (!syncFs.existsSync(statePath)) {
+	if (!fs.existsSync(statePath)) {
 		return fallback;
 	}
 	try {
-		const raw = syncFs.readFileSync(statePath, "utf8");
+		const raw = fs.readFileSync(statePath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (parsed.version !== 1) {
 			throw new Error("wallet policy state version is unsupported");

package/dist/wallet/wallet-provider-registry.js

@@ -1,7 +1,7 @@
 import { resolveStateDir } from "../config/paths.js";
 import { throwLegacyEmbeddedKeystoreMigrationRequired } from "./legacy-embedded-keystore.js";
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
 
@@ -165,12 +165,12 @@ function buildMiningDeleteBlockedMessage(details) {
 }
 function readSatMiningRuntimeDeletionDetails(walletId, env) {
 	const runtimeStorePath = path.join(resolveStateDir(env), "sat-mining", "wallets", normalizeSatWalletStateKey(walletId), "runtime-store.json");
-	if (!syncFs.existsSync(runtimeStorePath)) {
+	if (!fs.existsSync(runtimeStorePath)) {
 		return null;
 	}
 	let parsed;
 	try {
-		parsed = JSON.parse(syncFs.readFileSync(runtimeStorePath, "utf8"));
+		parsed = JSON.parse(fs.readFileSync(runtimeStorePath, "utf8"));
 	} catch {
 		return null;
 	}
@@ -370,11 +370,11 @@ function normalizeRegistry(raw) {
 }
 function readWalletProviderRegistry(env = process.env) {
 	const file = registryPath(env);
-	if (!syncFs.existsSync(file)) {
+	if (!fs.existsSync(file)) {
 		return makeDefaultRegistry();
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(file, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
 		const normalized = normalizeRegistry(parsed);
 		if (normalized.changed) {
 			writeWalletProviderRegistry(normalized.registry, env);
@@ -391,12 +391,12 @@ function writeWalletProviderRegistry(registry, env = process.env) {
 		version: 1,
 		updatedAt: nowIso()
 	};
-	syncFs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`, {
+	fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`, {
 		encoding: "utf8",
 		mode: REGISTRY_FILE_MODE
 	});
 	try {
-		syncFs.chmodSync(file, REGISTRY_FILE_MODE);
+		fs.chmodSync(file, REGISTRY_FILE_MODE);
 	} catch {}
 }
 function setWalletProviderEnabled(params) {

package/dist/wallet/wallet-runtime-config.js

@@ -1,5 +1,5 @@
 import { resolveStateDir } from "../config/paths.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 
 //#region src/wallet/wallet-runtime-config.ts
@@ -72,12 +72,12 @@ function resolveWalletStatePaths(env = process.env) {
 }
 function ensureWalletStateDir(env = process.env) {
 	const paths = resolveWalletStatePaths(env);
-	syncFs.mkdirSync(paths.rootDir, {
+	fs.mkdirSync(paths.rootDir, {
 		recursive: true,
 		mode: 448
 	});
 	try {
-		syncFs.chmodSync(paths.rootDir, 448);
+		fs.chmodSync(paths.rootDir, 448);
 	} catch {}
 	return paths;
 }

package/dist/wallet/wallet-secrets-store.js

@@ -1,6 +1,6 @@
 import { resolveStateDir } from "../config/paths.js";
 import { throwLegacyEmbeddedKeystoreMigrationRequired } from "./legacy-embedded-keystore.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 
@@ -13,12 +13,12 @@ const WALLET_RPC_SECRET_FILENAME = "wallet-rpc.v1.enc.json";
 const MASTER_KEY_FILENAME = "master.key";
 function ensureSecretsDir(env = process.env) {
 	const dir = path.join(resolveStateDir(env), "secrets");
-	syncFs.mkdirSync(dir, {
+	fs.mkdirSync(dir, {
 		recursive: true,
 		mode: SECRETS_DIR_MODE
 	});
 	try {
-		syncFs.chmodSync(dir, SECRETS_DIR_MODE);
+		fs.chmodSync(dir, SECRETS_DIR_MODE);
 	} catch {}
 	return dir;
 }
@@ -38,20 +38,20 @@ function resolveWalletProviderSecretPath(providerId, env = process.env) {
 }
 function readOrCreateMasterKey(env = process.env) {
 	const keyPath = resolveMasterKeyPath(env);
-	if (syncFs.existsSync(keyPath)) {
-		const raw = syncFs.readFileSync(keyPath, "utf8").trim();
+	if (fs.existsSync(keyPath)) {
+		const raw = fs.readFileSync(keyPath, "utf8").trim();
 		const parsed = Buffer.from(raw, "hex");
 		if (parsed.length === MASTER_KEY_BYTES) {
 			return parsed;
 		}
 	}
 	const key = randomBytes(MASTER_KEY_BYTES);
-	syncFs.writeFileSync(keyPath, `${key.toString("hex")}\n`, {
+	fs.writeFileSync(keyPath, `${key.toString("hex")}\n`, {
 		mode: SECRET_FILE_MODE,
 		encoding: "utf8"
 	});
 	try {
-		syncFs.chmodSync(keyPath, SECRET_FILE_MODE);
+		fs.chmodSync(keyPath, SECRET_FILE_MODE);
 	} catch {}
 	return key;
 }
@@ -199,12 +199,12 @@ function saveWalletRpcSecret(input, env = process.env) {
 	};
 	const encrypted = encryptPayload(record, env);
 	const secretPath = resolveWalletRpcSecretPath(env, input.providerId);
-	syncFs.writeFileSync(secretPath, `${JSON.stringify(encrypted, null, 2)}\n`, {
+	fs.writeFileSync(secretPath, `${JSON.stringify(encrypted, null, 2)}\n`, {
 		mode: SECRET_FILE_MODE,
 		encoding: "utf8"
 	});
 	try {
-		syncFs.chmodSync(secretPath, SECRET_FILE_MODE);
+		fs.chmodSync(secretPath, SECRET_FILE_MODE);
 	} catch {}
 	return record;
 }
@@ -238,23 +238,23 @@ function saveWalletProviderSecret(input, env = process.env) {
 	};
 	const encrypted = encryptProviderPayload(record, env);
 	const secretPath = resolveWalletProviderSecretPath(providerId, env);
-	syncFs.writeFileSync(secretPath, `${JSON.stringify(encrypted, null, 2)}\n`, {
+	fs.writeFileSync(secretPath, `${JSON.stringify(encrypted, null, 2)}\n`, {
 		mode: SECRET_FILE_MODE,
 		encoding: "utf8"
 	});
 	try {
-		syncFs.chmodSync(secretPath, SECRET_FILE_MODE);
+		fs.chmodSync(secretPath, SECRET_FILE_MODE);
 	} catch {}
 	return record;
 }
 function loadWalletRpcSecret(env = process.env, options) {
 	const candidatePaths = options?.providerId ? [resolveWalletRpcSecretPath(env, options.providerId), resolveWalletRpcSecretPath(env)] : [resolveWalletRpcSecretPath(env)];
 	for (const secretPath of candidatePaths) {
-		if (!syncFs.existsSync(secretPath)) {
+		if (!fs.existsSync(secretPath)) {
 			continue;
 		}
 		try {
-			const parsed = JSON.parse(syncFs.readFileSync(secretPath, "utf8"));
+			const parsed = JSON.parse(fs.readFileSync(secretPath, "utf8"));
 			const decrypted = decryptPayload(parsed, env);
 			if (decrypted) {
 				return decrypted;
@@ -271,11 +271,11 @@ function loadWalletProviderSecret(providerId, env = process.env) {
 		return null;
 	}
 	const secretPath = resolveWalletProviderSecretPath(providerId, env);
-	if (!syncFs.existsSync(secretPath)) {
+	if (!fs.existsSync(secretPath)) {
 		return null;
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(secretPath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(secretPath, "utf8"));
 		const value = decryptProviderPayload(parsed, env);
 		if (!value || value.providerId !== providerId) {
 			return null;
@@ -288,13 +288,13 @@ function loadWalletProviderSecret(providerId, env = process.env) {
 function deleteWalletRpcSecret(env = process.env) {
 	const dir = ensureSecretsDir(env);
 	const legacyPath = resolveWalletRpcSecretPath(env);
-	const candidatePaths = [legacyPath, ...syncFs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && /^wallet-rpc-[a-z0-9-]+\.v1\.enc\.json$/i.test(entry.name)).map((entry) => path.join(dir, entry.name))];
+	const candidatePaths = [legacyPath, ...fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && /^wallet-rpc-[a-z0-9-]+\.v1\.enc\.json$/i.test(entry.name)).map((entry) => path.join(dir, entry.name))];
 	const removedPaths = [];
 	for (const secretPath of candidatePaths) {
-		if (!syncFs.existsSync(secretPath)) {
+		if (!fs.existsSync(secretPath)) {
 			continue;
 		}
-		syncFs.rmSync(secretPath, { force: true });
+		fs.rmSync(secretPath, { force: true });
 		removedPaths.push(secretPath);
 	}
 	return {
@@ -305,13 +305,13 @@ function deleteWalletRpcSecret(env = process.env) {
 }
 function deleteWalletRpcSecretForProvider(providerId, env = process.env) {
 	const secretPath = resolveWalletRpcSecretPath(env, providerId);
-	if (!syncFs.existsSync(secretPath)) {
+	if (!fs.existsSync(secretPath)) {
 		return {
 			removed: false,
 			path: secretPath
 		};
 	}
-	syncFs.rmSync(secretPath, { force: true });
+	fs.rmSync(secretPath, { force: true });
 	return {
 		removed: true,
 		path: secretPath
@@ -319,13 +319,13 @@ function deleteWalletRpcSecretForProvider(providerId, env = process.env) {
 }
 function deleteWalletProviderSecret(providerId, env = process.env) {
 	const secretPath = resolveWalletProviderSecretPath(providerId, env);
-	if (!syncFs.existsSync(secretPath)) {
+	if (!fs.existsSync(secretPath)) {
 		return {
 			removed: false,
 			path: secretPath
 		};
 	}
-	syncFs.rmSync(secretPath, { force: true });
+	fs.rmSync(secretPath, { force: true });
 	return {
 		removed: true,
 		path: secretPath

package/dist/wallet/wallet-send-approvals.js

@@ -19,7 +19,7 @@ import { simulateWalletPolicy } from "./wallet-policy-simulation.js";
 import { beginWalletSendExecution, claimWalletSendExecution, getWalletSendExecution, updateWalletSendExecution, walletSendIntentDigest, walletSendRequestId } from "./wallet-send-execution-ledger.js";
 import { getWalletSettlementLinkByRequestId, markWalletSettlementLinkOutcome, upsertWalletSettlementLink } from "./wallet-settlement-links.js";
 import { syncWalletApprovalTask, walletApprovalTaskId } from "./wallet-task-ledger.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 
@@ -590,14 +590,14 @@ async function reconcileTypedWalletSend(params) {
 }
 function loadFile(env = process.env) {
 	const paths = ensureWalletStateDir(env);
-	if (!syncFs.existsSync(paths.sendApprovalsPath)) {
+	if (!fs.existsSync(paths.sendApprovalsPath)) {
 		return {
 			version: 1,
 			requests: []
 		};
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(paths.sendApprovalsPath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(paths.sendApprovalsPath, "utf8"));
 		if (parsed?.version === 1 && Array.isArray(parsed.requests)) {
 			return {
 				version: 1,
@@ -616,28 +616,28 @@ function saveFile(file, env = process.env) {
 	let tempFd;
 	let renamed = false;
 	try {
-		tempFd = syncFs.openSync(tempPath, "wx", 384);
-		syncFs.writeFileSync(tempFd, serialized, { encoding: "utf8" });
-		syncFs.fsyncSync(tempFd);
-		syncFs.closeSync(tempFd);
+		tempFd = fs.openSync(tempPath, "wx", 384);
+		fs.writeFileSync(tempFd, serialized, { encoding: "utf8" });
+		fs.fsyncSync(tempFd);
+		fs.closeSync(tempFd);
 		tempFd = undefined;
-		syncFs.renameSync(tempPath, paths.sendApprovalsPath);
+		fs.renameSync(tempPath, paths.sendApprovalsPath);
 		renamed = true;
-		const directoryFd = syncFs.openSync(path.dirname(paths.sendApprovalsPath), "r");
+		const directoryFd = fs.openSync(path.dirname(paths.sendApprovalsPath), "r");
 		try {
-			syncFs.fsyncSync(directoryFd);
+			fs.fsyncSync(directoryFd);
 		} finally {
-			syncFs.closeSync(directoryFd);
+			fs.closeSync(directoryFd);
 		}
 	} catch (error) {
 		if (tempFd !== undefined) {
 			try {
-				syncFs.closeSync(tempFd);
+				fs.closeSync(tempFd);
 			} catch {}
 		}
 		if (!renamed) {
 			try {
-				syncFs.unlinkSync(tempPath);
+				fs.unlinkSync(tempPath);
 			} catch {}
 		}
 		throw error;
@@ -680,7 +680,7 @@ function approvalRequestDigest(request) {
 }
 function reserveWalletApprovalIdentity(request, env) {
 	const identityDir = path.join(path.dirname(ensureWalletStateDir(env).sendApprovalsPath), ".wallet-approval-identities");
-	syncFs.mkdirSync(identityDir, {
+	fs.mkdirSync(identityDir, {
 		recursive: true,
 		mode: 448
 	});
@@ -692,19 +692,19 @@ function reserveWalletApprovalIdentity(request, env) {
 	})}\n`;
 	let descriptor;
 	try {
-		descriptor = syncFs.openSync(identityPath, "wx", 384);
-		syncFs.writeFileSync(descriptor, payload, "utf8");
-		syncFs.fsyncSync(descriptor);
-		syncFs.closeSync(descriptor);
+		descriptor = fs.openSync(identityPath, "wx", 384);
+		fs.writeFileSync(descriptor, payload, "utf8");
+		fs.fsyncSync(descriptor);
+		fs.closeSync(descriptor);
 		descriptor = undefined;
 	} catch (error) {
 		if (descriptor !== undefined) {
-			syncFs.closeSync(descriptor);
+			fs.closeSync(descriptor);
 		}
 		if (error.code === "EEXIST") {
 			let existingDigest;
 			try {
-				const existing = JSON.parse(syncFs.readFileSync(identityPath, "utf8"));
+				const existing = JSON.parse(fs.readFileSync(identityPath, "utf8"));
 				existingDigest = typeof existing.requestDigest === "string" ? existing.requestDigest : undefined;
 			} catch {}
 			throw new Error(existingDigest === request.requestDigest ? "wallet approval request ID already exists" : "wallet approval request ID collides with a different immutable request", { cause: error });
@@ -713,7 +713,7 @@ function reserveWalletApprovalIdentity(request, env) {
 	}
 	return () => {
 		try {
-			syncFs.unlinkSync(identityPath);
+			fs.unlinkSync(identityPath);
 		} catch {}
 	};
 }

package/dist/wallet/wallet-send-execution-ledger.js

@@ -3,7 +3,7 @@ import { acquireFileLock, withFileLock } from "../plugin-sdk/file-lock.js";
 import "../infra/file-lock.js";
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
 import { serializeWalletState, writeWalletStateFileAtomically } from "./wallet-atomic-state.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
 
@@ -149,14 +149,14 @@ function validateEntry(value) {
 }
 function loadLedger(env) {
 	const filePath = ledgerPath(env);
-	if (!syncFs.existsSync(filePath)) {
+	if (!fs.existsSync(filePath)) {
 		return {
 			version: 1,
 			entries: []
 		};
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(filePath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
 		if (parsed.version !== 1 || !Array.isArray(parsed.entries)) {
 			throw new Error("unsupported shape");
 		}

package/dist/wallet/wallet-settlement-links.js

@@ -1,6 +1,6 @@
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
 import { serializeWalletState, writeWalletStateFileAtomically } from "./wallet-atomic-state.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 
 //#region src/wallet/wallet-settlement-links.ts
@@ -16,14 +16,14 @@ function isWalletSettlementLink(value) {
 }
 function loadFile(env = process.env) {
 	const filePath = linksFilePath(env);
-	if (!syncFs.existsSync(filePath)) {
+	if (!fs.existsSync(filePath)) {
 		return {
 			version: 1,
 			links: []
 		};
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(filePath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
 		if (parsed?.version === 1 && Array.isArray(parsed.links) && parsed.links.every(isWalletSettlementLink)) {
 			return {
 				version: 1,

package/dist/wallet/wallet-standard-review.js

@@ -4,7 +4,7 @@ import { ensureWalletStateDir } from "./wallet-runtime-config.js";
 import { fetchSolanaRpc } from "./solana-assets.js";
 import { WalletProviderError } from "./wallet-provider-adapter.js";
 import { broadcastReviewedSolanaTransaction, buildReviewedSolanaTransaction, computeReviewedSolanaRequestDigest, reconcileReviewedSolanaTransaction, validateReviewedSolanaSignedTransaction } from "./solana-reviewed-transaction.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 
@@ -33,14 +33,14 @@ function reviewPath(env) {
 }
 function readFile(env) {
 	const filePath = reviewPath(env);
-	if (!syncFs.existsSync(filePath)) {
+	if (!fs.existsSync(filePath)) {
 		return {
 			version: 1,
 			reviews: []
 		};
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(filePath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
 		if (parsed.version === 1 && Array.isArray(parsed.reviews)) {
 			return parsed;
 		}
@@ -56,29 +56,29 @@ function saveFile(file, env) {
 	const temporary = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
 	let descriptor;
 	try {
-		descriptor = syncFs.openSync(temporary, "wx", REVIEW_FILE_MODE);
-		syncFs.writeFileSync(descriptor, `${JSON.stringify(file, null, 2)}\n`, "utf8");
-		syncFs.fsyncSync(descriptor);
-		syncFs.closeSync(descriptor);
+		descriptor = fs.openSync(temporary, "wx", REVIEW_FILE_MODE);
+		fs.writeFileSync(descriptor, `${JSON.stringify(file, null, 2)}\n`, "utf8");
+		fs.fsyncSync(descriptor);
+		fs.closeSync(descriptor);
 		descriptor = undefined;
-		syncFs.renameSync(temporary, filePath);
+		fs.renameSync(temporary, filePath);
 		try {
-			syncFs.chmodSync(filePath, REVIEW_FILE_MODE);
+			fs.chmodSync(filePath, REVIEW_FILE_MODE);
 		} catch {}
 		try {
-			const directory = syncFs.openSync(path.dirname(filePath), "r");
+			const directory = fs.openSync(path.dirname(filePath), "r");
 			try {
-				syncFs.fsyncSync(directory);
+				fs.fsyncSync(directory);
 			} finally {
-				syncFs.closeSync(directory);
+				fs.closeSync(directory);
 			}
 		} catch {}
 	} catch (error) {
 		if (descriptor !== undefined) {
-			syncFs.closeSync(descriptor);
+			fs.closeSync(descriptor);
 		}
 		try {
-			syncFs.unlinkSync(temporary);
+			fs.unlinkSync(temporary);
 		} catch {}
 		throw error;
 	}

package/dist/web/accounts.js

@@ -5,7 +5,7 @@ import "../routing/session-key.js";
 import { resolveAccountEntry } from "../routing/account-lookup.js";
 import { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
 import { hasWebCredsSync } from "./auth-store.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 
 //#region src/web/accounts.ts
@@ -24,7 +24,7 @@ function listWhatsAppAuthDirs(cfg) {
 		}).authDir);
 	}
 	try {
-		const entries = syncFs.readdirSync(whatsappDir, { withFileTypes: true });
+		const entries = fs.readdirSync(whatsappDir, { withFileTypes: true });
 		for (const entry of entries) {
 			if (!entry.isDirectory()) {
 				continue;
@@ -48,7 +48,7 @@ function resolveLegacyAuthDir() {
 }
 function legacyAuthExists(authDir) {
 	try {
-		return syncFs.existsSync(path.join(authDir, "creds.json"));
+		return fs.existsSync(path.join(authDir, "creds.json"));
 	} catch {
 		return false;
 	}