mithril-lynx 0.0.9 → 2.0.0

package/src/dev-reload-client.js

@@ -1,138 +1,121 @@
-// Development-only client for Lynx Go.
+// Development-only client for Lynx Go — background thread only.
 //
-// Mithril view code runs in the main-thread/Lepus bundle, while WebSocket and
-// Native Module access only exist in the background JS bundle. Consequently
-// normal module HMR cannot patch the view code. On a successful rebuild this
-// client triggers an in-place reload of the current page.
+// Adapted from mithril-lynx v1's src/dev-reload-client.js, with the F0
+// monkey-patch of `lynx.requireModuleAsync` REMOVED: that patch existed
+// only because v1's `RuntimeWrapperWebpackPlugin` config never matched
+// `.hot-update.js` chunks, so the native eval context had no `module`/
+// `exports` bindings for them (see mithril-lynx-v2-desde-cero.md §F0.2 —
+// the real fix is the widened `test` regex in this package's plugin.js,
+// applied at build time to every chunk including hot-update ones, not a
+// runtime patch of the module loader).
 //
-// Mechanism: CDP `Page.reload` via the DevTool native module
-// (`NativeModules.LynxDevToolSetModule.invokeCdp`) — the same mechanism
-// Rspeedy's own official live-reload client uses
-// (`@lynx-js/webpack-dev-transport/lib/client/reloadApp.js`). It reloads the
-// CURRENT page in place (no new Activity on the back stack) and it is invoked
-// from inside the bundle itself, so the only network hop is the WebSocket the
-// client runs on: Wi-Fi only, no adb, no cable.
+// Also REMOVED: the `__mithril_redraw` global v1 called after a successful
+// check(). It isn't needed — the app's own background.ts calls
+// `module.hot.accept("./index.js", ...)` and re-renders from ITS OWN
+// closure when that fires (see the demo app's background.ts for the
+// pattern). This client's only job is: decide whether a rebuild can be
+// applied via HMR at all, and fall back to a full CDP `Page.reload` when
+// it can't (structural changes, `module.hot.decline()`, or a check()
+// rejection).
 //
