gscdump 3.4.4 → 3.6.0

package/README.md

@@ -25,20 +25,36 @@ const client = googleSearchConsole({ accessToken: 'ya29.xxx' })
 const sites = await client.sites()
 ```
 
+Use `fetchOptions` for custom headers, request hooks, or retry settings:
+
+```ts
+const client = googleSearchConsole('ya29.xxx', {
+  fetchOptions: {
+    headers: new Headers({ 'x-project': 'analytics' }),
+    retry: 0,
+    timeout: 10_000,
+    onRequest({ options }) {
+      options.headers.set('x-request-id', crypto.randomUUID())
+    },
+  },
+})
+```
+
+Request hooks run after authentication. The client awaits each hook, including arrays of hooks.
+If you omit retry settings, requests use three retries and respect Google's `Retry-After` header.
+
 Use `gscdump/query` to build a request. `client.query()` paginates through Google's 25,000-row pages and yields each non-empty batch.
 
 ```ts
 import { googleSearchConsole } from 'gscdump'
-import { and, between, date, daysAgo, gsc, page, query, today } from 'gscdump/query'
+import { between, date, daysAgo, gsc, page, query } from 'gscdump/query'
 
 const client = googleSearchConsole('ya29.xxx')
 const siteUrl = 'sc-domain:example.com'
 
 const request = gsc
   .select(page, query)
