gscdump 0.37.3 → 0.37.5

package/dist/api/index.mjs

@@ -2352,7 +2352,9 @@ function parseGoogleError(text, httpStatus) {
 	let parsed = null;
 	try {
 		parsed = JSON.parse(text);
-	} catch {}
+	} catch (error) {
+		if (!(error instanceof SyntaxError)) throw error;
+	}
 	if (!parsed || !("error" in parsed)) return {
 		code: httpStatus ?? 500,
 		message: text || "Unknown Google API error"
@@ -2597,16 +2599,18 @@ async function fetchSitemapUrls(sitemapUrl, options = {}) {
 		});
 		if (!res.ok) throw new Error(`Fetch ${url} failed: ${res.status}`);
 		const text = await res.text();
-		const isIndex = SITEMAPINDEX_RE.test(text);
-		const matches = [...text.matchAll(LOC_RE)].map((m) => m[1].trim()).filter(Boolean);
-		if (isIndex) {
-			for (const child of matches) {
+		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 u of matches) {
+		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);

package/dist/dates.d.mts

@@ -0,0 +1,61 @@
+/** Milliseconds in a UTC day. Use for date arithmetic without DST surprises. */
+declare const MS_PER_DAY = 86400000;
+/** Format a Date as YYYY-MM-DD (UTC). */
+declare function toIsoDate(d: Date): string;
+/** Most recent date GSC has fully finalized data for (no further updates). */
+declare const GSC_FINALIZED_LAG_DAYS = 3;
+/** Most recent date GSC will return data for, may still be updating. */
+declare const GSC_FRESHEST_LAG_DAYS = 1;
+/** Approximate historical retention window for Search Analytics. */
+declare const GSC_RETENTION_MONTHS = 16;
+/** Today's date (YYYY-MM-DD) in PST. */
+declare function getPstDate(): string;
+/** YYYY-MM-DD for `now() - n` days, UTC. */
+declare function daysAgo(n: number): string;
+/** Most recent finalized date (3 days ago PST). */
+declare function getLatestGscDate(): string;
+/** Freshest date GSC will return (yesterday PST, may still update). */
+declare function getFreshestGscDate(): string;
+/**
+ * Dates that are still pending (1-3 days ago PST). These need to be re-synced
+ * each day until they finalize.
+ */
+declare function getPendingDates(): string[];
+/** All dates between two YYYY-MM-DD strings (inclusive, oldest first). */
+declare function getDateRange(startDate: string, endDate: string): string[];
+/** Default span used when chunking long backfills into batches. */
+declare const DAYS_PER_RANGE = 30;
+/**
+ * Like {@link getDateRange} but skips dates outside GSC's queryable window
+ * (older than retention or newer than the freshest date).
+ */
+declare function generateGscDateRange(startDate: string, endDate: string): string[];
+/**
+ * Group a sorted list of dates into contiguous runs, splitting on either a
+ * gap or after `daysPerRange` dates accumulate. Useful for bucketing
+ * backfill work into bounded jobs.
+ */
+declare function groupIntoRanges(dates: string[], daysPerRange?: number): Array<{
+  startDate: string;
+  endDate: string;
+}>;
+/** Inclusive day count between two YYYY-MM-DD strings. */
+declare function countDays(startDate: string, endDate: string): number;
+/** Oldest date GSC retains (~16 months ago). */
+declare function getOldestGscDate(): string;
+declare function getNextDate(dateStr: string): string;
+interface BackfillProgress {
+  progress: number;
+  daysAvailable: number;
+  daysSynced: number;
+  oldestGscDate: string;
+  isComplete: boolean;
+}
+/**
+ * Backfill progress (0-1) given the oldest + newest dates synced.
+ * Returns null when no sync data exists.
+ */
+declare function getBackfillProgress(oldestDateSynced: string | null, newestDateSynced: string | null): BackfillProgress | null;
+declare function currentPstDate(): string;
+declare function daysAgoPst(n: number): string;
+export { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, countDays, currentPstDate, daysAgoPst, daysAgo as daysAgoUtc, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, toIsoDate };

package/dist/dates.mjs

@@ -0,0 +1,118 @@
+import { format, subDays } from "date-fns";
+const MS_PER_DAY = 864e5;
+function toIsoDate(d) {
+	return d.toISOString().slice(0, 10);
+}
+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" });
+}
+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);
+}
+function daysAgo(n) {
+	return toIsoDate(/* @__PURE__ */ new Date(Date.now() - n * MS_PER_DAY));
+}
+function getLatestGscDate() {
+	return getPstDateDaysAgo(3);
+}
+function getFreshestGscDate() {
+	return getPstDateDaysAgo(1);
+}
+function getPendingDates() {
+	const dates = [];
+	for (let daysAgo = 1; daysAgo <= 3; daysAgo++) dates.push(getPstDateDaysAgo(daysAgo));
+	return dates;
+}
+function getDateRange(startDate, endDate) {
+	const dates = [];
+	const endMs = Date.parse(`${endDate}T00:00:00Z`);
+	for (let cursor = Date.parse(`${startDate}T00:00:00Z`); cursor <= endMs; cursor += MS_PER_DAY) dates.push(toIsoDate(new Date(cursor)));
+	return dates;
+}
+const DAYS_PER_RANGE = 30;
+function generateGscDateRange(startDate, endDate) {
+	const start = startDate < getOldestGscDate() ? getOldestGscDate() : startDate;
+	const end = endDate > getFreshestGscDate() ? getFreshestGscDate() : endDate;
+	return start <= end ? getDateRange(start, end) : [];
+}
+function groupIntoRanges(dates, daysPerRange = 30) {
+	if (dates.length === 0) return [];
+	const sorted = [...dates].sort();
+	const ranges = [];
+	let rangeStart = sorted[0];
+	let rangePrev = sorted[0];
+	for (let i = 1; i < sorted.length; i++) {
+		const current = sorted[i];
+		const expected = getNextDate(rangePrev);
+		const daysInRange = countDays(rangeStart, rangePrev);
+		if (current !== expected || daysInRange >= daysPerRange) {
+			ranges.push({
+				startDate: rangeStart,
+				endDate: rangePrev
+			});
+			rangeStart = current;
+		}
+		rangePrev = current;
+	}
+	ranges.push({
+		startDate: rangeStart,
+		endDate: rangePrev
+	});
+	return ranges;
+}
+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);
+	return toIsoDate(date);
+}
+function addDays(dateStr, n) {
+	return toIsoDate(new Date(Date.parse(`${dateStr}T00:00:00Z`) + n * MS_PER_DAY));
+}
+function getNextDate(dateStr) {
+	return addDays(dateStr, 1);
+}
+function getBackfillProgress(oldestDateSynced, newestDateSynced) {
+	if (!oldestDateSynced || !newestDateSynced) return null;
+	const oldestGsc = getOldestGscDate();
+	const totalDays = countDays(oldestGsc, getLatestGscDate());
+	const syncedDays = countDays(oldestDateSynced, newestDateSynced);
+	return {
+		progress: Math.round(Math.min(1, syncedDays / totalDays) * 100) / 100,
+		daysAvailable: totalDays,
+		daysSynced: syncedDays,
+		oldestGscDate: oldestGsc,
+		isComplete: oldestDateSynced <= oldestGsc
+	};
+}
+const PST_FORMATTER = new Intl.DateTimeFormat("en-CA", {
+	timeZone: "America/Los_Angeles",
+	year: "numeric",
+	month: "2-digit",
+	day: "2-digit"
+});
+function pstDateParts(d = /* @__PURE__ */ new Date()) {
+	const parts = PST_FORMATTER.formatToParts(d);
+	const get = (t) => Number(parts.find((p) => p.type === t).value);
+	return {
+		year: get("year"),
+		month: get("month"),
+		day: get("day")
+	};
+}
+function currentPstDate() {
+	const { year, month, day } = pstDateParts();
+	return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+function daysAgoPst(n) {
+	const { year, month, day } = pstDateParts();
+	return format(subDays(new Date(year, month - 1, day, 12), n), "yyyy-MM-dd");
+}
+export { DAYS_PER_RANGE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_RETENTION_MONTHS, MS_PER_DAY, countDays, currentPstDate, daysAgoPst, daysAgo as daysAgoUtc, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getLatestGscDate, getNextDate, getOldestGscDate, getPendingDates, getPstDate, groupIntoRanges, toIsoDate };

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import { $Fetch, FetchOptions } from "ofetch";
+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, lifecycleWebhookEvents, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses } from "@gscdump/contracts/partner";
 import { indexing_v3 } from "@googleapis/indexing/build/v3";
 import { searchconsole_v1 } from "@googleapis/searchconsole/build/v1";
 /**
@@ -820,17 +821,17 @@ declare function findExactGscProperty<T extends GscPropertyCandidate>(propertyUr
 declare function formatGscPropertyCandidates(candidates: ReadonlyArray<GscPropertyCandidate | null | undefined>): string;
 declare const URL_INSPECTION_DAILY_LIMIT = 2000;
 declare const URL_INSPECTION_EFFECTIVE_LIMIT = 1800;
-type GoogleScopesInput$2 = string | readonly string[] | null | undefined;
+type GoogleScopesInput$1 = string | readonly string[] | null | undefined;
 declare const GSC_READ_SCOPE: "https://www.googleapis.com/auth/webmasters.readonly";
 declare const GSC_WRITE_SCOPE: "https://www.googleapis.com/auth/webmasters";
 declare const GSC_INDEXING_SCOPE: "https://www.googleapis.com/auth/indexing";
 declare const GSC_SITE_VERIFICATION_SCOPE: "https://www.googleapis.com/auth/siteverification";
-declare function parseGoogleScopes(scopes: GoogleScopesInput$2): string[];
-declare function hasGoogleScope(scopes: GoogleScopesInput$2, scope: string): boolean;
-type GoogleScopesInput$1 = string | readonly string[] | null | undefined;
-declare function hasGscReadScope(scopes: GoogleScopesInput$1): boolean;
-declare function hasGscWriteScope(scopes: GoogleScopesInput$1): boolean;
-declare function hasIndexingScope(scopes: GoogleScopesInput$1): boolean;
+declare function parseGoogleScopes(scopes: GoogleScopesInput$1): string[];
+declare function hasGoogleScope(scopes: GoogleScopesInput$1, scope: string): boolean;
+type GoogleScopesInput = string | readonly string[] | null | undefined;
+declare function hasGscReadScope(scopes: GoogleScopesInput): boolean;
+declare function hasGscWriteScope(scopes: GoogleScopesInput): boolean;
+declare function hasIndexingScope(scopes: GoogleScopesInput): boolean;
 interface ParsedGscSiteUrl {
   /** Original, canonical GSC property URL. */
   label: string;
