@gscdump/sdk 1.0.1 → 1.0.3

package/dist/site-triage.mjs

@@ -0,0 +1,268 @@
+import { countSearchConsoleIssues, formatSearchConsoleCount } from "./_chunks/search-console-signals.mjs";
+import { normalizeSiteType } from "./site-baseline.mjs";
+const NASCENT_IMPRESSIONS_28D = 1e3;
+const ESTABLISHED_IMPRESSIONS_28D = 2e4;
+const LIFETIME_FLOOR = 500;
+const GROWTH_CLICKS_PCT = 10;
+const GROWTH_IMPRESSIONS_PCT = 20;
+const DECLINE_CLICKS_PCT = -10;
+const MIN_DECLINE_PRIOR_CLICKS = 50;
+const FADED_LIVENESS = .2;
+const DECAY_CTR = .005;
+const HARD_BLOCK_FLOOR = 10;
+const HARD_BLOCK_SHARE = .03;
+const REJECT_SHARE = .3;
+const REJECT_MIN = 50;
+function reachLivenessRatio(daily) {
+	if (!daily || daily.length < 14) return null;
+	const series = daily.map((d) => d.impressions);
+	while (series.length && series[series.length - 1] === 0) series.pop();
+	if (series.length < 14) return null;
+	const rolling7 = (end) => {
+		let sum = 0;
+		for (let i = Math.max(0, end - 6); i <= end; i++) sum += series[i];
+		return sum;
+	};
+	const latestWeek = rolling7(series.length - 1);
+	let peakWeek = 0;
+	for (let i = 6; i < series.length; i++) peakWeek = Math.max(peakWeek, rolling7(i));
+	return peakWeek > 0 ? latestWeek / peakWeek : null;
+}
+function clamp01(n) {
+	if (!Number.isFinite(n)) return 0;
+	return Math.min(1, Math.max(0, n));
+}
+function pctStr(n) {
+	return `${n >= 0 ? "+" : ""}${Math.round(n)}%`;
+}
+function advance(nextStage, metric, value, target, gapLabel) {
+	return {
+		nextStage,
+		metric,
+		value,
+		target,
+		pct: clamp01(value / target),
+		gapLabel,
+		direction: "advance"
+	};
+}
+function escapeToward(nextStage, metric, value, target, gapLabel) {
+	return {
+		nextStage,
+		metric,
+		value,
+		target,
+		pct: clamp01(value / target),
+		gapLabel,
+		direction: "escape"
+	};
+}
+function escapeReduce(nextStage, metric, value, target, gapLabel) {
+	return {
+		nextStage,
+		metric,
+		value,
+		target,
+		pct: target <= 0 ? value <= 0 ? 1 : 0 : clamp01(2 - value / target),
+		gapLabel,
+		direction: "escape"
+	};
+}
+function sustain(metric, value, gapLabel) {
+	return {
+		nextStage: null,
+		metric,
+		value,
+		target: value,
+		pct: 1,
+		gapLabel,
+		direction: "sustain"
+	};
+}
+const HEALTH_COPY = {
+	healthy: {
+		summary: "Google can crawl and index the pages that should be indexed.",
+		primaryAction: "No indexing cleanup needed — focus on reach."
+	},
+	crawl_faults: {
+		summary: "Real access faults (server errors / broken links) are capping otherwise-indexable pages.",
+		primaryAction: "Fix the 5xx and broken URLs; return 410/404 for pages you retire on purpose."
+	},
+	quality_rejection: {
+		summary: "Google is crawling pages and refusing to index them — a soft quality signal it never reports explicitly.",
+		primaryAction: "Consolidate or improve the rejected pages, or noindex the thin/low-value set."
+	}
+};
+function isIntentionalRetirementSite(input, notFound, serverError) {
+	const type = normalizeSiteType(input.siteType);
+	const typeMatches = type === "agency" || type === "portfolio" || type === "other";
+	const fingerprint = notFound > 50 && serverError <= Math.max(5, notFound * .1);
+	return typeMatches && fingerprint;
+}
+function classifyHealthStage(input) {
+	const issues = input.issues ?? [];
+	const totalUrls = input.totalUrls ?? 0;
+	const noindex = countSearchConsoleIssues(issues, "noindex");
+	const notFound = countSearchConsoleIssues(issues, "not_found");
+	const softFound = countSearchConsoleIssues(issues, "soft_404");
+	const serverError = countSearchConsoleIssues(issues, "server_error", "blocked_robots", "access_denied", "forbidden");
+	const crawledNotIndexed = countSearchConsoleIssues(issues, "crawled_not_indexed");
+	const intentionalDead = isIntentionalRetirementSite(input, notFound, serverError) ? notFound : 0;
+	const indexableUrls = Math.max(1, totalUrls - noindex - intentionalDead);
+	const hardBlocks = serverError + (input.crawlAuditBlockerCount ?? 0);
+	const faultTarget = Math.max(HARD_BLOCK_FLOOR, indexableUrls * HARD_BLOCK_SHARE);
+	if (hardBlocks > faultTarget) {
+		const toFix = Math.ceil(hardBlocks - faultTarget);
+		return {
+			stage: "crawl_faults",
+			...HEALTH_COPY.crawl_faults,
+			evidence: [{
+				label: "Access faults (5xx / broken)",
+				value: formatSearchConsoleCount(hardBlocks)
+			}],
+			progression: escapeReduce("healthy", "access faults", hardBlocks, faultTarget, `${formatSearchConsoleCount(hardBlocks)} faults — fix ~${formatSearchConsoleCount(toFix)} to clear the gate`)
+		};
+	}
+	const rejectPool = crawledNotIndexed + softFound;
+	if (totalUrls > 0 && rejectPool > REJECT_MIN && rejectPool / totalUrls >= REJECT_SHARE) {
+		const share = rejectPool / totalUrls;
+		const toClear = Math.max(0, Math.ceil(rejectPool - REJECT_SHARE * totalUrls));
+		return {
+			stage: "quality_rejection",
+			...HEALTH_COPY.quality_rejection,
+			evidence: [{
+				label: "Crawled, then refused",
+				value: formatSearchConsoleCount(rejectPool)
+			}, {
+				label: "Share of known URLs",
+				value: `${(share * 100).toFixed(0)}%`
+			}],
+			progression: escapeReduce("healthy", "crawled-rejected share", share, REJECT_SHARE, `${(share * 100).toFixed(0)}% rejected — improve/consolidate ~${formatSearchConsoleCount(toClear)} pages to clear`)
+		};
+	}
+	return {
+		stage: "healthy",
+		...HEALTH_COPY.healthy,
+		evidence: [],
+		progression: sustain("indexing health", 1, "Indexable pages are getting indexed — no gate blocking reach.")
+	};
+}
+const REACH_COPY = {
+	waiting_for_data: {
+		summary: "Too new to diagnose — not enough search history yet.",
+		primaryAction: "Submit a clean sitemap, add internal links, and give it time."
+	},
+	emerging: {
+		summary: "Early but climbing — real impressions are starting to land.",
+		primaryAction: "Keep publishing on the themes already gaining impressions."
+	},
+	growing: {
+		summary: "Discoverable, indexed-enough, and trending up. The next work is expansion, not cleanup.",
+		primaryAction: "Expand: striking-distance pages, content gaps, authority."
+	},
+	plateaued: {
+		summary: "Established but flat — visibility is steady, not compounding.",
+		primaryAction: "Refresh top pages and open a new content cluster to restart growth."
+	},
+	declining: {
+		summary: "Established visibility is genuinely falling versus the previous period.",
+		primaryAction: "Investigate the losing pages, recent releases, and competitor moves before expanding."
+	},
+	faded: {
+		summary: "The site had real reach that has collapsed — it spiked and is now near-invisible in search.",
+		primaryAction: "Diagnose the drop (quality, deindexing, lost rankings) — the 90-day total hides it; look at the recent week."
+	},
+	decayed: {
+		summary: "Still shows for old terms but earns almost no clicks — the content has aged out of relevance.",
+		primaryAction: "Refresh the decayed top pages, or mark the site low-priority if it is no longer maintained."
+	}
+};
+function reach(stage, evidence, progression) {
+	return {
+		stage,
+		...REACH_COPY[stage],
+		evidence,
+		progression
+	};
+}
+function classifyReachStage(input) {
+	const imp28d = input.impressions28d ?? 0;
+	const imp12m = input.impressions12m ?? null;
+	const clicks28d = input.clicks28d ?? null;
+	const clicks90dPct = input.clicksPct90d ?? null;
+	const clicks28dPct = input.clicksPct28d ?? null;
+	const priorClicks = input.clicksPrior28d ?? null;
+	const imp90dPct = input.impressionsPct90d ?? null;
+	const posDelta = input.positionDelta90d ?? null;
+	const liveness = input.livenessRatio ?? null;
+	if (imp12m != null && imp12m < LIFETIME_FLOOR) return reach("waiting_for_data", [{
+		label: "Impressions (12m)",
+		value: formatSearchConsoleCount(imp12m)
+	}], advance("emerging", "lifetime impressions", imp12m, LIFETIME_FLOOR, `${formatSearchConsoleCount(imp12m)} of ${formatSearchConsoleCount(LIFETIME_FLOOR)} lifetime impressions — collecting data, keep indexing`));
+	const hadRealReach = (imp12m ?? imp28d) > LIFETIME_FLOOR;
+	const isGrowing = clicks90dPct != null && clicks90dPct > GROWTH_CLICKS_PCT || imp90dPct != null && imp90dPct > GROWTH_IMPRESSIONS_PCT && posDelta != null && posDelta < 0;
+	if (hadRealReach && liveness != null && liveness < FADED_LIVENESS && !isGrowing) return reach("faded", [{
+		label: "Recent week vs peak",
+		value: `${(liveness * 100).toFixed(0)}%`
+	}], escapeToward("growing", "recent week vs peak (liveness)", liveness, .5, `recent week is ${(liveness * 100).toFixed(0)}% of peak — revive toward ~50%`));
+	if (clicks90dPct != null && clicks90dPct < DECLINE_CLICKS_PCT && clicks28dPct != null && clicks28dPct < DECLINE_CLICKS_PCT && priorClicks != null && priorClicks >= MIN_DECLINE_PRIOR_CLICKS) return reach("declining", [{
+		label: "Clicks 90d",
+		value: pctStr(clicks90dPct)
+	}, {
+		label: "Clicks 28d",
+		value: pctStr(clicks28dPct)
+	}], {
+		nextStage: "plateaued",
+		metric: "90d clicks change",
+		value: clicks90dPct,
+		target: DECLINE_CLICKS_PCT,
+		pct: clamp01(2 - Math.abs(clicks90dPct) / Math.abs(DECLINE_CLICKS_PCT)),
+		gapLabel: `down ${pctStr(clicks90dPct)} (90d) — recover clicks above ${pctStr(DECLINE_CLICKS_PCT)} to exit`,
+		direction: "escape"
+	});
+	if (isGrowing) {
+		const clickGrowth = clicks90dPct != null && clicks90dPct > GROWTH_CLICKS_PCT;
+		const growthPct = clickGrowth ? clicks90dPct : imp90dPct ?? clicks90dPct ?? 0;
+		const growthMetric = clickGrowth ? "90d clicks growth" : "90d impressions growth";
+		const growthLabel = clickGrowth ? `${pctStr(clicks90dPct)} 90d clicks — comfortably growing; defend & expand` : `${pctStr(growthPct)} 90d impressions — comfortably growing; defend & expand`;
+		return reach("growing", [...clicks90dPct != null ? [{
+			label: "Clicks 90d",
+			value: pctStr(clicks90dPct)
+		}] : [], ...imp90dPct != null ? [{
+			label: "Impressions 90d",
+			value: pctStr(imp90dPct)
+		}] : []], sustain(growthMetric, growthPct, growthLabel));
+	}
+	const ctr = clicks28d != null && imp28d > 0 ? clicks28d / imp28d : null;
+	if (hadRealReach && imp28d >= NASCENT_IMPRESSIONS_28D && ctr != null && ctr < DECAY_CTR) return reach("decayed", [{
+		label: "Impressions (28d)",
+		value: formatSearchConsoleCount(imp28d)
+	}, {
+		label: "Clicks (28d)",
+		value: formatSearchConsoleCount(clicks28d ?? 0)
+	}], escapeToward("growing", "CTR (clicks/impressions)", ctr, DECAY_CTR, `${(ctr * 100).toFixed(2)}% CTR on ${formatSearchConsoleCount(imp28d)} impressions — refresh content toward ~${(DECAY_CTR * 100).toFixed(1)}%`));
+	const growthVal = clicks90dPct ?? 0;
+	const growthGap = Math.max(0, GROWTH_CLICKS_PCT - growthVal);
+	const growthProgression = (stage) => advance("growing", "90d clicks growth", growthVal, GROWTH_CLICKS_PCT, clicks90dPct != null ? `${pctStr(growthVal)} 90d clicks — need ${pctStr(growthGap)} more to clear the +${GROWTH_CLICKS_PCT}% growth bar` : `${stage === "plateaued" ? "flat" : "rising"} — reach +${GROWTH_CLICKS_PCT}% 90d clicks growth to break into growing`);
+	if (imp28d >= ESTABLISHED_IMPRESSIONS_28D) return reach("plateaued", [{
+		label: "Impressions (28d)",
+		value: formatSearchConsoleCount(imp28d)
+	}], growthProgression("plateaued"));
+	if (imp28d < NASCENT_IMPRESSIONS_28D) return reach("emerging", [{
+		label: "Impressions (28d)",
+		value: formatSearchConsoleCount(imp28d)
+	}], growthProgression("emerging"));
+	return reach("plateaued", [{
+		label: "Impressions (28d)",
+		value: formatSearchConsoleCount(imp28d)
+	}], growthProgression("plateaued"));
+}
+function classifySiteTriage(input) {
+	const health = classifyHealthStage(input);
+	return {
+		reach: classifyReachStage(input),
+		health,
+		headline: health.stage === "healthy" ? "reach" : "health"
+	};
+}
+export { classifyHealthStage, classifyReachStage, classifySiteTriage, reachLivenessRatio };

