gscdump 3.4.4 → 3.6.0

package/dist/bing/types.d.mts

@@ -1,12 +1,12 @@
 import { Result } from "../core/result.mjs";
-interface BingSiteWire {
+export interface BingSiteWire {
   __type?: string;
   AuthenticationCode: string;
   DnsVerificationCode: string;
   IsVerified: boolean;
   Url: string;
 }
-interface BingUrlInfoWire {
+export interface BingUrlInfoWire {
   __type?: string;
   AnchorCount: number;
   DiscoveryDate?: string | null;
@@ -17,14 +17,14 @@ interface BingUrlInfoWire {
   TotalChildUrlCount: number;
   Url: string;
 }
-interface BingUrlTrafficInfoWire {
+export interface BingUrlTrafficInfoWire {
   __type?: string;
   Clicks: number;
   Impressions: number;
   IsPage: boolean;
   Url: string;
 }
-interface BingQueryStatsWire {
+export interface BingQueryStatsWire {
   __type?: string;
   AvgClickPosition: number;
   AvgImpressionPosition: number;
@@ -33,13 +33,13 @@ interface BingQueryStatsWire {
   Impressions: number;
   Query: string;
 }
-interface BingRankAndTrafficStatsWire {
+export interface BingRankAndTrafficStatsWire {
   __type?: string;
   Clicks: number;
   Date: string;
   Impressions: number;
 }
-interface BingCrawlStatsWire {
+export interface BingCrawlStatsWire {
   __type?: string;
   AllOtherCodes: number;
   BlockedByRobotsTxt: number;
@@ -57,30 +57,30 @@ interface BingCrawlStatsWire {
   InIndex: number;
   InLinks: number;
 }
-interface BingCrawlIssueWire {
+export interface BingCrawlIssueWire {
   __type?: string;
   HttpCode: number;
   InLinks: number;
   Issues: number;
   Url: string;
 }
-interface BingWireResponse<T> {
+export interface BingWireResponse<T> {
   d: T;
 }
-interface BingVerifiedSite {
+export interface BingVerifiedSite {
   _tag: 'VerifiedSite';
   isVerified: true;
   url: string;
 }
-interface BingUnverifiedSite {
+export interface BingUnverifiedSite {
   _tag: 'UnverifiedSite';
   authenticationCode: string;
   dnsVerificationCode: string;
   isVerified: false;
   url: string;
 }
-type BingSite = BingVerifiedSite | BingUnverifiedSite;
-interface BingUrlInfo {
+export type BingSite = BingVerifiedSite | BingUnverifiedSite;
+export interface BingUrlInfo {
   anchorCount: number;
   discoveryDate?: string;
   documentSize: number;
@@ -90,13 +90,13 @@ interface BingUrlInfo {
   totalChildUrlCount: number;
   url: string;
 }
-interface BingUrlTrafficInfo {
+export interface BingUrlTrafficInfo {
   clicks: number;
   impressions: number;
   isPage: boolean;
   url: string;
 }
-interface BingPageStats {
+export interface BingPageStats {
   averageClickPosition: number | null;
   averageImpressionPosition: number | null;
   clicks: number;
@@ -104,7 +104,7 @@ interface BingPageStats {
   impressions: number;
   page: string;
 }
-interface BingQueryStats {
+export interface BingQueryStats {
   averageClickPosition: number | null;
   averageImpressionPosition: number | null;
   clicks: number;
@@ -112,12 +112,12 @@ interface BingQueryStats {
   impressions: number;
   query: string;
 }
-interface BingRankAndTrafficStats {
+export interface BingRankAndTrafficStats {
   clicks: number;
   date: string;
   impressions: number;
 }
-interface BingCrawlStats {
+export interface BingCrawlStats {
   allOtherCodes: number;
   blockedByRobotsTxt: number;
   code2xx: number;
@@ -134,15 +134,15 @@ interface BingCrawlStats {
   inIndex: number;
   inLinks: number;
 }
-type BingCrawlIssue = 'none' | '301' | '302' | '4xx' | '5xx' | 'blocked-by-robots-txt' | 'contains-malware' | 'important-url-blocked-by-robots-txt' | 'dns-errors' | 'timeout-errors' | 'unknown';
-interface BingUrlWithCrawlIssues {
+export type BingCrawlIssue = 'none' | '301' | '302' | '4xx' | '5xx' | 'blocked-by-robots-txt' | 'contains-malware' | 'important-url-blocked-by-robots-txt' | 'dns-errors' | 'timeout-errors' | 'unknown';
+export interface BingUrlWithCrawlIssues {
   httpCode: number;
   inLinks: number;
   issue: BingCrawlIssue;
   rawIssueCode: number;
   url: string;
 }
-interface BingCrawlEvidence {
+export interface BingCrawlEvidence {
   _tag: 'CrawlEvidence';
   anchorCount: number;
   discoveryDate?: string;
@@ -156,15 +156,15 @@ interface BingCrawlEvidence {
   uncertaintyReason: 'indexed-verdict-unavailable';
   url: string;
 }
-interface BingUnknownEvidence {
+export interface BingUnknownEvidence {
   _tag: 'UnknownEvidence';
   observedAt: string;
   reason: 'not-discovered' | 'not-observed';
   searchEngine: 'bing';
   url: string;
 }
-type BingIndexingEvidence = BingCrawlEvidence | BingUnknownEvidence;
-type BingProviderError = {
+export type BingIndexingEvidence = BingCrawlEvidence | BingUnknownEvidence;
+export type BingProviderError = {
   _tag: 'AuthenticationRequired';
 } | {
   _tag: 'PermissionDenied';
@@ -201,30 +201,30 @@ type BingProviderError = {
   _tag: 'PaginationLimitExceeded';
   maxPages: number;
 };
-interface BingEvidenceError {
+export interface BingEvidenceError {
   _tag: 'UnsupportedEvidence';
   reason: 'not-a-page';
   url: string;
 }
-type BingOperation = 'AddSite' | 'GetUserSites' | 'GetUrlInfo' | 'GetUrlTrafficInfo' | 'GetChildrenUrlInfo' | 'GetPageStats' | 'GetQueryStats' | 'GetRankAndTrafficStats' | 'GetCrawlStats' | 'GetCrawlIssues' | 'VerifySite';
-interface BingCallOptions {
+export type BingOperation = 'AddSite' | 'GetUserSites' | 'GetUrlInfo' | 'GetUrlTrafficInfo' | 'GetChildrenUrlInfo' | 'GetPageStats' | 'GetQueryStats' | 'GetRankAndTrafficStats' | 'GetCrawlStats' | 'GetCrawlIssues' | 'VerifySite';
+export interface BingCallOptions {
   signal?: AbortSignal;
 }
-type BingCrawlDateFilter = 'any' | 'last-week' | 'last-two-weeks' | 'last-three-weeks';
-type BingDiscoveredDateFilter = 'any' | 'last-week' | 'last-month';
-type BingDocumentFilter = 'any' | 'blocked-by-robots-txt' | 'malware';
-type BingHttpCodeFilter = 'any' | '2xx' | '3xx' | '301' | '302' | '4xx' | '5xx' | 'other';
-interface BingChildrenFilters {
+export type BingCrawlDateFilter = 'any' | 'last-week' | 'last-two-weeks' | 'last-three-weeks';
+export type BingDiscoveredDateFilter = 'any' | 'last-week' | 'last-month';
+export type BingDocumentFilter = 'any' | 'blocked-by-robots-txt' | 'malware';
+export type BingHttpCodeFilter = 'any' | '2xx' | '3xx' | '301' | '302' | '4xx' | '5xx' | 'other';
+export interface BingChildrenFilters {
   crawlDate?: BingCrawlDateFilter;
   discoveredDate?: BingDiscoveredDateFilter;
   document?: BingDocumentFilter;
   httpCode?: BingHttpCodeFilter;
 }
-interface BingChildrenOptions extends BingCallOptions {
+export interface BingChildrenOptions extends BingCallOptions {
   filters?: BingChildrenFilters;
   maxPages?: number;
 }
-interface BingWebmasterClient {
+export interface BingWebmasterClient {
   addSite: (siteUrl: string, options?: BingCallOptions) => Promise<Result<void, BingProviderError>>;
   getUserSites: (options?: BingCallOptions) => Promise<Result<BingSite[], BingProviderError>>;
   getVerifiedSite: (siteUrl: string, options?: BingCallOptions) => Promise<Result<BingVerifiedSite, BingProviderError>>;
@@ -239,11 +239,15 @@ interface BingWebmasterClient {
   getCrawlIssues: (siteUrl: string, options?: BingCallOptions) => Promise<Result<BingUrlWithCrawlIssues[], BingProviderError>>;
   verifySite: (siteUrl: string, options?: BingCallOptions) => Promise<Result<void, BingProviderError>>;
 }
-type BingFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-interface BingWebmasterOptions {
-  accessToken: string;
+export type BingFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export type BingWebmasterOptions = ({
+  accessToken: string | (() => string | Promise<string>);
+  apiKey?: never;
+} | {
+  apiKey: string;
+  accessToken?: never;
+}) & {
   baseUrl?: string;
   clock?: () => Date;
   fetch?: BingFetch;
-}
-export { BingCallOptions, BingChildrenFilters, BingChildrenOptions, BingCrawlDateFilter, BingCrawlEvidence, BingCrawlIssue, BingCrawlIssueWire, BingCrawlStats, BingCrawlStatsWire, BingDiscoveredDateFilter, BingDocumentFilter, BingEvidenceError, BingFetch, BingHttpCodeFilter, BingIndexingEvidence, BingOperation, BingPageStats, BingProviderError, BingQueryStats, BingQueryStatsWire, BingRankAndTrafficStats, BingRankAndTrafficStatsWire, BingSite, BingSiteWire, BingUnknownEvidence, BingUnverifiedSite, BingUrlInfo, BingUrlInfoWire, BingUrlTrafficInfo, BingUrlTrafficInfoWire, BingUrlWithCrawlIssues, BingVerifiedSite, BingWebmasterClient, BingWebmasterOptions, BingWireResponse };
+};

package/dist/contracts.d.mts

@@ -1,26 +1,26 @@
 import { GscSearchType, GscSearchType as GscSearchType$1 } from "@gscdump/contracts/search-types";
 import { ColumnDef, ColumnType, Row, TableName, TableSchema, TenantCtx } from "@gscdump/contracts";
-type GscSearchAnalyticsDimension = 'page' | 'query' | 'country' | 'device' | 'date' | 'hour' | 'searchAppearance';
-type GscDataState = 'final' | 'all' | 'hourly_all';
-interface GscSearchAnalyticsMetadata {
+export type GscSearchAnalyticsDimension = 'page' | 'query' | 'country' | 'device' | 'date' | 'hour' | 'searchAppearance';
+export type GscDataState = 'final' | 'all' | 'hourly_all';
+export interface GscSearchAnalyticsMetadata {
   /** First date (YYYY-MM-DD, PT) still being collected. Populated when dataState=`all` and grouped by `date`. */
   first_incomplete_date?: string;
   /** First hour (YYYY-MM-DDThh:mm:ss±hh:mm, PT) still being collected. Populated when dataState=`hourly_all` and grouped by `hour`. */
   first_incomplete_hour?: string;
 }
-type GscSearchAnalyticsFilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'includingRegex' | 'excludingRegex';
-interface GscSearchAnalyticsFilter {
+export type GscSearchAnalyticsFilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'includingRegex' | 'excludingRegex';
+export interface GscSearchAnalyticsFilter {
   dimension: GscSearchAnalyticsDimension;
   expression: string;
   operator?: GscSearchAnalyticsFilterOperator;
 }
-interface GscSearchAnalyticsFilterGroup {
+export interface GscSearchAnalyticsFilterGroup {
   groupType?: 'and' | 'or';
   filters: GscSearchAnalyticsFilter[];
 }
-type GscAggregationType = 'auto' | 'byPage' | 'byProperty' | 'byNewsShowcasePanel';
-type GscResponseAggregationType = 'auto' | 'byPage' | 'byProperty' | 'byNewsShowcasePanel';
-interface GscSearchAnalyticsRequest {
+export type GscAggregationType = 'auto' | 'byPage' | 'byProperty' | 'byNewsShowcasePanel';
+export type GscResponseAggregationType = 'auto' | 'byPage' | 'byProperty' | 'byNewsShowcasePanel';
+export interface GscSearchAnalyticsRequest {
   startDate: string;
   endDate: string;
   dimensions?: GscSearchAnalyticsDimension[];
@@ -32,16 +32,16 @@ interface GscSearchAnalyticsRequest {
   dataState?: GscDataState;
   aggregationType?: GscAggregationType;
 }
-interface GscSearchAnalyticsRow {
+export interface GscSearchAnalyticsRow {
   keys: string[];
   clicks: number;
   impressions: number;
   ctr: number;
   position: number;
 }
-interface GscSearchAnalyticsResponse {
+export interface GscSearchAnalyticsResponse {
   rows?: GscSearchAnalyticsRow[];
   responseAggregationType?: GscResponseAggregationType;
   metadata?: GscSearchAnalyticsMetadata;
 }
-export { type ColumnDef, type ColumnType, GscAggregationType, GscDataState, GscResponseAggregationType, GscSearchAnalyticsDimension, GscSearchAnalyticsFilter, GscSearchAnalyticsFilterGroup, GscSearchAnalyticsFilterOperator, GscSearchAnalyticsMetadata, GscSearchAnalyticsRequest, GscSearchAnalyticsResponse, GscSearchAnalyticsRow, type GscSearchType, type Row, type TableName, type TableSchema, type TenantCtx };
+export type { ColumnDef, ColumnType, GscSearchType, Row, TableName, TableSchema, TenantCtx };

package/dist/core/canonical.d.mts

@@ -1,4 +1,4 @@
-type CanonicalDifferenceKind = 'none' |
+export type CanonicalDifferenceKind = 'none' |
 /** Same resource, different spelling: trailing slash, scheme, `www.`, host case. */
 'formatting' |
 /** Same host, genuinely different resource. The ordinary "Google overrode you". */
@@ -12,7 +12,7 @@ type CanonicalDifferenceKind = 'none' |
  * either side is `none` — it preserves the both-non-null guard of the predicate
  * this replaces, and "Google has no opinion yet" is not a mismatch.
  */
-declare function classifyCanonicalDifference(userCanonical: string | null | undefined, googleCanonical: string | null | undefined): CanonicalDifferenceKind;
+export declare function classifyCanonicalDifference(userCanonical: string | null | undefined, googleCanonical: string | null | undefined): CanonicalDifferenceKind;
 /**
  * Does this pair represent a canonical problem worth counting?
  *
@@ -20,5 +20,4 @@ declare function classifyCanonicalDifference(userCanonical: string | null | unde
  * ways, and counting them is what inflated the headline number. Surface them
  * separately if they matter, but never in the mismatch count.
  */
-declare function isCanonicalMismatch(userCanonical: string | null | undefined, googleCanonical: string | null | undefined): boolean;
-export { CanonicalDifferenceKind, classifyCanonicalDifference, isCanonicalMismatch };
+export declare function isCanonicalMismatch(userCanonical: string | null | undefined, googleCanonical: string | null | undefined): boolean;

package/dist/core/client.d.mts

@@ -4,18 +4,18 @@ import { GSCQueryBuilder } from "../query/builder.mjs";
 import { ApiSite, ApiSitemap, InspectUrlIndexResponse, PublishUrlNotificationResponse, SearchAnalyticsQuery, SearchAnalyticsResponse, UrlNotificationMetadata } from "./types.mjs";
 import { $Fetch, FetchOptions } from "ofetch";
 /** Default deadline for each direct Google API request. */
-declare const DEFAULT_GSC_REQUEST_TIMEOUT_MS = 30000;
-type VerificationMethod = 'META' | 'FILE' | 'DNS_TXT' | 'DNS_CNAME' | 'ANALYTICS' | 'TAG_MANAGER';
-type VerificationSiteType = 'SITE' | 'INET_DOMAIN' | 'ANDROID_APP';
-interface VerificationSite {
+export declare const DEFAULT_GSC_REQUEST_TIMEOUT_MS = 30000;
+export type VerificationMethod = 'META' | 'FILE' | 'DNS_TXT' | 'DNS_CNAME' | 'ANALYTICS' | 'TAG_MANAGER';
+export type VerificationSiteType = 'SITE' | 'INET_DOMAIN' | 'ANDROID_APP';
+export interface VerificationSite {
   type: VerificationSiteType;
   identifier: string;
 }
-interface VerificationToken {
+export interface VerificationToken {
   method: string;
   token: string;
 }
-interface VerificationWebResource {
+export interface VerificationWebResource {
   id?: string;
   site: VerificationSite;
   owners?: string[];
@@ -23,7 +23,7 @@ interface VerificationWebResource {
 /**
  * Compatible interface with OAuth2Client from google-auth-library
  */
-interface AuthClient {
+export interface AuthClient {
   credentials?: {
     access_token?: string | null;
     refresh_token?: string | null;
@@ -33,28 +33,28 @@ interface AuthClient {
     token?: string | null;
   }>;
 }
-interface AuthOptions {
+export interface AuthOptions {
   clientId: string;
   clientSecret: string;
   refreshToken: string;
 }
-declare function createAuth(options: AuthOptions): AuthClient;
+export declare function createAuth(options: AuthOptions): AuthClient;
 /** Auth can be a token string, object with accessToken, or OAuth2Client-like object with credentials */
-type Auth = string | {
+export type Auth = string | {
   accessToken: string;
 } | AuthClient | AuthOptions;
-declare function createFetch(auth: Auth, options?: FetchOptions): $Fetch;
+export declare function createFetch(auth: Auth, options?: FetchOptions): $Fetch;
 /** Per-call options. `signal` cancels the in-flight request (and, for `query`, the next page too). */
-interface CallOptions {
+export interface CallOptions {
   signal?: AbortSignal;
 }
 /** Generator return value for `client.query` — exposes API response metadata plus the resolved aggregation type Google actually used (may differ from the requested `aggregationType: 'auto'`). */
-interface QueryReturn {
+export interface QueryReturn {
   metadata?: GscSearchAnalyticsMetadata;
   /** Aggregation type Google actually used. Useful when requesting `auto` to know if rows were aggregated `byPage` vs `byProperty`. */
   responseAggregationType?: GscResponseAggregationType;
 }
-interface GoogleSearchConsoleClient {
+export interface GoogleSearchConsoleClient {
   /** Query search analytics with builder, returns async generator yielding typed row batches */
   query: <D extends Dimension[], C>(siteUrl: string, builder: GSCQueryBuilder<D, C>, opts?: CallOptions) => AsyncGenerator<GSCRow<D, C>[], QueryReturn>;
   /**
@@ -113,12 +113,11 @@ interface GoogleSearchConsoleClient {
     query: (siteUrl: string, body: SearchAnalyticsQuery, opts?: CallOptions) => Promise<SearchAnalyticsResponse>;
   };
 }
-interface GoogleSearchConsoleClientOptions {
+export interface GoogleSearchConsoleClientOptions {
   fetchOptions?: FetchOptions;
   fetch?: $Fetch;
   onRateLimited?: (context: {
     response: Response;
   }) => void | Promise<void>;
 }
-declare function googleSearchConsole(auth: Auth, options?: GoogleSearchConsoleClientOptions): GoogleSearchConsoleClient;
-export { Auth, AuthClient, AuthOptions, CallOptions, DEFAULT_GSC_REQUEST_TIMEOUT_MS, GoogleSearchConsoleClient, GoogleSearchConsoleClientOptions, QueryReturn, VerificationMethod, VerificationSite, VerificationSiteType, VerificationToken, VerificationWebResource, createAuth, createFetch, googleSearchConsole };
+export declare function googleSearchConsole(auth: Auth, options?: GoogleSearchConsoleClientOptions): GoogleSearchConsoleClient;

package/dist/core/client.mjs

@@ -51,11 +51,13 @@ async function resolveToken(auth) {
 }
 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)");
 	return ofetch.create({
 		...options,
-		timeout: options?.timeout ?? 3e4,
-		retry: 3,
-		retryDelay: (ctx) => {
+		retry: options?.retry ?? 3,
+		retryDelay: options?.retryDelay ?? ((ctx) => {
 			const status = ctx.response?.status;
 			if (status === 429 || status === 503) {
 				const header = ctx.response?.headers.get("retry-after");
@@ -67,8 +69,8 @@ function createFetch(auth, options) {
 				}
 			}
 			return 1e3;
-		},
-		retryStatusCodes: [
+		}),
+		retryStatusCodes: options?.retryStatusCodes ?? [
 			408,
 			425,
 			429,
@@ -77,16 +79,17 @@ function createFetch(auth, options) {
 			503,
 			504
 		],
-		headers: {
-			...options?.headers,
-			"Accept-Encoding": "gzip",
-			"User-Agent": "gscdump (gzip)"
-		},
-		async onRequest({ options }) {
+		timeout: options?.timeout ?? 3e4,
+		headers,
+		async onRequest(ctx) {
 			const token = await resolveToken(authState);
 			if (token) {
-				options.headers = new Headers(options.headers);
-				options.headers.set("Authorization", `Bearer ${token}`);
+				ctx.options.headers = new Headers(ctx.options.headers);
+				ctx.options.headers.set("Authorization", `Bearer ${token}`);
+			}
+			if (options?.onRequest) {
+				const handlers = Array.isArray(options.onRequest) ? options.onRequest : [options.onRequest];
+				for (const handler of handlers) await handler(ctx);
 			}
 		},
 		async onResponseError(ctx) {

package/dist/core/errors.d.mts

@@ -1,5 +1,5 @@
-type GscErrorKind = 'auth-expired' | 'rate-limited' | 'not-found' | 'validation' | 'storage' | 'transport';
-type GscError = {
+export type GscErrorKind = 'auth-expired' | 'rate-limited' | 'not-found' | 'validation' | 'storage' | 'transport';
+export type GscError = {
   kind: 'auth-expired';
   message: string;
   cause: unknown;
@@ -30,22 +30,22 @@ type GscError = {
  * Classify an unknown error into a `GscError` discriminated union.
  * Transport is the catch-all — anything without a recognizable status ends up there.
  */
-declare function classifyError(cause: unknown): GscError;
+export declare function classifyError(cause: unknown): GscError;
 /**
  * Re-raises a `GscError` value as an `Error`, preserving its `cause` for
  * stack-walking and stashing the original union under `.gscError`. Pairs with
  * `unwrapResult` from `gscdump/result` so a `fooResult(): Result<A, GscError>`
  * core can be wrapped by a throwing `foo()` without losing the typed error.
  */
-declare function gscErrorToException(error: GscError): Error;
-interface GscApiErrorInfo {
+export declare function gscErrorToException(error: GscError): Error;
+export interface GscApiErrorInfo {
   code: number;
   message: string;
   reason?: string;
   status?: string;
 }
-declare function parseGoogleError(text: string, httpStatus?: number): GscApiErrorInfo;
-declare class GscApiError extends Error {
+export declare function parseGoogleError(text: string, httpStatus?: number): GscApiErrorInfo;
+export declare class GscApiError extends Error {
   info: GscApiErrorInfo;
   constructor(message: string, info: GscApiErrorInfo);
 }
@@ -55,12 +55,11 @@ declare class GscApiError extends Error {
  * via `parseGoogleError`); passes through existing `GscApiError`; re-throws
  * anything else as-is.
  */
-declare function rethrowAsGscApiError(prefix: string): (err: unknown) => never;
+export declare function rethrowAsGscApiError(prefix: string): (err: unknown) => never;
 /**
  * String-matches an error against the signals Google returns when a token
  * has lost access to a property (revoked, downgraded, or never had it).
  * Cheaper than a full {@link classifyError} call when the caller only
  * needs the permission verdict.
  */
-declare function isPermissionDeniedError(err: unknown): boolean;
-export { GscApiError, GscApiErrorInfo, GscError, GscErrorKind, classifyError, gscErrorToException, isPermissionDeniedError, parseGoogleError, rethrowAsGscApiError };
+export declare function isPermissionDeniedError(err: unknown): boolean;

package/dist/core/errors.mjs

@@ -38,6 +38,7 @@ function extractMessage(error) {
 	], isString) ?? String(error);
 }
 function extractRetryAfter(error) {
+	const headers = pickField(error, [["headers"], ["response", "headers"]], (value) => value instanceof Headers);
 	const raw = pickField(error, [
 		["headers", "retry-after"],
 		["headers", "Retry-After"],
@@ -51,7 +52,7 @@ function extractRetryAfter(error) {
 			"headers",
 			"Retry-After"
 		]
-	], (v) => typeof v === "number" || typeof v === "string");
+	], (v) => typeof v === "number" || typeof v === "string") ?? headers?.get("retry-after");
 	if (typeof raw === "number") return raw;
 	if (typeof raw === "string") {
 		const seconds = Number.parseInt(raw, 10);

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

@@ -1,55 +1,55 @@
 /** Milliseconds in a UTC day. Use for date arithmetic without DST surprises. */
-declare const MS_PER_DAY = 86400000;
+export declare const MS_PER_DAY = 86400000;
 /** Format a Date as YYYY-MM-DD (UTC). */
-declare function toIsoDate(d: Date): string;
+export 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;
+export 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;
+export declare const GSC_FRESHEST_LAG_DAYS = 1;
 /** Approximate historical retention window for Search Analytics. */
-declare const GSC_RETENTION_MONTHS = 16;
+export declare const GSC_RETENTION_MONTHS = 16;
 /** Today's date (YYYY-MM-DD) in PST. */
-declare function getPstDate(): string;
+export declare function getPstDate(): string;
 /** YYYY-MM-DD for `now() - n` days, UTC. */
-declare function daysAgo(n: number): string;
+export declare function daysAgo(n: number): string;
 /** Most recent finalized date (3 days ago PST). */
-declare function getLatestGscDate(): string;
+export declare function getLatestGscDate(): string;
 /** Freshest date GSC will return (yesterday PST, may still update). */
-declare function getFreshestGscDate(): string;
+export 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[];
+export declare function getPendingDates(): string[];
 /** All dates between two YYYY-MM-DD strings (inclusive, oldest first). */
-declare function getDateRange(startDate: string, endDate: string): string[];
+export declare function getDateRange(startDate: string, endDate: string): string[];
 /** Default span used when chunking long backfills into batches. */
-declare const DAYS_PER_RANGE = 30;
+export 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[];
+export 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<{
+export 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;
+export declare function countDays(startDate: string, endDate: string): number;
 /** Oldest date GSC retains (~16 months ago). */
-declare function getOldestGscDate(): string;
+export declare function getOldestGscDate(): string;
 /** Add `n` UTC days to a YYYY-MM-DD string (n may be negative). */
-declare function addDays(dateStr: string, n: number): string;
-declare function getPreviousDate(dateStr: string): string;
-declare function getNextDate(dateStr: string): string;
+export declare function addDays(dateStr: string, n: number): string;
+export declare function getPreviousDate(dateStr: string): string;
+export declare function getNextDate(dateStr: string): string;
 /** True if `dateStr` falls within GSC's queryable window. */
-declare function isValidGscDate(dateStr: string): boolean;
-interface BackfillProgress {
+export declare function isValidGscDate(dateStr: string): boolean;
+export interface BackfillProgress {
   progress: number;
   daysAvailable: number;
   daysSynced: number;
@@ -60,5 +60,4 @@ interface BackfillProgress {
  * 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;
-export { BackfillProgress, 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 declare function getBackfillProgress(oldestDateSynced: string | null, newestDateSynced: string | null): BackfillProgress | null;

package/dist/core/indexing-issues.d.mts

@@ -9,8 +9,8 @@
  * Kept beside {@link INDEXING_ISSUE_FILTERS} so the JS and SQL sides of the rule
  * cannot drift; call sites must use this rather than re-deriving `includes('#')`.
  */
-declare function isFragmentUrl(url: string): boolean;
-declare const INDEXING_ISSUE_FILTERS: {
+export declare function isFragmentUrl(url: string): boolean;
+export declare const INDEXING_ISSUE_FILTERS: {
   readonly canonical_mismatch: "canonical_mismatch_kind = 'path'";
   readonly canonical_cross_domain: "canonical_mismatch_kind = 'cross_domain'";
   readonly canonical_formatting: "canonical_mismatch_kind = 'formatting'";
@@ -42,21 +42,21 @@ declare const INDEXING_ISSUE_FILTERS: {
   readonly rich_results_warning: "rich_results_verdict = 'PARTIAL'";
   readonly rich_results_pass: "rich_results_verdict = 'PASS'";
 };
-type IndexingIssueType = keyof typeof INDEXING_ISSUE_FILTERS;
-declare const INDEXING_ISSUE_LABELS: Record<IndexingIssueType, string>;
-declare const INDEXING_ISSUE_SEVERITY: Record<IndexingIssueType, 'error' | 'warning' | 'info'>;
+export type IndexingIssueType = keyof typeof INDEXING_ISSUE_FILTERS;
+export declare const INDEXING_ISSUE_LABELS: Record<IndexingIssueType, string>;
+export declare const INDEXING_ISSUE_SEVERITY: Record<IndexingIssueType, 'error' | 'warning' | 'info'>;
 /**
  * Every `pageFetchState` the URL Inspection API documents. `SUCCESSFUL` and the
  * `_UNSPECIFIED` sentinel are non-faults; the rest each map to a filter above.
  */
-declare const KNOWN_PAGE_FETCH_STATES: ReadonlySet<string>;
+export declare const KNOWN_PAGE_FETCH_STATES: ReadonlySet<string>;
 /**
  * Every `coverageState` string we have a bucket for, plus the indexed-state strings
  * that are not faults. Google is free to invent new prose here at any time — that's
  * exactly what {@link unmappedInspectionReasons} exists to catch.
  */
-declare const KNOWN_COVERAGE_STATES: ReadonlySet<string>;
-interface UnmappedInspectionReasons {
+export declare const KNOWN_COVERAGE_STATES: ReadonlySet<string>;
+export interface UnmappedInspectionReasons {
   coverageStates: string[];
   pageFetchStates: string[];
 }
@@ -68,8 +68,7 @@ interface UnmappedInspectionReasons {
  * still counted in `not_indexed`, but nothing narrower, so the product will
  * under-report exactly the way it did for `ACCESS_FORBIDDEN` before this existed.
  */
-declare function unmappedInspectionReasons(rows: ReadonlyArray<{
+export declare function unmappedInspectionReasons(rows: ReadonlyArray<{
   coverageState?: string | null;
   pageFetchState?: string | null;
-}>): UnmappedInspectionReasons;
-export { INDEXING_ISSUE_FILTERS, INDEXING_ISSUE_LABELS, INDEXING_ISSUE_SEVERITY, IndexingIssueType, KNOWN_COVERAGE_STATES, KNOWN_PAGE_FETCH_STATES, UnmappedInspectionReasons, isFragmentUrl, unmappedInspectionReasons };
+}>): UnmappedInspectionReasons;