@ait-co/devtools 0.1.141 → 0.1.143

package/dist/in-app/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/in-app/gate.ts","../../src/in-app/attach.ts","../../src/in-app/eruda-overlay.ts","../../src/in-app/index.ts"],"mappings":";;AAwFA;;;;;;;;;AASA;;;;;AAmBA;;;;;AAQA;;;;;;;;;;;AA8EA;;;;;AAqCA;;;;;AAuBA;;;;;AA2EA;;;;;;;;;;;;AC5RA;;;;;AAUC;;;;;;;;;;AAgPD;;;;;AA4CA;;;;;;;;AC3SA;AAAA,UFwCiB,gBAAA;EAAA,SACN,MAAA;EEzCyB;EAAA,SF2CzB,QAAA;;WAEA,YAAA;AAAA;AG3CX;AAAA,UH+CiB,iBAAA;EAAA,SACN,MAAA;EGhDuB;;;;;;;;;;;;;;EAAA,SH+DvB,MAAA;AAAA;AAAA,KAGC,UAAA,GAAa,gBAAA,GAAmB,iBAAA;;;;;;;UAQ3B,SAAA;;;;;;;;;;;;;WAaN,QAAA;;;;;;;WAQA,YAAA,EAAc,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;WA0Bd,cAAA,IAAkB,IAAA;AAAA;;;;;;;;;;;;iBA+Bb,iBAAA,CAAkB,QAAA;;;;;;;iBAqClB,cAAA,CAAe,QAAA;;;;;;;;;;;;;;;;;;;;iBAuBf,mBAAA,CAAoB,QAAA;;;;;;;;;;;;;;;;;;;;;;iBA2EpB,iBAAA,CAAkB,KAAA,EAAO,SAAA,GAAY,UAAA;;;;;;AA7NrD;;;;;AAQA;;;;;;;;;;;AA8EA;;;;;AAqCA;;;;;AAuBA;;;;iBCjNgB,qBAAA,CAAsB,QAAA,UAAkB,MAAA;AAAA,QAoChD,MAAA;EAAA,UACI,MAAA;IDuP6B;;;;;;;IC/OrC,uBAAA;EAAA;AAAA;AA7CJ;;;;;AAUC;;;;;;;;;;;;;;AA4RD;;;;;;;;AC3SA;;;;;;;;ACEA;;;iBF6PgB,iBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;iBA4CA,WAAA,CAAY,UAAA,GAAY,UAAA;;;;ADnQxC;;;;;;;;;AASA;;;;;AAmBA;;;;;AAQA;;;;;;;;;;;AA8EA;;;;;AAqCA;;;;;AAuBA;;;iBEtNsB,UAAA,CAAA,GAAc,OAAA;;;;;;AF0JpC;;;;;AAqCA;;;;;AAuBA;iBGpNgB,cAAA,CAAA,GAAkB,UAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/in-app/gate.ts","../../src/in-app/attach.ts","../../src/in-app/bridge-observer.ts","../../src/in-app/eruda-overlay.ts","../../src/in-app/index.ts"],"mappings":";;AAwFA;;;;;;;;;AASA;;;;;AAmBA;;;;;AAQA;;;;;;;;;;;AA8EA;;;;;AAqCA;;;;;AAuBA;;;;;AA2EA;;;;;;;;;;;;AC3RA;;;;;AAUC;;;;;;;;;;AA+OD;;;;;AAkKA;;;;;AA4CA;;;;UDraiB,gBAAA;EAAA,SACN,MAAA;;WAEA,QAAA;EEhDM;EAAA,SFkDN,YAAA;AAAA;;UAIM,iBAAA;EAAA,SACN,MAAA;EEhDoB;;;;;;;;AAY/B;;;;;;EAZ+B,SF+DpB,MAAA;AAAA;AAAA,KAGC,UAAA,GAAa,gBAAA,GAAmB,iBAAA;;;;;;;UAQ3B,SAAA;EEpDa;;;;AAAqB;;;;;;;;EAArB,SFiEnB,QAAA;EEtCL;;;;;;EAAA,SF8CK,YAAA,EAAc,eAAA;EExClB;;;;;;;;;AA2HP;;;;;AAoFA;;;;;;;;ACjQA;;EDkDO,SFkEI,cAAA,IAAkB,IAAA;AAAA;;AGpF7B;;;;;;;;ACxBA;;iBJ2IgB,iBAAA,CAAkB,QAAA;;;;;;;iBAqClB,cAAA,CAAe,QAAA;;;;;;;;;;;;;;;;;;;;iBAuBf,mBAAA,CAAoB,QAAA;;;;;;;;;;;;;;;;;;;;;;iBA2EpB,iBAAA,CAAkB,KAAA,EAAO,SAAA,GAAY,UAAA;;;;;;AA7NrD;;;;;AAQA;;;;;;;;;;;AA8EA;;;;;AAqCA;;;;;AAuBA;;;;iBChNgB,qBAAA,CAAsB,QAAA,UAAkB,MAAA;AAAA,QAoChD,MAAA;EAAA,UACI,MAAA;IDsP6B;;;;;;;IC9OrC,uBAAA;EAAA;AAAA;AA7CJ;;;;;AAUC;;;;;;;;;;AA+OD;;;;;AAkKA;;;;;AA4CA;;AAvcA,iBAyPgB,kBAAA,CAAA;;;;ACjPhB;;;;;;;;;;;;;;;AAUA;;;;;iBDyYgB,iBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;iBA4CA,WAAA,CAAY,UAAA,GAAY,UAAA;;;;ADraxC;;;;;;;;;AASA;;;;;AAmBA;;;;;AAQA;;;;;;;;;;;AA8EA;;;;;AAqCA;;;;;AAuBA;AAAA,UE3NiB,iBAAA;EACf,MAAA;EF0NkC;EExNlC,SAAA;AAAA;;UAIe,cAAA;EACf,MAAA;EF8RuC;EE5RvC,EAAA;EACA,MAAA;AAAA;;;;;ADAF;UCQiB,mBAAA;EACf,OAAA,EAAS,MAAA,SAAe,iBAAA;EACxB,IAAA,EAAM,cAAA;AAAA;ADAP;;;;;AAAA,cCQY,iBAAA;AAAA,QAWL,MAAA;EAAA,UACI,MAAA;IDee;;AA4M3B;;;;;ICnNI,YAAA,GAAe,mBAAA;IDqXc;;;;AA4CjC;IC3ZI,wBAAA;MACE,eAAA,IAAmB,IAAA,UAAc,MAAA;MAAA,CAChC,GAAA;IAAA;;IAGH,kBAAA;MACE,WAAA,IAAe,OAAA;MAAA,CACd,GAAA;IAAA;IA9D2B;IAiE9B,wBAAA;MACE,IAAA,IAAQ,KAAA,UAAe,IAAA;MAAA,CACtB,GAAA;IAAA;EAAA;AAAA;;;;;;AAhDP;;;;;;iBAsKgB,qBAAA,CAAA;;;;;;iBAoFA,uBAAA,CAAA;;;;AFhOhB;;;;;;;;;AASA;;;;;AAmBA;;;;;AAQA;;;;;;;;;;;AA8EA;;;;;AAqCA;;;;;AAuBA;;;iBG/MsB,UAAA,CAAA,GAAc,OAAA;;AH0RpC;;;;;;;;;;;;iBG1PgB,YAAA,CAAA;;;;;AHmHhB;;;;;AAqCA;;;;;AAuBA;;iBIvMgB,cAAA,CAAA,GAAkB,UAAA"}

package/dist/in-app/index.js

@@ -247,6 +247,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.
@@ -283,6 +463,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
@@ -298,12 +484,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/attach.ts
 /**
@@ -467,6 +679,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).
 *
@@ -489,19 +776,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;
 	} });
@@ -597,6 +892,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;
@@ -667,6 +963,6 @@ function checkDebugGate() {
 	});
 }
 //#endregion
-export { checkDebugGate, deriveTargetScriptUrl, evaluateDebugGate, isPrivateAppsHost, isTossminiHost, isTrycloudflareHost, maybeAttach, mountEruda, reportWebViewType };
+export { BRIDGE_CALL_EVENT, checkDebugGate, deriveTargetScriptUrl, detachDebugSurface, evaluateDebugGate, installBridgeObserver, isPrivateAppsHost, isTossminiHost, isTrycloudflareHost, maybeAttach, mountEruda, reportWebViewType, uninstallBridgeObserver, unmountEruda };
 
 //# sourceMappingURL=index.js.map