package/dist/v1/index.d.mts

@@ -92,7 +92,7 @@ interface GscdumpV1Client {
 /** Create one framework-neutral client whose behavior is driven by the v1 registry. */
 declare function createGscdumpV1Client(options: CreateGscdumpV1ClientOptions): GscdumpV1Client;
 type MaybePromise<T> = T | Promise<T>;
-declare const GSCDUMP_REALTIME_V1_SDK_VERSION: "1.0.0";
+declare const GSCDUMP_REALTIME_V1_SDK_VERSION: "1.0.2";
 type GscdumpRealtimeV1TransportState = 'idle' | 'ticketing' | 'connecting' | 'handshaking' | 'replaying' | 'live' | 'waiting' | 'stopped' | 'terminal';
 type GscdumpRealtimeV1Freshness = 'unknown' | 'stale' | 'applying' | 'fresh' | 'resyncing' | 'degraded';
 type GscdumpRealtimeV1ErrorCode = 'cursor_store_failed' | 'effect_failed' | 'heartbeat_stale' | 'integration_failed' | 'protocol_error' | 'resync_failed' | 'runtime_unavailable' | 'socket_error' | 'ticket_invalid' | 'ticket_provider_failed' | 'upgrade_rejected';

package/dist/v1/index.mjs

@@ -395,7 +395,7 @@ function utf8Size(value) {
 	}
 	return bytes;
 }