@@ -856,113 +857,6 @@ declare function normalizeGscSiteUrl(siteUrl: string): string;
  */
 declare function normalizeRegistrationTarget(inputUrl: string): string | null;
 declare function normalizeUrl(input: string): string;
-type GoogleScopesInput = string | readonly string[] | null | undefined;
-declare const GSCDUMP_ONBOARDING_CONTRACT_VERSION: "2026-05-11";
-declare const GSCDUMP_REQUIRED_ANALYTICS_SCOPE: "https://www.googleapis.com/auth/webmasters.readonly";
-declare const GSCDUMP_OPTIONAL_INDEXING_SCOPE: "https://www.googleapis.com/auth/indexing";
-declare const accountStatuses: readonly ["disconnected", "oauth_received", "scope_missing", "refresh_missing", "db_provisioning", "ready", "reauth_required"];
-declare const accountNextActions: readonly ["connect_google", "reconnect_google", "wait_for_provisioning", "none"];
-declare const propertyStatuses: readonly ["no_local_site", "no_gsc_property", "unverified_property", "verified_candidate", "registered", "linked"];
-declare const propertyNextActions: readonly ["create_site", "verify_gsc_property", "choose_property", "register_site", "none"];
-declare const analyticsStatuses: readonly ["not_registered", "queued", "preparing", "syncing", "queryable_live", "queryable_partial", "ready", "failed"];
-declare const analyticsNextActions: readonly ["wait_for_sync", "retry_sync", "none"];
-declare const querySourceModes: readonly ["none", "live", "d1", "r2", "mixed"];
-declare const sitemapStatuses: readonly ["unknown", "discovering", "none_found", "auto_submitted", "syncing", "ready", "failed"];
-declare const sitemapNextActions: readonly ["submit_sitemap", "wait_for_sitemaps", "retry_sitemaps", "none"];
-declare const indexingStatuses: readonly ["not_requested", "missing_scope", "insufficient_permission", "waiting_for_sitemaps", "discovering", "checking", "ready", "budget_exhausted", "no_urls", "failed"];
-declare const indexingNextActions: readonly ["reconnect_google", "fix_gsc_permission", "wait_for_sitemaps", "wait_for_indexing", "retry_indexing", "none"];
-declare const lifecycleWebhookEvents: readonly ["user.lifecycle.changed", "site.lifecycle.changed", "site.analytics.ready", "site.indexing.ready", "site.auth.failed", "job.failed"];
-declare const lifecycleErrorCodes: readonly ["missing_refresh_token", "missing_analytics_scope", "missing_indexing_scope", "token_refresh_failed", "permission_lost", "insufficient_gsc_permission", "gsc_property_not_found", "gsc_property_unverified", "user_database_not_provisioned", "sync_failed", "sitemap_sync_failed", "indexing_failed"];
-type AccountStatus = typeof accountStatuses[number];
-type AccountNextAction = typeof accountNextActions[number];
-type PropertyStatus = typeof propertyStatuses[number];
-type PropertyNextAction = typeof propertyNextActions[number];
-type AnalyticsStatus = typeof analyticsStatuses[number];
-type AnalyticsNextAction = typeof analyticsNextActions[number];
-type QuerySourceMode = typeof querySourceModes[number];
-type SitemapStatus = typeof sitemapStatuses[number];
-type SitemapNextAction = typeof sitemapNextActions[number];
-type IndexingStatus = typeof indexingStatuses[number];
-type IndexingNextAction = typeof indexingNextActions[number];
-type LifecycleWebhookEvent = typeof lifecycleWebhookEvents[number];
-type LifecycleErrorCode = typeof lifecycleErrorCodes[number];
-interface LifecycleProgress {
-  completed: number;
-  failed: number;
-  total: number;
-  percent: number;
-}
-interface LifecycleError {
-  code: LifecycleErrorCode;
-  message: string;
-  retryable: boolean;
-}
-interface PartnerLifecycleAccount {
-  status: AccountStatus;
-  grantedScopes: string[];
-  missingScopes: string[];
-  nextAction: AccountNextAction;
-}
-interface PartnerLifecycleSite {
-  siteId: string;
-  externalSiteId: string | null;
-  requestedUrl: string;
-  gscPropertyUrl: string | null;
-  permissionLevel: string | null;
-  property: {
-    status: PropertyStatus;
-    nextAction: PropertyNextAction;
-  };
-  analytics: {
-    status: AnalyticsStatus;
-    progress: LifecycleProgress;
-    queryable: boolean;
-    sourceMode: QuerySourceMode;
-    syncedRange: {
-      oldest: string | null;
-      newest: string | null;
-    };
-    nextAction: AnalyticsNextAction;
-  };
-  sitemaps: {
-    status: SitemapStatus;
-    discoveredCount: number;
-    nextAction: SitemapNextAction;
-  };
-  indexing: {
-    status: IndexingStatus;
-    eligible: boolean;
-    reason: string | null;
-    progress: LifecycleProgress;
-    nextAction: IndexingNextAction;
-  };
-  latestError: LifecycleError | null;
-  lifecycleRevision: number;
-  updatedAt: string;
-}
-interface PartnerLifecycleResponse {
-  contractVersion: typeof GSCDUMP_ONBOARDING_CONTRACT_VERSION;
-  userId: string;
-  partnerId: string | null;
-  account: PartnerLifecycleAccount;
-  sites: PartnerLifecycleSite[];
-}
-interface LifecycleWebhookEnvelope<TData extends Record<string, unknown> = Record<string, unknown>> {
-  contractVersion: typeof GSCDUMP_ONBOARDING_CONTRACT_VERSION;
-  deliveryId: string;
-  event: LifecycleWebhookEvent;
-  partnerId: string;
-  userId: string;
-  siteId?: string;
-  externalUserId?: string | null;
-  externalSiteId?: string | null;
-  lifecycleRevision: number;
-  occurredAt: string;
-  data: TData;
-}
-declare function parseGrantedScopes(scopes: GoogleScopesInput): string[];
-declare function hasRequiredAnalyticsScope(scopes: GoogleScopesInput): boolean;
-declare function hasOptionalIndexingScope(scopes: GoogleScopesInput): boolean;
 interface DiscoverSitemapOptions {
   /** User-Agent sent on the discovery requests. */
   userAgent?: string;
@@ -1013,4 +907,4 @@ declare function normalizeSiteUrl(siteUrl: string): string;
  * Example: `https://www.Example.com/Foo/` → `example.com/foo`
  */
 declare function urlMatchKey(url: string): string | null;
-export { AccountNextAction, AccountStatus, AnalyticsNextAction, AnalyticsStatus, ApiSite, ApiSitemap, ApiSitemapContent, Auth, AuthClient, AuthOptions, BackfillProgress, CallOptions, DAYS_PER_RANGE, DataRow, DimensionFilter, DimensionFilterGroup, DiscoverSitemapOptions, Err, FetchSitemapUrlsOptions, GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_INDEXING_SCOPE, GSC_QUOTAS, GSC_READ_SCOPE, GSC_RETENTION_MONTHS, GSC_SITE_VERIFICATION_SCOPE, GSC_WRITE_SCOPE, GoogleSearchConsoleClient, GoogleSearchConsoleClientOptions, GscApiError, GscApiErrorInfo, GscError, GscErrorKind, GscPropertyCandidate, GscdumpApiOptions, INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, IndexStatusResult, IndexingEligibility, IndexingIneligibleReason, IndexingIssueType, IndexingMetadata, IndexingNextAction, IndexingNotificationType, IndexingResult, IndexingStatus, InspectUrlIndexResponse, InspectUrlResult, InspectionPriority, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, LifecycleError, LifecycleErrorCode, LifecycleProgress, LifecycleWebhookEnvelope, LifecycleWebhookEvent, MS_PER_DAY, MobileUsabilityResult, OAuthTokens, Ok, ParsedGscSiteUrl, ParsedIndexingResult, PartnerLifecycleAccount, PartnerLifecycleResponse, PartnerLifecycleSite, Period, PropertyNextAction, PropertyStatus, PublishUrlNotificationResponse, QueryReturn, QuerySourceMode, RequiredNonNullable, ResolvedAnalyticsRange, Result, RichResultsResult, SearchAnalyticsQuery, SearchAnalyticsResponse, Site, SiteAnalytics, SitemapNextAction, SitemapStatus, URL_INSPECTION_DAILY_LIMIT, URL_INSPECTION_EFFECTIVE_LIMIT, UnmappedInspectionReasons, UrlInspectionResult, UrlNotificationMetadata, VerificationMethod, VerificationSite, VerificationSiteType, VerificationToken, VerificationWebResource, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchRequestIndexing, canUseUrlInspection, classifyError, countDays, createAuth, createFetch, daysAgo, decodeSiteId, deleteSite, deleteSitemap, discoverSitemap, encodeSiteId, err, exchangeAuthCode, exchangeAuthCodeResult, fetchSitemap, fetchSitemapUrls, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, findBestGscProperty, findExactGscProperty, formatErrorForCli, formatGscPropertyCandidates, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getIndexingEligibility, getIndexingMetadata, getLatestGscDate, getNextCheckAfter, getNextCheckPriority, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, getVerificationToken, getVerifiedSite, googleSearchConsole, grantedScopeList, groupIntoRanges, gscErrorToException, gscPropertyMatchesTarget, gscdumpApi, hasGoogleScope, hasGscReadScope, hasGscWriteScope, hasIndexingScope, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, inspectUrl, inspectUrlFlat, isErr, isOk, isPermissionDeniedError, isValidGscDate, isVerifiedGscPermission, isVerifiedGscProperty, lifecycleErrorCodes, lifecycleWebhookEvents, listVerifiedSites, mapErr, mapResult, matchGscSite, matchResult, normalizeGscSiteUrl, normalizeRegistrationTarget, normalizeSiteUrl, normalizeUrl, ok, parseGoogleError, parseGoogleScopes, parseGrantedScopes, parseGscSiteUrl, pickBestGscProperty, progressBar, propertyNextActions, propertyStatuses, querySourceModes, refreshAccessToken, refreshAccessTokenResult, requestIndexing, rethrowAsGscApiError, rowWithMetricDefaults, runSequentialBatch, siteUrlToVerificationSite, sitemapNextActions, sitemapStatuses, storageError, submitSitemap, toIsoDate, unmappedInspectionReasons, unverifySite, unwrapResult, urlMatchKey, verificationMethodsFor, verifySite };
+export { type AccountNextAction, type AccountStatus, type AnalyticsNextAction, type AnalyticsStatus, ApiSite, ApiSitemap, ApiSitemapContent, Auth, AuthClient, AuthOptions, BackfillProgress, CallOptions, DAYS_PER_RANGE, DataRow, DimensionFilter, DimensionFilterGroup, DiscoverSitemapOptions, Err, FetchSitemapUrlsOptions, 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_QUOTAS, GSC_READ_SCOPE, GSC_RETENTION_MONTHS, GSC_SITE_VERIFICATION_SCOPE, GSC_WRITE_SCOPE, GoogleSearchConsoleClient, GoogleSearchConsoleClientOptions, GscApiError, GscApiErrorInfo, GscError, GscErrorKind, GscPropertyCandidate, GscdumpApiOptions, INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, IndexStatusResult, IndexingEligibility, IndexingIneligibleReason, IndexingIssueType, IndexingMetadata, type IndexingNextAction, IndexingNotificationType, IndexingResult, type IndexingStatus, InspectUrlIndexResponse, InspectUrlResult, InspectionPriority, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, type LifecycleError, type LifecycleErrorCode, type LifecycleProgress, type LifecycleWebhookEnvelope, type LifecycleWebhookEvent, MS_PER_DAY, MobileUsabilityResult, OAuthTokens, Ok, ParsedGscSiteUrl, ParsedIndexingResult, type PartnerLifecycleAccount, type PartnerLifecycleResponse, type PartnerLifecycleSite, Period, type PropertyNextAction, type PropertyStatus, PublishUrlNotificationResponse, QueryReturn, type QuerySourceMode, RequiredNonNullable, ResolvedAnalyticsRange, Result, RichResultsResult, SearchAnalyticsQuery, SearchAnalyticsResponse, Site, SiteAnalytics, type SitemapNextAction, type SitemapStatus, URL_INSPECTION_DAILY_LIMIT, URL_INSPECTION_EFFECTIVE_LIMIT, UnmappedInspectionReasons, UrlInspectionResult, UrlNotificationMetadata, VerificationMethod, VerificationSite, VerificationSiteType, VerificationToken, VerificationWebResource, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchRequestIndexing, canUseUrlInspection, classifyError, countDays, createAuth, createFetch, daysAgo, decodeSiteId, deleteSite, deleteSitemap, discoverSitemap, encodeSiteId, err, exchangeAuthCode, exchangeAuthCodeResult, fetchSitemap, fetchSitemapUrls, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, findBestGscProperty, findExactGscProperty, formatErrorForCli, formatGscPropertyCandidates, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getIndexingEligibility, getIndexingMetadata, getLatestGscDate, getNextCheckAfter, getNextCheckPriority, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, getVerificationToken, getVerifiedSite, googleSearchConsole, grantedScopeList, groupIntoRanges, gscErrorToException, gscPropertyMatchesTarget, gscdumpApi, hasGoogleScope, hasGscReadScope, hasGscWriteScope, hasIndexingScope, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, inspectUrl, inspectUrlFlat, isErr, isOk, isPermissionDeniedError, isValidGscDate, isVerifiedGscPermission, isVerifiedGscProperty, lifecycleErrorCodes, lifecycleWebhookEvents, listVerifiedSites, mapErr, mapResult, matchGscSite, matchResult, normalizeGscSiteUrl, normalizeRegistrationTarget, normalizeSiteUrl, normalizeUrl, ok, parseGoogleError, parseGoogleScopes, parseGrantedScopes, parseGscSiteUrl, pickBestGscProperty, progressBar, propertyNextActions, propertyStatuses, querySourceModes, refreshAccessToken, refreshAccessTokenResult, requestIndexing, rethrowAsGscApiError, rowWithMetricDefaults, runSequentialBatch, siteUrlToVerificationSite, sitemapNextActions, sitemapStatuses, storageError, submitSitemap, toIsoDate, unmappedInspectionReasons, unverifySite, unwrapResult, urlMatchKey, verificationMethodsFor, verifySite };

package/dist/index.mjs

@@ -1,4 +1,5 @@
 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, lifecycleWebhookEvents, 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 });
