gscdump 1.4.0 → 1.4.1

package/dist/index.mjs

@@ -1,1247 +1,23 @@
+import { runSequentialBatch } from "./api/batch.mjs";
+import { batchRequestIndexing, getIndexingMetadata, requestIndexing } from "./api/indexing.mjs";
+import { GSC_INDEXING_SCOPE, GSC_READ_SCOPE, GSC_SITE_VERIFICATION_SCOPE, GSC_WRITE_SCOPE, hasGoogleScope } from "./core/scope-values.mjs";
+import { hasGscReadScope, hasGscWriteScope, hasIndexingScope } from "./core/scopes.mjs";
+import { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
+import { GscApiError, classifyError, gscErrorToException, isPermissionDeniedError, parseGoogleError, rethrowAsGscApiError } from "./core/errors.mjs";
 import { err, isErr, isOk, ok, unwrapResult } from "./core/result.mjs";
-import { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, groupIntoRanges, isValidGscDate, toIsoDate } from "./_chunks/gsc-dates.mjs";
-import { resolveToBody } from "./_chunks/resolver.mjs";
+import { exchangeAuthCodeResult, introspectAccessToken, introspectAccessTokenResult, refreshAccessToken, revokeOAuthToken, revokeOAuthTokenResult } from "./api/oauth.mjs";
+import { addSite, deleteSite, deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, submitSitemap } from "./api/sites.mjs";
+import { getVerificationToken, getVerifiedSite, listVerifiedSites, resolveVerificationTarget, siteUrlToVerificationSite, unverifySite, verificationMethodsFor, verifySite } from "./api/verification.mjs";
+import { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, groupIntoRanges, isValidGscDate, toIsoDate } from "./core/gsc-dates.mjs";
+import { DEFAULT_GSC_REQUEST_TIMEOUT_MS, createAuth, createFetch, googleSearchConsole } from "./core/client.mjs";
+import { INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, unmappedInspectionReasons } from "./core/indexing-issues.mjs";
+import { normalizeGscSiteUrl, normalizeRegistrationTarget, parseGscSiteUrl } from "./core/site-url.mjs";
+import { findBestGscProperty, findExactGscProperty, formatGscPropertyCandidates, gscPropertyMatchesTarget, isVerifiedGscPermission, isVerifiedGscProperty, matchGscSite, pickBestGscProperty } from "./core/property.mjs";
+import { URL_INSPECTION_EFFECTIVE_LIMIT } from "./core/quota.mjs";
+import "./core/types.mjs";
 import { normalizeUrl } from "./normalize.mjs";
+import { GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, lifecycleErrorCodes, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses } from "./onboarding.mjs";
+import { discoverSitemap, fetchSitemapUrls } from "./sitemap.mjs";
 import { decodeSiteId, encodeSiteId, normalizeSiteUrl } from "./tenant.mjs";
-import { ofetch } from "ofetch";
-import { GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, lifecycleErrorCodes, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses } from "@gscdump/contracts/partner";
-async function runSequentialBatch(items, operation, options = {}) {
-	const { delayMs = 0, concurrency = 1, onProgress } = options;
-	const results = Array.from({ length: items.length });
-	let completed = 0;
-	if (concurrency <= 1) {
-		for (let i = 0; i < items.length; i++) {
-			const result = await operation(items[i], i);
-			results[i] = result;
-			onProgress?.(result, i, items.length);
-			if (i < items.length - 1 && delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
-		}
-		return results;
-	}
-	const cursor = { i: 0 };
-	const worker = async () => {
-		while (true) {
-			const i = cursor.i++;
-			if (i >= items.length) return;
-			const result = await operation(items[i], i);
-			results[i] = result;
-			completed++;
-			onProgress?.(result, completed - 1, items.length);
-			if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
-		}
-	};
-	await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
-	return results;
-}
-async function requestIndexing(client, url, options = {}) {
-	const { type = "URL_UPDATED" } = options;
-	return client.indexing.publish(url, type).then((r) => ({
-		url,
-		type,
-		notifyTime: r.urlNotificationMetadata?.latestUpdate?.notifyTime || void 0
-	}));
-}
-async function getIndexingMetadata(client, url) {
-	return client.indexing.getMetadata(url).then((r) => ({
-		url,
-		latestUpdate: r.latestUpdate || void 0,
-		latestRemove: r.latestRemove || void 0
-	}));
-}
-async function batchRequestIndexing(client, urls, options = {}) {
-	const { type = "URL_UPDATED", delayMs = 100, concurrency, onProgress } = options;
-	return runSequentialBatch(urls, (url) => requestIndexing(client, url, { type }), {
-		delayMs,
-		concurrency,
-		onProgress
-	});
-}
-const GSC_READ_SCOPE = "https://www.googleapis.com/auth/webmasters.readonly";
-const GSC_WRITE_SCOPE = "https://www.googleapis.com/auth/webmasters";
-const GSC_INDEXING_SCOPE = "https://www.googleapis.com/auth/indexing";
-const GSC_SITE_VERIFICATION_SCOPE = "https://www.googleapis.com/auth/siteverification";
-function parseGoogleScopes(scopes) {
-	if (!scopes) return [];
-	if (typeof scopes === "string") return scopes.split(/\s+/).map((scope) => scope.trim()).filter(Boolean);
-	return scopes.map((scope) => scope.trim()).filter(Boolean);
-}
-function hasGoogleScope(scopes, scope) {
-	const tokens = parseGoogleScopes(scopes);
-	const suffix = scope.replace("https://www.googleapis.com/auth/", "");
-	return tokens.includes(scope) || tokens.includes(suffix);
-}
-function hasGscReadScope(scopes) {
-	return hasGoogleScope(scopes, "https://www.googleapis.com/auth/webmasters.readonly") || hasGoogleScope(scopes, "https://www.googleapis.com/auth/webmasters");
-}
-function hasGscWriteScope(scopes) {
-	return hasGoogleScope(scopes, GSC_WRITE_SCOPE);
-}
-function hasIndexingScope(scopes) {
-	return hasGoogleScope(scopes, GSC_INDEXING_SCOPE);
-}
-async function inspectUrl(client, siteUrl, inspectionUrl) {
-	const inspection = (await client.inspect(siteUrl, inspectionUrl)).inspectionResult;
-	return {
-		inspection,
-		isIndexed: inspection?.indexStatusResult?.verdict === "PASS"
-	};
-}
-async function batchInspectUrls(client, siteUrl, urls, options = {}) {
-	const { delayMs = 200, concurrency, onProgress } = options;
-	return runSequentialBatch(urls, async (url) => {
-		const { inspection, isIndexed } = await inspectUrl(client, siteUrl, url);
-		return {
-			url,
-			inspection,
-			isIndexed
-		};
-	}, {
-		delayMs,
-		concurrency,
-		onProgress
-	});
-}
-async function inspectUrlFlat(client, siteUrl, inspectionUrl, options) {
-	const inspection = (await client.inspect(siteUrl, inspectionUrl, options)).inspectionResult;
-	const index = inspection?.indexStatusResult;
-	const mobile = inspection?.mobileUsabilityResult;
-	const rich = inspection?.richResultsResult;
-	const amp = inspection?.ampResult;
-	return {
-		url: inspectionUrl,
-		verdict: index?.verdict ?? null,
-		coverageState: index?.coverageState ?? null,
-		indexingState: index?.indexingState ?? null,
-		robotsTxtState: index?.robotsTxtState ?? null,
-		pageFetchState: index?.pageFetchState ?? null,
-		lastCrawlTime: index?.lastCrawlTime ?? null,
-		crawlingUserAgent: index?.crawledAs ?? null,
-		userCanonical: index?.userCanonical ?? null,
-		googleCanonical: index?.googleCanonical ?? null,
-		sitemaps: index?.sitemap?.length ? JSON.stringify(index.sitemap) : null,
-		referringUrls: index?.referringUrls?.length ? JSON.stringify(index.referringUrls) : null,
-		mobileVerdict: mobile?.verdict ?? null,
-		mobileIssues: mobile?.issues?.length ? JSON.stringify(mobile.issues) : null,
-		richResultsVerdict: rich?.verdict ?? null,
-		richResultsItems: rich?.detectedItems?.length ? JSON.stringify(rich.detectedItems) : null,
-		ampVerdict: amp?.verdict ?? null,
-		ampUrl: amp?.ampUrl ?? null,
-		ampIndexingState: amp?.indexingState ?? null,
-		ampIndexStatusVerdict: amp?.ampIndexStatusVerdict ?? null,
-		ampRobotsTxtState: amp?.robotsTxtState ?? null,
-		ampPageFetchState: amp?.pageFetchState ?? null,
-		ampLastCrawlTime: amp?.lastCrawlTime ?? null,
-		ampIssues: amp?.issues?.length ? JSON.stringify(amp.issues) : null,
-		inspectionResultLink: inspection?.inspectionResultLink ?? null
-	};
-}
-const MAX_FLAT_INSPECTION_BATCH_CONCURRENCY = 10;
-async function batchInspectUrlsFlatSettled(client, siteUrl, urls, options = {}) {
-	const requestedConcurrency = Math.trunc(options.concurrency ?? 1);
-	const concurrency = Number.isFinite(requestedConcurrency) ? Math.max(1, Math.min(requestedConcurrency, 10)) : 1;
-	return runSequentialBatch([...urls], async (url) => {
-		try {
-			return {
-				url,
-				status: "fulfilled",
-				value: await inspectUrlFlat(client, siteUrl, url, { signal: options.signal })
-			};
-		} catch (reason) {
-			return {
-				url,
-				status: "rejected",
-				reason
-			};
-		}
-	}, {
-		delayMs: options.delayMs ?? 200,
-		concurrency,
-		onProgress: options.onProgress
-	});
-}
-function getNextCheckPriority(result) {
-	if (!result.verdict || result.verdict === "VERDICT_UNSPECIFIED") return "medium";
-	if (result.verdict === "FAIL" || result.verdict === "PARTIAL" || result.verdict === "NEUTRAL") return "high";
-	if (result.verdict === "PASS") return "low";
-	return "medium";
-}
-function getNextCheckAfter(priority) {
-	const now = Math.floor(Date.now() / 1e3);
-	switch (priority) {
-		case "high": return now + 7 * 86400;
-		case "medium": return now + 14 * 86400;
-		case "low": return now + 30 * 86400;
-	}
-}
-const INSPECTION_ALLOWED_PERMISSIONS = /* @__PURE__ */ new Set([
-	"siteOwner",
-	"siteFullUser",
-	"siteRestrictedUser"
-]);
-function canUseUrlInspection(permissionLevel) {
-	return !!permissionLevel && INSPECTION_ALLOWED_PERMISSIONS.has(permissionLevel);
-}
-function grantedScopeList(scopes) {
-	return scopes?.split(/\s+/).map((s) => s.trim()).filter(Boolean) ?? [];
-}
-function getIndexingEligibility(grantedScopes, permissionLevel) {
-	const scopes = grantedScopeList(grantedScopes);
-	if (!hasIndexingScope(grantedScopes)) return {
-		indexingEligible: false,
-		indexingIneligibleReason: "missing_indexing_scope",
-		indexingPermissionLevel: permissionLevel ?? null,
-		grantedScopes: scopes
-	};
-	if (!canUseUrlInspection(permissionLevel)) return {
-		indexingEligible: false,
-		indexingIneligibleReason: "insufficient_gsc_permission",
-		indexingPermissionLevel: permissionLevel ?? null,
-		grantedScopes: scopes
-	};
-	return {
-		indexingEligible: true,
-		indexingPermissionLevel: permissionLevel ?? null,
-		grantedScopes: scopes
-	};
-}
-function pickField(error, paths, is) {
-	if (!error || typeof error !== "object") return void 0;
-	for (const path of paths) {
-		let current = error;
-		for (const key of path) {
-			if (!current || typeof current !== "object") {
-				current = void 0;
-				break;
-			}
-			current = current[key];
-		}
-		if (is(current)) return current;
-	}
-}
-const isNumber = (v) => typeof v === "number";
-const isString = (v) => typeof v === "string";
-function extractStatus(error) {
-	return pickField(error, [
-		["statusCode"],
-		["status"],
-		["response", "status"],
-		["code"]
-	], isNumber);
-}
-function extractMessage(error) {
-	if (!error) return "Unknown error";
-	if (typeof error === "string") return error;
-	if (error instanceof Error) return error.message;
-	if (typeof error !== "object") return String(error);
-	return pickField(error, [
-		[
-			"data",
-			"error",
-			"message"
-		],
-		["message"],
-		["statusMessage"]
-	], isString) ?? String(error);
-}
-function extractRetryAfter(error) {
-	const raw = pickField(error, [
-		["headers", "retry-after"],
-		["headers", "Retry-After"],
-		[
-			"response",
-			"headers",
-			"retry-after"
-		],
-		[
-			"response",
-			"headers",
-			"Retry-After"
-		]
-	], (v) => typeof v === "number" || typeof v === "string");
-	if (typeof raw === "number") return raw;
-	if (typeof raw === "string") {
-		const seconds = Number.parseInt(raw, 10);
-		return Number.isNaN(seconds) ? void 0 : seconds;
-	}
-}
-const QUOTA_MESSAGE_RE = /quota|rate\s*limit/i;
-const QUOTA_REASONS = /* @__PURE__ */ new Set([
-	"dailyLimitExceeded",
-	"dailyLimitExceededUnreg",
-	"rateLimitExceeded",
-	"rateLimitExceededUnreg",
-	"userRateLimitExceeded",
-	"userRateLimitExceededUnreg",
-	"quotaExceeded",
-	"concurrentLimitExceeded",
-	"variableTermLimitExceeded",
-	"variableTermExpiredDailyExceeded",
-	"servingLimitExceeded",
-	"responseTooLarge",
-	"limitExceeded",
-	"batchSizeTooLarge",
-	"RATE_LIMIT_EXCEEDED",
-	"RESOURCE_EXHAUSTED"
-]);
-function extractReason(cause) {
-	const data = pickField(cause, [["data"]], (_v) => true);
-	if (data) {
-		const errorInfo = pickField(data, [["error", "details"]], (v) => Array.isArray(v));
-		if (errorInfo) {
-			const reason = errorInfo.find((d) => typeof d["@type"] === "string" && d["@type"].includes("ErrorInfo"))?.reason;
-			if (typeof reason === "string") return reason;
-		}
-		const directErrors = pickField(data, [["error", "errors"]], (v) => Array.isArray(v));
-		if (directErrors) {
-			const reason = directErrors[0]?.reason;
-			if (typeof reason === "string") return reason;
-		}
-	}
-}
-function isQuotaCondition(cause, message) {
-	const reason = extractReason(cause);
-	if (reason && QUOTA_REASONS.has(reason)) return true;
-	return QUOTA_MESSAGE_RE.test(message);
-}
-function classifyError(cause) {
-	const status = extractStatus(cause);
-	const message = extractMessage(cause);
-	if (status === 401) return {
-		kind: "auth-expired",
-		message,
-		cause
-	};
-	if (status === 429) return {
-		kind: "rate-limited",
-		message,
-		retryAfter: extractRetryAfter(cause),
-		cause
-	};
-	if (status === 403) {
-		if (isQuotaCondition(cause, message)) return {
-			kind: "rate-limited",
-			message,
-			retryAfter: extractRetryAfter(cause),
-			cause
-		};
-		return {
-			kind: "auth-expired",
-			message,
-			cause
-		};
-	}
-	if (status === 404 || status === 410) return {
-		kind: "not-found",
-		message,
-		cause
-	};
-	if (status === 400 || status === 402 || status === 409 || status === 413 || status === 422) return {
-		kind: "validation",
-		message,
-		cause
-	};
-	return {
-		kind: "transport",
-		message,
-		status,
-		cause
-	};
-}
-function gscErrorToException(error) {
-	const exception = new Error(error.message);
-	if (error.cause !== void 0) exception.cause = error.cause;
-	exception.gscError = error;
-	return exception;
-}
-function parseGoogleError(text, httpStatus) {
-	let parsed = null;
-	try {
-		parsed = JSON.parse(text);
-	} catch (error) {
-		if (!(error instanceof SyntaxError)) throw error;
-	}
-	if (!parsed || !("error" in parsed)) return {
-		code: httpStatus ?? 500,
-		message: text || "Unknown Google API error"
-	};
-	if (typeof parsed.error === "string") {
-		const oauth = parsed;
-		return {
-			code: httpStatus ?? 400,
-			message: oauth.error_description || oauth.error,
-			reason: oauth.error
-		};
-	}
-	const err = parsed.error;
-	const errorInfo = err.details?.find((d) => d["@type"]?.includes("ErrorInfo"));
-	return {
-		code: err.code ?? httpStatus ?? 500,
-		message: err.message || err.status || text || `HTTP ${httpStatus ?? "?"}`,
-		reason: errorInfo?.reason,
-		status: err.status
-	};
-}
-var GscApiError = class extends Error {
-	info;
-	constructor(message, info) {
-		super(message);
-		this.info = info;
-		this.name = "GscApiError";
-	}
-};
-function rethrowAsGscApiError(prefix) {
-	return (err) => {
-		if (err instanceof GscApiError) throw err;
-		const maybe = err;
-		if (maybe && maybe.name === "FetchError") {
-			const info = parseGoogleError(typeof maybe.data === "string" ? maybe.data : JSON.stringify(maybe.data ?? {}), maybe.statusCode);
-			throw new GscApiError(`${prefix}: ${info.message}`, info);
-		}
-		throw err;
-	};
-}
-const PERMISSION_SIGNALS = [
-	"403 forbidden",
-	"permission_denied",
-	"does not have sufficient permission",
-	"insufficient permission"
-];
-function isPermissionDeniedError(err) {
-	const msg = String(err?.message ?? err ?? "").toLowerCase();
-	return PERMISSION_SIGNALS.some((s) => msg.includes(s));
-}
-const OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token";
-const OAUTH_TOKEN_INFO_URL = "https://oauth2.googleapis.com/tokeninfo";
-const OAUTH_REVOKE_URL = "https://oauth2.googleapis.com/revoke";
-const OAUTH_TIMEOUT_MS = 8e3;
-const OAUTH_MAX_ATTEMPTS = 3;
-const OAUTH_BACKOFF_MS = [
-	0,
-	400,
-	1500
-];
-async function refreshAccessTokenResult(refreshToken, clientId, clientSecret) {
-	const result = await postOAuthTokenResult(new URLSearchParams({
-		client_id: clientId,
-		client_secret: clientSecret,
-		refresh_token: refreshToken,
-		grant_type: "refresh_token"
-	}), "refresh");
-	if (!result.ok) return result;
-	return ok({
-		accessToken: result.value.accessToken,
-		expiresAt: result.value.expiresAt,
-		scope: result.value.scope
-	});
-}
-async function refreshAccessToken(refreshToken, clientId, clientSecret) {
-	return unwrapResult(await refreshAccessTokenResult(refreshToken, clientId, clientSecret), oauthErrorToException);
-}
-async function exchangeAuthCodeResult(code, clientId, clientSecret, redirectUri) {
-	const result = await postOAuthTokenResult(new URLSearchParams({
-		client_id: clientId,
-		client_secret: clientSecret,
-		code,
-		redirect_uri: redirectUri,
-		grant_type: "authorization_code"
-	}), "exchange");
-	if (!result.ok) return result;
-	return result;
-}
-async function introspectAccessTokenResult(accessToken) {
-	const response = await requestOAuthResult(`${OAUTH_TOKEN_INFO_URL}?access_token=${encodeURIComponent(accessToken)}`, { method: "GET" }, "introspect");
-	if (!response.ok) return response;
-	const parsed = await readOAuthJsonResult(response.value, "introspect");
-	if (!parsed.ok) return parsed;
-	const data = parsed.value;
-	return ok({
-		issuedTo: optionalString(data.issued_to),
-		audience: optionalString(data.aud),
-		authorizedParty: optionalString(data.azp),
-		userId: optionalString(data.user_id),
-		subject: optionalString(data.sub),
-		scope: optionalString(data.scope),
-		expiresIn: optionalNumber(data.expires_in),
-		expiresAt: optionalNumber(data.exp),
-		email: optionalString(data.email),
-		emailVerified: optionalBoolean(data.email_verified),
-		accessType: optionalString(data.access_type)
-	});
-}
-async function introspectAccessToken(accessToken) {
-	return unwrapResult(await introspectAccessTokenResult(accessToken), oauthErrorToException);
-}
-async function revokeOAuthTokenResult(token) {
-	const response = await requestOAuthResult(OAUTH_REVOKE_URL, {
-		method: "POST",
-		headers: { "Content-Type": "application/x-www-form-urlencoded" },
-		body: new URLSearchParams({ token })
-	}, "revoke");
-	return response.ok ? ok(void 0) : response;
-}
-async function revokeOAuthToken(token) {
-	return unwrapResult(await revokeOAuthTokenResult(token), oauthErrorToException);
-}
-function oauthHttpError(op, info) {
-	const message = `Failed to ${op} token: ${info.message}`;
-	const cause = new GscApiError(message, info);
-	return info.reason === "invalid_grant" || info.reason === "invalid_token" || info.code === 400 || info.code === 401 || info.code === 403 ? {
-		kind: "auth-expired",
-		message,
-		cause
-	} : {
-		kind: "transport",
-		message,
-		status: info.code,
-		cause
-	};
-}
-function oauthErrorToException(error) {
-	return error.cause instanceof Error ? error.cause : gscErrorToException(error);
-}
-async function postOAuthTokenResult(body, op) {
-	const response = await requestOAuthResult(OAUTH_TOKEN_URL, {
-		method: "POST",
-		headers: { "Content-Type": "application/x-www-form-urlencoded" },
-		body
-	}, op);
-	if (!response.ok) return response;
-	const parsed = await readOAuthJsonResult(response.value, op);
-	if (!parsed.ok) return parsed;
-	const data = parsed.value;
-	return ok({
-		accessToken: data.access_token,
-		expiresAt: Math.floor(Date.now() / 1e3) + data.expires_in,
-		refreshToken: data.refresh_token,
-		scope: data.scope
-	});
-}
-async function requestOAuthResult(url, init, op) {
-	let lastError;
-	for (let attempt = 0; attempt < OAUTH_MAX_ATTEMPTS; attempt++) {
-		if (OAUTH_BACKOFF_MS[attempt]) await new Promise((r) => setTimeout(r, OAUTH_BACKOFF_MS[attempt]));
-		const res = await fetch(url, {
-			...init,
-			signal: AbortSignal.timeout(OAUTH_TIMEOUT_MS)
-		}).catch((error) => {
-			lastError = error;
-			return null;
-		});
-		if (!res) continue;
-		if (!res.ok) return err(oauthHttpError(op, parseGoogleError(await res.text(), res.status)));
-		return ok(res);
-	}
-	return err({
-		kind: "transport",
-		message: lastError instanceof Error ? lastError.message : `OAuth ${op} failed after ${OAUTH_MAX_ATTEMPTS} attempts`,
-		cause: lastError
-	});
-}
-async function readOAuthJsonResult(response, op) {
-	try {
-		return ok(await response.json());
-	} catch (cause) {
-		return err({
-			kind: "transport",
-			message: `Failed to parse ${op} token response`,
-			status: response.status,
-			cause
-		});
-	}
-}
-function optionalString(value) {
-	return typeof value === "string" ? value : void 0;
-}
-function optionalNumber(value) {
-	const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
-	return Number.isFinite(parsed) ? parsed : void 0;
-}
-function optionalBoolean(value) {
-	if (typeof value === "boolean") return value;
-	if (value === "true") return true;
-	if (value === "false") return false;
-}
-async function fetchSites(client) {
-	return client.sites();
-}
-async function fetchSitesWithSitemaps(client, options = {}) {
-	const sites = (await client.sites()).filter((s) => !!s.siteUrl && s.permissionLevel !== "siteUnverifiedUser");
-	const requestedConcurrency = options.concurrency ?? 4;
-	return runSequentialBatch(sites, async (site) => {
-		const sitemaps = await client.sitemaps.list(site.siteUrl).catch(() => []);
-		return {
-			...site,
-			sitemaps
-		};
-	}, { concurrency: Number.isFinite(requestedConcurrency) ? Math.max(1, Math.floor(requestedConcurrency)) : 4 });
-}
-async function fetchSitemaps(client, siteUrl) {
-	return client.sitemaps.list(siteUrl);
-}
-async function fetchSitemap(client, siteUrl, feedpath) {
-	return client.sitemaps.get(siteUrl, feedpath);
-}
-async function submitSitemap(client, siteUrl, feedpath) {
-	return client.sitemaps.submit(siteUrl, feedpath);
-}
-async function deleteSitemap(client, siteUrl, feedpath) {
-	return client.sitemaps.delete(siteUrl, feedpath);
-}
-async function addSite(client, siteUrl) {
-	return client.sites.add(siteUrl);
-}
-async function deleteSite(client, siteUrl) {
-	return client.sites.delete(siteUrl);
-}
-const SC_DOMAIN_PREFIX = "sc-domain:";
-function bareDomain(siteUrl) {
-	if (siteUrl.startsWith(SC_DOMAIN_PREFIX)) return siteUrl.slice(10);
-	try {
-		return new URL(siteUrl.startsWith("http") ? siteUrl : `https://${siteUrl}`).host;
-	} catch {
-		return siteUrl;
-	}
-}
-function urlPrefix(siteUrl) {
-	try {
-		const url = new URL(siteUrl.startsWith("http") ? siteUrl : `https://${siteUrl}`);
-		return `${url.protocol}//${url.host}/`;
-	} catch {
-		return siteUrl;
-	}
-}
-function siteUrlToVerificationSite(siteUrl) {
-	if (siteUrl.startsWith(SC_DOMAIN_PREFIX)) return {
-		type: "INET_DOMAIN",
-		identifier: siteUrl.slice(10)
-	};
-	return {
-		type: "SITE",
-		identifier: siteUrl
-	};
-}
-function resolveVerificationTarget(siteUrl, method) {
-	const isDomainProperty = siteUrl.startsWith(SC_DOMAIN_PREFIX);
-	const chosen = method ?? (isDomainProperty ? "DNS_TXT" : "META");
-	const isDns = chosen === "DNS_TXT" || chosen === "DNS_CNAME";
-	if (isDomainProperty && !isDns) return {
-		site: {
-			type: "INET_DOMAIN",
-			identifier: bareDomain(siteUrl)
-		},
-		method: "DNS_TXT"
-	};
-	if (isDns) return {
-		site: {
-			type: "INET_DOMAIN",
-			identifier: bareDomain(siteUrl)
-		},
-		method: chosen
-	};
-	return {
-		site: {
-			type: "SITE",
-			identifier: urlPrefix(siteUrl)
-		},
-		method: chosen
-	};
-}
-function verificationMethodsFor(site) {
-	if (site.type === "INET_DOMAIN") return ["DNS_TXT", "DNS_CNAME"];
-	return [
-		"META",
-		"FILE",
-		"ANALYTICS",
-		"TAG_MANAGER"
-	];
-}
-async function getVerificationToken(client, siteUrl, method) {
-	const { site, method: verificationMethod } = resolveVerificationTarget(siteUrl, method);
-	return {
-		...await client.verification.getToken({
-			site,
-			verificationMethod
-		}),
-		site
-	};
-}
-async function verifySite(client, siteUrl, method) {
-	const { site, method: verificationMethod } = resolveVerificationTarget(siteUrl, method);
-	return client.verification.insert({
-		site,
-		verificationMethod
-	});
-}
-async function listVerifiedSites(client) {
-	return client.verification.list();
-}
-async function getVerifiedSite(client, id) {
-	return client.verification.get(id);
-}
-async function unverifySite(client, id) {
-	return client.verification.delete(id);
-}
-function rowWithMetricDefaults(row) {
-	return {
-		clicks: row.clicks ?? 0,
-		impressions: row.impressions ?? 0,
-		ctr: row.ctr ?? 0,
-		position: row.position ?? 0
-	};
-}
-const GSC_API = "https://searchconsole.googleapis.com";
-const INDEXING_API = "https://indexing.googleapis.com";
-const SITE_VERIFICATION_API = "https://www.googleapis.com/siteVerification/v1";
-const DEFAULT_GSC_REQUEST_TIMEOUT_MS = 3e4;
-function encodeSiteUrl(siteUrl) {
-	if (siteUrl.startsWith("sc-domain:")) return `sc-domain:${encodeURIComponent(siteUrl.slice(10))}`;
-	return encodeURIComponent(siteUrl);
-}
-function assertValidSiteUrl(siteUrl) {
-	if (siteUrl.startsWith("sc-domain:") && siteUrl.length > 10) return;
-	if (/^https?:\/\/.+/.test(siteUrl)) return;
-	throw new Error(`Invalid siteUrl: expected "https?://…" or "sc-domain:…", got "${siteUrl}"`);
-}
-const OAUTH_EXPIRY_SKEW_MS = 6e4;
-function createAuth(options) {
-	let credentials = { refresh_token: options.refreshToken };
-	let refreshPromise = null;
-	return {
-		get credentials() {
-			return credentials;
-		},
-		async getAccessToken() {
-			if (credentials?.access_token && credentials.expiry_date && credentials.expiry_date > Date.now() + OAUTH_EXPIRY_SKEW_MS) return { token: credentials.access_token };
-			refreshPromise ??= refreshAccessToken(options.refreshToken, options.clientId, options.clientSecret).then((response) => {
-				credentials = {
-					...credentials,
-					access_token: response.accessToken,
-					expiry_date: response.expiresAt * 1e3
-				};
-				return response.accessToken;
-			}).finally(() => {
-				refreshPromise = null;
-			});
-			return { token: await refreshPromise };
-		}
-	};
-}
-async function resolveToken(auth) {
-	if (typeof auth === "string") return auth;
-	if ("accessToken" in auth && typeof auth.accessToken === "string") return auth.accessToken;
-	if ("getAccessToken" in auth && typeof auth.getAccessToken === "function") {
-		const { token } = await auth.getAccessToken();
-		return token || "";
-	}
-	if ("credentials" in auth && auth.credentials) return auth.credentials.access_token || "";
-	return "";
-}
-function createFetch(auth, options) {
-	const authState = typeof auth === "object" && auth !== null && "clientId" in auth && "refreshToken" in auth && !("getAccessToken" in auth) ? createAuth(auth) : auth;
-	return ofetch.create({
-		...options,
-		timeout: options?.timeout ?? 3e4,
-		retry: 3,
-		retryDelay: (ctx) => {
-			const status = ctx.response?.status;
-			if (status === 429 || status === 503) {
-				const header = ctx.response?.headers.get("retry-after");
-				if (header) {
-					const secs = Number.parseInt(header, 10);
-					if (Number.isFinite(secs)) return secs * 1e3;
-					const when = Date.parse(header);
-					if (Number.isFinite(when)) return Math.max(0, when - Date.now());
-				}
-			}
-			return 1e3;
-		},
-		retryStatusCodes: [
-			408,
-			425,
-			429,
-			500,
-			502,
-			503,
-			504
-		],
-		headers: {
-			...options?.headers,
-			"Accept-Encoding": "gzip",
-			"User-Agent": "gscdump (gzip)"
-		},
-		async onRequest({ options }) {
-			const token = await resolveToken(authState);
-			if (token) {
-				options.headers = new Headers(options.headers);
-				options.headers.set("Authorization", `Bearer ${token}`);
-			}
-		},
-		async onResponseError(ctx) {
-			if (ctx.response.status === 403) console.error("[gscdump] Permission denied (403). check your service account permissions being added to the GSC property.");
-			if (options?.onResponseError) if (Array.isArray(options.onResponseError)) for (const handler of options.onResponseError) await handler(ctx);
-			else await options.onResponseError(ctx);
-		}
-	});
-}
-function googleSearchConsole(auth, options = {}) {
-	let fetch;
-	const authState = typeof auth === "object" && auth !== null && "clientId" in auth && "refreshToken" in auth && !("getAccessToken" in auth) ? createAuth(auth) : auth;
-	if (options.fetch) fetch = options.fetch;
-	else {
-		const fetchOptions = { ...options.fetchOptions };
-		if (options.onRateLimited) {
-			const originalOnError = fetchOptions.onResponseError;
-			fetchOptions.onResponseError = async (ctx) => {
-				if (ctx.response.status === 429) await options.onRateLimited({ response: ctx.response });
-				if (originalOnError) if (Array.isArray(originalOnError)) for (const handler of originalOnError) await handler(ctx);
-				else await originalOnError(ctx);
-			};
-		}
-		fetch = createFetch(authState, fetchOptions);
-	}
-	const querySearchAnalytics = (siteUrl, body, opts) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}/searchAnalytics/query`, {
-		method: "POST",
-		body,
-		signal: opts?.signal
-	});
-	return {
-		async *query(siteUrl, builder, opts) {
-			const state = builder.getState();
-			const body = resolveToBody(state);
-			const totalCap = body.rowLimit;
-			const pageSize = Math.min(totalCap ?? 25e3, 25e3);
-			let startRow = body.startRow || 0;
-			let yielded = 0;
-			let metadata;
-			let responseAggregationType;
-			while (true) {
-				opts?.signal?.throwIfAborted();
-				const remaining = totalCap ? totalCap - yielded : pageSize;
-				if (remaining <= 0) break;
-				const rowLimit = Math.min(pageSize, remaining);
-				const response = await querySearchAnalytics(siteUrl, {
-					...body,
-					startRow,
-					rowLimit
-				}, opts);
-				if (response.metadata) metadata = response.metadata;
-				if (response.responseAggregationType) responseAggregationType = response.responseAggregationType;
-				const rows = (response.rows || []).map((row) => {
-					const result = rowWithMetricDefaults(row);
-					state.dimensions.forEach((dim, i) => {
-						result[dim] = row.keys?.[i];
-					});
-					return result;
-				});
-				if (rows.length === 0) break;
-				yield rows;
-				yielded += rows.length;
-				startRow += rows.length;
-			}
-			return {
-				metadata,
-				responseAggregationType
-			};
-		},
-		sites: (() => {
-			const list = async (opts) => {
-				return (await fetch(`${GSC_API}/webmasters/v3/sites`, { signal: opts?.signal })).siteEntry || [];
-			};
-			return Object.assign(list, {
-				list,
-				get: (siteUrl, opts) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}`, { signal: opts?.signal }),
-				add: (siteUrl, opts) => {
-					assertValidSiteUrl(siteUrl);
-					return fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}`, {
-						method: "PUT",
-						signal: opts?.signal
-					});
-				},
-				delete: (siteUrl, opts) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}`, {
-					method: "DELETE",
-					signal: opts?.signal
-				})
-			});
-		})(),
-		verification: {
-			getToken: (params, opts) => fetch(`${SITE_VERIFICATION_API}/token`, {
-				method: "POST",
-				body: params,
-				signal: opts?.signal
-			}),
-			insert: (params, opts) => fetch(`${SITE_VERIFICATION_API}/webResource`, {
-				method: "POST",
-				query: { verificationMethod: params.verificationMethod },
-				body: { site: params.site },
-				signal: opts?.signal
-			}),
-			list: async (opts) => {
-				return (await fetch(`${SITE_VERIFICATION_API}/webResource`, { signal: opts?.signal })).items || [];
-			},
-			get: (id, opts) => fetch(`${SITE_VERIFICATION_API}/webResource/${encodeURIComponent(id)}`, { signal: opts?.signal }),
-			delete: (id, opts) => fetch(`${SITE_VERIFICATION_API}/webResource/${encodeURIComponent(id)}`, {
-				method: "DELETE",
-				signal: opts?.signal
-			})
-		},
-		inspect: (siteUrl, url, opts) => fetch(`${GSC_API}/v1/urlInspection/index:inspect`, {
-			method: "POST",
-			body: opts?.languageCode ? {
-				inspectionUrl: url,
-				siteUrl,
-				languageCode: opts.languageCode
-			} : {
-				inspectionUrl: url,
-				siteUrl
-			},
-			signal: opts?.signal
-		}),
-		sitemaps: {
-			list: async (siteUrl, opts) => {
-				return (await fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}/sitemaps`, {
-					signal: opts?.signal,
-					query: opts?.sitemapIndex ? { sitemapIndex: opts.sitemapIndex } : void 0
-				})).sitemap || [];
-			},
-			get: (siteUrl, feedpath, opts) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}`, { signal: opts?.signal }),
-			submit: (siteUrl, feedpath, opts) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}`, {
-				method: "PUT",
-				signal: opts?.signal
-			}),
-			delete: (siteUrl, feedpath, opts) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}`, {
-				method: "DELETE",
-				signal: opts?.signal
-			})
-		},
-		indexing: {
-			publish: (url, type, opts) => fetch(`${INDEXING_API}/v3/urlNotifications:publish`, {
-				method: "POST",
-				body: {
-					url,
-					type
-				},
-				signal: opts?.signal
-			}),
-			getMetadata: (url, opts) => fetch(`${INDEXING_API}/v3/urlNotifications/metadata`, {
-				query: { url },
-				signal: opts?.signal
-			})
-		},
-		searchAnalytics: { query: querySearchAnalytics }
-	};
-}
-const INDEXING_ISSUE_FILTERS = {
-	canonical_mismatch: `user_canonical IS NOT NULL AND google_canonical IS NOT NULL AND user_canonical != google_canonical`,
-	stale_crawl: `last_crawl_time < datetime('now', '-30 days')`,
-	very_stale_crawl: `last_crawl_time < datetime('now', '-60 days')`,
-	not_indexed: `verdict IN ('FAIL', 'PARTIAL', 'NEUTRAL')`,
-	unknown_to_google: `coverage_state = 'URL is unknown to Google'`,
-	crawled_not_indexed: `coverage_state = 'Crawled - currently not indexed'`,
-	discovered_not_indexed: `coverage_state = 'Discovered - currently not indexed'`,
-	not_found: `page_fetch_state = 'NOT_FOUND' OR coverage_state = 'Not found (404)'`,
-	soft_404: `page_fetch_state = 'SOFT_404' OR coverage_state = 'Soft 404'`,
-	server_error: `page_fetch_state = 'SERVER_ERROR' OR coverage_state = 'Server error (5xx)'`,
-	access_forbidden: `page_fetch_state = 'ACCESS_FORBIDDEN' OR coverage_state = 'Blocked due to access forbidden (403)'`,
-	access_denied: `page_fetch_state = 'ACCESS_DENIED' OR coverage_state = 'Blocked due to unauthorized request (401)'`,
-	blocked_4xx: `page_fetch_state = 'BLOCKED_4XX' OR coverage_state = 'Blocked due to other 4xx issue'`,
-	redirect_error: `page_fetch_state = 'REDIRECT_ERROR' OR coverage_state = 'Redirect error'`,
-	crawl_error: `page_fetch_state IN ('INTERNAL_CRAWL_ERROR', 'INVALID_URL')`,
-	blocked_robots: `robots_txt_state = 'DISALLOWED'`,
-	noindex: `indexing_state LIKE '%noindex%' OR coverage_state LIKE '%noindex%'`,
-	redirect: `coverage_state = 'Page with redirect'`,
-	sitemap_redirect: `coverage_state = 'Page with redirect' AND sitemaps IS NOT NULL AND sitemaps != '[]'`,
-	alternate_canonical: `coverage_state = 'Alternate page with proper canonical tag'`,
-	duplicate_no_canonical: `coverage_state = 'Duplicate without user-selected canonical'`,
-	page_removed: `coverage_state = 'Blocked by page removal tool'`,
-	fragment_url: `url LIKE '%#%'`,
-	mobile_fail: `mobile_verdict IN ('FAIL', 'PARTIAL')`,
-	rich_results_fail: `rich_results_verdict = 'FAIL'`,
-	rich_results_warning: `rich_results_verdict = 'PARTIAL'`,
-	rich_results_pass: `rich_results_verdict = 'PASS'`
-};
-const INDEXING_ISSUE_LABELS = {
-	canonical_mismatch: "Canonical mismatch",
-	stale_crawl: "Not crawled in 30+ days",
-	very_stale_crawl: "Not crawled in 60+ days",
-	not_indexed: "Not indexed",
-	unknown_to_google: "Unknown to Google",
-	crawled_not_indexed: "Crawled but not indexed",
-	discovered_not_indexed: "Discovered but not indexed",
-	not_found: "404 Not Found",
-	soft_404: "Soft 404",
-	server_error: "Server error",
-	access_forbidden: "Blocked: forbidden (403)",
-	access_denied: "Blocked: unauthorized (401)",
-	blocked_4xx: "Blocked: other 4xx",
-	redirect_error: "Redirect error",
-	crawl_error: "Crawl error",
-	blocked_robots: "Blocked by robots.txt",
-	noindex: "Noindex tag",
-	redirect: "Redirect",
-	sitemap_redirect: "Sitemap URL redirects",
-	alternate_canonical: "Alternate page with canonical",
-	duplicate_no_canonical: "Duplicate, no canonical declared",
-	page_removed: "Removed via removal tool",
-	fragment_url: "Fragment URL (#)",
-	mobile_fail: "Mobile usability issues",
-	rich_results_fail: "Rich results errors",
-	rich_results_warning: "Rich results warnings",
-	rich_results_pass: "Has rich results"
-};
-const INDEXING_ISSUE_SEVERITY = {
-	canonical_mismatch: "warning",
-	stale_crawl: "info",
-	very_stale_crawl: "warning",
-	not_indexed: "error",
-	unknown_to_google: "warning",
-	crawled_not_indexed: "error",
-	discovered_not_indexed: "warning",
-	not_found: "error",
-	soft_404: "error",
-	server_error: "error",
-	access_forbidden: "error",
-	access_denied: "error",
-	blocked_4xx: "error",
-	redirect_error: "error",
-	crawl_error: "warning",
-	blocked_robots: "warning",
-	noindex: "info",
-	redirect: "info",
-	sitemap_redirect: "warning",
-	alternate_canonical: "info",
-	duplicate_no_canonical: "warning",
-	page_removed: "info",
-	fragment_url: "warning",
-	mobile_fail: "warning",
-	rich_results_fail: "error",
-	rich_results_warning: "warning",
-	rich_results_pass: "info"
-};
-const KNOWN_PAGE_FETCH_STATES = /* @__PURE__ */ new Set([
-	"PAGE_FETCH_STATE_UNSPECIFIED",
-	"SUCCESSFUL",
-	"SOFT_404",
-	"BLOCKED_ROBOTS_TXT",
-	"NOT_FOUND",
-	"ACCESS_DENIED",
-	"SERVER_ERROR",
-	"REDIRECT_ERROR",
-	"ACCESS_FORBIDDEN",
-	"BLOCKED_4XX",
-	"INTERNAL_CRAWL_ERROR",
-	"INVALID_URL"
-]);
-const KNOWN_COVERAGE_STATES = /* @__PURE__ */ new Set([
-	"Submitted and indexed",
-	"Indexed, not submitted in sitemap",
-	"Indexed, though blocked by robots.txt",
-	"Indexed; consider marking as canonical",
-	"URL is unknown to Google",
-	"Crawled - currently not indexed",
-	"Discovered - currently not indexed",
-	"Not found (404)",
-	"Soft 404",
-	"Server error (5xx)",
-	"Blocked due to access forbidden (403)",
-	"Blocked due to unauthorized request (401)",
-	"Blocked due to other 4xx issue",
-	"Redirect error",
-	"Blocked by robots.txt",
-	"Excluded by ‘noindex’ tag",
-	"Page with redirect",
-	"Alternate page with proper canonical tag",
-	"Duplicate without user-selected canonical",
-	"Duplicate, Google chose different canonical than user",
-	"Blocked by page removal tool"
-]);
-function unmappedInspectionReasons(rows) {
-	const coverageStates = /* @__PURE__ */ new Set();
-	const pageFetchStates = /* @__PURE__ */ new Set();
-	for (const row of rows) {
-		const coverage = row.coverageState?.trim();
-		if (coverage && !KNOWN_COVERAGE_STATES.has(coverage)) coverageStates.add(coverage);
-		const fetchState = row.pageFetchState?.trim();
-		if (fetchState && !KNOWN_PAGE_FETCH_STATES.has(fetchState)) pageFetchStates.add(fetchState);
-	}
-	return {
-		coverageStates: [...coverageStates],
-		pageFetchStates: [...pageFetchStates]
-	};
-}
-const SCHEME_RE = /^(sc-domain:|https?:\/\/)/;
-function parseGscSiteUrl(siteUrl) {
-	const isDomain = siteUrl.startsWith("sc-domain:");
-	let hostname = siteUrl;
-	if (isDomain) hostname = siteUrl.slice(10);
-	else try {
-		hostname = new URL(siteUrl).hostname;
-	} catch {
-		hostname = siteUrl;
-	}
-	const displayLabel = siteUrl.replace(SCHEME_RE, "").replace(/\/$/, "");
-	return {
-		label: siteUrl,
-		hostname,
-		displayLabel,
-		propertyType: isDomain ? "domain" : "url-prefix",
-		isDomain
-	};
-}
-function normalizeGscSiteUrl(siteUrl) {
-	return siteUrl.replace(/^sc-domain:/, "").replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/$/, "").toLowerCase();
-}
-function normalizeRegistrationTarget(inputUrl) {
-	const trimmed = inputUrl.trim();
-	if (!trimmed) return null;
-	const inputParsed = parseGscSiteUrl(trimmed);
-	if (inputParsed.isDomain) return inputParsed.hostname.toLowerCase();
-	return trimmed.match(/^(?:https?:\/\/)?([^/]+)/)?.[1]?.toLowerCase() ?? null;
-}
-const VERIFIED_PERMISSIONS = /* @__PURE__ */ new Set([
-	"siteOwner",
-	"siteFullUser",
-	"siteRestrictedUser"
-]);
-function isVerifiedGscProperty(property) {
-	return !!property?.permissionLevel && VERIFIED_PERMISSIONS.has(property.permissionLevel);
-}
-function isVerifiedGscPermission(level) {
-	return !!level && VERIFIED_PERMISSIONS.has(level);
-}
-const stripWww = (d) => d.replace(/^www\./, "");
-function gscPropertyMatchesTarget(targetDomain, propertyUrl) {
-	if (!propertyUrl) return false;
-	const cleanTarget = stripWww(targetDomain);
-	const parsed = parseGscSiteUrl(propertyUrl);
-	if (parsed.isDomain) return cleanTarget === parsed.hostname || cleanTarget.endsWith(`.${parsed.hostname}`);
-	const match = propertyUrl.match(/^https?:\/\/([^/]+)/);
-	return !!match && stripWww(match[1].toLowerCase()) === cleanTarget;
-}
-function matchGscSite(siteUrl, gscSiteUrl) {
-	if (!siteUrl || !gscSiteUrl) return false;
-	const getHostname = (url) => {
-		if (url.startsWith("sc-domain:")) return url.replace("sc-domain:", "");
-		try {
-			return new URL(url).hostname;
-		} catch {
-			return url;
-		}
-	};
-	return gscPropertyMatchesTarget(getHostname(siteUrl), gscSiteUrl);
-}
-function pickBestGscProperty(origin, availableSites) {
-	const matches = availableSites.filter((p) => matchGscSite(origin, p.siteUrl));
-	if (!matches.length) return void 0;
-	const isDomain = (p) => !!p.siteUrl?.startsWith("sc-domain:");
-	const isHttps = (p) => !!p.siteUrl?.startsWith("https://");
-	const pickTier = (pool) => pool.find(isDomain) ?? pool.find(isHttps) ?? pool[0];
-	const verified = matches.filter((p) => isVerifiedGscPermission(p.permissionLevel));
-	const pool = verified.length ? verified : matches;
-	const originHost = stripWww(parseGscSiteUrl(origin).hostname.toLowerCase());
-	const exact = pool.filter((property) => {
-		if (!property.siteUrl) return false;
-		return stripWww(parseGscSiteUrl(property.siteUrl).hostname.toLowerCase()) === originHost;
-	});
-	return pickTier(exact.length ? exact : pool);
-}
-function findBestGscProperty(targetDomain, properties) {
-	const cleanTarget = stripWww(targetDomain);
-	const domainProperty = properties.find((property) => {
-		if (!property.siteUrl) return false;
-		const parsed = parseGscSiteUrl(property.siteUrl);
-		if (!parsed.isDomain) return false;
-		return cleanTarget === parsed.hostname || cleanTarget.endsWith(`.${parsed.hostname}`);
-	});
-	const urlProperty = properties.find((property) => {
-		if (!property.siteUrl) return false;
-		const match = property.siteUrl.match(/^https?:\/\/([^/]+)/);
-		return match && stripWww(match[1].toLowerCase()) === cleanTarget;
-	});
-	return {
-		matchedSite: (isVerifiedGscProperty(domainProperty) ? domainProperty : isVerifiedGscProperty(urlProperty) ? urlProperty : domainProperty || urlProperty) ?? null,
-		domainProperty: domainProperty ?? null,
-		urlProperty: urlProperty ?? null
-	};
-}
-function findExactGscProperty(propertyUrl, properties) {
-	return properties.find((property) => property.siteUrl === propertyUrl) ?? null;
-}
-function formatGscPropertyCandidates(candidates) {
-	return candidates.filter((c) => !!c).map((property) => `${property.siteUrl} (${property.permissionLevel})`).join(", ");
-}
-const URL_INSPECTION_EFFECTIVE_LIMIT = 1800;
-const FETCH_TIMEOUT_MS = 1e4;
-const COMMON_PATHS = ["/sitemap.xml", "/sitemap_index.xml"];
-const SITEMAP_DIRECTIVE_RE = /^Sitemap:\s*(\S+)/im;
-async function discoverSitemap(domain, options = {}) {
-	const userAgent = options.userAgent ?? "gscdump sitemap fetcher";
-	const baseUrl = `https://${domain}`;
-	const signalFor = () => options.signal ?? AbortSignal.timeout(FETCH_TIMEOUT_MS);
-	const robotsRes = await fetch(`${baseUrl}/robots.txt`, {
-		headers: { "User-Agent": userAgent },
-		signal: signalFor()
-	}).catch(() => null);
-	if (robotsRes?.ok) {
-		const match = (await robotsRes.text()).match(SITEMAP_DIRECTIVE_RE);
-		if (match?.[1]) {
-			if ((await fetch(match[1], {
-				method: "HEAD",
-				signal: signalFor()
-			}).catch(() => null))?.ok) return match[1];
-		}
-	}
-	for (const path of COMMON_PATHS) {
-		const url = `${baseUrl}${path}`;
-		if ((await fetch(url, {
-			method: "HEAD",
-			headers: { "User-Agent": userAgent },
-			signal: signalFor()
-		}).catch(() => null))?.ok) return url;
-	}
-	return null;
-}
-const LOC_RE = /<loc>([^<]+)<\/loc>/gi;
-const SITEMAPINDEX_RE = /<sitemapindex\b/i;
-async function fetchSitemapUrls(sitemapUrl, options = {}) {
-	const userAgent = options.userAgent ?? "gscdump sitemap fetcher";
-	const maxDepth = options.maxDepth ?? 3;
-	const limit = options.limit;
-	const signalFor = () => options.signal ?? AbortSignal.timeout(FETCH_TIMEOUT_MS);
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	const visit = async (url, depth) => {
-		if (limit != null && out.length >= limit) return;
-		if (depth > maxDepth) return;
-		const res = await fetch(url, {
-			headers: { "User-Agent": userAgent },
-			signal: signalFor()
-		});
-		if (!res.ok) throw new Error(`Fetch ${url} failed: ${res.status}`);
-		const text = await res.text();
-		if (SITEMAPINDEX_RE.test(text)) {
-			for (const match of text.matchAll(LOC_RE)) {
-				if (limit != null && out.length >= limit) return;
-				const child = match[1].trim();
-				if (!child) continue;
-				await visit(child, depth + 1);
-			}
-			return;
-		}
-		for (const match of text.matchAll(LOC_RE)) {
-			const u = match[1].trim();
-			if (!u) continue;
-			if (seen.has(u)) continue;
-			seen.add(u);
-			out.push(u);
-			if (limit != null && out.length >= limit) return;
-		}
-	};
-	await visit(sitemapUrl, 0);
-	return out;
-}
-function urlMatchKey(url) {
-	const u = URL.parse(url);
-	if (!u) return null;
-	return [u.hostname.replace(/^www\./, ""), u.pathname.replace(/\/$/, "") || "/"].join("").toLowerCase();
-}
+import { urlMatchKey } from "./url.mjs";
 export { DAYS_PER_RANGE, DEFAULT_GSC_REQUEST_TIMEOUT_MS, GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_INDEXING_SCOPE, GSC_READ_SCOPE, GSC_RETENTION_MONTHS, GSC_SITE_VERIFICATION_SCOPE, GSC_WRITE_SCOPE, GscApiError, INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, MS_PER_DAY, URL_INSPECTION_EFFECTIVE_LIMIT, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, classifyError, countDays, createAuth, createFetch, decodeSiteId, deleteSite, deleteSitemap, discoverSitemap, encodeSiteId, err, exchangeAuthCodeResult, fetchSitemap, fetchSitemapUrls, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, findBestGscProperty, findExactGscProperty, formatGscPropertyCandidates, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getIndexingEligibility, getIndexingMetadata, getLatestGscDate, getNextCheckAfter, getNextCheckPriority, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, getVerificationToken, getVerifiedSite, googleSearchConsole, groupIntoRanges, gscErrorToException, gscPropertyMatchesTarget, hasGoogleScope, hasGscReadScope, hasGscWriteScope, hasIndexingScope, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, inspectUrl, inspectUrlFlat, introspectAccessToken, introspectAccessTokenResult, isErr, isOk, isPermissionDeniedError, isValidGscDate, isVerifiedGscPermission, isVerifiedGscProperty, lifecycleErrorCodes, listVerifiedSites, matchGscSite, normalizeGscSiteUrl, normalizeRegistrationTarget, normalizeSiteUrl, normalizeUrl, ok, parseGoogleError, parseGrantedScopes, parseGscSiteUrl, pickBestGscProperty, propertyNextActions, propertyStatuses, querySourceModes, refreshAccessToken, requestIndexing, resolveVerificationTarget, rethrowAsGscApiError, revokeOAuthToken, revokeOAuthTokenResult, runSequentialBatch, siteUrlToVerificationSite, sitemapNextActions, sitemapStatuses, submitSitemap, toIsoDate, unmappedInspectionReasons, unverifySite, unwrapResult, urlMatchKey, verificationMethodsFor, verifySite };