@ait-co/devtools 0.1.140 → 0.1.142

package/dist/in-app/auto.js

@@ -40,6 +40,186 @@ const RELAY_AUTH_REJECT_CLOSE_CODE = 4401;
 */
 const RELAY_AUTH_REJECT_REASON = "totp-rejected";
 //#endregion
+//#region src/in-app/bridge-observer.ts
+/**
+* CustomEvent fired (no detail) on every start/settle so the indicator badge
+* re-renders promptly. SECRET-HANDLING: carries no detail payload at all — the
+* badge reads the enum-only `window.__ait_bridge` snapshot on receipt.
+*/
+const BRIDGE_CALL_EVENT = "ait:bridge-call";
+/**
+* Pending entries older than this are pruned on the next start — a safety net
+* for the fallback path where a settle signal might be missed, so the pending
+* list can never grow unbounded or show a forever-stuck row. Generous enough
+* that a genuinely slow native call (the exact signal we want to surface) still
+* shows while it is plausibly in flight.
+*/
+const MAX_PENDING_AGE_MS = 12e4;
+/** Guard so the observer wraps the bridge at most once per page lifecycle. */
+let bridgeObserverInstalled = false;
+/** Monotonic id source for the primary (3.0) path, where native gives us none. */
+let callIdCounter = 0;
+/** Undo hooks that {@link uninstallBridgeObserver} runs to restore originals. */
+let restoreHooks = [];
+/** Drops pending entries older than {@link MAX_PENDING_AGE_MS}. */
+function pruneStale(state, now) {
+	for (const id of Object.keys(state.pending)) {
+		const entry = state.pending[id];
+		if (entry !== void 0 && now - entry.startedAt > MAX_PENDING_AGE_MS) delete state.pending[id];
+	}
+}
+/** Fires the payload-less notify event so the badge re-renders. */
+function broadcast() {
+	if (typeof window === "undefined") return;
+	window.dispatchEvent(new CustomEvent(BRIDGE_CALL_EVENT));
+}
+/** Records a call start: add to pending, set last=pending, notify. */
+function startCall(state, id, method, now) {
+	pruneStale(state, now);
+	state.pending[id] = {
+		method,
+		startedAt: now
+	};
+	state.last = {
+		method,
+		at: now,
+		status: "pending"
+	};
+	broadcast();
+}
+/** Records a call settle: remove from pending, stamp last, notify. */
+function settleCall(state, id, status, now) {
+	const entry = state.pending[id];
+	delete state.pending[id];
+	state.last = {
+		method: entry?.method ?? state.last?.method ?? "unknown",
+		at: now,
+		status
+	};
+	broadcast();
+}
+/**
+* Parses an outbound `ReactNativeWebView.postMessage` JSON envelope and records
+* a START for async request/response calls only. Event subscriptions
+* (`addEventListener`/`removeEventListener`/`callEventMethod`), cleanup, and
+* constants are ignored — they are not the "spinner is a pending call" signal.
+*
+* SECRET-HANDLING: reads `type`/`name`/`functionName`/`callbackId`/`eventId`
+* ONLY — never `params`/`args`.
+*/
+function observeOutbound(state, message) {
+	if (typeof message !== "string") return;
+	let parsed;
+	try {
+		parsed = JSON.parse(message);
+	} catch {
+		return;
+	}
+	const now = Date.now();
+	if (parsed.type === "callAsyncMethod" && typeof parsed.name === "string" && typeof parsed.callbackId === "string") {
+		startCall(state, parsed.callbackId, parsed.name, now);
+		return;
+	}
+	if (parsed.type === "method" && typeof parsed.functionName === "string" && typeof parsed.eventId === "string") startCall(state, parsed.eventId, parsed.functionName, now);
+}
+/**
+* Parses a `__GRANITE_NATIVE_EMITTER.emit` event name and records a SETTLE for
+* 2.x async resolves/rejects (`<method>/resolve/<eventId>` |
+* `<method>/reject/<eventId>`). Event-bridge emits (`.../onEvent/...`) are
+* ignored. SECRET-HANDLING: reads the event NAME only — never the emitted args.
+*/
+function observeSettle(state, event) {
+	if (typeof event !== "string") return;
+	const match = /\/(resolve|reject)\/([^/]+)$/.exec(event);
+	if (match === null) return;
+	settleCall(state, match[2], match[1] === "resolve" ? "resolved" : "rejected", Date.now());
+}
+/**
+* Installs the native-bridge call observer (#749). Idempotent per page
+* lifecycle. Called by {@link maybeAttach} after the gate passes (debug builds
+* only). Prefers the 3.0 single-dispatcher wrap; falls back to the universal
+* 2.x postMessage-start + emitter-settle pair. A context with no observable
+* bridge (env 2 mock) leaves `window.__ait_bridge` as an empty snapshot — the
+* badge then shows the heartbeat only, which is correct.
+*
+* Never throws into the host app — a wrapped hook that somehow fails is caught
+* and the original behavior is always preserved.
+*/
+function installBridgeObserver() {
+	if (bridgeObserverInstalled) return;
+	if (typeof window === "undefined") return;
+	bridgeObserverInstalled = true;
+	const state = {
+		pending: Object.create(null),
+		last: null
+	};
+	window.__ait_bridge = state;
+	const nativeBridge = window.__appsInTossNativeBridge;
+	if (nativeBridge !== void 0 && typeof nativeBridge.callAsyncMethod === "function") {
+		const original = nativeBridge.callAsyncMethod;
+		const wrapped = function(name, params) {
+			const id = `c${++callIdCounter}`;
+			startCall(state, id, String(name), Date.now());
+			let result;
+			try {
+				result = original.call(this, name, params);
+			} catch (err) {
+				settleCall(state, id, "rejected", Date.now());
+				throw err;
+			}
+			if (result !== null && typeof result.then === "function") result.then(() => settleCall(state, id, "resolved", Date.now()), () => settleCall(state, id, "rejected", Date.now()));
+			else settleCall(state, id, "resolved", Date.now());
+			return result;
+		};
+		nativeBridge.callAsyncMethod = wrapped;
+		restoreHooks.push(() => {
+			nativeBridge.callAsyncMethod = original;
+		});
+		return;
+	}
+	const webView = window.ReactNativeWebView;
+	if (webView !== void 0 && typeof webView.postMessage === "function") {
+		const originalPost = webView.postMessage;
+		webView.postMessage = function(message) {
+			try {
+				observeOutbound(state, message);
+			} catch {}
+			originalPost.call(this, message);
+		};
+		restoreHooks.push(() => {
+			webView.postMessage = originalPost;
+		});
+	}
+	const emitter = window.__GRANITE_NATIVE_EMITTER;
+	if (emitter !== void 0 && typeof emitter.emit === "function") {
+		const originalEmit = emitter.emit;
+		emitter.emit = function(event, args) {
+			try {
+				observeSettle(state, event);
+			} catch {}
+			originalEmit.call(this, event, args);
+		};
+		restoreHooks.push(() => {
+			emitter.emit = originalEmit;
+		});
+	}
+}
+/**
+* Restores every wrapped bridge hook and removes `window.__ait_bridge` (#749).
+* Idempotent; safe to call when nothing was installed. Wired into
+* {@link detachDebugSurface} (#748) so no bridge wrap survives a run's end.
+*/
+function uninstallBridgeObserver() {
+	if (!bridgeObserverInstalled) return;
+	bridgeObserverInstalled = false;
+	const hooks = restoreHooks;
+	restoreHooks = [];
+	for (const undo of hooks) try {
+		undo();
+	} catch {}
+	if (typeof window !== "undefined") window.__ait_bridge = void 0;
+}
+//#endregion
 //#region src/in-app/eruda-overlay.ts
 /**
 * In-app eruda console overlay for the debug attach flow.
@@ -76,6 +256,12 @@ const RELAY_AUTH_REJECT_REASON = "totp-rejected";
 /** Module-level guard against double mount across repeated `maybeAttach` calls. */
 let erudaMounted = false;
 /**
+* The loaded eruda module, captured on a successful {@link mountEruda} so
+* {@link unmountEruda} can call `.destroy()` on the same instance during
+* graceful detach (#748). `null` when eruda was never mounted.
+*/
+let erudaModule = null;
+/**
 * Mounts the eruda in-page console once.
 *
 * Idempotent: repeated calls after a successful mount are no-ops, mirroring the
@@ -91,12 +277,38 @@ async function mountEruda() {
 	if (erudaMounted || typeof document === "undefined") return;
 	erudaMounted = true;
 	try {
-		(await import("eruda")).default.init();
+		const eruda = (await import("eruda")).default;
+		eruda.init();
+		erudaModule = eruda;
 	} catch (err) {
 		erudaMounted = false;
 		console.debug("[@ait-co/devtools] eruda console mount skipped:", err);
 	}
 }
+/**
+* Unmounts the eruda in-page console (#748 graceful detach).
+*
+* Calls `eruda.destroy()`, which removes eruda's floating entry button, any
+* open panel, and its `#eruda` shadow host — returning the phone screen to a
+* clean, non-debug state when a debug session ends. After a successful unmount
+* the guard is reset so a later {@link mountEruda} (a fresh attach) can
+* re-mount.
+*
+* Idempotent: a call when eruda was never mounted (or already unmounted) is a
+* no-op. Fail-silent: a `destroy()` throw is swallowed — teardown must never
+* throw into the host app.
+*/
+function unmountEruda() {
+	if (!erudaMounted || erudaModule === null) return;
+	try {
+		erudaModule.destroy();
+	} catch (err) {
+		console.debug("[@ait-co/devtools] eruda console unmount skipped:", err);
+	} finally {
+		erudaMounted = false;
+		erudaModule = null;
+	}
+}
 //#endregion
 //#region src/in-app/gate.ts
 /**
@@ -512,6 +724,81 @@ function createFailFastSocket(url) {
 	}, 0);
 	return sock;
 }
+/** Grace window before a non-terminal relay close tears the surface down. */
+const RECONNECT_GRACE_MS = 5e3;
+/** One-shot guard so the teardown runs at most once per page lifecycle. */
+let debugSurfaceDetached = false;
+/** Pending grace-window timer for a non-terminal close, or `null`. */
+let pendingDetachTimer = null;
+/** Cancels a scheduled teardown — called when a relay socket re-opens. */
+function cancelScheduledDetach() {
+	if (pendingDetachTimer !== null) {
+		clearTimeout(pendingDetachTimer);
+		pendingDetachTimer = null;
+	}
+}
+/**
+* Schedules {@link detachDebugSurface} after {@link RECONNECT_GRACE_MS} unless
+* a reconnect cancels it first. No-op if teardown already ran or is already
+* scheduled. Defensive: if `setTimeout` is somehow unavailable, tears down
+* immediately rather than never.
+*/
+function scheduleDetach() {
+	if (debugSurfaceDetached || pendingDetachTimer !== null) return;
+	if (typeof setTimeout === "undefined") {
+		detachDebugSurface();
+		return;
+	}
+	pendingDetachTimer = setTimeout(() => {
+		pendingDetachTimer = null;
+		detachDebugSurface();
+	}, RECONNECT_GRACE_MS);
+}
+/**
+* Idempotent, non-throwing teardown of the in-app debug surface (issue #748).
+*
+* Removes every debug-surface element WE injected and restores the one side
+* effect WE applied:
+*   1. The CDP-injected `#__ait_debug_indicator` badge (the persistent
+*      "Debugger Disconnected" element). Its live heartbeat/pending-call timer
+*      (#749) is stopped first via the badge controller's `stop()` so no 1 Hz
+*      interval leaks past detach; `buildIndicatorExpression` also
+*      self-dismisses the node — this is the in-app hard guarantee, idempotent,
+*      a no-op if it is already gone.
+*   2. The eruda in-page console (floating button + any open panel).
+*   3. The native-bridge call observer (#749) — its `callAsyncMethod` /
+*      `postMessage` / emitter wraps are restored and `window.__ait_bridge` is
+*      removed, so nothing we wrapped survives the run's end.
+*   4. keepAwake — forced on at attach; restored here so a run that ends
+*      WITHOUT a page unload does not leave the screen pinned awake (the
+*      existing `beforeunload` restore only covers the unload path).
+*
+* Deliberately NOT touched: the `window.WebSocket` observer proxy (kept so the
+* #478 post-4401 fail-fast survives; it is non-blocking and never absorbs
+* input), and any NATIVE overlay (out of our layer — see the block comment
+* above and issue #748 hypothesis (a)).
+*
+* Never throws into the host app — every step is individually guarded.
+* Exported for unit tests and for a consumer that wants to force a clean detach.
+*/
+function detachDebugSurface() {
+	if (debugSurfaceDetached) return;
+	debugSurfaceDetached = true;
+	cancelScheduledDetach();
+	try {
+		if (typeof window !== "undefined") window.__ait_indicator?.stop?.();
+		if (typeof document !== "undefined") document.getElementById("__ait_debug_indicator")?.remove();
+	} catch {}
+	try {
+		unmountEruda();
+	} catch {}
+	try {
+		uninstallBridgeObserver();
+	} catch {}
+	try {
+		setScreenAwakeMode({ enabled: false }).catch(() => {});
+	} catch {}
+}
 /**
 * Wraps `window.WebSocket` with a relay-origin-scoped observer (issue #478).
 *
@@ -534,19 +821,27 @@ function installRelayWsObserver(relayUrl) {
 	if (relayKey === null) return;
 	wsObserverInstalled = true;
 	window.__ait_relay_ws_observed = true;
+	window.addEventListener("pagehide", () => detachDebugSurface(), { once: true });
 	const NativeWebSocket = window.WebSocket;
 	const observed = new Proxy(NativeWebSocket, { construct(target, args) {
 		const url = String(args[0]);
 		if (wsOriginKey(url) !== relayKey) return Reflect.construct(target, args);
 		if (relayAuthExpired) return createFailFastSocket(url);
 		const ws = Reflect.construct(target, args);
-		ws.addEventListener("open", () => broadcastRelayWsState("open"));
+		ws.addEventListener("open", () => {
+			broadcastRelayWsState("open");
+			cancelScheduledDetach();
+		});
 		ws.addEventListener("close", (event) => {
 			broadcastRelayWsState("close");
 			if (event.code === 4401) {
 				relayAuthExpired = true;
 				notifyAuthExpired();
-			}
+				detachDebugSurface();
+			} else scheduleDetach();
+		});
+		ws.addEventListener("error", () => {
+			scheduleDetach();
 		});
 		return ws;
 	} });
@@ -642,6 +937,7 @@ function maybeAttach(gateResult = checkDebugGate()) {
 	const atCode = typeof window !== "undefined" ? new URLSearchParams(window.location.search).get("at") : null;
 	const src = deriveTargetScriptUrl(gateResult.relayUrl, atCode);
 	installRelayWsObserver(gateResult.relayUrl);
+	installBridgeObserver();
 	if (document.querySelector(`script[src="${src}"]`) !== null) {
 		attached = true;
 		return;