@fased/fased 0.1.61 → 0.1.64

package/dist/gateway/config-reload.js

@@ -291,7 +291,6 @@ function startGatewayConfigReloader(opts) {
 	let pending = false;
 	let running = false;
 	let stopped = false;
-	let restartQueued = false;
 	let missingConfigRetries = 0;
 	const scheduleAfter = (wait) => {
 		if (stopped) {
@@ -307,19 +306,14 @@ function startGatewayConfigReloader(opts) {
 	const schedule = () => {
 		scheduleAfter(settings.debounceMs);
 	};
-	const queueRestart = (plan, nextConfig) => {
-		if (restartQueued) {
-			return;
+	const queueRestart = async (plan, nextConfig, snapshot) => {
+		try {
+			await opts.onRestart(plan, nextConfig, snapshot);
+			return true;
+		} catch {
+			opts.log.error("config restart validation failed; restart was not scheduled");
+			return false;
 		}
-		restartQueued = true;
-		void (async () => {
-			try {
-				await opts.onRestart(plan, nextConfig);
-			} catch (err) {
-				restartQueued = false;
-				opts.log.error(`config restart failed: ${String(err)}`);
-			}
-		})();
 	};
 	const handleMissingSnapshot = (snapshot) => {
 		if (snapshot.exists) {
@@ -343,32 +337,38 @@ function startGatewayConfigReloader(opts) {
 		opts.log.warn(`config reload skipped (invalid config): ${issues}`);
 		return true;
 	};
-	const applySnapshot = async (nextConfig) => {
+	const applySnapshot = async (snapshot) => {
+		const nextConfig = snapshot.config;
 		const changedPaths = diffConfigPaths(currentConfig, nextConfig);
-		currentConfig = nextConfig;
-		settings = resolveGatewayReloadSettings(nextConfig);
+		const nextSettings = resolveGatewayReloadSettings(nextConfig);
+		const commitBaseline = () => {
+			currentConfig = nextConfig;
+			settings = nextSettings;
+		};
 		if (changedPaths.length === 0) {
+			commitBaseline();
 			return;
 		}
 		opts.log.info(`config change detected; evaluating reload (${changedPaths.join(", ")})`);
 		const plan = buildGatewayReloadPlan(changedPaths);
-		if (settings.mode === "off") {
+		if (nextSettings.mode === "off") {
 			opts.log.info("config reload disabled (gateway.reload.mode=off)");
 			return;
 		}
-		if (settings.mode === "restart") {
-			queueRestart(plan, nextConfig);
+		if (nextSettings.mode === "restart") {
+			await queueRestart(plan, nextConfig, snapshot);
 			return;
 		}
 		if (plan.restartGateway) {
-			if (settings.mode === "hot") {
+			if (nextSettings.mode === "hot") {
 				opts.log.warn(`config reload requires gateway restart; hot mode ignoring (${plan.restartReasons.join(", ")})`);
 				return;
 			}
-			queueRestart(plan, nextConfig);
+			await queueRestart(plan, nextConfig, snapshot);
 			return;
 		}
-		await opts.onHotReload(plan, nextConfig);
+		await opts.onHotReload(plan, nextConfig, snapshot);
+		commitBaseline();
 	};
 	const runReload = async () => {
 		if (stopped) {
@@ -385,15 +385,16 @@ function startGatewayConfigReloader(opts) {
 		}
 		try {
 			const snapshot = await opts.readSnapshot();
+			opts.onSourceRevision?.(snapshot);
 			if (handleMissingSnapshot(snapshot)) {
 				return;
 			}
 			if (handleInvalidSnapshot(snapshot)) {
 				return;
 			}
-			await applySnapshot(snapshot.config);
-		} catch (err) {
-			opts.log.error(`config reload failed: ${String(err)}`);
+			await applySnapshot(snapshot);
+		} catch {
+			opts.log.error("config reload failed; keeping last-known-good configuration");
 		} finally {
 			running = false;
 			if (pending) {
@@ -422,16 +423,28 @@ function startGatewayConfigReloader(opts) {
 		opts.log.warn(`config watcher error: ${String(err)}`);
 		void watcher.close().catch(() => {});
 	});
-	return { stop: async () => {
-		stopped = true;
-		if (debounceTimer) {
-			clearTimeout(debounceTimer);
+	let stopPromise = null;
+	return { stop: () => {
+		if (stopPromise) {
+			return stopPromise;
 		}
-		debounceTimer = null;
-		watcherClosed = true;
-		await watcher.close().catch(() => {});
+		stopPromise = (async () => {
+			stopped = true;
+			try {
+				opts.onStop?.();
+			} catch {
+				opts.log.warn("config reload shutdown cleanup failed");
+			}
+			if (debounceTimer) {
+				clearTimeout(debounceTimer);
+			}
+			debounceTimer = null;
+			watcherClosed = true;
+			await watcher.close().catch(() => {});
+		})();
+		return stopPromise;
 	} };
 }
 
 //#endregion
-export { diffConfigPaths, startGatewayConfigReloader };
+export { buildGatewayReloadPlan, diffConfigPaths, resolveGatewayReloadSettings, startGatewayConfigReloader };

package/dist/gateway/control-ui-boot-check.js

@@ -2,7 +2,7 @@ import { openBoundaryFileSync } from "../infra/boundary-file-read.js";
 import { isWithinDir } from "../infra/path-safety.js";
 import { normalizeControlUiBasePath } from "./control-ui-shared.js";
 import { resolveControlUiRootSync } from "../infra/control-ui-assets.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/gateway/control-ui-boot-check.ts
@@ -189,7 +189,7 @@ function readControlUiBootAsset(params) {
 		};
 	}
 	try {
-		const body = fs.readFileSync(safeFile.fd);
+		const body = syncFs.readFileSync(safeFile.fd);
 		return {
 			check: {
 				url: params.url,
@@ -200,7 +200,7 @@ function readControlUiBootAsset(params) {
 			text: body.toString("utf8")
 		};
 	} finally {
-		fs.closeSync(safeFile.fd);
+		syncFs.closeSync(safeFile.fd);
 	}
 }
 function resolveBootCheckRoot(rootState) {
@@ -231,7 +231,7 @@ function resolveBootCheckRoot(rootState) {
 		return {
 			ok: true,
 			root,
-			rootReal: fs.realpathSync(root)
+			rootReal: syncFs.realpathSync(root)
 		};
 	} catch (error) {
 		if (isExpectedSafePathError(error)) {
@@ -268,9 +268,9 @@ function resolveControlUiBootCheck(params) {
 	}
 	let html = "";
 	try {
-		html = fs.readFileSync(safeIndex.fd, "utf8");
+		html = syncFs.readFileSync(safeIndex.fd, "utf8");
 	} finally {
-		fs.closeSync(safeIndex.fd);
+		syncFs.closeSync(safeIndex.fd);
 	}
 	const entryJsUrl = extractHtmlScriptAssetUrls(html, indexUrl)[0] ?? null;
 	const entry = entryJsUrl == null ? {

package/dist/gateway/control-ui-login.js

@@ -1,7 +1,7 @@
 import { resolveStateDir } from "../config/paths.js";
 import { safeEqualSecret } from "../security/secret-equal.js";
 import { isTrustedProxyAddress } from "./net.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import { createHash, createHmac, randomBytes } from "node:crypto";
 
@@ -512,10 +512,10 @@ var ControlUiLoginService = class {
 	}
 	readState() {
 		try {
-			if (!fs.existsSync(this.statePath)) {
+			if (!syncFs.existsSync(this.statePath)) {
 				return buildEmptyState();
 			}
-			const raw = fs.readFileSync(this.statePath, "utf8");
+			const raw = syncFs.readFileSync(this.statePath, "utf8");
 			return normalizeState(safeJsonParse(raw));
 		} catch {
 			return buildEmptyState();
@@ -525,13 +525,13 @@ var ControlUiLoginService = class {
 		if (!this.state) {
 			return;
 		}
-		fs.mkdirSync(path.dirname(this.statePath), { recursive: true });
+		syncFs.mkdirSync(path.dirname(this.statePath), { recursive: true });
 		const tmpPath = `${this.statePath}.${process.pid}.${Date.now()}.tmp`;
 		const body = `${JSON.stringify(this.state, null, 2)}\n`;
-		fs.writeFileSync(tmpPath, body, { mode: 384 });
-		fs.renameSync(tmpPath, this.statePath);
+		syncFs.writeFileSync(tmpPath, body, { mode: 384 });
+		syncFs.renameSync(tmpPath, this.statePath);
 		try {
-			fs.chmodSync(this.statePath, 384);
+			syncFs.chmodSync(this.statePath, 384);
 		} catch {}
 	}
 };

package/dist/gateway/control-ui.js

@@ -8,7 +8,7 @@ import { resolveControlUiRootSync } from "../infra/control-ui-assets.js";
 import { DEFAULT_ASSISTANT_IDENTITY, resolveAssistantIdentity } from "./assistant-identity.js";
 import { CONTROL_UI_BOOTSTRAP_CONFIG_PATH } from "./control-ui-contract.js";
 import { buildControlUiCspHeader } from "./control-ui-csp.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/gateway/control-ui.ts
@@ -152,10 +152,10 @@ function handleControlUiAvatarRequest(req, res, opts) {
 			res.end();
 			return true;
 		}
-		serveResolvedFile(res, safeAvatar.path, fs.readFileSync(safeAvatar.fd));
+		serveResolvedFile(res, safeAvatar.path, syncFs.readFileSync(safeAvatar.fd));
 		return true;
 	} finally {
-		fs.closeSync(safeAvatar.fd);
+		syncFs.closeSync(safeAvatar.fd);
 	}
 }
 function respondNotFound(res) {
@@ -318,7 +318,7 @@ function handleControlUiHttpRequest(req, res, opts) {
 	}
 	const rootReal = (() => {
 		try {
-			return fs.realpathSync(root);
+			return syncFs.realpathSync(root);
 		} catch (error) {
 			if (isExpectedSafePathError(error)) {
 				return null;
@@ -364,13 +364,13 @@ function handleControlUiHttpRequest(req, res, opts) {
 				return true;
 			}
 			if (path.basename(safeFile.path) === "index.html") {
-				serveResolvedIndexHtml(res, fs.readFileSync(safeFile.fd, "utf8"));
+				serveResolvedIndexHtml(res, syncFs.readFileSync(safeFile.fd, "utf8"));
 				return true;
 			}
-			serveResolvedFile(res, safeFile.path, fs.readFileSync(safeFile.fd));
+			serveResolvedFile(res, safeFile.path, syncFs.readFileSync(safeFile.fd));
 			return true;
 		} finally {
-			fs.closeSync(safeFile.fd);
+			syncFs.closeSync(safeFile.fd);
 		}
 	}
 	if (STATIC_ASSET_EXTENSIONS.has(path.extname(fileRel).toLowerCase())) {
@@ -387,10 +387,10 @@ function handleControlUiHttpRequest(req, res, opts) {
 				res.end();
 				return true;
 			}
-			serveResolvedIndexHtml(res, fs.readFileSync(safeIndex.fd, "utf8"));
+			serveResolvedIndexHtml(res, syncFs.readFileSync(safeIndex.fd, "utf8"));
 			return true;
 		} finally {
-			fs.closeSync(safeIndex.fd);
+			syncFs.closeSync(safeIndex.fd);
 		}
 	}
 	respondNotFound(res);

package/dist/gateway/durable-capacity.js

@@ -0,0 +1,31 @@
+//#region src/gateway/durable-capacity.ts
+const WARNING_PERCENT = 80;
+const emittedWarnings = new Set();
+function durableCapacityStatus(used, maximum) {
+	if (!Number.isSafeInteger(used) || used < 0 || !Number.isSafeInteger(maximum) || maximum < 1) {
+		throw new Error("durable capacity values must be non-negative safe integers");
+	}
+	const warnAt = Math.ceil(maximum * WARNING_PERCENT / 100);
+	return {
+		used,
+		maximum,
+		warnAt,
+		warning: used >= warnAt
+	};
+}
+function emitDurableCapacityWarning(label, used, maximum) {
+	const status = durableCapacityStatus(used, maximum);
+	const key = `${label}\0${maximum}`;
+	if (!status.warning) {
+		emittedWarnings.delete(key);
+		return;
+	}
+	if (emittedWarnings.has(key)) {
+		return;
+	}
+	emittedWarnings.add(key);
+	console.warn(`[fased] ${label} capacity warning: ${status.used}/${status.maximum} records (warning threshold ${status.warnAt}); archive/retention review is required before the fail-closed limit`);
+}
+
+//#endregion
+export { emitDurableCapacityWarning };