gscdump 3.7.0 → 4.0.0

package/dist/api/inspection.d.mts

@@ -12,6 +12,16 @@ export declare function inspectUrl(client: GoogleSearchConsoleClient, siteUrl: s
   inspection: UrlInspectionResult | undefined;
   isIndexed: boolean;
 }>;
+/** Google's URL Inspection quota for each property. */
+export declare const URL_INSPECTION_QUOTA: {
+  readonly perDay: 2000;
+  readonly perMinute: 600;
+};
+/**
+ * Plain text for a failed URL Inspection call. The generic 403 and 429 texts
+ * do not say what URL Inspection needs, so these name the real limits.
+ */
+export declare function describeInspectionError(cause: unknown): string;
 /**
  * Batch inspect multiple URLs with rate limiting.
  * Returns inspection results for each URL.

package/dist/api/inspection.mjs

@@ -1,4 +1,5 @@
 import { runSequentialBatch } from "./batch.mjs";
+import { classifyError } from "../core/errors.mjs";
 import { hasGscReadScope } from "../core/scopes.mjs";
 async function inspectUrl(client, siteUrl, inspectionUrl) {
 	const inspection = (await client.inspect(siteUrl, inspectionUrl)).inspectionResult;
@@ -7,6 +8,16 @@ async function inspectUrl(client, siteUrl, inspectionUrl) {
 		isIndexed: inspection?.indexStatusResult?.verdict === "PASS"
 	};
 }
+const URL_INSPECTION_QUOTA = {
+	perDay: 2e3,
+	perMinute: 600
+};
+function describeInspectionError(cause) {
+	const error = classifyError(cause);
+	if (error.kind === "rate-limited") return `URL Inspection quota reached. Google allows ${URL_INSPECTION_QUOTA.perDay.toLocaleString("en-US")} inspections per day and ${URL_INSPECTION_QUOTA.perMinute} per minute for each property.`;
+	if (error.kind === "permission-denied") return "The URL is outside this property, or you are not a full user or owner of the property.";
+	return error.message;
+}
 async function batchInspectUrls(client, siteUrl, urls, options = {}) {
 	const { delayMs = 200, concurrency, onProgress } = options;
 	return runSequentialBatch(urls, async (url) => {
@@ -136,4 +147,4 @@ function getIndexingEligibility(grantedScopes, permissionLevel) {
 		grantedScopes: scopes
 	};
 }
-export { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat };
+export { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, URL_INSPECTION_QUOTA, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, describeInspectionError, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat };

package/dist/core/client.mjs

@@ -1,3 +1,4 @@
+import { classifyError } from "./errors.mjs";
 import { refreshAccessToken } from "../api/oauth.mjs";
 import { resolveToBody } from "../query/resolver.mjs";
 import { rowWithMetricDefaults } from "./cli-format.mjs";
@@ -49,14 +50,30 @@ async function resolveToken(auth) {
 	if ("credentials" in auth && auth.credentials) return auth.credentials.access_token || "";
 	return "";
 }
+function isQuota403(body) {
+	return classifyError({
+		status: 403,
+		data: body
+	}).kind === "rate-limited";
+}
 function createFetch(auth, options) {
 	const authState = typeof auth === "object" && auth !== null && "clientId" in auth && "refreshToken" in auth && !("getAccessToken" in auth) ? createAuth(auth) : auth;
 	const headers = new Headers(options?.headers);
 	if (!headers.has("Accept-Encoding")) headers.set("Accept-Encoding", "gzip");
 	if (!headers.has("User-Agent")) headers.set("User-Agent", "gscdump (gzip)");
+	const baseRetryStatusCodes = options?.retryStatusCodes ?? [
+		408,
+		425,
+		429,
+		500,
+		502,
+		503,
+		504
+	];
+	const retries = options?.retry ?? 3;
 	return ofetch.create({
 		...options,
-		retry: options?.retry ?? 3,
+		retry: retries,
 		retryDelay: options?.retryDelay ?? ((ctx) => {
 			const status = ctx.response?.status;
 			if (status === 429 || status === 503) {
@@ -68,17 +85,10 @@ function createFetch(auth, options) {
 					if (Number.isFinite(when)) return Math.max(0, when - Date.now());
 				}
 			}
+			if (status === 403 && typeof ctx.options.retry === "number" && typeof retries === "number") return 5e3 * 3 ** Math.max(0, retries - ctx.options.retry);
 			return 1e3;
 		}),
-		retryStatusCodes: options?.retryStatusCodes ?? [
-			408,
-			425,
-			429,
-			500,
-			502,
-			503,
-			504
-		],
+		retryStatusCodes: baseRetryStatusCodes,
 		timeout: options?.timeout ?? 3e4,
 		headers,
 		async onRequest(ctx) {
@@ -93,7 +103,9 @@ function createFetch(auth, options) {
 			}
 		},
 		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.");
+			const retryable = new Set(baseRetryStatusCodes);
+			if (ctx.response.status === 403 && isQuota403(ctx.response._data)) retryable.add(403);
+			if (ctx.options) ctx.options.retryStatusCodes = [...retryable];
 			if (options?.onResponseError) {
 				if (Array.isArray(options.onResponseError)) for (const handler of options.onResponseError) await handler(ctx);
 				else await options.onResponseError(ctx);

package/dist/core/errors.d.mts

@@ -1,8 +1,12 @@
-export type GscErrorKind = 'auth-expired' | 'rate-limited' | 'not-found' | 'validation' | 'storage' | 'transport';
+export type GscErrorKind = 'auth-expired' | 'permission-denied' | 'rate-limited' | 'not-found' | 'validation' | 'storage' | 'transport';
 export type GscError = {
   kind: 'auth-expired';
   message: string;
   cause: unknown;
+} | {
+  kind: 'permission-denied';
+  message: string;
+  cause: unknown;
 } | {
   kind: 'rate-limited';
   message: string;

package/dist/core/errors.mjs

@@ -25,7 +25,6 @@ function extractStatus(error) {
 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, [
 		[
@@ -33,6 +32,7 @@ function extractMessage(error) {
 			"error",
 			"message"
 		],
+		["data", "error_description"],
 		["message"],
 		["statusMessage"]
 	], isString) ?? String(error);
@@ -59,7 +59,7 @@ function extractRetryAfter(error) {
 		return Number.isNaN(seconds) ? void 0 : seconds;
 	}
 }
-const QUOTA_MESSAGE_RE = /quota|rate\s*limit/i;
+const QUOTA_MESSAGE_RE = /quota|rate\s*limit|\bqps\b/i;
 const QUOTA_REASONS = /* @__PURE__ */ new Set([
 	"dailyLimitExceeded",
 	"dailyLimitExceededUnreg",
@@ -120,7 +120,7 @@ function classifyError(cause) {
 			cause
 		};
 		return {
-			kind: "auth-expired",
+			kind: "permission-denied",
 			message,
 			cause
 		};

package/dist/core/gsc-dates.d.mts

@@ -8,8 +8,13 @@ export declare const GSC_FINALIZED_LAG_DAYS = 3;
 export declare const GSC_FRESHEST_LAG_DAYS = 1;
 /** Approximate historical retention window for Search Analytics. */
 export declare const GSC_RETENTION_MONTHS = 16;
-/** Today's date (YYYY-MM-DD) in PST. */
-export declare function getPstDate(): string;
+/** Today's date (YYYY-MM-DD) in PST, whatever the machine's time zone. */
+export declare function getPstDate(now?: Date): string;
+/**
+ * Start of the next PST reporting day, in epoch milliseconds. Google resets
+ * its daily quotas then.
+ */
+export declare function getNextPstMidnight(now?: Date): number;
 /** YYYY-MM-DD for `now() - n` days, UTC. */
 export declare function daysAgo(n: number): string;
 /** Most recent finalized date (3 days ago PST). */

package/dist/core/gsc-dates.mjs

@@ -5,13 +5,28 @@ function toIsoDate(d) {
 const GSC_FINALIZED_LAG_DAYS = 3;
 const GSC_FRESHEST_LAG_DAYS = 1;
 const GSC_RETENTION_MONTHS = 16;
-function getPstDate() {
-	return (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA", { timeZone: "America/Los_Angeles" });
+let pstFormatter;
+function getPstDate(now = /* @__PURE__ */ new Date()) {
+	pstFormatter ??= new Intl.DateTimeFormat("en-CA", {
+		timeZone: "America/Los_Angeles",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	});
+	const parts = pstFormatter.formatToParts(now);
+	const get = (type) => parts.find((part) => part.type === type).value;
+	return `${get("year")}-${get("month")}-${get("day")}`;
 }
 function getPstDateDaysAgo(daysAgo) {
-	const pstNow = new Date((/* @__PURE__ */ new Date()).toLocaleString("en-US", { timeZone: "America/Los_Angeles" }));
-	pstNow.setDate(pstNow.getDate() - daysAgo);
-	return toIsoDate(pstNow);
+	return addDays(getPstDate(), -daysAgo);
+}
+function getNextPstMidnight(now = /* @__PURE__ */ new Date()) {
+	const tomorrow = addDays(getPstDate(now), 1);
+	for (const offsetHours of [7, 8]) {
+		const at = Date.parse(`${tomorrow}T00:00:00Z`) + offsetHours * 36e5;
+		if (getPstDate(new Date(at)) === tomorrow && getPstDate(/* @__PURE__ */ new Date(at - 1)) !== tomorrow) return at;
+	}
+	return Date.parse(`${tomorrow}T08:00:00Z`);
 }
 function daysAgo(n) {
 	return toIsoDate(/* @__PURE__ */ new Date(Date.now() - n * MS_PER_DAY));
@@ -68,8 +83,8 @@ function countDays(startDate, endDate) {
 	return Math.round((Date.parse(`${endDate}T00:00:00Z`) - Date.parse(`${startDate}T00:00:00Z`)) / MS_PER_DAY) + 1;
 }
 function getOldestGscDate() {
-	const date = /* @__PURE__ */ new Date();
-	date.setMonth(date.getMonth() - 16);
+	const date = /* @__PURE__ */ new Date(`${getPstDate()}T00:00:00Z`);
+	date.setUTCMonth(date.getUTCMonth() - 16);
 	return toIsoDate(date);
 }
 function addDays(dateStr, n) {
@@ -97,4 +112,4 @@ function getBackfillProgress(oldestDateSynced, newestDateSynced) {
 		isComplete: oldestDateSynced <= oldestGsc
 	};
 }
-export { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, daysAgo, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, groupIntoRanges, isValidGscDate, toIsoDate };
+export { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, daysAgo, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getNextPstMidnight, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, groupIntoRanges, isValidGscDate, toIsoDate };

package/dist/core/property.d.mts

@@ -37,4 +37,44 @@ export declare function findBestGscProperty<T extends GscPropertyCandidate>(targ
   urlProperty: T | null;
 };
 export declare function findExactGscProperty<T extends GscPropertyCandidate>(propertyUrl: string, properties: readonly T[]): T | null;
-export declare function formatGscPropertyCandidates(candidates: ReadonlyArray<GscPropertyCandidate | null | undefined>): string;
+export declare function formatGscPropertyCandidates(candidates: ReadonlyArray<GscPropertyCandidate | null | undefined>): string;
+/** One Site the resolver may pick. `inStore` marks a Site with local data. */
+export interface SiteCandidate {
+  siteUrl: string;
+  inStore?: boolean;
+}
+/**
+ * Outcome of matching user input to a Site. `covered-by-parent` means a
+ * domain property covers the input, but the input names a narrower scope
+ * (a subdomain or a path). Callers must never swap one for the other
+ * silently: the parent Site holds more data than the input asked for.
+ */
+export type SiteResolution = {
+  kind: 'resolved';
+  siteUrl: string;
+  via: 'exact' | 'host';
+} | {
+  kind: 'ambiguous';
+  input: string;
+  candidates: string[];
+} | {
+  kind: 'covered-by-parent';
+  input: string;
+  parent: string;
+} | {
+  kind: 'not-found';
+  input: string;
+  known: string[];
+};
+/**
+ * Resolve what a person typed for `--site` to one Site from `candidates`.
+ *
+ * - An exact Site URL match wins, ignoring case and a trailing slash.
+ * - Otherwise the input matches on its Site root: scheme, `www.`, case and
+ *   a trailing slash are ignored. Hosts compare whole, never as substrings.
+ * - Among several root matches, a Site with Store data wins, then a domain
+ *   property, then the one whose `www.` matches the input, then HTTPS.
+ * - A domain property that only covers the input (a subdomain or a path)
+ *   returns `covered-by-parent`.
+ */
+export declare function resolveSiteInput(input: string, candidates: readonly SiteCandidate[]): SiteResolution;

package/dist/core/property.mjs

@@ -71,4 +71,129 @@ function findExactGscProperty(propertyUrl, properties) {
 function formatGscPropertyCandidates(candidates) {
 	return candidates.filter((c) => !!c).map((property) => `${property.siteUrl} (${property.permissionLevel})`).join(", ");
 }
-export { findBestGscProperty, findExactGscProperty, formatGscPropertyCandidates, gscPropertyMatchesTarget, isVerifiedGscPermission, isVerifiedGscProperty, matchGscSite, pickBestGscProperty };
+const INPUT_SCHEME_RE = /^[a-z][\w+.-]*:\/\//i;
+const SC_DOMAIN_PREFIX_RE = /^sc-domain:/i;
+const TRAILING_SLASHES_RE = /\/+$/;
+function parseSiteKey(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	if (SC_DOMAIN_PREFIX_RE.test(trimmed)) {
+		const host = trimmed.replace(SC_DOMAIN_PREFIX_RE, "").replace(TRAILING_SLASHES_RE, "").toLowerCase();
+		return host ? {
+			host,
+			bareHost: stripWww(host),
+			path: "",
+			domain: true,
+			https: false
+		} : null;
+	}
+	const https = /^https:\/\//i.test(trimmed);
+	const rest = trimmed.replace(INPUT_SCHEME_RE, "").split(/[?#]/)[0];
+	const slash = rest.indexOf("/");
+	const host = (slash === -1 ? rest : rest.slice(0, slash)).toLowerCase();
+	if (!host) return null;
+	const path = slash === -1 ? "" : rest.slice(slash).replace(TRAILING_SLASHES_RE, "").toLowerCase();
+	return {
+		host,
+		bareHost: stripWww(host),
+		path,
+		domain: false,
+		https
+	};
+}
+function sameSiteUrl(a, b) {
+	const normalize = (value) => value.trim().replace(TRAILING_SLASHES_RE, "").toLowerCase();
+	return normalize(a) === normalize(b);
+}
+function resolveSiteInput(input, candidates) {
+	const unique = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const prior = unique.get(candidate.siteUrl);
+		unique.set(candidate.siteUrl, {
+			siteUrl: candidate.siteUrl,
+			inStore: !!(prior?.inStore || candidate.inStore)
+		});
+	}
+	const pool = [...unique.values()];
+	const known = pool.map((candidate) => candidate.siteUrl);
+	const exact = pool.filter((candidate) => sameSiteUrl(candidate.siteUrl, input));
+	if (exact.length === 1) return {
+		kind: "resolved",
+		siteUrl: exact[0].siteUrl,
+		via: "exact"
+	};
+	if (exact.length > 1) {
+		const verbatim = exact.find((candidate) => candidate.siteUrl === input.trim());
+		return verbatim ? {
+			kind: "resolved",
+			siteUrl: verbatim.siteUrl,
+			via: "exact"
+		} : {
+			kind: "ambiguous",
+			input,
+			candidates: exact.map((candidate) => candidate.siteUrl)
+		};
+	}
+	const key = parseSiteKey(input);
+	if (!key) return {
+		kind: "not-found",
+		input,
+		known
+	};
+	const keyed = pool.flatMap((candidate) => {
+		const candidateKey = parseSiteKey(candidate.siteUrl);
+		return candidateKey ? [{
+			candidate,
+			key: candidateKey
+		}] : [];
+	});
+	const matches = keyed.filter((entry) => entry.key.bareHost === key.bareHost && entry.key.path === key.path);
+	if (matches.length > 0) {
+		const ranked = narrow(matches, [
+			(entry) => !!entry.candidate.inStore,
+			(entry) => entry.key.domain,
+			(entry) => entry.key.host === key.host,
+			(entry) => entry.key.https
+		]);
+		return ranked.length === 1 ? {
+			kind: "resolved",
+			siteUrl: ranked[0].candidate.siteUrl,
+			via: "host"
+		} : {
+			kind: "ambiguous",
+			input,
+			candidates: ranked.map((entry) => entry.candidate.siteUrl)
+		};
+	}
+	const parents = keyed.filter((entry) => entry.key.bareHost === key.bareHost && entry.key.path !== "" && key.path.startsWith(`${entry.key.path}/`) || entry.key.bareHost === key.bareHost && entry.key.path === "" || entry.key.domain && key.bareHost.endsWith(`.${entry.key.bareHost}`));
+	if (parents.length > 0) {
+		const specificity = (entry) => entry.key.bareHost.length + entry.key.path.length;
+		const closest = Math.max(...parents.map(specificity));
+		const [parent] = narrow(parents.filter((entry) => specificity(entry) === closest), [
+			(entry) => !!entry.candidate.inStore,
+			(entry) => entry.key.domain,
+			(entry) => entry.key.host === key.host,
+			(entry) => entry.key.https
+		]);
+		return {
+			kind: "covered-by-parent",
+			input,
+			parent: parent.candidate.siteUrl
+		};
+	}
+	return {
+		kind: "not-found",
+		input,
+		known
+	};
+}
+function narrow(entries, rules) {
+	let pool = [...entries];
+	for (const rule of rules) {
+		const kept = pool.filter(rule);
+		if (kept.length > 0) pool = kept;
+		if (pool.length === 1) break;
+	}
+	return pool;
+}
+export { findBestGscProperty, findExactGscProperty, formatGscPropertyCandidates, gscPropertyMatchesTarget, isVerifiedGscPermission, isVerifiedGscProperty, matchGscSite, pickBestGscProperty, resolveSiteInput };

package/dist/core/window.d.mts

@@ -1,12 +1,26 @@
-export type WindowPreset = 'last-7d' | 'last-28d' | 'last-30d' | 'last-90d' | 'last-180d' | 'last-365d' | 'mtd' | 'ytd' | 'custom';
+export type WindowPreset = 'last-7d' | 'last-28d' | 'last-30d' | 'last-90d' | 'last-180d' | 'last-365d' | 'mtd' | 'qtd' | 'ytd' | 'last-quarter' | 'custom';
+/**
+ * `yoy` shifts the window back 364 days (52 weeks), so each day compares
+ * against the same weekday one year earlier. Search traffic has a strong
+ * weekly cycle, so a 365-day shift would compare Mondays with Sundays.
+ */
 export type ComparisonMode = 'none' | 'prev-period' | 'yoy';
-export interface ResolveWindowOptions {
-  preset: WindowPreset;
+/**
+ * `anchor` is the last day the window may include: the newest complete date
+ * in the data, never the wall clock. Callers pass the Store's newest synced
+ * date, or `getLatestGscDate()` for live reads. Custom windows take explicit
+ * bounds and need no anchor.
+ */
+export type ResolveWindowOptions = {
+  preset: Exclude<WindowPreset, 'custom'>;
+  anchor: string;
   comparison?: ComparisonMode;
-  anchor?: string;
-  start?: string;
-  end?: string;
-}
+} | {
+  preset: 'custom';
+  start: string;
+  end: string;
+  comparison?: ComparisonMode;
+};
 export interface ResolvedWindow {
   start: string;
   end: string;
@@ -16,4 +30,5 @@ export interface ResolvedWindow {
     end: string;
   };
 }
+/** Pure: the same options always resolve to the same window. */
 export declare function resolveWindow(opts: ResolveWindowOptions): ResolvedWindow;

package/dist/core/window.mjs

@@ -1,46 +1,57 @@
 import { addDays, countDays, toIsoDate } from "./gsc-dates.mjs";
+const ROLLING_DAYS = {
+	"last-7d": 7,
+	"last-28d": 28,
+	"last-30d": 30,
+	"last-90d": 90,
+	"last-180d": 180,
+	"last-365d": 365
+};
+function presetBounds(preset, anchorIso) {
+	const rolling = ROLLING_DAYS[preset];
+	if (rolling) return {
+		start: addDays(anchorIso, -(rolling - 1)),
+		end: anchorIso
+	};
+	const anchor = /* @__PURE__ */ new Date(`${anchorIso}T00:00:00Z`);
+	const year = anchor.getUTCFullYear();
+	const quarterStartMonth = Math.floor(anchor.getUTCMonth() / 3) * 3;
+	switch (preset) {
+		case "mtd": return {
+			start: toIsoDate(new Date(Date.UTC(year, anchor.getUTCMonth(), 1))),
+			end: anchorIso
+		};
+		case "qtd": return {
+			start: toIsoDate(new Date(Date.UTC(year, quarterStartMonth, 1))),
+			end: anchorIso
+		};
+		case "ytd": return {
+			start: toIsoDate(new Date(Date.UTC(year, 0, 1))),
+			end: anchorIso
+		};
+		case "last-quarter": {
+			const nextQuarterStart = new Date(Date.UTC(year, quarterStartMonth + 3, 1));
+			const startMonth = addDays(toIsoDate(nextQuarterStart), -1) === anchorIso ? quarterStartMonth : quarterStartMonth - 3;
+			return {
+				start: toIsoDate(new Date(Date.UTC(year, startMonth, 1))),
+				end: addDays(toIsoDate(new Date(Date.UTC(year, startMonth + 3, 1))), -1)
+			};
+		}
+		default: throw new Error(`resolveWindow: unknown preset ${preset}`);
+	}
+}
 function resolveWindow(opts) {
-	const anchor = opts.anchor ? /* @__PURE__ */ new Date(`${opts.anchor}T00:00:00Z`) : /* @__PURE__ */ new Date();
-	const anchorIso = toIsoDate(anchor);
 	let start;
 	let end;
-	switch (opts.preset) {
-		case "last-7d":
-			end = anchorIso;
-			start = addDays(anchorIso, -6);
-			break;
-		case "last-28d":
-			end = anchorIso;
-			start = addDays(anchorIso, -27);
-			break;
-		case "last-30d":
-			end = anchorIso;
-			start = addDays(anchorIso, -29);
-			break;
-		case "last-90d":
-			end = anchorIso;
-			start = addDays(anchorIso, -89);
-			break;
-		case "last-180d":
-			end = anchorIso;
-			start = addDays(anchorIso, -179);
-			break;
-		case "last-365d":
-			end = anchorIso;
-			start = addDays(anchorIso, -364);
-			break;
-		case "mtd":
-			end = anchorIso;
-			start = toIsoDate(new Date(Date.UTC(anchor.getUTCFullYear(), anchor.getUTCMonth(), 1)));
-			break;
-		case "ytd":
-			end = anchorIso;
-			start = toIsoDate(new Date(Date.UTC(anchor.getUTCFullYear(), 0, 1)));
-			break;
-		case "custom":
-			if (!opts.start || !opts.end) throw new Error("resolveWindow: preset=custom requires start and end");
-			start = opts.start;
-			end = opts.end;
+	if (opts.preset === "custom") {
+		if (!opts.start || !opts.end) throw new Error("resolveWindow: preset=custom requires start and end");
+		start = opts.start;
+		end = opts.end;
+	} else {
+		if (!opts.anchor) throw new Error(`resolveWindow: preset=${opts.preset} requires an anchor date`);
+		const bounds = presetBounds(opts.preset, opts.anchor);
+		start = bounds.start;
+		end = bounds.end;
 	}
 	const days = countDays(start, end);
 	const result = {
@@ -55,8 +66,8 @@ function resolveWindow(opts) {
 			end: previousEnd
 		};
 	} else if (opts.comparison === "yoy") result.comparison = {
-		start: addDays(start, -365),
-		end: addDays(end, -365)
+		start: addDays(start, -364),
+		end: addDays(end, -364)
 	};
 	return result;
 }

package/dist/dates.d.mts

@@ -1,5 +1,5 @@
 import { Period, ResolvedAnalyticsRange } from "./core/types.mjs";
-import { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, daysAgo, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, toIsoDate } from "./core/gsc-dates.mjs";
+import { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, daysAgo, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getNextPstMidnight, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, toIsoDate } from "./core/gsc-dates.mjs";
 import { ComparisonMode, ResolveWindowOptions, ResolvedWindow, WindowPreset, resolveWindow } from "./core/window.mjs";
 import { currentPstDate, daysAgoPst } from "./query/utils/dayjs.mjs";
-export { type ComparisonMode, DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, type Period, type ResolveWindowOptions, type ResolvedAnalyticsRange, type ResolvedWindow, type WindowPreset, addDays, countDays, currentPstDate, daysAgoPst, daysAgo as daysAgoUtc, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, resolveWindow, toIsoDate };
+export { type ComparisonMode, DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, type Period, type ResolveWindowOptions, type ResolvedAnalyticsRange, type ResolvedWindow, type WindowPreset, addDays, countDays, currentPstDate, daysAgoPst, daysAgo as daysAgoUtc, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getNextPstMidnight, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, resolveWindow, toIsoDate };

package/dist/dates.mjs

@@ -1,4 +1,4 @@
-import { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, daysAgo, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, toIsoDate } from "./core/gsc-dates.mjs";
+import { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, daysAgo, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getNextPstMidnight, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, toIsoDate } from "./core/gsc-dates.mjs";
 import { currentPstDate, daysAgoPst } from "./query/utils/dayjs.mjs";
 import { resolveWindow } from "./core/window.mjs";
-export { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, currentPstDate, daysAgoPst, daysAgo as daysAgoUtc, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, resolveWindow, toIsoDate };
+export { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, addDays, countDays, currentPstDate, daysAgoPst, daysAgo as daysAgoUtc, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getNextPstMidnight, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, resolveWindow, toIsoDate };

package/dist/index.d.mts

@@ -7,17 +7,17 @@ import { BackfillProgress, DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_
 import { GscApiError, GscApiErrorInfo, GscError, GscErrorKind, classifyError, gscErrorToException, isPermissionDeniedError, parseGoogleError, rethrowAsGscApiError } from "./core/errors.mjs";
 import { runSequentialBatch } from "./api/batch.mjs";
 import { IndexingMetadata, IndexingNotificationType, IndexingResult, batchRequestIndexing, getIndexingMetadata, requestIndexing } from "./api/indexing.mjs";
-import { BatchInspectUrlsFlatSettledOptions, IndexingEligibility, IndexingIneligibleReason, InspectUrlFlatSettledResult, InspectUrlResult, InspectionPriority, LegacyInspectionPriority, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, ParsedIndexingResult, ValueWeightedInspectionPriority, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
+import { BatchInspectUrlsFlatSettledOptions, IndexingEligibility, IndexingIneligibleReason, InspectUrlFlatSettledResult, InspectUrlResult, InspectionPriority, LegacyInspectionPriority, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, ParsedIndexingResult, URL_INSPECTION_QUOTA, ValueWeightedInspectionPriority, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, describeInspectionError, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
 import { OAuthTokenInfo, OAuthTokens, exchangeAuthCodeResult, introspectAccessToken, introspectAccessTokenResult, refreshAccessToken, revokeOAuthToken, revokeOAuthTokenResult } from "./api/oauth.mjs";
 import { FetchSitesWithSitemapsOptions, 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 { CanonicalDifferenceKind, classifyCanonicalDifference, isCanonicalMismatch } from "./core/canonical.mjs";
 import { INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, IndexingIssueType, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, UnmappedInspectionReasons, isFragmentUrl, unmappedInspectionReasons } from "./core/indexing-issues.mjs";
-import { GscPropertyCandidate, findBestGscProperty, findExactGscProperty, formatGscPropertyCandidates, gscPropertyMatchesTarget, isVerifiedGscPermission, isVerifiedGscProperty, matchGscSite, pickBestGscProperty } from "./core/property.mjs";
+import { GscPropertyCandidate, SiteCandidate, SiteResolution, findBestGscProperty, findExactGscProperty, formatGscPropertyCandidates, gscPropertyMatchesTarget, isVerifiedGscPermission, isVerifiedGscProperty, matchGscSite, pickBestGscProperty, resolveSiteInput } from "./core/property.mjs";
 import { URL_INSPECTION_EFFECTIVE_LIMIT } from "./core/quota.mjs";
 import { ParsedGscSiteUrl, normalizeGscSiteUrl, normalizeRegistrationTarget, parseGscSiteUrl } from "./core/site-url.mjs";
 import { normalizeUrl } from "./normalize.mjs";
 import { AccountNextAction, AccountStatus, AnalyticsNextAction, AnalyticsStatus, GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, IndexingNextAction, IndexingStatus, LifecycleError, LifecycleErrorCode, LifecycleProgress, LifecycleWebhookEnvelope, LifecycleWebhookEvent, PartnerLifecycleAccount, PartnerLifecycleResponse, PartnerLifecycleSite, PropertyNextAction, PropertyStatus, QuerySourceMode, SitemapNextAction, SitemapStatus, accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, lifecycleErrorCodes, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses } from "./onboarding.mjs";
 import { decodeSiteId, encodeSiteId, normalizeSiteUrl } from "./tenant.mjs";
 import { urlMatchKey } from "./url.mjs";
-export { type AccountNextAction, type AccountStatus, AmpInspectionResult, AmpIssue, type AnalyticsNextAction, type AnalyticsStatus, ApiSite, ApiSitemap, ApiSitemapContent, Auth, AuthClient, AuthOptions, type BackfillProgress, BatchInspectUrlsFlatSettledOptions, CallOptions, CanonicalDifferenceKind, DAYS_PER_RANGE, DEFAULT_GSC_REQUEST_TIMEOUT_MS, DataRow, DimensionFilter, DimensionFilterGroup, Err, FetchSitesWithSitemapsOptions, 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, GoogleSearchConsoleClient, GoogleSearchConsoleClientOptions, GscApiError, type GscApiErrorInfo, type GscError, type GscErrorKind, GscPropertyCandidate, INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, IndexStatusResult, IndexingEligibility, IndexingIneligibleReason, IndexingIssueType, IndexingMetadata, type IndexingNextAction, IndexingNotificationType, IndexingResult, type IndexingStatus, InspectUrlFlatSettledResult, InspectUrlIndexResponse, InspectUrlResult, InspectionPriority, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, LegacyInspectionPriority, type LifecycleError, type LifecycleErrorCode, type LifecycleProgress, type LifecycleWebhookEnvelope, type LifecycleWebhookEvent, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, MS_PER_DAY, MobileUsabilityIssue, MobileUsabilityResult, OAuthTokenInfo, OAuthTokens, Ok, ParsedGscSiteUrl, ParsedIndexingResult, type PartnerLifecycleAccount, type PartnerLifecycleResponse, type PartnerLifecycleSite, Period, type PropertyNextAction, type PropertyStatus, PublishUrlNotificationResponse, QueryReturn, type QuerySourceMode, RequiredNonNullable, ResolvedAnalyticsRange, Result, RichResultsDetectedItem, RichResultsIssue, RichResultsItem, RichResultsResult, SearchAnalyticsMetadata, SearchAnalyticsQuery, SearchAnalyticsResponse, Site, SiteAnalytics, type SitemapNextAction, type SitemapStatus, URL_INSPECTION_EFFECTIVE_LIMIT, UnmappedInspectionReasons, UrlInspectionResult, UrlNotification, UrlNotificationMetadata, ValueWeightedInspectionPriority, VerificationMethod, VerificationSite, VerificationSiteType, VerificationToken, VerificationWebResource, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, classifyCanonicalDifference, classifyError, countDays, createAuth, createFetch, decodeSiteId, deleteSite, deleteSitemap, encodeSiteId, err, exchangeAuthCodeResult, fetchSitemap, 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, isCanonicalMismatch, isErr, isFragmentUrl, 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 };
+export { type AccountNextAction, type AccountStatus, AmpInspectionResult, AmpIssue, type AnalyticsNextAction, type AnalyticsStatus, ApiSite, ApiSitemap, ApiSitemapContent, Auth, AuthClient, AuthOptions, type BackfillProgress, BatchInspectUrlsFlatSettledOptions, CallOptions, CanonicalDifferenceKind, DAYS_PER_RANGE, DEFAULT_GSC_REQUEST_TIMEOUT_MS, DataRow, DimensionFilter, DimensionFilterGroup, Err, FetchSitesWithSitemapsOptions, 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, GoogleSearchConsoleClient, GoogleSearchConsoleClientOptions, GscApiError, type GscApiErrorInfo, type GscError, type GscErrorKind, GscPropertyCandidate, INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, IndexStatusResult, IndexingEligibility, IndexingIneligibleReason, IndexingIssueType, IndexingMetadata, type IndexingNextAction, IndexingNotificationType, IndexingResult, type IndexingStatus, InspectUrlFlatSettledResult, InspectUrlIndexResponse, InspectUrlResult, InspectionPriority, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, LegacyInspectionPriority, type LifecycleError, type LifecycleErrorCode, type LifecycleProgress, type LifecycleWebhookEnvelope, type LifecycleWebhookEvent, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, MS_PER_DAY, MobileUsabilityIssue, MobileUsabilityResult, OAuthTokenInfo, OAuthTokens, Ok, ParsedGscSiteUrl, ParsedIndexingResult, type PartnerLifecycleAccount, type PartnerLifecycleResponse, type PartnerLifecycleSite, Period, type PropertyNextAction, type PropertyStatus, PublishUrlNotificationResponse, QueryReturn, type QuerySourceMode, RequiredNonNullable, ResolvedAnalyticsRange, Result, RichResultsDetectedItem, RichResultsIssue, RichResultsItem, RichResultsResult, SearchAnalyticsMetadata, SearchAnalyticsQuery, SearchAnalyticsResponse, Site, SiteAnalytics, SiteCandidate, SiteResolution, type SitemapNextAction, type SitemapStatus, URL_INSPECTION_EFFECTIVE_LIMIT, URL_INSPECTION_QUOTA, UnmappedInspectionReasons, UrlInspectionResult, UrlNotification, UrlNotificationMetadata, ValueWeightedInspectionPriority, VerificationMethod, VerificationSite, VerificationSiteType, VerificationToken, VerificationWebResource, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, classifyCanonicalDifference, classifyError, countDays, createAuth, createFetch, decodeSiteId, deleteSite, deleteSitemap, describeInspectionError, encodeSiteId, err, exchangeAuthCodeResult, fetchSitemap, 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, isCanonicalMismatch, isErr, isFragmentUrl, isOk, isPermissionDeniedError, isValidGscDate, isVerifiedGscPermission, isVerifiedGscProperty, lifecycleErrorCodes, listVerifiedSites, matchGscSite, normalizeGscSiteUrl, normalizeRegistrationTarget, normalizeSiteUrl, normalizeUrl, ok, parseGoogleError, parseGrantedScopes, parseGscSiteUrl, pickBestGscProperty, propertyNextActions, propertyStatuses, querySourceModes, refreshAccessToken, requestIndexing, resolveSiteInput, resolveVerificationTarget, rethrowAsGscApiError, revokeOAuthToken, revokeOAuthTokenResult, runSequentialBatch, siteUrlToVerificationSite, sitemapNextActions, sitemapStatuses, submitSitemap, toIsoDate, unmappedInspectionReasons, unverifySite, unwrapResult, urlMatchKey, verificationMethodsFor, verifySite };

package/dist/index.mjs

@@ -1,9 +1,9 @@
 import { runSequentialBatch } from "./api/batch.mjs";
 import { batchRequestIndexing, getIndexingMetadata, requestIndexing } from "./api/indexing.mjs";
+import { GscApiError, classifyError, gscErrorToException, isPermissionDeniedError, parseGoogleError, rethrowAsGscApiError } from "./core/errors.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 { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, URL_INSPECTION_QUOTA, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, describeInspectionError, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
 import { err, isErr, isOk, ok, unwrapResult } from "./core/result.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";
@@ -13,11 +13,11 @@ import { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETE
 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, isFragmentUrl, 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 { findBestGscProperty, findExactGscProperty, formatGscPropertyCandidates, gscPropertyMatchesTarget, isVerifiedGscPermission, isVerifiedGscProperty, matchGscSite, pickBestGscProperty, resolveSiteInput } 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 { decodeSiteId, encodeSiteId, normalizeSiteUrl } from "./tenant.mjs";
 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, classifyCanonicalDifference, classifyError, countDays, createAuth, createFetch, decodeSiteId, deleteSite, deleteSitemap, encodeSiteId, err, exchangeAuthCodeResult, fetchSitemap, 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, isCanonicalMismatch, isErr, isFragmentUrl, 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 };
+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, URL_INSPECTION_QUOTA, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, classifyCanonicalDifference, classifyError, countDays, createAuth, createFetch, decodeSiteId, deleteSite, deleteSitemap, describeInspectionError, encodeSiteId, err, exchangeAuthCodeResult, fetchSitemap, 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, isCanonicalMismatch, isErr, isFragmentUrl, isOk, isPermissionDeniedError, isValidGscDate, isVerifiedGscPermission, isVerifiedGscProperty, lifecycleErrorCodes, listVerifiedSites, matchGscSite, normalizeGscSiteUrl, normalizeRegistrationTarget, normalizeSiteUrl, normalizeUrl, ok, parseGoogleError, parseGrantedScopes, parseGscSiteUrl, pickBestGscProperty, propertyNextActions, propertyStatuses, querySourceModes, refreshAccessToken, requestIndexing, resolveSiteInput, resolveVerificationTarget, rethrowAsGscApiError, revokeOAuthToken, revokeOAuthTokenResult, runSequentialBatch, siteUrlToVerificationSite, sitemapNextActions, sitemapStatuses, submitSitemap, toIsoDate, unmappedInspectionReasons, unverifySite, unwrapResult, urlMatchKey, verificationMethodsFor, verifySite };

package/dist/indexing.d.mts

@@ -1,5 +1,5 @@
 import { UrlInspectionResult } from "./core/types.mjs";
 import { runSequentialBatch } from "./api/batch.mjs";
 import { IndexingMetadata, IndexingNotificationType, IndexingResult, batchRequestIndexing, getIndexingMetadata, requestIndexing } from "./api/indexing.mjs";
-import { BatchInspectUrlsFlatSettledOptions, IndexingEligibility, IndexingIneligibleReason, InspectUrlFlatSettledResult, InspectUrlResult, InspectionPriority, LegacyInspectionPriority, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, ParsedIndexingResult, ValueWeightedInspectionPriority, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
-export { type BatchInspectUrlsFlatSettledOptions, type IndexingEligibility, type IndexingIneligibleReason, type IndexingMetadata, type IndexingNotificationType, type IndexingResult, type InspectUrlFlatSettledResult, type InspectUrlResult, type InspectionPriority, type LegacyInspectionPriority, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, type ParsedIndexingResult, type UrlInspectionResult, type ValueWeightedInspectionPriority, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, getIndexingEligibility, getIndexingMetadata, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat, requestIndexing, runSequentialBatch };
+import { BatchInspectUrlsFlatSettledOptions, IndexingEligibility, IndexingIneligibleReason, InspectUrlFlatSettledResult, InspectUrlResult, InspectionPriority, LegacyInspectionPriority, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, ParsedIndexingResult, URL_INSPECTION_QUOTA, ValueWeightedInspectionPriority, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, describeInspectionError, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
+export { type BatchInspectUrlsFlatSettledOptions, type IndexingEligibility, type IndexingIneligibleReason, type IndexingMetadata, type IndexingNotificationType, type IndexingResult, type InspectUrlFlatSettledResult, type InspectUrlResult, type InspectionPriority, type LegacyInspectionPriority, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, type ParsedIndexingResult, URL_INSPECTION_QUOTA, type UrlInspectionResult, type ValueWeightedInspectionPriority, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, describeInspectionError, getIndexingEligibility, getIndexingMetadata, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat, requestIndexing, runSequentialBatch };

package/dist/indexing.mjs

@@ -1,4 +1,4 @@
 import { runSequentialBatch } from "./api/batch.mjs";
 import { batchRequestIndexing, getIndexingMetadata, requestIndexing } from "./api/indexing.mjs";
-import { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
-export { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, getIndexingEligibility, getIndexingMetadata, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat, requestIndexing, runSequentialBatch };
+import { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, URL_INSPECTION_QUOTA, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, describeInspectionError, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat } from "./api/inspection.mjs";
+export { MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, URL_INSPECTION_QUOTA, batchInspectUrls, batchInspectUrlsFlatSettled, batchRequestIndexing, canUseUrlInspection, describeInspectionError, getIndexingEligibility, getIndexingMetadata, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat, requestIndexing, runSequentialBatch };

package/dist/query/utils/dayjs.mjs

@@ -1,26 +1,6 @@
-import { addDays } from "../../core/gsc-dates.mjs";
-let pstFormatter;
-function getPstFormatter() {
-	pstFormatter ??= new Intl.DateTimeFormat("en-CA", {
-		timeZone: "America/Los_Angeles",
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit"
-	});
-	return pstFormatter;
-}
-function pstDateParts(d = /* @__PURE__ */ new Date()) {
-	const parts = getPstFormatter().formatToParts(d);
-	const get = (t) => Number(parts.find((p) => p.type === t).value);
-	return {
-		year: get("year"),
-		month: get("month"),
-		day: get("day")
-	};
-}
+import { addDays, getPstDate } from "../../core/gsc-dates.mjs";
 function currentPstDate() {
-	const { year, month, day } = pstDateParts();
-	return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+	return getPstDate();
 }
 function daysAgoPst(n) {
 	return addDays(currentPstDate(), -n);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gscdump",
   "type": "module",
-  "version": "3.7.0",
+  "version": "4.0.0",
   "description": "Direct Google Search Console and Bing Webmaster clients with typed queries and Indexing Evidence",
   "author": {
     "name": "Harlan Wilton",
@@ -110,10 +110,10 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22"
+    "node": ">=22.13.0"
   },
   "dependencies": {
-    "@gscdump/contracts": "^3.7.0",
+    "@gscdump/contracts": "^4.0.0",
     "ofetch": "^1.5.1"
   },
   "scripts": {