gscdump 2.1.0 → 2.2.0

package/README.md

@@ -4,7 +4,7 @@
 [![npm downloads](https://img.shields.io/npm/dm/gscdump?color=yellow)](https://npm.chart.dev/gscdump)
 [![license](https://img.shields.io/github/license/harlan-zw/gscdump?color=yellow)](https://github.com/harlan-zw/gscdump/blob/main/LICENSE)
 
-Direct Google Search Console client with a typed query builder, streaming pagination, URL inspection, sitemap administration, verification, and Indexing API helpers.
+Direct Google Search Console and Bing Webmaster clients with typed queries and Indexing Evidence.
 
 ## Install
 
@@ -73,6 +73,24 @@ await client.indexing.publish(
 
 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
+`Result` values and never infers an indexed verdict from crawl evidence.
+
+```ts
+import { bingWebmaster } from 'gscdump/bing'
+
+const client = bingWebmaster({ accessToken: 'access-token' })
+const evidence = await client.getIndexingEvidence(
+  'https://example.com/',
+  'https://example.com/docs',
+)
+
+if (evidence.ok)
+  console.log(evidence.value)
+```
+
 Sitemap XML reading and traversal lives in `sitemapd`. Product feed scoping and
 exact membership hashing live in `gscdump/sitemap-identity`. Hosted canonical
 sitemap membership is available through `@gscdump/sdk/v1`.
@@ -81,6 +99,7 @@ sitemap membership is available through `@gscdump/sdk/v1`.
 
 - `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
 - `gscdump/dates`: explicit UTC and Pacific Search Console date helpers
 - `gscdump/contracts`: Search Analytics request and response contracts
 - `gscdump/result`: `Result` helpers

package/dist/api/inspection.d.mts

@@ -34,7 +34,9 @@ interface ParsedIndexingResult {
   googleCanonical: string | null;
   sitemaps: string | null;
   referringUrls: string | null;
+  /** @deprecated Retained for historical storage rows. */
   mobileVerdict: string | null;
+  /** @deprecated Retained for historical storage rows. */
   mobileIssues: string | null;
   richResultsVerdict: string | null;
   richResultsItems: string | null;
@@ -90,7 +92,7 @@ declare function getNextCheckPriority(result: Pick<ParsedIndexingResult, 'verdic
 /** 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_indexing_scope' | 'insufficient_gsc_permission';
+type IndexingIneligibleReason = 'missing_gsc_read_scope' | 'insufficient_gsc_permission';
 interface IndexingEligibility {
   indexingEligible: boolean;
   indexingIneligibleReason?: IndexingIneligibleReason;

package/dist/api/inspection.mjs

@@ -1,5 +1,5 @@
 import { runSequentialBatch } from "./batch.mjs";
-import { hasIndexingScope } from "../core/scopes.mjs";
+import { hasGscReadScope } from "../core/scopes.mjs";
 async function inspectUrl(client, siteUrl, inspectionUrl) {
 	const inspection = (await client.inspect(siteUrl, inspectionUrl)).inspectionResult;
 	return {
@@ -97,12 +97,12 @@ function getNextCheckAfter(priority) {
 	const now = Math.floor(Date.now() / 1e3);
 	switch (priority) {
 		case "critical":
-		case "high": return now + 7 * 86400;
+		case "high": return now + 604800;
 		case "elevated":
-		case "medium": return now + 14 * 86400;
+		case "medium": return now + 1209600;
 		case "low":
-		case "normal": return now + 30 * 86400;
-		case "dormant": return now + 120 * 86400;
+		case "normal": return now + 2592e3;
+		case "dormant": return now + 10368e3;
 	}
 }
 const INSPECTION_ALLOWED_PERMISSIONS = /* @__PURE__ */ new Set([
@@ -118,9 +118,9 @@ function grantedScopeList(scopes) {
 }
 function getIndexingEligibility(grantedScopes, permissionLevel) {
 	const scopes = grantedScopeList(grantedScopes);
-	if (!hasIndexingScope(grantedScopes)) return {
+	if (!hasGscReadScope(grantedScopes)) return {
 		indexingEligible: false,
-		indexingIneligibleReason: "missing_indexing_scope",
+		indexingIneligibleReason: "missing_gsc_read_scope",
 		indexingPermissionLevel: permissionLevel ?? null,
 		grantedScopes: scopes
 	};

package/dist/api/oauth.mjs

@@ -118,7 +118,11 @@ async function requestOAuthResult(url, init, op) {
 			return null;
 		});
 		if (!res) continue;
-		if (!res.ok) return err(oauthHttpError(op, parseGoogleError(await res.text(), res.status)));
+		if (!res.ok) {
+			const text = await res.text();
+			const info = parseGoogleError(text, res.status);
+			return err(oauthHttpError(op, info));
+		}
 		return ok(res);
 	}
 	return err({

package/dist/bing/client.d.mts

@@ -0,0 +1,5 @@
+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 };

package/dist/bing/client.mjs

@@ -0,0 +1,215 @@
+import { err, ok } from "../core/result.mjs";
+import { normalizeBingCrawlIssue, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo } from "./normalize.mjs";
+const DEFAULT_BING_WEBMASTER_API_URL = "https://www.bing.com/webmaster/api.svc/json";
+const DEFAULT_BING_CHILD_PAGE_LIMIT = 100;
+const BING_MAX_CHILD_PAGE_COUNT = 65536;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseErrorPayload(value) {
+	if (!isRecord(value)) return {};
+	return {
+		...typeof value.ErrorCode === "number" ? { ErrorCode: value.ErrorCode } : {},
+		...typeof value.Message === "string" ? { Message: value.Message } : {}
+	};
+}
+function retryAfterMs(response, now) {
+	const header = response.headers.get("retry-after");
+	if (!header) return void 0;
+	const seconds = Number(header);
+	if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+	const date = Date.parse(header);
+	if (!Number.isFinite(date)) return void 0;
+	return Math.max(0, date - now.getTime());
+}
+function mapResponseError(response, payload, now) {
+	const apiError = parseErrorPayload(payload);
+	if (response.status === 401 || apiError.ErrorCode === 3) return { _tag: "AuthenticationRequired" };
+	if (apiError.ErrorCode === 6) return { _tag: "UserBlocked" };
+	if (response.status === 403 || apiError.ErrorCode === 14) return { _tag: "PermissionDenied" };
+	if (response.status === 429 || apiError.ErrorCode === 4 || apiError.ErrorCode === 5) {
+		const delay = retryAfterMs(response, now);
+		return {
+			_tag: "Throttled",
+			...delay === void 0 ? {} : { retryAfterMs: delay }
+		};
+	}
+	if (response.status >= 500) return {
+		_tag: "ProviderUnavailable",
+		status: response.status
+	};
+	return {
+		_tag: "RequestRejected",
+		...apiError.ErrorCode === void 0 ? {} : { errorCode: apiError.ErrorCode },
+		...apiError.Message === void 0 ? {} : { message: apiError.Message },
+		status: response.status
+	};
+}
+function parseWrapped(value, parser) {
+	if (!isRecord(value) || !Object.hasOwn(value, "d")) return err("invalid-payload");
+	return parser(value.d);
+}
+function parseNullable(parser) {
+	return (value) => {
+		if (value === null) return ok(null);
+		return parser(value);
+	};
+}
+function parseList(parser) {
+	return (value) => {
+		if (!Array.isArray(value)) return err("invalid-payload");
+		const parsed = [];
+		for (const item of value) {
+			const result = parser(item);
+			if (!result.ok) return result;
+			parsed.push(result.value);
+		}
+		return ok(parsed);
+	};
+}
+const CRAWL_DATE_FILTERS = {
+	"any": 0,
+	"last-week": 1,
+	"last-two-weeks": 2,
+	"last-three-weeks": 4
+};
+const DISCOVERED_DATE_FILTERS = {
+	"any": 0,
+	"last-week": 1,
+	"last-month": 2
+};
+const DOCUMENT_FILTERS = {
+	"any": 0,
+	"blocked-by-robots-txt": 1,
+	"malware": 2
+};
+const HTTP_CODE_FILTERS = {
+	"any": 0,
+	"2xx": 1,
+	"3xx": 2,
+	"301": 4,
+	"302": 8,
+	"4xx": 16,
+	"5xx": 32,
+	"other": 64
+};
+function toFilterProperties(filters = {}) {
+	return {
+		__type: "FilterProperties:#Microsoft.Bing.Webmaster.Api",
+		CrawlDateFilter: CRAWL_DATE_FILTERS[filters.crawlDate ?? "any"],
+		DiscoveredDateFilter: DISCOVERED_DATE_FILTERS[filters.discoveredDate ?? "any"],
+		DocFlagsFilters: DOCUMENT_FILTERS[filters.document ?? "any"],
+		HttpCodeFilters: HTTP_CODE_FILTERS[filters.httpCode ?? "any"]
+	};
+}
+function bingWebmaster(options) {
+	const baseUrl = (options.baseUrl ?? "https://www.bing.com/webmaster/api.svc/json").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 url = new URL(`${baseUrl}/${operation}`);
+		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}`,
+				...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"));
+		if (!response.ok) return err(mapResponseError(response, payload.ok ? payload.value : void 0, clock()));
+		if (!payload.ok) return err({
+			_tag: "MalformedResponse",
+			operation,
+			reason: "invalid-json"
+		});
+		const parsed = parseWrapped(payload.value, parser);
+		if (!parsed.ok) return err({
+			_tag: "MalformedResponse",
+			operation,
+			reason: "invalid-payload"
+		});
+		return parsed;
+	};
+	const getUserSites = (callOptions) => request("GetUserSites", parseList(normalizeBingSite), { signal: callOptions?.signal });
+	const getUrlInfo = (siteUrl, url, callOptions) => request("GetUrlInfo", parseNullable(normalizeBingUrlInfo), {
+		query: {
+			siteUrl,
+			url
+		},
+		signal: callOptions?.signal
+	});
+	return {
+		getUserSites,
+		async getVerifiedSite(siteUrl, callOptions) {
+			const sites = await getUserSites(callOptions);
+			if (!sites.ok) return sites;
+			const site = sites.value.find((candidate) => candidate.url === siteUrl);
+			if (!site) return err({
+				_tag: "SiteUnavailable",
+				siteUrl
+			});
+			if (!site.isVerified) return err({
+				_tag: "UnverifiedSite",
+				siteUrl
+			});
+			return ok(site);
+		},
+		getUrlInfo,
+		async getIndexingEvidence(siteUrl, url, callOptions) {
+			const info = await getUrlInfo(siteUrl, url, callOptions);
+			if (!info.ok) return info;
+			return normalizeBingIndexingEvidence(info.value, url, clock());
+		},
+		getUrlTrafficInfo: (siteUrl, url, callOptions) => request("GetUrlTrafficInfo", parseNullable(normalizeBingUrlTrafficInfo), {
+			query: {
+				siteUrl,
+				url
+			},
+			signal: callOptions?.signal
+		}),
+		async getChildrenUrlInfo(siteUrl, url, childrenOptions = {}) {
+			const maxPages = childrenOptions.maxPages ?? 100;
+			if (!Number.isInteger(maxPages) || maxPages < 1 || maxPages > BING_MAX_CHILD_PAGE_COUNT) return err({
+				_tag: "InvalidPagination",
+				maximum: BING_MAX_CHILD_PAGE_COUNT,
+				maxPages,
+				minimum: 1,
+				reason: "max-pages-out-of-range"
+			});
+			const children = [];
+			for (let page = 0; page < maxPages; page++) {
+				const response = await request("GetChildrenUrlInfo", parseList(normalizeBingUrlInfo), {
+					body: {
+						filterProperties: toFilterProperties(childrenOptions.filters),
+						page,
+						siteUrl,
+						url
+					},
+					method: "POST",
+					signal: childrenOptions.signal
+				});
+				if (!response.ok) return response;
+				if (response.value.length === 0) return ok(children);
+				children.push(...response.value);
+			}
+			return err({
+				_tag: "PaginationLimitExceeded",
+				maxPages
+			});
+		},
+		getPageStats: (siteUrl, callOptions) => request("GetPageStats", parseList(normalizeBingPageStats), {
+			query: { siteUrl },
+			signal: callOptions?.signal
+		}),
+		getCrawlIssues: (siteUrl, callOptions) => request("GetCrawlIssues", parseList(normalizeBingCrawlIssue), {
+			query: { siteUrl },
+			signal: callOptions?.signal
+		})
+	};
+}
+export { DEFAULT_BING_CHILD_PAGE_LIMIT, DEFAULT_BING_WEBMASTER_API_URL, bingWebmaster };

package/dist/bing/index.d.mts

@@ -0,0 +1,4 @@
+import { BingCallOptions, BingChildrenFilters, BingChildrenOptions, BingCrawlDateFilter, BingCrawlEvidence, BingCrawlIssue, BingCrawlIssueWire, BingDiscoveredDateFilter, BingDocumentFilter, BingEvidenceError, BingFetch, BingHttpCodeFilter, BingIndexingEvidence, BingOperation, BingPageStats, BingProviderError, BingQueryStatsWire, BingSite, BingSiteWire, BingUnknownEvidence, BingUrlInfo, BingUrlInfoWire, BingUrlTrafficInfo, BingUrlTrafficInfoWire, BingUrlWithCrawlIssues, BingWebmasterClient, BingWebmasterOptions, BingWireResponse } from "./types.mjs";
+import { DEFAULT_BING_CHILD_PAGE_LIMIT, DEFAULT_BING_WEBMASTER_API_URL, bingWebmaster } from "./client.mjs";
+import { normalizeBingCrawlIssue, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo } from "./normalize.mjs";
+export { type BingCallOptions, type BingChildrenFilters, type BingChildrenOptions, type BingCrawlDateFilter, type BingCrawlEvidence, type BingCrawlIssue, type BingCrawlIssueWire, type BingDiscoveredDateFilter, type BingDocumentFilter, type BingEvidenceError, type BingFetch, type BingHttpCodeFilter, type BingIndexingEvidence, type BingOperation, type BingPageStats, type BingProviderError, type BingQueryStatsWire, type BingSite, type BingSiteWire, type BingUnknownEvidence, type BingUrlInfo, type BingUrlInfoWire, type BingUrlTrafficInfo, type BingUrlTrafficInfoWire, type BingUrlWithCrawlIssues, type BingWebmasterClient, type BingWebmasterOptions, type BingWireResponse, DEFAULT_BING_CHILD_PAGE_LIMIT, DEFAULT_BING_WEBMASTER_API_URL, bingWebmaster, normalizeBingCrawlIssue, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo };

package/dist/bing/index.mjs

@@ -0,0 +1,3 @@
+import { normalizeBingCrawlIssue, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo } from "./normalize.mjs";
+import { DEFAULT_BING_CHILD_PAGE_LIMIT, DEFAULT_BING_WEBMASTER_API_URL, bingWebmaster } from "./client.mjs";
+export { DEFAULT_BING_CHILD_PAGE_LIMIT, DEFAULT_BING_WEBMASTER_API_URL, bingWebmaster, normalizeBingCrawlIssue, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo };

package/dist/bing/normalize.d.mts

@@ -0,0 +1,9 @@
+import { Result } from "../core/result.mjs";
+import { BingEvidenceError, BingIndexingEvidence, BingPageStats, 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 normalizeBingCrawlIssue(value: unknown): Result<BingUrlWithCrawlIssues, 'invalid-payload'>;
+declare function normalizeBingIndexingEvidence(info: BingUrlInfo | null, url: string, observedAt: Date): Result<BingIndexingEvidence, BingEvidenceError>;
+export { normalizeBingCrawlIssue, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo };

package/dist/bing/normalize.mjs

@@ -0,0 +1,124 @@
+import { err, ok } from "../core/result.mjs";
+const BING_UNAVAILABLE_DATE_MS = -62135568e6;
+const BING_DATE_PATTERN = /^\/Date\((-?\d+)(?:[+-]\d{4})?\)\/$/;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonNegativeInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function parseBingDate(value) {
+	if (value === void 0 || value === null) return ok(void 0);
+	if (typeof value !== "string") return err("invalid-date");
+	const match = BING_DATE_PATTERN.exec(value);
+	if (!match) return err("invalid-date");
+	const milliseconds = Number(match[1]);
+	if (!Number.isFinite(milliseconds)) return err("invalid-date");
+	if (milliseconds <= BING_UNAVAILABLE_DATE_MS) return ok(void 0);
+	const date = new Date(milliseconds);
+	if (!Number.isFinite(date.getTime())) return err("invalid-date");
+	return ok(date.toISOString());
+}
+function normalizeBingSite(value) {
+	if (!isRecord(value) || typeof value.IsVerified !== "boolean" || typeof value.Url !== "string") return err("invalid-payload");
+	return ok({
+		isVerified: value.IsVerified,
+		url: value.Url
+	});
+}
+function normalizeBingUrlInfo(value) {
+	if (!isRecord(value) || !isNonNegativeInteger(value.AnchorCount) || !isNonNegativeInteger(value.DocumentSize) || !isNonNegativeInteger(value.HttpStatus) || typeof value.IsPage !== "boolean" || !isNonNegativeInteger(value.TotalChildUrlCount) || typeof value.Url !== "string") return err("invalid-payload");
+	const discoveryDate = parseBingDate(value.DiscoveryDate);
+	const lastCrawledDate = parseBingDate(value.LastCrawledDate);
+	if (!discoveryDate.ok || !lastCrawledDate.ok) return err("invalid-payload");
+	return ok({
+		anchorCount: value.AnchorCount,
+		...discoveryDate.value ? { discoveryDate: discoveryDate.value } : {},
+		documentSize: value.DocumentSize,
+		httpStatus: value.HttpStatus,
+		isPage: value.IsPage,
+		...lastCrawledDate.value ? { lastCrawledDate: lastCrawledDate.value } : {},
+		totalChildUrlCount: value.TotalChildUrlCount,
+		url: value.Url
+	});
+}
+function normalizeBingUrlTrafficInfo(value) {
+	if (!isRecord(value) || !isNonNegativeInteger(value.Clicks) || !isNonNegativeInteger(value.Impressions) || typeof value.IsPage !== "boolean" || typeof value.Url !== "string") return err("invalid-payload");
+	return ok({
+		clicks: value.Clicks,
+		impressions: value.Impressions,
+		isPage: value.IsPage,
+		url: value.Url
+	});
+}
+function normalizeBingPageStats(value) {
+	if (!isRecord(value) || !isNonNegativeInteger(value.AvgClickPosition) || !isNonNegativeInteger(value.AvgImpressionPosition) || !isNonNegativeInteger(value.Clicks) || !isNonNegativeInteger(value.Impressions) || typeof value.Query !== "string") return err("invalid-payload");
+	const date = parseBingDate(value.Date);
+	if (!date.ok || !date.value) return err("invalid-payload");
+	return ok({
+		averageClickPosition: value.AvgClickPosition,
+		averageImpressionPosition: value.AvgImpressionPosition,
+		clicks: value.Clicks,
+		date: date.value,
+		impressions: value.Impressions,
+		query: value.Query
+	});
+}
+const CRAWL_ISSUES = {
+	0: "none",
+	1: "301",
+	2: "302",
+	4: "4xx",
+	8: "5xx",
+	16: "blocked-by-robots-txt",
+	32: "contains-malware",
+	64: "important-url-blocked-by-robots-txt",
+	128: "dns-errors",
+	256: "timeout-errors"
+};
+function normalizeBingCrawlIssue(value) {
+	if (!isRecord(value) || !isNonNegativeInteger(value.HttpCode) || !isNonNegativeInteger(value.InLinks) || !isNonNegativeInteger(value.Issues) || typeof value.Url !== "string") return err("invalid-payload");
+	return ok({
+		httpCode: value.HttpCode,
+		inLinks: value.InLinks,
+		issue: CRAWL_ISSUES[value.Issues] ?? "unknown",
+		rawIssueCode: value.Issues,
+		url: value.Url
+	});
+}
+function normalizeBingIndexingEvidence(info, url, observedAt) {
+	if (!info) return ok({
+		_tag: "UnknownEvidence",
+		observedAt: observedAt.toISOString(),
+		reason: "not-observed",
+		searchEngine: "bing",
+		url
+	});
+	if (!info.discoveryDate && !info.lastCrawledDate && info.httpStatus === 0 && info.documentSize === 0 && info.anchorCount === 0 && info.totalChildUrlCount === 0) return ok({
+		_tag: "UnknownEvidence",
+		observedAt: observedAt.toISOString(),
+		reason: "not-discovered",
+		searchEngine: "bing",
+		url
+	});
+	if (!info.isPage) return err({
+		_tag: "UnsupportedEvidence",
+		reason: "not-a-page",
+		url
+	});
+	return ok({
+		_tag: "CrawlEvidence",
+		anchorCount: info.anchorCount,
+		...info.discoveryDate ? { discoveryDate: info.discoveryDate } : {},
+		documentSize: info.documentSize,
+		httpStatus: info.httpStatus,
+		...info.lastCrawledDate ? { lastCrawledDate: info.lastCrawledDate } : {},
+		observedAt: observedAt.toISOString(),
+		rawStatus: info.httpStatus,
+		searchEngine: "bing",
+		totalChildUrlCount: info.totalChildUrlCount,
+		uncertaintyReason: "indexed-verdict-unavailable",
+		url
+	});
+}
+export { normalizeBingCrawlIssue, normalizeBingIndexingEvidence, normalizeBingPageStats, normalizeBingSite, normalizeBingUrlInfo, normalizeBingUrlTrafficInfo };

package/dist/bing/types.d.mts

@@ -0,0 +1,181 @@
+import { Result } from "../core/result.mjs";
+interface BingSiteWire {
+  __type?: string;
+  AuthenticationCode: string;
+  DnsVerificationCode: string;
+  IsVerified: boolean;
+  Url: string;
+}
+interface BingUrlInfoWire {
+  __type?: string;
+  AnchorCount: number;
+  DiscoveryDate?: string | null;
+  DocumentSize: number;
+  HttpStatus: number;
+  IsPage: boolean;
+  LastCrawledDate?: string | null;
+  TotalChildUrlCount: number;
+  Url: string;
+}
+interface BingUrlTrafficInfoWire {
+  __type?: string;
+  Clicks: number;
+  Impressions: number;
+  IsPage: boolean;
+  Url: string;
+}
+interface BingQueryStatsWire {
+  __type?: string;
+  AvgClickPosition: number;
+  AvgImpressionPosition: number;
+  Clicks: number;
+  Date: string;
+  Impressions: number;
+  Query: string;
+}
+interface BingCrawlIssueWire {
+  __type?: string;
+  HttpCode: number;
+  InLinks: number;
+  Issues: number;
+  Url: string;
+}
+interface BingWireResponse<T> {
+  d: T;
+}
+interface BingSite {
+  isVerified: boolean;
+  url: string;
+}
+interface BingUrlInfo {
+  anchorCount: number;
+  discoveryDate?: string;
+  documentSize: number;
+  httpStatus: number;
+  isPage: boolean;
+  lastCrawledDate?: string;
+  totalChildUrlCount: number;
+  url: string;
+}
+interface BingUrlTrafficInfo {
+  clicks: number;
+  impressions: number;
+  isPage: boolean;
+  url: string;
+}
+interface BingPageStats {
+  averageClickPosition: number;
+  averageImpressionPosition: number;
+  clicks: number;
+  date: string;
+  impressions: number;
+  query: string;
+}
+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 {
+  httpCode: number;
+  inLinks: number;
+  issue: BingCrawlIssue;
+  rawIssueCode: number;
+  url: string;
+}
+interface BingCrawlEvidence {
+  _tag: 'CrawlEvidence';
+  anchorCount: number;
+  discoveryDate?: string;
+  documentSize: number;
+  httpStatus: number;
+  lastCrawledDate?: string;
+  observedAt: string;
+  rawStatus: number;
+  searchEngine: 'bing';
+  totalChildUrlCount: number;
+  uncertaintyReason: 'indexed-verdict-unavailable';
+  url: string;
+}
+interface BingUnknownEvidence {
+  _tag: 'UnknownEvidence';
+  observedAt: string;
+  reason: 'not-discovered' | 'not-observed';
+  searchEngine: 'bing';
+  url: string;
+}
+type BingIndexingEvidence = BingCrawlEvidence | BingUnknownEvidence;
+type BingProviderError = {
+  _tag: 'AuthenticationRequired';
+} | {
+  _tag: 'PermissionDenied';
+} | {
+  _tag: 'UserBlocked';
+} | {
+  _tag: 'UnverifiedSite';
+  siteUrl: string;
+} | {
+  _tag: 'SiteUnavailable';
+  siteUrl: string;
+} | {
+  _tag: 'Throttled';
+  retryAfterMs?: number;
+} | {
+  _tag: 'ProviderUnavailable';
+  status: number;
+} | {
+  _tag: 'RequestRejected';
+  errorCode?: number;
+  message?: string;
+  status: number;
+} | {
+  _tag: 'MalformedResponse';
+  operation: BingOperation;
+  reason: 'invalid-json' | 'invalid-payload';
+} | {
+  _tag: 'InvalidPagination';
+  maximum: number;
+  maxPages: number;
+  minimum: number;
+  reason: 'max-pages-out-of-range';
+} | {
+  _tag: 'PaginationLimitExceeded';
+  maxPages: number;
+};
+interface BingEvidenceError {
+  _tag: 'UnsupportedEvidence';
+  reason: 'not-a-page';
+  url: string;
+}
+type BingOperation = 'GetUserSites' | 'GetUrlInfo' | 'GetUrlTrafficInfo' | 'GetChildrenUrlInfo' | 'GetPageStats' | 'GetCrawlIssues';
+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 {
+  crawlDate?: BingCrawlDateFilter;
+  discoveredDate?: BingDiscoveredDateFilter;
+  document?: BingDocumentFilter;
+  httpCode?: BingHttpCodeFilter;
+}
+interface BingChildrenOptions extends BingCallOptions {
+  filters?: BingChildrenFilters;
+  maxPages?: number;
+}
+interface BingWebmasterClient {
+  getUserSites: (options?: BingCallOptions) => Promise<Result<BingSite[], BingProviderError>>;
+  getVerifiedSite: (siteUrl: string, options?: BingCallOptions) => Promise<Result<BingSite, BingProviderError>>;
+  getUrlInfo: (siteUrl: string, url: string, options?: BingCallOptions) => Promise<Result<BingUrlInfo | null, BingProviderError>>;
+  getIndexingEvidence: (siteUrl: string, url: string, options?: BingCallOptions) => Promise<Result<BingIndexingEvidence, BingProviderError | BingEvidenceError>>;
+  getUrlTrafficInfo: (siteUrl: string, url: string, options?: BingCallOptions) => Promise<Result<BingUrlTrafficInfo | null, BingProviderError>>;
+  getChildrenUrlInfo: (siteUrl: string, url: string, options?: BingChildrenOptions) => Promise<Result<BingUrlInfo[], BingProviderError>>;
+  getPageStats: (siteUrl: string, options?: BingCallOptions) => Promise<Result<BingPageStats[], BingProviderError>>;
+  getCrawlIssues: (siteUrl: string, options?: BingCallOptions) => Promise<Result<BingUrlWithCrawlIssues[], BingProviderError>>;
+}
+type BingFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface BingWebmasterOptions {
+  accessToken: string;
+  baseUrl?: string;
+  clock?: () => Date;
+  fetch?: BingFetch;
+}
+export { BingCallOptions, BingChildrenFilters, BingChildrenOptions, BingCrawlDateFilter, BingCrawlEvidence, BingCrawlIssue, BingCrawlIssueWire, BingDiscoveredDateFilter, BingDocumentFilter, BingEvidenceError, BingFetch, BingHttpCodeFilter, BingIndexingEvidence, BingOperation, BingPageStats, BingProviderError, BingQueryStatsWire, BingSite, BingSiteWire, BingUnknownEvidence, BingUrlInfo, BingUrlInfoWire, BingUrlTrafficInfo, BingUrlTrafficInfoWire, BingUrlWithCrawlIssues, BingWebmasterClient, BingWebmasterOptions, BingWireResponse };

package/dist/core/client.d.mts

@@ -85,6 +85,8 @@ interface GoogleSearchConsoleClient {
     }, opts?: CallOptions) => Promise<VerificationWebResource>;
     list: (opts?: CallOptions) => Promise<VerificationWebResource[]>;
     get: (id: string, opts?: CallOptions) => Promise<VerificationWebResource>;
+    patch: (id: string, resource: VerificationWebResource, opts?: CallOptions) => Promise<VerificationWebResource>;
+    update: (id: string, resource: VerificationWebResource, opts?: CallOptions) => Promise<VerificationWebResource>;
     delete: (id: string, opts?: CallOptions) => Promise<void>;
   };
   /** Inspect a URL. `languageCode` is a BCP-47 tag for translating result strings; omit to let Google pick. */

package/dist/core/client.mjs

@@ -91,8 +91,10 @@ function createFetch(auth, options) {
 		},
 		async onResponseError(ctx) {
 			if (ctx.response.status === 403) console.error("[gscdump] Permission denied (403). check your service account permissions being added to the GSC property.");
-			if (options?.onResponseError) if (Array.isArray(options.onResponseError)) for (const handler of options.onResponseError) await handler(ctx);
-			else await options.onResponseError(ctx);
+			if (options?.onResponseError) {
+				if (Array.isArray(options.onResponseError)) for (const handler of options.onResponseError) await handler(ctx);
+				else await options.onResponseError(ctx);
+			}
 		}
 	});
 }
