devflare 1.0.0-next.69 → 1.0.0-next.70

package/dist/_chunks/{cli-3RIFRu7O.js → cli-ZJYtm-lW.js}

@@ -1140,7 +1140,7 @@ async function runInit(parsed, logger, options) {
 	return runInitCommand(parsed, logger, options);
 }
 async function runDev(parsed, logger, options) {
-	const { runDevCommand } = await import("./dev-D8JuhNjD.js");
+	const { runDevCommand } = await import("./dev-BagtFegV.js");
 	return runDevCommand(parsed, logger, options);
 }
 async function runWorkspace(parsed, logger, options) {

package/dist/_chunks/{dev-D8JuhNjD.js → dev-BagtFegV.js}

@@ -12,6 +12,7 @@ import { r as stopSpawnedProcessTree, t as detectViteProject } from "./vite-util
 import { dirname, relative, resolve } from "pathe";
 import { exec } from "node:child_process";
 import { createConsola } from "consola";
+import { connect } from "node:net";
 import { promisify } from "node:util";
 //#region src/bridge/miniflare.ts
 function isIgnorableMiniflareDisposeError(error) {
@@ -204,6 +205,123 @@ function createReloadQueue({ reload, logger }) {
 	};
 }
 //#endregion
+//#region src/dev-server/runtime-health.ts
+/** How often the runtime is probed. Cheap enough to be free, quick enough to catch a death between requests. */
+const RUNTIME_PROBE_INTERVAL_MS = 2e3;
+/** How long a single probe waits for the connection before counting as a failure. */
+const RUNTIME_PROBE_TIMEOUT_MS = 1e3;
+/**
+* Whether something is accepting connections at this address.
+*
+* A plain TCP connect, deliberately: the bridge only needs the listener to exist, and an HTTP request
+* would need a route that is meaningful for every app shape — a worker that 500s, hangs, or has no
+* matching route would then read as "dead" and have its runtime rebuilt underneath it. The tradeoff
+* is that a FOREIGN listener on the same port reads as alive; that only matters if something else
+* seizes the port while the runtime is down, in which case the rebuild fails on the address anyway
+* and the attempt limit reports it.
+*
+* @param options - `host`/`port` of the runtime, and how long to wait before giving up on the connect.
+* @returns true when the connection was accepted.
+*/
+function probeTcpReachable(options) {
+	const { host, port, timeoutMs = RUNTIME_PROBE_TIMEOUT_MS } = options;
+	return new Promise((resolve) => {
+		let settled = false;
+		const settle = (reachable) => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			resolve(reachable);
+		};
+		const socket = connect({
+			host,
+			port
+		});
+		socket.setTimeout(timeoutMs);
+		socket.once("connect", () => settle(true));
+		socket.once("timeout", () => settle(false));
+		socket.on("error", () => settle(false));
+	});
+}
+/**
+* A connect target that is dialable regardless of the address the runtime was bound to.
+*
+* A wildcard bind is not itself a valid destination on every platform, so probe the loopback address
+* of the SAME family. The families do not cross: a `::` bind is reachable on `::1` and NOT on
+* `127.0.0.1`, so collapsing both wildcards to the IPv4 loopback makes a healthy IPv6 runtime look
+* dead — and the watchdog would then kill and rebuild it on a loop.
+*
+* @param host - the configured Miniflare host.
+* @returns a host that can be connected to.
+*/
+function dialableHost(host) {
+	if (host === "::") return "::1";
+	if (host === "0.0.0.0") return "127.0.0.1";
+	return host;
+}
+/**
+* Watch a runtime and report it lost when it stops answering.
+*
+* The next probe is scheduled only once the previous one (and any rebuild it triggered) has finished,
+* so a slow rebuild cannot stack up signals. Reaching the threshold resets the failure count, which
+* spaces successive rebuild attempts a full threshold apart instead of firing on every probe.
+*
+* @param options - see {@link RuntimeWatchdogOptions}.
+* @returns a handle whose `stop()` ends the watch.
+*/
+function createRuntimeWatchdog(options) {
+	const { probe, onRuntimeLost, intervalMs = RUNTIME_PROBE_INTERVAL_MS, failureThreshold = 3, recoveryAttemptLimit = 3, setTimer = (fn, ms) => setTimeout(fn, ms), clearTimer = (handle) => clearTimeout(handle), logger } = options;
+	let stopped = false;
+	let timer = null;
+	let consecutiveFailures = 0;
+	let recoveryAttempts = 0;
+	function scheduleNext() {
+		if (stopped) return;
+		timer = setTimer(() => {
+			tick();
+		}, intervalMs);
+	}
+	async function tick() {
+		if (stopped) return;
+		const reachable = await probe().catch(() => false);
+		if (stopped) return;
+		if (reachable) {
+			consecutiveFailures = 0;
+			recoveryAttempts = 0;
+			scheduleNext();
+			return;
+		}
+		consecutiveFailures++;
+		if (consecutiveFailures < failureThreshold) {
+			scheduleNext();
+			return;
+		}
+		recoveryAttempts++;
+		if (recoveryAttempts > recoveryAttemptLimit) {
+			logger?.error(`The local runtime keeps going away after ${recoveryAttemptLimit} rebuild attempts. Giving up so the real error stays visible — restart \`devflare dev\` once it is resolved.`);
+			stop();
+			return;
+		}
+		try {
+			await onRuntimeLost();
+		} catch (error) {
+			logger?.error("[devflare dev] runtime rebuild failed:", error);
+		}
+		consecutiveFailures = 0;
+		scheduleNext();
+	}
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		if (timer !== null) {
+			clearTimer(timer);
+			timer = null;
+		}
+	}
+	scheduleNext();
+	return { stop };
+}
+//#endregion
 //#region src/dev-server/worker-source-watcher.ts
 async function startWorkerSourceWatcher(options) {
 	const { watchTargets, resolvedWorkerConfigPath, logger, onConfigChange, onWorkerChange } = options;
@@ -313,8 +431,55 @@ function createDevServer(options) {
 	const { cwd, configPath, vitePort = 5173, miniflarePort = 8787, miniflareHost = "127.0.0.1", enableVite: enableViteRequested = true, persist = true, logger, verbose = false, debug = process.env.DEVFLARE_DEBUG === "true" } = options;
 	const state = createDevServerState({ enableVite: enableViteRequested });
 	const r2PresignSecret = `${crypto.randomUUID()}${crypto.randomUUID()}`;
+	/** Whether the local runtime is still accepting connections. */
+	async function isRuntimeReachable() {
+		return probeTcpReachable({
+			host: dialableHost(miniflareHost),
+			port: miniflarePort
+		});
+	}
+	/**
+	* Drop a runtime that has already gone away.
+	*
+	* Disposing a dead Miniflare routinely throws (its runtime is not there to talk to), which is not a
+	* reason to abandon the rebuild — so anything unrecognised is logged rather than propagated.
+	*/
+	async function discardDeadMiniflare() {
+		if (!state.miniflare) return;
+		try {
+			await state.miniflare.dispose();
+		} catch (error) {
+			if (!isIgnorableMiniflareDisposeError(error)) logger?.debug("Disposing the dead Miniflare threw (continuing with the rebuild):", error);
+		}
+		state.miniflare = null;
+	}
+	/**
+	* Set once {@link stop} begins. A rebuild started just before shutdown would otherwise construct a
+	* fresh Miniflare AFTER the teardown disposed the old one, leaking a runtime that outlives the
+	* server — which shows up as the next thing to use the port hanging.
+	*/
+	let isStopping = false;
+	/**
+	* Set once the runtime has come up at least once. Gates the rebuild path so a reload that arrives
+	* before the first start cannot mistake "not started yet" for "died".
+	*/
+	let hasStartedRuntime = false;
 	const reloadQueue = createReloadQueue({
 		reload: async () => {
+			if (isStopping) return;
+			if (hasStartedRuntime && !await isRuntimeReachable()) {
+				if (isStopping) return;
+				logger?.warn("Local runtime stopped responding — rebuilding it");
+				await discardDeadMiniflare();
+				await startMiniflare(state.currentDoResult);
+				await runD1Migrations({
+					cwd,
+					config: state.config,
+					miniflarePort,
+					logger
+				});
+				return;
+			}
 			if (!state.miniflare) return;
 			const { Log, LogLevel } = await import("miniflare");
 			const mfConfig = buildMiniflareConfig(state.currentDoResult);
@@ -327,6 +492,29 @@ function createDevServer(options) {
 		},
 		logger
 	});
+	/**
+	* Watches the runtime for the rest of the process's life, once it is first up.
+	*
+	* Held here rather than on {@link DevServerState} because it is pure server orchestration — it owns
+	* no resource the teardown sequence has to order around, only a timer.
+	*/
+	let runtimeWatchdog = null;
+	/**
+	* Begin watching the runtime, if it is not already being watched.
+	*
+	* Deliberately idempotent, because `startMiniflare` also runs on the REBUILD path — replacing the
+	* watchdog there would hand each rebuild a fresh recovery budget, so a probe that is wrong about a
+	* healthy runtime could rebuild it forever without the attempt limit ever biting. One watchdog for
+	* the server's lifetime keeps that budget meaningful; only a successful probe clears it.
+	*/
+	function watchRuntimeHealth() {
+		if (isStopping || runtimeWatchdog) return;
+		runtimeWatchdog = createRuntimeWatchdog({
+			probe: isRuntimeReachable,
+			onRuntimeLost: () => reloadQueue.schedule(),
+			logger
+		});
+	}
 	async function bundleMainWorker() {
 		if (!state.mainWorkerScriptPath || !state.config) {
 			state.bundledMainWorkerScriptPath = null;
@@ -383,10 +571,13 @@ function createDevServer(options) {
 		mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
 		const shouldLogMiniflareDiagnostics = verbose || debug;
 		if (shouldLogMiniflareDiagnostics) logMiniflareConfigDiagnostics(logger, mfConfig);
-		state.miniflare = new Miniflare(mfConfig);
-		await state.miniflare.ready;
+		const miniflare = new Miniflare(mfConfig);
+		state.miniflare = miniflare;
+		await miniflare.ready;
 		const displayHost = miniflareHost === "0.0.0.0" || miniflareHost === "::" ? "localhost" : miniflareHost;
 		logger?.success(`Miniflare ready on http://${displayHost}:${miniflarePort}`);
+		hasStartedRuntime = true;
+		watchRuntimeHealth();
 		if (shouldLogMiniflareDiagnostics) await logMiniflareBindingDiagnostics(logger, state.miniflare, mfConfig);
 	}
 	/**
@@ -552,6 +743,10 @@ function createDevServer(options) {
 	* Stop the dev server
 	*/
 	async function stop() {
+		isStopping = true;
+		runtimeWatchdog?.stop();
+		runtimeWatchdog = null;
+		await reloadQueue.drain();
 		await disposeDevServerState(state);
 	}
 	/**

package/dist/cli/index.js

@@ -1,2 +1,2 @@
-import { n as runCli, t as parseArgs } from "../_chunks/cli-3RIFRu7O.js";
+import { n as runCli, t as parseArgs } from "../_chunks/cli-ZJYtm-lW.js";
 export { parseArgs, runCli };

package/dist/dev-server/runtime-health.d.ts

@@ -0,0 +1,79 @@
+import type { ConsolaInstance } from 'consola';
+/** How often the runtime is probed. Cheap enough to be free, quick enough to catch a death between requests. */
+export declare const RUNTIME_PROBE_INTERVAL_MS = 2000;
+/**
+ * Consecutive failed probes before the runtime is declared gone. More than one so a probe that lands
+ * inside a legitimate reload — when the listener is briefly absent — does not trigger a rebuild.
+ */
+export declare const RUNTIME_PROBE_FAILURE_THRESHOLD = 3;
+/** How long a single probe waits for the connection before counting as a failure. */
+export declare const RUNTIME_PROBE_TIMEOUT_MS = 1000;
+/**
+ * How many times an outage may be recovered before the watchdog stands down. A runtime that dies
+ * immediately on every rebuild is broken in a way retrying cannot fix; looping on it would bury the
+ * real error under restart noise.
+ */
+export declare const RUNTIME_RECOVERY_ATTEMPT_LIMIT = 3;
+/**
+ * Whether something is accepting connections at this address.
+ *
+ * A plain TCP connect, deliberately: the bridge only needs the listener to exist, and an HTTP request
+ * would need a route that is meaningful for every app shape — a worker that 500s, hangs, or has no
+ * matching route would then read as "dead" and have its runtime rebuilt underneath it. The tradeoff
+ * is that a FOREIGN listener on the same port reads as alive; that only matters if something else
+ * seizes the port while the runtime is down, in which case the rebuild fails on the address anyway
+ * and the attempt limit reports it.
+ *
+ * @param options - `host`/`port` of the runtime, and how long to wait before giving up on the connect.
+ * @returns true when the connection was accepted.
+ */
+export declare function probeTcpReachable(options: {
+    host: string;
+    port: number;
+    timeoutMs?: number;
+}): Promise<boolean>;
+/**
+ * A connect target that is dialable regardless of the address the runtime was bound to.
+ *
+ * A wildcard bind is not itself a valid destination on every platform, so probe the loopback address
+ * of the SAME family. The families do not cross: a `::` bind is reachable on `::1` and NOT on
+ * `127.0.0.1`, so collapsing both wildcards to the IPv4 loopback makes a healthy IPv6 runtime look
+ * dead — and the watchdog would then kill and rebuild it on a loop.
+ *
+ * @param host - the configured Miniflare host.
+ * @returns a host that can be connected to.
+ */
+export declare function dialableHost(host: string): string;
+export interface RuntimeWatchdogOptions {
+    /** Answers "is the runtime still there?"; injected so the schedule can be tested without sockets. */
+    probe: () => Promise<boolean>;
+    /** Invoked once per outage, after {@link RUNTIME_PROBE_FAILURE_THRESHOLD} consecutive failures. */
+    onRuntimeLost: () => Promise<void>;
+    /** Probe period. */
+    intervalMs?: number;
+    /** Consecutive failures that constitute an outage. */
+    failureThreshold?: number;
+    /** Consecutive unrecovered outages before the watchdog stands down. */
+    recoveryAttemptLimit?: number;
+    /** Schedules the next probe; injected so tests can drive the clock. */
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    /** Cancels a scheduled probe. */
+    clearTimer?: (handle: unknown) => void;
+    logger?: ConsolaInstance;
+}
+export interface RuntimeWatchdog {
+    /** Stop probing. Idempotent. */
+    stop(): void;
+}
+/**
+ * Watch a runtime and report it lost when it stops answering.
+ *
+ * The next probe is scheduled only once the previous one (and any rebuild it triggered) has finished,
+ * so a slow rebuild cannot stack up signals. Reaching the threshold resets the failure count, which
+ * spaces successive rebuild attempts a full threshold apart instead of firing on every probe.
+ *
+ * @param options - see {@link RuntimeWatchdogOptions}.
+ * @returns a handle whose `stop()` ends the watch.
+ */
+export declare function createRuntimeWatchdog(options: RuntimeWatchdogOptions): RuntimeWatchdog;
+//# sourceMappingURL=runtime-health.d.ts.map

package/dist/dev-server/runtime-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-health.d.ts","sourceRoot":"","sources":["../../src/dev-server/runtime-health.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,gHAAgH;AAChH,eAAO,MAAM,yBAAyB,OAAO,CAAA;AAC7C;;;GAGG;AACH,eAAO,MAAM,+BAA+B,IAAI,CAAA;AAChD,qFAAqF;AACrF,eAAO,MAAM,wBAAwB,OAAO,CAAA;AAC5C;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,IAAI,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIjD;AAED,MAAM,WAAW,sBAAsB;IACtC,qGAAqG;IACrG,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;IAC7B,mGAAmG;IACnG,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAClC,oBAAoB;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sDAAsD;IACtD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,uEAAuE;IACvE,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAA;IAClD,iCAAiC;IACjC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IACtC,MAAM,CAAC,EAAE,eAAe,CAAA;CACxB;AAED,MAAM,WAAW,eAAe;IAC/B,gCAAgC;IAChC,IAAI,IAAI,IAAI,CAAA;CACZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,eAAe,CA+EtF"}

package/dist/dev-server/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dev-server/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,WAAW,CAAA;AAiD3D,MAAM,WAAW,gBAAgB;IAChC,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,wEAAwE;IACxE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB;IACtB,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACzB,2BAA2B;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,0BAA0B;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,yCAAyC;IACzC,YAAY,IAAI,aAAa,GAAG,IAAI,CAAA;CACpC;AAMD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAwYpE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dev-server/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,WAAW,CAAA;AAwD3D,MAAM,WAAW,gBAAgB;IAChC,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,wEAAwE;IACxE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB;IACtB,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACzB,2BAA2B;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,0BAA0B;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,yCAAyC;IACzC,YAAY,IAAI,aAAa,GAAG,IAAI,CAAA;CACpC;AAMD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CA0epE"}

package/dist/index.js

@@ -5,6 +5,6 @@ import { a as ConfigResourceResolutionError, d as configSchema, n as ConfigValid
 import { n as compileConfig, s as stringifyConfig } from "./_chunks/compiler-UxXQgEPq.js";
 import { t as workerName } from "./_chunks/workerName-kEXwmV2m.js";
 import { n as getDurableObjectOptions, t as durableObject } from "./_chunks/decorators-eXNZ1S0N.js";
-import { n as runCli, t as parseArgs } from "./_chunks/cli-3RIFRu7O.js";
+import { n as runCli, t as parseArgs } from "./_chunks/cli-ZJYtm-lW.js";
 import { i as vars, r as env } from "./_chunks/env-D4uJqqgu.js";
 export { ConfigNotFoundError, ConfigResourceResolutionError, ConfigValidationError, compileConfig, configSchema, defineConfig as default, defineConfig, defineWorkspace, durableObject, env, getDurableObjectOptions, loadConfig, loadResolvedConfig, parseArgs, preview, ref, runCli, stringifyConfig, vars, workerName };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "devflare",
-	"version": "1.0.0-next.69",
+	"version": "1.0.0-next.70",
 	"description": "Devflare is a developer-first toolkit for Cloudflare Workers that sits on top of Miniflare and Wrangler-compatible config",
 	"repository": {
 		"type": "git",