-// Why not the alternatives (each verified on-device):
-// - `lynx.reload({})` (v0.0.9's original mechanism): on the device's engine it
-//   re-executes the main-thread bundle against the live session, but the
-//   runtime helpers `removeComponents`/`updatePage` are not re-injected, so
-//   the render crashes with two TypeErrors (captured via lynx-devtool) and the
-//   background chunk never re-runs — the socket dies and later builds are
-//   silently ignored.
-// - `ExplorerModule.openSchema(url)` (0.0.7's mechanism): real navigation —
-//   Lynx Go starts a NEW LynxViewShellActivity every time and never finishes
-//   the one it replaces, so Back steps through one frozen snapshot per reload.
-// - `lynx.fetchBundle(url)` + `lynx.loadScript(sectionName, {bundleName})`:
-//   in lynx-core these are the lazy-bundle path (`LazyBundleLoader` /
-//   `LoadCustomSectionScript`) — they load a customSection of a SEPARATE
-//   lazily-fetched bundle, not the page's own main-thread/Lepus template, so
-//   they cannot re-render the current page.
-//
-// The reload passes a cache-busted `url` (`?t=<ts>`) because Lynx keys both
-// its HTTP layer and its bytecode cache by URL: measured on-device in 0.0.8,
-// a `Page.reload` without a changed URL re-runs the PREVIOUS bundle
-// byte-for-byte even with `ignoreCache:true` (see `cacheBustedUrl()` in
-// plugin.js).
-//
-// This client runs on the background/JS thread (where WebSocket + the
-// `lynx`/`NativeModules` globals are available), is only ever imported in dev
-// builds (see plugin.js's synthetic background chunk), and reads its config
-// from a resource query string injected at build time.
+// One real fix over v1 that IS new here: the "race de doble-build" (two
+// rebuilds landing close together made v1 see `hotStatus !== "idle"` and
+// give up to a full reload even though each edit alone was light) is
+// fixed by coalescing instead of by a version counter — see
+// `pendingRecheckHash` below. `module.hot.check()` itself already refuses
+// to run when not idle (real webpack behavior), so the fix has to live on
+// this side of that call, not inside it.
+
+var MRL = "[mrl-trace]";
 
 function parseResourceQuery(query) {
-	const values = {};
+	var values = {};
 	if (typeof query !== "string" || !query.startsWith("?")) return values;
-	for (const pair of query.slice(1).split("&")) {
-		const index = pair.indexOf("=");
-		const key = index === -1 ? pair : pair.slice(0, index);
-		const value = index === -1 ? "" : pair.slice(index + 1);
+	for (var i = 0, pairs = query.slice(1).split("&"); i < pairs.length; i++) {
+		var pair = pairs[i];
+		var index = pair.indexOf("=");
+		var key = index === -1 ? pair : pair.slice(0, index);
+		var value = index === -1 ? "" : pair.slice(index + 1);
 		values[key] = decodeURIComponent(value);
 	}
 	return values;
 }
 
 function socketURL(options) {
-	const hostname = options.hostname || "";
-	const port = options.port ? `:${options.port}` : "";
-	const pathname = options.pathname || "/rsbuild-hmr";
-	const token = options.token ? `?token=${encodeURIComponent(options.token)}` : "";
-	return `${options.protocol || "ws"}://${hostname}${port}${pathname}${token}`;
+	var hostname = options.hostname || "";
+	var port = options.port ? ":" + options.port : "";
+	var pathname = options.pathname || "/rsbuild-hmr";
+	var token = options.token ? "?token=" + encodeURIComponent(options.token) : "";
+	return (options.protocol || "ws") + "://" + hostname + port + pathname + token;
 }
 
-const options = parseResourceQuery(__resourceQuery);
-const bundleUrl = options["bundle-url"];
-
 /**
- * Appends a unique query parameter to a bundle URL. Lynx keys both the HTTP
- * layer and its bytecode cache by URL, so `Page.reload` with the SAME URL
- * re-runs the previous bundle byte-for-byte even with `ignoreCache: true`
- * (measured on-device in 0.0.8). Changing the URL is what actually forces a
- * fresh fetch — same reasoning as `cacheBustedUrl()` in plugin.js.
- *
- * Returns undefined for anything that isn't an http(s) URL, so the caller can
- * fall back to letting Page.reload use its existing URL.
+ * Lynx keys both the HTTP layer and its bytecode cache by URL — a
+ * `Page.reload` with the SAME url re-runs the previous bundle byte-for-byte
+ * even with `ignoreCache: true` (measured on-device against v1, 0.0.8).
  */
-function cacheBustedUrl(url, now = Date.now()) {
+function cacheBustedUrl(url, now) {
 	if (typeof url !== "string" || !/^https?:\/\//i.test(url)) return undefined;
-	const [base, query = ""] = url.split("?");
-	const params = new URLSearchParams(query);
+	if (now === undefined) now = Date.now();
+	var parts = url.split("?");
+	var base = parts[0];
+	var query = parts[1] || "";
+	var params = new URLSearchParams(query);
 	params.set("t", String(now));
-	return `${base}?${params.toString()}`;
+	return base + "?" + params.toString();
 }
 
-let currentHash;
-let initialBuild = true;
-let socket;
-// Reloading the current page — including re-executing this very module from
-// scratch would naturally replace this stale instance's socket with a fresh
-// one, except the OLD connection is otherwise left open: confirmed on-device
-// (0.0.7) that every earlier reload's socket stays alive and keeps receiving
-// server broadcasts, so a build a few reloads in fires the reload several
-// times at once (one call per still-open stale socket), and the resulting
-// reloads race. Closing this socket ourselves right before reloading, and
-// suppressing the reconnect-on-close it would otherwise trigger, keeps exactly
-// one socket alive at a time. Same lifecycle bug as 0.0.7, identical fix.
-let reloading = false;
-
-console.info(
-	"[mithril-lynx] LynxDevToolSetModule.invokeCdp:",
-	typeof NativeModules !== "undefined" && typeof NativeModules.LynxDevToolSetModule?.invokeCdp,
-	"| lynx.reload:",
-	typeof lynx !== "undefined" && typeof lynx?.reload,
-	"| ExplorerModule.openSchema:",
-	typeof NativeModules !== "undefined" && typeof NativeModules.ExplorerModule?.openSchema,
-);
+var options = parseResourceQuery(__resourceQuery);
+var bundleUrl = options["bundle-url"];
+
+console.info(MRL + ":0 client-boot", JSON.stringify({
+	hostname: options.hostname,
+	port: options.port,
+	protocol: options.protocol,
+	pathname: options.pathname,
+	hasToken: !!options.token,
+	bundleUrl: bundleUrl,
+}));
+
+var currentHash;
+var initialBuild = true;
+// Anti-loop guard: without comparing against the hash the running bundle
+// was actually built with, every boot would trigger check() for the SAME
+// hash it already carries -> manifest 404 -> full reload -> boot -> loop.
+var runtimeHash = typeof __webpack_require__ !== "undefined"
+	&& typeof __webpack_require__.h === "function"
+	? __webpack_require__.h()
+	: null;
+var socket;
+var reloading = false;
+// Set when an "ok" for a NEW hash arrives while a check() from a PREVIOUS
+// hash is still in flight. Instead of giving up to a full reload (v1's
+// race), the in-flight check's `.then`/`.catch` re-drives the check logic
+// against this hash once it settles.
+var pendingRecheckHash;
 
 function invokeCdpReload() {
-	// Mirrors @lynx-js/webpack-dev-transport/lib/client/reloadApp.js:
-	// Lynx Go exposes the DevTool CDP bridge under two module casings;
-	// either one accepts the Page.reload CDP message. Note the older
-	// casing binds "Page.reload" as a leading argument, like the official
-	// client does.
-	const upperCase = typeof NativeModules !== "undefined" ? NativeModules.LynxDevToolSetModule : undefined;
-	const lowerCase = typeof NativeModules !== "undefined" ? NativeModules.LynxDevtoolSetModule : undefined;
-	const invokeCdp =
-		(upperCase?.invokeCdp?.bind(upperCase)) ??
-		(typeof lowerCase?.invokeCdp === "function" ? lowerCase.invokeCdp.bind(lowerCase, "Page.reload") : undefined);
+	var upperCase = typeof NativeModules !== "undefined" ? NativeModules.LynxDevToolSetModule : undefined;
+	var lowerCase = typeof NativeModules !== "undefined" ? NativeModules.LynxDevtoolSetModule : undefined;
+	var invokeCdp =
+		(upperCase && upperCase.invokeCdp ? upperCase.invokeCdp.bind(upperCase) : undefined) ??
+		(typeof (lowerCase && lowerCase.invokeCdp) === "function" ? lowerCase.invokeCdp.bind(lowerCase, "Page.reload") : undefined);
 	if (typeof invokeCdp !== "function") return false;
 
-	// Page.reload with the SAME URL re-runs the previous bundle (URL-keyed
-	// bytecode cache — measured in 0.0.8), so pass the cache-busted URL. If
-	// the URL is unusable for some reason, fall back to the bare CDP reload
-	// rather than skipping the reload entirely.
-	const params = { ignoreCache: true };
-	const url = cacheBustedUrl(bundleUrl);
+	var params = { ignoreCache: true };
+	var url = cacheBustedUrl(bundleUrl);
 	if (url != null) params.url = url;
 
+	console.info(MRL + ":9 cdp-page-reload", JSON.stringify({ url: url, bundleUrl: bundleUrl }));
+
 	invokeCdp(
 		JSON.stringify({ method: "Page.reload", params }),
-		(data) => {
+		function (data) {
 			if (!data) return;
 			try {
-				const { error } = JSON.parse(data);
-				if (error) console.error("[mithril-lynx] Page.reload failed:", error.message);
-			} catch {
+				var parsed = JSON.parse(data);
+				if (parsed.error) console.error("[mithril-lynx-v2] Page.reload failed:", parsed.error.message);
+			} catch (e) {
 				// response is not JSON — ignore
 			}
 		},
@@ -140,121 +123,122 @@ function invokeCdpReload() {
 	return true;
 }
 
-function reload() {
-	// Preferred: CDP Page.reload through the DevTool native module — the
-	// same mechanism Rspeedy's own live-reload client uses. Page.reload
-	// reloads the current page in place (no new Activity, no back-stack
-	// corruption — verified on-device in 0.0.8), and because it is invoked
-	// from inside the bundle it works over Wi-Fi alone.
-	const cdpModule =
-		(typeof NativeModules !== "undefined" && NativeModules.LynxDevToolSetModule?.invokeCdp) ||
-		(typeof NativeModules !== "undefined" && NativeModules.LynxDevtoolSetModule?.invokeCdp);
-	if (typeof cdpModule === "function") {
-		console.info("[mithril-lynx] Reloading in place via CDP Page.reload.");
-		reloading = true;
-		socket?.close();
-		invokeCdpReload();
-		return;
+function reload(reason) {
+	console.info(MRL + ":8 reload-called", JSON.stringify({ reason: reason || "unspecified" }));
+	reloading = true;
+	if (socket) socket.close();
+	if (!invokeCdpReload()) {
+		console.warn(
+			"[mithril-lynx-v2] Live reload unavailable: NativeModules.LynxDevToolSetModule.invokeCdp was not found.",
+		);
 	}
+}
 
-	// Fallback: lynx.reload() reloads the current page in place — no new
-	// Activity, no back-stack corruption. `value` is the new init data for the
-	// page; pass {} to keep the same (no new initData), mirroring openSchema's
-	// full reload. The callback fires when the reload completes. NOTE: on the
-	// engine this project targets (reported 3.5 on-device), lynx.reload
-	// re-executes the main-thread bundle against the live session without
-	// re-injecting the runtime helpers removeComponents/updatePage, crashing
-	// with two TypeErrors and never re-running the background chunk — that is
-	// why CDP is preferred and lynx.reload stays only as a fallback for
-	// viewers/SDKs whose reload path is intact.
-	const reloadFn = typeof lynx !== "undefined" && typeof lynx?.reload === "function" ? lynx.reload : null;
-	if (reloadFn) {
-		console.info("[mithril-lynx] Reloading in place via lynx.reload().");
-		reloading = true;
-		socket?.close();
-		try {
-			reloadFn.call(lynx, {}, () => {
-				console.info("[mithril-lynx] Reload complete.");
-			});
-		} catch (error) {
-			console.error("[mithril-lynx] lynx.reload threw:", error);
+function runCheck(hash) {
+	console.info(MRL + ":5 hmr-check-calling", "module.hot.check(true)");
+	module.hot.check(true).then(function (updatedModules) {
+		console.info(MRL + ":6 hmr-check-resolved", JSON.stringify({
+			updatedModulesLength: updatedModules ? updatedModules.length : 0,
+		}));
+		var recheck = pendingRecheckHash;
+		pendingRecheckHash = undefined;
+		if (recheck && recheck !== hash) {
+			console.info(MRL + ":6d coalesced-recheck", JSON.stringify({ hash: recheck }));
+			maybeCheck(recheck);
+			return;
 		}
-		return;
-	}
+		if (!updatedModules || updatedModules.length === 0) {
+			console.info(MRL + ":6c hmr-no-modules", "falling back to full reload");
+			reload("hmr-check-returned-no-modules");
+		}
+	}).catch(function (err) {
+		console.warn(MRL + ":7 hmr-check-rejected", JSON.stringify({
+			message: err && err.message,
+		}));
+		var recheck = pendingRecheckHash;
+		pendingRecheckHash = undefined;
+		if (recheck) {
+			maybeCheck(recheck);
+			return;
+		}
+		reload("hmr-check-rejected:" + (err && err.message ? err.message : String(err)));
+	});
+}
 
-	// Last resort: ExplorerModule.openSchema(url) — the 0.0.7 mechanism. Works
-	// over Wi-Fi too, but it is a real navigation and stacks a new
-	// LynxViewShellActivity per reload (Back then walks frozen snapshots). Kept
-	// only for viewers/SDKs where lynx.reload is unavailable.
-	const openSchema =
-		typeof NativeModules !== "undefined" && NativeModules.ExplorerModule?.openSchema;
-	if (typeof openSchema !== "function") {
-		console.warn(
-			"[mithril-lynx] Live reload unavailable: neither CDP invokeCdp, lynx.reload, nor ExplorerModule.openSchema was found.",
-		);
+function maybeCheck(hash) {
+	var hasHot = typeof module !== "undefined" && module.hot;
+	var hotStatus = hasHot ? module.hot.status() : "n/a";
+
+	console.info(MRL + ":4 hmr-check", JSON.stringify({ hasModuleHot: hasHot, hotStatus: hotStatus }));
+
+	if (!hasHot) {
+		console.info(MRL + ":4a hmr-unavailable", JSON.stringify({ hasHot: hasHot }));
+		reload("hmr-unavailable:no-module-hot");
 		return;
 	}
-	if (!bundleUrl) {
-		console.warn("[mithril-lynx] Live reload unavailable: the bundle URL was not configured.");
+	if (hotStatus !== "idle") {
+		// A check for an OLDER hash is still in flight — coalesce instead of
+		// bailing to a full reload (the v1 "race de doble-build" fix).
+		pendingRecheckHash = hash;
+		console.info(MRL + ":4b hmr-check-in-flight", JSON.stringify({ queuedHash: hash }));
 		return;
 	}
-	console.info("[mithril-lynx] Reloading updated bundle via ExplorerModule.openSchema (fallback).");
-	reloading = true;
-	socket?.close();
-	openSchema.call(NativeModules.ExplorerModule, bundleUrl);
+	runCheck(hash);
 }
 
 function handleMessage(rawMessage) {
-	let message;
+	var message;
 	try {
 		message = JSON.parse(rawMessage);
-	} catch {
-		console.warn("[mithril-lynx] Ignoring an invalid dev-server message.");
+	} catch (e) {
+		console.warn("[mithril-lynx-v2] Ignoring an invalid dev-server message.");
 		return;
 	}
 
 	switch (message.type) {
 		case "hash":
 			currentHash = message.data;
+			console.info(MRL + ":2a hash-received", JSON.stringify({ hash: message.data }));
 			break;
 		case "ok":
-			// The server sends hash + ok immediately after connecting. Reloading
-			// then would loop forever, so only act after a later successful build.
-			if (initialBuild) initialBuild = false;
-			else if (currentHash) reload();
-			break;
-		case "still-ok":
-			console.info("[mithril-lynx] Nothing changed.");
+			console.info(MRL + ":3 ok-received", JSON.stringify({ initialBuild: initialBuild }));
+			if (initialBuild) {
+				initialBuild = false;
+				console.info(MRL + ":3a initial-build-skipped");
+			} else if (currentHash) {
+				if (runtimeHash && currentHash === runtimeHash) {
+					console.info(MRL + ":3b hash-equal-same-build");
+					break;
+				}
+				maybeCheck(currentHash);
+			}
 			break;
 		case "warnings":
-			console.warn("[mithril-lynx] Build completed with warnings.", message.data);
-			if (!message.params?.preventReloading && !initialBuild) reload();
+			if (!message.params || !message.params.preventReloading) {
+				if (!initialBuild) reload("build-warnings");
+			}
 			break;
 		case "errors":
-			console.warn("[mithril-lynx] Build failed; waiting for the next successful build.", message.data);
-			break;
-		case "invalid":
-			console.info("[mithril-lynx] App updated. Recompiling...");
-			break;
-		case "error":
-			console.error("[mithril-lynx] Dev server error:", message.data);
+			console.warn("[mithril-lynx-v2] Build failed; waiting for the next successful build.", message.data);
 			break;
 	}
 }
 
-function connect(retries = 0) {
+function connect(retries) {
+	if (retries === undefined) retries = 0;
+	console.info(MRL + ":1 ws-connecting", JSON.stringify({ url: socketURL(options), retry: retries }));
+
 	socket = new WebSocket(socketURL(options));
-	socket.onmessage = (event) => handleMessage(event.data);
-	socket.onerror = (error) => console.error("[mithril-lynx] Dev server connection error:", error);
-	socket.onclose = () => {
-		if (reloading) return; // Deliberately closed by reload() — a fresh socket is on its way already.
+	socket.onmessage = function (event) { handleMessage(event.data); };
+	socket.onerror = function (error) { console.error("[mithril-lynx-v2] Dev server connection error:", error); };
+	socket.onclose = function () {
+		if (reloading) return;
 		if (retries >= 10) {
-			console.error("[mithril-lynx] Unable to reconnect to the dev server.");
+			console.error("[mithril-lynx-v2] Unable to reconnect to the dev server.");
 			return;
 		}
-		const delay = 1000 * 2 ** retries + Math.random() * 100;
-		console.info("[mithril-lynx] Dev server disconnected; reconnecting...");
-		setTimeout(() => connect(retries + 1), delay);
+		var delay = 1000 * Math.pow(2, retries) + Math.random() * 100;
+		setTimeout(function () { connect(retries + 1); }, delay);
 	};
 }
 

package/src/dev-transport-noop.js

@@ -0,0 +1,10 @@
+// No-op stand-in for @lynx-js/webpack-dev-transport/client.
+//
+// `dev.hmr: true` makes Rsbuild/Rspeedy inject the official transport
+// client, which opens its OWN WebSocket to /rsbuild-hmr and full-reloads
+// via reloadApp.js — a second reload channel on top of this package's
+// in-bundle dev-reload-client.js. plugin.js re-aliases the module here
+// (order "post", so it wins over the alias @lynx-js/rsbuild-plugin
+// registers) so `module.hot` stays live without a competing channel. Same
+// fix as mithril-lynx v1's F2 (src/dev-transport-noop.js).
+export default class DevTransportClientNoop {}