@mks2508/bundlp 0.1.6 → 0.1.7

package/dist/index.mjs

@@ -457,7 +457,7 @@ function isDrmOnly(formats) {
 
 //#endregion
 //#region src/innertube/client.ts
-const log = logger.scope("InnerTube");
+const log$5 = logger.scope("InnerTube");
 /**
 * Client for interacting with YouTube's InnerTube API.
 */
@@ -521,7 +521,7 @@ var InnerTubeClient = class {
 	*/
 	async fetchPlayer(videoId, options = {}) {
 		const config = INNERTUBE_CLIENTS[this.currentClient];
-		log.debug(`Fetching player for ${videoId} with client ${this.currentClient}`);
+		log$5.debug(`Fetching player for ${videoId} with client ${this.currentClient}`);
 		const payload = {
 			context: this.buildContext(),
 			videoId,
@@ -532,45 +532,45 @@ var InnerTubeClient = class {
 		if (options.poToken) {
 			if (!payload.serviceIntegrityDimensions) payload.serviceIntegrityDimensions = {};
 			payload.serviceIntegrityDimensions.poToken = options.poToken;
-			log.debug(`Using po_token (length: ${options.poToken.length})`);
+			log$5.debug(`Using po_token (length: ${options.poToken.length})`);
 		}
 		const url = `${INNER_TUBE_API_URL}/player?key=${config.API_KEY || ""}`;
 		const responseResult = await httpClient.post(url, payload, { headers: this.getHeaders() });
 		if (isErr(responseResult)) {
-			log.error(`HTTP request failed for client ${this.currentClient}:`, responseResult.error.message);
+			log$5.error(`HTTP request failed for client ${this.currentClient}:`, responseResult.error.message);
 			return responseResult;
 		}
 		const response = responseResult.value;
 		if (!response.ok) {
-			log.error(`Player request failed for ${this.currentClient}: HTTP ${response.status}`);
+			log$5.error(`Player request failed for ${this.currentClient}: HTTP ${response.status}`);
 			return err(createError("INNERTUBE_ERROR", `Player request failed with status ${response.status}`));
 		}
 		try {
 			const validated = PlayerResponseSchema(await response.json());
 			if (validated instanceof type.errors) {
-				log.error(`Parse error for ${this.currentClient}:`, validated.summary);
+				log$5.error(`Parse error for ${this.currentClient}:`, validated.summary);
 				return err(createError("PARSE_ERROR", `Invalid player response: ${validated.summary}`));
 			}
 			const status = validated.playabilityStatus.status;
 			const reason = validated.playabilityStatus.reason || "No reason";
-			log.debug(`Client ${this.currentClient} response: status=${status}, reason=${reason}`);
+			log$5.debug(`Client ${this.currentClient} response: status=${status}, reason=${reason}`);
 			if (status === "ERROR") {
-				log.warn(`Client ${this.currentClient} returned ERROR: ${reason}`);
+				log$5.warn(`Client ${this.currentClient} returned ERROR: ${reason}`);
 				return err(createError("VIDEO_UNAVAILABLE", reason));
 			}
 			if (status === "LOGIN_REQUIRED") {
-				log.warn(`Client ${this.currentClient} requires login: ${reason}`);
+				log$5.warn(`Client ${this.currentClient} requires login: ${reason}`);
 				return err(createError("VIDEO_UNAVAILABLE", `Login required: ${reason}`));
 			}
 			if (status === "UNPLAYABLE") {
-				log.warn(`Client ${this.currentClient} unplayable: ${reason}`);
+				log$5.warn(`Client ${this.currentClient} unplayable: ${reason}`);
 				return err(createError("VIDEO_UNAVAILABLE", `Unplayable: ${reason}`));
 			}
 			const formatsCount = (validated.streamingData?.formats?.length || 0) + (validated.streamingData?.adaptiveFormats?.length || 0);
-			log.info(`Client ${this.currentClient} success: ${formatsCount} formats`);
+			log$5.info(`Client ${this.currentClient} success: ${formatsCount} formats`);
 			return ok(validated);
 		} catch (error) {
-			log.error(`Parse exception for ${this.currentClient}:`, error);
+			log$5.error(`Parse exception for ${this.currentClient}:`, error);
 			return err(createError("PARSE_ERROR", "Failed to parse InnerTube response", error));
 		}
 	}
@@ -583,35 +583,35 @@ var InnerTubeClient = class {
 	*/
 	async fetchPlayerWithFallback(videoId, options = {}) {
 		const errors = [];
-		log.info(`Starting fallback extraction for ${videoId}`);
-		log.info(`Fallback order: ${this.FALLBACK_ORDER.join(" → ")}`);
+		log$5.info(`Starting fallback extraction for ${videoId}`);
+		log$5.info(`Fallback order: ${this.FALLBACK_ORDER.join(" → ")}`);
 		for (const clientName of this.FALLBACK_ORDER) {
-			log.info(`Trying client: ${clientName}`);
+			log$5.info(`Trying client: ${clientName}`);
 			if (isErr(this.setClient(clientName))) {
-				log.warn(`Failed to set client ${clientName}`);
+				log$5.warn(`Failed to set client ${clientName}`);
 				continue;
 			}
 			const result = await this.fetchPlayer(videoId, options);
 			if (isOk(result)) {
 				const validationResult = this.isValidResponse(result.value);
 				if (validationResult.valid) {
-					log.success(`Client ${clientName} returned valid response`);
+					log$5.success(`Client ${clientName} returned valid response`);
 					return result;
 				}
-				log.warn(`Client ${clientName} response invalid: ${validationResult.reason}`);
+				log$5.warn(`Client ${clientName} response invalid: ${validationResult.reason}`);
 				errors.push({
 					client: clientName,
 					error: createError("VIDEO_UNAVAILABLE", validationResult.reason)
 				});
 			} else {
-				log.warn(`Client ${clientName} failed: ${result.error.message}`);
+				log$5.warn(`Client ${clientName} failed: ${result.error.message}`);
 				errors.push({
 					client: clientName,
 					error: result.error
 				});
 			}
 		}
-		log.error(`All clients failed for ${videoId}. Errors:`, errors.map((e) => ({
+		log$5.error(`All clients failed for ${videoId}. Errors:`, errors.map((e) => ({
 			client: e.client,
 			error: e.error.message
 		})));
@@ -2385,6 +2385,7 @@ const PO_TOKEN_POLICIES = {
 
 //#endregion
 //#region src/po-token/botguard/challenge.ts
+const log$4 = logger.scope("ChallengeFetcher");
 const WAA_CREATE_ENDPOINT = "https://jnn-pa.googleapis.com/$rpc/google.internal.waa.v1.Waa/Create";
 const INNERTUBE_ATT_ENDPOINT = "https://www.youtube.com/youtubei/v1/att/get";
 const GOOG_API_KEY$1 = "AIzaSyDyT5W0Jh49F30Pqqtyfdf7pDLFKLJoAnw";
@@ -2395,6 +2396,7 @@ var ChallengeFetcher = class {
 		this.timeout = options.timeout ?? 15e3;
 	}
 	async fetchAttestation() {
+		log$4.info(`Fetching attestation from ${INNERTUBE_ATT_ENDPOINT}`);
 		const payload = { context: { client: {
 			clientName: "WEB",
 			clientVersion: "2.20250222.10.00",
@@ -2402,6 +2404,7 @@ var ChallengeFetcher = class {
 			gl: "US"
 		} } };
 		try {
+			log$4.debug("Sending POST request...");
 			const response = await fetch(INNERTUBE_ATT_ENDPOINT, {
 				method: "POST",
 				headers: {
@@ -2413,11 +2416,22 @@ var ChallengeFetcher = class {
 				body: JSON.stringify(payload),
 				signal: AbortSignal.timeout(this.timeout)
 			});
-			if (!response.ok) return err(createError("BOTGUARD_INIT_FAILED", `Attestation request failed with status ${response.status}`));
+			log$4.debug(`Response status: ${response.status}`);
+			if (!response.ok) {
+				log$4.error(`Attestation request failed with status ${response.status}`);
+				return err(createError("BOTGUARD_INIT_FAILED", `Attestation request failed with status ${response.status}`));
+			}
 			const data = await response.json();
-			return this.parseAttestationResponse(data);
+			log$4.debug("Parsing attestation response...");
+			const result = this.parseAttestationResponse(data);
+			if (result.ok) log$4.success(`Attestation fetched successfully (visitorData length: ${result.value.visitorData.length})`);
+			return result;
 		} catch (error) {
-			if (error instanceof Error && error.name === "TimeoutError") return err(createError("BOTGUARD_INIT_FAILED", "Attestation fetch timeout"));
+			if (error instanceof Error && error.name === "TimeoutError") {
+				log$4.error(`Attestation fetch timeout after ${this.timeout}ms`);
+				return err(createError("BOTGUARD_INIT_FAILED", "Attestation fetch timeout"));
+			}
+			log$4.error("Failed to fetch attestation", error);
 			return err(createError("BOTGUARD_INIT_FAILED", "Failed to fetch attestation", error));
 		}
 	}
@@ -2437,7 +2451,9 @@ var ChallengeFetcher = class {
 		});
 	}
 	async fetchWaaChallenge() {
+		log$4.info(`Fetching WAA challenge from ${WAA_CREATE_ENDPOINT}`);
 		try {
+			log$4.debug("Sending POST request with API key...");
 			const response = await fetch(WAA_CREATE_ENDPOINT, {
 				method: "POST",
 				headers: {
@@ -2447,12 +2463,26 @@ var ChallengeFetcher = class {
 				body: JSON.stringify([REQUEST_KEY$1]),
 				signal: AbortSignal.timeout(this.timeout)
 			});
-			if (!response.ok) return err(createError("BOTGUARD_INIT_FAILED", `WAA Create request failed with status ${response.status}`));
+			log$4.debug(`Response status: ${response.status}`);
+			if (!response.ok) {
+				log$4.error(`WAA Create request failed with status ${response.status}`);
+				return err(createError("BOTGUARD_INIT_FAILED", `WAA Create request failed with status ${response.status}`));
+			}
 			const encoded = (await response.json())[1];
-			if (!encoded || typeof encoded !== "string") return err(createError("PARSE_ERROR", "Invalid WAA response format"));
-			return this.descrambleWaaResponse(encoded);
+			if (!encoded || typeof encoded !== "string") {
+				log$4.error("Invalid WAA response format - missing encoded data");
+				return err(createError("PARSE_ERROR", "Invalid WAA response format"));
+			}
+			log$4.debug(`Descrambling WAA response (encoded length: ${encoded.length})...`);
+			const result = this.descrambleWaaResponse(encoded);
+			if (result.ok) log$4.success(`WAA challenge descrambled (program: ${result.value.program.length} bytes, globalName: ${result.value.globalName})`);
+			return result;
 		} catch (error) {
-			if (error instanceof Error && error.name === "TimeoutError") return err(createError("BOTGUARD_INIT_FAILED", "WAA Create fetch timeout"));
+			if (error instanceof Error && error.name === "TimeoutError") {
+				log$4.error(`WAA Create fetch timeout after ${this.timeout}ms`);
+				return err(createError("BOTGUARD_INIT_FAILED", "WAA Create fetch timeout"));
+			}
+			log$4.error("Failed to fetch WAA challenge", error);
 			return err(createError("BOTGUARD_INIT_FAILED", "Failed to fetch WAA challenge", error));
 		}
 	}
@@ -2493,6 +2523,7 @@ var ChallengeFetcher = class {
 
 //#endregion
 //#region src/po-token/botguard/client.ts
+const log$3 = logger.scope("BotGuardClient");
 var DeferredPromise = class {
 	promise;
 	resolve;
@@ -2520,13 +2551,21 @@ var BotGuardClient = class BotGuardClient {
 		this.snapshotTimeout = 5e3;
 	}
 	static async create(challenge, options = {}) {
+		log$3.info("Creating BotGuard client...");
+		log$3.debug(`Options: timeout=${options.timeout || "default"}`);
 		const client = new BotGuardClient(challenge, options);
 		const loadResult = await client.load(challenge);
-		if (!isOk(loadResult)) return loadResult;
+		if (!isOk(loadResult)) {
+			log$3.error("Client creation failed", loadResult.error);
+			return loadResult;
+		}
+		log$3.success("BotGuard client created successfully");
 		return ok(client);
 	}
 	async load(challenge) {
+		log$3.debug("Loading BotGuard VM environment...");
 		try {
+			log$3.debug("Creating JSDOM instance with YouTube context");
 			this.dom = new JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", {
 				url: "https://www.youtube.com/",
 				runScripts: "dangerously",
@@ -2543,15 +2582,25 @@ var BotGuardClient = class BotGuardClient {
 			window.Request = globalThis.Request;
 			window.Response = globalThis.Response;
 			window.Headers = globalThis.Headers;
+			log$3.debug(`Evaluating interpreter script (${challenge.interpreterScript.length} bytes)...`);
 			const evalFn = window.eval;
 			evalFn(challenge.interpreterScript);
 			this.vm = window[this.globalName];
-			if (!this.vm) return err(createError("BOTGUARD_INIT_FAILED", `VM not found at globalName: ${this.globalName}`));
-			if (typeof this.vm.a !== "function") return err(createError("BOTGUARD_INIT_FAILED", "VM init function (a) not found"));
+			if (!this.vm) {
+				log$3.error(`VM not found at globalName: ${this.globalName}`);
+				return err(createError("BOTGUARD_INIT_FAILED", `VM not found at globalName: ${this.globalName}`));
+			}
+			if (typeof this.vm.a !== "function") {
+				log$3.error("VM init function (a) not found");
+				return err(createError("BOTGUARD_INIT_FAILED", "VM init function (a) not found"));
+			}
+			log$3.debug("Loading BotGuard program...");
 			const loadResult = await this.loadProgram();
 			if (!isOk(loadResult)) return loadResult;
+			log$3.success("BotGuard VM loaded successfully");
 			return ok(void 0);
 		} catch (error) {
+			log$3.error("Failed to load BotGuard", error);
 			return err(createError("BOTGUARD_INIT_FAILED", `Failed to load BotGuard: ${error.message}`, error));
 		}
 	}
@@ -2607,6 +2656,7 @@ var BotGuardClient = class BotGuardClient {
 		}
 	}
 	async snapshotWithSignalOutput(binding) {
+		log$3.info("Generating snapshot with signal output...");
 		const webPoSignalOutput = [];
 		const snapshotArgs = [
 			binding,
@@ -2616,10 +2666,17 @@ var BotGuardClient = class BotGuardClient {
 		];
 		try {
 			let snapshot;
-			if (this.syncSnapshotFunction) snapshot = await this.syncSnapshotFunction(snapshotArgs);
-			else {
+			if (this.syncSnapshotFunction) {
+				log$3.debug("Using sync snapshot function");
+				snapshot = await this.syncSnapshotFunction(snapshotArgs);
+			} else {
+				log$3.debug("Using async snapshot function, waiting for VM functions...");
 				const vmFunctions = await Promise.race([this.deferredVmFunctions.promise, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout waiting for VM functions")), this.snapshotTimeout))]);
-				if (!vmFunctions.asyncSnapshotFunction) return err(createError("BOTGUARD_SNAPSHOT_FAILED", "No snapshot function available"));
+				if (!vmFunctions.asyncSnapshotFunction) {
+					log$3.error("No snapshot function available in VM");
+					return err(createError("BOTGUARD_SNAPSHOT_FAILED", "No snapshot function available"));
+				}
+				log$3.debug("Executing async snapshot...");
 				snapshot = await new Promise((resolve, reject) => {
 					const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("Snapshot timeout")), this.snapshotTimeout);
 					vmFunctions.asyncSnapshotFunction((response) => {
@@ -2628,11 +2685,13 @@ var BotGuardClient = class BotGuardClient {
 					}, snapshotArgs);
 				});
 			}
+			log$3.success(`Snapshot generated (length: ${snapshot.length}, signals: ${webPoSignalOutput.length})`);
 			return ok({
 				snapshot,
 				webPoSignalOutput
 			});
 		} catch (error) {
+			log$3.error("Snapshot generation failed", error);
 			return err(createError("BOTGUARD_SNAPSHOT_FAILED", `Snapshot failed: ${error.message}`, error));
 		}
 	}
@@ -2679,6 +2738,7 @@ function u8ToBase64Url$1(u8) {
 
 //#endregion
 //#region src/po-token/minter/web-minter.ts
+const log$2 = logger.scope("WebPoMinter");
 const WAA_GENERATE_IT_ENDPOINT = "https://jnn-pa.googleapis.com/$rpc/google.internal.waa.v1.Waa/GenerateIT";
 const GOOG_API_KEY = "AIzaSyDyT5W0Jh49F30Pqqtyfdf7pDLFKLJoAnw";
 const REQUEST_KEY = "O43z0dpjhgX20SCx4KAo";
@@ -2688,38 +2748,73 @@ var WebPoMinter = class WebPoMinter {
 		this.mintCallback = mintCallback;
 	}
 	static async create(integrityTokenData, webPoSignalOutput) {
+		log$2.info("Creating WebPoMinter...");
 		const getMinter = webPoSignalOutput[0];
-		if (!getMinter || typeof getMinter !== "function") return err(createError("INTEGRITY_TOKEN_FAILED", "Minter function not found in webPoSignalOutput"));
-		if (!integrityTokenData.integrityToken) return err(createError("INTEGRITY_TOKEN_FAILED", "No integrity token provided"));
+		if (!getMinter || typeof getMinter !== "function") {
+			log$2.error("Minter function not found in webPoSignalOutput");
+			return err(createError("INTEGRITY_TOKEN_FAILED", "Minter function not found in webPoSignalOutput"));
+		}
+		if (!integrityTokenData.integrityToken) {
+			log$2.error("No integrity token provided");
+			return err(createError("INTEGRITY_TOKEN_FAILED", "No integrity token provided"));
+		}
 		try {
-			const mintCallback = await getMinter(base64ToU8(integrityTokenData.integrityToken));
-			if (typeof mintCallback !== "function") return err(createError("INTEGRITY_TOKEN_FAILED", "Invalid mint callback returned"));
+			log$2.debug(`Decoding integrity token (length: ${integrityTokenData.integrityToken.length})...`);
+			const integrityTokenBytes = base64ToU8(integrityTokenData.integrityToken);
+			log$2.debug("Calling getMinter with integrity token bytes...");
+			const mintCallback = await getMinter(integrityTokenBytes);
+			if (typeof mintCallback !== "function") {
+				log$2.error("Invalid mint callback returned (not a function)");
+				return err(createError("INTEGRITY_TOKEN_FAILED", "Invalid mint callback returned"));
+			}
+			log$2.success("WebPoMinter created successfully");
 			return ok(new WebPoMinter(mintCallback));
 		} catch (error) {
+			log$2.error("Failed to create minter", error);
 			return err(createError("INTEGRITY_TOKEN_FAILED", `Failed to create minter: ${error.message}`, error));
 		}
 	}
 	async mint(identifier) {
+		log$2.debug(`Minting for identifier: ${identifier.substring(0, 30)}...`);
 		try {
 			const identifierBytes = new TextEncoder().encode(identifier);
 			const result = await this.mintCallback(identifierBytes);
-			if (!result) return err(createError("INTEGRITY_TOKEN_FAILED", "Mint returned undefined"));
-			if (result instanceof Uint8Array) return ok(result);
-			if (ArrayBuffer.isView(result)) return ok(new Uint8Array(result.buffer));
-			if (Array.isArray(result)) return ok(new Uint8Array(result));
+			if (!result) {
+				log$2.error("Mint returned undefined");
+				return err(createError("INTEGRITY_TOKEN_FAILED", "Mint returned undefined"));
+			}
+			if (result instanceof Uint8Array) {
+				log$2.debug(`Mint successful (Uint8Array, ${result.length} bytes)`);
+				return ok(result);
+			}
+			if (ArrayBuffer.isView(result)) {
+				log$2.debug(`Mint successful (ArrayBufferView, ${result.buffer.byteLength} bytes)`);
+				return ok(new Uint8Array(result.buffer));
+			}
+			if (Array.isArray(result)) {
+				log$2.debug(`Mint successful (Array, ${result.length} bytes)`);
+				return ok(new Uint8Array(result));
+			}
+			log$2.error(`Mint returned invalid type: ${typeof result}`);
 			return err(createError("INTEGRITY_TOKEN_FAILED", `Mint returned invalid type: ${typeof result}`));
 		} catch (error) {
+			log$2.error("Mint failed", error);
 			return err(createError("INTEGRITY_TOKEN_FAILED", `Mint failed: ${error.message}`, error));
 		}
 	}
 	async mintAsWebsafeString(identifier) {
+		log$2.info(`Minting as websafe string for: ${identifier.substring(0, 30)}...`);
 		const mintResult = await this.mint(identifier);
 		if (!isOk(mintResult)) return mintResult;
-		return ok(u8ToBase64Url(mintResult.value));
+		const token = u8ToBase64Url(mintResult.value);
+		log$2.success(`Websafe token generated (length: ${token.length})`);
+		return ok(token);
 	}
 };
 async function fetchIntegrityToken(botguardResponse, options = {}) {
 	const timeout = options.timeout ?? 1e4;
+	log$2.info("Fetching integrity token from GenerateIT...");
+	log$2.debug(`BotGuard response length: ${botguardResponse.length}, timeout: ${timeout}ms`);
 	try {
 		const response = await fetch(WAA_GENERATE_IT_ENDPOINT, {
 			method: "POST",
@@ -2730,13 +2825,21 @@ async function fetchIntegrityToken(botguardResponse, options = {}) {
 			body: JSON.stringify([REQUEST_KEY, botguardResponse]),
 			signal: AbortSignal.timeout(timeout)
 		});
-		if (!response.ok) return err(createError("INTEGRITY_TOKEN_FAILED", `GenerateIT request failed with status ${response.status}`));
+		log$2.debug(`GenerateIT response status: ${response.status}`);
+		if (!response.ok) {
+			log$2.error(`GenerateIT request failed with status ${response.status}`);
+			return err(createError("INTEGRITY_TOKEN_FAILED", `GenerateIT request failed with status ${response.status}`));
+		}
 		const json = await response.json();
 		const integrityToken = json[0];
 		const estimatedTtlSecs = json[1];
 		const mintRefreshThreshold = json[2];
 		const websafeFallbackToken = json[3];
-		if (!integrityToken) return err(createError("INTEGRITY_TOKEN_FAILED", "No integrity token in response"));
+		if (!integrityToken) {
+			log$2.error("No integrity token in GenerateIT response");
+			return err(createError("INTEGRITY_TOKEN_FAILED", "No integrity token in response"));
+		}
+		log$2.success(`Integrity token received (length: ${integrityToken.length}, TTL: ${estimatedTtlSecs}s, threshold: ${mintRefreshThreshold})`);
 		return ok({
 			integrityToken,
 			estimatedTtlSecs: estimatedTtlSecs ?? 3600,
@@ -2744,7 +2847,11 @@ async function fetchIntegrityToken(botguardResponse, options = {}) {
 			websafeFallbackToken
 		});
 	} catch (error) {
-		if (error instanceof Error && error.name === "TimeoutError") return err(createError("INTEGRITY_TOKEN_FAILED", "GenerateIT request timeout"));
+		if (error instanceof Error && error.name === "TimeoutError") {
+			log$2.error(`GenerateIT request timeout after ${timeout}ms`);
+			return err(createError("INTEGRITY_TOKEN_FAILED", "GenerateIT request timeout"));
+		}
+		log$2.error("Failed to fetch integrity token", error);
 		return err(createError("INTEGRITY_TOKEN_FAILED", "Failed to fetch integrity token", error));
 	}
 }
@@ -2761,6 +2868,7 @@ function u8ToBase64Url(u8) {
 
 //#endregion
 //#region src/po-token/providers/local.provider.ts
+const log$1 = logger.scope("LocalBotGuard");
 const REFRESH_MARGIN_MS = 600 * 1e3;
 var LocalBotGuardProvider = class {
 	name = "local-botguard";
@@ -2781,19 +2889,33 @@ var LocalBotGuardProvider = class {
 	async isAvailable() {
 		try {
 			await import("jsdom");
+			log$1.debug("jsdom available - provider is ready");
 			return true;
-		} catch {
+		} catch (e) {
+			log$1.warn("jsdom not available - provider disabled", e);
 			return false;
 		}
 	}
 	async generate(identifier, _binding) {
+		log$1.info(`generate() called for identifier: ${identifier.substring(0, 30)}...`);
 		const initResult = await this.ensureInitialized();
-		if (!isOk(initResult)) return initResult;
-		if (!this.minter || !this.integrityData) return err(createError("BOTGUARD_INIT_FAILED", "Minter not initialized"));
+		if (!isOk(initResult)) {
+			log$1.error("Initialization failed", initResult.error);
+			return initResult;
+		}
+		if (!this.minter || !this.integrityData) {
+			log$1.error("Minter or integrityData is null after initialization");
+			return err(createError("BOTGUARD_INIT_FAILED", "Minter not initialized"));
+		}
+		log$1.info("Minting po_token...");
 		const tokenResult = await this.minter.mintAsWebsafeString(identifier);
-		if (!isOk(tokenResult)) return tokenResult;
+		if (!isOk(tokenResult)) {
+			log$1.error("Minting failed", tokenResult.error);
+			return tokenResult;
+		}
 		const now = Date.now();
 		const ttlMs = (this.integrityData.estimatedTtlSecs ?? 43200) * 1e3;
+		log$1.success(`Token minted successfully (length: ${tokenResult.value.length}, TTL: ${Math.round(ttlMs / 1e3)}s)`);
 		return ok({
 			token: tokenResult.value,
 			createdAt: now,
@@ -2819,25 +2941,71 @@ var LocalBotGuardProvider = class {
 		return result;
 	}
 	async initialize() {
+		log$1.info("=== Starting BotGuard initialization ===");
+		log$1.time("botguard-init");
+		log$1.info("[1/6] Fetching WAA challenge...");
+		log$1.time("waa-challenge");
 		const challengeResult = await this.challengeFetcher.fetchFullChallenge();
-		if (!isOk(challengeResult)) return challengeResult;
+		log$1.timeEnd("waa-challenge");
+		if (!isOk(challengeResult)) {
+			log$1.error("[1/6] FAILED: Could not fetch WAA challenge", challengeResult.error);
+			return challengeResult;
+		}
 		this.challenge = challengeResult.value;
+		log$1.success(`[1/6] Challenge received (program: ${this.challenge.program.length} bytes, globalName: ${this.challenge.globalName})`);
+		log$1.info("[2/6] Fetching attestation...");
+		log$1.time("attestation");
 		const attResult = await this.challengeFetcher.fetchAttestation();
-		if (!isOk(attResult)) return attResult;
+		log$1.timeEnd("attestation");
+		if (!isOk(attResult)) {
+			log$1.error("[2/6] FAILED: Could not fetch attestation", attResult.error);
+			return attResult;
+		}
 		this.attestation = attResult.value;
+		log$1.success(`[2/6] Attestation received (visitorData: ${this.attestation.visitorData.substring(0, 30)}...)`);
+		log$1.info("[3/6] Creating BotGuard client (JSDOM VM)...");
+		log$1.time("botguard-client");
 		const clientResult = await BotGuardClient.create(this.challenge, { timeout: this.options.timeout });
-		if (!isOk(clientResult)) return clientResult;
+		log$1.timeEnd("botguard-client");
+		if (!isOk(clientResult)) {
+			log$1.error("[3/6] FAILED: Could not create BotGuard client", clientResult.error);
+			return clientResult;
+		}
 		this.client = clientResult.value;
+		log$1.success("[3/6] BotGuard client created");
+		log$1.info("[4/6] Generating BotGuard snapshot...");
+		log$1.time("snapshot");
 		const snapshotResult = await this.client.snapshotWithSignalOutput();
-		if (!isOk(snapshotResult)) return snapshotResult;
+		log$1.timeEnd("snapshot");
+		if (!isOk(snapshotResult)) {
+			log$1.error("[4/6] FAILED: Could not generate snapshot", snapshotResult.error);
+			return snapshotResult;
+		}
 		const { snapshot, webPoSignalOutput } = snapshotResult.value;
+		log$1.success(`[4/6] Snapshot generated (length: ${snapshot.length}, signals: ${webPoSignalOutput.length})`);
+		log$1.info("[5/6] Fetching integrity token from GenerateIT...");
+		log$1.time("integrity-token");
 		const integrityResult = await fetchIntegrityToken(snapshot, { timeout: this.options.timeout });
-		if (!isOk(integrityResult)) return integrityResult;
+		log$1.timeEnd("integrity-token");
+		if (!isOk(integrityResult)) {
+			log$1.error("[5/6] FAILED: Could not fetch integrity token", integrityResult.error);
+			return integrityResult;
+		}
 		this.integrityData = integrityResult.value;
 		this.createdAt = Date.now();
+		log$1.success(`[5/6] Integrity token received (TTL: ${this.integrityData.estimatedTtlSecs}s, refreshThreshold: ${this.integrityData.mintRefreshThreshold})`);
+		log$1.info("[6/6] Creating WebPoMinter...");
+		log$1.time("minter-create");
 		const minterResult = await WebPoMinter.create(this.integrityData, webPoSignalOutput);
-		if (!isOk(minterResult)) return minterResult;
+		log$1.timeEnd("minter-create");
+		if (!isOk(minterResult)) {
+			log$1.error("[6/6] FAILED: Could not create WebPoMinter", minterResult.error);
+			return minterResult;
+		}
 		this.minter = minterResult.value;
+		log$1.success("[6/6] WebPoMinter created");
+		log$1.timeEnd("botguard-init");
+		log$1.success("=== BotGuard initialization COMPLETE ===");
 		return ok(void 0);
 	}
 	reset() {
@@ -3005,6 +3173,7 @@ var TokenCache = class {
 
 //#endregion
 //#region src/po-token/manager.ts
+const log = logger.scope("PoTokenManager");
 var PoTokenManager = class {
 	staticToken;
 	policies;
@@ -3018,22 +3187,53 @@ var PoTokenManager = class {
 		if (config.cacheEnabled !== false && config.cachePath) this.cache = new TokenCache(config.cachePath);
 	}
 	async getToken(identifier, client = "WEB", binding) {
-		if (this.staticToken) return ok(this.staticToken);
-		if (!this.isRequired(client)) return ok("");
+		log.info(`getToken called`, {
+			identifier: identifier.substring(0, 20) + "...",
+			client,
+			hasBinding: !!binding
+		});
+		if (this.staticToken) {
+			log.debug(`Using static token (length: ${this.staticToken.length})`);
+			return ok(this.staticToken);
+		}
+		if (!this.isRequired(client)) {
+			log.debug(`Token not required for client ${client}`);
+			return ok("");
+		}
 		const context = binding ? "GVS" : "GVS";
 		if (this.cache) {
 			const cachedResult = this.cache.get(identifier, client, context);
-			if (isOk(cachedResult) && cachedResult.value && cachedResult.value.expiresAt > Date.now()) return ok(cachedResult.value.token);
-		}
-		for (const provider of this.providers) {
-			if (!await provider.isAvailable()) continue;
+			if (isOk(cachedResult) && cachedResult.value && cachedResult.value.expiresAt > Date.now()) {
+				log.success(`Cache HIT - using cached token (expires in ${Math.round((cachedResult.value.expiresAt - Date.now()) / 1e3)}s)`);
+				return ok(cachedResult.value.token);
+			}
+			log.debug(`Cache MISS - need to generate new token`);
+		}
+		log.info(`Trying ${this.providers.length} provider(s) to generate token`);
+		for (let i = 0; i < this.providers.length; i++) {
+			const provider = this.providers[i];
+			const providerName = provider.constructor.name;
+			log.debug(`Checking provider ${i + 1}/${this.providers.length}: ${providerName}`);
+			if (!await provider.isAvailable()) {
+				log.warn(`Provider ${providerName} not available, skipping`);
+				continue;
+			}
+			log.info(`Provider ${providerName} available, generating token...`);
 			const result = await provider.generate(identifier, binding);
 			if (isOk(result)) {
-				if (this.cache) this.cache.set(result.value);
+				log.success(`Provider ${providerName} generated token successfully (length: ${result.value.token.length})`);
+				if (this.cache) {
+					this.cache.set(result.value);
+					log.debug(`Token cached`);
+				}
 				return ok(result.value.token);
 			}
+			log.warn(`Provider ${providerName} failed to generate token`);
 		}
-		return ok(generateColdStartToken(identifier));
+		log.warn(`All providers failed, generating cold start token`);
+		const coldToken = generateColdStartToken(identifier);
+		log.info(`Cold start token generated (length: ${coldToken.length})`);
+		return ok(coldToken);
 	}
 	async getTokenData(identifier, client = "WEB", binding) {
 		if (this.staticToken) return ok({