@fased/fased 0.1.62 → 0.1.65

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/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 };