@@ -339,7 +340,9 @@ function parseGoogleError(text, httpStatus) {
 	let parsed = null;
 	try {
 		parsed = JSON.parse(text);
-	} catch {}
+	} catch (error) {
+		if (!(error instanceof SyntaxError)) throw error;
+	}
 	if (!parsed || !("error" in parsed)) return {
 		code: httpStatus ?? 500,
 		message: text || "Unknown Google API error"
@@ -3126,127 +3129,6 @@ function safeParse(input) {
 		return null;
 	}
 }
-const GSCDUMP_ONBOARDING_CONTRACT_VERSION = "2026-05-11";
-const GSCDUMP_REQUIRED_ANALYTICS_SCOPE = GSC_READ_SCOPE;
-const GSCDUMP_OPTIONAL_INDEXING_SCOPE = GSC_INDEXING_SCOPE;
-const accountStatuses = [
-	"disconnected",
-	"oauth_received",
-	"scope_missing",
-	"refresh_missing",
-	"db_provisioning",
-	"ready",
-	"reauth_required"
-];
-const accountNextActions = [
-	"connect_google",
-	"reconnect_google",
-	"wait_for_provisioning",
-	"none"
-];
-const propertyStatuses = [
-	"no_local_site",
-	"no_gsc_property",
-	"unverified_property",
-	"verified_candidate",
-	"registered",
-	"linked"
-];
-const propertyNextActions = [
-	"create_site",
-	"verify_gsc_property",
-	"choose_property",
-	"register_site",
-	"none"
-];
-const analyticsStatuses = [
-	"not_registered",
-	"queued",
-	"preparing",
-	"syncing",
-	"queryable_live",
-	"queryable_partial",
-	"ready",
-	"failed"
-];
-const analyticsNextActions = [
-	"wait_for_sync",
-	"retry_sync",
-	"none"
-];
-const querySourceModes = [
-	"none",
-	"live",
-	"d1",
-	"r2",
-	"mixed"
-];
-const sitemapStatuses = [
-	"unknown",
-	"discovering",
-	"none_found",
-	"auto_submitted",
-	"syncing",
-	"ready",
-	"failed"
-];
-const sitemapNextActions = [
-	"submit_sitemap",
-	"wait_for_sitemaps",
-	"retry_sitemaps",
-	"none"
-];
-const indexingStatuses = [
-	"not_requested",
-	"missing_scope",
-	"insufficient_permission",
-	"waiting_for_sitemaps",
-	"discovering",
-	"checking",
-	"ready",
-	"budget_exhausted",
-	"no_urls",
-	"failed"
-];
-const indexingNextActions = [
-	"reconnect_google",
-	"fix_gsc_permission",
-	"wait_for_sitemaps",
-	"wait_for_indexing",
-	"retry_indexing",
-	"none"
-];
-const lifecycleWebhookEvents = [
-	"user.lifecycle.changed",
-	"site.lifecycle.changed",
-	"site.analytics.ready",
-	"site.indexing.ready",
-	"site.auth.failed",
-	"job.failed"
-];
-const lifecycleErrorCodes = [
-	"missing_refresh_token",
-	"missing_analytics_scope",
-	"missing_indexing_scope",
-	"token_refresh_failed",
-	"permission_lost",
-	"insufficient_gsc_permission",
-	"gsc_property_not_found",
-	"gsc_property_unverified",
-	"user_database_not_provisioned",
-	"sync_failed",
-	"sitemap_sync_failed",
-	"indexing_failed"
-];
-function parseGrantedScopes(scopes) {
-	return parseGoogleScopes(scopes);
-}
-function hasRequiredAnalyticsScope(scopes) {
-	return hasGscReadScope(scopes);
-}
-function hasOptionalIndexingScope(scopes) {
-	return hasIndexingScope(scopes);
-}
 const FETCH_TIMEOUT_MS = 1e4;
 const COMMON_PATHS = ["/sitemap.xml", "/sitemap_index.xml"];
 const SITEMAP_DIRECTIVE_RE = /^Sitemap:\s*(\S+)/im;
