@apps-in-toss/devtools 3.0.2

package/dist/mock/2x.js

@@ -0,0 +1,2610 @@
+//#region src/mock/throttle-registry.ts
+/**
+* throttle 레지스트리 (devtools#834).
+*
+* 메서드별 마지막 *허용* 호출 시각만 담는 leaf 모듈이다. `state.ts`가 `reset()`에서
+* 이걸 비워야 하는데, 로직 본체(`throttle.ts`)는 거꾸로 `state.ts`를 읽는다 —
+* 그래서 **의존이 없는 이 파일로 레지스트리를 분리해** 순환 import를 피한다.
+*
+* `state.ts`의 `AitStateManager`와 같은 이유로 `globalThis` 싱글턴이어야 한다 (#836):
+* `tsdown.config.ts`가 mock/panel/unplugin entry를 각각 self-contained로 빌드하므로,
+* 소비자가 두 entry를 동시에 import하면 이 모듈이 entry당 하나씩 복제된다. Map을
+* 모듈 지역 변수로 두면 `aitState.reset()`이 비우는 Map(싱글턴을 먼저 생성한 번들의 것)과
+* `throttleErrorFor`가 읽는 Map(mock 번들의 것)이 갈려, 리셋 직후 첫 호출이 낡은
+* 타임스탬프 때문에 거부된다 — 이 파일이 막으려던 바로 그 증상이다.
+*/
+const SINGLETON_KEY$1 = "__aitDevtoolsThrottleRegistry__";
+const globalRef$1 = globalThis;
+if (!globalRef$1[SINGLETON_KEY$1]) globalRef$1[SINGLETON_KEY$1] = /* @__PURE__ */ new Map();
+/** 메서드별 마지막 *허용* 호출 시각(ms). 페이지 안의 모든 entry가 공유한다. */
+const lastAllowedAt = globalRef$1[SINGLETON_KEY$1];
+/**
+* throttle 레지스트리를 비운다. `aitState.reset()`이 호출한다 — 상태를 되돌렸는데
+* 직전 세션의 호출 시각이 남아 있으면 첫 호출이 이유 없이 거부된다.
+*/
+function resetThrottleRegistry() {
+	lastAllowedAt.clear();
+}
+//#endregion
+//#region src/mock/state.ts
+/** SDK 호출 로그 ring buffer 상한 */
+const SDK_CALL_LOG_MAX = 200;
+const DEFAULT_STATE = {
+	platform: "ios",
+	environment: "sandbox",
+	appVersion: "5.240.0",
+	locale: "ko-KR",
+	schemeUri: "/",
+	groupId: "mock-group-id",
+	deploymentId: "mock-deployment-id",
+	deviceId: "",
+	brand: {
+		displayName: "Mock App",
+		icon: "",
+		primaryColor: "#3182F6"
+	},
+	networkStatus: "WIFI",
+	navigation: { iosSwipeGestureEnabled: null },
+	permissions: {
+		clipboard: "allowed",
+		contacts: "allowed",
+		photos: "allowed",
+		geolocation: "allowed",
+		camera: "allowed",
+		microphone: "notDetermined"
+	},
+	location: {
+		coords: {
+			latitude: 37.5665,
+			longitude: 126.978,
+			altitude: 0,
+			accuracy: 10,
+			altitudeAccuracy: 0,
+			heading: 0
+		},
+		timestamp: Date.now(),
+		accessLocation: "FINE"
+	},
+	safeAreaInsets: {
+		top: 54,
+		bottom: 34,
+		left: 0,
+		right: 0
+	},
+	contacts: [{
+		name: "홍길동",
+		phoneNumber: "010-1234-5678"
+	}, {
+		name: "김토스",
+		phoneNumber: "010-9876-5432"
+	}],
+	iap: {
+		products: [{
+			sku: "mock-gem-100",
+			type: "CONSUMABLE",
+			displayName: "보석 100개",
+			displayAmount: "1,000원",
+			iconUrl: "",
+			description: "게임에서 사용할 수 있는 보석 100개"
+		}],
+		nextResult: "success",
+		pendingOrders: [],
+		completedOrders: []
+	},
+	payment: {
+		nextResult: "success",
+		failReason: ""
+	},
+	auth: {
+		isLoggedIn: true,
+		isTossLoginIntegrated: true,
+		userKeyHash: "mock-user-hash-abc123",
+		anonymousKeyHash: "mock-anon-hash-xyz789",
+		consentedUserData: { USER_NAME: "mock-user-name" },
+		declaredAgeRange: {
+			status: "NOT_AVAILABLE",
+			activeParentalControls: []
+		}
+	},
+	notification: { nextResult: "newAgreement" },
+	ads: {
+		isLoaded: false,
+		nextEvent: "loaded",
+		forceNoFill: false,
+		lastEvent: null,
+		rewardUnitType: "coins",
+		rewardAmount: 10
+	},
+	game: {
+		profile: {
+			nickname: "MockPlayer",
+			profileImageUri: ""
+		},
+		leaderboardScores: []
+	},
+	analyticsLog: [],
+	sdkCallLog: [],
+	deviceModes: {
+		camera: "mock",
+		photos: "mock",
+		location: "mock",
+		network: "mock",
+		clipboard: "mock"
+	},
+	mockData: {
+		images: [],
+		clipboardText: ""
+	},
+	panelEditable: true,
+	viewport: {
+		preset: "none",
+		orientation: "auto",
+		appOrientation: null,
+		customWidth: 402,
+		customHeight: 874,
+		frame: false,
+		aitNavBar: true,
+		aitNavBarType: "partner"
+	},
+	failureModes: { sdkLine: "2.x" }
+};
+function generateDeviceId() {
+	const stored = localStorage.getItem("__ait_device_id");
+	if (stored) return stored;
+	const id = crypto.randomUUID();
+	localStorage.setItem("__ait_device_id", id);
+	return id;
+}
+var AitStateManager = class {
+	_state;
+	_listeners = /* @__PURE__ */ new Set();
+	_inTransaction = false;
+	constructor() {
+		this._state = structuredClone(DEFAULT_STATE);
+		try {
+			this._state.deviceId = generateDeviceId();
+		} catch {
+			this._state.deviceId = `mock-device-${Math.random().toString(36).slice(2)}`;
+		}
+	}
+	get state() {
+		return this._state;
+	}
+	update(partial) {
+		this._state = {
+			...this._state,
+			...partial
+		};
+		this._notify();
+	}
+	/** 중첩 객체 업데이트용 */
+	patch(key, partial) {
+		const current = this._state[key];
+		if (typeof current === "object" && current !== null && !Array.isArray(current)) this._state = {
+			...this._state,
+			[key]: {
+				...current,
+				...partial
+			}
+		};
+		else this._state = {
+			...this._state,
+			[key]: partial
+		};
+		this._notify();
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		return () => this._listeners.delete(listener);
+	}
+	/**
+	* 한 묶음의 update/patch 호출을 묶어 listener notify 1회로 만든다.
+	* preset 적용처럼 여러 슬라이스를 동시에 바꿀 때 panel re-render 폭주를
+	* 방지한다. 중첩 호출은 outermost transaction이 끝날 때 한 번만 notify
+	* (inner도 throw해도 outer finally가 flag를 복구한다).
+	*
+	* Rollback은 없다 — `fn`이 throw해도 그때까지의 state 변경은 유지된다.
+	* 구독자가 partial state를 영원히 못 보는 사고를 막기 위해, throw 여부와
+	* 무관하게 항상 한 번 notify한 뒤 throw를 propagate한다. DB transaction이
+	* 아니라 "여러 mutation을 한 notify로 묶는 batch"라고 생각하면 된다.
+	*
+	* Listener는 throw해선 안 된다 — finally 안의 `_notify()`가 throw하면 원래
+	* `fn`의 throw를 덮어버린다. 우리 구독자는 panel re-render뿐이라 실제
+	* 발생 사례는 없지만, 외부에서 listener를 등록할 때 주의.
+	*/
+	transaction(fn) {
+		if (this._inTransaction) {
+			fn();
+			return;
+		}
+		this._inTransaction = true;
+		try {
+			fn();
+		} finally {
+			this._inTransaction = false;
+			this._notify();
+		}
+	}
+	/** 분석 로그 추가 */
+	logAnalytics(entry) {
+		this._state = {
+			...this._state,
+			analyticsLog: [...this._state.analyticsLog, {
+				...entry,
+				timestamp: Date.now()
+			}]
+		};
+		this._notify();
+	}
+	/**
+	* SDK 호출 로그 추가 (ring buffer, 상한 SDK_CALL_LOG_MAX).
+	* `observe()`가 호출하고, proxy의 KNOWN_UNIMPLEMENTED 경로도 직접 호출한다.
+	*/
+	logSdkCall(entry) {
+		const log = this._state.sdkCallLog;
+		const next = log.length >= SDK_CALL_LOG_MAX ? log.slice(1 - SDK_CALL_LOG_MAX) : log;
+		this._state = {
+			...this._state,
+			sdkCallLog: [...next, entry]
+		};
+		this._notify();
+	}
+	/** 이벤트 트리거 (backEvent, homeEvent 등) */
+	trigger(event) {
+		window.dispatchEvent(new CustomEvent(`__ait:${event}`));
+	}
+	reset() {
+		const deviceId = this._state.deviceId;
+		this._state = {
+			...structuredClone(DEFAULT_STATE),
+			deviceId
+		};
+		resetThrottleRegistry();
+		this._notify();
+	}
+	_notify() {
+		if (this._inTransaction) return;
+		for (const listener of this._listeners) listener();
+	}
+};
+const SINGLETON_KEY = "__aitDevtoolsStateSingleton__";
+const globalRef = globalThis;
+if (!globalRef[SINGLETON_KEY]) globalRef[SINGLETON_KEY] = new AitStateManager();
+const aitState = globalRef[SINGLETON_KEY];
+if (typeof window !== "undefined") window.__ait = aitState;
+//#endregion
+//#region src/mock/device/_helpers.ts
+/**
+* 디바이스 모듈 내부 공유 헬퍼
+*/
+function generatePlaceholderImage(width, height, text, color) {
+	const canvas = document.createElement("canvas");
+	canvas.width = width;
+	canvas.height = height;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) {
+		const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}"><rect fill="${color}" width="${width}" height="${height}"/><text x="50%" y="50%" fill="white" font-size="16" text-anchor="middle" dominant-baseline="middle">${text}</text></svg>`;
+		return `data:image/svg+xml;base64,${btoa(svg)}`;
+	}
+	ctx.fillStyle = color;
+	ctx.fillRect(0, 0, width, height);
+	ctx.fillStyle = "white";
+	ctx.font = "16px sans-serif";
+	ctx.textAlign = "center";
+	ctx.textBaseline = "middle";
+	ctx.fillText(text, width / 2, height / 2);
+	return canvas.toDataURL("image/png");
+}
+const DEFAULT_PLACEHOLDERS = [
+	{
+		text: "Mock Photo 1",
+		color: "#3182F6"
+	},
+	{
+		text: "Mock Photo 2",
+		color: "#27ae60"
+	},
+	{
+		text: "Mock Photo 3",
+		color: "#e67e22"
+	}
+];
+let cachedPlaceholders = null;
+function getDefaultPlaceholderImages() {
+	if (!cachedPlaceholders) cachedPlaceholders = DEFAULT_PLACEHOLDERS.map((p) => generatePlaceholderImage(320, 240, p.text, p.color));
+	return [...cachedPlaceholders];
+}
+/** @internal device 모듈 내부 전용 */
+function getMockImages() {
+	const images = aitState.state.mockData.images;
+	if (images.length > 0) return images;
+	return getDefaultPlaceholderImages();
+}
+const PROMPT_TIMEOUT_MS = 3e4;
+/** @internal device 모듈 내부 전용 */
+function waitForPromptResponse(type) {
+	return new Promise((resolve, reject) => {
+		const eventName = `__ait:prompt-response:${type}`;
+		const cancelName = "__ait:prompt-cancel";
+		function cleanup() {
+			clearTimeout(timer);
+			window.removeEventListener(eventName, handler);
+			window.removeEventListener(cancelName, cancelHandler);
+		}
+		const timer = setTimeout(() => {
+			cleanup();
+			const hint = !!document.querySelector(".ait-panel") ? "Please provide input via the DevTools panel." : "Is @apps-in-toss/devtools/panel imported?";
+			reject(/* @__PURE__ */ new Error(`[@apps-in-toss/devtools] Prompt timeout for "${type}" after ${PROMPT_TIMEOUT_MS / 1e3}s. ${hint}`));
+		}, PROMPT_TIMEOUT_MS);
+		const handler = (e) => {
+			cleanup();
+			resolve(e.detail);
+		};
+		const cancelHandler = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`[@apps-in-toss/devtools] Prompt cancelled for "${type}"`));
+		};
+		window.addEventListener(eventName, handler);
+		window.addEventListener(cancelName, cancelHandler);
+		window.dispatchEvent(new CustomEvent("__ait:prompt-request", { detail: { type } }));
+	});
+}
+//#endregion
+//#region src/mock/native-error.ts
+/**
+* 실패-모드 다이얼 — 네이티브 에러 envelope 조립 (devtools#770).
+*
+* env1(mock)이 env3(실기기)의 프로비저닝-의존 reject 계약을 재현할 수 있게 하는
+* 공용 헬퍼. `aitState.failureModes`(state.ts)에 per-API 코드를 설정하면, 각
+* mock 도메인(auth/ads 등)이 이 모듈의 {@link buildNativeError}로 실기기 캡처와
+* 필드 단위로 일치하는 에러 객체를 만들어 reject/onError한다.
+*
+* 코드 인벤토리와 envelope shape의 정본은 sdk-example#284 2.x↔3.0 diff
+* 매트릭스(2026-07-10 iOS run10 캡처 + 이후 manual 패스)다:
+*
+* - 2.x 라인: 네이티브 브리지가 `{ name, code, userInfo, moduleName, __isError }`
+*   envelope을 얹은 `Error` 인스턴스로 reject한다. `errorKeys` 관측이 이 5개
+*   필드로 고정.
+* - 3.x 라인: 같은 실패가 "맨 Error"(위 envelope 필드 없음)로 평탄화된다 —
+*   sdk-example#284 "패턴 ① 오류 envelope 평탄화" 표.
+*
+* `@ait-co/debugger`의 `packages/debugger/src/test-runner/bridge-stub.ts`(분리 전
+* 이 repo의 `src/test-runner/bridge-stub.ts`)에 있는
+* `NativeBridgeErrorShape`/`makeNativeError`가
+* 같은 shape을 이미 CI 러너 쪽에서 재현하고 있다(devtools#740) — 이 모듈은 그
+* shape을 mock 소비자 표면(`src/mock/**`)에 대해 재사용 가능한 형태로 옮긴 것이다.
+* 두 모듈은 레이어가 다르다: test-runner 쪽은 env3 blocking-call 인터셉터(빌드에
+* 안 실림, CI 전용), 이쪽은 `@apps-in-toss/devtools` 소비자가 `pnpm dev`에서 실제로
+* import하는 mock 런타임이다 — 서로 import하지 않는다(devtools#740이 test-runner
+* 전용 모듈임을 명시).
+*/
+/** 코드별 기본 message/moduleName — 실기기 캡처 관측값. */
+const CODE_META = {
+	APP_LOGIN: {
+		message: "Login failed",
+		moduleName: "RNTossLogin"
+	},
+	PLACEMENT_ID_FETCH_FAILED: {
+		message: "Failed to fetch placement id",
+		moduleName: "RNAdMob"
+	},
+	EXECUTION_ERROR: {
+		message: "Execution error",
+		moduleName: "RNFullScreenAd"
+	},
+	NO_PERMISSION: {
+		message: "No permission",
+		moduleName: "RNPermissions"
+	},
+	INVALID_REQUEST: {
+		message: "Invalid request",
+		moduleName: "RNPermissions"
+	},
+	INVALID_DATA: {
+		message: "Invalid data",
+		moduleName: "RNFileSystem"
+	},
+	FAILED_TO_GET_LOADED_AD: {
+		message: "Failed to get loaded ad",
+		moduleName: "RNAdMob"
+	},
+	APP_BRIDGE_THROTTLED: {
+		message: "Too many app bridge calls from this method.",
+		moduleName: "RNBridge"
+	},
+	"1006": {
+		message: "광고가 로드 중이거나 준비되지 않았습니다",
+		moduleName: "RNFullScreenAd"
+	},
+	"4000": {
+		message: "Notification agreement failed",
+		moduleName: "RNNotification"
+	}
+};
+/**
+* `aitState.failureModes.sdkLine`이 가리키는 라인으로 네이티브 실패를 조립한다.
+*
+* - `'2.x'`(기본): {@link NativeErrorEnvelope} 필드가 실린 `Error` — 실기기 2.x
+*   캡처(`{name, code, userInfo, moduleName, __isError}`)와 필드 단위 일치.
+* - `'3.x'`: 같은 실패가 "맨 Error"로 평탄화된 것을 재현 — envelope 필드 없이
+*   message만 실린 순수 `Error` 인스턴스.
+*
+* 호출부는 두 종류다:
+*
+* - **다이얼 게이트 뒤**(대부분): 프로비저닝처럼 환경에 따라 갈리는 실패는
+*   다이얼이 설정된 경우에만 재현한다 — 미설정 시 기존 동작 무변화
+*   (zero behavior change). 호출 전에 다이얼 값을 명시적으로 확인한다.
+* - **무조건**(입력 검증): 빈 `data`나 알 수 없는 haptic type처럼 환경과 무관하게
+*   실기기가 **항상** 거부하는 입력은 다이얼 없이 바로 던진다. 이건 "가끔 일어나는
+*   실패"의 시뮬레이션이 아니라 결정적 계약이므로 opt-in 대상이 아니다.
+*/
+function buildNativeError(code) {
+	const meta = CODE_META[code];
+	if (aitState.state.failureModes.sdkLine === "3.x") return new Error(meta.message);
+	const err = new Error(meta.message);
+	err.name = "Error";
+	err.code = code;
+	err.userInfo = {};
+	err.moduleName = meta.moduleName;
+	err.__isError = true;
+	return err;
+}
+//#endregion
+//#region src/mock/permissions.ts
+/**
+* web-framework 3.0+ 권한 에러 기반 클래스.
+* `instanceof PermissionError`로 체크하는 코드와 호환된다.
+*/
+var PermissionError = class extends Error {
+	constructor({ methodName, message }) {
+		super(message ?? `${methodName}: permission denied`);
+		this.name = `${methodName}PermissionError`;
+	}
+};
+/** openCamera 권한 에러 */
+var OpenCameraPermissionError = class extends PermissionError {
+	constructor() {
+		super({ methodName: "openCamera" });
+	}
+};
+/** fetchAlbumPhotos 권한 에러 */
+var FetchAlbumPhotosPermissionError = class extends PermissionError {
+	constructor() {
+		super({ methodName: "fetchAlbumPhotos" });
+	}
+};
+/** fetchContacts 권한 에러 */
+var FetchContactsPermissionError = class extends PermissionError {
+	constructor() {
+		super({ methodName: "fetchContacts" });
+	}
+};
+/** getCurrentLocation 권한 에러 */
+var GetCurrentLocationPermissionError = class extends PermissionError {
+	constructor() {
+		super({ methodName: "getCurrentLocation" });
+	}
+};
+/** getClipboardText 권한 에러 */
+var GetClipboardTextPermissionError = class extends PermissionError {
+	constructor() {
+		super({ methodName: "getClipboardText" });
+	}
+};
+/** setClipboardText 권한 에러 */
+var SetClipboardTextPermissionError = class extends PermissionError {
+	constructor() {
+		super({ methodName: "setClipboardText" });
+	}
+};
+/**
+* startUpdateLocation 권한 에러.
+* web-framework 3.0에서 GetCurrentLocationPermissionError의 alias.
+*/
+const StartUpdateLocationPermissionError = GetCurrentLocationPermissionError;
+const permissionErrorMap = {
+	openCamera: OpenCameraPermissionError,
+	fetchAlbumPhotos: FetchAlbumPhotosPermissionError,
+	fetchAlbumItems: FetchAlbumPhotosPermissionError,
+	fetchContacts: FetchContactsPermissionError,
+	getCurrentLocation: GetCurrentLocationPermissionError,
+	getClipboardText: GetClipboardTextPermissionError,
+	setClipboardText: SetClipboardTextPermissionError
+};
+async function getPermission(permission) {
+	const failureCode = permissionGateCode(permission);
+	if (failureCode) throw buildNativeError(failureCode);
+	return aitState.state.permissions[permission.name];
+}
+/**
+* 선언 게이트에 걸리는 이름·access 조합이면 다이얼에 등록된 native errorCode를
+* 돌려준다. 세 권한 API(`getPermission`/`requestPermission`/`openPermissionDialog`)가
+* **걸리는 조건**은 공유하지만 **떨어지는 코드**는 공유하지 않는다 — 아래 참조.
+*/
+function permissionGateCode(permission) {
+	if (permission.access === "access") return;
+	return aitState.state.failureModes.getPermission?.[permission.name];
+}
+/**
+* `openPermissionDialog`가 선언 게이트에 걸렸을 때의 코드.
+*
+* 형제 API와 갈린다 — env3 run11 실측(2.x/iOS, sdk-example#313에서 시나리오 키가
+* 통일되며 비교 대상에 들어온 값):
+*
+*   getPermission        { geolocation, read }   → rejected NO_PERMISSION
+*   requestPermission    { geolocation, read }   → rejected NO_PERMISSION
+*   openPermissionDialog { geolocation, read }   → rejected INVALID_REQUEST
+*   openPermissionDialog { camera, access }      → resolved
+*
+* 즉 **걸리는 조건은 셋이 같고(access 축 모델 그대로) 코드만 갈린다.** 처음엔
+* `requestPermission`이 `openPermissionDialog`에 위임하니 게이트도 위임하면
+* 된다고 보고 한 지점에만 배선했는데, 그 모델은 코드 층위에서 실측과 어긋났다
+* (env1 NO_PERMISSION ↔ env3 INVALID_REQUEST). 그래서 `requestPermission`은
+* 위임 **전에** 자기 게이트를 먼저 타고, 다이얼로그를 여는 호출만 이 코드를 쓴다.
+*
+* 관측이 geolocation/read 한 조합뿐이라 이름·access별 분기는 두지 않는다 —
+* 근거 없는 확장은 #783에서 이름 단위 맵을 택한 원칙에 어긋난다.
+*/
+const OPEN_DIALOG_GATE_CODE = "INVALID_REQUEST";
+async function openPermissionDialog(permission) {
+	if (permissionGateCode(permission)) throw buildNativeError(OPEN_DIALOG_GATE_CODE);
+	if (aitState.state.permissions[permission.name] === "allowed") return "allowed";
+	aitState.patch("permissions", { [permission.name]: "allowed" });
+	return "allowed";
+}
+async function requestPermission(permission) {
+	const failureCode = permissionGateCode(permission);
+	if (failureCode) throw buildNativeError(failureCode);
+	return openPermissionDialog(permission);
+}
+/** 권한이 필요한 함수에 .getPermission(), .openPermissionDialog()를 부착 */
+function withPermission(fn, permissionName) {
+	const enhanced = fn;
+	enhanced.getPermission = () => getPermission({
+		name: permissionName,
+		access: "access"
+	});
+	enhanced.openPermissionDialog = () => openPermissionDialog({
+		name: permissionName,
+		access: "access"
+	});
+	return enhanced;
+}
+/**
+* 권한 체크 후 denied면 per-API *PermissionError 서브클래스를 throw한다.
+* 실 3.0 SDK 동작과 일치 — `instanceof PermissionError` 분기가 mock에서도 동작한다 (#372).
+*/
+function checkPermission(name, fnName) {
+	if (aitState.state.permissions[name] === "denied") {
+		const ErrorClass = permissionErrorMap[fnName];
+		if (ErrorClass) throw new ErrorClass();
+		throw new PermissionError({ methodName: fnName });
+	}
+}
+//#endregion
+//#region src/mock/device/camera.ts
+/**
+* Camera & Album Photos & Album Items mock
+* mock/web/prompt 모드 지원
+*/
+async function openCameraMock() {
+	const images = getMockImages();
+	return {
+		id: crypto.randomUUID(),
+		dataUri: images[0]
+	};
+}
+async function openCameraWeb() {
+	return new Promise((resolve, reject) => {
+		const input = document.createElement("input");
+		input.type = "file";
+		input.accept = "image/*";
+		input.capture = "environment";
+		let settled = false;
+		input.onchange = () => {
+			settled = true;
+			const file = input.files?.[0];
+			if (!file) {
+				reject(/* @__PURE__ */ new Error("No file selected"));
+				return;
+			}
+			const reader = new FileReader();
+			reader.onload = () => resolve({
+				id: crypto.randomUUID(),
+				dataUri: reader.result
+			});
+			reader.onerror = () => reject(/* @__PURE__ */ new Error("Failed to read file"));
+			reader.readAsDataURL(file);
+		};
+		const onFocus = () => {
+			setTimeout(() => {
+				if (!settled) reject(/* @__PURE__ */ new Error("File picker cancelled"));
+				window.removeEventListener("focus", onFocus);
+			}, 300);
+		};
+		window.addEventListener("focus", onFocus);
+		input.click();
+	});
+}
+async function openCameraPrompt() {
+	const dataUri = await waitForPromptResponse("camera");
+	return {
+		id: crypto.randomUUID(),
+		dataUri
+	};
+}
+const _openCamera = async (_options) => {
+	checkPermission("camera", "openCamera");
+	const mode = aitState.state.deviceModes.camera;
+	if (mode === "web") return openCameraWeb();
+	if (mode === "prompt") return openCameraPrompt();
+	return openCameraMock();
+};
+const openCamera = withPermission(_openCamera, "camera");
+async function fetchAlbumPhotosMock(maxCount) {
+	return getMockImages().slice(0, maxCount).map((dataUri) => ({
+		id: crypto.randomUUID(),
+		dataUri
+	}));
+}
+async function fetchAlbumPhotosWeb(maxCount) {
+	return new Promise((resolve, reject) => {
+		const input = document.createElement("input");
+		input.type = "file";
+		input.accept = "image/*";
+		input.multiple = true;
+		let settled = false;
+		input.onchange = async () => {
+			settled = true;
+			const files = Array.from(input.files ?? []).slice(0, maxCount);
+			if (files.length === 0) {
+				reject(/* @__PURE__ */ new Error("No files selected"));
+				return;
+			}
+			resolve(await Promise.all(files.map((file) => new Promise((res, rej) => {
+				const reader = new FileReader();
+				reader.onload = () => res({
+					id: crypto.randomUUID(),
+					dataUri: reader.result
+				});
+				reader.onerror = () => rej(/* @__PURE__ */ new Error("Failed to read file"));
+				reader.readAsDataURL(file);
+			}))));
+		};
+		const onFocus = () => {
+			setTimeout(() => {
+				if (!settled) reject(/* @__PURE__ */ new Error("File picker cancelled"));
+				window.removeEventListener("focus", onFocus);
+			}, 300);
+		};
+		window.addEventListener("focus", onFocus);
+		input.click();
+	});
+}
+async function fetchAlbumPhotosPrompt(maxCount) {
+	return (await waitForPromptResponse("photos")).slice(0, maxCount).map((dataUri) => ({
+		id: crypto.randomUUID(),
+		dataUri
+	}));
+}
+const _fetchAlbumPhotos = async (options) => {
+	checkPermission("photos", "fetchAlbumPhotos");
+	const maxCount = options?.maxCount ?? 10;
+	const mode = aitState.state.deviceModes.photos;
+	if (mode === "web") return fetchAlbumPhotosWeb(maxCount);
+	if (mode === "prompt") return fetchAlbumPhotosPrompt(maxCount);
+	return fetchAlbumPhotosMock(maxCount);
+};
+const fetchAlbumPhotos = withPermission(_fetchAlbumPhotos, "photos");
+async function fetchAlbumItemsMock(maxCount, types) {
+	return getMockImages().slice(0, maxCount).filter(() => types.includes("PHOTO")).map((dataUri) => ({
+		id: crypto.randomUUID(),
+		dataUri,
+		type: "PHOTO"
+	}));
+}
+async function fetchAlbumItemsWeb(maxCount, types) {
+	return new Promise((resolve) => {
+		const input = document.createElement("input");
+		input.type = "file";
+		input.accept = types.includes("VIDEO") ? "image/*,video/*" : "image/*";
+		input.multiple = true;
+		let settled = false;
+		input.onchange = async () => {
+			settled = true;
+			const files = Array.from(input.files ?? []).slice(0, maxCount);
+			if (files.length === 0) {
+				resolve([]);
+				return;
+			}
+			resolve(await Promise.all(files.map((file) => new Promise((res, rej) => {
+				const itemType = file.type.startsWith("video/") ? "VIDEO" : "PHOTO";
+				const reader = new FileReader();
+				reader.onload = () => res({
+					id: crypto.randomUUID(),
+					dataUri: reader.result,
+					type: itemType
+				});
+				reader.onerror = () => rej(/* @__PURE__ */ new Error("Failed to read file"));
+				reader.readAsDataURL(file);
+			}))));
+		};
+		const onFocus = () => {
+			setTimeout(() => {
+				if (!settled) resolve([]);
+				window.removeEventListener("focus", onFocus);
+			}, 300);
+		};
+		window.addEventListener("focus", onFocus);
+		input.click();
+	});
+}
+async function fetchAlbumItemsPrompt(maxCount) {
+	return (await waitForPromptResponse("photos")).slice(0, maxCount).map((dataUri) => ({
+		id: crypto.randomUUID(),
+		dataUri,
+		type: "PHOTO"
+	}));
+}
+const _fetchAlbumItems = async (options) => {
+	checkPermission("photos", "fetchAlbumItems");
+	const maxCount = options?.maxCount ?? 10;
+	const types = options?.types ?? ["PHOTO"];
+	const mode = aitState.state.deviceModes.photos;
+	if (mode === "web") return fetchAlbumItemsWeb(maxCount, types);
+	if (mode === "prompt") return fetchAlbumItemsPrompt(maxCount);
+	return fetchAlbumItemsMock(maxCount, types);
+};
+const _fetchAlbumItemsWithPermission = withPermission(_fetchAlbumItems, "photos");
+const fetchAlbumItems = Object.assign(_fetchAlbumItemsWithPermission, { isSupported: () => true });
+//#endregion
+//#region src/mock/throttle.ts
+/**
+* THROTTLED 시뮬레이션 (devtools#834 — #770 §3 분리).
+*
+* 실기기 네이티브 브리지는 같은 메서드를 짧은 간격으로 연타하면
+* `APP_BRIDGE_THROTTLED`로 거부한다. 이 모듈은 그 per-method rate limit을
+* env1(mock)에서 **opt-in으로** 재현한다 — 다이얼(`failureModes.throttled`)이
+* 미설정이면 아무 일도 하지 않으므로 zero behavior change다.
+*
+* 설계 메모 두 가지:
+*
+* 1. **거부된 호출은 창을 갱신하지 않는다.** 마지막 *허용된* 호출 시각만 기록하므로,
+*    `intervalMs` 안에서 계속 연타해도 창이 밀려나지 않고 최초 허용 시점 기준으로
+*    풀린다. 네이티브 rate limit의 통상 동작이자, 연타 중 영원히 막히는(창이 계속
+*    갱신되는) 반-패턴을 피한다.
+* 2. **`observe()`에 걸지 않는다.** `observe()`는 `fn`을 호출하기 *전에* 감싸므로
+*    거기서 throw하면 원래 Promise를 반환하는 API가 **동기 throw**로 바뀐다.
+*    `threwSync`는 env1↔env3 동치 diff의 관측 축이라 그 차이가 곧 가짜 불일치가 된다.
+*    그래서 각 mock 구현 본문 안(= 그 API 자신의 sync/async 계약 안)에 수동 삽입한다.
+*/
+/**
+* `method`가 지금 throttle에 걸리면 네이티브 실패 에러를 돌려주고, 아니면
+* 호출 시각을 기록한 뒤 `undefined`를 돌려준다.
+*
+* 반환된 에러를 **호출부가 자신의 계약대로** 흘려보낸다 — async mock은 `throw`
+* (= reject), 콜백형 mock은 `onError(err)`. 그래서 이 함수 자체는 던지지 않는다.
+*/
+function throttleErrorFor(method) {
+	const dial = aitState.state.failureModes.throttled;
+	if (!dial?.methods?.includes(method)) return void 0;
+	const now = Date.now();
+	const prev = lastAllowedAt.get(method);
+	if (prev !== void 0 && now - prev < dial.intervalMs) return buildNativeError("APP_BRIDGE_THROTTLED");
+	lastAllowedAt.set(method, now);
+}
+/**
+* `throttleErrorFor`의 throw 버전 — async mock 본문에서 한 줄로 쓴다.
+* async 함수 안에서 던지므로 호출자에게는 rejection으로 도달한다.
+*/
+function checkThrottle(method) {
+	const err = throttleErrorFor(method);
+	if (err) throw err;
+}
+//#endregion
+//#region src/mock/device/clipboard.ts
+/**
+* Clipboard mock
+* mock/web 모드 지원
+*/
+const _getClipboardText = async () => {
+	checkPermission("clipboard", "getClipboardText");
+	checkThrottle("getClipboardText");
+	if (aitState.state.deviceModes.clipboard === "mock") return aitState.state.mockData.clipboardText;
+	try {
+		return await navigator.clipboard.readText();
+	} catch {
+		return "";
+	}
+};
+const getClipboardText = withPermission(_getClipboardText, "clipboard");
+const _setClipboardText = async (text) => {
+	checkPermission("clipboard", "setClipboardText");
+	checkThrottle("setClipboardText");
+	if (aitState.state.deviceModes.clipboard === "mock") {
+		aitState.patch("mockData", { clipboardText: text });
+		return { text };
+	}
+	await navigator.clipboard.writeText(text);
+	return { text };
+};
+const setClipboardText = withPermission(_setClipboardText, "clipboard");
+//#endregion
+//#region src/mock/device/contacts.ts
+const _fetchContacts = async (options) => {
+	checkPermission("contacts", "fetchContacts");
+	let contacts = aitState.state.contacts;
+	if (options.query?.contains) {
+		const q = options.query.contains.toLowerCase();
+		contacts = contacts.filter((c) => c.name.toLowerCase().includes(q) || c.phoneNumber.includes(q));
+	}
+	const sliced = contacts.slice(options.offset, options.offset + options.size);
+	const nextOffset = options.offset + options.size;
+	return {
+		result: sliced,
+		nextOffset: nextOffset < contacts.length ? nextOffset : null,
+		done: nextOffset >= contacts.length
+	};
+};
+/**
+* 상류 SDK는 `fetchContacts`의 타입에 `.getPermission`/`.openPermissionDialog`를
+* `PermissionFunctionWithDialog`로 선언하지만, 실기기(2.x×iOS)에는 그 메서드가
+* **런타임에 붙어 있지 않다**(devtools#795 — 호출 시 `fetchContacts.getPermission
+* is not a function` native `TypeError`). standalone `getPermission({name:
+* 'contacts', access: 'access'})`는 실기기에서 정상 resolve하므로(env3 run11,
+* `../permissions.ts`) 부재는 fetchContacts에 **부착된** 메서드에만 해당하는
+* 상류 타입↔런타임 불일치다.
+*
+* mock은 다른 device API처럼 `withPermission()`으로 감싸지 않고, bare async fn을
+* 상류 시그니처로만 캐스트한다 — `.getPermission`/`.openPermissionDialog` 접근은
+* `undefined`가 되고, 호출하면 `undefined()` → native `TypeError`로 떨어져
+* 실기기와 일치한다(`__typecheck.ts`/`__typecheck-2x.ts`는 캐스트 타입에 두
+* 메서드가 여전히 남아 있어 그대로 통과). `_fetchContacts` 내부에서 이미
+* `checkPermission`을 호출하므로 메인 동작(권한 거부 시
+* `FetchContactsPermissionError`)은 변화 없다.
+*
+* 직접 관측된 것은 `getPermission` 부재뿐이다. `openPermissionDialog` 부재는
+* "상류가 fetchContacts에 권한 헬퍼 전체를 붙이지 않는다"는 합리적 추론이지
+* 별도 실측은 아니다. 다른 `withPermission` API(clipboard/camera/location)로는
+* 이 부재를 확장하지 않는다 — 그쪽 부착 메서드가 실기기에서 없다는 관측은
+* 없다(#783 "측정 밖 확장 금지" 원칙).
+*/
+const fetchContacts = _fetchContacts;
+//#endregion
+//#region src/mock/device/haptic.ts
+/**
+* Haptic Feedback & saveBase64Data mock
+*
+* generateHapticFeedback — 영역 3 (하드웨어 API 관측):
+*   - 10종 HapticFeedbackType을 navigator.vibrate 패턴으로 매핑(근사, best-effort).
+*   - `typeof navigator.vibrate === 'function'` 가드 — API 없는 환경에서 throw 없이 skip.
+*   - @ait-co/polyfill 동시 사용 시 재귀 방지: polyfill이 navigator.vibrate를 override하고
+*     내부에서 mock의 generateHapticFeedback을 호출하므로 무한 재귀가 발생한다. polyfill이
+*     원본 vibrate를 BACKUP_KEY(Symbol.for('@ait-co/polyfill/vibrate.original'))에 저장하면
+*     그 원본을 직접 호출해 재귀를 끊는다.
+*   - sdkCallLog에 🟡(partial)로 기록. params: { hapticType, vibrated: boolean }.
+*   - 시그니처 불변 — __typecheck.ts의 Assert<Mock, Original> 통과.
+*/
+/**
+* HapticFeedbackType 10종 → navigator.vibrate 패턴 매핑.
+* 숫자: 진동 ms. 배열: [진동, 정지, 진동, …] 교대 패턴.
+*/
+const HAPTIC_VIBRATE_PATTERN = {
+	tickWeak: 10,
+	tap: 20,
+	tickMedium: 30,
+	softMedium: 40,
+	basicWeak: 15,
+	basicMedium: 50,
+	success: [
+		10,
+		40,
+		10
+	],
+	error: [
+		40,
+		30,
+		40
+	],
+	wiggle: [
+		20,
+		20,
+		20,
+		20,
+		20
+	],
+	confetti: [
+		10,
+		20,
+		10,
+		20,
+		10,
+		20,
+		10
+	]
+};
+/**
+* navigator.vibrate를 안전하게 호출한다.
+*
+* @ait-co/polyfill/auto가 설치된 환경에서는 navigator.vibrate가 polyfill shim으로
+* override되어 있고, 그 shim은 내부적으로 mock의 generateHapticFeedback을 호출한다.
+* mock이 다시 navigator.vibrate(현재 = shim)를 호출하면 무한 재귀가 발생한다.
+* polyfill은 원본 vibrate를 BACKUP_KEY에 저장하므로 그쪽을 직접 호출한다.
+*/
+const POLYFILL_VIBRATE_BACKUP = Symbol.for("@ait-co/polyfill/vibrate.original");
+function callVibrate(pattern) {
+	if (typeof navigator === "undefined") return false;
+	const nav = navigator;
+	const original = POLYFILL_VIBRATE_BACKUP in nav ? nav[POLYFILL_VIBRATE_BACKUP] : null;
+	if (typeof original === "function") return original(pattern);
+	return typeof navigator.vibrate === "function" ? navigator.vibrate(pattern) : false;
+}
+async function generateHapticFeedback(options) {
+	if (!Object.hasOwn(HAPTIC_VIBRATE_PATTERN, options.type)) throw buildNativeError("EXECUTION_ERROR");
+	const timestamp = Date.now();
+	aitState.logAnalytics({
+		type: "haptic",
+		params: { hapticType: options.type }
+	});
+	const vibrated = callVibrate(HAPTIC_VIBRATE_PATTERN[options.type] ?? 30);
+	aitState.logSdkCall({
+		method: "generateHapticFeedback",
+		args: [{ type: options.type }],
+		timestamp,
+		status: "resolved",
+		result: {
+			hapticType: options.type,
+			vibrated
+		},
+		fidelity: "partial"
+	});
+}
+async function saveBase64Data(params) {
+	if (params.data === "") throw buildNativeError("INVALID_DATA");
+	const a = document.createElement("a");
+	a.href = `data:${params.mimeType};base64,${params.data}`;
+	a.download = params.fileName;
+	a.click();
+}
+//#endregion
+//#region src/mock/device/location.ts
+/**
+* Location mock (getCurrentLocation, startUpdateLocation)
+* mock/web/prompt 모드 지원
+*/
+var Accuracy = /* @__PURE__ */ function(Accuracy) {
+	Accuracy[Accuracy["Lowest"] = 1] = "Lowest";
+	Accuracy[Accuracy["Low"] = 2] = "Low";
+	Accuracy[Accuracy["Balanced"] = 3] = "Balanced";
+	Accuracy[Accuracy["High"] = 4] = "High";
+	Accuracy[Accuracy["Highest"] = 5] = "Highest";
+	Accuracy[Accuracy["BestForNavigation"] = 6] = "BestForNavigation";
+	return Accuracy;
+}(Accuracy || {});
+function buildLocation() {
+	return {
+		coords: { ...aitState.state.location.coords },
+		timestamp: Date.now(),
+		accessLocation: aitState.state.location.accessLocation
+	};
+}
+async function getCurrentLocationMock() {
+	const { coords, timestamp } = buildLocation();
+	return {
+		coords,
+		timestamp
+	};
+}
+async function getCurrentLocationWeb() {
+	return new Promise((resolve) => {
+		if (!navigator.geolocation) {
+			console.warn("[@apps-in-toss/devtools] Geolocation API not available, falling back to mock");
+			resolve(buildLocation());
+			return;
+		}
+		navigator.geolocation.getCurrentPosition((pos) => {
+			resolve({
+				coords: {
+					latitude: pos.coords.latitude,
+					longitude: pos.coords.longitude,
+					altitude: pos.coords.altitude ?? 0,
+					accuracy: pos.coords.accuracy,
+					altitudeAccuracy: pos.coords.altitudeAccuracy ?? 0,
+					heading: pos.coords.heading ?? 0
+				},
+				timestamp: pos.timestamp
+			});
+		}, () => {
+			console.warn("[@apps-in-toss/devtools] Geolocation failed, falling back to mock");
+			resolve(buildLocation());
+		});
+	});
+}
+async function getCurrentLocationPrompt() {
+	const { coords, timestamp } = await waitForPromptResponse("location");
+	return {
+		coords,
+		timestamp
+	};
+}
+const _getCurrentLocation = async (_options) => {
+	checkPermission("geolocation", "getCurrentLocation");
+	checkThrottle("getCurrentLocation");
+	const mode = aitState.state.deviceModes.location;
+	if (mode === "web") return getCurrentLocationWeb();
+	if (mode === "prompt") return getCurrentLocationPrompt();
+	return getCurrentLocationMock();
+};
+const getCurrentLocation = withPermission(_getCurrentLocation, "geolocation");
+function startUpdateLocationMock(eventParams) {
+	const { onEvent, options } = eventParams;
+	const interval = Math.max(options.timeInterval, 500);
+	const id = setInterval(() => {
+		const loc = buildLocation();
+		loc.coords.latitude += (Math.random() - .5) * 1e-4;
+		loc.coords.longitude += (Math.random() - .5) * 1e-4;
+		onEvent(loc);
+	}, interval);
+	return () => clearInterval(id);
+}
+function startUpdateLocationWeb(eventParams) {
+	const { onEvent, onError } = eventParams;
+	if (!navigator.geolocation) {
+		console.warn("[@apps-in-toss/devtools] Geolocation API not available, falling back to mock");
+		return startUpdateLocationMock(eventParams);
+	}
+	const watchId = navigator.geolocation.watchPosition((pos) => {
+		onEvent({
+			coords: {
+				latitude: pos.coords.latitude,
+				longitude: pos.coords.longitude,
+				altitude: pos.coords.altitude ?? 0,
+				accuracy: pos.coords.accuracy,
+				altitudeAccuracy: pos.coords.altitudeAccuracy ?? 0,
+				heading: pos.coords.heading ?? 0
+			},
+			timestamp: pos.timestamp,
+			accessLocation: "FINE"
+		});
+	}, (err) => onError(err));
+	return () => navigator.geolocation.clearWatch(watchId);
+}
+function startUpdateLocationPrompt(eventParams) {
+	const { onEvent } = eventParams;
+	const handler = (e) => {
+		onEvent(e.detail);
+	};
+	window.addEventListener("__ait:prompt-response:location-update", handler);
+	window.dispatchEvent(new CustomEvent("__ait:prompt-request", { detail: { type: "location-update" } }));
+	return () => window.removeEventListener("__ait:prompt-response:location-update", handler);
+}
+const _startUpdateLocation = (eventParams) => {
+	const mode = aitState.state.deviceModes.location;
+	if (mode === "web") return startUpdateLocationWeb(eventParams);
+	if (mode === "prompt") return startUpdateLocationPrompt(eventParams);
+	return startUpdateLocationMock(eventParams);
+};
+const startUpdateLocation = withPermission(_startUpdateLocation, "geolocation");
+//#endregion
+//#region src/mock/device/network.ts
+/**
+* Network Status mock (mode-aware helper)
+* navigation 모듈에서 사용. circular dep 방지를 위해 device에 위치.
+*/
+/**
+* Web mode: uses navigator.connection.effectiveType (4g/3g/2g) and navigator.onLine.
+* Limitations: WIFI, 5G, WWAN cannot be detected via the Network Information API.
+* Falls back to state-based value when effectiveType is unavailable.
+*/
+function getNetworkStatusByMode() {
+	const mode = aitState.state.deviceModes.network;
+	if (mode === "mock") return null;
+	if (mode === "web") {
+		if (!navigator.onLine) return "OFFLINE";
+		const conn = navigator.connection;
+		if (conn?.effectiveType) return {
+			"4g": "4G",
+			"3g": "3G",
+			"2g": "2G",
+			"slow-2g": "2G"
+		}[conn.effectiveType] ?? "UNKNOWN";
+		return aitState.state.networkStatus;
+	}
+	return null;
+}
+//#endregion
+//#region src/mock/device/pdf.ts
+/**
+* Base64로 인코딩된 PDF 데이터를 네이티브 PDF 뷰어로 여는 mock.
+* mock 환경에서는 즉시 `'CLOSE'`를 반환한다.
+*/
+const _openPDFViewerImpl = async (_params) => {
+	await Promise.resolve();
+	return "CLOSE";
+};
+const openPDFViewer = Object.assign(_openPDFViewerImpl, { isSupported: () => true });
+//#endregion
+//#region src/mock/proxy.ts
+/**
+* 미구현 API용 Proxy 트립와이어.
+*
+* 미구현 프로퍼티에 접근하면 throw한다. 이는 "devtools에서는 멀쩡히 돌지만
+* 실 SDK에선 실제로 동작하는" 시나리오를 차단하기 위한 의도적 선택이다.
+* mock이 미구현인 API는 실 SDK에서는 존재할 수 있고, 사용자가 이를 인지하지
+* 못한 채 개발을 이어가면 배포 시점에 놀라게 된다. 에러 메시지에 이슈 URL을
+* 포함해 사용자가 mock 누락을 제보할 수 있게 한다.
+*
+* ## KNOWN_UNIMPLEMENTED 정책
+* SDK에 존재하는 것으로 알려져 있으나 현재 mock이 없는 API 이름만 이 집합에 둔다.
+* 이 경우에만 throw 대신 🔴 inert no-op을 반환하고 sdkCallLog에 기록한다.
+* 완전히 미지의 이름은 여전히 throw — "잘 되는 척" 방지.
+*/
+const ISSUES_URL = "https://github.com/apps-in-toss-community/devtools/issues";
+/**
+* SDK에 존재하나 mock이 아직 없는 것으로 확인된 이름 목록.
+* 새 API가 SDK에 추가되면 여기에 추가하고 별도 PR에서 mock 구현으로 이동한다.
+* 확인되지 않은 이름은 절대 여기에 추가하지 않는다 — throw가 더 안전하다.
+*/
+const KNOWN_UNIMPLEMENTED = /* @__PURE__ */ new Set([]);
+function createMockProxy(moduleName, implementations) {
+	return new Proxy(implementations, { get(target, prop) {
+		if (typeof prop === "symbol") return void 0;
+		if (prop in target) return target[prop];
+		const name = String(prop);
+		if (KNOWN_UNIMPLEMENTED.has(name)) return (...args) => {
+			console.warn(`[@apps-in-toss/devtools] ${moduleName}.${name} is known-unimplemented (🔴 inert). Returning undefined. Please file or upvote an issue: ${ISSUES_URL}`);
+			aitState.logSdkCall({
+				method: `${moduleName}.${name}`,
+				args,
+				timestamp: Date.now(),
+				status: "resolved",
+				result: void 0,
+				fidelity: "inert"
+			});
+		};
+		throw new Error(`[@apps-in-toss/devtools] ${moduleName}.${prop} is not mocked. This API may exist in @apps-in-toss/web-framework, but devtools' mock does not cover it yet. Please file an issue: ${ISSUES_URL}`);
+	} });
+}
+//#endregion
+//#region src/mock/device/storage.ts
+/**
+* Storage mock
+* localStorage에 `__ait_storage:` prefix로 저장하여 앱 자체 localStorage와 분리
+*
+* 실기기(2.x×iOS) capture는 `setItem`/`removeItem`/`clearItems` 세 메서드가
+* `undefined`가 아니라 `null`로 resolve됨을 보였다(devtools#770). 원본 SDK 타입
+* 선언은 여전히 `Promise<void>`이므로 시그니처는 그대로 두고, 런타임 반환값만
+* `null`로 캐스트해 실측과 동치시킨다 — Analytics·setClipboardText와 같은 처리(#775).
+* `getItem`은 이미 `string | null`이라 실측과 일치하므로 손대지 않는다.
+*/
+const Storage = createMockProxy("Storage", {
+	getItem: async (key) => {
+		return localStorage.getItem(`__ait_storage:${key}`);
+	},
+	setItem: async (key, value) => {
+		localStorage.setItem(`__ait_storage:${key}`, value);
+		return null;
+	},
+	removeItem: async (key) => {
+		localStorage.removeItem(`__ait_storage:${key}`);
+		return null;
+	},
+	clearItems: async () => {
+		const keys = Object.keys(localStorage).filter((k) => k.startsWith("__ait_storage:"));
+		for (const k of keys) localStorage.removeItem(k);
+		return null;
+	}
+});
+//#endregion
+//#region src/mock/observe.ts
+/**
+* fn을 observe로 감싼다.
+*
+* @param apiName  - 로그에 기록할 SDK 메서드 이름 (예: `'setScreenAwakeMode'`)
+* @param fidelity - 이 mock의 fidelity grade ('faithful' | 'partial' | 'inert')
+* @param fn       - 실제 mock 구현체. 시그니처를 그대로 통과시킨다.
+* @returns fn과 동일한 타입의 래퍼 함수
+*/
+function observe(apiName, fidelity, fn) {
+	return (...args) => {
+		const timestamp = Date.now();
+		const safeArgs = args.map((a) => safeSerialize(a));
+		const result = fn(...args);
+		if (result instanceof Promise) {
+			aitState.logSdkCall({
+				method: apiName,
+				args: safeArgs,
+				timestamp,
+				status: "pending",
+				fidelity
+			});
+			result.then((value) => {
+				aitState.logSdkCall({
+					method: apiName,
+					args: safeArgs,
+					timestamp,
+					status: "resolved",
+					result: safeSerialize(value),
+					fidelity
+				});
+			}, (err) => {
+				aitState.logSdkCall({
+					method: apiName,
+					args: safeArgs,
+					timestamp,
+					status: "rejected",
+					error: err instanceof Error ? err.message : String(err),
+					fidelity
+				});
+			});
+			return result;
+		}
+		aitState.logSdkCall({
+			method: apiName,
+			args: safeArgs,
+			timestamp,
+			status: "resolved",
+			result: safeSerialize(result),
+			fidelity
+		});
+		return result;
+	};
+}
+/**
+* 값을 JSON-safe한 형태로 변환한다.
+* - null / primitive — 그대로.
+* - 함수 — `'[Function: name]'` 문자열.
+* - 기타 객체 — JSON.stringify 실패 시 `'[unserializable]'`.
+*/
+function safeSerialize(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
+	if (typeof value !== "object") return value;
+	try {
+		return JSON.parse(JSON.stringify(value));
+	} catch {
+		return "[unserializable]";
+	}
+}
+//#endregion
+//#region src/mock/navigation/index.ts
+async function closeView() {
+	console.log("[@apps-in-toss/devtools] closeView called");
+	window.history.back();
+}
+async function openURL(url) {
+	console.log("[@apps-in-toss/devtools] openURL:", url);
+	window.open(url, "_blank");
+}
+async function share(message) {
+	if (navigator.share) {
+		await navigator.share({ text: message.message });
+		return;
+	}
+	console.log("[@apps-in-toss/devtools] share:", message.message);
+}
+const URI_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+async function getTossShareLink(path, _ogImageUrl) {
+	if (!URI_SCHEME_PATTERN.test(path)) throw buildNativeError("EXECUTION_ERROR");
+	return `https://toss.im/share/mock${path}`;
+}
+async function setIosSwipeGestureEnabled(options) {
+	console.log("[@apps-in-toss/devtools] setIosSwipeGestureEnabled:", options.isEnabled);
+	aitState.patch("navigation", { iosSwipeGestureEnabled: options.isEnabled });
+}
+async function setDeviceOrientation(options) {
+	const current = aitState.state.viewport.orientation;
+	if (current === "auto") {
+		console.log("[@apps-in-toss/devtools] setDeviceOrientation:", options.type);
+		aitState.patch("viewport", { appOrientation: options.type });
+		return;
+	}
+	console.warn(`[@apps-in-toss/devtools] setDeviceOrientation(${options.type}) ignored — Panel is forcing "${current}". Change the Viewport tab's orientation to "auto" to let the app control rotation.`);
+}
+const setScreenAwakeMode = observe("setScreenAwakeMode", "inert", async (options) => {
+	console.log("[@apps-in-toss/devtools] setScreenAwakeMode:", options.enabled);
+	return { enabled: options.enabled };
+});
+const setSecureScreen = observe("setSecureScreen", "inert", async (options) => {
+	console.log("[@apps-in-toss/devtools] setSecureScreen:", options.enabled);
+	return { enabled: options.enabled };
+});
+const requestReview = observe("requestReview", "inert", async () => {
+	console.log("[@apps-in-toss/devtools] requestReview called");
+});
+requestReview.isSupported = () => true;
+/**
+* 아래 6개 함수(`getPlatformOS`/`getOperationalEnvironment`/`isMinVersionSupported`/
+* `getSchemeUri`/`getLocale`/`getDeviceId`, `getSchemeUri`는 devtools#806) + 이
+* 파일 최하단의 `getSafeAreaInsets`는 실기기(2.x×iOS) capture에서 전부
+* **Promise를 반환**함이 확인됐다(devtools#795/#806 — sdk-example type-probe
+* 실측). 그런데 상류 `.d.ts`는 이 함수들을 전부 **동기**로 선언한다 — 선언과
+* 런타임이 어긋난 상류 타입 버그다.
+*
+* mock은 타입 선언이 아니라 런타임 실측을 재현해야 개발자가 env1(브라우저)에서
+* 겪는 동작이 env3(실기기)와 같아진다(#775 원칙 — Analytics·setClipboardText·
+* Storage·getSafeAreaInsets(#770)에 이미 적용). 그래서 시그니처는 상류와 동일하게
+* 두고(`__typecheck.ts`/`__typecheck-2x.ts`의 `Assert*`가 계속 컴파일되도록)
+* 반환값만 `Promise.resolve(...)`로 감싸 기존 시그니처로 캐스트한다 — 선언 타입이
+* 안 바뀌므로 런타임 Promise는 tsc에 보이지 않는다.
+*
+* `getTossAppVersion`/`getGroupId`/`getAppsInTossGlobals`/`env.getDeploymentId`는
+* devtools#806 env3 재캡처에서도 여전히 미측정이다 — environment 테스트가
+* `getSchemeUri` 단언에서 조기 실패해 뒤 4개 accessor 캡처가 애초에 안 떨어졌다.
+* 같은 async 축일 가능성은 있으나 관측 전까지 손대지 않는다(#783 "측정 밖 확장
+* 금지").
+*/
+function getPlatformOS() {
+	return Promise.resolve(aitState.state.platform);
+}
+function getOperationalEnvironment() {
+	return Promise.resolve(aitState.state.environment);
+}
+function getTossAppVersion() {
+	return aitState.state.appVersion;
+}
+function isMinVersionSupported(minVersions) {
+	const result = computeIsMinVersionSupported(minVersions);
+	return Promise.resolve(result);
+}
+function computeIsMinVersionSupported(minVersions) {
+	const required = aitState.state.platform === "ios" ? minVersions.ios : minVersions.android;
+	if (required === "always") return true;
+	if (required === "never") return false;
+	const current = aitState.state.appVersion.split(".").map(Number);
+	const min = required.split(".").map(Number);
+	for (let i = 0; i < 3; i++) {
+		if ((current[i] ?? 0) > (min[i] ?? 0)) return true;
+		if ((current[i] ?? 0) < (min[i] ?? 0)) return false;
+	}
+	return true;
+}
+function getSchemeUri() {
+	const result = aitState.state.schemeUri || window.location.pathname;
+	return Promise.resolve(result);
+}
+function getLocale() {
+	return Promise.resolve(aitState.state.locale);
+}
+function getDeviceId() {
+	return Promise.resolve(aitState.state.deviceId);
+}
+function getGroupId() {
+	return aitState.state.groupId;
+}
+async function getNetworkStatus() {
+	const modeResult = getNetworkStatusByMode();
+	if (modeResult) return modeResult;
+	return aitState.state.networkStatus;
+}
+const _getServerTimeImpl = async () => {
+	return Date.now();
+};
+const getServerTime = Object.assign(_getServerTimeImpl, { isSupported: () => true });
+/**
+* 현재 backEvent 구독자 수. graniteEvent.addEventListener('backEvent', …)가
+* 증가시키고, 반환된 cleanup이 감소시킨다. 호스트 back 메시지 처리 시 인터셉트
+* 여부를 판단하는 데 쓰인다.
+*
+* @internal 테스트 및 safe-area-bridge에서만 사용.
+*/
+let _backEventSubscriberCount = 0;
+const graniteEvent = { addEventListener(event, { onEvent, onError }) {
+	const handler = () => {
+		try {
+			onEvent();
+		} catch (e) {
+			onError?.(e instanceof Error ? e : new Error(String(e)));
+		}
+	};
+	window.addEventListener(`__ait:${event}`, handler);
+	if (event === "backEvent") _backEventSubscriberCount++;
+	let cleaned = false;
+	return () => {
+		if (cleaned) return;
+		cleaned = true;
+		window.removeEventListener(`__ait:${event}`, handler);
+		if (event === "backEvent") _backEventSubscriberCount--;
+	};
+} };
+/**
+* 호스트 back 내비게이션을 처리한다.
+*
+* backEvent 구독자가 1명 이상이면 `window.dispatchEvent(new CustomEvent('__ait:backEvent'))`만
+* 발사한다 — 미니앱이 back을 가로채는(intercept) 채널이고 실제 토스 호스트와 동일한 시맨틱.
+* 구독자가 없으면 `history.back()`을 호출해 기본 브라우저 뒤로가기를 수행한다.
+*
+* env 1 패널의 back 버튼(`src/panel/viewport.ts` `aitState.trigger('backEvent')`)과
+* 동일한 경로를 거쳐 back 시맨틱의 단일 소유처를 navigation 모듈에 유지한다.
+*/
+function dispatchHostBackNavigation() {
+	if (_backEventSubscriberCount > 0) window.dispatchEvent(new CustomEvent("__ait:backEvent"));
+	else history.back();
+}
+const appsInTossEvent = { addEventListener(_event, _handlers) {
+	return () => {};
+} };
+const tdsEvent = { addEventListener(event, { onEvent }) {
+	const handler = (e) => {
+		const detail = e.detail;
+		onEvent(detail);
+	};
+	window.addEventListener(`__ait:${event}`, handler);
+	return () => window.removeEventListener(`__ait:${event}`, handler);
+} };
+/**
+* @deprecated web-framework 3.0 에서 제거됨. 2.x 소비자 back-compat용으로 유지.
+*/
+function onVisibilityChangedByTransparentServiceWeb(eventParams) {
+	const handler = () => eventParams.onEvent(!document.hidden);
+	document.addEventListener("visibilitychange", handler);
+	return () => document.removeEventListener("visibilitychange", handler);
+}
+const env = { getDeploymentId: () => aitState.state.deploymentId };
+function getAppsInTossGlobals() {
+	return {
+		deploymentId: aitState.state.deploymentId,
+		brandDisplayName: aitState.state.brand.displayName,
+		brandIcon: aitState.state.brand.icon,
+		brandPrimaryColor: aitState.state.brand.primaryColor
+	};
+}
+const SafeAreaInsets = {
+	get: () => ({ ...aitState.state.safeAreaInsets }),
+	subscribe: ({ onEvent }) => {
+		return aitState.subscribe(() => onEvent({ ...aitState.state.safeAreaInsets }));
+	}
+};
+/**
+* @deprecated `SafeAreaInsets.get()`을 쓸 것.
+*
+* 상류 SDK의 타입 선언은 `getSafeAreaInsets(): number`지만, 실기기(2.x×iOS)
+* capture는 이 함수가 숫자가 아니라 `SafeAreaInsets.get()`과 같은 객체
+* (`{ top, right, bottom, left }`)를 반환함을 보였다(devtools#770 —
+* `returnType: "object"`, `valueKeys: ["top","right","bottom","left"]`).
+* 즉 선언과 런타임이 어긋나 있는 상류 타입 버그다. 게다가 그 반환 자체도
+* 동기가 아니라 **Promise**다(devtools#795 — 위 "환경 정보" 섹션 상단 주석과
+* 같은 축, type-probe 실측). shape(object)와 sync/async 두 축 모두 선언과
+* 어긋나 있다.
+*
+* mock은 타입 선언이 아니라 **런타임 실측**을 재현해야 개발자가 env1에서 겪는
+* 동작이 실기기와 같아진다. 그래서 시그니처는 상류와 동일하게 `number`로 두되
+* (`__typecheck.ts`가 SDK 타입에 대해 계속 컴파일되도록) 반환값만 실측 객체를
+* `Promise.resolve`로 감싸 캐스트한다 — Analytics·setClipboardText·Storage와
+* 같은 처리(#775).
+*/
+function getSafeAreaInsets() {
+	return Promise.resolve({ ...aitState.state.safeAreaInsets });
+}
+//#endregion
+//#region src/mock/safe-area-bridge.ts
+/**
+* env-2 postMessage bridges (#484, #510).
+*
+* In the AITC Sandbox PWA (env 2) the dev app runs inside the launcher's
+* full-viewport `<iframe>`. The launcher is the top-level document, so its
+* `env(safe-area-inset-*)` measurement is the ground truth for the real device
+* geometry. The framed page's mock would otherwise report a synthetic preset
+* value (e.g. top=54), which sdk-example then double-pads on top of a viewport
+* that already starts below the status bar — the env-2 "dead band" defect.
+*
+* This module installs receive-half listeners for two message types:
+*
+* 1. `ait:safe-area-insets` (#484): the launcher forwards its real env() insets
+*    to the framed page on iframe load and resize/orientationchange. Validates the
+*    envelope and writes real insets into the mock SafeAreaInsets state, firing the
+*    subscribe path (see navigation/index.ts) so apps that subscribe re-read the
+*    corrected values.
+*
+* 2. `ait:navigate-back` (#510): the launcher partner bar's `←` button posts this
+*    command to the framed page. The receive half calls `dispatchHostBackNavigation()`
+*    (navigation/index.ts): if backEvent subscribers are present, a `__ait:backEvent`
+*    CustomEvent is dispatched (the mini-app intercept channel, matching the env-1
+*    panel path); otherwise `history.back()` is called. No data other than `type` is
+*    read from or written to the message — shape validation rejects anything that
+*    carries extra fields with the wrong type. Apps that do not install this mock
+*    (older builds) silently ignore the message (natural no-op).
+*
+* Origin policy: neither message type carries sensitive data, so we do NOT
+* restrict by origin — the launcher posts cross-origin from a *.trycloudflare.com
+* tunnel with targetOrigin '*'. Shape validation is still mandatory: a malformed
+* or out-of-range message is silently ignored so a stray postMessage can never
+* corrupt the mock state or trigger spurious navigation.
+*
+* Message-driven by design: env 1 (desktop browser, no launcher) never receives
+* these messages, so the panel preset stays authoritative there with zero special
+* casing here.
+*/
+/** The postMessage envelope the launcher posts to the framed dev app (inset forward). */
+const SAFE_AREA_INSETS_MESSAGE_TYPE = "ait:safe-area-insets";
+/**
+* The postMessage command the launcher partner bar's `←` button sends to the
+* framed dev app (#510). The framed page calls `history.back()` in response.
+*
+* Protocol: only `{ type: 'ait:navigate-back' }` is valid. No other fields are
+* read or acted on — extra fields are silently ignored by the shape guard.
+* Game variant never sends this message (back button is partner-bar-only).
+*/
+const NAVIGATE_BACK_MESSAGE_TYPE = "ait:navigate-back";
+/**
+* The postMessage envelope the framed mini-app self-reports its webViewType
+* with (#580). The mini-app knows its own type from the build constant
+* `__WEB_VIEW_TYPE__` (`granite.config.ts`'s `webViewProps.type`, injected by
+* the devtools unplugin). The launcher is cross-origin so it cannot read that
+* constant directly — the mini-app posts it to `window.parent` once so the
+* launcher (env-2 PWA shell) switches to game mode automatically, with no
+* manual `?navBarType=game` URL edit.
+*
+* Direction: this is the SEND side's contract (posted from inside the iframe by
+* `@ait-co/debug-console`'s `packages/debug-console/src/attach.ts`). The
+* launcher's receive half lives in
+* `e2e/fixture/launcher/Launcher.tsx` and mirrors the same value enum inline,
+* staying decoupled from the mock package internals — the same pattern the
+* other launcher message types follow.
+*
+* Value enum: only `'partner'` and `'game'` are valid. The SDK's deprecated
+* `'external'` alias of `partner` (web-framework 2.6.1) is mapped to `'partner'`
+* at the send site so the wire only ever carries the two shapes the launcher
+* emulates.
+*/
+const WEB_VIEW_TYPE_MESSAGE_TYPE = "ait:web-view-type";
+const MAX_INSET_PX = 200;
+function isValidInset(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= MAX_INSET_PX;
+}
+/**
+* Parse + validate a raw postMessage payload into a `SafeAreaInsets`, or return
+* null when it is not a well-formed `ait:safe-area-insets` message. Pure — unit
+* tested without a real MessageEvent.
+*/
+function parseSafeAreaInsetsMessage(data) {
+	if (typeof data !== "object" || data === null) return null;
+	if (data.type !== "ait:safe-area-insets") return null;
+	const insets = data.insets;
+	if (typeof insets !== "object" || insets === null) return null;
+	const { top, bottom, left, right } = insets;
+	if (!isValidInset(top) || !isValidInset(bottom) || !isValidInset(left) || !isValidInset(right)) return null;
+	return {
+		top,
+		bottom,
+		left,
+		right
+	};
+}
+/**
+* Parse + validate a raw postMessage payload into a webViewType value
+* (`'partner'` | `'game'`), or return `null` when it is not a well-formed
+* `ait:web-view-type` message (#580). Pure — unit tested without a real
+* MessageEvent.
+*
+* Strict shape guard (the safety boundary for the cross-origin receive path):
+* the payload must be a non-null object whose `type` is exactly
+* {@link WEB_VIEW_TYPE_MESSAGE_TYPE} and whose `value` is exactly `'partner'`
+* or `'game'` (an enum allow-list). Anything else — a foreign type, a missing
+* or non-string value, the deprecated `'external'` alias, or any other string —
+* returns `null` so a stray postMessage can never flip the launcher's visual
+* mode. The send site is responsible for collapsing `'external'` → `'partner'`
+* before posting; the parser does NOT silently accept it.
+*/
+function parseWebViewTypeMessage(data) {
+	if (typeof data !== "object" || data === null) return null;
+	if (data.type !== "ait:web-view-type") return null;
+	const value = data.value;
+	if (value === "partner" || value === "game") return value;
+	return null;
+}
+/**
+* Apply forwarded insets to the mock state. Skips the write (and the resulting
+* subscribe notify) when nothing changed, so repeated identical messages from a
+* resize storm don't churn subscribers.
+*/
+function applyForwardedSafeAreaInsets(insets) {
+	const current = aitState.state.safeAreaInsets;
+	if (current.top === insets.top && current.bottom === insets.bottom && current.left === insets.left && current.right === insets.right) return;
+	aitState.update({ safeAreaInsets: insets });
+}
+/**
+* The `id` attribute of the `<style>` element injected by
+* {@link applyEnv2Compensation}. Using a stable id makes the injection
+* idempotent — the element is reused on every subsequent message rather than
+* accumulating multiple `<style>` nodes.
+*/
+const ENV2_COMPENSATION_STYLE_ID = "ait-env2-safe-area-compensation";
+/**
+* The CSS text injected when the launcher forwards partner-mode insets
+* (`top === 0`). The negative margin pulls the mini-app document up by exactly
+* the device's status-bar inset so the launcher's own bar offset is not
+* double-counted.
+*
+* jsdom cannot evaluate `env()` expressions, so unit tests assert on this
+* string literal rather than computed geometry.
+*/
+const ENV2_COMPENSATION_CSS = "body { margin-top: calc(-1 * env(safe-area-inset-top)); }";
+/**
+* Inject or remove the env-2 safe-area compensation `<style>` based on the
+* forwarded insets received from the launcher.
+*
+* ### Why this is needed
+*
+* In env 2 (AITC Sandbox PWA) the launcher frames the mini-app in a
+* full-bleed `<iframe>` whose top edge is already positioned BELOW the
+* launcher's partner bar (at `env(safe-area-inset-top) + 54px`). However,
+* inside the cross-origin child iframe, CSS `env(safe-area-inset-top)` STILL
+* reports the full device status-bar inset (e.g. 62 px on an iPhone 15). Any
+* mini-app that pads itself by that CSS `env()` value ends up double-counting
+* the status-bar, producing a ≈62 px white dead-band between the partner bar
+* and the first content.
+*
+* The fix is a compensating negative margin on `body` inside the iframe. When
+* the launcher forwards partner insets (`top === 0`, meaning "the iframe
+* already starts below the bar"), we inject:
+*
+* ```css
+* body { margin-top: calc(-1 * env(safe-area-inset-top)); }
+* ```
+*
+* This cancels the duplicate padding without knowing the app's internal DOM
+* structure. The launcher's html/body `screen.height` force (#527) lives in the
+* LAUNCHER document (cross-origin) and never touches the mini-app document, so
+* margin and height force compose independently — they cannot interfere.
+*
+* ### Gating
+*
+* - **`top === 0`** (partner mode) → install the style (dead-band compensation).
+* - **`top > 0`** (game mode — launcher forwards the raw device inset for the
+*   floating status-bar capsule) → remove any previously installed style so
+*   `env()` is the authoritative clearance and nothing is double-removed.
+*
+* On every insets message (resize/orientation re-post) this function is called
+* so the gate is re-evaluated and the style toggled accordingly.
+*
+* ### env 1 / env 3 / env 4 no-regression
+*
+* This function is only called from the `message` listener installed by
+* {@link installSafeAreaInsetsBridge}. That listener fires only when the
+* launcher posts an `ait:safe-area-insets` message, which never happens in
+* env 1 (desktop browser, no launcher), env 3 (intoss-private WebView), or
+* env 4 (live relay) — they have no launcher posting to the iframe.
+*
+* @param top - The forwarded `top` inset value from the launcher message.
+*/
+function applyEnv2Compensation(top) {
+	if (typeof document === "undefined") return;
+	const existing = document.getElementById(ENV2_COMPENSATION_STYLE_ID);
+	if (top === 0) {
+		if (existing !== null) return;
+		const style = document.createElement("style");
+		style.id = ENV2_COMPENSATION_STYLE_ID;
+		style.textContent = ENV2_COMPENSATION_CSS;
+		document.head.appendChild(style);
+	} else if (existing !== null) existing.remove();
+}
+let installed = false;
+/**
+* Install the window `message` listener that receives forwarded insets. Safe to
+* call multiple times (idempotent) and a no-op outside a browser (SSR/jsdom
+* without a window). Imported for its side effect by the mock barrel so any
+* consumer that aliases `@apps-in-toss/web-framework` to the mock gets it wired.
+*
+* On each valid `ait:safe-area-insets` message:
+* 1. Writes the corrected insets into the mock `SafeAreaInsets` state
+*    (existing #484 behaviour — for apps that still read SDK insets).
+* 2. Drives the env-2 dead-band compensation style via
+*    {@link applyEnv2Compensation} — injects a `body { margin-top: calc(-1 *
+*    env(safe-area-inset-top)) }` style when `top === 0` (partner mode) and
+*    removes it when `top > 0` (game / full-bleed mode).
+*/
+function installSafeAreaInsetsBridge() {
+	if (installed || typeof window === "undefined") return;
+	installed = true;
+	window.addEventListener("message", (event) => {
+		const insets = parseSafeAreaInsetsMessage(event.data);
+		if (insets) {
+			applyForwardedSafeAreaInsets(insets);
+			applyEnv2Compensation(insets.top);
+		}
+	});
+}
+/**
+* Parse a raw postMessage payload as an `ait:navigate-back` command.
+*
+* Returns true when the payload is a well-formed navigate-back command
+* (`{ type: 'ait:navigate-back' }`), false otherwise. Pure — unit tested
+* without a real MessageEvent.
+*
+* Shape guard: only the `type` field is inspected; any extra fields are
+* ignored so future extensions do not break older receivers. The function
+* does NOT read any data field beyond `type` — no sensitive values, no host
+* disclosure (same principle as the insets bridge).
+*/
+function isNavigateBackMessage(data) {
+	if (typeof data !== "object" || data === null) return false;
+	return data.type === NAVIGATE_BACK_MESSAGE_TYPE;
+}
+let navigateBackInstalled = false;
+/**
+* Install the window `message` listener that handles `ait:navigate-back`
+* commands (#510). When the launcher partner bar's `←` button is clicked it
+* posts `{ type: 'ait:navigate-back' }` to the framed dev app; this listener
+* calls `dispatchHostBackNavigation()` from the navigation module.
+*
+* Dispatch semantics: if there are any `graniteEvent.addEventListener('backEvent', …)`
+* subscribers the CustomEvent `__ait:backEvent` is fired (same path as the env-1
+* panel back button — the mini-app intercept channel). When there are no
+* subscribers `history.back()` is called as the fallback. Back semantics are
+* owned entirely by the navigation module; this bridge only delegates.
+*
+* Safe to call multiple times (idempotent) and a no-op outside a browser.
+* Installed together with the inset bridge by `installBridges()` so any consumer
+* of the mock barrel gets both wired automatically.
+*
+* No-op on apps that predate this bridge — the launcher posts the message but
+* older mocks simply have no listener (harmless).
+*/
+function installNavigateBackBridge() {
+	if (navigateBackInstalled || typeof window === "undefined") return;
+	navigateBackInstalled = true;
+	window.addEventListener("message", (event) => {
+		if (isNavigateBackMessage(event.data)) dispatchHostBackNavigation();
+	});
+}
+/**
+* Install both env-2 postMessage bridges in one call (#484 insets + #510
+* navigate-back). The mock barrel calls this at import time so consumers get
+* all bridges wired without any explicit setup.
+*/
+function installBridges() {
+	installSafeAreaInsetsBridge();
+	installNavigateBackBridge();
+}
+//#endregion
+//#region src/mock/ads/index.ts
+function withIsSupported(fn) {
+	fn.isSupported = () => true;
+	return fn;
+}
+const _slotRegistry = /* @__PURE__ */ new Map();
+let _slotCounter = 0;
+function _nextSlotId(adGroupId) {
+	_slotCounter += 1;
+	return `mock-slot-${adGroupId}-${_slotCounter}`;
+}
+const GoogleAdMob = createMockProxy("GoogleAdMob", {
+	loadAppsInTossAdMob: withIsSupported(observe("GoogleAdMob.loadAppsInTossAdMob", "faithful", (args) => {
+		setTimeout(() => {
+			const failureCode = aitState.state.failureModes.loadAdMob;
+			if (failureCode) {
+				args.onError(buildNativeError(failureCode));
+				return;
+			}
+			const throttleError = throttleErrorFor("loadAppsInTossAdMob");
+			if (throttleError) {
+				args.onError(throttleError);
+				return;
+			}
+			if (aitState.state.ads.forceNoFill) {
+				args.onError(/* @__PURE__ */ new Error("No fill"));
+				return;
+			}
+			aitState.patch("ads", { isLoaded: true });
+			args.onEvent({
+				type: "loaded",
+				data: {
+					adGroupId: args.options.adGroupId,
+					adUnitId: `mock-unit-${args.options.adGroupId}`,
+					responseInfo: {
+						responseId: `mock-response-${args.options.adGroupId}`,
+						adNetworkInfoArray: [],
+						loadedAdNetworkInfo: null
+					}
+				}
+			});
+		}, 200);
+		return () => {};
+	})),
+	showAppsInTossAdMob: withIsSupported(observe("GoogleAdMob.showAppsInTossAdMob", "faithful", (args) => {
+		if (!aitState.state.ads.isLoaded) {
+			args.onError(/* @__PURE__ */ new Error("Ad not loaded"));
+			return () => {};
+		}
+		const { rewardUnitType, rewardAmount } = aitState.state.ads;
+		setTimeout(() => args.onEvent({
+			type: "userEarnedReward",
+			data: {
+				unitType: rewardUnitType,
+				unitAmount: rewardAmount
+			}
+		}), 1e3);
+		setTimeout(() => {
+			args.onEvent({ type: "dismissed" });
+			aitState.patch("ads", { isLoaded: false });
+		}, 1500);
+		return () => {};
+	})),
+	isAppsInTossAdMobLoaded: withIsSupported(observe("GoogleAdMob.isAppsInTossAdMobLoaded", "faithful", async (_options) => {
+		if (_options?.adGroupId !== void 0 && _options.adGroupId.trim() === "") throw buildNativeError("INVALID_REQUEST");
+		return aitState.state.ads.isLoaded;
+	}))
+});
+const TossAds = createMockProxy("TossAds", {
+	initialize: withIsSupported(observe("TossAds.initialize", "partial", (options) => {
+		if (aitState.state.ads.forceNoFill) {
+			options.callbacks?.onInitializationFailed?.(/* @__PURE__ */ new Error("No fill"));
+			return;
+		}
+		options.callbacks?.onInitialized?.();
+	})),
+	attach: withIsSupported(observe("TossAds.attach", "partial", (_adGroupId, target, _options) => {
+		const el = typeof target === "string" ? document.querySelector(target) : target;
+		if (el) {
+			const placeholder = document.createElement("div");
+			placeholder.style.cssText = "background:#f0f0f0;border:1px dashed #999;padding:16px;text-align:center;color:#666;font-size:14px;";
+			placeholder.textContent = "[@apps-in-toss/devtools] TossAds Placeholder";
+			el.appendChild(placeholder);
+		}
+	})),
+	attachBanner: withIsSupported(observe("TossAds.attachBanner", "faithful", (adGroupId, target, options) => {
+		const el = typeof target === "string" ? document.querySelector(target) : target;
+		const slotId = _nextSlotId(adGroupId);
+		const placeholder = document.createElement("div");
+		const theme = options?.theme ?? "auto";
+		const variant = options?.variant ?? "card";
+		const isDark = theme === "dark" || theme === "auto" && typeof window !== "undefined" && window.matchMedia?.("(prefers-color-scheme: dark)").matches;
+		const bg = isDark ? "#1a1a1a" : "#f0f0f0";
+		const textColor = isDark ? "#aaa" : "#666";
+		const borderColor = isDark ? "#555" : "#999";
+		const height = variant === "expanded" ? "120px" : "60px";
+		placeholder.dataset.aitSlotId = slotId;
+		placeholder.style.cssText = `background:${bg};border:1px dashed ${borderColor};padding:8px 12px;text-align:center;color:${textColor};font-size:12px;min-height:${height};display:flex;align-items:center;justify-content:center;`;
+		placeholder.textContent = `[@apps-in-toss/devtools] Banner Ad (${variant})`;
+		if (el) {
+			el.appendChild(placeholder);
+			_slotRegistry.set(slotId, placeholder);
+		}
+		const destroySlot = () => {
+			const registered = _slotRegistry.get(slotId);
+			if (registered) {
+				registered.remove();
+				_slotRegistry.delete(slotId);
+			}
+		};
+		setTimeout(() => {
+			if (aitState.state.ads.forceNoFill) {
+				options?.callbacks?.onNoFill?.({
+					slotId,
+					adGroupId,
+					adMetadata: {}
+				});
+				options?.callbacks?.onAdFailedToRender?.({
+					slotId,
+					adGroupId,
+					adMetadata: {},
+					error: {
+						code: 0,
+						message: "No fill"
+					}
+				});
+				return;
+			}
+			const eventPayload = {
+				slotId,
+				adGroupId,
+				adMetadata: {
+					creativeId: `mock-creative-${slotId}`,
+					requestId: `mock-req-${slotId}`
+				}
+			};
+			options?.callbacks?.onAdRendered?.(eventPayload);
+			options?.callbacks?.onAdImpression?.(eventPayload);
+		}, 100);
+		return { destroy: destroySlot };
+	})),
+	destroy: withIsSupported(observe("TossAds.destroy", "faithful", (slotId) => {
+		const el = _slotRegistry.get(slotId);
+		if (el) {
+			el.remove();
+			_slotRegistry.delete(slotId);
+		}
+	})),
+	destroyAll: withIsSupported(observe("TossAds.destroyAll", "faithful", () => {
+		for (const el of _slotRegistry.values()) el.remove();
+		_slotRegistry.clear();
+	}))
+});
+const loadFullScreenAd = observe("loadFullScreenAd", "faithful", (args) => {
+	setTimeout(() => {
+		const failureCode = aitState.state.failureModes.loadFullScreenAd;
+		if (failureCode) {
+			args.onError(buildNativeError(failureCode));
+			return;
+		}
+		const throttleError = throttleErrorFor("loadFullScreenAd");
+		if (throttleError) {
+			args.onError(throttleError);
+			return;
+		}
+		if (aitState.state.ads.forceNoFill) {
+			args.onError(/* @__PURE__ */ new Error("No fill"));
+			return;
+		}
+		aitState.patch("ads", { isLoaded: true });
+		args.onEvent({ type: "loaded" });
+	}, 200);
+	return () => {};
+});
+const showFullScreenAd = withIsSupported(observe("showFullScreenAd", "faithful", (args) => {
+	if (!aitState.state.ads.isLoaded) {
+		args.onError(/* @__PURE__ */ new Error("Ad not loaded"));
+		return () => {};
+	}
+	setTimeout(() => args.onEvent({ type: "clicked" }), 100);
+	setTimeout(() => args.onEvent({ type: "dismissed" }), 1500);
+	return () => {};
+}));
+//#endregion
+//#region src/mock/analytics/index.ts
+/**
+* Analytics mock
+*/
+const Analytics = {
+	screen: (params) => {
+		aitState.logAnalytics({
+			type: "screen",
+			params: params ?? {}
+		});
+		return Promise.resolve(null);
+	},
+	impression: (params) => {
+		aitState.logAnalytics({
+			type: "impression",
+			params: params ?? {}
+		});
+		return Promise.resolve(null);
+	},
+	click: (params) => {
+		aitState.logAnalytics({
+			type: "click",
+			params: params ?? {}
+		});
+		return Promise.resolve(null);
+	}
+};
+async function eventLog(params) {
+	aitState.logAnalytics({
+		type: params.log_type,
+		params: {
+			log_name: params.log_name,
+			...params.params
+		}
+	});
+	return null;
+}
+//#endregion
+//#region src/mock/auth/index.ts
+/**
+* 인증/로그인 mock
+*/
+async function appLogin() {
+	const failureCode = aitState.state.failureModes.appLogin;
+	if (failureCode) throw buildNativeError(failureCode);
+	return {
+		authorizationCode: `mock-auth-${crypto.randomUUID()}`,
+		referrer: aitState.state.environment === "toss" ? "DEFAULT" : "SANDBOX"
+	};
+}
+async function getIsTossLoginIntegratedService() {
+	const failureCode = aitState.state.failureModes.getIsTossLoginIntegratedService;
+	if (failureCode) throw buildNativeError(failureCode);
+	return aitState.state.auth.isTossLoginIntegrated;
+}
+async function getUserKeyForGame() {
+	return {
+		hash: aitState.state.auth.userKeyHash ?? "",
+		type: "HASH"
+	};
+}
+async function getAnonymousKey() {
+	if (!aitState.state.auth.anonymousKeyHash) return void 0;
+	return {
+		hash: aitState.state.auth.anonymousKeyHash,
+		type: "HASH"
+	};
+}
+async function appsInTossSignTossCert(_params) {
+	console.log("[@apps-in-toss/devtools] appsInTossSignTossCert called (no-op in mock)");
+}
+/**
+* 사용자 동의 기반 데이터 mock (devtools#798 — env1에 배선 부재였던 실 export).
+*
+* SDK는 이 API를 `@apps-in-toss/web-bridge` 호환 export로 노출하며 2.x와 3.x GA
+* 양쪽 facade에서 제공한다. 선언 시그니처는 `Promise<Partial<Record<ConsentedUserDataKey, string>>
+* | undefined>` — appLogin과 같은 async bridge 모양이라 항상 resolve하는 낙관적
+* 패턴을 따른다.
+*
+* 어떤 키가 채워지는지는 콘솔에 등록된 동의문/데이터 묶음(`consentedUserDataKey`)에
+* 달려 있고 그 매핑은 서버 쪽 설정이라 mock이 알 수 없다 — 호출 파라미터와 무관하게
+* 상태에 저장된 최소 plausible 객체를 그대로 resolve한다. SDK 선언 밖의 필드는
+* 추가하지 않는다(devtools#783 — 실측/타입 밖 추정 금지).
+*/
+async function getConsentedUserData(_options) {
+	return aitState.state.auth.consentedUserData;
+}
+async function getDeclaredAgeRange(_params) {
+	return { ...aitState.state.auth.declaredAgeRange };
+}
+//#endregion
+//#region src/mock/iap/index.ts
+let orderCounter = 0;
+function generateOrderId() {
+	return `mock-order-${++orderCounter}-${Date.now()}`;
+}
+function buildOrderResult(sku) {
+	const product = aitState.state.iap.products.find((p) => p.sku === sku);
+	const amountStr = product?.displayAmount?.replace(/[^0-9]/g, "") ?? "1000";
+	return {
+		orderId: generateOrderId(),
+		displayName: product?.displayName ?? "Mock Product",
+		displayAmount: product?.displayAmount ?? "1,000원",
+		amount: parseInt(amountStr, 10) || 1e3,
+		currency: "KRW",
+		fraction: 0,
+		miniAppIconUrl: product?.iconUrl || null
+	};
+}
+async function handlePurchase(sku, processProductGrant, onEvent, onError) {
+	const nextResult = aitState.state.iap.nextResult;
+	await new Promise((r) => setTimeout(r, 300));
+	if (nextResult !== "success") {
+		onError({ code: nextResult });
+		return;
+	}
+	const result = buildOrderResult(sku);
+	try {
+		if (!await processProductGrant({ orderId: result.orderId })) {
+			onError({ code: "PRODUCT_NOT_GRANTED_BY_PARTNER" });
+			return;
+		}
+	} catch (e) {
+		onError(e);
+		return;
+	}
+	aitState.patch("iap", { completedOrders: [...aitState.state.iap.completedOrders, {
+		orderId: result.orderId,
+		sku,
+		status: "COMPLETED",
+		date: (/* @__PURE__ */ new Date()).toISOString()
+	}] });
+	await onEvent({
+		type: "success",
+		data: result
+	});
+}
+const IAP = createMockProxy("IAP", {
+	createOneTimePurchaseOrder(params) {
+		handlePurchase(params.options.sku ?? params.options.productId ?? "", params.options.processProductGrant, params.onEvent, params.onError).catch((e) => console.error("[@apps-in-toss/devtools] IAP unexpected error:", e));
+		return () => {};
+	},
+	createSubscriptionPurchaseOrder(params) {
+		handlePurchase(params.options.sku, params.options.processProductGrant, params.onEvent, params.onError).catch((e) => console.error("[@apps-in-toss/devtools] IAP unexpected error:", e));
+		return () => {};
+	},
+	async getProductItemList() {
+		return { products: aitState.state.iap.products.map((p) => ({
+			...p,
+			...p.type === "SUBSCRIPTION" ? { renewalCycle: p.renewalCycle ?? "MONTHLY" } : {}
+		})) };
+	},
+	async getPendingOrders() {
+		const orders = [...aitState.state.iap.pendingOrders];
+		return {
+			orders,
+			orderIds: orders.map((o) => o.orderId)
+		};
+	},
+	async getCompletedOrRefundedOrders() {
+		return {
+			hasNext: false,
+			orders: [...aitState.state.iap.completedOrders]
+		};
+	},
+	async completeProductGrant(args) {
+		const idx = aitState.state.iap.pendingOrders.findIndex((o) => o.orderId === args.params.orderId);
+		if (idx !== -1) {
+			const order = aitState.state.iap.pendingOrders[idx];
+			const pendingOrders = aitState.state.iap.pendingOrders.filter((_, i) => i !== idx);
+			const completedOrders = [...aitState.state.iap.completedOrders, {
+				orderId: order.orderId,
+				sku: order.sku,
+				status: "COMPLETED",
+				date: (/* @__PURE__ */ new Date()).toISOString()
+			}];
+			aitState.patch("iap", {
+				pendingOrders,
+				completedOrders
+			});
+		}
+		return true;
+	},
+	async getSubscriptionInfo(_args) {
+		if (aitState.state.failureModes.softResolve?.getSubscriptionInfo) return {};
+		return { subscription: {
+			catalogId: 1,
+			status: "ACTIVE",
+			expiresAt: new Date(Date.now() + 720 * 60 * 60 * 1e3).toISOString(),
+			isAutoRenew: true,
+			gracePeriodExpiresAt: null,
+			isAccessible: true
+		} };
+	}
+});
+async function checkoutPayment(options) {
+	const { nextResult, failReason } = aitState.state.payment;
+	console.log("[@apps-in-toss/devtools] checkoutPayment:", options.params.payToken);
+	if (aitState.state.failureModes.softResolve?.checkoutPayment) return {
+		false: "PAYMENT_FAILED",
+		reason: "mock soft-resolve (env3 unprovisioned)"
+	};
+	await new Promise((r) => setTimeout(r, 300));
+	if (nextResult === "success") return { success: true };
+	return {
+		success: false,
+		reason: failReason || "Mock payment failed"
+	};
+}
+const requestTossPayPaysBilling = Object.assign(async function requestTossPayPaysBilling(options) {
+	const { nextResult, failReason } = aitState.state.payment;
+	console.log("[@apps-in-toss/devtools] requestTossPayPaysBilling:", options.params.wrappedToken);
+	if (aitState.state.failureModes.softResolve?.requestTossPayPaysBilling) return {
+		false: "BILLING_FAILED",
+		reason: "mock soft-resolve (env3 unprovisioned)"
+	};
+	await new Promise((r) => setTimeout(r, 300));
+	if (nextResult === "success") return { success: true };
+	return {
+		success: false,
+		reason: failReason || "Mock billing auth failed"
+	};
+}, { isSupported: () => true });
+//#endregion
+//#region src/mock/bridge-factories.ts
+/** Generic bridge escape hatches exposed by both SDK lines. */
+const asyncBridgeRegistry = {
+	appLogin,
+	appsInTossSignTossCert,
+	checkoutPayment,
+	closeView,
+	generateHapticFeedback,
+	getAnonymousKey,
+	getConsentedUserData,
+	getDeclaredAgeRange,
+	getNetworkStatus,
+	getServerTime,
+	openPDFViewer,
+	openURL,
+	requestReview,
+	saveBase64Data,
+	share
+};
+function createAsyncBridge(method) {
+	return async (...args) => {
+		const fn = asyncBridgeRegistry[method];
+		if (!fn) throw new Error(`@apps-in-toss/devtools: unknown async bridge method "${method}"`);
+		return await fn(...args);
+	};
+}
+function createConstantBridge(name) {
+	return () => {
+		const constants = {
+			deploymentId: aitState.state.deploymentId,
+			deviceId: aitState.state.deviceId,
+			groupId: aitState.state.groupId,
+			locale: aitState.state.locale,
+			operationalEnvironment: aitState.state.environment,
+			platformOS: aitState.state.platform,
+			safeAreaInsets: { ...aitState.state.safeAreaInsets },
+			schemeUri: aitState.state.schemeUri || window.location.pathname,
+			tossAppVersion: aitState.state.appVersion
+		};
+		if (!(name in constants)) throw new Error(`@apps-in-toss/devtools: unknown constant bridge "${name}"`);
+		return constants[name];
+	};
+}
+function createEventBridge(method) {
+	return (args) => {
+		if (method === "onVisibilityChangedByTransparentServiceWeb") return onVisibilityChangedByTransparentServiceWeb({
+			options: args.options,
+			onEvent: args.onEvent,
+			onError: (error) => args.onError(error instanceof Error ? error : new Error(String(error)))
+		});
+		throw new Error(`@apps-in-toss/devtools: unknown event bridge method "${method}"`);
+	};
+}
+//#endregion
+//#region src/mock/game/index.ts
+async function grantPromotionReward(params) {
+	console.log("[@apps-in-toss/devtools] grantPromotionReward:", params.params);
+	if (aitState.state.failureModes.softResolve?.grantPromotionReward) return {
+		errorCode: "PROMOTION_NOT_FOUND",
+		message: "no active promotion"
+	};
+	return { key: `mock-reward-${Date.now()}` };
+}
+async function grantPromotionRewardForGame(params) {
+	console.log("[@apps-in-toss/devtools] grantPromotionRewardForGame:", params.params);
+	if (aitState.state.failureModes.softResolve?.grantPromotionRewardForGame) return {
+		errorCode: "PROMOTION_NOT_FOUND",
+		message: "no active promotion"
+	};
+	return { key: `mock-reward-${Date.now()}` };
+}
+async function submitGameCenterLeaderBoardScore(params) {
+	aitState.patch("game", { leaderboardScores: [...aitState.state.game.leaderboardScores, {
+		score: params.score,
+		timestamp: Date.now()
+	}] });
+	return { statusCode: "SUCCESS" };
+}
+async function getGameCenterGameProfile() {
+	const profile = aitState.state.game.profile;
+	if (!profile) return { statusCode: "PROFILE_NOT_FOUND" };
+	return {
+		statusCode: "SUCCESS",
+		gameSessionId: "mock-session",
+		nickname: profile.nickname,
+		profileImageUri: profile.profileImageUri
+	};
+}
+async function openGameCenterLeaderboard() {
+	console.log("[@apps-in-toss/devtools] openGameCenterLeaderboard (no-op in browser)");
+}
+function contactsViral(params) {
+	setTimeout(() => {
+		params.onEvent({
+			type: "close",
+			data: {
+				closeReason: "noReward",
+				sentRewardsCount: 0
+			}
+		});
+	}, 500);
+	return () => {};
+}
+//#endregion
+//#region src/mock/notification.ts
+/**
+* 알림 동의 mock
+*
+* 상류 SDK 타입 선언은 `requestNotificationAgreement(params)`이 callback-style로
+* 즉시 cancel 함수를 반환한다고 선언하지만, 실기기(2.x×iOS) capture는 반환값이
+* 함수가 아니라 **object**임을 보였다(devtools#806 — env3 재캡처, "Expected
+* function, received object" 단언 실패 2건: happy-default cancel 단언 +
+* A1-빈-templateCode 단언, 동일 원인 이중 측정). object의 내부 shape은 이번
+* run에서 미기록(단언이 "function인가"에서 끊겨 뒤 관측이 안 남음).
+*
+* mock은 #775 원칙대로 선언 타입은 상류와 동일하게 두고(`__typecheck.ts`/
+* `__typecheck-2x.ts`가 계속 컴파일되도록) 반환값만 실측 있는 수준까지
+* 캐스트한다 — 1차 착수는 "함수가 아니라 object"까지만, shape은 과잉 발명하지
+* 않는다(#783 "측정 밖 확장 금지"). 다음 재캡처에서 object keys가 잡히면 그때
+* shape을 채운다.
+*
+* 결과는 panel(Notifications 탭)이 토글한
+* `aitState.state.notification.nextResult`를 그대로 사용한다.
+*
+* `agreementRejected`도 정상 결과의 한 종류이므로 `onEvent`로 전달한다.
+* `onError`는 `onEvent` 호출 자체가 throw할 때만 들어간다 (실제 SDK도 reject를
+* error가 아닌 event type으로 표현한다).
+*/
+const _requestNotificationAgreementImpl = (params) => {
+	Promise.resolve().then(async () => {
+		const failureCode = aitState.state.failureModes.requestNotificationAgreement;
+		if (failureCode) {
+			await params.onError(buildNativeError(failureCode));
+			return;
+		}
+		const type = aitState.state.notification.nextResult;
+		console.log("[@apps-in-toss/devtools] requestNotificationAgreement:", params.options.templateCode, "→", type);
+		try {
+			params.onEvent({ type });
+		} catch (e) {
+			await params.onError(e);
+		}
+	});
+	return {};
+};
+const requestNotificationAgreement = Object.assign(_requestNotificationAgreementImpl, { isSupported: () => true });
+//#endregion
+//#region src/mock/partner/index.ts
+const partner = {
+	async addAccessoryButton(options) {
+		console.log("[@apps-in-toss/devtools] partner.addAccessoryButton:", options);
+	},
+	async removeAccessoryButton() {
+		console.log("[@apps-in-toss/devtools] partner.removeAccessoryButton");
+	}
+};
+//#endregion
+//#region src/mock/preset-store.ts
+const PREFIX = "__ait_preset:";
+function safeLocalStorage() {
+	try {
+		if (typeof localStorage === "undefined") return null;
+		return localStorage;
+	} catch {
+		return null;
+	}
+}
+function isObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Storage에서 읽은 임의 JSON을 MockPreset으로 검증. id/label 필수, state는
+* object여야 함. 실패하면 null — caller가 storage entry를 무시하거나 정리하면 된다.
+*
+* `state`의 내부 키/값은 검증하지 않는다. `applyPreset`이 `pickKnownKeys`로
+* 키만 거른 뒤 그대로 state에 패치하므로 잘못된 enum 값이 통과될 수 있지만,
+* mock state라 보안 위협은 없다 — 새 enum 값이 추가됐을 때 저장된 preset을
+* reject하지 않으려는 의도.
+*/
+function parsePreset(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!isObject(parsed)) return null;
+		const { id, label, description, state } = parsed;
+		if (typeof id !== "string" || id.length === 0) return null;
+		if (typeof label !== "string" || label.length === 0) return null;
+		if (!isObject(state)) return null;
+		return {
+			id,
+			label,
+			description: typeof description === "string" ? description : void 0,
+			state
+		};
+	} catch {
+		return null;
+	}
+}
+function listUserPresets() {
+	const ls = safeLocalStorage();
+	if (!ls) return [];
+	const out = [];
+	for (let i = 0; i < ls.length; i++) {
+		const key = ls.key(i);
+		if (!key?.startsWith(PREFIX)) continue;
+		const raw = ls.getItem(key);
+		if (!raw) continue;
+		const preset = parsePreset(raw);
+		if (preset) out.push(preset);
+	}
+	return out.sort((a, b) => a.label.localeCompare(b.label));
+}
+/**
+* Preset을 저장한다. label에서 slug를 derive — 같은 slug가 이미 있으면 `-2`, `-3`
+* suffix를 붙여 새 entry를 만든다 (기존 entry 덮어쓰기 아님). UI는 label만 받으면 된다.
+*
+* Throws:
+* - label trim한 뒤 빈 문자열일 때
+* - localStorage 미가용 환경일 때 (SSR 등)
+* - `setItem` 실패 (`QuotaExceededError` 등) — caller가 처리해야 함
+*/
+function saveUserPreset(label, state, description) {
+	const trimmed = label.trim();
+	if (trimmed.length === 0) throw new Error("Preset label cannot be empty");
+	const ls = safeLocalStorage();
+	if (!ls) throw new Error("localStorage not available");
+	const id = generateId(trimmed, ls);
+	const preset = {
+		id,
+		label: trimmed,
+		state,
+		...description !== void 0 && description.length > 0 ? { description } : {}
+	};
+	ls.setItem(PREFIX + id, JSON.stringify(preset));
+	return preset;
+}
+function deleteUserPreset(id) {
+	const ls = safeLocalStorage();
+	if (!ls) return;
+	ls.removeItem(PREFIX + id);
+}
+/** 충돌 시 `-2`, `-3` 등 suffix를 붙여 unique한 id 만든다. */
+function generateId(label, ls) {
+	const base = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "preset";
+	let candidate = base;
+	let n = 2;
+	while (ls.getItem(PREFIX + candidate) !== null) {
+		candidate = `${base}-${n}`;
+		n += 1;
+	}
+	return candidate;
+}
+//#endregion
+//#region src/mock/presets.ts
+const builtInPresets = [
+	{
+		id: "all-allowed",
+		label: "All allowed (default-ish)",
+		description: "모든 권한 허용, WIFI, 로그인됨, IAP success",
+		state: {
+			networkStatus: "WIFI",
+			permissions: {
+				camera: "allowed",
+				photos: "allowed",
+				geolocation: "allowed",
+				clipboard: "allowed",
+				contacts: "allowed",
+				microphone: "allowed"
+			},
+			auth: { isLoggedIn: true },
+			iap: { nextResult: "success" },
+			ads: { forceNoFill: false },
+			payment: {
+				nextResult: "success",
+				failReason: ""
+			}
+		}
+	},
+	{
+		id: "permission-denied",
+		label: "Permissions denied",
+		description: "camera / photos / geolocation / contacts 거부",
+		state: { permissions: {
+			camera: "denied",
+			photos: "denied",
+			geolocation: "denied",
+			contacts: "denied"
+		} }
+	},
+	{
+		id: "offline",
+		label: "Offline",
+		description: "getNetworkStatus → OFFLINE, IAP NETWORK_ERROR",
+		state: {
+			networkStatus: "OFFLINE",
+			iap: { nextResult: "NETWORK_ERROR" },
+			payment: {
+				nextResult: "fail",
+				failReason: "NETWORK_ERROR"
+			}
+		}
+	},
+	{
+		id: "logged-out",
+		label: "Logged out",
+		description: "auth.isLoggedIn=false. login flow 검증용",
+		state: { auth: { isLoggedIn: false } }
+	},
+	{
+		id: "iap-pending",
+		label: "IAP payment pending",
+		description: "결제 진행 중 분기 검증",
+		state: { iap: { nextResult: "PAYMENT_PENDING" } }
+	},
+	{
+		id: "ads-no-fill",
+		label: "Ads — no fill",
+		description: "광고 fill 실패 분기 검증",
+		state: {
+			networkStatus: "WIFI",
+			ads: { forceNoFill: true }
+		}
+	}
+];
+/**
+* Preset의 nested slice를 검증된 키만 골라서 풀어낸다. Forward-compat 차원에서
+* 알지 못하는 키는 drop, drop된 키 전부를 모아 한 번에 warn한다.
+*
+* Value 단위 검증은 하지 않는다 — `permissions.camera`에 enum 외 값이 들어와도
+* 그대로 통과한다. mock state라 잘못된 값은 mock 함수 분기 결과만 흔든다.
+* 새 enum 값이 추가됐을 때 저장된 preset을 reject하지 않으려는 의도.
+*/
+function pickKnownKeys(input, allowed) {
+	if (typeof input !== "object" || input === null) return {};
+	const out = {};
+	const dropped = [];
+	for (const [key, value] of Object.entries(input)) if (allowed.includes(key)) out[key] = value;
+	else dropped.push(key);
+	if (dropped.length > 0) console.warn(`[@apps-in-toss/devtools] Preset dropped unknown keys: ${dropped.join(", ")}`);
+	return out;
+}
+const PERMISSION_KEYS = [
+	"camera",
+	"photos",
+	"geolocation",
+	"clipboard",
+	"contacts",
+	"microphone"
+];
+const AUTH_KEYS = [
+	"isLoggedIn",
+	"isTossLoginIntegrated",
+	"userKeyHash"
+];
+const IAP_KEYS = ["nextResult"];
+const ADS_KEYS = [
+	"isLoaded",
+	"nextEvent",
+	"forceNoFill",
+	"lastEvent"
+];
+const PAYMENT_KEYS = ["nextResult", "failReason"];
+/**
+* Preset state를 현재 `aitState`에 적용한다. 정의된 키만 덮어쓰고, 알지 못하는 키는
+* 조용히 drop한다 (한 번 warn). 여러 슬라이스를 적용해도 listener notify는 한 번이다
+* (`aitState.transaction` 사용 — panel re-render 폭주 방지).
+*/
+function applyPreset(state) {
+	aitState.transaction(() => {
+		if (state.networkStatus !== void 0) aitState.update({ networkStatus: state.networkStatus });
+		if (state.permissions !== void 0) aitState.patch("permissions", pickKnownKeys(state.permissions, PERMISSION_KEYS));
+		if (state.auth !== void 0) aitState.patch("auth", pickKnownKeys(state.auth, AUTH_KEYS));
+		if (state.iap !== void 0) {
+			const picked = pickKnownKeys(state.iap, IAP_KEYS);
+			aitState.patch("iap", picked);
+		}
+		if (state.ads !== void 0) aitState.patch("ads", pickKnownKeys(state.ads, ADS_KEYS));
+		if (state.payment !== void 0) aitState.patch("payment", pickKnownKeys(state.payment, PAYMENT_KEYS));
+	});
+}
+/**
+* Preset의 모든 정의된 슬라이스가 현재 state와 일치하는지 검사. UI에서 dirty
+* indicator를 그릴 때 쓴다.
+*
+* 일치한다 = preset이 정의한 키 전부가 그대로다. preset이 정의하지 않은 키는
+* 비교 대상이 아니다 — preset은 partial이므로 다른 토글이 바뀌어도 dirty가 아니다.
+*/
+function matchesPreset(snapshot, preset) {
+	if (preset.networkStatus !== void 0 && snapshot.networkStatus !== preset.networkStatus) return false;
+	if (preset.permissions !== void 0) for (const k of PERMISSION_KEYS) {
+		const want = preset.permissions[k];
+		if (want !== void 0 && snapshot.permissions[k] !== want) return false;
+	}
+	if (preset.auth !== void 0) for (const k of AUTH_KEYS) {
+		const want = preset.auth[k];
+		if (want !== void 0 && snapshot.auth[k] !== want) return false;
+	}
+	if (preset.iap !== void 0) {
+		if (preset.iap.nextResult !== void 0 && snapshot.iap.nextResult !== preset.iap.nextResult) return false;
+	}
+	if (preset.ads !== void 0) {
+		if (preset.ads.forceNoFill !== void 0 && snapshot.ads.forceNoFill !== preset.ads.forceNoFill) return false;
+		if (preset.ads.isLoaded !== void 0 && snapshot.ads.isLoaded !== preset.ads.isLoaded) return false;
+		if (preset.ads.nextEvent !== void 0 && snapshot.ads.nextEvent !== preset.ads.nextEvent) return false;
+	}
+	if (preset.payment !== void 0) for (const k of PAYMENT_KEYS) {
+		const want = preset.payment[k];
+		if (want !== void 0 && snapshot.payment[k] !== want) return false;
+	}
+	return true;
+}
+/**
+* 현재 state에서 preset에 저장할 만한 슬라이스를 추출. "save current as preset"에서 쓴다.
+*/
+function captureCurrentState(snapshot) {
+	return {
+		networkStatus: snapshot.networkStatus,
+		permissions: { ...snapshot.permissions },
+		auth: {
+			isLoggedIn: snapshot.auth.isLoggedIn,
+			isTossLoginIntegrated: snapshot.auth.isTossLoginIntegrated,
+			userKeyHash: snapshot.auth.userKeyHash
+		},
+		iap: { nextResult: snapshot.iap.nextResult },
+		ads: {
+			forceNoFill: snapshot.ads.forceNoFill,
+			isLoaded: snapshot.ads.isLoaded,
+			nextEvent: snapshot.ads.nextEvent
+		},
+		payment: { ...snapshot.payment }
+	};
+}
+//#endregion
+//#region src/mock/index.ts
+/**
+* @apps-in-toss/devtools/mock
+*
+* @apps-in-toss/web-framework의 모든 export를 mock으로 대체한다.
+* 번들러 alias로 원본 대신 이 모듈이 resolve된다.
+*/
+installBridges();
+//#endregion
+export { Accuracy, Analytics, FetchAlbumPhotosPermissionError, FetchContactsPermissionError, GetClipboardTextPermissionError, GetCurrentLocationPermissionError, GoogleAdMob, IAP, NAVIGATE_BACK_MESSAGE_TYPE, OpenCameraPermissionError, PermissionError, SAFE_AREA_INSETS_MESSAGE_TYPE, SafeAreaInsets, SetClipboardTextPermissionError, StartUpdateLocationPermissionError, Storage, TossAds, WEB_VIEW_TYPE_MESSAGE_TYPE, aitState, appLogin, applyForwardedSafeAreaInsets, applyPreset, appsInTossEvent, appsInTossSignTossCert, builtInPresets, captureCurrentState, checkoutPayment, closeView, contactsViral, createAsyncBridge, createConstantBridge, createEventBridge, deleteUserPreset, env, eventLog, fetchAlbumItems, fetchAlbumPhotos, fetchContacts, generateHapticFeedback, getAnonymousKey, getAppsInTossGlobals, getClipboardText, getConsentedUserData, getCurrentLocation, getDeclaredAgeRange, getDefaultPlaceholderImages, getDeviceId, getGameCenterGameProfile, getGroupId, getIsTossLoginIntegratedService, getLocale, getNetworkStatus, getOperationalEnvironment, getPermission, getPlatformOS, getSafeAreaInsets, getSchemeUri, getServerTime, getTossAppVersion, getTossShareLink, getUserKeyForGame, graniteEvent, grantPromotionReward, grantPromotionRewardForGame, installBridges, installNavigateBackBridge, installSafeAreaInsetsBridge, isMinVersionSupported, isNavigateBackMessage, listUserPresets, loadFullScreenAd, matchesPreset, onVisibilityChangedByTransparentServiceWeb, openCamera, openGameCenterLeaderboard, openPDFViewer, openPermissionDialog, openURL, parseSafeAreaInsetsMessage, parseWebViewTypeMessage, partner, requestNotificationAgreement, requestPermission, requestReview, requestTossPayPaysBilling, saveBase64Data, saveUserPreset, setClipboardText, setDeviceOrientation, setIosSwipeGestureEnabled, setScreenAwakeMode, setSecureScreen, share, showFullScreenAd, startUpdateLocation, submitGameCenterLeaderBoardScore, tdsEvent };