-const GSCDUMP_REALTIME_V1_SDK_VERSION = "1.0.0";
+const GSCDUMP_REALTIME_V1_SDK_VERSION = "1.0.2";
 var GscdumpRealtimeV1Error = class extends Error {
 	tag = "GscdumpRealtimeV1Error";
 	code;
@@ -482,7 +482,7 @@ function createGscdumpRealtimeV1Client(options) {
 	const protocol = createGscdumpV1Protocol();
 	const runtime = options.runtime ?? defaultRuntime();
 	const cursorStore = options.cursorStore ?? createMemoryCursorStore();
-	const sdkVersion = options.sdkVersion ?? "1.0.0";
+	const sdkVersion = options.sdkVersion ?? "1.0.2";
 	if (!sdkVersion) throw new TypeError("sdkVersion cannot be empty.");
 	let running = false;
 	let epoch = 0;

package/dist/webhook.d.mts

@@ -0,0 +1,29 @@
+import { PartnerApiError } from "./_chunks/errors.mjs";
+import { Result } from "gscdump/result";
+import { CANONICAL_WEBHOOK_EVENTS, CreateWebhookEnvelopeOptions, PartnerWebhookHeaders, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, WebhookEnvelope } from "@gscdump/contracts";
+declare function generateWebhookSecret(): string;
+declare function generateWebhookDeliveryId(): string;
+declare function shouldQueueWebhook(webhookEvents: string | string[] | null | undefined, eventType: string): boolean;
+declare function createWebhookEnvelope<TData extends Record<string, unknown>>(options: CreateWebhookEnvelopeOptions<TData>): WebhookEnvelope<TData>;
+declare function signWebhookPayload(payload: string | object, secret: string): Promise<string>;
+declare function verifyWebhookSignature(payload: string | object, signature: string | null | undefined, secret: string): Promise<boolean>;
+/**
+ * Errors-as-values core for {@link parseWebhookPayload}: a failed HMAC signature
+ * check is a caller-actionable `auth` (401) failure at the webhook boundary, so
+ * it is returned as a modelled `PartnerApiError` rather than only thrown. A
+ * malformed envelope (schema parse) is a defect and keeps propagating.
+ */
+declare function parseWebhookPayloadResult<TData extends Record<string, unknown> = Record<string, unknown>>(payload: string | object, options?: {
+  secret?: string;
+  signature?: string | null;
+  headers?: PartnerWebhookHeaders | Headers;
+  validateSignature?: boolean;
+}): Promise<Result<WebhookEnvelope<TData>, PartnerApiError>>;
+declare function parseWebhookPayload<TData extends Record<string, unknown> = Record<string, unknown>>(payload: string | object, options?: {
+  secret?: string;
+  signature?: string | null;
+  headers?: PartnerWebhookHeaders | Headers;
+  validateSignature?: boolean;
+}): Promise<WebhookEnvelope<TData>>;
+declare function readWebhookHeaders(headers: Headers | PartnerWebhookHeaders | null | undefined): Required<PartnerWebhookHeaders>;
+export { CANONICAL_WEBHOOK_EVENTS, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, createWebhookEnvelope, generateWebhookDeliveryId, generateWebhookSecret, parseWebhookPayload, parseWebhookPayloadResult, readWebhookHeaders, shouldQueueWebhook, signWebhookPayload, verifyWebhookSignature };

package/dist/webhook.mjs

@@ -0,0 +1,118 @@
+import { PartnerApiError, partnerErrorToException } from "./errors.mjs";
+import { err, ok, unwrapResult } from "gscdump/result";
+import { CANONICAL_WEBHOOK_EVENTS, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION as WEBHOOK_CONTRACT_VERSION$1, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_CONTRACT_VERSION_HEADER as WEBHOOK_CONTRACT_VERSION_HEADER$1, WEBHOOK_DELIVERY_HEADER, WEBHOOK_DELIVERY_HEADER as WEBHOOK_DELIVERY_HEADER$1, WEBHOOK_EVENT_HEADER, WEBHOOK_EVENT_HEADER as WEBHOOK_EVENT_HEADER$1, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_SIGNATURE_HEADER as WEBHOOK_SIGNATURE_HEADER$1, WEBHOOK_TIMESTAMP_HEADER, WEBHOOK_TIMESTAMP_HEADER as WEBHOOK_TIMESTAMP_HEADER$1, partnerWebhookEnvelopeSchema } from "@gscdump/contracts";
+const CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const SECRET_LENGTH = 32;
+const encoder = new TextEncoder();
+function randomString(length) {
+	const bytes = crypto.getRandomValues(new Uint8Array(length));
+	let value = "";
+	for (let i = 0; i < length; i++) value += CHARSET[bytes[i] % 62];
+	return value;
+}
+function toPayloadString(payload) {
+	return typeof payload === "string" ? payload : JSON.stringify(payload);
+}
+function bytesToHex(bytes) {
+	return Array.from(new Uint8Array(bytes)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+	if (!/^[\da-f]+$/i.test(hex) || hex.length % 2 !== 0) return null;
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+function constantTimeEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let diff = 0;
+	for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+	return diff === 0;
+}
+function signatureHex(signature) {
+	const trimmed = signature.trim();
+	return trimmed.startsWith("sha256=") ? trimmed.slice(7) : null;
+}
+async function hmacSha256(payload, secret) {
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+}
+function generateWebhookSecret() {
+	return `whsec_${randomString(SECRET_LENGTH)}`;
+}
+function generateWebhookDeliveryId() {
+	return `whd_${crypto.randomUUID()}`;
+}
+function shouldQueueWebhook(webhookEvents, eventType) {
+	if (!webhookEvents) return false;
+	return (Array.isArray(webhookEvents) ? webhookEvents : JSON.parse(webhookEvents)).includes(eventType);
+}
+function createWebhookEnvelope(options) {
+	const occurredAt = options.occurredAt instanceof Date ? options.occurredAt.toISOString() : options.occurredAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		contractVersion: options.contractVersion ?? WEBHOOK_CONTRACT_VERSION$1,
+		deliveryId: options.deliveryId ?? generateWebhookDeliveryId(),
+		event: options.event,
+		partnerId: options.partnerId,
+		userId: options.userId,
+		siteId: options.siteId,
+		externalUserId: options.externalUserId ?? null,
+		externalSiteId: options.externalSiteId ?? null,
+		lifecycleRevision: options.lifecycleRevision,
+		occurredAt,
+		data: options.data
+	};
+}
+async function signWebhookPayload(payload, secret) {
+	return `sha256=${bytesToHex(await hmacSha256(toPayloadString(payload), secret))}`;
+}
+async function verifyWebhookSignature(payload, signature, secret) {
+	if (!signature) return false;
+	const hex = signatureHex(signature);
+	if (!hex) return false;
+	const received = hexToBytes(hex);
+	if (!received) return false;
+	return constantTimeEqual(new Uint8Array(await hmacSha256(toPayloadString(payload), secret)), received);
+}
+async function parseWebhookPayloadResult(payload, options = {}) {
+	const payloadString = toPayloadString(payload);
+	const signature = options.signature ?? readWebhookHeaders(options.headers).signature;
+	if (options.secret && (options.validateSignature ?? true)) {
+		if (!await verifyWebhookSignature(payloadString, signature, options.secret)) return err(new PartnerApiError({
+			kind: "auth",
+			statusCode: 401,
+			message: "Invalid webhook signature"
+		}));
+	}
+	const parsed = typeof payload === "string" ? JSON.parse(payload) : payload;
+	return ok(partnerWebhookEnvelopeSchema.parse(parsed));
+}
+async function parseWebhookPayload(payload, options = {}) {
+	return unwrapResult(await parseWebhookPayloadResult(payload, options), partnerErrorToException);
+}
+function readWebhookHeaders(headers) {
+	if (!headers) return {
+		event: null,
+		delivery: null,
+		contractVersion: null,
+		timestamp: null,
+		signature: null
+	};
+	if (headers instanceof Headers) return {
+		event: headers.get(WEBHOOK_EVENT_HEADER$1),
+		delivery: headers.get(WEBHOOK_DELIVERY_HEADER$1),
+		contractVersion: headers.get(WEBHOOK_CONTRACT_VERSION_HEADER$1),
+		timestamp: headers.get(WEBHOOK_TIMESTAMP_HEADER$1),
+		signature: headers.get(WEBHOOK_SIGNATURE_HEADER$1)
+	};
+	return {
+		event: headers.event ?? null,
+		delivery: headers.delivery ?? null,
+		contractVersion: headers.contractVersion ?? null,
+		timestamp: headers.timestamp ?? null,
+		signature: headers.signature ?? null
+	};
+}
+export { CANONICAL_WEBHOOK_EVENTS, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, createWebhookEnvelope, generateWebhookDeliveryId, generateWebhookSecret, parseWebhookPayload, parseWebhookPayloadResult, readWebhookHeaders, shouldQueueWebhook, signWebhookPayload, verifyWebhookSignature };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/sdk",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Consumer SDK for hosted gscdump.com integrations.",
   "author": {
     "name": "Harlan Wilton",
@@ -26,6 +26,111 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./analytics": {
+      "types": "./dist/analytics-client.d.mts",
+      "import": "./dist/analytics-client.mjs",
+      "default": "./dist/analytics-client.mjs"
+    },
+    "./analyzers": {
+      "types": "./dist/analyzer-defs.d.mts",
+      "import": "./dist/analyzer-defs.mjs",
+      "default": "./dist/analyzer-defs.mjs"
+    },
+    "./anonymization": {
+      "types": "./dist/anonymization.d.mts",
+      "import": "./dist/anonymization.mjs",
+      "default": "./dist/anonymization.mjs"
+    },
+    "./archetype": {
+      "types": "./dist/archetype-compile.d.mts",
+      "import": "./dist/archetype-compile.mjs",
+      "default": "./dist/archetype-compile.mjs"
+    },
+    "./partner": {
+      "types": "./dist/client.d.mts",
+      "import": "./dist/client.mjs",
+      "default": "./dist/client.mjs"
+    },
+    "./country": {
+      "types": "./dist/country-names.d.mts",
+      "import": "./dist/country-names.mjs",
+      "default": "./dist/country-names.mjs"
+    },
+    "./cwv": {
+      "types": "./dist/cwv-thresholds.d.mts",
+      "import": "./dist/cwv-thresholds.mjs",
+      "default": "./dist/cwv-thresholds.mjs"
+    },
+    "./partner-errors": {
+      "types": "./dist/errors.d.mts",
+      "import": "./dist/errors.mjs",
+      "default": "./dist/errors.mjs"
+    },
+    "./gsc-console-url": {
+      "types": "./dist/gsc-console-url.d.mts",
+      "import": "./dist/gsc-console-url.mjs",
+      "default": "./dist/gsc-console-url.mjs"
+    },
+    "./gsc-constants": {
+      "types": "./dist/gsc-constants.d.mts",
+      "import": "./dist/gsc-constants.mjs",
+      "default": "./dist/gsc-constants.mjs"
+    },
+    "./gsc-error": {
+      "types": "./dist/gsc-error.d.mts",
+      "import": "./dist/gsc-error.mjs",
+      "default": "./dist/gsc-error.mjs"
+    },
+    "./period-presets": {
+      "types": "./dist/gsc-period-presets.d.mts",
+      "import": "./dist/gsc-period-presets.mjs",
+      "default": "./dist/gsc-period-presets.mjs"
+    },
+    "./rows": {
+      "types": "./dist/gsc-rows.d.mts",
+      "import": "./dist/gsc-rows.mjs",
+      "default": "./dist/gsc-rows.mjs"
+    },
+    "./hosted-query": {
+      "types": "./dist/hosted-query.d.mts",
+      "import": "./dist/hosted-query.mjs",
+      "default": "./dist/hosted-query.mjs"
+    },
+    "./indexing-issues": {
+      "types": "./dist/indexing-issues.d.mts",
+      "import": "./dist/indexing-issues.mjs",
+      "default": "./dist/indexing-issues.mjs"
+    },
+    "./lifecycle": {
+      "types": "./dist/lifecycle.d.mts",
+      "import": "./dist/lifecycle.mjs",
+      "default": "./dist/lifecycle.mjs"
+    },
+    "./period": {
+      "types": "./dist/period.d.mts",
+      "import": "./dist/period.mjs",
+      "default": "./dist/period.mjs"
+    },
+    "./search-console-stage": {
+      "types": "./dist/search-console-stage.d.mts",
+      "import": "./dist/search-console-stage.mjs",
+      "default": "./dist/search-console-stage.mjs"
+    },
+    "./site-baseline": {
+      "types": "./dist/site-baseline.d.mts",
+      "import": "./dist/site-baseline.mjs",
+      "default": "./dist/site-baseline.mjs"
+    },
+    "./site-triage": {
+      "types": "./dist/site-triage.d.mts",
+      "import": "./dist/site-triage.mjs",
+      "default": "./dist/site-triage.mjs"
+    },
+    "./webhook": {
+      "types": "./dist/webhook.d.mts",
+      "import": "./dist/webhook.mjs",
+      "default": "./dist/webhook.mjs"
+    },
     "./v1": {
       "types": "./dist/v1/index.d.mts",
       "import": "./dist/v1/index.mjs",
@@ -44,10 +149,10 @@
     "date-fns": "^4.4.0",
     "ofetch": "^1.5.1",
     "zod": "^4.4.3",
-    "@gscdump/contracts": "^1.0.1",
-    "@gscdump/engine": "^1.0.1",
-    "gscdump": "^1.0.1",
-    "@gscdump/analysis": "^1.0.1"
+    "@gscdump/analysis": "^1.0.3",
+    "@gscdump/engine": "^1.0.3",
+    "@gscdump/contracts": "^1.0.3",
+    "gscdump": "^1.0.3"
   },
   "devDependencies": {
     "typescript": "^6.0.3",