-  .where(and(
-    between(date, daysAgo(28), today()),
-  ))
+  .where(between(date, daysAgo(30), daysAgo(3)))
 
 for await (const rows of client.query(siteUrl, request)) {
   for (const row of rows)
@@ -59,7 +75,7 @@ const response = await client.searchAnalytics.query(siteUrl, {
 
 ## Other Google resources
 
-The same client exposes the Google resources owned by this package:
+Use the same client for sitemaps, inspections, and eligible Indexing API notifications:
 
 ```ts
 const sitemapList = await client.sitemaps.list(siteUrl)
@@ -71,17 +87,21 @@ await client.indexing.publish(
 )
 ```
 
+Indexing notifications apply only to eligible job or livestream pages.
+See [URL inspection and indexing](../../docs/guides/url-indexing.md).
+
 The package root also exports batch and projection helpers such as `fetchSitesWithSitemaps`, `batchInspectUrlsFlatSettled`, `inspectUrlFlat`, and `batchRequestIndexing`.
 
 ## Read Bing Indexing Evidence
 
-Use `gscdump/bing` with an OAuth access token. The client returns tagged
+Use `gscdump/bing` with an OAuth access token or Bing Webmaster API key. The client returns tagged
 `Result` values and never infers an indexed verdict from crawl evidence.
 
 ```ts
 import { bingWebmaster } from 'gscdump/bing'
 
 const client = bingWebmaster({ accessToken: 'access-token' })
+// API key alternative: bingWebmaster({ apiKey: 'bing-webmaster-api-key' })
 const evidence = await client.getIndexingEvidence(
   'https://example.com/',
   'https://example.com/docs',
@@ -97,12 +117,21 @@ const [pages, queries, crawl] = await Promise.all([
 ])
 ```
 
-Sitemap XML reading and traversal lives in `sitemapd`. Product feed scoping and
+`accessToken` also accepts a function returning a string or `Promise<string>`.
+The client calls that function before each request, so callers can refresh expiring tokens during long exports.
+The CLI manages this refresh when you use `gscdump bing login --mode local --oauth`.
+
+Sitemap XML reading and traversal live in `sitemapd`. Product feed scoping and
 exact membership hashing live in `gscdump/sitemap-identity`. Hosted canonical
 sitemap membership is available through `@gscdump/sdk/v1`.
 
 ## Public subpaths
 
+- `gscdump/client`: Google client and authentication types
+- `gscdump/indexing`: inspection and indexing helpers
+- `gscdump/errors`: typed Google API failures
+- `gscdump/sites`: Site helpers
+- `gscdump/sitemap-identity`: sitemap scope and membership hashing
 - `gscdump/query`: query builder, columns, operators, Pacific date helpers, and logical query plans
 - `gscdump/query/plan`: logical query planning only
 - `gscdump/bing`: Bing Site, URL, traffic, and crawl evidence calls

package/dist/api/batch.d.mts

@@ -4,9 +4,8 @@
  * (concurrency = 1) because the underlying APIs rate-limit aggressively;
  * callers that know their quota headroom can opt into parallelism.
  */
-declare function runSequentialBatch<I, R>(items: I[], operation: (item: I, index: number) => Promise<R>, options?: {
+export declare function runSequentialBatch<I, R>(items: I[], operation: (item: I, index: number) => Promise<R>, options?: {
   delayMs?: number;
   concurrency?: number;
   onProgress?: (result: R, index: number, total: number) => void;
-}): Promise<R[]>;
-export { runSequentialBatch };
+}): Promise<R[]>;

package/dist/api/batch.mjs

@@ -1,5 +1,7 @@
 async function runSequentialBatch(items, operation, options = {}) {
 	const { delayMs = 0, concurrency = 1, onProgress } = options;
+	if (!Number.isInteger(concurrency) || concurrency < 1) throw new RangeError("concurrency must be a positive integer.");
+	if (!Number.isFinite(delayMs) || delayMs < 0) throw new RangeError("delayMs must be a finite, nonnegative number.");
 	const results = Array.from({ length: items.length });
 	let completed = 0;
 	if (concurrency <= 1) {

package/dist/api/indexing.d.mts

@@ -1,12 +1,12 @@
 import { UrlNotification } from "../core/types.mjs";
 import { GoogleSearchConsoleClient } from "../core/client.mjs";
-type IndexingNotificationType = 'URL_UPDATED' | 'URL_DELETED';
-interface IndexingResult {
+export type IndexingNotificationType = 'URL_UPDATED' | 'URL_DELETED';
+export interface IndexingResult {
   url: string;
   type: IndexingNotificationType;
   notifyTime?: string;
 }
-interface IndexingMetadata {
+export interface IndexingMetadata {
   url: string;
   latestUpdate?: UrlNotification;
   latestRemove?: UrlNotification;
@@ -16,22 +16,21 @@ interface IndexingMetadata {
  * Note: The Indexing API officially supports only job posting and livestream content,
  * but can be used for any URL with varying success.
  */
-declare function requestIndexing(client: GoogleSearchConsoleClient, url: string, options?: {
+export declare function requestIndexing(client: GoogleSearchConsoleClient, url: string, options?: {
   type?: IndexingNotificationType;
 }): Promise<IndexingResult>;
 /**
  * Get the indexing notification metadata for a URL.
  * Returns when Google was last notified about updates/removals.
  */
-declare function getIndexingMetadata(client: GoogleSearchConsoleClient, url: string): Promise<IndexingMetadata>;
+export declare function getIndexingMetadata(client: GoogleSearchConsoleClient, url: string): Promise<IndexingMetadata>;
 /**
  * Batch request indexing for multiple URLs with rate limiting.
  * Returns results for each URL.
  */
-declare function batchRequestIndexing(client: GoogleSearchConsoleClient, urls: string[], options?: {
+export declare function batchRequestIndexing(client: GoogleSearchConsoleClient, urls: string[], options?: {
   type?: IndexingNotificationType;
   delayMs?: number;
   concurrency?: number;
   onProgress?: (result: IndexingResult, index: number, total: number) => void;
-}): Promise<IndexingResult[]>;
-export { IndexingMetadata, IndexingNotificationType, IndexingResult, batchRequestIndexing, getIndexingMetadata, requestIndexing };
+}): Promise<IndexingResult[]>;

package/dist/api/indexing.mjs

@@ -4,7 +4,7 @@ async function requestIndexing(client, url, options = {}) {
 	return client.indexing.publish(url, type).then((r) => ({
 		url,
 		type,
-		notifyTime: r.urlNotificationMetadata?.latestUpdate?.notifyTime || void 0
+		notifyTime: (type === "URL_DELETED" ? r.urlNotificationMetadata?.latestRemove : r.urlNotificationMetadata?.latestUpdate)?.notifyTime || void 0
 	}));
 }
 async function getIndexingMetadata(client, url) {

package/dist/api/inspection.d.mts

@@ -1,6 +1,6 @@
 import { UrlInspectionResult } from "../core/types.mjs";
 import { CallOptions, GoogleSearchConsoleClient } from "../core/client.mjs";
-interface InspectUrlResult {
+export interface InspectUrlResult {
   url: string;
   inspection?: UrlInspectionResult;
   isIndexed: boolean;
@@ -8,7 +8,7 @@ interface InspectUrlResult {
 /**
  * Inspects a URL in Google Search Console to check its indexing status.
  */
-declare function inspectUrl(client: GoogleSearchConsoleClient, siteUrl: string, inspectionUrl: string): Promise<{
+export declare function inspectUrl(client: GoogleSearchConsoleClient, siteUrl: string, inspectionUrl: string): Promise<{
   inspection: UrlInspectionResult | undefined;
   isIndexed: boolean;
 }>;
@@ -16,12 +16,12 @@ declare function inspectUrl(client: GoogleSearchConsoleClient, siteUrl: string,
  * Batch inspect multiple URLs with rate limiting.
  * Returns inspection results for each URL.
  */
-declare function batchInspectUrls(client: GoogleSearchConsoleClient, siteUrl: string, urls: string[], options?: {
+export declare function batchInspectUrls(client: GoogleSearchConsoleClient, siteUrl: string, urls: string[], options?: {
   delayMs?: number;
   concurrency?: number;
   onProgress?: (result: InspectUrlResult, index: number, total: number) => void;
 }): Promise<InspectUrlResult[]>;
-interface ParsedIndexingResult {
+export interface ParsedIndexingResult {
   url: string;
   verdict: string | null;
   coverageState: string | null;
@@ -50,10 +50,10 @@ interface ParsedIndexingResult {
   ampIssues: string | null;
   inspectionResultLink: string | null;
 }
-declare function inspectUrlFlat(client: GoogleSearchConsoleClient, siteUrl: string, inspectionUrl: string, options?: CallOptions): Promise<ParsedIndexingResult>;
+export declare function inspectUrlFlat(client: GoogleSearchConsoleClient, siteUrl: string, inspectionUrl: string, options?: CallOptions): Promise<ParsedIndexingResult>;
 /** Maximum parallel URL Inspection requests started by the settled flat batch helper. */
-declare const MAX_FLAT_INSPECTION_BATCH_CONCURRENCY = 10;
-type InspectUrlFlatSettledResult = {
+export declare const MAX_FLAT_INSPECTION_BATCH_CONCURRENCY = 10;
+export type InspectUrlFlatSettledResult = {
   url: string;
   status: 'fulfilled';
   value: ParsedIndexingResult;
@@ -62,7 +62,7 @@ type InspectUrlFlatSettledResult = {
   status: 'rejected';
   reason: unknown;
 };
-interface BatchInspectUrlsFlatSettledOptions extends CallOptions {
+export interface BatchInspectUrlsFlatSettledOptions extends CallOptions {
   /** Delay after each request handled by a worker. Defaults to 200ms. */
   delayMs?: number;
   /** Number of workers. Defaults to 1 and is capped at {@link MAX_FLAT_INSPECTION_BATCH_CONCURRENCY}. */
@@ -74,10 +74,10 @@ interface BatchInspectUrlsFlatSettledOptions extends CallOptions {
  * when one URL fails. Results retain input order and include each URL so
  * callers can persist successes and classify individual failures safely.
  */
-declare function batchInspectUrlsFlatSettled(client: GoogleSearchConsoleClient, siteUrl: string, urls: readonly string[], options?: BatchInspectUrlsFlatSettledOptions): Promise<InspectUrlFlatSettledResult[]>;
-type LegacyInspectionPriority = 'high' | 'medium' | 'low';
-type ValueWeightedInspectionPriority = 'critical' | 'high' | 'elevated' | 'normal' | 'dormant';
-type InspectionPriority = LegacyInspectionPriority | ValueWeightedInspectionPriority;
+export declare function batchInspectUrlsFlatSettled(client: GoogleSearchConsoleClient, siteUrl: string, urls: readonly string[], options?: BatchInspectUrlsFlatSettledOptions): Promise<InspectUrlFlatSettledResult[]>;
+export type LegacyInspectionPriority = 'high' | 'medium' | 'low';
+export type ValueWeightedInspectionPriority = 'critical' | 'high' | 'elevated' | 'normal' | 'dormant';
+export type InspectionPriority = LegacyInspectionPriority | ValueWeightedInspectionPriority;
 /**
  * Derive the recheck tier.
  *
@@ -85,19 +85,18 @@ type InspectionPriority = LegacyInspectionPriority | ValueWeightedInspectionPrio
  * signal freshness and the 90-day stable-zero guard, and should omit the value
  * until those conditions make a dormant classification safe.
  */
-declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>): LegacyInspectionPriority;
-declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>, impressions28d: undefined): LegacyInspectionPriority;
-declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>, impressions28d: number): ValueWeightedInspectionPriority;
-declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>, impressions28d: number | undefined): InspectionPriority;
+export declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>): LegacyInspectionPriority;
+export declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>, impressions28d: undefined): LegacyInspectionPriority;
+export declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>, impressions28d: number): ValueWeightedInspectionPriority;
+export declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdict'>, impressions28d: number | undefined): InspectionPriority;
 /** Next-check unix seconds for a given priority. */
-declare function getNextCheckAfter(priority: InspectionPriority): number;
-declare function canUseUrlInspection(permissionLevel: string | null | undefined): boolean;
-type IndexingIneligibleReason = 'missing_gsc_read_scope' | 'insufficient_gsc_permission';
-interface IndexingEligibility {
+export declare function getNextCheckAfter(priority: InspectionPriority): number;
+export declare function canUseUrlInspection(permissionLevel: string | null | undefined): boolean;
+export type IndexingIneligibleReason = 'missing_gsc_read_scope' | 'insufficient_gsc_permission';
+export interface IndexingEligibility {
   indexingEligible: boolean;
   indexingIneligibleReason?: IndexingIneligibleReason;
   indexingPermissionLevel?: string | null;
   grantedScopes?: string[];
 }
-declare function getIndexingEligibility(grantedScopes: string | null | undefined, permissionLevel: string | null | undefined): IndexingEligibility;
-export { BatchInspectUrlsFlatSettledOptions, IndexingEligibility, IndexingIneligibleReason, InspectUrlFlatSettledResult, InspectUrlResult, InspectionPriority, LegacyInspectionPriority, MAX_FLAT_INSPECTION_BATCH_CONCURRENCY, ParsedIndexingResult, ValueWeightedInspectionPriority, batchInspectUrls, batchInspectUrlsFlatSettled, canUseUrlInspection, getIndexingEligibility, getNextCheckAfter, getNextCheckPriority, inspectUrl, inspectUrlFlat };
+export declare function getIndexingEligibility(grantedScopes: string | null | undefined, permissionLevel: string | null | undefined): IndexingEligibility;

package/dist/api/oauth.d.mts

@@ -1,6 +1,6 @@
 import { Result } from "../core/result.mjs";
 import { GscError } from "../core/errors.mjs";
-interface OAuthTokens {
+export interface OAuthTokens {
   accessToken: string;
   /** Unix seconds. */
   expiresAt: number;
@@ -8,7 +8,7 @@ interface OAuthTokens {
   scope?: string;
 }
 /** Normalized response from Google's access-token introspection endpoint. */
-interface OAuthTokenInfo {
+export interface OAuthTokenInfo {
   issuedTo?: string;
   audience?: string;
   authorizedParty?: string;
@@ -28,21 +28,20 @@ interface OAuthTokenInfo {
  * failures; surfaces HTTP failures (invalid_grant, etc.) immediately as
  * `GscApiError` so callers can mark the refresh token as bad.
  */
-declare function refreshAccessToken(refreshToken: string, clientId: string, clientSecret: string): Promise<OAuthTokens>;
+export declare function refreshAccessToken(refreshToken: string, clientId: string, clientSecret: string): Promise<OAuthTokens>;
 /**
  * Exchange an authorization code (from the OAuth consent redirect) for
  * access + refresh tokens. Same retry / surface model and `auth-expired` vs
  * `transport` classification as {@link refreshAccessTokenResult}.
  */
-declare function exchangeAuthCodeResult(code: string, clientId: string, clientSecret: string, redirectUri: string): Promise<Result<OAuthTokens & {
+export declare function exchangeAuthCodeResult(code: string, clientId: string, clientSecret: string, redirectUri: string): Promise<Result<OAuthTokens & {
   refreshToken?: string;
 }, GscError>>;
 /** Inspect an access token without throwing on expected OAuth failures. */
-declare function introspectAccessTokenResult(accessToken: string): Promise<Result<OAuthTokenInfo, GscError>>;
+export declare function introspectAccessTokenResult(accessToken: string): Promise<Result<OAuthTokenInfo, GscError>>;
 /** Throwing convenience wrapper for {@link introspectAccessTokenResult}. */
-declare function introspectAccessToken(accessToken: string): Promise<OAuthTokenInfo>;
+export declare function introspectAccessToken(accessToken: string): Promise<OAuthTokenInfo>;
 /** Revoke an access or refresh token without throwing on expected OAuth failures. */
-declare function revokeOAuthTokenResult(token: string): Promise<Result<void, GscError>>;
+export declare function revokeOAuthTokenResult(token: string): Promise<Result<void, GscError>>;
 /** Throwing convenience wrapper for {@link revokeOAuthTokenResult}. */
-declare function revokeOAuthToken(token: string): Promise<void>;
-export { OAuthTokenInfo, OAuthTokens, exchangeAuthCodeResult, introspectAccessToken, introspectAccessTokenResult, refreshAccessToken, revokeOAuthToken, revokeOAuthTokenResult };
+export declare function revokeOAuthToken(token: string): Promise<void>;

package/dist/api/oauth.mjs

@@ -99,6 +99,12 @@ async function postOAuthTokenResult(body, op) {
 	const parsed = await readOAuthJsonResult(response.value, op);
 	if (!parsed.ok) return parsed;
 	const data = parsed.value;
+	if (typeof data.access_token !== "string" || !data.access_token.trim() || typeof data.expires_in !== "number" || !Number.isFinite(data.expires_in) || data.expires_in < 0 || data.refresh_token !== void 0 && typeof data.refresh_token !== "string" || data.scope !== void 0 && typeof data.scope !== "string") return err({
+		kind: "transport",
+		message: `Invalid ${op} token response`,
+		status: response.value.status,
+		cause: /* @__PURE__ */ new TypeError("OAuth response requires a nonempty access_token and a finite, nonnegative expires_in.")
+	});
 	return ok({
 		accessToken: data.access_token,
 		expiresAt: Math.floor(Date.now() / 1e3) + data.expires_in,
@@ -133,7 +139,9 @@ async function requestOAuthResult(url, init, op) {
 }
 async function readOAuthJsonResult(response, op) {
 	try {
-		return ok(await response.json());
+		const value = await response.json();
+		if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("OAuth response must be an object.");
+		return ok(value);
 	} catch (cause) {
 		return err({
 			kind: "transport",

package/dist/api/sites.d.mts

@@ -1,35 +1,35 @@
 import { ApiSite, ApiSitemap, Site } from "../core/types.mjs";
 import { GoogleSearchConsoleClient } from "../core/client.mjs";
-interface FetchSitesWithSitemapsOptions {
+export interface FetchSitesWithSitemapsOptions {
   /** Maximum concurrent sitemap-list requests. Defaults to 4. */
   concurrency?: number;
 }
 /**
  * Fetches all sites the authenticated user has access to in Google Search Console.
  */
-declare function fetchSites(client: GoogleSearchConsoleClient): Promise<ApiSite[]>;
+export declare function fetchSites(client: GoogleSearchConsoleClient): Promise<ApiSite[]>;
 /**
  * Fetches all verified sites with their sitemaps from Google Search Console.
  */
-declare function fetchSitesWithSitemaps(client: GoogleSearchConsoleClient, options?: FetchSitesWithSitemapsOptions): Promise<(Site & {
+export declare function fetchSitesWithSitemaps(client: GoogleSearchConsoleClient, options?: FetchSitesWithSitemapsOptions): Promise<(Site & {
   sitemaps: ApiSitemap[];
 })[]>;
 /**
  * Fetches all sitemaps for a site.
  */
-declare function fetchSitemaps(client: GoogleSearchConsoleClient, siteUrl: string): Promise<ApiSitemap[]>;
+export declare function fetchSitemaps(client: GoogleSearchConsoleClient, siteUrl: string): Promise<ApiSitemap[]>;
 /**
  * Fetches a specific sitemap.
  */
-declare function fetchSitemap(client: GoogleSearchConsoleClient, siteUrl: string, feedpath: string): Promise<ApiSitemap>;
+export declare function fetchSitemap(client: GoogleSearchConsoleClient, siteUrl: string, feedpath: string): Promise<ApiSitemap>;
 /**
  * Submits a sitemap to Google Search Console.
  */
-declare function submitSitemap(client: GoogleSearchConsoleClient, siteUrl: string, feedpath: string): Promise<void>;
+export declare function submitSitemap(client: GoogleSearchConsoleClient, siteUrl: string, feedpath: string): Promise<void>;
 /**
  * Deletes a sitemap from Google Search Console.
  */
-declare function deleteSitemap(client: GoogleSearchConsoleClient, siteUrl: string, feedpath: string): Promise<void>;
+export declare function deleteSitemap(client: GoogleSearchConsoleClient, siteUrl: string, feedpath: string): Promise<void>;
 /**
  * Add a property to the user's Search Console account.
  *
@@ -37,9 +37,8 @@ declare function deleteSitemap(client: GoogleSearchConsoleClient, siteUrl: strin
  * must be proven via the Site Verification API (see `verifySite`) before any
  * data is accessible.
  */
-declare function addSite(client: GoogleSearchConsoleClient, siteUrl: string): Promise<void>;
+export declare function addSite(client: GoogleSearchConsoleClient, siteUrl: string): Promise<void>;
 /**
  * Remove a property from the user's Search Console account.
  */
-declare function deleteSite(client: GoogleSearchConsoleClient, siteUrl: string): Promise<void>;
-export { FetchSitesWithSitemapsOptions, addSite, deleteSite, deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, submitSitemap };
+export declare function deleteSite(client: GoogleSearchConsoleClient, siteUrl: string): Promise<void>;

package/dist/api/verification.d.mts

@@ -3,9 +3,9 @@ import { GoogleSearchConsoleClient, VerificationMethod, VerificationSite, Verifi
  * Resolve a Search Console site URL (`https://example.com/` or
  * `sc-domain:example.com`) to the Site Verification API's site shape.
  */
-declare function siteUrlToVerificationSite(siteUrl: string): VerificationSite;
+export declare function siteUrlToVerificationSite(siteUrl: string): VerificationSite;
 /** Resolve a Search Console property and method to Google's verification target. */
-declare function resolveVerificationTarget(siteUrl: string, method?: VerificationMethod): {
+export declare function resolveVerificationTarget(siteUrl: string, method?: VerificationMethod): {
   site: VerificationSite;
   method: VerificationMethod;
 };
@@ -13,31 +13,30 @@ declare function resolveVerificationTarget(siteUrl: string, method?: Verificatio
  * Methods valid for a given site shape. SITE properties can use META/FILE/
  * ANALYTICS/TAG_MANAGER; INET_DOMAIN must use DNS_TXT or DNS_CNAME.
  */
-declare function verificationMethodsFor(site: VerificationSite): VerificationMethod[];
+export declare function verificationMethodsFor(site: VerificationSite): VerificationMethod[];
 /**
  * Get the verification token Google expects to find on the site or DNS.
  */
-declare function getVerificationToken(client: GoogleSearchConsoleClient, siteUrl: string, method: VerificationMethod): Promise<VerificationToken & {
+export declare function getVerificationToken(client: GoogleSearchConsoleClient, siteUrl: string, method: VerificationMethod): Promise<VerificationToken & {
   site: VerificationSite;
 }>;
 /**
  * Trigger Google to validate the placed token. Caller is responsible for
  * having placed the token (HTML tag / file / DNS record) before calling.
  */
-declare function verifySite(client: GoogleSearchConsoleClient, siteUrl: string, method: VerificationMethod): Promise<VerificationWebResource>;
+export declare function verifySite(client: GoogleSearchConsoleClient, siteUrl: string, method: VerificationMethod): Promise<VerificationWebResource>;
 /**
  * List all verified WebResources for the authed user.
  */
-declare function listVerifiedSites(client: GoogleSearchConsoleClient): Promise<VerificationWebResource[]>;
+export declare function listVerifiedSites(client: GoogleSearchConsoleClient): Promise<VerificationWebResource[]>;
 /**
  * Fetch a single verified WebResource by id.
  */
-declare function getVerifiedSite(client: GoogleSearchConsoleClient, id: string): Promise<VerificationWebResource>;
+export declare function getVerifiedSite(client: GoogleSearchConsoleClient, id: string): Promise<VerificationWebResource>;
 /**
  * Drop the calling user's verified ownership of a WebResource. The placed
  * verification token (meta tag / file / DNS record) MUST be removed first,
  * otherwise Google may auto-re-verify and the call will fail. Other owners
  * on the property are unaffected.
  */
-declare function unverifySite(client: GoogleSearchConsoleClient, id: string): Promise<void>;
-export { getVerificationToken, getVerifiedSite, listVerifiedSites, resolveVerificationTarget, siteUrlToVerificationSite, unverifySite, verificationMethodsFor, verifySite };
+export declare function unverifySite(client: GoogleSearchConsoleClient, id: string): Promise<void>;

package/dist/bing/client.d.mts

@@ -1,5 +1,4 @@
 import { BingWebmasterClient, BingWebmasterOptions } from "./types.mjs";
-declare const DEFAULT_BING_WEBMASTER_API_URL = "https://www.bing.com/webmaster/api.svc/json";
-declare const DEFAULT_BING_CHILD_PAGE_LIMIT = 100;
-declare function bingWebmaster(options: BingWebmasterOptions): BingWebmasterClient;
-export { DEFAULT_BING_CHILD_PAGE_LIMIT, DEFAULT_BING_WEBMASTER_API_URL, bingWebmaster };
+export declare const DEFAULT_BING_WEBMASTER_API_URL = "https://www.bing.com/webmaster/api.svc/json";
+export declare const DEFAULT_BING_CHILD_PAGE_LIMIT = 100;
+export declare function bingWebmaster(options: BingWebmasterOptions): BingWebmasterClient;

package/dist/bing/client.mjs

@@ -1,6 +1,7 @@
 import { err, ok } from "../core/result.mjs";
 import { normalizeBingCrawlIssue, normalizeBingCrawlStats, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingQueryStats, normalizeBingRankAndTrafficStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo } from "./normalize.mjs";
 const DEFAULT_BING_WEBMASTER_API_URL = "https://www.bing.com/webmaster/api.svc/json";
+const DEFAULT_BING_API_KEY_URL = "https://ssl.bing.com/webmaster/api.svc/json";
 const DEFAULT_BING_CHILD_PAGE_LIMIT = 100;
 const BING_MAX_CHILD_PAGE_COUNT = 65536;
 function isRecord(value) {
@@ -109,24 +110,29 @@ function toFilterProperties(filters = {}) {
 	};
 }
 function bingWebmaster(options) {
-	const baseUrl = (options.baseUrl ?? "https://www.bing.com/webmaster/api.svc/json").replace(/\/+$/, "");
+	const baseUrl = (options.baseUrl ?? (options.apiKey === void 0 ? "https://www.bing.com/webmaster/api.svc/json" : DEFAULT_BING_API_KEY_URL)).replace(/\/+$/, "");
 	const clock = options.clock ?? (() => /* @__PURE__ */ new Date());
 	const fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
 	const request = async (operation, parser, input = {}) => {
-		if (!options.accessToken.trim()) return err({ _tag: "AuthenticationRequired" });
+		const accessToken = typeof options.accessToken === "function" ? await options.accessToken() : options.accessToken;
+		if (!(options.apiKey ?? accessToken)?.trim()) return err({ _tag: "AuthenticationRequired" });
 		const url = new URL(`${baseUrl}/${operation}`);
+		if (options.apiKey !== void 0) url.searchParams.set("apikey", options.apiKey);
 		for (const [key, value] of Object.entries(input.query ?? {})) url.searchParams.set(key, value);
 		const response = await fetch(url.toString(), {
 			...input.body === void 0 ? {} : { body: JSON.stringify(input.body) },
 			headers: {
 				Accept: "application/json",
-				Authorization: `Bearer ${options.accessToken}`,
+				...accessToken === void 0 ? {} : { Authorization: `Bearer ${accessToken}` },
 				...input.body === void 0 ? {} : { "Content-Type": "application/json; charset=utf-8" }
 			},
 			method: input.method ?? "GET",
 			signal: input.signal
 		});
-		const payload = await response.json().then((value) => ok(value)).catch(() => err("invalid-json"));
+		const payload = await response.json().then((value) => ok(value)).catch((cause) => {
+			if (cause instanceof SyntaxError) return err("invalid-json");
+			throw cause;
+		});
 		if (!response.ok) return err(mapResponseError(response, payload.ok ? payload.value : void 0, clock()));
 		if (!payload.ok) return err({
 			_tag: "MalformedResponse",

package/dist/bing/normalize.d.mts

@@ -1,12 +1,11 @@
 import { Result } from "../core/result.mjs";
 import { BingCrawlStats, BingEvidenceError, BingIndexingEvidence, BingPageStats, BingQueryStats, BingRankAndTrafficStats, BingSite, BingUrlInfo, BingUrlTrafficInfo, BingUrlWithCrawlIssues } from "./types.mjs";
-declare function normalizeBingSite(value: unknown): Result<BingSite, 'invalid-payload'>;
-declare function normalizeBingUrlInfo(value: unknown): Result<BingUrlInfo, 'invalid-payload'>;
-declare function normalizeBingUrlTrafficInfo(value: unknown): Result<BingUrlTrafficInfo, 'invalid-payload'>;
-declare function normalizeBingPageStats(value: unknown): Result<BingPageStats, 'invalid-payload'>;
-declare function normalizeBingQueryStats(value: unknown): Result<BingQueryStats, 'invalid-payload'>;
-declare function normalizeBingRankAndTrafficStats(value: unknown): Result<BingRankAndTrafficStats, 'invalid-payload'>;
-declare function normalizeBingCrawlStats(value: unknown): Result<BingCrawlStats, 'invalid-payload'>;
-declare function normalizeBingCrawlIssue(value: unknown): Result<BingUrlWithCrawlIssues, 'invalid-payload'>;
-declare function normalizeBingIndexingEvidence(info: BingUrlInfo | null, url: string, observedAt: Date): Result<BingIndexingEvidence, BingEvidenceError>;
-export { normalizeBingCrawlIssue, normalizeBingCrawlStats, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingQueryStats, normalizeBingRankAndTrafficStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo };
+export declare function normalizeBingSite(value: unknown): Result<BingSite, 'invalid-payload'>;
+export declare function normalizeBingUrlInfo(value: unknown): Result<BingUrlInfo, 'invalid-payload'>;
+export declare function normalizeBingUrlTrafficInfo(value: unknown): Result<BingUrlTrafficInfo, 'invalid-payload'>;
+export declare function normalizeBingPageStats(value: unknown): Result<BingPageStats, 'invalid-payload'>;
+export declare function normalizeBingQueryStats(value: unknown): Result<BingQueryStats, 'invalid-payload'>;
+export declare function normalizeBingRankAndTrafficStats(value: unknown): Result<BingRankAndTrafficStats, 'invalid-payload'>;
+export declare function normalizeBingCrawlStats(value: unknown): Result<BingCrawlStats, 'invalid-payload'>;
+export declare function normalizeBingCrawlIssue(value: unknown): Result<BingUrlWithCrawlIssues, 'invalid-payload'>;
+export declare function normalizeBingIndexingEvidence(info: BingUrlInfo | null, url: string, observedAt: Date): Result<BingIndexingEvidence, BingEvidenceError>;