@@ -106,17 +108,31 @@ function googleSearchConsole(auth, options = {}) {
 			const originalOnError = fetchOptions.onResponseError;
 			fetchOptions.onResponseError = async (ctx) => {
 				if (ctx.response.status === 429) await options.onRateLimited({ response: ctx.response });
-				if (originalOnError) if (Array.isArray(originalOnError)) for (const handler of originalOnError) await handler(ctx);
-				else await originalOnError(ctx);
+				if (originalOnError) {
+					if (Array.isArray(originalOnError)) for (const handler of originalOnError) await handler(ctx);
+					else await originalOnError(ctx);
+				}
 			};
 		}
 		fetch = createFetch(authState, fetchOptions);
 	}
-	const querySearchAnalytics = (siteUrl, body, opts) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}/searchAnalytics/query`, {
-		method: "POST",
-		body,
-		signal: opts?.signal
-	});
+	const querySearchAnalytics = async (siteUrl, body, opts) => {
+		const response = await fetch(`${GSC_API}/webmasters/v3/sites/${encodeSiteUrl(siteUrl)}/searchAnalytics/query`, {
+			method: "POST",
+			body,
+			signal: opts?.signal
+		});
+		if (!response.metadata) return response;
+		const firstIncompleteDate = response.metadata.first_incomplete_date ?? response.metadata.firstIncompleteDate;
+		const firstIncompleteHour = response.metadata.first_incomplete_hour ?? response.metadata.firstIncompleteHour;
+		return {
+			...response,
+			metadata: {
+				...typeof firstIncompleteDate === "string" ? { first_incomplete_date: firstIncompleteDate } : {},
+				...typeof firstIncompleteHour === "string" ? { first_incomplete_hour: firstIncompleteHour } : {}
+			}
+		};
+	};
 	return {
 		async *query(siteUrl, builder, opts) {
 			const state = builder.getState();
@@ -192,6 +208,16 @@ function googleSearchConsole(auth, options = {}) {
 				return (await fetch(`${SITE_VERIFICATION_API}/webResource`, { signal: opts?.signal })).items || [];
 			},
 			get: (id, opts) => fetch(`${SITE_VERIFICATION_API}/webResource/${encodeURIComponent(id)}`, { signal: opts?.signal }),
+			patch: (id, resource, opts) => fetch(`${SITE_VERIFICATION_API}/webResource/${encodeURIComponent(id)}`, {
+				method: "PATCH",
+				body: resource,
+				signal: opts?.signal
+			}),
+			update: (id, resource, opts) => fetch(`${SITE_VERIFICATION_API}/webResource/${encodeURIComponent(id)}`, {
+				method: "PUT",
+				body: resource,
+				signal: opts?.signal
+			}),
 			delete: (id, opts) => fetch(`${SITE_VERIFICATION_API}/webResource/${encodeURIComponent(id)}`, {
 				method: "DELETE",
 				signal: opts?.signal

package/dist/core/types.d.mts

@@ -5,7 +5,7 @@ interface ApiSite {
 }
 /** Per-content-type counts returned with a sitemap. */
 interface ApiSitemapContent {
-  /** Deprecated by Google, retained because it can still appear on the wire. */
+  /** @deprecated Google can still include this field on the wire. */
   indexed?: string | null;
   submitted?: string | null;
   type?: string | null;
@@ -56,12 +56,8 @@ interface DataRow {
 }
 /** Completeness metadata returned with recent Search Analytics data. */
 interface SearchAnalyticsMetadata {
-  firstIncompleteDate?: string | null;
-  firstIncompleteHour?: string | null;
-  /** Field name returned by the direct REST endpoint. */
-  first_incomplete_date?: string | null;
-  /** Field name returned by the direct REST endpoint. */
-  first_incomplete_hour?: string | null;
+  first_incomplete_date?: string;
+  first_incomplete_hour?: string;
 }
 /** Raw Search Analytics response returned by Google's REST endpoint. */
 interface SearchAnalyticsResponse {
@@ -126,6 +122,7 @@ interface UrlInspectionResult {
   ampResult?: AmpInspectionResult;
   indexStatusResult?: IndexStatusResult;
   inspectionResultLink?: string | null;
+  /** @deprecated Google no longer returns this result. */
   mobileUsabilityResult?: MobileUsabilityResult;
   richResultsResult?: RichResultsResult;
 }

package/dist/query/plan.d.mts

@@ -1,5 +1,5 @@
-import { TableName } from "../contracts.mjs";
 import { Result } from "../core/result.mjs";
+import { TableName } from "../contracts.mjs";
 import { BuilderState, Dimension, FilterOperator, Metric, MetricOperator, QueryParamName } from "./types.mjs";
 import { QueryError, QueryErrorKind, UnresolvableDatasetError, UnsupportedLogicalCapabilityError } from "./errors.mjs";
 type LogicalDataset = TableName;

package/dist/query/plan.mjs

@@ -94,7 +94,8 @@ function buildLogicalPlanResult(state, capabilities = {}) {
 	if (!capabilities.regex && allFilters.some((f) => isDimensionLeaf(f) && isRegexOperator(f.operator))) return err(queryErrors.unsupportedCapability("regex", "logical plan"));
 	const metricFilters = extractMetricFilters(normalizedFilter);
 	const specialFilters = extractSpecialOperatorFilters(normalizedFilter);
-	const prefilters = extractMetricFilters(normalizeFilter(state.prefilter));
+	const normalizedPrefilter = normalizeFilter(state.prefilter);
+	const prefilters = extractMetricFilters(normalizedPrefilter);
 	const queryParams = {};
 	const dimensionFilters = [];
 	for (const filter of allFilters) {
@@ -115,8 +116,9 @@ function buildLogicalPlanResult(state, capabilities = {}) {
 	const dimensionFilterTree = buildDimensionFilterTree(normalizedFilter);
 	const filterDims = dimensionFilters.map((filter) => filter.dimension);
 	if (!isDatasetResolvable(state.dimensions, filterDims)) return err(queryErrors.unresolvableDataset(state.dimensions, filterDims));
+	const dataset = inferDataset(state.dimensions, filterDims);
 	return ok({
-		dataset: inferDataset(state.dimensions, filterDims),
+		dataset,
 		dimensions: [...state.dimensions],
 		groupByDimensions: state.dimensions.filter((d) => d !== "date"),
 		hasDate: state.dimensions.includes("date"),

package/dist/query/resolver.d.mts

@@ -1,5 +1,5 @@
-import { GscSearchAnalyticsRequest } from "../contracts.mjs";
 import { Result } from "../core/result.mjs";
+import { GscSearchAnalyticsRequest } from "../contracts.mjs";
 import { SearchType } from "./constants.mjs";
 import { BuilderState, Filter, FilterInput, InternalFilter } from "./types.mjs";
 import { QueryError } from "./errors.mjs";

package/dist/query/resolver.mjs

@@ -114,7 +114,6 @@ function extractSpecialFilters(filter) {
 		case "between":
 			startDate = f.expression;
 			endDate = f.expression2;
-			break;
 	}
 	else if (isQueryParam(f.dimension)) {
 		if (f.dimension === "searchType") searchType = f.expression;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "gscdump",
   "type": "module",
-  "version": "2.1.0",
-  "description": "Direct Google Search Console client with typed queries, streaming pagination, URL inspection, and indexing helpers",
+  "version": "2.2.0",
+  "description": "Direct Google Search Console and Bing Webmaster clients with typed queries and Indexing Evidence",
   "author": {
     "name": "Harlan Wilton",
     "email": "harlan@harlanzw.com",
@@ -21,6 +21,7 @@
   },
   "keywords": [
     "google-search-console",
+    "bing-webmaster-tools",
     "gsc",
     "seo",
     "search-analytics",
@@ -42,6 +43,11 @@
       "import": "./dist/query/index.mjs",
       "default": "./dist/query/index.mjs"
     },
+    "./bing": {
+      "types": "./dist/bing/index.d.mts",
+      "import": "./dist/bing/index.mjs",
+      "default": "./dist/bing/index.mjs"
+    },
     "./query/plan": {
       "types": "./dist/query/plan.d.mts",
       "import": "./dist/query/plan.mjs",
@@ -88,7 +94,7 @@
   },
   "dependencies": {
     "ofetch": "^1.5.1",
-    "@gscdump/contracts": "^2.1.0"
+    "@gscdump/contracts": "^2.2.0"
   },
   "scripts": {
     "dev": "obuild --stub",