@@ -3295,16 +3177,18 @@ async function fetchSitemapUrls(sitemapUrl, options = {}) {
 		});
 		if (!res.ok) throw new Error(`Fetch ${url} failed: ${res.status}`);
 		const text = await res.text();
-		const isIndex = SITEMAPINDEX_RE.test(text);
-		const matches = [...text.matchAll(LOC_RE)].map((m) => m[1].trim()).filter(Boolean);
-		if (isIndex) {
-			for (const child of matches) {
+		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 u of matches) {
+		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);
@@ -3336,4 +3220,4 @@ function urlMatchKey(url) {
 	if (!u) return null;
 	return [u.hostname.replace(/^www\./, ""), u.pathname.replace(/\/$/, "") || "/"].join("").toLowerCase();
 }
-export { DAYS_PER_RANGE, GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSC_FINALIZED_LAG_DAYS, GSC_FRESHEST_LAG_DAYS, GSC_INDEXING_SCOPE, GSC_QUOTAS, 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, MS_PER_DAY, URL_INSPECTION_DAILY_LIMIT, URL_INSPECTION_EFFECTIVE_LIMIT, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchRequestIndexing, canUseUrlInspection, classifyError, countDays, createAuth, createFetch, daysAgo, decodeSiteId, deleteSite, deleteSitemap, discoverSitemap, encodeSiteId, err, exchangeAuthCode, exchangeAuthCodeResult, fetchSitemap, fetchSitemapUrls, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, findBestGscProperty, findExactGscProperty, formatErrorForCli, formatGscPropertyCandidates, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getIndexingEligibility, getIndexingMetadata, getLatestGscDate, getNextCheckAfter, getNextCheckPriority, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, getVerificationToken, getVerifiedSite, googleSearchConsole, grantedScopeList, groupIntoRanges, gscErrorToException, gscPropertyMatchesTarget, gscdumpApi, hasGoogleScope, hasGscReadScope, hasGscWriteScope, hasIndexingScope, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, inspectUrl, inspectUrlFlat, isErr, isOk, isPermissionDeniedError, isValidGscDate, isVerifiedGscPermission, isVerifiedGscProperty, lifecycleErrorCodes, lifecycleWebhookEvents, listVerifiedSites, mapErr, mapResult, matchGscSite, matchResult, normalizeGscSiteUrl, normalizeRegistrationTarget, normalizeSiteUrl, normalizeUrl, ok, parseGoogleError, parseGoogleScopes, parseGrantedScopes, parseGscSiteUrl, pickBestGscProperty, progressBar, propertyNextActions, propertyStatuses, querySourceModes, refreshAccessToken, refreshAccessTokenResult, requestIndexing, rethrowAsGscApiError, rowWithMetricDefaults, runSequentialBatch, siteUrlToVerificationSite, sitemapNextActions, sitemapStatuses, storageError, submitSitemap, toIsoDate, unmappedInspectionReasons, unverifySite, unwrapResult, urlMatchKey, verificationMethodsFor, verifySite };
+export { DAYS_PER_RANGE, 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_QUOTAS, 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, MS_PER_DAY, URL_INSPECTION_DAILY_LIMIT, URL_INSPECTION_EFFECTIVE_LIMIT, accountNextActions, accountStatuses, addDays, addSite, analyticsNextActions, analyticsStatuses, batchInspectUrls, batchRequestIndexing, canUseUrlInspection, classifyError, countDays, createAuth, createFetch, daysAgo, decodeSiteId, deleteSite, deleteSitemap, discoverSitemap, encodeSiteId, err, exchangeAuthCode, exchangeAuthCodeResult, fetchSitemap, fetchSitemapUrls, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, findBestGscProperty, findExactGscProperty, formatErrorForCli, formatGscPropertyCandidates, generateGscDateRange, getBackfillProgress, getDateRange, getFreshestGscDate, getIndexingEligibility, getIndexingMetadata, getLatestGscDate, getNextCheckAfter, getNextCheckPriority, getNextDate, getOldestGscDate, getPendingDates, getPreviousDate, getPstDate, getVerificationToken, getVerifiedSite, googleSearchConsole, grantedScopeList, groupIntoRanges, gscErrorToException, gscPropertyMatchesTarget, gscdumpApi, hasGoogleScope, hasGscReadScope, hasGscWriteScope, hasIndexingScope, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, inspectUrl, inspectUrlFlat, isErr, isOk, isPermissionDeniedError, isValidGscDate, isVerifiedGscPermission, isVerifiedGscProperty, lifecycleErrorCodes, lifecycleWebhookEvents, listVerifiedSites, mapErr, mapResult, matchGscSite, matchResult, normalizeGscSiteUrl, normalizeRegistrationTarget, normalizeSiteUrl, normalizeUrl, ok, parseGoogleError, parseGoogleScopes, parseGrantedScopes, parseGscSiteUrl, pickBestGscProperty, progressBar, propertyNextActions, propertyStatuses, querySourceModes, refreshAccessToken, refreshAccessTokenResult, requestIndexing, rethrowAsGscApiError, rowWithMetricDefaults, runSequentialBatch, siteUrlToVerificationSite, sitemapNextActions, sitemapStatuses, storageError, submitSitemap, toIsoDate, unmappedInspectionReasons, unverifySite, unwrapResult, urlMatchKey, verificationMethodsFor, verifySite };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gscdump",
   "type": "module",
-  "version": "0.37.3",
+  "version": "0.37.5",
   "description": "Google Search Console API wrapper with typed query builder, streaming pagination, and SEO analysis functions",
   "author": {
     "name": "Harlan Wilton",
@@ -62,6 +62,11 @@
       "import": "./dist/contracts.mjs",
       "default": "./dist/contracts.mjs"
     },
+    "./dates": {
+      "types": "./dist/dates.d.mts",
+      "import": "./dist/dates.mjs",
+      "default": "./dist/dates.mjs"
+    },
     "./normalize": {
       "types": "./dist/normalize.d.mts",
       "import": "./dist/normalize.mjs",
@@ -98,7 +103,7 @@
     "defu": "^6.1.7",
     "ofetch": "^1.5.1",
     "ufo": "^1.6.4",
-    "@gscdump/contracts": "0.37.3"
+    "@gscdump/contracts": "0.37.5"
   },
   "devDependencies": {
     "@googleapis/indexing": "^6.0.1",