gscdump 2.1.1 → 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/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/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/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/package.json

@@ -1,8 +1,8 @@
 {
   "name": "gscdump",
   "type": "module",
-  "version": "2.1.1",
-  "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.1"
+    "@gscdump/contracts": "^2.2.0"
   },
   "scripts": {
     "dev": "obuild --stub",